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 (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;
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  STRINGIFY_CODE(CST_CODE, NO_CFI_VALUE)
223  case bitc::CST_CODE_BLOCKADDRESS:
224  return "CST_CODE_BLOCKADDRESS";
225  STRINGIFY_CODE(CST_CODE, DATA)
226  }
227  case bitc::FUNCTION_BLOCK_ID:
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  }
271  case bitc::VALUE_SYMTAB_BLOCK_ID:
272  switch (CodeID) {
273  default:
274  return None;
275  STRINGIFY_CODE(VST_CODE, ENTRY)
276  STRINGIFY_CODE(VST_CODE, BBENTRY)
277  STRINGIFY_CODE(VST_CODE, FNENTRY)
278  STRINGIFY_CODE(VST_CODE, COMBINED_ENTRY)
279  }
280  case bitc::MODULE_STRTAB_BLOCK_ID:
281  switch (CodeID) {
282  default:
283  return None;
284  STRINGIFY_CODE(MST_CODE, ENTRY)
285  STRINGIFY_CODE(MST_CODE, HASH)
286  }
287  case bitc::GLOBALVAL_SUMMARY_BLOCK_ID:
288  case bitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID:
289  switch (CodeID) {
290  default:
291  return None;
292  STRINGIFY_CODE(FS, PERMODULE)
293  STRINGIFY_CODE(FS, PERMODULE_PROFILE)
294  STRINGIFY_CODE(FS, PERMODULE_RELBF)
295  STRINGIFY_CODE(FS, PERMODULE_GLOBALVAR_INIT_REFS)
296  STRINGIFY_CODE(FS, PERMODULE_VTABLE_GLOBALVAR_INIT_REFS)
297  STRINGIFY_CODE(FS, COMBINED)
298  STRINGIFY_CODE(FS, COMBINED_PROFILE)
299  STRINGIFY_CODE(FS, COMBINED_GLOBALVAR_INIT_REFS)
300  STRINGIFY_CODE(FS, ALIAS)
301  STRINGIFY_CODE(FS, COMBINED_ALIAS)
302  STRINGIFY_CODE(FS, COMBINED_ORIGINAL_NAME)
303  STRINGIFY_CODE(FS, VERSION)
304  STRINGIFY_CODE(FS, FLAGS)
305  STRINGIFY_CODE(FS, TYPE_TESTS)
306  STRINGIFY_CODE(FS, TYPE_TEST_ASSUME_VCALLS)
307  STRINGIFY_CODE(FS, TYPE_CHECKED_LOAD_VCALLS)
308  STRINGIFY_CODE(FS, TYPE_TEST_ASSUME_CONST_VCALL)
309  STRINGIFY_CODE(FS, TYPE_CHECKED_LOAD_CONST_VCALL)
310  STRINGIFY_CODE(FS, VALUE_GUID)
311  STRINGIFY_CODE(FS, CFI_FUNCTION_DEFS)
312  STRINGIFY_CODE(FS, CFI_FUNCTION_DECLS)
313  STRINGIFY_CODE(FS, TYPE_ID)
314  STRINGIFY_CODE(FS, TYPE_ID_METADATA)
315  STRINGIFY_CODE(FS, BLOCK_COUNT)
316  STRINGIFY_CODE(FS, PARAM_ACCESS)
317  }
318  case bitc::METADATA_ATTACHMENT_ID:
319  switch (CodeID) {
320  default:
321  return None;
322  STRINGIFY_CODE(METADATA, ATTACHMENT)
323  }
324  case bitc::METADATA_BLOCK_ID:
325  switch (CodeID) {
326  default:
327  return None;
328  STRINGIFY_CODE(METADATA, STRING_OLD)
329  STRINGIFY_CODE(METADATA, VALUE)
330  STRINGIFY_CODE(METADATA, NODE)
331  STRINGIFY_CODE(METADATA, NAME)
332  STRINGIFY_CODE(METADATA, DISTINCT_NODE)
333  STRINGIFY_CODE(METADATA, KIND) // Older bitcode has it in a MODULE_BLOCK
334  STRINGIFY_CODE(METADATA, LOCATION)
335  STRINGIFY_CODE(METADATA, OLD_NODE)
336  STRINGIFY_CODE(METADATA, OLD_FN_NODE)
337  STRINGIFY_CODE(METADATA, NAMED_NODE)
338  STRINGIFY_CODE(METADATA, GENERIC_DEBUG)
339  STRINGIFY_CODE(METADATA, SUBRANGE)
340  STRINGIFY_CODE(METADATA, ENUMERATOR)
341  STRINGIFY_CODE(METADATA, BASIC_TYPE)
342  STRINGIFY_CODE(METADATA, FILE)
343  STRINGIFY_CODE(METADATA, DERIVED_TYPE)
344  STRINGIFY_CODE(METADATA, COMPOSITE_TYPE)
345  STRINGIFY_CODE(METADATA, SUBROUTINE_TYPE)
346  STRINGIFY_CODE(METADATA, COMPILE_UNIT)
347  STRINGIFY_CODE(METADATA, SUBPROGRAM)
348  STRINGIFY_CODE(METADATA, LEXICAL_BLOCK)
349  STRINGIFY_CODE(METADATA, LEXICAL_BLOCK_FILE)
350  STRINGIFY_CODE(METADATA, NAMESPACE)
351  STRINGIFY_CODE(METADATA, TEMPLATE_TYPE)
352  STRINGIFY_CODE(METADATA, TEMPLATE_VALUE)
353  STRINGIFY_CODE(METADATA, GLOBAL_VAR)
354  STRINGIFY_CODE(METADATA, LOCAL_VAR)
355  STRINGIFY_CODE(METADATA, EXPRESSION)
356  STRINGIFY_CODE(METADATA, OBJC_PROPERTY)
357  STRINGIFY_CODE(METADATA, IMPORTED_ENTITY)
358  STRINGIFY_CODE(METADATA, MODULE)
359  STRINGIFY_CODE(METADATA, MACRO)
360  STRINGIFY_CODE(METADATA, MACRO_FILE)
361  STRINGIFY_CODE(METADATA, STRINGS)
362  STRINGIFY_CODE(METADATA, GLOBAL_DECL_ATTACHMENT)
363  STRINGIFY_CODE(METADATA, GLOBAL_VAR_EXPR)
364  STRINGIFY_CODE(METADATA, INDEX_OFFSET)
365  STRINGIFY_CODE(METADATA, INDEX)
366  STRINGIFY_CODE(METADATA, ARG_LIST)
367  }
368  case bitc::METADATA_KIND_BLOCK_ID:
369  switch (CodeID) {
370  default:
371  return None;
372  STRINGIFY_CODE(METADATA, KIND)
373  }
374  case bitc::USELIST_BLOCK_ID:
375  switch (CodeID) {
376  default:
377  return None;
378  case bitc::USELIST_CODE_DEFAULT:
379  return "USELIST_CODE_DEFAULT";
380  case bitc::USELIST_CODE_BB:
381  return "USELIST_CODE_BB";
382  }
383 
384  case bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID:
385  switch (CodeID) {
386  default:
387  return None;
388  case bitc::OPERAND_BUNDLE_TAG:
389  return "OPERAND_BUNDLE_TAG";
390  }
391  case bitc::STRTAB_BLOCK_ID:
392  switch (CodeID) {
393  default:
394  return None;
395  case bitc::STRTAB_BLOB:
396  return "BLOB";
397  }
398  case bitc::SYMTAB_BLOCK_ID:
399  switch (CodeID) {
400  default:
401  return None;
402  case bitc::SYMTAB_BLOB:
403  return "BLOB";
404  }
405  }
406 #undef STRINGIFY_CODE
407 }
408 
409 static void printSize(raw_ostream &OS, double Bits) {
410  OS << format("%.2f/%.2fB/%luW", Bits, Bits / 8, (unsigned long)(Bits / 32));
411 }
412 static void printSize(raw_ostream &OS, uint64_t Bits) {
413  OS << format("%lub/%.2fB/%luW", (unsigned long)Bits, (double)Bits / 8,
414  (unsigned long)(Bits / 32));
415 }
416 
417 static Expected<CurStreamTypeType> ReadSignature(BitstreamCursor &Stream) {
418  auto tryRead = [&Stream](char &Dest, size_t size) -> Error {
419  if (Expected<SimpleBitstreamCursor::word_t> MaybeWord = Stream.Read(size))
420  Dest = MaybeWord.get();
421  else
422  return MaybeWord.takeError();
423  return Error::success();
424  };
425 
426  char Signature[6];
427  if (Error Err = tryRead(Signature[0], 8))
428  return std::move(Err);
429  if (Error Err = tryRead(Signature[1], 8))
430  return std::move(Err);
431 
432  // Autodetect the file contents, if it is one we know.
433  if (Signature[0] == 'C' && Signature[1] == 'P') {
434  if (Error Err = tryRead(Signature[2], 8))
435  return std::move(Err);
436  if (Error Err = tryRead(Signature[3], 8))
437  return std::move(Err);
438  if (Signature[2] == 'C' && Signature[3] == 'H')
439  return ClangSerializedASTBitstream;
440  } else if (Signature[0] == 'D' && Signature[1] == 'I') {
441  if (Error Err = tryRead(Signature[2], 8))
442  return std::move(Err);
443  if (Error Err = tryRead(Signature[3], 8))
444  return std::move(Err);
445  if (Signature[2] == 'A' && Signature[3] == 'G')
446  return ClangSerializedDiagnosticsBitstream;
447  } else if (Signature[0] == 'R' && Signature[1] == 'M') {
448  if (Error Err = tryRead(Signature[2], 8))
449  return std::move(Err);
450  if (Error Err = tryRead(Signature[3], 8))
451  return std::move(Err);
452  if (Signature[2] == 'R' && Signature[3] == 'K')
453  return LLVMBitstreamRemarks;
454  } else {
455  if (Error Err = tryRead(Signature[2], 4))
456  return std::move(Err);
457  if (Error Err = tryRead(Signature[3], 4))
458  return std::move(Err);
459  if (Error Err = tryRead(Signature[4], 4))
460  return std::move(Err);
461  if (Error Err = tryRead(Signature[5], 4))
462  return std::move(Err);
463  if (Signature[0] == 'B' && Signature[1] == 'C' && Signature[2] == 0x0 &&
464  Signature[3] == 0xC && Signature[4] == 0xE && Signature[5] == 0xD)
465  return LLVMIRBitstream;
466  }
467  return UnknownBitstream;
468 }
469 
470 static Expected<CurStreamTypeType> analyzeHeader(Optional<BCDumpOptions> O,
471  BitstreamCursor &Stream) {
472  ArrayRef<uint8_t> Bytes = Stream.getBitcodeBytes();
473  const unsigned char *BufPtr = (const unsigned char *)Bytes.data();
474  const unsigned char *EndBufPtr = BufPtr + Bytes.size();
475 
476  // If we have a wrapper header, parse it and ignore the non-bc file
477  // contents. The magic number is 0x0B17C0DE stored in little endian.
478  if (isBitcodeWrapper(BufPtr, EndBufPtr)) {
479  if (Bytes.size() < BWH_HeaderSize)
480  return reportError("Invalid bitcode wrapper header");
481 
482  if (O) {
483  unsigned Magic = support::endian::read32le(&BufPtr[BWH_MagicField]);
484  unsigned Version = support::endian::read32le(&BufPtr[BWH_VersionField]);
485  unsigned Offset = support::endian::read32le(&BufPtr[BWH_OffsetField]);
486  unsigned Size = support::endian::read32le(&BufPtr[BWH_SizeField]);
487  unsigned CPUType = support::endian::read32le(&BufPtr[BWH_CPUTypeField]);
488 
489  O->OS << "<BITCODE_WRAPPER_HEADER"
490  << " Magic=" << format_hex(Magic, 10)
491  << " Version=" << format_hex(Version, 10)
492  << " Offset=" << format_hex(Offset, 10)
493  << " Size=" << format_hex(Size, 10)
494  << " CPUType=" << format_hex(CPUType, 10) << "/>\n";
495  }
496 
497  if (SkipBitcodeWrapperHeader(BufPtr, EndBufPtr, true))
498  return reportError("Invalid bitcode wrapper header");
499  }
500 
501  // Use the cursor modified by skipping the wrapper header.
502  Stream = BitstreamCursor(ArrayRef<uint8_t>(BufPtr, EndBufPtr));
503 
504  return ReadSignature(Stream);
505 }
506 
507 static bool canDecodeBlob(unsigned Code, unsigned BlockID) {
508  return BlockID == bitc::METADATA_BLOCK_ID && Code == bitc::METADATA_STRINGS;
509 }
510 
511 Error BitcodeAnalyzer::decodeMetadataStringsBlob(StringRef Indent,
512  ArrayRef<uint64_t> Record,
513  StringRef Blob,
514  raw_ostream &OS) {
515  if (Blob.empty())
516  return reportError("Cannot decode empty blob.");
517 
518  if (Record.size() != 2)
519  return reportError(
520  "Decoding metadata strings blob needs two record entries.");
521 
522  unsigned NumStrings = Record[0];
523  unsigned StringsOffset = Record[1];
524  OS << " num-strings = " << NumStrings << " {\n";
525 
526  StringRef Lengths = Blob.slice(0, StringsOffset);
527  SimpleBitstreamCursor R(Lengths);
528  StringRef Strings = Blob.drop_front(StringsOffset);
529  do {
530  if (R.AtEndOfStream())
531  return reportError("bad length");
532 
533  uint32_t Size;
534  if (Error E = R.ReadVBR(6).moveInto(Size))
535  return E;
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  if (Error E = analyzeHeader(O, Stream).moveInto(CurStreamType))
559  return E;
560 
561  Stream.setBlockInfo(&BlockInfo);
562 
563  // Read block info from BlockInfoStream, if specified.
564  // The block info must be a top-level block.
565  if (BlockInfoStream) {
566  BitstreamCursor BlockInfoCursor(*BlockInfoStream);
567  if (Error E = analyzeHeader(O, BlockInfoCursor).takeError())
568  return E;
569 
570  while (!BlockInfoCursor.AtEndOfStream()) {
571  Expected<unsigned> MaybeCode = BlockInfoCursor.ReadCode();
572  if (!MaybeCode)
573  return MaybeCode.takeError();
574  if (MaybeCode.get() != bitc::ENTER_SUBBLOCK)
575  return reportError("Invalid record at top-level in block info file");
576 
577  Expected<unsigned> MaybeBlockID = BlockInfoCursor.ReadSubBlockID();
578  if (!MaybeBlockID)
579  return MaybeBlockID.takeError();
580  if (MaybeBlockID.get() == bitc::BLOCKINFO_BLOCK_ID) {
581  Optional<BitstreamBlockInfo> NewBlockInfo;
582  if (Error E =
583  BlockInfoCursor.ReadBlockInfoBlock(/*ReadBlockInfoNames=*/true)
584  .moveInto(NewBlockInfo))
585  return E;
586  if (!NewBlockInfo)
587  return reportError("Malformed BlockInfoBlock in block info file");
588  BlockInfo = std::move(*NewBlockInfo);
589  break;
590  }
591 
592  if (Error Err = BlockInfoCursor.SkipBlock())
593  return Err;
594  }
595  }
596 
597  // Parse the top-level structure. We only allow blocks at the top-level.
598  while (!Stream.AtEndOfStream()) {
599  Expected<unsigned> MaybeCode = Stream.ReadCode();
600  if (!MaybeCode)
601  return MaybeCode.takeError();
602  if (MaybeCode.get() != bitc::ENTER_SUBBLOCK)
603  return reportError("Invalid record at top-level");
604 
605  Expected<unsigned> MaybeBlockID = Stream.ReadSubBlockID();
606  if (!MaybeBlockID)
607  return MaybeBlockID.takeError();
608 
609  if (Error E = parseBlock(MaybeBlockID.get(), 0, O, CheckHash))
610  return E;
611  ++NumTopBlocks;
612  }
613 
614  return Error::success();
615 }
616 
617 void BitcodeAnalyzer::printStats(BCDumpOptions O,
618  Optional<StringRef> Filename) {
619  uint64_t BufferSizeBits = Stream.getBitcodeBytes().size() * CHAR_BIT;
620  // Print a summary of the read file.
621  O.OS << "Summary ";
622  if (Filename)
623  O.OS << "of " << Filename->data() << ":\n";
624  O.OS << " Total size: ";
625  printSize(O.OS, BufferSizeBits);
626  O.OS << "\n";
627  O.OS << " Stream type: ";
628  switch (CurStreamType) {
629  case UnknownBitstream:
630  O.OS << "unknown\n";
631  break;
632  case LLVMIRBitstream:
633  O.OS << "LLVM IR\n";
634  break;
635  case ClangSerializedASTBitstream:
636  O.OS << "Clang Serialized AST\n";
637  break;
638  case ClangSerializedDiagnosticsBitstream:
639  O.OS << "Clang Serialized Diagnostics\n";
640  break;
641  case LLVMBitstreamRemarks:
642  O.OS << "LLVM Remarks\n";
643  break;
644  }
645  O.OS << " # Toplevel Blocks: " << NumTopBlocks << "\n";
646  O.OS << "\n";
647 
648  // Emit per-block stats.
649  O.OS << "Per-block Summary:\n";
650  for (const auto &Stat : BlockIDStats) {
651  O.OS << " Block ID #" << Stat.first;
652  if (Optional<const char *> BlockName =
653  GetBlockName(Stat.first, BlockInfo, CurStreamType))
654  O.OS << " (" << *BlockName << ")";
655  O.OS << ":\n";
656 
657  const PerBlockIDStats &Stats = Stat.second;
658  O.OS << " Num Instances: " << Stats.NumInstances << "\n";
659  O.OS << " Total Size: ";
660  printSize(O.OS, Stats.NumBits);
661  O.OS << "\n";
662  double pct = (Stats.NumBits * 100.0) / BufferSizeBits;
663  O.OS << " Percent of file: " << format("%2.4f%%", pct) << "\n";
664  if (Stats.NumInstances > 1) {
665  O.OS << " Average Size: ";
666  printSize(O.OS, Stats.NumBits / (double)Stats.NumInstances);
667  O.OS << "\n";
668  O.OS << " Tot/Avg SubBlocks: " << Stats.NumSubBlocks << "/"
669  << Stats.NumSubBlocks / (double)Stats.NumInstances << "\n";
670  O.OS << " Tot/Avg Abbrevs: " << Stats.NumAbbrevs << "/"
671  << Stats.NumAbbrevs / (double)Stats.NumInstances << "\n";
672  O.OS << " Tot/Avg Records: " << Stats.NumRecords << "/"
673  << Stats.NumRecords / (double)Stats.NumInstances << "\n";
674  } else {
675  O.OS << " Num SubBlocks: " << Stats.NumSubBlocks << "\n";
676  O.OS << " Num Abbrevs: " << Stats.NumAbbrevs << "\n";
677  O.OS << " Num Records: " << Stats.NumRecords << "\n";
678  }
679  if (Stats.NumRecords) {
680  double pct = (Stats.NumAbbreviatedRecords * 100.0) / Stats.NumRecords;
681  O.OS << " Percent Abbrevs: " << format("%2.4f%%", pct) << "\n";
682  }
683  O.OS << "\n";
684 
685  // Print a histogram of the codes we see.
686  if (O.Histogram && !Stats.CodeFreq.empty()) {
687  std::vector<std::pair<unsigned, unsigned>> FreqPairs; // <freq,code>
688  for (unsigned i = 0, e = Stats.CodeFreq.size(); i != e; ++i)
689  if (unsigned Freq = Stats.CodeFreq[i].NumInstances)
690  FreqPairs.push_back(std::make_pair(Freq, i));
691  llvm::stable_sort(FreqPairs);
692  std::reverse(FreqPairs.begin(), FreqPairs.end());
693 
694  O.OS << "\tRecord Histogram:\n";
695  O.OS << "\t\t Count # Bits b/Rec % Abv Record Kind\n";
696  for (const auto &FreqPair : FreqPairs) {
697  const PerRecordStats &RecStats = Stats.CodeFreq[FreqPair.second];
698 
699  O.OS << format("\t\t%7d %9lu", RecStats.NumInstances,
700  (unsigned long)RecStats.TotalBits);
701 
702  if (RecStats.NumInstances > 1)
703  O.OS << format(" %9.1f",
704  (double)RecStats.TotalBits / RecStats.NumInstances);
705  else
706  O.OS << " ";
707 
708  if (RecStats.NumAbbrev)
709  O.OS << format(" %7.2f", (double)RecStats.NumAbbrev /
710  RecStats.NumInstances * 100);
711  else
712  O.OS << " ";
713 
714  O.OS << " ";
715  if (Optional<const char *> CodeName = GetCodeName(
716  FreqPair.second, Stat.first, BlockInfo, CurStreamType))
717  O.OS << *CodeName << "\n";
718  else
719  O.OS << "UnknownCode" << FreqPair.second << "\n";
720  }
721  O.OS << "\n";
722  }
723  }
724 }
725 
726 Error BitcodeAnalyzer::parseBlock(unsigned BlockID, unsigned IndentLevel,
727  Optional<BCDumpOptions> O,
728  Optional<StringRef> CheckHash) {
729  std::string Indent(IndentLevel * 2, ' ');
730  uint64_t BlockBitStart = Stream.GetCurrentBitNo();
731 
732  // Get the statistics for this BlockID.
733  PerBlockIDStats &BlockStats = BlockIDStats[BlockID];
734 
735  BlockStats.NumInstances++;
736 
737  // BLOCKINFO is a special part of the stream.
738  bool DumpRecords = O.hasValue();
739  if (BlockID == bitc::BLOCKINFO_BLOCK_ID) {
740  if (O && !O->DumpBlockinfo)
741  O->OS << Indent << "<BLOCKINFO_BLOCK/>\n";
742  Optional<BitstreamBlockInfo> NewBlockInfo;
743  if (Error E = Stream.ReadBlockInfoBlock(/*ReadBlockInfoNames=*/true)
744  .moveInto(NewBlockInfo))
745  return E;
746  if (!NewBlockInfo)
747  return reportError("Malformed BlockInfoBlock");
748  BlockInfo = std::move(*NewBlockInfo);
749  if (Error Err = Stream.JumpToBit(BlockBitStart))
750  return Err;
751  // It's not really interesting to dump the contents of the blockinfo
752  // block, so only do it if the user explicitly requests it.
753  DumpRecords = O && O->DumpBlockinfo;
754  }
755 
756  unsigned NumWords = 0;
757  if (Error Err = Stream.EnterSubBlock(BlockID, &NumWords))
758  return Err;
759 
760  // Keep it for later, when we see a MODULE_HASH record
761  uint64_t BlockEntryPos = Stream.getCurrentByteNo();
762 
763  Optional<const char *> BlockName = None;
764  if (DumpRecords) {
765  O->OS << Indent << "<";
766  if ((BlockName = GetBlockName(BlockID, BlockInfo, CurStreamType)))
767  O->OS << *BlockName;
768  else
769  O->OS << "UnknownBlock" << BlockID;
770 
771  if (!O->Symbolic && BlockName)
772  O->OS << " BlockID=" << BlockID;
773 
774  O->OS << " NumWords=" << NumWords
775  << " BlockCodeSize=" << Stream.getAbbrevIDWidth() << ">\n";
776  }
777 
778  SmallVector<uint64_t, 64> Record;
779 
780  // Keep the offset to the metadata index if seen.
781  uint64_t MetadataIndexOffset = 0;
782 
783  // Read all the records for this block.
784  while (true) {
785  if (Stream.AtEndOfStream())
786  return reportError("Premature end of bitstream");
787 
788  uint64_t RecordStartBit = Stream.GetCurrentBitNo();
789 
790  BitstreamEntry Entry;
791  if (Error E = Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs)
792  .moveInto(Entry))
793  return E;
794 
795  switch (Entry.Kind) {
796  case BitstreamEntry::Error:
797  return reportError("malformed bitcode file");
798  case BitstreamEntry::EndBlock: {
799  uint64_t BlockBitEnd = Stream.GetCurrentBitNo();
800  BlockStats.NumBits += BlockBitEnd - BlockBitStart;
801  if (DumpRecords) {
802  O->OS << Indent << "</";
803  if (BlockName)
804  O->OS << *BlockName << ">\n";
805  else
806  O->OS << "UnknownBlock" << BlockID << ">\n";
807  }
808  return Error::success();
809  }
810 
811  case BitstreamEntry::SubBlock: {
812  uint64_t SubBlockBitStart = Stream.GetCurrentBitNo();
813  if (Error E = parseBlock(Entry.ID, IndentLevel + 1, O, CheckHash))
814  return E;
815  ++BlockStats.NumSubBlocks;
816  uint64_t SubBlockBitEnd = Stream.GetCurrentBitNo();
817 
818  // Don't include subblock sizes in the size of this block.
819  BlockBitStart += SubBlockBitEnd - SubBlockBitStart;
820  continue;
821  }
822  case BitstreamEntry::Record:
823  // The interesting case.
824  break;
825  }
826 
827  if (Entry.ID == bitc::DEFINE_ABBREV) {
828  if (Error Err = Stream.ReadAbbrevRecord())
829  return Err;
830  ++BlockStats.NumAbbrevs;
831  continue;
832  }
833 
834  Record.clear();
835 
836  ++BlockStats.NumRecords;
837 
838  StringRef Blob;
839  uint64_t CurrentRecordPos = Stream.GetCurrentBitNo();
840  unsigned Code;
841  if (Error E = Stream.readRecord(Entry.ID, Record, &Blob).moveInto(Code))
842  return E;
843 
844  // Increment the # occurrences of this code.
845  if (BlockStats.CodeFreq.size() <= Code)
846  BlockStats.CodeFreq.resize(Code + 1);
847  BlockStats.CodeFreq[Code].NumInstances++;
848  BlockStats.CodeFreq[Code].TotalBits +=
849  Stream.GetCurrentBitNo() - RecordStartBit;
850  if (Entry.ID != bitc::UNABBREV_RECORD) {
851  BlockStats.CodeFreq[Code].NumAbbrev++;
852  ++BlockStats.NumAbbreviatedRecords;
853  }
854 
855  if (DumpRecords) {
856  O->OS << Indent << " <";
857  Optional<const char *> CodeName =
858  GetCodeName(Code, BlockID, BlockInfo, CurStreamType);
859  if (CodeName)
860  O->OS << *CodeName;
861  else
862  O->OS << "UnknownCode" << Code;
863  if (!O->Symbolic && CodeName)
864  O->OS << " codeid=" << Code;
865  const BitCodeAbbrev *Abbv = nullptr;
866  if (Entry.ID != bitc::UNABBREV_RECORD) {
867  Abbv = Stream.getAbbrev(Entry.ID);
868  O->OS << " abbrevid=" << Entry.ID;
869  }
870 
871  for (unsigned i = 0, e = Record.size(); i != e; ++i)
872  O->OS << " op" << i << "=" << (int64_t)Record[i];
873 
874  // If we found a metadata index, let's verify that we had an offset
875  // before and validate its forward reference offset was correct!
876  if (BlockID == bitc::METADATA_BLOCK_ID) {
877  if (Code == bitc::METADATA_INDEX_OFFSET) {
878  if (Record.size() != 2)
879  O->OS << "(Invalid record)";
880  else {
881  auto Offset = Record[0] + (Record[1] << 32);
882  MetadataIndexOffset = Stream.GetCurrentBitNo() + Offset;
883  }
884  }
885  if (Code == bitc::METADATA_INDEX) {
886  O->OS << " (offset ";
887  if (MetadataIndexOffset == RecordStartBit)
888  O->OS << "match)";
889  else
890  O->OS << "mismatch: " << MetadataIndexOffset << " vs "
891  << RecordStartBit << ")";
892  }
893  }
894 
895  // If we found a module hash, let's verify that it matches!
896  if (BlockID == bitc::MODULE_BLOCK_ID && Code == bitc::MODULE_CODE_HASH &&
897  CheckHash.hasValue()) {
898  if (Record.size() != 5)
899  O->OS << " (invalid)";
900  else {
901  // Recompute the hash and compare it to the one in the bitcode
902  SHA1 Hasher;
903  StringRef Hash;
904  Hasher.update(*CheckHash);
905  {
906  int BlockSize = (CurrentRecordPos / 8) - BlockEntryPos;
907  auto Ptr = Stream.getPointerToByte(BlockEntryPos, BlockSize);
908  Hasher.update(ArrayRef<uint8_t>(Ptr, BlockSize));
909  Hash = Hasher.result();
910  }
911  std::array<char, 20> RecordedHash;
912  int Pos = 0;
913  for (auto &Val : Record) {
914  assert(!(Val >> 32) && "Unexpected high bits set");
915  support::endian::write32be(&RecordedHash[Pos], Val);
916  Pos += 4;
917  }
918  if (Hash == StringRef(RecordedHash.data(), RecordedHash.size()))
919  O->OS << " (match)";
920  else
921  O->OS << " (!mismatch!)";
922  }
923  }
924 
925  O->OS << "/>";
926 
927  if (Abbv) {
928  for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i != e; ++i) {
929  const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
930  if (!Op.isEncoding() || Op.getEncoding() != BitCodeAbbrevOp::Array)
931  continue;
932  assert(i + 2 == e && "Array op not second to last");
933  std::string Str;
934  bool ArrayIsPrintable = true;
935  for (unsigned j = i - 1, je = Record.size(); j != je; ++j) {
936  if (!isPrint(static_cast<unsigned char>(Record[j]))) {
937  ArrayIsPrintable = false;
938  break;
939  }
940  Str += (char)Record[j];
941  }
942  if (ArrayIsPrintable)
943  O->OS << " record string = '" << Str << "'";
944  break;
945  }
946  }
947 
948  if (Blob.data()) {
949  if (canDecodeBlob(Code, BlockID)) {
950  if (Error E = decodeMetadataStringsBlob(Indent, Record, Blob, O->OS))
951  return E;
952  } else {
953  O->OS << " blob data = ";
954  if (O->ShowBinaryBlobs) {
955  O->OS << "'";
956  O->OS.write_escaped(Blob, /*hex=*/true) << "'";
957  } else {
958  bool BlobIsPrintable = true;
959  for (char C : Blob)
960  if (!isPrint(static_cast<unsigned char>(C))) {
961  BlobIsPrintable = false;
962  break;
963  }
964 
965  if (BlobIsPrintable)
966  O->OS << "'" << Blob << "'";
967  else
968  O->OS << "unprintable, " << Blob.size() << " bytes.";
969  }
970  }
971  }
972 
973  O->OS << "\n";
974  }
975 
976  // Make sure that we can skip the current record.
977  if (Error Err = Stream.JumpToBit(CurrentRecordPos))
978  return Err;
979  if (Expected<unsigned> Skipped = Stream.skipRecord(Entry.ID))
980  ; // Do nothing.
981  else
982  return Skipped.takeError();
983  }
984 }
985 
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:409
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
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:23
BlockSize
static const int BlockSize
Definition: TarWriter.cpp:33
llvm::X86AS::FS
@ FS
Definition: X86.h:188
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::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:507
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:695
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:414
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:1419
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:80
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::bitc::USELIST_CODE_BB
@ USELIST_CODE_BB
Definition: LLVMBitCodes.h:597
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:731
llvm::BitstreamEntry::EndBlock
@ EndBlock
Definition: BitstreamReader.h:310
Format.h
llvm::bitc::SYMTAB_BLOCK_ID
@ SYMTAB_BLOCK_ID
Definition: LLVMBitCodes.h:60
llvm::ArrayRef::data
const T * data() const
Definition: ArrayRef.h:160
llvm::BitstreamCursor::ReadCode
Expected< unsigned > ReadCode()
Definition: BitstreamReader.h:456
llvm::RISCVFenceField::R
@ R
Definition: RISCVBaseInfo.h:207
llvm::bitc::ENTER_SUBBLOCK
@ ENTER_SUBBLOCK
Definition: BitCodes.h:48
llvm::ISD::INLINEASM
@ INLINEASM
INLINEASM - Represents an inline asm block.
Definition: ISDOpcodes.h:984
llvm::Optional::hasValue
constexpr bool hasValue() const
Definition: Optional.h:288
llvm::BitstreamEntry::SubBlock
@ SubBlock
Definition: BitstreamReader.h:312
llvm::BitstreamEntry::Record
@ Record
Definition: BitstreamReader.h:313
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::MODULE
@ MODULE
Definition: Attributor.h:4792
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")
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: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
Info
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
analyzeHeader
static Expected< CurStreamTypeType > analyzeHeader(Optional< BCDumpOptions > O, BitstreamCursor &Stream)
Definition: BitcodeAnalyzer.cpp:470
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::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
NODE
#define NODE(name)
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:206
llvm::BitstreamCursor::GetCurrentBitNo
uint64_t GetCurrentBitNo() const
Return the bit # of the bit we are reading.
Definition: BitstreamReader.h:121
llvm::StringRef::empty
constexpr LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:152
llvm::bitc::PARAMATTR_BLOCK_ID
@ PARAMATTR_BLOCK_ID
Definition: LLVMBitCodes.h:30
uint64_t
llvm::BitstreamCursor::AF_DontAutoprocessAbbrevs
@ AF_DontAutoprocessAbbrevs
If this flag is used, abbrev entries are returned just like normal records.
Definition: BitstreamReader.h:396
llvm::BitstreamEntry::Error
@ Error
Definition: BitstreamReader.h:309
llvm::BitstreamCursor::Read
Expected< word_t > Read(unsigned NumBits)
Definition: BitstreamReader.h:190
llvm::bitc::USELIST_CODE_DEFAULT
@ USELIST_CODE_DEFAULT
Definition: LLVMBitCodes.h:596
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
llvm::BitstreamBlockInfo::BlockInfo
This contains information emitted to BLOCKINFO_BLOCK blocks.
Definition: BitstreamReader.h:42
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:1485
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:1630
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:57
llvm::BitstreamCursor::getAbbrev
const BitCodeAbbrev * getAbbrev(unsigned AbbrevID)
Return the abbreviation for the specified AbbrevId.
Definition: BitstreamReader.h:525
llvm::msf::Magic
static const char Magic[]
Definition: MSFCommon.h:23
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:1784
llvm::createStringError
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1241
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
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:652
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:325
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::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:417
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:599
llvm::bitc::METADATA_BLOCK_ID
@ METADATA_BLOCK_ID
Definition: LLVMBitCodes.h:42
Version
uint64_t Version
Definition: RawMemProfReader.cpp:25
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:691
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:163
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:148
llvm::BTF::VERSION
@ VERSION
Definition: BTF.h:54
llvm::bitc::USELIST_BLOCK_ID
@ USELIST_BLOCK_ID
Definition: LLVMBitCodes.h:47
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: 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:617
llvm::LLVMBitstreamRemarks
@ LLVMBitstreamRemarks
Definition: BitcodeAnalyzer.h:33
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 Jan 17 2022 11:18:05 for LLVM by   doxygen 1.8.17