diff --git a/llvm/include/llvm/Bitcode/BitcodeWriterBase.h b/llvm/include/llvm/Bitcode/BitcodeWriterBase.h --- a/llvm/include/llvm/Bitcode/BitcodeWriterBase.h +++ b/llvm/include/llvm/Bitcode/BitcodeWriterBase.h @@ -135,9 +135,10 @@ ModuleBitcodeWriterBase(const Module &M, StringTableBuilder &StrtabBuilder, BitstreamWriter &Stream, bool ShouldPreserveUseListOrder, - const ModuleSummaryIndex *Index) + const ModuleSummaryIndex *Index, + Type *PrefixType = nullptr) : BitcodeWriterBase(Stream, StrtabBuilder), M(M), - VE(M, ShouldPreserveUseListOrder), Index(Index) { + VE(M, ShouldPreserveUseListOrder, PrefixType), Index(Index) { // Assign ValueIds to any callee values in the index that came from // indirect call profiles and were recorded as a GUID not a Value* // (which would have been assigned an ID by the ValueEnumerator). diff --git a/llvm/include/llvm/Bitcode/ValueEnumerator.h b/llvm/include/llvm/Bitcode/ValueEnumerator.h --- a/llvm/include/llvm/Bitcode/ValueEnumerator.h +++ b/llvm/include/llvm/Bitcode/ValueEnumerator.h @@ -138,7 +138,8 @@ unsigned FirstInstID; public: - ValueEnumerator(const Module &M, bool ShouldPreserveUseListOrder); + ValueEnumerator(const Module &M, bool ShouldPreserveUseListOrder, + Type *PrefixType = nullptr); ValueEnumerator(const ValueEnumerator &) = delete; ValueEnumerator &operator=(const ValueEnumerator &) = delete; @@ -171,6 +172,9 @@ unsigned getInstructionID(const Instruction *I) const; void setInstructionID(const Instruction *I); + unsigned allocateInstructionID() { + return InstructionCount++; + } unsigned getAttributeListID(AttributeList PAL) const { if (PAL.isEmpty()) return 0; // Null maps to zero. @@ -236,6 +240,8 @@ void purgeFunction(); uint64_t computeBitsRequiredForTypeIndicies() const; + void EnumerateType(Type *T); + private: void OptimizeConstants(unsigned CstStart, unsigned CstEnd); @@ -292,7 +298,6 @@ void EnumerateFunctionLocalListMetadata(unsigned F, const DIArgList *Arglist); void EnumerateNamedMDNode(const NamedMDNode *NMD); void EnumerateValue(const Value *V); - void EnumerateType(Type *T); void EnumerateOperandType(const Value *V); void EnumerateAttributes(AttributeList PAL); diff --git a/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp b/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp --- a/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp +++ b/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp @@ -361,11 +361,17 @@ } ValueEnumerator::ValueEnumerator(const Module &M, - bool ShouldPreserveUseListOrder) + bool ShouldPreserveUseListOrder, + Type *PrefixType) : ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) { if (ShouldPreserveUseListOrder) UseListOrders = predictUseListOrder(M); + if (PrefixType) { + // If prefix type is specified enumerate it first + EnumerateType(PrefixType); + } + // Enumerate the global variables. for (const GlobalVariable &GV : M.globals()) { EnumerateValue(&GV); @@ -517,7 +523,7 @@ } void ValueEnumerator::setInstructionID(const Instruction *I) { - InstructionMap[I] = InstructionCount++; + InstructionMap[I] = allocateInstructionID(); } unsigned ValueEnumerator::getValueID(const Value *V) const { diff --git a/llvm/lib/Target/DirectX/DXILBitcodeWriter.h b/llvm/lib/Target/DirectX/DXILBitcodeWriter.h --- a/llvm/lib/Target/DirectX/DXILBitcodeWriter.h +++ b/llvm/lib/Target/DirectX/DXILBitcodeWriter.h @@ -10,6 +10,7 @@ // //===----------------------------------------------------------------------===// +#include "PointerTypeAnalysis.h" #include "llvm/Bitcode/BitcodeCommon.h" #include "llvm/Bitcode/BitcodeWriterBase.h" @@ -44,6 +45,12 @@ /// The start bit of the identification block. uint64_t BitcodeStartBit; + /// This maps values to their typed pointers + PointerTypeMap PointerMap; + + Type *I8Ty; + Type *I8PtrTy; + public: /// Constructs a ModuleBitcodeWriter object for the given Module, /// writing to the provided \p Buffer. @@ -51,11 +58,7 @@ StringTableBuilder &StrtabBuilder, BitstreamWriter &Stream, bool ShouldPreserveUseListOrder, const ModuleSummaryIndex *Index, bool GenerateHash, - ModuleHash *ModHash = nullptr) - : ModuleBitcodeWriterBase(M, StrtabBuilder, Stream, - ShouldPreserveUseListOrder, Index), - Buffer(Buffer), GenerateHash(GenerateHash), ModHash(ModHash), - BitcodeStartBit(Stream.GetCurrentBitNo()) {} + ModuleHash *ModHash = nullptr); /// Emit the current module to the bitstream. void write() override; @@ -212,5 +215,7 @@ unsigned getEncodedSyncScopeID(SyncScope::ID SSID) { return unsigned(SSID); } unsigned getEncodedAlign(MaybeAlign Alignment) { return encode(Alignment); } + unsigned getTypeID(Type *T, const Value *V = nullptr); + unsigned getTypeID(Type *T, const Function *F); }; } // namespace llvm diff --git a/llvm/lib/Target/DirectX/DXILBitcodeWriter.cpp b/llvm/lib/Target/DirectX/DXILBitcodeWriter.cpp --- a/llvm/lib/Target/DirectX/DXILBitcodeWriter.cpp +++ b/llvm/lib/Target/DirectX/DXILBitcodeWriter.cpp @@ -19,15 +19,55 @@ #include "llvm/Support/ErrorHandling.h" using namespace llvm; +using namespace llvm::dxil; + +DXILBitcodeWriter::DXILBitcodeWriter(const Module &M, + SmallVectorImpl &Buffer, + StringTableBuilder &StrtabBuilder, + BitstreamWriter &Stream, + bool ShouldPreserveUseListOrder, + const ModuleSummaryIndex *Index, + bool GenerateHash, ModuleHash *ModHash) + : ModuleBitcodeWriterBase( + M, StrtabBuilder, Stream, ShouldPreserveUseListOrder, Index, + TypedPointerType::get(Type::getInt8Ty(M.getContext()), 0)), + Buffer(Buffer), GenerateHash(GenerateHash), ModHash(ModHash), + BitcodeStartBit(Stream.GetCurrentBitNo()), + PointerMap(PointerTypeAnalysis::run(M)), + I8Ty(Type::getInt8Ty(M.getContext())), + I8PtrTy(TypedPointerType::get(I8Ty, 0)) { + // Enumerate the typed pointers + for (auto El : PointerMap) { + VE.EnumerateType(El.second); + //El.first->dump(); + //El.second->dump(); + } +} + +unsigned DXILBitcodeWriter::getTypeID(Type *T, const Value *V) { + if (!T->isOpaquePointerTy()) + return VE.getTypeID(T); + auto It = PointerMap.find(V); + if (It != PointerMap.end()) + return VE.getTypeID(It->second); + return VE.getTypeID(I8PtrTy); +} + +unsigned DXILBitcodeWriter::getTypeID(Type *T, const Function *F) { + auto It = PointerMap.find(F); + if (It != PointerMap.end()) + return VE.getTypeID(It->second); + return VE.getTypeID(T); +} std::unique_ptr DXILBitcodeWriter::Create( const Module &M, SmallVectorImpl &Buffer, StringTableBuilder &StrtabBuilder, BitstreamWriter &Stream, bool ShouldPreserveUseListOrder, const ModuleSummaryIndex *Index, bool GenerateHash, ModuleHash *ModHash) { - return std::make_unique( - M, Buffer, StrtabBuilder, Stream, ShouldPreserveUseListOrder, Index, - GenerateHash, ModHash); + return std::make_unique(M, Buffer, StrtabBuilder, Stream, + ShouldPreserveUseListOrder, Index, + GenerateHash, ModHash); } void DXILBitcodeWriter::writeAttributeGroupTable() { @@ -209,25 +249,46 @@ Code = bitc::TYPE_CODE_INTEGER; TypeVals.push_back(cast(T)->getBitWidth()); break; - case Type::PointerTyID: { - PointerType *PTy = cast(T); + case Type::DXILPointerTyID: { + TypedPointerType *PTy = cast(T); // POINTER: [pointee type, address space] Code = bitc::TYPE_CODE_POINTER; - TypeVals.push_back(VE.getTypeID(PTy->getNonOpaquePointerElementType())); + TypeVals.push_back(getTypeID(PTy->getElementType())); unsigned AddressSpace = PTy->getAddressSpace(); TypeVals.push_back(AddressSpace); if (AddressSpace == 0) AbbrevToUse = PtrAbbrev; break; } + case Type::PointerTyID: { + PointerType *PTy = cast(T); + // POINTER: [pointee type, address space] + Code = bitc::TYPE_CODE_POINTER; + // Emitting an empty struct type for the opaque pointer's type allows this + // to be order-independent. Non-struct types must be emitted in bitcode + // before they can be referenced. + if (PTy->isOpaquePointerTy()) { + TypeVals.push_back(false); + Code = bitc::TYPE_CODE_OPAQUE; + writeStringRecord(Stream, bitc::TYPE_CODE_STRUCT_NAME, + "dxilOpaquePtrReservedName", StructNameAbbrev); + } else { + TypeVals.push_back(getTypeID(PTy->getNonOpaquePointerElementType())); + unsigned AddressSpace = PTy->getAddressSpace(); + TypeVals.push_back(AddressSpace); + if (AddressSpace == 0) + AbbrevToUse = PtrAbbrev; + } + break; + } case Type::FunctionTyID: { FunctionType *FT = cast(T); // FUNCTION: [isvararg, retty, paramty x N] Code = bitc::TYPE_CODE_FUNCTION; TypeVals.push_back(FT->isVarArg()); - TypeVals.push_back(VE.getTypeID(FT->getReturnType())); + TypeVals.push_back(getTypeID(FT->getReturnType())); for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) - TypeVals.push_back(VE.getTypeID(FT->getParamType(i))); + TypeVals.push_back(getTypeID(FT->getParamType(i))); AbbrevToUse = FunctionAbbrev; break; } @@ -239,7 +300,7 @@ for (StructType::element_iterator I = ST->element_begin(), E = ST->element_end(); I != E; ++I) - TypeVals.push_back(VE.getTypeID(*I)); + TypeVals.push_back(getTypeID(*I)); if (ST->isLiteral()) { Code = bitc::TYPE_CODE_STRUCT_ANON; @@ -264,7 +325,7 @@ // ARRAY: [numelts, eltty] Code = bitc::TYPE_CODE_ARRAY; TypeVals.push_back(AT->getNumElements()); - TypeVals.push_back(VE.getTypeID(AT->getElementType())); + TypeVals.push_back(getTypeID(AT->getElementType())); AbbrevToUse = ArrayAbbrev; break; } @@ -274,7 +335,7 @@ // VECTOR [numelts, eltty] Code = bitc::TYPE_CODE_VECTOR; TypeVals.push_back(VT->getElementCount().getKnownMinValue()); - TypeVals.push_back(VE.getTypeID(VT->getElementType())); + TypeVals.push_back(getTypeID(VT->getElementType())); break; } } @@ -331,7 +392,7 @@ }; for (const GlobalVariable &GV : M.globals()) { UpdateMaxAlignment(GV.getAlign()); - MaxGlobalType = std::max(MaxGlobalType, VE.getTypeID(GV.getValueType())); + MaxGlobalType = std::max(MaxGlobalType, getTypeID(GV.getValueType(), &GV)); if (GV.hasSection()) { // Give section names unique ID's. unsigned &Entry = SectionMap[std::string(GV.getSection())]; @@ -402,7 +463,7 @@ // linkage, alignment, section, visibility, threadlocal, // unnamed_addr, externally_initialized, dllstorageclass, // comdat] - Vals.push_back(VE.getTypeID(GV.getValueType())); + Vals.push_back(getTypeID(GV.getValueType(), &GV)); Vals.push_back( GV.getType()->getAddressSpace() << 2 | 2 | (GV.isConstant() ? 1 : 0)); // HLSL Change - bitwise | was used with @@ -438,7 +499,7 @@ // FUNCTION: [type, callingconv, isproto, linkage, paramattrs, alignment, // section, visibility, gc, unnamed_addr, prologuedata, // dllstorageclass, comdat, prefixdata, personalityfn] - Vals.push_back(VE.getTypeID(F.getFunctionType())); + Vals.push_back(getTypeID(F.getFunctionType(), &F)); Vals.push_back(F.getCallingConv()); Vals.push_back(F.isDeclaration()); Vals.push_back(getEncodedLinkage(F)); @@ -466,7 +527,7 @@ // Emit the alias information. for (const GlobalAlias &A : M.aliases()) { // ALIAS: [alias type, aliasee val#, linkage, visibility] - Vals.push_back(VE.getTypeID(A.getValueType())); + Vals.push_back(getTypeID(A.getValueType(), &A)); Vals.push_back(VE.getValueID(A.getAliasee())); Vals.push_back(getEncodedLinkage(A)); Vals.push_back(getEncodedVisibility(A)); @@ -483,7 +544,7 @@ const ValueAsMetadata *MD, SmallVectorImpl &Record) { // Mimic an MDNode with a value as one operand. Value *V = MD->getValue(); - Record.push_back(VE.getTypeID(V->getType())); + Record.push_back(getTypeID(V->getType())); Record.push_back(VE.getValueID(V)); Stream.EmitRecord(bitc::METADATA_VALUE, Record, 0); Record.clear(); @@ -1087,7 +1148,7 @@ // If we need to switch types, do so now. if (V->getType() != LastTy) { LastTy = V->getType(); - Record.push_back(VE.getTypeID(LastTy)); + Record.push_back(getTypeID(LastTy)); Stream.EmitRecord(bitc::CST_CODE_SETTYPE, Record, CONSTANTS_SETTYPE_ABBREV); Record.clear(); @@ -1222,7 +1283,7 @@ if (Instruction::isCast(CE->getOpcode())) { Code = bitc::CST_CODE_CE_CAST; Record.push_back(getEncodedCastOpcode(CE->getOpcode())); - Record.push_back(VE.getTypeID(C->getOperand(0)->getType())); + Record.push_back(getTypeID(C->getOperand(0)->getType())); Record.push_back(VE.getValueID(C->getOperand(0))); AbbrevToUse = CONSTANTS_CE_CAST_Abbrev; } else { @@ -1241,9 +1302,9 @@ const auto *GO = cast(C); if (GO->isInBounds()) Code = bitc::CST_CODE_CE_INBOUNDS_GEP; - Record.push_back(VE.getTypeID(GO->getSourceElementType())); + Record.push_back(getTypeID(GO->getSourceElementType())); for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i) { - Record.push_back(VE.getTypeID(C->getOperand(i)->getType())); + Record.push_back(getTypeID(C->getOperand(i)->getType())); Record.push_back(VE.getValueID(C->getOperand(i))); } break; @@ -1256,16 +1317,16 @@ break; case Instruction::ExtractElement: Code = bitc::CST_CODE_CE_EXTRACTELT; - Record.push_back(VE.getTypeID(C->getOperand(0)->getType())); + Record.push_back(getTypeID(C->getOperand(0)->getType())); Record.push_back(VE.getValueID(C->getOperand(0))); - Record.push_back(VE.getTypeID(C->getOperand(1)->getType())); + Record.push_back(getTypeID(C->getOperand(1)->getType())); Record.push_back(VE.getValueID(C->getOperand(1))); break; case Instruction::InsertElement: Code = bitc::CST_CODE_CE_INSERTELT; Record.push_back(VE.getValueID(C->getOperand(0))); Record.push_back(VE.getValueID(C->getOperand(1))); - Record.push_back(VE.getTypeID(C->getOperand(2)->getType())); + Record.push_back(getTypeID(C->getOperand(2)->getType())); Record.push_back(VE.getValueID(C->getOperand(2))); break; case Instruction::ShuffleVector: @@ -1277,7 +1338,7 @@ Code = bitc::CST_CODE_CE_SHUFFLEVEC; } else { Code = bitc::CST_CODE_CE_SHUFVEC_EX; - Record.push_back(VE.getTypeID(C->getOperand(0)->getType())); + Record.push_back(getTypeID(C->getOperand(0)->getType())); } Record.push_back(VE.getValueID(C->getOperand(0))); Record.push_back(VE.getValueID(C->getOperand(1))); @@ -1286,7 +1347,7 @@ case Instruction::ICmp: case Instruction::FCmp: Code = bitc::CST_CODE_CE_CMP; - Record.push_back(VE.getTypeID(C->getOperand(0)->getType())); + Record.push_back(getTypeID(C->getOperand(0)->getType())); Record.push_back(VE.getValueID(C->getOperand(0))); Record.push_back(VE.getValueID(C->getOperand(1))); Record.push_back(CE->getPredicate()); @@ -1294,7 +1355,7 @@ } } else if (const BlockAddress *BA = dyn_cast(C)) { Code = bitc::CST_CODE_BLOCKADDRESS; - Record.push_back(VE.getTypeID(BA->getFunction()->getType())); + Record.push_back(getTypeID(BA->getFunction()->getType())); Record.push_back(VE.getValueID(BA->getFunction())); Record.push_back(VE.getGlobalBasicBlockID(BA->getBasicBlock())); } else { @@ -1337,7 +1398,7 @@ // Make encoding relative to the InstID. Vals.push_back(InstID - ValID); if (ValID >= InstID) { - Vals.push_back(VE.getTypeID(V->getType())); + Vals.push_back(getTypeID(V->getType(), V)); return true; } return false; @@ -1370,7 +1431,7 @@ Code = bitc::FUNC_CODE_INST_CAST; if (!pushValueAndType(I.getOperand(0), InstID, Vals)) AbbrevToUse = (unsigned)dxilc::FUNCTION_INST_CAST_ABBREV; - Vals.push_back(VE.getTypeID(I.getType())); + Vals.push_back(getTypeID(I.getType(), &I)); Vals.push_back(getEncodedCastOpcode(I.getOpcode())); } else { assert(isa(I) && "Unknown instruction!"); @@ -1393,7 +1454,7 @@ AbbrevToUse = (unsigned)dxilc::FUNCTION_INST_GEP_ABBREV; auto &GEPInst = cast(I); Vals.push_back(GEPInst.isInBounds()); - Vals.push_back(VE.getTypeID(GEPInst.getSourceElementType())); + Vals.push_back(getTypeID(GEPInst.getSourceElementType())); for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) pushValueAndType(I.getOperand(i), InstID, Vals); break; @@ -1474,7 +1535,7 @@ case Instruction::Switch: { Code = bitc::FUNC_CODE_INST_SWITCH; const SwitchInst &SI = cast(I); - Vals.push_back(VE.getTypeID(SI.getCondition()->getType())); + Vals.push_back(getTypeID(SI.getCondition()->getType())); pushValue(SI.getCondition(), InstID, Vals); Vals.push_back(VE.getValueID(SI.getDefaultDest())); for (auto Case : SI.cases()) { @@ -1484,7 +1545,7 @@ } break; case Instruction::IndirectBr: Code = bitc::FUNC_CODE_INST_INDIRECTBR; - Vals.push_back(VE.getTypeID(I.getOperand(0)->getType())); + Vals.push_back(getTypeID(I.getOperand(0)->getType())); // Encode the address operand as relative, but not the basic blocks. pushValue(I.getOperand(0), InstID, Vals); for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) @@ -1501,7 +1562,7 @@ Vals.push_back(II->getCallingConv() | 1 << 13); Vals.push_back(VE.getValueID(II->getNormalDest())); Vals.push_back(VE.getValueID(II->getUnwindDest())); - Vals.push_back(VE.getTypeID(FTy)); + Vals.push_back(getTypeID(FTy)); pushValueAndType(Callee, InstID, Vals); // Emit value #'s for the fixed parameters. @@ -1532,7 +1593,7 @@ // negative valued IDs. This is most common for PHIs, so we use // signed VBRs. SmallVector Vals64; - Vals64.push_back(VE.getTypeID(PN.getType())); + Vals64.push_back(getTypeID(PN.getType())); for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) { pushValueSigned(PN.getIncomingValue(i), InstID, Vals64); Vals64.push_back(VE.getValueID(PN.getIncomingBlock(i))); @@ -1546,7 +1607,7 @@ case Instruction::LandingPad: { const LandingPadInst &LP = cast(I); Code = bitc::FUNC_CODE_INST_LANDINGPAD; - Vals.push_back(VE.getTypeID(LP.getType())); + Vals.push_back(getTypeID(LP.getType())); Vals.push_back(LP.isCleanup()); Vals.push_back(LP.getNumClauses()); for (unsigned I = 0, E = LP.getNumClauses(); I != E; ++I) { @@ -1562,8 +1623,8 @@ case Instruction::Alloca: { Code = bitc::FUNC_CODE_INST_ALLOCA; const AllocaInst &AI = cast(I); - Vals.push_back(VE.getTypeID(AI.getAllocatedType())); - Vals.push_back(VE.getTypeID(I.getOperand(0)->getType())); + Vals.push_back(getTypeID(AI.getAllocatedType())); + Vals.push_back(getTypeID(I.getOperand(0)->getType())); Vals.push_back(VE.getValueID(I.getOperand(0))); // size. using APV = AllocaPackedValues; unsigned Record = 0; @@ -1586,7 +1647,7 @@ if (!pushValueAndType(I.getOperand(0), InstID, Vals)) // ptr AbbrevToUse = (unsigned)dxilc::FUNCTION_INST_LOAD_ABBREV; } - Vals.push_back(VE.getTypeID(I.getType())); + Vals.push_back(getTypeID(I.getType())); Vals.push_back(Log2_32(cast(I).getAlignment()) + 1); Vals.push_back(cast(I).isVolatile()); if (cast(I).isAtomic()) { @@ -1648,7 +1709,7 @@ Vals.push_back(VE.getAttributeListID(CI.getAttributes())); Vals.push_back((CI.getCallingConv() << 1) | unsigned(CI.isTailCall()) | unsigned(CI.isMustTailCall()) << 14 | 1 << 15); - Vals.push_back(VE.getTypeID(FTy)); + Vals.push_back(getTypeID(FTy, CI.getCalledFunction())); pushValueAndType(CI.getCalledOperand(), InstID, Vals); // Callee // Emit value #'s for the fixed parameters. @@ -1669,9 +1730,9 @@ } case Instruction::VAArg: Code = bitc::FUNC_CODE_INST_VAARG; - Vals.push_back(VE.getTypeID(I.getOperand(0)->getType())); // valistty - pushValue(I.getOperand(0), InstID, Vals); // valist. - Vals.push_back(VE.getTypeID(I.getType())); // restype. + Vals.push_back(getTypeID(I.getOperand(0)->getType())); // valistty + pushValue(I.getOperand(0), InstID, Vals); // valist. + Vals.push_back(getTypeID(I.getType())); // restype. break; } @@ -1690,7 +1751,7 @@ // FIXME: We know if the type names can use 7-bit ascii. SmallVector NameVals; - // HLSL Change - Begin + // HLSL Changed from LLVM 3.7 // Read the named values from a sorted list instead of the original list // to ensure the binary is the same no matter what values ever existed. SmallVector SortedTable; @@ -1707,12 +1768,6 @@ for (const ValueName *SI : SortedTable) { auto &Name = *SI; -// HLSL Change - End -#if 0 // HLSL Change - for (ValueSymbolTable::const_iterator SI = VST.begin(), SE = VST.end(); - SI != SE; ++SI) { - const ValueName &Name = *SI; -#endif // HLSL Change // Figure out the encoding to use for the name. bool is7Bit = true; diff --git a/llvm/test/tools/dxil-dis/opaque-gep.ll b/llvm/test/tools/dxil-dis/opaque-gep.ll new file mode 100644 --- /dev/null +++ b/llvm/test/tools/dxil-dis/opaque-gep.ll @@ -0,0 +1,12 @@ +; RUN: llc --filetype=obj %s -o - | dxil-dis -o - | FileCheck %s +target triple = "dxil-unknown-unknown" + +define i32 @fn(ptr %0) { + %2 = getelementptr i32, ptr %0, i32 4 + %3 = load i32, ptr %2 + ret i32 %3 +} + +; CHECK: define i32 @fn(i32*) +; CHECK-NEXT: %2 = getelementptr i32, i32* %0, i32 4 +; CHECK-NEXT: %3 = load i32, i32* %2, align 4 diff --git a/llvm/test/tools/dxil-dis/opaque-pointers.ll b/llvm/test/tools/dxil-dis/opaque-pointers.ll new file mode 100644 --- /dev/null +++ b/llvm/test/tools/dxil-dis/opaque-pointers.ll @@ -0,0 +1,24 @@ +; RUN: llc --filetype=obj %s -o - | dxil-dis -o - | FileCheck %s +target triple = "dxil-unknown-unknown" + +define i64 @test(ptr %p) { + store i32 0, ptr %p + %v = load i64, ptr %p + ret i64 %v +} + +; CHECK: define i64 @test(i8* %p) { +; CHECK-NEXT: %1 = bitcast i8* %p to i32* +; CHECK-NEXT: %2 = bitcast i8* %p to i64* +; CHECK-NEXT: store i32 0, i32* %1, align 4 +; CHECK-NEXT: %3 = load i64, i64* %2, align 8 + +define i64 @test2(ptr %p) { + store i64 0, ptr %p + %v = load i64, ptr %p + ret i64 %v +} + +; CHECK: define i64 @test2(i64* %p) { +; CHECK-NEXT: store i64 0, i64* %p, align 8 +; CHECK-NEXT: %v = load i64, i64* %p, align 8