Suzero. X8664. NaCl Sandboxing.

tests_lit/assembler/x86/sandboxing.ll

 ; Tests basics and corner cases of x86-32 sandboxing, using -Om1 in
 ; the hope that the output will remain stable.  When packing bundles,
 ; we try to limit to a few instructions with well known sizes and
 ; minimal use of registers and stack slots in the lowering sequence.
 
 ; RUN: %p2i -i %s --sandbox --filetype=obj --disassemble --args -Om1 \
 ; RUN:   -allow-externally-defined-symbols \
 ; RUN:   -ffunction-sections | FileCheck %s
 
+; RUN: %p2i -i %s --sandbox --filetype=obj --disassemble --target=x8664 \
+; RUN:   --args -Om1 -allow-externally-defined-symbols  \
+; RUN:   -ffunction-sections | FileCheck %s --check-prefix X8664
+
 declare void @call_target()
 @global_byte = internal global [1 x i8] zeroinitializer
 @global_short = internal global [2 x i8] zeroinitializer
 @global_int = internal global [4 x i8] zeroinitializer
 
 ; A direct call sequence uses the right mask and register-call sequence.
 define internal void @test_direct_call() {
 entry:
   call void @call_target()
   ret void
 }
 ; CHECK-LABEL: test_direct_call
 ; CHECK: nop
 ; CHECK: 1b: {{.*}} call 1c
 ; CHECK-NEXT: 20:
