Handle pointer conversions for call instructions.

This also should complete the changes associated with removing pointer cast
instructions from the PNaCl bitcode file.

BUG= https://code.google.com/p/nativeclient/issues/detail?id=3544
R=dschuff@chromium.org, jvoung@chromium.org

Review URL: https://codereview.chromium.org/23482002

4 files changed, 394 insertions, 9 deletions

diff --git a/test/NaCl/Bitcode/bitcast-elide.ll b/test/NaCl/Bitcode/bitcast-elide.ll
index 383673d684..418b593762 100644
--- a/test/NaCl/Bitcode/bitcast-elide.ll
+++ b/test/NaCl/Bitcode/bitcast-elide.ll
@@ -1,5 +1,4 @@
 ; Test how we handle eliding (pointer) bitcast instructions.
-; TODO(kschimpf) Expand these tests as further CL's are added for issue 3544.
 
 ; RUN: llvm-as < %s | pnacl-freeze --pnacl-version=1 \
 ; RUN:              | pnacl-bcanalyzer -dump-records \
diff --git a/test/NaCl/Bitcode/call-elide.ll b/test/NaCl/Bitcode/call-elide.ll
new file mode 100644
index 0000000000..b3acb36a9d
--- /dev/null
+++ b/test/NaCl/Bitcode/call-elide.ll
@@ -0,0 +1,391 @@
+; Test how we handle eliding pointers in call instructions.
+
+; RUN: llvm-as < %s | pnacl-freeze --pnacl-version=1 \
+; RUN:              | pnacl-bcanalyzer -dump-records \
+; RUN:              | FileCheck %s -check-prefix=PF1
+
+; RUN: llvm-as < %s | pnacl-freeze --pnacl-version=1 | pnacl-thaw \
+; RUN:              | llvm-dis - | FileCheck %s -check-prefix=TD1
+
+; RUN: llvm-as < %s | pnacl-freeze --pnacl-version=2 \
+; RUN:              | pnacl-bcanalyzer -dump-records \
+; RUN:              | FileCheck %s -check-prefix=PF2
+
+; RUN: llvm-as < %s | pnacl-freeze --pnacl-version=2 | pnacl-thaw \
+; RUN:              | llvm-dis - | FileCheck %s -check-prefix=TD2
+
+; ------------------------------------------------------
+; Define some global functions/variables to be used in testing.
+
+
+@bytes = internal global [4 x i8] c"abcd"
+declare void @foo(i32 %i)
+declare i32 @bar(i32* %i)
+
+; ------------------------------------------------------
+; Test how we handle a direct call.
+
+define void @DirectCall() {
+  call void @foo(i32 0)
+  ret void
+}
+
+; TD1:      define void @DirectCall() {
+; TD1-NEXT:   call void @foo(i32 0)
+; TD1-NEXT:   ret void
+; TD1-NEXT: }
+
+; PF1:      <FUNCTION_BLOCK>
+; PF1:        </CONSTANTS_BLOCK>
+; PF1-NEXT:   <INST_CALL op0=0 op1=14 op2=1/>
+; PF1-NEXT:   <INST_RET/>
+; PF1-NEXT: </FUNCTION_BLOCK>
+
+; TD2:      define void @DirectCall() {
+; TD2-NEXT:   call void @foo(i32 0)
+; TD2-NEXT:   ret void
+; TD2-NEXT: }
+
+; PF2:      <FUNCTION_BLOCK>
+; PF2:        </CONSTANTS_BLOCK>
+; PF2-NEXT:   <INST_CALL op0=0 op1=14 op2=1/>
+; PF2-NEXT:   <INST_RET/>
+; PF2-NEXT: </FUNCTION_BLOCK>
+
+; ------------------------------------------------------
+; Test how we handle a direct call with a normalized inttoptr argument.
+; Note: This code doesn't follow the PNaCl ABI in that function
+; calls can't get pointer arguments. However, intrinsic calls can, and
+; this code is a placeholder for such a test.
+
+define void @DirectCallIntToPtrArg(i32 %i) {
+  %1 = inttoptr i32 %i to i32*
+  %2 = call i32 @bar(i32* %1)
+  ret void
+}
+
+; TD1:      define void @DirectCallIntToPtrArg(i32 %i) {
+; TD1-NEXT:   %1 = inttoptr i32 %i to i32*
+; TD1-NEXT:   %2 = call i32 @bar(i32* %1)
+; TD1-NEXT:   ret void
+; TD1-NEXT: }
+
+; PF1:      <FUNCTION_BLOCK>
+; PF1-NEXT:   <DECLAREBLOCKS op0=1/>
+; PF1-NEXT:   <INST_CAST op0=1 op1=4 op2=10/>
+; PF1-NEXT:   <INST_CALL op0=0 op1=14 op2=1/>
+; PF1-NEXT:   <INST_RET/>
+; PF1:      </FUNCTION_BLOCK>
+
+; TD2:      define void @DirectCallIntToPtrArg(i32 %i) {
+; TD2-NEXT:   %1 = inttoptr i32 %i to i32*
+; TD2-NEXT:   %2 = call i32 @bar(i32* %1)
+; TD2-NEXT:   ret void
+; TD2-NEXT: }
+
+; PF2:      <FUNCTION_BLOCK>
+; PF2-NEXT:   <DECLAREBLOCKS op0=1/>
+; PF2-NEXT:   <INST_CALL op0=0 op1=13 op2=1/>
+; PF2-NEXT:   <INST_RET/>
+; PF2:      </FUNCTION_BLOCK>
+
+; ------------------------------------------------------
+; Test how we handle a direct call with a normalized ptroint argument.
+
+define void @DirectCallPtrToIntArg() {
+  %1 = alloca i8, i32 4, align 8
+  %2 = ptrtoint i8* %1 to i32
+  call void @foo(i32 %2)
+  ret void
+}
+
+; TD1:      define void @DirectCallPtrToIntArg() {
+; TD1-NEXT:   %1 = alloca i8, i32 4, align 8
+; TD1-NEXT:   %2 = ptrtoint i8* %1 to i32
+; TD1-NEXT:   call void @foo(i32 %2)
+; TD1-NEXT:   ret void
+; TD1-NEXT: }
+
+; PF1:      <FUNCTION_BLOCK>
+; PF1:        </CONSTANTS_BLOCK>
+; PF1-NEXT:   <INST_ALLOCA op0=1 op1=4/>
+; PF1-NEXT:   <INST_CAST op0=1 op1=0 op2=9/>
+; PF1-NEXT:   <INST_CALL op0=0 op1=16 op2=1/>
+; PF1-NEXT:   <INST_RET/>
+; PF1-NEXT: </FUNCTION_BLOCK>
+
+; TD2:      define void @DirectCallPtrToIntArg() {
+; TD2-NEXT:   %1 = alloca i8, i32 4, align 8
+; TD2-NEXT:   %2 = ptrtoint i8* %1 to i32
+; TD2-NEXT:   call void @foo(i32 %2)
+; TD2-NEXT:   ret void
+; TD2-NEXT: }
+
+; PF2:      <FUNCTION_BLOCK>
+; PF2:        </CONSTANTS_BLOCK>
+; PF2-NEXT:   <INST_ALLOCA op0=1 op1=4/>
+; PF2-NEXT:   <INST_CALL op0=0 op1=15 op2=1/>
+; PF2-NEXT:   <INST_RET/>
+; PF2-NEXT: </FUNCTION_BLOCK>
+
+; ------------------------------------------------------
+; Test how we handle a direct call with a normalized bitcast argument.
+
+define void @DirectCallBitcastArg(i32 %i) {
+  %1 = bitcast [4 x i8]* @bytes to i32*
+  %2 = call i32 @bar(i32* %1)
+  ret void
+}
+
+; TD1:      define void @DirectCallBitcastArg(i32 %i) {
+; TD1-NEXT:   %1 = bitcast [4 x i8]* @bytes to i32*
+; TD1-NEXT:   %2 = call i32 @bar(i32* %1)
+; TD1-NEXT:   ret void
+; TD1-NEXT: }
+
+; PF1:      <FUNCTION_BLOCK>
+; PF1-NEXT:   <DECLAREBLOCKS op0=1/>
+; PF1-NEXT:   <INST_CAST op0=2 op1=4 op2=11/>
+; PF1-NEXT:   <INST_CALL op0=0 op1=14 op2=1/>
+; PF1-NEXT:   <INST_RET/>
+; PF1:      </FUNCTION_BLOCK>
+
+; TD2:      define void @DirectCallBitcastArg(i32 %i) {
+; TD2-NEXT:   %1 = bitcast [4 x i8]* @bytes to i32*
+; TD2-NEXT:   %2 = call i32 @bar(i32* %1)
+; TD2-NEXT:   ret void
+; TD2-NEXT: }
+
+; PF2:      <FUNCTION_BLOCK>
+; PF2-NEXT:   <DECLAREBLOCKS op0=1/>
+; PF2-NEXT:   <INST_CALL op0=0 op1=13 op2=2/>
+; PF2-NEXT:   <INST_RET/>
+; PF2:      </FUNCTION_BLOCK>
+
+; ------------------------------------------------------
+; Test how we handle a direct call with a pointer to scalar conversion.
+
+define void @DirectCallScalarArg(i32* %ptr) {
+  %1 = ptrtoint [4 x i8]* @bytes to i32
+  call void @foo(i32 %1)
+  ret void
+}
+
+; TD1:      define void @DirectCallScalarArg(i32* %ptr) {
+; TD1-NEXT:   %1 = ptrtoint [4 x i8]* @bytes to i32
+; TD1-NEXT:   call void @foo(i32 %1)
+; TD1-NEXT:   ret void
+; TD1-NEXT: }
+
+; PF1:      <FUNCTION_BLOCK>
+; PF1-NEXT:   <DECLAREBLOCKS op0=1/>
+; PF1-NEXT:   <INST_CAST op0=2 op1=0 op2=9/>
+; PF1-NEXT:   <INST_CALL op0=0 op1=15 op2=1/>
+; PF1-NEXT:   <INST_RET/>
+; PF1:      </FUNCTION_BLOCK>
+
+; TD2:      define void @DirectCallScalarArg(i32* %ptr) {
+; TD2-NEXT:   %1 = ptrtoint [4 x i8]* @bytes to i32
+; TD2-NEXT:   call void @foo(i32 %1)
+; TD2-NEXT:   ret void
+; TD2-NEXT: }
+
+; PF2:      <FUNCTION_BLOCK>
+; PF2-NEXT:   <DECLAREBLOCKS op0=1/>
+; PF2-NEXT:   <INST_CALL op0=0 op1=14 op2=2/>
+; PF2-NEXT:   <INST_RET/>
+; PF2:      </FUNCTION_BLOCK>
+
+; ------------------------------------------------------
+; Test how we handle an indirect call.
+
+define void @IndirectCall(i32 %i) {
+  %1 = inttoptr i32 %i to void (i32)*
+  call void %1(i32 %i)
+  ret void
+}
+
+; TD1:      define void @IndirectCall(i32 %i) {
+; TD1-NEXT:   %1 = inttoptr i32 %i to void (i32)*
+; TD1-NEXT:   call void %1(i32 %i)
+; TD1-NEXT:   ret void
+; TD1-NEXT: }
+
+; PF1:      <FUNCTION_BLOCK>
+; PF1-NEXT:   <DECLAREBLOCKS op0=1/>
+; PF1-NEXT:   <INST_CAST op0=1 op1=3 op2=10/>
+; PF1-NEXT:   <INST_CALL op0=0 op1=1 op2=2/>
+; PF1-NEXT:   <INST_RET/>
+; PF1:      </FUNCTION_BLOCK>
+
+; TD2:      define void @IndirectCall(i32 %i) {
+; TD2-NEXT:   %1 = inttoptr i32 %i to void (i32)*
+; TD2-NEXT:   call void %1(i32 %i)
+; TD2-NEXT:   ret void
+; TD2-NEXT: }
+
+; PF2:      <FUNCTION_BLOCK>
+; PF2-NEXT:   <DECLAREBLOCKS op0=1/>
+; PF2-NEXT:   <INST_CALL_INDIRECT op0=0 op1=1 op2=2 op3=1/>
+; PF2-NEXT:   <INST_RET/>
+; PF2:      </FUNCTION_BLOCK>
+
+; ------------------------------------------------------
+; Test how we handle an indirect call with a normalized ptrtoint argument.
+
+define void @IndirectCallPtrToIntArg(i32 %i) {
+  %1 = alloca i8, i32 4, align 8
+  %2 = inttoptr i32 %i to void (i32)*
+  %3 = ptrtoint i8* %1 to i32
+  call void %2(i32 %3)
+  ret void
+}
+
+; TD1:      define void @IndirectCallPtrToIntArg(i32 %i) {
+; TD1-NEXT:   %1 = alloca i8, i32 4, align 8
+; TD1-NEXT:   %2 = inttoptr i32 %i to void (i32)*
+; TD1-NEXT:   %3 = ptrtoint i8* %1 to i32
+; TD1-NEXT:   call void %2(i32 %3)
+; TD1-NEXT:   ret void
+; TD1-NEXT: }
+
+; PF1:      <FUNCTION_BLOCK>
+; PF1:        </CONSTANTS_BLOCK>
+; PF1-NEXT:   <INST_ALLOCA op0=1 op1=4/>
+; PF1-NEXT:   <INST_CAST op0=3 op1=3 op2=10/>
+; PF1-NEXT:   <INST_CAST op0=2 op1=0 op2=9/>
+; PF1-NEXT:   <INST_CALL op0=0 op1=2 op2=1/>
+; PF1-NEXT:   <INST_RET/>
+; PF1:      </FUNCTION_BLOCK>
+
+; TD2:      define void @IndirectCallPtrToIntArg(i32 %i) {
+; TD2-NEXT:   %1 = alloca i8, i32 4, align 8
+; TD2-NEXT:   %2 = inttoptr i32 %i to void (i32)*
+; TD2-NEXT:   %3 = ptrtoint i8* %1 to i32
+; TD2-NEXT:   call void %2(i32 %3)
+; TD2-NEXT:   ret void
+; TD2-NEXT: }
+
+; PF2:      <FUNCTION_BLOCK>
+; PF2:        </CONSTANTS_BLOCK>
+; PF2-NEXT:   <INST_ALLOCA op0=1 op1=4/>
+; PF2-NEXT:   <INST_CALL_INDIRECT op0=0 op1=3 op2=2 op3=1/>
+; PF2-NEXT:   <INST_RET/>
+; PF2:      </FUNCTION_BLOCK>
+
+; ------------------------------------------------------
+; Test how we handle a direct call with a normalized inttoptr argument.
+; Note: This code doesn't follow the PNaCl ABI in that function
+; calls can't get pointer arguments. However, intrinsic calls can, and
+; this code is a placeholder for such a test.
+
+define void @IndirectCallIntToPtrArg(i32 %i) {
+  %1 = inttoptr i32 %i to i32 (i32*)*
+  %2 = inttoptr i32 %i to i32*
+  %3 = call i32 %1(i32* %2)
+  ret void
+}
+
+; TD1:      define void @IndirectCallIntToPtrArg(i32 %i) {
+; TD1-NEXT:   %1 = inttoptr i32 %i to i32 (i32*)*
+; TD1-NEXT:   %2 = inttoptr i32 %i to i32*
+; TD1-NEXT:   %3 = call i32 %1(i32* %2)
+; TD1-NEXT:   ret void
+; TD1-NEXT: }
+
+; PF1:      <FUNCTION_BLOCK>
+; PF1-NEXT:   <DECLAREBLOCKS op0=1/>
+; PF1-NEXT:   <INST_CAST op0=1 op1=6 op2=10/>
+; PF1-NEXT:   <INST_CAST op0=2 op1=4 op2=10/>
+; PF1-NEXT:   <INST_CALL op0=0 op1=2 op2=1/>
+; PF1-NEXT:   <INST_RET/>
+; PF1:      </FUNCTION_BLOCK>
+
+; TD2:      define void @IndirectCallIntToPtrArg(i32 %i) {
+; TD2-NEXT:   %1 = inttoptr i32 %i to i32 (i32*)*
+; TD2-NEXT:   %2 = inttoptr i32 %i to i32*
+; TD2-NEXT:   %3 = call i32 %1(i32* %2)
+; TD2-NEXT:   ret void
+; TD2-NEXT: }
+
+; PF2:      <FUNCTION_BLOCK>
+; PF2-NEXT:   <DECLAREBLOCKS op0=1/>
+; PF2-NEXT:   <INST_CALL_INDIRECT op0=0 op1=1 op2=5 op3=1/>
+; PF2-NEXT:   <INST_RET/>
+; PF2:      </FUNCTION_BLOCK>
+
+; ------------------------------------------------------
+; Test how we handle an indirect call with a normalized bitcast argument.
+
+define void @IndirectCallBitcastArg(i32 %i) {
+  %1 = inttoptr i32 %i to i32 (i32*)*
+  %2 = bitcast [4 x i8]* @bytes to i32*
+  %3 = call i32 %1(i32* %2)
+  ret void
+}
+
+; TD1:      define void @IndirectCallBitcastArg(i32 %i) {
+; TD1-NEXT:   %1 = inttoptr i32 %i to i32 (i32*)*
+; TD1-NEXT:   %2 = bitcast [4 x i8]* @bytes to i32*
+; TD1-NEXT:   %3 = call i32 %1(i32* %2)
+; TD1-NEXT:   ret void
+; TD1-NEXT: }
+
+; PF1:      <FUNCTION_BLOCK>
+; PF1-NEXT:   <DECLAREBLOCKS op0=1/>
+; PF1-NEXT:   <INST_CAST op0=1 op1=6 op2=10/>
+; PF1-NEXT:   <INST_CAST op0=3 op1=4 op2=11/>
+; PF1-NEXT:   <INST_CALL op0=0 op1=2 op2=1/>
+; PF1-NEXT:   <INST_RET/>
+; PF1:      </FUNCTION_BLOCK>
+
+; TD2:      define void @IndirectCallBitcastArg(i32 %i) {
+; TD2-NEXT:   %1 = inttoptr i32 %i to i32 (i32*)*
+; TD2-NEXT:   %2 = bitcast [4 x i8]* @bytes to i32*
+; TD2-NEXT:   %3 = call i32 %1(i32* %2)
+; TD2-NEXT:   ret void
+; TD2-NEXT: }
+
+; PF2:      <FUNCTION_BLOCK>
+; PF2-NEXT:   <DECLAREBLOCKS op0=1/>
+; PF2-NEXT:   <INST_CALL_INDIRECT op0=0 op1=1 op2=5 op3=2/>
+; PF2-NEXT:   <INST_RET/>
+; PF2:      </FUNCTION_BLOCK>
+
+; ------------------------------------------------------
+; Test how we handle an indirect call with a pointer to scalar conversion.
+
+define void @IndirectCallScalarArg(i32 %i, i32* %ptr) {
+  %1 = inttoptr i32 %i to void (i32)*
+  %2 = ptrtoint [4 x i8]* @bytes to i32
+  call void %1(i32 %2)
+  ret void
+}
+
+; TD1:      define void @IndirectCallScalarArg(i32 %i, i32* %ptr) {
+; TD1-NEXT:   %1 = inttoptr i32 %i to void (i32)*
+; TD1-NEXT:   %2 = ptrtoint [4 x i8]* @bytes to i32
+; TD1-NEXT:   call void %1(i32 %2)
+; TD1-NEXT:   ret void
+; TD1-NEXT: }
+
+; PF1:      <FUNCTION_BLOCK>
+; PF1-NEXT:   <DECLAREBLOCKS op0=1/>
+; PF1-NEXT:   <INST_CAST op0=2 op1=3 op2=10/>
+; PF1-NEXT:   <INST_CAST op0=4 op1=0 op2=9/>
+; PF1-NEXT:   <INST_CALL op0=0 op1=2 op2=1/>
+; PF1-NEXT:   <INST_RET/>
+; PF1:      </FUNCTION_BLOCK>
+
+; TD2:      define void @IndirectCallScalarArg(i32 %i, i32* %ptr) {
+; TD2-NEXT:   %1 = inttoptr i32 %i to void (i32)*
+; TD2-NEXT:   %2 = ptrtoint [4 x i8]* @bytes to i32
+; TD2-NEXT:   call void %1(i32 %2)
+; TD2-NEXT:   ret void
+; TD2-NEXT: }
+
+; PF2:      <FUNCTION_BLOCK>
+; PF2-NEXT:   <DECLAREBLOCKS op0=1/>
+; PF2-NEXT:   <INST_CALL_INDIRECT op0=0 op1=2 op2=2 op3=3/>
+; PF2-NEXT:   <INST_RET/>
+; PF2:      </FUNCTION_BLOCK>
diff --git a/test/NaCl/Bitcode/inttoptr-elide.ll b/test/NaCl/Bitcode/inttoptr-elide.ll
index 679f5f1d47..a01aaae1f7 100644
--- a/test/NaCl/Bitcode/inttoptr-elide.ll
+++ b/test/NaCl/Bitcode/inttoptr-elide.ll
@@ -1,5 +1,4 @@
 ; Test how we handle eliding inttoptr instructions.
