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 10 matching lines @@
 // produces on std::out a summary of the bitcode file that shows various
 // statistics about the contents of the file. By default this information is
 // detailed and contains information about individual bitcode blocks and the
 // functions in the module.
 // The tool is also able to print a bitcode file in a straight forward text
 // format that shows the containment and relationships of the information in
 // the bitcode file (-dump option).
 //
 //===----------------------------------------------------------------------===//
 
+#define DEBUG_TYPE "pnacl-bcanalyzer"
+
 #include "llvm/ADT/OwningPtr.h"
 #include "llvm/Analysis/Verifier.h"
 #include "llvm/Bitcode/NaCl/NaClBitstreamReader.h"
 #include "llvm/Bitcode/NaCl/NaClLLVMBitCodes.h"
 #include "llvm/Bitcode/NaCl/NaClReaderWriter.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/Format.h"
 #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;
@@ skipping 271 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, ' ');
+  DEBUG(dbgs() << Indent << "-> ParseBlock(" << BlockID << ")\n");
   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;
+    DEBUG(dbgs() << 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";
       }
+      DEBUG(dbgs() << 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() {
+  DEBUG(dbgs() << "-> 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";
 
     }
   }
+  DEBUG(dbgs() << "<- 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();
 }