Fix code checking arguments to an intrinsic call.

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 2648 matching lines @@
         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;
+    // Name of function if a direct call/intrinsic. Null otherwise.
+    Ice::FunctionDeclaration *Fcn = nullptr;
     if (Record.GetCode() == naclbitc::FUNC_CODE_INST_CALL) {
-      Ice::FunctionDeclaration *Fcn = Context->getFunctionByID(CalleeIndex);
+      Fcn = Context->getFunctionByID(CalleeIndex);
       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;
@@ skipping 112 matching lines @@
 
     // If intrinsic call, validate call signature.
     if (IntrinsicInfo) {
       Ice::SizeT ArgIndex = 0;
       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 "
+        StrBuf << "Intrinsic " << Fcn->getName() << " expects return type"
                << IntrinsicInfo->getReturnType()
                << ". Found: " << Inst->getReturnType();
         Error(StrBuf.str());
         break;
       }
       case Ice::Intrinsics::WrongNumOfArgs: {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
-        StrBuf << "Intrinsic call expects " << IntrinsicInfo->getNumArgs()
+        StrBuf << "Intrinsic " << Fcn->getName() << " expects "
+               << IntrinsicInfo->getNumArgs()
                << ". Found: " << Inst->getNumArgs();
         Error(StrBuf.str());
         break;
       }
       case Ice::Intrinsics::WrongCallArgType: {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
-        StrBuf << "Intrinsic call argument " << ArgIndex << " expects type "
-               << IntrinsicInfo->getArgType(ArgIndex)
+        StrBuf << "Intrinsic " << Fcn->getName() << " expects "
+               << IntrinsicInfo->getArgType(ArgIndex) << " for argument "
+               << (ArgIndex + 1)
                << ". Found: " << Inst->getArg(ArgIndex)->getType();
         Error(StrBuf.str());
         break;
       }
       }
     }
 
     CurrentNode->appendInst(Inst.release());
     return;
   }
@@ skipping 460 matching lines @@
     raw_string_ostream StrBuf(Buffer);
     StrBuf << IRFilename << ": Does not contain a module!";
     llvm::report_fatal_error(StrBuf.str());
   }
   if (InputStreamFile.getBitcodeBytes().getExtent() % 4 != 0) {
     llvm::report_fatal_error("Bitcode stream should be a multiple of 4 bytes");
   }
 }
 
 } // end of namespace Ice