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/CodeGen/AsmPrinterHandler.h" 18 #include "llvm/CodeGen/DbgEntityHistoryCalculator.h" 19 #include "llvm/CodeGen/LexicalScopes.h" 20 #include "llvm/IR/DebugInfoMetadata.h" 21 #include "llvm/IR/DebugLoc.h" 22 #include <optional> 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 std::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 std::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 = nullptr; 59 60 /// Collected machine module information. 61 MachineModuleInfo *MMI = nullptr; 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 /// This block includes epilogue instructions. 76 const MachineBasicBlock *EpilogBeginBlock = nullptr; 77 78 /// If nonnull, stores the current machine instruction we're processing. 79 const MachineInstr *CurMI = nullptr; 80 81 LexicalScopes LScopes; 82 83 /// History of DBG_VALUE and clobber instructions for each user 84 /// variable. Variables are listed in order of appearance. 85 DbgValueHistoryMap DbgValues; 86 87 /// Mapping of inlined labels and DBG_LABEL machine instruction. 88 DbgLabelInstrMap DbgLabels; 89 90 /// Maps instruction with label emitted before instruction. 91 /// FIXME: Make this private from DwarfDebug, we have the necessary accessors 92 /// for it. 93 DenseMap<const MachineInstr *, MCSymbol *> LabelsBeforeInsn; 94 95 /// Maps instruction with label emitted after instruction. 96 DenseMap<const MachineInstr *, MCSymbol *> LabelsAfterInsn; 97 98 /// Indentify instructions that are marking the beginning of or 99 /// ending of a scope. 100 void identifyScopeMarkers(); 101 102 /// Ensure that a label will be emitted before MI. 103 void requestLabelBeforeInsn(const MachineInstr *MI) { 104 LabelsBeforeInsn.insert(std::make_pair(MI, nullptr)); 105 } 106 107 /// Ensure that a label will be emitted after MI. 108 void requestLabelAfterInsn(const MachineInstr *MI) { 109 LabelsAfterInsn.insert(std::make_pair(MI, nullptr)); 110 } 111 112 virtual void beginFunctionImpl(const MachineFunction *MF) = 0; 113 virtual void endFunctionImpl(const MachineFunction *MF) = 0; 114 virtual void skippedNonDebugFunction() {} 115 116 private: 117 InstructionOrdering InstOrdering; 118 119 // AsmPrinterHandler overrides. 120 public: 121 void beginModule(Module *M) override; 122 123 void beginInstruction(const MachineInstr *MI) override; 124 void endInstruction() override; 125 126 void beginFunction(const MachineFunction *MF) override; 127 void endFunction(const MachineFunction *MF) override; 128 129 void beginBasicBlockSection(const MachineBasicBlock &MBB) override; 130 void endBasicBlockSection(const MachineBasicBlock &MBB) override; 131 132 /// Return Label preceding the instruction. 133 MCSymbol *getLabelBeforeInsn(const MachineInstr *MI); 134 135 /// Return Label immediately following the instruction. 136 MCSymbol *getLabelAfterInsn(const MachineInstr *MI); 137 138 /// If this type is derived from a base type then return base type size. 139 static uint64_t getBaseTypeSize(const DIType *Ty); 140 141 /// Return true if type encoding is unsigned. 142 static bool isUnsignedDIType(const DIType *Ty); 143 144 const InstructionOrdering &getInstOrdering() const { return InstOrdering; } 145 }; 146 147 } // namespace llvm 148 149 #endif 150