Subzero. Fixes memory leaks.

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 276 matching lines @@
     } else {
       return ValueIDConstants.size();
     }
   }
 
   /// Creates Count global variable declarations.
   void CreateGlobalVariables(size_t Count) {
     assert(VariableDeclarations);
     assert(VariableDeclarations->empty());
     for (size_t i = 0; i < Count; ++i) {
-      VariableDeclarations->push_back(Ice::VariableDeclaration::create());
+      VariableDeclarations->push_back(
+          Ice::VariableDeclaration::create(getTranslator().getContext()));
     }
   }
 
   /// Returns the number of global variable declarations in the
   /// bitcode file.
   Ice::SizeT getNumGlobalVariables() const {
     if (VariableDeclarations) {
       return VariableDeclarations->size();
     } else {
       return ValueIDConstants.size() - FunctionDeclarationList.size();
@@ skipping 592 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()),
         InitializersNeeded(0), NextGlobalID(0),
-        DummyGlobalVar(Ice::VariableDeclaration::create()),
+        DummyGlobalVar(
+            Ice::VariableDeclaration::create(getTranslator().getContext())),
         CurGlobalVar(DummyGlobalVar) {}
 
   ~GlobalsParser() final {}
 
   const char *getBlockName() const override { return "globals"; }
 
 private:
   Ice::TimerMarker Timer;
   // Keeps track of how many initializers are expected for the global variable
   // declaration being built.
@@ skipping 92 matching lines @@
       return;
     InitializersNeeded = Values[0];
     return;
   case naclbitc::GLOBALVAR_ZEROFILL: {
     // ZEROFILL: [size]
     if (!isValidRecordSize(1, "zerofill"))
       return;
     if (isIRGenerationDisabled())
       return;
     CurGlobalVar->addInitializer(
-        new Ice::VariableDeclaration::ZeroInitializer(Values[0]));
+        Ice::VariableDeclaration::ZeroInitializer::create(Values[0]));
     return;
   }
   case naclbitc::GLOBALVAR_DATA: {
     // DATA: [b0, b1, ...]
     if (!isValidRecordSizeAtLeast(1, "data"))
       return;
     if (isIRGenerationDisabled())
       return;
     CurGlobalVar->addInitializer(
-        new Ice::VariableDeclaration::DataInitializer(Values));
+        Ice::VariableDeclaration::DataInitializer::create(Values));
     return;
   }
   case naclbitc::GLOBALVAR_RELOC: {
     // RELOC: [val, [addend]]
     if (!isValidRecordSizeInRange(1, 2, "reloc"))
       return;
     if (isIRGenerationDisabled())
       return;
     unsigned Index = Values[0];
     Ice::SizeT Offset = 0;
     if (Values.size() == 2)
       Offset = Values[1];
-    CurGlobalVar->addInitializer(new Ice::VariableDeclaration::RelocInitializer(
-        Context->getGlobalDeclarationByID(Index), Offset));
+    CurGlobalVar->addInitializer(
+        Ice::VariableDeclaration::RelocInitializer::create(
+            Context->getGlobalDeclarationByID(Index), Offset));
     return;
   }
   default:
     BlockParserBaseClass::ProcessRecord();
     return;
   }
 }
 
 /// Base class for parsing a valuesymtab block in the bitcode file.
 class ValuesymtabParser : public BlockParserBaseClass {
@@ skipping 1886 matching lines @@
     GlobalValue::LinkageTypes Linkage;
     if (!naclbitc::DecodeLinkage(Values[3], Linkage)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Function address has unknown linkage. Found " << Values[3];
       Error(StrBuf.str());
       return;
     }
     bool IsProto = Values[2] == 1;
     Ice::FunctionDeclaration *Func = Ice::FunctionDeclaration::create(
-        Signature, CallingConv, Linkage, IsProto);
+        Context->getTranslator().getContext(), Signature, CallingConv, Linkage,
+        IsProto);
     Context->setNextFunctionID(Func);
     return;
   }
   default:
     BlockParserBaseClass::ProcessRecord();
     return;
   }
 }
 
 bool TopLevelParser::ParseBlock(unsigned BlockID) {
@@ skipping 61 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