+; X8664-LABEL: test_direct_call
+; X8664: push {{.*}}$local$__0
+; X8664: jmp {{.*}} call_target
+; X8664: {{0+}}20 <{{.*}}$local$__0>:
 
 ; An indirect call sequence uses the right mask and register-call sequence.
 define internal void @test_indirect_call(i32 %target) {
 entry:
   %__1 = inttoptr i32 %target to void ()*
   call void %__1()
   ret void
 }
 ; CHECK-LABEL: test_indirect_call
 ; CHECK: mov [[REG:.*]],DWORD PTR [esp
 ; CHECK-NEXT: nop
 ; CHECK: 1b: {{.*}} and [[REG]],0xffffffe0
 ; CHECK-NEXT: call [[REG]]
 ; CHECk-NEXT: 20:
+; X8664-LABEL: test_indirect_call
+; X8664: push {{.*}}$local$__0
+; X8664: {{.*}} and e[[REG:..]],0xffffffe0
+; X8664: add r[[REG]],r15
+; X8664: jmp r[[REG]]
+; X8664: {{0+}}20 <{{.*}}$local$__0>:
 
-; A return sequences uses the right pop / mask / jmp sequence.
+; A return sequence uses the right pop / mask / jmp sequence.
 define internal void @test_ret() {
 entry:
   ret void
 }
 ; CHECK-LABEL: test_ret
 ; CHECK: pop ecx
 ; CHECK-NEXT: and ecx,0xffffffe0
 ; CHECK-NEXT: jmp ecx
+; X8664-LABEL: test_ret
+; X8664: pop rcx
+; X8664: and ecx,0xffffffe0
+; X8664: add rcx,r15
+; X8664: jmp rcx
 
 ; A perfectly packed bundle should not have nops at the end.
 define internal void @packed_bundle() {
 entry:
   call void @call_target()
   ; bundle boundary
   %addr_byte = bitcast [1 x i8]* @global_byte to i8*
   %addr_short = bitcast [2 x i8]* @global_short to i16*
   store i8 0, i8* %addr_byte, align 1      ; 7-byte instruction
   store i16 0, i16* %addr_short, align 1   ; 9-byte instruction
@@ skipping 173 matching lines @@
 ; CHECK: call
 ; CHECK-NEXT: 20: {{.*}} mov BYTE PTR
 ; CHECK-NEXT: 27: {{.*}} mov WORD PTR
 ; CHECK-NEXT: 30: {{.*}} mov WORD PTR
 ; CHECK-NEXT: 39: {{.*}} mov [[REG:.*]],DWORD PTR [esp
 ; CHECK-NEXT: 3d: {{.*}} nop
 ; CHECK: 40: {{.*}} nop
 ; CHECK: 5b: {{.*}} and [[REG]],0xffffffe0
 ; CHECK-NEXT: 5e: {{.*}} call [[REG]]
 
+; Tests the pad_to_end bundle alignment with no padding bytes needed.
+define internal void @bundle_lock_pad_to_end_padding_0(i32 %arg0, i32 %arg1,
+                                                       i32 %arg3, i32 %arg4,
+                                                       i32 %arg5, i32 %arg6) {
+  call void @call_target()
+  ; bundle boundary
+  %x = add i32 %arg5, %arg6  ; 12 bytes
+  %y = trunc i32 %x to i16   ; 10 bytes
+  call void @call_target()   ; 10 bytes
+  ; bundle boundary
+  ret void
+}
+; X8664-LABEL: bundle_lock_pad_to_end_padding_0
+; X8664: <{{.*}}$local$__0>:
+; X8664: 56: {{.*}} push {{.*}}$local$__1
+; X8664: 5b: {{.*}} jmp {{.*}} call_target
+; X8664: 60: {{.*}} add
+
+; Tests the pad_to_end bundle alignment with 11 padding bytes needed, and some
+; instructions before the call.
+define internal void @bundle_lock_pad_to_end_padding_11(i32 %arg0, i32 %arg1,
+                                                        i32 %arg3, i32 %arg4,
+                                                        i32 %arg5, i32 %arg6) {
+  call void @call_target()
+  ; bundle boundary
+  %x = add i32 %arg5, %arg6  ; 11 bytes
+  call void @call_target()   ; 10 bytes
+                             ; 11 bytes of nop
+  ; bundle boundary
+  ret void
+}
+; X8664-LABEL: bundle_lock_pad_to_end_padding_11
+; X8664: <{{.*}}$local$__0>:
+; X8664: 4b: {{.*}} push {{.*}}$local$__1
+; X8664: 50: {{.*}} jmp {{.*}} call_target
+; X8664: 55: {{.*}} nop
+; X8664: 5d: {{.*}} nop
+; X8664: 60: {{.*}} add
+
+; Tests the pad_to_end bundle alignment with 22 padding bytes needed, and no
+; instructions before the call.
+define internal void @bundle_lock_pad_to_end_padding_22(i32 %arg0, i32 %arg1,
+                                                        i32 %arg3, i32 %arg4,
+                                                        i32 %arg5, i32 %arg6) {
+  call void @call_target()
+  ; bundle boundary
+  call void @call_target()   ; 10 bytes
+                             ; 22 bytes of nop
+  ; bundle boundary
+  ret void
+}
+; X8664-LABEL: bundle_lock_pad_to_end_padding_22
+; X8664: <{{.*}}$local$__0>:
+; X8664: 40: {{.*}} push {{.*}}$local$__1
+; X8664: 45: {{.*}} jmp {{.*}} call_target
+; X8664: 4a: {{.*}} nop
+; X8664: 52: {{.*}} nop
+; X8664: 5a: {{.*}} nop
+; X8664: 60: {{.*}} add
+
 ; Stack adjustment state during an argument push sequence gets
 ; properly checkpointed and restored during the two passes, as
 ; observed by the stack adjustment for accessing stack-allocated
 ; variables.
 define internal void @checkpoint_restore_stack_adjustment(i32 %arg) {
 entry:
   call void @call_target()
   ; bundle boundary
   call void @checkpoint_restore_stack_adjustment(i32 %arg)
   ret void
 }
 ; CHECK-LABEL: checkpoint_restore_stack_adjustment
 ; CHECK: sub esp,0x1c
 ; CHECK: call
 ; The address of %arg should be [esp+0x20], not [esp+0x30].
 ; CHECK-NEXT: mov [[REG:.*]],DWORD PTR [esp+0x20]
 ; CHECK-NEXT: mov DWORD PTR [esp],[[REG]]
 ; CHECK: call
 ; CHECK: add esp,0x1c
+