Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(516)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: tests_lit/llvm2ice_tests/nacl-atomic-intrinsics.ll

Issue 914263005: Subzero: switch from llvm-objdump to objdump for lit tests (for LLVM merge) (Closed) Base URL: https://chromium.googlesource.com/native_client/pnacl-subzero.git@master
Patch Set: Created 5 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« tests_lit/llvm2ice_tests/nacl-atomic-cmpxchg-optimization.ll ('K') | « tests_lit/llvm2ice_tests/nacl-atomic-fence-all.ll ('k') | tests_lit/llvm2ice_tests/nacl-other-intrinsics.ll » ('j') | tests_lit/llvm2ice_tests/vector-arith.ll » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: tests_lit/llvm2ice_tests/nacl-atomic-intrinsics.ll
diff --git a/tests_lit/llvm2ice_tests/nacl-atomic-intrinsics.ll b/tests_lit/llvm2ice_tests/nacl-atomic-intrinsics.ll
index c16f7c0429d918694553d08895b1e73f4310b96a..9c5ad5f7ce93d201ac967f1cd828bc951be89c66 100644
--- a/tests_lit/llvm2ice_tests/nacl-atomic-intrinsics.ll
+++ b/tests_lit/llvm2ice_tests/nacl-atomic-intrinsics.ll
@@ -1,17 +1,11 @@
; This tests each of the supported NaCl atomic instructions for every
; size allowed.
-; RUN: %p2i -i %s --args -O2 --verbose none \
-; RUN: | llvm-mc -triple=i686-none-nacl -filetype=obj \
-; RUN: | llvm-objdump -d --symbolize -x86-asm-syntax=intel - \
+; RUN: %p2i -i %s --assemble --disassemble --args -O2 --verbose none \
; RUN: | FileCheck %s
-; RUN: %p2i -i %s --args -O2 --verbose none \
-; RUN: | llvm-mc -triple=i686-none-nacl -filetype=obj \
-; RUN: | llvm-objdump -d --symbolize -x86-asm-syntax=intel - \
+; RUN: %p2i -i %s --assemble --disassemble --args -O2 --verbose none \
; RUN: | FileCheck --check-prefix=CHECKO2 %s
-; RUN: %p2i -i %s --args -Om1 --verbose none \
-; RUN: | llvm-mc -triple=i686-none-nacl -filetype=obj \
-; RUN: | llvm-objdump -d --symbolize -x86-asm-syntax=intel - \
+; RUN: %p2i -i %s --assemble --disassemble --args -Om1 --verbose none \
; RUN: | FileCheck %s
declare i8 @llvm.nacl.atomic.load.i8(i8*, i32)
@@ -53,8 +47,8 @@ entry:
ret i32 %r
}
; CHECK-LABEL: test_atomic_load_8
-; CHECK: mov {{.*}}, dword
-; CHECK: mov {{.*}}, byte
+; CHECK: mov {{.*}},DWORD
+; CHECK: mov {{.*}},byte
define i32 @test_atomic_load_16(i32 %iptr) {
entry:
@@ -64,8 +58,8 @@ entry:
ret i32 %r
}
; CHECK-LABEL: test_atomic_load_16
-; CHECK: mov {{.*}}, dword
-; CHECK: mov {{.*}}, word
+; CHECK: mov {{.*}},DWORD
+; CHECK: mov {{.*}},word
define i32 @test_atomic_load_32(i32 %iptr) {
entry:
@@ -74,8 +68,8 @@ entry:
ret i32 %r
}
; CHECK-LABEL: test_atomic_load_32
-; CHECK: mov {{.*}}, dword
-; CHECK: mov {{.*}}, dword
+; CHECK: mov {{.*}},DWORD
+; CHECK: mov {{.*}},DWORD
define i64 @test_atomic_load_64(i32 %iptr) {
entry:
@@ -84,8 +78,8 @@ entry:
ret i64 %r
}
; CHECK-LABEL: test_atomic_load_64
-; CHECK: movq x{{.*}}, qword
-; CHECK: movq qword {{.*}}, x{{.*}}
+; CHECK: movq x{{.*}},QWORD
+; CHECK: movq QWORD {{.*}},x{{.*}}
define i32 @test_atomic_load_32_with_arith(i32 %iptr) {
entry:
@@ -98,13 +92,13 @@ next:
ret i32 %r2
}
; CHECK-LABEL: test_atomic_load_32_with_arith
-; CHECK: mov {{.*}}, dword
+; CHECK: mov {{.*}},DWORD
; The next instruction may be a separate load or folded into an add.
;
; In O2 mode, we know that the load and add are going to be fused.
; CHECKO2-LABEL: test_atomic_load_32_with_arith
-; CHECKO2: mov {{.*}}, dword
-; CHECKO2: add {{.*}}, dword
+; CHECKO2: mov {{.*}}, DWORD
+; CHECKO2: add {{.*}}, DWORD
define i32 @test_atomic_load_32_ignored(i32 %iptr) {
entry:
@@ -113,11 +107,11 @@ entry:
ret i32 0
}
; CHECK-LABEL: test_atomic_load_32_ignored
-; CHECK: mov {{.*}}, dword
-; CHECK: mov {{.*}}, dword
+; CHECK: mov {{.*}},DWORD
+; CHECK: mov {{.*}},DWORD
; CHECKO2-LABEL: test_atomic_load_32_ignored
-; CHECKO2: mov {{.*}}, dword
-; CHECKO2: mov {{.*}}, dword
+; CHECKO2: mov {{.*}}, DWORD
+; CHECKO2: mov {{.*}}, DWORD
define i64 @test_atomic_load_64_ignored(i32 %iptr) {
entry:
@@ -126,8 +120,8 @@ entry:
ret i64 0
}
; CHECK-LABEL: test_atomic_load_64_ignored
-; CHECK: movq x{{.*}}, qword
-; CHECK: movq qword {{.*}}, x{{.*}}
+; CHECK: movq x{{.*}},QWORD
+; CHECK: movq QWORD {{.*}},x{{.*}}
;;; Store
@@ -160,7 +154,7 @@ entry:
ret void
}
; CHECK-LABEL: test_atomic_store_32
-; CHECK: mov dword
+; CHECK: mov DWORD
; CHECK: mfence
define void @test_atomic_store_64(i32 %iptr, i64 %v) {
@@ -170,8 +164,8 @@ entry:
ret void
}
; CHECK-LABEL: test_atomic_store_64
-; CHECK: movq x{{.*}}, qword
-; CHECK: movq qword {{.*}}, x{{.*}}
+; CHECK: movq x{{.*}},QWORD
+; CHECK: movq QWORD {{.*}},x{{.*}}
; CHECK: mfence
define void @test_atomic_store_64_const(i32 %iptr) {
@@ -181,10 +175,10 @@ entry:
ret void
}
; CHECK-LABEL: test_atomic_store_64_const
-; CHECK: mov {{.*}}, 1942892530
-; CHECK: mov {{.*}}, 2874
-; CHECK: movq x{{.*}}, qword
-; CHECK: movq qword {{.*}}, x{{.*}}
+; CHECK: mov {{.*}},1942892530
+; CHECK: mov {{.*}},2874
+; CHECK: movq x{{.*}},QWORD
+; CHECK: movq QWORD {{.*}},x{{.*}}
; CHECK: mfence
@@ -204,7 +198,7 @@ entry:
; CHECK-LABEL: test_atomic_rmw_add_8
; CHECK: lock
; CHECK-NEXT: xadd byte {{.*}}, [[REG:.*]]
-; CHECK: {{mov|movzx}} {{.*}}, [[REG]]
+; CHECK: {{mov|movzx}} {{.*}},[[REG]]
define i32 @test_atomic_rmw_add_16(i32 %iptr, i32 %v) {
entry:
@@ -217,7 +211,7 @@ entry:
; CHECK-LABEL: test_atomic_rmw_add_16
; CHECK: lock
; CHECK-NEXT: xadd word {{.*}}, [[REG:.*]]
-; CHECK: {{mov|movzx}} {{.*}}, [[REG]]
+; CHECK: {{mov|movzx}} {{.*}},[[REG]]
define i32 @test_atomic_rmw_add_32(i32 %iptr, i32 %v) {
entry:
@@ -227,8 +221,8 @@ entry:
}
; CHECK-LABEL: test_atomic_rmw_add_32
; CHECK: lock
-; CHECK-NEXT: xadd dword {{.*}}, [[REG:.*]]
-; CHECK: mov {{.*}}, [[REG]]
+; CHECK-NEXT: xadd DWORD {{.*}}, [[REG:.*]]
+; CHECK: mov {{.*}},[[REG]]
define i64 @test_atomic_rmw_add_64(i32 %iptr, i64 %v) {
entry:
@@ -238,20 +232,20 @@ entry:
}
; CHECK-LABEL: test_atomic_rmw_add_64
; CHECK: push ebx
-; CHECK: mov eax, dword ptr [{{.*}}]
-; CHECK: mov edx, dword ptr [{{.*}} + 4]
-; CHECK: mov ebx, eax
+; CHECK: mov eax,DWORD ptr [{{.*}}]
+; CHECK: mov edx,DWORD ptr [{{.*}}+4]
+; CHECK: mov ebx,eax
; RHS of add cannot be any of the e[abcd]x regs because they are
; clobbered in the loop, and the RHS needs to be remain live.
; CHECK: add ebx, {{.*e.[^x]}}
-; CHECK: mov ecx, edx
+; CHECK: mov ecx,edx
; CHECK: adc ecx, {{.*e.[^x]}}
; Ptr cannot be eax, ebx, ecx, or edx (used up for the expected and desired).
; It can be esi, edi, or ebp though, for example (so we need to be careful
; about rejecting eb* and ed*.)
; CHECK: lock
-; CHECK-NEXT: cmpxchg8b qword ptr [e{{.[^x]}}]
-; CHECK: jne -{{[0-9]}}
+; CHECK-NEXT: cmpxchg8b QWORD PTR [e{{.[^x]}}]
+; CHECK: jne-{{[0-9]}}
; Test with some more register pressure. When we have an alloca, ebp is
; used to manage the stack frame, so it cannot be used as a register either.
@@ -285,8 +279,9 @@ entry:
; the later use_ptr function call.
; That pretty much leaves esi, or edi as the only viable registers.
; CHECK: lock
-; CHECK-NEXT: cmpxchg8b qword ptr [e{{[ds]}}i]
-; CHECK: call use_ptr
+; CHECK-NEXT: cmpxchg8b QWORD PTR [e{{[ds]}}i]
+; CHECK: call
+; CHECK-NEXT: R_{{.*}} use_ptr
define i32 @test_atomic_rmw_add_32_ignored(i32 %iptr, i32 %v) {
entry:
@@ -298,7 +293,7 @@ entry:
; tells us that the destination variable is dead.
; CHECK-LABEL: test_atomic_rmw_add_32_ignored
; CHECK: lock
-; CHECK-NEXT: xadd dword {{.*}}, [[REG:.*]]
+; CHECK-NEXT: xadd DWORD {{.*}}, [[REG:.*]]
; Atomic RMW 64 needs to be expanded into its own loop.
; Make sure that works w/ non-trivial function bodies.
@@ -322,15 +317,15 @@ err:
}
; CHECK-LABEL: test_atomic_rmw_add_64_loop
; CHECK: push ebx
-; CHECK: mov eax, dword ptr [{{.*}}]
-; CHECK: mov edx, dword ptr [{{.*}} + 4]
-; CHECK: mov ebx, eax
+; CHECK: mov eax,DWORD ptr [{{.*}}]
+; CHECK: mov edx,DWORD ptr [{{.*}}+4]
+; CHECK: mov ebx,eax
; CHECK: add ebx, {{.*e.[^x]}}
-; CHECK: mov ecx, edx
+; CHECK: mov ecx,edx
; CHECK: adc ecx, {{.*e.[^x]}}
; CHECK: lock
-; CHECK-NEXT: cmpxchg8b qword ptr [e{{.[^x]}}]
-; CHECK: jne -{{[0-9]}}
+; CHECK-NEXT: cmpxchg8b QWORD PTR [e{{.[^x]}}]
+; CHECK: jne-{{[0-9]}}
;; sub
@@ -346,7 +341,7 @@ entry:
; CHECK: neg [[REG:.*]]
; CHECK: lock
; CHECK-NEXT: xadd byte {{.*}}, [[REG]]
-; CHECK: {{mov|movzx}} {{.*}}, [[REG]]
+; CHECK: {{mov|movzx}} {{.*}},[[REG]]
define i32 @test_atomic_rmw_sub_16(i32 %iptr, i32 %v) {
entry:
@@ -360,7 +355,7 @@ entry:
; CHECK: neg [[REG:.*]]
; CHECK: lock
; CHECK-NEXT: xadd word {{.*}}, [[REG]]
-; CHECK: {{mov|movzx}} {{.*}}, [[REG]]
+; CHECK: {{mov|movzx}} {{.*}},[[REG]]
define i32 @test_atomic_rmw_sub_32(i32 %iptr, i32 %v) {
entry:
@@ -371,8 +366,8 @@ entry:
; CHECK-LABEL: test_atomic_rmw_sub_32
; CHECK: neg [[REG:.*]]
; CHECK: lock
-; CHECK-NEXT: xadd dword {{.*}}, [[REG]]
-; CHECK: mov {{.*}}, [[REG]]
+; CHECK-NEXT: xadd DWORD {{.*}}, [[REG]]
+; CHECK: mov {{.*}},[[REG]]
define i64 @test_atomic_rmw_sub_64(i32 %iptr, i64 %v) {
entry:
@@ -382,15 +377,15 @@ entry:
}
; CHECK-LABEL: test_atomic_rmw_sub_64
; CHECK: push ebx
-; CHECK: mov eax, dword ptr [{{.*}}]
-; CHECK: mov edx, dword ptr [{{.*}} + 4]
-; CHECK: mov ebx, eax
+; CHECK: mov eax,DWORD ptr [{{.*}}]
+; CHECK: mov edx,DWORD ptr [{{.*}}+4]
+; CHECK: mov ebx,eax
; CHECK: sub ebx, {{.*e.[^x]}}
-; CHECK: mov ecx, edx
+; CHECK: mov ecx,edx
; CHECK: sbb ecx, {{.*e.[^x]}}
; CHECK: lock
-; CHECK-NEXT: cmpxchg8b qword ptr [e{{.[^x]}}]
-; CHECK: jne -{{[0-9]}}
+; CHECK-NEXT: cmpxchg8b QWORD PTR [e{{.[^x]}}]
+; CHECK: jne-{{[0-9]}}
define i32 @test_atomic_rmw_sub_32_ignored(i32 %iptr, i32 %v) {
@@ -403,7 +398,7 @@ entry:
; CHECK-LABEL: test_atomic_rmw_sub_32_ignored
; CHECK: neg [[REG:.*]]
; CHECK: lock
-; CHECK-NEXT: xadd dword {{.*}}, [[REG]]
+; CHECK-NEXT: xadd DWORD {{.*}}, [[REG]]
;; or
@@ -416,13 +411,13 @@ entry:
ret i32 %a_ext
}
; CHECK-LABEL: test_atomic_rmw_or_8
-; CHECK: mov al, byte ptr
+; CHECK: mov al,BYTE PTR
; Dest cannot be eax here, because eax is used for the old value. Also want
; to make sure that cmpxchg's source is the same register.
; CHECK: or [[REG:[^a].]]
; CHECK: lock
-; CHECK-NEXT: cmpxchg byte ptr [e{{[^a].}}], [[REG]]
-; CHECK: jne -{{[0-9]}}
+; CHECK-NEXT: cmpxchg BYTE PTR [e{{[^a].}}], [[REG]]
+; CHECK: jne-{{[0-9]}}
define i32 @test_atomic_rmw_or_16(i32 %iptr, i32 %v) {
entry:
@@ -433,11 +428,11 @@ entry:
ret i32 %a_ext
}
; CHECK-LABEL: test_atomic_rmw_or_16
-; CHECK: mov ax, word ptr
+; CHECK: mov ax,word ptr
; CHECK: or [[REG:[^a].]]
; CHECK: lock
; CHECK-NEXT: cmpxchg word ptr [e{{[^a].}}], [[REG]]
-; CHECK: jne -{{[0-9]}}
+; CHECK: jne-{{[0-9]}}
define i32 @test_atomic_rmw_or_32(i32 %iptr, i32 %v) {
entry:
@@ -446,11 +441,11 @@ entry:
ret i32 %a
}
; CHECK-LABEL: test_atomic_rmw_or_32
-; CHECK: mov eax, dword ptr
+; CHECK: mov eax,DWORD ptr
; CHECK: or [[REG:e[^a].]]
; CHECK: lock
-; CHECK-NEXT: cmpxchg dword ptr [e{{[^a].}}], [[REG]]
-; CHECK: jne -{{[0-9]}}
+; CHECK-NEXT: cmpxchg DWORD PTR [e{{[^a].}}], [[REG]]
+; CHECK: jne-{{[0-9]}}
define i64 @test_atomic_rmw_or_64(i32 %iptr, i64 %v) {
entry:
@@ -460,15 +455,15 @@ entry:
}
; CHECK-LABEL: test_atomic_rmw_or_64
; CHECK: push ebx
-; CHECK: mov eax, dword ptr [{{.*}}]
-; CHECK: mov edx, dword ptr [{{.*}} + 4]
-; CHECK: mov ebx, eax
+; CHECK: mov eax,DWORD ptr [{{.*}}]
+; CHECK: mov edx,DWORD ptr [{{.*}}+4]
+; CHECK: mov ebx,eax
; CHECK: or ebx, {{.*e.[^x]}}
-; CHECK: mov ecx, edx
+; CHECK: mov ecx,edx
; CHECK: or ecx, {{.*e.[^x]}}
; CHECK: lock
-; CHECK-NEXT: cmpxchg8b qword ptr [e{{.[^x]}}]
-; CHECK: jne -{{[0-9]}}
+; CHECK-NEXT: cmpxchg8b QWORD PTR [e{{.[^x]}}]
+; CHECK: jne-{{[0-9]}}
define i32 @test_atomic_rmw_or_32_ignored(i32 %iptr, i32 %v) {
entry:
@@ -480,11 +475,11 @@ entry:
; Could just "lock or", if we inspect the liveness information first.
; Would also need a way to introduce "lock"'edness to binary
; operators without introducing overhead on the more common binary ops.
-; CHECK: mov eax, dword ptr
+; CHECK: mov eax,DWORD ptr
; CHECK: or [[REG:e[^a].]]
; CHECK: lock
-; CHECK-NEXT: cmpxchg dword ptr [e{{[^a].}}], [[REG]]
-; CHECK: jne -{{[0-9]}}
+; CHECK-NEXT: cmpxchg DWORD PTR [e{{[^a].}}], [[REG]]
+; CHECK: jne-{{[0-9]}}
;; and
@@ -497,11 +492,11 @@ entry:
ret i32 %a_ext
}
; CHECK-LABEL: test_atomic_rmw_and_8
-; CHECK: mov al, byte ptr
+; CHECK: mov al,BYTE PTR
; CHECK: and [[REG:[^a].]]
; CHECK: lock
-; CHECK-NEXT: cmpxchg byte ptr [e{{[^a].}}], [[REG]]
-; CHECK: jne -{{[0-9]}}
+; CHECK-NEXT: cmpxchg BYTE PTR [e{{[^a].}}], [[REG]]
+; CHECK: jne-{{[0-9]}}
define i32 @test_atomic_rmw_and_16(i32 %iptr, i32 %v) {
entry:
@@ -512,11 +507,11 @@ entry:
ret i32 %a_ext
}
; CHECK-LABEL: test_atomic_rmw_and_16
-; CHECK: mov ax, word ptr
+; CHECK: mov ax,word ptr
; CHECK: and
; CHECK: lock
; CHECK-NEXT: cmpxchg word ptr [e{{[^a].}}]
-; CHECK: jne -{{[0-9]}}
+; CHECK: jne-{{[0-9]}}
define i32 @test_atomic_rmw_and_32(i32 %iptr, i32 %v) {
entry:
@@ -525,11 +520,11 @@ entry:
ret i32 %a
}
; CHECK-LABEL: test_atomic_rmw_and_32
-; CHECK: mov eax, dword ptr
+; CHECK: mov eax,DWORD ptr
; CHECK: and
; CHECK: lock
-; CHECK-NEXT: cmpxchg dword ptr [e{{[^a].}}]
-; CHECK: jne -{{[0-9]}}
+; CHECK-NEXT: cmpxchg DWORD PTR [e{{[^a].}}]
+; CHECK: jne-{{[0-9]}}
define i64 @test_atomic_rmw_and_64(i32 %iptr, i64 %v) {
entry:
@@ -539,15 +534,15 @@ entry:
}
; CHECK-LABEL: test_atomic_rmw_and_64
; CHECK: push ebx
-; CHECK: mov eax, dword ptr [{{.*}}]
-; CHECK: mov edx, dword ptr [{{.*}} + 4]
-; CHECK: mov ebx, eax
+; CHECK: mov eax,DWORD ptr [{{.*}}]
+; CHECK: mov edx,DWORD ptr [{{.*}}+4]
+; CHECK: mov ebx,eax
; CHECK: and ebx, {{.*e.[^x]}}
-; CHECK: mov ecx, edx
+; CHECK: mov ecx,edx
; CHECK: and ecx, {{.*e.[^x]}}
; CHECK: lock
-; CHECK-NEXT: cmpxchg8b qword ptr [e{{.[^x]}}]
-; CHECK: jne -{{[0-9]}}
+; CHECK-NEXT: cmpxchg8b QWORD PTR [e{{.[^x]}}]
+; CHECK: jne-{{[0-9]}}
define i32 @test_atomic_rmw_and_32_ignored(i32 %iptr, i32 %v) {
entry:
@@ -557,11 +552,11 @@ entry:
}
; CHECK-LABEL: test_atomic_rmw_and_32_ignored
; Could just "lock and"
-; CHECK: mov eax, dword ptr
+; CHECK: mov eax,DWORD ptr
; CHECK: and
; CHECK: lock
-; CHECK-NEXT: cmpxchg dword ptr [e{{[^a].}}]
-; CHECK: jne -{{[0-9]}}
+; CHECK-NEXT: cmpxchg DWORD PTR [e{{[^a].}}]
+; CHECK: jne-{{[0-9]}}
;; xor
@@ -574,11 +569,11 @@ entry:
ret i32 %a_ext
}
; CHECK-LABEL: test_atomic_rmw_xor_8
-; CHECK: mov al, byte ptr
+; CHECK: mov al,BYTE PTR
; CHECK: xor [[REG:[^a].]]
; CHECK: lock
-; CHECK-NEXT: cmpxchg byte ptr [e{{[^a].}}], [[REG]]
-; CHECK: jne -{{[0-9]}}
+; CHECK-NEXT: cmpxchg BYTE PTR [e{{[^a].}}], [[REG]]
+; CHECK: jne-{{[0-9]}}
define i32 @test_atomic_rmw_xor_16(i32 %iptr, i32 %v) {
entry:
@@ -589,11 +584,11 @@ entry:
ret i32 %a_ext
}
; CHECK-LABEL: test_atomic_rmw_xor_16
-; CHECK: mov ax, word ptr
+; CHECK: mov ax,word ptr
; CHECK: xor
; CHECK: lock
; CHECK-NEXT: cmpxchg word ptr [e{{[^a].}}]
-; CHECK: jne -{{[0-9]}}
+; CHECK: jne-{{[0-9]}}
define i32 @test_atomic_rmw_xor_32(i32 %iptr, i32 %v) {
@@ -603,11 +598,11 @@ entry:
ret i32 %a
}
; CHECK-LABEL: test_atomic_rmw_xor_32
-; CHECK: mov eax, dword ptr
+; CHECK: mov eax,DWORD ptr
; CHECK: xor
; CHECK: lock
-; CHECK-NEXT: cmpxchg dword ptr [e{{[^a].}}]
-; CHECK: jne -{{[0-9]}}
+; CHECK-NEXT: cmpxchg DWORD PTR [e{{[^a].}}]
+; CHECK: jne-{{[0-9]}}
define i64 @test_atomic_rmw_xor_64(i32 %iptr, i64 %v) {
entry:
@@ -617,15 +612,15 @@ entry:
}
; CHECK-LABEL: test_atomic_rmw_xor_64
; CHECK: push ebx
-; CHECK: mov eax, dword ptr [{{.*}}]
-; CHECK: mov edx, dword ptr [{{.*}} + 4]
-; CHECK: mov ebx, eax
+; CHECK: mov eax,DWORD ptr [{{.*}}]
+; CHECK: mov edx,DWORD ptr [{{.*}}+4]
+; CHECK: mov ebx,eax
; CHECK: or ebx, {{.*e.[^x]}}
-; CHECK: mov ecx, edx
+; CHECK: mov ecx,edx
; CHECK: or ecx, {{.*e.[^x]}}
; CHECK: lock
-; CHECK-NEXT: cmpxchg8b qword ptr [e{{.[^x]}}]
-; CHECK: jne -{{[0-9]}}
+; CHECK-NEXT: cmpxchg8b QWORD PTR [e{{.[^x]}}]
+; CHECK: jne-{{[0-9]}}
define i32 @test_atomic_rmw_xor_32_ignored(i32 %iptr, i32 %v) {
entry:
@@ -634,11 +629,11 @@ entry:
ret i32 %v
}
; CHECK-LABEL: test_atomic_rmw_xor_32_ignored
-; CHECK: mov eax, dword ptr
+; CHECK: mov eax,DWORD ptr
; CHECK: xor
; CHECK: lock
-; CHECK-NEXT: cmpxchg dword ptr [e{{[^a].}}]
-; CHECK: jne -{{[0-9]}}
+; CHECK-NEXT: cmpxchg DWORD PTR [e{{[^a].}}]
+; CHECK: jne-{{[0-9]}}
;; exchange
@@ -651,7 +646,7 @@ entry:
ret i32 %a_ext
}
; CHECK-LABEL: test_atomic_rmw_xchg_8
-; CHECK: xchg byte ptr {{.*}}, [[REG:.*]]
+; CHECK: xchg BYTE PTR {{.*}}, [[REG:.*]]
define i32 @test_atomic_rmw_xchg_16(i32 %iptr, i32 %v) {
entry:
@@ -671,7 +666,7 @@ entry:
ret i32 %a
}
; CHECK-LABEL: test_atomic_rmw_xchg_32
-; CHECK: xchg dword ptr {{.*}}, [[REG:.*]]
+; CHECK: xchg DWORD PTR {{.*}}, [[REG:.*]]
define i64 @test_atomic_rmw_xchg_64(i32 %iptr, i64 %v) {
entry:
@@ -686,8 +681,8 @@ entry:
; CHECK-DAG: mov ecx
; CHECK-DAG: mov ebx
; CHECK: lock
-; CHECK-NEXT: cmpxchg8b qword ptr [{{e.[^x]}}]
-; CHECK: jne -{{[0-9]}}
+; CHECK-NEXT: cmpxchg8b QWORD PTR [{{e.[^x]}}]
+; CHECK: jne-{{[0-9]}}
define i32 @test_atomic_rmw_xchg_32_ignored(i32 %iptr, i32 %v) {
entry:
@@ -698,7 +693,7 @@ entry:
; In this case, ignoring the return value doesn't help. The xchg is
; used to do an atomic store.
; CHECK-LABEL: test_atomic_rmw_xchg_32_ignored
-; CHECK: xchg dword ptr {{.*}}, [[REG:.*]]
+; CHECK: xchg DWORD PTR {{.*}}, [[REG:.*]]
;;;; Cmpxchg
@@ -713,11 +708,11 @@ entry:
ret i32 %old_ext
}
; CHECK-LABEL: test_atomic_cmpxchg_8
-; CHECK: mov eax, {{.*}}
+; CHECK: mov eax,{{.*}}
; Need to check that eax isn't used as the address register or the desired.
; since it is already used as the *expected* register.
; CHECK: lock
-; CHECK-NEXT: cmpxchg byte ptr [e{{[^a].}}], {{[^a]}}l
+; CHECK-NEXT: cmpxchg BYTE PTR [e{{[^a].}}], {{[^a]}}l
define i32 @test_atomic_cmpxchg_16(i32 %iptr, i32 %expected, i32 %desired) {
entry:
@@ -730,7 +725,7 @@ entry:
ret i32 %old_ext
}
; CHECK-LABEL: test_atomic_cmpxchg_16
-; CHECK: mov eax, {{.*}}
+; CHECK: mov eax,{{.*}}
; CHECK: lock
; CHECK-NEXT: cmpxchg word ptr [e{{[^a].}}], {{[^a]}}x
@@ -742,9 +737,9 @@ entry:
ret i32 %old
}
; CHECK-LABEL: test_atomic_cmpxchg_32
-; CHECK: mov eax, {{.*}}
+; CHECK: mov eax,{{.*}}
; CHECK: lock
-; CHECK-NEXT: cmpxchg dword ptr [e{{[^a].}}], e{{[^a]}}
+; CHECK-NEXT: cmpxchg DWORD PTR [e{{[^a].}}], e{{[^a]}}
define i64 @test_atomic_cmpxchg_64(i32 %iptr, i64 %expected, i64 %desired) {
entry:
@@ -760,7 +755,7 @@ entry:
; CHECK-DAG: mov ecx
; CHECK-DAG: mov ebx
; CHECK: lock
-; CHECK-NEXT: cmpxchg8b qword ptr [e{{.[^x]}}]
+; CHECK-NEXT: cmpxchg8b QWORD PTR [e{{.[^x]}}]
; edx and eax are already the return registers, so they don't actually
; need to be reshuffled via movs. The next test stores the result
; somewhere, so in that case they do need to be mov'ed.
@@ -782,7 +777,7 @@ entry:
; CHECK-DAG: mov ecx
; CHECK-DAG: mov ebx
; CHECK: lock
-; CHECK-NEXT: cmpxchg8b qword ptr [e{{.[^x]}}]
+; CHECK-NEXT: cmpxchg8b QWORD PTR [e{{.[^x]}}]
; CHECK-DAG: mov {{.*}}, edx
; CHECK-DAG: mov {{.*}}, eax
@@ -814,8 +809,9 @@ entry:
; the later use_ptr function call.
; That pretty much leaves esi, or edi as the only viable registers.
; CHECK: lock
-; CHECK-NEXT: cmpxchg8b qword ptr [e{{[ds]}}i]
-; CHECK: call use_ptr
+; CHECK-NEXT: cmpxchg8b QWORD PTR [e{{[ds]}}i]
+; CHECK: call
+; CHECK-NEXT: R_{{.*}} use_ptr
define i32 @test_atomic_cmpxchg_32_ignored(i32 %iptr, i32 %expected, i32 %desired) {
entry:
@@ -825,9 +821,9 @@ entry:
ret i32 0
}
; CHECK-LABEL: test_atomic_cmpxchg_32_ignored
-; CHECK: mov eax, {{.*}}
+; CHECK: mov eax,{{.*}}
; CHECK: lock
-; CHECK-NEXT: cmpxchg dword ptr [e{{[^a].}}]
+; CHECK-NEXT: cmpxchg DWORD PTR [e{{[^a].}}]
define i64 @test_atomic_cmpxchg_64_ignored(i32 %iptr, i64 %expected, i64 %desired) {
entry:
@@ -843,7 +839,7 @@ entry:
; CHECK-DAG: mov ecx
; CHECK-DAG: mov ebx
; CHECK: lock
-; CHECK-NEXT: cmpxchg8b qword ptr [e{{.[^x]}}]
+; CHECK-NEXT: cmpxchg8b QWORD PTR [e{{.[^x]}}]
;;;; Fence and is-lock-free.
@@ -871,7 +867,7 @@ entry:
ret i32 %r
}
; CHECK-LABEL: test_atomic_is_lock_free
-; CHECK: mov {{.*}}, 1
+; CHECK: mov {{.*}},1
define i32 @test_not_lock_free(i32 %iptr) {
entry:
@@ -881,7 +877,7 @@ entry:
ret i32 %r
}
; CHECK-LABEL: test_not_lock_free
-; CHECK: mov {{.*}}, 0
+; CHECK: mov {{.*}},0
define i32 @test_atomic_is_lock_free_ignored(i32 %iptr) {
entry:
@@ -890,7 +886,7 @@ entry:
ret i32 0
}
; CHECK-LABEL: test_atomic_is_lock_free_ignored
-; CHECK: mov {{.*}}, 0
+; CHECK: mov {{.*}},0
; This can get optimized out, because it's side-effect-free.
; CHECKO2-LABEL: test_atomic_is_lock_free_ignored
; CHECKO2-NOT: mov {{.*}}, 1
@@ -915,7 +911,7 @@ not_lock_free:
ret i32 %z
}
; CHECK-LABEL: test_atomic_is_lock_free_can_dce
-; CHECK: mov {{.*}}, 1
+; CHECK: mov {{.*}},1
; CHECK: ret
; CHECK: add
; CHECK: ret
« tests_lit/llvm2ice_tests/nacl-atomic-cmpxchg-optimization.ll ('K') | « tests_lit/llvm2ice_tests/nacl-atomic-fence-all.ll ('k') | tests_lit/llvm2ice_tests/nacl-other-intrinsics.ll » ('j') | tests_lit/llvm2ice_tests/vector-arith.ll » ('J')

Powered by Google App Engine
This is Rietveld 408576698