Fix call instructions to check parameter types for consistency.

src/PNaClTranslator.cpp

 //===- subzero/src/PNaClTranslator.cpp - ICE from bitcode -----------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 2626 matching lines @@
         return;
     } else {
       if (!isValidRecordSizeAtLeast(3, "call indirect"))
         return;
       ParamsStartIndex = 3;
     }
 
     // Extract out the called function and its return type.
     uint32_t CalleeIndex = convertRelativeToAbsIndex(Values[1], BaseIndex);
     Ice::Operand *Callee = getOperand(CalleeIndex);
+    const Ice::FuncSigType *Signature = nullptr;
     Ice::Type ReturnType = Ice::IceType_void;
     const Ice::Intrinsics::FullIntrinsicInfo *IntrinsicInfo = nullptr;
     if (Record.GetCode() == naclbitc::FUNC_CODE_INST_CALL) {
       Ice::FunctionDeclaration *Fcn = Context->getFunctionByID(CalleeIndex);
-      const Ice::FuncSigType &Signature = Fcn->getSignature();
-      ReturnType = Signature.getReturnType();
+      Signature = &Fcn->getSignature();
+      ReturnType = Signature->getReturnType();
 
       // Check if this direct call is to an Intrinsic (starts with "llvm.")
       bool BadIntrinsic;
       const Ice::IceString &Name = Fcn->getName();
       IntrinsicInfo = getTranslator().getContext()->getIntrinsicsInfo().find(
           Name, BadIntrinsic);
       if (BadIntrinsic) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Invalid PNaCl intrinsic call to " << Name;
         Error(StrBuf.str());
-        appendErrorInstruction(ReturnType);
+        if (ReturnType != Ice::IceType_void)
+          appendErrorInstruction(ReturnType);
         return;
       }
     } else {
       ReturnType = Context->getSimpleTypeByID(Values[2]);
     }
 
     // Extract call information.
     uint64_t CCInfo = Values[0];
     CallingConv::ID CallingConv;
     if (!naclbitc::DecodeCallingConv(CCInfo >> 1, CallingConv)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Function call calling convention value " << (CCInfo >> 1)
              << " not understood.";
       Error(StrBuf.str());
-      appendErrorInstruction(ReturnType);
+      if (ReturnType != Ice::IceType_void)
+        appendErrorInstruction(ReturnType);
       return;
     }
     bool IsTailCall = static_cast<bool>(CCInfo & 1);
     Ice::SizeT NumParams = Values.size() - ParamsStartIndex;
-
+    if (Signature && NumParams != Signature->getNumArgs()) {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "Call has " << NumParams
+             << " parameters. Signature expects: " << Signature->getNumArgs();
+      Error(StrBuf.str());
+      // Error recover by only checking parameters in both signature and call.
+      NumParams = std::min(NumParams, Signature->getNumArgs());
+    }
     if (isIRGenerationDisabled()) {
       assert(Callee == nullptr);
       // Check that parameters are defined.
       for (Ice::SizeT ParamIndex = 0; ParamIndex < NumParams; ++ParamIndex) {
         assert(getRelativeOperand(Values[ParamsStartIndex + ParamIndex],
                                   BaseIndex) == nullptr);
       }
       // Define value slot only if value returned.
       if (ReturnType != Ice::IceType_void)
         setNextLocalInstIndex(nullptr);
       return;
     }
 
     // Create the call instruction.
     Ice::Variable *Dest = (ReturnType == Ice::IceType_void)

[Jim Stichnoth, 2015/09/17 19:56:46]

Before creating Dest, you should also check for
  ReturnType == Ice::IceType_void || isCallParameterType(ReturnType)
and print a similar error if that's not true.

[Karl, 2015/09/18 17:22:49]

Done.

                               ? nullptr
                               : getNextInstVar(ReturnType);
