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

2 files changed, 49 insertions, 33 deletions

diff --git a/lib/Bitcode/NaCl/Writer/NaClBitcodeWriter.cpp b/lib/Bitcode/NaCl/Writer/NaClBitcodeWriter.cpp
index 6624ad1d7c..2ac88c92a4 100644
--- a/lib/Bitcode/NaCl/Writer/NaClBitcodeWriter.cpp
+++ b/lib/Bitcode/NaCl/Writer/NaClBitcodeWriter.cpp
@@ -975,32 +975,47 @@ static bool WriteInstruction(const Instruction &I, unsigned InstID,
     }
     break;
   case Instruction::Call: {
-    const CallInst &CI = cast<CallInst>(I);
-    PointerType *PTy = cast<PointerType>(CI.getCalledValue()->getType());
-    FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
-
-    Code = naclbitc::FUNC_CODE_INST_CALL;
-
-    Vals.push_back((GetEncodedCallingConv(CI.getCallingConv()) << 1)
-                   | unsigned(CI.isTailCall()));
-    pushValue(CI.getCalledValue(), InstID, Vals, VE, Stream);  // Callee
-
-    // Emit value #'s for the fixed parameters.
-    for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
-      // Check for labels (can happen with asm labels).
-      if (FTy->getParamType(i)->isLabelTy())
-        Vals.push_back(VE.getValueID(CI.getArgOperand(i)));
-      else
-        // fixed param.
-        pushValue(CI.getArgOperand(i), InstID, Vals, VE, Stream);
+    // CALL: [cc, fnid, args...]
+    // PNaCl version 2: CALL_INDIRECT: [cc, fnid, fnty, args...]
+
+    const CallInst &Call = cast<CallInst>(I);
+    const Value* Callee = Call.getCalledValue();
+    Vals.push_back((GetEncodedCallingConv(Call.getCallingConv()) << 1)
+                   | unsigned(Call.isTailCall()));
+
+    pushValue(Callee, InstID, Vals, VE, Stream);
+
+    switch (PNaClVersion) {
+    case 1:
+      Code = naclbitc::FUNC_CODE_INST_CALL;
+      break;
+    case 2:
+      if (Callee == VE.ElideCasts(Callee)) {
+        // Since the call pointer has not been elided, we know that
+        // the call pointer has the type signature of the called
+        // function.  This implies that the reader can use the type
+        // signature of the callee to figure out how to add casts to
+        // the arguments.
+        Code = naclbitc::FUNC_CODE_INST_CALL;
+      } else {
+        // If the cast was elided, a pointer conversion to a pointer
+        // was applied, meaning that this is an indirect call. For the
+        // reader, this implies that we can't use the type signature
+        // of the callee to resolve elided call arguments, since it is
+        // not known. Hence, we must send the type signature to the
+        // reader.
+        Code = naclbitc::FUNC_CODE_INST_CALL_INDIRECT;
+        PointerType *FcnPtrType =
+          cast<PointerType>(Callee->getType());
+        FunctionType *FcnType =
+          cast<FunctionType>(FcnPtrType->getElementType());
+        Vals.push_back(VE.getTypeID(FcnType));
+      }
+      break;
     }
 
-    // Emit type/value pairs for varargs params.
-    if (FTy->isVarArg()) {
-      for (unsigned i = FTy->getNumParams(), e = CI.getNumArgOperands();
-           i != e; ++i)
-        // varargs
-        pushValue(CI.getArgOperand(i), InstID, Vals, VE, Stream);
+    for (unsigned I = 0, E = Call.getNumArgOperands(); I < E; ++I) {
+      pushValue(Call.getArgOperand(I), InstID, Vals, VE, Stream);
     }
     break;
   }
diff --git a/lib/Bitcode/NaCl/Writer/NaClValueEnumerator.cpp b/lib/Bitcode/NaCl/Writer/NaClValueEnumerator.cpp
index 060a6d63f4..8cfdf13240 100644
--- a/lib/Bitcode/NaCl/Writer/NaClValueEnumerator.cpp
+++ b/lib/Bitcode/NaCl/Writer/NaClValueEnumerator.cpp
@@ -438,9 +438,6 @@ static bool ExpectsNormalizedPtr(const Value *V, const Instruction *Arg) {
   const Instruction *I = dyn_cast<Instruction>(V);
   if (I == 0) return false;
 
-  // TODO(kschimpf) Expand this list to any operation that can handle
-  // normalized pointers. That is loads and stores, function calls, and
-  // instrinsic calls.
   switch (I->getOpcode()) {
   default:
     return false;
@@ -448,6 +445,10 @@ static bool ExpectsNormalizedPtr(const Value *V, const Instruction *Arg) {
     return I->getOperand(0) == Arg;
   case Instruction::Store:
     return I->getOperand(1) == Arg;
+  case Instruction::Call:
+    // For function calls, the function operand is normalized, and for
+    // intrinsic calls, all pointer arguments are normalized.
+    return true;
   }
 }
 
@@ -493,12 +494,13 @@ static bool ExpectsScalarValue(const Value *V, const Instruction *Arg) {
       const SelectInst *Op = dyn_cast<SelectInst>(I);
       return Arg == Op->getTrueValue() || Arg == Op->getFalseValue();
     }
+    case Instruction::Call: {
+      // All operands (except the first, which must be a function pointer),
+      // can be scalar values.
+      const CallInst *Call = cast<CallInst>(I);
+      return Call->getCalledValue() != Arg;
+    }
     }
-    // TODO(kschimpf): Need to think more about how to handle following
-    // instructions:
-    // case Instruction::IntToPtr:
-    // case Instruction::BitCast:
-    // case Instruction::Call:
   }
 }
 
@@ -526,7 +528,6 @@ static inline bool IsInherentPtr(const Value *V) {
 // llvm/lib/Transforms/NaCl/ReplacePtrsWithInts.cpp.
 const Value *NaClValueEnumerator::ElideCasts(const Value *V) {
   if (PNaClVersion == 1) return V;
-  // TODO(kschimpf): Expand this out to cover all cases.
   if (const Instruction *I = dyn_cast<Instruction>(V)) {
     switch (I->getOpcode()) {
     default: