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