tests_lit/assembler/arm32/sandboxing.ll

   1 ; Tests basics and corner cases of arm32 sandboxing, using -Om1 in the hope that
   2 ; the output will remain stable.  When packing bundles, we try to limit to a few
   3 ; instructions with well known sizes and minimal use of registers and stack
   4 ; slots in the lowering sequence.
   5
   6 ; REQUIRES: allow_dump, target_ARM32
   7 ; RUN: %p2i -i %s --sandbox --filetype=asm --target=arm32 --assemble \
   8 ; RUN:   --disassemble --args -Om1 -allow-externally-defined-symbols \
   9 ; RUN:   -ffunction-sections  | FileCheck %s
  10
  11 declare void @call_target()
  12 declare void @call_target1(i32 %arg0)
  13 declare void @call_target2(i32 %arg0, i32 %arg1)
  14 declare void @call_target3(i32 %arg0, i32 %arg1, i32 %arg2)
  15 @global_short = internal global [2 x i8] zeroinitializer
  16
  17 ; A direct call sequence uses the right mask and register-call sequence.
  18 define internal void @test_direct_call() {
  19 entry:
  20   call void @call_target()
  21   ret void
  22 }
  23 ; CHECK-LABEL: test_direct_call
  24 ; CHECK: sub sp,
  25 ; CHECK-NEXT: bic sp, sp, {{.*}} ; 0xc0000000
  26 ; CHECK: {{[0-9]*}}c: {{.*}} bl {{.*}} call_target
  27 ; CHECK-NEXT: {{[0-9]*}}0:
  28
  29 ; An indirect call sequence uses the right mask and register-call sequence.
  30 define internal void @test_indirect_call(i32 %target) {
  31 entry:
  32   %__1 = inttoptr i32 %target to void ()*
  33   call void %__1()
  34   ret void
  35 }
  36 ; CHECK-LABEL: test_indirect_call
  37 ; CHECK: sub sp,
  38 ; CHECK: bic sp, sp, {{.*}} ; 0xc0000000
  39 ; CHECK-NOT: bic sp, sp, {{.*}} ; 0xc0000000
  40 ; CHECK: ldr [[REG:r[0-9]+]], [sp,
  41 ; CHECK-NEXT: nop
  42 ; CHECK: {{[0-9]+}}8: {{.*}} bic [[REG:r[0-9]+]], [[REG]], {{.*}} 0xc000000f
  43 ; CHECK-NEXT: blx [[REG]]
  44 ; CHECk-NEXT: {{[0-9]+}}0:
  45
  46 ; A return sequences uses the right pop / mask / jmp sequence.
  47 define internal void @test_ret() {
  48 entry:
  49   ret void
  50 }
  51 ; CHECK-LABEL: test_ret
  52 ; CHECK: 0: {{.*}} bic lr, lr, {{.*}} 0xc000000f
  53 ; CHECK-NEXT: bx lr
  54
  55 ; Bundle lock without padding.
  56 define internal void @bundle_lock_without_padding() {
  57 entry:
  58   %addr_short = bitcast [2 x i8]* @global_short to i16*
  59   store i16 0, i16* %addr_short, align 1
  60   ret void
  61 }
  62 ; CHECK-LABEL: bundle_lock_without_padding
  63 ; CHECK: 0: {{.*}} movw
  64 ; CHECK-NEXT: movt
  65 ; CHECK-NEXT: mov
  66 ; CHECK-NEXT: nop
  67 ; CHECK-NEXT: bic [[REG:r[0-9]+]], {{.*}} 0xc0000000
  68 ; CHECK-NEXT: strh {{.*}}, {{[[]}}[[REG]]
  69 ; CHECK-NEXT: bic lr, lr, {{.*}} ; 0xc000000f
  70 ; CHECK-NEXT: {{.*}} bx lr
  71
  72 ; Bundle lock with padding.
  73 define internal void @bundle_lock_with_padding() {
  74 entry:
  75   call void @call_target()
  76   ; bundle boundary
  77   store i16 0, i16* undef, align 1   ; 3 insts
  78   store i16 0, i16* undef, align 1   ; 3 insts
  79   store i16 0, i16* undef, align 1   ; 3 insts
  80                                      ; SP adjustment + pop
  81   ; nop
  82   ; bundle boundary
  83   ret void
  84 }
  85 ; CHECK-LABEL: bundle_lock_with_padding
  86 ; CHECK: 48: {{.*}} pop
  87 ; CHECK-NEXT: nop
  88 ; CHECK-NEXT: bic lr, {{.*}} 0xc000000f
  89 ; CHECK-NEXT: {{.*}} bx lr
  90
  91 ; Bundle lock align_to_end without any padding.
  92 define internal void @bundle_lock_align_to_end_padding_0() {
  93 entry:
  94   call void @call_target()
  95   ; bundle boundary
  96   call void @call_target3(i32 1, i32 2, i32 3)
  97   ; bundle boundary
  98   ret void
  99 }
 100 ; CHECK-LABEL: bundle_lock_align_to_end_padding_0
 101 ; CHECK: c: {{.*}} bl {{.*}} call_target
 102 ; CHECK-NEXT: mov
 103 ; CHECK-NEXT: mov
 104 ; CHECK-NEXT: mov
 105 ; CHECK-NEXT: {{[0-9]+}}c: {{.*}} bl {{.*}} call_target3
 106 ; CHECK-NEXT: add sp
 107 ; CHECK-NEXT: bic sp, {{.*}} 0xc0000000
 108 ; CHECK-NEXT: pop
 109 ; CHECK: {{[0-9]+}}0: {{.*}} bic lr, lr, {{.*}} 0xc000000f
 110 ; CHECK-NEXT: {{.*}} bx lr
 111
 112 ; Bundle lock align_to_end with one bunch of padding.
 113 define internal void @bundle_lock_align_to_end_padding_1() {
 114 entry:
 115   call void @call_target()
 116   ; bundle boundary
 117   call void @call_target2(i32 1, i32 2)
 118   ; bundle boundary
 119   ret void
 120 }
 121 ; CHECK-LABEL: bundle_lock_align_to_end_padding_1
 122 ; CHECK: {{[0-9]*}}c: {{.*}} bl {{.*}} call_target
 123 ; CHECK-NEXT: mov
 124 ; CHECK-NEXT: mov
 125 ; CHECK-NEXT: nop
 126 ; CHECK-NEXT: bl {{.*}} call_target2
 127 ; CHECK: {{[0-9]+}}0: {{.*}} bic lr, lr, {{.*}} 0xc000000f
 128 ; CHECK-NEXT: {{.*}} bx lr
 129
 130 ; Bundle lock align_to_end with two bunches of padding.
 131 define internal void @bundle_lock_align_to_end_padding_2() {
 132 entry:
 133   call void @call_target2(i32 1, i32 2)
 134   ; bundle boundary
 135   ret void
 136 }
 137 ; CHECK-LABEL: bundle_lock_align_to_end_padding_2
 138 ; CHECK: mov
 139 ; CHECK-NEXT: mov
 140 ; CHECK-NEXT: nop
 141 ; CHECK-NEXT: nop
 142 ; CHECK-NEXT: bl {{.*}} call_target2