Subzero: Render constants in dump() to be more like LLVM.

tests_lit/llvm2ice_tests/nacl-other-intrinsics.ll

 ; This tests the NaCl intrinsics not related to atomic operations.
 
 ; TODO(jvoung): fix extra "CALLTARGETS" run. The llvm-objdump symbolizer
 ; doesn't know how to symbolize non-section-local functions.
 ; The newer LLVM 3.6 one does work, but watch out for other bugs.
 
 ; RUN: %llvm2ice -O2 --verbose none %s \
 ; RUN:   | FileCheck --check-prefix=CALLTARGETS %s
 ; RUN: %llvm2ice -O2 --verbose none -sandbox %s \
 ; RUN:   | llvm-mc -triple=i686-none-nacl -x86-asm-syntax=intel -filetype=obj \
@@ skipping 99 matching lines @@
 ; CHECKO2UNSANDBOXEDREM-LABEL: test_nacl_read_tp_dead
 ; CHECKO2UNSANDBOXEDREM-NOT: call -4
 ; CALLTARGETS-LABEL: test_nacl_read_tp_dead
 ; CALLTARGETS-NOT: call __nacl_read_tp
 
 define void @test_memcpy(i32 %iptr_dst, i32 %iptr_src, i32 %len) {
 entry:
   %dst = inttoptr i32 %iptr_dst to i8*
   %src = inttoptr i32 %iptr_src to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %src,
-                                       i32 %len, i32 1, i1 0)
+                                       i32 %len, i32 1, i1 false)
   ret void
 }
 ; CHECK-LABEL: test_memcpy
 ; CHECK: call -4
 ; CALLTARGETS-LABEL: test_memcpy
 ; CALLTARGETS: call memcpy
 ; CHECKO2REM-LABEL: test_memcpy
 ; CHECKO2UNSANDBOXEDREM-LABEL: test_memcpy
 
 ; TODO(jvoung) -- if we want to be clever, we can do this and the memmove,
 ; memset without a function call.
 define void @test_memcpy_const_len_align(i32 %iptr_dst, i32 %iptr_src) {
 entry:
   %dst = inttoptr i32 %iptr_dst to i8*
   %src = inttoptr i32 %iptr_src to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %src,
-                                       i32 8, i32 1, i1 0)
+                                       i32 8, i32 1, i1 false)
   ret void
 }
 ; CHECK-LABEL: test_memcpy_const_len_align
 ; CHECK: call -4
 ; CALLTARGETS-LABEL: test_memcpy_const_len_align
 ; CALLTARGETS: call memcpy
 
 define void @test_memmove(i32 %iptr_dst, i32 %iptr_src, i32 %len) {
 entry:
   %dst = inttoptr i32 %iptr_dst to i8*
   %src = inttoptr i32 %iptr_src to i8*
   call void @llvm.memmove.p0i8.p0i8.i32(i8* %dst, i8* %src,
-                                        i32 %len, i32 1, i1 0)
+                                        i32 %len, i32 1, i1 false)
   ret void
 }
 ; CHECK-LABEL: test_memmove
 ; CHECK: call -4
 ; CALLTARGETS-LABEL: test_memmove
 ; CALLTARGETS: call memmove
 
 define void @test_memmove_const_len_align(i32 %iptr_dst, i32 %iptr_src) {
 entry:
   %dst = inttoptr i32 %iptr_dst to i8*
   %src = inttoptr i32 %iptr_src to i8*
   call void @llvm.memmove.p0i8.p0i8.i32(i8* %dst, i8* %src,
-                                        i32 8, i32 1, i1 0)
+                                        i32 8, i32 1, i1 false)
   ret void
 }
 ; CHECK-LABEL: test_memmove_const_len_align
 ; CHECK: call -4
 ; CALLTARGETS-LABEL: test_memmove_const_len_align
 ; CALLTARGETS: call memmove
 
 define void @test_memset(i32 %iptr_dst, i32 %wide_val, i32 %len) {
 entry:
   %val = trunc i32 %wide_val to i8
   %dst = inttoptr i32 %iptr_dst to i8*
   call void @llvm.memset.p0i8.i32(i8* %dst, i8 %val,
-                                  i32 %len, i32 1, i1 0)
+                                  i32 %len, i32 1, i1 false)
   ret void
 }
 ; CHECK-LABEL: test_memset
 ; CHECK: movzx
 ; CHECK: call -4
 ; CALLTARGETS-LABEL: test_memset
 ; CALLTARGETS: call memset
 
 define void @test_memset_const_len_align(i32 %iptr_dst, i32 %wide_val) {
 entry:
   %val = trunc i32 %wide_val to i8
   %dst = inttoptr i32 %iptr_dst to i8*
   call void @llvm.memset.p0i8.i32(i8* %dst, i8 %val,
-                                  i32 8, i32 1, i1 0)
+                                  i32 8, i32 1, i1 false)
   ret void
 }
 ; CHECK-LABEL: test_memset_const_len_align
 ; CHECK: movzx
 ; CHECK: call -4
 ; CALLTARGETS-LABEL: test_memset_const_len_align
 ; CALLTARGETS: call memset
 
 define void @test_memset_const_val(i32 %iptr_dst, i32 %len) {
 entry:
   %dst = inttoptr i32 %iptr_dst to i8*
-  call void @llvm.memset.p0i8.i32(i8* %dst, i8 0, i32 %len, i32 1, i1 0)
+  call void @llvm.memset.p0i8.i32(i8* %dst, i8 0, i32 %len, i32 1, i1 false)
   ret void
 }
 ; CHECK-LABEL: test_memset_const_val
 ; Make sure the argument is legalized (can't movzx reg, 0).
 ; CHECK: movzx {{.*}}, {{[^0]}}
 ; CHECK: call -4
 ; CALLTARGETS-LABEL: test_memset_const_val
 ; CALLTARGETS: call memset
 
 
@@ skipping 130 matching lines @@
 entry:
   %r = call i64 @llvm.bswap.i64(i64 %x)
   ret i64 %r
 }
 ; CHECK-LABEL: test_bswap_64
 ; CHECK: bswap e{{.*}}
 ; CHECK: bswap e{{.*}}
 
 define i32 @test_ctlz_32(i32 %x) {
 entry:
-  %r = call i32 @llvm.ctlz.i32(i32 %x, i1 0)
+  %r = call i32 @llvm.ctlz.i32(i32 %x, i1 false)
   ret i32 %r
 }
 ; CHECK-LABEL: test_ctlz_32
 ; TODO(jvoung): If we detect that LZCNT is supported, then use that
 ; and avoid the need to do the cmovne and xor stuff to guarantee that
 ; the result is well-defined w/ input == 0.
 ; CHECK: bsr [[REG_TMP:e.*]], {{.*}}
 ; CHECK: mov [[REG_RES:e.*]], 63
 ; CHECK: cmovne [[REG_RES]], [[REG_TMP]]
 ; CHECK: xor [[REG_RES]], 31
 
 define i32 @test_ctlz_32_const() {
 entry:
-  %r = call i32 @llvm.ctlz.i32(i32 123456, i1 0)
+  %r = call i32 @llvm.ctlz.i32(i32 123456, i1 false)
   ret i32 %r
 }
 ; Could potentially constant fold this, but the front-end should have done that.
 ; The dest operand must be a register and the source operand must be a register
 ; or memory.
 ; CHECK-LABEL: test_ctlz_32_const
 ; CHECK: bsr e{{.*}}, {{.*}}e{{.*}}
 
 define i32 @test_ctlz_32_ignored(i32 %x) {
 entry:
-  %ignored = call i32 @llvm.ctlz.i32(i32 %x, i1 0)
+  %ignored = call i32 @llvm.ctlz.i32(i32 %x, i1 false)
   ret i32 1
 }
 ; CHECKO2REM-LABEL: test_ctlz_32_ignored
 ; CHECKO2REM-NOT: bsr
 
 define i64 @test_ctlz_64(i64 %x) {
 entry:
-  %r = call i64 @llvm.ctlz.i64(i64 %x, i1 0)
+  %r = call i64 @llvm.ctlz.i64(i64 %x, i1 false)
   ret i64 %r
 }
 ; CHECKO2REM-LABEL: test_ctlz_64
 ; CHECK-LABEL: test_ctlz_64
 ; CHECK: bsr [[REG_TMP1:e.*]], {{.*}}
 ; CHECK: mov [[REG_RES1:e.*]], 63
 ; CHECK: cmovne [[REG_RES1]], [[REG_TMP1]]
 ; CHECK: xor [[REG_RES1]], 31
 ; CHECK: add [[REG_RES1]], 32
 ; CHECK: bsr [[REG_RES2:e.*]], {{.*}}
 ; CHECK: xor [[REG_RES2]], 31
 ; CHECK: test [[REG_UPPER:.*]], [[REG_UPPER]]
 ; CHECK: cmove [[REG_RES2]], [[REG_RES1]]
 ; CHECK: mov {{.*}}, 0
 
 define i32 @test_ctlz_64_const(i64 %x) {
 entry:
-  %r = call i64 @llvm.ctlz.i64(i64 123456789012, i1 0)
+  %r = call i64 @llvm.ctlz.i64(i64 123456789012, i1 false)
   %r2 = trunc i64 %r to i32
   ret i32 %r2
 }
 ; CHECK-LABEL: test_ctlz_64_const
 ; CHECK: bsr e{{.*}}, {{.*}}e{{.*}}
 ; CHECK: bsr e{{.*}}, {{.*}}e{{.*}}
 
 
 define i32 @test_ctlz_64_ignored(i64 %x) {
 entry:
-  %ignored = call i64 @llvm.ctlz.i64(i64 1234567890, i1 0)
+  %ignored = call i64 @llvm.ctlz.i64(i64 1234567890, i1 false)
   ret i32 2
 }
 ; CHECKO2REM-LABEL: test_ctlz_64_ignored
 ; CHECKO2REM-NOT: bsr
 
 define i32 @test_cttz_32(i32 %x) {
 entry:
-  %r = call i32 @llvm.cttz.i32(i32 %x, i1 0)
+  %r = call i32 @llvm.cttz.i32(i32 %x, i1 false)
   ret i32 %r
 }
 ; CHECK-LABEL: test_cttz_32
 ; CHECK: bsf [[REG_IF_NOTZERO:e.*]], {{.*}}
 ; CHECK: mov [[REG_IF_ZERO:e.*]], 32
 ; CHECK: cmovne [[REG_IF_ZERO]], [[REG_IF_NOTZERO]]
 
 define i64 @test_cttz_64(i64 %x) {
 entry:
-  %r = call i64 @llvm.cttz.i64(i64 %x, i1 0)
+  %r = call i64 @llvm.cttz.i64(i64 %x, i1 false)
   ret i64 %r
 }
 ; CHECK-LABEL: test_cttz_64
 ; CHECK: bsf [[REG_IF_NOTZERO:e.*]], {{.*}}
 ; CHECK: mov [[REG_RES1:e.*]], 32
 ; CHECK: cmovne [[REG_RES1]], [[REG_IF_NOTZERO]]
 ; CHECK: add [[REG_RES1]], 32
 ; CHECK: bsf [[REG_RES2:e.*]], [[REG_LOWER:.*]]
 ; CHECK: test [[REG_LOWER]], [[REG_LOWER]]
 ; CHECK: cmove [[REG_RES2]], [[REG_RES1]]
@@ skipping 76 matching lines @@
 }
 ; CHECK-LABEL: test_stacksave_multiple
 ; At least 3 copies of esp, but probably more from having to do the allocas.
 ; CHECK: mov {{.*}}, esp
 ; CHECK: mov {{.*}}, esp
 ; CHECK: mov {{.*}}, esp
 ; CHECK: mov esp, {{.*}}
 
 ; ERRORS-NOT: ICE translation error
 ; DUMP-NOT: SZ