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