| //===--- DXILDebugInfo.cpp - analysis&lowering for Debug info -*- C++ -*- ---=// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "DXILDebugInfo.h" |
| #include "DXILAttributes.h" |
| #include "llvm/BinaryFormat/Dwarf.h" |
| #include "llvm/IR/AttributeMask.h" |
| #include "llvm/IR/Attributes.h" |
| #include "llvm/IR/DebugInfo.h" |
| #include "llvm/IR/Instructions.h" |
| #include "llvm/IR/IntrinsicsDirectX.h" |
| #include "llvm/IR/Module.h" |
| #include "llvm/Transforms/Utils/BasicBlockUtils.h" |
| |
| #define DEBUG_TYPE "dx-debug-info" |
| |
| using namespace llvm; |
| using namespace llvm::dxil; |
| |
| // llvm.dbg.value has an additional "offset" operand in DXIL. |
| static void replaceDbgVariableIntr(DbgVariableIntrinsic *DVI, Function *NewF, |
| DXILDebugInfoMap &Res) { |
| if (DVI->getIntrinsicID() != Intrinsic::dbg_value) { |
| return; |
| } |
| |
| Type *Int64Ty = Type::getInt64Ty(DVI->getContext()); |
| Constant *ZeroOffset = ConstantInt::get(Int64Ty, 0); |
| |
| Value *NewOps[] = { |
| DVI->getOperand(0), |
| ZeroOffset, |
| DVI->getOperand(1), |
| DVI->getOperand(2), |
| }; |
| |
| CallInst *NewI = CallInst::Create(NewF->getFunctionType(), NewF, NewOps); |
| NewI->setTailCall(DVI->isTailCall()); |
| NewI->setDebugLoc(DVI->getDebugLoc()); |
| Res.InstReplace.insert({DVI, decltype(Res.InstReplace)::mapped_type(NewI)}); |
| } |
| |
| static void replaceDbgValue(Module &M, DXILDebugInfoMap &Res) { |
| Function *F = getDeclarationIfExists(&M, Intrinsic::dbg_value); |
| if (!F) |
| return; |
| |
| FunctionType *FT = F->getFunctionType(); |
| Type *Int64Ty = Type::getInt64Ty(F->getContext()); |
| FunctionType *NewFT = FunctionType::get( |
| FT->getReturnType(), |
| {FT->getParamType(0), Int64Ty, FT->getParamType(1), FT->getParamType(2)}, |
| /*isVarArg=*/false); |
| Function *NewF = Function::Create(NewFT, F->getLinkage(), F->getName()); |
| NewF->copyAttributesFrom(F); |
| Res.FuncReplace.insert({F, decltype(Res.FuncReplace)::mapped_type(NewF)}); |
| |
| for (User *U : F->users()) { |
| auto *DVI = cast<DbgVariableIntrinsic>(U); |
| replaceDbgVariableIntr(DVI, NewF, Res); |
| } |
| } |
| |
| DXILDebugInfoMap DXILDebugInfoPass::run(Module &M) { |
| M.convertFromNewDbgValues(); |
| |
| DXILDebugInfoMap Res; |
| DebugInfoFinder DIF; |
| DIF.processModule(M); |
| |
| { |
| Function *DVDecl = nullptr; |
| |
| // Logically these should be variables in the |
| // for (BasicBlock &BB : F) loop. |
| // They are defined here and cleared at the start of the loop body to avoid |
| // the cost of deconstruction and reconstruction. |
| DenseMap<DILocalVariable *, std::pair<Instruction *, DbgValueInst *>> |
| DbgValues; |
| DenseMap<std::pair<DILocalVariable *, DIExpression *>, |
| std::pair<Instruction *, DbgValueInst *>> |
| DbgValueFragments; |
| // Likewise, logically, this should be a variable in the |
| // for (Function &F : M) loop. |
| DenseSet<DILocalVariable *> DbgVariablesSeen; |
| |
| const AttributeMask &AttrMask = getNonDXILAttributeMask(); |
| |
| for (Function &F : M) { |
| F.removeFnAttrs(AttrMask); |
| F.removeRetAttrs(AttrMask); |
| for (unsigned ArgNo = 0; ArgNo != F.arg_size(); ++ArgNo) |
| F.removeParamAttrs(ArgNo, AttrMask); |
| |
| bool IsEntryBlock = true; |
| DbgVariablesSeen.clear(); |
| for (BasicBlock &BB : F) { |
| Instruction *NextNonDebugInst = nullptr; |
| DbgValues.clear(); |
| DbgValueFragments.clear(); |
| for (Instruction &I : make_early_inc_range(reverse(BB))) { |
| I.eraseMetadataIf([](unsigned KindID, MDNode *) { |
| return KindID == LLVMContext::MD_DIAssignID; |
| }); |
| if (!isa<DbgInfoIntrinsic>(I)) { |
| NextNonDebugInst = &I; |
| continue; |
| } |
| if (auto *DL = dyn_cast<DbgLabelInst>(&I)) { |
| DL->eraseFromParent(); |
| continue; |
| } |
| // Process both llvm.dbg.value and llvm.dbg.assign here. We convert |
| // llvm.dbg.assign to llvm.dbg.value by dropping the last arguments, |
| // and remove redundant llvm.dbg.values. |
| if (auto *DV = dyn_cast<DbgValueInst>(&I)) { |
| // Keep track of the last location where we saw any debug value for |
| // a variable. |
| DILocalVariable *V = DV->getVariable(); |
| DIExpression *E = DV->getExpression(); |
| // If this is already an llvm.dbg.value instruction that we can |
| // keep, just do that, otherwise convert it. |
| auto *Val = cast<MetadataAsValue>(DV->getArgOperand(0)); |
| auto *Var = cast<MetadataAsValue>(DV->getArgOperand(1)); |
| auto *Expr = cast<MetadataAsValue>(DV->getArgOperand(2)); |
| bool Replace = DV->getIntrinsicID() != Intrinsic::dbg_value; |
| if (!isa<ValueAsMetadata>(Val->getMetadata())) { |
| // This may be a DIArgList which is not supported in LLVM 3.7. If |
| // it is, we cannot record the new value, but we still need to |
| // kill any old value. Do this by poison. We do not know the |
| // correct type to use here and arbitrarily use i1. |
| // This should never be anything other than ValueAsMetadata or |
| // DIArgList, but in manually constructed LLVM IR, it can be. |
| // Handle this gracefully by also replacing it with poison. |
| Val = MetadataAsValue::get( |
| M.getContext(), ConstantAsMetadata::get(PoisonValue::get( |
| Type::getInt1Ty(M.getContext())))); |
| E = DIExpression::get(M.getContext(), {}); |
| Expr = MetadataAsValue::get(M.getContext(), E); |
| Replace = true; |
| } |
| std::pair<Instruction *, DbgValueInst *> &DbgValue = DbgValues[V]; |
| std::pair<Instruction *, DbgValueInst *> &DbgValueFragment = |
| DbgValueFragments[{V, E}]; |
| if (DbgValue.second) { |
| // If there is a later value of the same fragment at the same |
| // location, this value is redundant. |
| if (DbgValueFragment.first == NextNonDebugInst) { |
| DV->eraseFromParent(); |
| continue; |
| } |
| // If there is a later identical value of the same fragment at a |
| // later point, and there have been no intervening values of |
| // different possibly overlapping fragments, that later value is |
| // redundant. |
| if (DbgValueFragment.second && |
| DbgValueFragment.second == DbgValue.second && |
| DbgValueFragment.second->getValue() == DV->getValue()) { |
| DbgValue.second->eraseFromParent(); |
| } |
| } |
| DbgValueInst *NewDV; |
| if (Replace) { |
| if (!DVDecl) { |
| DVDecl = |
| Intrinsic::getOrInsertDeclaration(&M, Intrinsic::dbg_value); |
| AttributeMask AM; |
| for (Attribute A : DVDecl->getAttributes().getFnAttrs()) |
| if (A.isStringAttribute() || |
| (A.getKindAsEnum() != Attribute::NoUnwind && |
| A.getKindAsEnum() != Attribute::Memory)) |
| AM.addAttribute(A); |
| DVDecl->removeFnAttrs(AM); |
| } |
| NewDV = cast<DbgValueInst>( |
| CallInst::Create(DVDecl, {Val, Var, Expr}, {}, "", |
| std::next(DV->getIterator()))); |
| NewDV->setTailCall(); |
| NewDV->setDebugLoc(DV->getDebugLoc()); |
| DV->eraseFromParent(); |
| } else { |
| NewDV = DV; |
| } |
| DbgValue = DbgValueFragment = {NextNonDebugInst, NewDV}; |
| continue; |
| } |
| } |
| // If this is the entry block, if the first value we see for each debug |
| // value is undef, it is redundant. |
| if (IsEntryBlock) { |
| for (Instruction &I : make_early_inc_range(BB)) { |
| auto *DV = dyn_cast<DbgValueInst>(&I); |
| if (!DV || DbgVariablesSeen.contains(DV->getVariable())) |
| continue; |
| if (isa<UndefValue>(DV->getValue())) { |
| DV->eraseFromParent(); |
| continue; |
| } |
| DbgVariablesSeen.insert(DV->getVariable()); |
| } |
| } |
| IsEntryBlock = false; |
| } |
| } |
| } |
| |
| for (DISubprogram *SP : DIF.subprograms()) { |
| if (MDTuple *RN = cast_or_null<MDTuple>(SP->getRawRetainedNodes())) { |
| SmallVector<Metadata *> MDs(RN->operands()); |
| MDs.erase(std::remove_if(MDs.begin(), MDs.end(), |
| [](Metadata *M) { return isa<DILabel>(M); }), |
| MDs.end()); |
| SP->replaceRetainedNodes(MDTuple::get(M.getContext(), MDs)); |
| } |
| } |
| |
| // Re-scan the module to account for removed metadata. |
| DIF.reset(); |
| DIF.processModule(M); |
| |
| // Replace llvm.dbg.value with equivalent DXIL intrinsics. |
| replaceDbgValue(M, Res); |
| |
| for (DICompileUnit *CU : DIF.compile_units()) { |
| DISourceLanguageName Lang = CU->getSourceLanguage(); |
| if (Lang.hasVersionedName()) { |
| auto LangName = static_cast<dwarf::SourceLanguageName>(Lang.getName()); |
| Lang = dwarf::toDW_LANG(LangName, Lang.getVersion()) |
| .value_or(dwarf::SourceLanguage{}); |
| auto *NewCU = DICompileUnit::getDistinct( |
| M.getContext(), Lang, CU->getFile(), CU->getProducer(), |
| CU->isOptimized(), CU->getFlags(), CU->getRuntimeVersion(), |
| CU->getSplitDebugFilename(), CU->getEmissionKind(), |
| CU->getEnumTypes(), CU->getRetainedTypes(), CU->getGlobalVariables(), |
| CU->getImportedEntities(), CU->getMacros(), CU->getDWOId(), |
| CU->getSplitDebugInlining(), CU->getDebugInfoForProfiling(), |
| CU->getNameTableKind(), CU->getRangesBaseAddress(), CU->getSysRoot(), |
| CU->getSDK()); |
| Res.MDReplace.insert({CU, NewCU}); |
| } |
| } |
| |
| std::vector<std::pair<const DICompileUnit *, const Metadata *>> CUSubprograms; |
| |
| for (const Function &F : M) { |
| if (const DISubprogram *SP = F.getSubprogram()) { |
| auto *FunctionMD = ConstantAsMetadata::get(const_cast<Function *>(&F)); |
| Res.MDExtra.insert({SP, FunctionMD}); |
| } |
| } |
| |
| for (const DISubprogram *SP : DIF.subprograms()) { |
| const DISubprogram *NewSP = SP; |
| |
| static constexpr auto SupportedDIFlags = |
| static_cast<DISubprogram::DIFlags>(DISubprogram::FlagExportSymbols - 1); |
| static constexpr auto SupportedDISPFlags = |
| static_cast<DISubprogram::DISPFlags>(DISubprogram::SPFlagPure - 1); |
| if (SP->isDistinct() || SP->getFlags() & ~SupportedDIFlags || |
| SP->getSPFlags() & ~SupportedDISPFlags) { |
| NewSP = DISubprogram::get( |
| M.getContext(), SP->getScope(), SP->getName(), SP->getLinkageName(), |
| SP->getFile(), SP->getLine(), SP->getType(), SP->getScopeLine(), |
| SP->getContainingType(), SP->getVirtualIndex(), |
| SP->getThisAdjustment(), SP->getFlags() & SupportedDIFlags, |
| SP->getSPFlags() & SupportedDISPFlags, SP->getUnit(), |
| SP->getTemplateParams(), SP->getDeclaration(), SP->getRetainedNodes(), |
| SP->getThrownTypes(), SP->getAnnotations(), SP->getTargetFuncName(), |
| SP->getKeyInstructionsEnabled()); |
| |
| Res.MDReplace.insert({SP, NewSP}); |
| |
| if (auto It = Res.MDExtra.find(SP); It != Res.MDExtra.end()) { |
| const Metadata *FunctionMD = It->second; |
| Res.MDExtra.erase(It); |
| Res.MDExtra.insert({NewSP, FunctionMD}); |
| } |
| } |
| |
| if (SP->getUnit()) |
| CUSubprograms.push_back( |
| {SP->getUnit(), static_cast<const Metadata *>(SP)}); |
| } |
| |
| std::stable_sort( |
| CUSubprograms.begin(), CUSubprograms.end(), [](auto &&A, auto &&B) { |
| return std::less<const DICompileUnit *>()(A.first, B.first); |
| }); |
| for (auto It = CUSubprograms.begin(), End = CUSubprograms.end(); It != End;) { |
| const DICompileUnit *CU = It->first; |
| const DICompileUnit *NewCU = |
| cast<DICompileUnit>(Res.MDReplace.lookup_or(CU, CU)); |
| SmallVector<Metadata *, 16> Subprograms; |
| do { |
| Subprograms.push_back(const_cast<Metadata *>(It->second)); |
| } while (++It != End && It->first == CU); |
| const auto *SubprogramsMD = MDTuple::get(M.getContext(), Subprograms); |
| Res.MDExtra.insert({NewCU, SubprogramsMD}); |
| } |
| |
| for (const GlobalVariable &GV : M.globals()) { |
| SmallVector<DIGlobalVariableExpression *, 4> GVEs; |
| GV.getDebugInfo(GVEs); |
| for (DIGlobalVariableExpression *GVE : GVEs) { |
| if (GVE->getExpression()->getNumElements()) |
| continue; |
| auto [It, Inserted] = Res.MDExtra.insert( |
| {GVE->getVariable(), |
| ValueAsMetadata::get(const_cast<GlobalVariable *>(&GV))}); |
| if (!Inserted) |
| It->second = nullptr; |
| } |
| } |
| |
| for (DIGlobalVariableExpression *GVE : DIF.global_variables()) |
| Res.MDReplace.insert({GVE, GVE->getVariable()}); |
| |
| for (DIScope *S : DIF.scopes()) { |
| if (auto *CB = dyn_cast<DICommonBlock>(S)) { |
| const Metadata *Scope = CB->getScope(); |
| Scope = Res.MDReplace.lookup_or(Scope, Scope); |
| Res.MDReplace.insert({CB, Scope}); |
| } |
| } |
| |
| for (DIType *T : DIF.types()) { |
| if (auto *SR = dyn_cast<DISubrangeType>(T)) { |
| DIType *BT = SR->getBaseType(); |
| if (!BT) |
| BT = DIBasicType::get(SR->getContext(), dwarf::DW_TAG_base_type, |
| SR->getName(), SR->getSizeInBits(), |
| SR->getAlignInBits(), dwarf::DW_ATE_unsigned, |
| SR->getNumExtraInhabitants(), |
| /*DataSizeInBits=*/0, SR->getFlags()); |
| Res.MDReplace.insert({T, BT}); |
| } |
| } |
| |
| return Res; |
| } |
