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