LLVM  10.0.0svn
BitcodeAnalyzer.cpp
Go to the documentation of this file.
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 
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.
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;
48  return "OPERAND_BUNDLE_TAGS_BLOCK";
50  return "MODULE_BLOCK";
52  return "PARAMATTR_BLOCK";
54  return "PARAMATTR_GROUP_BLOCK_ID";
56  return "TYPE_BLOCK_ID";
58  return "CONSTANTS_BLOCK";
60  return "FUNCTION_BLOCK";
62  return "IDENTIFICATION_BLOCK_ID";
64  return "VALUE_SYMTAB";
66  return "METADATA_BLOCK";
68  return "METADATA_KIND_BLOCK";
70  return "METADATA_ATTACHMENT_BLOCK";
72  return "USELIST_BLOCK_ID";
74  return "GLOBALVAL_SUMMARY_BLOCK";
76  return "FULL_LTO_GLOBALVAL_SUMMARY_BLOCK";
78  return "MODULE_STRTAB_BLOCK";
80  return "STRTAB_BLOCK";
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;
97  return "SETBID";
99  return "BLOCKNAME";
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.
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;
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  }
144  switch (CodeID) {
145  default:
146  return None;
147  STRINGIFY_CODE(IDENTIFICATION_CODE, STRING)
148  STRINGIFY_CODE(IDENTIFICATION_CODE, EPOCH)
149  }
151  switch (CodeID) {
152  default:
153  return None;
154  // FIXME: Should these be different?
156  return "ENTRY";
158  return "ENTRY";
159  }
161  switch (CodeID) {
162  default:
163  return None;
165  return "ENTRY";
166  }
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 
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)
217  return "CST_CODE_BLOCKADDRESS";
218  STRINGIFY_CODE(CST_CODE, DATA)
219  }
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  }
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  }
274  switch (CodeID) {
275  default:
276  return None;
277  STRINGIFY_CODE(MST_CODE, ENTRY)
278  STRINGIFY_CODE(MST_CODE, HASH)
279  }
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)
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  }
310  switch (CodeID) {
311  default:
312  return None;
313  STRINGIFY_CODE(METADATA, ATTACHMENT)
314  }
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  }
359  switch (CodeID) {
360  default:
361  return None;
362  STRINGIFY_CODE(METADATA, KIND)
363  }
365  switch (CodeID) {
366  default:
367  return None;
369  return "USELIST_CODE_DEFAULT";
371  return "USELIST_CODE_BB";
372  }
373 
375  switch (CodeID) {
376  default:
377  return None;
379  return "OPERAND_BUNDLE_TAG";
380  }
382  switch (CodeID) {
383  default:
384  return None;
385  case bitc::STRTAB_BLOB:
386  return "BLOB";
387  }
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 
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')
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')
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 
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]);
475  unsigned Offset = support::endian::read32le(&BufPtr[BWH_OffsetField]);
476  unsigned Size = support::endian::read32le(&BufPtr[BWH_SizeField]);
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,
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 
541  Optional<StringRef> BlockInfoBuffer)
542  : Stream(Buffer) {
543  if (BlockInfoBuffer)
544  BlockInfoStream.emplace(*BlockInfoBuffer);
545 }
546 
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 
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;
632  O.OS << "Clang Serialized AST\n";
633  break;
635  O.OS << "Clang Serialized Diagnostics\n";
636  break;
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,
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 
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 =
792  if (!MaybeEntry)
793  return MaybeEntry.takeError();
794  BitstreamEntry Entry = MaybeEntry.get();
795 
796  switch (Entry.Kind) {
798  return reportError("malformed bitcode file");
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 
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  }
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 
const NoneType None
Definition: None.h:23
bool isEncoding() const
Definition: BitCodes.h:113
Encoding getEncoding() const
Definition: BitCodes.h:119
This contains information emitted to BLOCKINFO_BLOCK blocks.
bool ShowBinaryBlobs
Print binary blobs using hex escapes.
const BitCodeAbbrev * getAbbrev(unsigned AbbrevID)
Return the abbreviation for the specified AbbrevId.
BLOCKINFO_BLOCK is used to define metadata about blocks, for example, standard abbrevs that should be...
Definition: BitCodes.h:70
bool isPrint(char C)
Checks whether character C is printable.
Definition: StringExtras.h:105
static Expected< CurStreamTypeType > ReadSignature(BitstreamCursor &Stream)
This class represents lattice values for constants.
Definition: AllocatorList.h:23
uint64_t GetCurrentBitNo() const
Return the bit # of the bit we are reading.
FormattedNumber format_hex(uint64_t N, unsigned Width, bool Upper=false)
format_hex - Output N as a fixed width hexadecimal.
Definition: Format.h:186
BitcodeAnalyzer(StringRef Buffer, Optional< StringRef > BlockInfoBuffer=None)
const uint8_t * getPointerToByte(uint64_t ByteNo, uint64_t NumBytes)
Get a pointer into the bitstream at the specified byte offset.
BitCodeAbbrev - This class represents an abbreviation record.
Definition: BitCodes.h:167
Expected< uint32_t > ReadVBR(unsigned NumBits)
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:124
#define ENUMERATOR(NodeKind)
bool isBitcodeWrapper(const unsigned char *BufPtr, const unsigned char *BufEnd)
isBitcodeWrapper - Return true if the given bytes are the magic bytes for an LLVM IR bitcode wrapper...
unsigned second
A class that wrap the SHA1 algorithm.
Definition: SHA1.h:28
Error takeError()
Take ownership of the stored error.
Definition: Error.h:552
void setBlockInfo(BitstreamBlockInfo *BI)
Set the block info to be used by this BitstreamCursor to interpret abbreviated records.
static Optional< const char * > GetBlockName(unsigned BlockID, const BitstreamBlockInfo &BlockInfo, CurStreamTypeType CurStreamType)
Return a symbolic block name if known, otherwise return null.
Expected< BitstreamEntry > advance(unsigned Flags=0)
Advance the current bitstream, returning the next entry in the stream.
bool Symbolic
Don&#39;t emit numeric info in dump if symbolic info is available.
static Expected< CurStreamTypeType > analyzeHeader(Optional< BCDumpOptions > O, BitstreamCursor &Stream)
LLVM_NODISCARD StringRef drop_front(size_t N=1) const
Return a StringRef equal to &#39;this&#39; but with the first N elements dropped.
Definition: StringRef.h:634
Error SkipBlock()
Having read the ENTER_SUBBLOCK abbrevid and a BlockID, skip over the body of this block...
static void printSize(raw_ostream &OS, double Bits)
LLVM_NODISCARD StringRef slice(size_t Start, size_t End) const
Return a reference to the substring from [Start, End).
Definition: StringRef.h:693
Tagged union holding either a T or a Error.
Definition: yaml2obj.h:21
If this flag is used, abbrev entries are returned just like normal records.
block placement Basic Block Placement Stats
static bool canDecodeBlob(unsigned Code, unsigned BlockID)
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:140
INLINEASM - Represents an inline asm block.
Definition: ISDOpcodes.h:703
#define ENTRY(ASMNAME, ENUM)
Expected< unsigned > ReadCode()
auto reverse(ContainerTy &&C, typename std::enable_if< has_rbegin< ContainerTy >::value >::type *=nullptr) -> decltype(make_range(C.rbegin(), C.rend()))
Definition: STLExtras.h:261
Expected< unsigned > skipRecord(unsigned AbbrevID)
Read the current record and discard it, returning the code for the record.
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:144
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:25
ArrayRef< uint8_t > getBitcodeBytes() const
Analysis containing CSE Info
Definition: CSEInfo.cpp:20
#define STRINGIFY_CODE(PREFIX, CODE)
UNDEF - An undefined node.
Definition: ISDOpcodes.h:177
uint64_t getCurrentByteNo() const
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:148
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This represents a position within a bitcode file, implemented on top of a SimpleBitstreamCursor.
#define H(x, y, z)
Definition: MD5.cpp:57
BitCodeAbbrevOp - This describes one or more operands in an abbreviation.
Definition: BitCodes.h:95
Expected< Optional< BitstreamBlockInfo > > ReadBlockInfoBlock(bool ReadBlockInfoNames=false)
Read and return a block info block from the bitstream.
constexpr double e
Definition: MathExtras.h:57
raw_ostream & OS
The stream.
const BlockInfo * getBlockInfo(unsigned BlockID) const
If there is block info for the specified ID, return it, otherwise return null.
unsigned getAbbrevIDWidth() const
Return the number of bits used to encode an abbrev #.
size_t size() const
Definition: SmallVector.h:52
Expected< unsigned > ReadSubBlockID()
Having read the ENTER_SUBBLOCK code, read the BlockID for the block.
const T * data() const
Definition: ArrayRef.h:145
Error JumpToBit(uint64_t BitNo)
Reset the stream to the specified bit number.
Expected< unsigned > readRecord(unsigned AbbrevID, SmallVectorImpl< uint64_t > &Vals, StringRef *Blob=nullptr)
static const char *const Magic
Definition: Archive.cpp:41
static const int BlockSize
Definition: TarWriter.cpp:33
raw_ostream & write_escaped(StringRef Str, bool UseHexEscapes=false)
Output Str, turning &#39;\&#39;, &#39;&#39;, &#39; &#39;, &#39;"&#39;, and anything that doesn&#39;t satisfy llvm::isPrint into an escape...
static ErrorSuccess success()
Create a success value.
Definition: Error.h:326
When advancing through a bitstream cursor, each advance can discover a few different kinds of entries...
auto size(R &&Range, typename std::enable_if< std::is_same< typename std::iterator_traits< decltype(Range.begin())>::iterator_category, std::random_access_iterator_tag >::value, void >::type *=nullptr) -> decltype(std::distance(Range.begin(), Range.end()))
Get the size of a range.
Definition: STLExtras.h:1146
static Error reportError(StringRef Message)
#define NODE(name)
This class maintains the abbreviations read from a block info block.
reference get()
Returns a reference to the stored T value.
Definition: Error.h:532
DEFINE_ABBREV - Defines an abbrev for the current block.
Definition: BitCodes.h:54
bool Histogram
Print per-code histogram.
Error analyze(Optional< BCDumpOptions > O=None, Optional< StringRef > CheckHash=None)
Analyze the bitcode file.
bool hasValue() const
Definition: Optional.h:259
Error EnterSubBlock(unsigned BlockID, unsigned *NumWordsP=nullptr)
Having read the ENTER_SUBBLOCK abbrevid, and enter the block.
bool SkipBitcodeWrapperHeader(const unsigned char *&BufPtr, const unsigned char *&BufEnd, bool VerifyBufferSize)
SkipBitcodeWrapperHeader - Some systems wrap bc files with a special header for padding or other reas...
#define I(x, y, z)
Definition: MD5.cpp:58
uint32_t read32le(const void *P)
Definition: Endian.h:383
uint32_t Size
Definition: Profile.cpp:46
LLVM_NODISCARD const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:136
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void stable_sort(R &&Range)
Definition: STLExtras.h:1289
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
void printStats(BCDumpOptions O, Optional< StringRef > Filename=None)
Print stats about the bitcode file.
static Optional< const char * > GetCodeName(unsigned CodeID, unsigned BlockID, const BitstreamBlockInfo &BlockInfo, CurStreamTypeType CurStreamType)
Return a symbolic code name if known, otherwise return null.
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
enum llvm::BitstreamEntry::@159 Kind
CurStreamTypeType
CurStreamTypeType - A type for CurStreamType.
This represents a position within a bitstream.
Expected< word_t > Read(unsigned NumBits)
const uint64_t Version
Definition: InstrProf.h:980
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1197
void resize(size_type N)
Definition: SmallVector.h:344