NFC. Refactor bitcode writer

[beanz]

Summary

This is an initial NFC refactor of the LLVM bitcode writer to support
implementing alternate bitcode serializations of LLVM IR.

This refactoring moves the basic bitcode encoding helper functionality
into a header that is available outside the BitWriter library.

This is in support of adding DXIL emission to LLVM as discussed in the
RFC here:
https://discourse.llvm.org/t/rfc-adding-hlsl-and-directx-support-to-clang-llvm/60783/

[efriedma]

llvm/include/llvm/Bitcode/BitcodeWriterBase.h

200

Not sure I follow why you're exposing ModuleBitcodeWriter publicly.

[beanz]

Rolling back some unintendedly over-grabby changes :)

[beanz]

Abandoning this revision. Reviews on the downstream changes have requested forking the full bit writer infrastructure instead of refactoring it for reuse. The next patch in the stack has the forked bit writer (see: D122082).

llvm/include/llvm/Bitcode/BitcodeWriterBase.h

+//===- llvm/Bitcode/BitcodeWriterBase.h - Bitcode writer --------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Base classes for writing LLVM objects to bitcode
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_BITCODE_BITCODEWRITERBASE_H
+#define LLVM_BITCODE_BITCODEWRITERBASE_H
+
+#include "llvm/Bitcode/ValueEnumerator.h"
+#include "llvm/Bitstream/BitstreamWriter.h"
+#include "llvm/IR/GlobalValue.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/ModuleSummaryIndex.h"
+#include "llvm/Support/SHA1.h"
+
+namespace llvm {
+
+class GlobalValueSummary;
+class Module;
+class ModuleSummaryIndex;
+class StringTableBuilder;
+
+// Generates an enum to use as an index in the Abbrev array of Metadata record.
+enum MetadataAbbrev : unsigned {
+#define HANDLE_MDNODE_LEAF(CLASS) CLASS##AbbrevID,
+#include "llvm/IR/Metadata.def"
+  LastPlusOne
+};
+
+/// Abstract class to manage the bitcode writing, subclassed for each bitcode
+/// file type.
+class BitcodeWriterBase {
+protected:
+  /// The stream created and owned by the client.
+  BitstreamWriter &Stream;
+
+  StringTableBuilder &StrtabBuilder;
+
+  /// These are manifest constants used by the bitcode writer. They do not need
+  /// to be kept in sync with the reader, but need to be consistent within this
+  /// file.
+  enum {
+    // VALUE_SYMTAB_BLOCK abbrev id's.
+    VST_ENTRY_8_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
+    VST_ENTRY_7_ABBREV,
+    VST_ENTRY_6_ABBREV,
+    VST_BBENTRY_6_ABBREV,
+
+    // CONSTANTS_BLOCK abbrev id's.
+    CONSTANTS_SETTYPE_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
+    CONSTANTS_INTEGER_ABBREV,
+    CONSTANTS_CE_CAST_Abbrev,
+    CONSTANTS_NULL_Abbrev,
+
+    // FUNCTION_BLOCK abbrev id's.
+    FUNCTION_INST_LOAD_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
+    FUNCTION_INST_UNOP_ABBREV,
+    FUNCTION_INST_UNOP_FLAGS_ABBREV,
+    FUNCTION_INST_BINOP_ABBREV,
+    FUNCTION_INST_BINOP_FLAGS_ABBREV,
+    FUNCTION_INST_CAST_ABBREV,
+    FUNCTION_INST_RET_VOID_ABBREV,
+    FUNCTION_INST_RET_VAL_ABBREV,
+    FUNCTION_INST_UNREACHABLE_ABBREV,
+    FUNCTION_INST_GEP_ABBREV,
+  };
+
+public:
+  /// Constructs a BitcodeWriterBase object that writes to the provided
+  /// \p Stream.
+  BitcodeWriterBase(BitstreamWriter &Stream, StringTableBuilder &StrtabBuilder)
+      : Stream(Stream), StrtabBuilder(StrtabBuilder) {}
+
+  static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind);
+  static void writeStringRecord(BitstreamWriter &Stream, unsigned Code,
+                                StringRef Str, unsigned AbbrevToUse);
+  static void writeIdentificationBlock(BitstreamWriter &Stream);
+  static void emitSignedInt64(SmallVectorImpl<uint64_t> &Vals, uint64_t V);
+  static void emitWideAPInt(SmallVectorImpl<uint64_t> &Vals, const APInt &A);
+
+  static unsigned getEncodedComdatSelectionKind(const Comdat &C);
+  static unsigned getEncodedLinkage(const GlobalValue::LinkageTypes Linkage);
+  static unsigned getEncodedLinkage(const GlobalValue &GV);
+  static unsigned getEncodedVisibility(const GlobalValue &GV);
+  static unsigned getEncodedThreadLocalMode(const GlobalValue &GV);
+  static unsigned getEncodedDLLStorageClass(const GlobalValue &GV);
+  static unsigned getEncodedCastOpcode(unsigned Opcode);
+  static unsigned getEncodedUnaryOpcode(unsigned Opcode);
+  static unsigned getEncodedBinaryOpcode(unsigned Opcode);
+  static unsigned getEncodedRMWOperation(AtomicRMWInst::BinOp Op);
+  static unsigned getEncodedOrdering(AtomicOrdering Ordering);
+  static uint64_t getOptimizationFlags(const Value *V);
+
+protected:
+  void writeModuleVersion();
+};
+
+} // namespace llvm
+#endif // LLVM_BITCODE_BITCODEWRITERBASE_H

