brintos / llvm-project-archived public Read only

1//===- Bitcode/Writer/BitcodeWriter.cpp - Bitcode Writer ------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8//9// Bitcode writer implementation.10//11//===----------------------------------------------------------------------===//12 13#include "llvm/Bitcode/BitcodeWriter.h"14#include "ValueEnumerator.h"15#include "llvm/ADT/APFloat.h"16#include "llvm/ADT/APInt.h"17#include "llvm/ADT/ArrayRef.h"18#include "llvm/ADT/DenseMap.h"19#include "llvm/ADT/STLExtras.h"20#include "llvm/ADT/SetVector.h"21#include "llvm/ADT/SmallPtrSet.h"22#include "llvm/ADT/SmallString.h"23#include "llvm/ADT/SmallVector.h"24#include "llvm/ADT/StringMap.h"25#include "llvm/ADT/StringRef.h"26#include "llvm/Analysis/MemoryProfileInfo.h"27#include "llvm/BinaryFormat/Dwarf.h"28#include "llvm/Bitcode/BitcodeCommon.h"29#include "llvm/Bitcode/BitcodeReader.h"30#include "llvm/Bitcode/LLVMBitCodes.h"31#include "llvm/Bitstream/BitCodes.h"32#include "llvm/Bitstream/BitstreamWriter.h"33#include "llvm/Config/llvm-config.h"34#include "llvm/IR/Attributes.h"35#include "llvm/IR/BasicBlock.h"36#include "llvm/IR/Comdat.h"37#include "llvm/IR/Constant.h"38#include "llvm/IR/ConstantRangeList.h"39#include "llvm/IR/Constants.h"40#include "llvm/IR/DebugInfoMetadata.h"41#include "llvm/IR/DebugLoc.h"42#include "llvm/IR/DerivedTypes.h"43#include "llvm/IR/Function.h"44#include "llvm/IR/GlobalAlias.h"45#include "llvm/IR/GlobalIFunc.h"46#include "llvm/IR/GlobalObject.h"47#include "llvm/IR/GlobalValue.h"48#include "llvm/IR/GlobalVariable.h"49#include "llvm/IR/InlineAsm.h"50#include "llvm/IR/InstrTypes.h"51#include "llvm/IR/Instruction.h"52#include "llvm/IR/Instructions.h"53#include "llvm/IR/LLVMContext.h"54#include "llvm/IR/Metadata.h"55#include "llvm/IR/Module.h"56#include "llvm/IR/ModuleSummaryIndex.h"57#include "llvm/IR/Operator.h"58#include "llvm/IR/Type.h"59#include "llvm/IR/UseListOrder.h"60#include "llvm/IR/Value.h"61#include "llvm/IR/ValueSymbolTable.h"62#include "llvm/MC/StringTableBuilder.h"63#include "llvm/MC/TargetRegistry.h"64#include "llvm/Object/IRSymtab.h"65#include "llvm/ProfileData/MemProf.h"66#include "llvm/ProfileData/MemProfRadixTree.h"67#include "llvm/Support/AtomicOrdering.h"68#include "llvm/Support/Casting.h"69#include "llvm/Support/CommandLine.h"70#include "llvm/Support/Compiler.h"71#include "llvm/Support/Endian.h"72#include "llvm/Support/Error.h"73#include "llvm/Support/ErrorHandling.h"74#include "llvm/Support/MathExtras.h"75#include "llvm/Support/SHA1.h"76#include "llvm/Support/raw_ostream.h"77#include "llvm/TargetParser/Triple.h"78#include <algorithm>79#include <cassert>80#include <cstddef>81#include <cstdint>82#include <iterator>83#include <map>84#include <memory>85#include <optional>86#include <string>87#include <utility>88#include <vector>89 90using namespace llvm;91using namespace llvm::memprof;92 93static cl::opt<unsigned>94    IndexThreshold("bitcode-mdindex-threshold", cl::Hidden, cl::init(25),95                   cl::desc("Number of metadatas above which we emit an index "96                            "to enable lazy-loading"));97static cl::opt<uint32_t> FlushThreshold(98    "bitcode-flush-threshold", cl::Hidden, cl::init(512),99    cl::desc("The threshold (unit M) for flushing LLVM bitcode."));100 101static cl::opt<bool> WriteRelBFToSummary(102    "write-relbf-to-summary", cl::Hidden, cl::init(false),103    cl::desc("Write relative block frequency to function summary "));104 105// Since we only use the context information in the memprof summary records in106// the LTO backends to do assertion checking, save time and space by only107// serializing the context for non-NDEBUG builds.108// TODO: Currently this controls writing context of the allocation info records,109// which are larger and more expensive, but we should do this for the callsite110// records as well.111// FIXME: Convert to a const once this has undergone more sigificant testing.112static cl::opt<bool>113    CombinedIndexMemProfContext("combined-index-memprof-context", cl::Hidden,114#ifdef NDEBUG115                                cl::init(false),116#else117                                cl::init(true),118#endif119                                cl::desc(""));120 121static cl::opt<bool> PreserveBitcodeUseListOrder(122    "preserve-bc-uselistorder", cl::Hidden, cl::init(true),123    cl::desc("Preserve use-list order when writing LLVM bitcode."));124 125namespace llvm {126extern FunctionSummary::ForceSummaryHotnessType ForceSummaryEdgesCold;127}128 129namespace {130 131/// These are manifest constants used by the bitcode writer. They do not need to132/// be kept in sync with the reader, but need to be consistent within this file.133enum {134  // VALUE_SYMTAB_BLOCK abbrev id's.135  VST_ENTRY_8_ABBREV = bitc::FIRST_APPLICATION_ABBREV,136  VST_ENTRY_7_ABBREV,137  VST_ENTRY_6_ABBREV,138  VST_BBENTRY_6_ABBREV,139 140  // CONSTANTS_BLOCK abbrev id's.141  CONSTANTS_SETTYPE_ABBREV = bitc::FIRST_APPLICATION_ABBREV,142  CONSTANTS_INTEGER_ABBREV,143  CONSTANTS_CE_CAST_Abbrev,144  CONSTANTS_NULL_Abbrev,145 146  // FUNCTION_BLOCK abbrev id's.147  FUNCTION_INST_LOAD_ABBREV = bitc::FIRST_APPLICATION_ABBREV,148  FUNCTION_INST_STORE_ABBREV,149  FUNCTION_INST_UNOP_ABBREV,150  FUNCTION_INST_UNOP_FLAGS_ABBREV,151  FUNCTION_INST_BINOP_ABBREV,152  FUNCTION_INST_BINOP_FLAGS_ABBREV,153  FUNCTION_INST_CAST_ABBREV,154  FUNCTION_INST_CAST_FLAGS_ABBREV,155  FUNCTION_INST_RET_VOID_ABBREV,156  FUNCTION_INST_RET_VAL_ABBREV,157  FUNCTION_INST_BR_UNCOND_ABBREV,158  FUNCTION_INST_BR_COND_ABBREV,159  FUNCTION_INST_UNREACHABLE_ABBREV,160  FUNCTION_INST_GEP_ABBREV,161  FUNCTION_INST_CMP_ABBREV,162  FUNCTION_INST_CMP_FLAGS_ABBREV,163  FUNCTION_DEBUG_RECORD_VALUE_ABBREV,164  FUNCTION_DEBUG_LOC_ABBREV,165};166 167/// Abstract class to manage the bitcode writing, subclassed for each bitcode168/// file type.169class BitcodeWriterBase {170protected:171  /// The stream created and owned by the client.172  BitstreamWriter &Stream;173 174  StringTableBuilder &StrtabBuilder;175 176public:177  /// Constructs a BitcodeWriterBase object that writes to the provided178  /// \p Stream.179  BitcodeWriterBase(BitstreamWriter &Stream, StringTableBuilder &StrtabBuilder)180      : Stream(Stream), StrtabBuilder(StrtabBuilder) {}181 182protected:183  void writeModuleVersion();184};185 186void BitcodeWriterBase::writeModuleVersion() {187  // VERSION: [version#]188  Stream.EmitRecord(bitc::MODULE_CODE_VERSION, ArrayRef<uint64_t>{2});189}190 191/// Base class to manage the module bitcode writing, currently subclassed for192/// ModuleBitcodeWriter and ThinLinkBitcodeWriter.193class ModuleBitcodeWriterBase : public BitcodeWriterBase {194protected:195  /// The Module to write to bitcode.196  const Module &M;197 198  /// Enumerates ids for all values in the module.199  ValueEnumerator VE;200 201  /// Optional per-module index to write for ThinLTO.202  const ModuleSummaryIndex *Index;203 204  /// Map that holds the correspondence between GUIDs in the summary index,205  /// that came from indirect call profiles, and a value id generated by this206  /// class to use in the VST and summary block records.207  std::map<GlobalValue::GUID, unsigned> GUIDToValueIdMap;208 209  /// Tracks the last value id recorded in the GUIDToValueMap.210  unsigned GlobalValueId;211 212  /// Saves the offset of the VSTOffset record that must eventually be213  /// backpatched with the offset of the actual VST.214  uint64_t VSTOffsetPlaceholder = 0;215 216public:217  /// Constructs a ModuleBitcodeWriterBase object for the given Module,218  /// writing to the provided \p Buffer.219  ModuleBitcodeWriterBase(const Module &M, StringTableBuilder &StrtabBuilder,220                          BitstreamWriter &Stream,221                          bool ShouldPreserveUseListOrder,222                          const ModuleSummaryIndex *Index)223      : BitcodeWriterBase(Stream, StrtabBuilder), M(M),224        VE(M, PreserveBitcodeUseListOrder.getNumOccurrences()225                  ? PreserveBitcodeUseListOrder226                  : ShouldPreserveUseListOrder),227        Index(Index) {228    // Assign ValueIds to any callee values in the index that came from229    // indirect call profiles and were recorded as a GUID not a Value*230    // (which would have been assigned an ID by the ValueEnumerator).231    // The starting ValueId is just after the number of values in the232    // ValueEnumerator, so that they can be emitted in the VST.233    GlobalValueId = VE.getValues().size();234    if (!Index)235      return;236    for (const auto &GUIDSummaryLists : *Index)237      // Examine all summaries for this GUID.238      for (auto &Summary : GUIDSummaryLists.second.getSummaryList())239        if (auto FS = dyn_cast<FunctionSummary>(Summary.get())) {240          // For each call in the function summary, see if the call241          // is to a GUID (which means it is for an indirect call,242          // otherwise we would have a Value for it). If so, synthesize243          // a value id.244          for (auto &CallEdge : FS->calls())245            if (!CallEdge.first.haveGVs() || !CallEdge.first.getValue())246              assignValueId(CallEdge.first.getGUID());247 248          // For each referenced variables in the function summary, see if the249          // variable is represented by a GUID (as opposed to a symbol to250          // declarations or definitions in the module). If so, synthesize a251          // value id.252          for (auto &RefEdge : FS->refs())253            if (!RefEdge.haveGVs() || !RefEdge.getValue())254              assignValueId(RefEdge.getGUID());255        }256  }257 258protected:259  void writePerModuleGlobalValueSummary();260 261private:262  void writePerModuleFunctionSummaryRecord(263      SmallVector<uint64_t, 64> &NameVals, GlobalValueSummary *Summary,264      unsigned ValueID, unsigned FSCallsAbbrev, unsigned FSCallsProfileAbbrev,265      unsigned CallsiteAbbrev, unsigned AllocAbbrev, unsigned ContextIdAbbvId,266      const Function &F, DenseMap<CallStackId, LinearCallStackId> &CallStackPos,267      CallStackId &CallStackCount);268  void writeModuleLevelReferences(const GlobalVariable &V,269                                  SmallVector<uint64_t, 64> &NameVals,270                                  unsigned FSModRefsAbbrev,271                                  unsigned FSModVTableRefsAbbrev);272 273  void assignValueId(GlobalValue::GUID ValGUID) {274    GUIDToValueIdMap[ValGUID] = ++GlobalValueId;275  }276 277  unsigned getValueId(GlobalValue::GUID ValGUID) {278    const auto &VMI = GUIDToValueIdMap.find(ValGUID);279    // Expect that any GUID value had a value Id assigned by an280    // earlier call to assignValueId.281    assert(VMI != GUIDToValueIdMap.end() &&282           "GUID does not have assigned value Id");283    return VMI->second;284  }285 286  // Helper to get the valueId for the type of value recorded in VI.287  unsigned getValueId(ValueInfo VI) {288    if (!VI.haveGVs() || !VI.getValue())289      return getValueId(VI.getGUID());290    return VE.getValueID(VI.getValue());291  }292 293  std::map<GlobalValue::GUID, unsigned> &valueIds() { return GUIDToValueIdMap; }294};295 296/// Class to manage the bitcode writing for a module.297class ModuleBitcodeWriter : public ModuleBitcodeWriterBase {298  /// True if a module hash record should be written.299  bool GenerateHash;300 301  /// If non-null, when GenerateHash is true, the resulting hash is written302  /// into ModHash.303  ModuleHash *ModHash;304 305  SHA1 Hasher;306 307  /// The start bit of the identification block.308  uint64_t BitcodeStartBit;309 310public:311  /// Constructs a ModuleBitcodeWriter object for the given Module,312  /// writing to the provided \p Buffer.313  ModuleBitcodeWriter(const Module &M, StringTableBuilder &StrtabBuilder,314                      BitstreamWriter &Stream, bool ShouldPreserveUseListOrder,315                      const ModuleSummaryIndex *Index, bool GenerateHash,316                      ModuleHash *ModHash = nullptr)317      : ModuleBitcodeWriterBase(M, StrtabBuilder, Stream,318                                ShouldPreserveUseListOrder, Index),319        GenerateHash(GenerateHash), ModHash(ModHash),320        BitcodeStartBit(Stream.GetCurrentBitNo()) {}321 322  /// Emit the current module to the bitstream.323  void write();324 325private:326  uint64_t bitcodeStartBit() { return BitcodeStartBit; }327 328  size_t addToStrtab(StringRef Str);329 330  void writeAttributeGroupTable();331  void writeAttributeTable();332  void writeTypeTable();333  void writeComdats();334  void writeValueSymbolTableForwardDecl();335  void writeModuleInfo();336  void writeValueAsMetadata(const ValueAsMetadata *MD,337                            SmallVectorImpl<uint64_t> &Record);338  void writeMDTuple(const MDTuple *N, SmallVectorImpl<uint64_t> &Record,339                    unsigned Abbrev);340  unsigned createDILocationAbbrev();341  void writeDILocation(const DILocation *N, SmallVectorImpl<uint64_t> &Record,342                       unsigned &Abbrev);343  unsigned createGenericDINodeAbbrev();344  void writeGenericDINode(const GenericDINode *N,345                          SmallVectorImpl<uint64_t> &Record, unsigned &Abbrev);346  void writeDISubrange(const DISubrange *N, SmallVectorImpl<uint64_t> &Record,347                       unsigned Abbrev);348  void writeDIGenericSubrange(const DIGenericSubrange *N,349                              SmallVectorImpl<uint64_t> &Record,350                              unsigned Abbrev);351  void writeDIEnumerator(const DIEnumerator *N,352                         SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);353  void writeDIBasicType(const DIBasicType *N, SmallVectorImpl<uint64_t> &Record,354                        unsigned Abbrev);355  void writeDIFixedPointType(const DIFixedPointType *N,356                             SmallVectorImpl<uint64_t> &Record,357                             unsigned Abbrev);358  void writeDIStringType(const DIStringType *N,359                         SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);360  void writeDIDerivedType(const DIDerivedType *N,361                          SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);362  void writeDISubrangeType(const DISubrangeType *N,363                           SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);364  void writeDICompositeType(const DICompositeType *N,365                            SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);366  void writeDISubroutineType(const DISubroutineType *N,367                             SmallVectorImpl<uint64_t> &Record,368                             unsigned Abbrev);369  void writeDIFile(const DIFile *N, SmallVectorImpl<uint64_t> &Record,370                   unsigned Abbrev);371  void writeDICompileUnit(const DICompileUnit *N,372                          SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);373  void writeDISubprogram(const DISubprogram *N,374                         SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);375  void writeDILexicalBlock(const DILexicalBlock *N,376                           SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);377  void writeDILexicalBlockFile(const DILexicalBlockFile *N,378                               SmallVectorImpl<uint64_t> &Record,379                               unsigned Abbrev);380  void writeDICommonBlock(const DICommonBlock *N,381                          SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);382  void writeDINamespace(const DINamespace *N, SmallVectorImpl<uint64_t> &Record,383                        unsigned Abbrev);384  void writeDIMacro(const DIMacro *N, SmallVectorImpl<uint64_t> &Record,385                    unsigned Abbrev);386  void writeDIMacroFile(const DIMacroFile *N, SmallVectorImpl<uint64_t> &Record,387                        unsigned Abbrev);388  void writeDIArgList(const DIArgList *N, SmallVectorImpl<uint64_t> &Record);389  void writeDIModule(const DIModule *N, SmallVectorImpl<uint64_t> &Record,390                     unsigned Abbrev);391  void writeDIAssignID(const DIAssignID *N, SmallVectorImpl<uint64_t> &Record,392                       unsigned Abbrev);393  void writeDITemplateTypeParameter(const DITemplateTypeParameter *N,394                                    SmallVectorImpl<uint64_t> &Record,395                                    unsigned Abbrev);396  void writeDITemplateValueParameter(const DITemplateValueParameter *N,397                                     SmallVectorImpl<uint64_t> &Record,398                                     unsigned Abbrev);399  void writeDIGlobalVariable(const DIGlobalVariable *N,400                             SmallVectorImpl<uint64_t> &Record,401                             unsigned Abbrev);402  void writeDILocalVariable(const DILocalVariable *N,403                            SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);404  void writeDILabel(const DILabel *N,405                    SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);406  void writeDIExpression(const DIExpression *N,407                         SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);408  void writeDIGlobalVariableExpression(const DIGlobalVariableExpression *N,409                                       SmallVectorImpl<uint64_t> &Record,410                                       unsigned Abbrev);411  void writeDIObjCProperty(const DIObjCProperty *N,412                           SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);413  void writeDIImportedEntity(const DIImportedEntity *N,414                             SmallVectorImpl<uint64_t> &Record,415                             unsigned Abbrev);416  unsigned createNamedMetadataAbbrev();417  void writeNamedMetadata(SmallVectorImpl<uint64_t> &Record);418  unsigned createMetadataStringsAbbrev();419  void writeMetadataStrings(ArrayRef<const Metadata *> Strings,420                            SmallVectorImpl<uint64_t> &Record);421  void writeMetadataRecords(ArrayRef<const Metadata *> MDs,422                            SmallVectorImpl<uint64_t> &Record,423                            std::vector<unsigned> *MDAbbrevs = nullptr,424                            std::vector<uint64_t> *IndexPos = nullptr);425  void writeModuleMetadata();426  void writeFunctionMetadata(const Function &F);427  void writeFunctionMetadataAttachment(const Function &F);428  void pushGlobalMetadataAttachment(SmallVectorImpl<uint64_t> &Record,429                                    const GlobalObject &GO);430  void writeModuleMetadataKinds();431  void writeOperandBundleTags();432  void writeSyncScopeNames();433  void writeConstants(unsigned FirstVal, unsigned LastVal, bool isGlobal);434  void writeModuleConstants();435  bool pushValueAndType(const Value *V, unsigned InstID,436                        SmallVectorImpl<unsigned> &Vals);437  bool pushValueOrMetadata(const Value *V, unsigned InstID,438                           SmallVectorImpl<unsigned> &Vals);439  void writeOperandBundles(const CallBase &CB, unsigned InstID);440  void pushValue(const Value *V, unsigned InstID,441                 SmallVectorImpl<unsigned> &Vals);442  void pushValueSigned(const Value *V, unsigned InstID,443                       SmallVectorImpl<uint64_t> &Vals);444  void writeInstruction(const Instruction &I, unsigned InstID,445                        SmallVectorImpl<unsigned> &Vals);446  void writeFunctionLevelValueSymbolTable(const ValueSymbolTable &VST);447  void writeGlobalValueSymbolTable(448      DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex);449  void writeUseList(UseListOrder &&Order);450  void writeUseListBlock(const Function *F);451  void452  writeFunction(const Function &F,453                DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex);454  void writeBlockInfo();455  void writeModuleHash(StringRef View);456 457  unsigned getEncodedSyncScopeID(SyncScope::ID SSID) {458    return unsigned(SSID);459  }460 461  unsigned getEncodedAlign(MaybeAlign Alignment) { return encode(Alignment); }462};463 464/// Class to manage the bitcode writing for a combined index.465class IndexBitcodeWriter : public BitcodeWriterBase {466  /// The combined index to write to bitcode.467  const ModuleSummaryIndex &Index;468 469  /// When writing combined summaries, provides the set of global value470  /// summaries for which the value (function, function alias, etc) should be471  /// imported as a declaration.472  const GVSummaryPtrSet *DecSummaries = nullptr;473 474  /// When writing a subset of the index for distributed backends, client475  /// provides a map of modules to the corresponding GUIDs/summaries to write.476  const ModuleToSummariesForIndexTy *ModuleToSummariesForIndex;477 478  /// Map that holds the correspondence between the GUID used in the combined479  /// index and a value id generated by this class to use in references.480  std::map<GlobalValue::GUID, unsigned> GUIDToValueIdMap;481 482  // The stack ids used by this index, which will be a subset of those in483  // the full index in the case of distributed indexes.484  std::vector<uint64_t> StackIds;485 486  // Keep a map of the stack id indices used by records being written for this487  // index to the index of the corresponding stack id in the above StackIds488  // vector. Ensures we write each referenced stack id once.489  DenseMap<unsigned, unsigned> StackIdIndicesToIndex;490 491  /// Tracks the last value id recorded in the GUIDToValueMap.492  unsigned GlobalValueId = 0;493 494  /// Tracks the assignment of module paths in the module path string table to495  /// an id assigned for use in summary references to the module path.496  DenseMap<StringRef, uint64_t> ModuleIdMap;497 498public:499  /// Constructs a IndexBitcodeWriter object for the given combined index,500  /// writing to the provided \p Buffer. When writing a subset of the index501  /// for a distributed backend, provide a \p ModuleToSummariesForIndex map.502  /// If provided, \p DecSummaries specifies the set of summaries for which503  /// the corresponding functions or aliased functions should be imported as a504  /// declaration (but not definition) for each module.505  IndexBitcodeWriter(506      BitstreamWriter &Stream, StringTableBuilder &StrtabBuilder,507      const ModuleSummaryIndex &Index,508      const GVSummaryPtrSet *DecSummaries = nullptr,509      const ModuleToSummariesForIndexTy *ModuleToSummariesForIndex = nullptr)510      : BitcodeWriterBase(Stream, StrtabBuilder), Index(Index),511        DecSummaries(DecSummaries),512        ModuleToSummariesForIndex(ModuleToSummariesForIndex) {513 514    // See if the StackIdIndex was already added to the StackId map and515    // vector. If not, record it.516    auto RecordStackIdReference = [&](unsigned StackIdIndex) {517      // If the StackIdIndex is not yet in the map, the below insert ensures518      // that it will point to the new StackIds vector entry we push to just519      // below.520      auto Inserted =521          StackIdIndicesToIndex.insert({StackIdIndex, StackIds.size()});522      if (Inserted.second)523        StackIds.push_back(Index.getStackIdAtIndex(StackIdIndex));524    };525 526    // Assign unique value ids to all summaries to be written, for use527    // in writing out the call graph edges. Save the mapping from GUID528    // to the new global value id to use when writing those edges, which529    // are currently saved in the index in terms of GUID.530    forEachSummary([&](GVInfo I, bool IsAliasee) {531      GUIDToValueIdMap[I.first] = ++GlobalValueId;532      // If this is invoked for an aliasee, we want to record the above mapping,533      // but not the information needed for its summary entry (if the aliasee is534      // to be imported, we will invoke this separately with IsAliasee=false).535      if (IsAliasee)536        return;537      auto *FS = dyn_cast<FunctionSummary>(I.second);538      if (!FS)539        return;540      // Record all stack id indices actually used in the summary entries being541      // written, so that we can compact them in the case of distributed ThinLTO542      // indexes.543      for (auto &CI : FS->callsites()) {544        // If the stack id list is empty, this callsite info was synthesized for545        // a missing tail call frame. Ensure that the callee's GUID gets a value546        // id. Normally we only generate these for defined summaries, which in547        // the case of distributed ThinLTO is only the functions already defined548        // in the module or that we want to import. We don't bother to include549        // all the callee symbols as they aren't normally needed in the backend.550        // However, for the synthesized callsite infos we do need the callee551        // GUID in the backend so that we can correlate the identified callee552        // with this callsite info (which for non-tail calls is done by the553        // ordering of the callsite infos and verified via stack ids).554        if (CI.StackIdIndices.empty()) {555          GUIDToValueIdMap[CI.Callee.getGUID()] = ++GlobalValueId;556          continue;557        }558        for (auto Idx : CI.StackIdIndices)559          RecordStackIdReference(Idx);560      }561      if (CombinedIndexMemProfContext) {562        for (auto &AI : FS->allocs())563          for (auto &MIB : AI.MIBs)564            for (auto Idx : MIB.StackIdIndices)565              RecordStackIdReference(Idx);566      }567    });568  }569 570  /// The below iterator returns the GUID and associated summary.571  using GVInfo = std::pair<GlobalValue::GUID, GlobalValueSummary *>;572 573  /// Calls the callback for each value GUID and summary to be written to574  /// bitcode. This hides the details of whether they are being pulled from the575  /// entire index or just those in a provided ModuleToSummariesForIndex map.576  template<typename Functor>577  void forEachSummary(Functor Callback) {578    if (ModuleToSummariesForIndex) {579      for (auto &M : *ModuleToSummariesForIndex)580        for (auto &Summary : M.second) {581          Callback(Summary, false);582          // Ensure aliasee is handled, e.g. for assigning a valueId,583          // even if we are not importing the aliasee directly (the584          // imported alias will contain a copy of aliasee).585          if (auto *AS = dyn_cast<AliasSummary>(Summary.getSecond()))586            Callback({AS->getAliaseeGUID(), &AS->getAliasee()}, true);587        }588    } else {589      for (auto &Summaries : Index)590        for (auto &Summary : Summaries.second.getSummaryList())591          Callback({Summaries.first, Summary.get()}, false);592    }593  }594 595  /// Calls the callback for each entry in the modulePaths StringMap that596  /// should be written to the module path string table. This hides the details597  /// of whether they are being pulled from the entire index or just those in a598  /// provided ModuleToSummariesForIndex map.599  template <typename Functor> void forEachModule(Functor Callback) {600    if (ModuleToSummariesForIndex) {601      for (const auto &M : *ModuleToSummariesForIndex) {602        const auto &MPI = Index.modulePaths().find(M.first);603        if (MPI == Index.modulePaths().end()) {604          // This should only happen if the bitcode file was empty, in which605          // case we shouldn't be importing (the ModuleToSummariesForIndex606          // would only include the module we are writing and index for).607          assert(ModuleToSummariesForIndex->size() == 1);608          continue;609        }610        Callback(*MPI);611      }612    } else {613      // Since StringMap iteration order isn't guaranteed, order by path string614      // first.615      // FIXME: Make this a vector of StringMapEntry instead to avoid the later616      // map lookup.617      std::vector<StringRef> ModulePaths;618      for (auto &[ModPath, _] : Index.modulePaths())619        ModulePaths.push_back(ModPath);620      llvm::sort(ModulePaths);621      for (auto &ModPath : ModulePaths)622        Callback(*Index.modulePaths().find(ModPath));623    }624  }625 626  /// Main entry point for writing a combined index to bitcode.627  void write();628 629private:630  void writeModStrings();631  void writeCombinedGlobalValueSummary();632 633  std::optional<unsigned> getValueId(GlobalValue::GUID ValGUID) {634    auto VMI = GUIDToValueIdMap.find(ValGUID);635    if (VMI == GUIDToValueIdMap.end())636      return std::nullopt;637    return VMI->second;638  }639 640  std::map<GlobalValue::GUID, unsigned> &valueIds() { return GUIDToValueIdMap; }641};642 643} // end anonymous namespace644 645static unsigned getEncodedCastOpcode(unsigned Opcode) {646  switch (Opcode) {647  default: llvm_unreachable("Unknown cast instruction!");648  case Instruction::Trunc   : return bitc::CAST_TRUNC;649  case Instruction::ZExt    : return bitc::CAST_ZEXT;650  case Instruction::SExt    : return bitc::CAST_SEXT;651  case Instruction::FPToUI  : return bitc::CAST_FPTOUI;652  case Instruction::FPToSI  : return bitc::CAST_FPTOSI;653  case Instruction::UIToFP  : return bitc::CAST_UITOFP;654  case Instruction::SIToFP  : return bitc::CAST_SITOFP;655  case Instruction::FPTrunc : return bitc::CAST_FPTRUNC;656  case Instruction::FPExt   : return bitc::CAST_FPEXT;657  case Instruction::PtrToAddr: return bitc::CAST_PTRTOADDR;658  case Instruction::PtrToInt: return bitc::CAST_PTRTOINT;659  case Instruction::IntToPtr: return bitc::CAST_INTTOPTR;660  case Instruction::BitCast : return bitc::CAST_BITCAST;661  case Instruction::AddrSpaceCast: return bitc::CAST_ADDRSPACECAST;662  }663}664 665static unsigned getEncodedUnaryOpcode(unsigned Opcode) {666  switch (Opcode) {667  default: llvm_unreachable("Unknown binary instruction!");668  case Instruction::FNeg: return bitc::UNOP_FNEG;669  }670}671 672static unsigned getEncodedBinaryOpcode(unsigned Opcode) {673  switch (Opcode) {674  default: llvm_unreachable("Unknown binary instruction!");675  case Instruction::Add:676  case Instruction::FAdd: return bitc::BINOP_ADD;677  case Instruction::Sub:678  case Instruction::FSub: return bitc::BINOP_SUB;679  case Instruction::Mul:680  case Instruction::FMul: return bitc::BINOP_MUL;681  case Instruction::UDiv: return bitc::BINOP_UDIV;682  case Instruction::FDiv:683  case Instruction::SDiv: return bitc::BINOP_SDIV;684  case Instruction::URem: return bitc::BINOP_UREM;685  case Instruction::FRem:686  case Instruction::SRem: return bitc::BINOP_SREM;687  case Instruction::Shl:  return bitc::BINOP_SHL;688  case Instruction::LShr: return bitc::BINOP_LSHR;689  case Instruction::AShr: return bitc::BINOP_ASHR;690  case Instruction::And:  return bitc::BINOP_AND;691  case Instruction::Or:   return bitc::BINOP_OR;692  case Instruction::Xor:  return bitc::BINOP_XOR;693  }694}695 696static unsigned getEncodedRMWOperation(AtomicRMWInst::BinOp Op) {697  switch (Op) {698  default: llvm_unreachable("Unknown RMW operation!");699  case AtomicRMWInst::Xchg: return bitc::RMW_XCHG;700  case AtomicRMWInst::Add: return bitc::RMW_ADD;701  case AtomicRMWInst::Sub: return bitc::RMW_SUB;702  case AtomicRMWInst::And: return bitc::RMW_AND;703  case AtomicRMWInst::Nand: return bitc::RMW_NAND;704  case AtomicRMWInst::Or: return bitc::RMW_OR;705  case AtomicRMWInst::Xor: return bitc::RMW_XOR;706  case AtomicRMWInst::Max: return bitc::RMW_MAX;707  case AtomicRMWInst::Min: return bitc::RMW_MIN;708  case AtomicRMWInst::UMax: return bitc::RMW_UMAX;709  case AtomicRMWInst::UMin: return bitc::RMW_UMIN;710  case AtomicRMWInst::FAdd: return bitc::RMW_FADD;711  case AtomicRMWInst::FSub: return bitc::RMW_FSUB;712  case AtomicRMWInst::FMax: return bitc::RMW_FMAX;713  case AtomicRMWInst::FMin: return bitc::RMW_FMIN;714  case AtomicRMWInst::FMaximum:715    return bitc::RMW_FMAXIMUM;716  case AtomicRMWInst::FMinimum:717    return bitc::RMW_FMINIMUM;718  case AtomicRMWInst::UIncWrap:719    return bitc::RMW_UINC_WRAP;720  case AtomicRMWInst::UDecWrap:721    return bitc::RMW_UDEC_WRAP;722  case AtomicRMWInst::USubCond:723    return bitc::RMW_USUB_COND;724  case AtomicRMWInst::USubSat:725    return bitc::RMW_USUB_SAT;726  }727}728 729static unsigned getEncodedOrdering(AtomicOrdering Ordering) {730  switch (Ordering) {731  case AtomicOrdering::NotAtomic: return bitc::ORDERING_NOTATOMIC;732  case AtomicOrdering::Unordered: return bitc::ORDERING_UNORDERED;733  case AtomicOrdering::Monotonic: return bitc::ORDERING_MONOTONIC;734  case AtomicOrdering::Acquire: return bitc::ORDERING_ACQUIRE;735  case AtomicOrdering::Release: return bitc::ORDERING_RELEASE;736  case AtomicOrdering::AcquireRelease: return bitc::ORDERING_ACQREL;737  case AtomicOrdering::SequentiallyConsistent: return bitc::ORDERING_SEQCST;738  }739  llvm_unreachable("Invalid ordering");740}741 742static void writeStringRecord(BitstreamWriter &Stream, unsigned Code,743                              StringRef Str, unsigned AbbrevToUse) {744  SmallVector<unsigned, 64> Vals;745 746  // Code: [strchar x N]747  for (char C : Str) {748    if (AbbrevToUse && !BitCodeAbbrevOp::isChar6(C))749      AbbrevToUse = 0;750    Vals.push_back(C);751  }752 753  // Emit the finished record.754  Stream.EmitRecord(Code, Vals, AbbrevToUse);755}756 757static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {758  switch (Kind) {759  case Attribute::Alignment:760    return bitc::ATTR_KIND_ALIGNMENT;761  case Attribute::AllocAlign:762    return bitc::ATTR_KIND_ALLOC_ALIGN;763  case Attribute::AllocSize:764    return bitc::ATTR_KIND_ALLOC_SIZE;765  case Attribute::AlwaysInline:766    return bitc::ATTR_KIND_ALWAYS_INLINE;767  case Attribute::Builtin:768    return bitc::ATTR_KIND_BUILTIN;769  case Attribute::ByVal:770    return bitc::ATTR_KIND_BY_VAL;771  case Attribute::Convergent:772    return bitc::ATTR_KIND_CONVERGENT;773  case Attribute::InAlloca:774    return bitc::ATTR_KIND_IN_ALLOCA;775  case Attribute::Cold:776    return bitc::ATTR_KIND_COLD;777  case Attribute::DisableSanitizerInstrumentation:778    return bitc::ATTR_KIND_DISABLE_SANITIZER_INSTRUMENTATION;779  case Attribute::FnRetThunkExtern:780    return bitc::ATTR_KIND_FNRETTHUNK_EXTERN;781  case Attribute::Hot:782    return bitc::ATTR_KIND_HOT;783  case Attribute::ElementType:784    return bitc::ATTR_KIND_ELEMENTTYPE;785  case Attribute::HybridPatchable:786    return bitc::ATTR_KIND_HYBRID_PATCHABLE;787  case Attribute::InlineHint:788    return bitc::ATTR_KIND_INLINE_HINT;789  case Attribute::InReg:790    return bitc::ATTR_KIND_IN_REG;791  case Attribute::JumpTable:792    return bitc::ATTR_KIND_JUMP_TABLE;793  case Attribute::MinSize:794    return bitc::ATTR_KIND_MIN_SIZE;795  case Attribute::AllocatedPointer:796    return bitc::ATTR_KIND_ALLOCATED_POINTER;797  case Attribute::AllocKind:798    return bitc::ATTR_KIND_ALLOC_KIND;799  case Attribute::Memory:800    return bitc::ATTR_KIND_MEMORY;801  case Attribute::NoFPClass:802    return bitc::ATTR_KIND_NOFPCLASS;803  case Attribute::Naked:804    return bitc::ATTR_KIND_NAKED;805  case Attribute::Nest:806    return bitc::ATTR_KIND_NEST;807  case Attribute::NoAlias:808    return bitc::ATTR_KIND_NO_ALIAS;809  case Attribute::NoBuiltin:810    return bitc::ATTR_KIND_NO_BUILTIN;811  case Attribute::NoCallback:812    return bitc::ATTR_KIND_NO_CALLBACK;813  case Attribute::NoDivergenceSource:814    return bitc::ATTR_KIND_NO_DIVERGENCE_SOURCE;815  case Attribute::NoDuplicate:816    return bitc::ATTR_KIND_NO_DUPLICATE;817  case Attribute::NoFree:818    return bitc::ATTR_KIND_NOFREE;819  case Attribute::NoImplicitFloat:820    return bitc::ATTR_KIND_NO_IMPLICIT_FLOAT;821  case Attribute::NoInline:822    return bitc::ATTR_KIND_NO_INLINE;823  case Attribute::NoRecurse:824    return bitc::ATTR_KIND_NO_RECURSE;825  case Attribute::NoMerge:826    return bitc::ATTR_KIND_NO_MERGE;827  case Attribute::NonLazyBind:828    return bitc::ATTR_KIND_NON_LAZY_BIND;829  case Attribute::NonNull:830    return bitc::ATTR_KIND_NON_NULL;831  case Attribute::Dereferenceable:832    return bitc::ATTR_KIND_DEREFERENCEABLE;833  case Attribute::DereferenceableOrNull:834    return bitc::ATTR_KIND_DEREFERENCEABLE_OR_NULL;835  case Attribute::NoRedZone:836    return bitc::ATTR_KIND_NO_RED_ZONE;837  case Attribute::NoReturn:838    return bitc::ATTR_KIND_NO_RETURN;839  case Attribute::NoSync:840    return bitc::ATTR_KIND_NOSYNC;841  case Attribute::NoCfCheck:842    return bitc::ATTR_KIND_NOCF_CHECK;843  case Attribute::NoProfile:844    return bitc::ATTR_KIND_NO_PROFILE;845  case Attribute::SkipProfile:846    return bitc::ATTR_KIND_SKIP_PROFILE;847  case Attribute::NoUnwind:848    return bitc::ATTR_KIND_NO_UNWIND;849  case Attribute::NoSanitizeBounds:850    return bitc::ATTR_KIND_NO_SANITIZE_BOUNDS;851  case Attribute::NoSanitizeCoverage:852    return bitc::ATTR_KIND_NO_SANITIZE_COVERAGE;853  case Attribute::NullPointerIsValid:854    return bitc::ATTR_KIND_NULL_POINTER_IS_VALID;855  case Attribute::OptimizeForDebugging:856    return bitc::ATTR_KIND_OPTIMIZE_FOR_DEBUGGING;857  case Attribute::OptForFuzzing:858    return bitc::ATTR_KIND_OPT_FOR_FUZZING;859  case Attribute::OptimizeForSize:860    return bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE;861  case Attribute::OptimizeNone:862    return bitc::ATTR_KIND_OPTIMIZE_NONE;863  case Attribute::ReadNone:864    return bitc::ATTR_KIND_READ_NONE;865  case Attribute::ReadOnly:866    return bitc::ATTR_KIND_READ_ONLY;867  case Attribute::Returned:868    return bitc::ATTR_KIND_RETURNED;869  case Attribute::ReturnsTwice:870    return bitc::ATTR_KIND_RETURNS_TWICE;871  case Attribute::SExt:872    return bitc::ATTR_KIND_S_EXT;873  case Attribute::Speculatable:874    return bitc::ATTR_KIND_SPECULATABLE;875  case Attribute::StackAlignment:876    return bitc::ATTR_KIND_STACK_ALIGNMENT;877  case Attribute::StackProtect:878    return bitc::ATTR_KIND_STACK_PROTECT;879  case Attribute::StackProtectReq:880    return bitc::ATTR_KIND_STACK_PROTECT_REQ;881  case Attribute::StackProtectStrong:882    return bitc::ATTR_KIND_STACK_PROTECT_STRONG;883  case Attribute::SafeStack:884    return bitc::ATTR_KIND_SAFESTACK;885  case Attribute::ShadowCallStack:886    return bitc::ATTR_KIND_SHADOWCALLSTACK;887  case Attribute::StrictFP:888    return bitc::ATTR_KIND_STRICT_FP;889  case Attribute::StructRet:890    return bitc::ATTR_KIND_STRUCT_RET;891  case Attribute::SanitizeAddress:892    return bitc::ATTR_KIND_SANITIZE_ADDRESS;893  case Attribute::SanitizeAllocToken:894    return bitc::ATTR_KIND_SANITIZE_ALLOC_TOKEN;895  case Attribute::SanitizeHWAddress:896    return bitc::ATTR_KIND_SANITIZE_HWADDRESS;897  case Attribute::SanitizeThread:898    return bitc::ATTR_KIND_SANITIZE_THREAD;899  case Attribute::SanitizeType:900    return bitc::ATTR_KIND_SANITIZE_TYPE;901  case Attribute::SanitizeMemory:902    return bitc::ATTR_KIND_SANITIZE_MEMORY;903  case Attribute::SanitizeNumericalStability:904    return bitc::ATTR_KIND_SANITIZE_NUMERICAL_STABILITY;905  case Attribute::SanitizeRealtime:906    return bitc::ATTR_KIND_SANITIZE_REALTIME;907  case Attribute::SanitizeRealtimeBlocking:908    return bitc::ATTR_KIND_SANITIZE_REALTIME_BLOCKING;909  case Attribute::SpeculativeLoadHardening:910    return bitc::ATTR_KIND_SPECULATIVE_LOAD_HARDENING;911  case Attribute::SwiftError:912    return bitc::ATTR_KIND_SWIFT_ERROR;913  case Attribute::SwiftSelf:914    return bitc::ATTR_KIND_SWIFT_SELF;915  case Attribute::SwiftAsync:916    return bitc::ATTR_KIND_SWIFT_ASYNC;917  case Attribute::UWTable:918    return bitc::ATTR_KIND_UW_TABLE;919  case Attribute::VScaleRange:920    return bitc::ATTR_KIND_VSCALE_RANGE;921  case Attribute::WillReturn:922    return bitc::ATTR_KIND_WILLRETURN;923  case Attribute::WriteOnly:924    return bitc::ATTR_KIND_WRITEONLY;925  case Attribute::ZExt:926    return bitc::ATTR_KIND_Z_EXT;927  case Attribute::ImmArg:928    return bitc::ATTR_KIND_IMMARG;929  case Attribute::SanitizeMemTag:930    return bitc::ATTR_KIND_SANITIZE_MEMTAG;931  case Attribute::Preallocated:932    return bitc::ATTR_KIND_PREALLOCATED;933  case Attribute::NoUndef:934    return bitc::ATTR_KIND_NOUNDEF;935  case Attribute::ByRef:936    return bitc::ATTR_KIND_BYREF;937  case Attribute::MustProgress:938    return bitc::ATTR_KIND_MUSTPROGRESS;939  case Attribute::PresplitCoroutine:940    return bitc::ATTR_KIND_PRESPLIT_COROUTINE;941  case Attribute::Writable:942    return bitc::ATTR_KIND_WRITABLE;943  case Attribute::CoroDestroyOnlyWhenComplete:944    return bitc::ATTR_KIND_CORO_ONLY_DESTROY_WHEN_COMPLETE;945  case Attribute::CoroElideSafe:946    return bitc::ATTR_KIND_CORO_ELIDE_SAFE;947  case Attribute::DeadOnUnwind:948    return bitc::ATTR_KIND_DEAD_ON_UNWIND;949  case Attribute::Range:950    return bitc::ATTR_KIND_RANGE;951  case Attribute::Initializes:952    return bitc::ATTR_KIND_INITIALIZES;953  case Attribute::NoExt:954    return bitc::ATTR_KIND_NO_EXT;955  case Attribute::Captures:956    return bitc::ATTR_KIND_CAPTURES;957  case Attribute::DeadOnReturn:958    return bitc::ATTR_KIND_DEAD_ON_RETURN;959  case Attribute::NoCreateUndefOrPoison:960    return bitc::ATTR_KIND_NO_CREATE_UNDEF_OR_POISON;961  case Attribute::EndAttrKinds:962    llvm_unreachable("Can not encode end-attribute kinds marker.");963  case Attribute::None:964    llvm_unreachable("Can not encode none-attribute.");965  case Attribute::EmptyKey:966  case Attribute::TombstoneKey:967    llvm_unreachable("Trying to encode EmptyKey/TombstoneKey");968  }969 970  llvm_unreachable("Trying to encode unknown attribute");971}972 973static void emitSignedInt64(SmallVectorImpl<uint64_t> &Vals, uint64_t V) {974  if ((int64_t)V >= 0)975    Vals.push_back(V << 1);976  else977    Vals.push_back((-V << 1) | 1);978}979 980static void emitWideAPInt(SmallVectorImpl<uint64_t> &Vals, const APInt &A) {981  // We have an arbitrary precision integer value to write whose982  // bit width is > 64. However, in canonical unsigned integer983  // format it is likely that the high bits are going to be zero.984  // So, we only write the number of active words.985  unsigned NumWords = A.getActiveWords();986  const uint64_t *RawData = A.getRawData();987  for (unsigned i = 0; i < NumWords; i++)988    emitSignedInt64(Vals, RawData[i]);989}990 991static void emitConstantRange(SmallVectorImpl<uint64_t> &Record,992                              const ConstantRange &CR, bool EmitBitWidth) {993  unsigned BitWidth = CR.getBitWidth();994  if (EmitBitWidth)995    Record.push_back(BitWidth);996  if (BitWidth > 64) {997    Record.push_back(CR.getLower().getActiveWords() |998                     (uint64_t(CR.getUpper().getActiveWords()) << 32));999    emitWideAPInt(Record, CR.getLower());1000    emitWideAPInt(Record, CR.getUpper());1001  } else {1002    emitSignedInt64(Record, CR.getLower().getSExtValue());1003    emitSignedInt64(Record, CR.getUpper().getSExtValue());1004  }1005}1006 1007void ModuleBitcodeWriter::writeAttributeGroupTable() {1008  const std::vector<ValueEnumerator::IndexAndAttrSet> &AttrGrps =1009      VE.getAttributeGroups();1010  if (AttrGrps.empty()) return;1011 1012  Stream.EnterSubblock(bitc::PARAMATTR_GROUP_BLOCK_ID, 3);1013 1014  SmallVector<uint64_t, 64> Record;1015  for (ValueEnumerator::IndexAndAttrSet Pair : AttrGrps) {1016    unsigned AttrListIndex = Pair.first;1017    AttributeSet AS = Pair.second;1018    Record.push_back(VE.getAttributeGroupID(Pair));1019    Record.push_back(AttrListIndex);1020 1021    for (Attribute Attr : AS) {1022      if (Attr.isEnumAttribute()) {1023        Record.push_back(0);1024        Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));1025      } else if (Attr.isIntAttribute()) {1026        Record.push_back(1);1027        Attribute::AttrKind Kind = Attr.getKindAsEnum();1028        Record.push_back(getAttrKindEncoding(Kind));1029        if (Kind == Attribute::Memory) {1030          // Version field for upgrading old memory effects.1031          const uint64_t Version = 1;1032          Record.push_back((Version << 56) | Attr.getValueAsInt());1033        } else {1034          Record.push_back(Attr.getValueAsInt());1035        }1036      } else if (Attr.isStringAttribute()) {1037        StringRef Kind = Attr.getKindAsString();1038        StringRef Val = Attr.getValueAsString();1039 1040        Record.push_back(Val.empty() ? 3 : 4);1041        Record.append(Kind.begin(), Kind.end());1042        Record.push_back(0);1043        if (!Val.empty()) {1044          Record.append(Val.begin(), Val.end());1045          Record.push_back(0);1046        }1047      } else if (Attr.isTypeAttribute()) {1048        Type *Ty = Attr.getValueAsType();1049        Record.push_back(Ty ? 6 : 5);1050        Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));1051        if (Ty)1052          Record.push_back(VE.getTypeID(Attr.getValueAsType()));1053      } else if (Attr.isConstantRangeAttribute()) {1054        Record.push_back(7);1055        Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));1056        emitConstantRange(Record, Attr.getValueAsConstantRange(),1057                          /*EmitBitWidth=*/true);1058      } else {1059        assert(Attr.isConstantRangeListAttribute());1060        Record.push_back(8);1061        Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));1062        ArrayRef<ConstantRange> Val = Attr.getValueAsConstantRangeList();1063        Record.push_back(Val.size());1064        Record.push_back(Val[0].getBitWidth());1065        for (auto &CR : Val)1066          emitConstantRange(Record, CR, /*EmitBitWidth=*/false);1067      }1068    }1069 1070    Stream.EmitRecord(bitc::PARAMATTR_GRP_CODE_ENTRY, Record);1071    Record.clear();1072  }1073 1074  Stream.ExitBlock();1075}1076 1077void ModuleBitcodeWriter::writeAttributeTable() {1078  const std::vector<AttributeList> &Attrs = VE.getAttributeLists();1079  if (Attrs.empty()) return;1080 1081  Stream.EnterSubblock(bitc::PARAMATTR_BLOCK_ID, 3);1082 1083  SmallVector<uint64_t, 64> Record;1084  for (const AttributeList &AL : Attrs) {1085    for (unsigned i : AL.indexes()) {1086      AttributeSet AS = AL.getAttributes(i);1087      if (AS.hasAttributes())1088        Record.push_back(VE.getAttributeGroupID({i, AS}));1089    }1090 1091    Stream.EmitRecord(bitc::PARAMATTR_CODE_ENTRY, Record);1092    Record.clear();1093  }1094 1095  Stream.ExitBlock();1096}1097 1098/// WriteTypeTable - Write out the type table for a module.1099void ModuleBitcodeWriter::writeTypeTable() {1100  const ValueEnumerator::TypeList &TypeList = VE.getTypes();1101 1102  Stream.EnterSubblock(bitc::TYPE_BLOCK_ID_NEW, 4 /*count from # abbrevs */);1103  SmallVector<uint64_t, 64> TypeVals;1104 1105  uint64_t NumBits = VE.computeBitsRequiredForTypeIndices();1106 1107  // Abbrev for TYPE_CODE_OPAQUE_POINTER.1108  auto Abbv = std::make_shared<BitCodeAbbrev>();1109  Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_OPAQUE_POINTER));1110  Abbv->Add(BitCodeAbbrevOp(0)); // Addrspace = 01111  unsigned OpaquePtrAbbrev = Stream.EmitAbbrev(std::move(Abbv));1112 1113  // Abbrev for TYPE_CODE_FUNCTION.1114  Abbv = std::make_shared<BitCodeAbbrev>();1115  Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_FUNCTION));1116  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));  // isvararg1117  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));1118  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));1119  unsigned FunctionAbbrev = Stream.EmitAbbrev(std::move(Abbv));1120 1121  // Abbrev for TYPE_CODE_STRUCT_ANON.1122  Abbv = std::make_shared<BitCodeAbbrev>();1123  Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_ANON));1124  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));  // ispacked1125  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));1126  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));1127  unsigned StructAnonAbbrev = Stream.EmitAbbrev(std::move(Abbv));1128 1129  // Abbrev for TYPE_CODE_STRUCT_NAME.1130  Abbv = std::make_shared<BitCodeAbbrev>();1131  Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_NAME));1132  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));1133  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));1134  unsigned StructNameAbbrev = Stream.EmitAbbrev(std::move(Abbv));1135 1136  // Abbrev for TYPE_CODE_STRUCT_NAMED.1137  Abbv = std::make_shared<BitCodeAbbrev>();1138  Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_NAMED));1139  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));  // ispacked1140  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));1141  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));1142  unsigned StructNamedAbbrev = Stream.EmitAbbrev(std::move(Abbv));1143 1144  // Abbrev for TYPE_CODE_ARRAY.1145  Abbv = std::make_shared<BitCodeAbbrev>();1146  Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_ARRAY));1147  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // size1148  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));1149  unsigned ArrayAbbrev = Stream.EmitAbbrev(std::move(Abbv));1150 1151  // Emit an entry count so the reader can reserve space.1152  TypeVals.push_back(TypeList.size());1153  Stream.EmitRecord(bitc::TYPE_CODE_NUMENTRY, TypeVals);1154  TypeVals.clear();1155 1156  // Loop over all of the types, emitting each in turn.1157  for (Type *T : TypeList) {1158    int AbbrevToUse = 0;1159    unsigned Code = 0;1160 1161    switch (T->getTypeID()) {1162    case Type::VoidTyID:      Code = bitc::TYPE_CODE_VOID;      break;1163    case Type::HalfTyID:      Code = bitc::TYPE_CODE_HALF;      break;1164    case Type::BFloatTyID:    Code = bitc::TYPE_CODE_BFLOAT;    break;1165    case Type::FloatTyID:     Code = bitc::TYPE_CODE_FLOAT;     break;1166    case Type::DoubleTyID:    Code = bitc::TYPE_CODE_DOUBLE;    break;1167    case Type::X86_FP80TyID:  Code = bitc::TYPE_CODE_X86_FP80;  break;1168    case Type::FP128TyID:     Code = bitc::TYPE_CODE_FP128;     break;1169    case Type::PPC_FP128TyID: Code = bitc::TYPE_CODE_PPC_FP128; break;1170    case Type::LabelTyID:     Code = bitc::TYPE_CODE_LABEL;     break;1171    case Type::MetadataTyID:1172      Code = bitc::TYPE_CODE_METADATA;1173      break;1174    case Type::X86_AMXTyID:   Code = bitc::TYPE_CODE_X86_AMX;   break;1175    case Type::TokenTyID:     Code = bitc::TYPE_CODE_TOKEN;     break;1176    case Type::IntegerTyID:1177      // INTEGER: [width]1178      Code = bitc::TYPE_CODE_INTEGER;1179      TypeVals.push_back(cast<IntegerType>(T)->getBitWidth());1180      break;1181    case Type::PointerTyID: {1182      PointerType *PTy = cast<PointerType>(T);1183      unsigned AddressSpace = PTy->getAddressSpace();1184      // OPAQUE_POINTER: [address space]1185      Code = bitc::TYPE_CODE_OPAQUE_POINTER;1186      TypeVals.push_back(AddressSpace);1187      if (AddressSpace == 0)1188        AbbrevToUse = OpaquePtrAbbrev;1189      break;1190    }1191    case Type::FunctionTyID: {1192      FunctionType *FT = cast<FunctionType>(T);1193      // FUNCTION: [isvararg, retty, paramty x N]1194      Code = bitc::TYPE_CODE_FUNCTION;1195      TypeVals.push_back(FT->isVarArg());1196      TypeVals.push_back(VE.getTypeID(FT->getReturnType()));1197      for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i)1198        TypeVals.push_back(VE.getTypeID(FT->getParamType(i)));1199      AbbrevToUse = FunctionAbbrev;1200      break;1201    }1202    case Type::StructTyID: {1203      StructType *ST = cast<StructType>(T);1204      // STRUCT: [ispacked, eltty x N]1205      TypeVals.push_back(ST->isPacked());1206      // Output all of the element types.1207      for (Type *ET : ST->elements())1208        TypeVals.push_back(VE.getTypeID(ET));1209 1210      if (ST->isLiteral()) {1211        Code = bitc::TYPE_CODE_STRUCT_ANON;1212        AbbrevToUse = StructAnonAbbrev;1213      } else {1214        if (ST->isOpaque()) {1215          Code = bitc::TYPE_CODE_OPAQUE;1216        } else {1217          Code = bitc::TYPE_CODE_STRUCT_NAMED;1218          AbbrevToUse = StructNamedAbbrev;1219        }1220 1221        // Emit the name if it is present.1222        if (!ST->getName().empty())1223          writeStringRecord(Stream, bitc::TYPE_CODE_STRUCT_NAME, ST->getName(),1224                            StructNameAbbrev);1225      }1226      break;1227    }1228    case Type::ArrayTyID: {1229      ArrayType *AT = cast<ArrayType>(T);1230      // ARRAY: [numelts, eltty]1231      Code = bitc::TYPE_CODE_ARRAY;1232      TypeVals.push_back(AT->getNumElements());1233      TypeVals.push_back(VE.getTypeID(AT->getElementType()));1234      AbbrevToUse = ArrayAbbrev;1235      break;1236    }1237    case Type::FixedVectorTyID:1238    case Type::ScalableVectorTyID: {1239      VectorType *VT = cast<VectorType>(T);1240      // VECTOR [numelts, eltty] or1241      //        [numelts, eltty, scalable]1242      Code = bitc::TYPE_CODE_VECTOR;1243      TypeVals.push_back(VT->getElementCount().getKnownMinValue());1244      TypeVals.push_back(VE.getTypeID(VT->getElementType()));1245      if (isa<ScalableVectorType>(VT))1246        TypeVals.push_back(true);1247      break;1248    }1249    case Type::TargetExtTyID: {1250      TargetExtType *TET = cast<TargetExtType>(T);1251      Code = bitc::TYPE_CODE_TARGET_TYPE;1252      writeStringRecord(Stream, bitc::TYPE_CODE_STRUCT_NAME, TET->getName(),1253                        StructNameAbbrev);1254      TypeVals.push_back(TET->getNumTypeParameters());1255      for (Type *InnerTy : TET->type_params())1256        TypeVals.push_back(VE.getTypeID(InnerTy));1257      llvm::append_range(TypeVals, TET->int_params());1258      break;1259    }1260    case Type::TypedPointerTyID:1261      llvm_unreachable("Typed pointers cannot be added to IR modules");1262    }1263 1264    // Emit the finished record.1265    Stream.EmitRecord(Code, TypeVals, AbbrevToUse);1266    TypeVals.clear();1267  }1268 1269  Stream.ExitBlock();1270}1271 1272static unsigned getEncodedLinkage(const GlobalValue::LinkageTypes Linkage) {1273  switch (Linkage) {1274  case GlobalValue::ExternalLinkage:1275    return 0;1276  case GlobalValue::WeakAnyLinkage:1277    return 16;1278  case GlobalValue::AppendingLinkage:1279    return 2;1280  case GlobalValue::InternalLinkage:1281    return 3;1282  case GlobalValue::LinkOnceAnyLinkage:1283    return 18;1284  case GlobalValue::ExternalWeakLinkage:1285    return 7;1286  case GlobalValue::CommonLinkage:1287    return 8;1288  case GlobalValue::PrivateLinkage:1289    return 9;1290  case GlobalValue::WeakODRLinkage:1291    return 17;1292  case GlobalValue::LinkOnceODRLinkage:1293    return 19;1294  case GlobalValue::AvailableExternallyLinkage:1295    return 12;1296  }1297  llvm_unreachable("Invalid linkage");1298}1299 1300static unsigned getEncodedLinkage(const GlobalValue &GV) {1301  return getEncodedLinkage(GV.getLinkage());1302}1303 1304static uint64_t getEncodedFFlags(FunctionSummary::FFlags Flags) {1305  uint64_t RawFlags = 0;1306  RawFlags |= Flags.ReadNone;1307  RawFlags |= (Flags.ReadOnly << 1);1308  RawFlags |= (Flags.NoRecurse << 2);1309  RawFlags |= (Flags.ReturnDoesNotAlias << 3);1310  RawFlags |= (Flags.NoInline << 4);1311  RawFlags |= (Flags.AlwaysInline << 5);1312  RawFlags |= (Flags.NoUnwind << 6);1313  RawFlags |= (Flags.MayThrow << 7);1314  RawFlags |= (Flags.HasUnknownCall << 8);1315  RawFlags |= (Flags.MustBeUnreachable << 9);1316  return RawFlags;1317}1318 1319// Decode the flags for GlobalValue in the summary. See getDecodedGVSummaryFlags1320// in BitcodeReader.cpp.1321static uint64_t getEncodedGVSummaryFlags(GlobalValueSummary::GVFlags Flags,1322                                         bool ImportAsDecl = false) {1323  uint64_t RawFlags = 0;1324 1325  RawFlags |= Flags.NotEligibleToImport; // bool1326  RawFlags |= (Flags.Live << 1);1327  RawFlags |= (Flags.DSOLocal << 2);1328  RawFlags |= (Flags.CanAutoHide << 3);1329 1330  // Linkage don't need to be remapped at that time for the summary. Any future1331  // change to the getEncodedLinkage() function will need to be taken into1332  // account here as well.1333  RawFlags = (RawFlags << 4) | Flags.Linkage; // 4 bits1334 1335  RawFlags |= (Flags.Visibility << 8); // 2 bits1336 1337  unsigned ImportType = Flags.ImportType | ImportAsDecl;1338  RawFlags |= (ImportType << 10); // 1 bit1339 1340  return RawFlags;1341}1342 1343static uint64_t getEncodedGVarFlags(GlobalVarSummary::GVarFlags Flags) {1344  uint64_t RawFlags = Flags.MaybeReadOnly | (Flags.MaybeWriteOnly << 1) |1345                      (Flags.Constant << 2) | Flags.VCallVisibility << 3;1346  return RawFlags;1347}1348 1349static uint64_t getEncodedHotnessCallEdgeInfo(const CalleeInfo &CI) {1350  uint64_t RawFlags = 0;1351 1352  RawFlags |= CI.Hotness;            // 3 bits1353  RawFlags |= (CI.HasTailCall << 3); // 1 bit1354 1355  return RawFlags;1356}1357 1358static uint64_t getEncodedRelBFCallEdgeInfo(const CalleeInfo &CI) {1359  uint64_t RawFlags = 0;1360 1361  RawFlags |= CI.RelBlockFreq; // CalleeInfo::RelBlockFreqBits bits1362  RawFlags |= (CI.HasTailCall << CalleeInfo::RelBlockFreqBits); // 1 bit1363 1364  return RawFlags;1365}1366 1367static unsigned getEncodedVisibility(const GlobalValue &GV) {1368  switch (GV.getVisibility()) {1369  case GlobalValue::DefaultVisibility:   return 0;1370  case GlobalValue::HiddenVisibility:    return 1;1371  case GlobalValue::ProtectedVisibility: return 2;1372  }1373  llvm_unreachable("Invalid visibility");1374}1375 1376static unsigned getEncodedDLLStorageClass(const GlobalValue &GV) {1377  switch (GV.getDLLStorageClass()) {1378  case GlobalValue::DefaultStorageClass:   return 0;1379  case GlobalValue::DLLImportStorageClass: return 1;1380  case GlobalValue::DLLExportStorageClass: return 2;1381  }1382  llvm_unreachable("Invalid DLL storage class");1383}1384 1385static unsigned getEncodedThreadLocalMode(const GlobalValue &GV) {1386  switch (GV.getThreadLocalMode()) {1387    case GlobalVariable::NotThreadLocal:         return 0;1388    case GlobalVariable::GeneralDynamicTLSModel: return 1;1389    case GlobalVariable::LocalDynamicTLSModel:   return 2;1390    case GlobalVariable::InitialExecTLSModel:    return 3;1391    case GlobalVariable::LocalExecTLSModel:      return 4;1392  }1393  llvm_unreachable("Invalid TLS model");1394}1395 1396static unsigned getEncodedComdatSelectionKind(const Comdat &C) {1397  switch (C.getSelectionKind()) {1398  case Comdat::Any:1399    return bitc::COMDAT_SELECTION_KIND_ANY;1400  case Comdat::ExactMatch:1401    return bitc::COMDAT_SELECTION_KIND_EXACT_MATCH;1402  case Comdat::Largest:1403    return bitc::COMDAT_SELECTION_KIND_LARGEST;1404  case Comdat::NoDeduplicate:1405    return bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES;1406  case Comdat::SameSize:1407    return bitc::COMDAT_SELECTION_KIND_SAME_SIZE;1408  }1409  llvm_unreachable("Invalid selection kind");1410}1411 1412static unsigned getEncodedUnnamedAddr(const GlobalValue &GV) {1413  switch (GV.getUnnamedAddr()) {1414  case GlobalValue::UnnamedAddr::None:   return 0;1415  case GlobalValue::UnnamedAddr::Local:  return 2;1416  case GlobalValue::UnnamedAddr::Global: return 1;1417  }1418  llvm_unreachable("Invalid unnamed_addr");1419}1420 1421size_t ModuleBitcodeWriter::addToStrtab(StringRef Str) {1422  if (GenerateHash)1423    Hasher.update(Str);1424  return StrtabBuilder.add(Str);1425}1426 1427void ModuleBitcodeWriter::writeComdats() {1428  SmallVector<unsigned, 64> Vals;1429  for (const Comdat *C : VE.getComdats()) {1430    // COMDAT: [strtab offset, strtab size, selection_kind]1431    Vals.push_back(addToStrtab(C->getName()));1432    Vals.push_back(C->getName().size());1433    Vals.push_back(getEncodedComdatSelectionKind(*C));1434    Stream.EmitRecord(bitc::MODULE_CODE_COMDAT, Vals, /*AbbrevToUse=*/0);1435    Vals.clear();1436  }1437}1438 1439/// Write a record that will eventually hold the word offset of the1440/// module-level VST. For now the offset is 0, which will be backpatched1441/// after the real VST is written. Saves the bit offset to backpatch.1442void ModuleBitcodeWriter::writeValueSymbolTableForwardDecl() {1443  // Write a placeholder value in for the offset of the real VST,1444  // which is written after the function blocks so that it can include1445  // the offset of each function. The placeholder offset will be1446  // updated when the real VST is written.1447  auto Abbv = std::make_shared<BitCodeAbbrev>();1448  Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_VSTOFFSET));1449  // Blocks are 32-bit aligned, so we can use a 32-bit word offset to1450  // hold the real VST offset. Must use fixed instead of VBR as we don't1451  // know how many VBR chunks to reserve ahead of time.1452  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));1453  unsigned VSTOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbv));1454 1455  // Emit the placeholder1456  uint64_t Vals[] = {bitc::MODULE_CODE_VSTOFFSET, 0};1457  Stream.EmitRecordWithAbbrev(VSTOffsetAbbrev, Vals);1458 1459  // Compute and save the bit offset to the placeholder, which will be1460  // patched when the real VST is written. We can simply subtract the 32-bit1461  // fixed size from the current bit number to get the location to backpatch.1462  VSTOffsetPlaceholder = Stream.GetCurrentBitNo() - 32;1463}1464 1465enum StringEncoding { SE_Char6, SE_Fixed7, SE_Fixed8 };1466 1467/// Determine the encoding to use for the given string name and length.1468static StringEncoding getStringEncoding(StringRef Str) {1469  bool isChar6 = true;1470  for (char C : Str) {1471    if (isChar6)1472      isChar6 = BitCodeAbbrevOp::isChar6(C);1473    if ((unsigned char)C & 128)1474      // don't bother scanning the rest.1475      return SE_Fixed8;1476  }1477  if (isChar6)1478    return SE_Char6;1479  return SE_Fixed7;1480}1481 1482static_assert(sizeof(GlobalValue::SanitizerMetadata) <= sizeof(unsigned),1483              "Sanitizer Metadata is too large for naive serialization.");1484static unsigned1485serializeSanitizerMetadata(const GlobalValue::SanitizerMetadata &Meta) {1486  return Meta.NoAddress | (Meta.NoHWAddress << 1) |1487         (Meta.Memtag << 2) | (Meta.IsDynInit << 3);1488}1489 1490/// Emit top-level description of module, including target triple, inline asm,1491/// descriptors for global variables, and function prototype info.1492/// Returns the bit offset to backpatch with the location of the real VST.1493void ModuleBitcodeWriter::writeModuleInfo() {1494  // Emit various pieces of data attached to a module.1495  if (!M.getTargetTriple().empty())1496    writeStringRecord(Stream, bitc::MODULE_CODE_TRIPLE,1497                      M.getTargetTriple().str(), 0 /*TODO*/);1498  const std::string &DL = M.getDataLayoutStr();1499  if (!DL.empty())1500    writeStringRecord(Stream, bitc::MODULE_CODE_DATALAYOUT, DL, 0 /*TODO*/);1501  if (!M.getModuleInlineAsm().empty())1502    writeStringRecord(Stream, bitc::MODULE_CODE_ASM, M.getModuleInlineAsm(),1503                      0 /*TODO*/);1504 1505  // Emit information about sections and GC, computing how many there are. Also1506  // compute the maximum alignment value.1507  std::map<std::string, unsigned> SectionMap;1508  std::map<std::string, unsigned> GCMap;1509  MaybeAlign MaxGVarAlignment;1510  unsigned MaxGlobalType = 0;1511  for (const GlobalVariable &GV : M.globals()) {1512    if (MaybeAlign A = GV.getAlign())1513      MaxGVarAlignment = !MaxGVarAlignment ? *A : std::max(*MaxGVarAlignment, *A);1514    MaxGlobalType = std::max(MaxGlobalType, VE.getTypeID(GV.getValueType()));1515    if (GV.hasSection()) {1516      // Give section names unique ID's.1517      unsigned &Entry = SectionMap[std::string(GV.getSection())];1518      if (!Entry) {1519        writeStringRecord(Stream, bitc::MODULE_CODE_SECTIONNAME, GV.getSection(),1520                          0 /*TODO*/);1521        Entry = SectionMap.size();1522      }1523    }1524  }1525  for (const Function &F : M) {1526    if (F.hasSection()) {1527      // Give section names unique ID's.1528      unsigned &Entry = SectionMap[std::string(F.getSection())];1529      if (!Entry) {1530        writeStringRecord(Stream, bitc::MODULE_CODE_SECTIONNAME, F.getSection(),1531                          0 /*TODO*/);1532        Entry = SectionMap.size();1533      }1534    }1535    if (F.hasGC()) {1536      // Same for GC names.1537      unsigned &Entry = GCMap[F.getGC()];1538      if (!Entry) {1539        writeStringRecord(Stream, bitc::MODULE_CODE_GCNAME, F.getGC(),1540                          0 /*TODO*/);1541        Entry = GCMap.size();1542      }1543    }1544  }1545 1546  // Emit abbrev for globals, now that we know # sections and max alignment.1547  unsigned SimpleGVarAbbrev = 0;1548  if (!M.global_empty()) {1549    // Add an abbrev for common globals with no visibility or thread localness.1550    auto Abbv = std::make_shared<BitCodeAbbrev>();1551    Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_GLOBALVAR));1552    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));1553    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));1554    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,1555                              Log2_32_Ceil(MaxGlobalType+1)));1556    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // AddrSpace << 21557                                                           //| explicitType << 11558                                                           //| constant1559    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Initializer.1560    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // Linkage.1561    if (!MaxGVarAlignment)                                 // Alignment.1562      Abbv->Add(BitCodeAbbrevOp(0));1563    else {1564      unsigned MaxEncAlignment = getEncodedAlign(MaxGVarAlignment);1565      Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,1566                               Log2_32_Ceil(MaxEncAlignment+1)));1567    }1568    if (SectionMap.empty())                                    // Section.1569      Abbv->Add(BitCodeAbbrevOp(0));1570    else1571      Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,1572                               Log2_32_Ceil(SectionMap.size()+1)));1573    // Don't bother emitting vis + thread local.1574    SimpleGVarAbbrev = Stream.EmitAbbrev(std::move(Abbv));1575  }1576 1577  SmallVector<unsigned, 64> Vals;1578  // Emit the module's source file name.1579  {1580    StringEncoding Bits = getStringEncoding(M.getSourceFileName());1581    BitCodeAbbrevOp AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8);1582    if (Bits == SE_Char6)1583      AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Char6);1584    else if (Bits == SE_Fixed7)1585      AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7);1586 1587    // MODULE_CODE_SOURCE_FILENAME: [namechar x N]1588    auto Abbv = std::make_shared<BitCodeAbbrev>();1589    Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_SOURCE_FILENAME));1590    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));1591    Abbv->Add(AbbrevOpToUse);1592    unsigned FilenameAbbrev = Stream.EmitAbbrev(std::move(Abbv));1593 1594    for (const auto P : M.getSourceFileName())1595      Vals.push_back((unsigned char)P);1596 1597    // Emit the finished record.1598    Stream.EmitRecord(bitc::MODULE_CODE_SOURCE_FILENAME, Vals, FilenameAbbrev);1599    Vals.clear();1600  }1601 1602  // Emit the global variable information.1603  for (const GlobalVariable &GV : M.globals()) {1604    unsigned AbbrevToUse = 0;1605 1606    // GLOBALVAR: [strtab offset, strtab size, type, isconst, initid,1607    //             linkage, alignment, section, visibility, threadlocal,1608    //             unnamed_addr, externally_initialized, dllstorageclass,1609    //             comdat, attributes, DSO_Local, GlobalSanitizer, code_model]1610    Vals.push_back(addToStrtab(GV.getName()));1611    Vals.push_back(GV.getName().size());1612    Vals.push_back(VE.getTypeID(GV.getValueType()));1613    Vals.push_back(GV.getType()->getAddressSpace() << 2 | 2 | GV.isConstant());1614    Vals.push_back(GV.isDeclaration() ? 0 :1615                   (VE.getValueID(GV.getInitializer()) + 1));1616    Vals.push_back(getEncodedLinkage(GV));1617    Vals.push_back(getEncodedAlign(GV.getAlign()));1618    Vals.push_back(GV.hasSection() ? SectionMap[std::string(GV.getSection())]1619                                   : 0);1620    if (GV.isThreadLocal() ||1621        GV.getVisibility() != GlobalValue::DefaultVisibility ||1622        GV.getUnnamedAddr() != GlobalValue::UnnamedAddr::None ||1623        GV.isExternallyInitialized() ||1624        GV.getDLLStorageClass() != GlobalValue::DefaultStorageClass ||1625        GV.hasComdat() || GV.hasAttributes() || GV.isDSOLocal() ||1626        GV.hasPartition() || GV.hasSanitizerMetadata() || GV.getCodeModel()) {1627      Vals.push_back(getEncodedVisibility(GV));1628      Vals.push_back(getEncodedThreadLocalMode(GV));1629      Vals.push_back(getEncodedUnnamedAddr(GV));1630      Vals.push_back(GV.isExternallyInitialized());1631      Vals.push_back(getEncodedDLLStorageClass(GV));1632      Vals.push_back(GV.hasComdat() ? VE.getComdatID(GV.getComdat()) : 0);1633 1634      auto AL = GV.getAttributesAsList(AttributeList::FunctionIndex);1635      Vals.push_back(VE.getAttributeListID(AL));1636 1637      Vals.push_back(GV.isDSOLocal());1638      Vals.push_back(addToStrtab(GV.getPartition()));1639      Vals.push_back(GV.getPartition().size());1640 1641      Vals.push_back((GV.hasSanitizerMetadata() ? serializeSanitizerMetadata(1642                                                      GV.getSanitizerMetadata())1643                                                : 0));1644      Vals.push_back(GV.getCodeModelRaw());1645    } else {1646      AbbrevToUse = SimpleGVarAbbrev;1647    }1648 1649    Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse);1650    Vals.clear();1651  }1652 1653  // Emit the function proto information.1654  for (const Function &F : M) {1655    // FUNCTION:  [strtab offset, strtab size, type, callingconv, isproto,1656    //             linkage, paramattrs, alignment, section, visibility, gc,1657    //             unnamed_addr, prologuedata, dllstorageclass, comdat,1658    //             prefixdata, personalityfn, DSO_Local, addrspace]1659    Vals.push_back(addToStrtab(F.getName()));1660    Vals.push_back(F.getName().size());1661    Vals.push_back(VE.getTypeID(F.getFunctionType()));1662    Vals.push_back(F.getCallingConv());1663    Vals.push_back(F.isDeclaration());1664    Vals.push_back(getEncodedLinkage(F));1665    Vals.push_back(VE.getAttributeListID(F.getAttributes()));1666    Vals.push_back(getEncodedAlign(F.getAlign()));1667    Vals.push_back(F.hasSection() ? SectionMap[std::string(F.getSection())]1668                                  : 0);1669    Vals.push_back(getEncodedVisibility(F));1670    Vals.push_back(F.hasGC() ? GCMap[F.getGC()] : 0);1671    Vals.push_back(getEncodedUnnamedAddr(F));1672    Vals.push_back(F.hasPrologueData() ? (VE.getValueID(F.getPrologueData()) + 1)1673                                       : 0);1674    Vals.push_back(getEncodedDLLStorageClass(F));1675    Vals.push_back(F.hasComdat() ? VE.getComdatID(F.getComdat()) : 0);1676    Vals.push_back(F.hasPrefixData() ? (VE.getValueID(F.getPrefixData()) + 1)1677                                     : 0);1678    Vals.push_back(1679        F.hasPersonalityFn() ? (VE.getValueID(F.getPersonalityFn()) + 1) : 0);1680 1681    Vals.push_back(F.isDSOLocal());1682    Vals.push_back(F.getAddressSpace());1683    Vals.push_back(addToStrtab(F.getPartition()));1684    Vals.push_back(F.getPartition().size());1685 1686    unsigned AbbrevToUse = 0;1687    Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse);1688    Vals.clear();1689  }1690 1691  // Emit the alias information.1692  for (const GlobalAlias &A : M.aliases()) {1693    // ALIAS: [strtab offset, strtab size, alias type, aliasee val#, linkage,1694    //         visibility, dllstorageclass, threadlocal, unnamed_addr,1695    //         DSO_Local]1696    Vals.push_back(addToStrtab(A.getName()));1697    Vals.push_back(A.getName().size());1698    Vals.push_back(VE.getTypeID(A.getValueType()));1699    Vals.push_back(A.getType()->getAddressSpace());1700    Vals.push_back(VE.getValueID(A.getAliasee()));1701    Vals.push_back(getEncodedLinkage(A));1702    Vals.push_back(getEncodedVisibility(A));1703    Vals.push_back(getEncodedDLLStorageClass(A));1704    Vals.push_back(getEncodedThreadLocalMode(A));1705    Vals.push_back(getEncodedUnnamedAddr(A));1706    Vals.push_back(A.isDSOLocal());1707    Vals.push_back(addToStrtab(A.getPartition()));1708    Vals.push_back(A.getPartition().size());1709 1710    unsigned AbbrevToUse = 0;1711    Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals, AbbrevToUse);1712    Vals.clear();1713  }1714 1715  // Emit the ifunc information.1716  for (const GlobalIFunc &I : M.ifuncs()) {1717    // IFUNC: [strtab offset, strtab size, ifunc type, address space, resolver1718    //         val#, linkage, visibility, DSO_Local]1719    Vals.push_back(addToStrtab(I.getName()));1720    Vals.push_back(I.getName().size());1721    Vals.push_back(VE.getTypeID(I.getValueType()));1722    Vals.push_back(I.getType()->getAddressSpace());1723    Vals.push_back(VE.getValueID(I.getResolver()));1724    Vals.push_back(getEncodedLinkage(I));1725    Vals.push_back(getEncodedVisibility(I));1726    Vals.push_back(I.isDSOLocal());1727    Vals.push_back(addToStrtab(I.getPartition()));1728    Vals.push_back(I.getPartition().size());1729    Stream.EmitRecord(bitc::MODULE_CODE_IFUNC, Vals);1730    Vals.clear();1731  }1732 1733  writeValueSymbolTableForwardDecl();1734}1735 1736static uint64_t getOptimizationFlags(const Value *V) {1737  uint64_t Flags = 0;1738 1739  if (const auto *OBO = dyn_cast<OverflowingBinaryOperator>(V)) {1740    if (OBO->hasNoSignedWrap())1741      Flags |= 1 << bitc::OBO_NO_SIGNED_WRAP;1742    if (OBO->hasNoUnsignedWrap())1743      Flags |= 1 << bitc::OBO_NO_UNSIGNED_WRAP;1744  } else if (const auto *PEO = dyn_cast<PossiblyExactOperator>(V)) {1745    if (PEO->isExact())1746      Flags |= 1 << bitc::PEO_EXACT;1747  } else if (const auto *PDI = dyn_cast<PossiblyDisjointInst>(V)) {1748    if (PDI->isDisjoint())1749      Flags |= 1 << bitc::PDI_DISJOINT;1750  } else if (const auto *FPMO = dyn_cast<FPMathOperator>(V)) {1751    if (FPMO->hasAllowReassoc())1752      Flags |= bitc::AllowReassoc;1753    if (FPMO->hasNoNaNs())1754      Flags |= bitc::NoNaNs;1755    if (FPMO->hasNoInfs())1756      Flags |= bitc::NoInfs;1757    if (FPMO->hasNoSignedZeros())1758      Flags |= bitc::NoSignedZeros;1759    if (FPMO->hasAllowReciprocal())1760      Flags |= bitc::AllowReciprocal;1761    if (FPMO->hasAllowContract())1762      Flags |= bitc::AllowContract;1763    if (FPMO->hasApproxFunc())1764      Flags |= bitc::ApproxFunc;1765  } else if (const auto *NNI = dyn_cast<PossiblyNonNegInst>(V)) {1766    if (NNI->hasNonNeg())1767      Flags |= 1 << bitc::PNNI_NON_NEG;1768  } else if (const auto *TI = dyn_cast<TruncInst>(V)) {1769    if (TI->hasNoSignedWrap())1770      Flags |= 1 << bitc::TIO_NO_SIGNED_WRAP;1771    if (TI->hasNoUnsignedWrap())1772      Flags |= 1 << bitc::TIO_NO_UNSIGNED_WRAP;1773  } else if (const auto *GEP = dyn_cast<GEPOperator>(V)) {1774    if (GEP->isInBounds())1775      Flags |= 1 << bitc::GEP_INBOUNDS;1776    if (GEP->hasNoUnsignedSignedWrap())1777      Flags |= 1 << bitc::GEP_NUSW;1778    if (GEP->hasNoUnsignedWrap())1779      Flags |= 1 << bitc::GEP_NUW;1780  } else if (const auto *ICmp = dyn_cast<ICmpInst>(V)) {1781    if (ICmp->hasSameSign())1782      Flags |= 1 << bitc::ICMP_SAME_SIGN;1783  }1784 1785  return Flags;1786}1787 1788void ModuleBitcodeWriter::writeValueAsMetadata(1789    const ValueAsMetadata *MD, SmallVectorImpl<uint64_t> &Record) {1790  // Mimic an MDNode with a value as one operand.1791  Value *V = MD->getValue();1792  Record.push_back(VE.getTypeID(V->getType()));1793  Record.push_back(VE.getValueID(V));1794  Stream.EmitRecord(bitc::METADATA_VALUE, Record, 0);1795  Record.clear();1796}1797 1798void ModuleBitcodeWriter::writeMDTuple(const MDTuple *N,1799                                       SmallVectorImpl<uint64_t> &Record,1800                                       unsigned Abbrev) {1801  for (const MDOperand &MDO : N->operands()) {1802    Metadata *MD = MDO;1803    assert(!(MD && isa<LocalAsMetadata>(MD)) &&1804           "Unexpected function-local metadata");1805    Record.push_back(VE.getMetadataOrNullID(MD));1806  }1807  Stream.EmitRecord(N->isDistinct() ? bitc::METADATA_DISTINCT_NODE1808                                    : bitc::METADATA_NODE,1809                    Record, Abbrev);1810  Record.clear();1811}1812 1813unsigned ModuleBitcodeWriter::createDILocationAbbrev() {1814  // Assume the column is usually under 128, and always output the inlined-at1815  // location (it's never more expensive than building an array size 1).1816  auto Abbv = std::make_shared<BitCodeAbbrev>();1817  Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_LOCATION));1818  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isDistinct1819  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // line1820  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // column1821  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // scope1822  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // inlinedAt1823  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isImplicitCode1824  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // atomGroup1825  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // atomRank1826  return Stream.EmitAbbrev(std::move(Abbv));1827}1828 1829void ModuleBitcodeWriter::writeDILocation(const DILocation *N,1830                                          SmallVectorImpl<uint64_t> &Record,1831                                          unsigned &Abbrev) {1832  if (!Abbrev)1833    Abbrev = createDILocationAbbrev();1834 1835  Record.push_back(N->isDistinct());1836  Record.push_back(N->getLine());1837  Record.push_back(N->getColumn());1838  Record.push_back(VE.getMetadataID(N->getScope()));1839  Record.push_back(VE.getMetadataOrNullID(N->getInlinedAt()));1840  Record.push_back(N->isImplicitCode());1841  Record.push_back(N->getAtomGroup());1842  Record.push_back(N->getAtomRank());1843  Stream.EmitRecord(bitc::METADATA_LOCATION, Record, Abbrev);1844  Record.clear();1845}1846 1847unsigned ModuleBitcodeWriter::createGenericDINodeAbbrev() {1848  // Assume the column is usually under 128, and always output the inlined-at1849  // location (it's never more expensive than building an array size 1).1850  auto Abbv = std::make_shared<BitCodeAbbrev>();1851  Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_GENERIC_DEBUG));1852  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));1853  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));1854  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));1855  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));1856  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));1857  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));1858  return Stream.EmitAbbrev(std::move(Abbv));1859}1860 1861void ModuleBitcodeWriter::writeGenericDINode(const GenericDINode *N,1862                                             SmallVectorImpl<uint64_t> &Record,1863                                             unsigned &Abbrev) {1864  if (!Abbrev)1865    Abbrev = createGenericDINodeAbbrev();1866 1867  Record.push_back(N->isDistinct());1868  Record.push_back(N->getTag());1869  Record.push_back(0); // Per-tag version field; unused for now.1870 1871  for (auto &I : N->operands())1872    Record.push_back(VE.getMetadataOrNullID(I));1873 1874  Stream.EmitRecord(bitc::METADATA_GENERIC_DEBUG, Record, Abbrev);1875  Record.clear();1876}1877 1878void ModuleBitcodeWriter::writeDISubrange(const DISubrange *N,1879                                          SmallVectorImpl<uint64_t> &Record,1880                                          unsigned Abbrev) {1881  const uint64_t Version = 2 << 1;1882  Record.push_back((uint64_t)N->isDistinct() | Version);1883  Record.push_back(VE.getMetadataOrNullID(N->getRawCountNode()));1884  Record.push_back(VE.getMetadataOrNullID(N->getRawLowerBound()));1885  Record.push_back(VE.getMetadataOrNullID(N->getRawUpperBound()));1886  Record.push_back(VE.getMetadataOrNullID(N->getRawStride()));1887 1888  Stream.EmitRecord(bitc::METADATA_SUBRANGE, Record, Abbrev);1889  Record.clear();1890}1891 1892void ModuleBitcodeWriter::writeDIGenericSubrange(1893    const DIGenericSubrange *N, SmallVectorImpl<uint64_t> &Record,1894    unsigned Abbrev) {1895  Record.push_back((uint64_t)N->isDistinct());1896  Record.push_back(VE.getMetadataOrNullID(N->getRawCountNode()));1897  Record.push_back(VE.getMetadataOrNullID(N->getRawLowerBound()));1898  Record.push_back(VE.getMetadataOrNullID(N->getRawUpperBound()));1899  Record.push_back(VE.getMetadataOrNullID(N->getRawStride()));1900 1901  Stream.EmitRecord(bitc::METADATA_GENERIC_SUBRANGE, Record, Abbrev);1902  Record.clear();1903}1904 1905void ModuleBitcodeWriter::writeDIEnumerator(const DIEnumerator *N,1906                                            SmallVectorImpl<uint64_t> &Record,1907                                            unsigned Abbrev) {1908  const uint64_t IsBigInt = 1 << 2;1909  Record.push_back(IsBigInt | (N->isUnsigned() << 1) | N->isDistinct());1910  Record.push_back(N->getValue().getBitWidth());1911  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));1912  emitWideAPInt(Record, N->getValue());1913 1914  Stream.EmitRecord(bitc::METADATA_ENUMERATOR, Record, Abbrev);1915  Record.clear();1916}1917 1918void ModuleBitcodeWriter::writeDIBasicType(const DIBasicType *N,1919                                           SmallVectorImpl<uint64_t> &Record,1920                                           unsigned Abbrev) {1921  const unsigned SizeIsMetadata = 0x2;1922  Record.push_back(SizeIsMetadata | (unsigned)N->isDistinct());1923  Record.push_back(N->getTag());1924  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));1925  Record.push_back(VE.getMetadataOrNullID(N->getRawSizeInBits()));1926  Record.push_back(N->getAlignInBits());1927  Record.push_back(N->getEncoding());1928  Record.push_back(N->getFlags());1929  Record.push_back(N->getNumExtraInhabitants());1930  Record.push_back(N->getDataSizeInBits());1931 1932  Stream.EmitRecord(bitc::METADATA_BASIC_TYPE, Record, Abbrev);1933  Record.clear();1934}1935 1936void ModuleBitcodeWriter::writeDIFixedPointType(1937    const DIFixedPointType *N, SmallVectorImpl<uint64_t> &Record,1938    unsigned Abbrev) {1939  const unsigned SizeIsMetadata = 0x2;1940  Record.push_back(SizeIsMetadata | (unsigned)N->isDistinct());1941  Record.push_back(N->getTag());1942  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));1943  Record.push_back(VE.getMetadataOrNullID(N->getRawSizeInBits()));1944  Record.push_back(N->getAlignInBits());1945  Record.push_back(N->getEncoding());1946  Record.push_back(N->getFlags());1947  Record.push_back(N->getKind());1948  Record.push_back(N->getFactorRaw());1949 1950  auto WriteWideInt = [&](const APInt &Value) {1951    // Write an encoded word that holds the number of active words and1952    // the number of bits.1953    uint64_t NumWords = Value.getActiveWords();1954    uint64_t Encoded = (NumWords << 32) | Value.getBitWidth();1955    Record.push_back(Encoded);1956    emitWideAPInt(Record, Value);1957  };1958 1959  WriteWideInt(N->getNumeratorRaw());1960  WriteWideInt(N->getDenominatorRaw());1961 1962  Stream.EmitRecord(bitc::METADATA_FIXED_POINT_TYPE, Record, Abbrev);1963  Record.clear();1964}1965 1966void ModuleBitcodeWriter::writeDIStringType(const DIStringType *N,1967                                            SmallVectorImpl<uint64_t> &Record,1968                                            unsigned Abbrev) {1969  const unsigned SizeIsMetadata = 0x2;1970  Record.push_back(SizeIsMetadata | (unsigned)N->isDistinct());1971  Record.push_back(N->getTag());1972  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));1973  Record.push_back(VE.getMetadataOrNullID(N->getStringLength()));1974  Record.push_back(VE.getMetadataOrNullID(N->getStringLengthExp()));1975  Record.push_back(VE.getMetadataOrNullID(N->getStringLocationExp()));1976  Record.push_back(VE.getMetadataOrNullID(N->getRawSizeInBits()));1977  Record.push_back(N->getAlignInBits());1978  Record.push_back(N->getEncoding());1979 1980  Stream.EmitRecord(bitc::METADATA_STRING_TYPE, Record, Abbrev);1981  Record.clear();1982}1983 1984void ModuleBitcodeWriter::writeDIDerivedType(const DIDerivedType *N,1985                                             SmallVectorImpl<uint64_t> &Record,1986                                             unsigned Abbrev) {1987  const unsigned SizeIsMetadata = 0x2;1988  Record.push_back(SizeIsMetadata | (unsigned)N->isDistinct());1989  Record.push_back(N->getTag());1990  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));1991  Record.push_back(VE.getMetadataOrNullID(N->getFile()));1992  Record.push_back(N->getLine());1993  Record.push_back(VE.getMetadataOrNullID(N->getScope()));1994  Record.push_back(VE.getMetadataOrNullID(N->getBaseType()));1995  Record.push_back(VE.getMetadataOrNullID(N->getRawSizeInBits()));1996  Record.push_back(N->getAlignInBits());1997  Record.push_back(VE.getMetadataOrNullID(N->getRawOffsetInBits()));1998  Record.push_back(N->getFlags());1999  Record.push_back(VE.getMetadataOrNullID(N->getExtraData()));2000 2001  // DWARF address space is encoded as N->getDWARFAddressSpace() + 1. 0 means2002  // that there is no DWARF address space associated with DIDerivedType.2003  if (const auto &DWARFAddressSpace = N->getDWARFAddressSpace())2004    Record.push_back(*DWARFAddressSpace + 1);2005  else2006    Record.push_back(0);2007 2008  Record.push_back(VE.getMetadataOrNullID(N->getAnnotations().get()));2009 2010  if (auto PtrAuthData = N->getPtrAuthData())2011    Record.push_back(PtrAuthData->RawData);2012  else2013    Record.push_back(0);2014 2015  Stream.EmitRecord(bitc::METADATA_DERIVED_TYPE, Record, Abbrev);2016  Record.clear();2017}2018 2019void ModuleBitcodeWriter::writeDISubrangeType(const DISubrangeType *N,2020                                              SmallVectorImpl<uint64_t> &Record,2021                                              unsigned Abbrev) {2022  const unsigned SizeIsMetadata = 0x2;2023  Record.push_back(SizeIsMetadata | (unsigned)N->isDistinct());2024  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));2025  Record.push_back(VE.getMetadataOrNullID(N->getFile()));2026  Record.push_back(N->getLine());2027  Record.push_back(VE.getMetadataOrNullID(N->getScope()));2028  Record.push_back(VE.getMetadataOrNullID(N->getRawSizeInBits()));2029  Record.push_back(N->getAlignInBits());2030  Record.push_back(N->getFlags());2031  Record.push_back(VE.getMetadataOrNullID(N->getBaseType()));2032  Record.push_back(VE.getMetadataOrNullID(N->getRawLowerBound()));2033  Record.push_back(VE.getMetadataOrNullID(N->getRawUpperBound()));2034  Record.push_back(VE.getMetadataOrNullID(N->getRawStride()));2035  Record.push_back(VE.getMetadataOrNullID(N->getRawBias()));2036 2037  Stream.EmitRecord(bitc::METADATA_SUBRANGE_TYPE, Record, Abbrev);2038  Record.clear();2039}2040 2041void ModuleBitcodeWriter::writeDICompositeType(2042    const DICompositeType *N, SmallVectorImpl<uint64_t> &Record,2043    unsigned Abbrev) {2044  const unsigned IsNotUsedInOldTypeRef = 0x2;2045  const unsigned SizeIsMetadata = 0x4;2046  Record.push_back(SizeIsMetadata | IsNotUsedInOldTypeRef |2047                   (unsigned)N->isDistinct());2048  Record.push_back(N->getTag());2049  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));2050  Record.push_back(VE.getMetadataOrNullID(N->getFile()));2051  Record.push_back(N->getLine());2052  Record.push_back(VE.getMetadataOrNullID(N->getScope()));2053  Record.push_back(VE.getMetadataOrNullID(N->getBaseType()));2054  Record.push_back(VE.getMetadataOrNullID(N->getRawSizeInBits()));2055  Record.push_back(N->getAlignInBits());2056  Record.push_back(VE.getMetadataOrNullID(N->getRawOffsetInBits()));2057  Record.push_back(N->getFlags());2058  Record.push_back(VE.getMetadataOrNullID(N->getElements().get()));2059  Record.push_back(N->getRuntimeLang());2060  Record.push_back(VE.getMetadataOrNullID(N->getVTableHolder()));2061  Record.push_back(VE.getMetadataOrNullID(N->getTemplateParams().get()));2062  Record.push_back(VE.getMetadataOrNullID(N->getRawIdentifier()));2063  Record.push_back(VE.getMetadataOrNullID(N->getDiscriminator()));2064  Record.push_back(VE.getMetadataOrNullID(N->getRawDataLocation()));2065  Record.push_back(VE.getMetadataOrNullID(N->getRawAssociated()));2066  Record.push_back(VE.getMetadataOrNullID(N->getRawAllocated()));2067  Record.push_back(VE.getMetadataOrNullID(N->getRawRank()));2068  Record.push_back(VE.getMetadataOrNullID(N->getAnnotations().get()));2069  Record.push_back(N->getNumExtraInhabitants());2070  Record.push_back(VE.getMetadataOrNullID(N->getRawSpecification()));2071  Record.push_back(2072      N->getEnumKind().value_or(dwarf::DW_APPLE_ENUM_KIND_invalid));2073  Record.push_back(VE.getMetadataOrNullID(N->getRawBitStride()));2074 2075  Stream.EmitRecord(bitc::METADATA_COMPOSITE_TYPE, Record, Abbrev);2076  Record.clear();2077}2078 2079void ModuleBitcodeWriter::writeDISubroutineType(2080    const DISubroutineType *N, SmallVectorImpl<uint64_t> &Record,2081    unsigned Abbrev) {2082  const unsigned HasNoOldTypeRefs = 0x2;2083  Record.push_back(HasNoOldTypeRefs | (unsigned)N->isDistinct());2084  Record.push_back(N->getFlags());2085  Record.push_back(VE.getMetadataOrNullID(N->getTypeArray().get()));2086  Record.push_back(N->getCC());2087 2088  Stream.EmitRecord(bitc::METADATA_SUBROUTINE_TYPE, Record, Abbrev);2089  Record.clear();2090}2091 2092void ModuleBitcodeWriter::writeDIFile(const DIFile *N,2093                                      SmallVectorImpl<uint64_t> &Record,2094                                      unsigned Abbrev) {2095  Record.push_back(N->isDistinct());2096  Record.push_back(VE.getMetadataOrNullID(N->getRawFilename()));2097  Record.push_back(VE.getMetadataOrNullID(N->getRawDirectory()));2098  if (N->getRawChecksum()) {2099    Record.push_back(N->getRawChecksum()->Kind);2100    Record.push_back(VE.getMetadataOrNullID(N->getRawChecksum()->Value));2101  } else {2102    // Maintain backwards compatibility with the old internal representation of2103    // CSK_None in ChecksumKind by writing nulls here when Checksum is None.2104    Record.push_back(0);2105    Record.push_back(VE.getMetadataOrNullID(nullptr));2106  }2107  auto Source = N->getRawSource();2108  if (Source)2109    Record.push_back(VE.getMetadataOrNullID(Source));2110 2111  Stream.EmitRecord(bitc::METADATA_FILE, Record, Abbrev);2112  Record.clear();2113}2114 2115void ModuleBitcodeWriter::writeDICompileUnit(const DICompileUnit *N,2116                                             SmallVectorImpl<uint64_t> &Record,2117                                             unsigned Abbrev) {2118  assert(N->isDistinct() && "Expected distinct compile units");2119  Record.push_back(/* IsDistinct */ true);2120 2121  auto Lang = N->getSourceLanguage();2122  Record.push_back(Lang.getName());2123  // Set bit so the MetadataLoader can distniguish between versioned and2124  // unversioned names.2125  if (Lang.hasVersionedName())2126    Record.back() ^= (uint64_t(1) << 63);2127 2128  Record.push_back(VE.getMetadataOrNullID(N->getFile()));2129  Record.push_back(VE.getMetadataOrNullID(N->getRawProducer()));2130  Record.push_back(N->isOptimized());2131  Record.push_back(VE.getMetadataOrNullID(N->getRawFlags()));2132  Record.push_back(N->getRuntimeVersion());2133  Record.push_back(VE.getMetadataOrNullID(N->getRawSplitDebugFilename()));2134  Record.push_back(N->getEmissionKind());2135  Record.push_back(VE.getMetadataOrNullID(N->getEnumTypes().get()));2136  Record.push_back(VE.getMetadataOrNullID(N->getRetainedTypes().get()));2137  Record.push_back(/* subprograms */ 0);2138  Record.push_back(VE.getMetadataOrNullID(N->getGlobalVariables().get()));2139  Record.push_back(VE.getMetadataOrNullID(N->getImportedEntities().get()));2140  Record.push_back(N->getDWOId());2141  Record.push_back(VE.getMetadataOrNullID(N->getMacros().get()));2142  Record.push_back(N->getSplitDebugInlining());2143  Record.push_back(N->getDebugInfoForProfiling());2144  Record.push_back((unsigned)N->getNameTableKind());2145  Record.push_back(N->getRangesBaseAddress());2146  Record.push_back(VE.getMetadataOrNullID(N->getRawSysRoot()));2147  Record.push_back(VE.getMetadataOrNullID(N->getRawSDK()));2148  Record.push_back(Lang.hasVersionedName() ? Lang.getVersion() : 0);2149 2150  Stream.EmitRecord(bitc::METADATA_COMPILE_UNIT, Record, Abbrev);2151  Record.clear();2152}2153 2154void ModuleBitcodeWriter::writeDISubprogram(const DISubprogram *N,2155                                            SmallVectorImpl<uint64_t> &Record,2156                                            unsigned Abbrev) {2157  const uint64_t HasUnitFlag = 1 << 1;2158  const uint64_t HasSPFlagsFlag = 1 << 2;2159  Record.push_back(uint64_t(N->isDistinct()) | HasUnitFlag | HasSPFlagsFlag);2160  Record.push_back(VE.getMetadataOrNullID(N->getScope()));2161  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));2162  Record.push_back(VE.getMetadataOrNullID(N->getRawLinkageName()));2163  Record.push_back(VE.getMetadataOrNullID(N->getFile()));2164  Record.push_back(N->getLine());2165  Record.push_back(VE.getMetadataOrNullID(N->getType()));2166  Record.push_back(N->getScopeLine());2167  Record.push_back(VE.getMetadataOrNullID(N->getContainingType()));2168  Record.push_back(N->getSPFlags());2169  Record.push_back(N->getVirtualIndex());2170  Record.push_back(N->getFlags());2171  Record.push_back(VE.getMetadataOrNullID(N->getRawUnit()));2172  Record.push_back(VE.getMetadataOrNullID(N->getTemplateParams().get()));2173  Record.push_back(VE.getMetadataOrNullID(N->getDeclaration()));2174  Record.push_back(VE.getMetadataOrNullID(N->getRetainedNodes().get()));2175  Record.push_back(N->getThisAdjustment());2176  Record.push_back(VE.getMetadataOrNullID(N->getThrownTypes().get()));2177  Record.push_back(VE.getMetadataOrNullID(N->getAnnotations().get()));2178  Record.push_back(VE.getMetadataOrNullID(N->getRawTargetFuncName()));2179  Record.push_back(N->getKeyInstructionsEnabled());2180 2181  Stream.EmitRecord(bitc::METADATA_SUBPROGRAM, Record, Abbrev);2182  Record.clear();2183}2184 2185void ModuleBitcodeWriter::writeDILexicalBlock(const DILexicalBlock *N,2186                                              SmallVectorImpl<uint64_t> &Record,2187                                              unsigned Abbrev) {2188  Record.push_back(N->isDistinct());2189  Record.push_back(VE.getMetadataOrNullID(N->getScope()));2190  Record.push_back(VE.getMetadataOrNullID(N->getFile()));2191  Record.push_back(N->getLine());2192  Record.push_back(N->getColumn());2193 2194  Stream.EmitRecord(bitc::METADATA_LEXICAL_BLOCK, Record, Abbrev);2195  Record.clear();2196}2197 2198void ModuleBitcodeWriter::writeDILexicalBlockFile(2199    const DILexicalBlockFile *N, SmallVectorImpl<uint64_t> &Record,2200    unsigned Abbrev) {2201  Record.push_back(N->isDistinct());2202  Record.push_back(VE.getMetadataOrNullID(N->getScope()));2203  Record.push_back(VE.getMetadataOrNullID(N->getFile()));2204  Record.push_back(N->getDiscriminator());2205 2206  Stream.EmitRecord(bitc::METADATA_LEXICAL_BLOCK_FILE, Record, Abbrev);2207  Record.clear();2208}2209 2210void ModuleBitcodeWriter::writeDICommonBlock(const DICommonBlock *N,2211                                             SmallVectorImpl<uint64_t> &Record,2212                                             unsigned Abbrev) {2213  Record.push_back(N->isDistinct());2214  Record.push_back(VE.getMetadataOrNullID(N->getScope()));2215  Record.push_back(VE.getMetadataOrNullID(N->getDecl()));2216  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));2217  Record.push_back(VE.getMetadataOrNullID(N->getFile()));2218  Record.push_back(N->getLineNo());2219 2220  Stream.EmitRecord(bitc::METADATA_COMMON_BLOCK, Record, Abbrev);2221  Record.clear();2222}2223 2224void ModuleBitcodeWriter::writeDINamespace(const DINamespace *N,2225                                           SmallVectorImpl<uint64_t> &Record,2226                                           unsigned Abbrev) {2227  Record.push_back(N->isDistinct() | N->getExportSymbols() << 1);2228  Record.push_back(VE.getMetadataOrNullID(N->getScope()));2229  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));2230 2231  Stream.EmitRecord(bitc::METADATA_NAMESPACE, Record, Abbrev);2232  Record.clear();2233}2234 2235void ModuleBitcodeWriter::writeDIMacro(const DIMacro *N,2236                                       SmallVectorImpl<uint64_t> &Record,2237                                       unsigned Abbrev) {2238  Record.push_back(N->isDistinct());2239  Record.push_back(N->getMacinfoType());2240  Record.push_back(N->getLine());2241  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));2242  Record.push_back(VE.getMetadataOrNullID(N->getRawValue()));2243 2244  Stream.EmitRecord(bitc::METADATA_MACRO, Record, Abbrev);2245  Record.clear();2246}2247 2248void ModuleBitcodeWriter::writeDIMacroFile(const DIMacroFile *N,2249                                           SmallVectorImpl<uint64_t> &Record,2250                                           unsigned Abbrev) {2251  Record.push_back(N->isDistinct());2252  Record.push_back(N->getMacinfoType());2253  Record.push_back(N->getLine());2254  Record.push_back(VE.getMetadataOrNullID(N->getFile()));2255  Record.push_back(VE.getMetadataOrNullID(N->getElements().get()));2256 2257  Stream.EmitRecord(bitc::METADATA_MACRO_FILE, Record, Abbrev);2258  Record.clear();2259}2260 2261void ModuleBitcodeWriter::writeDIArgList(const DIArgList *N,2262                                         SmallVectorImpl<uint64_t> &Record) {2263  Record.reserve(N->getArgs().size());2264  for (ValueAsMetadata *MD : N->getArgs())2265    Record.push_back(VE.getMetadataID(MD));2266 2267  Stream.EmitRecord(bitc::METADATA_ARG_LIST, Record);2268  Record.clear();2269}2270 2271void ModuleBitcodeWriter::writeDIModule(const DIModule *N,2272                                        SmallVectorImpl<uint64_t> &Record,2273                                        unsigned Abbrev) {2274  Record.push_back(N->isDistinct());2275  for (auto &I : N->operands())2276    Record.push_back(VE.getMetadataOrNullID(I));2277  Record.push_back(N->getLineNo());2278  Record.push_back(N->getIsDecl());2279 2280  Stream.EmitRecord(bitc::METADATA_MODULE, Record, Abbrev);2281  Record.clear();2282}2283 2284void ModuleBitcodeWriter::writeDIAssignID(const DIAssignID *N,2285                                          SmallVectorImpl<uint64_t> &Record,2286                                          unsigned Abbrev) {2287  // There are no arguments for this metadata type.2288  Record.push_back(N->isDistinct());2289  Stream.EmitRecord(bitc::METADATA_ASSIGN_ID, Record, Abbrev);2290  Record.clear();2291}2292 2293void ModuleBitcodeWriter::writeDITemplateTypeParameter(2294    const DITemplateTypeParameter *N, SmallVectorImpl<uint64_t> &Record,2295    unsigned Abbrev) {2296  Record.push_back(N->isDistinct());2297  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));2298  Record.push_back(VE.getMetadataOrNullID(N->getType()));2299  Record.push_back(N->isDefault());2300 2301  Stream.EmitRecord(bitc::METADATA_TEMPLATE_TYPE, Record, Abbrev);2302  Record.clear();2303}2304 2305void ModuleBitcodeWriter::writeDITemplateValueParameter(2306    const DITemplateValueParameter *N, SmallVectorImpl<uint64_t> &Record,2307    unsigned Abbrev) {2308  Record.push_back(N->isDistinct());2309  Record.push_back(N->getTag());2310  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));2311  Record.push_back(VE.getMetadataOrNullID(N->getType()));2312  Record.push_back(N->isDefault());2313  Record.push_back(VE.getMetadataOrNullID(N->getValue()));2314 2315  Stream.EmitRecord(bitc::METADATA_TEMPLATE_VALUE, Record, Abbrev);2316  Record.clear();2317}2318 2319void ModuleBitcodeWriter::writeDIGlobalVariable(2320    const DIGlobalVariable *N, SmallVectorImpl<uint64_t> &Record,2321    unsigned Abbrev) {2322  const uint64_t Version = 2 << 1;2323  Record.push_back((uint64_t)N->isDistinct() | Version);2324  Record.push_back(VE.getMetadataOrNullID(N->getScope()));2325  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));2326  Record.push_back(VE.getMetadataOrNullID(N->getRawLinkageName()));2327  Record.push_back(VE.getMetadataOrNullID(N->getFile()));2328  Record.push_back(N->getLine());2329  Record.push_back(VE.getMetadataOrNullID(N->getType()));2330  Record.push_back(N->isLocalToUnit());2331  Record.push_back(N->isDefinition());2332  Record.push_back(VE.getMetadataOrNullID(N->getStaticDataMemberDeclaration()));2333  Record.push_back(VE.getMetadataOrNullID(N->getTemplateParams()));2334  Record.push_back(N->getAlignInBits());2335  Record.push_back(VE.getMetadataOrNullID(N->getAnnotations().get()));2336 2337  Stream.EmitRecord(bitc::METADATA_GLOBAL_VAR, Record, Abbrev);2338  Record.clear();2339}2340 2341void ModuleBitcodeWriter::writeDILocalVariable(2342    const DILocalVariable *N, SmallVectorImpl<uint64_t> &Record,2343    unsigned Abbrev) {2344  // In order to support all possible bitcode formats in BitcodeReader we need2345  // to distinguish the following cases:2346  // 1) Record has no artificial tag (Record[1]),2347  //   has no obsolete inlinedAt field (Record[9]).2348  //   In this case Record size will be 8, HasAlignment flag is false.2349  // 2) Record has artificial tag (Record[1]),2350  //   has no obsolete inlignedAt field (Record[9]).2351  //   In this case Record size will be 9, HasAlignment flag is false.2352  // 3) Record has both artificial tag (Record[1]) and2353  //   obsolete inlignedAt field (Record[9]).2354  //   In this case Record size will be 10, HasAlignment flag is false.2355  // 4) Record has neither artificial tag, nor inlignedAt field, but2356  //   HasAlignment flag is true and Record[8] contains alignment value.2357  const uint64_t HasAlignmentFlag = 1 << 1;2358  Record.push_back((uint64_t)N->isDistinct() | HasAlignmentFlag);2359  Record.push_back(VE.getMetadataOrNullID(N->getScope()));2360  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));2361  Record.push_back(VE.getMetadataOrNullID(N->getFile()));2362  Record.push_back(N->getLine());2363  Record.push_back(VE.getMetadataOrNullID(N->getType()));2364  Record.push_back(N->getArg());2365  Record.push_back(N->getFlags());2366  Record.push_back(N->getAlignInBits());2367  Record.push_back(VE.getMetadataOrNullID(N->getAnnotations().get()));2368 2369  Stream.EmitRecord(bitc::METADATA_LOCAL_VAR, Record, Abbrev);2370  Record.clear();2371}2372 2373void ModuleBitcodeWriter::writeDILabel(2374    const DILabel *N, SmallVectorImpl<uint64_t> &Record,2375    unsigned Abbrev) {2376  uint64_t IsArtificialFlag = uint64_t(N->isArtificial()) << 1;2377  Record.push_back((uint64_t)N->isDistinct() | IsArtificialFlag);2378  Record.push_back(VE.getMetadataOrNullID(N->getScope()));2379  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));2380  Record.push_back(VE.getMetadataOrNullID(N->getFile()));2381  Record.push_back(N->getLine());2382  Record.push_back(N->getColumn());2383  Record.push_back(N->getCoroSuspendIdx().has_value()2384                       ? (uint64_t)N->getCoroSuspendIdx().value()2385                       : std::numeric_limits<uint64_t>::max());2386 2387  Stream.EmitRecord(bitc::METADATA_LABEL, Record, Abbrev);2388  Record.clear();2389}2390 2391void ModuleBitcodeWriter::writeDIExpression(const DIExpression *N,2392                                            SmallVectorImpl<uint64_t> &Record,2393                                            unsigned Abbrev) {2394  Record.reserve(N->getElements().size() + 1);2395  const uint64_t Version = 3 << 1;2396  Record.push_back((uint64_t)N->isDistinct() | Version);2397  Record.append(N->elements_begin(), N->elements_end());2398 2399  Stream.EmitRecord(bitc::METADATA_EXPRESSION, Record, Abbrev);2400  Record.clear();2401}2402 2403void ModuleBitcodeWriter::writeDIGlobalVariableExpression(2404    const DIGlobalVariableExpression *N, SmallVectorImpl<uint64_t> &Record,2405    unsigned Abbrev) {2406  Record.push_back(N->isDistinct());2407  Record.push_back(VE.getMetadataOrNullID(N->getVariable()));2408  Record.push_back(VE.getMetadataOrNullID(N->getExpression()));2409 2410  Stream.EmitRecord(bitc::METADATA_GLOBAL_VAR_EXPR, Record, Abbrev);2411  Record.clear();2412}2413 2414void ModuleBitcodeWriter::writeDIObjCProperty(const DIObjCProperty *N,2415                                              SmallVectorImpl<uint64_t> &Record,2416                                              unsigned Abbrev) {2417  Record.push_back(N->isDistinct());2418  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));2419  Record.push_back(VE.getMetadataOrNullID(N->getFile()));2420  Record.push_back(N->getLine());2421  Record.push_back(VE.getMetadataOrNullID(N->getRawSetterName()));2422  Record.push_back(VE.getMetadataOrNullID(N->getRawGetterName()));2423  Record.push_back(N->getAttributes());2424  Record.push_back(VE.getMetadataOrNullID(N->getType()));2425 2426  Stream.EmitRecord(bitc::METADATA_OBJC_PROPERTY, Record, Abbrev);2427  Record.clear();2428}2429 2430void ModuleBitcodeWriter::writeDIImportedEntity(2431    const DIImportedEntity *N, SmallVectorImpl<uint64_t> &Record,2432    unsigned Abbrev) {2433  Record.push_back(N->isDistinct());2434  Record.push_back(N->getTag());2435  Record.push_back(VE.getMetadataOrNullID(N->getScope()));2436  Record.push_back(VE.getMetadataOrNullID(N->getEntity()));2437  Record.push_back(N->getLine());2438  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));2439  Record.push_back(VE.getMetadataOrNullID(N->getRawFile()));2440  Record.push_back(VE.getMetadataOrNullID(N->getElements().get()));2441 2442  Stream.EmitRecord(bitc::METADATA_IMPORTED_ENTITY, Record, Abbrev);2443  Record.clear();2444}2445 2446unsigned ModuleBitcodeWriter::createNamedMetadataAbbrev() {2447  auto Abbv = std::make_shared<BitCodeAbbrev>();2448  Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_NAME));2449  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));2450  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));2451  return Stream.EmitAbbrev(std::move(Abbv));2452}2453 2454void ModuleBitcodeWriter::writeNamedMetadata(2455    SmallVectorImpl<uint64_t> &Record) {2456  if (M.named_metadata_empty())2457    return;2458 2459  unsigned Abbrev = createNamedMetadataAbbrev();2460  for (const NamedMDNode &NMD : M.named_metadata()) {2461    // Write name.2462    StringRef Str = NMD.getName();2463    Record.append(Str.bytes_begin(), Str.bytes_end());2464    Stream.EmitRecord(bitc::METADATA_NAME, Record, Abbrev);2465    Record.clear();2466 2467    // Write named metadata operands.2468    for (const MDNode *N : NMD.operands())2469      Record.push_back(VE.getMetadataID(N));2470    Stream.EmitRecord(bitc::METADATA_NAMED_NODE, Record, 0);2471    Record.clear();2472  }2473}2474 2475unsigned ModuleBitcodeWriter::createMetadataStringsAbbrev() {2476  auto Abbv = std::make_shared<BitCodeAbbrev>();2477  Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_STRINGS));2478  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of strings2479  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // offset to chars2480  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));2481  return Stream.EmitAbbrev(std::move(Abbv));2482}2483 2484/// Write out a record for MDString.2485///2486/// All the metadata strings in a metadata block are emitted in a single2487/// record.  The sizes and strings themselves are shoved into a blob.2488void ModuleBitcodeWriter::writeMetadataStrings(2489    ArrayRef<const Metadata *> Strings, SmallVectorImpl<uint64_t> &Record) {2490  if (Strings.empty())2491    return;2492 2493  // Start the record with the number of strings.2494  Record.push_back(bitc::METADATA_STRINGS);2495  Record.push_back(Strings.size());2496 2497  // Emit the sizes of the strings in the blob.2498  SmallString<256> Blob;2499  {2500    BitstreamWriter W(Blob);2501    for (const Metadata *MD : Strings)2502      W.EmitVBR(cast<MDString>(MD)->getLength(), 6);2503    W.FlushToWord();2504  }2505 2506  // Add the offset to the strings to the record.2507  Record.push_back(Blob.size());2508 2509  // Add the strings to the blob.2510  for (const Metadata *MD : Strings)2511    Blob.append(cast<MDString>(MD)->getString());2512 2513  // Emit the final record.2514  Stream.EmitRecordWithBlob(createMetadataStringsAbbrev(), Record, Blob);2515  Record.clear();2516}2517 2518// Generates an enum to use as an index in the Abbrev array of Metadata record.2519enum MetadataAbbrev : unsigned {2520#define HANDLE_MDNODE_LEAF(CLASS) CLASS##AbbrevID,2521#include "llvm/IR/Metadata.def"2522  LastPlusOne2523};2524 2525void ModuleBitcodeWriter::writeMetadataRecords(2526    ArrayRef<const Metadata *> MDs, SmallVectorImpl<uint64_t> &Record,2527    std::vector<unsigned> *MDAbbrevs, std::vector<uint64_t> *IndexPos) {2528  if (MDs.empty())2529    return;2530 2531  // Initialize MDNode abbreviations.2532#define HANDLE_MDNODE_LEAF(CLASS) unsigned CLASS##Abbrev = 0;2533#include "llvm/IR/Metadata.def"2534 2535  for (const Metadata *MD : MDs) {2536    if (IndexPos)2537      IndexPos->push_back(Stream.GetCurrentBitNo());2538    if (const MDNode *N = dyn_cast<MDNode>(MD)) {2539      assert(N->isResolved() && "Expected forward references to be resolved");2540 2541      switch (N->getMetadataID()) {2542      default:2543        llvm_unreachable("Invalid MDNode subclass");2544#define HANDLE_MDNODE_LEAF(CLASS)                                              \2545  case Metadata::CLASS##Kind:                                                  \2546    if (MDAbbrevs)                                                             \2547      write##CLASS(cast<CLASS>(N), Record,                                     \2548                   (*MDAbbrevs)[MetadataAbbrev::CLASS##AbbrevID]);             \2549    else                                                                       \2550      write##CLASS(cast<CLASS>(N), Record, CLASS##Abbrev);                     \2551    continue;2552#include "llvm/IR/Metadata.def"2553      }2554    }2555    if (auto *AL = dyn_cast<DIArgList>(MD)) {2556      writeDIArgList(AL, Record);2557      continue;2558    }2559    writeValueAsMetadata(cast<ValueAsMetadata>(MD), Record);2560  }2561}2562 2563void ModuleBitcodeWriter::writeModuleMetadata() {2564  if (!VE.hasMDs() && M.named_metadata_empty())2565    return;2566 2567  Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 4);2568  SmallVector<uint64_t, 64> Record;2569 2570  // Emit all abbrevs upfront, so that the reader can jump in the middle of the2571  // block and load any metadata.2572  std::vector<unsigned> MDAbbrevs;2573 2574  MDAbbrevs.resize(MetadataAbbrev::LastPlusOne);2575  MDAbbrevs[MetadataAbbrev::DILocationAbbrevID] = createDILocationAbbrev();2576  MDAbbrevs[MetadataAbbrev::GenericDINodeAbbrevID] =2577      createGenericDINodeAbbrev();2578 2579  auto Abbv = std::make_shared<BitCodeAbbrev>();2580  Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_INDEX_OFFSET));2581  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));2582  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));2583  unsigned OffsetAbbrev = Stream.EmitAbbrev(std::move(Abbv));2584 2585  Abbv = std::make_shared<BitCodeAbbrev>();2586  Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_INDEX));2587  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));2588  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));2589  unsigned IndexAbbrev = Stream.EmitAbbrev(std::move(Abbv));2590 2591  // Emit MDStrings together upfront.2592  writeMetadataStrings(VE.getMDStrings(), Record);2593 2594  // We only emit an index for the metadata record if we have more than a given2595  // (naive) threshold of metadatas, otherwise it is not worth it.2596  if (VE.getNonMDStrings().size() > IndexThreshold) {2597    // Write a placeholder value in for the offset of the metadata index,2598    // which is written after the records, so that it can include2599    // the offset of each entry. The placeholder offset will be2600    // updated after all records are emitted.2601    uint64_t Vals[] = {0, 0};2602    Stream.EmitRecord(bitc::METADATA_INDEX_OFFSET, Vals, OffsetAbbrev);2603  }2604 2605  // Compute and save the bit offset to the current position, which will be2606  // patched when we emit the index later. We can simply subtract the 64-bit2607  // fixed size from the current bit number to get the location to backpatch.2608  uint64_t IndexOffsetRecordBitPos = Stream.GetCurrentBitNo();2609 2610  // This index will contain the bitpos for each individual record.2611  std::vector<uint64_t> IndexPos;2612  IndexPos.reserve(VE.getNonMDStrings().size());2613 2614  // Write all the records2615  writeMetadataRecords(VE.getNonMDStrings(), Record, &MDAbbrevs, &IndexPos);2616 2617  if (VE.getNonMDStrings().size() > IndexThreshold) {2618    // Now that we have emitted all the records we will emit the index. But2619    // first2620    // backpatch the forward reference so that the reader can skip the records2621    // efficiently.2622    Stream.BackpatchWord64(IndexOffsetRecordBitPos - 64,2623                           Stream.GetCurrentBitNo() - IndexOffsetRecordBitPos);2624 2625    // Delta encode the index.2626    uint64_t PreviousValue = IndexOffsetRecordBitPos;2627    for (auto &Elt : IndexPos) {2628      auto EltDelta = Elt - PreviousValue;2629      PreviousValue = Elt;2630      Elt = EltDelta;2631    }2632    // Emit the index record.2633    Stream.EmitRecord(bitc::METADATA_INDEX, IndexPos, IndexAbbrev);2634    IndexPos.clear();2635  }2636 2637  // Write the named metadata now.2638  writeNamedMetadata(Record);2639 2640  auto AddDeclAttachedMetadata = [&](const GlobalObject &GO) {2641    SmallVector<uint64_t, 4> Record;2642    Record.push_back(VE.getValueID(&GO));2643    pushGlobalMetadataAttachment(Record, GO);2644    Stream.EmitRecord(bitc::METADATA_GLOBAL_DECL_ATTACHMENT, Record);2645  };2646  for (const Function &F : M)2647    if (F.isDeclaration() && F.hasMetadata())2648      AddDeclAttachedMetadata(F);2649  for (const GlobalIFunc &GI : M.ifuncs())2650    if (GI.hasMetadata())2651      AddDeclAttachedMetadata(GI);2652  // FIXME: Only store metadata for declarations here, and move data for global2653  // variable definitions to a separate block (PR28134).2654  for (const GlobalVariable &GV : M.globals())2655    if (GV.hasMetadata())2656      AddDeclAttachedMetadata(GV);2657 2658  Stream.ExitBlock();2659}2660 2661void ModuleBitcodeWriter::writeFunctionMetadata(const Function &F) {2662  if (!VE.hasMDs())2663    return;2664 2665  Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);2666  SmallVector<uint64_t, 64> Record;2667  writeMetadataStrings(VE.getMDStrings(), Record);2668  writeMetadataRecords(VE.getNonMDStrings(), Record);2669  Stream.ExitBlock();2670}2671 2672void ModuleBitcodeWriter::pushGlobalMetadataAttachment(2673    SmallVectorImpl<uint64_t> &Record, const GlobalObject &GO) {2674  // [n x [id, mdnode]]2675  SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;2676  GO.getAllMetadata(MDs);2677  for (const auto &I : MDs) {2678    Record.push_back(I.first);2679    Record.push_back(VE.getMetadataID(I.second));2680  }2681}2682 2683void ModuleBitcodeWriter::writeFunctionMetadataAttachment(const Function &F) {2684  Stream.EnterSubblock(bitc::METADATA_ATTACHMENT_ID, 3);2685 2686  SmallVector<uint64_t, 64> Record;2687 2688  if (F.hasMetadata()) {2689    pushGlobalMetadataAttachment(Record, F);2690    Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0);2691    Record.clear();2692  }2693 2694  // Write metadata attachments2695  // METADATA_ATTACHMENT - [m x [value, [n x [id, mdnode]]]2696  SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;2697  for (const BasicBlock &BB : F)2698    for (const Instruction &I : BB) {2699      MDs.clear();2700      I.getAllMetadataOtherThanDebugLoc(MDs);2701 2702      // If no metadata, ignore instruction.2703      if (MDs.empty()) continue;2704 2705      Record.push_back(VE.getInstructionID(&I));2706 2707      for (const auto &[ID, MD] : MDs) {2708        Record.push_back(ID);2709        Record.push_back(VE.getMetadataID(MD));2710      }2711      Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0);2712      Record.clear();2713    }2714 2715  Stream.ExitBlock();2716}2717 2718void ModuleBitcodeWriter::writeModuleMetadataKinds() {2719  SmallVector<uint64_t, 64> Record;2720 2721  // Write metadata kinds2722  // METADATA_KIND - [n x [id, name]]2723  SmallVector<StringRef, 8> Names;2724  M.getMDKindNames(Names);2725 2726  if (Names.empty()) return;2727 2728  Stream.EnterSubblock(bitc::METADATA_KIND_BLOCK_ID, 3);2729 2730  for (unsigned MDKindID = 0, e = Names.size(); MDKindID != e; ++MDKindID) {2731    Record.push_back(MDKindID);2732    StringRef KName = Names[MDKindID];2733    Record.append(KName.begin(), KName.end());2734 2735    Stream.EmitRecord(bitc::METADATA_KIND, Record, 0);2736    Record.clear();2737  }2738 2739  Stream.ExitBlock();2740}2741 2742void ModuleBitcodeWriter::writeOperandBundleTags() {2743  // Write metadata kinds2744  //2745  // OPERAND_BUNDLE_TAGS_BLOCK_ID : N x OPERAND_BUNDLE_TAG2746  //2747  // OPERAND_BUNDLE_TAG - [strchr x N]2748 2749  SmallVector<StringRef, 8> Tags;2750  M.getOperandBundleTags(Tags);2751 2752  if (Tags.empty())2753    return;2754 2755  Stream.EnterSubblock(bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID, 3);2756 2757  SmallVector<uint64_t, 64> Record;2758 2759  for (auto Tag : Tags) {2760    Record.append(Tag.begin(), Tag.end());2761 2762    Stream.EmitRecord(bitc::OPERAND_BUNDLE_TAG, Record, 0);2763    Record.clear();2764  }2765 2766  Stream.ExitBlock();2767}2768 2769void ModuleBitcodeWriter::writeSyncScopeNames() {2770  SmallVector<StringRef, 8> SSNs;2771  M.getContext().getSyncScopeNames(SSNs);2772  if (SSNs.empty())2773    return;2774 2775  Stream.EnterSubblock(bitc::SYNC_SCOPE_NAMES_BLOCK_ID, 2);2776 2777  SmallVector<uint64_t, 64> Record;2778  for (auto SSN : SSNs) {2779    Record.append(SSN.begin(), SSN.end());2780    Stream.EmitRecord(bitc::SYNC_SCOPE_NAME, Record, 0);2781    Record.clear();2782  }2783 2784  Stream.ExitBlock();2785}2786 2787void ModuleBitcodeWriter::writeConstants(unsigned FirstVal, unsigned LastVal,2788                                         bool isGlobal) {2789  if (FirstVal == LastVal) return;2790 2791  Stream.EnterSubblock(bitc::CONSTANTS_BLOCK_ID, 4);2792 2793  unsigned AggregateAbbrev = 0;2794  unsigned String8Abbrev = 0;2795  unsigned CString7Abbrev = 0;2796  unsigned CString6Abbrev = 0;2797  // If this is a constant pool for the module, emit module-specific abbrevs.2798  if (isGlobal) {2799    // Abbrev for CST_CODE_AGGREGATE.2800    auto Abbv = std::make_shared<BitCodeAbbrev>();2801    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_AGGREGATE));2802    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));2803    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, Log2_32_Ceil(LastVal+1)));2804    AggregateAbbrev = Stream.EmitAbbrev(std::move(Abbv));2805 2806    // Abbrev for CST_CODE_STRING.2807    Abbv = std::make_shared<BitCodeAbbrev>();2808    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_STRING));2809    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));2810    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));2811    String8Abbrev = Stream.EmitAbbrev(std::move(Abbv));2812    // Abbrev for CST_CODE_CSTRING.2813    Abbv = std::make_shared<BitCodeAbbrev>();2814    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CSTRING));2815    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));2816    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));2817    CString7Abbrev = Stream.EmitAbbrev(std::move(Abbv));2818    // Abbrev for CST_CODE_CSTRING.2819    Abbv = std::make_shared<BitCodeAbbrev>();2820    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CSTRING));2821    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));2822    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));2823    CString6Abbrev = Stream.EmitAbbrev(std::move(Abbv));2824  }2825 2826  SmallVector<uint64_t, 64> Record;2827 2828  const ValueEnumerator::ValueList &Vals = VE.getValues();2829  Type *LastTy = nullptr;2830  for (unsigned i = FirstVal; i != LastVal; ++i) {2831    const Value *V = Vals[i].first;2832    // If we need to switch types, do so now.2833    if (V->getType() != LastTy) {2834      LastTy = V->getType();2835      Record.push_back(VE.getTypeID(LastTy));2836      Stream.EmitRecord(bitc::CST_CODE_SETTYPE, Record,2837                        CONSTANTS_SETTYPE_ABBREV);2838      Record.clear();2839    }2840 2841    if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {2842      Record.push_back(VE.getTypeID(IA->getFunctionType()));2843      Record.push_back(2844          unsigned(IA->hasSideEffects()) | unsigned(IA->isAlignStack()) << 1 |2845          unsigned(IA->getDialect() & 1) << 2 | unsigned(IA->canThrow()) << 3);2846 2847      // Add the asm string.2848      StringRef AsmStr = IA->getAsmString();2849      Record.push_back(AsmStr.size());2850      Record.append(AsmStr.begin(), AsmStr.end());2851 2852      // Add the constraint string.2853      StringRef ConstraintStr = IA->getConstraintString();2854      Record.push_back(ConstraintStr.size());2855      Record.append(ConstraintStr.begin(), ConstraintStr.end());2856      Stream.EmitRecord(bitc::CST_CODE_INLINEASM, Record);2857      Record.clear();2858      continue;2859    }2860    const Constant *C = cast<Constant>(V);2861    unsigned Code = -1U;2862    unsigned AbbrevToUse = 0;2863    if (C->isNullValue()) {2864      Code = bitc::CST_CODE_NULL;2865    } else if (isa<PoisonValue>(C)) {2866      Code = bitc::CST_CODE_POISON;2867    } else if (isa<UndefValue>(C)) {2868      Code = bitc::CST_CODE_UNDEF;2869    } else if (const ConstantInt *IV = dyn_cast<ConstantInt>(C)) {2870      if (IV->getBitWidth() <= 64) {2871        uint64_t V = IV->getSExtValue();2872        emitSignedInt64(Record, V);2873        Code = bitc::CST_CODE_INTEGER;2874        AbbrevToUse = CONSTANTS_INTEGER_ABBREV;2875      } else {                             // Wide integers, > 64 bits in size.2876        emitWideAPInt(Record, IV->getValue());2877        Code = bitc::CST_CODE_WIDE_INTEGER;2878      }2879    } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {2880      Code = bitc::CST_CODE_FLOAT;2881      Type *Ty = CFP->getType()->getScalarType();2882      if (Ty->isHalfTy() || Ty->isBFloatTy() || Ty->isFloatTy() ||2883          Ty->isDoubleTy()) {2884        Record.push_back(CFP->getValueAPF().bitcastToAPInt().getZExtValue());2885      } else if (Ty->isX86_FP80Ty()) {2886        // api needed to prevent premature destruction2887        // bits are not in the same order as a normal i80 APInt, compensate.2888        APInt api = CFP->getValueAPF().bitcastToAPInt();2889        const uint64_t *p = api.getRawData();2890        Record.push_back((p[1] << 48) | (p[0] >> 16));2891        Record.push_back(p[0] & 0xffffLL);2892      } else if (Ty->isFP128Ty() || Ty->isPPC_FP128Ty()) {2893        APInt api = CFP->getValueAPF().bitcastToAPInt();2894        const uint64_t *p = api.getRawData();2895        Record.push_back(p[0]);2896        Record.push_back(p[1]);2897      } else {2898        assert(0 && "Unknown FP type!");2899      }2900    } else if (isa<ConstantDataSequential>(C) &&2901               cast<ConstantDataSequential>(C)->isString()) {2902      const ConstantDataSequential *Str = cast<ConstantDataSequential>(C);2903      // Emit constant strings specially.2904      uint64_t NumElts = Str->getNumElements();2905      // If this is a null-terminated string, use the denser CSTRING encoding.2906      if (Str->isCString()) {2907        Code = bitc::CST_CODE_CSTRING;2908        --NumElts;  // Don't encode the null, which isn't allowed by char6.2909      } else {2910        Code = bitc::CST_CODE_STRING;2911        AbbrevToUse = String8Abbrev;2912      }2913      bool isCStr7 = Code == bitc::CST_CODE_CSTRING;2914      bool isCStrChar6 = Code == bitc::CST_CODE_CSTRING;2915      for (uint64_t i = 0; i != NumElts; ++i) {2916        unsigned char V = Str->getElementAsInteger(i);2917        Record.push_back(V);2918        isCStr7 &= (V & 128) == 0;2919        if (isCStrChar6)2920          isCStrChar6 = BitCodeAbbrevOp::isChar6(V);2921      }2922 2923      if (isCStrChar6)2924        AbbrevToUse = CString6Abbrev;2925      else if (isCStr7)2926        AbbrevToUse = CString7Abbrev;2927    } else if (const ConstantDataSequential *CDS =2928                  dyn_cast<ConstantDataSequential>(C)) {2929      Code = bitc::CST_CODE_DATA;2930      Type *EltTy = CDS->getElementType();2931      if (isa<IntegerType>(EltTy)) {2932        for (uint64_t i = 0, e = CDS->getNumElements(); i != e; ++i)2933          Record.push_back(CDS->getElementAsInteger(i));2934      } else {2935        for (uint64_t i = 0, e = CDS->getNumElements(); i != e; ++i)2936          Record.push_back(2937              CDS->getElementAsAPFloat(i).bitcastToAPInt().getLimitedValue());2938      }2939    } else if (isa<ConstantAggregate>(C)) {2940      Code = bitc::CST_CODE_AGGREGATE;2941      for (const Value *Op : C->operands())2942        Record.push_back(VE.getValueID(Op));2943      AbbrevToUse = AggregateAbbrev;2944    } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {2945      switch (CE->getOpcode()) {2946      default:2947        if (Instruction::isCast(CE->getOpcode())) {2948          Code = bitc::CST_CODE_CE_CAST;2949          Record.push_back(getEncodedCastOpcode(CE->getOpcode()));2950          Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));2951          Record.push_back(VE.getValueID(C->getOperand(0)));2952          AbbrevToUse = CONSTANTS_CE_CAST_Abbrev;2953        } else {2954          assert(CE->getNumOperands() == 2 && "Unknown constant expr!");2955          Code = bitc::CST_CODE_CE_BINOP;2956          Record.push_back(getEncodedBinaryOpcode(CE->getOpcode()));2957          Record.push_back(VE.getValueID(C->getOperand(0)));2958          Record.push_back(VE.getValueID(C->getOperand(1)));2959          uint64_t Flags = getOptimizationFlags(CE);2960          if (Flags != 0)2961            Record.push_back(Flags);2962        }2963        break;2964      case Instruction::FNeg: {2965        assert(CE->getNumOperands() == 1 && "Unknown constant expr!");2966        Code = bitc::CST_CODE_CE_UNOP;2967        Record.push_back(getEncodedUnaryOpcode(CE->getOpcode()));2968        Record.push_back(VE.getValueID(C->getOperand(0)));2969        uint64_t Flags = getOptimizationFlags(CE);2970        if (Flags != 0)2971          Record.push_back(Flags);2972        break;2973      }2974      case Instruction::GetElementPtr: {2975        Code = bitc::CST_CODE_CE_GEP;2976        const auto *GO = cast<GEPOperator>(C);2977        Record.push_back(VE.getTypeID(GO->getSourceElementType()));2978        Record.push_back(getOptimizationFlags(GO));2979        if (std::optional<ConstantRange> Range = GO->getInRange()) {2980          Code = bitc::CST_CODE_CE_GEP_WITH_INRANGE;2981          emitConstantRange(Record, *Range, /*EmitBitWidth=*/true);2982        }2983        for (const Value *Op : CE->operands()) {2984          Record.push_back(VE.getTypeID(Op->getType()));2985          Record.push_back(VE.getValueID(Op));2986        }2987        break;2988      }2989      case Instruction::ExtractElement:2990        Code = bitc::CST_CODE_CE_EXTRACTELT;2991        Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));2992        Record.push_back(VE.getValueID(C->getOperand(0)));2993        Record.push_back(VE.getTypeID(C->getOperand(1)->getType()));2994        Record.push_back(VE.getValueID(C->getOperand(1)));2995        break;2996      case Instruction::InsertElement:2997        Code = bitc::CST_CODE_CE_INSERTELT;2998        Record.push_back(VE.getValueID(C->getOperand(0)));2999        Record.push_back(VE.getValueID(C->getOperand(1)));3000        Record.push_back(VE.getTypeID(C->getOperand(2)->getType()));3001        Record.push_back(VE.getValueID(C->getOperand(2)));3002        break;3003      case Instruction::ShuffleVector:3004        // If the return type and argument types are the same, this is a3005        // standard shufflevector instruction.  If the types are different,3006        // then the shuffle is widening or truncating the input vectors, and3007        // the argument type must also be encoded.3008        if (C->getType() == C->getOperand(0)->getType()) {3009          Code = bitc::CST_CODE_CE_SHUFFLEVEC;3010        } else {3011          Code = bitc::CST_CODE_CE_SHUFVEC_EX;3012          Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));3013        }3014        Record.push_back(VE.getValueID(C->getOperand(0)));3015        Record.push_back(VE.getValueID(C->getOperand(1)));3016        Record.push_back(VE.getValueID(CE->getShuffleMaskForBitcode()));3017        break;3018      }3019    } else if (const BlockAddress *BA = dyn_cast<BlockAddress>(C)) {3020      Code = bitc::CST_CODE_BLOCKADDRESS;3021      Record.push_back(VE.getTypeID(BA->getFunction()->getType()));3022      Record.push_back(VE.getValueID(BA->getFunction()));3023      Record.push_back(VE.getGlobalBasicBlockID(BA->getBasicBlock()));3024    } else if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(C)) {3025      Code = bitc::CST_CODE_DSO_LOCAL_EQUIVALENT;3026      Record.push_back(VE.getTypeID(Equiv->getGlobalValue()->getType()));3027      Record.push_back(VE.getValueID(Equiv->getGlobalValue()));3028    } else if (const auto *NC = dyn_cast<NoCFIValue>(C)) {3029      Code = bitc::CST_CODE_NO_CFI_VALUE;3030      Record.push_back(VE.getTypeID(NC->getGlobalValue()->getType()));3031      Record.push_back(VE.getValueID(NC->getGlobalValue()));3032    } else if (const auto *CPA = dyn_cast<ConstantPtrAuth>(C)) {3033      Code = bitc::CST_CODE_PTRAUTH2;3034      Record.push_back(VE.getValueID(CPA->getPointer()));3035      Record.push_back(VE.getValueID(CPA->getKey()));3036      Record.push_back(VE.getValueID(CPA->getDiscriminator()));3037      Record.push_back(VE.getValueID(CPA->getAddrDiscriminator()));3038      Record.push_back(VE.getValueID(CPA->getDeactivationSymbol()));3039    } else {3040#ifndef NDEBUG3041      C->dump();3042#endif3043      llvm_unreachable("Unknown constant!");3044    }3045    Stream.EmitRecord(Code, Record, AbbrevToUse);3046    Record.clear();3047  }3048 3049  Stream.ExitBlock();3050}3051 3052void ModuleBitcodeWriter::writeModuleConstants() {3053  const ValueEnumerator::ValueList &Vals = VE.getValues();3054 3055  // Find the first constant to emit, which is the first non-globalvalue value.3056  // We know globalvalues have been emitted by WriteModuleInfo.3057  for (unsigned i = 0, e = Vals.size(); i != e; ++i) {3058    if (!isa<GlobalValue>(Vals[i].first)) {3059      writeConstants(i, Vals.size(), true);3060      return;3061    }3062  }3063}3064 3065/// pushValueAndType - The file has to encode both the value and type id for3066/// many values, because we need to know what type to create for forward3067/// references.  However, most operands are not forward references, so this type3068/// field is not needed.3069///3070/// This function adds V's value ID to Vals.  If the value ID is higher than the3071/// instruction ID, then it is a forward reference, and it also includes the3072/// type ID.  The value ID that is written is encoded relative to the InstID.3073bool ModuleBitcodeWriter::pushValueAndType(const Value *V, unsigned InstID,3074                                           SmallVectorImpl<unsigned> &Vals) {3075  unsigned ValID = VE.getValueID(V);3076  // Make encoding relative to the InstID.3077  Vals.push_back(InstID - ValID);3078  if (ValID >= InstID) {3079    Vals.push_back(VE.getTypeID(V->getType()));3080    return true;3081  }3082  return false;3083}3084 3085bool ModuleBitcodeWriter::pushValueOrMetadata(const Value *V, unsigned InstID,3086                                              SmallVectorImpl<unsigned> &Vals) {3087  bool IsMetadata = V->getType()->isMetadataTy();3088  if (IsMetadata) {3089    Vals.push_back(bitc::OB_METADATA);3090    Metadata *MD = cast<MetadataAsValue>(V)->getMetadata();3091    unsigned ValID = VE.getMetadataID(MD);3092    Vals.push_back(InstID - ValID);3093    return false;3094  }3095  return pushValueAndType(V, InstID, Vals);3096}3097 3098void ModuleBitcodeWriter::writeOperandBundles(const CallBase &CS,3099                                              unsigned InstID) {3100  SmallVector<unsigned, 64> Record;3101  LLVMContext &C = CS.getContext();3102 3103  for (unsigned i = 0, e = CS.getNumOperandBundles(); i != e; ++i) {3104    const auto &Bundle = CS.getOperandBundleAt(i);3105    Record.push_back(C.getOperandBundleTagID(Bundle.getTagName()));3106 3107    for (auto &Input : Bundle.Inputs)3108      pushValueOrMetadata(Input, InstID, Record);3109 3110    Stream.EmitRecord(bitc::FUNC_CODE_OPERAND_BUNDLE, Record);3111    Record.clear();3112  }3113}3114 3115/// pushValue - Like pushValueAndType, but where the type of the value is3116/// omitted (perhaps it was already encoded in an earlier operand).3117void ModuleBitcodeWriter::pushValue(const Value *V, unsigned InstID,3118                                    SmallVectorImpl<unsigned> &Vals) {3119  unsigned ValID = VE.getValueID(V);3120  Vals.push_back(InstID - ValID);3121}3122 3123void ModuleBitcodeWriter::pushValueSigned(const Value *V, unsigned InstID,3124                                          SmallVectorImpl<uint64_t> &Vals) {3125  unsigned ValID = VE.getValueID(V);3126  int64_t diff = ((int32_t)InstID - (int32_t)ValID);3127  emitSignedInt64(Vals, diff);3128}3129 3130/// WriteInstruction - Emit an instruction to the specified stream.3131void ModuleBitcodeWriter::writeInstruction(const Instruction &I,3132                                           unsigned InstID,3133                                           SmallVectorImpl<unsigned> &Vals) {3134  unsigned Code = 0;3135  unsigned AbbrevToUse = 0;3136  VE.setInstructionID(&I);3137  switch (I.getOpcode()) {3138  default:3139    if (Instruction::isCast(I.getOpcode())) {3140      Code = bitc::FUNC_CODE_INST_CAST;3141      if (!pushValueAndType(I.getOperand(0), InstID, Vals))3142        AbbrevToUse = FUNCTION_INST_CAST_ABBREV;3143      Vals.push_back(VE.getTypeID(I.getType()));3144      Vals.push_back(getEncodedCastOpcode(I.getOpcode()));3145      uint64_t Flags = getOptimizationFlags(&I);3146      if (Flags != 0) {3147        if (AbbrevToUse == FUNCTION_INST_CAST_ABBREV)3148          AbbrevToUse = FUNCTION_INST_CAST_FLAGS_ABBREV;3149        Vals.push_back(Flags);3150      }3151    } else {3152      assert(isa<BinaryOperator>(I) && "Unknown instruction!");3153      Code = bitc::FUNC_CODE_INST_BINOP;3154      if (!pushValueAndType(I.getOperand(0), InstID, Vals))3155        AbbrevToUse = FUNCTION_INST_BINOP_ABBREV;3156      pushValue(I.getOperand(1), InstID, Vals);3157      Vals.push_back(getEncodedBinaryOpcode(I.getOpcode()));3158      uint64_t Flags = getOptimizationFlags(&I);3159      if (Flags != 0) {3160        if (AbbrevToUse == FUNCTION_INST_BINOP_ABBREV)3161          AbbrevToUse = FUNCTION_INST_BINOP_FLAGS_ABBREV;3162        Vals.push_back(Flags);3163      }3164    }3165    break;3166  case Instruction::FNeg: {3167    Code = bitc::FUNC_CODE_INST_UNOP;3168    if (!pushValueAndType(I.getOperand(0), InstID, Vals))3169      AbbrevToUse = FUNCTION_INST_UNOP_ABBREV;3170    Vals.push_back(getEncodedUnaryOpcode(I.getOpcode()));3171    uint64_t Flags = getOptimizationFlags(&I);3172    if (Flags != 0) {3173      if (AbbrevToUse == FUNCTION_INST_UNOP_ABBREV)3174        AbbrevToUse = FUNCTION_INST_UNOP_FLAGS_ABBREV;3175      Vals.push_back(Flags);3176    }3177    break;3178  }3179  case Instruction::GetElementPtr: {3180    Code = bitc::FUNC_CODE_INST_GEP;3181    AbbrevToUse = FUNCTION_INST_GEP_ABBREV;3182    auto &GEPInst = cast<GetElementPtrInst>(I);3183    Vals.push_back(getOptimizationFlags(&I));3184    Vals.push_back(VE.getTypeID(GEPInst.getSourceElementType()));3185    for (const Value *Op : I.operands())3186      pushValueAndType(Op, InstID, Vals);3187    break;3188  }3189  case Instruction::ExtractValue: {3190    Code = bitc::FUNC_CODE_INST_EXTRACTVAL;3191    pushValueAndType(I.getOperand(0), InstID, Vals);3192    const ExtractValueInst *EVI = cast<ExtractValueInst>(&I);3193    Vals.append(EVI->idx_begin(), EVI->idx_end());3194    break;3195  }3196  case Instruction::InsertValue: {3197    Code = bitc::FUNC_CODE_INST_INSERTVAL;3198    pushValueAndType(I.getOperand(0), InstID, Vals);3199    pushValueAndType(I.getOperand(1), InstID, Vals);3200    const InsertValueInst *IVI = cast<InsertValueInst>(&I);3201    Vals.append(IVI->idx_begin(), IVI->idx_end());3202    break;3203  }3204  case Instruction::Select: {3205    Code = bitc::FUNC_CODE_INST_VSELECT;3206    pushValueAndType(I.getOperand(1), InstID, Vals);3207    pushValue(I.getOperand(2), InstID, Vals);3208    pushValueAndType(I.getOperand(0), InstID, Vals);3209    uint64_t Flags = getOptimizationFlags(&I);3210    if (Flags != 0)3211      Vals.push_back(Flags);3212    break;3213  }3214  case Instruction::ExtractElement:3215    Code = bitc::FUNC_CODE_INST_EXTRACTELT;3216    pushValueAndType(I.getOperand(0), InstID, Vals);3217    pushValueAndType(I.getOperand(1), InstID, Vals);3218    break;3219  case Instruction::InsertElement:3220    Code = bitc::FUNC_CODE_INST_INSERTELT;3221    pushValueAndType(I.getOperand(0), InstID, Vals);3222    pushValue(I.getOperand(1), InstID, Vals);3223    pushValueAndType(I.getOperand(2), InstID, Vals);3224    break;3225  case Instruction::ShuffleVector:3226    Code = bitc::FUNC_CODE_INST_SHUFFLEVEC;3227    pushValueAndType(I.getOperand(0), InstID, Vals);3228    pushValue(I.getOperand(1), InstID, Vals);3229    pushValue(cast<ShuffleVectorInst>(I).getShuffleMaskForBitcode(), InstID,3230              Vals);3231    break;3232  case Instruction::ICmp:3233  case Instruction::FCmp: {3234    // compare returning Int1Ty or vector of Int1Ty3235    Code = bitc::FUNC_CODE_INST_CMP2;3236    AbbrevToUse = FUNCTION_INST_CMP_ABBREV;3237    if (pushValueAndType(I.getOperand(0), InstID, Vals))3238      AbbrevToUse = 0;3239    pushValue(I.getOperand(1), InstID, Vals);3240    Vals.push_back(cast<CmpInst>(I).getPredicate());3241    uint64_t Flags = getOptimizationFlags(&I);3242    if (Flags != 0) {3243      Vals.push_back(Flags);3244      if (AbbrevToUse)3245        AbbrevToUse = FUNCTION_INST_CMP_FLAGS_ABBREV;3246    }3247    break;3248  }3249 3250  case Instruction::Ret:3251    {3252      Code = bitc::FUNC_CODE_INST_RET;3253      unsigned NumOperands = I.getNumOperands();3254      if (NumOperands == 0)3255        AbbrevToUse = FUNCTION_INST_RET_VOID_ABBREV;3256      else if (NumOperands == 1) {3257        if (!pushValueAndType(I.getOperand(0), InstID, Vals))3258          AbbrevToUse = FUNCTION_INST_RET_VAL_ABBREV;3259      } else {3260        for (const Value *Op : I.operands())3261          pushValueAndType(Op, InstID, Vals);3262      }3263    }3264    break;3265  case Instruction::Br:3266    {3267      Code = bitc::FUNC_CODE_INST_BR;3268      AbbrevToUse = FUNCTION_INST_BR_UNCOND_ABBREV;3269      const BranchInst &II = cast<BranchInst>(I);3270      Vals.push_back(VE.getValueID(II.getSuccessor(0)));3271      if (II.isConditional()) {3272        Vals.push_back(VE.getValueID(II.getSuccessor(1)));3273        pushValue(II.getCondition(), InstID, Vals);3274        AbbrevToUse = FUNCTION_INST_BR_COND_ABBREV;3275      }3276    }3277    break;3278  case Instruction::Switch:3279    {3280      Code = bitc::FUNC_CODE_INST_SWITCH;3281      const SwitchInst &SI = cast<SwitchInst>(I);3282      Vals.push_back(VE.getTypeID(SI.getCondition()->getType()));3283      pushValue(SI.getCondition(), InstID, Vals);3284      Vals.push_back(VE.getValueID(SI.getDefaultDest()));3285      for (auto Case : SI.cases()) {3286        Vals.push_back(VE.getValueID(Case.getCaseValue()));3287        Vals.push_back(VE.getValueID(Case.getCaseSuccessor()));3288      }3289    }3290    break;3291  case Instruction::IndirectBr:3292    Code = bitc::FUNC_CODE_INST_INDIRECTBR;3293    Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));3294    // Encode the address operand as relative, but not the basic blocks.3295    pushValue(I.getOperand(0), InstID, Vals);3296    for (const Value *Op : drop_begin(I.operands()))3297      Vals.push_back(VE.getValueID(Op));3298    break;3299 3300  case Instruction::Invoke: {3301    const InvokeInst *II = cast<InvokeInst>(&I);3302    const Value *Callee = II->getCalledOperand();3303    FunctionType *FTy = II->getFunctionType();3304 3305    if (II->hasOperandBundles())3306      writeOperandBundles(*II, InstID);3307 3308    Code = bitc::FUNC_CODE_INST_INVOKE;3309 3310    Vals.push_back(VE.getAttributeListID(II->getAttributes()));3311    Vals.push_back(II->getCallingConv() | 1 << 13);3312    Vals.push_back(VE.getValueID(II->getNormalDest()));3313    Vals.push_back(VE.getValueID(II->getUnwindDest()));3314    Vals.push_back(VE.getTypeID(FTy));3315    pushValueAndType(Callee, InstID, Vals);3316 3317    // Emit value #'s for the fixed parameters.3318    for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)3319      pushValue(I.getOperand(i), InstID, Vals); // fixed param.3320 3321    // Emit type/value pairs for varargs params.3322    if (FTy->isVarArg()) {3323      for (unsigned i = FTy->getNumParams(), e = II->arg_size(); i != e; ++i)3324        pushValueAndType(I.getOperand(i), InstID, Vals); // vararg3325    }3326    break;3327  }3328  case Instruction::Resume:3329    Code = bitc::FUNC_CODE_INST_RESUME;3330    pushValueAndType(I.getOperand(0), InstID, Vals);3331    break;3332  case Instruction::CleanupRet: {3333    Code = bitc::FUNC_CODE_INST_CLEANUPRET;3334    const auto &CRI = cast<CleanupReturnInst>(I);3335    pushValue(CRI.getCleanupPad(), InstID, Vals);3336    if (CRI.hasUnwindDest())3337      Vals.push_back(VE.getValueID(CRI.getUnwindDest()));3338    break;3339  }3340  case Instruction::CatchRet: {3341    Code = bitc::FUNC_CODE_INST_CATCHRET;3342    const auto &CRI = cast<CatchReturnInst>(I);3343    pushValue(CRI.getCatchPad(), InstID, Vals);3344    Vals.push_back(VE.getValueID(CRI.getSuccessor()));3345    break;3346  }3347  case Instruction::CleanupPad:3348  case Instruction::CatchPad: {3349    const auto &FuncletPad = cast<FuncletPadInst>(I);3350    Code = isa<CatchPadInst>(FuncletPad) ? bitc::FUNC_CODE_INST_CATCHPAD3351                                         : bitc::FUNC_CODE_INST_CLEANUPPAD;3352    pushValue(FuncletPad.getParentPad(), InstID, Vals);3353 3354    unsigned NumArgOperands = FuncletPad.arg_size();3355    Vals.push_back(NumArgOperands);3356    for (unsigned Op = 0; Op != NumArgOperands; ++Op)3357      pushValueAndType(FuncletPad.getArgOperand(Op), InstID, Vals);3358    break;3359  }3360  case Instruction::CatchSwitch: {3361    Code = bitc::FUNC_CODE_INST_CATCHSWITCH;3362    const auto &CatchSwitch = cast<CatchSwitchInst>(I);3363 3364    pushValue(CatchSwitch.getParentPad(), InstID, Vals);3365 3366    unsigned NumHandlers = CatchSwitch.getNumHandlers();3367    Vals.push_back(NumHandlers);3368    for (const BasicBlock *CatchPadBB : CatchSwitch.handlers())3369      Vals.push_back(VE.getValueID(CatchPadBB));3370 3371    if (CatchSwitch.hasUnwindDest())3372      Vals.push_back(VE.getValueID(CatchSwitch.getUnwindDest()));3373    break;3374  }3375  case Instruction::CallBr: {3376    const CallBrInst *CBI = cast<CallBrInst>(&I);3377    const Value *Callee = CBI->getCalledOperand();3378    FunctionType *FTy = CBI->getFunctionType();3379 3380    if (CBI->hasOperandBundles())3381      writeOperandBundles(*CBI, InstID);3382 3383    Code = bitc::FUNC_CODE_INST_CALLBR;3384 3385    Vals.push_back(VE.getAttributeListID(CBI->getAttributes()));3386 3387    Vals.push_back(CBI->getCallingConv() << bitc::CALL_CCONV |3388                   1 << bitc::CALL_EXPLICIT_TYPE);3389 3390    Vals.push_back(VE.getValueID(CBI->getDefaultDest()));3391    Vals.push_back(CBI->getNumIndirectDests());3392    for (unsigned i = 0, e = CBI->getNumIndirectDests(); i != e; ++i)3393      Vals.push_back(VE.getValueID(CBI->getIndirectDest(i)));3394 3395    Vals.push_back(VE.getTypeID(FTy));3396    pushValueAndType(Callee, InstID, Vals);3397 3398    // Emit value #'s for the fixed parameters.3399    for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)3400      pushValue(I.getOperand(i), InstID, Vals); // fixed param.3401 3402    // Emit type/value pairs for varargs params.3403    if (FTy->isVarArg()) {3404      for (unsigned i = FTy->getNumParams(), e = CBI->arg_size(); i != e; ++i)3405        pushValueAndType(I.getOperand(i), InstID, Vals); // vararg3406    }3407    break;3408  }3409  case Instruction::Unreachable:3410    Code = bitc::FUNC_CODE_INST_UNREACHABLE;3411    AbbrevToUse = FUNCTION_INST_UNREACHABLE_ABBREV;3412    break;3413 3414  case Instruction::PHI: {3415    const PHINode &PN = cast<PHINode>(I);3416    Code = bitc::FUNC_CODE_INST_PHI;3417    // With the newer instruction encoding, forward references could give3418    // negative valued IDs.  This is most common for PHIs, so we use3419    // signed VBRs.3420    SmallVector<uint64_t, 128> Vals64;3421    Vals64.push_back(VE.getTypeID(PN.getType()));3422    for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) {3423      pushValueSigned(PN.getIncomingValue(i), InstID, Vals64);3424      Vals64.push_back(VE.getValueID(PN.getIncomingBlock(i)));3425    }3426 3427    uint64_t Flags = getOptimizationFlags(&I);3428    if (Flags != 0)3429      Vals64.push_back(Flags);3430 3431    // Emit a Vals64 vector and exit.3432    Stream.EmitRecord(Code, Vals64, AbbrevToUse);3433    Vals64.clear();3434    return;3435  }3436 3437  case Instruction::LandingPad: {3438    const LandingPadInst &LP = cast<LandingPadInst>(I);3439    Code = bitc::FUNC_CODE_INST_LANDINGPAD;3440    Vals.push_back(VE.getTypeID(LP.getType()));3441    Vals.push_back(LP.isCleanup());3442    Vals.push_back(LP.getNumClauses());3443    for (unsigned I = 0, E = LP.getNumClauses(); I != E; ++I) {3444      if (LP.isCatch(I))3445        Vals.push_back(LandingPadInst::Catch);3446      else3447        Vals.push_back(LandingPadInst::Filter);3448      pushValueAndType(LP.getClause(I), InstID, Vals);3449    }3450    break;3451  }3452 3453  case Instruction::Alloca: {3454    Code = bitc::FUNC_CODE_INST_ALLOCA;3455    const AllocaInst &AI = cast<AllocaInst>(I);3456    Vals.push_back(VE.getTypeID(AI.getAllocatedType()));3457    Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));3458    Vals.push_back(VE.getValueID(I.getOperand(0))); // size.3459    using APV = AllocaPackedValues;3460    unsigned Record = 0;3461    unsigned EncodedAlign = getEncodedAlign(AI.getAlign());3462    Bitfield::set<APV::AlignLower>(3463        Record, EncodedAlign & ((1 << APV::AlignLower::Bits) - 1));3464    Bitfield::set<APV::AlignUpper>(Record,3465                                   EncodedAlign >> APV::AlignLower::Bits);3466    Bitfield::set<APV::UsedWithInAlloca>(Record, AI.isUsedWithInAlloca());3467    Bitfield::set<APV::ExplicitType>(Record, true);3468    Bitfield::set<APV::SwiftError>(Record, AI.isSwiftError());3469    Vals.push_back(Record);3470 3471    unsigned AS = AI.getAddressSpace();3472    if (AS != M.getDataLayout().getAllocaAddrSpace())3473      Vals.push_back(AS);3474    break;3475  }3476 3477  case Instruction::Load:3478    if (cast<LoadInst>(I).isAtomic()) {3479      Code = bitc::FUNC_CODE_INST_LOADATOMIC;3480      pushValueAndType(I.getOperand(0), InstID, Vals);3481    } else {3482      Code = bitc::FUNC_CODE_INST_LOAD;3483      if (!pushValueAndType(I.getOperand(0), InstID, Vals)) // ptr3484        AbbrevToUse = FUNCTION_INST_LOAD_ABBREV;3485    }3486    Vals.push_back(VE.getTypeID(I.getType()));3487    Vals.push_back(getEncodedAlign(cast<LoadInst>(I).getAlign()));3488    Vals.push_back(cast<LoadInst>(I).isVolatile());3489    if (cast<LoadInst>(I).isAtomic()) {3490      Vals.push_back(getEncodedOrdering(cast<LoadInst>(I).getOrdering()));3491      Vals.push_back(getEncodedSyncScopeID(cast<LoadInst>(I).getSyncScopeID()));3492    }3493    break;3494  case Instruction::Store:3495    if (cast<StoreInst>(I).isAtomic()) {3496      Code = bitc::FUNC_CODE_INST_STOREATOMIC;3497    } else {3498      Code = bitc::FUNC_CODE_INST_STORE;3499      AbbrevToUse = FUNCTION_INST_STORE_ABBREV;3500    }3501    if (pushValueAndType(I.getOperand(1), InstID, Vals)) // ptrty + ptr3502      AbbrevToUse = 0;3503    if (pushValueAndType(I.getOperand(0), InstID, Vals)) // valty + val3504      AbbrevToUse = 0;3505    Vals.push_back(getEncodedAlign(cast<StoreInst>(I).getAlign()));3506    Vals.push_back(cast<StoreInst>(I).isVolatile());3507    if (cast<StoreInst>(I).isAtomic()) {3508      Vals.push_back(getEncodedOrdering(cast<StoreInst>(I).getOrdering()));3509      Vals.push_back(3510          getEncodedSyncScopeID(cast<StoreInst>(I).getSyncScopeID()));3511    }3512    break;3513  case Instruction::AtomicCmpXchg:3514    Code = bitc::FUNC_CODE_INST_CMPXCHG;3515    pushValueAndType(I.getOperand(0), InstID, Vals); // ptrty + ptr3516    pushValueAndType(I.getOperand(1), InstID, Vals); // cmp.3517    pushValue(I.getOperand(2), InstID, Vals);        // newval.3518    Vals.push_back(cast<AtomicCmpXchgInst>(I).isVolatile());3519    Vals.push_back(3520        getEncodedOrdering(cast<AtomicCmpXchgInst>(I).getSuccessOrdering()));3521    Vals.push_back(3522        getEncodedSyncScopeID(cast<AtomicCmpXchgInst>(I).getSyncScopeID()));3523    Vals.push_back(3524        getEncodedOrdering(cast<AtomicCmpXchgInst>(I).getFailureOrdering()));3525    Vals.push_back(cast<AtomicCmpXchgInst>(I).isWeak());3526    Vals.push_back(getEncodedAlign(cast<AtomicCmpXchgInst>(I).getAlign()));3527    break;3528  case Instruction::AtomicRMW:3529    Code = bitc::FUNC_CODE_INST_ATOMICRMW;3530    pushValueAndType(I.getOperand(0), InstID, Vals); // ptrty + ptr3531    pushValueAndType(I.getOperand(1), InstID, Vals); // valty + val3532    Vals.push_back(3533        getEncodedRMWOperation(cast<AtomicRMWInst>(I).getOperation()));3534    Vals.push_back(cast<AtomicRMWInst>(I).isVolatile());3535    Vals.push_back(getEncodedOrdering(cast<AtomicRMWInst>(I).getOrdering()));3536    Vals.push_back(3537        getEncodedSyncScopeID(cast<AtomicRMWInst>(I).getSyncScopeID()));3538    Vals.push_back(getEncodedAlign(cast<AtomicRMWInst>(I).getAlign()));3539    break;3540  case Instruction::Fence:3541    Code = bitc::FUNC_CODE_INST_FENCE;3542    Vals.push_back(getEncodedOrdering(cast<FenceInst>(I).getOrdering()));3543    Vals.push_back(getEncodedSyncScopeID(cast<FenceInst>(I).getSyncScopeID()));3544    break;3545  case Instruction::Call: {3546    const CallInst &CI = cast<CallInst>(I);3547    FunctionType *FTy = CI.getFunctionType();3548 3549    if (CI.hasOperandBundles())3550      writeOperandBundles(CI, InstID);3551 3552    Code = bitc::FUNC_CODE_INST_CALL;3553 3554    Vals.push_back(VE.getAttributeListID(CI.getAttributes()));3555 3556    unsigned Flags = getOptimizationFlags(&I);3557    Vals.push_back(CI.getCallingConv() << bitc::CALL_CCONV |3558                   unsigned(CI.isTailCall()) << bitc::CALL_TAIL |3559                   unsigned(CI.isMustTailCall()) << bitc::CALL_MUSTTAIL |3560                   1 << bitc::CALL_EXPLICIT_TYPE |3561                   unsigned(CI.isNoTailCall()) << bitc::CALL_NOTAIL |3562                   unsigned(Flags != 0) << bitc::CALL_FMF);3563    if (Flags != 0)3564      Vals.push_back(Flags);3565 3566    Vals.push_back(VE.getTypeID(FTy));3567    pushValueAndType(CI.getCalledOperand(), InstID, Vals); // Callee3568 3569    // Emit value #'s for the fixed parameters.3570    for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)3571      pushValue(CI.getArgOperand(i), InstID, Vals); // fixed param.3572 3573    // Emit type/value pairs for varargs params.3574    if (FTy->isVarArg()) {3575      for (unsigned i = FTy->getNumParams(), e = CI.arg_size(); i != e; ++i)3576        pushValueAndType(CI.getArgOperand(i), InstID, Vals); // varargs3577    }3578    break;3579  }3580  case Instruction::VAArg:3581    Code = bitc::FUNC_CODE_INST_VAARG;3582    Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));   // valistty3583    pushValue(I.getOperand(0), InstID, Vals);                   // valist.3584    Vals.push_back(VE.getTypeID(I.getType())); // restype.3585    break;3586  case Instruction::Freeze:3587    Code = bitc::FUNC_CODE_INST_FREEZE;3588    pushValueAndType(I.getOperand(0), InstID, Vals);3589    break;3590  }3591 3592  Stream.EmitRecord(Code, Vals, AbbrevToUse);3593  Vals.clear();3594}3595 3596/// Write a GlobalValue VST to the module. The purpose of this data structure is3597/// to allow clients to efficiently find the function body.3598void ModuleBitcodeWriter::writeGlobalValueSymbolTable(3599  DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex) {3600  // Get the offset of the VST we are writing, and backpatch it into3601  // the VST forward declaration record.3602  uint64_t VSTOffset = Stream.GetCurrentBitNo();3603  // The BitcodeStartBit was the stream offset of the identification block.3604  VSTOffset -= bitcodeStartBit();3605  assert((VSTOffset & 31) == 0 && "VST block not 32-bit aligned");3606  // Note that we add 1 here because the offset is relative to one word3607  // before the start of the identification block, which was historically3608  // always the start of the regular bitcode header.3609  Stream.BackpatchWord(VSTOffsetPlaceholder, VSTOffset / 32 + 1);3610 3611  Stream.EnterSubblock(bitc::VALUE_SYMTAB_BLOCK_ID, 4);3612 3613  auto Abbv = std::make_shared<BitCodeAbbrev>();3614  Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY));3615  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id3616  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset3617  unsigned FnEntryAbbrev = Stream.EmitAbbrev(std::move(Abbv));3618 3619  for (const Function &F : M) {3620    uint64_t Record[2];3621 3622    if (F.isDeclaration())3623      continue;3624 3625    Record[0] = VE.getValueID(&F);3626 3627    // Save the word offset of the function (from the start of the3628    // actual bitcode written to the stream).3629    uint64_t BitcodeIndex = FunctionToBitcodeIndex[&F] - bitcodeStartBit();3630    assert((BitcodeIndex & 31) == 0 && "function block not 32-bit aligned");3631    // Note that we add 1 here because the offset is relative to one word3632    // before the start of the identification block, which was historically3633    // always the start of the regular bitcode header.3634    Record[1] = BitcodeIndex / 32 + 1;3635 3636    Stream.EmitRecord(bitc::VST_CODE_FNENTRY, Record, FnEntryAbbrev);3637  }3638 3639  Stream.ExitBlock();3640}3641 3642/// Emit names for arguments, instructions and basic blocks in a function.3643void ModuleBitcodeWriter::writeFunctionLevelValueSymbolTable(3644    const ValueSymbolTable &VST) {3645  if (VST.empty())3646    return;3647 3648  Stream.EnterSubblock(bitc::VALUE_SYMTAB_BLOCK_ID, 4);3649 3650  // FIXME: Set up the abbrev, we know how many values there are!3651  // FIXME: We know if the type names can use 7-bit ascii.3652  SmallVector<uint64_t, 64> NameVals;3653 3654  for (const ValueName &Name : VST) {3655    // Figure out the encoding to use for the name.3656    StringEncoding Bits = getStringEncoding(Name.getKey());3657 3658    unsigned AbbrevToUse = VST_ENTRY_8_ABBREV;3659    NameVals.push_back(VE.getValueID(Name.getValue()));3660 3661    // VST_CODE_ENTRY:   [valueid, namechar x N]3662    // VST_CODE_BBENTRY: [bbid, namechar x N]3663    unsigned Code;3664    if (isa<BasicBlock>(Name.getValue())) {3665      Code = bitc::VST_CODE_BBENTRY;3666      if (Bits == SE_Char6)3667        AbbrevToUse = VST_BBENTRY_6_ABBREV;3668    } else {3669      Code = bitc::VST_CODE_ENTRY;3670      if (Bits == SE_Char6)3671        AbbrevToUse = VST_ENTRY_6_ABBREV;3672      else if (Bits == SE_Fixed7)3673        AbbrevToUse = VST_ENTRY_7_ABBREV;3674    }3675 3676    for (const auto P : Name.getKey())3677      NameVals.push_back((unsigned char)P);3678 3679    // Emit the finished record.3680    Stream.EmitRecord(Code, NameVals, AbbrevToUse);3681    NameVals.clear();3682  }3683 3684  Stream.ExitBlock();3685}3686 3687void ModuleBitcodeWriter::writeUseList(UseListOrder &&Order) {3688  assert(Order.Shuffle.size() >= 2 && "Shuffle too small");3689  unsigned Code;3690  if (isa<BasicBlock>(Order.V))3691    Code = bitc::USELIST_CODE_BB;3692  else3693    Code = bitc::USELIST_CODE_DEFAULT;3694 3695  SmallVector<uint64_t, 64> Record(Order.Shuffle.begin(), Order.Shuffle.end());3696  Record.push_back(VE.getValueID(Order.V));3697  Stream.EmitRecord(Code, Record);3698}3699 3700void ModuleBitcodeWriter::writeUseListBlock(const Function *F) {3701  assert(VE.shouldPreserveUseListOrder() &&3702         "Expected to be preserving use-list order");3703 3704  auto hasMore = [&]() {3705    return !VE.UseListOrders.empty() && VE.UseListOrders.back().F == F;3706  };3707  if (!hasMore())3708    // Nothing to do.3709    return;3710 3711  Stream.EnterSubblock(bitc::USELIST_BLOCK_ID, 3);3712  while (hasMore()) {3713    writeUseList(std::move(VE.UseListOrders.back()));3714    VE.UseListOrders.pop_back();3715  }3716  Stream.ExitBlock();3717}3718 3719/// Emit a function body to the module stream.3720void ModuleBitcodeWriter::writeFunction(3721    const Function &F,3722    DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex) {3723  // Save the bitcode index of the start of this function block for recording3724  // in the VST.3725  FunctionToBitcodeIndex[&F] = Stream.GetCurrentBitNo();3726 3727  Stream.EnterSubblock(bitc::FUNCTION_BLOCK_ID, 5);3728  VE.incorporateFunction(F);3729 3730  SmallVector<unsigned, 64> Vals;3731 3732  // Emit the number of basic blocks, so the reader can create them ahead of3733  // time.3734  Vals.push_back(VE.getBasicBlocks().size());3735  Stream.EmitRecord(bitc::FUNC_CODE_DECLAREBLOCKS, Vals);3736  Vals.clear();3737 3738  // If there are function-local constants, emit them now.3739  unsigned CstStart, CstEnd;3740  VE.getFunctionConstantRange(CstStart, CstEnd);3741  writeConstants(CstStart, CstEnd, false);3742 3743  // If there is function-local metadata, emit it now.3744  writeFunctionMetadata(F);3745 3746  // Keep a running idea of what the instruction ID is.3747  unsigned InstID = CstEnd;3748 3749  bool NeedsMetadataAttachment = F.hasMetadata();3750 3751  DILocation *LastDL = nullptr;3752  SmallSetVector<Function *, 4> BlockAddressUsers;3753 3754  // Finally, emit all the instructions, in order.3755  for (const BasicBlock &BB : F) {3756    for (const Instruction &I : BB) {3757      writeInstruction(I, InstID, Vals);3758 3759      if (!I.getType()->isVoidTy())3760        ++InstID;3761 3762      // If the instruction has metadata, write a metadata attachment later.3763      NeedsMetadataAttachment |= I.hasMetadataOtherThanDebugLoc();3764 3765      // If the instruction has a debug location, emit it.3766      if (DILocation *DL = I.getDebugLoc()) {3767        if (DL == LastDL) {3768          // Just repeat the same debug loc as last time.3769          Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC_AGAIN, Vals);3770        } else {3771          Vals.push_back(DL->getLine());3772          Vals.push_back(DL->getColumn());3773          Vals.push_back(VE.getMetadataOrNullID(DL->getScope()));3774          Vals.push_back(VE.getMetadataOrNullID(DL->getInlinedAt()));3775          Vals.push_back(DL->isImplicitCode());3776          Vals.push_back(DL->getAtomGroup());3777          Vals.push_back(DL->getAtomRank());3778          Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC, Vals,3779                            FUNCTION_DEBUG_LOC_ABBREV);3780          Vals.clear();3781          LastDL = DL;3782        }3783      }3784 3785      // If the instruction has DbgRecords attached to it, emit them. Note that3786      // they come after the instruction so that it's easy to attach them again3787      // when reading the bitcode, even though conceptually the debug locations3788      // start "before" the instruction.3789      if (I.hasDbgRecords()) {3790        /// Try to push the value only (unwrapped), otherwise push the3791        /// metadata wrapped value. Returns true if the value was pushed3792        /// without the ValueAsMetadata wrapper.3793        auto PushValueOrMetadata = [&Vals, InstID,3794                                    this](Metadata *RawLocation) {3795          assert(RawLocation &&3796                 "RawLocation unexpectedly null in DbgVariableRecord");3797          if (ValueAsMetadata *VAM = dyn_cast<ValueAsMetadata>(RawLocation)) {3798            SmallVector<unsigned, 2> ValAndType;3799            // If the value is a fwd-ref the type is also pushed. We don't3800            // want the type, so fwd-refs are kept wrapped (pushValueAndType3801            // returns false if the value is pushed without type).3802            if (!pushValueAndType(VAM->getValue(), InstID, ValAndType)) {3803              Vals.push_back(ValAndType[0]);3804              return true;3805            }3806          }3807          // The metadata is a DIArgList, or ValueAsMetadata wrapping a3808          // fwd-ref. Push the metadata ID.3809          Vals.push_back(VE.getMetadataID(RawLocation));3810          return false;3811        };3812 3813        // Write out non-instruction debug information attached to this3814        // instruction. Write it after the instruction so that it's easy to3815        // re-attach to the instruction reading the records in.3816        for (DbgRecord &DR : I.DebugMarker->getDbgRecordRange()) {3817          if (DbgLabelRecord *DLR = dyn_cast<DbgLabelRecord>(&DR)) {3818            Vals.push_back(VE.getMetadataID(&*DLR->getDebugLoc()));3819            Vals.push_back(VE.getMetadataID(DLR->getLabel()));3820            Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_RECORD_LABEL, Vals);3821            Vals.clear();3822            continue;3823          }3824 3825          // First 3 fields are common to all kinds:3826          //   DILocation, DILocalVariable, DIExpression3827          // dbg_value (FUNC_CODE_DEBUG_RECORD_VALUE)3828          //   ..., LocationMetadata3829          // dbg_value (FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE - abbrev'd)3830          //   ..., Value3831          // dbg_declare (FUNC_CODE_DEBUG_RECORD_DECLARE)3832          //   ..., LocationMetadata3833          // dbg_assign (FUNC_CODE_DEBUG_RECORD_ASSIGN)3834          //   ..., LocationMetadata, DIAssignID, DIExpression, LocationMetadata3835          DbgVariableRecord &DVR = cast<DbgVariableRecord>(DR);3836          Vals.push_back(VE.getMetadataID(&*DVR.getDebugLoc()));3837          Vals.push_back(VE.getMetadataID(DVR.getVariable()));3838          Vals.push_back(VE.getMetadataID(DVR.getExpression()));3839          if (DVR.isDbgValue()) {3840            if (PushValueOrMetadata(DVR.getRawLocation()))3841              Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE, Vals,3842                                FUNCTION_DEBUG_RECORD_VALUE_ABBREV);3843            else3844              Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_RECORD_VALUE, Vals);3845          } else if (DVR.isDbgDeclare()) {3846            Vals.push_back(VE.getMetadataID(DVR.getRawLocation()));3847            Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_RECORD_DECLARE, Vals);3848          } else if (DVR.isDbgDeclareValue()) {3849            Vals.push_back(VE.getMetadataID(DVR.getRawLocation()));3850            Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_RECORD_DECLARE_VALUE, Vals);3851          } else {3852            assert(DVR.isDbgAssign() && "Unexpected DbgRecord kind");3853            Vals.push_back(VE.getMetadataID(DVR.getRawLocation()));3854            Vals.push_back(VE.getMetadataID(DVR.getAssignID()));3855            Vals.push_back(VE.getMetadataID(DVR.getAddressExpression()));3856            Vals.push_back(VE.getMetadataID(DVR.getRawAddress()));3857            Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_RECORD_ASSIGN, Vals);3858          }3859          Vals.clear();3860        }3861      }3862    }3863 3864    if (BlockAddress *BA = BlockAddress::lookup(&BB)) {3865      SmallVector<Value *> Worklist{BA};3866      SmallPtrSet<Value *, 8> Visited{BA};3867      while (!Worklist.empty()) {3868        Value *V = Worklist.pop_back_val();3869        for (User *U : V->users()) {3870          if (auto *I = dyn_cast<Instruction>(U)) {3871            Function *P = I->getFunction();3872            if (P != &F)3873              BlockAddressUsers.insert(P);3874          } else if (isa<Constant>(U) && !isa<GlobalValue>(U) &&3875                     Visited.insert(U).second)3876            Worklist.push_back(U);3877        }3878      }3879    }3880  }3881 3882  if (!BlockAddressUsers.empty()) {3883    Vals.resize(BlockAddressUsers.size());3884    for (auto I : llvm::enumerate(BlockAddressUsers))3885      Vals[I.index()] = VE.getValueID(I.value());3886    Stream.EmitRecord(bitc::FUNC_CODE_BLOCKADDR_USERS, Vals);3887    Vals.clear();3888  }3889 3890  // Emit names for all the instructions etc.3891  if (auto *Symtab = F.getValueSymbolTable())3892    writeFunctionLevelValueSymbolTable(*Symtab);3893 3894  if (NeedsMetadataAttachment)3895    writeFunctionMetadataAttachment(F);3896  if (VE.shouldPreserveUseListOrder())3897    writeUseListBlock(&F);3898  VE.purgeFunction();3899  Stream.ExitBlock();3900}3901 3902// Emit blockinfo, which defines the standard abbreviations etc.3903void ModuleBitcodeWriter::writeBlockInfo() {3904  // We only want to emit block info records for blocks that have multiple3905  // instances: CONSTANTS_BLOCK, FUNCTION_BLOCK and VALUE_SYMTAB_BLOCK.3906  // Other blocks can define their abbrevs inline.3907  Stream.EnterBlockInfoBlock();3908 3909  // Encode type indices using fixed size based on number of types.3910  BitCodeAbbrevOp TypeAbbrevOp(BitCodeAbbrevOp::Fixed,3911                               VE.computeBitsRequiredForTypeIndices());3912  // Encode value indices as 6-bit VBR.3913  BitCodeAbbrevOp ValAbbrevOp(BitCodeAbbrevOp::VBR, 6);3914 3915  { // 8-bit fixed-width VST_CODE_ENTRY/VST_CODE_BBENTRY strings.3916    auto Abbv = std::make_shared<BitCodeAbbrev>();3917    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));3918    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));3919    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));3920    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));3921    if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID, Abbv) !=3922        VST_ENTRY_8_ABBREV)3923      llvm_unreachable("Unexpected abbrev ordering!");3924  }3925 3926  { // 7-bit fixed width VST_CODE_ENTRY strings.3927    auto Abbv = std::make_shared<BitCodeAbbrev>();3928    Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY));3929    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));3930    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));3931    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));3932    if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID, Abbv) !=3933        VST_ENTRY_7_ABBREV)3934      llvm_unreachable("Unexpected abbrev ordering!");3935  }3936  { // 6-bit char6 VST_CODE_ENTRY strings.3937    auto Abbv = std::make_shared<BitCodeAbbrev>();3938    Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY));3939    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));3940    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));3941    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));3942    if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID, Abbv) !=3943        VST_ENTRY_6_ABBREV)3944      llvm_unreachable("Unexpected abbrev ordering!");3945  }3946  { // 6-bit char6 VST_CODE_BBENTRY strings.3947    auto Abbv = std::make_shared<BitCodeAbbrev>();3948    Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_BBENTRY));3949    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));3950    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));3951    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));3952    if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID, Abbv) !=3953        VST_BBENTRY_6_ABBREV)3954      llvm_unreachable("Unexpected abbrev ordering!");3955  }3956 3957  { // SETTYPE abbrev for CONSTANTS_BLOCK.3958    auto Abbv = std::make_shared<BitCodeAbbrev>();3959    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_SETTYPE));3960    Abbv->Add(TypeAbbrevOp);3961    if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, Abbv) !=3962        CONSTANTS_SETTYPE_ABBREV)3963      llvm_unreachable("Unexpected abbrev ordering!");3964  }3965 3966  { // INTEGER abbrev for CONSTANTS_BLOCK.3967    auto Abbv = std::make_shared<BitCodeAbbrev>();3968    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_INTEGER));3969    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));3970    if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, Abbv) !=3971        CONSTANTS_INTEGER_ABBREV)3972      llvm_unreachable("Unexpected abbrev ordering!");3973  }3974 3975  { // CE_CAST abbrev for CONSTANTS_BLOCK.3976    auto Abbv = std::make_shared<BitCodeAbbrev>();3977    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CE_CAST));3978    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4));  // cast opc3979    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,       // typeid3980                              VE.computeBitsRequiredForTypeIndices()));3981    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));    // value id3982 3983    if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, Abbv) !=3984        CONSTANTS_CE_CAST_Abbrev)3985      llvm_unreachable("Unexpected abbrev ordering!");3986  }3987  { // NULL abbrev for CONSTANTS_BLOCK.3988    auto Abbv = std::make_shared<BitCodeAbbrev>();3989    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_NULL));3990    if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, Abbv) !=3991        CONSTANTS_NULL_Abbrev)3992      llvm_unreachable("Unexpected abbrev ordering!");3993  }3994 3995  // FIXME: This should only use space for first class types!3996 3997  { // INST_LOAD abbrev for FUNCTION_BLOCK.3998    auto Abbv = std::make_shared<BitCodeAbbrev>();3999    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_LOAD));4000    Abbv->Add(ValAbbrevOp); // Ptr4001    Abbv->Add(TypeAbbrevOp); // dest ty4002    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // Align4003    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // volatile4004    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4005        FUNCTION_INST_LOAD_ABBREV)4006      llvm_unreachable("Unexpected abbrev ordering!");4007  }4008  {4009    auto Abbv = std::make_shared<BitCodeAbbrev>();4010    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_STORE));4011    Abbv->Add(ValAbbrevOp);                                // op14012    Abbv->Add(ValAbbrevOp);                                // op04013    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // align4014    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // volatile4015    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4016        FUNCTION_INST_STORE_ABBREV)4017      llvm_unreachable("Unexpected abbrev ordering!");4018  }4019  { // INST_UNOP abbrev for FUNCTION_BLOCK.4020    auto Abbv = std::make_shared<BitCodeAbbrev>();4021    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_UNOP));4022    Abbv->Add(ValAbbrevOp); // LHS4023    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc4024    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4025        FUNCTION_INST_UNOP_ABBREV)4026      llvm_unreachable("Unexpected abbrev ordering!");4027  }4028  { // INST_UNOP_FLAGS abbrev for FUNCTION_BLOCK.4029    auto Abbv = std::make_shared<BitCodeAbbrev>();4030    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_UNOP));4031    Abbv->Add(ValAbbrevOp); // LHS4032    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc4033    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); // flags4034    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4035        FUNCTION_INST_UNOP_FLAGS_ABBREV)4036      llvm_unreachable("Unexpected abbrev ordering!");4037  }4038  { // INST_BINOP abbrev for FUNCTION_BLOCK.4039    auto Abbv = std::make_shared<BitCodeAbbrev>();4040    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_BINOP));4041    Abbv->Add(ValAbbrevOp); // LHS4042    Abbv->Add(ValAbbrevOp); // RHS4043    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc4044    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4045        FUNCTION_INST_BINOP_ABBREV)4046      llvm_unreachable("Unexpected abbrev ordering!");4047  }4048  { // INST_BINOP_FLAGS abbrev for FUNCTION_BLOCK.4049    auto Abbv = std::make_shared<BitCodeAbbrev>();4050    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_BINOP));4051    Abbv->Add(ValAbbrevOp); // LHS4052    Abbv->Add(ValAbbrevOp); // RHS4053    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc4054    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); // flags4055    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4056        FUNCTION_INST_BINOP_FLAGS_ABBREV)4057      llvm_unreachable("Unexpected abbrev ordering!");4058  }4059  { // INST_CAST abbrev for FUNCTION_BLOCK.4060    auto Abbv = std::make_shared<BitCodeAbbrev>();4061    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_CAST));4062    Abbv->Add(ValAbbrevOp); // OpVal4063    Abbv->Add(TypeAbbrevOp); // dest ty4064    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc4065    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4066        FUNCTION_INST_CAST_ABBREV)4067      llvm_unreachable("Unexpected abbrev ordering!");4068  }4069  { // INST_CAST_FLAGS abbrev for FUNCTION_BLOCK.4070    auto Abbv = std::make_shared<BitCodeAbbrev>();4071    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_CAST));4072    Abbv->Add(ValAbbrevOp); // OpVal4073    Abbv->Add(TypeAbbrevOp); // dest ty4074    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc4075    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); // flags4076    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4077        FUNCTION_INST_CAST_FLAGS_ABBREV)4078      llvm_unreachable("Unexpected abbrev ordering!");4079  }4080 4081  { // INST_RET abbrev for FUNCTION_BLOCK.4082    auto Abbv = std::make_shared<BitCodeAbbrev>();4083    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_RET));4084    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4085        FUNCTION_INST_RET_VOID_ABBREV)4086      llvm_unreachable("Unexpected abbrev ordering!");4087  }4088  { // INST_RET abbrev for FUNCTION_BLOCK.4089    auto Abbv = std::make_shared<BitCodeAbbrev>();4090    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_RET));4091    Abbv->Add(ValAbbrevOp);4092    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4093        FUNCTION_INST_RET_VAL_ABBREV)4094      llvm_unreachable("Unexpected abbrev ordering!");4095  }4096  {4097    auto Abbv = std::make_shared<BitCodeAbbrev>();4098    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_BR));4099    // TODO: Use different abbrev for absolute value reference (succ0)?4100    Abbv->Add(ValAbbrevOp); // succ04101    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4102        FUNCTION_INST_BR_UNCOND_ABBREV)4103      llvm_unreachable("Unexpected abbrev ordering!");4104  }4105  {4106    auto Abbv = std::make_shared<BitCodeAbbrev>();4107    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_BR));4108    // TODO: Use different abbrev for absolute value references (succ0, succ1)?4109    Abbv->Add(ValAbbrevOp); // succ04110    Abbv->Add(ValAbbrevOp); // succ14111    Abbv->Add(ValAbbrevOp); // cond4112    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4113        FUNCTION_INST_BR_COND_ABBREV)4114      llvm_unreachable("Unexpected abbrev ordering!");4115  }4116  { // INST_UNREACHABLE abbrev for FUNCTION_BLOCK.4117    auto Abbv = std::make_shared<BitCodeAbbrev>();4118    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_UNREACHABLE));4119    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4120        FUNCTION_INST_UNREACHABLE_ABBREV)4121      llvm_unreachable("Unexpected abbrev ordering!");4122  }4123  {4124    auto Abbv = std::make_shared<BitCodeAbbrev>();4125    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_GEP));4126    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // flags4127    Abbv->Add(TypeAbbrevOp); // dest ty4128    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));4129    Abbv->Add(ValAbbrevOp);4130    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4131        FUNCTION_INST_GEP_ABBREV)4132      llvm_unreachable("Unexpected abbrev ordering!");4133  }4134  {4135    auto Abbv = std::make_shared<BitCodeAbbrev>();4136    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_CMP2));4137    Abbv->Add(ValAbbrevOp);                                // op04138    Abbv->Add(ValAbbrevOp);                                // op14139    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 6)); // pred4140    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4141        FUNCTION_INST_CMP_ABBREV)4142      llvm_unreachable("Unexpected abbrev ordering!");4143  }4144  {4145    auto Abbv = std::make_shared<BitCodeAbbrev>();4146    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_CMP2));4147    Abbv->Add(ValAbbrevOp);                                // op04148    Abbv->Add(ValAbbrevOp);                                // op14149    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 6)); // pred4150    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); // flags4151    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4152        FUNCTION_INST_CMP_FLAGS_ABBREV)4153      llvm_unreachable("Unexpected abbrev ordering!");4154  }4155  {4156    auto Abbv = std::make_shared<BitCodeAbbrev>();4157    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE));4158    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7)); // dbgloc4159    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7)); // var4160    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7)); // expr4161    Abbv->Add(ValAbbrevOp); // val4162    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4163        FUNCTION_DEBUG_RECORD_VALUE_ABBREV)4164      llvm_unreachable("Unexpected abbrev ordering! 1");4165  }4166  {4167    auto Abbv = std::make_shared<BitCodeAbbrev>();4168    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_DEBUG_LOC));4169    // NOTE: No IsDistinct field for FUNC_CODE_DEBUG_LOC.4170    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));4171    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));4172    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));4173    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));4174    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));4175    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Atom group.4176    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 3)); // Atom rank.4177    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=4178        FUNCTION_DEBUG_LOC_ABBREV)4179      llvm_unreachable("Unexpected abbrev ordering!");4180  }4181  Stream.ExitBlock();4182}4183 4184/// Write the module path strings, currently only used when generating4185/// a combined index file.4186void IndexBitcodeWriter::writeModStrings() {4187  Stream.EnterSubblock(bitc::MODULE_STRTAB_BLOCK_ID, 3);4188 4189  // TODO: See which abbrev sizes we actually need to emit4190 4191  // 8-bit fixed-width MST_ENTRY strings.4192  auto Abbv = std::make_shared<BitCodeAbbrev>();4193  Abbv->Add(BitCodeAbbrevOp(bitc::MST_CODE_ENTRY));4194  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));4195  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));4196  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));4197  unsigned Abbrev8Bit = Stream.EmitAbbrev(std::move(Abbv));4198 4199  // 7-bit fixed width MST_ENTRY strings.4200  Abbv = std::make_shared<BitCodeAbbrev>();4201  Abbv->Add(BitCodeAbbrevOp(bitc::MST_CODE_ENTRY));4202  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));4203  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));4204  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));4205  unsigned Abbrev7Bit = Stream.EmitAbbrev(std::move(Abbv));4206 4207  // 6-bit char6 MST_ENTRY strings.4208  Abbv = std::make_shared<BitCodeAbbrev>();4209  Abbv->Add(BitCodeAbbrevOp(bitc::MST_CODE_ENTRY));4210  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));4211  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));4212  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));4213  unsigned Abbrev6Bit = Stream.EmitAbbrev(std::move(Abbv));4214 4215  // Module Hash, 160 bits SHA1. Optionally, emitted after each MST_CODE_ENTRY.4216  Abbv = std::make_shared<BitCodeAbbrev>();4217  Abbv->Add(BitCodeAbbrevOp(bitc::MST_CODE_HASH));4218  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));4219  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));4220  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));4221  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));4222  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));4223  unsigned AbbrevHash = Stream.EmitAbbrev(std::move(Abbv));4224 4225  SmallVector<unsigned, 64> Vals;4226  forEachModule([&](const StringMapEntry<ModuleHash> &MPSE) {4227    StringRef Key = MPSE.getKey();4228    const auto &Hash = MPSE.getValue();4229    StringEncoding Bits = getStringEncoding(Key);4230    unsigned AbbrevToUse = Abbrev8Bit;4231    if (Bits == SE_Char6)4232      AbbrevToUse = Abbrev6Bit;4233    else if (Bits == SE_Fixed7)4234      AbbrevToUse = Abbrev7Bit;4235 4236    auto ModuleId = ModuleIdMap.size();4237    ModuleIdMap[Key] = ModuleId;4238    Vals.push_back(ModuleId);4239    Vals.append(Key.begin(), Key.end());4240 4241    // Emit the finished record.4242    Stream.EmitRecord(bitc::MST_CODE_ENTRY, Vals, AbbrevToUse);4243 4244    // Emit an optional hash for the module now4245    if (llvm::any_of(Hash, [](uint32_t H) { return H; })) {4246      Vals.assign(Hash.begin(), Hash.end());4247      // Emit the hash record.4248      Stream.EmitRecord(bitc::MST_CODE_HASH, Vals, AbbrevHash);4249    }4250 4251    Vals.clear();4252  });4253  Stream.ExitBlock();4254}4255 4256/// Write the function type metadata related records that need to appear before4257/// a function summary entry (whether per-module or combined).4258template <typename Fn>4259static void writeFunctionTypeMetadataRecords(BitstreamWriter &Stream,4260                                             FunctionSummary *FS,4261                                             Fn GetValueID) {4262  if (!FS->type_tests().empty())4263    Stream.EmitRecord(bitc::FS_TYPE_TESTS, FS->type_tests());4264 4265  SmallVector<uint64_t, 64> Record;4266 4267  auto WriteVFuncIdVec = [&](uint64_t Ty,4268                             ArrayRef<FunctionSummary::VFuncId> VFs) {4269    if (VFs.empty())4270      return;4271    Record.clear();4272    for (auto &VF : VFs) {4273      Record.push_back(VF.GUID);4274      Record.push_back(VF.Offset);4275    }4276    Stream.EmitRecord(Ty, Record);4277  };4278 4279  WriteVFuncIdVec(bitc::FS_TYPE_TEST_ASSUME_VCALLS,4280                  FS->type_test_assume_vcalls());4281  WriteVFuncIdVec(bitc::FS_TYPE_CHECKED_LOAD_VCALLS,4282                  FS->type_checked_load_vcalls());4283 4284  auto WriteConstVCallVec = [&](uint64_t Ty,4285                                ArrayRef<FunctionSummary::ConstVCall> VCs) {4286    for (auto &VC : VCs) {4287      Record.clear();4288      Record.push_back(VC.VFunc.GUID);4289      Record.push_back(VC.VFunc.Offset);4290      llvm::append_range(Record, VC.Args);4291      Stream.EmitRecord(Ty, Record);4292    }4293  };4294 4295  WriteConstVCallVec(bitc::FS_TYPE_TEST_ASSUME_CONST_VCALL,4296                     FS->type_test_assume_const_vcalls());4297  WriteConstVCallVec(bitc::FS_TYPE_CHECKED_LOAD_CONST_VCALL,4298                     FS->type_checked_load_const_vcalls());4299 4300  auto WriteRange = [&](ConstantRange Range) {4301    Range = Range.sextOrTrunc(FunctionSummary::ParamAccess::RangeWidth);4302    assert(Range.getLower().getNumWords() == 1);4303    assert(Range.getUpper().getNumWords() == 1);4304    emitSignedInt64(Record, *Range.getLower().getRawData());4305    emitSignedInt64(Record, *Range.getUpper().getRawData());4306  };4307 4308  if (!FS->paramAccesses().empty()) {4309    Record.clear();4310    for (auto &Arg : FS->paramAccesses()) {4311      size_t UndoSize = Record.size();4312      Record.push_back(Arg.ParamNo);4313      WriteRange(Arg.Use);4314      Record.push_back(Arg.Calls.size());4315      for (auto &Call : Arg.Calls) {4316        Record.push_back(Call.ParamNo);4317        std::optional<unsigned> ValueID = GetValueID(Call.Callee);4318        if (!ValueID) {4319          // If ValueID is unknown we can't drop just this call, we must drop4320          // entire parameter.4321          Record.resize(UndoSize);4322          break;4323        }4324        Record.push_back(*ValueID);4325        WriteRange(Call.Offsets);4326      }4327    }4328    if (!Record.empty())4329      Stream.EmitRecord(bitc::FS_PARAM_ACCESS, Record);4330  }4331}4332 4333/// Collect type IDs from type tests used by function.4334static void4335getReferencedTypeIds(FunctionSummary *FS,4336                     std::set<GlobalValue::GUID> &ReferencedTypeIds) {4337  if (!FS->type_tests().empty())4338    for (auto &TT : FS->type_tests())4339      ReferencedTypeIds.insert(TT);4340 4341  auto GetReferencedTypesFromVFuncIdVec =4342      [&](ArrayRef<FunctionSummary::VFuncId> VFs) {4343        for (auto &VF : VFs)4344          ReferencedTypeIds.insert(VF.GUID);4345      };4346 4347  GetReferencedTypesFromVFuncIdVec(FS->type_test_assume_vcalls());4348  GetReferencedTypesFromVFuncIdVec(FS->type_checked_load_vcalls());4349 4350  auto GetReferencedTypesFromConstVCallVec =4351      [&](ArrayRef<FunctionSummary::ConstVCall> VCs) {4352        for (auto &VC : VCs)4353          ReferencedTypeIds.insert(VC.VFunc.GUID);4354      };4355 4356  GetReferencedTypesFromConstVCallVec(FS->type_test_assume_const_vcalls());4357  GetReferencedTypesFromConstVCallVec(FS->type_checked_load_const_vcalls());4358}4359 4360static void writeWholeProgramDevirtResolutionByArg(4361    SmallVector<uint64_t, 64> &NameVals, const std::vector<uint64_t> &args,4362    const WholeProgramDevirtResolution::ByArg &ByArg) {4363  NameVals.push_back(args.size());4364  llvm::append_range(NameVals, args);4365 4366  NameVals.push_back(ByArg.TheKind);4367  NameVals.push_back(ByArg.Info);4368  NameVals.push_back(ByArg.Byte);4369  NameVals.push_back(ByArg.Bit);4370}4371 4372static void writeWholeProgramDevirtResolution(4373    SmallVector<uint64_t, 64> &NameVals, StringTableBuilder &StrtabBuilder,4374    uint64_t Id, const WholeProgramDevirtResolution &Wpd) {4375  NameVals.push_back(Id);4376 4377  NameVals.push_back(Wpd.TheKind);4378  NameVals.push_back(StrtabBuilder.add(Wpd.SingleImplName));4379  NameVals.push_back(Wpd.SingleImplName.size());4380 4381  NameVals.push_back(Wpd.ResByArg.size());4382  for (auto &A : Wpd.ResByArg)4383    writeWholeProgramDevirtResolutionByArg(NameVals, A.first, A.second);4384}4385 4386static void writeTypeIdSummaryRecord(SmallVector<uint64_t, 64> &NameVals,4387                                     StringTableBuilder &StrtabBuilder,4388                                     StringRef Id,4389                                     const TypeIdSummary &Summary) {4390  NameVals.push_back(StrtabBuilder.add(Id));4391  NameVals.push_back(Id.size());4392 4393  NameVals.push_back(Summary.TTRes.TheKind);4394  NameVals.push_back(Summary.TTRes.SizeM1BitWidth);4395  NameVals.push_back(Summary.TTRes.AlignLog2);4396  NameVals.push_back(Summary.TTRes.SizeM1);4397  NameVals.push_back(Summary.TTRes.BitMask);4398  NameVals.push_back(Summary.TTRes.InlineBits);4399 4400  for (auto &W : Summary.WPDRes)4401    writeWholeProgramDevirtResolution(NameVals, StrtabBuilder, W.first,4402                                      W.second);4403}4404 4405static void writeTypeIdCompatibleVtableSummaryRecord(4406    SmallVector<uint64_t, 64> &NameVals, StringTableBuilder &StrtabBuilder,4407    StringRef Id, const TypeIdCompatibleVtableInfo &Summary,4408    ValueEnumerator &VE) {4409  NameVals.push_back(StrtabBuilder.add(Id));4410  NameVals.push_back(Id.size());4411 4412  for (auto &P : Summary) {4413    NameVals.push_back(P.AddressPointOffset);4414    NameVals.push_back(VE.getValueID(P.VTableVI.getValue()));4415  }4416}4417 4418// Adds the allocation contexts to the CallStacks map. We simply use the4419// size at the time the context was added as the CallStackId. This works because4420// when we look up the call stacks later on we process the function summaries4421// and their allocation records in the same exact order.4422static void collectMemProfCallStacks(4423    FunctionSummary *FS, std::function<LinearFrameId(unsigned)> GetStackIndex,4424    MapVector<CallStackId, llvm::SmallVector<LinearFrameId>> &CallStacks) {4425  // The interfaces in ProfileData/MemProf.h use a type alias for a stack frame4426  // id offset into the index of the full stack frames. The ModuleSummaryIndex4427  // currently uses unsigned. Make sure these stay in sync.4428  static_assert(std::is_same_v<LinearFrameId, unsigned>);4429  for (auto &AI : FS->allocs()) {4430    for (auto &MIB : AI.MIBs) {4431      SmallVector<unsigned> StackIdIndices;4432      StackIdIndices.reserve(MIB.StackIdIndices.size());4433      for (auto Id : MIB.StackIdIndices)4434        StackIdIndices.push_back(GetStackIndex(Id));4435      // The CallStackId is the size at the time this context was inserted.4436      CallStacks.insert({CallStacks.size(), StackIdIndices});4437    }4438  }4439}4440 4441// Build the radix tree from the accumulated CallStacks, write out the resulting4442// linearized radix tree array, and return the map of call stack positions into4443// this array for use when writing the allocation records. The returned map is4444// indexed by a CallStackId which in this case is implicitly determined by the4445// order of function summaries and their allocation infos being written.4446static DenseMap<CallStackId, LinearCallStackId> writeMemoryProfileRadixTree(4447    MapVector<CallStackId, llvm::SmallVector<LinearFrameId>> &&CallStacks,4448    BitstreamWriter &Stream, unsigned RadixAbbrev) {4449  assert(!CallStacks.empty());4450  DenseMap<unsigned, FrameStat> FrameHistogram =4451      computeFrameHistogram<LinearFrameId>(CallStacks);4452  CallStackRadixTreeBuilder<LinearFrameId> Builder;4453  // We don't need a MemProfFrameIndexes map as we have already converted the4454  // full stack id hash to a linear offset into the StackIds array.4455  Builder.build(std::move(CallStacks), /*MemProfFrameIndexes=*/nullptr,4456                FrameHistogram);4457  Stream.EmitRecord(bitc::FS_CONTEXT_RADIX_TREE_ARRAY, Builder.getRadixArray(),4458                    RadixAbbrev);4459  return Builder.takeCallStackPos();4460}4461 4462static void writeFunctionHeapProfileRecords(4463    BitstreamWriter &Stream, FunctionSummary *FS, unsigned CallsiteAbbrev,4464    unsigned AllocAbbrev, unsigned ContextIdAbbvId, bool PerModule,4465    std::function<unsigned(const ValueInfo &VI)> GetValueID,4466    std::function<unsigned(unsigned)> GetStackIndex,4467    bool WriteContextSizeInfoIndex,4468    DenseMap<CallStackId, LinearCallStackId> &CallStackPos,4469    CallStackId &CallStackCount) {4470  SmallVector<uint64_t> Record;4471 4472  for (auto &CI : FS->callsites()) {4473    Record.clear();4474    // Per module callsite clones should always have a single entry of4475    // value 0.4476    assert(!PerModule || (CI.Clones.size() == 1 && CI.Clones[0] == 0));4477    Record.push_back(GetValueID(CI.Callee));4478    if (!PerModule) {4479      Record.push_back(CI.StackIdIndices.size());4480      Record.push_back(CI.Clones.size());4481    }4482    for (auto Id : CI.StackIdIndices)4483      Record.push_back(GetStackIndex(Id));4484    if (!PerModule)4485      llvm::append_range(Record, CI.Clones);4486    Stream.EmitRecord(PerModule ? bitc::FS_PERMODULE_CALLSITE_INFO4487                                : bitc::FS_COMBINED_CALLSITE_INFO,4488                      Record, CallsiteAbbrev);4489  }4490 4491  for (auto &AI : FS->allocs()) {4492    Record.clear();4493    // Per module alloc versions should always have a single entry of4494    // value 0.4495    assert(!PerModule || (AI.Versions.size() == 1 && AI.Versions[0] == 0));4496    Record.push_back(AI.MIBs.size());4497    if (!PerModule)4498      Record.push_back(AI.Versions.size());4499    for (auto &MIB : AI.MIBs) {4500      Record.push_back((uint8_t)MIB.AllocType);4501      // The per-module summary always needs to include the alloc context, as we4502      // use it during the thin link. For the combined index it is optional (see4503      // comments where CombinedIndexMemProfContext is defined).4504      if (PerModule || CombinedIndexMemProfContext) {4505        // Record the index into the radix tree array for this context.4506        assert(CallStackCount <= CallStackPos.size());4507        Record.push_back(CallStackPos[CallStackCount++]);4508      }4509    }4510    if (!PerModule)4511      llvm::append_range(Record, AI.Versions);4512    assert(AI.ContextSizeInfos.empty() ||4513           AI.ContextSizeInfos.size() == AI.MIBs.size());4514    // Optionally emit the context size information if it exists.4515    if (WriteContextSizeInfoIndex && !AI.ContextSizeInfos.empty()) {4516      // The abbreviation id for the context ids record should have been created4517      // if we are emitting the per-module index, which is where we write this4518      // info.4519      assert(ContextIdAbbvId);4520      SmallVector<uint32_t> ContextIds;4521      // At least one context id per ContextSizeInfos entry (MIB), broken into 24522      // halves.4523      ContextIds.reserve(AI.ContextSizeInfos.size() * 2);4524      for (auto &Infos : AI.ContextSizeInfos) {4525        Record.push_back(Infos.size());4526        for (auto [FullStackId, TotalSize] : Infos) {4527          // The context ids are emitted separately as a fixed width array,4528          // which is more efficient than a VBR given that these hashes are4529          // typically close to 64-bits. The max fixed width entry is 32 bits so4530          // it is split into 2.4531          ContextIds.push_back(static_cast<uint32_t>(FullStackId >> 32));4532          ContextIds.push_back(static_cast<uint32_t>(FullStackId));4533          Record.push_back(TotalSize);4534        }4535      }4536      // The context ids are expected by the reader to immediately precede the4537      // associated alloc info record.4538      Stream.EmitRecord(bitc::FS_ALLOC_CONTEXT_IDS, ContextIds,4539                        ContextIdAbbvId);4540    }4541    Stream.EmitRecord(PerModule4542                          ? bitc::FS_PERMODULE_ALLOC_INFO4543                          : (CombinedIndexMemProfContext4544                                 ? bitc::FS_COMBINED_ALLOC_INFO4545                                 : bitc::FS_COMBINED_ALLOC_INFO_NO_CONTEXT),4546                      Record, AllocAbbrev);4547  }4548}4549 4550// Helper to emit a single function summary record.4551void ModuleBitcodeWriterBase::writePerModuleFunctionSummaryRecord(4552    SmallVector<uint64_t, 64> &NameVals, GlobalValueSummary *Summary,4553    unsigned ValueID, unsigned FSCallsRelBFAbbrev,4554    unsigned FSCallsProfileAbbrev, unsigned CallsiteAbbrev,4555    unsigned AllocAbbrev, unsigned ContextIdAbbvId, const Function &F,4556    DenseMap<CallStackId, LinearCallStackId> &CallStackPos,4557    CallStackId &CallStackCount) {4558  NameVals.push_back(ValueID);4559 4560  FunctionSummary *FS = cast<FunctionSummary>(Summary);4561 4562  writeFunctionTypeMetadataRecords(4563      Stream, FS, [&](const ValueInfo &VI) -> std::optional<unsigned> {4564        return {VE.getValueID(VI.getValue())};4565      });4566 4567  writeFunctionHeapProfileRecords(4568      Stream, FS, CallsiteAbbrev, AllocAbbrev, ContextIdAbbvId,4569      /*PerModule*/ true,4570      /*GetValueId*/ [&](const ValueInfo &VI) { return getValueId(VI); },4571      /*GetStackIndex*/ [&](unsigned I) { return I; },4572      /*WriteContextSizeInfoIndex*/ true, CallStackPos, CallStackCount);4573 4574  auto SpecialRefCnts = FS->specialRefCounts();4575  NameVals.push_back(getEncodedGVSummaryFlags(FS->flags()));4576  NameVals.push_back(FS->instCount());4577  NameVals.push_back(getEncodedFFlags(FS->fflags()));4578  NameVals.push_back(FS->refs().size());4579  NameVals.push_back(SpecialRefCnts.first);  // rorefcnt4580  NameVals.push_back(SpecialRefCnts.second); // worefcnt4581 4582  for (auto &RI : FS->refs())4583    NameVals.push_back(getValueId(RI));4584 4585  const bool UseRelBFRecord =4586      WriteRelBFToSummary && !F.hasProfileData() &&4587      ForceSummaryEdgesCold == FunctionSummary::FSHT_None;4588  for (auto &ECI : FS->calls()) {4589    NameVals.push_back(getValueId(ECI.first));4590    if (UseRelBFRecord)4591      NameVals.push_back(getEncodedRelBFCallEdgeInfo(ECI.second));4592    else4593      NameVals.push_back(getEncodedHotnessCallEdgeInfo(ECI.second));4594  }4595 4596  unsigned FSAbbrev =4597      (UseRelBFRecord ? FSCallsRelBFAbbrev : FSCallsProfileAbbrev);4598  unsigned Code =4599      (UseRelBFRecord ? bitc::FS_PERMODULE_RELBF : bitc::FS_PERMODULE_PROFILE);4600 4601  // Emit the finished record.4602  Stream.EmitRecord(Code, NameVals, FSAbbrev);4603  NameVals.clear();4604}4605 4606// Collect the global value references in the given variable's initializer,4607// and emit them in a summary record.4608void ModuleBitcodeWriterBase::writeModuleLevelReferences(4609    const GlobalVariable &V, SmallVector<uint64_t, 64> &NameVals,4610    unsigned FSModRefsAbbrev, unsigned FSModVTableRefsAbbrev) {4611  auto VI = Index->getValueInfo(V.getGUID());4612  if (!VI || VI.getSummaryList().empty()) {4613    // Only declarations should not have a summary (a declaration might however4614    // have a summary if the def was in module level asm).4615    assert(V.isDeclaration());4616    return;4617  }4618  auto *Summary = VI.getSummaryList()[0].get();4619  NameVals.push_back(VE.getValueID(&V));4620  GlobalVarSummary *VS = cast<GlobalVarSummary>(Summary);4621  NameVals.push_back(getEncodedGVSummaryFlags(VS->flags()));4622  NameVals.push_back(getEncodedGVarFlags(VS->varflags()));4623 4624  auto VTableFuncs = VS->vTableFuncs();4625  if (!VTableFuncs.empty())4626    NameVals.push_back(VS->refs().size());4627 4628  unsigned SizeBeforeRefs = NameVals.size();4629  for (auto &RI : VS->refs())4630    NameVals.push_back(VE.getValueID(RI.getValue()));4631  // Sort the refs for determinism output, the vector returned by FS->refs() has4632  // been initialized from a DenseSet.4633  llvm::sort(drop_begin(NameVals, SizeBeforeRefs));4634 4635  if (VTableFuncs.empty())4636    Stream.EmitRecord(bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS, NameVals,4637                      FSModRefsAbbrev);4638  else {4639    // VTableFuncs pairs should already be sorted by offset.4640    for (auto &P : VTableFuncs) {4641      NameVals.push_back(VE.getValueID(P.FuncVI.getValue()));4642      NameVals.push_back(P.VTableOffset);4643    }4644 4645    Stream.EmitRecord(bitc::FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS, NameVals,4646                      FSModVTableRefsAbbrev);4647  }4648  NameVals.clear();4649}4650 4651/// Emit the per-module summary section alongside the rest of4652/// the module's bitcode.4653void ModuleBitcodeWriterBase::writePerModuleGlobalValueSummary() {4654  // By default we compile with ThinLTO if the module has a summary, but the4655  // client can request full LTO with a module flag.4656  bool IsThinLTO = true;4657  if (auto *MD =4658          mdconst::extract_or_null<ConstantInt>(M.getModuleFlag("ThinLTO")))4659    IsThinLTO = MD->getZExtValue();4660  Stream.EnterSubblock(IsThinLTO ? bitc::GLOBALVAL_SUMMARY_BLOCK_ID4661                                 : bitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID,4662                       4);4663 4664  Stream.EmitRecord(4665      bitc::FS_VERSION,4666      ArrayRef<uint64_t>{ModuleSummaryIndex::BitcodeSummaryVersion});4667 4668  // Write the index flags.4669  uint64_t Flags = 0;4670  // Bits 1-3 are set only in the combined index, skip them.4671  if (Index->enableSplitLTOUnit())4672    Flags |= 0x8;4673  if (Index->hasUnifiedLTO())4674    Flags |= 0x200;4675 4676  Stream.EmitRecord(bitc::FS_FLAGS, ArrayRef<uint64_t>{Flags});4677 4678  if (Index->begin() == Index->end()) {4679    Stream.ExitBlock();4680    return;4681  }4682 4683  auto Abbv = std::make_shared<BitCodeAbbrev>();4684  Abbv->Add(BitCodeAbbrevOp(bitc::FS_VALUE_GUID));4685  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));4686  // GUIDS often use up most of 64-bits, so encode as two Fixed 32.4687  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));4688  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));4689  unsigned ValueGuidAbbrev = Stream.EmitAbbrev(std::move(Abbv));4690 4691  for (const auto &GVI : valueIds()) {4692    Stream.EmitRecord(bitc::FS_VALUE_GUID,4693                      ArrayRef<uint32_t>{GVI.second,4694                                         static_cast<uint32_t>(GVI.first >> 32),4695                                         static_cast<uint32_t>(GVI.first)},4696                      ValueGuidAbbrev);4697  }4698 4699  if (!Index->stackIds().empty()) {4700    auto StackIdAbbv = std::make_shared<BitCodeAbbrev>();4701    StackIdAbbv->Add(BitCodeAbbrevOp(bitc::FS_STACK_IDS));4702    // numids x stackid4703    StackIdAbbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));4704    // The stack ids are hashes that are close to 64 bits in size, so emitting4705    // as a pair of 32-bit fixed-width values is more efficient than a VBR.4706    StackIdAbbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));4707    unsigned StackIdAbbvId = Stream.EmitAbbrev(std::move(StackIdAbbv));4708    SmallVector<uint32_t> Vals;4709    Vals.reserve(Index->stackIds().size() * 2);4710    for (auto Id : Index->stackIds()) {4711      Vals.push_back(static_cast<uint32_t>(Id >> 32));4712      Vals.push_back(static_cast<uint32_t>(Id));4713    }4714    Stream.EmitRecord(bitc::FS_STACK_IDS, Vals, StackIdAbbvId);4715  }4716 4717  unsigned ContextIdAbbvId = 0;4718  if (metadataMayIncludeContextSizeInfo()) {4719    // n x context id4720    auto ContextIdAbbv = std::make_shared<BitCodeAbbrev>();4721    ContextIdAbbv->Add(BitCodeAbbrevOp(bitc::FS_ALLOC_CONTEXT_IDS));4722    ContextIdAbbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));4723    // The context ids are hashes that are close to 64 bits in size, so emitting4724    // as a pair of 32-bit fixed-width values is more efficient than a VBR if we4725    // are emitting them for all MIBs. Otherwise we use VBR to better compress 04726    // values that are expected to more frequently occur in an alloc's memprof4727    // summary.4728    if (metadataIncludesAllContextSizeInfo())4729      ContextIdAbbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));4730    else4731      ContextIdAbbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));4732    ContextIdAbbvId = Stream.EmitAbbrev(std::move(ContextIdAbbv));4733  }4734 4735  // Abbrev for FS_PERMODULE_PROFILE.4736  Abbv = std::make_shared<BitCodeAbbrev>();4737  Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_PROFILE));4738  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid4739  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // flags4740  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // instcount4741  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // fflags4742  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // numrefs4743  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // rorefcnt4744  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // worefcnt4745  // numrefs x valueid, n x (valueid, hotness+tailcall flags)4746  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));4747  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));4748  unsigned FSCallsProfileAbbrev = Stream.EmitAbbrev(std::move(Abbv));4749 4750  // Abbrev for FS_PERMODULE_RELBF.4751  Abbv = std::make_shared<BitCodeAbbrev>();4752  Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_RELBF));4753  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid4754  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags4755  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // instcount4756  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // fflags4757  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // numrefs4758  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // rorefcnt4759  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // worefcnt4760  // numrefs x valueid, n x (valueid, rel_block_freq+tailcall])4761  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));4762  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));4763  unsigned FSCallsRelBFAbbrev = Stream.EmitAbbrev(std::move(Abbv));4764 4765  // Abbrev for FS_PERMODULE_GLOBALVAR_INIT_REFS.4766  Abbv = std::make_shared<BitCodeAbbrev>();4767  Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS));4768  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid4769  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags4770  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));  // valueids4771  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));4772  unsigned FSModRefsAbbrev = Stream.EmitAbbrev(std::move(Abbv));4773 4774  // Abbrev for FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS.4775  Abbv = std::make_shared<BitCodeAbbrev>();4776  Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS));4777  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid4778  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags4779  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs4780  // numrefs x valueid, n x (valueid , offset)4781  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));4782  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));4783  unsigned FSModVTableRefsAbbrev = Stream.EmitAbbrev(std::move(Abbv));4784 4785  // Abbrev for FS_ALIAS.4786  Abbv = std::make_shared<BitCodeAbbrev>();4787  Abbv->Add(BitCodeAbbrevOp(bitc::FS_ALIAS));4788  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid4789  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags4790  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid4791  unsigned FSAliasAbbrev = Stream.EmitAbbrev(std::move(Abbv));4792 4793  // Abbrev for FS_TYPE_ID_METADATA4794  Abbv = std::make_shared<BitCodeAbbrev>();4795  Abbv->Add(BitCodeAbbrevOp(bitc::FS_TYPE_ID_METADATA));4796  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // typeid strtab index4797  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // typeid length4798  // n x (valueid , offset)4799  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));4800  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));4801  unsigned TypeIdCompatibleVtableAbbrev = Stream.EmitAbbrev(std::move(Abbv));4802 4803  Abbv = std::make_shared<BitCodeAbbrev>();4804  Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_CALLSITE_INFO));4805  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid4806  // n x stackidindex4807  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));4808  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));4809  unsigned CallsiteAbbrev = Stream.EmitAbbrev(std::move(Abbv));4810 4811  Abbv = std::make_shared<BitCodeAbbrev>();4812  Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_ALLOC_INFO));4813  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // nummib4814  // n x (alloc type, context radix tree index)4815  // optional: nummib x (numcontext x total size)4816  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));4817  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));4818  unsigned AllocAbbrev = Stream.EmitAbbrev(std::move(Abbv));4819 4820  Abbv = std::make_shared<BitCodeAbbrev>();4821  Abbv->Add(BitCodeAbbrevOp(bitc::FS_CONTEXT_RADIX_TREE_ARRAY));4822  // n x entry4823  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));4824  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));4825  unsigned RadixAbbrev = Stream.EmitAbbrev(std::move(Abbv));4826 4827  // First walk through all the functions and collect the allocation contexts in4828  // their associated summaries, for use in constructing a radix tree of4829  // contexts. Note that we need to do this in the same order as the functions4830  // are processed further below since the call stack positions in the resulting4831  // radix tree array are identified based on this order.4832  MapVector<CallStackId, llvm::SmallVector<LinearFrameId>> CallStacks;4833  for (const Function &F : M) {4834    // Summary emission does not support anonymous functions, they have to be4835    // renamed using the anonymous function renaming pass.4836    if (!F.hasName())4837      report_fatal_error("Unexpected anonymous function when writing summary");4838 4839    ValueInfo VI = Index->getValueInfo(F.getGUID());4840    if (!VI || VI.getSummaryList().empty()) {4841      // Only declarations should not have a summary (a declaration might4842      // however have a summary if the def was in module level asm).4843      assert(F.isDeclaration());4844      continue;4845    }4846    auto *Summary = VI.getSummaryList()[0].get();4847    FunctionSummary *FS = cast<FunctionSummary>(Summary);4848    collectMemProfCallStacks(4849        FS, /*GetStackIndex*/ [](unsigned I) { return I; }, CallStacks);4850  }4851  // Finalize the radix tree, write it out, and get the map of positions in the4852  // linearized tree array.4853  DenseMap<CallStackId, LinearCallStackId> CallStackPos;4854  if (!CallStacks.empty()) {4855    CallStackPos =4856        writeMemoryProfileRadixTree(std::move(CallStacks), Stream, RadixAbbrev);4857  }4858 4859  // Keep track of the current index into the CallStackPos map.4860  CallStackId CallStackCount = 0;4861 4862  SmallVector<uint64_t, 64> NameVals;4863  // Iterate over the list of functions instead of the Index to4864  // ensure the ordering is stable.4865  for (const Function &F : M) {4866    // Summary emission does not support anonymous functions, they have to4867    // renamed using the anonymous function renaming pass.4868    if (!F.hasName())4869      report_fatal_error("Unexpected anonymous function when writing summary");4870 4871    ValueInfo VI = Index->getValueInfo(F.getGUID());4872    if (!VI || VI.getSummaryList().empty()) {4873      // Only declarations should not have a summary (a declaration might4874      // however have a summary if the def was in module level asm).4875      assert(F.isDeclaration());4876      continue;4877    }4878    auto *Summary = VI.getSummaryList()[0].get();4879    writePerModuleFunctionSummaryRecord(4880        NameVals, Summary, VE.getValueID(&F), FSCallsRelBFAbbrev,4881        FSCallsProfileAbbrev, CallsiteAbbrev, AllocAbbrev, ContextIdAbbvId, F,4882        CallStackPos, CallStackCount);4883  }4884 4885  // Capture references from GlobalVariable initializers, which are outside4886  // of a function scope.4887  for (const GlobalVariable &G : M.globals())4888    writeModuleLevelReferences(G, NameVals, FSModRefsAbbrev,4889                               FSModVTableRefsAbbrev);4890 4891  for (const GlobalAlias &A : M.aliases()) {4892    auto *Aliasee = A.getAliaseeObject();4893    // Skip ifunc and nameless functions which don't have an entry in the4894    // summary.4895    if (!Aliasee->hasName() || isa<GlobalIFunc>(Aliasee))4896      continue;4897    auto AliasId = VE.getValueID(&A);4898    auto AliaseeId = VE.getValueID(Aliasee);4899    NameVals.push_back(AliasId);4900    auto *Summary = Index->getGlobalValueSummary(A);4901    AliasSummary *AS = cast<AliasSummary>(Summary);4902    NameVals.push_back(getEncodedGVSummaryFlags(AS->flags()));4903    NameVals.push_back(AliaseeId);4904    Stream.EmitRecord(bitc::FS_ALIAS, NameVals, FSAliasAbbrev);4905    NameVals.clear();4906  }4907 4908  for (auto &S : Index->typeIdCompatibleVtableMap()) {4909    writeTypeIdCompatibleVtableSummaryRecord(NameVals, StrtabBuilder, S.first,4910                                             S.second, VE);4911    Stream.EmitRecord(bitc::FS_TYPE_ID_METADATA, NameVals,4912                      TypeIdCompatibleVtableAbbrev);4913    NameVals.clear();4914  }4915 4916  if (Index->getBlockCount())4917    Stream.EmitRecord(bitc::FS_BLOCK_COUNT,4918                      ArrayRef<uint64_t>{Index->getBlockCount()});4919 4920  Stream.ExitBlock();4921}4922 4923/// Emit the combined summary section into the combined index file.4924void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {4925  Stream.EnterSubblock(bitc::GLOBALVAL_SUMMARY_BLOCK_ID, 4);4926  Stream.EmitRecord(4927      bitc::FS_VERSION,4928      ArrayRef<uint64_t>{ModuleSummaryIndex::BitcodeSummaryVersion});4929 4930  // Write the index flags.4931  Stream.EmitRecord(bitc::FS_FLAGS, ArrayRef<uint64_t>{Index.getFlags()});4932 4933  auto Abbv = std::make_shared<BitCodeAbbrev>();4934  Abbv->Add(BitCodeAbbrevOp(bitc::FS_VALUE_GUID));4935  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));4936  // GUIDS often use up most of 64-bits, so encode as two Fixed 32.4937  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));4938  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));4939  unsigned ValueGuidAbbrev = Stream.EmitAbbrev(std::move(Abbv));4940 4941  for (const auto &GVI : valueIds()) {4942    Stream.EmitRecord(bitc::FS_VALUE_GUID,4943                      ArrayRef<uint32_t>{GVI.second,4944                                         static_cast<uint32_t>(GVI.first >> 32),4945                                         static_cast<uint32_t>(GVI.first)},4946                      ValueGuidAbbrev);4947  }4948 4949  // Write the stack ids used by this index, which will be a subset of those in4950  // the full index in the case of distributed indexes.4951  if (!StackIds.empty()) {4952    auto StackIdAbbv = std::make_shared<BitCodeAbbrev>();4953    StackIdAbbv->Add(BitCodeAbbrevOp(bitc::FS_STACK_IDS));4954    // numids x stackid4955    StackIdAbbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));4956    // The stack ids are hashes that are close to 64 bits in size, so emitting4957    // as a pair of 32-bit fixed-width values is more efficient than a VBR.4958    StackIdAbbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));4959    unsigned StackIdAbbvId = Stream.EmitAbbrev(std::move(StackIdAbbv));4960    SmallVector<uint32_t> Vals;4961    Vals.reserve(StackIds.size() * 2);4962    for (auto Id : StackIds) {4963      Vals.push_back(static_cast<uint32_t>(Id >> 32));4964      Vals.push_back(static_cast<uint32_t>(Id));4965    }4966    Stream.EmitRecord(bitc::FS_STACK_IDS, Vals, StackIdAbbvId);4967  }4968 4969  // Abbrev for FS_COMBINED_PROFILE.4970  Abbv = std::make_shared<BitCodeAbbrev>();4971  Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_PROFILE));4972  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid4973  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // modid4974  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags4975  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // instcount4976  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // fflags4977  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // entrycount4978  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // numrefs4979  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // rorefcnt4980  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // worefcnt4981  // numrefs x valueid, n x (valueid, hotness+tailcall flags)4982  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));4983  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));4984  unsigned FSCallsProfileAbbrev = Stream.EmitAbbrev(std::move(Abbv));4985 4986  // Abbrev for FS_COMBINED_GLOBALVAR_INIT_REFS.4987  Abbv = std::make_shared<BitCodeAbbrev>();4988  Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_GLOBALVAR_INIT_REFS));4989  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid4990  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // modid4991  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags4992  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));    // valueids4993  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));4994  unsigned FSModRefsAbbrev = Stream.EmitAbbrev(std::move(Abbv));4995 4996  // Abbrev for FS_COMBINED_ALIAS.4997  Abbv = std::make_shared<BitCodeAbbrev>();4998  Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_ALIAS));4999  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid5000  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // modid5001  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags5002  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid5003  unsigned FSAliasAbbrev = Stream.EmitAbbrev(std::move(Abbv));5004 5005  Abbv = std::make_shared<BitCodeAbbrev>();5006  Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_CALLSITE_INFO));5007  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid5008  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numstackindices5009  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numver5010  // numstackindices x stackidindex, numver x version5011  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));5012  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));5013  unsigned CallsiteAbbrev = Stream.EmitAbbrev(std::move(Abbv));5014 5015  Abbv = std::make_shared<BitCodeAbbrev>();5016  Abbv->Add(BitCodeAbbrevOp(CombinedIndexMemProfContext5017                                ? bitc::FS_COMBINED_ALLOC_INFO5018                                : bitc::FS_COMBINED_ALLOC_INFO_NO_CONTEXT));5019  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // nummib5020  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numver5021  // nummib x (alloc type, context radix tree index),5022  // numver x version5023  // optional: nummib x total size5024  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));5025  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));5026  unsigned AllocAbbrev = Stream.EmitAbbrev(std::move(Abbv));5027 5028  auto shouldImportValueAsDecl = [&](GlobalValueSummary *GVS) -> bool {5029    if (DecSummaries == nullptr)5030      return false;5031    return DecSummaries->count(GVS);5032  };5033 5034  // The aliases are emitted as a post-pass, and will point to the value5035  // id of the aliasee. Save them in a vector for post-processing.5036  SmallVector<AliasSummary *, 64> Aliases;5037 5038  // Save the value id for each summary for alias emission.5039  DenseMap<const GlobalValueSummary *, unsigned> SummaryToValueIdMap;5040 5041  SmallVector<uint64_t, 64> NameVals;5042 5043  // Set that will be populated during call to writeFunctionTypeMetadataRecords5044  // with the type ids referenced by this index file.5045  std::set<GlobalValue::GUID> ReferencedTypeIds;5046 5047  // For local linkage, we also emit the original name separately5048  // immediately after the record.5049  auto MaybeEmitOriginalName = [&](GlobalValueSummary &S) {5050    // We don't need to emit the original name if we are writing the index for5051    // distributed backends (in which case ModuleToSummariesForIndex is5052    // non-null). The original name is only needed during the thin link, since5053    // for SamplePGO the indirect call targets for local functions have5054    // have the original name annotated in profile.5055    // Continue to emit it when writing out the entire combined index, which is5056    // used in testing the thin link via llvm-lto.5057    if (ModuleToSummariesForIndex || !GlobalValue::isLocalLinkage(S.linkage()))5058      return;5059    NameVals.push_back(S.getOriginalName());5060    Stream.EmitRecord(bitc::FS_COMBINED_ORIGINAL_NAME, NameVals);5061    NameVals.clear();5062  };5063 5064  DenseMap<CallStackId, LinearCallStackId> CallStackPos;5065  if (CombinedIndexMemProfContext) {5066    Abbv = std::make_shared<BitCodeAbbrev>();5067    Abbv->Add(BitCodeAbbrevOp(bitc::FS_CONTEXT_RADIX_TREE_ARRAY));5068    // n x entry5069    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));5070    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));5071    unsigned RadixAbbrev = Stream.EmitAbbrev(std::move(Abbv));5072 5073    // First walk through all the functions and collect the allocation contexts5074    // in their associated summaries, for use in constructing a radix tree of5075    // contexts. Note that we need to do this in the same order as the functions5076    // are processed further below since the call stack positions in the5077    // resulting radix tree array are identified based on this order.5078    MapVector<CallStackId, llvm::SmallVector<LinearFrameId>> CallStacks;5079    forEachSummary([&](GVInfo I, bool IsAliasee) {5080      // Don't collect this when invoked for an aliasee, as it is not needed for5081      // the alias summary. If the aliasee is to be imported, we will invoke5082      // this separately with IsAliasee=false.5083      if (IsAliasee)5084        return;5085      GlobalValueSummary *S = I.second;5086      assert(S);5087      auto *FS = dyn_cast<FunctionSummary>(S);5088      if (!FS)5089        return;5090      collectMemProfCallStacks(5091          FS,5092          /*GetStackIndex*/5093          [&](unsigned I) {5094            // Get the corresponding index into the list of StackIds actually5095            // being written for this combined index (which may be a subset in5096            // the case of distributed indexes).5097            assert(StackIdIndicesToIndex.contains(I));5098            return StackIdIndicesToIndex[I];5099          },5100          CallStacks);5101    });5102    // Finalize the radix tree, write it out, and get the map of positions in5103    // the linearized tree array.5104    if (!CallStacks.empty()) {5105      CallStackPos = writeMemoryProfileRadixTree(std::move(CallStacks), Stream,5106                                                 RadixAbbrev);5107    }5108  }5109 5110  // Keep track of the current index into the CallStackPos map. Not used if5111  // CombinedIndexMemProfContext is false.5112  CallStackId CallStackCount = 0;5113 5114  DenseSet<GlobalValue::GUID> DefOrUseGUIDs;5115  forEachSummary([&](GVInfo I, bool IsAliasee) {5116    GlobalValueSummary *S = I.second;5117    assert(S);5118    DefOrUseGUIDs.insert(I.first);5119    for (const ValueInfo &VI : S->refs())5120      DefOrUseGUIDs.insert(VI.getGUID());5121 5122    auto ValueId = getValueId(I.first);5123    assert(ValueId);5124    SummaryToValueIdMap[S] = *ValueId;5125 5126    // If this is invoked for an aliasee, we want to record the above5127    // mapping, but then not emit a summary entry (if the aliasee is5128    // to be imported, we will invoke this separately with IsAliasee=false).5129    if (IsAliasee)5130      return;5131 5132    if (auto *AS = dyn_cast<AliasSummary>(S)) {5133      // Will process aliases as a post-pass because the reader wants all5134      // global to be loaded first.5135      Aliases.push_back(AS);5136      return;5137    }5138 5139    if (auto *VS = dyn_cast<GlobalVarSummary>(S)) {5140      NameVals.push_back(*ValueId);5141      assert(ModuleIdMap.count(VS->modulePath()));5142      NameVals.push_back(ModuleIdMap[VS->modulePath()]);5143      NameVals.push_back(5144          getEncodedGVSummaryFlags(VS->flags(), shouldImportValueAsDecl(VS)));5145      NameVals.push_back(getEncodedGVarFlags(VS->varflags()));5146      for (auto &RI : VS->refs()) {5147        auto RefValueId = getValueId(RI.getGUID());5148        if (!RefValueId)5149          continue;5150        NameVals.push_back(*RefValueId);5151      }5152 5153      // Emit the finished record.5154      Stream.EmitRecord(bitc::FS_COMBINED_GLOBALVAR_INIT_REFS, NameVals,5155                        FSModRefsAbbrev);5156      NameVals.clear();5157      MaybeEmitOriginalName(*S);5158      return;5159    }5160 5161    auto GetValueId = [&](const ValueInfo &VI) -> std::optional<unsigned> {5162      if (!VI)5163        return std::nullopt;5164      return getValueId(VI.getGUID());5165    };5166 5167    auto *FS = cast<FunctionSummary>(S);5168    writeFunctionTypeMetadataRecords(Stream, FS, GetValueId);5169    getReferencedTypeIds(FS, ReferencedTypeIds);5170 5171    writeFunctionHeapProfileRecords(5172        Stream, FS, CallsiteAbbrev, AllocAbbrev, /*ContextIdAbbvId*/ 0,5173        /*PerModule*/ false,5174        /*GetValueId*/5175        [&](const ValueInfo &VI) -> unsigned {5176          std::optional<unsigned> ValueID = GetValueId(VI);5177          // This can happen in shared index files for distributed ThinLTO if5178          // the callee function summary is not included. Record 0 which we5179          // will have to deal with conservatively when doing any kind of5180          // validation in the ThinLTO backends.5181          if (!ValueID)5182            return 0;5183          return *ValueID;5184        },5185        /*GetStackIndex*/5186        [&](unsigned I) {5187          // Get the corresponding index into the list of StackIds actually5188          // being written for this combined index (which may be a subset in5189          // the case of distributed indexes).5190          assert(StackIdIndicesToIndex.contains(I));5191          return StackIdIndicesToIndex[I];5192        },5193        /*WriteContextSizeInfoIndex*/ false, CallStackPos, CallStackCount);5194 5195    NameVals.push_back(*ValueId);5196    assert(ModuleIdMap.count(FS->modulePath()));5197    NameVals.push_back(ModuleIdMap[FS->modulePath()]);5198    NameVals.push_back(5199        getEncodedGVSummaryFlags(FS->flags(), shouldImportValueAsDecl(FS)));5200    NameVals.push_back(FS->instCount());5201    NameVals.push_back(getEncodedFFlags(FS->fflags()));5202    // TODO: Stop writing entry count and bump bitcode version.5203    NameVals.push_back(0 /* EntryCount */);5204 5205    // Fill in below5206    NameVals.push_back(0); // numrefs5207    NameVals.push_back(0); // rorefcnt5208    NameVals.push_back(0); // worefcnt5209 5210    unsigned Count = 0, RORefCnt = 0, WORefCnt = 0;5211    for (auto &RI : FS->refs()) {5212      auto RefValueId = getValueId(RI.getGUID());5213      if (!RefValueId)5214        continue;5215      NameVals.push_back(*RefValueId);5216      if (RI.isReadOnly())5217        RORefCnt++;5218      else if (RI.isWriteOnly())5219        WORefCnt++;5220      Count++;5221    }5222    NameVals[6] = Count;5223    NameVals[7] = RORefCnt;5224    NameVals[8] = WORefCnt;5225 5226    for (auto &EI : FS->calls()) {5227      // If this GUID doesn't have a value id, it doesn't have a function5228      // summary and we don't need to record any calls to it.5229      std::optional<unsigned> CallValueId = GetValueId(EI.first);5230      if (!CallValueId)5231        continue;5232      NameVals.push_back(*CallValueId);5233      NameVals.push_back(getEncodedHotnessCallEdgeInfo(EI.second));5234    }5235 5236    // Emit the finished record.5237    Stream.EmitRecord(bitc::FS_COMBINED_PROFILE, NameVals,5238                      FSCallsProfileAbbrev);5239    NameVals.clear();5240    MaybeEmitOriginalName(*S);5241  });5242 5243  for (auto *AS : Aliases) {5244    auto AliasValueId = SummaryToValueIdMap[AS];5245    assert(AliasValueId);5246    NameVals.push_back(AliasValueId);5247    assert(ModuleIdMap.count(AS->modulePath()));5248    NameVals.push_back(ModuleIdMap[AS->modulePath()]);5249    NameVals.push_back(5250        getEncodedGVSummaryFlags(AS->flags(), shouldImportValueAsDecl(AS)));5251    auto AliaseeValueId = SummaryToValueIdMap[&AS->getAliasee()];5252    assert(AliaseeValueId);5253    NameVals.push_back(AliaseeValueId);5254 5255    // Emit the finished record.5256    Stream.EmitRecord(bitc::FS_COMBINED_ALIAS, NameVals, FSAliasAbbrev);5257    NameVals.clear();5258    MaybeEmitOriginalName(*AS);5259 5260    if (auto *FS = dyn_cast<FunctionSummary>(&AS->getAliasee()))5261      getReferencedTypeIds(FS, ReferencedTypeIds);5262  }5263 5264  SmallVector<StringRef, 4> Functions;5265  auto EmitCfiFunctions = [&](const CfiFunctionIndex &CfiIndex,5266                              bitc::GlobalValueSummarySymtabCodes Code) {5267    if (CfiIndex.empty())5268      return;5269    for (GlobalValue::GUID GUID : DefOrUseGUIDs) {5270      auto Defs = CfiIndex.forGuid(GUID);5271      llvm::append_range(Functions, Defs);5272    }5273    if (Functions.empty())5274      return;5275    llvm::sort(Functions);5276    for (const auto &S : Functions) {5277      NameVals.push_back(StrtabBuilder.add(S));5278      NameVals.push_back(S.size());5279    }5280    Stream.EmitRecord(Code, NameVals);5281    NameVals.clear();5282    Functions.clear();5283  };5284 5285  EmitCfiFunctions(Index.cfiFunctionDefs(), bitc::FS_CFI_FUNCTION_DEFS);5286  EmitCfiFunctions(Index.cfiFunctionDecls(), bitc::FS_CFI_FUNCTION_DECLS);5287 5288  // Walk the GUIDs that were referenced, and write the5289  // corresponding type id records.5290  for (auto &T : ReferencedTypeIds) {5291    auto TidIter = Index.typeIds().equal_range(T);5292    for (const auto &[GUID, TypeIdPair] : make_range(TidIter)) {5293      writeTypeIdSummaryRecord(NameVals, StrtabBuilder, TypeIdPair.first,5294                               TypeIdPair.second);5295      Stream.EmitRecord(bitc::FS_TYPE_ID, NameVals);5296      NameVals.clear();5297    }5298  }5299 5300  if (Index.getBlockCount())5301    Stream.EmitRecord(bitc::FS_BLOCK_COUNT,5302                      ArrayRef<uint64_t>{Index.getBlockCount()});5303 5304  Stream.ExitBlock();5305}5306 5307/// Create the "IDENTIFICATION_BLOCK_ID" containing a single string with the5308/// current llvm version, and a record for the epoch number.5309static void writeIdentificationBlock(BitstreamWriter &Stream) {5310  Stream.EnterSubblock(bitc::IDENTIFICATION_BLOCK_ID, 5);5311 5312  // Write the "user readable" string identifying the bitcode producer5313  auto Abbv = std::make_shared<BitCodeAbbrev>();5314  Abbv->Add(BitCodeAbbrevOp(bitc::IDENTIFICATION_CODE_STRING));5315  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));5316  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));5317  auto StringAbbrev = Stream.EmitAbbrev(std::move(Abbv));5318  writeStringRecord(Stream, bitc::IDENTIFICATION_CODE_STRING,5319                    "LLVM" LLVM_VERSION_STRING, StringAbbrev);5320 5321  // Write the epoch version5322  Abbv = std::make_shared<BitCodeAbbrev>();5323  Abbv->Add(BitCodeAbbrevOp(bitc::IDENTIFICATION_CODE_EPOCH));5324  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));5325  auto EpochAbbrev = Stream.EmitAbbrev(std::move(Abbv));5326  constexpr std::array<unsigned, 1> Vals = {{bitc::BITCODE_CURRENT_EPOCH}};5327  Stream.EmitRecord(bitc::IDENTIFICATION_CODE_EPOCH, Vals, EpochAbbrev);5328  Stream.ExitBlock();5329}5330 5331void ModuleBitcodeWriter::writeModuleHash(StringRef View) {5332  // Emit the module's hash.5333  // MODULE_CODE_HASH: [5*i32]5334  if (GenerateHash) {5335    uint32_t Vals[5];5336    Hasher.update(ArrayRef<uint8_t>(5337        reinterpret_cast<const uint8_t *>(View.data()), View.size()));5338    std::array<uint8_t, 20> Hash = Hasher.result();5339    for (int Pos = 0; Pos < 20; Pos += 4) {5340      Vals[Pos / 4] = support::endian::read32be(Hash.data() + Pos);5341    }5342 5343    // Emit the finished record.5344    Stream.EmitRecord(bitc::MODULE_CODE_HASH, Vals);5345 5346    if (ModHash)5347      // Save the written hash value.5348      llvm::copy(Vals, std::begin(*ModHash));5349  }5350}5351 5352void ModuleBitcodeWriter::write() {5353  writeIdentificationBlock(Stream);5354 5355  Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);5356  // We will want to write the module hash at this point. Block any flushing so5357  // we can have access to the whole underlying data later.5358  Stream.markAndBlockFlushing();5359 5360  writeModuleVersion();5361 5362  // Emit blockinfo, which defines the standard abbreviations etc.5363  writeBlockInfo();5364 5365  // Emit information describing all of the types in the module.5366  writeTypeTable();5367 5368  // Emit information about attribute groups.5369  writeAttributeGroupTable();5370 5371  // Emit information about parameter attributes.5372  writeAttributeTable();5373 5374  writeComdats();5375 5376  // Emit top-level description of module, including target triple, inline asm,5377  // descriptors for global variables, and function prototype info.5378  writeModuleInfo();5379 5380  // Emit constants.5381  writeModuleConstants();5382 5383  // Emit metadata kind names.5384  writeModuleMetadataKinds();5385 5386  // Emit metadata.5387  writeModuleMetadata();5388 5389  // Emit module-level use-lists.5390  if (VE.shouldPreserveUseListOrder())5391    writeUseListBlock(nullptr);5392 5393  writeOperandBundleTags();5394  writeSyncScopeNames();5395 5396  // Emit function bodies.5397  DenseMap<const Function *, uint64_t> FunctionToBitcodeIndex;5398  for (const Function &F : M)5399    if (!F.isDeclaration())5400      writeFunction(F, FunctionToBitcodeIndex);5401 5402  // Need to write after the above call to WriteFunction which populates5403  // the summary information in the index.5404  if (Index)5405    writePerModuleGlobalValueSummary();5406 5407  writeGlobalValueSymbolTable(FunctionToBitcodeIndex);5408 5409  writeModuleHash(Stream.getMarkedBufferAndResumeFlushing());5410 5411  Stream.ExitBlock();5412}5413 5414static void writeInt32ToBuffer(uint32_t Value, SmallVectorImpl<char> &Buffer,5415                               uint32_t &Position) {5416  support::endian::write32le(&Buffer[Position], Value);5417  Position += 4;5418}5419 5420/// If generating a bc file on darwin, we have to emit a5421/// header and trailer to make it compatible with the system archiver.  To do5422/// this we emit the following header, and then emit a trailer that pads the5423/// file out to be a multiple of 16 bytes.5424///5425/// struct bc_header {5426///   uint32_t Magic;         // 0x0B17C0DE5427///   uint32_t Version;       // Version, currently always 0.5428///   uint32_t BitcodeOffset; // Offset to traditional bitcode file.5429///   uint32_t BitcodeSize;   // Size of traditional bitcode file.5430///   uint32_t CPUType;       // CPU specifier.5431///   ... potentially more later ...5432/// };5433static void emitDarwinBCHeaderAndTrailer(SmallVectorImpl<char> &Buffer,5434                                         const Triple &TT) {5435  unsigned CPUType = ~0U;5436 5437  // Match x86_64-*, i[3-9]86-*, powerpc-*, powerpc64-*, arm-*, thumb-*,5438  // armv[0-9]-*, thumbv[0-9]-*, armv5te-*, or armv6t2-*. The CPUType is a magic5439  // number from /usr/include/mach/machine.h.  It is ok to reproduce the5440  // specific constants here because they are implicitly part of the Darwin ABI.5441  enum {5442    DARWIN_CPU_ARCH_ABI64      = 0x01000000,5443    DARWIN_CPU_TYPE_X86        = 7,5444    DARWIN_CPU_TYPE_ARM        = 12,5445    DARWIN_CPU_TYPE_POWERPC    = 185446  };5447 5448  Triple::ArchType Arch = TT.getArch();5449  if (Arch == Triple::x86_64)5450    CPUType = DARWIN_CPU_TYPE_X86 | DARWIN_CPU_ARCH_ABI64;5451  else if (Arch == Triple::x86)5452    CPUType = DARWIN_CPU_TYPE_X86;5453  else if (Arch == Triple::ppc)5454    CPUType = DARWIN_CPU_TYPE_POWERPC;5455  else if (Arch == Triple::ppc64)5456    CPUType = DARWIN_CPU_TYPE_POWERPC | DARWIN_CPU_ARCH_ABI64;5457  else if (Arch == Triple::arm || Arch == Triple::thumb)5458    CPUType = DARWIN_CPU_TYPE_ARM;5459 5460  // Traditional Bitcode starts after header.5461  assert(Buffer.size() >= BWH_HeaderSize &&5462         "Expected header size to be reserved");5463  unsigned BCOffset = BWH_HeaderSize;5464  unsigned BCSize = Buffer.size() - BWH_HeaderSize;5465 5466  // Write the magic and version.5467  unsigned Position = 0;5468  writeInt32ToBuffer(0x0B17C0DE, Buffer, Position);5469  writeInt32ToBuffer(0, Buffer, Position); // Version.5470  writeInt32ToBuffer(BCOffset, Buffer, Position);5471  writeInt32ToBuffer(BCSize, Buffer, Position);5472  writeInt32ToBuffer(CPUType, Buffer, Position);5473 5474  // If the file is not a multiple of 16 bytes, insert dummy padding.5475  while (Buffer.size() & 15)5476    Buffer.push_back(0);5477}5478 5479/// Helper to write the header common to all bitcode files.5480static void writeBitcodeHeader(BitstreamWriter &Stream) {5481  // Emit the file header.5482  Stream.Emit((unsigned)'B', 8);5483  Stream.Emit((unsigned)'C', 8);5484  Stream.Emit(0x0, 4);5485  Stream.Emit(0xC, 4);5486  Stream.Emit(0xE, 4);5487  Stream.Emit(0xD, 4);5488}5489 5490BitcodeWriter::BitcodeWriter(SmallVectorImpl<char> &Buffer)5491    : Stream(new BitstreamWriter(Buffer)) {5492  writeBitcodeHeader(*Stream);5493}5494 5495BitcodeWriter::BitcodeWriter(raw_ostream &FS)5496    : Stream(new BitstreamWriter(FS, FlushThreshold)) {5497  writeBitcodeHeader(*Stream);5498}5499 5500BitcodeWriter::~BitcodeWriter() { assert(WroteStrtab); }5501 5502void BitcodeWriter::writeBlob(unsigned Block, unsigned Record, StringRef Blob) {5503  Stream->EnterSubblock(Block, 3);5504 5505  auto Abbv = std::make_shared<BitCodeAbbrev>();5506  Abbv->Add(BitCodeAbbrevOp(Record));5507  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));5508  auto AbbrevNo = Stream->EmitAbbrev(std::move(Abbv));5509 5510  Stream->EmitRecordWithBlob(AbbrevNo, ArrayRef<uint64_t>{Record}, Blob);5511 5512  Stream->ExitBlock();5513}5514 5515void BitcodeWriter::writeSymtab() {5516  assert(!WroteStrtab && !WroteSymtab);5517 5518  // If any module has module-level inline asm, we will require a registered asm5519  // parser for the target so that we can create an accurate symbol table for5520  // the module.5521  for (Module *M : Mods) {5522    if (M->getModuleInlineAsm().empty())5523      continue;5524 5525    std::string Err;5526    const Triple TT(M->getTargetTriple());5527    const Target *T = TargetRegistry::lookupTarget(TT, Err);5528    if (!T || !T->hasMCAsmParser())5529      return;5530  }5531 5532  WroteSymtab = true;5533  SmallVector<char, 0> Symtab;5534  // The irsymtab::build function may be unable to create a symbol table if the5535  // module is malformed (e.g. it contains an invalid alias). Writing a symbol5536  // table is not required for correctness, but we still want to be able to5537  // write malformed modules to bitcode files, so swallow the error.5538  if (Error E = irsymtab::build(Mods, Symtab, StrtabBuilder, Alloc)) {5539    consumeError(std::move(E));5540    return;5541  }5542 5543  writeBlob(bitc::SYMTAB_BLOCK_ID, bitc::SYMTAB_BLOB,5544            {Symtab.data(), Symtab.size()});5545}5546 5547void BitcodeWriter::writeStrtab() {5548  assert(!WroteStrtab);5549 5550  std::vector<char> Strtab;5551  StrtabBuilder.finalizeInOrder();5552  Strtab.resize(StrtabBuilder.getSize());5553  StrtabBuilder.write((uint8_t *)Strtab.data());5554 5555  writeBlob(bitc::STRTAB_BLOCK_ID, bitc::STRTAB_BLOB,5556            {Strtab.data(), Strtab.size()});5557 5558  WroteStrtab = true;5559}5560 5561void BitcodeWriter::copyStrtab(StringRef Strtab) {5562  writeBlob(bitc::STRTAB_BLOCK_ID, bitc::STRTAB_BLOB, Strtab);5563  WroteStrtab = true;5564}5565 5566void BitcodeWriter::writeModule(const Module &M,5567                                bool ShouldPreserveUseListOrder,5568                                const ModuleSummaryIndex *Index,5569                                bool GenerateHash, ModuleHash *ModHash) {5570  assert(!WroteStrtab);5571 5572  // The Mods vector is used by irsymtab::build, which requires non-const5573  // Modules in case it needs to materialize metadata. But the bitcode writer5574  // requires that the module is materialized, so we can cast to non-const here,5575  // after checking that it is in fact materialized.5576  assert(M.isMaterialized());5577  Mods.push_back(const_cast<Module *>(&M));5578 5579  ModuleBitcodeWriter ModuleWriter(M, StrtabBuilder, *Stream,5580                                   ShouldPreserveUseListOrder, Index,5581                                   GenerateHash, ModHash);5582  ModuleWriter.write();5583}5584 5585void BitcodeWriter::writeIndex(5586    const ModuleSummaryIndex *Index,5587    const ModuleToSummariesForIndexTy *ModuleToSummariesForIndex,5588    const GVSummaryPtrSet *DecSummaries) {5589  IndexBitcodeWriter IndexWriter(*Stream, StrtabBuilder, *Index, DecSummaries,5590                                 ModuleToSummariesForIndex);5591  IndexWriter.write();5592}5593 5594/// Write the specified module to the specified output stream.5595void llvm::WriteBitcodeToFile(const Module &M, raw_ostream &Out,5596                              bool ShouldPreserveUseListOrder,5597                              const ModuleSummaryIndex *Index,5598                              bool GenerateHash, ModuleHash *ModHash) {5599  auto Write = [&](BitcodeWriter &Writer) {5600    Writer.writeModule(M, ShouldPreserveUseListOrder, Index, GenerateHash,5601                       ModHash);5602    Writer.writeSymtab();5603    Writer.writeStrtab();5604  };5605  Triple TT(M.getTargetTriple());5606  if (TT.isOSDarwin() || TT.isOSBinFormatMachO()) {5607    // If this is darwin or another generic macho target, reserve space for the5608    // header. Note that the header is computed *after* the output is known, so5609    // we currently explicitly use a buffer, write to it, and then subsequently5610    // flush to Out.5611    SmallVector<char, 0> Buffer;5612    Buffer.reserve(256 * 1024);5613    Buffer.insert(Buffer.begin(), BWH_HeaderSize, 0);5614    BitcodeWriter Writer(Buffer);5615    Write(Writer);5616    emitDarwinBCHeaderAndTrailer(Buffer, TT);5617    Out.write(Buffer.data(), Buffer.size());5618  } else {5619    BitcodeWriter Writer(Out);5620    Write(Writer);5621  }5622}5623 5624void IndexBitcodeWriter::write() {5625  Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);5626 5627  writeModuleVersion();5628 5629  // Write the module paths in the combined index.5630  writeModStrings();5631 5632  // Write the summary combined index records.5633  writeCombinedGlobalValueSummary();5634 5635  Stream.ExitBlock();5636}5637 5638// Write the specified module summary index to the given raw output stream,5639// where it will be written in a new bitcode block. This is used when5640// writing the combined index file for ThinLTO. When writing a subset of the5641// index for a distributed backend, provide a \p ModuleToSummariesForIndex map.5642void llvm::writeIndexToFile(5643    const ModuleSummaryIndex &Index, raw_ostream &Out,5644    const ModuleToSummariesForIndexTy *ModuleToSummariesForIndex,5645    const GVSummaryPtrSet *DecSummaries) {5646  SmallVector<char, 0> Buffer;5647  Buffer.reserve(256 * 1024);5648 5649  BitcodeWriter Writer(Buffer);5650  Writer.writeIndex(&Index, ModuleToSummariesForIndex, DecSummaries);5651  Writer.writeStrtab();5652 5653  Out.write((char *)&Buffer.front(), Buffer.size());5654}5655 5656namespace {5657 5658/// Class to manage the bitcode writing for a thin link bitcode file.5659class ThinLinkBitcodeWriter : public ModuleBitcodeWriterBase {5660  /// ModHash is for use in ThinLTO incremental build, generated while writing5661  /// the module bitcode file.5662  const ModuleHash *ModHash;5663 5664public:5665  ThinLinkBitcodeWriter(const Module &M, StringTableBuilder &StrtabBuilder,5666                        BitstreamWriter &Stream,5667                        const ModuleSummaryIndex &Index,5668                        const ModuleHash &ModHash)5669      : ModuleBitcodeWriterBase(M, StrtabBuilder, Stream,5670                                /*ShouldPreserveUseListOrder=*/false, &Index),5671        ModHash(&ModHash) {}5672 5673  void write();5674 5675private:5676  void writeSimplifiedModuleInfo();5677};5678 5679} // end anonymous namespace5680 5681// This function writes a simpilified module info for thin link bitcode file.5682// It only contains the source file name along with the name(the offset and5683// size in strtab) and linkage for global values. For the global value info5684// entry, in order to keep linkage at offset 5, there are three zeros used5685// as padding.5686void ThinLinkBitcodeWriter::writeSimplifiedModuleInfo() {5687  SmallVector<unsigned, 64> Vals;5688  // Emit the module's source file name.5689  {5690    StringEncoding Bits = getStringEncoding(M.getSourceFileName());5691    BitCodeAbbrevOp AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8);5692    if (Bits == SE_Char6)5693      AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Char6);5694    else if (Bits == SE_Fixed7)5695      AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7);5696 5697    // MODULE_CODE_SOURCE_FILENAME: [namechar x N]5698    auto Abbv = std::make_shared<BitCodeAbbrev>();5699    Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_SOURCE_FILENAME));5700    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));5701    Abbv->Add(AbbrevOpToUse);5702    unsigned FilenameAbbrev = Stream.EmitAbbrev(std::move(Abbv));5703 5704    for (const auto P : M.getSourceFileName())5705      Vals.push_back((unsigned char)P);5706 5707    Stream.EmitRecord(bitc::MODULE_CODE_SOURCE_FILENAME, Vals, FilenameAbbrev);5708    Vals.clear();5709  }5710 5711  // Emit the global variable information.5712  for (const GlobalVariable &GV : M.globals()) {5713    // GLOBALVAR: [strtab offset, strtab size, 0, 0, 0, linkage]5714    Vals.push_back(StrtabBuilder.add(GV.getName()));5715    Vals.push_back(GV.getName().size());5716    Vals.push_back(0);5717    Vals.push_back(0);5718    Vals.push_back(0);5719    Vals.push_back(getEncodedLinkage(GV));5720 5721    Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals);5722    Vals.clear();5723  }5724 5725  // Emit the function proto information.5726  for (const Function &F : M) {5727    // FUNCTION:  [strtab offset, strtab size, 0, 0, 0, linkage]5728    Vals.push_back(StrtabBuilder.add(F.getName()));5729    Vals.push_back(F.getName().size());5730    Vals.push_back(0);5731    Vals.push_back(0);5732    Vals.push_back(0);5733    Vals.push_back(getEncodedLinkage(F));5734 5735    Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals);5736    Vals.clear();5737  }5738 5739  // Emit the alias information.5740  for (const GlobalAlias &A : M.aliases()) {5741    // ALIAS: [strtab offset, strtab size, 0, 0, 0, linkage]5742    Vals.push_back(StrtabBuilder.add(A.getName()));5743    Vals.push_back(A.getName().size());5744    Vals.push_back(0);5745    Vals.push_back(0);5746    Vals.push_back(0);5747    Vals.push_back(getEncodedLinkage(A));5748 5749    Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals);5750    Vals.clear();5751  }5752 5753  // Emit the ifunc information.5754  for (const GlobalIFunc &I : M.ifuncs()) {5755    // IFUNC: [strtab offset, strtab size, 0, 0, 0, linkage]5756    Vals.push_back(StrtabBuilder.add(I.getName()));5757    Vals.push_back(I.getName().size());5758    Vals.push_back(0);5759    Vals.push_back(0);5760    Vals.push_back(0);5761    Vals.push_back(getEncodedLinkage(I));5762 5763    Stream.EmitRecord(bitc::MODULE_CODE_IFUNC, Vals);5764    Vals.clear();5765  }5766}5767 5768void ThinLinkBitcodeWriter::write() {5769  Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);5770 5771  writeModuleVersion();5772 5773  writeSimplifiedModuleInfo();5774 5775  writePerModuleGlobalValueSummary();5776 5777  // Write module hash.5778  Stream.EmitRecord(bitc::MODULE_CODE_HASH, ArrayRef<uint32_t>(*ModHash));5779 5780  Stream.ExitBlock();5781}5782 5783void BitcodeWriter::writeThinLinkBitcode(const Module &M,5784                                         const ModuleSummaryIndex &Index,5785                                         const ModuleHash &ModHash) {5786  assert(!WroteStrtab);5787 5788  // The Mods vector is used by irsymtab::build, which requires non-const5789  // Modules in case it needs to materialize metadata. But the bitcode writer5790  // requires that the module is materialized, so we can cast to non-const here,5791  // after checking that it is in fact materialized.5792  assert(M.isMaterialized());5793  Mods.push_back(const_cast<Module *>(&M));5794 5795  ThinLinkBitcodeWriter ThinLinkWriter(M, StrtabBuilder, *Stream, Index,5796                                       ModHash);5797  ThinLinkWriter.write();5798}5799 5800// Write the specified thin link bitcode file to the given raw output stream,5801// where it will be written in a new bitcode block. This is used when5802// writing the per-module index file for ThinLTO.5803void llvm::writeThinLinkBitcodeToFile(const Module &M, raw_ostream &Out,5804                                      const ModuleSummaryIndex &Index,5805                                      const ModuleHash &ModHash) {5806  SmallVector<char, 0> Buffer;5807  Buffer.reserve(256 * 1024);5808 5809  BitcodeWriter Writer(Buffer);5810  Writer.writeThinLinkBitcode(M, Index, ModHash);5811  Writer.writeSymtab();5812  Writer.writeStrtab();5813 5814  Out.write((char *)&Buffer.front(), Buffer.size());5815}5816 5817static const char *getSectionNameForBitcode(const Triple &T) {5818  switch (T.getObjectFormat()) {5819  case Triple::MachO:5820    return "__LLVM,__bitcode";5821  case Triple::COFF:5822  case Triple::ELF:5823  case Triple::Wasm:5824  case Triple::UnknownObjectFormat:5825    return ".llvmbc";5826  case Triple::GOFF:5827    llvm_unreachable("GOFF is not yet implemented");5828    break;5829  case Triple::SPIRV:5830    if (T.getVendor() == Triple::AMD)5831      return ".llvmbc";5832    llvm_unreachable("SPIRV is not yet implemented");5833    break;5834  case Triple::XCOFF:5835    llvm_unreachable("XCOFF is not yet implemented");5836    break;5837  case Triple::DXContainer:5838    llvm_unreachable("DXContainer is not yet implemented");5839    break;5840  }5841  llvm_unreachable("Unimplemented ObjectFormatType");5842}5843 5844static const char *getSectionNameForCommandline(const Triple &T) {5845  switch (T.getObjectFormat()) {5846  case Triple::MachO:5847    return "__LLVM,__cmdline";5848  case Triple::COFF:5849  case Triple::ELF:5850  case Triple::Wasm:5851  case Triple::UnknownObjectFormat:5852    return ".llvmcmd";5853  case Triple::GOFF:5854    llvm_unreachable("GOFF is not yet implemented");5855    break;5856  case Triple::SPIRV:5857    if (T.getVendor() == Triple::AMD)5858      return ".llvmcmd";5859    llvm_unreachable("SPIRV is not yet implemented");5860    break;5861  case Triple::XCOFF:5862    llvm_unreachable("XCOFF is not yet implemented");5863    break;5864  case Triple::DXContainer:5865    llvm_unreachable("DXC is not yet implemented");5866    break;5867  }5868  llvm_unreachable("Unimplemented ObjectFormatType");5869}5870 5871void llvm::embedBitcodeInModule(llvm::Module &M, llvm::MemoryBufferRef Buf,5872                                bool EmbedBitcode, bool EmbedCmdline,5873                                const std::vector<uint8_t> &CmdArgs) {5874  // Save llvm.compiler.used and remove it.5875  SmallVector<Constant *, 2> UsedArray;5876  SmallVector<GlobalValue *, 4> UsedGlobals;5877  GlobalVariable *Used = collectUsedGlobalVariables(M, UsedGlobals, true);5878  Type *UsedElementType = Used ? Used->getValueType()->getArrayElementType()5879                               : PointerType::getUnqual(M.getContext());5880  for (auto *GV : UsedGlobals) {5881    if (GV->getName() != "llvm.embedded.module" &&5882        GV->getName() != "llvm.cmdline")5883      UsedArray.push_back(5884          ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));5885  }5886  if (Used)5887    Used->eraseFromParent();5888 5889  // Embed the bitcode for the llvm module.5890  std::string Data;5891  ArrayRef<uint8_t> ModuleData;5892  Triple T(M.getTargetTriple());5893 5894  if (EmbedBitcode) {5895    if (Buf.getBufferSize() == 0 ||5896        !isBitcode((const unsigned char *)Buf.getBufferStart(),5897                   (const unsigned char *)Buf.getBufferEnd())) {5898      // If the input is LLVM Assembly, bitcode is produced by serializing5899      // the module. Use-lists order need to be preserved in this case.5900      llvm::raw_string_ostream OS(Data);5901      llvm::WriteBitcodeToFile(M, OS, /* ShouldPreserveUseListOrder */ true);5902      ModuleData =5903          ArrayRef<uint8_t>((const uint8_t *)OS.str().data(), OS.str().size());5904    } else5905      // If the input is LLVM bitcode, write the input byte stream directly.5906      ModuleData = ArrayRef<uint8_t>((const uint8_t *)Buf.getBufferStart(),5907                                     Buf.getBufferSize());5908  }5909  llvm::Constant *ModuleConstant =5910      llvm::ConstantDataArray::get(M.getContext(), ModuleData);5911  llvm::GlobalVariable *GV = new llvm::GlobalVariable(5912      M, ModuleConstant->getType(), true, llvm::GlobalValue::PrivateLinkage,5913      ModuleConstant);5914  GV->setSection(getSectionNameForBitcode(T));5915  // Set alignment to 1 to prevent padding between two contributions from input5916  // sections after linking.5917  GV->setAlignment(Align(1));5918  UsedArray.push_back(5919      ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));5920  if (llvm::GlobalVariable *Old =5921          M.getGlobalVariable("llvm.embedded.module", true)) {5922    assert(Old->hasZeroLiveUses() &&5923           "llvm.embedded.module can only be used once in llvm.compiler.used");5924    GV->takeName(Old);5925    Old->eraseFromParent();5926  } else {5927    GV->setName("llvm.embedded.module");5928  }5929 5930  // Skip if only bitcode needs to be embedded.5931  if (EmbedCmdline) {5932    // Embed command-line options.5933    ArrayRef<uint8_t> CmdData(const_cast<uint8_t *>(CmdArgs.data()),5934                              CmdArgs.size());5935    llvm::Constant *CmdConstant =5936        llvm::ConstantDataArray::get(M.getContext(), CmdData);5937    GV = new llvm::GlobalVariable(M, CmdConstant->getType(), true,5938                                  llvm::GlobalValue::PrivateLinkage,5939                                  CmdConstant);5940    GV->setSection(getSectionNameForCommandline(T));5941    GV->setAlignment(Align(1));5942    UsedArray.push_back(5943        ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));5944    if (llvm::GlobalVariable *Old = M.getGlobalVariable("llvm.cmdline", true)) {5945      assert(Old->hasZeroLiveUses() &&5946             "llvm.cmdline can only be used once in llvm.compiler.used");5947      GV->takeName(Old);5948      Old->eraseFromParent();5949    } else {5950      GV->setName("llvm.cmdline");5951    }5952  }5953 5954  if (UsedArray.empty())5955    return;5956 5957  // Recreate llvm.compiler.used.5958  ArrayType *ATy = ArrayType::get(UsedElementType, UsedArray.size());5959  auto *NewUsed = new GlobalVariable(5960      M, ATy, false, llvm::GlobalValue::AppendingLinkage,5961      llvm::ConstantArray::get(ATy, UsedArray), "llvm.compiler.used");5962  NewUsed->setSection("llvm.metadata");5963}5964