diff --git a/contrib/llvm-project/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp b/contrib/llvm-project/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp index 7edc44c48bbd..a3bf4be09fbe 100644 --- a/contrib/llvm-project/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp +++ b/contrib/llvm-project/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp @@ -1,1561 +1,1570 @@ //===- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Units ------------===// // // 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 // //===----------------------------------------------------------------------===// // // This file contains support for constructing a dwarf compile unit. // //===----------------------------------------------------------------------===// #include "DwarfCompileUnit.h" #include "AddressPool.h" #include "DwarfExpression.h" #include "llvm/ADT/None.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallString.h" #include "llvm/BinaryFormat/Dwarf.h" #include "llvm/CodeGen/AsmPrinter.h" #include "llvm/CodeGen/DIE.h" #include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/MachineOperand.h" #include "llvm/CodeGen/TargetFrameLowering.h" #include "llvm/CodeGen/TargetRegisterInfo.h" #include "llvm/CodeGen/TargetSubtargetInfo.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/DebugInfo.h" #include "llvm/IR/GlobalVariable.h" #include "llvm/MC/MCSection.h" #include "llvm/MC/MCStreamer.h" #include "llvm/MC/MCSymbol.h" #include "llvm/MC/MCSymbolWasm.h" #include "llvm/MC/MachineLocation.h" #include "llvm/Target/TargetLoweringObjectFile.h" #include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetOptions.h" #include #include #include using namespace llvm; static dwarf::Tag GetCompileUnitType(UnitKind Kind, DwarfDebug *DW) { // According to DWARF Debugging Information Format Version 5, // 3.1.2 Skeleton Compilation Unit Entries: // "When generating a split DWARF object file (see Section 7.3.2 // on page 187), the compilation unit in the .debug_info section // is a "skeleton" compilation unit with the tag DW_TAG_skeleton_unit" if (DW->getDwarfVersion() >= 5 && Kind == UnitKind::Skeleton) return dwarf::DW_TAG_skeleton_unit; return dwarf::DW_TAG_compile_unit; } DwarfCompileUnit::DwarfCompileUnit(unsigned UID, const DICompileUnit *Node, AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU, UnitKind Kind) : DwarfUnit(GetCompileUnitType(Kind, DW), Node, A, DW, DWU), UniqueID(UID) { insertDIE(Node, &getUnitDie()); MacroLabelBegin = Asm->createTempSymbol("cu_macro_begin"); } /// addLabelAddress - Add a dwarf label attribute data and value using /// DW_FORM_addr or DW_FORM_GNU_addr_index. void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Label) { // Don't use the address pool in non-fission or in the skeleton unit itself. if ((!DD->useSplitDwarf() || !Skeleton) && DD->getDwarfVersion() < 5) return addLocalLabelAddress(Die, Attribute, Label); if (Label) DD->addArangeLabel(SymbolCU(this, Label)); bool UseAddrOffsetFormOrExpressions = DD->useAddrOffsetForm() || DD->useAddrOffsetExpressions(); const MCSymbol *Base = nullptr; if (Label->isInSection() && UseAddrOffsetFormOrExpressions) Base = DD->getSectionLabel(&Label->getSection()); if (!Base || Base == Label) { unsigned idx = DD->getAddressPool().getIndex(Label); addAttribute(Die, Attribute, DD->getDwarfVersion() >= 5 ? dwarf::DW_FORM_addrx : dwarf::DW_FORM_GNU_addr_index, DIEInteger(idx)); return; } // Could be extended to work with DWARFv4 Split DWARF if that's important for // someone. In that case DW_FORM_data would be used. assert(DD->getDwarfVersion() >= 5 && "Addr+offset expressions are only valuable when using debug_addr (to " "reduce relocations) available in DWARFv5 or higher"); if (DD->useAddrOffsetExpressions()) { auto *Loc = new (DIEValueAllocator) DIEBlock(); addPoolOpAddress(*Loc, Label); addBlock(Die, Attribute, dwarf::DW_FORM_exprloc, Loc); } else addAttribute(Die, Attribute, dwarf::DW_FORM_LLVM_addrx_offset, new (DIEValueAllocator) DIEAddrOffset( DD->getAddressPool().getIndex(Base), Label, Base)); } void DwarfCompileUnit::addLocalLabelAddress(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Label) { if (Label) DD->addArangeLabel(SymbolCU(this, Label)); if (Label) addAttribute(Die, Attribute, dwarf::DW_FORM_addr, DIELabel(Label)); else addAttribute(Die, Attribute, dwarf::DW_FORM_addr, DIEInteger(0)); } unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) { // If we print assembly, we can't separate .file entries according to // compile units. Thus all files will belong to the default compile unit. // FIXME: add a better feature test than hasRawTextSupport. Even better, // extend .file to support this. unsigned CUID = Asm->OutStreamer->hasRawTextSupport() ? 0 : getUniqueID(); if (!File) return Asm->OutStreamer->emitDwarfFileDirective(0, "", "", None, None, CUID); return Asm->OutStreamer->emitDwarfFileDirective( 0, File->getDirectory(), File->getFilename(), DD->getMD5AsBytes(File), File->getSource(), CUID); } DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE( const DIGlobalVariable *GV, ArrayRef GlobalExprs) { // Check for pre-existence. if (DIE *Die = getDIE(GV)) return Die; assert(GV); auto *GVContext = GV->getScope(); const DIType *GTy = GV->getType(); // Construct the context before querying for the existence of the DIE in // case such construction creates the DIE. auto *CB = GVContext ? dyn_cast(GVContext) : nullptr; DIE *ContextDIE = CB ? getOrCreateCommonBlock(CB, GlobalExprs) : getOrCreateContextDIE(GVContext); // Add to map. DIE *VariableDIE = &createAndAddDIE(GV->getTag(), *ContextDIE, GV); DIScope *DeclContext; if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) { DeclContext = SDMDecl->getScope(); assert(SDMDecl->isStaticMember() && "Expected static member decl"); assert(GV->isDefinition()); // We need the declaration DIE that is in the static member's class. DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(SDMDecl); addDIEEntry(*VariableDIE, dwarf::DW_AT_specification, *VariableSpecDIE); // If the global variable's type is different from the one in the class // member type, assume that it's more specific and also emit it. if (GTy != SDMDecl->getBaseType()) addType(*VariableDIE, GTy); } else { DeclContext = GV->getScope(); // Add name and type. addString(*VariableDIE, dwarf::DW_AT_name, GV->getDisplayName()); if (GTy) addType(*VariableDIE, GTy); // Add scoping info. if (!GV->isLocalToUnit()) addFlag(*VariableDIE, dwarf::DW_AT_external); // Add line number info. addSourceLine(*VariableDIE, GV); } if (!GV->isDefinition()) addFlag(*VariableDIE, dwarf::DW_AT_declaration); else addGlobalName(GV->getName(), *VariableDIE, DeclContext); if (uint32_t AlignInBytes = GV->getAlignInBytes()) addUInt(*VariableDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, AlignInBytes); if (MDTuple *TP = GV->getTemplateParams()) addTemplateParams(*VariableDIE, DINodeArray(TP)); // Add location. addLocationAttribute(VariableDIE, GV, GlobalExprs); return VariableDIE; } void DwarfCompileUnit::addLocationAttribute( DIE *VariableDIE, const DIGlobalVariable *GV, ArrayRef GlobalExprs) { bool addToAccelTable = false; DIELoc *Loc = nullptr; Optional NVPTXAddressSpace; std::unique_ptr DwarfExpr; for (const auto &GE : GlobalExprs) { const GlobalVariable *Global = GE.Var; const DIExpression *Expr = GE.Expr; // For compatibility with DWARF 3 and earlier, // DW_AT_location(DW_OP_constu, X, DW_OP_stack_value) or // DW_AT_location(DW_OP_consts, X, DW_OP_stack_value) becomes // DW_AT_const_value(X). if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) { addToAccelTable = true; addConstantValue( *VariableDIE, DIExpression::SignedOrUnsignedConstant::UnsignedConstant == *Expr->isConstant(), Expr->getElement(1)); break; } // We cannot describe the location of dllimport'd variables: the // computation of their address requires loads from the IAT. if (Global && Global->hasDLLImportStorageClass()) continue; // Nothing to describe without address or constant. if (!Global && (!Expr || !Expr->isConstant())) continue; if (Global && Global->isThreadLocal() && !Asm->getObjFileLowering().supportDebugThreadLocalLocation()) continue; if (!Loc) { addToAccelTable = true; Loc = new (DIEValueAllocator) DIELoc; DwarfExpr = std::make_unique(*Asm, *this, *Loc); } if (Expr) { // According to // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf // cuda-gdb requires DW_AT_address_class for all variables to be able to // correctly interpret address space of the variable address. // Decode DW_OP_constu DW_OP_swap DW_OP_xderef // sequence for the NVPTX + gdb target. unsigned LocalNVPTXAddressSpace; if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) { const DIExpression *NewExpr = DIExpression::extractAddressClass(Expr, LocalNVPTXAddressSpace); if (NewExpr != Expr) { Expr = NewExpr; NVPTXAddressSpace = LocalNVPTXAddressSpace; } } DwarfExpr->addFragmentOffset(Expr); } if (Global) { const MCSymbol *Sym = Asm->getSymbol(Global); if (Global->isThreadLocal()) { if (Asm->TM.useEmulatedTLS()) { // TODO: add debug info for emulated thread local mode. } else { // FIXME: Make this work with -gsplit-dwarf. unsigned PointerSize = Asm->getDataLayout().getPointerSize(); assert((PointerSize == 4 || PointerSize == 8) && "Add support for other sizes if necessary"); // Based on GCC's support for TLS: if (!DD->useSplitDwarf()) { // 1) Start with a constNu of the appropriate pointer size addUInt(*Loc, dwarf::DW_FORM_data1, PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u); // 2) containing the (relocated) offset of the TLS variable // within the module's TLS block. addExpr(*Loc, PointerSize == 4 ? dwarf::DW_FORM_data4 : dwarf::DW_FORM_data8, Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym)); } else { addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index); addUInt(*Loc, dwarf::DW_FORM_udata, DD->getAddressPool().getIndex(Sym, /* TLS */ true)); } // 3) followed by an OP to make the debugger do a TLS lookup. addUInt(*Loc, dwarf::DW_FORM_data1, DD->useGNUTLSOpcode() ? dwarf::DW_OP_GNU_push_tls_address : dwarf::DW_OP_form_tls_address); } } else { DD->addArangeLabel(SymbolCU(this, Sym)); addOpAddress(*Loc, Sym); } } // Global variables attached to symbols are memory locations. // It would be better if this were unconditional, but malformed input that // mixes non-fragments and fragments for the same variable is too expensive // to detect in the verifier. if (DwarfExpr->isUnknownLocation()) DwarfExpr->setMemoryLocationKind(); DwarfExpr->addExpression(Expr); } if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) { // According to // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf // cuda-gdb requires DW_AT_address_class for all variables to be able to // correctly interpret address space of the variable address. const unsigned NVPTX_ADDR_global_space = 5; addUInt(*VariableDIE, dwarf::DW_AT_address_class, dwarf::DW_FORM_data1, NVPTXAddressSpace ? *NVPTXAddressSpace : NVPTX_ADDR_global_space); } if (Loc) addBlock(*VariableDIE, dwarf::DW_AT_location, DwarfExpr->finalize()); if (DD->useAllLinkageNames()) addLinkageName(*VariableDIE, GV->getLinkageName()); if (addToAccelTable) { DD->addAccelName(*CUNode, GV->getName(), *VariableDIE); // If the linkage name is different than the name, go ahead and output // that as well into the name table. if (GV->getLinkageName() != "" && GV->getName() != GV->getLinkageName() && DD->useAllLinkageNames()) DD->addAccelName(*CUNode, GV->getLinkageName(), *VariableDIE); } } DIE *DwarfCompileUnit::getOrCreateCommonBlock( const DICommonBlock *CB, ArrayRef GlobalExprs) { // Construct the context before querying for the existence of the DIE in case // such construction creates the DIE. DIE *ContextDIE = getOrCreateContextDIE(CB->getScope()); if (DIE *NDie = getDIE(CB)) return NDie; DIE &NDie = createAndAddDIE(dwarf::DW_TAG_common_block, *ContextDIE, CB); StringRef Name = CB->getName().empty() ? "_BLNK_" : CB->getName(); addString(NDie, dwarf::DW_AT_name, Name); addGlobalName(Name, NDie, CB->getScope()); if (CB->getFile()) addSourceLine(NDie, CB->getLineNo(), CB->getFile()); if (DIGlobalVariable *V = CB->getDecl()) getCU().addLocationAttribute(&NDie, V, GlobalExprs); return &NDie; } void DwarfCompileUnit::addRange(RangeSpan Range) { DD->insertSectionLabel(Range.Begin); bool SameAsPrevCU = this == DD->getPrevCU(); DD->setPrevCU(this); // If we have no current ranges just add the range and return, otherwise, // check the current section and CU against the previous section and CU we // emitted into and the subprogram was contained within. If these are the // same then extend our current range, otherwise add this as a new range. if (CURanges.empty() || !SameAsPrevCU || (&CURanges.back().End->getSection() != &Range.End->getSection())) { CURanges.push_back(Range); return; } CURanges.back().End = Range.End; } void DwarfCompileUnit::initStmtList() { if (CUNode->isDebugDirectivesOnly()) return; const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); if (DD->useSectionsAsReferences()) { LineTableStartSym = TLOF.getDwarfLineSection()->getBeginSymbol(); } else { LineTableStartSym = Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID()); } // DW_AT_stmt_list is a offset of line number information for this // compile unit in debug_line section. For split dwarf this is // left in the skeleton CU and so not included. // The line table entries are not always emitted in assembly, so it // is not okay to use line_table_start here. addSectionLabel(getUnitDie(), dwarf::DW_AT_stmt_list, LineTableStartSym, TLOF.getDwarfLineSection()->getBeginSymbol()); } void DwarfCompileUnit::applyStmtList(DIE &D) { const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); addSectionLabel(D, dwarf::DW_AT_stmt_list, LineTableStartSym, TLOF.getDwarfLineSection()->getBeginSymbol()); } void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin, const MCSymbol *End) { assert(Begin && "Begin label should not be null!"); assert(End && "End label should not be null!"); assert(Begin->isDefined() && "Invalid starting label"); assert(End->isDefined() && "Invalid end label"); addLabelAddress(D, dwarf::DW_AT_low_pc, Begin); if (DD->getDwarfVersion() < 4) addLabelAddress(D, dwarf::DW_AT_high_pc, End); else addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin); } // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc // and DW_AT_high_pc attributes. If there are global variables in this // scope then create and insert DIEs for these variables. DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) { DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes()); SmallVector BB_List; // If basic block sections are on, ranges for each basic block section has // to be emitted separately. for (const auto &R : Asm->MBBSectionRanges) BB_List.push_back({R.second.BeginLabel, R.second.EndLabel}); attachRangesOrLowHighPC(*SPDie, BB_List); if (DD->useAppleExtensionAttributes() && !DD->getCurrentFunction()->getTarget().Options.DisableFramePointerElim( *DD->getCurrentFunction())) addFlag(*SPDie, dwarf::DW_AT_APPLE_omit_frame_ptr); // Only include DW_AT_frame_base in full debug info if (!includeMinimalInlineScopes()) { const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering(); TargetFrameLowering::DwarfFrameBase FrameBase = TFI->getDwarfFrameBase(*Asm->MF); switch (FrameBase.Kind) { case TargetFrameLowering::DwarfFrameBase::Register: { if (Register::isPhysicalRegister(FrameBase.Location.Reg)) { MachineLocation Location(FrameBase.Location.Reg); addAddress(*SPDie, dwarf::DW_AT_frame_base, Location); } break; } case TargetFrameLowering::DwarfFrameBase::CFA: { DIELoc *Loc = new (DIEValueAllocator) DIELoc; addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_call_frame_cfa); addBlock(*SPDie, dwarf::DW_AT_frame_base, Loc); break; } case TargetFrameLowering::DwarfFrameBase::WasmFrameBase: { // FIXME: duplicated from Target/WebAssembly/WebAssembly.h // don't want to depend on target specific headers in this code? const unsigned TI_GLOBAL_RELOC = 3; if (FrameBase.Location.WasmLoc.Kind == TI_GLOBAL_RELOC) { // These need to be relocatable. assert(FrameBase.Location.WasmLoc.Index == 0); // Only SP so far. auto SPSym = cast( Asm->GetExternalSymbolSymbol("__stack_pointer")); // FIXME: this repeats what WebAssemblyMCInstLower:: // GetExternalSymbolSymbol does, since if there's no code that // refers to this symbol, we have to set it here. SPSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL); SPSym->setGlobalType(wasm::WasmGlobalType{ uint8_t(Asm->getSubtargetInfo().getTargetTriple().getArch() == Triple::wasm64 ? wasm::WASM_TYPE_I64 : wasm::WASM_TYPE_I32), true}); DIELoc *Loc = new (DIEValueAllocator) DIELoc; addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_WASM_location); addSInt(*Loc, dwarf::DW_FORM_sdata, TI_GLOBAL_RELOC); if (!isDwoUnit()) { addLabel(*Loc, dwarf::DW_FORM_data4, SPSym); DD->addArangeLabel(SymbolCU(this, SPSym)); } else { // FIXME: when writing dwo, we need to avoid relocations. Probably // the "right" solution is to treat globals the way func and data // symbols are (with entries in .debug_addr). // For now, since we only ever use index 0, this should work as-is. addUInt(*Loc, dwarf::DW_FORM_data4, FrameBase.Location.WasmLoc.Index); } addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value); addBlock(*SPDie, dwarf::DW_AT_frame_base, Loc); } else { DIELoc *Loc = new (DIEValueAllocator) DIELoc; DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); DIExpressionCursor Cursor({}); DwarfExpr.addWasmLocation(FrameBase.Location.WasmLoc.Kind, FrameBase.Location.WasmLoc.Index); DwarfExpr.addExpression(std::move(Cursor)); addBlock(*SPDie, dwarf::DW_AT_frame_base, DwarfExpr.finalize()); } break; } } } // Add name to the name table, we do this here because we're guaranteed // to have concrete versions of our DW_TAG_subprogram nodes. DD->addSubprogramNames(*CUNode, SP, *SPDie); return *SPDie; } // Construct a DIE for this scope. void DwarfCompileUnit::constructScopeDIE( LexicalScope *Scope, SmallVectorImpl &FinalChildren) { if (!Scope || !Scope->getScopeNode()) return; auto *DS = Scope->getScopeNode(); assert((Scope->getInlinedAt() || !isa(DS)) && "Only handle inlined subprograms here, use " "constructSubprogramScopeDIE for non-inlined " "subprograms"); SmallVector Children; // We try to create the scope DIE first, then the children DIEs. This will // avoid creating un-used children then removing them later when we find out // the scope DIE is null. DIE *ScopeDIE; if (Scope->getParent() && isa(DS)) { ScopeDIE = constructInlinedScopeDIE(Scope); if (!ScopeDIE) return; // We create children when the scope DIE is not null. createScopeChildrenDIE(Scope, Children); } else { // Early exit when we know the scope DIE is going to be null. if (DD->isLexicalScopeDIENull(Scope)) return; bool HasNonScopeChildren = false; // We create children here when we know the scope DIE is not going to be // null and the children will be added to the scope DIE. createScopeChildrenDIE(Scope, Children, &HasNonScopeChildren); // If there are only other scopes as children, put them directly in the // parent instead, as this scope would serve no purpose. if (!HasNonScopeChildren) { FinalChildren.insert(FinalChildren.end(), std::make_move_iterator(Children.begin()), std::make_move_iterator(Children.end())); return; } ScopeDIE = constructLexicalScopeDIE(Scope); assert(ScopeDIE && "Scope DIE should not be null."); } // Add children for (auto &I : Children) ScopeDIE->addChild(std::move(I)); FinalChildren.push_back(std::move(ScopeDIE)); } void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE, SmallVector Range) { HasRangeLists = true; // Add the range list to the set of ranges to be emitted. auto IndexAndList = (DD->getDwarfVersion() < 5 && Skeleton ? Skeleton->DU : DU) ->addRange(*(Skeleton ? Skeleton : this), std::move(Range)); uint32_t Index = IndexAndList.first; auto &List = *IndexAndList.second; // Under fission, ranges are specified by constant offsets relative to the // CU's DW_AT_GNU_ranges_base. // FIXME: For DWARF v5, do not generate the DW_AT_ranges attribute under // fission until we support the forms using the .debug_addr section // (DW_RLE_startx_endx etc.). if (DD->getDwarfVersion() >= 5) addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_rnglistx, Index); else { const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); const MCSymbol *RangeSectionSym = TLOF.getDwarfRangesSection()->getBeginSymbol(); if (isDwoUnit()) addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, List.Label, RangeSectionSym); else addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.Label, RangeSectionSym); } } void DwarfCompileUnit::attachRangesOrLowHighPC( DIE &Die, SmallVector Ranges) { assert(!Ranges.empty()); if (!DD->useRangesSection() || (Ranges.size() == 1 && (!DD->alwaysUseRanges() || DD->getSectionLabel(&Ranges.front().Begin->getSection()) == Ranges.front().Begin))) { const RangeSpan &Front = Ranges.front(); const RangeSpan &Back = Ranges.back(); attachLowHighPC(Die, Front.Begin, Back.End); } else addScopeRangeList(Die, std::move(Ranges)); } void DwarfCompileUnit::attachRangesOrLowHighPC( DIE &Die, const SmallVectorImpl &Ranges) { SmallVector List; List.reserve(Ranges.size()); for (const InsnRange &R : Ranges) { auto *BeginLabel = DD->getLabelBeforeInsn(R.first); auto *EndLabel = DD->getLabelAfterInsn(R.second); const auto *BeginMBB = R.first->getParent(); const auto *EndMBB = R.second->getParent(); const auto *MBB = BeginMBB; // Basic block sections allows basic block subsets to be placed in unique // sections. For each section, the begin and end label must be added to the // list. If there is more than one range, debug ranges must be used. // Otherwise, low/high PC can be used. // FIXME: Debug Info Emission depends on block order and this assumes that // the order of blocks will be frozen beyond this point. do { if (MBB->sameSection(EndMBB) || MBB->isEndSection()) { auto MBBSectionRange = Asm->MBBSectionRanges[MBB->getSectionIDNum()]; List.push_back( {MBB->sameSection(BeginMBB) ? BeginLabel : MBBSectionRange.BeginLabel, MBB->sameSection(EndMBB) ? EndLabel : MBBSectionRange.EndLabel}); } if (MBB->sameSection(EndMBB)) break; MBB = MBB->getNextNode(); } while (true); } attachRangesOrLowHighPC(Die, std::move(List)); } // This scope represents inlined body of a function. Construct DIE to // represent this concrete inlined copy of the function. DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) { assert(Scope->getScopeNode()); auto *DS = Scope->getScopeNode(); auto *InlinedSP = getDISubprogram(DS); // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram // was inlined from another compile unit. DIE *OriginDIE = getAbstractSPDies()[InlinedSP]; assert(OriginDIE && "Unable to find original DIE for an inlined subprogram."); auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_inlined_subroutine); addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE); attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges()); // Add the call site information to the DIE. const DILocation *IA = Scope->getInlinedAt(); addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None, getOrCreateSourceID(IA->getFile())); addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, IA->getLine()); if (IA->getColumn()) addUInt(*ScopeDIE, dwarf::DW_AT_call_column, None, IA->getColumn()); if (IA->getDiscriminator() && DD->getDwarfVersion() >= 4) addUInt(*ScopeDIE, dwarf::DW_AT_GNU_discriminator, None, IA->getDiscriminator()); // Add name to the name table, we do this here because we're guaranteed // to have concrete versions of our DW_TAG_inlined_subprogram nodes. DD->addSubprogramNames(*CUNode, InlinedSP, *ScopeDIE); return ScopeDIE; } // Construct new DW_TAG_lexical_block for this scope and attach // DW_AT_low_pc/DW_AT_high_pc labels. DIE *DwarfCompileUnit::constructLexicalScopeDIE(LexicalScope *Scope) { if (DD->isLexicalScopeDIENull(Scope)) return nullptr; auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_lexical_block); if (Scope->isAbstractScope()) return ScopeDIE; attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges()); return ScopeDIE; } /// constructVariableDIE - Construct a DIE for the given DbgVariable. DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, bool Abstract) { auto D = constructVariableDIEImpl(DV, Abstract); DV.setDIE(*D); return D; } DIE *DwarfCompileUnit::constructLabelDIE(DbgLabel &DL, const LexicalScope &Scope) { auto LabelDie = DIE::get(DIEValueAllocator, DL.getTag()); insertDIE(DL.getLabel(), LabelDie); DL.setDIE(*LabelDie); if (Scope.isAbstractScope()) applyLabelAttributes(DL, *LabelDie); return LabelDie; } DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV, bool Abstract) { // Define variable debug information entry. auto VariableDie = DIE::get(DIEValueAllocator, DV.getTag()); insertDIE(DV.getVariable(), VariableDie); if (Abstract) { applyVariableAttributes(DV, *VariableDie); return VariableDie; } // Add variable address. unsigned Index = DV.getDebugLocListIndex(); if (Index != ~0U) { addLocationList(*VariableDie, dwarf::DW_AT_location, Index); auto TagOffset = DV.getDebugLocListTagOffset(); if (TagOffset) addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1, *TagOffset); return VariableDie; } // Check if variable has a single location description. if (auto *DVal = DV.getValueLoc()) { if (!DVal->isVariadic()) { const DbgValueLocEntry *Entry = DVal->getLocEntries().begin(); if (Entry->isLocation()) { addVariableAddress(DV, *VariableDie, Entry->getLoc()); } else if (Entry->isInt()) { auto *Expr = DV.getSingleExpression(); if (Expr && Expr->getNumElements()) { DIELoc *Loc = new (DIEValueAllocator) DIELoc; DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); // If there is an expression, emit raw unsigned bytes. DwarfExpr.addFragmentOffset(Expr); DwarfExpr.addUnsignedConstant(Entry->getInt()); DwarfExpr.addExpression(Expr); addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize()); if (DwarfExpr.TagOffset) addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1, *DwarfExpr.TagOffset); } else addConstantValue(*VariableDie, Entry->getInt(), DV.getType()); } else if (Entry->isConstantFP()) { addConstantFPValue(*VariableDie, Entry->getConstantFP()); } else if (Entry->isConstantInt()) { addConstantValue(*VariableDie, Entry->getConstantInt(), DV.getType()); } else if (Entry->isTargetIndexLocation()) { DIELoc *Loc = new (DIEValueAllocator) DIELoc; DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); const DIBasicType *BT = dyn_cast( static_cast(DV.getVariable()->getType())); DwarfDebug::emitDebugLocValue(*Asm, BT, *DVal, DwarfExpr); addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize()); } return VariableDie; } // If any of the location entries are registers with the value 0, then the // location is undefined. if (any_of(DVal->getLocEntries(), [](const DbgValueLocEntry &Entry) { return Entry.isLocation() && !Entry.getLoc().getReg(); })) return VariableDie; const DIExpression *Expr = DV.getSingleExpression(); assert(Expr && "Variadic Debug Value must have an Expression."); DIELoc *Loc = new (DIEValueAllocator) DIELoc; DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); DwarfExpr.addFragmentOffset(Expr); DIExpressionCursor Cursor(Expr); const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo(); auto AddEntry = [&](const DbgValueLocEntry &Entry, - DIExpressionCursor &Cursor) { + DIExpressionCursor &Cursor) { if (Entry.isLocation()) { if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Entry.getLoc().getReg())) return false; } else if (Entry.isInt()) { // If there is an expression, emit raw unsigned bytes. DwarfExpr.addUnsignedConstant(Entry.getInt()); } else if (Entry.isConstantFP()) { + // DwarfExpression does not support arguments wider than 64 bits + // (see PR52584). + // TODO: Consider chunking expressions containing overly wide + // arguments into separate pointer-sized fragment expressions. APInt RawBytes = Entry.getConstantFP()->getValueAPF().bitcastToAPInt(); - DwarfExpr.addUnsignedConstant(RawBytes); + if (RawBytes.getBitWidth() > 64) + return false; + DwarfExpr.addUnsignedConstant(RawBytes.getZExtValue()); } else if (Entry.isConstantInt()) { APInt RawBytes = Entry.getConstantInt()->getValue(); - DwarfExpr.addUnsignedConstant(RawBytes); + if (RawBytes.getBitWidth() > 64) + return false; + DwarfExpr.addUnsignedConstant(RawBytes.getZExtValue()); } else if (Entry.isTargetIndexLocation()) { TargetIndexLocation Loc = Entry.getTargetIndexLocation(); // TODO TargetIndexLocation is a target-independent. Currently only the // WebAssembly-specific encoding is supported. assert(Asm->TM.getTargetTriple().isWasm()); DwarfExpr.addWasmLocation(Loc.Index, static_cast(Loc.Offset)); } else { llvm_unreachable("Unsupported Entry type."); } return true; }; - DwarfExpr.addExpression( - std::move(Cursor), - [&](unsigned Idx, DIExpressionCursor &Cursor) -> bool { - return AddEntry(DVal->getLocEntries()[Idx], Cursor); - }); + if (!DwarfExpr.addExpression( + std::move(Cursor), + [&](unsigned Idx, DIExpressionCursor &Cursor) -> bool { + return AddEntry(DVal->getLocEntries()[Idx], Cursor); + })) + return VariableDie; // Now attach the location information to the DIE. addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize()); if (DwarfExpr.TagOffset) addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1, *DwarfExpr.TagOffset); return VariableDie; } // .. else use frame index. if (!DV.hasFrameIndexExprs()) return VariableDie; Optional NVPTXAddressSpace; DIELoc *Loc = new (DIEValueAllocator) DIELoc; DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); for (auto &Fragment : DV.getFrameIndexExprs()) { Register FrameReg; const DIExpression *Expr = Fragment.Expr; const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering(); StackOffset Offset = TFI->getFrameIndexReference(*Asm->MF, Fragment.FI, FrameReg); DwarfExpr.addFragmentOffset(Expr); auto *TRI = Asm->MF->getSubtarget().getRegisterInfo(); SmallVector Ops; TRI->getOffsetOpcodes(Offset, Ops); // According to // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf // cuda-gdb requires DW_AT_address_class for all variables to be able to // correctly interpret address space of the variable address. // Decode DW_OP_constu DW_OP_swap DW_OP_xderef // sequence for the NVPTX + gdb target. unsigned LocalNVPTXAddressSpace; if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) { const DIExpression *NewExpr = DIExpression::extractAddressClass(Expr, LocalNVPTXAddressSpace); if (NewExpr != Expr) { Expr = NewExpr; NVPTXAddressSpace = LocalNVPTXAddressSpace; } } if (Expr) Ops.append(Expr->elements_begin(), Expr->elements_end()); DIExpressionCursor Cursor(Ops); DwarfExpr.setMemoryLocationKind(); if (const MCSymbol *FrameSymbol = Asm->getFunctionFrameSymbol()) addOpAddress(*Loc, FrameSymbol); else DwarfExpr.addMachineRegExpression( *Asm->MF->getSubtarget().getRegisterInfo(), Cursor, FrameReg); DwarfExpr.addExpression(std::move(Cursor)); } if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) { // According to // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf // cuda-gdb requires DW_AT_address_class for all variables to be able to // correctly interpret address space of the variable address. const unsigned NVPTX_ADDR_local_space = 6; addUInt(*VariableDie, dwarf::DW_AT_address_class, dwarf::DW_FORM_data1, NVPTXAddressSpace ? *NVPTXAddressSpace : NVPTX_ADDR_local_space); } addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize()); if (DwarfExpr.TagOffset) addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1, *DwarfExpr.TagOffset); return VariableDie; } DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, const LexicalScope &Scope, DIE *&ObjectPointer) { auto Var = constructVariableDIE(DV, Scope.isAbstractScope()); if (DV.isObjectPointer()) ObjectPointer = Var; return Var; } /// Return all DIVariables that appear in count: expressions. static SmallVector dependencies(DbgVariable *Var) { SmallVector Result; auto *Array = dyn_cast(Var->getType()); if (!Array || Array->getTag() != dwarf::DW_TAG_array_type) return Result; if (auto *DLVar = Array->getDataLocation()) Result.push_back(DLVar); if (auto *AsVar = Array->getAssociated()) Result.push_back(AsVar); if (auto *AlVar = Array->getAllocated()) Result.push_back(AlVar); for (auto *El : Array->getElements()) { if (auto *Subrange = dyn_cast(El)) { if (auto Count = Subrange->getCount()) if (auto *Dependency = Count.dyn_cast()) Result.push_back(Dependency); if (auto LB = Subrange->getLowerBound()) if (auto *Dependency = LB.dyn_cast()) Result.push_back(Dependency); if (auto UB = Subrange->getUpperBound()) if (auto *Dependency = UB.dyn_cast()) Result.push_back(Dependency); if (auto ST = Subrange->getStride()) if (auto *Dependency = ST.dyn_cast()) Result.push_back(Dependency); } else if (auto *GenericSubrange = dyn_cast(El)) { if (auto Count = GenericSubrange->getCount()) if (auto *Dependency = Count.dyn_cast()) Result.push_back(Dependency); if (auto LB = GenericSubrange->getLowerBound()) if (auto *Dependency = LB.dyn_cast()) Result.push_back(Dependency); if (auto UB = GenericSubrange->getUpperBound()) if (auto *Dependency = UB.dyn_cast()) Result.push_back(Dependency); if (auto ST = GenericSubrange->getStride()) if (auto *Dependency = ST.dyn_cast()) Result.push_back(Dependency); } } return Result; } /// Sort local variables so that variables appearing inside of helper /// expressions come first. static SmallVector sortLocalVars(SmallVectorImpl &Input) { SmallVector Result; SmallVector, 8> WorkList; // Map back from a DIVariable to its containing DbgVariable. SmallDenseMap DbgVar; // Set of DbgVariables in Result. SmallDenseSet Visited; // For cycle detection. SmallDenseSet Visiting; // Initialize the worklist and the DIVariable lookup table. for (auto Var : reverse(Input)) { DbgVar.insert({Var->getVariable(), Var}); WorkList.push_back({Var, 0}); } // Perform a stable topological sort by doing a DFS. while (!WorkList.empty()) { auto Item = WorkList.back(); DbgVariable *Var = Item.getPointer(); bool visitedAllDependencies = Item.getInt(); WorkList.pop_back(); // Dependency is in a different lexical scope or a global. if (!Var) continue; // Already handled. if (Visited.count(Var)) continue; // Add to Result if all dependencies are visited. if (visitedAllDependencies) { Visited.insert(Var); Result.push_back(Var); continue; } // Detect cycles. auto Res = Visiting.insert(Var); if (!Res.second) { assert(false && "dependency cycle in local variables"); return Result; } // Push dependencies and this node onto the worklist, so that this node is // visited again after all of its dependencies are handled. WorkList.push_back({Var, 1}); for (auto *Dependency : dependencies(Var)) { auto Dep = dyn_cast_or_null(Dependency); WorkList.push_back({DbgVar[Dep], 0}); } } return Result; } DIE *DwarfCompileUnit::createScopeChildrenDIE(LexicalScope *Scope, SmallVectorImpl &Children, bool *HasNonScopeChildren) { assert(Children.empty()); DIE *ObjectPointer = nullptr; // Emit function arguments (order is significant). auto Vars = DU->getScopeVariables().lookup(Scope); for (auto &DV : Vars.Args) Children.push_back(constructVariableDIE(*DV.second, *Scope, ObjectPointer)); // Emit local variables. auto Locals = sortLocalVars(Vars.Locals); for (DbgVariable *DV : Locals) Children.push_back(constructVariableDIE(*DV, *Scope, ObjectPointer)); // Skip imported directives in gmlt-like data. if (!includeMinimalInlineScopes()) { // There is no need to emit empty lexical block DIE. for (const auto *IE : ImportedEntities[Scope->getScopeNode()]) Children.push_back( constructImportedEntityDIE(cast(IE))); } if (HasNonScopeChildren) *HasNonScopeChildren = !Children.empty(); for (DbgLabel *DL : DU->getScopeLabels().lookup(Scope)) Children.push_back(constructLabelDIE(*DL, *Scope)); for (LexicalScope *LS : Scope->getChildren()) constructScopeDIE(LS, Children); return ObjectPointer; } DIE &DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub, LexicalScope *Scope) { DIE &ScopeDIE = updateSubprogramScopeDIE(Sub); if (Scope) { assert(!Scope->getInlinedAt()); assert(!Scope->isAbstractScope()); // Collect lexical scope children first. // ObjectPointer might be a local (non-argument) local variable if it's a // block's synthetic this pointer. if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE)) addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer); } // If this is a variadic function, add an unspecified parameter. DITypeRefArray FnArgs = Sub->getType()->getTypeArray(); // If we have a single element of null, it is a function that returns void. // If we have more than one elements and the last one is null, it is a // variadic function. if (FnArgs.size() > 1 && !FnArgs[FnArgs.size() - 1] && !includeMinimalInlineScopes()) ScopeDIE.addChild( DIE::get(DIEValueAllocator, dwarf::DW_TAG_unspecified_parameters)); return ScopeDIE; } DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope, DIE &ScopeDIE) { // We create children when the scope DIE is not null. SmallVector Children; DIE *ObjectPointer = createScopeChildrenDIE(Scope, Children); // Add children for (auto &I : Children) ScopeDIE.addChild(std::move(I)); return ObjectPointer; } void DwarfCompileUnit::constructAbstractSubprogramScopeDIE( LexicalScope *Scope) { DIE *&AbsDef = getAbstractSPDies()[Scope->getScopeNode()]; if (AbsDef) return; auto *SP = cast(Scope->getScopeNode()); DIE *ContextDIE; DwarfCompileUnit *ContextCU = this; if (includeMinimalInlineScopes()) ContextDIE = &getUnitDie(); // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with // the important distinction that the debug node is not associated with the // DIE (since the debug node will be associated with the concrete DIE, if // any). It could be refactored to some common utility function. else if (auto *SPDecl = SP->getDeclaration()) { ContextDIE = &getUnitDie(); getOrCreateSubprogramDIE(SPDecl); } else { ContextDIE = getOrCreateContextDIE(SP->getScope()); // The scope may be shared with a subprogram that has already been // constructed in another CU, in which case we need to construct this // subprogram in the same CU. ContextCU = DD->lookupCU(ContextDIE->getUnitDie()); } // Passing null as the associated node because the abstract definition // shouldn't be found by lookup. AbsDef = &ContextCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, nullptr); ContextCU->applySubprogramAttributesToDefinition(SP, *AbsDef); if (!ContextCU->includeMinimalInlineScopes()) ContextCU->addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined); if (DIE *ObjectPointer = ContextCU->createAndAddScopeChildren(Scope, *AbsDef)) ContextCU->addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer); } bool DwarfCompileUnit::useGNUAnalogForDwarf5Feature() const { return DD->getDwarfVersion() == 4 && !DD->tuneForLLDB(); } dwarf::Tag DwarfCompileUnit::getDwarf5OrGNUTag(dwarf::Tag Tag) const { if (!useGNUAnalogForDwarf5Feature()) return Tag; switch (Tag) { case dwarf::DW_TAG_call_site: return dwarf::DW_TAG_GNU_call_site; case dwarf::DW_TAG_call_site_parameter: return dwarf::DW_TAG_GNU_call_site_parameter; default: llvm_unreachable("DWARF5 tag with no GNU analog"); } } dwarf::Attribute DwarfCompileUnit::getDwarf5OrGNUAttr(dwarf::Attribute Attr) const { if (!useGNUAnalogForDwarf5Feature()) return Attr; switch (Attr) { case dwarf::DW_AT_call_all_calls: return dwarf::DW_AT_GNU_all_call_sites; case dwarf::DW_AT_call_target: return dwarf::DW_AT_GNU_call_site_target; case dwarf::DW_AT_call_origin: return dwarf::DW_AT_abstract_origin; case dwarf::DW_AT_call_return_pc: return dwarf::DW_AT_low_pc; case dwarf::DW_AT_call_value: return dwarf::DW_AT_GNU_call_site_value; case dwarf::DW_AT_call_tail_call: return dwarf::DW_AT_GNU_tail_call; default: llvm_unreachable("DWARF5 attribute with no GNU analog"); } } dwarf::LocationAtom DwarfCompileUnit::getDwarf5OrGNULocationAtom(dwarf::LocationAtom Loc) const { if (!useGNUAnalogForDwarf5Feature()) return Loc; switch (Loc) { case dwarf::DW_OP_entry_value: return dwarf::DW_OP_GNU_entry_value; default: llvm_unreachable("DWARF5 location atom with no GNU analog"); } } DIE &DwarfCompileUnit::constructCallSiteEntryDIE(DIE &ScopeDIE, const DISubprogram *CalleeSP, bool IsTail, const MCSymbol *PCAddr, const MCSymbol *CallAddr, unsigned CallReg) { // Insert a call site entry DIE within ScopeDIE. DIE &CallSiteDIE = createAndAddDIE(getDwarf5OrGNUTag(dwarf::DW_TAG_call_site), ScopeDIE, nullptr); if (CallReg) { // Indirect call. addAddress(CallSiteDIE, getDwarf5OrGNUAttr(dwarf::DW_AT_call_target), MachineLocation(CallReg)); } else { DIE *CalleeDIE = getOrCreateSubprogramDIE(CalleeSP); assert(CalleeDIE && "Could not create DIE for call site entry origin"); addDIEEntry(CallSiteDIE, getDwarf5OrGNUAttr(dwarf::DW_AT_call_origin), *CalleeDIE); } if (IsTail) { // Attach DW_AT_call_tail_call to tail calls for standards compliance. addFlag(CallSiteDIE, getDwarf5OrGNUAttr(dwarf::DW_AT_call_tail_call)); // Attach the address of the branch instruction to allow the debugger to // show where the tail call occurred. This attribute has no GNU analog. // // GDB works backwards from non-standard usage of DW_AT_low_pc (in DWARF4 // mode -- equivalently, in DWARF5 mode, DW_AT_call_return_pc) at tail-call // site entries to figure out the PC of tail-calling branch instructions. // This means it doesn't need the compiler to emit DW_AT_call_pc, so we // don't emit it here. // // There's no need to tie non-GDB debuggers to this non-standardness, as it // adds unnecessary complexity to the debugger. For non-GDB debuggers, emit // the standard DW_AT_call_pc info. if (!useGNUAnalogForDwarf5Feature()) addLabelAddress(CallSiteDIE, dwarf::DW_AT_call_pc, CallAddr); } // Attach the return PC to allow the debugger to disambiguate call paths // from one function to another. // // The return PC is only really needed when the call /isn't/ a tail call, but // GDB expects it in DWARF4 mode, even for tail calls (see the comment above // the DW_AT_call_pc emission logic for an explanation). if (!IsTail || useGNUAnalogForDwarf5Feature()) { assert(PCAddr && "Missing return PC information for a call"); addLabelAddress(CallSiteDIE, getDwarf5OrGNUAttr(dwarf::DW_AT_call_return_pc), PCAddr); } return CallSiteDIE; } void DwarfCompileUnit::constructCallSiteParmEntryDIEs( DIE &CallSiteDIE, SmallVector &Params) { for (const auto &Param : Params) { unsigned Register = Param.getRegister(); auto CallSiteDieParam = DIE::get(DIEValueAllocator, getDwarf5OrGNUTag(dwarf::DW_TAG_call_site_parameter)); insertDIE(CallSiteDieParam); addAddress(*CallSiteDieParam, dwarf::DW_AT_location, MachineLocation(Register)); DIELoc *Loc = new (DIEValueAllocator) DIELoc; DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); DwarfExpr.setCallSiteParamValueFlag(); DwarfDebug::emitDebugLocValue(*Asm, nullptr, Param.getValue(), DwarfExpr); addBlock(*CallSiteDieParam, getDwarf5OrGNUAttr(dwarf::DW_AT_call_value), DwarfExpr.finalize()); CallSiteDIE.addChild(CallSiteDieParam); } } DIE *DwarfCompileUnit::constructImportedEntityDIE( const DIImportedEntity *Module) { DIE *IMDie = DIE::get(DIEValueAllocator, (dwarf::Tag)Module->getTag()); insertDIE(Module, IMDie); DIE *EntityDie; auto *Entity = Module->getEntity(); if (auto *NS = dyn_cast(Entity)) EntityDie = getOrCreateNameSpace(NS); else if (auto *M = dyn_cast(Entity)) EntityDie = getOrCreateModule(M); else if (auto *SP = dyn_cast(Entity)) EntityDie = getOrCreateSubprogramDIE(SP); else if (auto *T = dyn_cast(Entity)) EntityDie = getOrCreateTypeDIE(T); else if (auto *GV = dyn_cast(Entity)) EntityDie = getOrCreateGlobalVariableDIE(GV, {}); else EntityDie = getDIE(Entity); assert(EntityDie); addSourceLine(*IMDie, Module->getLine(), Module->getFile()); addDIEEntry(*IMDie, dwarf::DW_AT_import, *EntityDie); StringRef Name = Module->getName(); if (!Name.empty()) addString(*IMDie, dwarf::DW_AT_name, Name); return IMDie; } void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) { DIE *D = getDIE(SP); if (DIE *AbsSPDIE = getAbstractSPDies().lookup(SP)) { if (D) // If this subprogram has an abstract definition, reference that addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE); } else { assert(D || includeMinimalInlineScopes()); if (D) // And attach the attributes applySubprogramAttributesToDefinition(SP, *D); } } void DwarfCompileUnit::finishEntityDefinition(const DbgEntity *Entity) { DbgEntity *AbsEntity = getExistingAbstractEntity(Entity->getEntity()); auto *Die = Entity->getDIE(); /// Label may be used to generate DW_AT_low_pc, so put it outside /// if/else block. const DbgLabel *Label = nullptr; if (AbsEntity && AbsEntity->getDIE()) { addDIEEntry(*Die, dwarf::DW_AT_abstract_origin, *AbsEntity->getDIE()); Label = dyn_cast(Entity); } else { if (const DbgVariable *Var = dyn_cast(Entity)) applyVariableAttributes(*Var, *Die); else if ((Label = dyn_cast(Entity))) applyLabelAttributes(*Label, *Die); else llvm_unreachable("DbgEntity must be DbgVariable or DbgLabel."); } if (Label) if (const auto *Sym = Label->getSymbol()) addLabelAddress(*Die, dwarf::DW_AT_low_pc, Sym); } DbgEntity *DwarfCompileUnit::getExistingAbstractEntity(const DINode *Node) { auto &AbstractEntities = getAbstractEntities(); auto I = AbstractEntities.find(Node); if (I != AbstractEntities.end()) return I->second.get(); return nullptr; } void DwarfCompileUnit::createAbstractEntity(const DINode *Node, LexicalScope *Scope) { assert(Scope && Scope->isAbstractScope()); auto &Entity = getAbstractEntities()[Node]; if (isa(Node)) { Entity = std::make_unique( cast(Node), nullptr /* IA */);; DU->addScopeVariable(Scope, cast(Entity.get())); } else if (isa(Node)) { Entity = std::make_unique( cast(Node), nullptr /* IA */); DU->addScopeLabel(Scope, cast(Entity.get())); } } void DwarfCompileUnit::emitHeader(bool UseOffsets) { // Don't bother labeling the .dwo unit, as its offset isn't used. if (!Skeleton && !DD->useSectionsAsReferences()) { LabelBegin = Asm->createTempSymbol("cu_begin"); Asm->OutStreamer->emitLabel(LabelBegin); } dwarf::UnitType UT = Skeleton ? dwarf::DW_UT_split_compile : DD->useSplitDwarf() ? dwarf::DW_UT_skeleton : dwarf::DW_UT_compile; DwarfUnit::emitCommonHeader(UseOffsets, UT); if (DD->getDwarfVersion() >= 5 && UT != dwarf::DW_UT_compile) Asm->emitInt64(getDWOId()); } bool DwarfCompileUnit::hasDwarfPubSections() const { switch (CUNode->getNameTableKind()) { case DICompileUnit::DebugNameTableKind::None: return false; // Opting in to GNU Pubnames/types overrides the default to ensure these are // generated for things like Gold's gdb_index generation. case DICompileUnit::DebugNameTableKind::GNU: return true; case DICompileUnit::DebugNameTableKind::Default: return DD->tuneForGDB() && !includeMinimalInlineScopes() && !CUNode->isDebugDirectivesOnly() && DD->getAccelTableKind() != AccelTableKind::Apple && DD->getDwarfVersion() < 5; } llvm_unreachable("Unhandled DICompileUnit::DebugNameTableKind enum"); } /// addGlobalName - Add a new global name to the compile unit. void DwarfCompileUnit::addGlobalName(StringRef Name, const DIE &Die, const DIScope *Context) { if (!hasDwarfPubSections()) return; std::string FullName = getParentContextString(Context) + Name.str(); GlobalNames[FullName] = &Die; } void DwarfCompileUnit::addGlobalNameForTypeUnit(StringRef Name, const DIScope *Context) { if (!hasDwarfPubSections()) return; std::string FullName = getParentContextString(Context) + Name.str(); // Insert, allowing the entry to remain as-is if it's already present // This way the CU-level type DIE is preferred over the "can't describe this // type as a unit offset because it's not really in the CU at all, it's only // in a type unit" GlobalNames.insert(std::make_pair(std::move(FullName), &getUnitDie())); } /// Add a new global type to the unit. void DwarfCompileUnit::addGlobalType(const DIType *Ty, const DIE &Die, const DIScope *Context) { if (!hasDwarfPubSections()) return; std::string FullName = getParentContextString(Context) + Ty->getName().str(); GlobalTypes[FullName] = &Die; } void DwarfCompileUnit::addGlobalTypeUnitType(const DIType *Ty, const DIScope *Context) { if (!hasDwarfPubSections()) return; std::string FullName = getParentContextString(Context) + Ty->getName().str(); // Insert, allowing the entry to remain as-is if it's already present // This way the CU-level type DIE is preferred over the "can't describe this // type as a unit offset because it's not really in the CU at all, it's only // in a type unit" GlobalTypes.insert(std::make_pair(std::move(FullName), &getUnitDie())); } void DwarfCompileUnit::addVariableAddress(const DbgVariable &DV, DIE &Die, MachineLocation Location) { if (DV.hasComplexAddress()) addComplexAddress(DV, Die, dwarf::DW_AT_location, Location); else addAddress(Die, dwarf::DW_AT_location, Location); } /// Add an address attribute to a die based on the location provided. void DwarfCompileUnit::addAddress(DIE &Die, dwarf::Attribute Attribute, const MachineLocation &Location) { DIELoc *Loc = new (DIEValueAllocator) DIELoc; DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); if (Location.isIndirect()) DwarfExpr.setMemoryLocationKind(); DIExpressionCursor Cursor({}); const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo(); if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg())) return; DwarfExpr.addExpression(std::move(Cursor)); // Now attach the location information to the DIE. addBlock(Die, Attribute, DwarfExpr.finalize()); if (DwarfExpr.TagOffset) addUInt(Die, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1, *DwarfExpr.TagOffset); } /// Start with the address based on the location provided, and generate the /// DWARF information necessary to find the actual variable given the extra /// address information encoded in the DbgVariable, starting from the starting /// location. Add the DWARF information to the die. void DwarfCompileUnit::addComplexAddress(const DbgVariable &DV, DIE &Die, dwarf::Attribute Attribute, const MachineLocation &Location) { DIELoc *Loc = new (DIEValueAllocator) DIELoc; DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); const DIExpression *DIExpr = DV.getSingleExpression(); DwarfExpr.addFragmentOffset(DIExpr); DwarfExpr.setLocation(Location, DIExpr); DIExpressionCursor Cursor(DIExpr); if (DIExpr->isEntryValue()) DwarfExpr.beginEntryValueExpression(Cursor); const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo(); if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg())) return; DwarfExpr.addExpression(std::move(Cursor)); // Now attach the location information to the DIE. addBlock(Die, Attribute, DwarfExpr.finalize()); if (DwarfExpr.TagOffset) addUInt(Die, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1, *DwarfExpr.TagOffset); } /// Add a Dwarf loclistptr attribute data and value. void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute, unsigned Index) { dwarf::Form Form = (DD->getDwarfVersion() >= 5) ? dwarf::DW_FORM_loclistx : DD->getDwarfSectionOffsetForm(); addAttribute(Die, Attribute, Form, DIELocList(Index)); } void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var, DIE &VariableDie) { StringRef Name = Var.getName(); if (!Name.empty()) addString(VariableDie, dwarf::DW_AT_name, Name); const auto *DIVar = Var.getVariable(); if (DIVar) if (uint32_t AlignInBytes = DIVar->getAlignInBytes()) addUInt(VariableDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, AlignInBytes); addSourceLine(VariableDie, DIVar); addType(VariableDie, Var.getType()); if (Var.isArtificial()) addFlag(VariableDie, dwarf::DW_AT_artificial); } void DwarfCompileUnit::applyLabelAttributes(const DbgLabel &Label, DIE &LabelDie) { StringRef Name = Label.getName(); if (!Name.empty()) addString(LabelDie, dwarf::DW_AT_name, Name); const auto *DILabel = Label.getLabel(); addSourceLine(LabelDie, DILabel); } /// Add a Dwarf expression attribute data and value. void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr) { addAttribute(Die, (dwarf::Attribute)0, Form, DIEExpr(Expr)); } void DwarfCompileUnit::applySubprogramAttributesToDefinition( const DISubprogram *SP, DIE &SPDie) { auto *SPDecl = SP->getDeclaration(); auto *Context = SPDecl ? SPDecl->getScope() : SP->getScope(); applySubprogramAttributes(SP, SPDie, includeMinimalInlineScopes()); addGlobalName(SP->getName(), SPDie, Context); } bool DwarfCompileUnit::isDwoUnit() const { return DD->useSplitDwarf() && Skeleton; } void DwarfCompileUnit::finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) { constructTypeDIE(D, CTy); } bool DwarfCompileUnit::includeMinimalInlineScopes() const { return getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly || (DD->useSplitDwarf() && !Skeleton); } void DwarfCompileUnit::addAddrTableBase() { const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); MCSymbol *Label = DD->getAddressPool().getLabel(); addSectionLabel(getUnitDie(), DD->getDwarfVersion() >= 5 ? dwarf::DW_AT_addr_base : dwarf::DW_AT_GNU_addr_base, Label, TLOF.getDwarfAddrSection()->getBeginSymbol()); } void DwarfCompileUnit::addBaseTypeRef(DIEValueList &Die, int64_t Idx) { addAttribute(Die, (dwarf::Attribute)0, dwarf::DW_FORM_udata, new (DIEValueAllocator) DIEBaseTypeRef(this, Idx)); } void DwarfCompileUnit::createBaseTypeDIEs() { // Insert the base_type DIEs directly after the CU so that their offsets will // fit in the fixed size ULEB128 used inside the location expressions. // Maintain order by iterating backwards and inserting to the front of CU // child list. for (auto &Btr : reverse(ExprRefedBaseTypes)) { DIE &Die = getUnitDie().addChildFront( DIE::get(DIEValueAllocator, dwarf::DW_TAG_base_type)); SmallString<32> Str; addString(Die, dwarf::DW_AT_name, Twine(dwarf::AttributeEncodingString(Btr.Encoding) + "_" + Twine(Btr.BitSize)).toStringRef(Str)); addUInt(Die, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, Btr.Encoding); addUInt(Die, dwarf::DW_AT_byte_size, None, Btr.BitSize / 8); Btr.Die = &Die; } } diff --git a/contrib/llvm-project/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp b/contrib/llvm-project/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp index 6409c39e7849..37407c98e75f 100644 --- a/contrib/llvm-project/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp +++ b/contrib/llvm-project/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp @@ -1,700 +1,701 @@ //===- llvm/CodeGen/DwarfExpression.cpp - Dwarf Debug Framework -----------===// // // 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 // //===----------------------------------------------------------------------===// // // This file contains support for writing dwarf debug info into asm files. // //===----------------------------------------------------------------------===// #include "DwarfExpression.h" #include "DwarfCompileUnit.h" #include "llvm/ADT/APInt.h" #include "llvm/ADT/SmallBitVector.h" #include "llvm/BinaryFormat/Dwarf.h" #include "llvm/CodeGen/Register.h" #include "llvm/CodeGen/TargetRegisterInfo.h" #include "llvm/IR/DataLayout.h" #include "llvm/Support/ErrorHandling.h" #include using namespace llvm; #define DEBUG_TYPE "dwarfdebug" void DwarfExpression::emitConstu(uint64_t Value) { if (Value < 32) emitOp(dwarf::DW_OP_lit0 + Value); else if (Value == std::numeric_limits::max()) { // Only do this for 64-bit values as the DWARF expression stack uses // target-address-size values. emitOp(dwarf::DW_OP_lit0); emitOp(dwarf::DW_OP_not); } else { emitOp(dwarf::DW_OP_constu); emitUnsigned(Value); } } void DwarfExpression::addReg(int DwarfReg, const char *Comment) { assert(DwarfReg >= 0 && "invalid negative dwarf register number"); assert((isUnknownLocation() || isRegisterLocation()) && "location description already locked down"); LocationKind = Register; if (DwarfReg < 32) { emitOp(dwarf::DW_OP_reg0 + DwarfReg, Comment); } else { emitOp(dwarf::DW_OP_regx, Comment); emitUnsigned(DwarfReg); } } void DwarfExpression::addBReg(int DwarfReg, int Offset) { assert(DwarfReg >= 0 && "invalid negative dwarf register number"); assert(!isRegisterLocation() && "location description already locked down"); if (DwarfReg < 32) { emitOp(dwarf::DW_OP_breg0 + DwarfReg); } else { emitOp(dwarf::DW_OP_bregx); emitUnsigned(DwarfReg); } emitSigned(Offset); } void DwarfExpression::addFBReg(int Offset) { emitOp(dwarf::DW_OP_fbreg); emitSigned(Offset); } void DwarfExpression::addOpPiece(unsigned SizeInBits, unsigned OffsetInBits) { if (!SizeInBits) return; const unsigned SizeOfByte = 8; if (OffsetInBits > 0 || SizeInBits % SizeOfByte) { emitOp(dwarf::DW_OP_bit_piece); emitUnsigned(SizeInBits); emitUnsigned(OffsetInBits); } else { emitOp(dwarf::DW_OP_piece); unsigned ByteSize = SizeInBits / SizeOfByte; emitUnsigned(ByteSize); } this->OffsetInBits += SizeInBits; } void DwarfExpression::addShr(unsigned ShiftBy) { emitConstu(ShiftBy); emitOp(dwarf::DW_OP_shr); } void DwarfExpression::addAnd(unsigned Mask) { emitConstu(Mask); emitOp(dwarf::DW_OP_and); } bool DwarfExpression::addMachineReg(const TargetRegisterInfo &TRI, llvm::Register MachineReg, unsigned MaxSize) { if (!llvm::Register::isPhysicalRegister(MachineReg)) { if (isFrameRegister(TRI, MachineReg)) { DwarfRegs.push_back(Register::createRegister(-1, nullptr)); return true; } return false; } int Reg = TRI.getDwarfRegNum(MachineReg, false); // If this is a valid register number, emit it. if (Reg >= 0) { DwarfRegs.push_back(Register::createRegister(Reg, nullptr)); return true; } // Walk up the super-register chain until we find a valid number. // For example, EAX on x86_64 is a 32-bit fragment of RAX with offset 0. for (MCSuperRegIterator SR(MachineReg, &TRI); SR.isValid(); ++SR) { Reg = TRI.getDwarfRegNum(*SR, false); if (Reg >= 0) { unsigned Idx = TRI.getSubRegIndex(*SR, MachineReg); unsigned Size = TRI.getSubRegIdxSize(Idx); unsigned RegOffset = TRI.getSubRegIdxOffset(Idx); DwarfRegs.push_back(Register::createRegister(Reg, "super-register")); // Use a DW_OP_bit_piece to describe the sub-register. setSubRegisterPiece(Size, RegOffset); return true; } } // Otherwise, attempt to find a covering set of sub-register numbers. // For example, Q0 on ARM is a composition of D0+D1. unsigned CurPos = 0; // The size of the register in bits. const TargetRegisterClass *RC = TRI.getMinimalPhysRegClass(MachineReg); unsigned RegSize = TRI.getRegSizeInBits(*RC); // Keep track of the bits in the register we already emitted, so we // can avoid emitting redundant aliasing subregs. Because this is // just doing a greedy scan of all subregisters, it is possible that // this doesn't find a combination of subregisters that fully cover // the register (even though one may exist). SmallBitVector Coverage(RegSize, false); for (MCSubRegIterator SR(MachineReg, &TRI); SR.isValid(); ++SR) { unsigned Idx = TRI.getSubRegIndex(MachineReg, *SR); unsigned Size = TRI.getSubRegIdxSize(Idx); unsigned Offset = TRI.getSubRegIdxOffset(Idx); Reg = TRI.getDwarfRegNum(*SR, false); if (Reg < 0) continue; // Used to build the intersection between the bits we already // emitted and the bits covered by this subregister. SmallBitVector CurSubReg(RegSize, false); CurSubReg.set(Offset, Offset + Size); // If this sub-register has a DWARF number and we haven't covered // its range, and its range covers the value, emit a DWARF piece for it. if (Offset < MaxSize && CurSubReg.test(Coverage)) { // Emit a piece for any gap in the coverage. if (Offset > CurPos) DwarfRegs.push_back(Register::createSubRegister( -1, Offset - CurPos, "no DWARF register encoding")); if (Offset == 0 && Size >= MaxSize) DwarfRegs.push_back(Register::createRegister(Reg, "sub-register")); else DwarfRegs.push_back(Register::createSubRegister( Reg, std::min(Size, MaxSize - Offset), "sub-register")); } // Mark it as emitted. Coverage.set(Offset, Offset + Size); CurPos = Offset + Size; } // Failed to find any DWARF encoding. if (CurPos == 0) return false; // Found a partial or complete DWARF encoding. if (CurPos < RegSize) DwarfRegs.push_back(Register::createSubRegister( -1, RegSize - CurPos, "no DWARF register encoding")); return true; } void DwarfExpression::addStackValue() { if (DwarfVersion >= 4) emitOp(dwarf::DW_OP_stack_value); } void DwarfExpression::addSignedConstant(int64_t Value) { assert(isImplicitLocation() || isUnknownLocation()); LocationKind = Implicit; emitOp(dwarf::DW_OP_consts); emitSigned(Value); } void DwarfExpression::addUnsignedConstant(uint64_t Value) { assert(isImplicitLocation() || isUnknownLocation()); LocationKind = Implicit; emitConstu(Value); } void DwarfExpression::addUnsignedConstant(const APInt &Value) { assert(isImplicitLocation() || isUnknownLocation()); LocationKind = Implicit; unsigned Size = Value.getBitWidth(); const uint64_t *Data = Value.getRawData(); // Chop it up into 64-bit pieces, because that's the maximum that // addUnsignedConstant takes. unsigned Offset = 0; while (Offset < Size) { addUnsignedConstant(*Data++); if (Offset == 0 && Size <= 64) break; addStackValue(); addOpPiece(std::min(Size - Offset, 64u), Offset); Offset += 64; } } void DwarfExpression::addConstantFP(const APFloat &APF, const AsmPrinter &AP) { assert(isImplicitLocation() || isUnknownLocation()); APInt API = APF.bitcastToAPInt(); int NumBytes = API.getBitWidth() / 8; if (NumBytes == 4 /*float*/ || NumBytes == 8 /*double*/) { // FIXME: Add support for `long double`. emitOp(dwarf::DW_OP_implicit_value); emitUnsigned(NumBytes /*Size of the block in bytes*/); // The loop below is emitting the value starting at least significant byte, // so we need to perform a byte-swap to get the byte order correct in case // of a big-endian target. if (AP.getDataLayout().isBigEndian()) API = API.byteSwap(); for (int i = 0; i < NumBytes; ++i) { emitData1(API.getZExtValue() & 0xFF); API = API.lshr(8); } return; } LLVM_DEBUG( dbgs() << "Skipped DW_OP_implicit_value creation for ConstantFP of size: " << API.getBitWidth() << " bits\n"); } bool DwarfExpression::addMachineRegExpression(const TargetRegisterInfo &TRI, DIExpressionCursor &ExprCursor, llvm::Register MachineReg, unsigned FragmentOffsetInBits) { auto Fragment = ExprCursor.getFragmentInfo(); if (!addMachineReg(TRI, MachineReg, Fragment ? Fragment->SizeInBits : ~1U)) { LocationKind = Unknown; return false; } bool HasComplexExpression = false; auto Op = ExprCursor.peek(); if (Op && Op->getOp() != dwarf::DW_OP_LLVM_fragment) HasComplexExpression = true; // If the register can only be described by a complex expression (i.e., // multiple subregisters) it doesn't safely compose with another complex // expression. For example, it is not possible to apply a DW_OP_deref // operation to multiple DW_OP_pieces, since composite location descriptions // do not push anything on the DWARF stack. // // DW_OP_entry_value operations can only hold a DWARF expression or a // register location description, so we can't emit a single entry value // covering a composite location description. In the future we may want to // emit entry value operations for each register location in the composite // location, but until that is supported do not emit anything. if ((HasComplexExpression || IsEmittingEntryValue) && DwarfRegs.size() > 1) { if (IsEmittingEntryValue) cancelEntryValue(); DwarfRegs.clear(); LocationKind = Unknown; return false; } // Handle simple register locations. If we are supposed to emit // a call site parameter expression and if that expression is just a register // location, emit it with addBReg and offset 0, because we should emit a DWARF // expression representing a value, rather than a location. if ((!isParameterValue() && !isMemoryLocation() && !HasComplexExpression) || isEntryValue()) { for (auto &Reg : DwarfRegs) { if (Reg.DwarfRegNo >= 0) addReg(Reg.DwarfRegNo, Reg.Comment); addOpPiece(Reg.SubRegSize); } if (isEntryValue()) { finalizeEntryValue(); if (!isIndirect() && !isParameterValue() && !HasComplexExpression && DwarfVersion >= 4) emitOp(dwarf::DW_OP_stack_value); } DwarfRegs.clear(); // If we need to mask out a subregister, do it now, unless the next // operation would emit an OpPiece anyway. auto NextOp = ExprCursor.peek(); if (SubRegisterSizeInBits && NextOp && (NextOp->getOp() != dwarf::DW_OP_LLVM_fragment)) maskSubRegister(); return true; } // Don't emit locations that cannot be expressed without DW_OP_stack_value. if (DwarfVersion < 4) if (any_of(ExprCursor, [](DIExpression::ExprOperand Op) -> bool { return Op.getOp() == dwarf::DW_OP_stack_value; })) { DwarfRegs.clear(); LocationKind = Unknown; return false; } assert(DwarfRegs.size() == 1); auto Reg = DwarfRegs[0]; bool FBReg = isFrameRegister(TRI, MachineReg); int SignedOffset = 0; assert(!Reg.isSubRegister() && "full register expected"); // Pattern-match combinations for which more efficient representations exist. // [Reg, DW_OP_plus_uconst, Offset] --> [DW_OP_breg, Offset]. if (Op && (Op->getOp() == dwarf::DW_OP_plus_uconst)) { uint64_t Offset = Op->getArg(0); uint64_t IntMax = static_cast(std::numeric_limits::max()); if (Offset <= IntMax) { SignedOffset = Offset; ExprCursor.take(); } } // [Reg, DW_OP_constu, Offset, DW_OP_plus] --> [DW_OP_breg, Offset] // [Reg, DW_OP_constu, Offset, DW_OP_minus] --> [DW_OP_breg,-Offset] // If Reg is a subregister we need to mask it out before subtracting. if (Op && Op->getOp() == dwarf::DW_OP_constu) { uint64_t Offset = Op->getArg(0); uint64_t IntMax = static_cast(std::numeric_limits::max()); auto N = ExprCursor.peekNext(); if (N && N->getOp() == dwarf::DW_OP_plus && Offset <= IntMax) { SignedOffset = Offset; ExprCursor.consume(2); } else if (N && N->getOp() == dwarf::DW_OP_minus && !SubRegisterSizeInBits && Offset <= IntMax + 1) { SignedOffset = -static_cast(Offset); ExprCursor.consume(2); } } if (FBReg) addFBReg(SignedOffset); else addBReg(Reg.DwarfRegNo, SignedOffset); DwarfRegs.clear(); // If we need to mask out a subregister, do it now, unless the next // operation would emit an OpPiece anyway. auto NextOp = ExprCursor.peek(); if (SubRegisterSizeInBits && NextOp && (NextOp->getOp() != dwarf::DW_OP_LLVM_fragment)) maskSubRegister(); return true; } void DwarfExpression::setEntryValueFlags(const MachineLocation &Loc) { LocationFlags |= EntryValue; if (Loc.isIndirect()) LocationFlags |= Indirect; } void DwarfExpression::setLocation(const MachineLocation &Loc, const DIExpression *DIExpr) { if (Loc.isIndirect()) setMemoryLocationKind(); if (DIExpr->isEntryValue()) setEntryValueFlags(Loc); } void DwarfExpression::beginEntryValueExpression( DIExpressionCursor &ExprCursor) { auto Op = ExprCursor.take(); (void)Op; assert(Op && Op->getOp() == dwarf::DW_OP_LLVM_entry_value); assert(!IsEmittingEntryValue && "Already emitting entry value?"); assert(Op->getArg(0) == 1 && "Can currently only emit entry values covering a single operation"); SavedLocationKind = LocationKind; LocationKind = Register; IsEmittingEntryValue = true; enableTemporaryBuffer(); } void DwarfExpression::finalizeEntryValue() { assert(IsEmittingEntryValue && "Entry value not open?"); disableTemporaryBuffer(); emitOp(CU.getDwarf5OrGNULocationAtom(dwarf::DW_OP_entry_value)); // Emit the entry value's size operand. unsigned Size = getTemporaryBufferSize(); emitUnsigned(Size); // Emit the entry value's DWARF block operand. commitTemporaryBuffer(); LocationFlags &= ~EntryValue; LocationKind = SavedLocationKind; IsEmittingEntryValue = false; } void DwarfExpression::cancelEntryValue() { assert(IsEmittingEntryValue && "Entry value not open?"); disableTemporaryBuffer(); // The temporary buffer can't be emptied, so for now just assert that nothing // has been emitted to it. assert(getTemporaryBufferSize() == 0 && "Began emitting entry value block before cancelling entry value"); LocationKind = SavedLocationKind; IsEmittingEntryValue = false; } unsigned DwarfExpression::getOrCreateBaseType(unsigned BitSize, dwarf::TypeKind Encoding) { // Reuse the base_type if we already have one in this CU otherwise we // create a new one. unsigned I = 0, E = CU.ExprRefedBaseTypes.size(); for (; I != E; ++I) if (CU.ExprRefedBaseTypes[I].BitSize == BitSize && CU.ExprRefedBaseTypes[I].Encoding == Encoding) break; if (I == E) CU.ExprRefedBaseTypes.emplace_back(BitSize, Encoding); return I; } /// Assuming a well-formed expression, match "DW_OP_deref* /// DW_OP_LLVM_fragment?". static bool isMemoryLocation(DIExpressionCursor ExprCursor) { while (ExprCursor) { auto Op = ExprCursor.take(); switch (Op->getOp()) { case dwarf::DW_OP_deref: case dwarf::DW_OP_LLVM_fragment: break; default: return false; } } return true; } -void DwarfExpression::addExpression(DIExpressionCursor &&ExprCursor, - unsigned FragmentOffsetInBits) { +void DwarfExpression::addExpression(DIExpressionCursor &&ExprCursor) { addExpression(std::move(ExprCursor), [](unsigned Idx, DIExpressionCursor &Cursor) -> bool { llvm_unreachable("unhandled opcode found in expression"); }); } -void DwarfExpression::addExpression( +bool DwarfExpression::addExpression( DIExpressionCursor &&ExprCursor, llvm::function_ref InsertArg) { // Entry values can currently only cover the initial register location, // and not any other parts of the following DWARF expression. assert(!IsEmittingEntryValue && "Can't emit entry value around expression"); Optional PrevConvertOp = None; while (ExprCursor) { auto Op = ExprCursor.take(); uint64_t OpNum = Op->getOp(); if (OpNum >= dwarf::DW_OP_reg0 && OpNum <= dwarf::DW_OP_reg31) { emitOp(OpNum); continue; } else if (OpNum >= dwarf::DW_OP_breg0 && OpNum <= dwarf::DW_OP_breg31) { addBReg(OpNum - dwarf::DW_OP_breg0, Op->getArg(0)); continue; } switch (OpNum) { case dwarf::DW_OP_LLVM_arg: if (!InsertArg(Op->getArg(0), ExprCursor)) { LocationKind = Unknown; - return; + return false; } break; case dwarf::DW_OP_LLVM_fragment: { unsigned SizeInBits = Op->getArg(1); unsigned FragmentOffset = Op->getArg(0); // The fragment offset must have already been adjusted by emitting an // empty DW_OP_piece / DW_OP_bit_piece before we emitted the base // location. assert(OffsetInBits >= FragmentOffset && "fragment offset not added?"); assert(SizeInBits >= OffsetInBits - FragmentOffset && "size underflow"); // If addMachineReg already emitted DW_OP_piece operations to represent // a super-register by splicing together sub-registers, subtract the size // of the pieces that was already emitted. SizeInBits -= OffsetInBits - FragmentOffset; // If addMachineReg requested a DW_OP_bit_piece to stencil out a // sub-register that is smaller than the current fragment's size, use it. if (SubRegisterSizeInBits) SizeInBits = std::min(SizeInBits, SubRegisterSizeInBits); // Emit a DW_OP_stack_value for implicit location descriptions. if (isImplicitLocation()) addStackValue(); // Emit the DW_OP_piece. addOpPiece(SizeInBits, SubRegisterOffsetInBits); setSubRegisterPiece(0, 0); // Reset the location description kind. LocationKind = Unknown; - return; + return true; } case dwarf::DW_OP_plus_uconst: assert(!isRegisterLocation()); emitOp(dwarf::DW_OP_plus_uconst); emitUnsigned(Op->getArg(0)); break; case dwarf::DW_OP_plus: case dwarf::DW_OP_minus: case dwarf::DW_OP_mul: case dwarf::DW_OP_div: case dwarf::DW_OP_mod: case dwarf::DW_OP_or: case dwarf::DW_OP_and: case dwarf::DW_OP_xor: case dwarf::DW_OP_shl: case dwarf::DW_OP_shr: case dwarf::DW_OP_shra: case dwarf::DW_OP_lit0: case dwarf::DW_OP_not: case dwarf::DW_OP_dup: case dwarf::DW_OP_push_object_address: case dwarf::DW_OP_over: emitOp(OpNum); break; case dwarf::DW_OP_deref: assert(!isRegisterLocation()); if (!isMemoryLocation() && ::isMemoryLocation(ExprCursor)) // Turning this into a memory location description makes the deref // implicit. LocationKind = Memory; else emitOp(dwarf::DW_OP_deref); break; case dwarf::DW_OP_constu: assert(!isRegisterLocation()); emitConstu(Op->getArg(0)); break; case dwarf::DW_OP_consts: assert(!isRegisterLocation()); emitOp(dwarf::DW_OP_consts); emitSigned(Op->getArg(0)); break; case dwarf::DW_OP_LLVM_convert: { unsigned BitSize = Op->getArg(0); dwarf::TypeKind Encoding = static_cast(Op->getArg(1)); if (DwarfVersion >= 5 && CU.getDwarfDebug().useOpConvert()) { emitOp(dwarf::DW_OP_convert); // If targeting a location-list; simply emit the index into the raw // byte stream as ULEB128, DwarfDebug::emitDebugLocEntry has been // fitted with means to extract it later. // If targeting a inlined DW_AT_location; insert a DIEBaseTypeRef // (containing the index and a resolve mechanism during emit) into the // DIE value list. emitBaseTypeRef(getOrCreateBaseType(BitSize, Encoding)); } else { if (PrevConvertOp && PrevConvertOp->getArg(0) < BitSize) { if (Encoding == dwarf::DW_ATE_signed) emitLegacySExt(PrevConvertOp->getArg(0)); else if (Encoding == dwarf::DW_ATE_unsigned) emitLegacyZExt(PrevConvertOp->getArg(0)); PrevConvertOp = None; } else { PrevConvertOp = Op; } } break; } case dwarf::DW_OP_stack_value: LocationKind = Implicit; break; case dwarf::DW_OP_swap: assert(!isRegisterLocation()); emitOp(dwarf::DW_OP_swap); break; case dwarf::DW_OP_xderef: assert(!isRegisterLocation()); emitOp(dwarf::DW_OP_xderef); break; case dwarf::DW_OP_deref_size: emitOp(dwarf::DW_OP_deref_size); emitData1(Op->getArg(0)); break; case dwarf::DW_OP_LLVM_tag_offset: TagOffset = Op->getArg(0); break; case dwarf::DW_OP_regx: emitOp(dwarf::DW_OP_regx); emitUnsigned(Op->getArg(0)); break; case dwarf::DW_OP_bregx: emitOp(dwarf::DW_OP_bregx); emitUnsigned(Op->getArg(0)); emitSigned(Op->getArg(1)); break; default: llvm_unreachable("unhandled opcode found in expression"); } } if (isImplicitLocation() && !isParameterValue()) // Turn this into an implicit location description. addStackValue(); + + return true; } /// add masking operations to stencil out a subregister. void DwarfExpression::maskSubRegister() { assert(SubRegisterSizeInBits && "no subregister was registered"); if (SubRegisterOffsetInBits > 0) addShr(SubRegisterOffsetInBits); uint64_t Mask = (1ULL << (uint64_t)SubRegisterSizeInBits) - 1ULL; addAnd(Mask); } void DwarfExpression::finalize() { assert(DwarfRegs.size() == 0 && "dwarf registers not emitted"); // Emit any outstanding DW_OP_piece operations to mask out subregisters. if (SubRegisterSizeInBits == 0) return; // Don't emit a DW_OP_piece for a subregister at offset 0. if (SubRegisterOffsetInBits == 0) return; addOpPiece(SubRegisterSizeInBits, SubRegisterOffsetInBits); } void DwarfExpression::addFragmentOffset(const DIExpression *Expr) { if (!Expr || !Expr->isFragment()) return; uint64_t FragmentOffset = Expr->getFragmentInfo()->OffsetInBits; assert(FragmentOffset >= OffsetInBits && "overlapping or duplicate fragments"); if (FragmentOffset > OffsetInBits) addOpPiece(FragmentOffset - OffsetInBits); OffsetInBits = FragmentOffset; } void DwarfExpression::emitLegacySExt(unsigned FromBits) { // (((X >> (FromBits - 1)) * (~0)) << FromBits) | X emitOp(dwarf::DW_OP_dup); emitOp(dwarf::DW_OP_constu); emitUnsigned(FromBits - 1); emitOp(dwarf::DW_OP_shr); emitOp(dwarf::DW_OP_lit0); emitOp(dwarf::DW_OP_not); emitOp(dwarf::DW_OP_mul); emitOp(dwarf::DW_OP_constu); emitUnsigned(FromBits); emitOp(dwarf::DW_OP_shl); emitOp(dwarf::DW_OP_or); } void DwarfExpression::emitLegacyZExt(unsigned FromBits) { // (X & (1 << FromBits - 1)) emitOp(dwarf::DW_OP_constu); emitUnsigned((1ULL << FromBits) - 1); emitOp(dwarf::DW_OP_and); } void DwarfExpression::addWasmLocation(unsigned Index, uint64_t Offset) { emitOp(dwarf::DW_OP_WASM_location); emitUnsigned(Index == 4/*TI_LOCAL_INDIRECT*/ ? 0/*TI_LOCAL*/ : Index); emitUnsigned(Offset); if (Index == 4 /*TI_LOCAL_INDIRECT*/) { assert(LocationKind == Unknown); LocationKind = Memory; } else { assert(LocationKind == Implicit || LocationKind == Unknown); LocationKind = Implicit; } } diff --git a/contrib/llvm-project/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.h b/contrib/llvm-project/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.h index 513e9072309e..e605fe2f7d39 100644 --- a/contrib/llvm-project/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.h +++ b/contrib/llvm-project/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.h @@ -1,439 +1,440 @@ //===- llvm/CodeGen/DwarfExpression.h - Dwarf Compile Unit ------*- 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 // //===----------------------------------------------------------------------===// // // This file contains support for writing dwarf compile unit. // //===----------------------------------------------------------------------===// #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DWARFEXPRESSION_H #define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFEXPRESSION_H #include "ByteStreamer.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/None.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/SmallVector.h" #include "llvm/IR/DebugInfoMetadata.h" #include #include #include namespace llvm { class AsmPrinter; class APInt; class DwarfCompileUnit; class DIELoc; class TargetRegisterInfo; class MachineLocation; /// Holds a DIExpression and keeps track of how many operands have been consumed /// so far. class DIExpressionCursor { DIExpression::expr_op_iterator Start, End; public: DIExpressionCursor(const DIExpression *Expr) { if (!Expr) { assert(Start == End); return; } Start = Expr->expr_op_begin(); End = Expr->expr_op_end(); } DIExpressionCursor(ArrayRef Expr) : Start(Expr.begin()), End(Expr.end()) {} DIExpressionCursor(const DIExpressionCursor &) = default; /// Consume one operation. Optional take() { if (Start == End) return None; return *(Start++); } /// Consume N operations. void consume(unsigned N) { std::advance(Start, N); } /// Return the current operation. Optional peek() const { if (Start == End) return None; return *(Start); } /// Return the next operation. Optional peekNext() const { if (Start == End) return None; auto Next = Start.getNext(); if (Next == End) return None; return *Next; } /// Determine whether there are any operations left in this expression. operator bool() const { return Start != End; } DIExpression::expr_op_iterator begin() const { return Start; } DIExpression::expr_op_iterator end() const { return End; } /// Retrieve the fragment information, if any. Optional getFragmentInfo() const { return DIExpression::getFragmentInfo(Start, End); } }; /// Base class containing the logic for constructing DWARF expressions /// independently of whether they are emitted into a DIE or into a .debug_loc /// entry. /// /// Some DWARF operations, e.g. DW_OP_entry_value, need to calculate the size /// of a succeeding DWARF block before the latter is emitted to the output. /// To handle such cases, data can conditionally be emitted to a temporary /// buffer, which can later on be committed to the main output. The size of the /// temporary buffer is queryable, allowing for the size of the data to be /// emitted before the data is committed. class DwarfExpression { protected: /// Holds information about all subregisters comprising a register location. struct Register { int DwarfRegNo; unsigned SubRegSize; const char *Comment; /// Create a full register, no extra DW_OP_piece operators necessary. static Register createRegister(int RegNo, const char *Comment) { return {RegNo, 0, Comment}; } /// Create a subregister that needs a DW_OP_piece operator with SizeInBits. static Register createSubRegister(int RegNo, unsigned SizeInBits, const char *Comment) { return {RegNo, SizeInBits, Comment}; } bool isSubRegister() const { return SubRegSize; } }; /// Whether we are currently emitting an entry value operation. bool IsEmittingEntryValue = false; DwarfCompileUnit &CU; /// The register location, if any. SmallVector DwarfRegs; /// Current Fragment Offset in Bits. uint64_t OffsetInBits = 0; /// Sometimes we need to add a DW_OP_bit_piece to describe a subregister. unsigned SubRegisterSizeInBits : 16; unsigned SubRegisterOffsetInBits : 16; /// The kind of location description being produced. enum { Unknown = 0, Register, Memory, Implicit }; /// Additional location flags which may be combined with any location kind. /// Currently, entry values are not supported for the Memory location kind. enum { EntryValue = 1 << 0, Indirect = 1 << 1, CallSiteParamValue = 1 << 2 }; unsigned LocationKind : 3; unsigned SavedLocationKind : 3; unsigned LocationFlags : 3; unsigned DwarfVersion : 4; public: /// Set the location (\p Loc) and \ref DIExpression (\p DIExpr) to describe. void setLocation(const MachineLocation &Loc, const DIExpression *DIExpr); bool isUnknownLocation() const { return LocationKind == Unknown; } bool isMemoryLocation() const { return LocationKind == Memory; } bool isRegisterLocation() const { return LocationKind == Register; } bool isImplicitLocation() const { return LocationKind == Implicit; } bool isEntryValue() const { return LocationFlags & EntryValue; } bool isIndirect() const { return LocationFlags & Indirect; } bool isParameterValue() { return LocationFlags & CallSiteParamValue; } Optional TagOffset; protected: /// Push a DW_OP_piece / DW_OP_bit_piece for emitting later, if one is needed /// to represent a subregister. void setSubRegisterPiece(unsigned SizeInBits, unsigned OffsetInBits) { assert(SizeInBits < 65536 && OffsetInBits < 65536); SubRegisterSizeInBits = SizeInBits; SubRegisterOffsetInBits = OffsetInBits; } /// Add masking operations to stencil out a subregister. void maskSubRegister(); /// Output a dwarf operand and an optional assembler comment. virtual void emitOp(uint8_t Op, const char *Comment = nullptr) = 0; /// Emit a raw signed value. virtual void emitSigned(int64_t Value) = 0; /// Emit a raw unsigned value. virtual void emitUnsigned(uint64_t Value) = 0; virtual void emitData1(uint8_t Value) = 0; virtual void emitBaseTypeRef(uint64_t Idx) = 0; /// Start emitting data to the temporary buffer. The data stored in the /// temporary buffer can be committed to the main output using /// commitTemporaryBuffer(). virtual void enableTemporaryBuffer() = 0; /// Disable emission to the temporary buffer. This does not commit data /// in the temporary buffer to the main output. virtual void disableTemporaryBuffer() = 0; /// Return the emitted size, in number of bytes, for the data stored in the /// temporary buffer. virtual unsigned getTemporaryBufferSize() = 0; /// Commit the data stored in the temporary buffer to the main output. virtual void commitTemporaryBuffer() = 0; /// Emit a normalized unsigned constant. void emitConstu(uint64_t Value); /// Return whether the given machine register is the frame register in the /// current function. virtual bool isFrameRegister(const TargetRegisterInfo &TRI, llvm::Register MachineReg) = 0; /// Emit a DW_OP_reg operation. Note that this is only legal inside a DWARF /// register location description. void addReg(int DwarfReg, const char *Comment = nullptr); /// Emit a DW_OP_breg operation. void addBReg(int DwarfReg, int Offset); /// Emit DW_OP_fbreg . void addFBReg(int Offset); /// Emit a partial DWARF register operation. /// /// \param MachineReg The register number. /// \param MaxSize If the register must be composed from /// sub-registers this is an upper bound /// for how many bits the emitted DW_OP_piece /// may cover. /// /// If size and offset is zero an operation for the entire register is /// emitted: Some targets do not provide a DWARF register number for every /// register. If this is the case, this function will attempt to emit a DWARF /// register by emitting a fragment of a super-register or by piecing together /// multiple subregisters that alias the register. /// /// \return false if no DWARF register exists for MachineReg. bool addMachineReg(const TargetRegisterInfo &TRI, llvm::Register MachineReg, unsigned MaxSize = ~1U); /// Emit a DW_OP_piece or DW_OP_bit_piece operation for a variable fragment. /// \param OffsetInBits This is an optional offset into the location that /// is at the top of the DWARF stack. void addOpPiece(unsigned SizeInBits, unsigned OffsetInBits = 0); /// Emit a shift-right dwarf operation. void addShr(unsigned ShiftBy); /// Emit a bitwise and dwarf operation. void addAnd(unsigned Mask); /// Emit a DW_OP_stack_value, if supported. /// /// The proper way to describe a constant value is DW_OP_constu , /// DW_OP_stack_value. Unfortunately, DW_OP_stack_value was not available /// until DWARF 4, so we will continue to generate DW_OP_constu for /// DWARF 2 and DWARF 3. Technically, this is incorrect since DW_OP_const /// actually describes a value at a constant address, not a constant /// value. However, in the past there was no better way to describe a /// constant value, so the producers and consumers started to rely on /// heuristics to disambiguate the value vs. location status of the /// expression. See PR21176 for more details. void addStackValue(); /// Finalize an entry value by emitting its size operand, and committing the /// DWARF block which has been emitted to the temporary buffer. void finalizeEntryValue(); /// Cancel the emission of an entry value. void cancelEntryValue(); ~DwarfExpression() = default; public: DwarfExpression(unsigned DwarfVersion, DwarfCompileUnit &CU) : CU(CU), SubRegisterSizeInBits(0), SubRegisterOffsetInBits(0), LocationKind(Unknown), SavedLocationKind(Unknown), LocationFlags(Unknown), DwarfVersion(DwarfVersion) {} /// This needs to be called last to commit any pending changes. void finalize(); /// Emit a signed constant. void addSignedConstant(int64_t Value); /// Emit an unsigned constant. void addUnsignedConstant(uint64_t Value); /// Emit an unsigned constant. void addUnsignedConstant(const APInt &Value); /// Emit an floating point constant. void addConstantFP(const APFloat &Value, const AsmPrinter &AP); /// Lock this down to become a memory location description. void setMemoryLocationKind() { assert(isUnknownLocation()); LocationKind = Memory; } /// Lock this down to become an entry value location. void setEntryValueFlags(const MachineLocation &Loc); /// Lock this down to become a call site parameter location. void setCallSiteParamValueFlag() { LocationFlags |= CallSiteParamValue; } /// Emit a machine register location. As an optimization this may also consume /// the prefix of a DwarfExpression if a more efficient representation for /// combining the register location and the first operation exists. /// /// \param FragmentOffsetInBits If this is one fragment out of a /// fragmented /// location, this is the offset of the /// fragment inside the entire variable. /// \return false if no DWARF register exists /// for MachineReg. bool addMachineRegExpression(const TargetRegisterInfo &TRI, DIExpressionCursor &Expr, llvm::Register MachineReg, unsigned FragmentOffsetInBits = 0); /// Begin emission of an entry value dwarf operation. The entry value's /// first operand is the size of the DWARF block (its second operand), /// which needs to be calculated at time of emission, so we don't emit /// any operands here. void beginEntryValueExpression(DIExpressionCursor &ExprCursor); /// Return the index of a base type with the given properties and /// create one if necessary. unsigned getOrCreateBaseType(unsigned BitSize, dwarf::TypeKind Encoding); + /// Emit all remaining operations in the DIExpressionCursor. The + /// cursor must not contain any DW_OP_LLVM_arg operations. + void addExpression(DIExpressionCursor &&Expr); + /// Emit all remaining operations in the DIExpressionCursor. - /// - /// \param FragmentOffsetInBits If this is one fragment out of multiple - /// locations, this is the offset of the - /// fragment inside the entire variable. - void addExpression(DIExpressionCursor &&Expr, - unsigned FragmentOffsetInBits = 0); - void - addExpression(DIExpressionCursor &&Expr, - llvm::function_ref InsertArg); + /// DW_OP_LLVM_arg operations are resolved by calling (\p InsertArg). + // + /// \return false if any call to (\p InsertArg) returns false. + bool addExpression( + DIExpressionCursor &&Expr, + llvm::function_ref InsertArg); /// If applicable, emit an empty DW_OP_piece / DW_OP_bit_piece to advance to /// the fragment described by \c Expr. void addFragmentOffset(const DIExpression *Expr); void emitLegacySExt(unsigned FromBits); void emitLegacyZExt(unsigned FromBits); /// Emit location information expressed via WebAssembly location + offset /// The Index is an identifier for locals, globals or operand stack. void addWasmLocation(unsigned Index, uint64_t Offset); }; /// DwarfExpression implementation for .debug_loc entries. class DebugLocDwarfExpression final : public DwarfExpression { struct TempBuffer { SmallString<32> Bytes; std::vector Comments; BufferByteStreamer BS; TempBuffer(bool GenerateComments) : BS(Bytes, Comments, GenerateComments) {} }; std::unique_ptr TmpBuf; BufferByteStreamer &OutBS; bool IsBuffering = false; /// Return the byte streamer that currently is being emitted to. ByteStreamer &getActiveStreamer() { return IsBuffering ? TmpBuf->BS : OutBS; } void emitOp(uint8_t Op, const char *Comment = nullptr) override; void emitSigned(int64_t Value) override; void emitUnsigned(uint64_t Value) override; void emitData1(uint8_t Value) override; void emitBaseTypeRef(uint64_t Idx) override; void enableTemporaryBuffer() override; void disableTemporaryBuffer() override; unsigned getTemporaryBufferSize() override; void commitTemporaryBuffer() override; bool isFrameRegister(const TargetRegisterInfo &TRI, llvm::Register MachineReg) override; public: DebugLocDwarfExpression(unsigned DwarfVersion, BufferByteStreamer &BS, DwarfCompileUnit &CU) : DwarfExpression(DwarfVersion, CU), OutBS(BS) {} }; /// DwarfExpression implementation for singular DW_AT_location. class DIEDwarfExpression final : public DwarfExpression { const AsmPrinter &AP; DIELoc &OutDIE; DIELoc TmpDIE; bool IsBuffering = false; /// Return the DIE that currently is being emitted to. DIELoc &getActiveDIE() { return IsBuffering ? TmpDIE : OutDIE; } void emitOp(uint8_t Op, const char *Comment = nullptr) override; void emitSigned(int64_t Value) override; void emitUnsigned(uint64_t Value) override; void emitData1(uint8_t Value) override; void emitBaseTypeRef(uint64_t Idx) override; void enableTemporaryBuffer() override; void disableTemporaryBuffer() override; unsigned getTemporaryBufferSize() override; void commitTemporaryBuffer() override; bool isFrameRegister(const TargetRegisterInfo &TRI, llvm::Register MachineReg) override; public: DIEDwarfExpression(const AsmPrinter &AP, DwarfCompileUnit &CU, DIELoc &DIE); DIELoc *finalize() { DwarfExpression::finalize(); return &OutDIE; } }; } // end namespace llvm #endif // LLVM_LIB_CODEGEN_ASMPRINTER_DWARFEXPRESSION_H