1351278Sdim//===- BitcodeAnalyzer.cpp - Internal BitcodeAnalyzer implementation ------===// 2351278Sdim// 3351278Sdim// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4351278Sdim// See https://llvm.org/LICENSE.txt for license information. 5351278Sdim// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6351278Sdim// 7351278Sdim//===----------------------------------------------------------------------===// 8351278Sdim 9351278Sdim#include "llvm/Bitcode/BitcodeAnalyzer.h" 10351278Sdim#include "llvm/Bitcode/BitcodeReader.h" 11351278Sdim#include "llvm/Bitcode/LLVMBitCodes.h" 12351278Sdim#include "llvm/Bitstream/BitCodes.h" 13351278Sdim#include "llvm/Bitstream/BitstreamReader.h" 14351278Sdim#include "llvm/Support/Format.h" 15351278Sdim#include "llvm/Support/SHA1.h" 16351278Sdim 17351278Sdimusing namespace llvm; 18351278Sdim 19351278Sdimstatic Error reportError(StringRef Message) { 20351278Sdim return createStringError(std::errc::illegal_byte_sequence, Message.data()); 21351278Sdim} 22351278Sdim 23351278Sdim/// Return a symbolic block name if known, otherwise return null. 24351278Sdimstatic Optional<const char *> GetBlockName(unsigned BlockID, 25351278Sdim const BitstreamBlockInfo &BlockInfo, 26351278Sdim CurStreamTypeType CurStreamType) { 27351278Sdim // Standard blocks for all bitcode files. 28351278Sdim if (BlockID < bitc::FIRST_APPLICATION_BLOCKID) { 29351278Sdim if (BlockID == bitc::BLOCKINFO_BLOCK_ID) 30351278Sdim return "BLOCKINFO_BLOCK"; 31351278Sdim return None; 32351278Sdim } 33351278Sdim 34351278Sdim // Check to see if we have a blockinfo record for this block, with a name. 35351278Sdim if (const BitstreamBlockInfo::BlockInfo *Info = 36351278Sdim BlockInfo.getBlockInfo(BlockID)) { 37351278Sdim if (!Info->Name.empty()) 38351278Sdim return Info->Name.c_str(); 39351278Sdim } 40351278Sdim 41351278Sdim if (CurStreamType != LLVMIRBitstream) 42351278Sdim return None; 43351278Sdim 44351278Sdim switch (BlockID) { 45351278Sdim default: 46351278Sdim return None; 47351278Sdim case bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID: 48351278Sdim return "OPERAND_BUNDLE_TAGS_BLOCK"; 49351278Sdim case bitc::MODULE_BLOCK_ID: 50351278Sdim return "MODULE_BLOCK"; 51351278Sdim case bitc::PARAMATTR_BLOCK_ID: 52351278Sdim return "PARAMATTR_BLOCK"; 53351278Sdim case bitc::PARAMATTR_GROUP_BLOCK_ID: 54351278Sdim return "PARAMATTR_GROUP_BLOCK_ID"; 55351278Sdim case bitc::TYPE_BLOCK_ID_NEW: 56351278Sdim return "TYPE_BLOCK_ID"; 57351278Sdim case bitc::CONSTANTS_BLOCK_ID: 58351278Sdim return "CONSTANTS_BLOCK"; 59351278Sdim case bitc::FUNCTION_BLOCK_ID: 60351278Sdim return "FUNCTION_BLOCK"; 61351278Sdim case bitc::IDENTIFICATION_BLOCK_ID: 62351278Sdim return "IDENTIFICATION_BLOCK_ID"; 63351278Sdim case bitc::VALUE_SYMTAB_BLOCK_ID: 64351278Sdim return "VALUE_SYMTAB"; 65351278Sdim case bitc::METADATA_BLOCK_ID: 66351278Sdim return "METADATA_BLOCK"; 67351278Sdim case bitc::METADATA_KIND_BLOCK_ID: 68351278Sdim return "METADATA_KIND_BLOCK"; 69351278Sdim case bitc::METADATA_ATTACHMENT_ID: 70351278Sdim return "METADATA_ATTACHMENT_BLOCK"; 71351278Sdim case bitc::USELIST_BLOCK_ID: 72351278Sdim return "USELIST_BLOCK_ID"; 73351278Sdim case bitc::GLOBALVAL_SUMMARY_BLOCK_ID: 74351278Sdim return "GLOBALVAL_SUMMARY_BLOCK"; 75351278Sdim case bitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID: 76351278Sdim return "FULL_LTO_GLOBALVAL_SUMMARY_BLOCK"; 77351278Sdim case bitc::MODULE_STRTAB_BLOCK_ID: 78351278Sdim return "MODULE_STRTAB_BLOCK"; 79351278Sdim case bitc::STRTAB_BLOCK_ID: 80351278Sdim return "STRTAB_BLOCK"; 81351278Sdim case bitc::SYMTAB_BLOCK_ID: 82351278Sdim return "SYMTAB_BLOCK"; 83351278Sdim } 84351278Sdim} 85351278Sdim 86351278Sdim/// Return a symbolic code name if known, otherwise return null. 87351278Sdimstatic Optional<const char *> GetCodeName(unsigned CodeID, unsigned BlockID, 88351278Sdim const BitstreamBlockInfo &BlockInfo, 89351278Sdim CurStreamTypeType CurStreamType) { 90351278Sdim // Standard blocks for all bitcode files. 91351278Sdim if (BlockID < bitc::FIRST_APPLICATION_BLOCKID) { 92351278Sdim if (BlockID == bitc::BLOCKINFO_BLOCK_ID) { 93351278Sdim switch (CodeID) { 94351278Sdim default: 95351278Sdim return None; 96351278Sdim case bitc::BLOCKINFO_CODE_SETBID: 97351278Sdim return "SETBID"; 98351278Sdim case bitc::BLOCKINFO_CODE_BLOCKNAME: 99351278Sdim return "BLOCKNAME"; 100351278Sdim case bitc::BLOCKINFO_CODE_SETRECORDNAME: 101351278Sdim return "SETRECORDNAME"; 102351278Sdim } 103351278Sdim } 104351278Sdim return None; 105351278Sdim } 106351278Sdim 107351278Sdim // Check to see if we have a blockinfo record for this record, with a name. 108351278Sdim if (const BitstreamBlockInfo::BlockInfo *Info = 109351278Sdim BlockInfo.getBlockInfo(BlockID)) { 110351278Sdim for (unsigned i = 0, e = Info->RecordNames.size(); i != e; ++i) 111351278Sdim if (Info->RecordNames[i].first == CodeID) 112351278Sdim return Info->RecordNames[i].second.c_str(); 113351278Sdim } 114351278Sdim 115351278Sdim if (CurStreamType != LLVMIRBitstream) 116351278Sdim return None; 117351278Sdim 118351278Sdim#define STRINGIFY_CODE(PREFIX, CODE) \ 119351278Sdim case bitc::PREFIX##_##CODE: \ 120351278Sdim return #CODE; 121351278Sdim switch (BlockID) { 122351278Sdim default: 123351278Sdim return None; 124351278Sdim case bitc::MODULE_BLOCK_ID: 125351278Sdim switch (CodeID) { 126351278Sdim default: 127351278Sdim return None; 128351278Sdim STRINGIFY_CODE(MODULE_CODE, VERSION) 129351278Sdim STRINGIFY_CODE(MODULE_CODE, TRIPLE) 130351278Sdim STRINGIFY_CODE(MODULE_CODE, DATALAYOUT) 131351278Sdim STRINGIFY_CODE(MODULE_CODE, ASM) 132351278Sdim STRINGIFY_CODE(MODULE_CODE, SECTIONNAME) 133351278Sdim STRINGIFY_CODE(MODULE_CODE, DEPLIB) // FIXME: Remove in 4.0 134351278Sdim STRINGIFY_CODE(MODULE_CODE, GLOBALVAR) 135351278Sdim STRINGIFY_CODE(MODULE_CODE, FUNCTION) 136351278Sdim STRINGIFY_CODE(MODULE_CODE, ALIAS) 137351278Sdim STRINGIFY_CODE(MODULE_CODE, GCNAME) 138351278Sdim STRINGIFY_CODE(MODULE_CODE, VSTOFFSET) 139351278Sdim STRINGIFY_CODE(MODULE_CODE, METADATA_VALUES_UNUSED) 140351278Sdim STRINGIFY_CODE(MODULE_CODE, SOURCE_FILENAME) 141351278Sdim STRINGIFY_CODE(MODULE_CODE, HASH) 142351278Sdim } 143351278Sdim case bitc::IDENTIFICATION_BLOCK_ID: 144351278Sdim switch (CodeID) { 145351278Sdim default: 146351278Sdim return None; 147351278Sdim STRINGIFY_CODE(IDENTIFICATION_CODE, STRING) 148351278Sdim STRINGIFY_CODE(IDENTIFICATION_CODE, EPOCH) 149351278Sdim } 150351278Sdim case bitc::PARAMATTR_BLOCK_ID: 151351278Sdim switch (CodeID) { 152351278Sdim default: 153351278Sdim return None; 154351278Sdim // FIXME: Should these be different? 155351278Sdim case bitc::PARAMATTR_CODE_ENTRY_OLD: 156351278Sdim return "ENTRY"; 157351278Sdim case bitc::PARAMATTR_CODE_ENTRY: 158351278Sdim return "ENTRY"; 159351278Sdim } 160351278Sdim case bitc::PARAMATTR_GROUP_BLOCK_ID: 161351278Sdim switch (CodeID) { 162351278Sdim default: 163351278Sdim return None; 164351278Sdim case bitc::PARAMATTR_GRP_CODE_ENTRY: 165351278Sdim return "ENTRY"; 166351278Sdim } 167351278Sdim case bitc::TYPE_BLOCK_ID_NEW: 168351278Sdim switch (CodeID) { 169351278Sdim default: 170351278Sdim return None; 171351278Sdim STRINGIFY_CODE(TYPE_CODE, NUMENTRY) 172351278Sdim STRINGIFY_CODE(TYPE_CODE, VOID) 173351278Sdim STRINGIFY_CODE(TYPE_CODE, FLOAT) 174351278Sdim STRINGIFY_CODE(TYPE_CODE, DOUBLE) 175351278Sdim STRINGIFY_CODE(TYPE_CODE, LABEL) 176351278Sdim STRINGIFY_CODE(TYPE_CODE, OPAQUE) 177351278Sdim STRINGIFY_CODE(TYPE_CODE, INTEGER) 178351278Sdim STRINGIFY_CODE(TYPE_CODE, POINTER) 179351278Sdim STRINGIFY_CODE(TYPE_CODE, ARRAY) 180351278Sdim STRINGIFY_CODE(TYPE_CODE, VECTOR) 181351278Sdim STRINGIFY_CODE(TYPE_CODE, X86_FP80) 182351278Sdim STRINGIFY_CODE(TYPE_CODE, FP128) 183351278Sdim STRINGIFY_CODE(TYPE_CODE, PPC_FP128) 184351278Sdim STRINGIFY_CODE(TYPE_CODE, METADATA) 185351278Sdim STRINGIFY_CODE(TYPE_CODE, STRUCT_ANON) 186351278Sdim STRINGIFY_CODE(TYPE_CODE, STRUCT_NAME) 187351278Sdim STRINGIFY_CODE(TYPE_CODE, STRUCT_NAMED) 188351278Sdim STRINGIFY_CODE(TYPE_CODE, FUNCTION) 189351278Sdim } 190351278Sdim 191351278Sdim case bitc::CONSTANTS_BLOCK_ID: 192351278Sdim switch (CodeID) { 193351278Sdim default: 194351278Sdim return None; 195351278Sdim STRINGIFY_CODE(CST_CODE, SETTYPE) 196351278Sdim STRINGIFY_CODE(CST_CODE, NULL) 197351278Sdim STRINGIFY_CODE(CST_CODE, UNDEF) 198351278Sdim STRINGIFY_CODE(CST_CODE, INTEGER) 199351278Sdim STRINGIFY_CODE(CST_CODE, WIDE_INTEGER) 200351278Sdim STRINGIFY_CODE(CST_CODE, FLOAT) 201351278Sdim STRINGIFY_CODE(CST_CODE, AGGREGATE) 202351278Sdim STRINGIFY_CODE(CST_CODE, STRING) 203351278Sdim STRINGIFY_CODE(CST_CODE, CSTRING) 204351278Sdim STRINGIFY_CODE(CST_CODE, CE_BINOP) 205351278Sdim STRINGIFY_CODE(CST_CODE, CE_CAST) 206351278Sdim STRINGIFY_CODE(CST_CODE, CE_GEP) 207351278Sdim STRINGIFY_CODE(CST_CODE, CE_INBOUNDS_GEP) 208351278Sdim STRINGIFY_CODE(CST_CODE, CE_SELECT) 209351278Sdim STRINGIFY_CODE(CST_CODE, CE_EXTRACTELT) 210351278Sdim STRINGIFY_CODE(CST_CODE, CE_INSERTELT) 211351278Sdim STRINGIFY_CODE(CST_CODE, CE_SHUFFLEVEC) 212351278Sdim STRINGIFY_CODE(CST_CODE, CE_CMP) 213351278Sdim STRINGIFY_CODE(CST_CODE, INLINEASM) 214351278Sdim STRINGIFY_CODE(CST_CODE, CE_SHUFVEC_EX) 215351278Sdim STRINGIFY_CODE(CST_CODE, CE_UNOP) 216351278Sdim case bitc::CST_CODE_BLOCKADDRESS: 217351278Sdim return "CST_CODE_BLOCKADDRESS"; 218351278Sdim STRINGIFY_CODE(CST_CODE, DATA) 219351278Sdim } 220351278Sdim case bitc::FUNCTION_BLOCK_ID: 221351278Sdim switch (CodeID) { 222351278Sdim default: 223351278Sdim return None; 224351278Sdim STRINGIFY_CODE(FUNC_CODE, DECLAREBLOCKS) 225351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_BINOP) 226351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_CAST) 227351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_GEP_OLD) 228351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_INBOUNDS_GEP_OLD) 229351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_SELECT) 230351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_EXTRACTELT) 231351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_INSERTELT) 232351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_SHUFFLEVEC) 233351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_CMP) 234351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_RET) 235351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_BR) 236351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_SWITCH) 237351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_INVOKE) 238351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_UNOP) 239351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_UNREACHABLE) 240351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_CLEANUPRET) 241351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_CATCHRET) 242351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_CATCHPAD) 243351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_PHI) 244351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_ALLOCA) 245351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_LOAD) 246351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_VAARG) 247351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_STORE) 248351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_EXTRACTVAL) 249351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_INSERTVAL) 250351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_CMP2) 251351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_VSELECT) 252351278Sdim STRINGIFY_CODE(FUNC_CODE, DEBUG_LOC_AGAIN) 253351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_CALL) 254351278Sdim STRINGIFY_CODE(FUNC_CODE, DEBUG_LOC) 255351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_GEP) 256351278Sdim STRINGIFY_CODE(FUNC_CODE, OPERAND_BUNDLE) 257351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_FENCE) 258351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_ATOMICRMW) 259351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_LOADATOMIC) 260351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_STOREATOMIC) 261351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_CMPXCHG) 262351278Sdim STRINGIFY_CODE(FUNC_CODE, INST_CALLBR) 263351278Sdim } 264351278Sdim case bitc::VALUE_SYMTAB_BLOCK_ID: 265351278Sdim switch (CodeID) { 266351278Sdim default: 267351278Sdim return None; 268351278Sdim STRINGIFY_CODE(VST_CODE, ENTRY) 269351278Sdim STRINGIFY_CODE(VST_CODE, BBENTRY) 270351278Sdim STRINGIFY_CODE(VST_CODE, FNENTRY) 271351278Sdim STRINGIFY_CODE(VST_CODE, COMBINED_ENTRY) 272351278Sdim } 273351278Sdim case bitc::MODULE_STRTAB_BLOCK_ID: 274351278Sdim switch (CodeID) { 275351278Sdim default: 276351278Sdim return None; 277351278Sdim STRINGIFY_CODE(MST_CODE, ENTRY) 278351278Sdim STRINGIFY_CODE(MST_CODE, HASH) 279351278Sdim } 280351278Sdim case bitc::GLOBALVAL_SUMMARY_BLOCK_ID: 281351278Sdim case bitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID: 282351278Sdim switch (CodeID) { 283351278Sdim default: 284351278Sdim return None; 285351278Sdim STRINGIFY_CODE(FS, PERMODULE) 286351278Sdim STRINGIFY_CODE(FS, PERMODULE_PROFILE) 287351278Sdim STRINGIFY_CODE(FS, PERMODULE_RELBF) 288351278Sdim STRINGIFY_CODE(FS, PERMODULE_GLOBALVAR_INIT_REFS) 289351278Sdim STRINGIFY_CODE(FS, PERMODULE_VTABLE_GLOBALVAR_INIT_REFS) 290351278Sdim STRINGIFY_CODE(FS, COMBINED) 291351278Sdim STRINGIFY_CODE(FS, COMBINED_PROFILE) 292351278Sdim STRINGIFY_CODE(FS, COMBINED_GLOBALVAR_INIT_REFS) 293351278Sdim STRINGIFY_CODE(FS, ALIAS) 294351278Sdim STRINGIFY_CODE(FS, COMBINED_ALIAS) 295351278Sdim STRINGIFY_CODE(FS, COMBINED_ORIGINAL_NAME) 296351278Sdim STRINGIFY_CODE(FS, VERSION) 297351278Sdim STRINGIFY_CODE(FS, FLAGS) 298351278Sdim STRINGIFY_CODE(FS, TYPE_TESTS) 299351278Sdim STRINGIFY_CODE(FS, TYPE_TEST_ASSUME_VCALLS) 300351278Sdim STRINGIFY_CODE(FS, TYPE_CHECKED_LOAD_VCALLS) 301351278Sdim STRINGIFY_CODE(FS, TYPE_TEST_ASSUME_CONST_VCALL) 302351278Sdim STRINGIFY_CODE(FS, TYPE_CHECKED_LOAD_CONST_VCALL) 303351278Sdim STRINGIFY_CODE(FS, VALUE_GUID) 304351278Sdim STRINGIFY_CODE(FS, CFI_FUNCTION_DEFS) 305351278Sdim STRINGIFY_CODE(FS, CFI_FUNCTION_DECLS) 306351278Sdim STRINGIFY_CODE(FS, TYPE_ID) 307351278Sdim STRINGIFY_CODE(FS, TYPE_ID_METADATA) 308351278Sdim } 309351278Sdim case bitc::METADATA_ATTACHMENT_ID: 310351278Sdim switch (CodeID) { 311351278Sdim default: 312351278Sdim return None; 313351278Sdim STRINGIFY_CODE(METADATA, ATTACHMENT) 314351278Sdim } 315351278Sdim case bitc::METADATA_BLOCK_ID: 316351278Sdim switch (CodeID) { 317351278Sdim default: 318351278Sdim return None; 319351278Sdim STRINGIFY_CODE(METADATA, STRING_OLD) 320351278Sdim STRINGIFY_CODE(METADATA, VALUE) 321351278Sdim STRINGIFY_CODE(METADATA, NODE) 322351278Sdim STRINGIFY_CODE(METADATA, NAME) 323351278Sdim STRINGIFY_CODE(METADATA, DISTINCT_NODE) 324351278Sdim STRINGIFY_CODE(METADATA, KIND) // Older bitcode has it in a MODULE_BLOCK 325351278Sdim STRINGIFY_CODE(METADATA, LOCATION) 326351278Sdim STRINGIFY_CODE(METADATA, OLD_NODE) 327351278Sdim STRINGIFY_CODE(METADATA, OLD_FN_NODE) 328351278Sdim STRINGIFY_CODE(METADATA, NAMED_NODE) 329351278Sdim STRINGIFY_CODE(METADATA, GENERIC_DEBUG) 330351278Sdim STRINGIFY_CODE(METADATA, SUBRANGE) 331351278Sdim STRINGIFY_CODE(METADATA, ENUMERATOR) 332351278Sdim STRINGIFY_CODE(METADATA, BASIC_TYPE) 333351278Sdim STRINGIFY_CODE(METADATA, FILE) 334351278Sdim STRINGIFY_CODE(METADATA, DERIVED_TYPE) 335351278Sdim STRINGIFY_CODE(METADATA, COMPOSITE_TYPE) 336351278Sdim STRINGIFY_CODE(METADATA, SUBROUTINE_TYPE) 337351278Sdim STRINGIFY_CODE(METADATA, COMPILE_UNIT) 338351278Sdim STRINGIFY_CODE(METADATA, SUBPROGRAM) 339351278Sdim STRINGIFY_CODE(METADATA, LEXICAL_BLOCK) 340351278Sdim STRINGIFY_CODE(METADATA, LEXICAL_BLOCK_FILE) 341351278Sdim STRINGIFY_CODE(METADATA, NAMESPACE) 342351278Sdim STRINGIFY_CODE(METADATA, TEMPLATE_TYPE) 343351278Sdim STRINGIFY_CODE(METADATA, TEMPLATE_VALUE) 344351278Sdim STRINGIFY_CODE(METADATA, GLOBAL_VAR) 345351278Sdim STRINGIFY_CODE(METADATA, LOCAL_VAR) 346351278Sdim STRINGIFY_CODE(METADATA, EXPRESSION) 347351278Sdim STRINGIFY_CODE(METADATA, OBJC_PROPERTY) 348351278Sdim STRINGIFY_CODE(METADATA, IMPORTED_ENTITY) 349351278Sdim STRINGIFY_CODE(METADATA, MODULE) 350351278Sdim STRINGIFY_CODE(METADATA, MACRO) 351351278Sdim STRINGIFY_CODE(METADATA, MACRO_FILE) 352351278Sdim STRINGIFY_CODE(METADATA, STRINGS) 353351278Sdim STRINGIFY_CODE(METADATA, GLOBAL_DECL_ATTACHMENT) 354351278Sdim STRINGIFY_CODE(METADATA, GLOBAL_VAR_EXPR) 355351278Sdim STRINGIFY_CODE(METADATA, INDEX_OFFSET) 356351278Sdim STRINGIFY_CODE(METADATA, INDEX) 357351278Sdim } 358351278Sdim case bitc::METADATA_KIND_BLOCK_ID: 359351278Sdim switch (CodeID) { 360351278Sdim default: 361351278Sdim return None; 362351278Sdim STRINGIFY_CODE(METADATA, KIND) 363351278Sdim } 364351278Sdim case bitc::USELIST_BLOCK_ID: 365351278Sdim switch (CodeID) { 366351278Sdim default: 367351278Sdim return None; 368351278Sdim case bitc::USELIST_CODE_DEFAULT: 369351278Sdim return "USELIST_CODE_DEFAULT"; 370351278Sdim case bitc::USELIST_CODE_BB: 371351278Sdim return "USELIST_CODE_BB"; 372351278Sdim } 373351278Sdim 374351278Sdim case bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID: 375351278Sdim switch (CodeID) { 376351278Sdim default: 377351278Sdim return None; 378351278Sdim case bitc::OPERAND_BUNDLE_TAG: 379351278Sdim return "OPERAND_BUNDLE_TAG"; 380351278Sdim } 381351278Sdim case bitc::STRTAB_BLOCK_ID: 382351278Sdim switch (CodeID) { 383351278Sdim default: 384351278Sdim return None; 385351278Sdim case bitc::STRTAB_BLOB: 386351278Sdim return "BLOB"; 387351278Sdim } 388351278Sdim case bitc::SYMTAB_BLOCK_ID: 389351278Sdim switch (CodeID) { 390351278Sdim default: 391351278Sdim return None; 392351278Sdim case bitc::SYMTAB_BLOB: 393351278Sdim return "BLOB"; 394351278Sdim } 395351278Sdim } 396351278Sdim#undef STRINGIFY_CODE 397351278Sdim} 398351278Sdim 399351278Sdimstatic void printSize(raw_ostream &OS, double Bits) { 400351278Sdim OS << format("%.2f/%.2fB/%luW", Bits, Bits / 8, (unsigned long)(Bits / 32)); 401351278Sdim} 402351278Sdimstatic void printSize(raw_ostream &OS, uint64_t Bits) { 403351278Sdim OS << format("%lub/%.2fB/%luW", (unsigned long)Bits, (double)Bits / 8, 404351278Sdim (unsigned long)(Bits / 32)); 405351278Sdim} 406351278Sdim 407351278Sdimstatic Expected<CurStreamTypeType> ReadSignature(BitstreamCursor &Stream) { 408351278Sdim auto tryRead = [&Stream](char &Dest, size_t size) -> Error { 409351278Sdim if (Expected<SimpleBitstreamCursor::word_t> MaybeWord = Stream.Read(size)) 410351278Sdim Dest = MaybeWord.get(); 411351278Sdim else 412351278Sdim return MaybeWord.takeError(); 413351278Sdim return Error::success(); 414351278Sdim }; 415351278Sdim 416351278Sdim char Signature[6]; 417351278Sdim if (Error Err = tryRead(Signature[0], 8)) 418351278Sdim return std::move(Err); 419351278Sdim if (Error Err = tryRead(Signature[1], 8)) 420351278Sdim return std::move(Err); 421351278Sdim 422351278Sdim // Autodetect the file contents, if it is one we know. 423351278Sdim if (Signature[0] == 'C' && Signature[1] == 'P') { 424351278Sdim if (Error Err = tryRead(Signature[2], 8)) 425351278Sdim return std::move(Err); 426351278Sdim if (Error Err = tryRead(Signature[3], 8)) 427351278Sdim return std::move(Err); 428351278Sdim if (Signature[2] == 'C' && Signature[3] == 'H') 429351278Sdim return ClangSerializedASTBitstream; 430351278Sdim } else if (Signature[0] == 'D' && Signature[1] == 'I') { 431351278Sdim if (Error Err = tryRead(Signature[2], 8)) 432351278Sdim return std::move(Err); 433351278Sdim if (Error Err = tryRead(Signature[3], 8)) 434351278Sdim return std::move(Err); 435351278Sdim if (Signature[2] == 'A' && Signature[3] == 'G') 436351278Sdim return ClangSerializedDiagnosticsBitstream; 437360784Sdim } else if (Signature[0] == 'R' && Signature[1] == 'M') { 438360784Sdim if (Error Err = tryRead(Signature[2], 8)) 439360784Sdim return std::move(Err); 440360784Sdim if (Error Err = tryRead(Signature[3], 8)) 441360784Sdim return std::move(Err); 442360784Sdim if (Signature[2] == 'R' && Signature[3] == 'K') 443360784Sdim return LLVMBitstreamRemarks; 444351278Sdim } else { 445351278Sdim if (Error Err = tryRead(Signature[2], 4)) 446351278Sdim return std::move(Err); 447351278Sdim if (Error Err = tryRead(Signature[3], 4)) 448351278Sdim return std::move(Err); 449351278Sdim if (Error Err = tryRead(Signature[4], 4)) 450351278Sdim return std::move(Err); 451351278Sdim if (Error Err = tryRead(Signature[5], 4)) 452351278Sdim return std::move(Err); 453351278Sdim if (Signature[0] == 'B' && Signature[1] == 'C' && Signature[2] == 0x0 && 454351278Sdim Signature[3] == 0xC && Signature[4] == 0xE && Signature[5] == 0xD) 455351278Sdim return LLVMIRBitstream; 456351278Sdim } 457351278Sdim return UnknownBitstream; 458351278Sdim} 459351278Sdim 460351278Sdimstatic Expected<CurStreamTypeType> analyzeHeader(Optional<BCDumpOptions> O, 461351278Sdim BitstreamCursor &Stream) { 462351278Sdim ArrayRef<uint8_t> Bytes = Stream.getBitcodeBytes(); 463351278Sdim const unsigned char *BufPtr = (const unsigned char *)Bytes.data(); 464351278Sdim const unsigned char *EndBufPtr = BufPtr + Bytes.size(); 465351278Sdim 466351278Sdim // If we have a wrapper header, parse it and ignore the non-bc file 467351278Sdim // contents. The magic number is 0x0B17C0DE stored in little endian. 468351278Sdim if (isBitcodeWrapper(BufPtr, EndBufPtr)) { 469351278Sdim if (Bytes.size() < BWH_HeaderSize) 470351278Sdim return reportError("Invalid bitcode wrapper header"); 471351278Sdim 472351278Sdim if (O) { 473351278Sdim unsigned Magic = support::endian::read32le(&BufPtr[BWH_MagicField]); 474351278Sdim unsigned Version = support::endian::read32le(&BufPtr[BWH_VersionField]); 475351278Sdim unsigned Offset = support::endian::read32le(&BufPtr[BWH_OffsetField]); 476351278Sdim unsigned Size = support::endian::read32le(&BufPtr[BWH_SizeField]); 477351278Sdim unsigned CPUType = support::endian::read32le(&BufPtr[BWH_CPUTypeField]); 478351278Sdim 479351278Sdim O->OS << "<BITCODE_WRAPPER_HEADER" 480351278Sdim << " Magic=" << format_hex(Magic, 10) 481351278Sdim << " Version=" << format_hex(Version, 10) 482351278Sdim << " Offset=" << format_hex(Offset, 10) 483351278Sdim << " Size=" << format_hex(Size, 10) 484351278Sdim << " CPUType=" << format_hex(CPUType, 10) << "/>\n"; 485351278Sdim } 486351278Sdim 487351278Sdim if (SkipBitcodeWrapperHeader(BufPtr, EndBufPtr, true)) 488351278Sdim return reportError("Invalid bitcode wrapper header"); 489351278Sdim } 490351278Sdim 491351278Sdim // Use the cursor modified by skipping the wrapper header. 492351278Sdim Stream = BitstreamCursor(ArrayRef<uint8_t>(BufPtr, EndBufPtr)); 493351278Sdim 494351278Sdim return ReadSignature(Stream); 495351278Sdim} 496351278Sdim 497351278Sdimstatic bool canDecodeBlob(unsigned Code, unsigned BlockID) { 498351278Sdim return BlockID == bitc::METADATA_BLOCK_ID && Code == bitc::METADATA_STRINGS; 499351278Sdim} 500351278Sdim 501351278SdimError BitcodeAnalyzer::decodeMetadataStringsBlob(StringRef Indent, 502351278Sdim ArrayRef<uint64_t> Record, 503351278Sdim StringRef Blob, 504351278Sdim raw_ostream &OS) { 505351278Sdim if (Blob.empty()) 506351278Sdim return reportError("Cannot decode empty blob."); 507351278Sdim 508351278Sdim if (Record.size() != 2) 509351278Sdim return reportError( 510351278Sdim "Decoding metadata strings blob needs two record entries."); 511351278Sdim 512351278Sdim unsigned NumStrings = Record[0]; 513351278Sdim unsigned StringsOffset = Record[1]; 514351278Sdim OS << " num-strings = " << NumStrings << " {\n"; 515351278Sdim 516351278Sdim StringRef Lengths = Blob.slice(0, StringsOffset); 517351278Sdim SimpleBitstreamCursor R(Lengths); 518351278Sdim StringRef Strings = Blob.drop_front(StringsOffset); 519351278Sdim do { 520351278Sdim if (R.AtEndOfStream()) 521351278Sdim return reportError("bad length"); 522351278Sdim 523351278Sdim Expected<uint32_t> MaybeSize = R.ReadVBR(6); 524351278Sdim if (!MaybeSize) 525351278Sdim return MaybeSize.takeError(); 526351278Sdim uint32_t Size = MaybeSize.get(); 527351278Sdim if (Strings.size() < Size) 528351278Sdim return reportError("truncated chars"); 529351278Sdim 530351278Sdim OS << Indent << " '"; 531351278Sdim OS.write_escaped(Strings.slice(0, Size), /*hex=*/true); 532351278Sdim OS << "'\n"; 533351278Sdim Strings = Strings.drop_front(Size); 534351278Sdim } while (--NumStrings); 535351278Sdim 536351278Sdim OS << Indent << " }"; 537351278Sdim return Error::success(); 538351278Sdim} 539351278Sdim 540351278SdimBitcodeAnalyzer::BitcodeAnalyzer(StringRef Buffer, 541351278Sdim Optional<StringRef> BlockInfoBuffer) 542351278Sdim : Stream(Buffer) { 543351278Sdim if (BlockInfoBuffer) 544351278Sdim BlockInfoStream.emplace(*BlockInfoBuffer); 545351278Sdim} 546351278Sdim 547351278SdimError BitcodeAnalyzer::analyze(Optional<BCDumpOptions> O, 548351278Sdim Optional<StringRef> CheckHash) { 549351278Sdim Expected<CurStreamTypeType> MaybeType = analyzeHeader(O, Stream); 550351278Sdim if (!MaybeType) 551351278Sdim return MaybeType.takeError(); 552351278Sdim else 553351278Sdim CurStreamType = *MaybeType; 554351278Sdim 555351278Sdim Stream.setBlockInfo(&BlockInfo); 556351278Sdim 557351278Sdim // Read block info from BlockInfoStream, if specified. 558351278Sdim // The block info must be a top-level block. 559351278Sdim if (BlockInfoStream) { 560351278Sdim BitstreamCursor BlockInfoCursor(*BlockInfoStream); 561351278Sdim Expected<CurStreamTypeType> H = analyzeHeader(O, BlockInfoCursor); 562351278Sdim if (!H) 563351278Sdim return H.takeError(); 564351278Sdim 565351278Sdim while (!BlockInfoCursor.AtEndOfStream()) { 566351278Sdim Expected<unsigned> MaybeCode = BlockInfoCursor.ReadCode(); 567351278Sdim if (!MaybeCode) 568351278Sdim return MaybeCode.takeError(); 569351278Sdim if (MaybeCode.get() != bitc::ENTER_SUBBLOCK) 570351278Sdim return reportError("Invalid record at top-level in block info file"); 571351278Sdim 572351278Sdim Expected<unsigned> MaybeBlockID = BlockInfoCursor.ReadSubBlockID(); 573351278Sdim if (!MaybeBlockID) 574351278Sdim return MaybeBlockID.takeError(); 575351278Sdim if (MaybeBlockID.get() == bitc::BLOCKINFO_BLOCK_ID) { 576351278Sdim Expected<Optional<BitstreamBlockInfo>> MaybeNewBlockInfo = 577351278Sdim BlockInfoCursor.ReadBlockInfoBlock(/*ReadBlockInfoNames=*/true); 578351278Sdim if (!MaybeNewBlockInfo) 579351278Sdim return MaybeNewBlockInfo.takeError(); 580351278Sdim Optional<BitstreamBlockInfo> NewBlockInfo = 581351278Sdim std::move(MaybeNewBlockInfo.get()); 582351278Sdim if (!NewBlockInfo) 583351278Sdim return reportError("Malformed BlockInfoBlock in block info file"); 584351278Sdim BlockInfo = std::move(*NewBlockInfo); 585351278Sdim break; 586351278Sdim } 587351278Sdim 588351278Sdim if (Error Err = BlockInfoCursor.SkipBlock()) 589351278Sdim return Err; 590351278Sdim } 591351278Sdim } 592351278Sdim 593351278Sdim // Parse the top-level structure. We only allow blocks at the top-level. 594351278Sdim while (!Stream.AtEndOfStream()) { 595351278Sdim Expected<unsigned> MaybeCode = Stream.ReadCode(); 596351278Sdim if (!MaybeCode) 597351278Sdim return MaybeCode.takeError(); 598351278Sdim if (MaybeCode.get() != bitc::ENTER_SUBBLOCK) 599351278Sdim return reportError("Invalid record at top-level"); 600351278Sdim 601351278Sdim Expected<unsigned> MaybeBlockID = Stream.ReadSubBlockID(); 602351278Sdim if (!MaybeBlockID) 603351278Sdim return MaybeBlockID.takeError(); 604351278Sdim 605351278Sdim if (Error E = parseBlock(MaybeBlockID.get(), 0, O, CheckHash)) 606351278Sdim return E; 607351278Sdim ++NumTopBlocks; 608351278Sdim } 609351278Sdim 610351278Sdim return Error::success(); 611351278Sdim} 612351278Sdim 613351278Sdimvoid BitcodeAnalyzer::printStats(BCDumpOptions O, 614351278Sdim Optional<StringRef> Filename) { 615351278Sdim uint64_t BufferSizeBits = Stream.getBitcodeBytes().size() * CHAR_BIT; 616351278Sdim // Print a summary of the read file. 617351278Sdim O.OS << "Summary "; 618351278Sdim if (Filename) 619351278Sdim O.OS << "of " << Filename->data() << ":\n"; 620351278Sdim O.OS << " Total size: "; 621351278Sdim printSize(O.OS, BufferSizeBits); 622351278Sdim O.OS << "\n"; 623351278Sdim O.OS << " Stream type: "; 624351278Sdim switch (CurStreamType) { 625351278Sdim case UnknownBitstream: 626351278Sdim O.OS << "unknown\n"; 627351278Sdim break; 628351278Sdim case LLVMIRBitstream: 629351278Sdim O.OS << "LLVM IR\n"; 630351278Sdim break; 631351278Sdim case ClangSerializedASTBitstream: 632351278Sdim O.OS << "Clang Serialized AST\n"; 633351278Sdim break; 634351278Sdim case ClangSerializedDiagnosticsBitstream: 635351278Sdim O.OS << "Clang Serialized Diagnostics\n"; 636351278Sdim break; 637360784Sdim case LLVMBitstreamRemarks: 638360784Sdim O.OS << "LLVM Remarks\n"; 639360784Sdim break; 640351278Sdim } 641351278Sdim O.OS << " # Toplevel Blocks: " << NumTopBlocks << "\n"; 642351278Sdim O.OS << "\n"; 643351278Sdim 644351278Sdim // Emit per-block stats. 645351278Sdim O.OS << "Per-block Summary:\n"; 646351278Sdim for (std::map<unsigned, PerBlockIDStats>::iterator I = BlockIDStats.begin(), 647351278Sdim E = BlockIDStats.end(); 648351278Sdim I != E; ++I) { 649351278Sdim O.OS << " Block ID #" << I->first; 650351278Sdim if (Optional<const char *> BlockName = 651351278Sdim GetBlockName(I->first, BlockInfo, CurStreamType)) 652351278Sdim O.OS << " (" << *BlockName << ")"; 653351278Sdim O.OS << ":\n"; 654351278Sdim 655351278Sdim const PerBlockIDStats &Stats = I->second; 656351278Sdim O.OS << " Num Instances: " << Stats.NumInstances << "\n"; 657351278Sdim O.OS << " Total Size: "; 658351278Sdim printSize(O.OS, Stats.NumBits); 659351278Sdim O.OS << "\n"; 660351278Sdim double pct = (Stats.NumBits * 100.0) / BufferSizeBits; 661351278Sdim O.OS << " Percent of file: " << format("%2.4f%%", pct) << "\n"; 662351278Sdim if (Stats.NumInstances > 1) { 663351278Sdim O.OS << " Average Size: "; 664351278Sdim printSize(O.OS, Stats.NumBits / (double)Stats.NumInstances); 665351278Sdim O.OS << "\n"; 666351278Sdim O.OS << " Tot/Avg SubBlocks: " << Stats.NumSubBlocks << "/" 667351278Sdim << Stats.NumSubBlocks / (double)Stats.NumInstances << "\n"; 668351278Sdim O.OS << " Tot/Avg Abbrevs: " << Stats.NumAbbrevs << "/" 669351278Sdim << Stats.NumAbbrevs / (double)Stats.NumInstances << "\n"; 670351278Sdim O.OS << " Tot/Avg Records: " << Stats.NumRecords << "/" 671351278Sdim << Stats.NumRecords / (double)Stats.NumInstances << "\n"; 672351278Sdim } else { 673351278Sdim O.OS << " Num SubBlocks: " << Stats.NumSubBlocks << "\n"; 674351278Sdim O.OS << " Num Abbrevs: " << Stats.NumAbbrevs << "\n"; 675351278Sdim O.OS << " Num Records: " << Stats.NumRecords << "\n"; 676351278Sdim } 677351278Sdim if (Stats.NumRecords) { 678351278Sdim double pct = (Stats.NumAbbreviatedRecords * 100.0) / Stats.NumRecords; 679351278Sdim O.OS << " Percent Abbrevs: " << format("%2.4f%%", pct) << "\n"; 680351278Sdim } 681351278Sdim O.OS << "\n"; 682351278Sdim 683351278Sdim // Print a histogram of the codes we see. 684351278Sdim if (O.Histogram && !Stats.CodeFreq.empty()) { 685351278Sdim std::vector<std::pair<unsigned, unsigned>> FreqPairs; // <freq,code> 686351278Sdim for (unsigned i = 0, e = Stats.CodeFreq.size(); i != e; ++i) 687351278Sdim if (unsigned Freq = Stats.CodeFreq[i].NumInstances) 688351278Sdim FreqPairs.push_back(std::make_pair(Freq, i)); 689351278Sdim llvm::stable_sort(FreqPairs); 690351278Sdim std::reverse(FreqPairs.begin(), FreqPairs.end()); 691351278Sdim 692351278Sdim O.OS << "\tRecord Histogram:\n"; 693351278Sdim O.OS << "\t\t Count # Bits b/Rec % Abv Record Kind\n"; 694351278Sdim for (unsigned i = 0, e = FreqPairs.size(); i != e; ++i) { 695351278Sdim const PerRecordStats &RecStats = Stats.CodeFreq[FreqPairs[i].second]; 696351278Sdim 697351278Sdim O.OS << format("\t\t%7d %9lu", RecStats.NumInstances, 698351278Sdim (unsigned long)RecStats.TotalBits); 699351278Sdim 700351278Sdim if (RecStats.NumInstances > 1) 701351278Sdim O.OS << format(" %9.1f", 702351278Sdim (double)RecStats.TotalBits / RecStats.NumInstances); 703351278Sdim else 704351278Sdim O.OS << " "; 705351278Sdim 706351278Sdim if (RecStats.NumAbbrev) 707351278Sdim O.OS << format(" %7.2f", (double)RecStats.NumAbbrev / 708351278Sdim RecStats.NumInstances * 100); 709351278Sdim else 710351278Sdim O.OS << " "; 711351278Sdim 712351278Sdim O.OS << " "; 713351278Sdim if (Optional<const char *> CodeName = GetCodeName( 714351278Sdim FreqPairs[i].second, I->first, BlockInfo, CurStreamType)) 715351278Sdim O.OS << *CodeName << "\n"; 716351278Sdim else 717351278Sdim O.OS << "UnknownCode" << FreqPairs[i].second << "\n"; 718351278Sdim } 719351278Sdim O.OS << "\n"; 720351278Sdim } 721351278Sdim } 722351278Sdim} 723351278Sdim 724351278SdimError BitcodeAnalyzer::parseBlock(unsigned BlockID, unsigned IndentLevel, 725351278Sdim Optional<BCDumpOptions> O, 726351278Sdim Optional<StringRef> CheckHash) { 727351278Sdim std::string Indent(IndentLevel * 2, ' '); 728351278Sdim uint64_t BlockBitStart = Stream.GetCurrentBitNo(); 729351278Sdim 730351278Sdim // Get the statistics for this BlockID. 731351278Sdim PerBlockIDStats &BlockStats = BlockIDStats[BlockID]; 732351278Sdim 733351278Sdim BlockStats.NumInstances++; 734351278Sdim 735351278Sdim // BLOCKINFO is a special part of the stream. 736351278Sdim bool DumpRecords = O.hasValue(); 737351278Sdim if (BlockID == bitc::BLOCKINFO_BLOCK_ID) { 738351278Sdim if (O) 739351278Sdim O->OS << Indent << "<BLOCKINFO_BLOCK/>\n"; 740351278Sdim Expected<Optional<BitstreamBlockInfo>> MaybeNewBlockInfo = 741351278Sdim Stream.ReadBlockInfoBlock(/*ReadBlockInfoNames=*/true); 742351278Sdim if (!MaybeNewBlockInfo) 743351278Sdim return MaybeNewBlockInfo.takeError(); 744351278Sdim Optional<BitstreamBlockInfo> NewBlockInfo = 745351278Sdim std::move(MaybeNewBlockInfo.get()); 746351278Sdim if (!NewBlockInfo) 747351278Sdim return reportError("Malformed BlockInfoBlock"); 748351278Sdim BlockInfo = std::move(*NewBlockInfo); 749351278Sdim if (Error Err = Stream.JumpToBit(BlockBitStart)) 750351278Sdim return Err; 751351278Sdim // It's not really interesting to dump the contents of the blockinfo 752351278Sdim // block. 753351278Sdim DumpRecords = false; 754351278Sdim } 755351278Sdim 756351278Sdim unsigned NumWords = 0; 757351278Sdim if (Error Err = Stream.EnterSubBlock(BlockID, &NumWords)) 758351278Sdim return Err; 759351278Sdim 760351278Sdim // Keep it for later, when we see a MODULE_HASH record 761351278Sdim uint64_t BlockEntryPos = Stream.getCurrentByteNo(); 762351278Sdim 763351278Sdim Optional<const char *> BlockName = None; 764351278Sdim if (DumpRecords) { 765351278Sdim O->OS << Indent << "<"; 766351278Sdim if ((BlockName = GetBlockName(BlockID, BlockInfo, CurStreamType))) 767351278Sdim O->OS << *BlockName; 768351278Sdim else 769351278Sdim O->OS << "UnknownBlock" << BlockID; 770351278Sdim 771351278Sdim if (!O->Symbolic && BlockName) 772351278Sdim O->OS << " BlockID=" << BlockID; 773351278Sdim 774351278Sdim O->OS << " NumWords=" << NumWords 775351278Sdim << " BlockCodeSize=" << Stream.getAbbrevIDWidth() << ">\n"; 776351278Sdim } 777351278Sdim 778351278Sdim SmallVector<uint64_t, 64> Record; 779351278Sdim 780351278Sdim // Keep the offset to the metadata index if seen. 781351278Sdim uint64_t MetadataIndexOffset = 0; 782351278Sdim 783351278Sdim // Read all the records for this block. 784351278Sdim while (1) { 785351278Sdim if (Stream.AtEndOfStream()) 786351278Sdim return reportError("Premature end of bitstream"); 787351278Sdim 788351278Sdim uint64_t RecordStartBit = Stream.GetCurrentBitNo(); 789351278Sdim 790351278Sdim Expected<BitstreamEntry> MaybeEntry = 791351278Sdim Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs); 792351278Sdim if (!MaybeEntry) 793351278Sdim return MaybeEntry.takeError(); 794351278Sdim BitstreamEntry Entry = MaybeEntry.get(); 795351278Sdim 796351278Sdim switch (Entry.Kind) { 797351278Sdim case BitstreamEntry::Error: 798351278Sdim return reportError("malformed bitcode file"); 799351278Sdim case BitstreamEntry::EndBlock: { 800351278Sdim uint64_t BlockBitEnd = Stream.GetCurrentBitNo(); 801351278Sdim BlockStats.NumBits += BlockBitEnd - BlockBitStart; 802351278Sdim if (DumpRecords) { 803351278Sdim O->OS << Indent << "</"; 804351278Sdim if (BlockName) 805351278Sdim O->OS << *BlockName << ">\n"; 806351278Sdim else 807351278Sdim O->OS << "UnknownBlock" << BlockID << ">\n"; 808351278Sdim } 809351278Sdim return Error::success(); 810351278Sdim } 811351278Sdim 812351278Sdim case BitstreamEntry::SubBlock: { 813351278Sdim uint64_t SubBlockBitStart = Stream.GetCurrentBitNo(); 814351278Sdim if (Error E = parseBlock(Entry.ID, IndentLevel + 1, O, CheckHash)) 815351278Sdim return E; 816351278Sdim ++BlockStats.NumSubBlocks; 817351278Sdim uint64_t SubBlockBitEnd = Stream.GetCurrentBitNo(); 818351278Sdim 819351278Sdim // Don't include subblock sizes in the size of this block. 820351278Sdim BlockBitStart += SubBlockBitEnd - SubBlockBitStart; 821351278Sdim continue; 822351278Sdim } 823351278Sdim case BitstreamEntry::Record: 824351278Sdim // The interesting case. 825351278Sdim break; 826351278Sdim } 827351278Sdim 828351278Sdim if (Entry.ID == bitc::DEFINE_ABBREV) { 829351278Sdim if (Error Err = Stream.ReadAbbrevRecord()) 830351278Sdim return Err; 831351278Sdim ++BlockStats.NumAbbrevs; 832351278Sdim continue; 833351278Sdim } 834351278Sdim 835351278Sdim Record.clear(); 836351278Sdim 837351278Sdim ++BlockStats.NumRecords; 838351278Sdim 839351278Sdim StringRef Blob; 840351278Sdim uint64_t CurrentRecordPos = Stream.GetCurrentBitNo(); 841351278Sdim Expected<unsigned> MaybeCode = Stream.readRecord(Entry.ID, Record, &Blob); 842351278Sdim if (!MaybeCode) 843351278Sdim return MaybeCode.takeError(); 844351278Sdim unsigned Code = MaybeCode.get(); 845351278Sdim 846351278Sdim // Increment the # occurrences of this code. 847351278Sdim if (BlockStats.CodeFreq.size() <= Code) 848351278Sdim BlockStats.CodeFreq.resize(Code + 1); 849351278Sdim BlockStats.CodeFreq[Code].NumInstances++; 850351278Sdim BlockStats.CodeFreq[Code].TotalBits += 851351278Sdim Stream.GetCurrentBitNo() - RecordStartBit; 852351278Sdim if (Entry.ID != bitc::UNABBREV_RECORD) { 853351278Sdim BlockStats.CodeFreq[Code].NumAbbrev++; 854351278Sdim ++BlockStats.NumAbbreviatedRecords; 855351278Sdim } 856351278Sdim 857351278Sdim if (DumpRecords) { 858351278Sdim O->OS << Indent << " <"; 859351278Sdim Optional<const char *> CodeName = 860351278Sdim GetCodeName(Code, BlockID, BlockInfo, CurStreamType); 861351278Sdim if (CodeName) 862351278Sdim O->OS << *CodeName; 863351278Sdim else 864351278Sdim O->OS << "UnknownCode" << Code; 865351278Sdim if (!O->Symbolic && CodeName) 866351278Sdim O->OS << " codeid=" << Code; 867351278Sdim const BitCodeAbbrev *Abbv = nullptr; 868351278Sdim if (Entry.ID != bitc::UNABBREV_RECORD) { 869351278Sdim Abbv = Stream.getAbbrev(Entry.ID); 870351278Sdim O->OS << " abbrevid=" << Entry.ID; 871351278Sdim } 872351278Sdim 873351278Sdim for (unsigned i = 0, e = Record.size(); i != e; ++i) 874351278Sdim O->OS << " op" << i << "=" << (int64_t)Record[i]; 875351278Sdim 876351278Sdim // If we found a metadata index, let's verify that we had an offset 877351278Sdim // before and validate its forward reference offset was correct! 878351278Sdim if (BlockID == bitc::METADATA_BLOCK_ID) { 879351278Sdim if (Code == bitc::METADATA_INDEX_OFFSET) { 880351278Sdim if (Record.size() != 2) 881351278Sdim O->OS << "(Invalid record)"; 882351278Sdim else { 883351278Sdim auto Offset = Record[0] + (Record[1] << 32); 884351278Sdim MetadataIndexOffset = Stream.GetCurrentBitNo() + Offset; 885351278Sdim } 886351278Sdim } 887351278Sdim if (Code == bitc::METADATA_INDEX) { 888351278Sdim O->OS << " (offset "; 889351278Sdim if (MetadataIndexOffset == RecordStartBit) 890351278Sdim O->OS << "match)"; 891351278Sdim else 892351278Sdim O->OS << "mismatch: " << MetadataIndexOffset << " vs " 893351278Sdim << RecordStartBit << ")"; 894351278Sdim } 895351278Sdim } 896351278Sdim 897351278Sdim // If we found a module hash, let's verify that it matches! 898351278Sdim if (BlockID == bitc::MODULE_BLOCK_ID && Code == bitc::MODULE_CODE_HASH && 899351278Sdim CheckHash.hasValue()) { 900351278Sdim if (Record.size() != 5) 901351278Sdim O->OS << " (invalid)"; 902351278Sdim else { 903351278Sdim // Recompute the hash and compare it to the one in the bitcode 904351278Sdim SHA1 Hasher; 905351278Sdim StringRef Hash; 906351278Sdim Hasher.update(*CheckHash); 907351278Sdim { 908351278Sdim int BlockSize = (CurrentRecordPos / 8) - BlockEntryPos; 909351278Sdim auto Ptr = Stream.getPointerToByte(BlockEntryPos, BlockSize); 910351278Sdim Hasher.update(ArrayRef<uint8_t>(Ptr, BlockSize)); 911351278Sdim Hash = Hasher.result(); 912351278Sdim } 913351278Sdim SmallString<20> RecordedHash; 914351278Sdim RecordedHash.resize(20); 915351278Sdim int Pos = 0; 916351278Sdim for (auto &Val : Record) { 917351278Sdim assert(!(Val >> 32) && "Unexpected high bits set"); 918351278Sdim RecordedHash[Pos++] = (Val >> 24) & 0xFF; 919351278Sdim RecordedHash[Pos++] = (Val >> 16) & 0xFF; 920351278Sdim RecordedHash[Pos++] = (Val >> 8) & 0xFF; 921351278Sdim RecordedHash[Pos++] = (Val >> 0) & 0xFF; 922351278Sdim } 923351278Sdim if (Hash == RecordedHash) 924351278Sdim O->OS << " (match)"; 925351278Sdim else 926351278Sdim O->OS << " (!mismatch!)"; 927351278Sdim } 928351278Sdim } 929351278Sdim 930351278Sdim O->OS << "/>"; 931351278Sdim 932351278Sdim if (Abbv) { 933351278Sdim for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i != e; ++i) { 934351278Sdim const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i); 935351278Sdim if (!Op.isEncoding() || Op.getEncoding() != BitCodeAbbrevOp::Array) 936351278Sdim continue; 937351278Sdim assert(i + 2 == e && "Array op not second to last"); 938351278Sdim std::string Str; 939351278Sdim bool ArrayIsPrintable = true; 940351278Sdim for (unsigned j = i - 1, je = Record.size(); j != je; ++j) { 941351278Sdim if (!isPrint(static_cast<unsigned char>(Record[j]))) { 942351278Sdim ArrayIsPrintable = false; 943351278Sdim break; 944351278Sdim } 945351278Sdim Str += (char)Record[j]; 946351278Sdim } 947351278Sdim if (ArrayIsPrintable) 948351278Sdim O->OS << " record string = '" << Str << "'"; 949351278Sdim break; 950351278Sdim } 951351278Sdim } 952351278Sdim 953351278Sdim if (Blob.data()) { 954351278Sdim if (canDecodeBlob(Code, BlockID)) { 955351278Sdim if (Error E = decodeMetadataStringsBlob(Indent, Record, Blob, O->OS)) 956351278Sdim return E; 957351278Sdim } else { 958351278Sdim O->OS << " blob data = "; 959351278Sdim if (O->ShowBinaryBlobs) { 960351278Sdim O->OS << "'"; 961351278Sdim O->OS.write_escaped(Blob, /*hex=*/true) << "'"; 962351278Sdim } else { 963351278Sdim bool BlobIsPrintable = true; 964351278Sdim for (unsigned i = 0, e = Blob.size(); i != e; ++i) 965351278Sdim if (!isPrint(static_cast<unsigned char>(Blob[i]))) { 966351278Sdim BlobIsPrintable = false; 967351278Sdim break; 968351278Sdim } 969351278Sdim 970351278Sdim if (BlobIsPrintable) 971351278Sdim O->OS << "'" << Blob << "'"; 972351278Sdim else 973351278Sdim O->OS << "unprintable, " << Blob.size() << " bytes."; 974351278Sdim } 975351278Sdim } 976351278Sdim } 977351278Sdim 978351278Sdim O->OS << "\n"; 979351278Sdim } 980351278Sdim 981351278Sdim // Make sure that we can skip the current record. 982351278Sdim if (Error Err = Stream.JumpToBit(CurrentRecordPos)) 983351278Sdim return Err; 984351278Sdim if (Expected<unsigned> Skipped = Stream.skipRecord(Entry.ID)) 985351278Sdim ; // Do nothing. 986351278Sdim else 987351278Sdim return Skipped.takeError(); 988351278Sdim } 989351278Sdim} 990351278Sdim 991