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