Subzero: Assemble calls to constant addresses.

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 149 matching lines @@
   TopLevelParser &operator=(const TopLevelParser &) = delete;
 
 public:
   typedef std::vector<Ice::FunctionDeclaration *> FunctionDeclarationListType;
 
   TopLevelParser(Ice::Translator &Translator, NaClBitstreamCursor &Cursor,
                  Ice::ErrorCode &ErrorStatus)
       : NaClBitcodeParser(Cursor), Translator(Translator),
         ErrorStatus(ErrorStatus), NumErrors(0), NextDefiningFunctionID(0),
         VariableDeclarations(new Ice::VariableDeclarationList()),
-        BlockParser(nullptr), StubbedConstCallValue(nullptr) {}
+        BlockParser(nullptr) {}
 
   ~TopLevelParser() override {}
 
   Ice::Translator &getTranslator() const { return Translator; }
 
   void setBlockParser(BlockParserBaseClass *NewBlockParser) {
     BlockParser = NewBlockParser;
   }
 
   /// Generates error with given Message, occurring at BitPosition
@@ skipping 88 matching lines @@
   }
 
   void createValueIDs() {
     assert(VariableDeclarations);
     ValueIDConstants.reserve(VariableDeclarations->size() +
                              FunctionDeclarationList.size());
     createValueIDsForFunctions();
     createValueIDsForGlobalVars();
   }
 
-  /// Returns a defined function reference to be used in place of
-  /// called constant addresses. Returns the corresponding operand
-  /// to replace the calling address with. Reports an error if
-  /// a stub could not be found, returning the CallValue.
-  Ice::Operand *getStubbedConstCallValue(Ice::Operand *CallValue) {
-    if (StubbedConstCallValue)
-      return StubbedConstCallValue;
-    for (unsigned i = 0; i < getNumFunctionIDs(); ++i) {
-      Ice::FunctionDeclaration *Func = getFunctionByID(i);
-      if (!Func->isProto()) {
-        StubbedConstCallValue = getGlobalConstantByID(i);
-        return StubbedConstCallValue;
-      }
-    }
-    Error("Unable to find function definition to stub constant calls with");
-    return CallValue;
-  }
-
   /// 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 {
     if (VariableDeclarations) {
       return FunctionDeclarationList.size() + VariableDeclarations->size();
     } else {
       return ValueIDConstants.size();
@@ skipping 69 matching lines @@
   size_t NextDefiningFunctionID;
   // The set of global variables.
   std::unique_ptr<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 105 matching lines @@
 
 bool TopLevelParser::ErrorAt(naclbitc::ErrorLevel Level, uint64_t Bit,
                              const std::string &Message) {
   ErrorStatus.assign(Ice::EC_Bitcode);
   ++NumErrors;
   Ice::GlobalContext *Context = Translator.getContext();
   Ice::OstreamLocker L(Context);
   raw_ostream &OldErrStream = setErrStream(Context->getStrDump());
   NaClBitcodeParser::ErrorAt(Level, Bit, Message);
   setErrStream(OldErrStream);
-  if (Level >= naclbitc::Error
-      && !Translator.getFlags().getAllowErrorRecovery())
+  if (Level >= naclbitc::Error &&
+      !Translator.getFlags().getAllowErrorRecovery())
     Fatal();
   return true;
 }
 
 void TopLevelParser::reportBadTypeIDAs(unsigned ID, const ExtendedType *Ty,
                                        ExtendedType::TypeKind WantedType) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   if (Ty == nullptr) {
     StrBuf << "Can't find extended type for type id: " << ID;
@@ skipping 145 matching lines @@
 };
 
 bool TopLevelParser::BlockError(const std::string &Message) {
   if (BlockParser)
     return BlockParser->Error(Message);
   else
     return Error(Message);
 }
 
 // Generates an error Message with the bit address prefixed to it.
-bool BlockParserBaseClass::ErrorAt(
-    naclbitc::ErrorLevel Level, uint64_t Bit, const std::string &Message) {
+bool BlockParserBaseClass::ErrorAt(naclbitc::ErrorLevel Level, uint64_t Bit,
+                                   const std::string &Message) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   // Note: If dump routines have been turned off, the error messages
   // will not be readable. Hence, replace with simple error. We also
   // use the simple form for unit tests.
   if (getFlags().getGenerateUnitTestMessages()) {
     StrBuf << "Invalid " << getBlockName() << " record: <" << Record.GetCode();
     for (const uint64_t Val : Record.GetValues()) {
       StrBuf << " " << Val;
     }
@@ skipping 1808 matching lines @@
           Name, BadIntrinsic);
       if (BadIntrinsic) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Invalid PNaCl intrinsic call to " << Name;
         Error(StrBuf.str());
         appendErrorInstruction(ReturnType);
         return;
       }
     } else {
-      if (getFlags().getStubConstantCalls() &&
-          llvm::isa<Ice::ConstantInteger32>(Callee)) {
-        Callee = Context->getStubbedConstCallValue(Callee);
-      }
       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 514 matching lines @@
   }
   if (InputStreamFile.getBitcodeBytes().getExtent() % 4 != 0) {
     errs() << IRFilename
            << ": Bitcode stream should be a multiple of 4 bytes in length.\n";
     ErrorStatus.assign(EC_Bitcode);
     return;
   }
 }
 
 } // end of namespace Ice