LLVM  15.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 
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 (const std::pair<unsigned, std::string> &RN : Info->RecordNames)
111  if (RN.first == CodeID)
112  return RN.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) // 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  }
145  switch (CodeID) {
146  default:
147  return None;
148  STRINGIFY_CODE(IDENTIFICATION_CODE, STRING)
149  STRINGIFY_CODE(IDENTIFICATION_CODE, EPOCH)
150  }
152  switch (CodeID) {
153  default:
154  return None;
155  // FIXME: Should these be different?
157  return "ENTRY";
159  return "ENTRY";
160  }
162  switch (CodeID) {
163  default:
164  return None;
166  return "ENTRY";
167  }
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 
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  STRINGIFY_CODE(CST_CODE, NO_CFI_VALUE)
224  return "CST_CODE_BLOCKADDRESS";
225  STRINGIFY_CODE(CST_CODE, DATA)
226  }
228  switch (CodeID) {
229  default:
230  return None;
231  STRINGIFY_CODE(FUNC_CODE, DECLAREBLOCKS)
232  STRINGIFY_CODE(FUNC_CODE, INST_BINOP)
233  STRINGIFY_CODE(FUNC_CODE, INST_CAST)
234  STRINGIFY_CODE(FUNC_CODE, INST_GEP_OLD)
235  STRINGIFY_CODE(FUNC_CODE, INST_INBOUNDS_GEP_OLD)
236  STRINGIFY_CODE(FUNC_CODE, INST_SELECT)
237  STRINGIFY_CODE(FUNC_CODE, INST_EXTRACTELT)
238  STRINGIFY_CODE(FUNC_CODE, INST_INSERTELT)
239  STRINGIFY_CODE(FUNC_CODE, INST_SHUFFLEVEC)
240  STRINGIFY_CODE(FUNC_CODE, INST_CMP)
241  STRINGIFY_CODE(FUNC_CODE, INST_RET)
242  STRINGIFY_CODE(FUNC_CODE, INST_BR)
243  STRINGIFY_CODE(FUNC_CODE, INST_SWITCH)
244  STRINGIFY_CODE(FUNC_CODE, INST_INVOKE)
245  STRINGIFY_CODE(FUNC_CODE, INST_UNOP)
246  STRINGIFY_CODE(FUNC_CODE, INST_UNREACHABLE)
247  STRINGIFY_CODE(FUNC_CODE, INST_CLEANUPRET)
248  STRINGIFY_CODE(FUNC_CODE, INST_CATCHRET)
249  STRINGIFY_CODE(FUNC_CODE, INST_CATCHPAD)
250  STRINGIFY_CODE(FUNC_CODE, INST_PHI)
251  STRINGIFY_CODE(FUNC_CODE, INST_ALLOCA)
252  STRINGIFY_CODE(FUNC_CODE, INST_LOAD)
253  STRINGIFY_CODE(FUNC_CODE, INST_VAARG)
254  STRINGIFY_CODE(FUNC_CODE, INST_STORE)
255  STRINGIFY_CODE(FUNC_CODE, INST_EXTRACTVAL)
256  STRINGIFY_CODE(FUNC_CODE, INST_INSERTVAL)
257  STRINGIFY_CODE(FUNC_CODE, INST_CMP2)
258  STRINGIFY_CODE(FUNC_CODE, INST_VSELECT)
259  STRINGIFY_CODE(FUNC_CODE, DEBUG_LOC_AGAIN)
260  STRINGIFY_CODE(FUNC_CODE, INST_CALL)
261  STRINGIFY_CODE(FUNC_CODE, DEBUG_LOC)
262  STRINGIFY_CODE(FUNC_CODE, INST_GEP)
263  STRINGIFY_CODE(FUNC_CODE, OPERAND_BUNDLE)
264  STRINGIFY_CODE(FUNC_CODE, INST_FENCE)
265  STRINGIFY_CODE(FUNC_CODE, INST_ATOMICRMW)
266  STRINGIFY_CODE(FUNC_CODE, INST_LOADATOMIC)
267  STRINGIFY_CODE(FUNC_CODE, INST_STOREATOMIC)
268  STRINGIFY_CODE(FUNC_CODE, INST_CMPXCHG)
269  STRINGIFY_CODE(FUNC_CODE, INST_CALLBR)
270  STRINGIFY_CODE(FUNC_CODE, BLOCKADDR_USERS)
271  }
273  switch (CodeID) {
274  default:
275  return None;
276  STRINGIFY_CODE(VST_CODE, ENTRY)
277  STRINGIFY_CODE(VST_CODE, BBENTRY)
278  STRINGIFY_CODE(VST_CODE, FNENTRY)
279  STRINGIFY_CODE(VST_CODE, COMBINED_ENTRY)
280  }
282  switch (CodeID) {
283  default:
284  return None;
285  STRINGIFY_CODE(MST_CODE, ENTRY)
286  STRINGIFY_CODE(MST_CODE, HASH)
287  }
290  switch (CodeID) {
291  default:
292  return None;
293  STRINGIFY_CODE(FS, PERMODULE)
294  STRINGIFY_CODE(FS, PERMODULE_PROFILE)
295  STRINGIFY_CODE(FS, PERMODULE_RELBF)
296  STRINGIFY_CODE(FS, PERMODULE_GLOBALVAR_INIT_REFS)
297  STRINGIFY_CODE(FS, PERMODULE_VTABLE_GLOBALVAR_INIT_REFS)
298  STRINGIFY_CODE(FS, COMBINED)
299  STRINGIFY_CODE(FS, COMBINED_PROFILE)
300  STRINGIFY_CODE(FS, COMBINED_GLOBALVAR_INIT_REFS)
301  STRINGIFY_CODE(FS, ALIAS)
302  STRINGIFY_CODE(FS, COMBINED_ALIAS)
303  STRINGIFY_CODE(FS, COMBINED_ORIGINAL_NAME)
305  STRINGIFY_CODE(FS, FLAGS)
306  STRINGIFY_CODE(FS, TYPE_TESTS)
307  STRINGIFY_CODE(FS, TYPE_TEST_ASSUME_VCALLS)
308  STRINGIFY_CODE(FS, TYPE_CHECKED_LOAD_VCALLS)
309  STRINGIFY_CODE(FS, TYPE_TEST_ASSUME_CONST_VCALL)
310  STRINGIFY_CODE(FS, TYPE_CHECKED_LOAD_CONST_VCALL)
311  STRINGIFY_CODE(FS, VALUE_GUID)
312  STRINGIFY_CODE(FS, CFI_FUNCTION_DEFS)
313  STRINGIFY_CODE(FS, CFI_FUNCTION_DECLS)
314  STRINGIFY_CODE(FS, TYPE_ID)
315  STRINGIFY_CODE(FS, TYPE_ID_METADATA)
316  STRINGIFY_CODE(FS, BLOCK_COUNT)
317  STRINGIFY_CODE(FS, PARAM_ACCESS)
318  }
320  switch (CodeID) {
321  default:
322  return None;
323  STRINGIFY_CODE(METADATA, ATTACHMENT)
324  }
326  switch (CodeID) {
327  default:
328  return None;
329  STRINGIFY_CODE(METADATA, STRING_OLD)
330  STRINGIFY_CODE(METADATA, VALUE)
331  STRINGIFY_CODE(METADATA, NODE)
332  STRINGIFY_CODE(METADATA, NAME)
333  STRINGIFY_CODE(METADATA, DISTINCT_NODE)
334  STRINGIFY_CODE(METADATA, KIND) // Older bitcode has it in a MODULE_BLOCK
335  STRINGIFY_CODE(METADATA, LOCATION)
336  STRINGIFY_CODE(METADATA, OLD_NODE)
337  STRINGIFY_CODE(METADATA, OLD_FN_NODE)
338  STRINGIFY_CODE(METADATA, NAMED_NODE)
339  STRINGIFY_CODE(METADATA, GENERIC_DEBUG)
340  STRINGIFY_CODE(METADATA, SUBRANGE)
341  STRINGIFY_CODE(METADATA, ENUMERATOR)
342  STRINGIFY_CODE(METADATA, BASIC_TYPE)
343  STRINGIFY_CODE(METADATA, FILE)
344  STRINGIFY_CODE(METADATA, DERIVED_TYPE)
345  STRINGIFY_CODE(METADATA, COMPOSITE_TYPE)
346  STRINGIFY_CODE(METADATA, SUBROUTINE_TYPE)
347  STRINGIFY_CODE(METADATA, COMPILE_UNIT)
348  STRINGIFY_CODE(METADATA, SUBPROGRAM)
349  STRINGIFY_CODE(METADATA, LEXICAL_BLOCK)
350  STRINGIFY_CODE(METADATA, LEXICAL_BLOCK_FILE)
351  STRINGIFY_CODE(METADATA, NAMESPACE)
352  STRINGIFY_CODE(METADATA, TEMPLATE_TYPE)
353  STRINGIFY_CODE(METADATA, TEMPLATE_VALUE)
354  STRINGIFY_CODE(METADATA, GLOBAL_VAR)
355  STRINGIFY_CODE(METADATA, LOCAL_VAR)
356  STRINGIFY_CODE(METADATA, EXPRESSION)
357  STRINGIFY_CODE(METADATA, OBJC_PROPERTY)
358  STRINGIFY_CODE(METADATA, IMPORTED_ENTITY)
359  STRINGIFY_CODE(METADATA, MODULE)
360  STRINGIFY_CODE(METADATA, MACRO)
361  STRINGIFY_CODE(METADATA, MACRO_FILE)
362  STRINGIFY_CODE(METADATA, STRINGS)
363  STRINGIFY_CODE(METADATA, GLOBAL_DECL_ATTACHMENT)
364  STRINGIFY_CODE(METADATA, GLOBAL_VAR_EXPR)
365  STRINGIFY_CODE(METADATA, INDEX_OFFSET)
366  STRINGIFY_CODE(METADATA, INDEX)
367  STRINGIFY_CODE(METADATA, ARG_LIST)
368  }
370  switch (CodeID) {
371  default:
372  return None;
373  STRINGIFY_CODE(METADATA, KIND)
374  }
376  switch (CodeID) {
377  default:
378  return None;
380  return "USELIST_CODE_DEFAULT";
382  return "USELIST_CODE_BB";
383  }
384 
386  switch (CodeID) {
387  default:
388  return None;
390  return "OPERAND_BUNDLE_TAG";
391  }
393  switch (CodeID) {
394  default:
395  return None;
396  case bitc::STRTAB_BLOB:
397  return "BLOB";
398  }
400  switch (CodeID) {
401  default:
402  return None;
403  case bitc::SYMTAB_BLOB:
404  return "BLOB";
405  }
406  }
407 #undef STRINGIFY_CODE
408 }
409 
410 static void printSize(raw_ostream &OS, double Bits) {
411  OS << format("%.2f/%.2fB/%luW", Bits, Bits / 8, (unsigned long)(Bits / 32));
412 }
413 static void printSize(raw_ostream &OS, uint64_t Bits) {
414  OS << format("%lub/%.2fB/%luW", (unsigned long)Bits, (double)Bits / 8,
415  (unsigned long)(Bits / 32));
416 }
417 
419  auto tryRead = [&Stream](char &Dest, size_t size) -> Error {
420  if (Expected<SimpleBitstreamCursor::word_t> MaybeWord = Stream.Read(size))
421  Dest = MaybeWord.get();
422  else
423  return MaybeWord.takeError();
424  return Error::success();
425  };
426 
427  char Signature[6];
428  if (Error Err = tryRead(Signature[0], 8))
429  return std::move(Err);
430  if (Error Err = tryRead(Signature[1], 8))
431  return std::move(Err);
432 
433  // Autodetect the file contents, if it is one we know.
434  if (Signature[0] == 'C' && Signature[1] == 'P') {
435  if (Error Err = tryRead(Signature[2], 8))
436  return std::move(Err);
437  if (Error Err = tryRead(Signature[3], 8))
438  return std::move(Err);
439  if (Signature[2] == 'C' && Signature[3] == 'H')
441  } else if (Signature[0] == 'D' && Signature[1] == 'I') {
442  if (Error Err = tryRead(Signature[2], 8))
443  return std::move(Err);
444  if (Error Err = tryRead(Signature[3], 8))
445  return std::move(Err);
446  if (Signature[2] == 'A' && Signature[3] == 'G')
448  } else if (Signature[0] == 'R' && Signature[1] == 'M') {
449  if (Error Err = tryRead(Signature[2], 8))
450  return std::move(Err);
451  if (Error Err = tryRead(Signature[3], 8))
452  return std::move(Err);
453  if (Signature[2] == 'R' && Signature[3] == 'K')
454  return LLVMBitstreamRemarks;
455  } else {
456  if (Error Err = tryRead(Signature[2], 4))
457  return std::move(Err);
458  if (Error Err = tryRead(Signature[3], 4))
459  return std::move(Err);
460  if (Error Err = tryRead(Signature[4], 4))
461  return std::move(Err);
462  if (Error Err = tryRead(Signature[5], 4))
463  return std::move(Err);
464  if (Signature[0] == 'B' && Signature[1] == 'C' && Signature[2] == 0x0 &&
465  Signature[3] == 0xC && Signature[4] == 0xE && Signature[5] == 0xD)
466  return LLVMIRBitstream;
467  }
468  return UnknownBitstream;
469 }
470 
472  BitstreamCursor &Stream) {
473  ArrayRef<uint8_t> Bytes = Stream.getBitcodeBytes();
474  const unsigned char *BufPtr = (const unsigned char *)Bytes.data();
475  const unsigned char *EndBufPtr = BufPtr + Bytes.size();
476 
477  // If we have a wrapper header, parse it and ignore the non-bc file
478  // contents. The magic number is 0x0B17C0DE stored in little endian.
479  if (isBitcodeWrapper(BufPtr, EndBufPtr)) {
480  if (Bytes.size() < BWH_HeaderSize)
481  return reportError("Invalid bitcode wrapper header");
482 
483  if (O) {
484  unsigned Magic = support::endian::read32le(&BufPtr[BWH_MagicField]);
486  unsigned Offset = support::endian::read32le(&BufPtr[BWH_OffsetField]);
487  unsigned Size = support::endian::read32le(&BufPtr[BWH_SizeField]);
489 
490  O->OS << "<BITCODE_WRAPPER_HEADER"
491  << " Magic=" << format_hex(Magic, 10)
492  << " Version=" << format_hex(Version, 10)
493  << " Offset=" << format_hex(Offset, 10)
494  << " Size=" << format_hex(Size, 10)
495  << " CPUType=" << format_hex(CPUType, 10) << "/>\n";
496  }
497 
498  if (SkipBitcodeWrapperHeader(BufPtr, EndBufPtr, true))
499  return reportError("Invalid bitcode wrapper header");
500  }
501 
502  // Use the cursor modified by skipping the wrapper header.
503  Stream = BitstreamCursor(ArrayRef<uint8_t>(BufPtr, EndBufPtr));
504 
505  return ReadSignature(Stream);
506 }
507 
508 static bool canDecodeBlob(unsigned Code, unsigned BlockID) {
509  return BlockID == bitc::METADATA_BLOCK_ID && Code == bitc::METADATA_STRINGS;
510 }
511 
512 Error BitcodeAnalyzer::decodeMetadataStringsBlob(StringRef Indent,
514  StringRef Blob,
515  raw_ostream &OS) {
516  if (Blob.empty())
517  return reportError("Cannot decode empty blob.");
518 
519  if (Record.size() != 2)
520  return reportError(
521  "Decoding metadata strings blob needs two record entries.");
522 
523  unsigned NumStrings = Record[0];
524  unsigned StringsOffset = Record[1];
525  OS << " num-strings = " << NumStrings << " {\n";
526 
527  StringRef Lengths = Blob.slice(0, StringsOffset);
528  SimpleBitstreamCursor R(Lengths);
529  StringRef Strings = Blob.drop_front(StringsOffset);
530  do {
531  if (R.AtEndOfStream())
532  return reportError("bad length");
533 
534  uint32_t Size;
535  if (Error E = R.ReadVBR(6).moveInto(Size))
536  return E;
537  if (Strings.size() < Size)
538  return reportError("truncated chars");
539 
540  OS << Indent << " '";
541  OS.write_escaped(Strings.slice(0, Size), /*hex=*/true);
542  OS << "'\n";
543  Strings = Strings.drop_front(Size);
544  } while (--NumStrings);
545 
546  OS << Indent << " }";
547  return Error::success();
548 }
549 
551  Optional<StringRef> BlockInfoBuffer)
552  : Stream(Buffer) {
553  if (BlockInfoBuffer)
554  BlockInfoStream.emplace(*BlockInfoBuffer);
555 }
556 
558  Optional<StringRef> CheckHash) {
559  if (Error E = analyzeHeader(O, Stream).moveInto(CurStreamType))
560  return E;
561 
562  Stream.setBlockInfo(&BlockInfo);
563 
564  // Read block info from BlockInfoStream, if specified.
565  // The block info must be a top-level block.
566  if (BlockInfoStream) {
567  BitstreamCursor BlockInfoCursor(*BlockInfoStream);
568  if (Error E = analyzeHeader(O, BlockInfoCursor).takeError())
569  return E;
570 
571  while (!BlockInfoCursor.AtEndOfStream()) {
572  Expected<unsigned> MaybeCode = BlockInfoCursor.ReadCode();
573  if (!MaybeCode)
574  return MaybeCode.takeError();
575  if (MaybeCode.get() != bitc::ENTER_SUBBLOCK)
576  return reportError("Invalid record at top-level in block info file");
577 
578  Expected<unsigned> MaybeBlockID = BlockInfoCursor.ReadSubBlockID();
579  if (!MaybeBlockID)
580  return MaybeBlockID.takeError();
581  if (MaybeBlockID.get() == bitc::BLOCKINFO_BLOCK_ID) {
582  Optional<BitstreamBlockInfo> NewBlockInfo;
583  if (Error E =
584  BlockInfoCursor.ReadBlockInfoBlock(/*ReadBlockInfoNames=*/true)
585  .moveInto(NewBlockInfo))
586  return E;
587  if (!NewBlockInfo)
588  return reportError("Malformed BlockInfoBlock in block info file");
589  BlockInfo = std::move(*NewBlockInfo);
590  break;
591  }
592 
593  if (Error Err = BlockInfoCursor.SkipBlock())
594  return Err;
595  }
596  }
597 
598  // Parse the top-level structure. We only allow blocks at the top-level.
599  while (!Stream.AtEndOfStream()) {
600  Expected<unsigned> MaybeCode = Stream.ReadCode();
601  if (!MaybeCode)
602  return MaybeCode.takeError();
603  if (MaybeCode.get() != bitc::ENTER_SUBBLOCK)
604  return reportError("Invalid record at top-level");
605 
606  Expected<unsigned> MaybeBlockID = Stream.ReadSubBlockID();
607  if (!MaybeBlockID)
608  return MaybeBlockID.takeError();
609 
610  if (Error E = parseBlock(MaybeBlockID.get(), 0, O, CheckHash))
611  return E;
612  ++NumTopBlocks;
613  }
614 
615  return Error::success();
616 }
617 
619  Optional<StringRef> Filename) {
620  uint64_t BufferSizeBits = Stream.getBitcodeBytes().size() * CHAR_BIT;
621  // Print a summary of the read file.
622  O.OS << "Summary ";
623  if (Filename)
624  O.OS << "of " << Filename->data() << ":\n";
625  O.OS << " Total size: ";
626  printSize(O.OS, BufferSizeBits);
627  O.OS << "\n";
628  O.OS << " Stream type: ";
629  switch (CurStreamType) {
630  case UnknownBitstream:
631  O.OS << "unknown\n";
632  break;
633  case LLVMIRBitstream:
634  O.OS << "LLVM IR\n";
635  break;
637  O.OS << "Clang Serialized AST\n";
638  break;
640  O.OS << "Clang Serialized Diagnostics\n";
641  break;
643  O.OS << "LLVM Remarks\n";
644  break;
645  }
646  O.OS << " # Toplevel Blocks: " << NumTopBlocks << "\n";
647  O.OS << "\n";
648 
649  // Emit per-block stats.
650  O.OS << "Per-block Summary:\n";
651  for (const auto &Stat : BlockIDStats) {
652  O.OS << " Block ID #" << Stat.first;
653  if (Optional<const char *> BlockName =
654  GetBlockName(Stat.first, BlockInfo, CurStreamType))
655  O.OS << " (" << *BlockName << ")";
656  O.OS << ":\n";
657 
658  const PerBlockIDStats &Stats = Stat.second;
659  O.OS << " Num Instances: " << Stats.NumInstances << "\n";
660  O.OS << " Total Size: ";
661  printSize(O.OS, Stats.NumBits);
662  O.OS << "\n";
663  double pct = (Stats.NumBits * 100.0) / BufferSizeBits;
664  O.OS << " Percent of file: " << format("%2.4f%%", pct) << "\n";
665  if (Stats.NumInstances > 1) {
666  O.OS << " Average Size: ";
667  printSize(O.OS, Stats.NumBits / (double)Stats.NumInstances);
668  O.OS << "\n";
669  O.OS << " Tot/Avg SubBlocks: " << Stats.NumSubBlocks << "/"
670  << Stats.NumSubBlocks / (double)Stats.NumInstances << "\n";
671  O.OS << " Tot/Avg Abbrevs: " << Stats.NumAbbrevs << "/"
672  << Stats.NumAbbrevs / (double)Stats.NumInstances << "\n";
673  O.OS << " Tot/Avg Records: " << Stats.NumRecords << "/"
674  << Stats.NumRecords / (double)Stats.NumInstances << "\n";
675  } else {
676  O.OS << " Num SubBlocks: " << Stats.NumSubBlocks << "\n";
677  O.OS << " Num Abbrevs: " << Stats.NumAbbrevs << "\n";
678  O.OS << " Num Records: " << Stats.NumRecords << "\n";
679  }
680  if (Stats.NumRecords) {
681  double pct = (Stats.NumAbbreviatedRecords * 100.0) / Stats.NumRecords;
682  O.OS << " Percent Abbrevs: " << format("%2.4f%%", pct) << "\n";
683  }
684  O.OS << "\n";
685 
686  // Print a histogram of the codes we see.
687  if (O.Histogram && !Stats.CodeFreq.empty()) {
688  std::vector<std::pair<unsigned, unsigned>> FreqPairs; // <freq,code>
689  for (unsigned i = 0, e = Stats.CodeFreq.size(); i != e; ++i)
690  if (unsigned Freq = Stats.CodeFreq[i].NumInstances)
691  FreqPairs.push_back(std::make_pair(Freq, i));
692  llvm::stable_sort(FreqPairs);
693  std::reverse(FreqPairs.begin(), FreqPairs.end());
694 
695  O.OS << "\tRecord Histogram:\n";
696  O.OS << "\t\t Count # Bits b/Rec % Abv Record Kind\n";
697  for (const auto &FreqPair : FreqPairs) {
698  const PerRecordStats &RecStats = Stats.CodeFreq[FreqPair.second];
699 
700  O.OS << format("\t\t%7d %9lu", RecStats.NumInstances,
701  (unsigned long)RecStats.TotalBits);
702 
703  if (RecStats.NumInstances > 1)
704  O.OS << format(" %9.1f",
705  (double)RecStats.TotalBits / RecStats.NumInstances);
706  else
707  O.OS << " ";
708 
709  if (RecStats.NumAbbrev)
710  O.OS << format(" %7.2f", (double)RecStats.NumAbbrev /
711  RecStats.NumInstances * 100);
712  else
713  O.OS << " ";
714 
715  O.OS << " ";
716  if (Optional<const char *> CodeName = GetCodeName(
717  FreqPair.second, Stat.first, BlockInfo, CurStreamType))
718  O.OS << *CodeName << "\n";
719  else
720  O.OS << "UnknownCode" << FreqPair.second << "\n";
721  }
722  O.OS << "\n";
723  }
724  }
725 }
726 
727 Error BitcodeAnalyzer::parseBlock(unsigned BlockID, unsigned IndentLevel,
729  Optional<StringRef> CheckHash) {
730  std::string Indent(IndentLevel * 2, ' ');
731  uint64_t BlockBitStart = Stream.GetCurrentBitNo();
732 
733  // Get the statistics for this BlockID.
734  PerBlockIDStats &BlockStats = BlockIDStats[BlockID];
735 
736  BlockStats.NumInstances++;
737 
738  // BLOCKINFO is a special part of the stream.
739  bool DumpRecords = O.has_value();
740  if (BlockID == bitc::BLOCKINFO_BLOCK_ID) {
741  if (O && !O->DumpBlockinfo)
742  O->OS << Indent << "<BLOCKINFO_BLOCK/>\n";
743  Optional<BitstreamBlockInfo> NewBlockInfo;
744  if (Error E = Stream.ReadBlockInfoBlock(/*ReadBlockInfoNames=*/true)
745  .moveInto(NewBlockInfo))
746  return E;
747  if (!NewBlockInfo)
748  return reportError("Malformed BlockInfoBlock");
749  BlockInfo = std::move(*NewBlockInfo);
750  if (Error Err = Stream.JumpToBit(BlockBitStart))
751  return Err;
752  // It's not really interesting to dump the contents of the blockinfo
753  // block, so only do it if the user explicitly requests it.
754  DumpRecords = O && O->DumpBlockinfo;
755  }
756 
757  unsigned NumWords = 0;
758  if (Error Err = Stream.EnterSubBlock(BlockID, &NumWords))
759  return Err;
760 
761  // Keep it for later, when we see a MODULE_HASH record
762  uint64_t BlockEntryPos = Stream.getCurrentByteNo();
763 
764  Optional<const char *> BlockName = None;
765  if (DumpRecords) {
766  O->OS << Indent << "<";
767  if ((BlockName = GetBlockName(BlockID, BlockInfo, CurStreamType)))
768  O->OS << *BlockName;
769  else
770  O->OS << "UnknownBlock" << BlockID;
771 
772  if (!O->Symbolic && BlockName)
773  O->OS << " BlockID=" << BlockID;
774 
775  O->OS << " NumWords=" << NumWords
776  << " BlockCodeSize=" << Stream.getAbbrevIDWidth() << ">\n";
777  }
778 
780 
781  // Keep the offset to the metadata index if seen.
782  uint64_t MetadataIndexOffset = 0;
783 
784  // Read all the records for this block.
785  while (true) {
786  if (Stream.AtEndOfStream())
787  return reportError("Premature end of bitstream");
788 
789  uint64_t RecordStartBit = Stream.GetCurrentBitNo();
790 
791  BitstreamEntry Entry;
793  .moveInto(Entry))
794  return E;
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  unsigned Code;
842  if (Error E = Stream.readRecord(Entry.ID, Record, &Blob).moveInto(Code))
843  return E;
844 
845  // Increment the # occurrences of this code.
846  if (BlockStats.CodeFreq.size() <= Code)
847  BlockStats.CodeFreq.resize(Code + 1);
848  BlockStats.CodeFreq[Code].NumInstances++;
849  BlockStats.CodeFreq[Code].TotalBits +=
850  Stream.GetCurrentBitNo() - RecordStartBit;
851  if (Entry.ID != bitc::UNABBREV_RECORD) {
852  BlockStats.CodeFreq[Code].NumAbbrev++;
853  ++BlockStats.NumAbbreviatedRecords;
854  }
855 
856  if (DumpRecords) {
857  O->OS << Indent << " <";
858  Optional<const char *> CodeName =
859  GetCodeName(Code, BlockID, BlockInfo, CurStreamType);
860  if (CodeName)
861  O->OS << *CodeName;
862  else
863  O->OS << "UnknownCode" << Code;
864  if (!O->Symbolic && CodeName)
865  O->OS << " codeid=" << Code;
866  const BitCodeAbbrev *Abbv = nullptr;
867  if (Entry.ID != bitc::UNABBREV_RECORD) {
868  Expected<const BitCodeAbbrev *> MaybeAbbv = Stream.getAbbrev(Entry.ID);
869  if (!MaybeAbbv)
870  return MaybeAbbv.takeError();
871  Abbv = MaybeAbbv.get();
872  O->OS << " abbrevid=" << Entry.ID;
873  }
874 
875  for (unsigned i = 0, e = Record.size(); i != e; ++i)
876  O->OS << " op" << i << "=" << (int64_t)Record[i];
877 
878  // If we found a metadata index, let's verify that we had an offset
879  // before and validate its forward reference offset was correct!
880  if (BlockID == bitc::METADATA_BLOCK_ID) {
881  if (Code == bitc::METADATA_INDEX_OFFSET) {
882  if (Record.size() != 2)
883  O->OS << "(Invalid record)";
884  else {
885  auto Offset = Record[0] + (Record[1] << 32);
886  MetadataIndexOffset = Stream.GetCurrentBitNo() + Offset;
887  }
888  }
889  if (Code == bitc::METADATA_INDEX) {
890  O->OS << " (offset ";
891  if (MetadataIndexOffset == RecordStartBit)
892  O->OS << "match)";
893  else
894  O->OS << "mismatch: " << MetadataIndexOffset << " vs "
895  << RecordStartBit << ")";
896  }
897  }
898 
899  // If we found a module hash, let's verify that it matches!
900  if (BlockID == bitc::MODULE_BLOCK_ID && Code == bitc::MODULE_CODE_HASH &&
901  CheckHash) {
902  if (Record.size() != 5)
903  O->OS << " (invalid)";
904  else {
905  // Recompute the hash and compare it to the one in the bitcode
906  SHA1 Hasher;
907  std::array<uint8_t, 20> Hash;
908  Hasher.update(*CheckHash);
909  {
910  int BlockSize = (CurrentRecordPos / 8) - BlockEntryPos;
911  auto Ptr = Stream.getPointerToByte(BlockEntryPos, BlockSize);
912  Hasher.update(ArrayRef<uint8_t>(Ptr, BlockSize));
913  Hash = Hasher.result();
914  }
915  std::array<uint8_t, 20> RecordedHash;
916  int Pos = 0;
917  for (auto &Val : Record) {
918  assert(!(Val >> 32) && "Unexpected high bits set");
919  support::endian::write32be(&RecordedHash[Pos], Val);
920  Pos += 4;
921  }
922  if (Hash == RecordedHash)
923  O->OS << " (match)";
924  else
925  O->OS << " (!mismatch!)";
926  }
927  }
928 
929  O->OS << "/>";
930 
931  if (Abbv) {
932  for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i != e; ++i) {
933  const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
934  if (!Op.isEncoding() || Op.getEncoding() != BitCodeAbbrevOp::Array)
935  continue;
936  assert(i + 2 == e && "Array op not second to last");
937  std::string Str;
938  bool ArrayIsPrintable = true;
939  for (unsigned j = i - 1, je = Record.size(); j != je; ++j) {
940  if (!isPrint(static_cast<unsigned char>(Record[j]))) {
941  ArrayIsPrintable = false;
942  break;
943  }
944  Str += (char)Record[j];
945  }
946  if (ArrayIsPrintable)
947  O->OS << " record string = '" << Str << "'";
948  break;
949  }
950  }
951 
952  if (Blob.data()) {
953  if (canDecodeBlob(Code, BlockID)) {
954  if (Error E = decodeMetadataStringsBlob(Indent, Record, Blob, O->OS))
955  return E;
956  } else {
957  O->OS << " blob data = ";
958  if (O->ShowBinaryBlobs) {
959  O->OS << "'";
960  O->OS.write_escaped(Blob, /*hex=*/true) << "'";
961  } else {
962  bool BlobIsPrintable = true;
963  for (char C : Blob)
964  if (!isPrint(static_cast<unsigned char>(C))) {
965  BlobIsPrintable = false;
966  break;
967  }
968 
969  if (BlobIsPrintable)
970  O->OS << "'" << Blob << "'";
971  else
972  O->OS << "unprintable, " << Blob.size() << " bytes.";
973  }
974  }
975  }
976 
977  O->OS << "\n";
978  }
979 
980  // Make sure that we can skip the current record.
981  if (Error Err = Stream.JumpToBit(CurrentRecordPos))
982  return Err;
983  if (Expected<unsigned> Skipped = Stream.skipRecord(Entry.ID))
984  ; // Do nothing.
985  else
986  return Skipped.takeError();
987  }
988 }
989 
llvm::Check::Size
@ Size
Definition: FileCheck.h:77
i
i
Definition: README.txt:29
llvm::bitc::CST_CODE_BLOCKADDRESS
@ CST_CODE_BLOCKADDRESS
Definition: LLVMBitCodes.h:379
llvm::BitCodeAbbrev::getNumOperandInfos
unsigned getNumOperandInfos() const
Definition: BitCodes.h:112
printSize
static void printSize(raw_ostream &OS, double Bits)
Definition: BitcodeAnalyzer.cpp:410
llvm::BitcodeAnalyzer::BitcodeAnalyzer
BitcodeAnalyzer(StringRef Buffer, Optional< StringRef > BlockInfoBuffer=None)
Definition: BitcodeAnalyzer.cpp:550
llvm::BitstreamCursor::ReadSubBlockID
Expected< unsigned > ReadSubBlockID()
Having read the ENTER_SUBBLOCK code, read the BlockID for the block.
Definition: BitstreamReader.h:480
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
BlockSize
static const int BlockSize
Definition: TarWriter.cpp:33
llvm::bitc::PARAMATTR_GROUP_BLOCK_ID
@ PARAMATTR_GROUP_BLOCK_ID
Definition: LLVMBitCodes.h:34
llvm::support::endian::write32be
void write32be(void *P, uint32_t V)
Definition: Endian.h:419
llvm::bitc::MODULE_BLOCK_ID
@ MODULE_BLOCK_ID
Definition: LLVMBitCodes.h:30
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:36
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:248
llvm::ClangSerializedDiagnosticsBitstream
@ ClangSerializedDiagnosticsBitstream
Definition: BitcodeAnalyzer.h:33
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:53
canDecodeBlob
static bool canDecodeBlob(unsigned Code, unsigned BlockID)
Definition: BitcodeAnalyzer.cpp:508
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:162
llvm::bitc::DEFINE_ABBREV
@ DEFINE_ABBREV
DEFINE_ABBREV - Defines an abbrev for the current block.
Definition: BitCodeEnums.h:53
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:329
llvm::bitc::SYMTAB_BLOB
@ SYMTAB_BLOB
Definition: LLVMBitCodes.h:704
R600_InstFlag::VECTOR
@ VECTOR
Definition: R600Defines.h:35
llvm::UnknownBitstream
@ UnknownBitstream
Definition: BitcodeAnalyzer.h:30
llvm::reverse
auto reverse(ContainerTy &&C, std::enable_if_t< has_rbegin< ContainerTy >::value > *=nullptr)
Definition: STLExtras.h:380
llvm::BitstreamCursor
This represents a position within a bitcode file, implemented on top of a SimpleBitstreamCursor.
Definition: BitstreamReader.h:358
llvm::tgtok::Bits
@ Bits
Definition: TGLexer.h:50
llvm::bitc::MODULE_CODE_HASH
@ MODULE_CODE_HASH
Definition: LLVMBitCodes.h:119
llvm::bitc::OPERAND_BUNDLE_TAG
@ OPERAND_BUNDLE_TAG
Definition: LLVMBitCodes.h:181
llvm::bitc::PARAMATTR_CODE_ENTRY
@ PARAMATTR_CODE_ENTRY
Definition: LLVMBitCodes.h:130
llvm::MachO::CPUType
CPUType
Definition: MachO.h:1441
llvm::BitstreamEntry::Record
@ Record
Definition: BitstreamReader.h:331
FUNCTION
#define FUNCTION(NAME, NARG, ROUND_MODE, INTRINSIC)
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: BitCodeEnums.h:69
llvm::bitc::METADATA_INDEX_OFFSET
@ METADATA_INDEX_OFFSET
Definition: LLVMBitCodes.h:344
llvm::BitstreamCursor::JumpToBit
Error JumpToBit(uint64_t BitNo)
Reset the stream to the specified bit number.
Definition: BitstreamReader.h:127
llvm::bitc::USELIST_CODE_BB
@ USELIST_CODE_BB
Definition: LLVMBitCodes.h:601
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:41
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:736
Format.h
llvm::bitc::SYMTAB_BLOCK_ID
@ SYMTAB_BLOCK_ID
Definition: LLVMBitCodes.h:63
llvm::ArrayRef::data
const T * data() const
Definition: ArrayRef.h:161
llvm::BitstreamCursor::ReadCode
Expected< unsigned > ReadCode()
Definition: BitstreamReader.h:474
llvm::RISCVFenceField::R
@ R
Definition: RISCVBaseInfo.h:240
llvm::BitstreamCursor::AF_DontAutoprocessAbbrevs
@ AF_DontAutoprocessAbbrevs
If this flag is used, abbrev entries are returned just like normal records.
Definition: BitstreamReader.h:414
llvm::bitc::ENTER_SUBBLOCK
@ ENTER_SUBBLOCK
Definition: BitCodeEnums.h:46
llvm::ISD::INLINEASM
@ INLINEASM
INLINEASM - Represents an inline asm block.
Definition: ISDOpcodes.h:1025
llvm::bitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID
@ FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID
Definition: LLVMBitCodes.h:61
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:44
llvm::MODULE
@ MODULE
Definition: Attributor.h:5034
llvm::bitc::MODULE_STRTAB_BLOCK_ID
@ MODULE_STRTAB_BLOCK_ID
Definition: LLVMBitCodes.h:52
llvm::bitc::METADATA_INDEX
@ METADATA_INDEX
Definition: LLVMBitCodes.h:345
llvm::bitc::METADATA_KIND_BLOCK_ID
@ METADATA_KIND_BLOCK_ID
Definition: LLVMBitCodes.h:57
llvm::SHA1
A class that wrap the SHA1 algorithm.
Definition: SHA1.h:26
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::BitstreamCursor::setBlockInfo
void setBlockInfo(BitstreamBlockInfo *BI)
Set the block info to be used by this BitstreamCursor to interpret abbreviated records.
Definition: BitstreamReader.h:573
llvm::BWH_CPUTypeField
@ BWH_CPUTypeField
Definition: BitCodeEnums.h:31
reportError
static Error reportError(StringRef Message)
Definition: BitcodeAnalyzer.cpp:19
llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME
@ BLOCKINFO_CODE_SETRECORDNAME
Definition: BitCodeEnums.h:83
llvm::BWH_OffsetField
@ BWH_OffsetField
Definition: BitCodeEnums.h:29
llvm::BitstreamCursor::ReadAbbrevRecord
Error ReadAbbrevRecord()
Definition: BitstreamReader.cpp:362
llvm::BWH_MagicField
@ BWH_MagicField
Definition: BitCodeEnums.h:27
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:54
llvm::bitc::FIRST_APPLICATION_BLOCKID
@ FIRST_APPLICATION_BLOCKID
Definition: BitCodeEnums.h:72
llvm::IndexedInstrProf::Version
const uint64_t Version
Definition: InstrProf.h:1027
Info
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
analyzeHeader
static Expected< CurStreamTypeType > analyzeHeader(Optional< BCDumpOptions > O, BitstreamCursor &Stream)
Definition: BitcodeAnalyzer.cpp:471
llvm::None
const NoneType None
Definition: None.h:24
llvm::BitstreamCursor::EnterSubBlock
Error EnterSubBlock(unsigned BlockID, unsigned *NumWordsP=nullptr)
Having read the ENTER_SUBBLOCK abbrevid, and enter the block.
Definition: BitstreamReader.cpp:25
llvm::BWH_HeaderSize
@ BWH_HeaderSize
Definition: BitCodeEnums.h:32
BitstreamReader.h
llvm::BWH_SizeField
@ BWH_SizeField
Definition: BitCodeEnums.h:30
llvm::BCDumpOptions
Definition: BitcodeAnalyzer.h:37
VOID
@ VOID
Definition: DXILOpLowering.cpp:33
FLOAT
@ FLOAT
Definition: DXILOpLowering.cpp:35
llvm::SimpleBitstreamCursor
This represents a position within a bitstream.
Definition: BitstreamReader.h:79
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:239
llvm::BitstreamCursor::GetCurrentBitNo
uint64_t GetCurrentBitNo() const
Return the bit # of the bit we are reading.
Definition: BitstreamReader.h:117
llvm::AMDGPU::Hwreg::Offset
Offset
Definition: SIDefines.h:413
llvm::StringRef::empty
constexpr LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
llvm::bitc::PARAMATTR_BLOCK_ID
@ PARAMATTR_BLOCK_ID
Definition: LLVMBitCodes.h:33
uint64_t
llvm::bitc::USELIST_CODE_DEFAULT
@ USELIST_CODE_DEFAULT
Definition: LLVMBitCodes.h:600
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:42
llvm::BitstreamBlockInfo::BlockInfo
This contains information emitted to BLOCKINFO_BLOCK blocks.
Definition: BitstreamReader.h:40
llvm::BitCodeAbbrevOp::Array
@ Array
Definition: BitCodes.h:41
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::BitstreamEntry::EndBlock
@ EndBlock
Definition: BitstreamReader.h:328
llvm::X86AS::FS
@ FS
Definition: X86.h:192
llvm::SPIRV::Decoration::Stream
@ Stream
llvm::BitstreamCursor::ReadBlockInfoBlock
Expected< Optional< BitstreamBlockInfo > > ReadBlockInfoBlock(bool ReadBlockInfoNames=false)
Read and return a block info block from the bitstream.
Definition: BitstreamReader.cpp:421
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:148
llvm::bitc::PARAMATTR_GRP_CODE_ENTRY
@ PARAMATTR_GRP_CODE_ENTRY
Definition: LLVMBitCodes.h:131
llvm::Record
Definition: Record.h:1543
llvm::bitc::BLOCKINFO_CODE_SETBID
@ BLOCKINFO_CODE_SETBID
Definition: BitCodeEnums.h:81
llvm::ClangSerializedASTBitstream
@ ClangSerializedASTBitstream
Definition: BitcodeAnalyzer.h:32
llvm::BitstreamCursor::readRecord
Expected< unsigned > readRecord(unsigned AbbrevID, SmallVectorImpl< uint64_t > &Vals, StringRef *Blob=nullptr)
Definition: BitstreamReader.cpp:213
llvm::BitstreamCursor::AtEndOfStream
bool AtEndOfStream()
Definition: BitstreamReader.h:112
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:1598
llvm::bitc::PARAMATTR_CODE_ENTRY_OLD
@ PARAMATTR_CODE_ENTRY_OLD
Definition: LLVMBitCodes.h:128
llvm::bitc::BLOCKINFO_CODE_BLOCKNAME
@ BLOCKINFO_CODE_BLOCKNAME
Definition: BitCodeEnums.h:82
llvm::SHA1::update
void update(ArrayRef< uint8_t > Data)
Digest more data.
Definition: SHA1.cpp:213
llvm::BitstreamCursor::getAbbrevIDWidth
unsigned getAbbrevIDWidth() const
Return the number of bits used to encode an abbrev #.
Definition: BitstreamReader.h:404
llvm::BitCodeAbbrev::getOperandInfo
const BitCodeAbbrevOp & getOperandInfo(unsigned N) const
Definition: BitCodes.h:115
llvm::BitcodeAnalyzer::analyze
Error analyze(Optional< BCDumpOptions > O=None, Optional< StringRef > CheckHash=None)
Analyze the bitcode file.
Definition: BitcodeAnalyzer.cpp:557
llvm::ArrayRef< uint8_t >
BitCodes.h
llvm::bitc::STRTAB_BLOCK_ID
@ STRTAB_BLOCK_ID
Definition: LLVMBitCodes.h:59
llvm::BitstreamEntry::Error
@ Error
Definition: BitstreamReader.h:327
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::msf::Magic
static const char Magic[]
Definition: MSFCommon.h:23
NODE
#define NODE(NodeKind)
Definition: ItaniumDemangle.h:2361
llvm::BitstreamCursor::getBitcodeBytes
ArrayRef< uint8_t > getBitcodeBytes() const
Definition: BitstreamReader.h:124
llvm::Expected::get
reference get()
Returns a reference to the stored T value.
Definition: Error.h:567
HALF
@ HALF
Definition: DXILOpLowering.cpp:34
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:418
llvm::ISD::UNDEF
@ UNDEF
UNDEF - An undefined node.
Definition: ISDOpcodes.h:211
llvm::bitc::CONSTANTS_BLOCK_ID
@ CONSTANTS_BLOCK_ID
Definition: LLVMBitCodes.h:36
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::BitstreamEntry::SubBlock
@ SubBlock
Definition: BitstreamReader.h:330
llvm::LLVMIRBitstream
@ LLVMIRBitstream
Definition: BitcodeAnalyzer.h:31
llvm::bitc::TYPE_BLOCK_ID_NEW
@ TYPE_BLOCK_ID_NEW
Definition: LLVMBitCodes.h:48
j
return j(j<< 16)
LLVMBitCodes.h
llvm::stable_sort
void stable_sort(R &&Range)
Definition: STLExtras.h:1761
llvm::createStringError
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1239
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: BitCodeEnums.h:57
Stats
block placement Basic Block Placement Stats
Definition: MachineBlockPlacement.cpp:3656
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:657
llvm::BitstreamEntry
When advancing through a bitstream cursor, each advance can discover a few different kinds of entries...
Definition: BitstreamReader.h:325
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:345
llvm::bitc::METADATA_STRINGS
@ METADATA_STRINGS
Definition: LLVMBitCodes.h:341
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:155
llvm::BTF::VERSION
@ VERSION
Definition: BTF.h:54
llvm::bitc::GLOBALVAL_SUMMARY_BLOCK_ID
@ GLOBALVAL_SUMMARY_BLOCK_ID
Definition: LLVMBitCodes.h:53
llvm::bitc::FUNCTION_BLOCK_ID
@ FUNCTION_BLOCK_ID
Definition: LLVMBitCodes.h:37
STRINGIFY_CODE
#define STRINGIFY_CODE(PREFIX, CODE)
ReadSignature
static Expected< CurStreamTypeType > ReadSignature(BitstreamCursor &Stream)
Definition: BitcodeAnalyzer.cpp:418
llvm::bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID
@ OPERAND_BUNDLE_TAGS_BLOCK_ID
Definition: LLVMBitCodes.h:55
llvm::bitc::METADATA_ATTACHMENT_ID
@ METADATA_ATTACHMENT_ID
Definition: LLVMBitCodes.h:46
llvm::CurStreamTypeType
CurStreamTypeType
CurStreamTypeType - A type for CurStreamType.
Definition: BitcodeAnalyzer.h:29
llvm::BitstreamCursor::getCurrentByteNo
uint64_t getCurrentByteNo() const
Definition: BitstreamReader.h:122
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:200
SHA1.h
llvm::BitCodeAbbrevOp
BitCodeAbbrevOp - This describes one or more operands in an abbreviation.
Definition: BitCodes.h:33
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:597
llvm::bitc::METADATA_BLOCK_ID
@ METADATA_BLOCK_ID
Definition: LLVMBitCodes.h:45
llvm::BitCodeAbbrev
BitCodeAbbrev - This class represents an abbreviation record.
Definition: BitCodes.h:103
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:700
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:164
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:50
RN
It looks like we only need to define PPCfmarto for these because according to these instructions perform RTO on fma s src2 rnd ← FPSCR RN
Definition: README_P9.txt:262
llvm::BWH_VersionField
@ BWH_VersionField
Definition: BitCodeEnums.h:28
BitcodeReader.h
llvm::BitcodeAnalyzer::printStats
void printStats(BCDumpOptions O, Optional< StringRef > Filename=None)
Print stats about the bitcode file.
Definition: BitcodeAnalyzer.cpp:618
llvm::LLVMBitstreamRemarks
@ LLVMBitstreamRemarks
Definition: BitcodeAnalyzer.h:34
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:484
llvm::BitstreamCursor::getAbbrev
Expected< const BitCodeAbbrev * > getAbbrev(unsigned AbbrevID)
Return the abbreviation for the specified AbbrevId.
Definition: BitstreamReader.h:543
DOUBLE
@ DOUBLE
Definition: DXILOpLowering.cpp:36