lib/Bitcode/Reader/BitcodeAnalyzer.cpp

   1 //===- BitcodeAnalyzer.cpp - Internal BitcodeAnalyzer implementation ------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/Bitcode/BitcodeAnalyzer.h"
  10 #include "llvm/Bitcode/BitcodeReader.h"
  11 #include "llvm/Bitcode/LLVMBitCodes.h"
  12 #include "llvm/Bitstream/BitCodes.h"
  13 #include "llvm/Bitstream/BitstreamReader.h"
  14 #include "llvm/Support/Format.h"
  15 #include "llvm/Support/SHA1.h"
  16
  17 using namespace llvm;
  18
  19 static Error reportError(StringRef Message) {
  20   return createStringError(std::errc::illegal_byte_sequence, Message.data());
  21 }
  22
  23 /// Return a symbolic block name if known, otherwise return null.
  24 static Optional<const char *> GetBlockName(unsigned BlockID,
  25                                            const BitstreamBlockInfo &BlockInfo,
  26                                            CurStreamTypeType CurStreamType) {
  27   // Standard blocks for all bitcode files.
  28   if (BlockID < bitc::FIRST_APPLICATION_BLOCKID) {
  29     if (BlockID == bitc::BLOCKINFO_BLOCK_ID)
  30       return "BLOCKINFO_BLOCK";
  31     return None;
  32   }
  33
  34   // Check to see if we have a blockinfo record for this block, with a name.
  35   if (const BitstreamBlockInfo::BlockInfo *Info =
  36           BlockInfo.getBlockInfo(BlockID)) {
  37     if (!Info->Name.empty())
  38       return Info->Name.c_str();
  39   }
  40
  41   if (CurStreamType != LLVMIRBitstream)
  42     return None;
  43
  44   switch (BlockID) {
  45   default:
  46     return None;
  47   case bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID:
  48     return "OPERAND_BUNDLE_TAGS_BLOCK";
  49   case bitc::MODULE_BLOCK_ID:
  50     return "MODULE_BLOCK";
  51   case bitc::PARAMATTR_BLOCK_ID:
  52     return "PARAMATTR_BLOCK";
  53   case bitc::PARAMATTR_GROUP_BLOCK_ID:
  54     return "PARAMATTR_GROUP_BLOCK_ID";
  55   case bitc::TYPE_BLOCK_ID_NEW:
  56     return "TYPE_BLOCK_ID";
  57   case bitc::CONSTANTS_BLOCK_ID:
  58     return "CONSTANTS_BLOCK";
  59   case bitc::FUNCTION_BLOCK_ID:
  60     return "FUNCTION_BLOCK";
  61   case bitc::IDENTIFICATION_BLOCK_ID:
  62     return "IDENTIFICATION_BLOCK_ID";
  63   case bitc::VALUE_SYMTAB_BLOCK_ID:
  64     return "VALUE_SYMTAB";
  65   case bitc::METADATA_BLOCK_ID:
  66     return "METADATA_BLOCK";
  67   case bitc::METADATA_KIND_BLOCK_ID:
  68     return "METADATA_KIND_BLOCK";
  69   case bitc::METADATA_ATTACHMENT_ID:
  70     return "METADATA_ATTACHMENT_BLOCK";
  71   case bitc::USELIST_BLOCK_ID:
  72     return "USELIST_BLOCK_ID";
  73   case bitc::GLOBALVAL_SUMMARY_BLOCK_ID:
  74     return "GLOBALVAL_SUMMARY_BLOCK";
  75   case bitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID:
  76     return "FULL_LTO_GLOBALVAL_SUMMARY_BLOCK";
  77   case bitc::MODULE_STRTAB_BLOCK_ID:
  78     return "MODULE_STRTAB_BLOCK";
  79   case bitc::STRTAB_BLOCK_ID:
  80     return "STRTAB_BLOCK";
  81   case bitc::SYMTAB_BLOCK_ID:
  82     return "SYMTAB_BLOCK";
  83   }
  84 }
  85
  86 /// Return a symbolic code name if known, otherwise return null.
  87 static Optional<const char *> GetCodeName(unsigned CodeID, unsigned BlockID,
  88                                           const BitstreamBlockInfo &BlockInfo,
  89                                           CurStreamTypeType CurStreamType) {
  90   // Standard blocks for all bitcode files.
  91   if (BlockID < bitc::FIRST_APPLICATION_BLOCKID) {
  92     if (BlockID == bitc::BLOCKINFO_BLOCK_ID) {
  93       switch (CodeID) {
  94       default:
  95         return None;
  96       case bitc::BLOCKINFO_CODE_SETBID:
  97         return "SETBID";
  98       case bitc::BLOCKINFO_CODE_BLOCKNAME:
  99         return "BLOCKNAME";
 100       case bitc::BLOCKINFO_CODE_SETRECORDNAME:
 101         return "SETRECORDNAME";
 102       }
 103     }
 104     return None;
 105   }
 106
 107   // Check to see if we have a blockinfo record for this record, with a name.
 108   if (const BitstreamBlockInfo::BlockInfo *Info =
 109           BlockInfo.getBlockInfo(BlockID)) {
 110     for (unsigned i = 0, e = Info->RecordNames.size(); i != e; ++i)
 111       if (Info->RecordNames[i].first == CodeID)
 112         return Info->RecordNames[i].second.c_str();
 113   }
 114
 115   if (CurStreamType != LLVMIRBitstream)
 116     return None;
 117
 118 #define STRINGIFY_CODE(PREFIX, CODE)                                           \
 119   case bitc::PREFIX##_##CODE:                                                  \
 120     return #CODE;
 121   switch (BlockID) {
 122   default:
 123     return None;
 124   case bitc::MODULE_BLOCK_ID:
 125     switch (CodeID) {
 126     default:
 127       return None;
 128       STRINGIFY_CODE(MODULE_CODE, VERSION)
 129       STRINGIFY_CODE(MODULE_CODE, TRIPLE)
 130       STRINGIFY_CODE(MODULE_CODE, DATALAYOUT)
 131       STRINGIFY_CODE(MODULE_CODE, ASM)
 132       STRINGIFY_CODE(MODULE_CODE, SECTIONNAME)
 133       STRINGIFY_CODE(MODULE_CODE, DEPLIB) // FIXME: Remove in 4.0
 134       STRINGIFY_CODE(MODULE_CODE, GLOBALVAR)
 135       STRINGIFY_CODE(MODULE_CODE, FUNCTION)
 136       STRINGIFY_CODE(MODULE_CODE, ALIAS)
 137       STRINGIFY_CODE(MODULE_CODE, GCNAME)
 138       STRINGIFY_CODE(MODULE_CODE, VSTOFFSET)
 139       STRINGIFY_CODE(MODULE_CODE, METADATA_VALUES_UNUSED)
 140       STRINGIFY_CODE(MODULE_CODE, SOURCE_FILENAME)
 141       STRINGIFY_CODE(MODULE_CODE, HASH)
 142     }
 143   case bitc::IDENTIFICATION_BLOCK_ID:
 144     switch (CodeID) {
 145     default:
 146       return None;
 147       STRINGIFY_CODE(IDENTIFICATION_CODE, STRING)
 148       STRINGIFY_CODE(IDENTIFICATION_CODE, EPOCH)
 149     }
 150   case bitc::PARAMATTR_BLOCK_ID:
 151     switch (CodeID) {
 152     default:
 153       return None;
 154     // FIXME: Should these be different?
 155     case bitc::PARAMATTR_CODE_ENTRY_OLD:
 156       return "ENTRY";
 157     case bitc::PARAMATTR_CODE_ENTRY:
 158       return "ENTRY";
 159     }
 160   case bitc::PARAMATTR_GROUP_BLOCK_ID:
 161     switch (CodeID) {
 162     default:
 163       return None;
 164     case bitc::PARAMATTR_GRP_CODE_ENTRY:
 165       return "ENTRY";
 166     }
 167   case bitc::TYPE_BLOCK_ID_NEW:
 168     switch (CodeID) {
 169     default:
 170       return None;
 171       STRINGIFY_CODE(TYPE_CODE, NUMENTRY)
 172       STRINGIFY_CODE(TYPE_CODE, VOID)
 173       STRINGIFY_CODE(TYPE_CODE, FLOAT)
 174       STRINGIFY_CODE(TYPE_CODE, DOUBLE)
 175       STRINGIFY_CODE(TYPE_CODE, LABEL)
 176       STRINGIFY_CODE(TYPE_CODE, OPAQUE)
 177       STRINGIFY_CODE(TYPE_CODE, INTEGER)
 178       STRINGIFY_CODE(TYPE_CODE, POINTER)
 179       STRINGIFY_CODE(TYPE_CODE, ARRAY)
 180       STRINGIFY_CODE(TYPE_CODE, VECTOR)
 181       STRINGIFY_CODE(TYPE_CODE, X86_FP80)
 182       STRINGIFY_CODE(TYPE_CODE, FP128)
 183       STRINGIFY_CODE(TYPE_CODE, PPC_FP128)
 184       STRINGIFY_CODE(TYPE_CODE, METADATA)
 185       STRINGIFY_CODE(TYPE_CODE, STRUCT_ANON)
 186       STRINGIFY_CODE(TYPE_CODE, STRUCT_NAME)
 187       STRINGIFY_CODE(TYPE_CODE, STRUCT_NAMED)
 188       STRINGIFY_CODE(TYPE_CODE, FUNCTION)
 189     }
 190
 191   case bitc::CONSTANTS_BLOCK_ID:
 192     switch (CodeID) {
 193     default:
 194       return None;
 195       STRINGIFY_CODE(CST_CODE, SETTYPE)
 196       STRINGIFY_CODE(CST_CODE, NULL)
 197       STRINGIFY_CODE(CST_CODE, UNDEF)
 198       STRINGIFY_CODE(CST_CODE, INTEGER)
 199       STRINGIFY_CODE(CST_CODE, WIDE_INTEGER)
 200       STRINGIFY_CODE(CST_CODE, FLOAT)
 201       STRINGIFY_CODE(CST_CODE, AGGREGATE)
 202       STRINGIFY_CODE(CST_CODE, STRING)
 203       STRINGIFY_CODE(CST_CODE, CSTRING)
 204       STRINGIFY_CODE(CST_CODE, CE_BINOP)
 205       STRINGIFY_CODE(CST_CODE, CE_CAST)
 206       STRINGIFY_CODE(CST_CODE, CE_GEP)
 207       STRINGIFY_CODE(CST_CODE, CE_INBOUNDS_GEP)
 208       STRINGIFY_CODE(CST_CODE, CE_SELECT)
 209       STRINGIFY_CODE(CST_CODE, CE_EXTRACTELT)
 210       STRINGIFY_CODE(CST_CODE, CE_INSERTELT)
 211       STRINGIFY_CODE(CST_CODE, CE_SHUFFLEVEC)
 212       STRINGIFY_CODE(CST_CODE, CE_CMP)
 213       STRINGIFY_CODE(CST_CODE, INLINEASM)
 214       STRINGIFY_CODE(CST_CODE, CE_SHUFVEC_EX)
 215       STRINGIFY_CODE(CST_CODE, CE_UNOP)
 216     case bitc::CST_CODE_BLOCKADDRESS:
 217       return "CST_CODE_BLOCKADDRESS";
 218       STRINGIFY_CODE(CST_CODE, DATA)
 219     }
 220   case bitc::FUNCTION_BLOCK_ID:
 221     switch (CodeID) {
 222     default:
 223       return None;
 224       STRINGIFY_CODE(FUNC_CODE, DECLAREBLOCKS)
 225       STRINGIFY_CODE(FUNC_CODE, INST_BINOP)
 226       STRINGIFY_CODE(FUNC_CODE, INST_CAST)
 227       STRINGIFY_CODE(FUNC_CODE, INST_GEP_OLD)
 228       STRINGIFY_CODE(FUNC_CODE, INST_INBOUNDS_GEP_OLD)
 229       STRINGIFY_CODE(FUNC_CODE, INST_SELECT)
 230       STRINGIFY_CODE(FUNC_CODE, INST_EXTRACTELT)
 231       STRINGIFY_CODE(FUNC_CODE, INST_INSERTELT)
 232       STRINGIFY_CODE(FUNC_CODE, INST_SHUFFLEVEC)
 233       STRINGIFY_CODE(FUNC_CODE, INST_CMP)
 234       STRINGIFY_CODE(FUNC_CODE, INST_RET)
 235       STRINGIFY_CODE(FUNC_CODE, INST_BR)
 236       STRINGIFY_CODE(FUNC_CODE, INST_SWITCH)
 237       STRINGIFY_CODE(FUNC_CODE, INST_INVOKE)
 238       STRINGIFY_CODE(FUNC_CODE, INST_UNOP)
 239       STRINGIFY_CODE(FUNC_CODE, INST_UNREACHABLE)
 240       STRINGIFY_CODE(FUNC_CODE, INST_CLEANUPRET)
 241       STRINGIFY_CODE(FUNC_CODE, INST_CATCHRET)
 242       STRINGIFY_CODE(FUNC_CODE, INST_CATCHPAD)
 243       STRINGIFY_CODE(FUNC_CODE, INST_PHI)
 244       STRINGIFY_CODE(FUNC_CODE, INST_ALLOCA)
 245       STRINGIFY_CODE(FUNC_CODE, INST_LOAD)
 246       STRINGIFY_CODE(FUNC_CODE, INST_VAARG)
 247       STRINGIFY_CODE(FUNC_CODE, INST_STORE)
 248       STRINGIFY_CODE(FUNC_CODE, INST_EXTRACTVAL)
 249       STRINGIFY_CODE(FUNC_CODE, INST_INSERTVAL)
 250       STRINGIFY_CODE(FUNC_CODE, INST_CMP2)
 251       STRINGIFY_CODE(FUNC_CODE, INST_VSELECT)
 252       STRINGIFY_CODE(FUNC_CODE, DEBUG_LOC_AGAIN)
 253       STRINGIFY_CODE(FUNC_CODE, INST_CALL)
 254       STRINGIFY_CODE(FUNC_CODE, DEBUG_LOC)
 255       STRINGIFY_CODE(FUNC_CODE, INST_GEP)
 256       STRINGIFY_CODE(FUNC_CODE, OPERAND_BUNDLE)
 257       STRINGIFY_CODE(FUNC_CODE, INST_FENCE)
 258       STRINGIFY_CODE(FUNC_CODE, INST_ATOMICRMW)
 259       STRINGIFY_CODE(FUNC_CODE, INST_LOADATOMIC)
 260       STRINGIFY_CODE(FUNC_CODE, INST_STOREATOMIC)
 261       STRINGIFY_CODE(FUNC_CODE, INST_CMPXCHG)
 262       STRINGIFY_CODE(FUNC_CODE, INST_CALLBR)
 263     }
 264   case bitc::VALUE_SYMTAB_BLOCK_ID:
 265     switch (CodeID) {
 266     default:
 267       return None;
 268       STRINGIFY_CODE(VST_CODE, ENTRY)
 269       STRINGIFY_CODE(VST_CODE, BBENTRY)
 270       STRINGIFY_CODE(VST_CODE, FNENTRY)
 271       STRINGIFY_CODE(VST_CODE, COMBINED_ENTRY)
 272     }
 273   case bitc::MODULE_STRTAB_BLOCK_ID:
 274     switch (CodeID) {
 275     default:
 276       return None;
 277       STRINGIFY_CODE(MST_CODE, ENTRY)
 278       STRINGIFY_CODE(MST_CODE, HASH)
 279     }
 280   case bitc::GLOBALVAL_SUMMARY_BLOCK_ID:
 281   case bitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID:
 282     switch (CodeID) {
 283     default:
 284       return None;
 285       STRINGIFY_CODE(FS, PERMODULE)
 286       STRINGIFY_CODE(FS, PERMODULE_PROFILE)
 287       STRINGIFY_CODE(FS, PERMODULE_RELBF)
 288       STRINGIFY_CODE(FS, PERMODULE_GLOBALVAR_INIT_REFS)
 289       STRINGIFY_CODE(FS, PERMODULE_VTABLE_GLOBALVAR_INIT_REFS)
 290       STRINGIFY_CODE(FS, COMBINED)
 291       STRINGIFY_CODE(FS, COMBINED_PROFILE)
 292       STRINGIFY_CODE(FS, COMBINED_GLOBALVAR_INIT_REFS)
 293       STRINGIFY_CODE(FS, ALIAS)
 294       STRINGIFY_CODE(FS, COMBINED_ALIAS)
 295       STRINGIFY_CODE(FS, COMBINED_ORIGINAL_NAME)
 296       STRINGIFY_CODE(FS, VERSION)
 297       STRINGIFY_CODE(FS, FLAGS)
 298       STRINGIFY_CODE(FS, TYPE_TESTS)
 299       STRINGIFY_CODE(FS, TYPE_TEST_ASSUME_VCALLS)
 300       STRINGIFY_CODE(FS, TYPE_CHECKED_LOAD_VCALLS)
 301       STRINGIFY_CODE(FS, TYPE_TEST_ASSUME_CONST_VCALL)
 302       STRINGIFY_CODE(FS, TYPE_CHECKED_LOAD_CONST_VCALL)
 303       STRINGIFY_CODE(FS, VALUE_GUID)
 304       STRINGIFY_CODE(FS, CFI_FUNCTION_DEFS)
 305       STRINGIFY_CODE(FS, CFI_FUNCTION_DECLS)
 306       STRINGIFY_CODE(FS, TYPE_ID)
 307       STRINGIFY_CODE(FS, TYPE_ID_METADATA)
 308     }
 309   case bitc::METADATA_ATTACHMENT_ID:
 310     switch (CodeID) {
 311     default:
 312       return None;
 313       STRINGIFY_CODE(METADATA, ATTACHMENT)
 314     }
 315   case bitc::METADATA_BLOCK_ID:
 316     switch (CodeID) {
 317     default:
 318       return None;
 319       STRINGIFY_CODE(METADATA, STRING_OLD)
 320       STRINGIFY_CODE(METADATA, VALUE)
 321       STRINGIFY_CODE(METADATA, NODE)
 322       STRINGIFY_CODE(METADATA, NAME)
 323       STRINGIFY_CODE(METADATA, DISTINCT_NODE)
 324       STRINGIFY_CODE(METADATA, KIND) // Older bitcode has it in a MODULE_BLOCK
 325       STRINGIFY_CODE(METADATA, LOCATION)
 326       STRINGIFY_CODE(METADATA, OLD_NODE)
 327       STRINGIFY_CODE(METADATA, OLD_FN_NODE)
 328       STRINGIFY_CODE(METADATA, NAMED_NODE)
 329       STRINGIFY_CODE(METADATA, GENERIC_DEBUG)
 330       STRINGIFY_CODE(METADATA, SUBRANGE)
 331       STRINGIFY_CODE(METADATA, ENUMERATOR)
 332       STRINGIFY_CODE(METADATA, BASIC_TYPE)
 333       STRINGIFY_CODE(METADATA, FILE)
 334       STRINGIFY_CODE(METADATA, DERIVED_TYPE)
 335       STRINGIFY_CODE(METADATA, COMPOSITE_TYPE)
 336       STRINGIFY_CODE(METADATA, SUBROUTINE_TYPE)
 337       STRINGIFY_CODE(METADATA, COMPILE_UNIT)
 338       STRINGIFY_CODE(METADATA, SUBPROGRAM)
 339       STRINGIFY_CODE(METADATA, LEXICAL_BLOCK)
 340       STRINGIFY_CODE(METADATA, LEXICAL_BLOCK_FILE)
 341       STRINGIFY_CODE(METADATA, NAMESPACE)
 342       STRINGIFY_CODE(METADATA, TEMPLATE_TYPE)
 343       STRINGIFY_CODE(METADATA, TEMPLATE_VALUE)
 344       STRINGIFY_CODE(METADATA, GLOBAL_VAR)
 345       STRINGIFY_CODE(METADATA, LOCAL_VAR)
 346       STRINGIFY_CODE(METADATA, EXPRESSION)
 347       STRINGIFY_CODE(METADATA, OBJC_PROPERTY)
 348       STRINGIFY_CODE(METADATA, IMPORTED_ENTITY)
 349       STRINGIFY_CODE(METADATA, MODULE)
 350       STRINGIFY_CODE(METADATA, MACRO)
 351       STRINGIFY_CODE(METADATA, MACRO_FILE)
 352       STRINGIFY_CODE(METADATA, STRINGS)
 353       STRINGIFY_CODE(METADATA, GLOBAL_DECL_ATTACHMENT)
 354       STRINGIFY_CODE(METADATA, GLOBAL_VAR_EXPR)
 355       STRINGIFY_CODE(METADATA, INDEX_OFFSET)
 356       STRINGIFY_CODE(METADATA, INDEX)
 357     }
 358   case bitc::METADATA_KIND_BLOCK_ID:
 359     switch (CodeID) {
 360     default:
 361       return None;
 362       STRINGIFY_CODE(METADATA, KIND)
 363     }
 364   case bitc::USELIST_BLOCK_ID:
 365     switch (CodeID) {
 366     default:
 367       return None;
 368     case bitc::USELIST_CODE_DEFAULT:
 369       return "USELIST_CODE_DEFAULT";
 370     case bitc::USELIST_CODE_BB:
 371       return "USELIST_CODE_BB";
 372     }
 373
 374   case bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID:
 375     switch (CodeID) {
 376     default:
 377       return None;
 378     case bitc::OPERAND_BUNDLE_TAG:
 379       return "OPERAND_BUNDLE_TAG";
 380     }
 381   case bitc::STRTAB_BLOCK_ID:
 382     switch (CodeID) {
 383     default:
 384       return None;
 385     case bitc::STRTAB_BLOB:
 386       return "BLOB";
 387     }
 388   case bitc::SYMTAB_BLOCK_ID:
 389     switch (CodeID) {
 390     default:
 391       return None;
 392     case bitc::SYMTAB_BLOB:
 393       return "BLOB";
 394     }
 395   }
 396 #undef STRINGIFY_CODE
 397 }
 398
 399 static void printSize(raw_ostream &OS, double Bits) {
 400   OS << format("%.2f/%.2fB/%luW", Bits, Bits / 8, (unsigned long)(Bits / 32));
 401 }
 402 static void printSize(raw_ostream &OS, uint64_t Bits) {
 403   OS << format("%lub/%.2fB/%luW", (unsigned long)Bits, (double)Bits / 8,
 404                (unsigned long)(Bits / 32));
 405 }
 406
 407 static Expected<CurStreamTypeType> ReadSignature(BitstreamCursor &Stream) {
 408   auto tryRead = [&Stream](char &Dest, size_t size) -> Error {
 409     if (Expected<SimpleBitstreamCursor::word_t> MaybeWord = Stream.Read(size))
 410       Dest = MaybeWord.get();
 411     else
 412       return MaybeWord.takeError();
 413     return Error::success();
 414   };
 415
 416   char Signature[6];
 417   if (Error Err = tryRead(Signature[0], 8))
 418     return std::move(Err);
 419   if (Error Err = tryRead(Signature[1], 8))
 420     return std::move(Err);
 421
 422   // Autodetect the file contents, if it is one we know.
 423   if (Signature[0] == 'C' && Signature[1] == 'P') {
 424     if (Error Err = tryRead(Signature[2], 8))
 425       return std::move(Err);
 426     if (Error Err = tryRead(Signature[3], 8))
 427       return std::move(Err);
 428     if (Signature[2] == 'C' && Signature[3] == 'H')
 429       return ClangSerializedASTBitstream;
 430   } else if (Signature[0] == 'D' && Signature[1] == 'I') {
 431     if (Error Err = tryRead(Signature[2], 8))
 432       return std::move(Err);
 433     if (Error Err = tryRead(Signature[3], 8))
 434       return std::move(Err);
 435     if (Signature[2] == 'A' && Signature[3] == 'G')
 436       return ClangSerializedDiagnosticsBitstream;
 437   } else if (Signature[0] == 'R' && Signature[1] == 'M') {
 438     if (Error Err = tryRead(Signature[2], 8))
 439       return std::move(Err);
 440     if (Error Err = tryRead(Signature[3], 8))
 441       return std::move(Err);
 442     if (Signature[2] == 'R' && Signature[3] == 'K')
 443       return LLVMBitstreamRemarks;
 444   } else {
 445     if (Error Err = tryRead(Signature[2], 4))
 446       return std::move(Err);
 447     if (Error Err = tryRead(Signature[3], 4))
 448       return std::move(Err);
 449     if (Error Err = tryRead(Signature[4], 4))
 450       return std::move(Err);
 451     if (Error Err = tryRead(Signature[5], 4))
 452       return std::move(Err);
 453     if (Signature[0] == 'B' && Signature[1] == 'C' && Signature[2] == 0x0 &&
 454         Signature[3] == 0xC && Signature[4] == 0xE && Signature[5] == 0xD)
 455       return LLVMIRBitstream;
 456   }
 457   return UnknownBitstream;
 458 }
 459
 460 static Expected<CurStreamTypeType> analyzeHeader(Optional<BCDumpOptions> O,
 461                                                  BitstreamCursor &Stream) {
 462   ArrayRef<uint8_t> Bytes = Stream.getBitcodeBytes();
 463   const unsigned char *BufPtr = (const unsigned char *)Bytes.data();
 464   const unsigned char *EndBufPtr = BufPtr + Bytes.size();
 465
 466   // If we have a wrapper header, parse it and ignore the non-bc file
 467   // contents. The magic number is 0x0B17C0DE stored in little endian.
 468   if (isBitcodeWrapper(BufPtr, EndBufPtr)) {
 469     if (Bytes.size() < BWH_HeaderSize)
 470       return reportError("Invalid bitcode wrapper header");
 471
 472     if (O) {
 473       unsigned Magic = support::endian::read32le(&BufPtr[BWH_MagicField]);
 474       unsigned Version = support::endian::read32le(&BufPtr[BWH_VersionField]);
 475       unsigned Offset = support::endian::read32le(&BufPtr[BWH_OffsetField]);
 476       unsigned Size = support::endian::read32le(&BufPtr[BWH_SizeField]);
 477       unsigned CPUType = support::endian::read32le(&BufPtr[BWH_CPUTypeField]);
 478
 479       O->OS << "<BITCODE_WRAPPER_HEADER"
 480             << " Magic=" << format_hex(Magic, 10)
 481             << " Version=" << format_hex(Version, 10)
 482             << " Offset=" << format_hex(Offset, 10)
 483             << " Size=" << format_hex(Size, 10)
 484             << " CPUType=" << format_hex(CPUType, 10) << "/>\n";
 485     }
 486
 487     if (SkipBitcodeWrapperHeader(BufPtr, EndBufPtr, true))
 488       return reportError("Invalid bitcode wrapper header");
 489   }
 490
 491   // Use the cursor modified by skipping the wrapper header.
 492   Stream = BitstreamCursor(ArrayRef<uint8_t>(BufPtr, EndBufPtr));
 493
 494   return ReadSignature(Stream);
 495 }
 496
 497 static bool canDecodeBlob(unsigned Code, unsigned BlockID) {
 498   return BlockID == bitc::METADATA_BLOCK_ID && Code == bitc::METADATA_STRINGS;
 499 }
 500
 501 Error BitcodeAnalyzer::decodeMetadataStringsBlob(StringRef Indent,
 502                                                  ArrayRef<uint64_t> Record,
 503                                                  StringRef Blob,
 504                                                  raw_ostream &OS) {
 505   if (Blob.empty())
 506     return reportError("Cannot decode empty blob.");
 507
 508   if (Record.size() != 2)
 509     return reportError(
 510         "Decoding metadata strings blob needs two record entries.");
 511
 512   unsigned NumStrings = Record[0];
 513   unsigned StringsOffset = Record[1];
 514   OS << " num-strings = " << NumStrings << " {\n";
 515
 516   StringRef Lengths = Blob.slice(0, StringsOffset);
 517   SimpleBitstreamCursor R(Lengths);
 518   StringRef Strings = Blob.drop_front(StringsOffset);
 519   do {
 520     if (R.AtEndOfStream())
 521       return reportError("bad length");
 522
 523     Expected<uint32_t> MaybeSize = R.ReadVBR(6);
 524     if (!MaybeSize)
 525       return MaybeSize.takeError();
 526     uint32_t Size = MaybeSize.get();
 527     if (Strings.size() < Size)
 528       return reportError("truncated chars");
 529
 530     OS << Indent << "    '";
 531     OS.write_escaped(Strings.slice(0, Size), /*hex=*/true);
 532     OS << "'\n";
 533     Strings = Strings.drop_front(Size);
 534   } while (--NumStrings);
 535
 536   OS << Indent << "  }";
 537   return Error::success();
 538 }
 539
 540 BitcodeAnalyzer::BitcodeAnalyzer(StringRef Buffer,
 541                                  Optional<StringRef> BlockInfoBuffer)
 542     : Stream(Buffer) {
 543   if (BlockInfoBuffer)
 544     BlockInfoStream.emplace(*BlockInfoBuffer);
 545 }
 546
 547 Error BitcodeAnalyzer::analyze(Optional<BCDumpOptions> O,
 548                                Optional<StringRef> CheckHash) {
 549   Expected<CurStreamTypeType> MaybeType = analyzeHeader(O, Stream);
 550   if (!MaybeType)
 551     return MaybeType.takeError();
 552   else
 553     CurStreamType = *MaybeType;
 554
 555   Stream.setBlockInfo(&BlockInfo);
 556
 557   // Read block info from BlockInfoStream, if specified.
 558   // The block info must be a top-level block.
 559   if (BlockInfoStream) {
 560     BitstreamCursor BlockInfoCursor(*BlockInfoStream);
 561     Expected<CurStreamTypeType> H = analyzeHeader(O, BlockInfoCursor);
 562     if (!H)
 563       return H.takeError();
 564
 565     while (!BlockInfoCursor.AtEndOfStream()) {
 566       Expected<unsigned> MaybeCode = BlockInfoCursor.ReadCode();
 567       if (!MaybeCode)
 568         return MaybeCode.takeError();
 569       if (MaybeCode.get() != bitc::ENTER_SUBBLOCK)
 570         return reportError("Invalid record at top-level in block info file");
 571
 572       Expected<unsigned> MaybeBlockID = BlockInfoCursor.ReadSubBlockID();
 573       if (!MaybeBlockID)
 574         return MaybeBlockID.takeError();
 575       if (MaybeBlockID.get() == bitc::BLOCKINFO_BLOCK_ID) {
 576         Expected<Optional<BitstreamBlockInfo>> MaybeNewBlockInfo =
 577             BlockInfoCursor.ReadBlockInfoBlock(/*ReadBlockInfoNames=*/true);
 578         if (!MaybeNewBlockInfo)
 579           return MaybeNewBlockInfo.takeError();
 580         Optional<BitstreamBlockInfo> NewBlockInfo =
 581             std::move(MaybeNewBlockInfo.get());
 582         if (!NewBlockInfo)
 583           return reportError("Malformed BlockInfoBlock in block info file");
 584         BlockInfo = std::move(*NewBlockInfo);
 585         break;
 586       }
 587
 588       if (Error Err = BlockInfoCursor.SkipBlock())
 589         return Err;
 590     }
 591   }
 592
 593   // Parse the top-level structure.  We only allow blocks at the top-level.
 594   while (!Stream.AtEndOfStream()) {
 595     Expected<unsigned> MaybeCode = Stream.ReadCode();
 596     if (!MaybeCode)
 597       return MaybeCode.takeError();
 598     if (MaybeCode.get() != bitc::ENTER_SUBBLOCK)
 599       return reportError("Invalid record at top-level");
 600
 601     Expected<unsigned> MaybeBlockID = Stream.ReadSubBlockID();
 602     if (!MaybeBlockID)
 603       return MaybeBlockID.takeError();
 604
 605     if (Error E = parseBlock(MaybeBlockID.get(), 0, O, CheckHash))
 606       return E;
 607     ++NumTopBlocks;
 608   }
 609
 610   return Error::success();
 611 }
 612
 613 void BitcodeAnalyzer::printStats(BCDumpOptions O,
 614                                  Optional<StringRef> Filename) {
 615   uint64_t BufferSizeBits = Stream.getBitcodeBytes().size() * CHAR_BIT;
 616   // Print a summary of the read file.
 617   O.OS << "Summary ";
 618   if (Filename)
 619     O.OS << "of " << Filename->data() << ":\n";
 620   O.OS << "         Total size: ";
 621   printSize(O.OS, BufferSizeBits);
 622   O.OS << "\n";
 623   O.OS << "        Stream type: ";
 624   switch (CurStreamType) {
 625   case UnknownBitstream:
 626     O.OS << "unknown\n";
 627     break;
 628   case LLVMIRBitstream:
 629     O.OS << "LLVM IR\n";
 630     break;
 631   case ClangSerializedASTBitstream:
 632     O.OS << "Clang Serialized AST\n";
 633     break;
 634   case ClangSerializedDiagnosticsBitstream:
 635     O.OS << "Clang Serialized Diagnostics\n";
 636     break;
 637   case LLVMBitstreamRemarks:
 638     O.OS << "LLVM Remarks\n";
 639     break;
 640   }
 641   O.OS << "  # Toplevel Blocks: " << NumTopBlocks << "\n";
 642   O.OS << "\n";
 643
 644   // Emit per-block stats.
 645   O.OS << "Per-block Summary:\n";
 646   for (std::map<unsigned, PerBlockIDStats>::iterator I = BlockIDStats.begin(),
 647                                                      E = BlockIDStats.end();
 648        I != E; ++I) {
 649     O.OS << "  Block ID #" << I->first;
 650     if (Optional<const char *> BlockName =
 651             GetBlockName(I->first, BlockInfo, CurStreamType))
 652       O.OS << " (" << *BlockName << ")";
 653     O.OS << ":\n";
 654
 655     const PerBlockIDStats &Stats = I->second;
 656     O.OS << "      Num Instances: " << Stats.NumInstances << "\n";
 657     O.OS << "         Total Size: ";
 658     printSize(O.OS, Stats.NumBits);
 659     O.OS << "\n";
 660     double pct = (Stats.NumBits * 100.0) / BufferSizeBits;
 661     O.OS << "    Percent of file: " << format("%2.4f%%", pct) << "\n";
 662     if (Stats.NumInstances > 1) {
 663       O.OS << "       Average Size: ";
 664       printSize(O.OS, Stats.NumBits / (double)Stats.NumInstances);
 665       O.OS << "\n";
 666       O.OS << "  Tot/Avg SubBlocks: " << Stats.NumSubBlocks << "/"
 667            << Stats.NumSubBlocks / (double)Stats.NumInstances << "\n";
 668       O.OS << "    Tot/Avg Abbrevs: " << Stats.NumAbbrevs << "/"
 669            << Stats.NumAbbrevs / (double)Stats.NumInstances << "\n";
 670       O.OS << "    Tot/Avg Records: " << Stats.NumRecords << "/"
 671            << Stats.NumRecords / (double)Stats.NumInstances << "\n";
 672     } else {
 673       O.OS << "      Num SubBlocks: " << Stats.NumSubBlocks << "\n";
 674       O.OS << "        Num Abbrevs: " << Stats.NumAbbrevs << "\n";
 675       O.OS << "        Num Records: " << Stats.NumRecords << "\n";
 676     }
 677     if (Stats.NumRecords) {
 678       double pct = (Stats.NumAbbreviatedRecords * 100.0) / Stats.NumRecords;
 679       O.OS << "    Percent Abbrevs: " << format("%2.4f%%", pct) << "\n";
 680     }
 681     O.OS << "\n";
 682
 683     // Print a histogram of the codes we see.
 684     if (O.Histogram && !Stats.CodeFreq.empty()) {
 685       std::vector<std::pair<unsigned, unsigned>> FreqPairs; // <freq,code>
 686       for (unsigned i = 0, e = Stats.CodeFreq.size(); i != e; ++i)
 687         if (unsigned Freq = Stats.CodeFreq[i].NumInstances)
 688           FreqPairs.push_back(std::make_pair(Freq, i));
 689       llvm::stable_sort(FreqPairs);
 690       std::reverse(FreqPairs.begin(), FreqPairs.end());
 691
 692       O.OS << "\tRecord Histogram:\n";
 693       O.OS << "\t\t  Count    # Bits     b/Rec   % Abv  Record Kind\n";
 694       for (unsigned i = 0, e = FreqPairs.size(); i != e; ++i) {
 695         const PerRecordStats &RecStats = Stats.CodeFreq[FreqPairs[i].second];
 696
 697         O.OS << format("\t\t%7d %9lu", RecStats.NumInstances,
 698                        (unsigned long)RecStats.TotalBits);
 699
 700         if (RecStats.NumInstances > 1)
 701           O.OS << format(" %9.1f",
 702                          (double)RecStats.TotalBits / RecStats.NumInstances);
 703         else
 704           O.OS << "          ";
 705
 706         if (RecStats.NumAbbrev)
 707           O.OS << format(" %7.2f", (double)RecStats.NumAbbrev /
 708                                        RecStats.NumInstances * 100);
 709         else
 710           O.OS << "        ";
 711
 712         O.OS << "  ";
 713         if (Optional<const char *> CodeName = GetCodeName(
 714                 FreqPairs[i].second, I->first, BlockInfo, CurStreamType))
 715           O.OS << *CodeName << "\n";
 716         else
 717           O.OS << "UnknownCode" << FreqPairs[i].second << "\n";
 718       }
 719       O.OS << "\n";
 720     }
 721   }
 722 }
 723
 724 Error BitcodeAnalyzer::parseBlock(unsigned BlockID, unsigned IndentLevel,
 725                                   Optional<BCDumpOptions> O,
 726                                   Optional<StringRef> CheckHash) {
 727   std::string Indent(IndentLevel * 2, ' ');
 728   uint64_t BlockBitStart = Stream.GetCurrentBitNo();
 729
 730   // Get the statistics for this BlockID.
 731   PerBlockIDStats &BlockStats = BlockIDStats[BlockID];
 732
 733   BlockStats.NumInstances++;
 734
 735   // BLOCKINFO is a special part of the stream.
 736   bool DumpRecords = O.hasValue();
 737   if (BlockID == bitc::BLOCKINFO_BLOCK_ID) {
 738     if (O)
 739       O->OS << Indent << "<BLOCKINFO_BLOCK/>\n";
 740     Expected<Optional<BitstreamBlockInfo>> MaybeNewBlockInfo =
 741         Stream.ReadBlockInfoBlock(/*ReadBlockInfoNames=*/true);
 742     if (!MaybeNewBlockInfo)
 743       return MaybeNewBlockInfo.takeError();
 744     Optional<BitstreamBlockInfo> NewBlockInfo =
 745         std::move(MaybeNewBlockInfo.get());
 746     if (!NewBlockInfo)
 747       return reportError("Malformed BlockInfoBlock");
 748     BlockInfo = std::move(*NewBlockInfo);
 749     if (Error Err = Stream.JumpToBit(BlockBitStart))
 750       return Err;
 751     // It's not really interesting to dump the contents of the blockinfo
 752     // block.
 753     DumpRecords = false;
 754   }
 755
 756   unsigned NumWords = 0;
 757   if (Error Err = Stream.EnterSubBlock(BlockID, &NumWords))
 758     return Err;
 759
 760   // Keep it for later, when we see a MODULE_HASH record
 761   uint64_t BlockEntryPos = Stream.getCurrentByteNo();
 762
 763   Optional<const char *> BlockName = None;
 764   if (DumpRecords) {
 765     O->OS << Indent << "<";
 766     if ((BlockName = GetBlockName(BlockID, BlockInfo, CurStreamType)))
 767       O->OS << *BlockName;
 768     else
 769       O->OS << "UnknownBlock" << BlockID;
 770
 771     if (!O->Symbolic && BlockName)
 772       O->OS << " BlockID=" << BlockID;
 773
 774     O->OS << " NumWords=" << NumWords
 775           << " BlockCodeSize=" << Stream.getAbbrevIDWidth() << ">\n";
 776   }
 777
 778   SmallVector<uint64_t, 64> Record;
 779
 780   // Keep the offset to the metadata index if seen.
 781   uint64_t MetadataIndexOffset = 0;
 782
 783   // Read all the records for this block.
 784   while (1) {
 785     if (Stream.AtEndOfStream())
 786       return reportError("Premature end of bitstream");
 787
 788     uint64_t RecordStartBit = Stream.GetCurrentBitNo();
 789
 790     Expected<BitstreamEntry> MaybeEntry =
 791         Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);
 792     if (!MaybeEntry)
 793       return MaybeEntry.takeError();
 794     BitstreamEntry Entry = MaybeEntry.get();
 795
 796     switch (Entry.Kind) {
 797     case BitstreamEntry::Error:
 798       return reportError("malformed bitcode file");
 799     case BitstreamEntry::EndBlock: {
 800       uint64_t BlockBitEnd = Stream.GetCurrentBitNo();
 801       BlockStats.NumBits += BlockBitEnd - BlockBitStart;
 802       if (DumpRecords) {
 803         O->OS << Indent << "</";
 804         if (BlockName)
 805           O->OS << *BlockName << ">\n";
 806         else
 807           O->OS << "UnknownBlock" << BlockID << ">\n";
 808       }
 809       return Error::success();
 810     }
 811
 812     case BitstreamEntry::SubBlock: {
 813       uint64_t SubBlockBitStart = Stream.GetCurrentBitNo();
 814       if (Error E = parseBlock(Entry.ID, IndentLevel + 1, O, CheckHash))
 815         return E;
 816       ++BlockStats.NumSubBlocks;
 817       uint64_t SubBlockBitEnd = Stream.GetCurrentBitNo();
 818
 819       // Don't include subblock sizes in the size of this block.
 820       BlockBitStart += SubBlockBitEnd - SubBlockBitStart;
 821       continue;
 822     }
 823     case BitstreamEntry::Record:
 824       // The interesting case.
 825       break;
 826     }
 827
 828     if (Entry.ID == bitc::DEFINE_ABBREV) {
 829       if (Error Err = Stream.ReadAbbrevRecord())
 830         return Err;
 831       ++BlockStats.NumAbbrevs;
 832       continue;
 833     }
 834
 835     Record.clear();
 836
 837     ++BlockStats.NumRecords;
 838
 839     StringRef Blob;
 840     uint64_t CurrentRecordPos = Stream.GetCurrentBitNo();
 841     Expected<unsigned> MaybeCode = Stream.readRecord(Entry.ID, Record, &Blob);
 842     if (!MaybeCode)
 843       return MaybeCode.takeError();
 844     unsigned Code = MaybeCode.get();
 845
 846     // Increment the # occurrences of this code.
 847     if (BlockStats.CodeFreq.size() <= Code)
 848       BlockStats.CodeFreq.resize(Code + 1);
 849     BlockStats.CodeFreq[Code].NumInstances++;
 850     BlockStats.CodeFreq[Code].TotalBits +=
 851         Stream.GetCurrentBitNo() - RecordStartBit;
 852     if (Entry.ID != bitc::UNABBREV_RECORD) {
 853       BlockStats.CodeFreq[Code].NumAbbrev++;
 854       ++BlockStats.NumAbbreviatedRecords;
 855     }
 856
 857     if (DumpRecords) {
 858       O->OS << Indent << "  <";
 859       Optional<const char *> CodeName =
 860           GetCodeName(Code, BlockID, BlockInfo, CurStreamType);
 861       if (CodeName)
 862         O->OS << *CodeName;
 863       else
 864         O->OS << "UnknownCode" << Code;
 865       if (!O->Symbolic && CodeName)
 866         O->OS << " codeid=" << Code;
 867       const BitCodeAbbrev *Abbv = nullptr;
 868       if (Entry.ID != bitc::UNABBREV_RECORD) {
 869         Abbv = Stream.getAbbrev(Entry.ID);
 870         O->OS << " abbrevid=" << Entry.ID;
 871       }
 872
 873       for (unsigned i = 0, e = Record.size(); i != e; ++i)
 874         O->OS << " op" << i << "=" << (int64_t)Record[i];
 875
 876       // If we found a metadata index, let's verify that we had an offset
 877       // before and validate its forward reference offset was correct!
 878       if (BlockID == bitc::METADATA_BLOCK_ID) {
 879         if (Code == bitc::METADATA_INDEX_OFFSET) {
 880           if (Record.size() != 2)
 881             O->OS << "(Invalid record)";
 882           else {
 883             auto Offset = Record[0] + (Record[1] << 32);
 884             MetadataIndexOffset = Stream.GetCurrentBitNo() + Offset;
 885           }
 886         }
 887         if (Code == bitc::METADATA_INDEX) {
 888           O->OS << " (offset ";
 889           if (MetadataIndexOffset == RecordStartBit)
 890             O->OS << "match)";
 891           else
 892             O->OS << "mismatch: " << MetadataIndexOffset << " vs "
 893                   << RecordStartBit << ")";
 894         }
 895       }
 896
 897       // If we found a module hash, let's verify that it matches!
 898       if (BlockID == bitc::MODULE_BLOCK_ID && Code == bitc::MODULE_CODE_HASH &&
 899           CheckHash.hasValue()) {
 900         if (Record.size() != 5)
 901           O->OS << " (invalid)";
 902         else {
 903           // Recompute the hash and compare it to the one in the bitcode
 904           SHA1 Hasher;
 905           StringRef Hash;
 906           Hasher.update(*CheckHash);
 907           {
 908             int BlockSize = (CurrentRecordPos / 8) - BlockEntryPos;
 909             auto Ptr = Stream.getPointerToByte(BlockEntryPos, BlockSize);
 910             Hasher.update(ArrayRef<uint8_t>(Ptr, BlockSize));
 911             Hash = Hasher.result();
 912           }
 913           SmallString<20> RecordedHash;
 914           RecordedHash.resize(20);
 915           int Pos = 0;
 916           for (auto &Val : Record) {
 917             assert(!(Val >> 32) && "Unexpected high bits set");
 918             RecordedHash[Pos++] = (Val >> 24) & 0xFF;
 919             RecordedHash[Pos++] = (Val >> 16) & 0xFF;
 920             RecordedHash[Pos++] = (Val >> 8) & 0xFF;
 921             RecordedHash[Pos++] = (Val >> 0) & 0xFF;
 922           }
 923           if (Hash == RecordedHash)
 924             O->OS << " (match)";
 925           else
 926             O->OS << " (!mismatch!)";
 927         }
 928       }
 929
 930       O->OS << "/>";
 931
 932       if (Abbv) {
 933         for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i != e; ++i) {
 934           const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
 935           if (!Op.isEncoding() || Op.getEncoding() != BitCodeAbbrevOp::Array)
 936             continue;
 937           assert(i + 2 == e && "Array op not second to last");
 938           std::string Str;
 939           bool ArrayIsPrintable = true;
 940           for (unsigned j = i - 1, je = Record.size(); j != je; ++j) {
 941             if (!isPrint(static_cast<unsigned char>(Record[j]))) {
 942               ArrayIsPrintable = false;
 943               break;
 944             }
 945             Str += (char)Record[j];
 946           }
 947           if (ArrayIsPrintable)
 948             O->OS << " record string = '" << Str << "'";
 949           break;
 950         }
 951       }
 952
 953       if (Blob.data()) {
 954         if (canDecodeBlob(Code, BlockID)) {
 955           if (Error E = decodeMetadataStringsBlob(Indent, Record, Blob, O->OS))
 956             return E;
 957         } else {
 958           O->OS << " blob data = ";
 959           if (O->ShowBinaryBlobs) {
 960             O->OS << "'";
 961             O->OS.write_escaped(Blob, /*hex=*/true) << "'";
 962           } else {
 963             bool BlobIsPrintable = true;
 964             for (unsigned i = 0, e = Blob.size(); i != e; ++i)
 965               if (!isPrint(static_cast<unsigned char>(Blob[i]))) {
 966                 BlobIsPrintable = false;
 967                 break;
 968               }
 969
 970             if (BlobIsPrintable)
 971               O->OS << "'" << Blob << "'";
 972             else
 973               O->OS << "unprintable, " << Blob.size() << " bytes.";
 974           }
 975         }
 976       }
 977
 978       O->OS << "\n";
 979     }
 980
 981     // Make sure that we can skip the current record.
 982     if (Error Err = Stream.JumpToBit(CurrentRecordPos))
 983       return Err;
 984     if (Expected<unsigned> Skipped = Stream.skipRecord(Entry.ID))
 985       ; // Do nothing.
 986     else
 987       return Skipped.takeError();
 988   }
 989 }
 990