Add a few Subzero intrinsics (not the atomic ones yet).

tests_lit/llvm2ice_tests/nacl-other-intrinsics.ll

+; This tests the NaCl intrinsics not related to atomic operations.
+
+; RUN: %llvm2ice -O2 --verbose none %s | FileCheck %s
+; RUN: %llvm2ice -O2 --verbose none %s | FileCheck %s --check-prefix=CHECKO2REM
+; RUN: %llvm2ice -Om1 --verbose none %s | FileCheck %s
+; RUN: %llvm2ice --verbose none %s | FileCheck --check-prefix=ERRORS %s
+
+; Don't actually do the szdiff test: Subzero treats pointers as i32,

[Jim Stichnoth, 2014/06/10 22:58:28]

Could probably add "i8 \*" to ignore_pattern in szdiff.py.

[jvoung (off chromium), 2014/06/12 05:48:30]

Ignoring "@llvm." lines instead of i8\* -- Unfortunately, there's also i16*,
i32*, i64* when we include the atomic intrinsics, and that ignoring all pointer
types would affect the loads and stores too.

Also added line wrap normalization, and reordered some of the instructions to
make the --pnacl version's cast-eliding/cast-reinsertion happy (potentially
reinserts in a different order from original order). The cast-reinsertion also
makes the variable names different, so manually tweaked that for now...

[Jim Stichnoth, 2014/06/12 20:52:06]

Ouch.  At some point we may want to just retire szdiff.py...

+; but llvm's intrinsics may use i8* in its intrinsics that take pointer
+; parameters. So, there is a diff in the way pointer types are printed.
+; RUIN: %llvm2iceinsts %s | %szdiff %s | FileCheck --check-prefix=DUMP %s
+; RUIN: %llvm2iceinsts --pnacl %s | %szdiff %s \
+; RUIN:                           | FileCheck --check-prefix=DUMP %s
+
+declare i8* @llvm.nacl.read.tp()
+declare void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i32, i1)
+declare void @llvm.memmove.p0i8.p0i8.i32(i8*, i8*, i32, i32, i1)
+declare void @llvm.memset.p0i8.i32(i8*, i8, i32, i32, i1)
+declare void @llvm.nacl.longjmp(i8*, i32)
+declare i32 @llvm.nacl.setjmp(i8*)
+declare void @llvm.trap()
+
+define i32 @test_nacl_read_tp() {
+entry:
+  %ptr = call i8* @llvm.nacl.read.tp()
+  %r = ptrtoint i8* %ptr to i32
+  ret i32 %r
+}
+; 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]
+
+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]
+
+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)
+  ret void
+}
+; CHECK-LABEL: test_memcpy
+; CHECK: call 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)
+  ret void
+}
+; CHECK-LABEL: test_memcpy_const_len_align
+; CHECK: 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)
+  ret void
+}
+; CHECK-LABEL: test_memmove
+; CHECK: 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)
+  ret void
+}
+; CHECK-LABEL: test_memmove_const_len_align
+; CHECK: call memmove
+
+define void @test_memset(i32 %iptr_dst, i32 %wide_val, i32 %len) {
+entry:
+  %dst = inttoptr i32 %iptr_dst to i8*
+  %val = trunc i32 %wide_val to i8
+  call void @llvm.memset.p0i8.i32(i8* %dst, i8 %val,
+                                  i32 %len, i32 1, i1 0)
+  ret void
+}
+; CHECK-LABEL: test_memset
+; CHECK: call memset
+
+define void @test_memset_const_len_align(i32 %iptr_dst, i32 %wide_val) {
+entry:
+  %dst = inttoptr i32 %iptr_dst to i8*
+  %val = trunc i32 %wide_val to i8
+  call void @llvm.memset.p0i8.i32(i8* %dst, i8 %val,
+                                  i32 8, i32 1, i1 0)
+  ret void
+}
+; CHECK-LABEL: test_memset_const_len_align
+; CHECK: call 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:
+  call void @llvm.nacl.longjmp(i8* %env, i32 1)
+  ret i32 0
+NonZero:
+  ret i32 1
+}
+; CHECK-LABEL: test_setjmplongjmp
+; CHECK: call setjmp
+; CHECK: call longjmp
+; CHECKO2REM-LABEL: test_setjmplongjmp
+; CHECKO2REM: call setjmp
+; CHECKO2REM: call 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 setjmp
+
+define i32 @test_trap(i32 %br) {
+entry:
+  %r1 = icmp eq i32 %br, 0
+  br i1 %r1, label %Zero, label %NonZero
+Zero:
+  call void @llvm.trap()
+  unreachable
+NonZero:
+  ret i32 1
+}
+; CHECK-LABEL: test_trap
+; CHECK: ud2
+
+; ERRORS-NOT: ICE translation error