Fix bitcode parser to check type signatures of functions.

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 320 matching lines @@
 
   /// Install names for all global values without names. Called after the global
   /// value symbol table is processed, but before any function blocks are
   /// processed.
   void installGlobalNames() {
     assert(VariableDeclarations);
     installGlobalVarNames();
     installFunctionNames();
   }
 
+  void verifyFunctionTypeSignatures();
+
   void createValueIDs() {
     assert(VariableDeclarations);
     ValueIDConstants.reserve(VariableDeclarations->size() +
                              FunctionDeclarations.size());
     createValueIDsForFunctions();
     createValueIDsForGlobalVars();
   }
 
   /// Returns the number of function declarations in the bitcode file.
   size_t getNumFunctionIDs() const { return FunctionDeclarations.size(); }
@@ skipping 279 matching lines @@
 }
 
 Ice::Type TopLevelParser::convertToIceTypeError(Type *LLVMTy) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Invalid LLVM type: " << *LLVMTy;
   Error(StrBuf.str());
   return Ice::IceType_void;
 }
 
+void TopLevelParser::verifyFunctionTypeSignatures() {
+  const Ice::GlobalContext *Ctx = getTranslator().getContext();
+  for (const auto FuncDecl : FunctionDeclarations) {

[Jim Stichnoth, 2016/01/14 22:59:08]

I would use Ice::FunctionDeclaration* instead of auto.

[Karl, 2016/01/15 15:33:34]

Done.

+    if (!FuncDecl->validateTypeSignature(Ctx))
+      Error(FuncDecl->getTypeSignatureError(Ctx));
+  }
+}
+
 // Base class for parsing blocks within the bitcode file. Note: Because this is
 // the base class of block parsers, we generate error messages if ParseBlock or
 // ParseRecord is not overridden in derived classes.
 class BlockParserBaseClass : public NaClBitcodeParser {
   BlockParserBaseClass() = delete;
   BlockParserBaseClass(const BlockParserBaseClass &) = delete;
   BlockParserBaseClass &operator=(const BlockParserBaseClass &) = delete;
 
 public:
   // Constructor for the top-level module block parser.
@@ skipping 1991 matching lines @@
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Call to " << printName(Fcn) << " has " << NumParams
                << " parameters. Signature expects: " << Signature->getNumArgs();
         Error(StrBuf.str());
         if (ReturnType != Ice::IceType_void)
           setNextLocalInstIndex(nullptr);
         return;
       }
 
       // Check if this direct call is to an Intrinsic (starts with "llvm.")
-      bool BadIntrinsic;
-      IntrinsicInfo = getTranslator().getContext()->getIntrinsicsInfo().find(
-          Fcn->getName(), BadIntrinsic);
-      if (BadIntrinsic) {
-        std::string Buffer;
-        raw_string_ostream StrBuf(Buffer);
-        StrBuf << "Invalid PNaCl intrinsic call to " << Fcn->getName();
-        Error(StrBuf.str());
-        IntrinsicInfo = nullptr;
-      }
+      IntrinsicInfo = Fcn->getIntrinsicInfo(getTranslator().getContext());
       if (IntrinsicInfo && IntrinsicInfo->getNumArgs() != NumParams) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Call to " << printName(Fcn) << " has " << NumParams
                << " parameters. Intrinsic expects: " << Signature->getNumArgs();
         Error(StrBuf.str());
         if (ReturnType != Ice::IceType_void)
           setNextLocalInstIndex(nullptr);
         return;
       }
@@ skipping 34 matching lines @@
       ReturnType = Ice::IceType_i32;
     }
 
     // Type check call parameters.
     for (Ice::SizeT Index = 0; Index < Params.size(); ++Index) {
       Ice::Operand *Op = Params[Index];
       Ice::Type OpType = Op->getType();
       if (Signature)
         verifyCallArgTypeMatches(Fcn, Index, OpType,
                                  Signature->getArgType(Index));
-      if (IntrinsicInfo) {
-        verifyCallArgTypeMatches(Fcn, Index, OpType,
-                                 IntrinsicInfo->getArgType(Index));
-      } else if (!isCallParameterType(OpType)) {
+      else if (!isCallParameterType(OpType)) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Argument " << *Op << " of " << printName(Fcn)
                << " has invalid type: " << Op->getType();
         Error(StrBuf.str());
         appendErrorInstruction(ReturnType);
+        return;
       }
     }
 
     // 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)
@@ skipping 265 matching lines @@
   bool FoundValuesymtab = false;
 
   // Generates names for unnamed global addresses (i.e. functions and global
   // variables). Then lowers global variable declaration initializers to the
   // target. May be called multiple times. Only the first call will do the
   // installation.
   void installGlobalNamesAndGlobalVarInitializers() {
     if (!GlobalDeclarationNamesAndInitializersInstalled) {
       Context->installGlobalNames();
       Context->createValueIDs();
+      Context->verifyFunctionTypeSignatures();
       std::unique_ptr<Ice::VariableDeclarationList> Globals =
           Context->getGlobalVariables();
       if (Globals)
         getTranslator().lowerGlobals(std::move(Globals));
       GlobalDeclarationNamesAndInitializersInstalled = true;
     }
   }
   bool ParseBlock(unsigned BlockID) override;
 
   void ExitBlock() override { installGlobalNamesAndGlobalVarInitializers(); }
@@ skipping 182 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