Subzero. Allocate global initializers from a dedicated arena.

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 239 matching lines @@
   bool blockError(const std::string &Message);
 
   /// Returns the number of errors found while parsing the bitcode file.
   unsigned getNumErrors() const { return NumErrors; }
 
   /// Changes the size of the type list to the given size.
   void resizeTypeIDValues(size_t NewSize) { TypeIDValues.resize(NewSize); }
 
   size_t getNumTypeIDValues() const { return TypeIDValues.size(); }
 
+  /// Returns a pointer to the pool where globals are allocated.
+  Ice::VariableDeclarationList *getGlobalVariablesPool() {
+    return VariableDeclarations.get();
+  }
+
   /// Returns the undefined type associated with type ID. Note: Returns extended
   /// type ready to be defined.
   ExtendedType *getTypeByIDForDefining(NaClBcIndexSize_t ID) {
     // Get corresponding element, verifying the value is still undefined (and
     // hence allowed to be defined).
     ExtendedType *Ty = getTypeByIDAsKind(ID, ExtendedType::Undefined);
     if (Ty)
       return Ty;
     if (ID >= TypeIDValues.size()) {
       if (ID >= NaClBcIndexSize_t_Max) {
@@ skipping 744 matching lines @@
 class GlobalsParser : public BlockParserBaseClass {
   GlobalsParser() = delete;
   GlobalsParser(const GlobalsParser &) = delete;
   GlobalsParser &operator=(const GlobalsParser &) = delete;
 
 public:
   GlobalsParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser),
         Timer(Ice::TimerStack::TT_parseGlobals, getTranslator().getContext()),
         NumFunctionIDs(Context->getNumFunctionIDs()),
-        DummyGlobalVar(
-            Ice::VariableDeclaration::create(getTranslator().getContext())),
-        CurGlobalVar(DummyGlobalVar) {}
+        DummyGlobalVar(Ice::VariableDeclaration::create(
+            Context->getGlobalVariablesPool())),
+        CurGlobalVar(DummyGlobalVar) {
+    Context->getGlobalVariablesPool()->willNotBeEmitted(DummyGlobalVar);
+  }
 
   ~GlobalsParser() final = default;
 
   const char *getBlockName() const override { return "globals"; }
 
 private:
   using GlobalVarsMapType =
       std::unordered_map<NaClBcIndexSize_t, Ice::VariableDeclaration *>;
 
   Ice::TimerMarker Timer;
@@ skipping 19 matching lines @@
   // defined (allowing code to not need to check if CurGlobalVar is nullptr).
   Ice::VariableDeclaration *DummyGlobalVar;
 
   // Holds the current global variable declaration being built.
   Ice::VariableDeclaration *CurGlobalVar;
 
   // Returns the global variable associated with the given Index.
   Ice::VariableDeclaration *getGlobalVarByID(NaClBcIndexSize_t Index) {
     Ice::VariableDeclaration *&Decl = GlobalVarsMap[Index];
     if (Decl == nullptr)
-      Decl = Ice::VariableDeclaration::create(getTranslator().getContext());
+      Decl =
+          Ice::VariableDeclaration::create(Context->getGlobalVariablesPool());
     return Decl;
   }
 
   // Returns the global declaration associated with the given index.
   Ice::GlobalDeclaration *getGlobalDeclByID(NaClBcIndexSize_t Index) {
     if (Index < NumFunctionIDs)
       return Context->getFunctionByID(Index);
     return getGlobalVarByID(Index - NumFunctionIDs);
   }
 
@@ skipping 89 matching lines @@
              << " compound record size invalid. Found: " << Values[0];
       Error(StrBuf.str());
       return;
     }
     InitializersNeeded = Values[0];
     return;
   case naclbitc::GLOBALVAR_ZEROFILL: {
     // ZEROFILL: [size]
     if (!isValidRecordSize(1, "zerofill"))
       return;
+    auto *Pool = Context->getGlobalVariablesPool();
     CurGlobalVar->addInitializer(
-        Ice::VariableDeclaration::ZeroInitializer::create(Values[0]));
+        Ice::VariableDeclaration::ZeroInitializer::create(Pool, Values[0]));
     return;
   }
   case naclbitc::GLOBALVAR_DATA: {
     // DATA: [b0, b1, ...]
     if (!isValidRecordSizeAtLeast(1, "data"))
       return;
+    auto *Pool = Context->getGlobalVariablesPool();
     CurGlobalVar->addInitializer(
-        Ice::VariableDeclaration::DataInitializer::create(Values));
+        Ice::VariableDeclaration::DataInitializer::create(Pool, Values));
     return;
   }
   case naclbitc::GLOBALVAR_RELOC: {
     // RELOC: [val, [addend]]
     if (!isValidRecordSizeInRange(1, 2, "reloc"))
       return;
     NaClBcIndexSize_t Index = Values[0];
     NaClBcIndexSize_t IndexLimit = SpecifiedNumberVars + NumFunctionIDs;
     if (Index >= IndexLimit) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Relocation index " << Index << " to big. Expect index < "
              << IndexLimit;
       Error(StrBuf.str());
     }
     uint64_t Offset = 0;
     if (Values.size() == 2) {
       Offset = Values[1];
       if (Offset > std::numeric_limits<uint32_t>::max()) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Addend of global reloc record too big: " << Offset;
         Error(StrBuf.str());
       }
     }
+    auto *Pool = Context->getGlobalVariablesPool();
     Ice::GlobalContext *Ctx = getTranslator().getContext();
     CurGlobalVar->addInitializer(
         Ice::VariableDeclaration::RelocInitializer::create(
-            getGlobalDeclByID(Index), {Ice::RelocOffset::create(Ctx, Offset)}));
+            Pool, getGlobalDeclByID(Index),
+            {Ice::RelocOffset::create(Ctx, Offset)}));
     return;
   }
   default:
     BlockParserBaseClass::ProcessRecord();
     return;
   }
 }
 
 /// Base class for parsing a valuesymtab block in the bitcode file.
 class ValuesymtabParser : public BlockParserBaseClass {
@@ skipping 1977 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