-; TODO(kschimpf) Expand these tests as further CL's are added for issue 3544.
 
 ; RUN: llvm-as < %s | pnacl-freeze --pnacl-version=1 \
 ; RUN:              | pnacl-bcanalyzer -dump-records \
diff --git a/test/NaCl/Bitcode/ptrtoint-elide.ll b/test/NaCl/Bitcode/ptrtoint-elide.ll
index 43a82a0802..eba451c289 100644
--- a/test/NaCl/Bitcode/ptrtoint-elide.ll
+++ b/test/NaCl/Bitcode/ptrtoint-elide.ll
@@ -1,5 +1,4 @@
 ; Test how we handle eliding ptrtoint instructions.
-; TODO(kschimpf) Expand these tests as further CL's are added for issue 3544.
 
 ; RUN: llvm-as < %s | pnacl-freeze --pnacl-version=1 \
 ; RUN:              | pnacl-bcanalyzer -dump-records \
@@ -684,9 +683,7 @@ define void @TestCasts() {
 
 ; ------------------------------------------------------
 
-; Show that if a ptrtoint is used in something other than known scalar operations,
-; it gets copied to the bitcode file
-; TODO(kschimpf): Remove this once all scalar operations have been handled.
+; Show that we elide a ptrtoint cast for a call.
 define void @TestSavedPtrToInt() {
   %1 = alloca i8, i32 4, align 8
   %2 = ptrtoint i8* %1 to i32
@@ -723,9 +720,8 @@ define void @TestSavedPtrToInt() {
 ; PF2:        <FUNCTION_BLOCK>
 ; PF2:          </CONSTANTS_BLOCK>
 ; PF2-NEXT:     <INST_ALLOCA op0=2 op1=4/>
-; PF2-NEXT:     <INST_CAST op0=1 op1=0 op2=9/>
-; PF2-NEXT:     <INST_BINOP op0=1 op1=3 op2=0/>
-; PF2-NEXT:     <INST_CALL op0=0 op1=26 op2=2/>
+; PF2-NEXT:     <INST_BINOP op0=1 op1=2 op2=0/>
+; PF2-NEXT:     <INST_CALL op0=0 op1=25 op2=2/>
 ; PF2-NEXT:     <INST_RET/>
 ; PF2-NEXT:   </FUNCTION_BLOCK>