Finalize bytecode dumping. The "handleFinish" method was getting called

too soon so the function data was not getting dumped (it was generated
after the call handleFinish). Also cleaned up the output format for
proper indentation.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14627 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Bytecode/Reader/Analyzer.cpp b/lib/Bytecode/Reader/Analyzer.cpp
index 1f29b2242da08f5a7e74deda271afcdeded63062..6defe27b010e5e7f34bbbebd597afd4937271adc 100644 (file)
--- a/lib/Bytecode/Reader/Analyzer.cpp
+++ b/lib/Bytecode/Reader/Analyzer.cpp
@@ -185,9 +185,9 @@ public:
   }
 
   virtual void handleGlobalInitializer(GlobalVariable* GV, Constant* CV) {
-    dump << "      Initializer: GV=";
+    dump << "    Initializer: GV=";
     GV->print(dump);
-    dump << " CV=";
+    dump << "      CV=";
     CV->print(dump);
     dump << "\n";
   }
@@ -204,17 +204,17 @@ public:
   }
 
   virtual void handleCompactionTableBegin() { 
-    dump << "    BLOCK: CompactionTable {\n";
+    dump << "      BLOCK: CompactionTable {\n";
   }
 
   virtual void handleCompactionTablePlane( unsigned Ty, unsigned NumEntries) {
     bca.numCmpctnTables++;
-    dump << "      Plane: Ty=" << Ty << " Size=" << NumEntries << "\n";
+    dump << "        Plane: Ty=" << Ty << " Size=" << NumEntries << "\n";
   }
 
   virtual void handleCompactionTableType( unsigned i, unsigned TypSlot, 
       const Type* Ty ) {
-    dump << "        Type: " << i << " Slot:" << TypSlot 
+    dump << "          Type: " << i << " Slot:" << TypSlot 
               << " is " << Ty->getDescription() << "\n"; 
   }
 