llvm/include/llvm/Bitcode/ValueEnumerator.h

-//===- Bitcode/Writer/ValueEnumerator.h - Number values ---------*- C++ -*-===//
+//===- llvm/Bitcode/ValueEnumerator.h - Number values -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This class gives values and types Unique ID's.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIB_BITCODE_WRITER_VALUEENUMERATOR_H
-#define LLVM_LIB_BITCODE_WRITER_VALUEENUMERATOR_H
+#ifndef LLVM_BITCODE_VALUEENUMERATOR_H
+#define LLVM_BITCODE_VALUEENUMERATOR_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/UniqueVector.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/UseListOrder.h"
 #include <cassert>
 #include <cstdint>
private:
   std::vector<IndexAndAttrSet> AttributeGroups;
 
   using AttributeListMapType = DenseMap<AttributeList, unsigned>;
   AttributeListMapType AttributeListMap;
   std::vector<AttributeList> AttributeLists;
 
   /// GlobalBasicBlockIDs - This map memoizes the basic block ID's referenced by
   /// the "getGlobalBasicBlockID" method.
   mutable DenseMap<const BasicBlock*, unsigned> GlobalBasicBlockIDs;
 
   using InstructionMapType = DenseMap<const Instruction *, unsigned>;
   InstructionMapType InstructionMap;
   unsigned InstructionCount;
 
   /// BasicBlocks - This contains all the basic blocks for the currently
   /// incorporated function.  Their reverse mapping is stored in ValueMap.
   std::vector<const BasicBlock*> BasicBlocks;
 
   /// When a function is incorporated, this is the size of the Values list
   /// before incorporation.
   unsigned NumModuleValues;
 
   /// When a function is incorporated, this is the size of the Metadatas list
   /// before incorporation.
   unsigned NumModuleMDs = 0;
