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