@@ -223,13 +223,13 @@ public:
     unsigned TypSlot,
     unsigned ValSlot, 
     const Type* Ty ) { 
-    dump << "        Value: " << i << " TypSlot: " << TypSlot 
+    dump << "          Value: " << i << " TypSlot: " << TypSlot 
          << " ValSlot:" << ValSlot << " is " << Ty->getDescription() 
          << "\n";
   }
 
   virtual void handleCompactionTableEnd() { 
-    dump << "    } END BLOCK: CompactionTable\n";
+    dump << "      } END BLOCK: CompactionTable\n";
   }
 
   virtual void handleSymbolTableBegin(Function* CF, SymbolTable* ST) { 
@@ -260,9 +260,9 @@ public:
   }
 
   virtual void handleFunctionBegin(Function* Func, unsigned Size) {
-    dump << "BLOCK: Function {\n";
-    dump << "  Linkage: " << Func->getLinkage() << "\n";
-    dump << "  Type: " << Func->getType()->getDescription() << "\n";
+    dump << "    BLOCK: Function {\n";
+    dump << "      Linkage: " << Func->getLinkage() << "\n";
+    dump << "      Type: " << Func->getType()->getDescription() << "\n";
     const FunctionType* FType = 
       cast<FunctionType>(Func->getType()->getElementType());
     currFunc = &bca.FunctionInfo[Func];
@@ -284,7 +284,7 @@ public:
   }
 
   virtual void handleFunctionEnd( Function* Func) {
-    dump << "} END BLOCK: Function\n";
+    dump << "    } END BLOCK: Function\n";
     currFunc->density = double(currFunc->byteSize) /
       double(currFunc->numInstructions+currFunc->numBasicBlocks);
 
@@ -298,7 +298,7 @@ public:
   }
 
   virtual void handleBasicBlockBegin( unsigned blocknum) {
-    dump << "  BLOCK: BasicBlock #" << blocknum << "{\n";
+    dump << "      BLOCK: BasicBlock #" << blocknum << "{\n";
     bca.numBasicBlocks++;
     bca.numValues++;
     if ( currFunc ) currFunc->numBasicBlocks++;
@@ -306,11 +306,12 @@ public:
 
   virtual bool handleInstruction( unsigned Opcode, const Type* iType, 
                                 std::vector<unsigned>& Operands, unsigned Size){
-    dump << "    INST: OpCode=" 
-         << Instruction::getOpcodeName(Opcode) << " Type=" 
-         << iType->getDescription() << "\n";
+    dump << "        INST: OpCode=" 
+         << Instruction::getOpcodeName(Opcode) << " Type=\"" 
+         << iType->getDescription() << "\"";
     for ( unsigned i = 0; i < Operands.size(); ++i ) 
-      dump << "      Op#" << i << " Slot=" << Operands[i] << "\n";
+      dump << " Op(" << i << ")=Slot(" << Operands[i] << ")";
+    dump << "\n";
 
     bca.numInstructions++;
     bca.numValues++;
@@ -327,7 +328,7 @@ public:
   }
 
   virtual void handleBasicBlockEnd(unsigned blocknum) { 
-    dump << "  } END BLOCK: BasicBlock #" << blocknum << "{\n";
+    dump << "      } END BLOCK: BasicBlock #" << blocknum << "{\n";
   }
 
   virtual void handleGlobalConstantsBegin() { 

diff --git a/lib/Bytecode/Reader/Reader.cpp b/lib/Bytecode/Reader/Reader.cpp
index 8d0df020ec31b1eaf803f7c61b1946efc7d08c3f..14f6c9f7e27bff969567bf05a869c8c3aa6eb712 100644 (file)
--- a/lib/Bytecode/Reader/Reader.cpp
+++ b/lib/Bytecode/Reader/Reader.cpp
@@ -894,7 +894,6 @@ unsigned BytecodeReader::ParseInstructionList(Function* F) {
       BB = ParsedBasicBlocks[BlockNo] = new BasicBlock();
     else
       BB = ParsedBasicBlocks[BlockNo];
-    if (Handler) Handler->handleBasicBlockEnd( BlockNo );
     ++BlockNo;
     F->getBasicBlockList().push_back(BB);
 
@@ -904,6 +903,8 @@ unsigned BytecodeReader::ParseInstructionList(Function* F) {
 
     if (!BB->getTerminator())
       throw std::string("Non-terminated basic block found!");
+
+    if (Handler) Handler->handleBasicBlockEnd( BlockNo-1 );
   }
 
   return BlockNo;
@@ -1898,7 +1899,8 @@ void BytecodeReader::ParseModule() {
 /// and \p Length parameters.
 void BytecodeReader::ParseBytecode(
        BufPtr Buf, unsigned Length,
-       const std::string &ModuleID) {
+       const std::string &ModuleID,
+       bool processFunctions) {
 
   try {
     At = MemStart = BlockStart = Buf;
@@ -1934,14 +1936,19 @@ void BytecodeReader::ParseBytecode(
     // Parse the module contents
     this->ParseModule();
 
-    // Tell the handler we're done
-    if (Handler) Handler->handleModuleEnd(ModuleID);
-
     // Check for missing functions
     if ( hasFunctions() )
       throw std::string("Function expected, but bytecode stream ended!");
 
-    // Tell the handler we're
+    // Process all the function bodies now, if requested
+    if ( processFunctions )
+      ParseAllFunctionBodies();
+
+    // Tell the handler we're done with the module
+    if (Handler) 
+      Handler->handleModuleEnd(ModuleID);
+
+    // Tell the handler we're finished the parse
     if (Handler) Handler->handleFinish();
 
   } catch (std::string& errstr ) {

diff --git a/lib/Bytecode/Reader/Reader.h b/lib/Bytecode/Reader/Reader.h
index 20801da94f6ae28780db4cca3ebee06cd4a5f325..4720e88a3cfd049ff80017db76836dafda5a2a75 100644 (file)
--- a/lib/Bytecode/Reader/Reader.h
+++ b/lib/Bytecode/Reader/Reader.h
@@ -127,9 +127,10 @@ public:
 public:
   /// @brief Main interface to parsing a bytecode buffer.
   void ParseBytecode(
-     const unsigned char *Buf,   ///< Beginning of the bytecode buffer
-     unsigned Length,            ///< Length of the bytecode buffer
-     const std::string &ModuleID ///< An identifier for the module constructed.
+     const unsigned char *Buf,    ///< Beginning of the bytecode buffer
+     unsigned Length,             ///< Length of the bytecode buffer
+     const std::string &ModuleID, ///< An identifier for the module constructed.
+     bool processFunctions=false  ///< Process all function bodies fully.
   );
 
   /// @brief Parse all function bodies

diff --git a/lib/Bytecode/Reader/ReaderWrappers.cpp b/lib/Bytecode/Reader/ReaderWrappers.cpp
index 42d2b0e2a1866afa38e44baeb58f2fab8b4cfdb2..f8f1101a0181d7098309a8c0dbdfc299b83102bb 100644 (file)
--- a/lib/Bytecode/Reader/ReaderWrappers.cpp
+++ b/lib/Bytecode/Reader/ReaderWrappers.cpp
@@ -58,7 +58,7 @@ BytecodeFileReader::BytecodeFileReader(const std::string &Filename,
 
   try {
     // Parse the bytecode we mmapped in
-    ParseBytecode(Buffer, Length, Filename);
+    ParseBytecode(Buffer, Length, Filename, H != 0);
   } catch (...) {
     UnmapFileFromAddressSpace(Buffer, Length);
     throw;
@@ -114,7 +114,7 @@ BytecodeBufferReader::BytecodeBufferReader(const unsigned char *Buf,
     MustDelete = false;
   }
   try {
-    ParseBytecode(ParseBegin, Length, ModuleID);
+    ParseBytecode(ParseBegin, Length, ModuleID, H != 0);
   } catch (...) {
     if (MustDelete) delete [] Buffer;
     throw;
@@ -163,7 +163,7 @@ BytecodeStdinReader::BytecodeStdinReader( BytecodeHandler* H )
     throw std::string("Standard Input empty!");
 
   FileBuf = &FileData[0];
-  ParseBytecode(FileBuf, FileData.size(), "<stdin>");
+  ParseBytecode(FileBuf, FileData.size(), "<stdin>", H != 0 );
 }
 
 //===----------------------------------------------------------------------===//