Allow stubbing of called constant addresses using command line argument.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the PNaCl bitcode file to Ice, to machine code
@@ skipping 145 matching lines @@
   TopLevelParser(const TopLevelParser &) = delete;
   TopLevelParser &operator=(const TopLevelParser &) = delete;
 
 public:
   typedef std::vector<Ice::FunctionDeclaration *> FunctionDeclarationListType;
 
   TopLevelParser(Ice::Translator &Translator, NaClBitcodeHeader &Header,
                  NaClBitstreamCursor &Cursor, Ice::ErrorCode &ErrorStatus)
       : NaClBitcodeParser(Cursor), Translator(Translator), Header(Header),
         ErrorStatus(ErrorStatus), NumErrors(0), NextDefiningFunctionID(0),
-        BlockParser(nullptr) {}
+        BlockParser(nullptr), StubbedConstCallValue(nullptr) {}
 
   ~TopLevelParser() override {}
 
   Ice::Translator &getTranslator() { return Translator; }
 
   void setBlockParser(BlockParserBaseClass *NewBlockParser) {
     BlockParser = NewBlockParser;
   }
 
   // Generates error with given Message. Always returns true.
@@ skipping 135 matching lines @@
       C = getTranslator().getContext()->getConstantExternSym(Name);
     else {
       const Ice::RelocOffsetT Offset = 0;
       C = getTranslator().getContext()->getConstantSym(Offset, Name,
                                                        SuppressMangling);
     }
     ValueIDConstants[ID] = C;
     return C;
   }
 
+  /// Returns a defined function reference to be used in place of
+  /// called constant addresses. Returns the corresponding operand
+  /// to replace the calling address with.
+  Ice::Operand *getStubbedConstCallValue() {
+    if (StubbedConstCallValue)
+      return StubbedConstCallValue;
+    for (unsigned i = 0; i < getNumFunctionIDs(); ++i) {
+      Ice::FunctionDeclaration *Func = getFunctionByID(i);
+      if (!Func->isProto()) {
+        StubbedConstCallValue = getOrCreateGlobalConstantByID(i);
+        return StubbedConstCallValue;
+      }
+    }
+    Error("Unable to find function definition to stub constant calls with");
+    report_fatal_error("Unable to continue");
+  }
+
   /// Returns the number of function declarations in the bitcode file.
   unsigned getNumFunctionIDs() const { return FunctionDeclarationList.size(); }
 
   /// Returns the number of global declarations (i.e. IDs) defined in
   /// the bitcode file.
   unsigned getNumGlobalIDs() const {
     return FunctionDeclarationList.size() + VariableDeclarations.size();
   }
 
   /// Creates Count global variable declarations.
@@ skipping 54 matching lines @@
   size_t NextDefiningFunctionID;
   // The set of global variables.
   Ice::VariableDeclarationList VariableDeclarations;
   // Relocatable constants associated with global declarations.
   std::vector<Ice::Constant *> ValueIDConstants;
   // Error recovery value to use when getFuncSigTypeByID fails.
   Ice::FuncSigType UndefinedFuncSigType;
   // The block parser currently being applied. Used for error
   // reporting.
   BlockParserBaseClass *BlockParser;
+  // Value to use to stub constant calls.
+  Ice::Operand *StubbedConstCallValue;
 
   bool ParseBlock(unsigned BlockID) override;
 
   // Gets extended type associated with the given index, assuming the
   // extended type is of the WantedKind. Generates error message if
   // corresponding extended type of WantedKind can't be found, and
   // returns nullptr.
   ExtendedType *getTypeByIDAsKind(unsigned ID,
                                   ExtendedType::TypeKind WantedKind) {
     ExtendedType *Ty = nullptr;
@@ skipping 2028 matching lines @@
         if (!IntrinsicInfo) {
           std::string Buffer;
           raw_string_ostream StrBuf(Buffer);
           StrBuf << "Invalid PNaCl intrinsic call to " << Name;
           Error(StrBuf.str());
           appendErrorInstruction(ReturnType);
           return;
         }
       }
     } else {
+      if (getFlags().StubConstantCalls &&
+          Callee->getKind() == Ice::Operand::kConstInteger32) {

[Jim Stichnoth, 2015/02/04 22:24:13]

Can you use
  llvm::isa<Ice::ConstantInteger32>(Callee)
instead?

[Karl, 2015/02/04 22:46:54]

Done.

+        Callee = Context->getStubbedConstCallValue();
+      }
       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)
@@ skipping 543 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus.assign(EC_Bitcode);
   }
 }
 
 } // end of namespace Ice