Make abbreviations explicit in pnacl-freeze/thaw.

tools/pnacl-bcanalyzer/pnacl-bcanalyzer.cpp

 //===-- pnacl-bcanalyzer.cpp - Bitcode Analyzer -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This tool may be invoked in the following manner:
@@ skipping 27 matching lines @@
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/system_error.h"
 #include <algorithm>
 #include <map>
 using namespace llvm;
 
+/* To turn on debugging for this file, change value of NACL_DEBUGGING to 1.
+ */
+#define NACL_DEBUGGING 0
+#include "llvm/Bitcode/NaCl/NaClDebugging.h"
+
 static cl::opt<std::string>
   InputFilename(cl::Positional, cl::desc("<input bitcode>"), cl::init("-"));
 
 static cl::opt<bool> Dump("dump", cl::desc("Dump low level bitcode trace"));
 
 //===----------------------------------------------------------------------===//
 // Bitcode specific analysis.
 //===----------------------------------------------------------------------===//
 
 static cl::opt<bool> NoHistogram("disable-histogram",
@@ skipping 260 matching lines @@
 /// good place to breakpoint if debugging.
 static bool Error(const std::string &Err) {
   errs() << Err << "\n";
   return true;
 }
 
 /// ParseBlock - Read a block, updating statistics, etc.
 static bool ParseBlock(NaClBitstreamCursor &Stream, unsigned BlockID,
                        unsigned IndentLevel) {
   std::string Indent(IndentLevel*2, ' ');
+  NACL_DEBUG(outs() << Indent << "-> ParseBlock(" << BlockID << ")\n");

[jvoung (off chromium), 2013/05/14 23:47:14]

Not sure you want to use "outs()" since that will mix your debug output with the
stdout output.  You could use dbgs() instead, to print to stderr.

[Karl, 2013/05/17 20:52:18]

Fixing to use llvm debug.h

   uint64_t BlockBitStart = Stream.GetCurrentBitNo();
 
   // Get the statistics for this BlockID.
   PerBlockIDStats &BlockStats = BlockIDStats[BlockID];
 
   BlockStats.NumInstances++;
 
   // BLOCKINFO is a special part of the stream.
   if (BlockID == naclbitc::BLOCKINFO_BLOCK_ID) {
     if (Dump) outs() << Indent << "<BLOCKINFO_BLOCK/>\n";
     if (Stream.ReadBlockInfoBlock())
       return Error("Malformed BlockInfoBlock");
     uint64_t BlockBitEnd = Stream.GetCurrentBitNo();
     BlockStats.NumBits += BlockBitEnd-BlockBitStart;
+    NACL_DEBUG(outs() << Indent << "<- ParseBlock\n");
     return false;
   }
 
   unsigned NumWords = 0;
   if (Stream.EnterSubBlock(BlockID, &NumWords))
     return Error("Malformed block record");
 
   const char *BlockName = 0;
   if (Dump) {
     outs() << Indent << "<";
@@ skipping 27 matching lines @@
     case NaClBitstreamEntry::EndBlock: {
       uint64_t BlockBitEnd = Stream.GetCurrentBitNo();
       BlockStats.NumBits += BlockBitEnd-BlockBitStart;
       if (Dump) {
         outs() << Indent << "</";
         if (BlockName)
           outs() << BlockName << ">\n";
         else
           outs() << "UnknownBlock" << BlockID << ">\n";
       }
+      NACL_DEBUG(outs() << Indent << "<- ParseBlock\n");
       return false;
     }
         
     case NaClBitstreamEntry::SubBlock: {
       uint64_t SubBlockBitStart = Stream.GetCurrentBitNo();
       if (ParseBlock(Stream, Entry.ID, IndentLevel+1))
         return true;
       ++BlockStats.NumSubBlocks;
       uint64_t SubBlockBitEnd = Stream.GetCurrentBitNo();
       
@@ skipping 72 matching lines @@
   outs() << format("%.2f/%.2fB/%luW", Bits, Bits/8,(unsigned long)(Bits/32));
 }
 static void PrintSize(uint64_t Bits) {
   outs() << format("%lub/%.2fB/%luW", (unsigned long)Bits,
                    (double)Bits/8, (unsigned long)(Bits/32));
 }
 
 
 /// AnalyzeBitcode - Analyze the bitcode file specified by InputFilename.
 static int AnalyzeBitcode() {
+  NACL_DEBUG(outs() << "-> AnalyzeBitcode\n");
   // Read the input file.
   OwningPtr<MemoryBuffer> MemBuf;
 
   if (error_code ec =
         MemoryBuffer::getFileOrSTDIN(InputFilename.c_str(), MemBuf))
     return Error("Error reading '" + InputFilename + "': " + ec.message());
 
   if (MemBuf->getBufferSize() & 3)
     return Error("Bitcode stream should be a multiple of 4 bytes in length");
 
@@ skipping 122 matching lines @@
         if (const char *CodeName =
               GetCodeName(FreqPairs[i].second, I->first, StreamFile))
           outs() << CodeName << "\n";
         else
           outs() << "UnknownCode" << FreqPairs[i].second << "\n";
       }
       outs() << "\n";
 
     }
   }
+  NACL_DEBUG(outs() << "<- AnalyzeBitcode\n");
   return 0;
 }
 
 
 int main(int argc, char **argv) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal();
   PrettyStackTraceProgram X(argc, argv);
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
   cl::ParseCommandLineOptions(argc, argv, "pnacl-bcanalyzer file analyzer\n");
 
   return AnalyzeBitcode();
 }