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