1 //===-- llvm/CodeGen/DebugHandlerBase.h -----------------------*- C++ -*--===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // Common functionality for different debug information format backends. 10 // LLVM currently supports DWARF and CodeView. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_CODEGEN_DEBUGHANDLERBASE_H 15 #define LLVM_CODEGEN_DEBUGHANDLERBASE_H 16 17 #include "llvm/ADT/Optional.h" 18 #include "llvm/CodeGen/AsmPrinterHandler.h" 19 #include "llvm/CodeGen/DbgEntityHistoryCalculator.h" 20 #include "llvm/CodeGen/LexicalScopes.h" 21 #include "llvm/IR/DebugInfoMetadata.h" 22 #include "llvm/IR/DebugLoc.h" 23 24 namespace llvm { 25 26 class AsmPrinter; 27 class MachineInstr; 28 class MachineModuleInfo; 29 30 /// Represents the location at which a variable is stored. 31 struct DbgVariableLocation { 32 /// Base register. 33 unsigned Register; 34 35 /// Chain of offsetted loads necessary to load the value if it lives in 36 /// memory. Every load except for the last is pointer-sized. 37 SmallVector<int64_t, 1> LoadChain; 38 39 /// Present if the location is part of a larger variable. 40 llvm::Optional<llvm::DIExpression::FragmentInfo> FragmentInfo; 41 42 /// Extract a VariableLocation from a MachineInstr. 43 /// This will only work if Instruction is a debug value instruction 44 /// and the associated DIExpression is in one of the supported forms. 45 /// If these requirements are not met, the returned Optional will not 46 /// have a value. 47 static Optional<DbgVariableLocation> 48 extractFromMachineInstruction(const MachineInstr &Instruction); 49 }; 50 51 /// Base class for debug information backends. Common functionality related to 52 /// tracking which variables and scopes are alive at a given PC live here. 53 class DebugHandlerBase : public AsmPrinterHandler { 54 protected: 55 DebugHandlerBase(AsmPrinter *A); 56 57 /// Target of debug info emission. 58 AsmPrinter *Asm; 59 60 /// Collected machine module information. 61 MachineModuleInfo *MMI; 62 63 /// Previous instruction's location information. This is used to 64 /// determine label location to indicate scope boundaries in debug info. 65 /// We track the previous instruction's source location (if not line 0), 66 /// whether it was a label, and its parent BB. 67 DebugLoc PrevInstLoc; 68 MCSymbol *PrevLabel = nullptr; 69 const MachineBasicBlock *PrevInstBB = nullptr; 70 71 /// This location indicates end of function prologue and beginning of 72 /// function body. 73 DebugLoc PrologEndLoc; 74 75 /// If nonnull, stores the current machine instruction we're processing. 76 const MachineInstr *CurMI = nullptr; 77 78 LexicalScopes LScopes; 79 80 /// History of DBG_VALUE and clobber instructions for each user 81 /// variable. Variables are listed in order of appearance. 82 DbgValueHistoryMap DbgValues; 83 84 /// Mapping of inlined labels and DBG_LABEL machine instruction. 85 DbgLabelInstrMap DbgLabels; 86 87 /// Maps instruction with label emitted before instruction. 88 /// FIXME: Make this private from DwarfDebug, we have the necessary accessors 89 /// for it. 90 DenseMap<const MachineInstr *, MCSymbol *> LabelsBeforeInsn; 91 92 /// Maps instruction with label emitted after instruction. 93 DenseMap<const MachineInstr *, MCSymbol *> LabelsAfterInsn; 94 95 /// Indentify instructions that are marking the beginning of or 96 /// ending of a scope. 97 void identifyScopeMarkers(); 98 99 /// Ensure that a label will be emitted before MI. 100 void requestLabelBeforeInsn(const MachineInstr *MI) { 101 LabelsBeforeInsn.insert(std::make_pair(MI, nullptr)); 102 } 103 104 /// Ensure that a label will be emitted after MI. 105 void requestLabelAfterInsn(const MachineInstr *MI) { 106 LabelsAfterInsn.insert(std::make_pair(MI, nullptr)); 107 } 108 109 virtual void beginFunctionImpl(const MachineFunction *MF) = 0; 110 virtual void endFunctionImpl(const MachineFunction *MF) = 0; 111 virtual void skippedNonDebugFunction() {} 112 113 private: 114 InstructionOrdering InstOrdering; 115 116 // AsmPrinterHandler overrides. 117 public: 118 void beginModule(Module *M) override; 119 120 void beginInstruction(const MachineInstr *MI) override; 121 void endInstruction() override; 122 123 void beginFunction(const MachineFunction *MF) override; 124 void endFunction(const MachineFunction *MF) override; 125 126 void beginBasicBlock(const MachineBasicBlock &MBB) override; 127 void endBasicBlock(const MachineBasicBlock &MBB) override; 128 129 /// Return Label preceding the instruction. 130 MCSymbol *getLabelBeforeInsn(const MachineInstr *MI); 131 132 /// Return Label immediately following the instruction. 133 MCSymbol *getLabelAfterInsn(const MachineInstr *MI); 134 135 /// If this type is derived from a base type then return base type size. 136 static uint64_t getBaseTypeSize(const DIType *Ty); 137 138 /// Return true if type encoding is unsigned. 139 static bool isUnsignedDIType(const DIType *Ty); 140 141 const InstructionOrdering &getInstOrdering() const { return InstOrdering; } 142 }; 143 144 } // namespace llvm 145 146 #endif 147
Indexes created Tue Jun 23 00:25:03 UTC 2026