LLVM  6.0.0svn
BitcodeWriter.cpp
Go to the documentation of this file.
1 //===- Bitcode/Writer/BitcodeWriter.cpp - Bitcode Writer ------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Bitcode writer implementation.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "ValueEnumerator.h"
16 #include "llvm/ADT/APFloat.h"
17 #include "llvm/ADT/APInt.h"
18 #include "llvm/ADT/ArrayRef.h"
19 #include "llvm/ADT/DenseMap.h"
20 #include "llvm/ADT/None.h"
21 #include "llvm/ADT/Optional.h"
22 #include "llvm/ADT/STLExtras.h"
23 #include "llvm/ADT/SmallString.h"
24 #include "llvm/ADT/SmallVector.h"
25 #include "llvm/ADT/StringMap.h"
26 #include "llvm/ADT/StringRef.h"
27 #include "llvm/ADT/Triple.h"
28 #include "llvm/Bitcode/BitCodes.h"
31 #include "llvm/IR/Attributes.h"
32 #include "llvm/IR/BasicBlock.h"
33 #include "llvm/IR/CallSite.h"
34 #include "llvm/IR/Comdat.h"
35 #include "llvm/IR/Constant.h"
36 #include "llvm/IR/Constants.h"
38 #include "llvm/IR/DebugLoc.h"
39 #include "llvm/IR/DerivedTypes.h"
40 #include "llvm/IR/Function.h"
41 #include "llvm/IR/GlobalAlias.h"
42 #include "llvm/IR/GlobalIFunc.h"
43 #include "llvm/IR/GlobalObject.h"
44 #include "llvm/IR/GlobalValue.h"
45 #include "llvm/IR/GlobalVariable.h"
46 #include "llvm/IR/InlineAsm.h"
47 #include "llvm/IR/InstrTypes.h"
48 #include "llvm/IR/Instruction.h"
49 #include "llvm/IR/Instructions.h"
50 #include "llvm/IR/LLVMContext.h"
51 #include "llvm/IR/Metadata.h"
52 #include "llvm/IR/Module.h"
54 #include "llvm/IR/Operator.h"
55 #include "llvm/IR/Type.h"
56 #include "llvm/IR/UseListOrder.h"
57 #include "llvm/IR/Value.h"
60 #include "llvm/Object/IRSymtab.h"
62 #include "llvm/Support/Casting.h"
64 #include "llvm/Support/Endian.h"
65 #include "llvm/Support/Error.h"
68 #include "llvm/Support/SHA1.h"
71 #include <algorithm>
72 #include <cassert>
73 #include <cstddef>
74 #include <cstdint>
75 #include <iterator>
76 #include <map>
77 #include <memory>
78 #include <string>
79 #include <utility>
80 #include <vector>
81 
82 using namespace llvm;
83 
84 static cl::opt<unsigned>
85  IndexThreshold("bitcode-mdindex-threshold", cl::Hidden, cl::init(25),
86  cl::desc("Number of metadatas above which we emit an index "
87  "to enable lazy-loading"));
88 
89 namespace {
90 
91 /// These are manifest constants used by the bitcode writer. They do not need to
92 /// be kept in sync with the reader, but need to be consistent within this file.
93 enum {
94  // VALUE_SYMTAB_BLOCK abbrev id's.
95  VST_ENTRY_8_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
96  VST_ENTRY_7_ABBREV,
97  VST_ENTRY_6_ABBREV,
98  VST_BBENTRY_6_ABBREV,
99 
100  // CONSTANTS_BLOCK abbrev id's.
101  CONSTANTS_SETTYPE_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
102  CONSTANTS_INTEGER_ABBREV,
103  CONSTANTS_CE_CAST_Abbrev,
104  CONSTANTS_NULL_Abbrev,
105 
106  // FUNCTION_BLOCK abbrev id's.
107  FUNCTION_INST_LOAD_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
108  FUNCTION_INST_BINOP_ABBREV,
109  FUNCTION_INST_BINOP_FLAGS_ABBREV,
110  FUNCTION_INST_CAST_ABBREV,
111  FUNCTION_INST_RET_VOID_ABBREV,
112  FUNCTION_INST_RET_VAL_ABBREV,
113  FUNCTION_INST_UNREACHABLE_ABBREV,
114  FUNCTION_INST_GEP_ABBREV,
115 };
116 
117 /// Abstract class to manage the bitcode writing, subclassed for each bitcode
118 /// file type.
119 class BitcodeWriterBase {
120 protected:
121  /// The stream created and owned by the client.
122  BitstreamWriter &Stream;
123 
124  StringTableBuilder &StrtabBuilder;
125 
126 public:
127  /// Constructs a BitcodeWriterBase object that writes to the provided
128  /// \p Stream.
129  BitcodeWriterBase(BitstreamWriter &Stream, StringTableBuilder &StrtabBuilder)
130  : Stream(Stream), StrtabBuilder(StrtabBuilder) {}
131 
132 protected:
133  void writeBitcodeHeader();
134  void writeModuleVersion();
135 };
136 
137 void BitcodeWriterBase::writeModuleVersion() {
138  // VERSION: [version#]
139  Stream.EmitRecord(bitc::MODULE_CODE_VERSION, ArrayRef<uint64_t>{2});
140 }
141 
142 /// Base class to manage the module bitcode writing, currently subclassed for
143 /// ModuleBitcodeWriter and ThinLinkBitcodeWriter.
144 class ModuleBitcodeWriterBase : public BitcodeWriterBase {
145 protected:
146  /// The Module to write to bitcode.
147  const Module &M;
148 
149  /// Enumerates ids for all values in the module.
150  ValueEnumerator VE;
151 
152  /// Optional per-module index to write for ThinLTO.
153  const ModuleSummaryIndex *Index;
154 
155  /// Map that holds the correspondence between GUIDs in the summary index,
156  /// that came from indirect call profiles, and a value id generated by this
157  /// class to use in the VST and summary block records.
158  std::map<GlobalValue::GUID, unsigned> GUIDToValueIdMap;
159 
160  /// Tracks the last value id recorded in the GUIDToValueMap.
161  unsigned GlobalValueId;
162 
163  /// Saves the offset of the VSTOffset record that must eventually be
164  /// backpatched with the offset of the actual VST.
165  uint64_t VSTOffsetPlaceholder = 0;
166 
167 public:
168  /// Constructs a ModuleBitcodeWriterBase object for the given Module,
169  /// writing to the provided \p Buffer.
170  ModuleBitcodeWriterBase(const Module *M, StringTableBuilder &StrtabBuilder,
171  BitstreamWriter &Stream,
172  bool ShouldPreserveUseListOrder,
173  const ModuleSummaryIndex *Index)
174  : BitcodeWriterBase(Stream, StrtabBuilder), M(*M),
175  VE(*M, ShouldPreserveUseListOrder), Index(Index) {
176  // Assign ValueIds to any callee values in the index that came from
177  // indirect call profiles and were recorded as a GUID not a Value*
178  // (which would have been assigned an ID by the ValueEnumerator).
179  // The starting ValueId is just after the number of values in the
180  // ValueEnumerator, so that they can be emitted in the VST.
181  GlobalValueId = VE.getValues().size();
182  if (!Index)
183  return;
184  for (const auto &GUIDSummaryLists : *Index)
185  // Examine all summaries for this GUID.
186  for (auto &Summary : GUIDSummaryLists.second.SummaryList)
187  if (auto FS = dyn_cast<FunctionSummary>(Summary.get()))
188  // For each call in the function summary, see if the call
189  // is to a GUID (which means it is for an indirect call,
190  // otherwise we would have a Value for it). If so, synthesize
191  // a value id.
192  for (auto &CallEdge : FS->calls())
193  if (!CallEdge.first.getValue())
194  assignValueId(CallEdge.first.getGUID());
195  }
196 
197 protected:
198  void writePerModuleGlobalValueSummary();
199 
200 private:
201  void writePerModuleFunctionSummaryRecord(SmallVector<uint64_t, 64> &NameVals,
202  GlobalValueSummary *Summary,
203  unsigned ValueID,
204  unsigned FSCallsAbbrev,
205  unsigned FSCallsProfileAbbrev,
206  const Function &F);
207  void writeModuleLevelReferences(const GlobalVariable &V,
208  SmallVector<uint64_t, 64> &NameVals,
209  unsigned FSModRefsAbbrev);
210 
211  void assignValueId(GlobalValue::GUID ValGUID) {
212  GUIDToValueIdMap[ValGUID] = ++GlobalValueId;
213  }
214 
215  unsigned getValueId(GlobalValue::GUID ValGUID) {
216  const auto &VMI = GUIDToValueIdMap.find(ValGUID);
217  // Expect that any GUID value had a value Id assigned by an
218  // earlier call to assignValueId.
219  assert(VMI != GUIDToValueIdMap.end() &&
220  "GUID does not have assigned value Id");
221  return VMI->second;
222  }
223 
224  // Helper to get the valueId for the type of value recorded in VI.
225  unsigned getValueId(ValueInfo VI) {
226  if (!VI.getValue())
227  return getValueId(VI.getGUID());
228  return VE.getValueID(VI.getValue());
229  }
230 
231  std::map<GlobalValue::GUID, unsigned> &valueIds() { return GUIDToValueIdMap; }
232 };
233 
234 /// Class to manage the bitcode writing for a module.
235 class ModuleBitcodeWriter : public ModuleBitcodeWriterBase {
236  /// Pointer to the buffer allocated by caller for bitcode writing.
237  const SmallVectorImpl<char> &Buffer;
238 
239  /// True if a module hash record should be written.
240  bool GenerateHash;
241 
242  /// If non-null, when GenerateHash is true, the resulting hash is written
243  /// into ModHash.
244  ModuleHash *ModHash;
245 
246  SHA1 Hasher;
247 
248  /// The start bit of the identification block.
249  uint64_t BitcodeStartBit;
250 
251 public:
252  /// Constructs a ModuleBitcodeWriter object for the given Module,
253  /// writing to the provided \p Buffer.
254  ModuleBitcodeWriter(const Module *M, SmallVectorImpl<char> &Buffer,
255  StringTableBuilder &StrtabBuilder,
256  BitstreamWriter &Stream, bool ShouldPreserveUseListOrder,
257  const ModuleSummaryIndex *Index, bool GenerateHash,
258  ModuleHash *ModHash = nullptr)
259  : ModuleBitcodeWriterBase(M, StrtabBuilder, Stream,
260  ShouldPreserveUseListOrder, Index),
261  Buffer(Buffer), GenerateHash(GenerateHash), ModHash(ModHash),
262  BitcodeStartBit(Stream.GetCurrentBitNo()) {}
263 
264  /// Emit the current module to the bitstream.
265  void write();
266 
267 private:
268  uint64_t bitcodeStartBit() { return BitcodeStartBit; }
269 
270  size_t addToStrtab(StringRef Str);
271 
272  void writeAttributeGroupTable();
273  void writeAttributeTable();
274  void writeTypeTable();
275  void writeComdats();
276  void writeValueSymbolTableForwardDecl();
277  void writeModuleInfo();
278  void writeValueAsMetadata(const ValueAsMetadata *MD,
281  unsigned Abbrev);
282  unsigned createDILocationAbbrev();
284  unsigned &Abbrev);
285  unsigned createGenericDINodeAbbrev();
286  void writeGenericDINode(const GenericDINode *N,
287  SmallVectorImpl<uint64_t> &Record, unsigned &Abbrev);
289  unsigned Abbrev);
290  void writeDIEnumerator(const DIEnumerator *N,
291  SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
293  unsigned Abbrev);
294  void writeDIDerivedType(const DIDerivedType *N,
295  SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
297  SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
300  unsigned Abbrev);
302  unsigned Abbrev);
303  void writeDICompileUnit(const DICompileUnit *N,
304  SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
305  void writeDISubprogram(const DISubprogram *N,
306  SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
308  SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
311  unsigned Abbrev);
313  unsigned Abbrev);
315  unsigned Abbrev);
317  unsigned Abbrev);
319  unsigned Abbrev);
322  unsigned Abbrev);
325  unsigned Abbrev);
328  unsigned Abbrev);
330  SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
331  void writeDIExpression(const DIExpression *N,
332  SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
335  unsigned Abbrev);
337  SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
340  unsigned Abbrev);
341  unsigned createNamedMetadataAbbrev();
342  void writeNamedMetadata(SmallVectorImpl<uint64_t> &Record);
343  unsigned createMetadataStringsAbbrev();
344  void writeMetadataStrings(ArrayRef<const Metadata *> Strings,
346  void writeMetadataRecords(ArrayRef<const Metadata *> MDs,
348  std::vector<unsigned> *MDAbbrevs = nullptr,
349  std::vector<uint64_t> *IndexPos = nullptr);
350  void writeModuleMetadata();
351  void writeFunctionMetadata(const Function &F);
352  void writeFunctionMetadataAttachment(const Function &F);
353  void writeGlobalVariableMetadataAttachment(const GlobalVariable &GV);
354  void pushGlobalMetadataAttachment(SmallVectorImpl<uint64_t> &Record,
355  const GlobalObject &GO);
356  void writeModuleMetadataKinds();
357  void writeOperandBundleTags();
358  void writeSyncScopeNames();
359  void writeConstants(unsigned FirstVal, unsigned LastVal, bool isGlobal);
360  void writeModuleConstants();
361  bool pushValueAndType(const Value *V, unsigned InstID,
363  void writeOperandBundles(ImmutableCallSite CS, unsigned InstID);
364  void pushValue(const Value *V, unsigned InstID,
366  void pushValueSigned(const Value *V, unsigned InstID,
368  void writeInstruction(const Instruction &I, unsigned InstID,
370  void writeFunctionLevelValueSymbolTable(const ValueSymbolTable &VST);
371  void writeGlobalValueSymbolTable(
372  DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex);
373  void writeUseList(UseListOrder &&Order);
374  void writeUseListBlock(const Function *F);
375  void
376  writeFunction(const Function &F,
377  DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex);
378  void writeBlockInfo();
379  void writeModuleHash(size_t BlockStartPos);
380 
381  unsigned getEncodedSyncScopeID(SyncScope::ID SSID) {
382  return unsigned(SSID);
383  }
384 };
385 
386 /// Class to manage the bitcode writing for a combined index.
387 class IndexBitcodeWriter : public BitcodeWriterBase {
388  /// The combined index to write to bitcode.
389  const ModuleSummaryIndex &Index;
390 
391  /// When writing a subset of the index for distributed backends, client
392  /// provides a map of modules to the corresponding GUIDs/summaries to write.
393  const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex;
394 
395  /// Map that holds the correspondence between the GUID used in the combined
396  /// index and a value id generated by this class to use in references.
397  std::map<GlobalValue::GUID, unsigned> GUIDToValueIdMap;
398 
399  /// Tracks the last value id recorded in the GUIDToValueMap.
400  unsigned GlobalValueId = 0;
401 
402 public:
403  /// Constructs a IndexBitcodeWriter object for the given combined index,
404  /// writing to the provided \p Buffer. When writing a subset of the index
405  /// for a distributed backend, provide a \p ModuleToSummariesForIndex map.
406  IndexBitcodeWriter(BitstreamWriter &Stream, StringTableBuilder &StrtabBuilder,
407  const ModuleSummaryIndex &Index,
408  const std::map<std::string, GVSummaryMapTy>
409  *ModuleToSummariesForIndex = nullptr)
410  : BitcodeWriterBase(Stream, StrtabBuilder), Index(Index),
411  ModuleToSummariesForIndex(ModuleToSummariesForIndex) {
412  // Assign unique value ids to all summaries to be written, for use
413  // in writing out the call graph edges. Save the mapping from GUID
414  // to the new global value id to use when writing those edges, which
415  // are currently saved in the index in terms of GUID.
416  forEachSummary([&](GVInfo I) {
417  GUIDToValueIdMap[I.first] = ++GlobalValueId;
418  });
419  }
420 
421  /// The below iterator returns the GUID and associated summary.
422  using GVInfo = std::pair<GlobalValue::GUID, GlobalValueSummary *>;
423 
424  /// Calls the callback for each value GUID and summary to be written to
425  /// bitcode. This hides the details of whether they are being pulled from the
426  /// entire index or just those in a provided ModuleToSummariesForIndex map.
427  template<typename Functor>
428  void forEachSummary(Functor Callback) {
429  if (ModuleToSummariesForIndex) {
430  for (auto &M : *ModuleToSummariesForIndex)
431  for (auto &Summary : M.second)
432  Callback(Summary);
433  } else {
434  for (auto &Summaries : Index)
435  for (auto &Summary : Summaries.second.SummaryList)
436  Callback({Summaries.first, Summary.get()});
437  }
438  }
439 
440  /// Calls the callback for each entry in the modulePaths StringMap that
441  /// should be written to the module path string table. This hides the details
442  /// of whether they are being pulled from the entire index or just those in a
443  /// provided ModuleToSummariesForIndex map.
444  template <typename Functor> void forEachModule(Functor Callback) {
445  if (ModuleToSummariesForIndex) {
446  for (const auto &M : *ModuleToSummariesForIndex) {
447  const auto &MPI = Index.modulePaths().find(M.first);
448  if (MPI == Index.modulePaths().end()) {
449  // This should only happen if the bitcode file was empty, in which
450  // case we shouldn't be importing (the ModuleToSummariesForIndex
451  // would only include the module we are writing and index for).
452  assert(ModuleToSummariesForIndex->size() == 1);
453  continue;
454  }
455  Callback(*MPI);
456  }
457  } else {
458  for (const auto &MPSE : Index.modulePaths())
459  Callback(MPSE);
460  }
461  }
462 
463  /// Main entry point for writing a combined index to bitcode.
464  void write();
465 
466 private:
467  void writeModStrings();
468  void writeCombinedGlobalValueSummary();
469 
470  Optional<unsigned> getValueId(GlobalValue::GUID ValGUID) {
471  auto VMI = GUIDToValueIdMap.find(ValGUID);
472  if (VMI == GUIDToValueIdMap.end())
473  return None;
474  return VMI->second;
475  }
476 
477  std::map<GlobalValue::GUID, unsigned> &valueIds() { return GUIDToValueIdMap; }
478 };
479 
480 } // end anonymous namespace
481 
482 static unsigned getEncodedCastOpcode(unsigned Opcode) {
483  switch (Opcode) {
484  default: llvm_unreachable("Unknown cast instruction!");
485  case Instruction::Trunc : return bitc::CAST_TRUNC;
486  case Instruction::ZExt : return bitc::CAST_ZEXT;
487  case Instruction::SExt : return bitc::CAST_SEXT;
488  case Instruction::FPToUI : return bitc::CAST_FPTOUI;
489  case Instruction::FPToSI : return bitc::CAST_FPTOSI;
490  case Instruction::UIToFP : return bitc::CAST_UITOFP;
491  case Instruction::SIToFP : return bitc::CAST_SITOFP;
492  case Instruction::FPTrunc : return bitc::CAST_FPTRUNC;
493  case Instruction::FPExt : return bitc::CAST_FPEXT;
494  case Instruction::PtrToInt: return bitc::CAST_PTRTOINT;
495  case Instruction::IntToPtr: return bitc::CAST_INTTOPTR;
496  case Instruction::BitCast : return bitc::CAST_BITCAST;
497  case Instruction::AddrSpaceCast: return bitc::CAST_ADDRSPACECAST;
498  }
499 }
500 
501 static unsigned getEncodedBinaryOpcode(unsigned Opcode) {
502  switch (Opcode) {
503  default: llvm_unreachable("Unknown binary instruction!");
504  case Instruction::Add:
505  case Instruction::FAdd: return bitc::BINOP_ADD;
506  case Instruction::Sub:
507  case Instruction::FSub: return bitc::BINOP_SUB;
508  case Instruction::Mul:
509  case Instruction::FMul: return bitc::BINOP_MUL;
510  case Instruction::UDiv: return bitc::BINOP_UDIV;
511  case Instruction::FDiv:
512  case Instruction::SDiv: return bitc::BINOP_SDIV;
513  case Instruction::URem: return bitc::BINOP_UREM;
514  case Instruction::FRem:
515  case Instruction::SRem: return bitc::BINOP_SREM;
516  case Instruction::Shl: return bitc::BINOP_SHL;
517  case Instruction::LShr: return bitc::BINOP_LSHR;
518  case Instruction::AShr: return bitc::BINOP_ASHR;
519  case Instruction::And: return bitc::BINOP_AND;
520  case Instruction::Or: return bitc::BINOP_OR;
521  case Instruction::Xor: return bitc::BINOP_XOR;
522  }
523 }
524 
526  switch (Op) {
527  default: llvm_unreachable("Unknown RMW operation!");
528  case AtomicRMWInst::Xchg: return bitc::RMW_XCHG;
529  case AtomicRMWInst::Add: return bitc::RMW_ADD;
530  case AtomicRMWInst::Sub: return bitc::RMW_SUB;
531  case AtomicRMWInst::And: return bitc::RMW_AND;
532  case AtomicRMWInst::Nand: return bitc::RMW_NAND;
533  case AtomicRMWInst::Or: return bitc::RMW_OR;
534  case AtomicRMWInst::Xor: return bitc::RMW_XOR;
535  case AtomicRMWInst::Max: return bitc::RMW_MAX;
536  case AtomicRMWInst::Min: return bitc::RMW_MIN;
537  case AtomicRMWInst::UMax: return bitc::RMW_UMAX;
538  case AtomicRMWInst::UMin: return bitc::RMW_UMIN;
539  }
540 }
541 
542 static unsigned getEncodedOrdering(AtomicOrdering Ordering) {
543  switch (Ordering) {
551  }
552  llvm_unreachable("Invalid ordering");
553 }
554 
555 static void writeStringRecord(BitstreamWriter &Stream, unsigned Code,
556  StringRef Str, unsigned AbbrevToUse) {
558 
559  // Code: [strchar x N]
560  for (unsigned i = 0, e = Str.size(); i != e; ++i) {
561  if (AbbrevToUse && !BitCodeAbbrevOp::isChar6(Str[i]))
562  AbbrevToUse = 0;
563  Vals.push_back(Str[i]);
564  }
565 
566  // Emit the finished record.
567  Stream.EmitRecord(Code, Vals, AbbrevToUse);
568 }
569 
571  switch (Kind) {
572  case Attribute::Alignment:
574  case Attribute::AllocSize:
576  case Attribute::AlwaysInline:
578  case Attribute::ArgMemOnly:
580  case Attribute::Builtin:
582  case Attribute::ByVal:
583  return bitc::ATTR_KIND_BY_VAL;
586  case Attribute::InAlloca:
588  case Attribute::Cold:
589  return bitc::ATTR_KIND_COLD;
590  case Attribute::InaccessibleMemOnly:
592  case Attribute::InaccessibleMemOrArgMemOnly:
594  case Attribute::InlineHint:
596  case Attribute::InReg:
597  return bitc::ATTR_KIND_IN_REG;
600  case Attribute::MinSize:
602  case Attribute::Naked:
603  return bitc::ATTR_KIND_NAKED;
604  case Attribute::Nest:
605  return bitc::ATTR_KIND_NEST;
606  case Attribute::NoAlias:
608  case Attribute::NoBuiltin:
610  case Attribute::NoCapture:
612  case Attribute::NoDuplicate:
614  case Attribute::NoImplicitFloat:
616  case Attribute::NoInline:
618  case Attribute::NoRecurse:
620  case Attribute::NonLazyBind:
622  case Attribute::NonNull:
624  case Attribute::Dereferenceable:
626  case Attribute::DereferenceableOrNull:
628  case Attribute::NoRedZone:
630  case Attribute::NoReturn:
632  case Attribute::NoUnwind:
634  case Attribute::OptimizeForSize:
636  case Attribute::OptimizeNone:
638  case Attribute::ReadNone:
640  case Attribute::ReadOnly:
642  case Attribute::Returned:
644  case Attribute::ReturnsTwice:
646  case Attribute::SExt:
647  return bitc::ATTR_KIND_S_EXT;
648  case Attribute::Speculatable:
650  case Attribute::StackAlignment:
652  case Attribute::StackProtect:
654  case Attribute::StackProtectReq:
656  case Attribute::StackProtectStrong:
658  case Attribute::SafeStack:
660  case Attribute::StrictFP:
662  case Attribute::StructRet:
664  case Attribute::SanitizeAddress:
666  case Attribute::SanitizeThread:
668  case Attribute::SanitizeMemory:
670  case Attribute::SwiftError:
672  case Attribute::SwiftSelf:
674  case Attribute::UWTable:
676  case Attribute::WriteOnly:
678  case Attribute::ZExt:
679  return bitc::ATTR_KIND_Z_EXT;
681  llvm_unreachable("Can not encode end-attribute kinds marker.");
682  case Attribute::None:
683  llvm_unreachable("Can not encode none-attribute.");
684  }
685 
686  llvm_unreachable("Trying to encode unknown attribute");
687 }
688 
689 void ModuleBitcodeWriter::writeAttributeGroupTable() {
690  const std::vector<ValueEnumerator::IndexAndAttrSet> &AttrGrps =
691  VE.getAttributeGroups();
692  if (AttrGrps.empty()) return;
693 
695 
697  for (ValueEnumerator::IndexAndAttrSet Pair : AttrGrps) {
698  unsigned AttrListIndex = Pair.first;
699  AttributeSet AS = Pair.second;
700  Record.push_back(VE.getAttributeGroupID(Pair));
701  Record.push_back(AttrListIndex);
702 
703  for (Attribute Attr : AS) {
704  if (Attr.isEnumAttribute()) {
705  Record.push_back(0);
706  Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
707  } else if (Attr.isIntAttribute()) {
708  Record.push_back(1);
709  Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
710  Record.push_back(Attr.getValueAsInt());
711  } else {
712  StringRef Kind = Attr.getKindAsString();
713  StringRef Val = Attr.getValueAsString();
714 
715  Record.push_back(Val.empty() ? 3 : 4);
716  Record.append(Kind.begin(), Kind.end());
717  Record.push_back(0);
718  if (!Val.empty()) {
719  Record.append(Val.begin(), Val.end());
720  Record.push_back(0);
721  }
722  }
723  }
724 
726  Record.clear();
727  }
728 
729  Stream.ExitBlock();
730 }
731 
732 void ModuleBitcodeWriter::writeAttributeTable() {
733  const std::vector<AttributeList> &Attrs = VE.getAttributeLists();
734  if (Attrs.empty()) return;
735 
737 
739  for (unsigned i = 0, e = Attrs.size(); i != e; ++i) {
740  AttributeList AL = Attrs[i];
741  for (unsigned i = AL.index_begin(), e = AL.index_end(); i != e; ++i) {
742  AttributeSet AS = AL.getAttributes(i);
743  if (AS.hasAttributes())
744  Record.push_back(VE.getAttributeGroupID({i, AS}));
745  }
746 
747  Stream.EmitRecord(bitc::PARAMATTR_CODE_ENTRY, Record);
748  Record.clear();
749  }
750 
751  Stream.ExitBlock();
752 }
753 
754 /// WriteTypeTable - Write out the type table for a module.
755 void ModuleBitcodeWriter::writeTypeTable() {
756  const ValueEnumerator::TypeList &TypeList = VE.getTypes();
757 
758  Stream.EnterSubblock(bitc::TYPE_BLOCK_ID_NEW, 4 /*count from # abbrevs */);
759  SmallVector<uint64_t, 64> TypeVals;
760 
761  uint64_t NumBits = VE.computeBitsRequiredForTypeIndicies();
762 
763  // Abbrev for TYPE_CODE_POINTER.
764  auto Abbv = std::make_shared<BitCodeAbbrev>();
766  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
767  Abbv->Add(BitCodeAbbrevOp(0)); // Addrspace = 0
768  unsigned PtrAbbrev = Stream.EmitAbbrev(std::move(Abbv));
769 
770  // Abbrev for TYPE_CODE_FUNCTION.
771  Abbv = std::make_shared<BitCodeAbbrev>();
773  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isvararg
775  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
776  unsigned FunctionAbbrev = Stream.EmitAbbrev(std::move(Abbv));
777 
778  // Abbrev for TYPE_CODE_STRUCT_ANON.
779  Abbv = std::make_shared<BitCodeAbbrev>();
781  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ispacked
783  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
784  unsigned StructAnonAbbrev = Stream.EmitAbbrev(std::move(Abbv));
785 
786  // Abbrev for TYPE_CODE_STRUCT_NAME.
787  Abbv = std::make_shared<BitCodeAbbrev>();
791  unsigned StructNameAbbrev = Stream.EmitAbbrev(std::move(Abbv));
792 
793  // Abbrev for TYPE_CODE_STRUCT_NAMED.
794  Abbv = std::make_shared<BitCodeAbbrev>();
796  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ispacked
798  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
799  unsigned StructNamedAbbrev = Stream.EmitAbbrev(std::move(Abbv));
800 
801  // Abbrev for TYPE_CODE_ARRAY.
802  Abbv = std::make_shared<BitCodeAbbrev>();
804  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // size
805  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
806  unsigned ArrayAbbrev = Stream.EmitAbbrev(std::move(Abbv));
807 
808  // Emit an entry count so the reader can reserve space.
809  TypeVals.push_back(TypeList.size());
810  Stream.EmitRecord(bitc::TYPE_CODE_NUMENTRY, TypeVals);
811  TypeVals.clear();
812 
813  // Loop over all of the types, emitting each in turn.
814  for (unsigned i = 0, e = TypeList.size(); i != e; ++i) {
815  Type *T = TypeList[i];
816  int AbbrevToUse = 0;
817  unsigned Code = 0;
818 
819  switch (T->getTypeID()) {
820  case Type::VoidTyID: Code = bitc::TYPE_CODE_VOID; break;
821  case Type::HalfTyID: Code = bitc::TYPE_CODE_HALF; break;
822  case Type::FloatTyID: Code = bitc::TYPE_CODE_FLOAT; break;
823  case Type::DoubleTyID: Code = bitc::TYPE_CODE_DOUBLE; break;
824  case Type::X86_FP80TyID: Code = bitc::TYPE_CODE_X86_FP80; break;
825  case Type::FP128TyID: Code = bitc::TYPE_CODE_FP128; break;
827  case Type::LabelTyID: Code = bitc::TYPE_CODE_LABEL; break;
828  case Type::MetadataTyID: Code = bitc::TYPE_CODE_METADATA; break;
829  case Type::X86_MMXTyID: Code = bitc::TYPE_CODE_X86_MMX; break;
830  case Type::TokenTyID: Code = bitc::TYPE_CODE_TOKEN; break;
831  case Type::IntegerTyID:
832  // INTEGER: [width]
834  TypeVals.push_back(cast<IntegerType>(T)->getBitWidth());
835  break;
836  case Type::PointerTyID: {
837  PointerType *PTy = cast<PointerType>(T);
838  // POINTER: [pointee type, address space]
840  TypeVals.push_back(VE.getTypeID(PTy->getElementType()));
841  unsigned AddressSpace = PTy->getAddressSpace();
842  TypeVals.push_back(AddressSpace);
843  if (AddressSpace == 0) AbbrevToUse = PtrAbbrev;
844  break;
845  }
846  case Type::FunctionTyID: {
847  FunctionType *FT = cast<FunctionType>(T);
848  // FUNCTION: [isvararg, retty, paramty x N]
850  TypeVals.push_back(FT->isVarArg());
851  TypeVals.push_back(VE.getTypeID(FT->getReturnType()));
852  for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i)
853  TypeVals.push_back(VE.getTypeID(FT->getParamType(i)));
854  AbbrevToUse = FunctionAbbrev;
855  break;
856  }
857  case Type::StructTyID: {
858  StructType *ST = cast<StructType>(T);
859  // STRUCT: [ispacked, eltty x N]
860  TypeVals.push_back(ST->isPacked());
861  // Output all of the element types.
863  E = ST->element_end(); I != E; ++I)
864  TypeVals.push_back(VE.getTypeID(*I));
865 
866  if (ST->isLiteral()) {
868  AbbrevToUse = StructAnonAbbrev;
869  } else {
870  if (ST->isOpaque()) {
871  Code = bitc::TYPE_CODE_OPAQUE;
872  } else {
874  AbbrevToUse = StructNamedAbbrev;
875  }
876 
877  // Emit the name if it is present.
878  if (!ST->getName().empty())
880  StructNameAbbrev);
881  }
882  break;
883  }
884  case Type::ArrayTyID: {
885  ArrayType *AT = cast<ArrayType>(T);
886  // ARRAY: [numelts, eltty]
887  Code = bitc::TYPE_CODE_ARRAY;
888  TypeVals.push_back(AT->getNumElements());
889  TypeVals.push_back(VE.getTypeID(AT->getElementType()));
890  AbbrevToUse = ArrayAbbrev;
891  break;
892  }
893  case Type::VectorTyID: {
894  VectorType *VT = cast<VectorType>(T);
895  // VECTOR [numelts, eltty]
896  Code = bitc::TYPE_CODE_VECTOR;
897  TypeVals.push_back(VT->getNumElements());
898  TypeVals.push_back(VE.getTypeID(VT->getElementType()));
899  break;
900  }
901  }
902 
903  // Emit the finished record.
904  Stream.EmitRecord(Code, TypeVals, AbbrevToUse);
905  TypeVals.clear();
906  }
907 
908  Stream.ExitBlock();
909 }
910 
911 static unsigned getEncodedLinkage(const GlobalValue::LinkageTypes Linkage) {
912  switch (Linkage) {
914  return 0;
916  return 16;
918  return 2;
920  return 3;
922  return 18;
924  return 7;
926  return 8;
928  return 9;
930  return 17;
932  return 19;
934  return 12;
935  }
936  llvm_unreachable("Invalid linkage");
937 }
938 
939 static unsigned getEncodedLinkage(const GlobalValue &GV) {
940  return getEncodedLinkage(GV.getLinkage());
941 }
942 
944  uint64_t RawFlags = 0;
945  RawFlags |= Flags.ReadNone;
946  RawFlags |= (Flags.ReadOnly << 1);
947  RawFlags |= (Flags.NoRecurse << 2);
948  RawFlags |= (Flags.ReturnDoesNotAlias << 3);
949  return RawFlags;
950 }
951 
952 // Decode the flags for GlobalValue in the summary
954  uint64_t RawFlags = 0;
955 
956  RawFlags |= Flags.NotEligibleToImport; // bool
957  RawFlags |= (Flags.Live << 1);
958  // Linkage don't need to be remapped at that time for the summary. Any future
959  // change to the getEncodedLinkage() function will need to be taken into
960  // account here as well.
961  RawFlags = (RawFlags << 4) | Flags.Linkage; // 4 bits
962 
963  return RawFlags;
964 }
965 
966 static unsigned getEncodedVisibility(const GlobalValue &GV) {
967  switch (GV.getVisibility()) {
968  case GlobalValue::DefaultVisibility: return 0;
969  case GlobalValue::HiddenVisibility: return 1;
970  case GlobalValue::ProtectedVisibility: return 2;
971  }
972  llvm_unreachable("Invalid visibility");
973 }
974 
975 static unsigned getEncodedDLLStorageClass(const GlobalValue &GV) {
976  switch (GV.getDLLStorageClass()) {
977  case GlobalValue::DefaultStorageClass: return 0;
978  case GlobalValue::DLLImportStorageClass: return 1;
979  case GlobalValue::DLLExportStorageClass: return 2;
980  }
981  llvm_unreachable("Invalid DLL storage class");
982 }
983 
984 static unsigned getEncodedThreadLocalMode(const GlobalValue &GV) {
985  switch (GV.getThreadLocalMode()) {
986  case GlobalVariable::NotThreadLocal: return 0;
990  case GlobalVariable::LocalExecTLSModel: return 4;
991  }
992  llvm_unreachable("Invalid TLS model");
993 }
994 
995 static unsigned getEncodedComdatSelectionKind(const Comdat &C) {
996  switch (C.getSelectionKind()) {
997  case Comdat::Any:
999  case Comdat::ExactMatch:
1001  case Comdat::Largest:
1003  case Comdat::NoDuplicates:
1005  case Comdat::SameSize:
1007  }
1008  llvm_unreachable("Invalid selection kind");
1009 }
1010 
1011 static unsigned getEncodedUnnamedAddr(const GlobalValue &GV) {
1012  switch (GV.getUnnamedAddr()) {
1013  case GlobalValue::UnnamedAddr::None: return 0;
1014  case GlobalValue::UnnamedAddr::Local: return 2;
1015  case GlobalValue::UnnamedAddr::Global: return 1;
1016  }
1017  llvm_unreachable("Invalid unnamed_addr");
1018 }
1019 
1020 size_t ModuleBitcodeWriter::addToStrtab(StringRef Str) {
1021  if (GenerateHash)
1022  Hasher.update(Str);
1023  return StrtabBuilder.add(Str);
1024 }
1025 
1026 void ModuleBitcodeWriter::writeComdats() {
1028  for (const Comdat *C : VE.getComdats()) {
1029  // COMDAT: [strtab offset, strtab size, selection_kind]
1030  Vals.push_back(addToStrtab(C->getName()));
1031  Vals.push_back(C->getName().size());
1033  Stream.EmitRecord(bitc::MODULE_CODE_COMDAT, Vals, /*AbbrevToUse=*/0);
1034  Vals.clear();
1035  }
1036 }
1037 
1038 /// Write a record that will eventually hold the word offset of the
1039 /// module-level VST. For now the offset is 0, which will be backpatched
1040 /// after the real VST is written. Saves the bit offset to backpatch.
1041 void ModuleBitcodeWriter::writeValueSymbolTableForwardDecl() {
1042  // Write a placeholder value in for the offset of the real VST,
1043  // which is written after the function blocks so that it can include
1044  // the offset of each function. The placeholder offset will be
1045  // updated when the real VST is written.
1046  auto Abbv = std::make_shared<BitCodeAbbrev>();
1048  // Blocks are 32-bit aligned, so we can use a 32-bit word offset to
1049  // hold the real VST offset. Must use fixed instead of VBR as we don't
1050  // know how many VBR chunks to reserve ahead of time.
1051  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1052  unsigned VSTOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbv));
1053 
1054  // Emit the placeholder
1055  uint64_t Vals[] = {bitc::MODULE_CODE_VSTOFFSET, 0};
1056  Stream.EmitRecordWithAbbrev(VSTOffsetAbbrev, Vals);
1057 
1058  // Compute and save the bit offset to the placeholder, which will be
1059  // patched when the real VST is written. We can simply subtract the 32-bit
1060  // fixed size from the current bit number to get the location to backpatch.
1061  VSTOffsetPlaceholder = Stream.GetCurrentBitNo() - 32;
1062 }
1063 
1065 
1066 /// Determine the encoding to use for the given string name and length.
1068  bool isChar6 = true;
1069  for (char C : Str) {
1070  if (isChar6)
1071  isChar6 = BitCodeAbbrevOp::isChar6(C);
1072  if ((unsigned char)C & 128)
1073  // don't bother scanning the rest.
1074  return SE_Fixed8;
1075  }
1076  if (isChar6)
1077  return SE_Char6;
1078  return SE_Fixed7;
1079 }
1080 
1081 /// Emit top-level description of module, including target triple, inline asm,
1082 /// descriptors for global variables, and function prototype info.
1083 /// Returns the bit offset to backpatch with the location of the real VST.
1084 void ModuleBitcodeWriter::writeModuleInfo() {
1085  // Emit various pieces of data attached to a module.
1086  if (!M.getTargetTriple().empty())
1088  0 /*TODO*/);
1089  const std::string &DL = M.getDataLayoutStr();
1090  if (!DL.empty())
1091  writeStringRecord(Stream, bitc::MODULE_CODE_DATALAYOUT, DL, 0 /*TODO*/);
1092  if (!M.getModuleInlineAsm().empty())
1094  0 /*TODO*/);
1095 
1096  // Emit information about sections and GC, computing how many there are. Also
1097  // compute the maximum alignment value.
1098  std::map<std::string, unsigned> SectionMap;
1099  std::map<std::string, unsigned> GCMap;
1100  unsigned MaxAlignment = 0;
1101  unsigned MaxGlobalType = 0;
1102  for (const GlobalValue &GV : M.globals()) {
1103  MaxAlignment = std::max(MaxAlignment, GV.getAlignment());
1104  MaxGlobalType = std::max(MaxGlobalType, VE.getTypeID(GV.getValueType()));
1105  if (GV.hasSection()) {
1106  // Give section names unique ID's.
1107  unsigned &Entry = SectionMap[GV.getSection()];
1108  if (!Entry) {
1109  writeStringRecord(Stream, bitc::MODULE_CODE_SECTIONNAME, GV.getSection(),
1110  0 /*TODO*/);
1111  Entry = SectionMap.size();
1112  }
1113  }
1114  }
1115  for (const Function &F : M) {
1116  MaxAlignment = std::max(MaxAlignment, F.getAlignment());
1117  if (F.hasSection()) {
1118  // Give section names unique ID's.
1119  unsigned &Entry = SectionMap[F.getSection()];
1120  if (!Entry) {
1121  writeStringRecord(Stream, bitc::MODULE_CODE_SECTIONNAME, F.getSection(),
1122  0 /*TODO*/);
1123  Entry = SectionMap.size();
1124  }
1125  }
1126  if (F.hasGC()) {
1127  // Same for GC names.
1128  unsigned &Entry = GCMap[F.getGC()];
1129  if (!Entry) {
1130  writeStringRecord(Stream, bitc::MODULE_CODE_GCNAME, F.getGC(),
1131  0 /*TODO*/);
1132  Entry = GCMap.size();
1133  }
1134  }
1135  }
1136 
1137  // Emit abbrev for globals, now that we know # sections and max alignment.
1138  unsigned SimpleGVarAbbrev = 0;
1139  if (!M.global_empty()) {
1140  // Add an abbrev for common globals with no visibility or thread localness.
1141  auto Abbv = std::make_shared<BitCodeAbbrev>();
1143  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1144  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1146  Log2_32_Ceil(MaxGlobalType+1)));
1147  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // AddrSpace << 2
1148  //| explicitType << 1
1149  //| constant
1150  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Initializer.
1151  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // Linkage.
1152  if (MaxAlignment == 0) // Alignment.
1153  Abbv->Add(BitCodeAbbrevOp(0));
1154  else {
1155  unsigned MaxEncAlignment = Log2_32(MaxAlignment)+1;
1157  Log2_32_Ceil(MaxEncAlignment+1)));
1158  }
1159  if (SectionMap.empty()) // Section.
1160  Abbv->Add(BitCodeAbbrevOp(0));
1161  else
1163  Log2_32_Ceil(SectionMap.size()+1)));
1164  // Don't bother emitting vis + thread local.
1165  SimpleGVarAbbrev = Stream.EmitAbbrev(std::move(Abbv));
1166  }
1167 
1169  // Emit the module's source file name.
1170  {
1171  StringEncoding Bits = getStringEncoding(M.getSourceFileName());
1173  if (Bits == SE_Char6)
1174  AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Char6);
1175  else if (Bits == SE_Fixed7)
1176  AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7);
1177 
1178  // MODULE_CODE_SOURCE_FILENAME: [namechar x N]
1179  auto Abbv = std::make_shared<BitCodeAbbrev>();
1182  Abbv->Add(AbbrevOpToUse);
1183  unsigned FilenameAbbrev = Stream.EmitAbbrev(std::move(Abbv));
1184 
1185  for (const auto P : M.getSourceFileName())
1186  Vals.push_back((unsigned char)P);
1187 
1188  // Emit the finished record.
1189  Stream.EmitRecord(bitc::MODULE_CODE_SOURCE_FILENAME, Vals, FilenameAbbrev);
1190  Vals.clear();
1191  }
1192 
1193  // Emit the global variable information.
1194  for (const GlobalVariable &GV : M.globals()) {
1195  unsigned AbbrevToUse = 0;
1196 
1197  // GLOBALVAR: [strtab offset, strtab size, type, isconst, initid,
1198  // linkage, alignment, section, visibility, threadlocal,
1199  // unnamed_addr, externally_initialized, dllstorageclass,
1200  // comdat, attributes]
1201  Vals.push_back(addToStrtab(GV.getName()));
1202  Vals.push_back(GV.getName().size());
1203  Vals.push_back(VE.getTypeID(GV.getValueType()));
1204  Vals.push_back(GV.getType()->getAddressSpace() << 2 | 2 | GV.isConstant());
1205  Vals.push_back(GV.isDeclaration() ? 0 :
1206  (VE.getValueID(GV.getInitializer()) + 1));
1207  Vals.push_back(getEncodedLinkage(GV));
1208  Vals.push_back(Log2_32(GV.getAlignment())+1);
1209  Vals.push_back(GV.hasSection() ? SectionMap[GV.getSection()] : 0);
1210  if (GV.isThreadLocal() ||
1211  GV.getVisibility() != GlobalValue::DefaultVisibility ||
1212  GV.getUnnamedAddr() != GlobalValue::UnnamedAddr::None ||
1213  GV.isExternallyInitialized() ||
1214  GV.getDLLStorageClass() != GlobalValue::DefaultStorageClass ||
1215  GV.hasComdat() ||
1216  GV.hasAttributes()) {
1217  Vals.push_back(getEncodedVisibility(GV));
1219  Vals.push_back(getEncodedUnnamedAddr(GV));
1220  Vals.push_back(GV.isExternallyInitialized());
1222  Vals.push_back(GV.hasComdat() ? VE.getComdatID(GV.getComdat()) : 0);
1223 
1224  auto AL = GV.getAttributesAsList(AttributeList::FunctionIndex);
1225  Vals.push_back(VE.getAttributeListID(AL));
1226  } else {
1227  AbbrevToUse = SimpleGVarAbbrev;
1228  }
1229 
1230  Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse);
1231  Vals.clear();
1232  }
1233 
1234  // Emit the function proto information.
1235  for (const Function &F : M) {
1236  // FUNCTION: [strtab offset, strtab size, type, callingconv, isproto,
1237  // linkage, paramattrs, alignment, section, visibility, gc,
1238  // unnamed_addr, prologuedata, dllstorageclass, comdat,
1239  // prefixdata, personalityfn]
1240  Vals.push_back(addToStrtab(F.getName()));
1241  Vals.push_back(F.getName().size());
1242  Vals.push_back(VE.getTypeID(F.getFunctionType()));
1243  Vals.push_back(F.getCallingConv());
1244  Vals.push_back(F.isDeclaration());
1245  Vals.push_back(getEncodedLinkage(F));
1246  Vals.push_back(VE.getAttributeListID(F.getAttributes()));
1247  Vals.push_back(Log2_32(F.getAlignment())+1);
1248  Vals.push_back(F.hasSection() ? SectionMap[F.getSection()] : 0);
1250  Vals.push_back(F.hasGC() ? GCMap[F.getGC()] : 0);
1252  Vals.push_back(F.hasPrologueData() ? (VE.getValueID(F.getPrologueData()) + 1)
1253  : 0);
1255  Vals.push_back(F.hasComdat() ? VE.getComdatID(F.getComdat()) : 0);
1256  Vals.push_back(F.hasPrefixData() ? (VE.getValueID(F.getPrefixData()) + 1)
1257  : 0);
1258  Vals.push_back(
1259  F.hasPersonalityFn() ? (VE.getValueID(F.getPersonalityFn()) + 1) : 0);
1260 
1261  unsigned AbbrevToUse = 0;
1262  Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse);
1263  Vals.clear();
1264  }
1265 
1266  // Emit the alias information.
1267  for (const GlobalAlias &A : M.aliases()) {
1268  // ALIAS: [strtab offset, strtab size, alias type, aliasee val#, linkage,
1269  // visibility, dllstorageclass, threadlocal, unnamed_addr]
1270  Vals.push_back(addToStrtab(A.getName()));
1271  Vals.push_back(A.getName().size());
1272  Vals.push_back(VE.getTypeID(A.getValueType()));
1273  Vals.push_back(A.getType()->getAddressSpace());
1274  Vals.push_back(VE.getValueID(A.getAliasee()));
1275  Vals.push_back(getEncodedLinkage(A));
1280  unsigned AbbrevToUse = 0;
1281  Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals, AbbrevToUse);
1282  Vals.clear();
1283  }
1284 
1285  // Emit the ifunc information.
1286  for (const GlobalIFunc &I : M.ifuncs()) {
1287  // IFUNC: [strtab offset, strtab size, ifunc type, address space, resolver
1288  // val#, linkage, visibility]
1289  Vals.push_back(addToStrtab(I.getName()));
1290  Vals.push_back(I.getName().size());
1291  Vals.push_back(VE.getTypeID(I.getValueType()));
1292  Vals.push_back(I.getType()->getAddressSpace());
1293  Vals.push_back(VE.getValueID(I.getResolver()));
1294  Vals.push_back(getEncodedLinkage(I));
1296  Stream.EmitRecord(bitc::MODULE_CODE_IFUNC, Vals);
1297  Vals.clear();
1298  }
1299 
1300  writeValueSymbolTableForwardDecl();
1301 }
1302 
1303 static uint64_t getOptimizationFlags(const Value *V) {
1304  uint64_t Flags = 0;
1305 
1306  if (const auto *OBO = dyn_cast<OverflowingBinaryOperator>(V)) {
1307  if (OBO->hasNoSignedWrap())
1308  Flags |= 1 << bitc::OBO_NO_SIGNED_WRAP;
1309  if (OBO->hasNoUnsignedWrap())
1310  Flags |= 1 << bitc::OBO_NO_UNSIGNED_WRAP;
1311  } else if (const auto *PEO = dyn_cast<PossiblyExactOperator>(V)) {
1312  if (PEO->isExact())
1313  Flags |= 1 << bitc::PEO_EXACT;
1314  } else if (const auto *FPMO = dyn_cast<FPMathOperator>(V)) {
1315  if (FPMO->hasUnsafeAlgebra())
1317  if (FPMO->hasNoNaNs())
1318  Flags |= FastMathFlags::NoNaNs;
1319  if (FPMO->hasNoInfs())
1320  Flags |= FastMathFlags::NoInfs;
1321  if (FPMO->hasNoSignedZeros())
1323  if (FPMO->hasAllowReciprocal())
1325  if (FPMO->hasAllowContract())
1327  }
1328 
1329  return Flags;
1330 }
1331 
1332 void ModuleBitcodeWriter::writeValueAsMetadata(
1334  // Mimic an MDNode with a value as one operand.
1335  Value *V = MD->getValue();
1336  Record.push_back(VE.getTypeID(V->getType()));
1337  Record.push_back(VE.getValueID(V));
1338  Stream.EmitRecord(bitc::METADATA_VALUE, Record, 0);
1339  Record.clear();
1340 }
1341 
1343  SmallVectorImpl<uint64_t> &Record,
1344  unsigned Abbrev) {
1345  for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
1346  Metadata *MD = N->getOperand(i);
1347  assert(!(MD && isa<LocalAsMetadata>(MD)) &&
1348  "Unexpected function-local metadata");
1349  Record.push_back(VE.getMetadataOrNullID(MD));
1350  }
1353  Record, Abbrev);
1354  Record.clear();
1355 }
1356 
1357 unsigned ModuleBitcodeWriter::createDILocationAbbrev() {
1358  // Assume the column is usually under 128, and always output the inlined-at
1359  // location (it's never more expensive than building an array size 1).
1360  auto Abbv = std::make_shared<BitCodeAbbrev>();
1362  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1363  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1364  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1365  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1366  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1367  return Stream.EmitAbbrev(std::move(Abbv));
1368 }
1369 
1371  SmallVectorImpl<uint64_t> &Record,
1372  unsigned &Abbrev) {
1373  if (!Abbrev)
1374  Abbrev = createDILocationAbbrev();
1375 
1376  Record.push_back(N->isDistinct());
1377  Record.push_back(N->getLine());
1378  Record.push_back(N->getColumn());
1379  Record.push_back(VE.getMetadataID(N->getScope()));
1380  Record.push_back(VE.getMetadataOrNullID(N->getInlinedAt()));
1381 
1382  Stream.EmitRecord(bitc::METADATA_LOCATION, Record, Abbrev);
1383  Record.clear();
1384 }
1385 
1386 unsigned ModuleBitcodeWriter::createGenericDINodeAbbrev() {
1387  // Assume the column is usually under 128, and always output the inlined-at
1388  // location (it's never more expensive than building an array size 1).
1389  auto Abbv = std::make_shared<BitCodeAbbrev>();
1391  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1392  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1393  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1394  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1396  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1397  return Stream.EmitAbbrev(std::move(Abbv));
1398 }
1399 
1401  SmallVectorImpl<uint64_t> &Record,
1402  unsigned &Abbrev) {
1403  if (!Abbrev)
1404  Abbrev = createGenericDINodeAbbrev();
1405 
1406  Record.push_back(N->isDistinct());
1407  Record.push_back(N->getTag());
1408  Record.push_back(0); // Per-tag version field; unused for now.
1409 
1410  for (auto &I : N->operands())
1411  Record.push_back(VE.getMetadataOrNullID(I));
1412 
1413  Stream.EmitRecord(bitc::METADATA_GENERIC_DEBUG, Record, Abbrev);
1414  Record.clear();
1415 }
1416 
1417 static uint64_t rotateSign(int64_t I) {
1418  uint64_t U = I;
1419  return I < 0 ? ~(U << 1) : U << 1;
1420 }
1421 
1423  SmallVectorImpl<uint64_t> &Record,
1424  unsigned Abbrev) {
1425  Record.push_back(N->isDistinct());
1426  Record.push_back(N->getCount());
1427  Record.push_back(rotateSign(N->getLowerBound()));
1428 
1429  Stream.EmitRecord(bitc::METADATA_SUBRANGE, Record, Abbrev);
1430  Record.clear();
1431 }
1432 
1434  SmallVectorImpl<uint64_t> &Record,
1435  unsigned Abbrev) {
1436  Record.push_back(N->isDistinct());
1437  Record.push_back(rotateSign(N->getValue()));
1438  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1439 
1440  Stream.EmitRecord(bitc::METADATA_ENUMERATOR, Record, Abbrev);
1441  Record.clear();
1442 }
1443 
1445  SmallVectorImpl<uint64_t> &Record,
1446  unsigned Abbrev) {
1447  Record.push_back(N->isDistinct());
1448  Record.push_back(N->getTag());
1449  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1450  Record.push_back(N->getSizeInBits());
1451  Record.push_back(N->getAlignInBits());
1452  Record.push_back(N->getEncoding());
1453 
1454  Stream.EmitRecord(bitc::METADATA_BASIC_TYPE, Record, Abbrev);
1455  Record.clear();
1456 }
1457 
1459  SmallVectorImpl<uint64_t> &Record,
1460  unsigned Abbrev) {
1461  Record.push_back(N->isDistinct());
1462  Record.push_back(N->getTag());
1463  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1464  Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1465  Record.push_back(N->getLine());
1466  Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1467  Record.push_back(VE.getMetadataOrNullID(N->getBaseType()));
1468  Record.push_back(N->getSizeInBits());
1469  Record.push_back(N->getAlignInBits());
1470  Record.push_back(N->getOffsetInBits());
1471  Record.push_back(N->getFlags());
1472  Record.push_back(VE.getMetadataOrNullID(N->getExtraData()));
1473 
1474  // DWARF address space is encoded as N->getDWARFAddressSpace() + 1. 0 means
1475  // that there is no DWARF address space associated with DIDerivedType.
1476  if (const auto &DWARFAddressSpace = N->getDWARFAddressSpace())
1477  Record.push_back(*DWARFAddressSpace + 1);
1478  else
1479  Record.push_back(0);
1480 
1481  Stream.EmitRecord(bitc::METADATA_DERIVED_TYPE, Record, Abbrev);
1482  Record.clear();
1483 }
1484 
1486  const DICompositeType *N, SmallVectorImpl<uint64_t> &Record,
1487  unsigned Abbrev) {
1488  const unsigned IsNotUsedInOldTypeRef = 0x2;
1489  Record.push_back(IsNotUsedInOldTypeRef | (unsigned)N->isDistinct());
1490  Record.push_back(N->getTag());
1491  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1492  Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1493  Record.push_back(N->getLine());
1494  Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1495  Record.push_back(VE.getMetadataOrNullID(N->getBaseType()));
1496  Record.push_back(N->getSizeInBits());
1497  Record.push_back(N->getAlignInBits());
1498  Record.push_back(N->getOffsetInBits());
1499  Record.push_back(N->getFlags());
1500  Record.push_back(VE.getMetadataOrNullID(N->getElements().get()));
1501  Record.push_back(N->getRuntimeLang());
1503  Record.push_back(VE.getMetadataOrNullID(N->getTemplateParams().get()));
1505 
1506  Stream.EmitRecord(bitc::METADATA_COMPOSITE_TYPE, Record, Abbrev);
1507  Record.clear();
1508 }
1509 
1511  const DISubroutineType *N, SmallVectorImpl<uint64_t> &Record,
1512  unsigned Abbrev) {
1513  const unsigned HasNoOldTypeRefs = 0x2;
1514  Record.push_back(HasNoOldTypeRefs | (unsigned)N->isDistinct());
1515  Record.push_back(N->getFlags());
1516  Record.push_back(VE.getMetadataOrNullID(N->getTypeArray().get()));
1517  Record.push_back(N->getCC());
1518 
1519  Stream.EmitRecord(bitc::METADATA_SUBROUTINE_TYPE, Record, Abbrev);
1520  Record.clear();
1521 }
1522 
1524  SmallVectorImpl<uint64_t> &Record,
1525  unsigned Abbrev) {
1526  Record.push_back(N->isDistinct());
1527  Record.push_back(VE.getMetadataOrNullID(N->getRawFilename()));
1529  Record.push_back(N->getChecksumKind());
1530  Record.push_back(VE.getMetadataOrNullID(N->getRawChecksum()));
1531 
1532  Stream.EmitRecord(bitc::METADATA_FILE, Record, Abbrev);
1533  Record.clear();
1534 }
1535 
1537  SmallVectorImpl<uint64_t> &Record,
1538  unsigned Abbrev) {
1539  assert(N->isDistinct() && "Expected distinct compile units");
1540  Record.push_back(/* IsDistinct */ true);
1541  Record.push_back(N->getSourceLanguage());
1542  Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1543  Record.push_back(VE.getMetadataOrNullID(N->getRawProducer()));
1544  Record.push_back(N->isOptimized());
1545  Record.push_back(VE.getMetadataOrNullID(N->getRawFlags()));
1546  Record.push_back(N->getRuntimeVersion());
1548  Record.push_back(N->getEmissionKind());
1549  Record.push_back(VE.getMetadataOrNullID(N->getEnumTypes().get()));
1550  Record.push_back(VE.getMetadataOrNullID(N->getRetainedTypes().get()));
1551  Record.push_back(/* subprograms */ 0);
1552  Record.push_back(VE.getMetadataOrNullID(N->getGlobalVariables().get()));
1553  Record.push_back(VE.getMetadataOrNullID(N->getImportedEntities().get()));
1554  Record.push_back(N->getDWOId());
1555  Record.push_back(VE.getMetadataOrNullID(N->getMacros().get()));
1556  Record.push_back(N->getSplitDebugInlining());
1557  Record.push_back(N->getDebugInfoForProfiling());
1558  Record.push_back(N->getGnuPubnames());
1559 
1560  Stream.EmitRecord(bitc::METADATA_COMPILE_UNIT, Record, Abbrev);
1561  Record.clear();
1562 }
1563 
1565  SmallVectorImpl<uint64_t> &Record,
1566  unsigned Abbrev) {
1567  uint64_t HasUnitFlag = 1 << 1;
1568  Record.push_back(N->isDistinct() | HasUnitFlag);
1569  Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1570  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1571  Record.push_back(VE.getMetadataOrNullID(N->getRawLinkageName()));
1572  Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1573  Record.push_back(N->getLine());
1574  Record.push_back(VE.getMetadataOrNullID(N->getType()));
1575  Record.push_back(N->isLocalToUnit());
1576  Record.push_back(N->isDefinition());
1577  Record.push_back(N->getScopeLine());
1578  Record.push_back(VE.getMetadataOrNullID(N->getContainingType()));
1579  Record.push_back(N->getVirtuality());
1580  Record.push_back(N->getVirtualIndex());
1581  Record.push_back(N->getFlags());
1582  Record.push_back(N->isOptimized());
1583  Record.push_back(VE.getMetadataOrNullID(N->getRawUnit()));
1584  Record.push_back(VE.getMetadataOrNullID(N->getTemplateParams().get()));
1585  Record.push_back(VE.getMetadataOrNullID(N->getDeclaration()));
1586  Record.push_back(VE.getMetadataOrNullID(N->getVariables().get()));
1587  Record.push_back(N->getThisAdjustment());
1588  Record.push_back(VE.getMetadataOrNullID(N->getThrownTypes().get()));
1589 
1590  Stream.EmitRecord(bitc::METADATA_SUBPROGRAM, Record, Abbrev);
1591  Record.clear();
1592 }
1593 
1595  SmallVectorImpl<uint64_t> &Record,
1596  unsigned Abbrev) {
1597  Record.push_back(N->isDistinct());
1598  Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1599  Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1600  Record.push_back(N->getLine());
1601  Record.push_back(N->getColumn());
1602 
1603  Stream.EmitRecord(bitc::METADATA_LEXICAL_BLOCK, Record, Abbrev);
1604  Record.clear();
1605 }
1606 
1609  unsigned Abbrev) {
1610  Record.push_back(N->isDistinct());
1611  Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1612  Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1613  Record.push_back(N->getDiscriminator());
1614 
1615  Stream.EmitRecord(bitc::METADATA_LEXICAL_BLOCK_FILE, Record, Abbrev);
1616  Record.clear();
1617 }
1618 
1620  SmallVectorImpl<uint64_t> &Record,
1621  unsigned Abbrev) {
1622  Record.push_back(N->isDistinct() | N->getExportSymbols() << 1);
1623  Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1624  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1625 
1626  Stream.EmitRecord(bitc::METADATA_NAMESPACE, Record, Abbrev);
1627  Record.clear();
1628 }
1629 
1631  SmallVectorImpl<uint64_t> &Record,
1632  unsigned Abbrev) {
1633  Record.push_back(N->isDistinct());
1634  Record.push_back(N->getMacinfoType());
1635  Record.push_back(N->getLine());
1636  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1637  Record.push_back(VE.getMetadataOrNullID(N->getRawValue()));
1638 
1639  Stream.EmitRecord(bitc::METADATA_MACRO, Record, Abbrev);
1640  Record.clear();
1641 }
1642 
1644  SmallVectorImpl<uint64_t> &Record,
1645  unsigned Abbrev) {
1646  Record.push_back(N->isDistinct());
1647  Record.push_back(N->getMacinfoType());
1648  Record.push_back(N->getLine());
1649  Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1650  Record.push_back(VE.getMetadataOrNullID(N->getElements().get()));
1651 
1652  Stream.EmitRecord(bitc::METADATA_MACRO_FILE, Record, Abbrev);
1653  Record.clear();
1654 }
1655 
1657  SmallVectorImpl<uint64_t> &Record,
1658  unsigned Abbrev) {
1659  Record.push_back(N->isDistinct());
1660  for (auto &I : N->operands())
1661  Record.push_back(VE.getMetadataOrNullID(I));
1662 
1663  Stream.EmitRecord(bitc::METADATA_MODULE, Record, Abbrev);
1664  Record.clear();
1665 }
1666 
1669  unsigned Abbrev) {
1670  Record.push_back(N->isDistinct());
1671  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1672  Record.push_back(VE.getMetadataOrNullID(N->getType()));
1673 
1674  Stream.EmitRecord(bitc::METADATA_TEMPLATE_TYPE, Record, Abbrev);
1675  Record.clear();
1676 }
1677 
1680  unsigned Abbrev) {
1681  Record.push_back(N->isDistinct());
1682  Record.push_back(N->getTag());
1683  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1684  Record.push_back(VE.getMetadataOrNullID(N->getType()));
1685  Record.push_back(VE.getMetadataOrNullID(N->getValue()));
1686 
1687  Stream.EmitRecord(bitc::METADATA_TEMPLATE_VALUE, Record, Abbrev);
1688  Record.clear();
1689 }
1690 
1692  const DIGlobalVariable *N, SmallVectorImpl<uint64_t> &Record,
1693  unsigned Abbrev) {
1694  const uint64_t Version = 1 << 1;
1695  Record.push_back((uint64_t)N->isDistinct() | Version);
1696  Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1697  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1699  Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1700  Record.push_back(N->getLine());
1701  Record.push_back(VE.getMetadataOrNullID(N->getType()));
1702  Record.push_back(N->isLocalToUnit());
1703  Record.push_back(N->isDefinition());
1704  Record.push_back(/* expr */ 0);
1706  Record.push_back(N->getAlignInBits());
1707 
1708  Stream.EmitRecord(bitc::METADATA_GLOBAL_VAR, Record, Abbrev);
1709  Record.clear();
1710 }
1711 
1713  const DILocalVariable *N, SmallVectorImpl<uint64_t> &Record,
1714  unsigned Abbrev) {
1715  // In order to support all possible bitcode formats in BitcodeReader we need
1716  // to distinguish the following cases:
1717  // 1) Record has no artificial tag (Record[1]),
1718  // has no obsolete inlinedAt field (Record[9]).
1719  // In this case Record size will be 8, HasAlignment flag is false.
1720  // 2) Record has artificial tag (Record[1]),
1721  // has no obsolete inlignedAt field (Record[9]).
1722  // In this case Record size will be 9, HasAlignment flag is false.
1723  // 3) Record has both artificial tag (Record[1]) and
1724  // obsolete inlignedAt field (Record[9]).
1725  // In this case Record size will be 10, HasAlignment flag is false.
1726  // 4) Record has neither artificial tag, nor inlignedAt field, but
1727  // HasAlignment flag is true and Record[8] contains alignment value.
1728  const uint64_t HasAlignmentFlag = 1 << 1;
1729  Record.push_back((uint64_t)N->isDistinct() | HasAlignmentFlag);
1730  Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1731  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1732  Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1733  Record.push_back(N->getLine());
1734  Record.push_back(VE.getMetadataOrNullID(N->getType()));
1735  Record.push_back(N->getArg());
1736  Record.push_back(N->getFlags());
1737  Record.push_back(N->getAlignInBits());
1738 
1739  Stream.EmitRecord(bitc::METADATA_LOCAL_VAR, Record, Abbrev);
1740  Record.clear();
1741 }
1742 
1744  SmallVectorImpl<uint64_t> &Record,
1745  unsigned Abbrev) {
1746  Record.reserve(N->getElements().size() + 1);
1747  const uint64_t Version = 3 << 1;
1748  Record.push_back((uint64_t)N->isDistinct() | Version);
1749  Record.append(N->elements_begin(), N->elements_end());
1750 
1751  Stream.EmitRecord(bitc::METADATA_EXPRESSION, Record, Abbrev);
1752  Record.clear();
1753 }
1754 
1757  unsigned Abbrev) {
1758  Record.push_back(N->isDistinct());
1759  Record.push_back(VE.getMetadataOrNullID(N->getVariable()));
1760  Record.push_back(VE.getMetadataOrNullID(N->getExpression()));
1761 
1762  Stream.EmitRecord(bitc::METADATA_GLOBAL_VAR_EXPR, Record, Abbrev);
1763  Record.clear();
1764 }
1765 
1767  SmallVectorImpl<uint64_t> &Record,
1768  unsigned Abbrev) {
1769  Record.push_back(N->isDistinct());
1770  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1771  Record.push_back(VE.getMetadataOrNullID(N->getFile()));
1772  Record.push_back(N->getLine());
1775  Record.push_back(N->getAttributes());
1776  Record.push_back(VE.getMetadataOrNullID(N->getType()));
1777 
1778  Stream.EmitRecord(bitc::METADATA_OBJC_PROPERTY, Record, Abbrev);
1779  Record.clear();
1780 }
1781 
1783  const DIImportedEntity *N, SmallVectorImpl<uint64_t> &Record,
1784  unsigned Abbrev) {
1785  Record.push_back(N->isDistinct());
1786  Record.push_back(N->getTag());
1787  Record.push_back(VE.getMetadataOrNullID(N->getScope()));
1788  Record.push_back(VE.getMetadataOrNullID(N->getEntity()));
1789  Record.push_back(N->getLine());
1790  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
1791  Record.push_back(VE.getMetadataOrNullID(N->getRawFile()));
1792 
1793  Stream.EmitRecord(bitc::METADATA_IMPORTED_ENTITY, Record, Abbrev);
1794  Record.clear();
1795 }
1796 
1797 unsigned ModuleBitcodeWriter::createNamedMetadataAbbrev() {
1798  auto Abbv = std::make_shared<BitCodeAbbrev>();
1801  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
1802  return Stream.EmitAbbrev(std::move(Abbv));
1803 }
1804 
1805 void ModuleBitcodeWriter::writeNamedMetadata(
1806  SmallVectorImpl<uint64_t> &Record) {
1807  if (M.named_metadata_empty())
1808  return;
1809 
1810  unsigned Abbrev = createNamedMetadataAbbrev();
1811  for (const NamedMDNode &NMD : M.named_metadata()) {
1812  // Write name.
1813  StringRef Str = NMD.getName();
1814  Record.append(Str.bytes_begin(), Str.bytes_end());
1815  Stream.EmitRecord(bitc::METADATA_NAME, Record, Abbrev);
1816  Record.clear();
1817 
1818  // Write named metadata operands.
1819  for (const MDNode *N : NMD.operands())
1820  Record.push_back(VE.getMetadataID(N));
1821  Stream.EmitRecord(bitc::METADATA_NAMED_NODE, Record, 0);
1822  Record.clear();
1823  }
1824 }
1825 
1826 unsigned ModuleBitcodeWriter::createMetadataStringsAbbrev() {
1827  auto Abbv = std::make_shared<BitCodeAbbrev>();
1829  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of strings
1830  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // offset to chars
1832  return Stream.EmitAbbrev(std::move(Abbv));
1833 }
1834 
1835 /// Write out a record for MDString.
1836 ///
1837 /// All the metadata strings in a metadata block are emitted in a single
1838 /// record. The sizes and strings themselves are shoved into a blob.
1839 void ModuleBitcodeWriter::writeMetadataStrings(
1841  if (Strings.empty())
1842  return;
1843 
1844  // Start the record with the number of strings.
1846  Record.push_back(Strings.size());
1847 
1848  // Emit the sizes of the strings in the blob.
1849  SmallString<256> Blob;
1850  {
1851  BitstreamWriter W(Blob);
1852  for (const Metadata *MD : Strings)
1853  W.EmitVBR(cast<MDString>(MD)->getLength(), 6);
1854  W.FlushToWord();
1855  }
1856 
1857  // Add the offset to the strings to the record.
1858  Record.push_back(Blob.size());
1859 
1860  // Add the strings to the blob.
1861  for (const Metadata *MD : Strings)
1862  Blob.append(cast<MDString>(MD)->getString());
1863 
1864  // Emit the final record.
1865  Stream.EmitRecordWithBlob(createMetadataStringsAbbrev(), Record, Blob);
1866  Record.clear();
1867 }
1868 
1869 // Generates an enum to use as an index in the Abbrev array of Metadata record.
1870 enum MetadataAbbrev : unsigned {
1871 #define HANDLE_MDNODE_LEAF(CLASS) CLASS##AbbrevID,
1872 #include "llvm/IR/Metadata.def"
1874 };
1875 
1876 void ModuleBitcodeWriter::writeMetadataRecords(
1878  std::vector<unsigned> *MDAbbrevs, std::vector<uint64_t> *IndexPos) {
1879  if (MDs.empty())
1880  return;
1881 
1882  // Initialize MDNode abbreviations.
1883 #define HANDLE_MDNODE_LEAF(CLASS) unsigned CLASS##Abbrev = 0;
1884 #include "llvm/IR/Metadata.def"
1885 
1886  for (const Metadata *MD : MDs) {
1887  if (IndexPos)
1888  IndexPos->push_back(Stream.GetCurrentBitNo());
1889  if (const MDNode *N = dyn_cast<MDNode>(MD)) {
1890  assert(N->isResolved() && "Expected forward references to be resolved");
1891 
1892  switch (N->getMetadataID()) {
1893  default:
1894  llvm_unreachable("Invalid MDNode subclass");
1895 #define HANDLE_MDNODE_LEAF(CLASS) \
1896  case Metadata::CLASS##Kind: \
1897  if (MDAbbrevs) \
1898  write##CLASS(cast<CLASS>(N), Record, \
1899  (*MDAbbrevs)[MetadataAbbrev::CLASS##AbbrevID]); \
1900  else \
1901  write##CLASS(cast<CLASS>(N), Record, CLASS##Abbrev); \
1902  continue;
1903 #include "llvm/IR/Metadata.def"
1904  }
1905  }
1906  writeValueAsMetadata(cast<ValueAsMetadata>(MD), Record);
1907  }
1908 }
1909 
1910 void ModuleBitcodeWriter::writeModuleMetadata() {
1911  if (!VE.hasMDs() && M.named_metadata_empty())
1912  return;
1913 
1916 
1917  // Emit all abbrevs upfront, so that the reader can jump in the middle of the
1918  // block and load any metadata.
1919  std::vector<unsigned> MDAbbrevs;
1920 
1922  MDAbbrevs[MetadataAbbrev::DILocationAbbrevID] = createDILocationAbbrev();
1923  MDAbbrevs[MetadataAbbrev::GenericDINodeAbbrevID] =
1924  createGenericDINodeAbbrev();
1925 
1926  auto Abbv = std::make_shared<BitCodeAbbrev>();
1928  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1929  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1930  unsigned OffsetAbbrev = Stream.EmitAbbrev(std::move(Abbv));
1931 
1932  Abbv = std::make_shared<BitCodeAbbrev>();
1935  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1936  unsigned IndexAbbrev = Stream.EmitAbbrev(std::move(Abbv));
1937 
1938  // Emit MDStrings together upfront.
1939  writeMetadataStrings(VE.getMDStrings(), Record);
1940 
1941  // We only emit an index for the metadata record if we have more than a given
1942  // (naive) threshold of metadatas, otherwise it is not worth it.
1943  if (VE.getNonMDStrings().size() > IndexThreshold) {
1944  // Write a placeholder value in for the offset of the metadata index,
1945  // which is written after the records, so that it can include
1946  // the offset of each entry. The placeholder offset will be
1947  // updated after all records are emitted.
1948  uint64_t Vals[] = {0, 0};
1949  Stream.EmitRecord(bitc::METADATA_INDEX_OFFSET, Vals, OffsetAbbrev);
1950  }
1951 
1952  // Compute and save the bit offset to the current position, which will be
1953  // patched when we emit the index later. We can simply subtract the 64-bit
1954  // fixed size from the current bit number to get the location to backpatch.
1955  uint64_t IndexOffsetRecordBitPos = Stream.GetCurrentBitNo();
1956 
1957  // This index will contain the bitpos for each individual record.
1958  std::vector<uint64_t> IndexPos;
1959  IndexPos.reserve(VE.getNonMDStrings().size());
1960 
1961  // Write all the records
1962  writeMetadataRecords(VE.getNonMDStrings(), Record, &MDAbbrevs, &IndexPos);
1963 
1964  if (VE.getNonMDStrings().size() > IndexThreshold) {
1965  // Now that we have emitted all the records we will emit the index. But
1966  // first
1967  // backpatch the forward reference so that the reader can skip the records
1968  // efficiently.
1969  Stream.BackpatchWord64(IndexOffsetRecordBitPos - 64,
1970  Stream.GetCurrentBitNo() - IndexOffsetRecordBitPos);
1971 
1972  // Delta encode the index.
1973  uint64_t PreviousValue = IndexOffsetRecordBitPos;
1974  for (auto &Elt : IndexPos) {
1975  auto EltDelta = Elt - PreviousValue;
1976  PreviousValue = Elt;
1977  Elt = EltDelta;
1978  }
1979  // Emit the index record.
1980  Stream.EmitRecord(bitc::METADATA_INDEX, IndexPos, IndexAbbrev);
1981  IndexPos.clear();
1982  }
1983 
1984  // Write the named metadata now.
1985  writeNamedMetadata(Record);
1986 
1987  auto AddDeclAttachedMetadata = [&](const GlobalObject &GO) {
1988  SmallVector<uint64_t, 4> Record;
1989  Record.push_back(VE.getValueID(&GO));
1990  pushGlobalMetadataAttachment(Record, GO);
1992  };
1993  for (const Function &F : M)
1994  if (F.isDeclaration() && F.hasMetadata())
1995  AddDeclAttachedMetadata(F);
1996  // FIXME: Only store metadata for declarations here, and move data for global
1997  // variable definitions to a separate block (PR28134).
1998  for (const GlobalVariable &GV : M.globals())
1999  if (GV.hasMetadata())
2000  AddDeclAttachedMetadata(GV);
2001 
2002  Stream.ExitBlock();
2003 }
2004 
2005 void ModuleBitcodeWriter::writeFunctionMetadata(const Function &F) {
2006  if (!VE.hasMDs())
2007  return;
2008 
2011  writeMetadataStrings(VE.getMDStrings(), Record);
2012  writeMetadataRecords(VE.getNonMDStrings(), Record);
2013  Stream.ExitBlock();
2014 }
2015 
2016 void ModuleBitcodeWriter::pushGlobalMetadataAttachment(
2017  SmallVectorImpl<uint64_t> &Record, const GlobalObject &GO) {
2018  // [n x [id, mdnode]]
2020  GO.getAllMetadata(MDs);
2021  for (const auto &I : MDs) {
2022  Record.push_back(I.first);
2023  Record.push_back(VE.getMetadataID(I.second));
2024  }
2025 }
2026 
2027 void ModuleBitcodeWriter::writeFunctionMetadataAttachment(const Function &F) {
2029 
2031 
2032  if (F.hasMetadata()) {
2033  pushGlobalMetadataAttachment(Record, F);
2034  Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0);
2035  Record.clear();
2036  }
2037 
2038  // Write metadata attachments
2039  // METADATA_ATTACHMENT - [m x [value, [n x [id, mdnode]]]
2041  for (const BasicBlock &BB : F)
2042  for (const Instruction &I : BB) {
2043  MDs.clear();
2044  I.getAllMetadataOtherThanDebugLoc(MDs);
2045 
2046  // If no metadata, ignore instruction.
2047  if (MDs.empty()) continue;
2048 
2049  Record.push_back(VE.getInstructionID(&I));
2050 
2051  for (unsigned i = 0, e = MDs.size(); i != e; ++i) {
2052  Record.push_back(MDs[i].first);
2053  Record.push_back(VE.getMetadataID(MDs[i].second));
2054  }
2055  Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0);
2056  Record.clear();
2057  }
2058 
2059  Stream.ExitBlock();
2060 }
2061 
2062 void ModuleBitcodeWriter::writeModuleMetadataKinds() {
2064 
2065  // Write metadata kinds
2066  // METADATA_KIND - [n x [id, name]]
2068  M.getMDKindNames(Names);
2069 
2070  if (Names.empty()) return;
2071 
2073 
2074  for (unsigned MDKindID = 0, e = Names.size(); MDKindID != e; ++MDKindID) {
2075  Record.push_back(MDKindID);
2076  StringRef KName = Names[MDKindID];
2077  Record.append(KName.begin(), KName.end());
2078 
2079  Stream.EmitRecord(bitc::METADATA_KIND, Record, 0);
2080  Record.clear();
2081  }
2082 
2083  Stream.ExitBlock();
2084 }
2085 
2086 void ModuleBitcodeWriter::writeOperandBundleTags() {
2087  // Write metadata kinds
2088  //
2089  // OPERAND_BUNDLE_TAGS_BLOCK_ID : N x OPERAND_BUNDLE_TAG
2090  //
2091  // OPERAND_BUNDLE_TAG - [strchr x N]
2092 
2094  M.getOperandBundleTags(Tags);
2095 
2096  if (Tags.empty())
2097  return;
2098 
2100 
2102 
2103  for (auto Tag : Tags) {
2104  Record.append(Tag.begin(), Tag.end());
2105 
2106  Stream.EmitRecord(bitc::OPERAND_BUNDLE_TAG, Record, 0);
2107  Record.clear();
2108  }
2109 
2110  Stream.ExitBlock();
2111 }
2112 
2113 void ModuleBitcodeWriter::writeSyncScopeNames() {
2115  M.getContext().getSyncScopeNames(SSNs);
2116  if (SSNs.empty())
2117  return;
2118 
2120 
2122  for (auto SSN : SSNs) {
2123  Record.append(SSN.begin(), SSN.end());
2124  Stream.EmitRecord(bitc::SYNC_SCOPE_NAME, Record, 0);
2125  Record.clear();
2126  }
2127 
2128  Stream.ExitBlock();
2129 }
2130 
2131 static void emitSignedInt64(SmallVectorImpl<uint64_t> &Vals, uint64_t V) {
2132  if ((int64_t)V >= 0)
2133  Vals.push_back(V << 1);
2134  else
2135  Vals.push_back((-V << 1) | 1);
2136 }
2137 
2138 void ModuleBitcodeWriter::writeConstants(unsigned FirstVal, unsigned LastVal,
2139  bool isGlobal) {
2140  if (FirstVal == LastVal) return;
2141 
2143 
2144  unsigned AggregateAbbrev = 0;
2145  unsigned String8Abbrev = 0;
2146  unsigned CString7Abbrev = 0;
2147  unsigned CString6Abbrev = 0;
2148  // If this is a constant pool for the module, emit module-specific abbrevs.
2149  if (isGlobal) {
2150  // Abbrev for CST_CODE_AGGREGATE.
2151  auto Abbv = std::make_shared<BitCodeAbbrev>();
2154  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, Log2_32_Ceil(LastVal+1)));
2155  AggregateAbbrev = Stream.EmitAbbrev(std::move(Abbv));
2156 
2157  // Abbrev for CST_CODE_STRING.
2158  Abbv = std::make_shared<BitCodeAbbrev>();
2161  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
2162  String8Abbrev = Stream.EmitAbbrev(std::move(Abbv));
2163  // Abbrev for CST_CODE_CSTRING.
2164  Abbv = std::make_shared<BitCodeAbbrev>();
2167  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
2168  CString7Abbrev = Stream.EmitAbbrev(std::move(Abbv));
2169  // Abbrev for CST_CODE_CSTRING.
2170  Abbv = std::make_shared<BitCodeAbbrev>();
2174  CString6Abbrev = Stream.EmitAbbrev(std::move(Abbv));
2175  }
2176 
2178 
2179  const ValueEnumerator::ValueList &Vals = VE.getValues();
2180  Type *LastTy = nullptr;
2181  for (unsigned i = FirstVal; i != LastVal; ++i) {
2182  const Value *V = Vals[i].first;
2183  // If we need to switch types, do so now.
2184  if (V->getType() != LastTy) {
2185  LastTy = V->getType();
2186  Record.push_back(VE.getTypeID(LastTy));
2187  Stream.EmitRecord(bitc::CST_CODE_SETTYPE, Record,
2188  CONSTANTS_SETTYPE_ABBREV);
2189  Record.clear();
2190  }
2191 
2192  if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
2193  Record.push_back(unsigned(IA->hasSideEffects()) |
2194  unsigned(IA->isAlignStack()) << 1 |
2195  unsigned(IA->getDialect()&1) << 2);
2196 
2197  // Add the asm string.
2198  const std::string &AsmStr = IA->getAsmString();
2199  Record.push_back(AsmStr.size());
2200  Record.append(AsmStr.begin(), AsmStr.end());
2201 
2202  // Add the constraint string.
2203  const std::string &ConstraintStr = IA->getConstraintString();
2204  Record.push_back(ConstraintStr.size());
2205  Record.append(ConstraintStr.begin(), ConstraintStr.end());
2206  Stream.EmitRecord(bitc::CST_CODE_INLINEASM, Record);
2207  Record.clear();
2208  continue;
2209  }
2210  const Constant *C = cast<Constant>(V);
2211  unsigned Code = -1U;
2212  unsigned AbbrevToUse = 0;
2213  if (C->isNullValue()) {
2214  Code = bitc::CST_CODE_NULL;
2215  } else if (isa<UndefValue>(C)) {
2216  Code = bitc::CST_CODE_UNDEF;
2217  } else if (const ConstantInt *IV = dyn_cast<ConstantInt>(C)) {
2218  if (IV->getBitWidth() <= 64) {
2219  uint64_t V = IV->getSExtValue();
2220  emitSignedInt64(Record, V);
2221  Code = bitc::CST_CODE_INTEGER;
2222  AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
2223  } else { // Wide integers, > 64 bits in size.
2224  // We have an arbitrary precision integer value to write whose
2225  // bit width is > 64. However, in canonical unsigned integer
2226  // format it is likely that the high bits are going to be zero.
2227  // So, we only write the number of active words.
2228  unsigned NWords = IV->getValue().getActiveWords();
2229  const uint64_t *RawWords = IV->getValue().getRawData();
2230  for (unsigned i = 0; i != NWords; ++i) {
2231  emitSignedInt64(Record, RawWords[i]);
2232  }
2234  }
2235  } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
2236  Code = bitc::CST_CODE_FLOAT;
2237  Type *Ty = CFP->getType();
2238  if (Ty->isHalfTy() || Ty->isFloatTy() || Ty->isDoubleTy()) {
2239  Record.push_back(CFP->getValueAPF().bitcastToAPInt().getZExtValue());
2240  } else if (Ty->isX86_FP80Ty()) {
2241  // api needed to prevent premature destruction
2242  // bits are not in the same order as a normal i80 APInt, compensate.
2243  APInt api = CFP->getValueAPF().bitcastToAPInt();
2244  const uint64_t *p = api.getRawData();
2245  Record.push_back((p[1] << 48) | (p[0] >> 16));
2246  Record.push_back(p[0] & 0xffffLL);
2247  } else if (Ty->isFP128Ty() || Ty->isPPC_FP128Ty()) {
2248  APInt api = CFP->getValueAPF().bitcastToAPInt();
2249  const uint64_t *p = api.getRawData();
2250  Record.push_back(p[0]);
2251  Record.push_back(p[1]);
2252  } else {
2253  assert(0 && "Unknown FP type!");
2254  }
2255  } else if (isa<ConstantDataSequential>(C) &&
2256  cast<ConstantDataSequential>(C)->isString()) {
2257  const ConstantDataSequential *Str = cast<ConstantDataSequential>(C);
2258  // Emit constant strings specially.
2259  unsigned NumElts = Str->getNumElements();
2260  // If this is a null-terminated string, use the denser CSTRING encoding.
2261  if (Str->isCString()) {
2262  Code = bitc::CST_CODE_CSTRING;
2263  --NumElts; // Don't encode the null, which isn't allowed by char6.
2264  } else {
2265  Code = bitc::CST_CODE_STRING;
2266  AbbrevToUse = String8Abbrev;
2267  }
2268  bool isCStr7 = Code == bitc::CST_CODE_CSTRING;
2269  bool isCStrChar6 = Code == bitc::CST_CODE_CSTRING;
2270  for (unsigned i = 0; i != NumElts; ++i) {
2271  unsigned char V = Str->getElementAsInteger(i);
2272  Record.push_back(V);
2273  isCStr7 &= (V & 128) == 0;
2274  if (isCStrChar6)
2275  isCStrChar6 = BitCodeAbbrevOp::isChar6(V);
2276  }
2277 
2278  if (isCStrChar6)
2279  AbbrevToUse = CString6Abbrev;
2280  else if (isCStr7)
2281  AbbrevToUse = CString7Abbrev;
2282  } else if (const ConstantDataSequential *CDS =
2283  dyn_cast<ConstantDataSequential>(C)) {
2284  Code = bitc::CST_CODE_DATA;
2285  Type *EltTy = CDS->getType()->getElementType();
2286  if (isa<IntegerType>(EltTy)) {
2287  for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i)
2288  Record.push_back(CDS->getElementAsInteger(i));
2289  } else {
2290  for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i)
2291  Record.push_back(
2292  CDS->getElementAsAPFloat(i).bitcastToAPInt().getLimitedValue());
2293  }
2294  } else if (isa<ConstantAggregate>(C)) {
2295  Code = bitc::CST_CODE_AGGREGATE;
2296  for (const Value *Op : C->operands())
2297  Record.push_back(VE.getValueID(Op));
2298  AbbrevToUse = AggregateAbbrev;
2299  } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
2300  switch (CE->getOpcode()) {
2301  default:
2302  if (Instruction::isCast(CE->getOpcode())) {
2303  Code = bitc::CST_CODE_CE_CAST;
2304  Record.push_back(getEncodedCastOpcode(CE->getOpcode()));
2305  Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
2306  Record.push_back(VE.getValueID(C->getOperand(0)));
2307  AbbrevToUse = CONSTANTS_CE_CAST_Abbrev;
2308  } else {
2309  assert(CE->getNumOperands() == 2 && "Unknown constant expr!");
2310  Code = bitc::CST_CODE_CE_BINOP;
2311  Record.push_back(getEncodedBinaryOpcode(CE->getOpcode()));
2312  Record.push_back(VE.getValueID(C->getOperand(0)));
2313  Record.push_back(VE.getValueID(C->getOperand(1)));
2314  uint64_t Flags = getOptimizationFlags(CE);
2315  if (Flags != 0)
2316  Record.push_back(Flags);
2317  }
2318  break;
2319  case Instruction::GetElementPtr: {
2320  Code = bitc::CST_CODE_CE_GEP;
2321  const auto *GO = cast<GEPOperator>(C);
2322  Record.push_back(VE.getTypeID(GO->getSourceElementType()));
2323  if (Optional<unsigned> Idx = GO->getInRangeIndex()) {
2325  Record.push_back((*Idx << 1) | GO->isInBounds());
2326  } else if (GO->isInBounds())
2328  for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i) {
2329  Record.push_back(VE.getTypeID(C->getOperand(i)->getType()));
2330  Record.push_back(VE.getValueID(C->getOperand(i)));
2331  }
2332  break;
2333  }
2334  case Instruction::Select:
2335  Code = bitc::CST_CODE_CE_SELECT;
2336  Record.push_back(VE.getValueID(C->getOperand(0)));
2337  Record.push_back(VE.getValueID(C->getOperand(1)));
2338  Record.push_back(VE.getValueID(C->getOperand(2)));
2339  break;
2340  case Instruction::ExtractElement:
2342  Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
2343  Record.push_back(VE.getValueID(C->getOperand(0)));
2344  Record.push_back(VE.getTypeID(C->getOperand(1)->getType()));
2345  Record.push_back(VE.getValueID(C->getOperand(1)));
2346  break;
2347  case Instruction::InsertElement:
2349  Record.push_back(VE.getValueID(C->getOperand(0)));
2350  Record.push_back(VE.getValueID(C->getOperand(1)));
2351  Record.push_back(VE.getTypeID(C->getOperand(2)->getType()));
2352  Record.push_back(VE.getValueID(C->getOperand(2)));
2353  break;
2354  case Instruction::ShuffleVector:
2355  // If the return type and argument types are the same, this is a
2356  // standard shufflevector instruction. If the types are different,
2357  // then the shuffle is widening or truncating the input vectors, and
2358  // the argument type must also be encoded.
2359  if (C->getType() == C->getOperand(0)->getType()) {
2361  } else {
2363  Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
2364  }
2365  Record.push_back(VE.getValueID(C->getOperand(0)));
2366  Record.push_back(VE.getValueID(C->getOperand(1)));
2367  Record.push_back(VE.getValueID(C->getOperand(2)));
2368  break;
2369  case Instruction::ICmp:
2370  case Instruction::FCmp:
2371  Code = bitc::CST_CODE_CE_CMP;
2372  Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
2373  Record.push_back(VE.getValueID(C->getOperand(0)));
2374  Record.push_back(VE.getValueID(C->getOperand(1)));
2375  Record.push_back(CE->getPredicate());
2376  break;
2377  }
2378  } else if (const BlockAddress *BA = dyn_cast<BlockAddress>(C)) {
2380  Record.push_back(VE.getTypeID(BA->getFunction()->getType()));
2381  Record.push_back(VE.getValueID(BA->getFunction()));
2382  Record.push_back(VE.getGlobalBasicBlockID(BA->getBasicBlock()));
2383  } else {
2384 #ifndef NDEBUG
2385  C->dump();
2386 #endif
2387  llvm_unreachable("Unknown constant!");
2388  }
2389  Stream.EmitRecord(Code, Record, AbbrevToUse);
2390  Record.clear();
2391  }
2392 
2393  Stream.ExitBlock();
2394 }
2395 
2396 void ModuleBitcodeWriter::writeModuleConstants() {
2397  const ValueEnumerator::ValueList &Vals = VE.getValues();
2398 
2399  // Find the first constant to emit, which is the first non-globalvalue value.
2400  // We know globalvalues have been emitted by WriteModuleInfo.
2401  for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
2402  if (!isa<GlobalValue>(Vals[i].first)) {
2403  writeConstants(i, Vals.size(), true);
2404  return;
2405  }
2406  }
2407 }
2408 
2409 /// pushValueAndType - The file has to encode both the value and type id for
2410 /// many values, because we need to know what type to create for forward
2411 /// references. However, most operands are not forward references, so this type
2412 /// field is not needed.
2413 ///
2414 /// This function adds V's value ID to Vals. If the value ID is higher than the
2415 /// instruction ID, then it is a forward reference, and it also includes the
2416 /// type ID. The value ID that is written is encoded relative to the InstID.
2417 bool ModuleBitcodeWriter::pushValueAndType(const Value *V, unsigned InstID,
2418  SmallVectorImpl<unsigned> &Vals) {
2419  unsigned ValID = VE.getValueID(V);
2420  // Make encoding relative to the InstID.
2421  Vals.push_back(InstID - ValID);
2422  if (ValID >= InstID) {
2423  Vals.push_back(VE.getTypeID(V->getType()));
2424  return true;
2425  }
2426  return false;
2427 }
2428 
2429 void ModuleBitcodeWriter::writeOperandBundles(ImmutableCallSite CS,
2430  unsigned InstID) {
2433 
2434  for (unsigned i = 0, e = CS.getNumOperandBundles(); i != e; ++i) {
2435  const auto &Bundle = CS.getOperandBundleAt(i);
2436  Record.push_back(C.getOperandBundleTagID(Bundle.getTagName()));
2437 
2438  for (auto &Input : Bundle.Inputs)
2439  pushValueAndType(Input, InstID, Record);
2440 
2442  Record.clear();
2443  }
2444 }
2445 
2446 /// pushValue - Like pushValueAndType, but where the type of the value is
2447 /// omitted (perhaps it was already encoded in an earlier operand).
2448 void ModuleBitcodeWriter::pushValue(const Value *V, unsigned InstID,
2449  SmallVectorImpl<unsigned> &Vals) {
2450  unsigned ValID = VE.getValueID(V);
2451  Vals.push_back(InstID - ValID);
2452 }
2453 
2454 void ModuleBitcodeWriter::pushValueSigned(const Value *V, unsigned InstID,
2455  SmallVectorImpl<uint64_t> &Vals) {
2456  unsigned ValID = VE.getValueID(V);
2457  int64_t diff = ((int32_t)InstID - (int32_t)ValID);
2458  emitSignedInt64(Vals, diff);
2459 }
2460 
2461 /// WriteInstruction - Emit an instruction to the specified stream.
2462 void ModuleBitcodeWriter::writeInstruction(const Instruction &I,
2463  unsigned InstID,
2464  SmallVectorImpl<unsigned> &Vals) {
2465  unsigned Code = 0;
2466  unsigned AbbrevToUse = 0;
2467  VE.setInstructionID(&I);
2468  switch (I.getOpcode()) {
2469  default:
2470  if (Instruction::isCast(I.getOpcode())) {
2472  if (!pushValueAndType(I.getOperand(0), InstID, Vals))
2473  AbbrevToUse = FUNCTION_INST_CAST_ABBREV;
2474  Vals.push_back(VE.getTypeID(I.getType()));
2476  } else {
2477  assert(isa<BinaryOperator>(I) && "Unknown instruction!");
2479  if (!pushValueAndType(I.getOperand(0), InstID, Vals))
2480  AbbrevToUse = FUNCTION_INST_BINOP_ABBREV;
2481  pushValue(I.getOperand(1), InstID, Vals);
2483  uint64_t Flags = getOptimizationFlags(&I);
2484  if (Flags != 0) {
2485  if (AbbrevToUse == FUNCTION_INST_BINOP_ABBREV)
2486  AbbrevToUse = FUNCTION_INST_BINOP_FLAGS_ABBREV;
2487  Vals.push_back(Flags);
2488  }
2489  }
2490  break;
2491 
2492  case Instruction::GetElementPtr: {
2493  Code = bitc::FUNC_CODE_INST_GEP;
2494  AbbrevToUse = FUNCTION_INST_GEP_ABBREV;
2495  auto &GEPInst = cast<GetElementPtrInst>(I);
2496  Vals.push_back(GEPInst.isInBounds());
2497  Vals.push_back(VE.getTypeID(GEPInst.getSourceElementType()));
2498  for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
2499  pushValueAndType(I.getOperand(i), InstID, Vals);
2500  break;
2501  }
2502  case Instruction::ExtractValue: {
2504  pushValueAndType(I.getOperand(0), InstID, Vals);
2505  const ExtractValueInst *EVI = cast<ExtractValueInst>(&I);
2506  Vals.append(EVI->idx_begin(), EVI->idx_end());
2507  break;
2508  }
2509  case Instruction::InsertValue: {
2511  pushValueAndType(I.getOperand(0), InstID, Vals);
2512  pushValueAndType(I.getOperand(1), InstID, Vals);
2513  const InsertValueInst *IVI = cast<InsertValueInst>(&I);
2514  Vals.append(IVI->idx_begin(), IVI->idx_end());
2515  break;
2516  }
2517  case Instruction::Select:
2519  pushValueAndType(I.getOperand(1), InstID, Vals);
2520  pushValue(I.getOperand(2), InstID, Vals);
2521  pushValueAndType(I.getOperand(0), InstID, Vals);
2522  break;
2523  case Instruction::ExtractElement:
2525  pushValueAndType(I.getOperand(0), InstID, Vals);
2526  pushValueAndType(I.getOperand(1), InstID, Vals);
2527  break;
2528  case Instruction::InsertElement:
2530  pushValueAndType(I.getOperand(0), InstID, Vals);
2531  pushValue(I.getOperand(1), InstID, Vals);
2532  pushValueAndType(I.getOperand(2), InstID, Vals);
2533  break;
2534  case Instruction::ShuffleVector:
2536  pushValueAndType(I.getOperand(0), InstID, Vals);
2537  pushValue(I.getOperand(1), InstID, Vals);
2538  pushValue(I.getOperand(2), InstID, Vals);
2539  break;
2540  case Instruction::ICmp:
2541  case Instruction::FCmp: {
2542  // compare returning Int1Ty or vector of Int1Ty
2544  pushValueAndType(I.getOperand(0), InstID, Vals);
2545  pushValue(I.getOperand(1), InstID, Vals);
2546  Vals.push_back(cast<CmpInst>(I).getPredicate());
2547  uint64_t Flags = getOptimizationFlags(&I);
2548  if (Flags != 0)
2549  Vals.push_back(Flags);
2550  break;
2551  }
2552 
2553  case Instruction::Ret:
2554  {
2555  Code = bitc::FUNC_CODE_INST_RET;
2556  unsigned NumOperands = I.getNumOperands();
2557  if (NumOperands == 0)
2558  AbbrevToUse = FUNCTION_INST_RET_VOID_ABBREV;
2559  else if (NumOperands == 1) {
2560  if (!pushValueAndType(I.getOperand(0), InstID, Vals))
2561  AbbrevToUse = FUNCTION_INST_RET_VAL_ABBREV;
2562  } else {
2563  for (unsigned i = 0, e = NumOperands; i != e; ++i)
2564  pushValueAndType(I.getOperand(i), InstID, Vals);
2565  }
2566  }
2567  break;
2568  case Instruction::Br:
2569  {
2570  Code = bitc::FUNC_CODE_INST_BR;
2571  const BranchInst &II = cast<BranchInst>(I);
2572  Vals.push_back(VE.getValueID(II.getSuccessor(0)));
2573  if (II.isConditional()) {
2574  Vals.push_back(VE.getValueID(II.getSuccessor(1)));
2575  pushValue(II.getCondition(), InstID, Vals);
2576  }
2577  }
2578  break;
2579  case Instruction::Switch:
2580  {
2582  const SwitchInst &SI = cast<SwitchInst>(I);
2583  Vals.push_back(VE.getTypeID(SI.getCondition()->getType()));
2584  pushValue(SI.getCondition(), InstID, Vals);
2585  Vals.push_back(VE.getValueID(SI.getDefaultDest()));
2586  for (auto Case : SI.cases()) {
2587  Vals.push_back(VE.getValueID(Case.getCaseValue()));
2588  Vals.push_back(VE.getValueID(Case.getCaseSuccessor()));
2589  }
2590  }
2591  break;
2592  case Instruction::IndirectBr:
2594  Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
2595  // Encode the address operand as relative, but not the basic blocks.
2596  pushValue(I.getOperand(0), InstID, Vals);
2597  for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i)
2598  Vals.push_back(VE.getValueID(I.getOperand(i)));
2599  break;
2600 
2601  case Instruction::Invoke: {
2602  const InvokeInst *II = cast<InvokeInst>(&I);
2603  const Value *Callee = II->getCalledValue();
2604  FunctionType *FTy = II->getFunctionType();
2605 
2606  if (II->hasOperandBundles())
2607  writeOperandBundles(II, InstID);
2608 
2610 
2611  Vals.push_back(VE.getAttributeListID(II->getAttributes()));
2612  Vals.push_back(II->getCallingConv() | 1 << 13);
2613  Vals.push_back(VE.getValueID(II->getNormalDest()));
2614  Vals.push_back(VE.getValueID(II->getUnwindDest()));
2615  Vals.push_back(VE.getTypeID(FTy));
2616  pushValueAndType(Callee, InstID, Vals);
2617 
2618  // Emit value #'s for the fixed parameters.
2619  for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
2620  pushValue(I.getOperand(i), InstID, Vals); // fixed param.
2621 
2622  // Emit type/value pairs for varargs params.
2623  if (FTy->isVarArg()) {
2624  for (unsigned i = FTy->getNumParams(), e = II->getNumArgOperands();
2625  i != e; ++i)
2626  pushValueAndType(I.getOperand(i), InstID, Vals); // vararg
2627  }
2628  break;
2629  }
2630  case Instruction::Resume:
2632  pushValueAndType(I.getOperand(0), InstID, Vals);
2633  break;
2634  case Instruction::CleanupRet: {
2636  const auto &CRI = cast<CleanupReturnInst>(I);
2637  pushValue(CRI.getCleanupPad(), InstID, Vals);
2638  if (CRI.hasUnwindDest())
2639  Vals.push_back(VE.getValueID(CRI.getUnwindDest()));
2640  break;
2641  }
2642  case Instruction::CatchRet: {
2644  const auto &CRI = cast<CatchReturnInst>(I);
2645  pushValue(CRI.getCatchPad(), InstID, Vals);
2646  Vals.push_back(VE.getValueID(CRI.getSuccessor()));
2647  break;
2648  }
2649  case Instruction::CleanupPad:
2650  case Instruction::CatchPad: {
2651  const auto &FuncletPad = cast<FuncletPadInst>(I);
2652  Code = isa<CatchPadInst>(FuncletPad) ? bitc::FUNC_CODE_INST_CATCHPAD
2654  pushValue(FuncletPad.getParentPad(), InstID, Vals);
2655 
2656  unsigned NumArgOperands = FuncletPad.getNumArgOperands();
2657  Vals.push_back(NumArgOperands);
2658  for (unsigned Op = 0; Op != NumArgOperands; ++Op)
2659  pushValueAndType(FuncletPad.getArgOperand(Op), InstID, Vals);
2660  break;
2661  }
2662  case Instruction::CatchSwitch: {
2664  const auto &CatchSwitch = cast<CatchSwitchInst>(I);
2665 
2666  pushValue(CatchSwitch.getParentPad(), InstID, Vals);
2667 
2668  unsigned NumHandlers = CatchSwitch.getNumHandlers();
2669  Vals.push_back(NumHandlers);
2670  for (const BasicBlock *CatchPadBB : CatchSwitch.handlers())
2671  Vals.push_back(VE.getValueID(CatchPadBB));
2672 
2673  if (CatchSwitch.hasUnwindDest())
2674  Vals.push_back(VE.getValueID(CatchSwitch.getUnwindDest()));
2675  break;
2676  }
2677  case Instruction::Unreachable:
2679  AbbrevToUse = FUNCTION_INST_UNREACHABLE_ABBREV;
2680  break;
2681 
2682  case Instruction::PHI: {
2683  const PHINode &PN = cast<PHINode>(I);
2684  Code = bitc::FUNC_CODE_INST_PHI;
2685  // With the newer instruction encoding, forward references could give
2686  // negative valued IDs. This is most common for PHIs, so we use
2687  // signed VBRs.
2689  Vals64.push_back(VE.getTypeID(PN.getType()));
2690  for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) {
2691  pushValueSigned(PN.getIncomingValue(i), InstID, Vals64);
2692  Vals64.push_back(VE.getValueID(PN.getIncomingBlock(i)));
2693  }
2694  // Emit a Vals64 vector and exit.
2695  Stream.EmitRecord(Code, Vals64, AbbrevToUse);
2696  Vals64.clear();
2697  return;
2698  }
2699 
2700  case Instruction::LandingPad: {
2701  const LandingPadInst &LP = cast<LandingPadInst>(I);
2703  Vals.push_back(VE.getTypeID(LP.getType()));
2704  Vals.push_back(LP.isCleanup());
2705  Vals.push_back(LP.getNumClauses());
2706  for (unsigned I = 0, E = LP.getNumClauses(); I != E; ++I) {
2707  if (LP.isCatch(I))
2709  else
2711  pushValueAndType(LP.getClause(I), InstID, Vals);
2712  }
2713  break;
2714  }
2715 
2716  case Instruction::Alloca: {
2718  const AllocaInst &AI = cast<AllocaInst>(I);
2719  Vals.push_back(VE.getTypeID(AI.getAllocatedType()));
2720  Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
2721  Vals.push_back(VE.getValueID(I.getOperand(0))); // size.
2722  unsigned AlignRecord = Log2_32(AI.getAlignment()) + 1;
2723  assert(Log2_32(Value::MaximumAlignment) + 1 < 1 << 5 &&
2724  "not enough bits for maximum alignment");
2725  assert(AlignRecord < 1 << 5 && "alignment greater than 1 << 64");
2726  AlignRecord |= AI.isUsedWithInAlloca() << 5;
2727  AlignRecord |= 1 << 6;
2728  AlignRecord |= AI.isSwiftError() << 7;
2729  Vals.push_back(AlignRecord);
2730  break;
2731  }
2732 
2733  case Instruction::Load:
2734  if (cast<LoadInst>(I).isAtomic()) {
2736  pushValueAndType(I.getOperand(0), InstID, Vals);
2737  } else {
2739  if (!pushValueAndType(I.getOperand(0), InstID, Vals)) // ptr
2740  AbbrevToUse = FUNCTION_INST_LOAD_ABBREV;
2741  }
2742  Vals.push_back(VE.getTypeID(I.getType()));
2743  Vals.push_back(Log2_32(cast<LoadInst>(I).getAlignment())+1);
2744  Vals.push_back(cast<LoadInst>(I).isVolatile());
2745  if (cast<LoadInst>(I).isAtomic()) {
2746  Vals.push_back(getEncodedOrdering(cast<LoadInst>(I).getOrdering()));
2747  Vals.push_back(getEncodedSyncScopeID(cast<LoadInst>(I).getSyncScopeID()));
2748  }
2749  break;
2750  case Instruction::Store:
2751  if (cast<StoreInst>(I).isAtomic())
2753  else
2755  pushValueAndType(I.getOperand(1), InstID, Vals); // ptrty + ptr
2756  pushValueAndType(I.getOperand(0), InstID, Vals); // valty + val
2757  Vals.push_back(Log2_32(cast<StoreInst>(I).getAlignment())+1);
2758  Vals.push_back(cast<StoreInst>(I).isVolatile());
2759  if (cast<StoreInst>(I).isAtomic()) {
2760  Vals.push_back(getEncodedOrdering(cast<StoreInst>(I).getOrdering()));
2761  Vals.push_back(
2762  getEncodedSyncScopeID(cast<StoreInst>(I).getSyncScopeID()));
2763  }
2764  break;
2765  case Instruction::AtomicCmpXchg:
2767  pushValueAndType(I.getOperand(0), InstID, Vals); // ptrty + ptr
2768  pushValueAndType(I.getOperand(1), InstID, Vals); // cmp.
2769  pushValue(I.getOperand(2), InstID, Vals); // newval.
2770  Vals.push_back(cast<AtomicCmpXchgInst>(I).isVolatile());
2771  Vals.push_back(
2772  getEncodedOrdering(cast<AtomicCmpXchgInst>(I).getSuccessOrdering()));
2773  Vals.push_back(
2774  getEncodedSyncScopeID(cast<AtomicCmpXchgInst>(I).getSyncScopeID()));
2775  Vals.push_back(
2776  getEncodedOrdering(cast<AtomicCmpXchgInst>(I).getFailureOrdering()));
2777  Vals.push_back(cast<AtomicCmpXchgInst>(I).isWeak());
2778  break;
2779  case Instruction::AtomicRMW:
2781  pushValueAndType(I.getOperand(0), InstID, Vals); // ptrty + ptr
2782  pushValue(I.getOperand(1), InstID, Vals); // val.
2783  Vals.push_back(
2784  getEncodedRMWOperation(cast<AtomicRMWInst>(I).getOperation()));
2785  Vals.push_back(cast<AtomicRMWInst>(I).isVolatile());
2786  Vals.push_back(getEncodedOrdering(cast<AtomicRMWInst>(I).getOrdering()));
2787  Vals.push_back(
2788  getEncodedSyncScopeID(cast<AtomicRMWInst>(I).getSyncScopeID()));
2789  break;
2790  case Instruction::Fence:
2792  Vals.push_back(getEncodedOrdering(cast<FenceInst>(I).getOrdering()));
2793  Vals.push_back(getEncodedSyncScopeID(cast<FenceInst>(I).getSyncScopeID()));
2794  break;
2795  case Instruction::Call: {
2796  const CallInst &CI = cast<CallInst>(I);
2797  FunctionType *FTy = CI.getFunctionType();
2798 
2799  if (CI.hasOperandBundles())
2800  writeOperandBundles(&CI, InstID);
2801 
2803 
2805 
2806  unsigned Flags = getOptimizationFlags(&I);
2809  unsigned(CI.isMustTailCall()) << bitc::CALL_MUSTTAIL |
2811  unsigned(CI.isNoTailCall()) << bitc::CALL_NOTAIL |
2812  unsigned(Flags != 0) << bitc::CALL_FMF);
2813  if (Flags != 0)
2814  Vals.push_back(Flags);
2815 
2816  Vals.push_back(VE.getTypeID(FTy));
2817  pushValueAndType(CI.getCalledValue(), InstID, Vals); // Callee
2818 
2819  // Emit value #'s for the fixed parameters.
2820  for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
2821  // Check for labels (can happen with asm labels).
2822  if (FTy->getParamType(i)->isLabelTy())
2823  Vals.push_back(VE.getValueID(CI.getArgOperand(i)));
2824  else
2825  pushValue(CI.getArgOperand(i), InstID, Vals); // fixed param.
2826  }
2827 
2828  // Emit type/value pairs for varargs params.
2829  if (FTy->isVarArg()) {
2830  for (unsigned i = FTy->getNumParams(), e = CI.getNumArgOperands();
2831  i != e; ++i)
2832  pushValueAndType(CI.getArgOperand(i), InstID, Vals); // varargs
2833  }
2834  break;
2835  }
2836  case Instruction::VAArg:
2838  Vals.push_back(VE.getTypeID(I.getOperand(0)->getType())); // valistty
2839  pushValue(I.getOperand(0), InstID, Vals); // valist.
2840  Vals.push_back(VE.getTypeID(I.getType())); // restype.
2841  break;
2842  }
2843 
2844  Stream.EmitRecord(Code, Vals, AbbrevToUse);
2845  Vals.clear();
2846 }
2847 
2848 /// Write a GlobalValue VST to the module. The purpose of this data structure is
2849 /// to allow clients to efficiently find the function body.
2850 void ModuleBitcodeWriter::writeGlobalValueSymbolTable(
2851  DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex) {
2852  // Get the offset of the VST we are writing, and backpatch it into
2853  // the VST forward declaration record.
2854  uint64_t VSTOffset = Stream.GetCurrentBitNo();
2855  // The BitcodeStartBit was the stream offset of the identification block.
2856  VSTOffset -= bitcodeStartBit();
2857  assert((VSTOffset & 31) == 0 && "VST block not 32-bit aligned");
2858  // Note that we add 1 here because the offset is relative to one word
2859  // before the start of the identification block, which was historically
2860  // always the start of the regular bitcode header.
2861  Stream.BackpatchWord(VSTOffsetPlaceholder, VSTOffset / 32 + 1);
2862 
2864 
2865  auto Abbv = std::make_shared<BitCodeAbbrev>();
2867  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
2868  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
2869  unsigned FnEntryAbbrev = Stream.EmitAbbrev(std::move(Abbv));
2870 
2871  for (const Function &F : M) {
2872  uint64_t Record[2];
2873 
2874  if (F.isDeclaration())
2875  continue;
2876 
2877  Record[0] = VE.getValueID(&F);
2878 
2879  // Save the word offset of the function (from the start of the
2880  // actual bitcode written to the stream).
2881  uint64_t BitcodeIndex = FunctionToBitcodeIndex[&F] - bitcodeStartBit();
2882  assert((BitcodeIndex & 31) == 0 && "function block not 32-bit aligned");
2883  // Note that we add 1 here because the offset is relative to one word
2884  // before the start of the identification block, which was historically
2885  // always the start of the regular bitcode header.
2886  Record[1] = BitcodeIndex / 32 + 1;
2887 
2888  Stream.EmitRecord(bitc::VST_CODE_FNENTRY, Record, FnEntryAbbrev);
2889  }
2890 
2891  Stream.ExitBlock();
2892 }
2893 
2894 /// Emit names for arguments, instructions and basic blocks in a function.
2895 void ModuleBitcodeWriter::writeFunctionLevelValueSymbolTable(
2896  const ValueSymbolTable &VST) {
2897  if (VST.empty())
2898  return;
2899 
2901 
2902  // FIXME: Set up the abbrev, we know how many values there are!
2903  // FIXME: We know if the type names can use 7-bit ascii.
2904  SmallVector<uint64_t, 64> NameVals;
2905 
2906  for (const ValueName &Name : VST) {
2907  // Figure out the encoding to use for the name.
2909 
2910  unsigned AbbrevToUse = VST_ENTRY_8_ABBREV;
2911  NameVals.push_back(VE.getValueID(Name.getValue()));
2912 
2913  // VST_CODE_ENTRY: [valueid, namechar x N]
2914  // VST_CODE_BBENTRY: [bbid, namechar x N]
2915  unsigned Code;
2916  if (isa<BasicBlock>(Name.getValue())) {
2917  Code = bitc::VST_CODE_BBENTRY;
2918  if (Bits == SE_Char6)
2919  AbbrevToUse = VST_BBENTRY_6_ABBREV;
2920  } else {
2921  Code = bitc::VST_CODE_ENTRY;
2922  if (Bits == SE_Char6)
2923  AbbrevToUse = VST_ENTRY_6_ABBREV;
2924  else if (Bits == SE_Fixed7)
2925  AbbrevToUse = VST_ENTRY_7_ABBREV;
2926  }
2927 
2928  for (const auto P : Name.getKey())
2929  NameVals.push_back((unsigned char)P);
2930 
2931  // Emit the finished record.
2932  Stream.EmitRecord(Code, NameVals, AbbrevToUse);
2933  NameVals.clear();
2934  }
2935 
2936  Stream.ExitBlock();
2937 }
2938 
2939 void ModuleBitcodeWriter::writeUseList(UseListOrder &&Order) {
2940  assert(Order.Shuffle.size() >= 2 && "Shuffle too small");
2941  unsigned Code;
2942  if (isa<BasicBlock>(Order.V))
2943  Code = bitc::USELIST_CODE_BB;
2944  else
2946 
2947  SmallVector<uint64_t, 64> Record(Order.Shuffle.begin(), Order.Shuffle.end());
2948  Record.push_back(VE.getValueID(Order.V));
2949  Stream.EmitRecord(Code, Record);
2950 }
2951 
2952 void ModuleBitcodeWriter::writeUseListBlock(const Function *F) {
2954  "Expected to be preserving use-list order");
2955 
2956  auto hasMore = [&]() {
2957  return !VE.UseListOrders.empty() && VE.UseListOrders.back().F == F;
2958  };
2959  if (!hasMore())
2960  // Nothing to do.
2961  return;
2962 
2964  while (hasMore()) {
2965  writeUseList(std::move(VE.UseListOrders.back()));
2966  VE.UseListOrders.pop_back();
2967  }
2968  Stream.ExitBlock();
2969 }
2970 
2971 /// Emit a function body to the module stream.
2972 void ModuleBitcodeWriter::writeFunction(
2973  const Function &F,
2974  DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex) {
2975  // Save the bitcode index of the start of this function block for recording
2976  // in the VST.
2977  FunctionToBitcodeIndex[&F] = Stream.GetCurrentBitNo();
2978 
2980  VE.incorporateFunction(F);
2981 
2983 
2984  // Emit the number of basic blocks, so the reader can create them ahead of
2985  // time.
2986  Vals.push_back(VE.getBasicBlocks().size());
2988  Vals.clear();
2989 
2990  // If there are function-local constants, emit them now.
2991  unsigned CstStart, CstEnd;
2992  VE.getFunctionConstantRange(CstStart, CstEnd);
2993  writeConstants(CstStart, CstEnd, false);
2994 
2995  // If there is function-local metadata, emit it now.
2996  writeFunctionMetadata(F);
2997 
2998  // Keep a running idea of what the instruction ID is.
2999  unsigned InstID = CstEnd;
3000 
3001  bool NeedsMetadataAttachment = F.hasMetadata();
3002 
3003  DILocation *LastDL = nullptr;
3004  // Finally, emit all the instructions, in order.
3005  for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
3006  for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();
3007  I != E; ++I) {
3008  writeInstruction(*I, InstID, Vals);
3009 
3010  if (!I->getType()->isVoidTy())
3011  ++InstID;
3012 
3013  // If the instruction has metadata, write a metadata attachment later.
3014  NeedsMetadataAttachment |= I->hasMetadataOtherThanDebugLoc();
3015 
3016  // If the instruction has a debug location, emit it.
3017  DILocation *DL = I->getDebugLoc();
3018  if (!DL)
3019  continue;
3020 
3021  if (DL == LastDL) {
3022  // Just repeat the same debug loc as last time.
3024  continue;
3025  }
3026 
3027  Vals.push_back(DL->getLine());
3028  Vals.push_back(DL->getColumn());
3029  Vals.push_back(VE.getMetadataOrNullID(DL->getScope()));
3030  Vals.push_back(VE.getMetadataOrNullID(DL->getInlinedAt()));
3031  Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC, Vals);
3032  Vals.clear();
3033 
3034  LastDL = DL;
3035  }
3036 
3037  // Emit names for all the instructions etc.
3038  if (auto *Symtab = F.getValueSymbolTable())
3039  writeFunctionLevelValueSymbolTable(*Symtab);
3040 
3041  if (NeedsMetadataAttachment)
3042  writeFunctionMetadataAttachment(F);
3043  if (VE.shouldPreserveUseListOrder())
3044  writeUseListBlock(&F);
3045  VE.purgeFunction();
3046  Stream.ExitBlock();
3047 }
3048 
3049 // Emit blockinfo, which defines the standard abbreviations etc.
3050 void ModuleBitcodeWriter::writeBlockInfo() {
3051  // We only want to emit block info records for blocks that have multiple
3052  // instances: CONSTANTS_BLOCK, FUNCTION_BLOCK and VALUE_SYMTAB_BLOCK.
3053  // Other blocks can define their abbrevs inline.
3054  Stream.EnterBlockInfoBlock();
3055 
3056  { // 8-bit fixed-width VST_CODE_ENTRY/VST_CODE_BBENTRY strings.
3057  auto Abbv = std::make_shared<BitCodeAbbrev>();
3058  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
3059  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3061  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
3063  VST_ENTRY_8_ABBREV)
3064  llvm_unreachable("Unexpected abbrev ordering!");
3065  }
3066 
3067  { // 7-bit fixed width VST_CODE_ENTRY strings.
3068  auto Abbv = std::make_shared<BitCodeAbbrev>();
3070  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3072  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
3074  VST_ENTRY_7_ABBREV)
3075  llvm_unreachable("Unexpected abbrev ordering!");
3076  }
3077  { // 6-bit char6 VST_CODE_ENTRY strings.
3078  auto Abbv = std::make_shared<BitCodeAbbrev>();
3080  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3084  VST_ENTRY_6_ABBREV)
3085  llvm_unreachable("Unexpected abbrev ordering!");
3086  }
3087  { // 6-bit char6 VST_CODE_BBENTRY strings.
3088  auto Abbv = std::make_shared<BitCodeAbbrev>();
3090  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3094  VST_BBENTRY_6_ABBREV)
3095  llvm_unreachable("Unexpected abbrev ordering!");
3096  }
3097 
3098  { // SETTYPE abbrev for CONSTANTS_BLOCK.
3099  auto Abbv = std::make_shared<BitCodeAbbrev>();
3103  if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, Abbv) !=
3104  CONSTANTS_SETTYPE_ABBREV)
3105  llvm_unreachable("Unexpected abbrev ordering!");
3106  }
3107 
3108  { // INTEGER abbrev for CONSTANTS_BLOCK.
3109  auto Abbv = std::make_shared<BitCodeAbbrev>();
3111  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3112  if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, Abbv) !=
3113  CONSTANTS_INTEGER_ABBREV)
3114  llvm_unreachable("Unexpected abbrev ordering!");
3115  }
3116 
3117  { // CE_CAST abbrev for CONSTANTS_BLOCK.
3118  auto Abbv = std::make_shared<BitCodeAbbrev>();
3120  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // cast opc
3121  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, // typeid
3123  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
3124 
3125  if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, Abbv) !=
3126  CONSTANTS_CE_CAST_Abbrev)
3127  llvm_unreachable("Unexpected abbrev ordering!");
3128  }
3129  { // NULL abbrev for CONSTANTS_BLOCK.
3130  auto Abbv = std::make_shared<BitCodeAbbrev>();
3132  if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, Abbv) !=
3133  CONSTANTS_NULL_Abbrev)
3134  llvm_unreachable("Unexpected abbrev ordering!");
3135  }
3136 
3137  // FIXME: This should only use space for first class types!
3138 
3139  { // INST_LOAD abbrev for FUNCTION_BLOCK.
3140  auto Abbv = std::make_shared<BitCodeAbbrev>();
3142  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Ptr
3143  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, // dest ty
3145  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // Align
3146  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // volatile
3147  if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3148  FUNCTION_INST_LOAD_ABBREV)
3149  llvm_unreachable("Unexpected abbrev ordering!");
3150  }
3151  { // INST_BINOP abbrev for FUNCTION_BLOCK.
3152  auto Abbv = std::make_shared<BitCodeAbbrev>();
3154  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LHS
3155  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // RHS
3156  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc
3157  if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3158  FUNCTION_INST_BINOP_ABBREV)
3159  llvm_unreachable("Unexpected abbrev ordering!");
3160  }
3161  { // INST_BINOP_FLAGS abbrev for FUNCTION_BLOCK.
3162  auto Abbv = std::make_shared<BitCodeAbbrev>();
3164  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LHS
3165  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // RHS
3166  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc
3167  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7)); // flags
3168  if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3169  FUNCTION_INST_BINOP_FLAGS_ABBREV)
3170  llvm_unreachable("Unexpected abbrev ordering!");
3171  }
3172  { // INST_CAST abbrev for FUNCTION_BLOCK.
3173  auto Abbv = std::make_shared<BitCodeAbbrev>();
3175  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // OpVal
3176  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, // dest ty
3178  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc
3179  if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3180  FUNCTION_INST_CAST_ABBREV)
3181  llvm_unreachable("Unexpected abbrev ordering!");
3182  }
3183 
3184  { // INST_RET abbrev for FUNCTION_BLOCK.
3185  auto Abbv = std::make_shared<BitCodeAbbrev>();
3187  if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3188  FUNCTION_INST_RET_VOID_ABBREV)
3189  llvm_unreachable("Unexpected abbrev ordering!");
3190  }
3191  { // INST_RET abbrev for FUNCTION_BLOCK.
3192  auto Abbv = std::make_shared<BitCodeAbbrev>();
3194  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ValID
3195  if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3196  FUNCTION_INST_RET_VAL_ABBREV)
3197  llvm_unreachable("Unexpected abbrev ordering!");
3198  }
3199  { // INST_UNREACHABLE abbrev for FUNCTION_BLOCK.
3200  auto Abbv = std::make_shared<BitCodeAbbrev>();
3202  if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3203  FUNCTION_INST_UNREACHABLE_ABBREV)
3204  llvm_unreachable("Unexpected abbrev ordering!");
3205  }
3206  {
3207  auto Abbv = std::make_shared<BitCodeAbbrev>();
3209  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
3210  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, // dest ty
3211  Log2_32_Ceil(VE.getTypes().size() + 1)));
3213  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
3214  if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
3215  FUNCTION_INST_GEP_ABBREV)
3216  llvm_unreachable("Unexpected abbrev ordering!");
3217  }
3218 
3219  Stream.ExitBlock();
3220 }
3221 
3222 /// Write the module path strings, currently only used when generating
3223 /// a combined index file.
3224 void IndexBitcodeWriter::writeModStrings() {
3226 
3227  // TODO: See which abbrev sizes we actually need to emit
3228 
3229  // 8-bit fixed-width MST_ENTRY strings.
3230  auto Abbv = std::make_shared<BitCodeAbbrev>();
3232  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3234  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
3235  unsigned Abbrev8Bit = Stream.EmitAbbrev(std::move(Abbv));
3236 
3237  // 7-bit fixed width MST_ENTRY strings.
3238  Abbv = std::make_shared<BitCodeAbbrev>();
3240  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3242  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
3243  unsigned Abbrev7Bit = Stream.EmitAbbrev(std::move(Abbv));
3244 
3245  // 6-bit char6 MST_ENTRY strings.
3246  Abbv = std::make_shared<BitCodeAbbrev>();
3248  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3251  unsigned Abbrev6Bit = Stream.EmitAbbrev(std::move(Abbv));
3252 
3253  // Module Hash, 160 bits SHA1. Optionally, emitted after each MST_CODE_ENTRY.
3254  Abbv = std::make_shared<BitCodeAbbrev>();
3256  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3257  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3258  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3259  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3260  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3261  unsigned AbbrevHash = Stream.EmitAbbrev(std::move(Abbv));
3262 
3264  forEachModule(
3265  [&](const StringMapEntry<std::pair<uint64_t, ModuleHash>> &MPSE) {
3266  StringRef Key = MPSE.getKey();
3267  const auto &Value = MPSE.getValue();
3269  unsigned AbbrevToUse = Abbrev8Bit;
3270  if (Bits == SE_Char6)
3271  AbbrevToUse = Abbrev6Bit;
3272  else if (Bits == SE_Fixed7)
3273  AbbrevToUse = Abbrev7Bit;
3274 
3275  Vals.push_back(Value.first);
3276  Vals.append(Key.begin(), Key.end());
3277 
3278  // Emit the finished record.
3279  Stream.EmitRecord(bitc::MST_CODE_ENTRY, Vals, AbbrevToUse);
3280 
3281  // Emit an optional hash for the module now
3282  const auto &Hash = Value.second;
3283  if (llvm::any_of(Hash, [](uint32_t H) { return H; })) {
3284  Vals.assign(Hash.begin(), Hash.end());
3285  // Emit the hash record.
3286  Stream.EmitRecord(bitc::MST_CODE_HASH, Vals, AbbrevHash);
3287  }
3288 
3289  Vals.clear();
3290  });
3291  Stream.ExitBlock();
3292 }
3293 
3294 /// Write the function type metadata related records that need to appear before
3295 /// a function summary entry (whether per-module or combined).
3297  FunctionSummary *FS) {
3298  if (!FS->type_tests().empty())
3299  Stream.EmitRecord(bitc::FS_TYPE_TESTS, FS->type_tests());
3300 
3302 
3303  auto WriteVFuncIdVec = [&](uint64_t Ty,
3305  if (VFs.empty())
3306  return;
3307  Record.clear();
3308  for (auto &VF : VFs) {
3309  Record.push_back(VF.GUID);
3310  Record.push_back(VF.Offset);
3311  }
3312  Stream.EmitRecord(Ty, Record);
3313  };
3314 
3315  WriteVFuncIdVec(bitc::FS_TYPE_TEST_ASSUME_VCALLS,
3316  FS->type_test_assume_vcalls());
3317  WriteVFuncIdVec(bitc::FS_TYPE_CHECKED_LOAD_VCALLS,
3318  FS->type_checked_load_vcalls());
3319 
3320  auto WriteConstVCallVec = [&](uint64_t Ty,
3322  for (auto &VC : VCs) {
3323  Record.clear();
3324  Record.push_back(VC.VFunc.GUID);
3325  Record.push_back(VC.VFunc.Offset);
3326  Record.insert(Record.end(), VC.Args.begin(), VC.Args.end());
3327  Stream.EmitRecord(Ty, Record);
3328  }
3329  };
3330 
3331  WriteConstVCallVec(bitc::FS_TYPE_TEST_ASSUME_CONST_VCALL,
3333  WriteConstVCallVec(bitc::FS_TYPE_CHECKED_LOAD_CONST_VCALL,
3335 }
3336 
3337 // Helper to emit a single function summary record.
3338 void ModuleBitcodeWriterBase::writePerModuleFunctionSummaryRecord(
3339  SmallVector<uint64_t, 64> &NameVals, GlobalValueSummary *Summary,
3340  unsigned ValueID, unsigned FSCallsAbbrev, unsigned FSCallsProfileAbbrev,
3341  const Function &F) {
3342  NameVals.push_back(ValueID);
3343 
3344  FunctionSummary *FS = cast<FunctionSummary>(Summary);
3346 
3347  NameVals.push_back(getEncodedGVSummaryFlags(FS->flags()));
3348  NameVals.push_back(FS->instCount());
3349  NameVals.push_back(getEncodedFFlags(FS->fflags()));
3350  NameVals.push_back(FS->refs().size());
3351 
3352  for (auto &RI : FS->refs())
3353  NameVals.push_back(VE.getValueID(RI.getValue()));
3354 
3355  bool HasProfileData = F.getEntryCount().hasValue();
3356  for (auto &ECI : FS->calls()) {
3357  NameVals.push_back(getValueId(ECI.first));
3358  if (HasProfileData)
3359  NameVals.push_back(static_cast<uint8_t>(ECI.second.Hotness));
3360  }
3361 
3362  unsigned FSAbbrev = (HasProfileData ? FSCallsProfileAbbrev : FSCallsAbbrev);
3363  unsigned Code =
3364  (HasProfileData ? bitc::FS_PERMODULE_PROFILE : bitc::FS_PERMODULE);
3365 
3366  // Emit the finished record.
3367  Stream.EmitRecord(Code, NameVals, FSAbbrev);
3368  NameVals.clear();
3369 }
3370 
3371 // Collect the global value references in the given variable's initializer,
3372 // and emit them in a summary record.
3373 void ModuleBitcodeWriterBase::writeModuleLevelReferences(
3374  const GlobalVariable &V, SmallVector<uint64_t, 64> &NameVals,
3375  unsigned FSModRefsAbbrev) {
3376  auto VI = Index->getValueInfo(GlobalValue::getGUID(V.getName()));
3377  if (!VI || VI.getSummaryList().empty()) {
3378  // Only declarations should not have a summary (a declaration might however
3379  // have a summary if the def was in module level asm).
3380  assert(V.isDeclaration());
3381  return;
3382  }
3383  auto *Summary = VI.getSummaryList()[0].get();
3384  NameVals.push_back(VE.getValueID(&V));
3385  GlobalVarSummary *VS = cast<GlobalVarSummary>(Summary);
3386  NameVals.push_back(getEncodedGVSummaryFlags(VS->flags()));
3387 
3388  unsigned SizeBeforeRefs = NameVals.size();
3389  for (auto &RI : VS->refs())
3390  NameVals.push_back(VE.getValueID(RI.getValue()));
3391  // Sort the refs for determinism output, the vector returned by FS->refs() has
3392  // been initialized from a DenseSet.
3393  std::sort(NameVals.begin() + SizeBeforeRefs, NameVals.end());
3394 
3396  FSModRefsAbbrev);
3397  NameVals.clear();
3398 }
3399 
3400 // Current version for the summary.
3401 // This is bumped whenever we introduce changes in the way some record are
3402 // interpreted, like flags for instance.
3403 static const uint64_t INDEX_VERSION = 4;
3404 
3405 /// Emit the per-module summary section alongside the rest of
3406 /// the module's bitcode.
3407 void ModuleBitcodeWriterBase::writePerModuleGlobalValueSummary() {
3408  // By default we compile with ThinLTO if the module has a summary, but the
3409  // client can request full LTO with a module flag.
3410  bool IsThinLTO = true;
3411  if (auto *MD =
3412  mdconst::extract_or_null<ConstantInt>(M.getModuleFlag("ThinLTO")))
3413  IsThinLTO = MD->getZExtValue();
3416  4);
3417 
3418  Stream.EmitRecord(bitc::FS_VERSION, ArrayRef<uint64_t>{INDEX_VERSION});
3419 
3420  if (Index->begin() == Index->end()) {
3421  Stream.ExitBlock();
3422  return;
3423  }
3424 
3425  for (const auto &GVI : valueIds()) {
3427  ArrayRef<uint64_t>{GVI.second, GVI.first});
3428  }
3429 
3430  // Abbrev for FS_PERMODULE.
3431  auto Abbv = std::make_shared<BitCodeAbbrev>();
3432  Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE));
3433  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
3434  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
3435  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount
3436  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // fflags
3437  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs
3438  // numrefs x valueid, n x (valueid)
3440  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3441  unsigned FSCallsAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3442 
3443  // Abbrev for FS_PERMODULE_PROFILE.
3444  Abbv = std::make_shared<BitCodeAbbrev>();
3446  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
3447  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
3448  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount
3449  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // fflags
3450  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs
3451  // numrefs x valueid, n x (valueid, hotness)
3453  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3454  unsigned FSCallsProfileAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3455 
3456  // Abbrev for FS_PERMODULE_GLOBALVAR_INIT_REFS.
3457  Abbv = std::make_shared<BitCodeAbbrev>();
3459  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
3460  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
3461  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); // valueids
3462  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3463  unsigned FSModRefsAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3464 
3465  // Abbrev for FS_ALIAS.
3466  Abbv = std::make_shared<BitCodeAbbrev>();
3467  Abbv->Add(BitCodeAbbrevOp(bitc::FS_ALIAS));
3468  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
3469  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
3470  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
3471  unsigned FSAliasAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3472 
3473  SmallVector<uint64_t, 64> NameVals;
3474  // Iterate over the list of functions instead of the Index to
3475  // ensure the ordering is stable.
3476  for (const Function &F : M) {
3477  // Summary emission does not support anonymous functions, they have to
3478  // renamed using the anonymous function renaming pass.
3479  if (!F.hasName())
3480  report_fatal_error("Unexpected anonymous function when writing summary");
3481 
3482  ValueInfo VI = Index->getValueInfo(GlobalValue::getGUID(F.getName()));
3483  if (!VI || VI.getSummaryList().empty()) {
3484  // Only declarations should not have a summary (a declaration might
3485  // however have a summary if the def was in module level asm).
3486  assert(F.isDeclaration());
3487  continue;
3488  }
3489  auto *Summary = VI.getSummaryList()[0].get();
3490  writePerModuleFunctionSummaryRecord(NameVals, Summary, VE.getValueID(&F),
3491  FSCallsAbbrev, FSCallsProfileAbbrev, F);
3492  }
3493 
3494  // Capture references from GlobalVariable initializers, which are outside
3495  // of a function scope.
3496  for (const GlobalVariable &G : M.globals())
3497  writeModuleLevelReferences(G, NameVals, FSModRefsAbbrev);
3498 
3499  for (const GlobalAlias &A : M.aliases()) {
3500  auto *Aliasee = A.getBaseObject();
3501  if (!Aliasee->hasName())
3502  // Nameless function don't have an entry in the summary, skip it.
3503  continue;
3504  auto AliasId = VE.getValueID(&A);
3505  auto AliaseeId = VE.getValueID(Aliasee);
3506  NameVals.push_back(AliasId);
3507  auto *Summary = Index->getGlobalValueSummary(A);
3508  AliasSummary *AS = cast<AliasSummary>(Summary);
3509  NameVals.push_back(getEncodedGVSummaryFlags(AS->flags()));
3510  NameVals.push_back(AliaseeId);
3511  Stream.EmitRecord(bitc::FS_ALIAS, NameVals, FSAliasAbbrev);
3512  NameVals.clear();
3513  }
3514 
3515  Stream.ExitBlock();
3516 }
3517 
3518 /// Emit the combined summary section into the combined index file.
3519 void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
3521  Stream.EmitRecord(bitc::FS_VERSION, ArrayRef<uint64_t>{INDEX_VERSION});
3522 
3523  for (const auto &GVI : valueIds()) {
3525  ArrayRef<uint64_t>{GVI.second, GVI.first});
3526  }
3527 
3528  // Abbrev for FS_COMBINED.
3529  auto Abbv = std::make_shared<BitCodeAbbrev>();
3530  Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED));
3531  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
3532  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid
3533  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
3534  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount
3535  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // fflags
3536  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs
3537  // numrefs x valueid, n x (valueid)
3539  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3540  unsigned FSCallsAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3541 
3542  // Abbrev for FS_COMBINED_PROFILE.
3543  Abbv = std::make_shared<BitCodeAbbrev>();
3545  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
3546  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid
3547  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
3548  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount
3549  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // fflags
3550  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs
3551  // numrefs x valueid, n x (valueid, hotness)
3553  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3554  unsigned FSCallsProfileAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3555 
3556  // Abbrev for FS_COMBINED_GLOBALVAR_INIT_REFS.
3557  Abbv = std::make_shared<BitCodeAbbrev>();
3559  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
3560  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid
3561  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
3562  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); // valueids
3563  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
3564  unsigned FSModRefsAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3565 
3566  // Abbrev for FS_COMBINED_ALIAS.
3567  Abbv = std::make_shared<BitCodeAbbrev>();
3569  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
3570  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid
3571  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
3572  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
3573  unsigned FSAliasAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3574 
3575  // The aliases are emitted as a post-pass, and will point to the value
3576  // id of the aliasee. Save them in a vector for post-processing.
3578 
3579  // Save the value id for each summary for alias emission.
3581 
3582  SmallVector<uint64_t, 64> NameVals;
3583 
3584  // For local linkage, we also emit the original name separately
3585  // immediately after the record.
3586  auto MaybeEmitOriginalName = [&](GlobalValueSummary &S) {
3587  if (!GlobalValue::isLocalLinkage(S.linkage()))
3588  return;
3589  NameVals.push_back(S.getOriginalName());
3590  Stream.EmitRecord(bitc::FS_COMBINED_ORIGINAL_NAME, NameVals);
3591  NameVals.clear();
3592  };
3593 
3594  forEachSummary([&](GVInfo I) {
3595  GlobalValueSummary *S = I.second;
3596  assert(S);
3597 
3598  auto ValueId = getValueId(I.first);
3599  assert(ValueId);
3600  SummaryToValueIdMap[S] = *ValueId;
3601 
3602  if (auto *AS = dyn_cast<AliasSummary>(S)) {
3603  // Will process aliases as a post-pass because the reader wants all
3604  // global to be loaded first.
3605  Aliases.push_back(AS);
3606  return;
3607  }
3608 
3609  if (auto *VS = dyn_cast<GlobalVarSummary>(S)) {
3610  NameVals.push_back(*ValueId);
3611  NameVals.push_back(Index.getModuleId(VS->modulePath()));
3612  NameVals.push_back(getEncodedGVSummaryFlags(VS->flags()));
3613  for (auto &RI : VS->refs()) {
3614  auto RefValueId = getValueId(RI.getGUID());
3615  if (!RefValueId)
3616  continue;
3617  NameVals.push_back(*RefValueId);
3618  }
3619 
3620  // Emit the finished record.
3622  FSModRefsAbbrev);
3623  NameVals.clear();
3624  MaybeEmitOriginalName(*S);
3625  return;
3626  }
3627 
3628  auto *FS = cast<FunctionSummary>(S);
3630 
3631  NameVals.push_back(*ValueId);
3632  NameVals.push_back(Index.getModuleId(FS->modulePath()));
3633  NameVals.push_back(getEncodedGVSummaryFlags(FS->flags()));
3634  NameVals.push_back(FS->instCount());
3635  NameVals.push_back(getEncodedFFlags(FS->fflags()));
3636  // Fill in below
3637  NameVals.push_back(0);
3638 
3639  unsigned Count = 0;
3640  for (auto &RI : FS->refs()) {
3641  auto RefValueId = getValueId(RI.getGUID());
3642  if (!RefValueId)
3643  continue;
3644  NameVals.push_back(*RefValueId);
3645  Count++;
3646  }
3647  NameVals[5] = Count;
3648 
3649  bool HasProfileData = false;
3650  for (auto &EI : FS->calls()) {
3651  HasProfileData |= EI.second.Hotness != CalleeInfo::HotnessType::Unknown;
3652  if (HasProfileData)
3653  break;
3654  }
3655 
3656  for (auto &EI : FS->calls()) {
3657  // If this GUID doesn't have a value id, it doesn't have a function
3658  // summary and we don't need to record any calls to it.
3659  GlobalValue::GUID GUID = EI.first.getGUID();
3660  auto CallValueId = getValueId(GUID);
3661  if (!CallValueId) {
3662  // For SamplePGO, the indirect call targets for local functions will
3663  // have its original name annotated in profile. We try to find the
3664  // corresponding PGOFuncName as the GUID.
3665  GUID = Index.getGUIDFromOriginalID(GUID);
3666  if (GUID == 0)
3667  continue;
3668  CallValueId = getValueId(GUID);
3669  if (!CallValueId)
3670  continue;
3671  // The mapping from OriginalId to GUID may return a GUID
3672  // that corresponds to a static variable. Filter it out here.
3673  // This can happen when
3674  // 1) There is a call to a library function which does not have
3675  // a CallValidId;
3676  // 2) There is a static variable with the OriginalGUID identical
3677  // to the GUID of the library function in 1);
3678  // When this happens, the logic for SamplePGO kicks in and
3679  // the static variable in 2) will be found, which needs to be
3680  // filtered out.
3681  auto *GVSum = Index.getGlobalValueSummary(GUID, false);
3682  if (GVSum &&
3683  GVSum->getSummaryKind() == GlobalValueSummary::GlobalVarKind)
3684  continue;
3685  }
3686  NameVals.push_back(*CallValueId);
3687  if (HasProfileData)
3688  NameVals.push_back(static_cast<uint8_t>(EI.second.Hotness));
3689  }
3690 
3691  unsigned FSAbbrev = (HasProfileData ? FSCallsProfileAbbrev : FSCallsAbbrev);
3692  unsigned Code =
3693  (HasProfileData ? bitc::FS_COMBINED_PROFILE : bitc::FS_COMBINED);
3694 
3695  // Emit the finished record.
3696  Stream.EmitRecord(Code, NameVals, FSAbbrev);
3697  NameVals.clear();
3698  MaybeEmitOriginalName(*S);
3699  });
3700 
3701  for (auto *AS : Aliases) {
3702  auto AliasValueId = SummaryToValueIdMap[AS];
3703  assert(AliasValueId);
3704  NameVals.push_back(AliasValueId);
3705  NameVals.push_back(Index.getModuleId(AS->modulePath()));
3706  NameVals.push_back(getEncodedGVSummaryFlags(AS->flags()));
3707  auto AliaseeValueId = SummaryToValueIdMap[&AS->getAliasee()];
3708  assert(AliaseeValueId);
3709  NameVals.push_back(AliaseeValueId);
3710 
3711  // Emit the finished record.
3712  Stream.EmitRecord(bitc::FS_COMBINED_ALIAS, NameVals, FSAliasAbbrev);
3713  NameVals.clear();
3714  MaybeEmitOriginalName(*AS);
3715  }
3716 
3717  if (!Index.cfiFunctionDefs().empty()) {
3718  for (auto &S : Index.cfiFunctionDefs()) {
3719  NameVals.push_back(StrtabBuilder.add(S));
3720  NameVals.push_back(S.size());
3721  }
3722  Stream.EmitRecord(bitc::FS_CFI_FUNCTION_DEFS, NameVals);
3723  NameVals.clear();
3724  }
3725 
3726  if (!Index.cfiFunctionDecls().empty()) {
3727  for (auto &S : Index.cfiFunctionDecls()) {
3728  NameVals.push_back(StrtabBuilder.add(S));
3729  NameVals.push_back(S.size());
3730  }
3731  Stream.EmitRecord(bitc::FS_CFI_FUNCTION_DECLS, NameVals);
3732  NameVals.clear();
3733  }
3734 
3735  Stream.ExitBlock();
3736 }
3737 
3738 /// Create the "IDENTIFICATION_BLOCK_ID" containing a single string with the
3739 /// current llvm version, and a record for the epoch number.
3742 
3743  // Write the "user readable" string identifying the bitcode producer
3744  auto Abbv = std::make_shared<BitCodeAbbrev>();
3748  auto StringAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3750  "LLVM" LLVM_VERSION_STRING, StringAbbrev);
3751 
3752  // Write the epoch version
3753  Abbv = std::make_shared<BitCodeAbbrev>();
3755  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
3756  auto EpochAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3758  Stream.EmitRecord(bitc::IDENTIFICATION_CODE_EPOCH, Vals, EpochAbbrev);
3759  Stream.ExitBlock();
3760 }
3761 
3762 void ModuleBitcodeWriter::writeModuleHash(size_t BlockStartPos) {
3763  // Emit the module's hash.
3764  // MODULE_CODE_HASH: [5*i32]
3765  if (GenerateHash) {
3766  uint32_t Vals[5];
3767  Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&(Buffer)[BlockStartPos],
3768  Buffer.size() - BlockStartPos));
3769  StringRef Hash = Hasher.result();
3770  for (int Pos = 0; Pos < 20; Pos += 4) {
3771  Vals[Pos / 4] = support::endian::read32be(Hash.data() + Pos);
3772  }
3773 
3774  // Emit the finished record.
3775  Stream.EmitRecord(bitc::MODULE_CODE_HASH, Vals);
3776 
3777  if (ModHash)
3778  // Save the written hash value.
3779  std::copy(std::begin(Vals), std::end(Vals), std::begin(*ModHash));
3780  }
3781 }
3782 
3784  writeIdentificationBlock(Stream);
3785 
3787  size_t BlockStartPos = Buffer.size();
3788 
3789  writeModuleVersion();
3790 
3791  // Emit blockinfo, which defines the standard abbreviations etc.
3792  writeBlockInfo();
3793 
3794  // Emit information about attribute groups.
3795  writeAttributeGroupTable();
3796 
3797  // Emit information about parameter attributes.
3798  writeAttributeTable();
3799 
3800  // Emit information describing all of the types in the module.
3801  writeTypeTable();
3802 
3803  writeComdats();
3804 
3805  // Emit top-level description of module, including target triple, inline asm,
3806  // descriptors for global variables, and function prototype info.
3807  writeModuleInfo();
3808 
3809  // Emit constants.
3810  writeModuleConstants();
3811 
3812  // Emit metadata kind names.
3813  writeModuleMetadataKinds();
3814 
3815  // Emit metadata.
3816  writeModuleMetadata();
3817 
3818  // Emit module-level use-lists.
3819  if (VE.shouldPreserveUseListOrder())
3820  writeUseListBlock(nullptr);
3821 
3822  writeOperandBundleTags();
3823  writeSyncScopeNames();
3824 
3825  // Emit function bodies.
3826  DenseMap<const Function *, uint64_t> FunctionToBitcodeIndex;
3827  for (Module::const_iterator F = M.begin(), E = M.end(); F != E; ++F)
3828  if (!F->isDeclaration())
3829  writeFunction(*F, FunctionToBitcodeIndex);
3830 
3831  // Need to write after the above call to WriteFunction which populates
3832  // the summary information in the index.
3833  if (Index)
3834  writePerModuleGlobalValueSummary();
3835 
3836  writeGlobalValueSymbolTable(FunctionToBitcodeIndex);
3837 
3838  writeModuleHash(BlockStartPos);
3839 
3840  Stream.ExitBlock();
3841 }
3842 
3844  uint32_t &Position) {
3845  support::endian::write32le(&Buffer[Position], Value);
3846  Position += 4;
3847 }
3848 
3849 /// If generating a bc file on darwin, we have to emit a
3850 /// header and trailer to make it compatible with the system archiver. To do
3851 /// this we emit the following header, and then emit a trailer that pads the
3852 /// file out to be a multiple of 16 bytes.
3853 ///
3854 /// struct bc_header {
3855 /// uint32_t Magic; // 0x0B17C0DE
3856 /// uint32_t Version; // Version, currently always 0.
3857 /// uint32_t BitcodeOffset; // Offset to traditional bitcode file.
3858 /// uint32_t BitcodeSize; // Size of traditional bitcode file.
3859 /// uint32_t CPUType; // CPU specifier.
3860 /// ... potentially more later ...
3861 /// };
3863  const Triple &TT) {
3864  unsigned CPUType = ~0U;
3865 
3866  // Match x86_64-*, i[3-9]86-*, powerpc-*, powerpc64-*, arm-*, thumb-*,
3867  // armv[0-9]-*, thumbv[0-9]-*, armv5te-*, or armv6t2-*. The CPUType is a magic
3868  // number from /usr/include/mach/machine.h. It is ok to reproduce the
3869  // specific constants here because they are implicitly part of the Darwin ABI.
3870  enum {
3871  DARWIN_CPU_ARCH_ABI64 = 0x01000000,
3872  DARWIN_CPU_TYPE_X86 = 7,
3873  DARWIN_CPU_TYPE_ARM = 12,
3874  DARWIN_CPU_TYPE_POWERPC = 18
3875  };
3876 
3877  Triple::ArchType Arch = TT.getArch();
3878  if (Arch == Triple::x86_64)
3879  CPUType = DARWIN_CPU_TYPE_X86 | DARWIN_CPU_ARCH_ABI64;
3880  else if (Arch == Triple::x86)
3881  CPUType = DARWIN_CPU_TYPE_X86;
3882  else if (Arch == Triple::ppc)
3883  CPUType = DARWIN_CPU_TYPE_POWERPC;
3884  else if (Arch == Triple::ppc64)
3885  CPUType = DARWIN_CPU_TYPE_POWERPC | DARWIN_CPU_ARCH_ABI64;
3886  else if (Arch == Triple::arm || Arch == Triple::thumb)
3887  CPUType = DARWIN_CPU_TYPE_ARM;
3888 
3889  // Traditional Bitcode starts after header.
3890  assert(Buffer.size() >= BWH_HeaderSize &&
3891  "Expected header size to be reserved");
3892  unsigned BCOffset = BWH_HeaderSize;
3893  unsigned BCSize = Buffer.size() - BWH_HeaderSize;
3894 
3895  // Write the magic and version.
3896  unsigned Position = 0;
3897  writeInt32ToBuffer(0x0B17C0DE, Buffer, Position);
3898  writeInt32ToBuffer(0, Buffer, Position); // Version.
3899  writeInt32ToBuffer(BCOffset, Buffer, Position);
3900  writeInt32ToBuffer(BCSize, Buffer, Position);
3901  writeInt32ToBuffer(CPUType, Buffer, Position);
3902 
3903  // If the file is not a multiple of 16 bytes, insert dummy padding.
3904  while (Buffer.size() & 15)
3905  Buffer.push_back(0);
3906 }
3907 
3908 /// Helper to write the header common to all bitcode files.
3909 static void writeBitcodeHeader(BitstreamWriter &Stream) {
3910  // Emit the file header.
3911  Stream.Emit((unsigned)'B', 8);
3912  Stream.Emit((unsigned)'C', 8);
3913  Stream.Emit(0x0, 4);
3914  Stream.Emit(0xC, 4);
3915  Stream.Emit(0xE, 4);
3916  Stream.Emit(0xD, 4);
3917 }
3918 
3920  : Buffer(Buffer), Stream(new BitstreamWriter(Buffer)) {
3921  writeBitcodeHeader(*Stream);
3922 }
3923 
3925 
3926 void BitcodeWriter::writeBlob(unsigned Block, unsigned Record, StringRef Blob) {
3927  Stream->EnterSubblock(Block, 3);
3928 
3929  auto Abbv = std::make_shared<BitCodeAbbrev>();
3930  Abbv->Add(BitCodeAbbrevOp(Record));
3932  auto AbbrevNo = Stream->EmitAbbrev(std::move(Abbv));
3933 
3934  Stream->EmitRecordWithBlob(AbbrevNo, ArrayRef<uint64_t>{Record}, Blob);
3935 
3936  Stream->ExitBlock();
3937 }
3938 
3940  assert(!WroteStrtab && !WroteSymtab);
3941 
3942  // If any module has module-level inline asm, we will require a registered asm
3943  // parser for the target so that we can create an accurate symbol table for
3944  // the module.
3945  for (Module *M : Mods) {
3946  if (M->getModuleInlineAsm().empty())
3947  continue;
3948 
3949  std::string Err;
3950  const Triple TT(M->getTargetTriple());
3951  const Target *T = TargetRegistry::lookupTarget(TT.str(), Err);
3952  if (!T || !T->hasMCAsmParser())
3953  return;
3954  }
3955 
3956  WroteSymtab = true;
3957  SmallVector<char, 0> Symtab;
3958  // The irsymtab::build function may be unable to create a symbol table if the
3959  // module is malformed (e.g. it contains an invalid alias). Writing a symbol
3960  // table is not required for correctness, but we still want to be able to
3961  // write malformed modules to bitcode files, so swallow the error.
3962  if (Error E = irsymtab::build(Mods, Symtab, StrtabBuilder, Alloc)) {
3963  consumeError(std::move(E));
3964  return;
3965  }
3966 
3968  {Symtab.data(), Symtab.size()});
3969 }
3970 
3972  assert(!WroteStrtab);
3973 
3974  std::vector<char> Strtab;
3975  StrtabBuilder.finalizeInOrder();
3976  Strtab.resize(StrtabBuilder.getSize());
3977  StrtabBuilder.write((uint8_t *)Strtab.data());
3978 
3980  {Strtab.data(), Strtab.size()});
3981 
3982  WroteStrtab = true;
3983 }
3984 
3986  writeBlob(bitc::STRTAB_BLOCK_ID, bitc::STRTAB_BLOB, Strtab);
3987  WroteStrtab = true;
3988 }
3989 
3991  bool ShouldPreserveUseListOrder,
3992  const ModuleSummaryIndex *Index,
3993  bool GenerateHash, ModuleHash *ModHash) {
3994  assert(!WroteStrtab);
3995 
3996  // The Mods vector is used by irsymtab::build, which requires non-const
3997  // Modules in case it needs to materialize metadata. But the bitcode writer
3998  // requires that the module is materialized, so we can cast to non-const here,
3999  // after checking that it is in fact materialized.
4000  assert(M->isMaterialized());
4001  Mods.push_back(const_cast<Module *>(M));
4002 
4003  ModuleBitcodeWriter ModuleWriter(M, Buffer, StrtabBuilder, *Stream,
4004  ShouldPreserveUseListOrder, Index,
4005  GenerateHash, ModHash);
4006  ModuleWriter.write();
4007 }
4008 
4010  const ModuleSummaryIndex *Index,
4011  const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex) {
4012  IndexBitcodeWriter IndexWriter(*Stream, StrtabBuilder, *Index,
4013  ModuleToSummariesForIndex);
4014  IndexWriter.write();
4015 }
4016 
4017 /// WriteBitcodeToFile - Write the specified module to the specified output
4018 /// stream.
4020  bool ShouldPreserveUseListOrder,
4021  const ModuleSummaryIndex *Index,
4022  bool GenerateHash, ModuleHash *ModHash) {
4023  SmallVector<char, 0> Buffer;
4024  Buffer.reserve(256*1024);
4025 
4026  // If this is darwin or another generic macho target, reserve space for the
4027  // header.
4028  Triple TT(M->getTargetTriple());
4029  if (TT.isOSDarwin() || TT.isOSBinFormatMachO())
4030  Buffer.insert(Buffer.begin(), BWH_HeaderSize, 0);
4031 
4032  BitcodeWriter Writer(Buffer);
4033  Writer.writeModule(M, ShouldPreserveUseListOrder, Index, GenerateHash,
4034  ModHash);
4035  Writer.writeSymtab();
4036  Writer.writeStrtab();
4037 
4038  if (TT.isOSDarwin() || TT.isOSBinFormatMachO())
4039  emitDarwinBCHeaderAndTrailer(Buffer, TT);
4040 
4041  // Write the generated bitstream to "Out".
4042  Out.write((char*)&Buffer.front(), Buffer.size());
4043 }
4044 
4047 
4048  writeModuleVersion();
4049 
4050  // Write the module paths in the combined index.
4051  writeModStrings();
4052 
4053  // Write the summary combined index records.
4054  writeCombinedGlobalValueSummary();
4055 
4056  Stream.ExitBlock();
4057 }
4058 
4059 // Write the specified module summary index to the given raw output stream,
4060 // where it will be written in a new bitcode block. This is used when
4061 // writing the combined index file for ThinLTO. When writing a subset of the
4062 // index for a distributed backend, provide a \p ModuleToSummariesForIndex map.
4064  const ModuleSummaryIndex &Index, raw_ostream &Out,
4065  const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex) {
4066  SmallVector<char, 0> Buffer;
4067  Buffer.reserve(256 * 1024);
4068 
4069  BitcodeWriter Writer(Buffer);
4070  Writer.writeIndex(&Index, ModuleToSummariesForIndex);
4071  Writer.writeStrtab();
4072 
4073  Out.write((char *)&Buffer.front(), Buffer.size());
4074 }
4075 
4076 namespace {
4077 
4078 /// Class to manage the bitcode writing for a thin link bitcode file.
4079 class ThinLinkBitcodeWriter : public ModuleBitcodeWriterBase {
4080  /// ModHash is for use in ThinLTO incremental build, generated while writing
4081  /// the module bitcode file.
4082  const ModuleHash *ModHash;
4083 
4084 public:
4085  ThinLinkBitcodeWriter(const Module *M, StringTableBuilder &StrtabBuilder,
4086  BitstreamWriter &Stream,
4087  const ModuleSummaryIndex &Index,
4088  const ModuleHash &ModHash)
4089  : ModuleBitcodeWriterBase(M, StrtabBuilder, Stream,
4090  /*ShouldPreserveUseListOrder=*/false, &Index),
4091  ModHash(&ModHash) {}
4092 
4093  void write();
4094 
4095 private:
4096  void writeSimplifiedModuleInfo();
4097 };
4098 
4099 } // end anonymous namespace
4100 
4101 // This function writes a simpilified module info for thin link bitcode file.
4102 // It only contains the source file name along with the name(the offset and
4103 // size in strtab) and linkage for global values. For the global value info
4104 // entry, in order to keep linkage at offset 5, there are three zeros used
4105 // as padding.
4106 void ThinLinkBitcodeWriter::writeSimplifiedModuleInfo() {
4108  // Emit the module's source file name.
4109  {
4112  if (Bits == SE_Char6)
4113  AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Char6);
4114  else if (Bits == SE_Fixed7)
4115  AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7);
4116 
4117  // MODULE_CODE_SOURCE_FILENAME: [namechar x N]
4118  auto Abbv = std::make_shared<BitCodeAbbrev>();
4121  Abbv->Add(AbbrevOpToUse);
4122  unsigned FilenameAbbrev = Stream.EmitAbbrev(std::move(Abbv));
4123 
4124  for (const auto P : M.getSourceFileName())
4125  Vals.push_back((unsigned char)P);
4126 
4127  Stream.EmitRecord(bitc::MODULE_CODE_SOURCE_FILENAME, Vals, FilenameAbbrev);
4128  Vals.clear();
4129  }
4130 
4131  // Emit the global variable information.
4132  for (const GlobalVariable &GV : M.globals()) {
4133  // GLOBALVAR: [strtab offset, strtab size, 0, 0, 0, linkage]
4134  Vals.push_back(StrtabBuilder.add(GV.getName()));
4135  Vals.push_back(GV.getName().size());
4136  Vals.push_back(0);
4137  Vals.push_back(0);
4138  Vals.push_back(0);
4139  Vals.push_back(getEncodedLinkage(GV));
4140 
4142  Vals.clear();
4143  }
4144 
4145  // Emit the function proto information.
4146  for (const Function &F : M) {
4147  // FUNCTION: [strtab offset, strtab size, 0, 0, 0, linkage]
4148  Vals.push_back(StrtabBuilder.add(F.getName()));
4149  Vals.push_back(F.getName().size());
4150  Vals.push_back(0);
4151  Vals.push_back(0);
4152  Vals.push_back(0);
4153  Vals.push_back(getEncodedLinkage(F));
4154 
4155  Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals);
4156  Vals.clear();
4157  }
4158 
4159  // Emit the alias information.
4160  for (const GlobalAlias &A : M.aliases()) {
4161  // ALIAS: [strtab offset, strtab size, 0, 0, 0, linkage]
4162  Vals.push_back(StrtabBuilder.add(A.getName()));
4163  Vals.push_back(A.getName().size());
4164  Vals.push_back(0);
4165  Vals.push_back(0);
4166  Vals.push_back(0);
4167  Vals.push_back(getEncodedLinkage(A));
4168 
4169  Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals);
4170  Vals.clear();
4171  }
4172 
4173  // Emit the ifunc information.
4174  for (const GlobalIFunc &I : M.ifuncs()) {
4175  // IFUNC: [strtab offset, strtab size, 0, 0, 0, linkage]
4176  Vals.push_back(StrtabBuilder.add(I.getName()));
4177  Vals.push_back(I.getName().size());
4178  Vals.push_back(0);
4179  Vals.push_back(0);
4180  Vals.push_back(0);
4181  Vals.push_back(getEncodedLinkage(I));
4182 
4183  Stream.EmitRecord(bitc::MODULE_CODE_IFUNC, Vals);
4184  Vals.clear();
4185  }
4186 }
4187 
4190 
4191  writeModuleVersion();
4192 
4193  writeSimplifiedModuleInfo();
4194 
4195  writePerModuleGlobalValueSummary();
4196 
4197  // Write module hash.
4199 
4200  Stream.ExitBlock();
4201 }
4202 
4204  const ModuleSummaryIndex &Index,
4205  const ModuleHash &ModHash) {
4206  assert(!WroteStrtab);
4207 
4208  // The Mods vector is used by irsymtab::build, which requires non-const
4209  // Modules in case it needs to materialize metadata. But the bitcode writer
4210  // requires that the module is materialized, so we can cast to non-const here,
4211  // after checking that it is in fact materialized.
4212  assert(M->isMaterialized());
4213  Mods.push_back(const_cast<Module *>(M));
4214 
4215  ThinLinkBitcodeWriter ThinLinkWriter(M, StrtabBuilder, *Stream, Index,
4216  ModHash);
4217  ThinLinkWriter.write();
4218 }
4219 
4220 // Write the specified thin link bitcode file to the given raw output stream,
4221 // where it will be written in a new bitcode block. This is used when
4222 // writing the per-module index file for ThinLTO.
4224  const ModuleSummaryIndex &Index,
4225  const ModuleHash &ModHash) {
4226  SmallVector<char, 0> Buffer;
4227  Buffer.reserve(256 * 1024);
4228 
4229  BitcodeWriter Writer(Buffer);
4230  Writer.writeThinLinkBitcode(M, Index, ModHash);
4231  Writer.writeSymtab();
4232  Writer.writeStrtab();
4233 
4234  Out.write((char *)&Buffer.front(), Buffer.size());
4235 }
DIFlags getFlags() const
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type.
bool hasOperandBundles() const
Return true if this User has any operand bundles.
Definition: InstrTypes.h:1305
uint64_t CallInst * C
MDString * getRawName() const
7: Labels
Definition: Type.h:64
unsigned Log2_32_Ceil(uint32_t Value)
Return the ceil log base 2 of the specified value, 32 if the value is zero.
Definition: MathExtras.h:544
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:243
void writeIndex(const ModuleSummaryIndex *Index, const std::map< std::string, GVSummaryMapTy > *ModuleToSummariesForIndex)
const std::string & getTargetTriple() const
Get the target triple which is a string describing the target host.
Definition: Module.h:233
ThreadLocalMode getThreadLocalMode() const
Definition: GlobalValue.h:241
ArrayRef< uint64_t > getElements() const
This class provides a symbol table of name/value pairs.
uint64_t getOffsetInBits() const
unsigned Live
In per-module summary, indicate that the global value must be considered a live root for index-based ...
static cl::opt< unsigned > IndexThreshold("bitcode-mdindex-threshold", cl::Hidden, cl::init(25), cl::desc("Number of metadatas above which we emit an index " "to enable lazy-loading"))
bool isDistinct() const
Definition: Metadata.h:941
This instruction extracts a struct member or array element value from an aggregate value...
Special purpose, only applies to global arrays.
Definition: GlobalValue.h:55
unsigned getLine() const
*p = old <signed v ? old : v
Definition: Instructions.h:707
iterator_range< CaseIt > cases()
Iteration adapter for range-for loops.
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:234
static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N, TypePrinting *, SlotTracker *, const Module *)
Definition: AsmWriter.cpp:1635
static uint64_t getOptimizationFlags(const Value *V)
unsigned getMetadataOrNullID(const Metadata *MD) const
Atomic ordering constants.
unsigned getValueID(const Value *V) const
const ValueList & getValues() const
struct fuzzer::@309 Flags
uint64_t GUID
Declare a type to represent a global unique identifier for a global value.
Definition: GlobalValue.h:472
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:103
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
static uint64_t getEncodedFFlags(FunctionSummary::FFlags Flags)
Type * getParamType(unsigned i) const
Parameter type accessors.
Definition: DerivedTypes.h:135
const unsigned char * bytes_end() const
Definition: StringRef.h:113
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
Definition: StringMap.h:126
unsigned getRuntimeVersion() const
unsigned Linkage
The linkage type of the associated global value.
bool hasMetadataOtherThanDebugLoc() const
Return true if this instruction has metadata attached to it other than a debug location.
Definition: Instruction.h:188
MDString * getRawName() const
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:136
2: 32-bit floating point type
Definition: Type.h:59
MDString * getRawName() const
iterator end()
Definition: Function.h:590
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:54
const GlobalValue * getValue() const
ArrayRef< VFuncId > type_test_assume_vcalls() const
Returns the list of virtual calls made by this function using llvm.assume(llvm.type.test) intrinsics that do not have all constant integer arguments.
Metadata * getRawFile() const
Global variable summary information to aid decisions and implementation of importing.
static unsigned getEncodedThreadLocalMode(const GlobalValue &GV)
std::pair< unsigned, AttributeSet > IndexAndAttrSet
Attribute groups as encoded in bitcode are almost AttributeSets, but they include the AttributeList i...
Available for inspection, not emission.
Definition: GlobalValue.h:50
DIFile * getFile() const
static void writeDISubrange(raw_ostream &Out, const DISubrange *N, TypePrinting *, SlotTracker *, const Module *)
Definition: AsmWriter.cpp:1617
ArrayRef< ValueInfo > refs() const
Return the list of values referenced by this global value definition.
DITypeRef getBaseType() const
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
unsigned getDiscriminator() const
bool isFP128Ty() const
Return true if this is &#39;fp128&#39;.
Definition: Type.h:156
MDString * getRawValue() const
This class represents a function call, abstracting a target machine&#39;s calling convention.
This file contains the declarations for metadata subclasses.
void setInstructionID(const Instruction *I)
Value * getCondition() const
bool shouldPreserveUseListOrder() const
StringEncoding
*p = old <unsigned v ? old : v
Definition: Instructions.h:711
void writeSymtab()
Attempt to write a symbol table to the bitcode file.
bool isSwiftError() const
Return true if this alloca is used as a swifterror argument to a call.
Definition: Instructions.h:132
Like Internal, but omit from symbol table.
Definition: GlobalValue.h:57
*p = old >unsigned v ? old : v
Definition: Instructions.h:709
void writeThinLinkBitcode(const Module *M, const ModuleSummaryIndex &Index, const ModuleHash &ModHash)
Write the specified thin link bitcode file (i.e., the minimized bitcode file) to the buffer specified...
Externally visible function.
Definition: GlobalValue.h:49
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:697
The data referenced by the COMDAT must be the same size.
Definition: Comdat.h:36
DICompositeTypeArray getEnumTypes() const
const std::string & getDataLayoutStr() const
Get the data layout string for the module&#39;s target platform.
Definition: Module.h:224
static void writeDIMacroFile(raw_ostream &Out, const DIMacroFile *N, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context)
Definition: AsmWriter.cpp:1829
uint64_t getDWOId() const
BasicBlock * getSuccessor(unsigned i) const
void write32le(void *P, uint32_t V)
Definition: Endian.h:404
13: Structures
Definition: Type.h:73
uint64_t GetCurrentBitNo() const
Retrieve the current position in the stream, in bits.
Metadata node.
Definition: Metadata.h:862
The two locations do not alias at all.
Definition: AliasAnalysis.h:85
F(f)
4: 80-bit floating point type (X87)
Definition: Type.h:61
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1067
A class that wrap the SHA1 algorithm.
Definition: SHA1.h:29
1: 16-bit floating point type
Definition: Type.h:58
bool isOpaque() const
Return true if this is a type with an identity that has no body specified yet.
Definition: DerivedTypes.h:269
Value * getCondition() const
static const Target * lookupTarget(const std::string &Triple, std::string &Error)
lookupTarget - Lookup a target based on a target triple.
unsigned index_end() const
Definition: Attributes.h:634
Constant * getClause(unsigned Idx) const
Get the value of the clause at index Idx.
15: Pointers
Definition: Type.h:75
static void writeDILocation(raw_ostream &Out, const DILocation *DL, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context)
Definition: AsmWriter.cpp:1604
static void writeDITemplateTypeParameter(raw_ostream &Out, const DITemplateTypeParameter *N, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context)
Definition: AsmWriter.cpp:1854
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode *>> &MDs) const
Appends all attachments for the global to MDs, sorting by attachment ID.
Definition: Metadata.cpp:1404
void reserve(size_type N)
Definition: SmallVector.h:380
bool hasMDs() const
Check whether the current block has any metadata to emit.
bool isMustTailCall() const
bool getDebugInfoForProfiling() const
CallingConv::ID getCallingConv() const
getCallingConv/setCallingConv - Get or set the calling convention of this function call...
static void writeDILocalVariable(raw_ostream &Out, const DILocalVariable *N, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context)
Definition: AsmWriter.cpp:1899
12: Functions
Definition: Type.h:72
bool isPPC_FP128Ty() const
Return true if this is powerpc long double.
Definition: Type.h:159
unsigned getAttributeGroupID(IndexAndAttrSet Group) const
*p = old >signed v ? old : v
Definition: Instructions.h:705
static unsigned getEncodedRMWOperation(AtomicRMWInst::BinOp Op)
Tentative definitions.
Definition: GlobalValue.h:59
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:128
static StringEncoding getStringEncoding(StringRef Str)
Determine the encoding to use for the given string name and length.
Tuple of metadata.
Definition: Metadata.h:1104
static void emitDarwinBCHeaderAndTrailer(SmallVectorImpl< char > &Buffer, const Triple &TT)
If generating a bc file on darwin, we have to emit a header and trailer to make it compatible with th...
static bool isLocalLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:301
DINodeArray getElements() const
static const uint64_t INDEX_VERSION
MDString * getRawName() const
unsigned getMetadataID(const Metadata *MD) const
AttributeList getAttributes() const
Return the parameter attributes for this call.
void incorporateFunction(const Function &F)
incorporateFunction/purgeFunction - If you&#39;d like to deal with a function, use these two methods to g...
void dump() const
Support for debugging, callable in GDB: V->dump()
Definition: AsmWriter.cpp:3627
The address of a basic block.
Definition: Constants.h:813
DIScope * getScope() const
static uint32_t getAlignment(const MCSectionCOFF &Sec)
unsigned NotEligibleToImport
Indicate if the global value cannot be imported (e.g.
GlobalValue::GUID getGUID() const
A tuple of MDNodes.
Definition: Metadata.h:1323
static void writeIdentificationBlock(BitstreamWriter &Stream)
Create the "IDENTIFICATION_BLOCK_ID" containing a single string with the current llvm version...
CallingConv::ID getCallingConv() const
getCallingConv/setCallingConv - Get or set the calling convention of this function call...
unsigned getAlignment() const
Return the alignment of the memory that is being allocated by the instruction.
Definition: Instructions.h:109
uint32_t read32be(const void *P)
Definition: Endian.h:372
unsigned getNumArgOperands() const
Return the number of call arguments.
GVFlags flags()
Get the flags for this GlobalValue (see struct GVFlags).
unsigned getTag() const
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:138
bool isResolved() const
Check if node is fully resolved.
Definition: Metadata.h:938
DIGlobalVariable * getVariable() const
Class to represent struct types.
Definition: DerivedTypes.h:201
void BackpatchWord(uint64_t BitNo, unsigned NewWord)
Backpatch a 32-bit word in the output at the given bit offset with the specified value.
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:237
Array subrange.
MDString * getRawSetterName() const
const TypeList & getTypes() const
UnnamedAddr getUnnamedAddr() const
Definition: GlobalValue.h:200
std::array< uint32_t, 5 > ModuleHash
160 bits SHA1
static unsigned getEncodedBinaryOpcode(unsigned Opcode)
This file contains the simple types necessary to represent the attributes associated with functions a...
No attributes have been set.
Definition: Attributes.h:72
void Emit(uint32_t Val, unsigned NumBits)
void EnterBlockInfoBlock()
EnterBlockInfoBlock - Start emitting the BLOCKINFO_BLOCK.
InstrTy * getInstruction() const
Definition: CallSite.h:92
The linker may choose any COMDAT.
Definition: Comdat.h:32
uint64_t computeBitsRequiredForTypeIndicies() const
uint64_t getSizeInBits() const
static void writeGenericDINode(raw_ostream &Out, const GenericDINode *N, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context)
Definition: AsmWriter.cpp:1585
uint64_t getNumElements() const
Definition: DerivedTypes.h:359
static const unsigned MaximumAlignment
Definition: Value.h:590
DITypeRef getVTableHolder() const
unsigned getNumClauses() const
Get the number of clauses for this landing pad.
This file implements a class to represent arbitrary precision integral constant values and operations...
ArrayRef< GlobalValue::GUID > type_tests() const
Returns the list of type identifiers used by this function in llvm.type.test intrinsics other than by...
static void writeDIGlobalVariableExpression(raw_ostream &Out, const DIGlobalVariableExpression *N, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context)
Definition: AsmWriter.cpp:1936
AtomicOrdering
Atomic ordering for LLVM&#39;s memory model.
void assign(size_type NumElts, const T &Elt)
Definition: SmallVector.h:427
bool getExportSymbols() const
static void writeDIFile(raw_ostream &Out, const DIFile *N, TypePrinting *, SlotTracker *, const Module *)
Definition: AsmWriter.cpp:1708
Subprogram description.
ArrayRef< ConstVCall > type_checked_load_const_vcalls() const
Returns the list of virtual calls made by this function using llvm.type.checked.load intrinsics with ...
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:86
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:862
Class to represent fu