Change to use arena allocation for function-local data in parser.

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 148 matching lines @@
 
 class BlockParserBaseClass;
 
 // Top-level class to read PNaCl bitcode files, and translate to ICE.
 class TopLevelParser : public NaClBitcodeParser {
   TopLevelParser() = delete;
   TopLevelParser(const TopLevelParser &) = delete;
   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),
         VariableDeclarations(new Ice::VariableDeclarationList()) {}
 
   ~TopLevelParser() override = default;
 
   Ice::Translator &getTranslator() const { return Translator; }
 
@@ skipping 59 matching lines @@
   const Ice::FuncSigType &getFuncSigTypeByID(NaClBcIndexSize_t ID) {
     const ExtendedType *Ty = getTypeByIDAsKind(ID, ExtendedType::FuncSig);
     if (Ty == nullptr)
       // Return error recovery value.
       return UndefinedFuncSigType;
     return cast<FuncSigExtendedType>(Ty)->getSignature();
   }
 
   /// Sets the next function ID to the given LLVM function.
   void setNextFunctionID(Ice::FunctionDeclaration *Fcn) {
-    FunctionDeclarationList.push_back(Fcn);
+    FunctionDeclarations.push_back(Fcn);
   }
 
   /// Returns the value id that should be associated with the the
   /// current function block. Increments internal counters during call
   /// so that it will be in correct position for next function block.
   NaClBcIndexSize_t getNextFunctionBlockValueID() {
-    size_t NumDeclaredFunctions = FunctionDeclarationList.size();
+    size_t NumDeclaredFunctions = FunctionDeclarations.size();
     while (NextDefiningFunctionID < NumDeclaredFunctions &&
-           FunctionDeclarationList[NextDefiningFunctionID]->isProto())
+           FunctionDeclarations[NextDefiningFunctionID]->isProto())
       ++NextDefiningFunctionID;
     if (NextDefiningFunctionID >= NumDeclaredFunctions)
       Fatal("More function blocks than defined function addresses");
     return NextDefiningFunctionID++;
   }
 
   /// Returns the function associated with ID.
   Ice::FunctionDeclaration *getFunctionByID(NaClBcIndexSize_t ID) {
-    if (ID < FunctionDeclarationList.size())
-      return FunctionDeclarationList[ID];
+    if (ID < FunctionDeclarations.size())
+      return FunctionDeclarations[ID];
     return reportGetFunctionByIDError(ID);
   }
 
   /// Returns the constant associated with the given global value ID.
   Ice::Constant *getGlobalConstantByID(NaClBcIndexSize_t ID) {
     assert(ID < ValueIDConstants.size());
     return ValueIDConstants[ID];
   }
 
   /// 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 createValueIDs() {
     assert(VariableDeclarations);
     ValueIDConstants.reserve(VariableDeclarations->size() +
-                             FunctionDeclarationList.size());
+                             FunctionDeclarations.size());
     createValueIDsForFunctions();
     createValueIDsForGlobalVars();
   }
 
   /// Returns the number of function declarations in the bitcode file.
