Test generation of global initializers in Subzero bitcode reader.

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 333 matching lines @@
 protected:
   // The context parser that contains the decoded state.
   TopLevelParser *Context;
 
   // Constructor for nested block parsers.
   BlockParserBaseClass(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : NaClBitcodeParser(BlockID, EnclosingParser),
         Context(EnclosingParser->Context) {}
 
   // Gets the translator associated with the bitcode parser.
-  Ice::Translator &getTranslator() { return Context->getTranslator(); }
+  Ice::Translator &getTranslator() const { return Context->getTranslator(); }
+
+  const Ice::ClFlags &getFlags() const { return getTranslator().getFlags(); }
 
   // Generates an error Message with the bit address prefixed to it.
   virtual bool Error(const std::string &Message) LLVM_OVERRIDE {
     uint64_t Bit = Record.GetStartBit() + Context->getHeaderSize() * 8;
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "(" << format("%" PRIu64 ":%u", (Bit / 8),
                             static_cast<unsigned>(Bit % 8)) << ") " << Message;
     return Context->Error(StrBuf.str());
   }
@@ skipping 1004 matching lines @@
     case naclbitc::FCMP_TRUE:
       Cond = Ice::InstFcmp::True;
       return true;
     default:
       return false;
     }
   }
 };
 
 FunctionParser::~FunctionParser() {
-  if (getTranslator().getFlags().SubzeroTimingEnabled) {
+  if (getFlags().SubzeroTimingEnabled) {
     errs() << "[Subzero timing] Convert function " << Func->getFunctionName()
            << ": " << TConvert.getElapsedSec() << " sec\n";
   }
 }
 
 void FunctionParser::ReportInvalidBinopOpcode(unsigned Opcode, Ice::Type Ty) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Binary opcode " << Opcode << "not understood for type " << Ty;
   Error(StrBuf.str());
@@ skipping 819 matching lines @@
   default:
     break;
   }
   return BlockParserBaseClass::ParseBlock(BlockID);
 }
 
 /// Parses the module block in the bitcode file.
 class ModuleParser : public BlockParserBaseClass {
 public:
   ModuleParser(unsigned BlockID, TopLevelParser *Context)
-      : BlockParserBaseClass(BlockID, Context), FoundFirstFunctionBlock(false) {
-  }
+      : BlockParserBaseClass(BlockID, Context),
+        GlobalAddressNamesAndInitializersInstalled(false) {}
 
   virtual ~ModuleParser() LLVM_OVERRIDE {}
 
 private:
-  // True if we have parsed a function block.
-  bool FoundFirstFunctionBlock;
+  // True if we have already instaledl names for unnamed global addresses,
+  // and generated global constant initializers.
+  bool GlobalAddressNamesAndInitializersInstalled;
+
+  // Temporary hack to generate names for unnamed global addresses,
+  // and generate global constant initializers. May be called multiple
+  // times. Only the first call will do the installation.
+  // NOTE: Doesn't handle relocations for global constant initializers.
+  void InstallGlobalAddressNamesAndInitializers() {
+    if (!GlobalAddressNamesAndInitializersInstalled) {
+      getTranslator().nameUnnamedGlobalAddresses(Context->getModule());
+      if (!getFlags().DisableGlobals)
+        getTranslator().convertGlobals(Context->getModule());
+      GlobalAddressNamesAndInitializersInstalled = true;
+    }
+  }
+
   virtual bool ParseBlock(unsigned BlockID) LLVM_OVERRIDE;
 
+  virtual void ExitBlock() LLVM_OVERRIDE {
+    InstallGlobalAddressNamesAndInitializers();
+    getTranslator().emitConstants();
+  }
+
   virtual void ProcessRecord() LLVM_OVERRIDE;
 };
 
 class ModuleValuesymtabParser : public ValuesymtabParser {
   ModuleValuesymtabParser(const ModuleValuesymtabParser &)
       LLVM_DELETED_FUNCTION;
   void operator=(const ModuleValuesymtabParser &) LLVM_DELETED_FUNCTION;
 
 public:
   ModuleValuesymtabParser(unsigned BlockID, ModuleParser *MP)
@@ skipping 36 matching lines @@
   }
   case naclbitc::GLOBALVAR_BLOCK_ID: {
     GlobalsParser Parser(BlockID, this);
     return Parser.ParseThisBlock();
   }
   case naclbitc::VALUE_SYMTAB_BLOCK_ID: {
     ModuleValuesymtabParser Parser(BlockID, this);
     return Parser.ParseThisBlock();
   }
   case naclbitc::FUNCTION_BLOCK_ID: {
-    if (!FoundFirstFunctionBlock) {
-      getTranslator().nameUnnamedGlobalAddresses(Context->getModule());
-      FoundFirstFunctionBlock = true;
-    }
+    InstallGlobalAddressNamesAndInitializers();
     FunctionParser Parser(BlockID, this);
     return Parser.ParseThisBlock();
   }
   default:
     return BlockParserBaseClass::ParseBlock(BlockID);
   }
 }
 
 void ModuleParser::ProcessRecord() {
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
@@ skipping 113 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
 }
 
 } // end of namespace Ice