-    Ice::InstCall *Inst = nullptr;
+    std::unique_ptr<Ice::InstCall> Inst;
     if (IntrinsicInfo) {
-      Inst = Ice::InstIntrinsicCall::create(Func.get(), NumParams, Dest, Callee,
-                                            IntrinsicInfo->Info);
+      Inst.reset(Ice::InstIntrinsicCall::create(Func.get(), NumParams, Dest,
+                                                Callee, IntrinsicInfo->Info));
     } else {
-      Inst = Ice::InstCall::create(Func.get(), NumParams, Dest, Callee,
-                                   IsTailCall);
+      Inst.reset(Ice::InstCall::create(Func.get(), NumParams, Dest, Callee,
+                                       IsTailCall));
     }
 
     // Add parameters.
     for (Ice::SizeT ParamIndex = 0; ParamIndex < NumParams; ++ParamIndex) {
-      Inst->addArg(
-          getRelativeOperand(Values[ParamsStartIndex + ParamIndex], BaseIndex));
+      Ice::Operand *Op =
+          getRelativeOperand(Values[ParamsStartIndex + ParamIndex], BaseIndex);
+      if (Op == nullptr) {
+        std::string Buffer;
+        raw_string_ostream StrBuf(Buffer);
+        StrBuf << "Parameter " << ParamIndex << " of call not defined";
+        Error(StrBuf.str());
+        if (ReturnType != Ice::IceType_void)
+          appendErrorInstruction(ReturnType);
+        return;
+      }
+
+      // Check that parameter type is valid.
+      if (Signature) {
+        if (Op->getType() != Signature->getArgType(ParamIndex)) {
+          std::string Buffer;
+          raw_string_ostream StrBuf(Buffer);
+          StrBuf << "Call argument " << *Op << " expects "
+                 << Signature->getArgType(ParamIndex)
+                 << ". Found: " << Op->getType();
+          Error(StrBuf.str());
+        } else if (IntrinsicInfo == nullptr &&
+                   !isCallParameterType(Op->getType())) {
+          // TODO(kschimpf): Move this check to the function declaration, so
+          // that it only needs to be checked once.
+          std::string Buffer;
+          raw_string_ostream StrBuf(Buffer);
+          StrBuf << "Call argument " << *Op
+                 << " matches declaration but has invalid type: "
+                 << Op->getType();
+          Error(StrBuf.str());
+        }
+      } else if (!isCallParameterType(Op->getType())) {
+        std::string Buffer;
+        raw_string_ostream StrBuf(Buffer);
+        StrBuf << "Call argument " << *Op
+               << " has invalid type: " << Op->getType();
+        Error(StrBuf.str());
+      }
+      Inst->addArg(Op);
     }
 
     // If intrinsic call, validate call signature.
     if (IntrinsicInfo) {
       Ice::SizeT ArgIndex = 0;
-      switch (IntrinsicInfo->validateCall(Inst, ArgIndex)) {
+      switch (IntrinsicInfo->validateCall(Inst.get(), ArgIndex)) {
       case Ice::Intrinsics::IsValidCall:
         break;
       case Ice::Intrinsics::BadReturnType: {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Intrinsic call expects return type "
                << IntrinsicInfo->getReturnType()
                << ". Found: " << Inst->getReturnType();
         Error(StrBuf.str());
         break;
@@ skipping 11 matching lines @@
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Intrinsic call argument " << ArgIndex << " expects type "
                << IntrinsicInfo->getArgType(ArgIndex)
                << ". Found: " << Inst->getArg(ArgIndex)->getType();
         Error(StrBuf.str());
         break;
       }
       }
     }
 
-    CurrentNode->appendInst(Inst);
+    CurrentNode->appendInst(Inst.release());
     return;
   }
   case naclbitc::FUNC_CODE_INST_FORWARDTYPEREF: {
     // FORWARDTYPEREF: [opval, ty]
     if (!isValidRecordSize(2, "forward type ref"))
       return;
     Ice::Type OpType = Context->getSimpleTypeByID(Values[1]);
     setOperand(Values[0],
                isIRGenerationDisabled() ? nullptr : createInstVar(OpType));
     return;
@@ skipping 439 matching lines @@
   }
   if (InputStreamFile.getBitcodeBytes().getExtent() % 4 != 0) {
     ErrStream
         << IRFilename
         << ": Bitcode stream should be a multiple of 4 bytes in length.\n";
     llvm::report_fatal_error("Bitcode stream should be a multiple of 4 bytes");
   }
 }
 
 } // end of namespace Ice