-  size_t getNumFunctionIDs() const { return FunctionDeclarationList.size(); }
+  size_t getNumFunctionIDs() const { return FunctionDeclarations.size(); }
 
   /// Returns the number of global declarations (i.e. IDs) defined in
   /// the bitcode file.
   size_t getNumGlobalIDs() const {
     if (VariableDeclarations) {
-      return FunctionDeclarationList.size() + VariableDeclarations->size();
+      return FunctionDeclarations.size() + VariableDeclarations->size();
     } else {
       return ValueIDConstants.size();
     }
   }
 
   /// Adds the given global declaration to the end of the list of global
   /// declarations.
   void addGlobalDeclaration(Ice::VariableDeclaration *Decl) {
     assert(VariableDeclarations);
     VariableDeclarations->push_back(Decl);
   }
 
   /// Returns the global variable declaration with the given index.
   Ice::VariableDeclaration *getGlobalVariableByID(NaClBcIndexSize_t Index) {
     assert(VariableDeclarations);
     if (Index < VariableDeclarations->size())
       return VariableDeclarations->at(Index);
     return reportGetGlobalVariableByIDError(Index);
   }
 
   /// Returns the global declaration (variable or function) with the
   /// given Index.
   Ice::GlobalDeclaration *getGlobalDeclarationByID(NaClBcIndexSize_t Index) {
-    size_t NumFunctionIds = FunctionDeclarationList.size();
+    size_t NumFunctionIds = FunctionDeclarations.size();
     if (Index < NumFunctionIds)
       return getFunctionByID(Index);
     else
       return getGlobalVariableByID(Index - NumFunctionIds);
   }
 
   /// Returns the list of parsed global variable
   /// declarations. Releases ownership of the current list of global
   /// variables. Note: only returns non-null pointer on first
   /// call. All successive calls return a null pointer.
   std::unique_ptr<Ice::VariableDeclarationList> getGlobalVariables() {
     // Before returning, check that ValidIDConstants has already been
     // built.
     assert(!VariableDeclarations ||
            VariableDeclarations->size() <= ValueIDConstants.size());
     return std::move(VariableDeclarations);
   }
 
 private:
   // The translator associated with the parser.
   Ice::Translator &Translator;
   // The exit status that should be set to true if an error occurs.
   Ice::ErrorCode &ErrorStatus;
   // The number of errors reported.
   unsigned NumErrors = 0;
   // The types associated with each type ID.
   std::vector<ExtendedType> TypeIDValues;
   // The set of functions (prototype and defined).
-  FunctionDeclarationListType FunctionDeclarationList;
-  // The ID of the next possible defined function ID in
-  // FunctionDeclarationList.  FunctionDeclarationList is filled
-  // first. It's the set of functions (either defined or isproto). Then
-  // function definitions are encountered/parsed and
-  // NextDefiningFunctionID is incremented to track the next
-  // actually-defined function.
+  Ice::FunctionDeclarationList FunctionDeclarations;
+  // The ID of the next possible defined function ID in FunctionDeclarations.
+  // FunctionDeclarations is filled first. It's the set of functions (either
+  // defined or isproto). Then function definitions are encountered/parsed and
+  // NextDefiningFunctionID is incremented to track the next actually-defined
+  // function.
   size_t NextDefiningFunctionID = 0;
   // The set of global variables.
   std::unique_ptr<Ice::VariableDeclarationList> VariableDeclarations;
   // Relocatable constants associated with global declarations.
-  std::vector<Ice::Constant *> ValueIDConstants;
+  Ice::ConstantList ValueIDConstants;
   // Error recovery value to use when getFuncSigTypeByID fails.
   Ice::FuncSigType UndefinedFuncSigType;
   // The block parser currently being applied. Used for error
   // reporting.
   BlockParserBaseClass *BlockParser = nullptr;
 
   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
@@ skipping 42 matching lines @@
       }
     }
   }
 
   // Installs names for functions without names.
   void installFunctionNames() {
     const Ice::IceString &FunctionPrefix =
         getTranslator().getFlags().getDefaultFunctionPrefix();
     if (!FunctionPrefix.empty()) {
       NaClBcIndexSize_t NameIndex = 0;
-      for (Ice::FunctionDeclaration *Func : FunctionDeclarationList) {
+      for (Ice::FunctionDeclaration *Func : FunctionDeclarations) {
         installDeclarationName(Func, FunctionPrefix, "function", NameIndex);
       }
     }
   }
 
   // Builds a constant symbol named Name, suppressing name mangling if
   // SuppressMangling.  IsExternal is true iff the symbol is external.
   Ice::Constant *getConstantSym(const Ice::IceString &Name,
                                 bool SuppressMangling, bool IsExternal) const {
     if (IsExternal) {
       return getTranslator().getContext()->getConstantExternSym(Name);
     } else {
       const Ice::RelocOffsetT Offset = 0;
       return getTranslator().getContext()->getConstantSym(Offset, Name,
                                                           SuppressMangling);
     }
   }
 
   // Converts function declarations into constant value IDs.
   void createValueIDsForFunctions() {
-    for (const Ice::FunctionDeclaration *Func : FunctionDeclarationList) {
+    for (const Ice::FunctionDeclaration *Func : FunctionDeclarations) {
       Ice::Constant *C = nullptr;
       if (!isIRGenerationDisabled()) {
         C = getConstantSym(Func->getName(), Func->getSuppressMangling(),
                            Func->isProto());
       }
       ValueIDConstants.push_back(C);
     }
   }
 
   // Converts global variable declarations into constant value IDs.
@@ skipping 55 matching lines @@
   }
   blockError(StrBuf.str());
 }
 
 Ice::FunctionDeclaration *
 TopLevelParser::reportGetFunctionByIDError(NaClBcIndexSize_t ID) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Function index " << ID
          << " not allowed. Out of range. Must be less than "
