Rearrange emit vs emitIAS. Wait till function is done before dumping text.

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: %p2i -i %s --args -O2 --verbose none \
 ; RUN:   | FileCheck --check-prefix=CALLTARGETS %s
 ; RUN: %p2i -i %s --args -O2 --verbose none -sandbox \
 ; RUN:   | llvm-mc -triple=i686-none-nacl -filetype=obj \
@@ skipping 45 matching lines @@
   %__1 = ptrtoint i8* %ptr to i32
   ret i32 %__1
 }
 ; CHECK-LABEL: test_nacl_read_tp
 ; CHECK: mov e{{.*}}, dword ptr gs:[0]
 ; CHECKO2REM-LABEL: test_nacl_read_tp
 ; CHECKO2REM: mov e{{.*}}, dword ptr gs:[0]
 ; CHECKO2UNSANDBOXEDREM-LABEL: test_nacl_read_tp
 ; CHECKO2UNSANDBOXEDREM: call -4
 ; CALLTARGETS-LABEL: test_nacl_read_tp
-; CALLTARGETS: call __nacl_read_tp
+; CALLTARGETS: .long __nacl_read_tp
 
 define i32 @test_nacl_read_tp_more_addressing() {
 entry:
   %ptr = call i8* @llvm.nacl.read.tp()
   %__1 = ptrtoint i8* %ptr to i32
   %x = add i32 %__1, %__1
   %__3 = inttoptr i32 %x to i32*
   %v = load i32* %__3, align 1
   %v_add = add i32 %v, 1
 
   %ptr2 = call i8* @llvm.nacl.read.tp()
   %__6 = ptrtoint i8* %ptr2 to i32
   %y = add i32 %__6, 4
   %__8 = inttoptr i32 %y to i32*
   %v_add2 = add i32 %v, 4
   store i32 %v_add2, i32* %__8, align 1
   ret i32 %v
 }
 ; CHECK-LABEL: test_nacl_read_tp_more_addressing
 ; CHECK: mov e{{.*}}, dword ptr gs:[0]
 ; CHECK: mov e{{.*}}, dword ptr gs:[0]
 ; CHECKO2REM-LABEL: test_nacl_read_tp_more_addressing
 ; CHECKO2REM: mov e{{.*}}, dword ptr gs:[0]
 ; CHECKO2REM: mov e{{.*}}, dword ptr gs:[0]
 ; CHECKO2UNSANDBOXEDREM-LABEL: test_nacl_read_tp_more_addressing
 ; CHECKO2UNSANDBOXEDREM: call -4
 ; CHECKO2UNSANDBOXEDREM: call -4
 ; CALLTARGETS-LABEL: test_nacl_read_tp_more_addressing
-; CALLTARGETS: call __nacl_read_tp
-; CALLTARGETS: call __nacl_read_tp
+; CALLTARGETS: .long __nacl_read_tp
+; CALLTARGETS: .long __nacl_read_tp
 
 define i32 @test_nacl_read_tp_dead(i32 %a) {
 entry:
   %ptr = call i8* @llvm.nacl.read.tp()
   ; Not actually using the result of nacl read tp call.
   ; In O2 mode this should be DCE'ed.
   ret i32 %a
 }
 ; Consider nacl.read.tp side-effect free, so it can be eliminated.
 ; CHECKO2REM-LABEL: test_nacl_read_tp_dead
 ; CHECKO2REM-NOT: mov e{{.*}}, dword ptr gs:[0]
 ; 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 false)
   ret void
 }
 ; CHECK-LABEL: test_memcpy
 ; CHECK: call -4
 ; CALLTARGETS-LABEL: test_memcpy
-; CALLTARGETS: call memcpy
+; CALLTARGETS: .long 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 false)
   ret void
 }
 ; CHECK-LABEL: test_memcpy_const_len_align
 ; CHECK: call -4
 ; CALLTARGETS-LABEL: test_memcpy_const_len_align
-; CALLTARGETS: call memcpy
+; CALLTARGETS: .long 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 false)
   ret void
 }
 ; CHECK-LABEL: test_memmove
 ; CHECK: call -4
 ; CALLTARGETS-LABEL: test_memmove
-; CALLTARGETS: call memmove
+; CALLTARGETS: .long 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 false)
   ret void
 }
 ; CHECK-LABEL: test_memmove_const_len_align
 ; CHECK: call -4
 ; CALLTARGETS-LABEL: test_memmove_const_len_align
-; CALLTARGETS: call memmove
+; CALLTARGETS: .long 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 false)
   ret void
 }
 ; CHECK-LABEL: test_memset
 ; CHECK: movzx
 ; CHECK: call -4
 ; CALLTARGETS-LABEL: test_memset
