contrib/llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.h

   1 //===-- llvm/lib/CodeGen/AsmPrinter/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_LIB_CODEGEN_ASMPRINTER_DEBUGHANDLERBASE_H
  16 #define LLVM_LIB_CODEGEN_ASMPRINTER_DEBUGHANDLERBASE_H
  17
  18 #include "AsmPrinterHandler.h"
  19 #include "DbgValueHistoryCalculator.h"
  20 #include "llvm/CodeGen/LexicalScopes.h"
  21 #include "llvm/CodeGen/MachineInstr.h"
  22
  23 namespace llvm {
  24
  25 class AsmPrinter;
  26 class MachineModuleInfo;
  27
  28 /// Base class for debug information backends. Common functionality related to
  29 /// tracking which variables and scopes are alive at a given PC live here.
  30 class DebugHandlerBase : public AsmPrinterHandler {
  31 protected:
  32   DebugHandlerBase(AsmPrinter *A);
  33
  34   /// Target of debug info emission.
  35   AsmPrinter *Asm;
  36
  37   /// Collected machine module information.
  38   MachineModuleInfo *MMI;
  39
  40   /// Previous instruction's location information. This is used to
  41   /// determine label location to indicate scope boundaries in debug info.
  42   /// We track the previous instruction's source location (if not line 0),
  43   /// whether it was a label, and its parent BB.
  44   DebugLoc PrevInstLoc;
  45   MCSymbol *PrevLabel = nullptr;
  46   const MachineBasicBlock *PrevInstBB = nullptr;
  47
  48   /// This location indicates end of function prologue and beginning of
  49   /// function body.
  50   DebugLoc PrologEndLoc;
  51
  52   /// If nonnull, stores the current machine instruction we're processing.
  53   const MachineInstr *CurMI = nullptr;
  54
  55   LexicalScopes LScopes;
  56
  57   /// History of DBG_VALUE and clobber instructions for each user
  58   /// variable.  Variables are listed in order of appearance.
  59   DbgValueHistoryMap DbgValues;
  60
  61   /// Maps instruction with label emitted before instruction.
  62   /// FIXME: Make this private from DwarfDebug, we have the necessary accessors
  63   /// for it.
  64   DenseMap<const MachineInstr *, MCSymbol *> LabelsBeforeInsn;
  65
  66   /// Maps instruction with label emitted after instruction.
  67   DenseMap<const MachineInstr *, MCSymbol *> LabelsAfterInsn;
  68
  69   /// Indentify instructions that are marking the beginning of or
  70   /// ending of a scope.
  71   void identifyScopeMarkers();
  72
  73   /// Ensure that a label will be emitted before MI.
  74   void requestLabelBeforeInsn(const MachineInstr *MI) {
  75     LabelsBeforeInsn.insert(std::make_pair(MI, nullptr));
  76   }
  77
  78   /// Ensure that a label will be emitted after MI.
  79   void requestLabelAfterInsn(const MachineInstr *MI) {
  80     LabelsAfterInsn.insert(std::make_pair(MI, nullptr));
  81   }
  82
  83   virtual void beginFunctionImpl(const MachineFunction *MF) = 0;
  84   virtual void endFunctionImpl(const MachineFunction *MF) = 0;
  85   virtual void skippedNonDebugFunction() {}
  86
  87   // AsmPrinterHandler overrides.
  88 public:
  89   void beginInstruction(const MachineInstr *MI) override;
  90   void endInstruction() override;
  91
  92   void beginFunction(const MachineFunction *MF) override;
  93   void endFunction(const MachineFunction *MF) override;
  94
  95   /// Return Label preceding the instruction.
  96   MCSymbol *getLabelBeforeInsn(const MachineInstr *MI);
  97
  98   /// Return Label immediately following the instruction.
  99   MCSymbol *getLabelAfterInsn(const MachineInstr *MI);
 100
 101   /// Determine the relative position of the fragments described by P1 and P2.
 102   /// Returns -1 if P1 is entirely before P2, 0 if P1 and P2 overlap, 1 if P1 is
 103   /// entirely after P2.
 104   static int fragmentCmp(const DIExpression *P1, const DIExpression *P2);
 105
 106   /// Determine whether two variable fragments overlap.
 107   static bool fragmentsOverlap(const DIExpression *P1, const DIExpression *P2);
 108
 109   /// If this type is derived from a base type then return base type size.
 110   static uint64_t getBaseTypeSize(const DITypeRef TyRef);
 111 };
 112
 113 }
 114
 115 #endif