-         << FunctionDeclarationList.size();
+         << FunctionDeclarations.size();
   blockError(StrBuf.str());
-  if (!FunctionDeclarationList.empty())
-    return FunctionDeclarationList[0];
+  if (!FunctionDeclarations.empty())
+    return FunctionDeclarations[0];
   Fatal();
 }
 
 Ice::VariableDeclaration *
 TopLevelParser::reportGetGlobalVariableByIDError(NaClBcIndexSize_t Index) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Global index " << Index
          << " not allowed. Out of range. Must be less than "
          << VariableDeclarations->size();
@@ skipping 685 matching lines @@
   bool convertFunction() {
     const Ice::TimerStackIdT StackID = Ice::GlobalContext::TSK_Funcs;
     Ice::TimerIdT TimerID = 0;
     const bool TimeThisFunction = getFlags().getTimeEachFunction();
     if (TimeThisFunction) {
       TimerID = getTranslator().getContext()->getTimerID(StackID,
                                                          FuncDecl->getName());
       getTranslator().getContext()->pushTimer(TimerID, StackID);
     }
 
-    if (!isIRGenerationDisabled())
-      Func = Ice::Cfg::create(getTranslator().getContext(),
-                              getTranslator().getNextSequenceNumber());
+    // Note: The Cfg is created, even when IR generation is disabled. This
+    // is done to install a CfgLocalAllocator for various internal containers.
+    Func = Ice::Cfg::create(getTranslator().getContext(),
+                            getTranslator().getNextSequenceNumber());
     Ice::Cfg::setCurrentCfg(Func.get());
 
     // TODO(kschimpf) Clean up API to add a function signature to
     // a CFG.
     const Ice::FuncSigType &Signature = FuncDecl->getSignature();
     if (isIRGenerationDisabled()) {
       CurrentNode = nullptr;
       for (Ice::Type ArgType : Signature.getArgList()) {
         (void)ArgType;
         setNextLocalInstIndex(nullptr);
@@ skipping 80 matching lines @@
   // The basic block being built.
   Ice::CfgNode *CurrentNode = nullptr;
   // The ID for the function.
   NaClBcIndexSize_t FcnId;
   // The corresponding function declaration.
   Ice::FunctionDeclaration *FuncDecl;
   // Holds the dividing point between local and global absolute value indices.
   size_t CachedNumGlobalValueIDs;
   // Holds operands local to the function block, based on indices
   // defined in the bitcode file.
-  std::vector<Ice::Operand *> LocalOperands;
+  Ice::OperandList LocalOperands;
   // Holds the index within LocalOperands corresponding to the next
   // instruction that generates a value.
   NaClBcIndexSize_t NextLocalInstIndex;
   // True if the last processed instruction was a terminating
   // instruction.
   bool InstIsTerminating = false;
   // Upper limit of alignment power allowed by LLVM
   static const uint32_t AlignPowerLimit = 29;
 
   // Extracts the corresponding Alignment to use, given the AlignPower
@@ skipping 1819 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