brintos / llvm-project-archived public Read only

1//===- Bitcode/Writer/DXILBitcodeWriter.cpp - DXIL 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 "DXILBitcodeWriter.h"14#include "DXILValueEnumerator.h"15#include "DirectXIRPasses/PointerTypeAnalysis.h"16#include "llvm/ADT/STLExtras.h"17#include "llvm/Bitcode/BitcodeCommon.h"18#include "llvm/Bitcode/BitcodeReader.h"19#include "llvm/Bitcode/LLVMBitCodes.h"20#include "llvm/Bitstream/BitCodes.h"21#include "llvm/Bitstream/BitstreamWriter.h"22#include "llvm/IR/Attributes.h"23#include "llvm/IR/BasicBlock.h"24#include "llvm/IR/Comdat.h"25#include "llvm/IR/Constant.h"26#include "llvm/IR/Constants.h"27#include "llvm/IR/DebugInfoMetadata.h"28#include "llvm/IR/DebugLoc.h"29#include "llvm/IR/DerivedTypes.h"30#include "llvm/IR/Function.h"31#include "llvm/IR/GlobalAlias.h"32#include "llvm/IR/GlobalIFunc.h"33#include "llvm/IR/GlobalObject.h"34#include "llvm/IR/GlobalValue.h"35#include "llvm/IR/GlobalVariable.h"36#include "llvm/IR/InlineAsm.h"37#include "llvm/IR/InstrTypes.h"38#include "llvm/IR/Instruction.h"39#include "llvm/IR/Instructions.h"40#include "llvm/IR/LLVMContext.h"41#include "llvm/IR/Metadata.h"42#include "llvm/IR/Module.h"43#include "llvm/IR/ModuleSummaryIndex.h"44#include "llvm/IR/Operator.h"45#include "llvm/IR/Type.h"46#include "llvm/IR/UseListOrder.h"47#include "llvm/IR/Value.h"48#include "llvm/IR/ValueSymbolTable.h"49#include "llvm/Object/IRSymtab.h"50#include "llvm/Support/ErrorHandling.h"51#include "llvm/Support/ModRef.h"52#include "llvm/Support/SHA1.h"53#include "llvm/TargetParser/Triple.h"54 55namespace llvm {56namespace dxil {57 58// Generates an enum to use as an index in the Abbrev array of Metadata record.59enum MetadataAbbrev : unsigned {60#define HANDLE_MDNODE_LEAF(CLASS) CLASS##AbbrevID,61#include "llvm/IR/Metadata.def"62  LastPlusOne63};64 65class DXILBitcodeWriter {66 67  /// These are manifest constants used by the bitcode writer. They do not need68  /// to be kept in sync with the reader, but need to be consistent within this69  /// file.70  enum {71    // VALUE_SYMTAB_BLOCK abbrev id's.72    VST_ENTRY_8_ABBREV = bitc::FIRST_APPLICATION_ABBREV,73    VST_ENTRY_7_ABBREV,74    VST_ENTRY_6_ABBREV,75    VST_BBENTRY_6_ABBREV,76 77    // CONSTANTS_BLOCK abbrev id's.78    CONSTANTS_SETTYPE_ABBREV = bitc::FIRST_APPLICATION_ABBREV,79    CONSTANTS_INTEGER_ABBREV,80    CONSTANTS_CE_CAST_Abbrev,81    CONSTANTS_NULL_Abbrev,82 83    // FUNCTION_BLOCK abbrev id's.84    FUNCTION_INST_LOAD_ABBREV = bitc::FIRST_APPLICATION_ABBREV,85    FUNCTION_INST_BINOP_ABBREV,86    FUNCTION_INST_BINOP_FLAGS_ABBREV,87    FUNCTION_INST_CAST_ABBREV,88    FUNCTION_INST_RET_VOID_ABBREV,89    FUNCTION_INST_RET_VAL_ABBREV,90    FUNCTION_INST_UNREACHABLE_ABBREV,91    FUNCTION_INST_GEP_ABBREV,92  };93 94  // Cache some types95  Type *I8Ty;96  Type *I8PtrTy;97 98  /// The stream created and owned by the client.99  BitstreamWriter &Stream;100 101  StringTableBuilder &StrtabBuilder;102 103  /// The Module to write to bitcode.104  const Module &M;105 106  /// Enumerates ids for all values in the module.107  ValueEnumerator VE;108 109  /// Map that holds the correspondence between GUIDs in the summary index,110  /// that came from indirect call profiles, and a value id generated by this111  /// class to use in the VST and summary block records.112  std::map<GlobalValue::GUID, unsigned> GUIDToValueIdMap;113 114  /// Tracks the last value id recorded in the GUIDToValueMap.115  unsigned GlobalValueId;116 117  /// Saves the offset of the VSTOffset record that must eventually be118  /// backpatched with the offset of the actual VST.119  uint64_t VSTOffsetPlaceholder = 0;120 121  /// Pointer to the buffer allocated by caller for bitcode writing.122  const SmallVectorImpl<char> &Buffer;123 124  /// The start bit of the identification block.125  uint64_t BitcodeStartBit;126 127  /// This maps values to their typed pointers128  PointerTypeMap PointerMap;129 130public:131  /// Constructs a ModuleBitcodeWriter object for the given Module,132  /// writing to the provided \p Buffer.133  DXILBitcodeWriter(const Module &M, SmallVectorImpl<char> &Buffer,134                    StringTableBuilder &StrtabBuilder, BitstreamWriter &Stream)135      : I8Ty(Type::getInt8Ty(M.getContext())),136        I8PtrTy(TypedPointerType::get(I8Ty, 0)), Stream(Stream),137        StrtabBuilder(StrtabBuilder), M(M), VE(M, I8PtrTy), Buffer(Buffer),138        BitcodeStartBit(Stream.GetCurrentBitNo()),139        PointerMap(PointerTypeAnalysis::run(M)) {140    GlobalValueId = VE.getValues().size();141    // Enumerate the typed pointers142    for (auto El : PointerMap)143      VE.EnumerateType(El.second);144  }145 146  /// Emit the current module to the bitstream.147  void write();148 149  static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind);150  static void writeStringRecord(BitstreamWriter &Stream, unsigned Code,151                                StringRef Str, unsigned AbbrevToUse);152  static void writeIdentificationBlock(BitstreamWriter &Stream);153  static void emitSignedInt64(SmallVectorImpl<uint64_t> &Vals, uint64_t V);154  static void emitWideAPInt(SmallVectorImpl<uint64_t> &Vals, const APInt &A);155 156  static unsigned getEncodedComdatSelectionKind(const Comdat &C);157  static unsigned getEncodedLinkage(const GlobalValue::LinkageTypes Linkage);158  static unsigned getEncodedLinkage(const GlobalValue &GV);159  static unsigned getEncodedVisibility(const GlobalValue &GV);160  static unsigned getEncodedThreadLocalMode(const GlobalValue &GV);161  static unsigned getEncodedDLLStorageClass(const GlobalValue &GV);162  static unsigned getEncodedCastOpcode(unsigned Opcode);163  static unsigned getEncodedUnaryOpcode(unsigned Opcode);164  static unsigned getEncodedBinaryOpcode(unsigned Opcode);165  static unsigned getEncodedRMWOperation(AtomicRMWInst::BinOp Op);166  static unsigned getEncodedOrdering(AtomicOrdering Ordering);167  static uint64_t getOptimizationFlags(const Value *V);168 169private:170  void writeModuleVersion();171  void writePerModuleGlobalValueSummary();172 173  void writePerModuleFunctionSummaryRecord(SmallVector<uint64_t, 64> &NameVals,174                                           GlobalValueSummary *Summary,175                                           unsigned ValueID,176                                           unsigned FSCallsAbbrev,177                                           unsigned FSCallsProfileAbbrev,178                                           const Function &F);179  void writeModuleLevelReferences(const GlobalVariable &V,180                                  SmallVector<uint64_t, 64> &NameVals,181                                  unsigned FSModRefsAbbrev,182                                  unsigned FSModVTableRefsAbbrev);183 184  void assignValueId(GlobalValue::GUID ValGUID) {185    GUIDToValueIdMap[ValGUID] = ++GlobalValueId;186  }187 188  unsigned getValueId(GlobalValue::GUID ValGUID) {189    const auto &VMI = GUIDToValueIdMap.find(ValGUID);190    // Expect that any GUID value had a value Id assigned by an191    // earlier call to assignValueId.192    assert(VMI != GUIDToValueIdMap.end() &&193           "GUID does not have assigned value Id");194    return VMI->second;195  }196 197  // Helper to get the valueId for the type of value recorded in VI.198  unsigned getValueId(ValueInfo VI) {199    if (!VI.haveGVs() || !VI.getValue())200      return getValueId(VI.getGUID());201    return VE.getValueID(VI.getValue());202  }203 204  std::map<GlobalValue::GUID, unsigned> &valueIds() { return GUIDToValueIdMap; }205 206  uint64_t bitcodeStartBit() { return BitcodeStartBit; }207 208  size_t addToStrtab(StringRef Str);209 210  unsigned createDILocationAbbrev();211  unsigned createGenericDINodeAbbrev();212 213  void writeAttributeGroupTable();214  void writeAttributeTable();215  void writeTypeTable();216  void writeComdats();217  void writeValueSymbolTableForwardDecl();218  void writeModuleInfo();219  void writeValueAsMetadata(const ValueAsMetadata *MD,220                            SmallVectorImpl<uint64_t> &Record);221  void writeMDTuple(const MDTuple *N, SmallVectorImpl<uint64_t> &Record,222                    unsigned Abbrev);223  void writeDILocation(const DILocation *N, SmallVectorImpl<uint64_t> &Record,224                       unsigned &Abbrev);225  void writeGenericDINode(const GenericDINode *N,226                          SmallVectorImpl<uint64_t> &Record, unsigned &Abbrev) {227    llvm_unreachable("DXIL cannot contain GenericDI Nodes");228  }229  void writeDISubrange(const DISubrange *N, SmallVectorImpl<uint64_t> &Record,230                       unsigned Abbrev);231  void writeDIGenericSubrange(const DIGenericSubrange *N,232                              SmallVectorImpl<uint64_t> &Record,233                              unsigned Abbrev) {234    llvm_unreachable("DXIL cannot contain DIGenericSubrange Nodes");235  }236  void writeDIEnumerator(const DIEnumerator *N,237                         SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);238  void writeDIBasicType(const DIBasicType *N, SmallVectorImpl<uint64_t> &Record,239                        unsigned Abbrev);240  void writeDIFixedPointType(const DIFixedPointType *N,241                             SmallVectorImpl<uint64_t> &Record,242                             unsigned Abbrev) {243    llvm_unreachable("DXIL cannot contain DIFixedPointType Nodes");244  }245  void writeDIStringType(const DIStringType *N,246                         SmallVectorImpl<uint64_t> &Record, unsigned Abbrev) {247    llvm_unreachable("DXIL cannot contain DIStringType Nodes");248  }249  void writeDIDerivedType(const DIDerivedType *N,250                          SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);251  void writeDISubrangeType(const DISubrangeType *N,252                           SmallVectorImpl<uint64_t> &Record, unsigned Abbrev) {253    llvm_unreachable("DXIL cannot contain DISubrangeType Nodes");254  }255  void writeDICompositeType(const DICompositeType *N,256                            SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);257  void writeDISubroutineType(const DISubroutineType *N,258                             SmallVectorImpl<uint64_t> &Record,259                             unsigned Abbrev);260  void writeDIFile(const DIFile *N, SmallVectorImpl<uint64_t> &Record,261                   unsigned Abbrev);262  void writeDICompileUnit(const DICompileUnit *N,263                          SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);264  void writeDISubprogram(const DISubprogram *N,265                         SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);266  void writeDILexicalBlock(const DILexicalBlock *N,267                           SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);268  void writeDILexicalBlockFile(const DILexicalBlockFile *N,269                               SmallVectorImpl<uint64_t> &Record,270                               unsigned Abbrev);271  void writeDICommonBlock(const DICommonBlock *N,272                          SmallVectorImpl<uint64_t> &Record, unsigned Abbrev) {273    llvm_unreachable("DXIL cannot contain DICommonBlock Nodes");274  }275  void writeDINamespace(const DINamespace *N, SmallVectorImpl<uint64_t> &Record,276                        unsigned Abbrev);277  void writeDIMacro(const DIMacro *N, SmallVectorImpl<uint64_t> &Record,278                    unsigned Abbrev) {279    llvm_unreachable("DXIL cannot contain DIMacro Nodes");280  }281  void writeDIMacroFile(const DIMacroFile *N, SmallVectorImpl<uint64_t> &Record,282                        unsigned Abbrev) {283    llvm_unreachable("DXIL cannot contain DIMacroFile Nodes");284  }285  void writeDIArgList(const DIArgList *N, SmallVectorImpl<uint64_t> &Record,286                      unsigned Abbrev) {287    llvm_unreachable("DXIL cannot contain DIArgList Nodes");288  }289  void writeDIAssignID(const DIAssignID *N, SmallVectorImpl<uint64_t> &Record,290                       unsigned Abbrev) {291    // DIAssignID is experimental feature to track variable location in IR..292    // FIXME: translate DIAssignID to debug info DXIL supports.293    //   See https://github.com/llvm/llvm-project/issues/58989294    llvm_unreachable("DXIL cannot contain DIAssignID Nodes");295  }296  void writeDIModule(const DIModule *N, SmallVectorImpl<uint64_t> &Record,297                     unsigned Abbrev);298  void writeDITemplateTypeParameter(const DITemplateTypeParameter *N,299                                    SmallVectorImpl<uint64_t> &Record,300                                    unsigned Abbrev);301  void writeDITemplateValueParameter(const DITemplateValueParameter *N,302                                     SmallVectorImpl<uint64_t> &Record,303                                     unsigned Abbrev);304  void writeDIGlobalVariable(const DIGlobalVariable *N,305                             SmallVectorImpl<uint64_t> &Record,306                             unsigned Abbrev);307  void writeDILocalVariable(const DILocalVariable *N,308                            SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);309  void writeDILabel(const DILabel *N, SmallVectorImpl<uint64_t> &Record,310                    unsigned Abbrev) {311    llvm_unreachable("DXIL cannot contain DILabel Nodes");312  }313  void writeDIExpression(const DIExpression *N,314                         SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);315  void writeDIGlobalVariableExpression(const DIGlobalVariableExpression *N,316                                       SmallVectorImpl<uint64_t> &Record,317                                       unsigned Abbrev) {318    llvm_unreachable("DXIL cannot contain GlobalVariableExpression Nodes");319  }320  void writeDIObjCProperty(const DIObjCProperty *N,321                           SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);322  void writeDIImportedEntity(const DIImportedEntity *N,323                             SmallVectorImpl<uint64_t> &Record,324                             unsigned Abbrev);325  unsigned createNamedMetadataAbbrev();326  void writeNamedMetadata(SmallVectorImpl<uint64_t> &Record);327  unsigned createMetadataStringsAbbrev();328  void writeMetadataStrings(ArrayRef<const Metadata *> Strings,329                            SmallVectorImpl<uint64_t> &Record);330  void writeMetadataRecords(ArrayRef<const Metadata *> MDs,331                            SmallVectorImpl<uint64_t> &Record,332                            std::vector<unsigned> *MDAbbrevs = nullptr,333                            std::vector<uint64_t> *IndexPos = nullptr);334  void writeModuleMetadata();335  void writeFunctionMetadata(const Function &F);336  void writeFunctionMetadataAttachment(const Function &F);337  void pushGlobalMetadataAttachment(SmallVectorImpl<uint64_t> &Record,338                                    const GlobalObject &GO);339  void writeModuleMetadataKinds();340  void writeOperandBundleTags();341  void writeSyncScopeNames();342  void writeConstants(unsigned FirstVal, unsigned LastVal, bool isGlobal);343  void writeModuleConstants();344  bool pushValueAndType(const Value *V, unsigned InstID,345                        SmallVectorImpl<unsigned> &Vals);346  void writeOperandBundles(const CallBase &CB, unsigned InstID);347  void pushValue(const Value *V, unsigned InstID,348                 SmallVectorImpl<unsigned> &Vals);349  void pushValueSigned(const Value *V, unsigned InstID,350                       SmallVectorImpl<uint64_t> &Vals);351  void writeInstruction(const Instruction &I, unsigned InstID,352                        SmallVectorImpl<unsigned> &Vals);353  void writeFunctionLevelValueSymbolTable(const ValueSymbolTable &VST);354  void writeGlobalValueSymbolTable(355      DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex);356  void writeFunction(const Function &F);357  void writeBlockInfo();358 359  unsigned getEncodedSyncScopeID(SyncScope::ID SSID) { return unsigned(SSID); }360 361  unsigned getEncodedAlign(MaybeAlign Alignment) { return encode(Alignment); }362 363  unsigned getTypeID(Type *T, const Value *V = nullptr);364  /// getGlobalObjectValueTypeID - returns the element type for a GlobalObject365  ///366  /// GlobalObject types are saved by PointerTypeAnalysis as pointers to the367  /// GlobalObject, but in the bitcode writer we need the pointer element type.368  unsigned getGlobalObjectValueTypeID(Type *T, const GlobalObject *G);369};370 371} // namespace dxil372} // namespace llvm373 374using namespace llvm;375using namespace llvm::dxil;376 377////////////////////////////////////////////////////////////////////////////////378/// Begin dxil::BitcodeWriter Implementation379////////////////////////////////////////////////////////////////////////////////380 381dxil::BitcodeWriter::BitcodeWriter(SmallVectorImpl<char> &Buffer)382    : Buffer(Buffer), Stream(new BitstreamWriter(Buffer)) {383  // Emit the file header.384  Stream->Emit((unsigned)'B', 8);385  Stream->Emit((unsigned)'C', 8);386  Stream->Emit(0x0, 4);387  Stream->Emit(0xC, 4);388  Stream->Emit(0xE, 4);389  Stream->Emit(0xD, 4);390}391 392dxil::BitcodeWriter::~BitcodeWriter() { }393 394/// Write the specified module to the specified output stream.395void dxil::WriteDXILToFile(const Module &M, raw_ostream &Out) {396  SmallVector<char, 0> Buffer;397  Buffer.reserve(256 * 1024);398 399  // If this is darwin or another generic macho target, reserve space for the400  // header.401  Triple TT(M.getTargetTriple());402  if (TT.isOSDarwin() || TT.isOSBinFormatMachO())403    Buffer.insert(Buffer.begin(), BWH_HeaderSize, 0);404 405  BitcodeWriter Writer(Buffer);406  Writer.writeModule(M);407 408  // Write the generated bitstream to "Out".409  if (!Buffer.empty())410    Out.write((char *)&Buffer.front(), Buffer.size());411}412 413void BitcodeWriter::writeBlob(unsigned Block, unsigned Record, StringRef Blob) {414  Stream->EnterSubblock(Block, 3);415 416  auto Abbv = std::make_shared<BitCodeAbbrev>();417  Abbv->Add(BitCodeAbbrevOp(Record));418  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));419  auto AbbrevNo = Stream->EmitAbbrev(std::move(Abbv));420 421  Stream->EmitRecordWithBlob(AbbrevNo, ArrayRef<uint64_t>{Record}, Blob);422 423  Stream->ExitBlock();424}425 426void BitcodeWriter::writeModule(const Module &M) {427 428  // The Mods vector is used by irsymtab::build, which requires non-const429  // Modules in case it needs to materialize metadata. But the bitcode writer430  // requires that the module is materialized, so we can cast to non-const here,431  // after checking that it is in fact materialized.432  assert(M.isMaterialized());433  Mods.push_back(const_cast<Module *>(&M));434 435  DXILBitcodeWriter ModuleWriter(M, Buffer, StrtabBuilder, *Stream);436  ModuleWriter.write();437}438 439////////////////////////////////////////////////////////////////////////////////440/// Begin dxil::BitcodeWriterBase Implementation441////////////////////////////////////////////////////////////////////////////////442 443unsigned DXILBitcodeWriter::getEncodedCastOpcode(unsigned Opcode) {444  switch (Opcode) {445  default:446    llvm_unreachable("Unknown cast instruction!");447  case Instruction::Trunc:448    return bitc::CAST_TRUNC;449  case Instruction::ZExt:450    return bitc::CAST_ZEXT;451  case Instruction::SExt:452    return bitc::CAST_SEXT;453  case Instruction::FPToUI:454    return bitc::CAST_FPTOUI;455  case Instruction::FPToSI:456    return bitc::CAST_FPTOSI;457  case Instruction::UIToFP:458    return bitc::CAST_UITOFP;459  case Instruction::SIToFP:460    return bitc::CAST_SITOFP;461  case Instruction::FPTrunc:462    return bitc::CAST_FPTRUNC;463  case Instruction::FPExt:464    return bitc::CAST_FPEXT;465  case Instruction::PtrToInt:466    return bitc::CAST_PTRTOINT;467  case Instruction::IntToPtr:468    return bitc::CAST_INTTOPTR;469  case Instruction::BitCast:470    return bitc::CAST_BITCAST;471  case Instruction::AddrSpaceCast:472    return bitc::CAST_ADDRSPACECAST;473  }474}475 476unsigned DXILBitcodeWriter::getEncodedUnaryOpcode(unsigned Opcode) {477  switch (Opcode) {478  default:479    llvm_unreachable("Unknown binary instruction!");480  case Instruction::FNeg:481    return bitc::UNOP_FNEG;482  }483}484 485unsigned DXILBitcodeWriter::getEncodedBinaryOpcode(unsigned Opcode) {486  switch (Opcode) {487  default:488    llvm_unreachable("Unknown binary instruction!");489  case Instruction::Add:490  case Instruction::FAdd:491    return bitc::BINOP_ADD;492  case Instruction::Sub:493  case Instruction::FSub:494    return bitc::BINOP_SUB;495  case Instruction::Mul:496  case Instruction::FMul:497    return bitc::BINOP_MUL;498  case Instruction::UDiv:499    return bitc::BINOP_UDIV;500  case Instruction::FDiv:501  case Instruction::SDiv:502    return bitc::BINOP_SDIV;503  case Instruction::URem:504    return bitc::BINOP_UREM;505  case Instruction::FRem:506  case Instruction::SRem:507    return bitc::BINOP_SREM;508  case Instruction::Shl:509    return bitc::BINOP_SHL;510  case Instruction::LShr:511    return bitc::BINOP_LSHR;512  case Instruction::AShr:513    return bitc::BINOP_ASHR;514  case Instruction::And:515    return bitc::BINOP_AND;516  case Instruction::Or:517    return bitc::BINOP_OR;518  case Instruction::Xor:519    return bitc::BINOP_XOR;520  }521}522 523unsigned DXILBitcodeWriter::getTypeID(Type *T, const Value *V) {524  if (!T->isPointerTy() &&525      // For Constant, always check PointerMap to make sure OpaquePointer in526      // things like constant struct/array works.527      (!V || !isa<Constant>(V)))528    return VE.getTypeID(T);529  auto It = PointerMap.find(V);530  if (It != PointerMap.end())531    return VE.getTypeID(It->second);532  // For Constant, return T when cannot find in PointerMap.533  // FIXME: support ConstantPointerNull which could map to more than one534  // TypedPointerType.535  // See https://github.com/llvm/llvm-project/issues/57942.536  if (V && isa<Constant>(V) && !isa<ConstantPointerNull>(V))537    return VE.getTypeID(T);538  return VE.getTypeID(I8PtrTy);539}540 541unsigned DXILBitcodeWriter::getGlobalObjectValueTypeID(Type *T,542                                                       const GlobalObject *G) {543  auto It = PointerMap.find(G);544  if (It != PointerMap.end()) {545    TypedPointerType *PtrTy = cast<TypedPointerType>(It->second);546    return VE.getTypeID(PtrTy->getElementType());547  }548  return VE.getTypeID(T);549}550 551unsigned DXILBitcodeWriter::getEncodedRMWOperation(AtomicRMWInst::BinOp Op) {552  switch (Op) {553  default:554    llvm_unreachable("Unknown RMW operation!");555  case AtomicRMWInst::Xchg:556    return bitc::RMW_XCHG;557  case AtomicRMWInst::Add:558    return bitc::RMW_ADD;559  case AtomicRMWInst::Sub:560    return bitc::RMW_SUB;561  case AtomicRMWInst::And:562    return bitc::RMW_AND;563  case AtomicRMWInst::Nand:564    return bitc::RMW_NAND;565  case AtomicRMWInst::Or:566    return bitc::RMW_OR;567  case AtomicRMWInst::Xor:568    return bitc::RMW_XOR;569  case AtomicRMWInst::Max:570    return bitc::RMW_MAX;571  case AtomicRMWInst::Min:572    return bitc::RMW_MIN;573  case AtomicRMWInst::UMax:574    return bitc::RMW_UMAX;575  case AtomicRMWInst::UMin:576    return bitc::RMW_UMIN;577  case AtomicRMWInst::FAdd:578    return bitc::RMW_FADD;579  case AtomicRMWInst::FSub:580    return bitc::RMW_FSUB;581  case AtomicRMWInst::FMax:582    return bitc::RMW_FMAX;583  case AtomicRMWInst::FMin:584    return bitc::RMW_FMIN;585  }586}587 588unsigned DXILBitcodeWriter::getEncodedOrdering(AtomicOrdering Ordering) {589  switch (Ordering) {590  case AtomicOrdering::NotAtomic:591    return bitc::ORDERING_NOTATOMIC;592  case AtomicOrdering::Unordered:593    return bitc::ORDERING_UNORDERED;594  case AtomicOrdering::Monotonic:595    return bitc::ORDERING_MONOTONIC;596  case AtomicOrdering::Acquire:597    return bitc::ORDERING_ACQUIRE;598  case AtomicOrdering::Release:599    return bitc::ORDERING_RELEASE;600  case AtomicOrdering::AcquireRelease:601    return bitc::ORDERING_ACQREL;602  case AtomicOrdering::SequentiallyConsistent:603    return bitc::ORDERING_SEQCST;604  }605  llvm_unreachable("Invalid ordering");606}607 608void DXILBitcodeWriter::writeStringRecord(BitstreamWriter &Stream,609                                          unsigned Code, StringRef Str,610                                          unsigned AbbrevToUse) {611  SmallVector<unsigned, 64> Vals;612 613  // Code: [strchar x N]614  for (char C : Str) {615    if (AbbrevToUse && !BitCodeAbbrevOp::isChar6(C))616      AbbrevToUse = 0;617    Vals.push_back(C);618  }619 620  // Emit the finished record.621  Stream.EmitRecord(Code, Vals, AbbrevToUse);622}623 624uint64_t DXILBitcodeWriter::getAttrKindEncoding(Attribute::AttrKind Kind) {625  switch (Kind) {626  case Attribute::Alignment:627    return bitc::ATTR_KIND_ALIGNMENT;628  case Attribute::AlwaysInline:629    return bitc::ATTR_KIND_ALWAYS_INLINE;630  case Attribute::Builtin:631    return bitc::ATTR_KIND_BUILTIN;632  case Attribute::ByVal:633    return bitc::ATTR_KIND_BY_VAL;634  case Attribute::Convergent:635    return bitc::ATTR_KIND_CONVERGENT;636  case Attribute::InAlloca:637    return bitc::ATTR_KIND_IN_ALLOCA;638  case Attribute::Cold:639    return bitc::ATTR_KIND_COLD;640  case Attribute::InlineHint:641    return bitc::ATTR_KIND_INLINE_HINT;642  case Attribute::InReg:643    return bitc::ATTR_KIND_IN_REG;644  case Attribute::JumpTable:645    return bitc::ATTR_KIND_JUMP_TABLE;646  case Attribute::MinSize:647    return bitc::ATTR_KIND_MIN_SIZE;648  case Attribute::Naked:649    return bitc::ATTR_KIND_NAKED;650  case Attribute::Nest:651    return bitc::ATTR_KIND_NEST;652  case Attribute::NoAlias:653    return bitc::ATTR_KIND_NO_ALIAS;654  case Attribute::NoBuiltin:655    return bitc::ATTR_KIND_NO_BUILTIN;656  case Attribute::NoDuplicate:657    return bitc::ATTR_KIND_NO_DUPLICATE;658  case Attribute::NoImplicitFloat:659    return bitc::ATTR_KIND_NO_IMPLICIT_FLOAT;660  case Attribute::NoInline:661    return bitc::ATTR_KIND_NO_INLINE;662  case Attribute::NonLazyBind:663    return bitc::ATTR_KIND_NON_LAZY_BIND;664  case Attribute::NonNull:665    return bitc::ATTR_KIND_NON_NULL;666  case Attribute::Dereferenceable:667    return bitc::ATTR_KIND_DEREFERENCEABLE;668  case Attribute::DereferenceableOrNull:669    return bitc::ATTR_KIND_DEREFERENCEABLE_OR_NULL;670  case Attribute::NoRedZone:671    return bitc::ATTR_KIND_NO_RED_ZONE;672  case Attribute::NoReturn:673    return bitc::ATTR_KIND_NO_RETURN;674  case Attribute::NoUnwind:675    return bitc::ATTR_KIND_NO_UNWIND;676  case Attribute::OptimizeForSize:677    return bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE;678  case Attribute::OptimizeNone:679    return bitc::ATTR_KIND_OPTIMIZE_NONE;680  case Attribute::ReadNone:681    return bitc::ATTR_KIND_READ_NONE;682  case Attribute::ReadOnly:683    return bitc::ATTR_KIND_READ_ONLY;684  case Attribute::Returned:685    return bitc::ATTR_KIND_RETURNED;686  case Attribute::ReturnsTwice:687    return bitc::ATTR_KIND_RETURNS_TWICE;688  case Attribute::SExt:689    return bitc::ATTR_KIND_S_EXT;690  case Attribute::StackAlignment:691    return bitc::ATTR_KIND_STACK_ALIGNMENT;692  case Attribute::StackProtect:693    return bitc::ATTR_KIND_STACK_PROTECT;694  case Attribute::StackProtectReq:695    return bitc::ATTR_KIND_STACK_PROTECT_REQ;696  case Attribute::StackProtectStrong:697    return bitc::ATTR_KIND_STACK_PROTECT_STRONG;698  case Attribute::SafeStack:699    return bitc::ATTR_KIND_SAFESTACK;700  case Attribute::StructRet:701    return bitc::ATTR_KIND_STRUCT_RET;702  case Attribute::SanitizeAddress:703    return bitc::ATTR_KIND_SANITIZE_ADDRESS;704  case Attribute::SanitizeThread:705    return bitc::ATTR_KIND_SANITIZE_THREAD;706  case Attribute::SanitizeMemory:707    return bitc::ATTR_KIND_SANITIZE_MEMORY;708  case Attribute::UWTable:709    return bitc::ATTR_KIND_UW_TABLE;710  case Attribute::ZExt:711    return bitc::ATTR_KIND_Z_EXT;712  case Attribute::EndAttrKinds:713    llvm_unreachable("Can not encode end-attribute kinds marker.");714  case Attribute::None:715    llvm_unreachable("Can not encode none-attribute.");716  case Attribute::EmptyKey:717  case Attribute::TombstoneKey:718    llvm_unreachable("Trying to encode EmptyKey/TombstoneKey");719  default:720    llvm_unreachable("Trying to encode attribute not supported by DXIL. These "721                     "should be stripped in DXILPrepare");722  }723 724  llvm_unreachable("Trying to encode unknown attribute");725}726 727void DXILBitcodeWriter::emitSignedInt64(SmallVectorImpl<uint64_t> &Vals,728                                        uint64_t V) {729  if ((int64_t)V >= 0)730    Vals.push_back(V << 1);731  else732    Vals.push_back((-V << 1) | 1);733}734 735void DXILBitcodeWriter::emitWideAPInt(SmallVectorImpl<uint64_t> &Vals,736                                      const APInt &A) {737  // We have an arbitrary precision integer value to write whose738  // bit width is > 64. However, in canonical unsigned integer739  // format it is likely that the high bits are going to be zero.740  // So, we only write the number of active words.741  unsigned NumWords = A.getActiveWords();742  const uint64_t *RawData = A.getRawData();743  for (unsigned i = 0; i < NumWords; i++)744    emitSignedInt64(Vals, RawData[i]);745}746 747uint64_t DXILBitcodeWriter::getOptimizationFlags(const Value *V) {748  uint64_t Flags = 0;749 750  if (const auto *OBO = dyn_cast<OverflowingBinaryOperator>(V)) {751    if (OBO->hasNoSignedWrap())752      Flags |= 1 << bitc::OBO_NO_SIGNED_WRAP;753    if (OBO->hasNoUnsignedWrap())754      Flags |= 1 << bitc::OBO_NO_UNSIGNED_WRAP;755  } else if (const auto *PEO = dyn_cast<PossiblyExactOperator>(V)) {756    if (PEO->isExact())757      Flags |= 1 << bitc::PEO_EXACT;758  } else if (const auto *FPMO = dyn_cast<FPMathOperator>(V)) {759    if (FPMO->hasAllowReassoc() || FPMO->hasAllowContract())760      Flags |= bitc::UnsafeAlgebra;761    if (FPMO->hasNoNaNs())762      Flags |= bitc::NoNaNs;763    if (FPMO->hasNoInfs())764      Flags |= bitc::NoInfs;765    if (FPMO->hasNoSignedZeros())766      Flags |= bitc::NoSignedZeros;767    if (FPMO->hasAllowReciprocal())768      Flags |= bitc::AllowReciprocal;769  }770 771  return Flags;772}773 774unsigned775DXILBitcodeWriter::getEncodedLinkage(const GlobalValue::LinkageTypes Linkage) {776  switch (Linkage) {777  case GlobalValue::ExternalLinkage:778    return 0;779  case GlobalValue::WeakAnyLinkage:780    return 16;781  case GlobalValue::AppendingLinkage:782    return 2;783  case GlobalValue::InternalLinkage:784    return 3;785  case GlobalValue::LinkOnceAnyLinkage:786    return 18;787  case GlobalValue::ExternalWeakLinkage:788    return 7;789  case GlobalValue::CommonLinkage:790    return 8;791  case GlobalValue::PrivateLinkage:792    return 9;793  case GlobalValue::WeakODRLinkage:794    return 17;795  case GlobalValue::LinkOnceODRLinkage:796    return 19;797  case GlobalValue::AvailableExternallyLinkage:798    return 12;799  }800  llvm_unreachable("Invalid linkage");801}802 803unsigned DXILBitcodeWriter::getEncodedLinkage(const GlobalValue &GV) {804  return getEncodedLinkage(GV.getLinkage());805}806 807unsigned DXILBitcodeWriter::getEncodedVisibility(const GlobalValue &GV) {808  switch (GV.getVisibility()) {809  case GlobalValue::DefaultVisibility:810    return 0;811  case GlobalValue::HiddenVisibility:812    return 1;813  case GlobalValue::ProtectedVisibility:814    return 2;815  }816  llvm_unreachable("Invalid visibility");817}818 819unsigned DXILBitcodeWriter::getEncodedDLLStorageClass(const GlobalValue &GV) {820  switch (GV.getDLLStorageClass()) {821  case GlobalValue::DefaultStorageClass:822    return 0;823  case GlobalValue::DLLImportStorageClass:824    return 1;825  case GlobalValue::DLLExportStorageClass:826    return 2;827  }828  llvm_unreachable("Invalid DLL storage class");829}830 831unsigned DXILBitcodeWriter::getEncodedThreadLocalMode(const GlobalValue &GV) {832  switch (GV.getThreadLocalMode()) {833  case GlobalVariable::NotThreadLocal:834    return 0;835  case GlobalVariable::GeneralDynamicTLSModel:836    return 1;837  case GlobalVariable::LocalDynamicTLSModel:838    return 2;839  case GlobalVariable::InitialExecTLSModel:840    return 3;841  case GlobalVariable::LocalExecTLSModel:842    return 4;843  }844  llvm_unreachable("Invalid TLS model");845}846 847unsigned DXILBitcodeWriter::getEncodedComdatSelectionKind(const Comdat &C) {848  switch (C.getSelectionKind()) {849  case Comdat::Any:850    return bitc::COMDAT_SELECTION_KIND_ANY;851  case Comdat::ExactMatch:852    return bitc::COMDAT_SELECTION_KIND_EXACT_MATCH;853  case Comdat::Largest:854    return bitc::COMDAT_SELECTION_KIND_LARGEST;855  case Comdat::NoDeduplicate:856    return bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES;857  case Comdat::SameSize:858    return bitc::COMDAT_SELECTION_KIND_SAME_SIZE;859  }860  llvm_unreachable("Invalid selection kind");861}862 863////////////////////////////////////////////////////////////////////////////////864/// Begin DXILBitcodeWriter Implementation865////////////////////////////////////////////////////////////////////////////////866 867void DXILBitcodeWriter::writeAttributeGroupTable() {868  const std::vector<ValueEnumerator::IndexAndAttrSet> &AttrGrps =869      VE.getAttributeGroups();870  if (AttrGrps.empty())871    return;872 873  Stream.EnterSubblock(bitc::PARAMATTR_GROUP_BLOCK_ID, 3);874 875  SmallVector<uint64_t, 64> Record;876  for (ValueEnumerator::IndexAndAttrSet Pair : AttrGrps) {877    unsigned AttrListIndex = Pair.first;878    AttributeSet AS = Pair.second;879    Record.push_back(VE.getAttributeGroupID(Pair));880    Record.push_back(AttrListIndex);881 882    for (Attribute Attr : AS) {883      if (Attr.isEnumAttribute()) {884        uint64_t Val = getAttrKindEncoding(Attr.getKindAsEnum());885        assert(Val <= bitc::ATTR_KIND_ARGMEMONLY &&886               "DXIL does not support attributes above ATTR_KIND_ARGMEMONLY");887        Record.push_back(0);888        Record.push_back(Val);889      } else if (Attr.isIntAttribute()) {890        if (Attr.getKindAsEnum() == Attribute::AttrKind::Memory) {891          MemoryEffects ME = Attr.getMemoryEffects();892          if (ME.doesNotAccessMemory()) {893            Record.push_back(0);894            Record.push_back(bitc::ATTR_KIND_READ_NONE);895          } else {896            if (ME.onlyReadsMemory()) {897              Record.push_back(0);898              Record.push_back(bitc::ATTR_KIND_READ_ONLY);899            }900            if (ME.onlyAccessesArgPointees()) {901              Record.push_back(0);902              Record.push_back(bitc::ATTR_KIND_ARGMEMONLY);903            }904          }905        } else {906          uint64_t Val = getAttrKindEncoding(Attr.getKindAsEnum());907          assert(Val <= bitc::ATTR_KIND_ARGMEMONLY &&908                 "DXIL does not support attributes above ATTR_KIND_ARGMEMONLY");909          Record.push_back(1);910          Record.push_back(Val);911          Record.push_back(Attr.getValueAsInt());912        }913      } else {914        StringRef Kind = Attr.getKindAsString();915        StringRef Val = Attr.getValueAsString();916 917        Record.push_back(Val.empty() ? 3 : 4);918        Record.append(Kind.begin(), Kind.end());919        Record.push_back(0);920        if (!Val.empty()) {921          Record.append(Val.begin(), Val.end());922          Record.push_back(0);923        }924      }925    }926 927    Stream.EmitRecord(bitc::PARAMATTR_GRP_CODE_ENTRY, Record);928    Record.clear();929  }930 931  Stream.ExitBlock();932}933 934void DXILBitcodeWriter::writeAttributeTable() {935  const std::vector<AttributeList> &Attrs = VE.getAttributeLists();936  if (Attrs.empty())937    return;938 939  Stream.EnterSubblock(bitc::PARAMATTR_BLOCK_ID, 3);940 941  SmallVector<uint64_t, 64> Record;942  for (AttributeList AL : Attrs) {943    for (unsigned i : AL.indexes()) {944      AttributeSet AS = AL.getAttributes(i);945      if (AS.hasAttributes())946        Record.push_back(VE.getAttributeGroupID({i, AS}));947    }948 949    Stream.EmitRecord(bitc::PARAMATTR_CODE_ENTRY, Record);950    Record.clear();951  }952 953  Stream.ExitBlock();954}955 956/// WriteTypeTable - Write out the type table for a module.957void DXILBitcodeWriter::writeTypeTable() {958  const ValueEnumerator::TypeList &TypeList = VE.getTypes();959 960  Stream.EnterSubblock(bitc::TYPE_BLOCK_ID_NEW, 4 /*count from # abbrevs */);961  SmallVector<uint64_t, 64> TypeVals;962 963  uint64_t NumBits = VE.computeBitsRequiredForTypeIndices();964 965  // Abbrev for TYPE_CODE_POINTER.966  auto Abbv = std::make_shared<BitCodeAbbrev>();967  Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_POINTER));968  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));969  Abbv->Add(BitCodeAbbrevOp(0)); // Addrspace = 0970  unsigned PtrAbbrev = Stream.EmitAbbrev(std::move(Abbv));971 972  // Abbrev for TYPE_CODE_FUNCTION.973  Abbv = std::make_shared<BitCodeAbbrev>();974  Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_FUNCTION));975  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isvararg976  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));977  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));978  unsigned FunctionAbbrev = Stream.EmitAbbrev(std::move(Abbv));979 980  // Abbrev for TYPE_CODE_STRUCT_ANON.981  Abbv = std::make_shared<BitCodeAbbrev>();982  Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_ANON));983  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ispacked984  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));985  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));986  unsigned StructAnonAbbrev = Stream.EmitAbbrev(std::move(Abbv));987 988  // Abbrev for TYPE_CODE_STRUCT_NAME.989  Abbv = std::make_shared<BitCodeAbbrev>();990  Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_NAME));991  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));992  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));993  unsigned StructNameAbbrev = Stream.EmitAbbrev(std::move(Abbv));994 995  // Abbrev for TYPE_CODE_STRUCT_NAMED.996  Abbv = std::make_shared<BitCodeAbbrev>();997  Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_NAMED));998  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ispacked999  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));1000  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));1001  unsigned StructNamedAbbrev = Stream.EmitAbbrev(std::move(Abbv));1002 1003  // Abbrev for TYPE_CODE_ARRAY.1004  Abbv = std::make_shared<BitCodeAbbrev>();1005  Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_ARRAY));1006  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // size1007  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));1008  unsigned ArrayAbbrev = Stream.EmitAbbrev(std::move(Abbv));1009 1010  // Emit an entry count so the reader can reserve space.1011  TypeVals.push_back(TypeList.size());1012  Stream.EmitRecord(bitc::TYPE_CODE_NUMENTRY, TypeVals);1013  TypeVals.clear();1014 1015  // Loop over all of the types, emitting each in turn.1016  for (Type *T : TypeList) {1017    int AbbrevToUse = 0;1018    unsigned Code = 0;1019 1020    switch (T->getTypeID()) {1021    case Type::BFloatTyID:1022    case Type::X86_AMXTyID:1023    case Type::TokenTyID:1024    case Type::TargetExtTyID:1025      llvm_unreachable("These should never be used!!!");1026      break;1027    case Type::VoidTyID:1028      Code = bitc::TYPE_CODE_VOID;1029      break;1030    case Type::HalfTyID:1031      Code = bitc::TYPE_CODE_HALF;1032      break;1033    case Type::FloatTyID:1034      Code = bitc::TYPE_CODE_FLOAT;1035      break;1036    case Type::DoubleTyID:1037      Code = bitc::TYPE_CODE_DOUBLE;1038      break;1039    case Type::X86_FP80TyID:1040      Code = bitc::TYPE_CODE_X86_FP80;1041      break;1042    case Type::FP128TyID:1043      Code = bitc::TYPE_CODE_FP128;1044      break;1045    case Type::PPC_FP128TyID:1046      Code = bitc::TYPE_CODE_PPC_FP128;1047      break;1048    case Type::LabelTyID:1049      Code = bitc::TYPE_CODE_LABEL;1050      break;1051    case Type::MetadataTyID:1052      Code = bitc::TYPE_CODE_METADATA;1053      break;1054    case Type::IntegerTyID:1055      // INTEGER: [width]1056      Code = bitc::TYPE_CODE_INTEGER;1057      TypeVals.push_back(cast<IntegerType>(T)->getBitWidth());1058      break;1059    case Type::TypedPointerTyID: {1060      TypedPointerType *PTy = cast<TypedPointerType>(T);1061      // POINTER: [pointee type, address space]1062      Code = bitc::TYPE_CODE_POINTER;1063      TypeVals.push_back(getTypeID(PTy->getElementType()));1064      unsigned AddressSpace = PTy->getAddressSpace();1065      TypeVals.push_back(AddressSpace);1066      if (AddressSpace == 0)1067        AbbrevToUse = PtrAbbrev;1068      break;1069    }1070    case Type::PointerTyID: {1071      // POINTER: [pointee type, address space]1072      // Emitting an empty struct type for the pointer's type allows this to be1073      // order-independent. Non-struct types must be emitted in bitcode before1074      // they can be referenced.1075      TypeVals.push_back(false);1076      Code = bitc::TYPE_CODE_OPAQUE;1077      writeStringRecord(Stream, bitc::TYPE_CODE_STRUCT_NAME,1078                        "dxilOpaquePtrReservedName", StructNameAbbrev);1079      break;1080    }1081    case Type::FunctionTyID: {1082      FunctionType *FT = cast<FunctionType>(T);1083      // FUNCTION: [isvararg, retty, paramty x N]1084      Code = bitc::TYPE_CODE_FUNCTION;1085      TypeVals.push_back(FT->isVarArg());1086      TypeVals.push_back(getTypeID(FT->getReturnType()));1087      for (Type *PTy : FT->params())1088        TypeVals.push_back(getTypeID(PTy));1089      AbbrevToUse = FunctionAbbrev;1090      break;1091    }1092    case Type::StructTyID: {1093      StructType *ST = cast<StructType>(T);1094      // STRUCT: [ispacked, eltty x N]1095      TypeVals.push_back(ST->isPacked());1096      // Output all of the element types.1097      for (Type *ElTy : ST->elements())1098        TypeVals.push_back(getTypeID(ElTy));1099 1100      if (ST->isLiteral()) {1101        Code = bitc::TYPE_CODE_STRUCT_ANON;1102        AbbrevToUse = StructAnonAbbrev;1103      } else {1104        if (ST->isOpaque()) {1105          Code = bitc::TYPE_CODE_OPAQUE;1106        } else {1107          Code = bitc::TYPE_CODE_STRUCT_NAMED;1108          AbbrevToUse = StructNamedAbbrev;1109        }1110 1111        // Emit the name if it is present.1112        if (!ST->getName().empty())1113          writeStringRecord(Stream, bitc::TYPE_CODE_STRUCT_NAME, ST->getName(),1114                            StructNameAbbrev);1115      }1116      break;1117    }1118    case Type::ArrayTyID: {1119      ArrayType *AT = cast<ArrayType>(T);1120      // ARRAY: [numelts, eltty]1121      Code = bitc::TYPE_CODE_ARRAY;1122      TypeVals.push_back(AT->getNumElements());1123      TypeVals.push_back(getTypeID(AT->getElementType()));1124      AbbrevToUse = ArrayAbbrev;1125      break;1126    }1127    case Type::FixedVectorTyID:1128    case Type::ScalableVectorTyID: {1129      VectorType *VT = cast<VectorType>(T);1130      // VECTOR [numelts, eltty]1131      Code = bitc::TYPE_CODE_VECTOR;1132      TypeVals.push_back(VT->getElementCount().getKnownMinValue());1133      TypeVals.push_back(getTypeID(VT->getElementType()));1134      break;1135    }1136    }1137 1138    // Emit the finished record.1139    Stream.EmitRecord(Code, TypeVals, AbbrevToUse);1140    TypeVals.clear();1141  }1142 1143  Stream.ExitBlock();1144}1145 1146void DXILBitcodeWriter::writeComdats() {1147  SmallVector<uint16_t, 64> Vals;1148  for (const Comdat *C : VE.getComdats()) {1149    // COMDAT: [selection_kind, name]1150    Vals.push_back(getEncodedComdatSelectionKind(*C));1151    size_t Size = C->getName().size();1152    assert(isUInt<16>(Size));1153    Vals.push_back(Size);1154    for (char Chr : C->getName())1155      Vals.push_back((unsigned char)Chr);1156    Stream.EmitRecord(bitc::MODULE_CODE_COMDAT, Vals, /*AbbrevToUse=*/0);1157    Vals.clear();1158  }1159}1160 1161void DXILBitcodeWriter::writeValueSymbolTableForwardDecl() {}1162 1163/// Emit top-level description of module, including target triple, inline asm,1164/// descriptors for global variables, and function prototype info.1165/// Returns the bit offset to backpatch with the location of the real VST.1166void DXILBitcodeWriter::writeModuleInfo() {1167  // Emit various pieces of data attached to a module.1168 1169  // We need to hardcode a triple and datalayout that's compatible with the1170  // historical DXIL triple and datalayout from DXC.1171  StringRef Triple = "dxil-ms-dx";1172  StringRef DL = "e-m:e-p:32:32-i1:32-i8:8-i16:16-i32:32-i64:64-"1173                 "f16:16-f32:32-f64:64-n8:16:32:64";1174  writeStringRecord(Stream, bitc::MODULE_CODE_TRIPLE, Triple, 0 /*TODO*/);1175  writeStringRecord(Stream, bitc::MODULE_CODE_DATALAYOUT, DL, 0 /*TODO*/);1176 1177  if (!M.getModuleInlineAsm().empty())1178    writeStringRecord(Stream, bitc::MODULE_CODE_ASM, M.getModuleInlineAsm(),1179                      0 /*TODO*/);1180 1181  // Emit information about sections and GC, computing how many there are. Also1182  // compute the maximum alignment value.1183  std::map<std::string, unsigned> SectionMap;1184  std::map<std::string, unsigned> GCMap;1185  MaybeAlign MaxAlignment;1186  unsigned MaxGlobalType = 0;1187  const auto UpdateMaxAlignment = [&MaxAlignment](const MaybeAlign A) {1188    if (A)1189      MaxAlignment = !MaxAlignment ? *A : std::max(*MaxAlignment, *A);1190  };1191  for (const GlobalVariable &GV : M.globals()) {1192    UpdateMaxAlignment(GV.getAlign());1193    // Use getGlobalObjectValueTypeID to look up the enumerated type ID for1194    // Global Variable types.1195    MaxGlobalType = std::max(1196        MaxGlobalType, getGlobalObjectValueTypeID(GV.getValueType(), &GV));1197    if (GV.hasSection()) {1198      // Give section names unique ID's.1199      unsigned &Entry = SectionMap[std::string(GV.getSection())];1200      if (!Entry) {1201        writeStringRecord(Stream, bitc::MODULE_CODE_SECTIONNAME,1202                          GV.getSection(), 0 /*TODO*/);1203        Entry = SectionMap.size();1204      }1205    }1206  }1207  for (const Function &F : M) {1208    UpdateMaxAlignment(F.getAlign());1209    if (F.hasSection()) {1210      // Give section names unique ID's.1211      unsigned &Entry = SectionMap[std::string(F.getSection())];1212      if (!Entry) {1213        writeStringRecord(Stream, bitc::MODULE_CODE_SECTIONNAME, F.getSection(),1214                          0 /*TODO*/);1215        Entry = SectionMap.size();1216      }1217    }1218    if (F.hasGC()) {1219      // Same for GC names.1220      unsigned &Entry = GCMap[F.getGC()];1221      if (!Entry) {1222        writeStringRecord(Stream, bitc::MODULE_CODE_GCNAME, F.getGC(),1223                          0 /*TODO*/);1224        Entry = GCMap.size();1225      }1226    }1227  }1228 1229  // Emit abbrev for globals, now that we know # sections and max alignment.1230  unsigned SimpleGVarAbbrev = 0;1231  if (!M.global_empty()) {1232    // Add an abbrev for common globals with no visibility or thread1233    // localness.1234    auto Abbv = std::make_shared<BitCodeAbbrev>();1235    Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_GLOBALVAR));1236    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,1237                              Log2_32_Ceil(MaxGlobalType + 1)));1238    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // AddrSpace << 21239                                                           //| explicitType << 11240                                                           //| constant1241    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Initializer.1242    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // Linkage.1243    if (!MaxAlignment)                                     // Alignment.1244      Abbv->Add(BitCodeAbbrevOp(0));1245    else {1246      unsigned MaxEncAlignment = getEncodedAlign(MaxAlignment);1247      Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,1248                                Log2_32_Ceil(MaxEncAlignment + 1)));1249    }1250    if (SectionMap.empty()) // Section.1251      Abbv->Add(BitCodeAbbrevOp(0));1252    else1253      Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,1254                                Log2_32_Ceil(SectionMap.size() + 1)));1255    // Don't bother emitting vis + thread local.1256    SimpleGVarAbbrev = Stream.EmitAbbrev(std::move(Abbv));1257  }1258 1259  // Emit the global variable information.1260  SmallVector<unsigned, 64> Vals;1261  for (const GlobalVariable &GV : M.globals()) {1262    unsigned AbbrevToUse = 0;1263 1264    // GLOBALVAR: [type, isconst, initid,1265    //             linkage, alignment, section, visibility, threadlocal,1266    //             unnamed_addr, externally_initialized, dllstorageclass,1267    //             comdat]1268    Vals.push_back(getGlobalObjectValueTypeID(GV.getValueType(), &GV));1269    Vals.push_back(1270        GV.getType()->getAddressSpace() << 2 | 2 |1271        (GV.isConstant() ? 1 : 0)); // HLSL Change - bitwise | was used with1272                                    // unsigned int and bool1273    Vals.push_back(1274        GV.isDeclaration() ? 0 : (VE.getValueID(GV.getInitializer()) + 1));1275    Vals.push_back(getEncodedLinkage(GV));1276    Vals.push_back(getEncodedAlign(GV.getAlign()));1277    Vals.push_back(GV.hasSection() ? SectionMap[std::string(GV.getSection())]1278                                   : 0);1279    if (GV.isThreadLocal() ||1280        GV.getVisibility() != GlobalValue::DefaultVisibility ||1281        GV.getUnnamedAddr() != GlobalValue::UnnamedAddr::None ||1282        GV.isExternallyInitialized() ||1283        GV.getDLLStorageClass() != GlobalValue::DefaultStorageClass ||1284        GV.hasComdat()) {1285      Vals.push_back(getEncodedVisibility(GV));1286      Vals.push_back(getEncodedThreadLocalMode(GV));1287      Vals.push_back(GV.getUnnamedAddr() != GlobalValue::UnnamedAddr::None);1288      Vals.push_back(GV.isExternallyInitialized());1289      Vals.push_back(getEncodedDLLStorageClass(GV));1290      Vals.push_back(GV.hasComdat() ? VE.getComdatID(GV.getComdat()) : 0);1291    } else {1292      AbbrevToUse = SimpleGVarAbbrev;1293    }1294 1295    Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse);1296    Vals.clear();1297  }1298 1299  // Emit the function proto information.1300  for (const Function &F : M) {1301    // FUNCTION:  [type, callingconv, isproto, linkage, paramattrs, alignment,1302    //             section, visibility, gc, unnamed_addr, prologuedata,1303    //             dllstorageclass, comdat, prefixdata, personalityfn]1304    Vals.push_back(getGlobalObjectValueTypeID(F.getFunctionType(), &F));1305    Vals.push_back(F.getCallingConv());1306    Vals.push_back(F.isDeclaration());1307    Vals.push_back(getEncodedLinkage(F));1308    Vals.push_back(VE.getAttributeListID(F.getAttributes()));1309    Vals.push_back(getEncodedAlign(F.getAlign()));1310    Vals.push_back(F.hasSection() ? SectionMap[std::string(F.getSection())]1311                                  : 0);1312    Vals.push_back(getEncodedVisibility(F));1313    Vals.push_back(F.hasGC() ? GCMap[F.getGC()] : 0);1314    Vals.push_back(F.getUnnamedAddr() != GlobalValue::UnnamedAddr::None);1315    Vals.push_back(1316        F.hasPrologueData() ? (VE.getValueID(F.getPrologueData()) + 1) : 0);1317    Vals.push_back(getEncodedDLLStorageClass(F));1318    Vals.push_back(F.hasComdat() ? VE.getComdatID(F.getComdat()) : 0);1319    Vals.push_back(F.hasPrefixData() ? (VE.getValueID(F.getPrefixData()) + 1)1320                                     : 0);1321    Vals.push_back(1322        F.hasPersonalityFn() ? (VE.getValueID(F.getPersonalityFn()) + 1) : 0);1323 1324    unsigned AbbrevToUse = 0;1325    Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse);1326    Vals.clear();1327  }1328 1329  // Emit the alias information.1330  for (const GlobalAlias &A : M.aliases()) {1331    // ALIAS: [alias type, aliasee val#, linkage, visibility]1332    Vals.push_back(getTypeID(A.getValueType(), &A));1333    Vals.push_back(VE.getValueID(A.getAliasee()));1334    Vals.push_back(getEncodedLinkage(A));1335    Vals.push_back(getEncodedVisibility(A));1336    Vals.push_back(getEncodedDLLStorageClass(A));1337    Vals.push_back(getEncodedThreadLocalMode(A));1338    Vals.push_back(A.getUnnamedAddr() != GlobalValue::UnnamedAddr::None);1339    unsigned AbbrevToUse = 0;1340    Stream.EmitRecord(bitc::MODULE_CODE_ALIAS_OLD, Vals, AbbrevToUse);1341    Vals.clear();1342  }1343}1344 1345void DXILBitcodeWriter::writeValueAsMetadata(1346    const ValueAsMetadata *MD, SmallVectorImpl<uint64_t> &Record) {1347  // Mimic an MDNode with a value as one operand.1348  Value *V = MD->getValue();1349  Type *Ty = V->getType();1350  if (Function *F = dyn_cast<Function>(V))1351    Ty = TypedPointerType::get(F->getFunctionType(), F->getAddressSpace());1352  else if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V))1353    Ty = TypedPointerType::get(GV->getValueType(), GV->getAddressSpace());1354  Record.push_back(getTypeID(Ty, V));1355  Record.push_back(VE.getValueID(V));1356  Stream.EmitRecord(bitc::METADATA_VALUE, Record, 0);1357  Record.clear();1358}1359 1360void DXILBitcodeWriter::writeMDTuple(const MDTuple *N,1361                                     SmallVectorImpl<uint64_t> &Record,1362                                     unsigned Abbrev) {1363  for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {1364    Metadata *MD = N->getOperand(i);1365    assert(!(MD && isa<LocalAsMetadata>(MD)) &&1366           "Unexpected function-local metadata");1367    Record.push_back(VE.getMetadataOrNullID(MD));1368  }1369  Stream.EmitRecord(N->isDistinct() ? bitc::METADATA_DISTINCT_NODE1370                                    : bitc::METADATA_NODE,1371                    Record, Abbrev);1372  Record.clear();1373}1374 1375void DXILBitcodeWriter::writeDILocation(const DILocation *N,1376                                        SmallVectorImpl<uint64_t> &Record,1377                                        unsigned &Abbrev) {1378  if (!Abbrev)1379    Abbrev = createDILocationAbbrev();1380  Record.push_back(N->isDistinct());1381  Record.push_back(N->getLine());1382  Record.push_back(N->getColumn());1383  Record.push_back(VE.getMetadataID(N->getScope()));1384  Record.push_back(VE.getMetadataOrNullID(N->getInlinedAt()));1385 1386  Stream.EmitRecord(bitc::METADATA_LOCATION, Record, Abbrev);1387  Record.clear();1388}1389 1390static uint64_t rotateSign(APInt Val) {1391  int64_t I = Val.getSExtValue();1392  uint64_t U = I;1393  return I < 0 ? ~(U << 1) : U << 1;1394}1395 1396void DXILBitcodeWriter::writeDISubrange(const DISubrange *N,1397                                        SmallVectorImpl<uint64_t> &Record,1398                                        unsigned Abbrev) {1399  Record.push_back(N->isDistinct());1400 1401  // TODO: Do we need to handle DIExpression here? What about cases where Count1402  // isn't specified but UpperBound and such are?1403  ConstantInt *Count = dyn_cast<ConstantInt *>(N->getCount());1404  assert(Count && "Count is missing or not ConstantInt");1405  Record.push_back(Count->getValue().getSExtValue());1406 1407  // TODO: Similarly, DIExpression is allowed here now1408  DISubrange::BoundType LowerBound = N->getLowerBound();1409  assert((LowerBound.isNull() || isa<ConstantInt *>(LowerBound)) &&1410         "Lower bound provided but not ConstantInt");1411  Record.push_back(1412      LowerBound ? rotateSign(cast<ConstantInt *>(LowerBound)->getValue()) : 0);1413 1414  Stream.EmitRecord(bitc::METADATA_SUBRANGE, Record, Abbrev);1415  Record.clear();1416}1417 1418void DXILBitcodeWriter::writeDIEnumerator(const DIEnumerator *N,1419                                          SmallVectorImpl<uint64_t> &Record,1420                                          unsigned Abbrev) {1421  Record.push_back(N->isDistinct());1422  Record.push_back(rotateSign(N->getValue()));1423  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));1424 1425  Stream.EmitRecord(bitc::METADATA_ENUMERATOR, Record, Abbrev);1426  Record.clear();1427}1428 1429void DXILBitcodeWriter::writeDIBasicType(const DIBasicType *N,1430                                         SmallVectorImpl<uint64_t> &Record,1431                                         unsigned Abbrev) {1432  Record.push_back(N->isDistinct());1433  Record.push_back(N->getTag());1434  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));1435  Record.push_back(N->getSizeInBits());1436  Record.push_back(N->getAlignInBits());1437  Record.push_back(N->getEncoding());1438 1439  Stream.EmitRecord(bitc::METADATA_BASIC_TYPE, Record, Abbrev);1440  Record.clear();1441}1442 1443void DXILBitcodeWriter::writeDIDerivedType(const DIDerivedType *N,1444                                           SmallVectorImpl<uint64_t> &Record,1445                                           unsigned Abbrev) {1446  Record.push_back(N->isDistinct());1447  Record.push_back(N->getTag());1448  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));1449  Record.push_back(VE.getMetadataOrNullID(N->getFile()));1450  Record.push_back(N->getLine());1451  Record.push_back(VE.getMetadataOrNullID(N->getScope()));1452  Record.push_back(VE.getMetadataOrNullID(N->getBaseType()));1453  Record.push_back(N->getSizeInBits());1454  Record.push_back(N->getAlignInBits());1455  Record.push_back(N->getOffsetInBits());1456  Record.push_back(N->getFlags());1457  Record.push_back(VE.getMetadataOrNullID(N->getExtraData()));1458 1459  Stream.EmitRecord(bitc::METADATA_DERIVED_TYPE, Record, Abbrev);1460  Record.clear();1461}1462 1463void DXILBitcodeWriter::writeDICompositeType(const DICompositeType *N,1464                                             SmallVectorImpl<uint64_t> &Record,1465                                             unsigned Abbrev) {1466  Record.push_back(N->isDistinct());1467  Record.push_back(N->getTag());1468  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));1469  Record.push_back(VE.getMetadataOrNullID(N->getFile()));1470  Record.push_back(N->getLine());1471  Record.push_back(VE.getMetadataOrNullID(N->getScope()));1472  Record.push_back(VE.getMetadataOrNullID(N->getBaseType()));1473  Record.push_back(N->getSizeInBits());1474  Record.push_back(N->getAlignInBits());1475  Record.push_back(N->getOffsetInBits());1476  Record.push_back(N->getFlags());1477  Record.push_back(VE.getMetadataOrNullID(N->getElements().get()));1478  Record.push_back(N->getRuntimeLang());1479  Record.push_back(VE.getMetadataOrNullID(N->getVTableHolder()));1480  Record.push_back(VE.getMetadataOrNullID(N->getTemplateParams().get()));1481  Record.push_back(VE.getMetadataOrNullID(N->getRawIdentifier()));1482 1483  Stream.EmitRecord(bitc::METADATA_COMPOSITE_TYPE, Record, Abbrev);1484  Record.clear();1485}1486 1487void DXILBitcodeWriter::writeDISubroutineType(const DISubroutineType *N,1488                                              SmallVectorImpl<uint64_t> &Record,1489                                              unsigned Abbrev) {1490  Record.push_back(N->isDistinct());1491  Record.push_back(N->getFlags());1492  Record.push_back(VE.getMetadataOrNullID(N->getTypeArray().get()));1493 1494  Stream.EmitRecord(bitc::METADATA_SUBROUTINE_TYPE, Record, Abbrev);1495  Record.clear();1496}1497 1498void DXILBitcodeWriter::writeDIFile(const DIFile *N,1499                                    SmallVectorImpl<uint64_t> &Record,1500                                    unsigned Abbrev) {1501  Record.push_back(N->isDistinct());1502  Record.push_back(VE.getMetadataOrNullID(N->getRawFilename()));1503  Record.push_back(VE.getMetadataOrNullID(N->getRawDirectory()));1504 1505  Stream.EmitRecord(bitc::METADATA_FILE, Record, Abbrev);1506  Record.clear();1507}1508 1509void DXILBitcodeWriter::writeDICompileUnit(const DICompileUnit *N,1510                                           SmallVectorImpl<uint64_t> &Record,1511                                           unsigned Abbrev) {1512  Record.push_back(N->isDistinct());1513  Record.push_back(N->getSourceLanguage().getUnversionedName());1514  Record.push_back(VE.getMetadataOrNullID(N->getFile()));1515  Record.push_back(VE.getMetadataOrNullID(N->getRawProducer()));1516  Record.push_back(N->isOptimized());1517  Record.push_back(VE.getMetadataOrNullID(N->getRawFlags()));1518  Record.push_back(N->getRuntimeVersion());1519  Record.push_back(VE.getMetadataOrNullID(N->getRawSplitDebugFilename()));1520  Record.push_back(N->getEmissionKind());1521  Record.push_back(VE.getMetadataOrNullID(N->getEnumTypes().get()));1522  Record.push_back(VE.getMetadataOrNullID(N->getRetainedTypes().get()));1523  Record.push_back(/* subprograms */ 0);1524  Record.push_back(VE.getMetadataOrNullID(N->getGlobalVariables().get()));1525  Record.push_back(VE.getMetadataOrNullID(N->getImportedEntities().get()));1526  Record.push_back(N->getDWOId());1527 1528  Stream.EmitRecord(bitc::METADATA_COMPILE_UNIT, Record, Abbrev);1529  Record.clear();1530}1531 1532void DXILBitcodeWriter::writeDISubprogram(const DISubprogram *N,1533                                          SmallVectorImpl<uint64_t> &Record,1534                                          unsigned Abbrev) {1535  Record.push_back(N->isDistinct());1536  Record.push_back(VE.getMetadataOrNullID(N->getScope()));1537  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));1538  Record.push_back(VE.getMetadataOrNullID(N->getRawLinkageName()));1539  Record.push_back(VE.getMetadataOrNullID(N->getFile()));1540  Record.push_back(N->getLine());1541  Record.push_back(VE.getMetadataOrNullID(N->getType()));1542  Record.push_back(N->isLocalToUnit());1543  Record.push_back(N->isDefinition());1544  Record.push_back(N->getScopeLine());1545  Record.push_back(VE.getMetadataOrNullID(N->getContainingType()));1546  Record.push_back(N->getVirtuality());1547  Record.push_back(N->getVirtualIndex());1548  Record.push_back(N->getFlags());1549  Record.push_back(N->isOptimized());1550  Record.push_back(VE.getMetadataOrNullID(N->getRawUnit()));1551  Record.push_back(VE.getMetadataOrNullID(N->getTemplateParams().get()));1552  Record.push_back(VE.getMetadataOrNullID(N->getDeclaration()));1553  Record.push_back(VE.getMetadataOrNullID(N->getRetainedNodes().get()));1554 1555  Stream.EmitRecord(bitc::METADATA_SUBPROGRAM, Record, Abbrev);1556  Record.clear();1557}1558 1559void DXILBitcodeWriter::writeDILexicalBlock(const DILexicalBlock *N,1560                                            SmallVectorImpl<uint64_t> &Record,1561                                            unsigned Abbrev) {1562  Record.push_back(N->isDistinct());1563  Record.push_back(VE.getMetadataOrNullID(N->getScope()));1564  Record.push_back(VE.getMetadataOrNullID(N->getFile()));1565  Record.push_back(N->getLine());1566  Record.push_back(N->getColumn());1567 1568  Stream.EmitRecord(bitc::METADATA_LEXICAL_BLOCK, Record, Abbrev);1569  Record.clear();1570}1571 1572void DXILBitcodeWriter::writeDILexicalBlockFile(1573    const DILexicalBlockFile *N, SmallVectorImpl<uint64_t> &Record,1574    unsigned Abbrev) {1575  Record.push_back(N->isDistinct());1576  Record.push_back(VE.getMetadataOrNullID(N->getScope()));1577  Record.push_back(VE.getMetadataOrNullID(N->getFile()));1578  Record.push_back(N->getDiscriminator());1579 1580  Stream.EmitRecord(bitc::METADATA_LEXICAL_BLOCK_FILE, Record, Abbrev);1581  Record.clear();1582}1583 1584void DXILBitcodeWriter::writeDINamespace(const DINamespace *N,1585                                         SmallVectorImpl<uint64_t> &Record,1586                                         unsigned Abbrev) {1587  Record.push_back(N->isDistinct());1588  Record.push_back(VE.getMetadataOrNullID(N->getScope()));1589  Record.push_back(VE.getMetadataOrNullID(N->getFile()));1590  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));1591  Record.push_back(/* line number */ 0);1592 1593  Stream.EmitRecord(bitc::METADATA_NAMESPACE, Record, Abbrev);1594  Record.clear();1595}1596 1597void DXILBitcodeWriter::writeDIModule(const DIModule *N,1598                                      SmallVectorImpl<uint64_t> &Record,1599                                      unsigned Abbrev) {1600  Record.push_back(N->isDistinct());1601  for (auto &I : N->operands())1602    Record.push_back(VE.getMetadataOrNullID(I));1603 1604  Stream.EmitRecord(bitc::METADATA_MODULE, Record, Abbrev);1605  Record.clear();1606}1607 1608void DXILBitcodeWriter::writeDITemplateTypeParameter(1609    const DITemplateTypeParameter *N, SmallVectorImpl<uint64_t> &Record,1610    unsigned Abbrev) {1611  Record.push_back(N->isDistinct());1612  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));1613  Record.push_back(VE.getMetadataOrNullID(N->getType()));1614 1615  Stream.EmitRecord(bitc::METADATA_TEMPLATE_TYPE, Record, Abbrev);1616  Record.clear();1617}1618 1619void DXILBitcodeWriter::writeDITemplateValueParameter(1620    const DITemplateValueParameter *N, SmallVectorImpl<uint64_t> &Record,1621    unsigned Abbrev) {1622  Record.push_back(N->isDistinct());1623  Record.push_back(N->getTag());1624  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));1625  Record.push_back(VE.getMetadataOrNullID(N->getType()));1626  Record.push_back(VE.getMetadataOrNullID(N->getValue()));1627 1628  Stream.EmitRecord(bitc::METADATA_TEMPLATE_VALUE, Record, Abbrev);1629  Record.clear();1630}1631 1632void DXILBitcodeWriter::writeDIGlobalVariable(const DIGlobalVariable *N,1633                                              SmallVectorImpl<uint64_t> &Record,1634                                              unsigned Abbrev) {1635  Record.push_back(N->isDistinct());1636  Record.push_back(VE.getMetadataOrNullID(N->getScope()));1637  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));1638  Record.push_back(VE.getMetadataOrNullID(N->getRawLinkageName()));1639  Record.push_back(VE.getMetadataOrNullID(N->getFile()));1640  Record.push_back(N->getLine());1641  Record.push_back(VE.getMetadataOrNullID(N->getType()));1642  Record.push_back(N->isLocalToUnit());1643  Record.push_back(N->isDefinition());1644  Record.push_back(/* N->getRawVariable() */ 0);1645  Record.push_back(VE.getMetadataOrNullID(N->getStaticDataMemberDeclaration()));1646 1647  Stream.EmitRecord(bitc::METADATA_GLOBAL_VAR, Record, Abbrev);1648  Record.clear();1649}1650 1651void DXILBitcodeWriter::writeDILocalVariable(const DILocalVariable *N,1652                                             SmallVectorImpl<uint64_t> &Record,1653                                             unsigned Abbrev) {1654  Record.push_back(N->isDistinct());1655  Record.push_back(N->getTag());1656  Record.push_back(VE.getMetadataOrNullID(N->getScope()));1657  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));1658  Record.push_back(VE.getMetadataOrNullID(N->getFile()));1659  Record.push_back(N->getLine());1660  Record.push_back(VE.getMetadataOrNullID(N->getType()));1661  Record.push_back(N->getArg());1662  Record.push_back(N->getFlags());1663 1664  Stream.EmitRecord(bitc::METADATA_LOCAL_VAR, Record, Abbrev);1665  Record.clear();1666}1667 1668void DXILBitcodeWriter::writeDIExpression(const DIExpression *N,1669                                          SmallVectorImpl<uint64_t> &Record,1670                                          unsigned Abbrev) {1671  Record.reserve(N->getElements().size() + 1);1672 1673  Record.push_back(N->isDistinct());1674  Record.append(N->elements_begin(), N->elements_end());1675 1676  Stream.EmitRecord(bitc::METADATA_EXPRESSION, Record, Abbrev);1677  Record.clear();1678}1679 1680void DXILBitcodeWriter::writeDIObjCProperty(const DIObjCProperty *N,1681                                            SmallVectorImpl<uint64_t> &Record,1682                                            unsigned Abbrev) {1683  llvm_unreachable("DXIL does not support objc!!!");1684}1685 1686void DXILBitcodeWriter::writeDIImportedEntity(const DIImportedEntity *N,1687                                              SmallVectorImpl<uint64_t> &Record,1688                                              unsigned Abbrev) {1689  Record.push_back(N->isDistinct());1690  Record.push_back(N->getTag());1691  Record.push_back(VE.getMetadataOrNullID(N->getScope()));1692  Record.push_back(VE.getMetadataOrNullID(N->getEntity()));1693  Record.push_back(N->getLine());1694  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));1695 1696  Stream.EmitRecord(bitc::METADATA_IMPORTED_ENTITY, Record, Abbrev);1697  Record.clear();1698}1699 1700unsigned DXILBitcodeWriter::createDILocationAbbrev() {1701  // Abbrev for METADATA_LOCATION.1702  //1703  // Assume the column is usually under 128, and always output the inlined-at1704  // location (it's never more expensive than building an array size 1).1705  std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();1706  Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_LOCATION));1707  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));1708  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));1709  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));1710  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));1711  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));1712  return Stream.EmitAbbrev(std::move(Abbv));1713}1714 1715unsigned DXILBitcodeWriter::createGenericDINodeAbbrev() {1716  // Abbrev for METADATA_GENERIC_DEBUG.1717  //1718  // Assume the column is usually under 128, and always output the inlined-at1719  // location (it's never more expensive than building an array size 1).1720  std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();1721  Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_GENERIC_DEBUG));1722  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));1723  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));1724  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));1725  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));1726  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));1727  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));1728  return Stream.EmitAbbrev(std::move(Abbv));1729}1730 1731void DXILBitcodeWriter::writeMetadataRecords(ArrayRef<const Metadata *> MDs,1732                                             SmallVectorImpl<uint64_t> &Record,1733                                             std::vector<unsigned> *MDAbbrevs,1734                                             std::vector<uint64_t> *IndexPos) {1735  if (MDs.empty())1736    return;1737 1738    // Initialize MDNode abbreviations.1739#define HANDLE_MDNODE_LEAF(CLASS) unsigned CLASS##Abbrev = 0;1740#include "llvm/IR/Metadata.def"1741 1742  for (const Metadata *MD : MDs) {1743    if (IndexPos)1744      IndexPos->push_back(Stream.GetCurrentBitNo());1745    if (const MDNode *N = dyn_cast<MDNode>(MD)) {1746      assert(N->isResolved() && "Expected forward references to be resolved");1747 1748      switch (N->getMetadataID()) {1749      default:1750        llvm_unreachable("Invalid MDNode subclass");1751#define HANDLE_MDNODE_LEAF(CLASS)                                              \1752  case Metadata::CLASS##Kind:                                                  \1753    if (MDAbbrevs)                                                             \1754      write##CLASS(cast<CLASS>(N), Record,                                     \1755                   (*MDAbbrevs)[MetadataAbbrev::CLASS##AbbrevID]);             \1756    else                                                                       \1757      write##CLASS(cast<CLASS>(N), Record, CLASS##Abbrev);                     \1758    continue;1759#include "llvm/IR/Metadata.def"1760      }1761    }1762    writeValueAsMetadata(cast<ValueAsMetadata>(MD), Record);1763  }1764}1765 1766unsigned DXILBitcodeWriter::createMetadataStringsAbbrev() {1767  auto Abbv = std::make_shared<BitCodeAbbrev>();1768  Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_STRING_OLD));1769  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));1770  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));1771  return Stream.EmitAbbrev(std::move(Abbv));1772}1773 1774void DXILBitcodeWriter::writeMetadataStrings(1775    ArrayRef<const Metadata *> Strings, SmallVectorImpl<uint64_t> &Record) {1776  if (Strings.empty())1777    return;1778 1779  unsigned MDSAbbrev = createMetadataStringsAbbrev();1780 1781  for (const Metadata *MD : Strings) {1782    const MDString *MDS = cast<MDString>(MD);1783    // Code: [strchar x N]1784    Record.append(MDS->bytes_begin(), MDS->bytes_end());1785 1786    // Emit the finished record.1787    Stream.EmitRecord(bitc::METADATA_STRING_OLD, Record, MDSAbbrev);1788    Record.clear();1789  }1790}1791 1792void DXILBitcodeWriter::writeModuleMetadata() {1793  if (!VE.hasMDs() && M.named_metadata_empty())1794    return;1795 1796  Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 5);1797 1798  // Emit all abbrevs upfront, so that the reader can jump in the middle of the1799  // block and load any metadata.1800  std::vector<unsigned> MDAbbrevs;1801 1802  MDAbbrevs.resize(MetadataAbbrev::LastPlusOne);1803  MDAbbrevs[MetadataAbbrev::DILocationAbbrevID] = createDILocationAbbrev();1804  MDAbbrevs[MetadataAbbrev::GenericDINodeAbbrevID] =1805      createGenericDINodeAbbrev();1806 1807  unsigned NameAbbrev = 0;1808  if (!M.named_metadata_empty()) {1809    // Abbrev for METADATA_NAME.1810    std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();1811    Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_NAME));1812    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));1813    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));1814    NameAbbrev = Stream.EmitAbbrev(std::move(Abbv));1815  }1816 1817  SmallVector<uint64_t, 64> Record;1818  writeMetadataStrings(VE.getMDStrings(), Record);1819 1820  std::vector<uint64_t> IndexPos;1821  IndexPos.reserve(VE.getNonMDStrings().size());1822  writeMetadataRecords(VE.getNonMDStrings(), Record, &MDAbbrevs, &IndexPos);1823 1824  // Write named metadata.1825  for (const NamedMDNode &NMD : M.named_metadata()) {1826    // Write name.1827    StringRef Str = NMD.getName();1828    Record.append(Str.bytes_begin(), Str.bytes_end());1829    Stream.EmitRecord(bitc::METADATA_NAME, Record, NameAbbrev);1830    Record.clear();1831 1832    // Write named metadata operands.1833    for (const MDNode *N : NMD.operands())1834      Record.push_back(VE.getMetadataID(N));1835    Stream.EmitRecord(bitc::METADATA_NAMED_NODE, Record, 0);1836    Record.clear();1837  }1838 1839  Stream.ExitBlock();1840}1841 1842void DXILBitcodeWriter::writeFunctionMetadata(const Function &F) {1843  if (!VE.hasMDs())1844    return;1845 1846  Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 4);1847  SmallVector<uint64_t, 64> Record;1848  writeMetadataStrings(VE.getMDStrings(), Record);1849  writeMetadataRecords(VE.getNonMDStrings(), Record);1850  Stream.ExitBlock();1851}1852 1853void DXILBitcodeWriter::writeFunctionMetadataAttachment(const Function &F) {1854  Stream.EnterSubblock(bitc::METADATA_ATTACHMENT_ID, 3);1855 1856  SmallVector<uint64_t, 64> Record;1857 1858  // Write metadata attachments1859  // METADATA_ATTACHMENT - [m x [value, [n x [id, mdnode]]]1860  SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;1861  F.getAllMetadata(MDs);1862  if (!MDs.empty()) {1863    for (const auto &I : MDs) {1864      Record.push_back(I.first);1865      Record.push_back(VE.getMetadataID(I.second));1866    }1867    Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0);1868    Record.clear();1869  }1870 1871  for (const BasicBlock &BB : F)1872    for (const Instruction &I : BB) {1873      MDs.clear();1874      I.getAllMetadataOtherThanDebugLoc(MDs);1875 1876      // If no metadata, ignore instruction.1877      if (MDs.empty())1878        continue;1879 1880      Record.push_back(VE.getInstructionID(&I));1881 1882      for (unsigned i = 0, e = MDs.size(); i != e; ++i) {1883        Record.push_back(MDs[i].first);1884        Record.push_back(VE.getMetadataID(MDs[i].second));1885      }1886      Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0);1887      Record.clear();1888    }1889 1890  Stream.ExitBlock();1891}1892 1893void DXILBitcodeWriter::writeModuleMetadataKinds() {1894  SmallVector<uint64_t, 64> Record;1895 1896  // Write metadata kinds1897  // METADATA_KIND - [n x [id, name]]1898  SmallVector<StringRef, 8> Names;1899  M.getMDKindNames(Names);1900 1901  if (Names.empty())1902    return;1903 1904  Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);1905 1906  for (unsigned MDKindID = 0, e = Names.size(); MDKindID != e; ++MDKindID) {1907    Record.push_back(MDKindID);1908    StringRef KName = Names[MDKindID];1909    Record.append(KName.begin(), KName.end());1910 1911    Stream.EmitRecord(bitc::METADATA_KIND, Record, 0);1912    Record.clear();1913  }1914 1915  Stream.ExitBlock();1916}1917 1918void DXILBitcodeWriter::writeConstants(unsigned FirstVal, unsigned LastVal,1919                                       bool isGlobal) {1920  if (FirstVal == LastVal)1921    return;1922 1923  Stream.EnterSubblock(bitc::CONSTANTS_BLOCK_ID, 4);1924 1925  unsigned AggregateAbbrev = 0;1926  unsigned String8Abbrev = 0;1927  unsigned CString7Abbrev = 0;1928  unsigned CString6Abbrev = 0;1929  // If this is a constant pool for the module, emit module-specific abbrevs.1930  if (isGlobal) {1931    // Abbrev for CST_CODE_AGGREGATE.1932    auto Abbv = std::make_shared<BitCodeAbbrev>();1933    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_AGGREGATE));1934    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));1935    Abbv->Add(1936        BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, Log2_32_Ceil(LastVal + 1)));1937    AggregateAbbrev = Stream.EmitAbbrev(std::move(Abbv));1938 1939    // Abbrev for CST_CODE_STRING.1940    Abbv = std::make_shared<BitCodeAbbrev>();1941    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_STRING));1942    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));1943    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));1944    String8Abbrev = Stream.EmitAbbrev(std::move(Abbv));1945    // Abbrev for CST_CODE_CSTRING.1946    Abbv = std::make_shared<BitCodeAbbrev>();1947    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CSTRING));1948    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));1949    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));1950    CString7Abbrev = Stream.EmitAbbrev(std::move(Abbv));1951    // Abbrev for CST_CODE_CSTRING.1952    Abbv = std::make_shared<BitCodeAbbrev>();1953    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CSTRING));1954    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));1955    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));1956    CString6Abbrev = Stream.EmitAbbrev(std::move(Abbv));1957  }1958 1959  SmallVector<uint64_t, 64> Record;1960 1961  const ValueEnumerator::ValueList &Vals = VE.getValues();1962  Type *LastTy = nullptr;1963  for (unsigned i = FirstVal; i != LastVal; ++i) {1964    const Value *V = Vals[i].first;1965    // If we need to switch types, do so now.1966    if (V->getType() != LastTy) {1967      LastTy = V->getType();1968      Record.push_back(getTypeID(LastTy, V));1969      Stream.EmitRecord(bitc::CST_CODE_SETTYPE, Record,1970                        CONSTANTS_SETTYPE_ABBREV);1971      Record.clear();1972    }1973 1974    if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {1975      Record.push_back(unsigned(IA->hasSideEffects()) |1976                       unsigned(IA->isAlignStack()) << 1 |1977                       unsigned(IA->getDialect() & 1) << 2);1978 1979      // Add the asm string.1980      StringRef AsmStr = IA->getAsmString();1981      Record.push_back(AsmStr.size());1982      Record.append(AsmStr.begin(), AsmStr.end());1983 1984      // Add the constraint string.1985      StringRef ConstraintStr = IA->getConstraintString();1986      Record.push_back(ConstraintStr.size());1987      Record.append(ConstraintStr.begin(), ConstraintStr.end());1988      Stream.EmitRecord(bitc::CST_CODE_INLINEASM, Record);1989      Record.clear();1990      continue;1991    }1992    const Constant *C = cast<Constant>(V);1993    unsigned Code = -1U;1994    unsigned AbbrevToUse = 0;1995    if (C->isNullValue()) {1996      Code = bitc::CST_CODE_NULL;1997    } else if (isa<UndefValue>(C)) {1998      Code = bitc::CST_CODE_UNDEF;1999    } else if (const ConstantInt *IV = dyn_cast<ConstantInt>(C)) {2000      if (IV->getBitWidth() <= 64) {2001        uint64_t V = IV->getSExtValue();2002        emitSignedInt64(Record, V);2003        Code = bitc::CST_CODE_INTEGER;2004        AbbrevToUse = CONSTANTS_INTEGER_ABBREV;2005      } else { // Wide integers, > 64 bits in size.2006        // We have an arbitrary precision integer value to write whose2007        // bit width is > 64. However, in canonical unsigned integer2008        // format it is likely that the high bits are going to be zero.2009        // So, we only write the number of active words.2010        unsigned NWords = IV->getValue().getActiveWords();2011        const uint64_t *RawWords = IV->getValue().getRawData();2012        for (unsigned i = 0; i != NWords; ++i) {2013          emitSignedInt64(Record, RawWords[i]);2014        }2015        Code = bitc::CST_CODE_WIDE_INTEGER;2016      }2017    } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {2018      Code = bitc::CST_CODE_FLOAT;2019      Type *Ty = CFP->getType();2020      if (Ty->isHalfTy() || Ty->isFloatTy() || Ty->isDoubleTy()) {2021        Record.push_back(CFP->getValueAPF().bitcastToAPInt().getZExtValue());2022      } else if (Ty->isX86_FP80Ty()) {2023        // api needed to prevent premature destruction2024        // bits are not in the same order as a normal i80 APInt, compensate.2025        APInt api = CFP->getValueAPF().bitcastToAPInt();2026        const uint64_t *p = api.getRawData();2027        Record.push_back((p[1] << 48) | (p[0] >> 16));2028        Record.push_back(p[0] & 0xffffLL);2029      } else if (Ty->isFP128Ty() || Ty->isPPC_FP128Ty()) {2030        APInt api = CFP->getValueAPF().bitcastToAPInt();2031        const uint64_t *p = api.getRawData();2032        Record.push_back(p[0]);2033        Record.push_back(p[1]);2034      } else {2035        assert(0 && "Unknown FP type!");2036      }2037    } else if (isa<ConstantDataSequential>(C) &&2038               cast<ConstantDataSequential>(C)->isString()) {2039      const ConstantDataSequential *Str = cast<ConstantDataSequential>(C);2040      // Emit constant strings specially.2041      unsigned NumElts = Str->getNumElements();2042      // If this is a null-terminated string, use the denser CSTRING encoding.2043      if (Str->isCString()) {2044        Code = bitc::CST_CODE_CSTRING;2045        --NumElts; // Don't encode the null, which isn't allowed by char6.2046      } else {2047        Code = bitc::CST_CODE_STRING;2048        AbbrevToUse = String8Abbrev;2049      }2050      bool isCStr7 = Code == bitc::CST_CODE_CSTRING;2051      bool isCStrChar6 = Code == bitc::CST_CODE_CSTRING;2052      for (unsigned i = 0; i != NumElts; ++i) {2053        unsigned char V = Str->getElementAsInteger(i);2054        Record.push_back(V);2055        isCStr7 &= (V & 128) == 0;2056        if (isCStrChar6)2057          isCStrChar6 = BitCodeAbbrevOp::isChar6(V);2058      }2059 2060      if (isCStrChar6)2061        AbbrevToUse = CString6Abbrev;2062      else if (isCStr7)2063        AbbrevToUse = CString7Abbrev;2064    } else if (const ConstantDataSequential *CDS =2065                   dyn_cast<ConstantDataSequential>(C)) {2066      Code = bitc::CST_CODE_DATA;2067      Type *EltTy = CDS->getElementType();2068      if (isa<IntegerType>(EltTy)) {2069        for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i)2070          Record.push_back(CDS->getElementAsInteger(i));2071      } else if (EltTy->isFloatTy()) {2072        for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {2073          union {2074            float F;2075            uint32_t I;2076          };2077          F = CDS->getElementAsFloat(i);2078          Record.push_back(I);2079        }2080      } else {2081        assert(EltTy->isDoubleTy() && "Unknown ConstantData element type");2082        for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {2083          union {2084            double F;2085            uint64_t I;2086          };2087          F = CDS->getElementAsDouble(i);2088          Record.push_back(I);2089        }2090      }2091    } else if (isa<ConstantArray>(C) || isa<ConstantStruct>(C) ||2092               isa<ConstantVector>(C)) {2093      Code = bitc::CST_CODE_AGGREGATE;2094      for (const Value *Op : C->operands())2095        Record.push_back(VE.getValueID(Op));2096      AbbrevToUse = AggregateAbbrev;2097    } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {2098      switch (CE->getOpcode()) {2099      default:2100        if (Instruction::isCast(CE->getOpcode())) {2101          Code = bitc::CST_CODE_CE_CAST;2102          Record.push_back(getEncodedCastOpcode(CE->getOpcode()));2103          Record.push_back(2104              getTypeID(C->getOperand(0)->getType(), C->getOperand(0)));2105          Record.push_back(VE.getValueID(C->getOperand(0)));2106          AbbrevToUse = CONSTANTS_CE_CAST_Abbrev;2107        } else {2108          assert(CE->getNumOperands() == 2 && "Unknown constant expr!");2109          Code = bitc::CST_CODE_CE_BINOP;2110          Record.push_back(getEncodedBinaryOpcode(CE->getOpcode()));2111          Record.push_back(VE.getValueID(C->getOperand(0)));2112          Record.push_back(VE.getValueID(C->getOperand(1)));2113          uint64_t Flags = getOptimizationFlags(CE);2114          if (Flags != 0)2115            Record.push_back(Flags);2116        }2117        break;2118      case Instruction::GetElementPtr: {2119        Code = bitc::CST_CODE_CE_GEP_OLD;2120        const auto *GO = cast<GEPOperator>(C);2121        if (GO->isInBounds())2122          Code = bitc::CST_CODE_CE_INBOUNDS_GEP;2123        Record.push_back(getTypeID(GO->getSourceElementType()));2124        for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i) {2125          Record.push_back(2126              getTypeID(C->getOperand(i)->getType(), C->getOperand(i)));2127          Record.push_back(VE.getValueID(C->getOperand(i)));2128        }2129        break;2130      }2131      case Instruction::Select:2132        Code = bitc::CST_CODE_CE_SELECT;2133        Record.push_back(VE.getValueID(C->getOperand(0)));2134        Record.push_back(VE.getValueID(C->getOperand(1)));2135        Record.push_back(VE.getValueID(C->getOperand(2)));2136        break;2137      case Instruction::ExtractElement:2138        Code = bitc::CST_CODE_CE_EXTRACTELT;2139        Record.push_back(getTypeID(C->getOperand(0)->getType()));2140        Record.push_back(VE.getValueID(C->getOperand(0)));2141        Record.push_back(getTypeID(C->getOperand(1)->getType()));2142        Record.push_back(VE.getValueID(C->getOperand(1)));2143        break;2144      case Instruction::InsertElement:2145        Code = bitc::CST_CODE_CE_INSERTELT;2146        Record.push_back(VE.getValueID(C->getOperand(0)));2147        Record.push_back(VE.getValueID(C->getOperand(1)));2148        Record.push_back(getTypeID(C->getOperand(2)->getType()));2149        Record.push_back(VE.getValueID(C->getOperand(2)));2150        break;2151      case Instruction::ShuffleVector:2152        // If the return type and argument types are the same, this is a2153        // standard shufflevector instruction.  If the types are different,2154        // then the shuffle is widening or truncating the input vectors, and2155        // the argument type must also be encoded.2156        if (C->getType() == C->getOperand(0)->getType()) {2157          Code = bitc::CST_CODE_CE_SHUFFLEVEC;2158        } else {2159          Code = bitc::CST_CODE_CE_SHUFVEC_EX;2160          Record.push_back(getTypeID(C->getOperand(0)->getType()));2161        }2162        Record.push_back(VE.getValueID(C->getOperand(0)));2163        Record.push_back(VE.getValueID(C->getOperand(1)));2164        Record.push_back(VE.getValueID(C->getOperand(2)));2165        break;2166      }2167    } else if (const BlockAddress *BA = dyn_cast<BlockAddress>(C)) {2168      Code = bitc::CST_CODE_BLOCKADDRESS;2169      Record.push_back(getTypeID(BA->getFunction()->getType()));2170      Record.push_back(VE.getValueID(BA->getFunction()));2171      Record.push_back(VE.getGlobalBasicBlockID(BA->getBasicBlock()));2172    } else {2173#ifndef NDEBUG2174      C->dump();2175#endif2176      llvm_unreachable("Unknown constant!");2177    }2178    Stream.EmitRecord(Code, Record, AbbrevToUse);2179    Record.clear();2180  }2181 2182  Stream.ExitBlock();2183}2184 2185void DXILBitcodeWriter::writeModuleConstants() {2186  const ValueEnumerator::ValueList &Vals = VE.getValues();2187 2188  // Find the first constant to emit, which is the first non-globalvalue value.2189  // We know globalvalues have been emitted by WriteModuleInfo.2190  for (unsigned i = 0, e = Vals.size(); i != e; ++i) {2191    if (!isa<GlobalValue>(Vals[i].first)) {2192      writeConstants(i, Vals.size(), true);2193      return;2194    }2195  }2196}2197 2198/// pushValueAndType - The file has to encode both the value and type id for2199/// many values, because we need to know what type to create for forward2200/// references.  However, most operands are not forward references, so this type2201/// field is not needed.2202///2203/// This function adds V's value ID to Vals.  If the value ID is higher than the2204/// instruction ID, then it is a forward reference, and it also includes the2205/// type ID.  The value ID that is written is encoded relative to the InstID.2206bool DXILBitcodeWriter::pushValueAndType(const Value *V, unsigned InstID,2207                                         SmallVectorImpl<unsigned> &Vals) {2208  unsigned ValID = VE.getValueID(V);2209  // Make encoding relative to the InstID.2210  Vals.push_back(InstID - ValID);2211  if (ValID >= InstID) {2212    Vals.push_back(getTypeID(V->getType(), V));2213    return true;2214  }2215  return false;2216}2217 2218/// pushValue - Like pushValueAndType, but where the type of the value is2219/// omitted (perhaps it was already encoded in an earlier operand).2220void DXILBitcodeWriter::pushValue(const Value *V, unsigned InstID,2221                                  SmallVectorImpl<unsigned> &Vals) {2222  unsigned ValID = VE.getValueID(V);2223  Vals.push_back(InstID - ValID);2224}2225 2226void DXILBitcodeWriter::pushValueSigned(const Value *V, unsigned InstID,2227                                        SmallVectorImpl<uint64_t> &Vals) {2228  unsigned ValID = VE.getValueID(V);2229  int64_t diff = ((int32_t)InstID - (int32_t)ValID);2230  emitSignedInt64(Vals, diff);2231}2232 2233/// WriteInstruction - Emit an instruction2234void DXILBitcodeWriter::writeInstruction(const Instruction &I, unsigned InstID,2235                                         SmallVectorImpl<unsigned> &Vals) {2236  unsigned Code = 0;2237  unsigned AbbrevToUse = 0;2238  VE.setInstructionID(&I);2239  switch (I.getOpcode()) {2240  default:2241    if (Instruction::isCast(I.getOpcode())) {2242      Code = bitc::FUNC_CODE_INST_CAST;2243      if (!pushValueAndType(I.getOperand(0), InstID, Vals))2244        AbbrevToUse = (unsigned)FUNCTION_INST_CAST_ABBREV;2245      Vals.push_back(getTypeID(I.getType(), &I));2246      Vals.push_back(getEncodedCastOpcode(I.getOpcode()));2247    } else {2248      assert(isa<BinaryOperator>(I) && "Unknown instruction!");2249      Code = bitc::FUNC_CODE_INST_BINOP;2250      if (!pushValueAndType(I.getOperand(0), InstID, Vals))2251        AbbrevToUse = (unsigned)FUNCTION_INST_BINOP_ABBREV;2252      pushValue(I.getOperand(1), InstID, Vals);2253      Vals.push_back(getEncodedBinaryOpcode(I.getOpcode()));2254      uint64_t Flags = getOptimizationFlags(&I);2255      if (Flags != 0) {2256        if (AbbrevToUse == (unsigned)FUNCTION_INST_BINOP_ABBREV)2257          AbbrevToUse = (unsigned)FUNCTION_INST_BINOP_FLAGS_ABBREV;2258        Vals.push_back(Flags);2259      }2260    }2261    break;2262 2263  case Instruction::GetElementPtr: {2264    Code = bitc::FUNC_CODE_INST_GEP;2265    AbbrevToUse = (unsigned)FUNCTION_INST_GEP_ABBREV;2266    auto &GEPInst = cast<GetElementPtrInst>(I);2267    Vals.push_back(GEPInst.isInBounds());2268    Vals.push_back(getTypeID(GEPInst.getSourceElementType()));2269    for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)2270      pushValueAndType(I.getOperand(i), InstID, Vals);2271    break;2272  }2273  case Instruction::ExtractValue: {2274    Code = bitc::FUNC_CODE_INST_EXTRACTVAL;2275    pushValueAndType(I.getOperand(0), InstID, Vals);2276    const ExtractValueInst *EVI = cast<ExtractValueInst>(&I);2277    Vals.append(EVI->idx_begin(), EVI->idx_end());2278    break;2279  }2280  case Instruction::InsertValue: {2281    Code = bitc::FUNC_CODE_INST_INSERTVAL;2282    pushValueAndType(I.getOperand(0), InstID, Vals);2283    pushValueAndType(I.getOperand(1), InstID, Vals);2284    const InsertValueInst *IVI = cast<InsertValueInst>(&I);2285    Vals.append(IVI->idx_begin(), IVI->idx_end());2286    break;2287  }2288  case Instruction::Select:2289    Code = bitc::FUNC_CODE_INST_VSELECT;2290    pushValueAndType(I.getOperand(1), InstID, Vals);2291    pushValue(I.getOperand(2), InstID, Vals);2292    pushValueAndType(I.getOperand(0), InstID, Vals);2293    break;2294  case Instruction::ExtractElement:2295    Code = bitc::FUNC_CODE_INST_EXTRACTELT;2296    pushValueAndType(I.getOperand(0), InstID, Vals);2297    pushValueAndType(I.getOperand(1), InstID, Vals);2298    break;2299  case Instruction::InsertElement:2300    Code = bitc::FUNC_CODE_INST_INSERTELT;2301    pushValueAndType(I.getOperand(0), InstID, Vals);2302    pushValue(I.getOperand(1), InstID, Vals);2303    pushValueAndType(I.getOperand(2), InstID, Vals);2304    break;2305  case Instruction::ShuffleVector:2306    Code = bitc::FUNC_CODE_INST_SHUFFLEVEC;2307    pushValueAndType(I.getOperand(0), InstID, Vals);2308    pushValue(I.getOperand(1), InstID, Vals);2309    pushValue(cast<ShuffleVectorInst>(&I)->getShuffleMaskForBitcode(), InstID,2310              Vals);2311    break;2312  case Instruction::ICmp:2313  case Instruction::FCmp: {2314    // compare returning Int1Ty or vector of Int1Ty2315    Code = bitc::FUNC_CODE_INST_CMP2;2316    pushValueAndType(I.getOperand(0), InstID, Vals);2317    pushValue(I.getOperand(1), InstID, Vals);2318    Vals.push_back(cast<CmpInst>(I).getPredicate());2319    uint64_t Flags = getOptimizationFlags(&I);2320    if (Flags != 0)2321      Vals.push_back(Flags);2322    break;2323  }2324 2325  case Instruction::Ret: {2326    Code = bitc::FUNC_CODE_INST_RET;2327    unsigned NumOperands = I.getNumOperands();2328    if (NumOperands == 0)2329      AbbrevToUse = (unsigned)FUNCTION_INST_RET_VOID_ABBREV;2330    else if (NumOperands == 1) {2331      if (!pushValueAndType(I.getOperand(0), InstID, Vals))2332        AbbrevToUse = (unsigned)FUNCTION_INST_RET_VAL_ABBREV;2333    } else {2334      for (unsigned i = 0, e = NumOperands; i != e; ++i)2335        pushValueAndType(I.getOperand(i), InstID, Vals);2336    }2337  } break;2338  case Instruction::Br: {2339    Code = bitc::FUNC_CODE_INST_BR;2340    const BranchInst &II = cast<BranchInst>(I);2341    Vals.push_back(VE.getValueID(II.getSuccessor(0)));2342    if (II.isConditional()) {2343      Vals.push_back(VE.getValueID(II.getSuccessor(1)));2344      pushValue(II.getCondition(), InstID, Vals);2345    }2346  } break;2347  case Instruction::Switch: {2348    Code = bitc::FUNC_CODE_INST_SWITCH;2349    const SwitchInst &SI = cast<SwitchInst>(I);2350    Vals.push_back(getTypeID(SI.getCondition()->getType()));2351    pushValue(SI.getCondition(), InstID, Vals);2352    Vals.push_back(VE.getValueID(SI.getDefaultDest()));2353    for (auto Case : SI.cases()) {2354      Vals.push_back(VE.getValueID(Case.getCaseValue()));2355      Vals.push_back(VE.getValueID(Case.getCaseSuccessor()));2356    }2357  } break;2358  case Instruction::IndirectBr:2359    Code = bitc::FUNC_CODE_INST_INDIRECTBR;2360    Vals.push_back(getTypeID(I.getOperand(0)->getType()));2361    // Encode the address operand as relative, but not the basic blocks.2362    pushValue(I.getOperand(0), InstID, Vals);2363    for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i)2364      Vals.push_back(VE.getValueID(I.getOperand(i)));2365    break;2366 2367  case Instruction::Invoke: {2368    const InvokeInst *II = cast<InvokeInst>(&I);2369    const Value *Callee = II->getCalledOperand();2370    FunctionType *FTy = II->getFunctionType();2371    Code = bitc::FUNC_CODE_INST_INVOKE;2372 2373    Vals.push_back(VE.getAttributeListID(II->getAttributes()));2374    Vals.push_back(II->getCallingConv() | 1 << 13);2375    Vals.push_back(VE.getValueID(II->getNormalDest()));2376    Vals.push_back(VE.getValueID(II->getUnwindDest()));2377    Vals.push_back(getTypeID(FTy));2378    pushValueAndType(Callee, InstID, Vals);2379 2380    // Emit value #'s for the fixed parameters.2381    for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)2382      pushValue(I.getOperand(i), InstID, Vals); // fixed param.2383 2384    // Emit type/value pairs for varargs params.2385    if (FTy->isVarArg()) {2386      for (unsigned i = FTy->getNumParams(), e = I.getNumOperands() - 3; i != e;2387           ++i)2388        pushValueAndType(I.getOperand(i), InstID, Vals); // vararg2389    }2390    break;2391  }2392  case Instruction::Resume:2393    Code = bitc::FUNC_CODE_INST_RESUME;2394    pushValueAndType(I.getOperand(0), InstID, Vals);2395    break;2396  case Instruction::Unreachable:2397    Code = bitc::FUNC_CODE_INST_UNREACHABLE;2398    AbbrevToUse = (unsigned)FUNCTION_INST_UNREACHABLE_ABBREV;2399    break;2400 2401  case Instruction::PHI: {2402    const PHINode &PN = cast<PHINode>(I);2403    Code = bitc::FUNC_CODE_INST_PHI;2404    // With the newer instruction encoding, forward references could give2405    // negative valued IDs.  This is most common for PHIs, so we use2406    // signed VBRs.2407    SmallVector<uint64_t, 128> Vals64;2408    Vals64.push_back(getTypeID(PN.getType()));2409    for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) {2410      pushValueSigned(PN.getIncomingValue(i), InstID, Vals64);2411      Vals64.push_back(VE.getValueID(PN.getIncomingBlock(i)));2412    }2413    // Emit a Vals64 vector and exit.2414    Stream.EmitRecord(Code, Vals64, AbbrevToUse);2415    Vals64.clear();2416    return;2417  }2418 2419  case Instruction::LandingPad: {2420    const LandingPadInst &LP = cast<LandingPadInst>(I);2421    Code = bitc::FUNC_CODE_INST_LANDINGPAD;2422    Vals.push_back(getTypeID(LP.getType()));2423    Vals.push_back(LP.isCleanup());2424    Vals.push_back(LP.getNumClauses());2425    for (unsigned I = 0, E = LP.getNumClauses(); I != E; ++I) {2426      if (LP.isCatch(I))2427        Vals.push_back(LandingPadInst::Catch);2428      else2429        Vals.push_back(LandingPadInst::Filter);2430      pushValueAndType(LP.getClause(I), InstID, Vals);2431    }2432    break;2433  }2434 2435  case Instruction::Alloca: {2436    Code = bitc::FUNC_CODE_INST_ALLOCA;2437    const AllocaInst &AI = cast<AllocaInst>(I);2438    Vals.push_back(getTypeID(AI.getAllocatedType()));2439    Vals.push_back(getTypeID(I.getOperand(0)->getType()));2440    Vals.push_back(VE.getValueID(I.getOperand(0))); // size.2441    unsigned AlignRecord = Log2_32(AI.getAlign().value()) + 1;2442    assert(AlignRecord < 1 << 5 && "alignment greater than 1 << 64");2443    AlignRecord |= AI.isUsedWithInAlloca() << 5;2444    AlignRecord |= 1 << 6;2445    Vals.push_back(AlignRecord);2446    break;2447  }2448 2449  case Instruction::Load:2450    if (cast<LoadInst>(I).isAtomic()) {2451      Code = bitc::FUNC_CODE_INST_LOADATOMIC;2452      pushValueAndType(I.getOperand(0), InstID, Vals);2453    } else {2454      Code = bitc::FUNC_CODE_INST_LOAD;2455      if (!pushValueAndType(I.getOperand(0), InstID, Vals)) // ptr2456        AbbrevToUse = (unsigned)FUNCTION_INST_LOAD_ABBREV;2457    }2458    Vals.push_back(getTypeID(I.getType()));2459    Vals.push_back(Log2(cast<LoadInst>(I).getAlign()) + 1);2460    Vals.push_back(cast<LoadInst>(I).isVolatile());2461    if (cast<LoadInst>(I).isAtomic()) {2462      Vals.push_back(getEncodedOrdering(cast<LoadInst>(I).getOrdering()));2463      Vals.push_back(getEncodedSyncScopeID(cast<LoadInst>(I).getSyncScopeID()));2464    }2465    break;2466  case Instruction::Store:2467    if (cast<StoreInst>(I).isAtomic())2468      Code = bitc::FUNC_CODE_INST_STOREATOMIC;2469    else2470      Code = bitc::FUNC_CODE_INST_STORE;2471    pushValueAndType(I.getOperand(1), InstID, Vals); // ptrty + ptr2472    pushValueAndType(I.getOperand(0), InstID, Vals); // valty + val2473    Vals.push_back(Log2(cast<StoreInst>(I).getAlign()) + 1);2474    Vals.push_back(cast<StoreInst>(I).isVolatile());2475    if (cast<StoreInst>(I).isAtomic()) {2476      Vals.push_back(getEncodedOrdering(cast<StoreInst>(I).getOrdering()));2477      Vals.push_back(2478          getEncodedSyncScopeID(cast<StoreInst>(I).getSyncScopeID()));2479    }2480    break;2481  case Instruction::AtomicCmpXchg:2482    Code = bitc::FUNC_CODE_INST_CMPXCHG;2483    pushValueAndType(I.getOperand(0), InstID, Vals); // ptrty + ptr2484    pushValueAndType(I.getOperand(1), InstID, Vals); // cmp.2485    pushValue(I.getOperand(2), InstID, Vals);        // newval.2486    Vals.push_back(cast<AtomicCmpXchgInst>(I).isVolatile());2487    Vals.push_back(2488        getEncodedOrdering(cast<AtomicCmpXchgInst>(I).getSuccessOrdering()));2489    Vals.push_back(2490        getEncodedSyncScopeID(cast<AtomicCmpXchgInst>(I).getSyncScopeID()));2491    Vals.push_back(2492        getEncodedOrdering(cast<AtomicCmpXchgInst>(I).getFailureOrdering()));2493    Vals.push_back(cast<AtomicCmpXchgInst>(I).isWeak());2494    break;2495  case Instruction::AtomicRMW:2496    Code = bitc::FUNC_CODE_INST_ATOMICRMW;2497    pushValueAndType(I.getOperand(0), InstID, Vals); // ptrty + ptr2498    pushValue(I.getOperand(1), InstID, Vals);        // val.2499    Vals.push_back(2500        getEncodedRMWOperation(cast<AtomicRMWInst>(I).getOperation()));2501    Vals.push_back(cast<AtomicRMWInst>(I).isVolatile());2502    Vals.push_back(getEncodedOrdering(cast<AtomicRMWInst>(I).getOrdering()));2503    Vals.push_back(2504        getEncodedSyncScopeID(cast<AtomicRMWInst>(I).getSyncScopeID()));2505    break;2506  case Instruction::Fence:2507    Code = bitc::FUNC_CODE_INST_FENCE;2508    Vals.push_back(getEncodedOrdering(cast<FenceInst>(I).getOrdering()));2509    Vals.push_back(getEncodedSyncScopeID(cast<FenceInst>(I).getSyncScopeID()));2510    break;2511  case Instruction::Call: {2512    const CallInst &CI = cast<CallInst>(I);2513    FunctionType *FTy = CI.getFunctionType();2514 2515    Code = bitc::FUNC_CODE_INST_CALL;2516 2517    Vals.push_back(VE.getAttributeListID(CI.getAttributes()));2518    Vals.push_back((CI.getCallingConv() << 1) | unsigned(CI.isTailCall()) |2519                   unsigned(CI.isMustTailCall()) << 14 | 1 << 15);2520    Vals.push_back(getGlobalObjectValueTypeID(FTy, CI.getCalledFunction()));2521    pushValueAndType(CI.getCalledOperand(), InstID, Vals); // Callee2522 2523    // Emit value #'s for the fixed parameters.2524    for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {2525      // Check for labels (can happen with asm labels).2526      if (FTy->getParamType(i)->isLabelTy())2527        Vals.push_back(VE.getValueID(CI.getArgOperand(i)));2528      else2529        pushValue(CI.getArgOperand(i), InstID, Vals); // fixed param.2530    }2531 2532    // Emit type/value pairs for varargs params.2533    if (FTy->isVarArg()) {2534      for (unsigned i = FTy->getNumParams(), e = CI.arg_size(); i != e; ++i)2535        pushValueAndType(CI.getArgOperand(i), InstID, Vals); // varargs2536    }2537    break;2538  }2539  case Instruction::VAArg:2540    Code = bitc::FUNC_CODE_INST_VAARG;2541    Vals.push_back(getTypeID(I.getOperand(0)->getType())); // valistty2542    pushValue(I.getOperand(0), InstID, Vals);              // valist.2543    Vals.push_back(getTypeID(I.getType()));                // restype.2544    break;2545  }2546 2547  Stream.EmitRecord(Code, Vals, AbbrevToUse);2548  Vals.clear();2549}2550 2551// Emit names for globals/functions etc.2552void DXILBitcodeWriter::writeFunctionLevelValueSymbolTable(2553    const ValueSymbolTable &VST) {2554  if (VST.empty())2555    return;2556  Stream.EnterSubblock(bitc::VALUE_SYMTAB_BLOCK_ID, 4);2557 2558  SmallVector<unsigned, 64> NameVals;2559 2560  // HLSL Change2561  // Read the named values from a sorted list instead of the original list2562  // to ensure the binary is the same no matter what values ever existed.2563  SmallVector<const ValueName *, 16> SortedTable;2564 2565  for (auto &VI : VST) {2566    SortedTable.push_back(VI.second->getValueName());2567  }2568  // The keys are unique, so there shouldn't be stability issues.2569  llvm::sort(SortedTable, [](const ValueName *A, const ValueName *B) {2570    return A->first() < B->first();2571  });2572 2573  for (const ValueName *SI : SortedTable) {2574    auto &Name = *SI;2575 2576    // Figure out the encoding to use for the name.2577    bool is7Bit = true;2578    bool isChar6 = true;2579    for (const char *C = Name.getKeyData(), *E = C + Name.getKeyLength();2580         C != E; ++C) {2581      if (isChar6)2582        isChar6 = BitCodeAbbrevOp::isChar6(*C);2583      if ((unsigned char)*C & 128) {2584        is7Bit = false;2585        break; // don't bother scanning the rest.2586      }2587    }2588 2589    unsigned AbbrevToUse = VST_ENTRY_8_ABBREV;2590 2591    // VST_ENTRY:   [valueid, namechar x N]2592    // VST_BBENTRY: [bbid, namechar x N]2593    unsigned Code;2594    if (isa<BasicBlock>(SI->getValue())) {2595      Code = bitc::VST_CODE_BBENTRY;2596      if (isChar6)2597        AbbrevToUse = VST_BBENTRY_6_ABBREV;2598    } else {2599      Code = bitc::VST_CODE_ENTRY;2600      if (isChar6)2601        AbbrevToUse = VST_ENTRY_6_ABBREV;2602      else if (is7Bit)2603        AbbrevToUse = VST_ENTRY_7_ABBREV;2604    }2605 2606    NameVals.push_back(VE.getValueID(SI->getValue()));2607    for (const char *P = Name.getKeyData(),2608                    *E = Name.getKeyData() + Name.getKeyLength();2609         P != E; ++P)2610      NameVals.push_back((unsigned char)*P);2611 2612    // Emit the finished record.2613    Stream.EmitRecord(Code, NameVals, AbbrevToUse);2614    NameVals.clear();2615  }2616  Stream.ExitBlock();2617}2618 2619/// Emit a function body to the module stream.2620void DXILBitcodeWriter::writeFunction(const Function &F) {2621  Stream.EnterSubblock(bitc::FUNCTION_BLOCK_ID, 4);2622  VE.incorporateFunction(F);2623 2624  SmallVector<unsigned, 64> Vals;2625 2626  // Emit the number of basic blocks, so the reader can create them ahead of2627  // time.2628  Vals.push_back(VE.getBasicBlocks().size());2629  Stream.EmitRecord(bitc::FUNC_CODE_DECLAREBLOCKS, Vals);2630  Vals.clear();2631 2632  // If there are function-local constants, emit them now.2633  unsigned CstStart, CstEnd;2634  VE.getFunctionConstantRange(CstStart, CstEnd);2635  writeConstants(CstStart, CstEnd, false);2636 2637  // If there is function-local metadata, emit it now.2638  writeFunctionMetadata(F);2639 2640  // Keep a running idea of what the instruction ID is.2641  unsigned InstID = CstEnd;2642 2643  bool NeedsMetadataAttachment = F.hasMetadata();2644 2645  DILocation *LastDL = nullptr;2646 2647  // Finally, emit all the instructions, in order.2648  for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)2649    for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E;2650         ++I) {2651      writeInstruction(*I, InstID, Vals);2652 2653      if (!I->getType()->isVoidTy())2654        ++InstID;2655 2656      // If the instruction has metadata, write a metadata attachment later.2657      NeedsMetadataAttachment |= I->hasMetadataOtherThanDebugLoc();2658 2659      // If the instruction has a debug location, emit it.2660      DILocation *DL = I->getDebugLoc();2661      if (!DL)2662        continue;2663 2664      if (DL == LastDL) {2665        // Just repeat the same debug loc as last time.2666        Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC_AGAIN, Vals);2667        continue;2668      }2669 2670      Vals.push_back(DL->getLine());2671      Vals.push_back(DL->getColumn());2672      Vals.push_back(VE.getMetadataOrNullID(DL->getScope()));2673      Vals.push_back(VE.getMetadataOrNullID(DL->getInlinedAt()));2674      Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC, Vals);2675      Vals.clear();2676 2677      LastDL = DL;2678    }2679 2680  // Emit names for all the instructions etc.2681  if (auto *Symtab = F.getValueSymbolTable())2682    writeFunctionLevelValueSymbolTable(*Symtab);2683 2684  if (NeedsMetadataAttachment)2685    writeFunctionMetadataAttachment(F);2686 2687  VE.purgeFunction();2688  Stream.ExitBlock();2689}2690 2691// Emit blockinfo, which defines the standard abbreviations etc.2692void DXILBitcodeWriter::writeBlockInfo() {2693  // We only want to emit block info records for blocks that have multiple2694  // instances: CONSTANTS_BLOCK, FUNCTION_BLOCK and VALUE_SYMTAB_BLOCK.2695  // Other blocks can define their abbrevs inline.2696  Stream.EnterBlockInfoBlock();2697 2698  { // 8-bit fixed-width VST_ENTRY/VST_BBENTRY strings.2699    auto Abbv = std::make_shared<BitCodeAbbrev>();2700    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));2701    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));2702    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));2703    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));2704    if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID,2705                                   std::move(Abbv)) != VST_ENTRY_8_ABBREV)2706      assert(false && "Unexpected abbrev ordering!");2707  }2708 2709  { // 7-bit fixed width VST_ENTRY strings.2710    auto Abbv = std::make_shared<BitCodeAbbrev>();2711    Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY));2712    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));2713    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));2714    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));2715    if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID,2716                                   std::move(Abbv)) != VST_ENTRY_7_ABBREV)2717      assert(false && "Unexpected abbrev ordering!");2718  }2719  { // 6-bit char6 VST_ENTRY strings.2720    auto Abbv = std::make_shared<BitCodeAbbrev>();2721    Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY));2722    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));2723    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));2724    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));2725    if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID,2726                                   std::move(Abbv)) != VST_ENTRY_6_ABBREV)2727      assert(false && "Unexpected abbrev ordering!");2728  }2729  { // 6-bit char6 VST_BBENTRY strings.2730    auto Abbv = std::make_shared<BitCodeAbbrev>();2731    Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_BBENTRY));2732    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));2733    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));2734    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));2735    if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID,2736                                   std::move(Abbv)) != VST_BBENTRY_6_ABBREV)2737      assert(false && "Unexpected abbrev ordering!");2738  }2739 2740  { // SETTYPE abbrev for CONSTANTS_BLOCK.2741    auto Abbv = std::make_shared<BitCodeAbbrev>();2742    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_SETTYPE));2743    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,2744                              VE.computeBitsRequiredForTypeIndices()));2745    if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, std::move(Abbv)) !=2746        CONSTANTS_SETTYPE_ABBREV)2747      assert(false && "Unexpected abbrev ordering!");2748  }2749 2750  { // INTEGER abbrev for CONSTANTS_BLOCK.2751    auto Abbv = std::make_shared<BitCodeAbbrev>();2752    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_INTEGER));2753    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));2754    if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, std::move(Abbv)) !=2755        CONSTANTS_INTEGER_ABBREV)2756      assert(false && "Unexpected abbrev ordering!");2757  }2758 2759  { // CE_CAST abbrev for CONSTANTS_BLOCK.2760    auto Abbv = std::make_shared<BitCodeAbbrev>();2761    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CE_CAST));2762    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // cast opc2763    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,      // typeid2764                              VE.computeBitsRequiredForTypeIndices()));2765    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id2766 2767    if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, std::move(Abbv)) !=2768        CONSTANTS_CE_CAST_Abbrev)2769      assert(false && "Unexpected abbrev ordering!");2770  }2771  { // NULL abbrev for CONSTANTS_BLOCK.2772    auto Abbv = std::make_shared<BitCodeAbbrev>();2773    Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_NULL));2774    if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID, std::move(Abbv)) !=2775        CONSTANTS_NULL_Abbrev)2776      assert(false && "Unexpected abbrev ordering!");2777  }2778 2779  // FIXME: This should only use space for first class types!2780 2781  { // INST_LOAD abbrev for FUNCTION_BLOCK.2782    auto Abbv = std::make_shared<BitCodeAbbrev>();2783    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_LOAD));2784    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Ptr2785    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,    // dest ty2786                              VE.computeBitsRequiredForTypeIndices()));2787    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // Align2788    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // volatile2789    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, std::move(Abbv)) !=2790        (unsigned)FUNCTION_INST_LOAD_ABBREV)2791      assert(false && "Unexpected abbrev ordering!");2792  }2793  { // INST_BINOP abbrev for FUNCTION_BLOCK.2794    auto Abbv = std::make_shared<BitCodeAbbrev>();2795    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_BINOP));2796    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // LHS2797    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // RHS2798    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc2799    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, std::move(Abbv)) !=2800        (unsigned)FUNCTION_INST_BINOP_ABBREV)2801      assert(false && "Unexpected abbrev ordering!");2802  }2803  { // INST_BINOP_FLAGS abbrev for FUNCTION_BLOCK.2804    auto Abbv = std::make_shared<BitCodeAbbrev>();2805    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_BINOP));2806    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // LHS2807    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // RHS2808    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc2809    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7)); // flags2810    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, std::move(Abbv)) !=2811        (unsigned)FUNCTION_INST_BINOP_FLAGS_ABBREV)2812      assert(false && "Unexpected abbrev ordering!");2813  }2814  { // INST_CAST abbrev for FUNCTION_BLOCK.2815    auto Abbv = std::make_shared<BitCodeAbbrev>();2816    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_CAST));2817    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // OpVal2818    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,    // dest ty2819                              VE.computeBitsRequiredForTypeIndices()));2820    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc2821    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, std::move(Abbv)) !=2822        (unsigned)FUNCTION_INST_CAST_ABBREV)2823      assert(false && "Unexpected abbrev ordering!");2824  }2825 2826  { // INST_RET abbrev for FUNCTION_BLOCK.2827    auto Abbv = std::make_shared<BitCodeAbbrev>();2828    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_RET));2829    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, std::move(Abbv)) !=2830        (unsigned)FUNCTION_INST_RET_VOID_ABBREV)2831      assert(false && "Unexpected abbrev ordering!");2832  }2833  { // INST_RET abbrev for FUNCTION_BLOCK.2834    auto Abbv = std::make_shared<BitCodeAbbrev>();2835    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_RET));2836    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ValID2837    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, std::move(Abbv)) !=2838        (unsigned)FUNCTION_INST_RET_VAL_ABBREV)2839      assert(false && "Unexpected abbrev ordering!");2840  }2841  { // INST_UNREACHABLE abbrev for FUNCTION_BLOCK.2842    auto Abbv = std::make_shared<BitCodeAbbrev>();2843    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_UNREACHABLE));2844    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, std::move(Abbv)) !=2845        (unsigned)FUNCTION_INST_UNREACHABLE_ABBREV)2846      assert(false && "Unexpected abbrev ordering!");2847  }2848  {2849    auto Abbv = std::make_shared<BitCodeAbbrev>();2850    Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_GEP));2851    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));2852    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, // dest ty2853                              Log2_32_Ceil(VE.getTypes().size() + 1)));2854    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));2855    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));2856    if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, std::move(Abbv)) !=2857        (unsigned)FUNCTION_INST_GEP_ABBREV)2858      assert(false && "Unexpected abbrev ordering!");2859  }2860 2861  Stream.ExitBlock();2862}2863 2864void DXILBitcodeWriter::writeModuleVersion() {2865  // VERSION: [version#]2866  Stream.EmitRecord(bitc::MODULE_CODE_VERSION, ArrayRef<unsigned>{1});2867}2868 2869/// WriteModule - Emit the specified module to the bitstream.2870void DXILBitcodeWriter::write() {2871  // The identification block is new since llvm-3.7, but the old bitcode reader2872  // will skip it.2873  // writeIdentificationBlock(Stream);2874 2875  Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);2876 2877  // It is redundant to fully-specify this here, but nice to make it explicit2878  // so that it is clear the DXIL module version is different.2879  DXILBitcodeWriter::writeModuleVersion();2880 2881  // Emit blockinfo, which defines the standard abbreviations etc.2882  writeBlockInfo();2883 2884  // Emit information about attribute groups.2885  writeAttributeGroupTable();2886 2887  // Emit information about parameter attributes.2888  writeAttributeTable();2889 2890  // Emit information describing all of the types in the module.2891  writeTypeTable();2892 2893  writeComdats();2894 2895  // Emit top-level description of module, including target triple, inline asm,2896  // descriptors for global variables, and function prototype info.2897  writeModuleInfo();2898 2899  // Emit constants.2900  writeModuleConstants();2901 2902  // Emit metadata.2903  writeModuleMetadataKinds();2904 2905  // Emit metadata.2906  writeModuleMetadata();2907 2908  // Emit names for globals/functions etc.2909  // DXIL uses the same format for module-level value symbol table as for the2910  // function level table.2911  writeFunctionLevelValueSymbolTable(M.getValueSymbolTable());2912 2913  // Emit function bodies.2914  for (const Function &F : M)2915    if (!F.isDeclaration())2916      writeFunction(F);2917 2918  Stream.ExitBlock();2919}2920