LCOV - code coverage report
Current view: top level - lib/CodeGen/AsmPrinter - DebugHandlerBase.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 4 4 100.0 %
Date: 2018-09-23 13:06:45 Functions: 1 1 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 "DbgEntityHistoryCalculator.h"
      20             : #include "llvm/ADT/Optional.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         129 : 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      673815 :     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      626010 :     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           6 :   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             :   /// If this type is derived from a base type then return base type size.
     129             :   static uint64_t getBaseTypeSize(const DITypeRef TyRef);
     130             : };
     131             : 
     132             : }
     133             : 
     134             : #endif

Generated by: LCOV version 1.13