-; CALLTARGETS: call memset
+; CALLTARGETS: .long 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 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
+; CALLTARGETS: .long 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 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
+; CALLTARGETS: .long memset
 
 
 define i32 @test_setjmplongjmp(i32 %iptr_env) {
 entry:
   %env = inttoptr i32 %iptr_env to i8*
   %i = call i32 @llvm.nacl.setjmp(i8* %env)
   %r1 = icmp eq i32 %i, 0
   br i1 %r1, label %Zero, label %NonZero
 Zero:
   ; Redundant inttoptr, to make --pnacl cast-eliding/re-insertion happy.
   %env2 = inttoptr i32 %iptr_env to i8*
   call void @llvm.nacl.longjmp(i8* %env2, i32 1)
   ret i32 0
 NonZero:
   ret i32 1
 }
 ; CHECK-LABEL: test_setjmplongjmp
 ; CHECK: call -4
 ; CHECK: call -4
 ; CHECKO2REM-LABEL: test_setjmplongjmp
 ; CHECKO2REM: call -4
 ; CHECKO2REM: call -4
 ; CALLTARGETS-LABEL: test_setjmplongjmp
-; CALLTARGETS: call setjmp
-; CALLTARGETS: call longjmp
+; CALLTARGETS: .long setjmp
+; CALLTARGETS: .long longjmp
 
 define i32 @test_setjmp_unused(i32 %iptr_env, i32 %i_other) {
 entry:
   %env = inttoptr i32 %iptr_env to i8*
   %i = call i32 @llvm.nacl.setjmp(i8* %env)
   ret i32 %i_other
 }
 ; Don't consider setjmp side-effect free, so it's not eliminated if
 ; result unused.
 ; CHECKO2REM-LABEL: test_setjmp_unused
 ; CHECKO2REM: call -4
 ; CALLTARGETS-LABEL: test_setjmp_unused
-; CALLTARGETS: call setjmp
+; CALLTARGETS: .long setjmp
 
 define float @test_sqrt_float(float %x, i32 %iptr) {
 entry:
   %r = call float @llvm.sqrt.f32(float %x)
   %r2 = call float @llvm.sqrt.f32(float %r)
   %r3 = call float @llvm.sqrt.f32(float -0.0)
   %r4 = fadd float %r2, %r3
   ret float %r4
 }
 ; CHECK-LABEL: test_sqrt_float
@@ skipping 187 matching lines @@
 ; CHECK: mov {{.*}}, 0
 
 define i32 @test_popcount_32(i32 %x) {
 entry:
   %r = call i32 @llvm.ctpop.i32(i32 %x)
   ret i32 %r
 }
 ; CHECK-LABEL: test_popcount_32
 ; CHECK: call -4
 ; CALLTARGETS-LABEL: test_popcount_32
-; CALLTARGETS: call __popcountsi2
+; CALLTARGETS: .long __popcountsi2
 
 define i64 @test_popcount_64(i64 %x) {
 entry:
   %r = call i64 @llvm.ctpop.i64(i64 %x)
   ret i64 %r
 }
 ; CHECK-LABEL: test_popcount_64
 ; CHECK: call -4
 ; __popcountdi2 only returns a 32-bit result, so clear the upper bits of
 ; the return value just in case.
 ; CHECK: mov {{.*}}, 0
 ; CALLTARGETS-LABEL: test_popcount_64
-; CALLTARGETS: call __popcountdi2
+; CALLTARGETS: .long __popcountdi2
 
 
 define i32 @test_popcount_64_ret_i32(i64 %x) {
 entry:
   %r_i64 = call i64 @llvm.ctpop.i64(i64 %x)
   %r = trunc i64 %r_i64 to i32
   ret i32 %r
 }
 ; If there is a trunc, then the mov {{.*}}, 0 is dead and gets optimized out.
 ; CHECKO2REM-LABEL: test_popcount_64_ret_i32
 ; CHECKO2REM: call -4
 ; CHECKO2REM-NOT: mov {{.*}}, 0
 ; CALLTARGETS-LABEL: test_popcount_64_ret_i32
-; CALLTARGETS: call __popcountdi2
+; CALLTARGETS: .long __popcountdi2
 
 define void @test_stacksave_noalloca() {
 entry:
   %sp = call i8* @llvm.stacksave()
   call void @llvm.stackrestore(i8* %sp)
   ret void
 }
 ; CHECK-LABEL: test_stacksave_noalloca
 ; CHECK: mov {{.*}}, esp
 ; CHECK: mov esp, {{.*}}
@@ skipping 25 matching lines @@
 
   call void @llvm.stackrestore(i8* %sp1)
   ret void
 }
 ; 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, {{.*}}