Home | History | Annotate | Download | only in llvm-bcanalyzer
      1 //===-- llvm-bcanalyzer.cpp - Bitcode Analyzer --------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This tool may be invoked in the following manner:
     11 //  llvm-bcanalyzer [options]      - Read LLVM bitcode from stdin
     12 //  llvm-bcanalyzer [options] x.bc - Read LLVM bitcode from the x.bc file
     13 //
     14 //  Options:
     15 //      --help      - Output information about command line switches
     16 //      --dump      - Dump low-level bitcode structure in readable format
     17 //
     18 // This tool provides analytical information about a bitcode file. It is
     19 // intended as an aid to developers of bitcode reading and writing software. It
     20 // produces on std::out a summary of the bitcode file that shows various
     21 // statistics about the contents of the file. By default this information is
     22 // detailed and contains information about individual bitcode blocks and the
     23 // functions in the module.
     24 // The tool is also able to print a bitcode file in a straight forward text
     25 // format that shows the containment and relationships of the information in
     26 // the bitcode file (-dump option).
     27 //
     28 //===----------------------------------------------------------------------===//
     29 
     30 #include "llvm/ADT/OwningPtr.h"
     31 #include "llvm/Analysis/Verifier.h"
     32 #include "llvm/Bitcode/BitstreamReader.h"
     33 #include "llvm/Bitcode/LLVMBitCodes.h"
     34 #include "llvm/Bitcode/ReaderWriter.h"
     35 #include "llvm/Support/CommandLine.h"
     36 #include "llvm/Support/Format.h"
     37 #include "llvm/Support/ManagedStatic.h"
     38 #include "llvm/Support/MemoryBuffer.h"
     39 #include "llvm/Support/PrettyStackTrace.h"
     40 #include "llvm/Support/Signals.h"
     41 #include "llvm/Support/raw_ostream.h"
     42 #include "llvm/Support/system_error.h"
     43 #include <algorithm>
     44 #include <map>
     45 using namespace llvm;
     46 
     47 static cl::opt<std::string>
     48   InputFilename(cl::Positional, cl::desc("<input bitcode>"), cl::init("-"));
     49 
     50 static cl::opt<bool> Dump("dump", cl::desc("Dump low level bitcode trace"));
     51 
     52 //===----------------------------------------------------------------------===//
     53 // Bitcode specific analysis.
     54 //===----------------------------------------------------------------------===//
     55 
     56 static cl::opt<bool> NoHistogram("disable-histogram",
     57                                  cl::desc("Do not print per-code histogram"));
     58 
     59 static cl::opt<bool>
     60 NonSymbolic("non-symbolic",
     61             cl::desc("Emit numeric info in dump even if"
     62                      " symbolic info is available"));
     63 
     64 namespace {
     65 
     66 /// CurStreamTypeType - A type for CurStreamType
     67 enum CurStreamTypeType {
     68   UnknownBitstream,
     69   LLVMIRBitstream
     70 };
     71 
     72 }
     73 
     74 /// CurStreamType - If we can sniff the flavor of this stream, we can produce
     75 /// better dump info.
     76 static CurStreamTypeType CurStreamType;
     77 
     78 
     79 /// GetBlockName - Return a symbolic block name if known, otherwise return
     80 /// null.
     81 static const char *GetBlockName(unsigned BlockID,
     82                                 const BitstreamReader &StreamFile) {
     83   // Standard blocks for all bitcode files.
     84   if (BlockID < bitc::FIRST_APPLICATION_BLOCKID) {
     85     if (BlockID == bitc::BLOCKINFO_BLOCK_ID)
     86       return "BLOCKINFO_BLOCK";
     87     return 0;
     88   }
     89 
     90   // Check to see if we have a blockinfo record for this block, with a name.
     91   if (const BitstreamReader::BlockInfo *Info =
     92         StreamFile.getBlockInfo(BlockID)) {
     93     if (!Info->Name.empty())
     94       return Info->Name.c_str();
     95   }
     96 
     97 
     98   if (CurStreamType != LLVMIRBitstream) return 0;
     99 
    100   switch (BlockID) {
    101   default:                             return 0;
    102   case bitc::MODULE_BLOCK_ID:          return "MODULE_BLOCK";
    103   case bitc::PARAMATTR_BLOCK_ID:       return "PARAMATTR_BLOCK";
    104   case bitc::PARAMATTR_GROUP_BLOCK_ID: return "PARAMATTR_GROUP_BLOCK_ID";
    105   case bitc::TYPE_BLOCK_ID_NEW:        return "TYPE_BLOCK_ID";
    106   case bitc::CONSTANTS_BLOCK_ID:       return "CONSTANTS_BLOCK";
    107   case bitc::FUNCTION_BLOCK_ID:        return "FUNCTION_BLOCK";
    108   case bitc::VALUE_SYMTAB_BLOCK_ID:    return "VALUE_SYMTAB";
    109   case bitc::METADATA_BLOCK_ID:        return "METADATA_BLOCK";
    110   case bitc::METADATA_ATTACHMENT_ID:   return "METADATA_ATTACHMENT_BLOCK";
    111   case bitc::USELIST_BLOCK_ID:         return "USELIST_BLOCK_ID";
    112   }
    113 }
    114 
    115 /// GetCodeName - Return a symbolic code name if known, otherwise return
    116 /// null.
    117 static const char *GetCodeName(unsigned CodeID, unsigned BlockID,
    118                                const BitstreamReader &StreamFile) {
    119   // Standard blocks for all bitcode files.
    120   if (BlockID < bitc::FIRST_APPLICATION_BLOCKID) {
    121     if (BlockID == bitc::BLOCKINFO_BLOCK_ID) {
    122       switch (CodeID) {
    123       default: return 0;
    124       case bitc::BLOCKINFO_CODE_SETBID:        return "SETBID";
    125       case bitc::BLOCKINFO_CODE_BLOCKNAME:     return "BLOCKNAME";
    126       case bitc::BLOCKINFO_CODE_SETRECORDNAME: return "SETRECORDNAME";
    127       }
    128     }
    129     return 0;
    130   }
    131 
    132   // Check to see if we have a blockinfo record for this record, with a name.
    133   if (const BitstreamReader::BlockInfo *Info =
    134         StreamFile.getBlockInfo(BlockID)) {
    135     for (unsigned i = 0, e = Info->RecordNames.size(); i != e; ++i)
    136       if (Info->RecordNames[i].first == CodeID)
    137         return Info->RecordNames[i].second.c_str();
    138   }
    139 
    140 
    141   if (CurStreamType != LLVMIRBitstream) return 0;
    142 
    143   switch (BlockID) {
    144   default: return 0;
    145   case bitc::MODULE_BLOCK_ID:
    146     switch (CodeID) {
    147     default: return 0;
    148     case bitc::MODULE_CODE_VERSION:     return "VERSION";
    149     case bitc::MODULE_CODE_TRIPLE:      return "TRIPLE";
    150     case bitc::MODULE_CODE_DATALAYOUT:  return "DATALAYOUT";
    151     case bitc::MODULE_CODE_ASM:         return "ASM";
    152     case bitc::MODULE_CODE_SECTIONNAME: return "SECTIONNAME";
    153     case bitc::MODULE_CODE_DEPLIB:      return "DEPLIB"; // FIXME: Remove in 4.0
    154     case bitc::MODULE_CODE_GLOBALVAR:   return "GLOBALVAR";
    155     case bitc::MODULE_CODE_FUNCTION:    return "FUNCTION";
    156     case bitc::MODULE_CODE_ALIAS:       return "ALIAS";
    157     case bitc::MODULE_CODE_PURGEVALS:   return "PURGEVALS";
    158     case bitc::MODULE_CODE_GCNAME:      return "GCNAME";
    159     }
    160   case bitc::PARAMATTR_BLOCK_ID:
    161     switch (CodeID) {
    162     default: return 0;
    163     case bitc::PARAMATTR_CODE_ENTRY_OLD: return "ENTRY";
    164     case bitc::PARAMATTR_CODE_ENTRY:     return "ENTRY";
    165     case bitc::PARAMATTR_GRP_CODE_ENTRY: return "ENTRY";
    166     }
    167   case bitc::TYPE_BLOCK_ID_NEW:
    168     switch (CodeID) {
    169     default: return 0;
    170     case bitc::TYPE_CODE_NUMENTRY:     return "NUMENTRY";
    171     case bitc::TYPE_CODE_VOID:         return "VOID";
    172     case bitc::TYPE_CODE_FLOAT:        return "FLOAT";
    173     case bitc::TYPE_CODE_DOUBLE:       return "DOUBLE";
    174     case bitc::TYPE_CODE_LABEL:        return "LABEL";
    175     case bitc::TYPE_CODE_OPAQUE:       return "OPAQUE";
    176     case bitc::TYPE_CODE_INTEGER:      return "INTEGER";
    177     case bitc::TYPE_CODE_POINTER:      return "POINTER";
    178     case bitc::TYPE_CODE_ARRAY:        return "ARRAY";
    179     case bitc::TYPE_CODE_VECTOR:       return "VECTOR";
    180     case bitc::TYPE_CODE_X86_FP80:     return "X86_FP80";
    181     case bitc::TYPE_CODE_FP128:        return "FP128";
    182     case bitc::TYPE_CODE_PPC_FP128:    return "PPC_FP128";
    183     case bitc::TYPE_CODE_METADATA:     return "METADATA";
    184     case bitc::TYPE_CODE_STRUCT_ANON:  return "STRUCT_ANON";
    185     case bitc::TYPE_CODE_STRUCT_NAME:  return "STRUCT_NAME";
    186     case bitc::TYPE_CODE_STRUCT_NAMED: return "STRUCT_NAMED";
    187     case bitc::TYPE_CODE_FUNCTION:     return "FUNCTION";
    188     }
    189 
    190   case bitc::CONSTANTS_BLOCK_ID:
    191     switch (CodeID) {
    192     default: return 0;
    193     case bitc::CST_CODE_SETTYPE:         return "SETTYPE";
    194     case bitc::CST_CODE_NULL:            return "NULL";
    195     case bitc::CST_CODE_UNDEF:           return "UNDEF";
    196     case bitc::CST_CODE_INTEGER:         return "INTEGER";
    197     case bitc::CST_CODE_WIDE_INTEGER:    return "WIDE_INTEGER";
    198     case bitc::CST_CODE_FLOAT:           return "FLOAT";
    199     case bitc::CST_CODE_AGGREGATE:       return "AGGREGATE";
    200     case bitc::CST_CODE_STRING:          return "STRING";
    201     case bitc::CST_CODE_CSTRING:         return "CSTRING";
    202     case bitc::CST_CODE_CE_BINOP:        return "CE_BINOP";
    203     case bitc::CST_CODE_CE_CAST:         return "CE_CAST";
    204     case bitc::CST_CODE_CE_GEP:          return "CE_GEP";
    205     case bitc::CST_CODE_CE_INBOUNDS_GEP: return "CE_INBOUNDS_GEP";
    206     case bitc::CST_CODE_CE_SELECT:       return "CE_SELECT";
    207     case bitc::CST_CODE_CE_EXTRACTELT:   return "CE_EXTRACTELT";
    208     case bitc::CST_CODE_CE_INSERTELT:    return "CE_INSERTELT";
    209     case bitc::CST_CODE_CE_SHUFFLEVEC:   return "CE_SHUFFLEVEC";
    210     case bitc::CST_CODE_CE_CMP:          return "CE_CMP";
    211     case bitc::CST_CODE_INLINEASM:       return "INLINEASM";
    212     case bitc::CST_CODE_CE_SHUFVEC_EX:   return "CE_SHUFVEC_EX";
    213     case bitc::CST_CODE_BLOCKADDRESS:    return "CST_CODE_BLOCKADDRESS";
    214     case bitc::CST_CODE_DATA:            return "DATA";
    215     }
    216   case bitc::FUNCTION_BLOCK_ID:
    217     switch (CodeID) {
    218     default: return 0;
    219     case bitc::FUNC_CODE_DECLAREBLOCKS: return "DECLAREBLOCKS";
    220 
    221     case bitc::FUNC_CODE_INST_BINOP:        return "INST_BINOP";
    222     case bitc::FUNC_CODE_INST_CAST:         return "INST_CAST";
    223     case bitc::FUNC_CODE_INST_GEP:          return "INST_GEP";
    224     case bitc::FUNC_CODE_INST_INBOUNDS_GEP: return "INST_INBOUNDS_GEP";
    225     case bitc::FUNC_CODE_INST_SELECT:       return "INST_SELECT";
    226     case bitc::FUNC_CODE_INST_EXTRACTELT:   return "INST_EXTRACTELT";
    227     case bitc::FUNC_CODE_INST_INSERTELT:    return "INST_INSERTELT";
    228     case bitc::FUNC_CODE_INST_SHUFFLEVEC:   return "INST_SHUFFLEVEC";
    229     case bitc::FUNC_CODE_INST_CMP:          return "INST_CMP";
    230 
    231     case bitc::FUNC_CODE_INST_RET:          return "INST_RET";
    232     case bitc::FUNC_CODE_INST_BR:           return "INST_BR";
    233     case bitc::FUNC_CODE_INST_SWITCH:       return "INST_SWITCH";
    234     case bitc::FUNC_CODE_INST_INVOKE:       return "INST_INVOKE";
    235     case bitc::FUNC_CODE_INST_UNREACHABLE:  return "INST_UNREACHABLE";
    236 
    237     case bitc::FUNC_CODE_INST_PHI:          return "INST_PHI";
    238     case bitc::FUNC_CODE_INST_ALLOCA:       return "INST_ALLOCA";
    239     case bitc::FUNC_CODE_INST_LOAD:         return "INST_LOAD";
    240     case bitc::FUNC_CODE_INST_VAARG:        return "INST_VAARG";
    241     case bitc::FUNC_CODE_INST_STORE:        return "INST_STORE";
    242     case bitc::FUNC_CODE_INST_EXTRACTVAL:   return "INST_EXTRACTVAL";
    243     case bitc::FUNC_CODE_INST_INSERTVAL:    return "INST_INSERTVAL";
    244     case bitc::FUNC_CODE_INST_CMP2:         return "INST_CMP2";
    245     case bitc::FUNC_CODE_INST_VSELECT:      return "INST_VSELECT";
    246     case bitc::FUNC_CODE_DEBUG_LOC_AGAIN:   return "DEBUG_LOC_AGAIN";
    247     case bitc::FUNC_CODE_INST_CALL:         return "INST_CALL";
    248     case bitc::FUNC_CODE_DEBUG_LOC:         return "DEBUG_LOC";
    249     }
    250   case bitc::VALUE_SYMTAB_BLOCK_ID:
    251     switch (CodeID) {
    252     default: return 0;
    253     case bitc::VST_CODE_ENTRY: return "ENTRY";
    254     case bitc::VST_CODE_BBENTRY: return "BBENTRY";
    255     }
    256   case bitc::METADATA_ATTACHMENT_ID:
    257     switch(CodeID) {
    258     default:return 0;
    259     case bitc::METADATA_ATTACHMENT: return "METADATA_ATTACHMENT";
    260     }
    261   case bitc::METADATA_BLOCK_ID:
    262     switch(CodeID) {
    263     default:return 0;
    264     case bitc::METADATA_STRING:      return "METADATA_STRING";
    265     case bitc::METADATA_NAME:        return "METADATA_NAME";
    266     case bitc::METADATA_KIND:        return "METADATA_KIND";
    267     case bitc::METADATA_NODE:        return "METADATA_NODE";
    268     case bitc::METADATA_FN_NODE:     return "METADATA_FN_NODE";
    269     case bitc::METADATA_NAMED_NODE:  return "METADATA_NAMED_NODE";
    270     }
    271   case bitc::USELIST_BLOCK_ID:
    272     switch(CodeID) {
    273     default:return 0;
    274     case bitc::USELIST_CODE_ENTRY:   return "USELIST_CODE_ENTRY";
    275     }
    276   }
    277 }
    278 
    279 struct PerRecordStats {
    280   unsigned NumInstances;
    281   unsigned NumAbbrev;
    282   uint64_t TotalBits;
    283 
    284   PerRecordStats() : NumInstances(0), NumAbbrev(0), TotalBits(0) {}
    285 };
    286 
    287 struct PerBlockIDStats {
    288   /// NumInstances - This the number of times this block ID has been seen.
    289   unsigned NumInstances;
    290 
    291   /// NumBits - The total size in bits of all of these blocks.
    292   uint64_t NumBits;
    293 
    294   /// NumSubBlocks - The total number of blocks these blocks contain.
    295   unsigned NumSubBlocks;
    296 
    297   /// NumAbbrevs - The total number of abbreviations.
    298   unsigned NumAbbrevs;
    299 
    300   /// NumRecords - The total number of records these blocks contain, and the
    301   /// number that are abbreviated.
    302   unsigned NumRecords, NumAbbreviatedRecords;
    303 
    304   /// CodeFreq - Keep track of the number of times we see each code.
    305   std::vector<PerRecordStats> CodeFreq;
    306 
    307   PerBlockIDStats()
    308     : NumInstances(0), NumBits(0),
    309       NumSubBlocks(0), NumAbbrevs(0), NumRecords(0), NumAbbreviatedRecords(0) {}
    310 };
    311 
    312 static std::map<unsigned, PerBlockIDStats> BlockIDStats;
    313 
    314 
    315 
    316 /// Error - All bitcode analysis errors go through this function, making this a
    317 /// good place to breakpoint if debugging.
    318 static bool Error(const std::string &Err) {
    319   errs() << Err << "\n";
    320   return true;
    321 }
    322 
    323 /// ParseBlock - Read a block, updating statistics, etc.
    324 static bool ParseBlock(BitstreamCursor &Stream, unsigned BlockID,
    325                        unsigned IndentLevel) {
    326   std::string Indent(IndentLevel*2, ' ');
    327   uint64_t BlockBitStart = Stream.GetCurrentBitNo();
    328 
    329   // Get the statistics for this BlockID.
    330   PerBlockIDStats &BlockStats = BlockIDStats[BlockID];
    331 
    332   BlockStats.NumInstances++;
    333 
    334   // BLOCKINFO is a special part of the stream.
    335   if (BlockID == bitc::BLOCKINFO_BLOCK_ID) {
    336     if (Dump) outs() << Indent << "<BLOCKINFO_BLOCK/>\n";
    337     if (Stream.ReadBlockInfoBlock())
    338       return Error("Malformed BlockInfoBlock");
    339     uint64_t BlockBitEnd = Stream.GetCurrentBitNo();
    340     BlockStats.NumBits += BlockBitEnd-BlockBitStart;
    341     return false;
    342   }
    343 
    344   unsigned NumWords = 0;
    345   if (Stream.EnterSubBlock(BlockID, &NumWords))
    346     return Error("Malformed block record");
    347 
    348   const char *BlockName = 0;
    349   if (Dump) {
    350     outs() << Indent << "<";
    351     if ((BlockName = GetBlockName(BlockID, *Stream.getBitStreamReader())))
    352       outs() << BlockName;
    353     else
    354       outs() << "UnknownBlock" << BlockID;
    355 
    356     if (NonSymbolic && BlockName)
    357       outs() << " BlockID=" << BlockID;
    358 
    359     outs() << " NumWords=" << NumWords
    360            << " BlockCodeSize=" << Stream.getAbbrevIDWidth() << ">\n";
    361   }
    362 
    363   SmallVector<uint64_t, 64> Record;
    364 
    365   // Read all the records for this block.
    366   while (1) {
    367     if (Stream.AtEndOfStream())
    368       return Error("Premature end of bitstream");
    369 
    370     uint64_t RecordStartBit = Stream.GetCurrentBitNo();
    371 
    372     BitstreamEntry Entry =
    373       Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);
    374 
    375     switch (Entry.Kind) {
    376     case BitstreamEntry::Error:
    377       return Error("malformed bitcode file");
    378     case BitstreamEntry::EndBlock: {
    379       uint64_t BlockBitEnd = Stream.GetCurrentBitNo();
    380       BlockStats.NumBits += BlockBitEnd-BlockBitStart;
    381       if (Dump) {
    382         outs() << Indent << "</";
    383         if (BlockName)
    384           outs() << BlockName << ">\n";
    385         else
    386           outs() << "UnknownBlock" << BlockID << ">\n";
    387       }
    388       return false;
    389     }
    390 
    391     case BitstreamEntry::SubBlock: {
    392       uint64_t SubBlockBitStart = Stream.GetCurrentBitNo();
    393       if (ParseBlock(Stream, Entry.ID, IndentLevel+1))
    394         return true;
    395       ++BlockStats.NumSubBlocks;
    396       uint64_t SubBlockBitEnd = Stream.GetCurrentBitNo();
    397 
    398       // Don't include subblock sizes in the size of this block.
    399       BlockBitStart += SubBlockBitEnd-SubBlockBitStart;
    400       continue;
    401     }
    402     case BitstreamEntry::Record:
    403       // The interesting case.
    404       break;
    405     }
    406 
    407     if (Entry.ID == bitc::DEFINE_ABBREV) {
    408       Stream.ReadAbbrevRecord();
    409       ++BlockStats.NumAbbrevs;
    410       continue;
    411     }
    412 
    413     Record.clear();
    414 
    415     ++BlockStats.NumRecords;
    416 
    417     StringRef Blob;
    418     unsigned Code = Stream.readRecord(Entry.ID, Record, &Blob);
    419 
    420     // Increment the # occurrences of this code.
    421     if (BlockStats.CodeFreq.size() <= Code)
    422       BlockStats.CodeFreq.resize(Code+1);
    423     BlockStats.CodeFreq[Code].NumInstances++;
    424     BlockStats.CodeFreq[Code].TotalBits +=
    425       Stream.GetCurrentBitNo()-RecordStartBit;
    426     if (Entry.ID != bitc::UNABBREV_RECORD) {
    427       BlockStats.CodeFreq[Code].NumAbbrev++;
    428       ++BlockStats.NumAbbreviatedRecords;
    429     }
    430 
    431     if (Dump) {
    432       outs() << Indent << "  <";
    433       if (const char *CodeName =
    434             GetCodeName(Code, BlockID, *Stream.getBitStreamReader()))
    435         outs() << CodeName;
    436       else
    437         outs() << "UnknownCode" << Code;
    438       if (NonSymbolic &&
    439           GetCodeName(Code, BlockID, *Stream.getBitStreamReader()))
    440         outs() << " codeid=" << Code;
    441       if (Entry.ID != bitc::UNABBREV_RECORD)
    442         outs() << " abbrevid=" << Entry.ID;
    443 
    444       for (unsigned i = 0, e = Record.size(); i != e; ++i)
    445         outs() << " op" << i << "=" << (int64_t)Record[i];
    446 
    447       outs() << "/>";
    448 
    449       if (Blob.data()) {
    450         outs() << " blob data = ";
    451         bool BlobIsPrintable = true;
    452         for (unsigned i = 0, e = Blob.size(); i != e; ++i)
    453           if (!isprint(static_cast<unsigned char>(Blob[i]))) {
    454             BlobIsPrintable = false;
    455             break;
    456           }
    457 
    458         if (BlobIsPrintable)
    459           outs() << "'" << Blob << "'";
    460         else
    461           outs() << "unprintable, " << Blob.size() << " bytes.";
    462       }
    463 
    464       outs() << "\n";
    465     }
    466   }
    467 }
    468 
    469 static void PrintSize(double Bits) {
    470   outs() << format("%.2f/%.2fB/%luW", Bits, Bits/8,(unsigned long)(Bits/32));
    471 }
    472 static void PrintSize(uint64_t Bits) {
    473   outs() << format("%lub/%.2fB/%luW", (unsigned long)Bits,
    474                    (double)Bits/8, (unsigned long)(Bits/32));
    475 }
    476 
    477 
    478 /// AnalyzeBitcode - Analyze the bitcode file specified by InputFilename.
    479 static int AnalyzeBitcode() {
    480   // Read the input file.
    481   OwningPtr<MemoryBuffer> MemBuf;
    482 
    483   if (error_code ec =
    484         MemoryBuffer::getFileOrSTDIN(InputFilename, MemBuf))
    485     return Error("Error reading '" + InputFilename + "': " + ec.message());
    486 
    487   if (MemBuf->getBufferSize() & 3)
    488     return Error("Bitcode stream should be a multiple of 4 bytes in length");
    489 
    490   const unsigned char *BufPtr = (const unsigned char *)MemBuf->getBufferStart();
    491   const unsigned char *EndBufPtr = BufPtr+MemBuf->getBufferSize();
    492 
    493   // If we have a wrapper header, parse it and ignore the non-bc file contents.
    494   // The magic number is 0x0B17C0DE stored in little endian.
    495   if (isBitcodeWrapper(BufPtr, EndBufPtr))
    496     if (SkipBitcodeWrapperHeader(BufPtr, EndBufPtr, true))
    497       return Error("Invalid bitcode wrapper header");
    498 
    499   BitstreamReader StreamFile(BufPtr, EndBufPtr);
    500   BitstreamCursor Stream(StreamFile);
    501   StreamFile.CollectBlockInfoNames();
    502 
    503   // Read the stream signature.
    504   char Signature[6];
    505   Signature[0] = Stream.Read(8);
    506   Signature[1] = Stream.Read(8);
    507   Signature[2] = Stream.Read(4);
    508   Signature[3] = Stream.Read(4);
    509   Signature[4] = Stream.Read(4);
    510   Signature[5] = Stream.Read(4);
    511 
    512   // Autodetect the file contents, if it is one we know.
    513   CurStreamType = UnknownBitstream;
    514   if (Signature[0] == 'B' && Signature[1] == 'C' &&
    515       Signature[2] == 0x0 && Signature[3] == 0xC &&
    516       Signature[4] == 0xE && Signature[5] == 0xD)
    517     CurStreamType = LLVMIRBitstream;
    518 
    519   unsigned NumTopBlocks = 0;
    520 
    521   // Parse the top-level structure.  We only allow blocks at the top-level.
    522   while (!Stream.AtEndOfStream()) {
    523     unsigned Code = Stream.ReadCode();
    524     if (Code != bitc::ENTER_SUBBLOCK)
    525       return Error("Invalid record at top-level");
    526 
    527     unsigned BlockID = Stream.ReadSubBlockID();
    528 
    529     if (ParseBlock(Stream, BlockID, 0))
    530       return true;
    531     ++NumTopBlocks;
    532   }
    533 
    534   if (Dump) outs() << "\n\n";
    535 
    536   uint64_t BufferSizeBits = (EndBufPtr-BufPtr)*CHAR_BIT;
    537   // Print a summary of the read file.
    538   outs() << "Summary of " << InputFilename << ":\n";
    539   outs() << "         Total size: ";
    540   PrintSize(BufferSizeBits);
    541   outs() << "\n";
    542   outs() << "        Stream type: ";
    543   switch (CurStreamType) {
    544   case UnknownBitstream: outs() << "unknown\n"; break;
    545   case LLVMIRBitstream:  outs() << "LLVM IR\n"; break;
    546   }
    547   outs() << "  # Toplevel Blocks: " << NumTopBlocks << "\n";
    548   outs() << "\n";
    549 
    550   // Emit per-block stats.
    551   outs() << "Per-block Summary:\n";
    552   for (std::map<unsigned, PerBlockIDStats>::iterator I = BlockIDStats.begin(),
    553        E = BlockIDStats.end(); I != E; ++I) {
    554     outs() << "  Block ID #" << I->first;
    555     if (const char *BlockName = GetBlockName(I->first, StreamFile))
    556       outs() << " (" << BlockName << ")";
    557     outs() << ":\n";
    558 
    559     const PerBlockIDStats &Stats = I->second;
    560     outs() << "      Num Instances: " << Stats.NumInstances << "\n";
    561     outs() << "         Total Size: ";
    562     PrintSize(Stats.NumBits);
    563     outs() << "\n";
    564     double pct = (Stats.NumBits * 100.0) / BufferSizeBits;
    565     outs() << "    Percent of file: " << format("%2.4f%%", pct) << "\n";
    566     if (Stats.NumInstances > 1) {
    567       outs() << "       Average Size: ";
    568       PrintSize(Stats.NumBits/(double)Stats.NumInstances);
    569       outs() << "\n";
    570       outs() << "  Tot/Avg SubBlocks: " << Stats.NumSubBlocks << "/"
    571              << Stats.NumSubBlocks/(double)Stats.NumInstances << "\n";
    572       outs() << "    Tot/Avg Abbrevs: " << Stats.NumAbbrevs << "/"
    573              << Stats.NumAbbrevs/(double)Stats.NumInstances << "\n";
    574       outs() << "    Tot/Avg Records: " << Stats.NumRecords << "/"
    575              << Stats.NumRecords/(double)Stats.NumInstances << "\n";
    576     } else {
    577       outs() << "      Num SubBlocks: " << Stats.NumSubBlocks << "\n";
    578       outs() << "        Num Abbrevs: " << Stats.NumAbbrevs << "\n";
    579       outs() << "        Num Records: " << Stats.NumRecords << "\n";
    580     }
    581     if (Stats.NumRecords) {
    582       double pct = (Stats.NumAbbreviatedRecords * 100.0) / Stats.NumRecords;
    583       outs() << "    Percent Abbrevs: " << format("%2.4f%%", pct) << "\n";
    584     }
    585     outs() << "\n";
    586 
    587     // Print a histogram of the codes we see.
    588     if (!NoHistogram && !Stats.CodeFreq.empty()) {
    589       std::vector<std::pair<unsigned, unsigned> > FreqPairs;  // <freq,code>
    590       for (unsigned i = 0, e = Stats.CodeFreq.size(); i != e; ++i)
    591         if (unsigned Freq = Stats.CodeFreq[i].NumInstances)
    592           FreqPairs.push_back(std::make_pair(Freq, i));
    593       std::stable_sort(FreqPairs.begin(), FreqPairs.end());
    594       std::reverse(FreqPairs.begin(), FreqPairs.end());
    595 
    596       outs() << "\tRecord Histogram:\n";
    597       outs() << "\t\t  Count    # Bits   %% Abv  Record Kind\n";
    598       for (unsigned i = 0, e = FreqPairs.size(); i != e; ++i) {
    599         const PerRecordStats &RecStats = Stats.CodeFreq[FreqPairs[i].second];
    600 
    601         outs() << format("\t\t%7d %9lu",
    602                          RecStats.NumInstances,
    603                          (unsigned long)RecStats.TotalBits);
    604 
    605         if (RecStats.NumAbbrev)
    606           outs() <<
    607               format("%7.2f  ",
    608                      (double)RecStats.NumAbbrev/RecStats.NumInstances*100);
    609         else
    610           outs() << "         ";
    611 
    612         if (const char *CodeName =
    613               GetCodeName(FreqPairs[i].second, I->first, StreamFile))
    614           outs() << CodeName << "\n";
    615         else
    616           outs() << "UnknownCode" << FreqPairs[i].second << "\n";
    617       }
    618       outs() << "\n";
    619 
    620     }
    621   }
    622   return 0;
    623 }
    624 
    625 
    626 int main(int argc, char **argv) {
    627   // Print a stack trace if we signal out.
    628   sys::PrintStackTraceOnErrorSignal();
    629   PrettyStackTraceProgram X(argc, argv);
    630   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
    631   cl::ParseCommandLineOptions(argc, argv, "llvm-bcanalyzer file analyzer\n");
    632 
    633   return AnalyzeBitcode();
    634 }
    635