contrib/llvm/include/llvm/CodeGen/DebugHandlerBase.h

   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.
 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.
 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;
 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