BitcodeAnalyzer.cpp revision 360784
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 17using namespace llvm; 18 19static 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. 24static 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. 87static 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 399static void printSize(raw_ostream &OS, double Bits) { 400 OS << format("%.2f/%.2fB/%luW", Bits, Bits / 8, (unsigned long)(Bits / 32)); 401} 402static 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 407static 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 460static 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 497static bool canDecodeBlob(unsigned Code, unsigned BlockID) { 498 return BlockID == bitc::METADATA_BLOCK_ID && Code == bitc::METADATA_STRINGS; 499} 500 501Error 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 540BitcodeAnalyzer::BitcodeAnalyzer(StringRef Buffer, 541 Optional<StringRef> BlockInfoBuffer) 542 : Stream(Buffer) { 543 if (BlockInfoBuffer) 544 BlockInfoStream.emplace(*BlockInfoBuffer); 545} 546 547Error 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 613void 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 724Error 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 991