public:
 
   unsigned numMDs() const { return MDs.size(); }
 
   bool shouldPreserveUseListOrder() const { return ShouldPreserveUseListOrder; }
 
   unsigned getTypeID(Type *T) const {
     TypeMapType::const_iterator I = TypeMap.find(T);
     assert(I != TypeMap.end() && "Type not in ValueEnumerator!");
     return I->second-1;
   }
 
   unsigned getInstructionID(const Instruction *I) const;
   void setInstructionID(const Instruction *I);
 
   unsigned getAttributeListID(AttributeList PAL) const {
     if (PAL.isEmpty()) return 0;  // Null maps to zero.
     AttributeListMapType::const_iterator I = AttributeListMap.find(PAL);
     assert(I != AttributeListMap.end() && "Attribute not in ValueEnumerator!");
     return I->second;
   }
 
   unsigned getAttributeGroupID(IndexAndAttrSet Group) const {
     if (!Group.second.hasAttributes())
       return 0; // Null maps to zero.
public:
 
   /// Get the non-MDString metadata for this block.
   ArrayRef<const Metadata *> getNonMDStrings() const {
     return makeArrayRef(MDs).slice(NumModuleMDs).slice(NumMDStrings);
   }
 
   const TypeList &getTypes() const { return Types; }
 
   const std::vector<const BasicBlock*> &getBasicBlocks() const {
     return BasicBlocks;
   }
 
   const std::vector<AttributeList> &getAttributeLists() const { return AttributeLists; }
 
   const std::vector<IndexAndAttrSet> &getAttributeGroups() const {
     return AttributeGroups;
   }
 
   const ComdatSetType &getComdats() const { return Comdats; }
   unsigned getComdatID(const Comdat *C) const;
 

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

 //===- Bitcode/Writer/BitcodeWriter.cpp - Bitcode Writer ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Bitcode writer implementation.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Bitcode/BitcodeWriter.h"
-#include "ValueEnumerator.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Bitcode/BitcodeCommon.h"
 #include "llvm/Bitcode/BitcodeReader.h"
+#include "llvm/Bitcode/BitcodeWriterBase.h"
 #include "llvm/Bitcode/LLVMBitCodes.h"
+#include "llvm/Bitcode/ValueEnumerator.h"
 #include "llvm/Bitstream/BitCodes.h"
 #include "llvm/Bitstream/BitstreamWriter.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Comdat.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
static cl::opt<uint32_t> FlushThreshold(
     cl::desc("The threshold (unit M) for flushing LLVM bitcode."));
 
 static cl::opt<bool> WriteRelBFToSummary(
     "write-relbf-to-summary", cl::Hidden, cl::init(false),
     cl::desc("Write relative block frequency to function summary "));
 
 extern FunctionSummary::ForceSummaryHotnessType ForceSummaryEdgesCold;
 
-namespace {
-
-/// These are manifest constants used by the bitcode writer. They do not need to
-/// be kept in sync with the reader, but need to be consistent within this file.
-enum {
-  // VALUE_SYMTAB_BLOCK abbrev id's.
-  VST_ENTRY_8_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
-  VST_ENTRY_7_ABBREV,
-  VST_ENTRY_6_ABBREV,
-  VST_BBENTRY_6_ABBREV,
-
-  // CONSTANTS_BLOCK abbrev id's.
-  CONSTANTS_SETTYPE_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
-  CONSTANTS_INTEGER_ABBREV,
-  CONSTANTS_CE_CAST_Abbrev,
-  CONSTANTS_NULL_Abbrev,
-
-  // FUNCTION_BLOCK abbrev id's.
-  FUNCTION_INST_LOAD_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
-  FUNCTION_INST_UNOP_ABBREV,
-  FUNCTION_INST_UNOP_FLAGS_ABBREV,
-  FUNCTION_INST_BINOP_ABBREV,
-  FUNCTION_INST_BINOP_FLAGS_ABBREV,
-  FUNCTION_INST_CAST_ABBREV,
-  FUNCTION_INST_RET_VOID_ABBREV,
-  FUNCTION_INST_RET_VAL_ABBREV,
-  FUNCTION_INST_UNREACHABLE_ABBREV,
-  FUNCTION_INST_GEP_ABBREV,
-};
-
-/// Abstract class to manage the bitcode writing, subclassed for each bitcode
-/// file type.
-class BitcodeWriterBase {
-protected:
-  /// The stream created and owned by the client.
-  BitstreamWriter &Stream;
-
-  StringTableBuilder &StrtabBuilder;
-
-public:
-  /// Constructs a BitcodeWriterBase object that writes to the provided
-  /// \p Stream.
-  BitcodeWriterBase(BitstreamWriter &Stream, StringTableBuilder &StrtabBuilder)
-      : Stream(Stream), StrtabBuilder(StrtabBuilder) {}
-
-protected:
-  void writeModuleVersion();
-};
-
 void BitcodeWriterBase::writeModuleVersion() {
   // VERSION: [version#]
   Stream.EmitRecord(bitc::MODULE_CODE_VERSION, ArrayRef<uint64_t>{2});
 }
 
-/// Base class to manage the module bitcode writing, currently subclassed for
-/// ModuleBitcodeWriter and ThinLinkBitcodeWriter.
-class ModuleBitcodeWriterBase : public BitcodeWriterBase {
-protected:
-  /// The Module to write to bitcode.
-  const Module &M;
-
-  /// Enumerates ids for all values in the module.
-  ValueEnumerator VE;
-
-  /// Optional per-module index to write for ThinLTO.
-  const ModuleSummaryIndex *Index;
-
-  /// Map that holds the correspondence between GUIDs in the summary index,
-  /// that came from indirect call profiles, and a value id generated by this
-  /// class to use in the VST and summary block records.
-  std::map<GlobalValue::GUID, unsigned> GUIDToValueIdMap;
-
-  /// Tracks the last value id recorded in the GUIDToValueMap.
-  unsigned GlobalValueId;
-
-  /// Saves the offset of the VSTOffset record that must eventually be
-  /// backpatched with the offset of the actual VST.
-  uint64_t VSTOffsetPlaceholder = 0;
-
-public:
-  /// Constructs a ModuleBitcodeWriterBase object for the given Module,
-  /// writing to the provided \p Buffer.
-  ModuleBitcodeWriterBase(const Module &M, StringTableBuilder &StrtabBuilder,
-                          BitstreamWriter &Stream,
-                          bool ShouldPreserveUseListOrder,
-                          const ModuleSummaryIndex *Index)
-      : BitcodeWriterBase(Stream, StrtabBuilder), M(M),
-        VE(M, ShouldPreserveUseListOrder), Index(Index) {
-    // Assign ValueIds to any callee values in the index that came from
-    // indirect call profiles and were recorded as a GUID not a Value*
-    // (which would have been assigned an ID by the ValueEnumerator).
-    // The starting ValueId is just after the number of values in the
-    // ValueEnumerator, so that they can be emitted in the VST.
-    GlobalValueId = VE.getValues().size();
-    if (!Index)
-      return;
-    for (const auto &GUIDSummaryLists : *Index)
-      // Examine all summaries for this GUID.
-      for (auto &Summary : GUIDSummaryLists.second.SummaryList)
-        if (auto FS = dyn_cast<FunctionSummary>(Summary.get()))
-          // For each call in the function summary, see if the call
-          // is to a GUID (which means it is for an indirect call,
-          // otherwise we would have a Value for it). If so, synthesize
-          // a value id.
-          for (auto &CallEdge : FS->calls())
-            if (!CallEdge.first.haveGVs() || !CallEdge.first.getValue())
-              assignValueId(CallEdge.first.getGUID());
-  }
-
-protected:
-  void writePerModuleGlobalValueSummary();
-
-private:
-  void writePerModuleFunctionSummaryRecord(SmallVector<uint64_t, 64> &NameVals,
-                                           GlobalValueSummary *Summary,
-                                           unsigned ValueID,
-                                           unsigned FSCallsAbbrev,
-                                           unsigned FSCallsProfileAbbrev,
-                                           const Function &F);
-  void writeModuleLevelReferences(const GlobalVariable &V,
-                                  SmallVector<uint64_t, 64> &NameVals,
-                                  unsigned FSModRefsAbbrev,
-                                  unsigned FSModVTableRefsAbbrev);
-
-  void assignValueId(GlobalValue::GUID ValGUID) {
-    GUIDToValueIdMap[ValGUID] = ++GlobalValueId;
-  }
-
-  unsigned getValueId(GlobalValue::GUID ValGUID) {
-    const auto &VMI = GUIDToValueIdMap.find(ValGUID);
-    // Expect that any GUID value had a value Id assigned by an
-    // earlier call to assignValueId.
-    assert(VMI != GUIDToValueIdMap.end() &&
-           "GUID does not have assigned value Id");
-    return VMI->second;
-  }
-
-  // Helper to get the valueId for the type of value recorded in VI.
-  unsigned getValueId(ValueInfo VI) {
-    if (!VI.haveGVs() || !VI.getValue())
-      return getValueId(VI.getGUID());
-    return VE.getValueID(VI.getValue());
-  }
-
-  std::map<GlobalValue::GUID, unsigned> &valueIds() { return GUIDToValueIdMap; }
-};
+namespace {
 
 /// Class to manage the bitcode writing for a module.
 class ModuleBitcodeWriter : public ModuleBitcodeWriterBase {
   /// Pointer to the buffer allocated by caller for bitcode writing.
   const SmallVectorImpl<char> &Buffer;
 
   /// True if a module hash record should be written.
   bool GenerateHash;
Optional<unsigned> getValueId(GlobalValue::GUID ValGUID) {
     return VMI->second;
   }
 
   std::map<GlobalValue::GUID, unsigned> &valueIds() { return GUIDToValueIdMap; }
 };
 
 } // end anonymous namespace
 
-static unsigned getEncodedCastOpcode(unsigned Opcode) {
+unsigned BitcodeWriterBase::getEncodedCastOpcode(unsigned Opcode) {
   switch (Opcode) {
   default: llvm_unreachable("Unknown cast instruction!");
   case Instruction::Trunc   : return bitc::CAST_TRUNC;
   case Instruction::ZExt    : return bitc::CAST_ZEXT;
   case Instruction::SExt    : return bitc::CAST_SEXT;
   case Instruction::FPToUI  : return bitc::CAST_FPTOUI;
   case Instruction::FPToSI  : return bitc::CAST_FPTOSI;
   case Instruction::UIToFP  : return bitc::CAST_UITOFP;
   case Instruction::SIToFP  : return bitc::CAST_SITOFP;
   case Instruction::FPTrunc : return bitc::CAST_FPTRUNC;
   case Instruction::FPExt   : return bitc::CAST_FPEXT;
   case Instruction::PtrToInt: return bitc::CAST_PTRTOINT;
   case Instruction::IntToPtr: return bitc::CAST_INTTOPTR;
   case Instruction::BitCast : return bitc::CAST_BITCAST;
   case Instruction::AddrSpaceCast: return bitc::CAST_ADDRSPACECAST;
   }
 }
 
-static unsigned getEncodedUnaryOpcode(unsigned Opcode) {
+unsigned BitcodeWriterBase::getEncodedUnaryOpcode(unsigned Opcode) {
   switch (Opcode) {
   default: llvm_unreachable("Unknown binary instruction!");
   case Instruction::FNeg: return bitc::UNOP_FNEG;
   }
 }
 
-static unsigned getEncodedBinaryOpcode(unsigned Opcode) {
+unsigned BitcodeWriterBase::getEncodedBinaryOpcode(unsigned Opcode) {
   switch (Opcode) {
   default: llvm_unreachable("Unknown binary instruction!");
   case Instruction::Add:
   case Instruction::FAdd: return bitc::BINOP_ADD;
   case Instruction::Sub:
   case Instruction::FSub: return bitc::BINOP_SUB;
   case Instruction::Mul:
   case Instruction::FMul: return bitc::BINOP_MUL;
   case Instruction::UDiv: return bitc::BINOP_UDIV;
   case Instruction::FDiv:
   case Instruction::SDiv: return bitc::BINOP_SDIV;
   case Instruction::URem: return bitc::BINOP_UREM;
   case Instruction::FRem:
   case Instruction::SRem: return bitc::BINOP_SREM;
   case Instruction::Shl:  return bitc::BINOP_SHL;
   case Instruction::LShr: return bitc::BINOP_LSHR;
   case Instruction::AShr: return bitc::BINOP_ASHR;
   case Instruction::And:  return bitc::BINOP_AND;
   case Instruction::Or:   return bitc::BINOP_OR;
   case Instruction::Xor:  return bitc::BINOP_XOR;
   }
 }
 
-static unsigned getEncodedRMWOperation(AtomicRMWInst::BinOp Op) {
+unsigned BitcodeWriterBase::getEncodedRMWOperation(AtomicRMWInst::BinOp Op) {
   switch (Op) {
   default: llvm_unreachable("Unknown RMW operation!");
   case AtomicRMWInst::Xchg: return bitc::RMW_XCHG;
   case AtomicRMWInst::Add: return bitc::RMW_ADD;
   case AtomicRMWInst::Sub: return bitc::RMW_SUB;
   case AtomicRMWInst::And: return bitc::RMW_AND;
   case AtomicRMWInst::Nand: return bitc::RMW_NAND;
   case AtomicRMWInst::Or: return bitc::RMW_OR;
   case AtomicRMWInst::Xor: return bitc::RMW_XOR;
   case AtomicRMWInst::Max: return bitc::RMW_MAX;
   case AtomicRMWInst::Min: return bitc::RMW_MIN;
   case AtomicRMWInst::UMax: return bitc::RMW_UMAX;
   case AtomicRMWInst::UMin: return bitc::RMW_UMIN;
   case AtomicRMWInst::FAdd: return bitc::RMW_FADD;
   case AtomicRMWInst::FSub: return bitc::RMW_FSUB;
   }
 }
 
-static unsigned getEncodedOrdering(AtomicOrdering Ordering) {
+unsigned BitcodeWriterBase::getEncodedOrdering(AtomicOrdering Ordering) {
   switch (Ordering) {
   case AtomicOrdering::NotAtomic: return bitc::ORDERING_NOTATOMIC;
   case AtomicOrdering::Unordered: return bitc::ORDERING_UNORDERED;
   case AtomicOrdering::Monotonic: return bitc::ORDERING_MONOTONIC;
   case AtomicOrdering::Acquire: return bitc::ORDERING_ACQUIRE;
   case AtomicOrdering::Release: return bitc::ORDERING_RELEASE;
   case AtomicOrdering::AcquireRelease: return bitc::ORDERING_ACQREL;
   case AtomicOrdering::SequentiallyConsistent: return bitc::ORDERING_SEQCST;
   }
   llvm_unreachable("Invalid ordering");
 }
 
-static void writeStringRecord(BitstreamWriter &Stream, unsigned Code,
-                              StringRef Str, unsigned AbbrevToUse) {
+void BitcodeWriterBase::writeStringRecord(BitstreamWriter &Stream,
+                                          unsigned Code, StringRef Str,
+                                          unsigned AbbrevToUse) {
   SmallVector<unsigned, 64> Vals;
 
   // Code: [strchar x N]
   for (char C : Str) {
     if (AbbrevToUse && !BitCodeAbbrevOp::isChar6(C))
       AbbrevToUse = 0;
     Vals.push_back(C);
   }
 
   // Emit the finished record.
   Stream.EmitRecord(Code, Vals, AbbrevToUse);
 }
 
-static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
+uint64_t BitcodeWriterBase::getAttrKindEncoding(Attribute::AttrKind Kind) {
   switch (Kind) {
   case Attribute::Alignment:
     return bitc::ATTR_KIND_ALIGNMENT;
   case Attribute::AllocAlign:
     return bitc::ATTR_KIND_ALLOC_ALIGN;
   case Attribute::AllocSize:
     return bitc::ATTR_KIND_ALLOC_SIZE;
   case Attribute::AlwaysInline:
for (Type *T : TypeList) {
     // Emit the finished record.
     Stream.EmitRecord(Code, TypeVals, AbbrevToUse);
     TypeVals.clear();
   }
 
   Stream.ExitBlock();
 }
 
-static unsigned getEncodedLinkage(const GlobalValue::LinkageTypes Linkage) {
+unsigned
+BitcodeWriterBase::getEncodedLinkage(const GlobalValue::LinkageTypes Linkage) {
   switch (Linkage) {
   case GlobalValue::ExternalLinkage:
     return 0;
   case GlobalValue::WeakAnyLinkage:
     return 16;
   case GlobalValue::AppendingLinkage:
     return 2;
   case GlobalValue::InternalLinkage:
BitcodeWriterBase::getEncodedLinkage(const GlobalValue::LinkageTypes Linkage) {
   case GlobalValue::LinkOnceODRLinkage:
     return 19;
   case GlobalValue::AvailableExternallyLinkage:
     return 12;
   }
   llvm_unreachable("Invalid linkage");
 }
 
-static unsigned getEncodedLinkage(const GlobalValue &GV) {
+unsigned BitcodeWriterBase::getEncodedLinkage(const GlobalValue &GV) {
   return getEncodedLinkage(GV.getLinkage());
 }
 
 static uint64_t getEncodedFFlags(FunctionSummary::FFlags Flags) {
   uint64_t RawFlags = 0;
   RawFlags |= Flags.ReadNone;
   RawFlags |= (Flags.ReadOnly << 1);
   RawFlags |= (Flags.NoRecurse << 2);

 }
 
 static uint64_t getEncodedGVarFlags(GlobalVarSummary::GVarFlags Flags) {
   uint64_t RawFlags = Flags.MaybeReadOnly | (Flags.MaybeWriteOnly << 1) |
                       (Flags.Constant << 2) | Flags.VCallVisibility << 3;
   return RawFlags;
 }
 
-static unsigned getEncodedVisibility(const GlobalValue &GV) {
+unsigned BitcodeWriterBase::getEncodedVisibility(const GlobalValue &GV) {
   switch (GV.getVisibility()) {
   case GlobalValue::DefaultVisibility:   return 0;
   case GlobalValue::HiddenVisibility:    return 1;
   case GlobalValue::ProtectedVisibility: return 2;
   }
   llvm_unreachable("Invalid visibility");
 }
 
-static unsigned getEncodedDLLStorageClass(const GlobalValue &GV) {
+unsigned BitcodeWriterBase::getEncodedDLLStorageClass(const GlobalValue &GV) {
   switch (GV.getDLLStorageClass()) {
   case GlobalValue::DefaultStorageClass:   return 0;
   case GlobalValue::DLLImportStorageClass: return 1;
   case GlobalValue::DLLExportStorageClass: return 2;
   }
   llvm_unreachable("Invalid DLL storage class");
 }
 
-static unsigned getEncodedThreadLocalMode(const GlobalValue &GV) {
+unsigned BitcodeWriterBase::getEncodedThreadLocalMode(const GlobalValue &GV) {
   switch (GV.getThreadLocalMode()) {
     case GlobalVariable::NotThreadLocal:         return 0;
     case GlobalVariable::GeneralDynamicTLSModel: return 1;
     case GlobalVariable::LocalDynamicTLSModel:   return 2;
     case GlobalVariable::InitialExecTLSModel:    return 3;
     case GlobalVariable::LocalExecTLSModel:      return 4;
   }
   llvm_unreachable("Invalid TLS model");
 }
 
-static unsigned getEncodedComdatSelectionKind(const Comdat &C) {
+unsigned BitcodeWriterBase::getEncodedComdatSelectionKind(const Comdat &C) {
   switch (C.getSelectionKind()) {
   case Comdat::Any:
     return bitc::COMDAT_SELECTION_KIND_ANY;
   case Comdat::ExactMatch:
     return bitc::COMDAT_SELECTION_KIND_EXACT_MATCH;
   case Comdat::Largest:
     return bitc::COMDAT_SELECTION_KIND_LARGEST;
   case Comdat::NoDeduplicate:
for (const GlobalIFunc &I : M.ifuncs()) {
     Vals.push_back(I.getPartition().size());
     Stream.EmitRecord(bitc::MODULE_CODE_IFUNC, Vals);
     Vals.clear();
   }
 
   writeValueSymbolTableForwardDecl();
 }
 
-static uint64_t getOptimizationFlags(const Value *V) {
+uint64_t BitcodeWriterBase::getOptimizationFlags(const Value *V) {
   uint64_t Flags = 0;
 
   if (const auto *OBO = dyn_cast<OverflowingBinaryOperator>(V)) {
     if (OBO->hasNoSignedWrap())
       Flags |= 1 << bitc::OBO_NO_SIGNED_WRAP;
     if (OBO->hasNoUnsignedWrap())
       Flags |= 1 << bitc::OBO_NO_UNSIGNED_WRAP;
   } else if (const auto *PEO = dyn_cast<PossiblyExactOperator>(V)) {
void ModuleBitcodeWriter::writeDIGenericSubrange(
   Record.push_back(VE.getMetadataOrNullID(N->getRawLowerBound()));
   Record.push_back(VE.getMetadataOrNullID(N->getRawUpperBound()));
   Record.push_back(VE.getMetadataOrNullID(N->getRawStride()));
 
   Stream.EmitRecord(bitc::METADATA_GENERIC_SUBRANGE, Record, Abbrev);
   Record.clear();
 }
 
-static void emitSignedInt64(SmallVectorImpl<uint64_t> &Vals, uint64_t V) {
+void BitcodeWriterBase::emitSignedInt64(SmallVectorImpl<uint64_t> &Vals,
+                                        uint64_t V) {
   if ((int64_t)V >= 0)
     Vals.push_back(V << 1);
   else
     Vals.push_back((-V << 1) | 1);
 }
 
-static void emitWideAPInt(SmallVectorImpl<uint64_t> &Vals, const APInt &A) {
+void BitcodeWriterBase::emitWideAPInt(SmallVectorImpl<uint64_t> &Vals,
+                                      const APInt &A) {
   // We have an arbitrary precision integer value to write whose
   // bit width is > 64. However, in canonical unsigned integer
   // format it is likely that the high bits are going to be zero.
   // So, we only write the number of active words.
   unsigned NumWords = A.getActiveWords();
   const uint64_t *RawData = A.getRawData();
   for (unsigned i = 0; i < NumWords; i++)
     emitSignedInt64(Vals, RawData[i]);
void ModuleBitcodeWriter::writeMetadataStrings(
   for (const Metadata *MD : Strings)
     Blob.append(cast<MDString>(MD)->getString());
 
   // Emit the final record.
   Stream.EmitRecordWithBlob(createMetadataStringsAbbrev(), Record, Blob);
   Record.clear();
 }
 
-// Generates an enum to use as an index in the Abbrev array of Metadata record.
-enum MetadataAbbrev : unsigned {
-#define HANDLE_MDNODE_LEAF(CLASS) CLASS##AbbrevID,
-#include "llvm/IR/Metadata.def"
-  LastPlusOne
-};
-
 void ModuleBitcodeWriter::writeMetadataRecords(
     ArrayRef<const Metadata *> MDs, SmallVectorImpl<uint64_t> &Record,
     std::vector<unsigned> *MDAbbrevs, std::vector<uint64_t> *IndexPos) {
   if (MDs.empty())
     return;
 
   // Initialize MDNode abbreviations.
 #define HANDLE_MDNODE_LEAF(CLASS) unsigned CLASS##Abbrev = 0;
WriteConstVCallVec(bitc::FS_TYPE_TEST_ASSUME_CONST_VCALL,
                      FS->type_test_assume_const_vcalls());
   WriteConstVCallVec(bitc::FS_TYPE_CHECKED_LOAD_CONST_VCALL,
                      FS->type_checked_load_const_vcalls());
 
   auto WriteRange = [&](ConstantRange Range) {
     Range = Range.sextOrTrunc(FunctionSummary::ParamAccess::RangeWidth);
     assert(Range.getLower().getNumWords() == 1);
     assert(Range.getUpper().getNumWords() == 1);
-    emitSignedInt64(Record, *Range.getLower().getRawData());
-    emitSignedInt64(Record, *Range.getUpper().getRawData());
+    BitcodeWriterBase::emitSignedInt64(Record, *Range.getLower().getRawData());
+    BitcodeWriterBase::emitSignedInt64(Record, *Range.getUpper().getRawData());
   };
 
   if (!FS->paramAccesses().empty()) {
     Record.clear();
     for (auto &Arg : FS->paramAccesses()) {
       size_t UndoSize = Record.size();
       Record.push_back(Arg.ParamNo);
       WriteRange(Arg.Use);
void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
   Stream.EmitRecord(bitc::FS_BLOCK_COUNT,
                     ArrayRef<uint64_t>{Index.getBlockCount()});
 
   Stream.ExitBlock();
 }
 
 /// Create the "IDENTIFICATION_BLOCK_ID" containing a single string with the
 /// current llvm version, and a record for the epoch number.
-static void writeIdentificationBlock(BitstreamWriter &Stream) {
+void BitcodeWriterBase::writeIdentificationBlock(BitstreamWriter &Stream) {
   Stream.EnterSubblock(bitc::IDENTIFICATION_BLOCK_ID, 5);
 
   // Write the "user readable" string identifying the bitcode producer
   auto Abbv = std::make_shared<BitCodeAbbrev>();
   Abbv->Add(BitCodeAbbrevOp(bitc::IDENTIFICATION_CODE_STRING));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
   auto StringAbbrev = Stream.EmitAbbrev(std::move(Abbv));

llvm/lib/Bitcode/Writer/ValueEnumerator.cpp

 //===- ValueEnumerator.cpp - Number values and types for bitcode writer ---===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the ValueEnumerator class.
 //
 //===----------------------------------------------------------------------===//
 
-#include "ValueEnumerator.h"
+#include "llvm/Bitcode/ValueEnumerator.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/Argument.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"