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