lib/CodeGen/AsmPrinter/DwarfExpression.h

   1 //===-- llvm/CodeGen/DwarfExpression.h - Dwarf Compile Unit ---*- 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 // This file contains support for writing dwarf compile unit.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DWARFEXPRESSION_H
  15 #define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFEXPRESSION_H
  16
  17 #include "llvm/Support/DataTypes.h"
  18 #include "llvm/IR/DebugInfo.h"
  19
  20 namespace llvm {
  21
  22 class AsmPrinter;
  23 class ByteStreamer;
  24 class TargetRegisterInfo;
  25 class DwarfUnit;
  26 class DIELoc;
  27
  28 /// Base class containing the logic for constructing DWARF expressions
  29 /// independently of whether they are emitted into a DIE or into a .debug_loc
  30 /// entry.
  31 class DwarfExpression {
  32 protected:
  33   const AsmPrinter &AP;
  34   // Various convenience accessors that extract things out of AsmPrinter.
  35   const TargetRegisterInfo *getTRI() const;
  36   unsigned getDwarfVersion() const;
  37
  38 public:
  39   DwarfExpression(const AsmPrinter &AP) : AP(AP) {}
  40   virtual ~DwarfExpression() {}
  41
  42   /// Output a dwarf operand and an optional assembler comment.
  43   virtual void EmitOp(uint8_t Op, const char *Comment = nullptr) = 0;
  44   /// Emit a raw signed value.
  45   virtual void EmitSigned(int Value) = 0;
  46   /// Emit a raw unsigned value.
  47   virtual void EmitUnsigned(unsigned Value) = 0;
  48   /// Return whether the given machine register is the frame register in the
  49   /// current function.
  50   virtual bool isFrameRegister(unsigned MachineReg) = 0;
  51
  52   /// Emit a dwarf register operation.
  53   void AddReg(int DwarfReg, const char *Comment = nullptr);
  54   /// Emit an (double-)indirect dwarf register operation.
  55   void AddRegIndirect(int DwarfReg, int Offset, bool Deref = false);
  56
  57   /// Emit a dwarf register operation for describing
  58   /// - a small value occupying only part of a register or
  59   /// - a register representing only part of a value.
  60   void AddOpPiece(unsigned SizeInBits, unsigned OffsetInBits = 0);
  61   /// Emit a shift-right dwarf expression.
  62   void AddShr(unsigned ShiftBy);
  63
  64   /// Emit an indirect dwarf register operation for the given machine register.
  65   /// \return false if no DWARF register exists for MachineReg.
  66   bool AddMachineRegIndirect(unsigned MachineReg, int Offset = 0);
  67
  68   /// \brief Emit a partial DWARF register operation.
  69   /// \param MachineReg        the register
  70   /// \param PieceSizeInBits   size and
  71   /// \param PieceOffsetInBits offset of the piece in bits, if this is one
  72   ///                          piece of an aggregate value.
  73   ///
  74   /// If size and offset is zero an operation for the entire
  75   /// register is emitted: Some targets do not provide a DWARF
  76   /// register number for every register.  If this is the case, this
  77   /// function will attempt to emit a DWARF register by emitting a
  78   /// piece of a super-register or by piecing together multiple
  79   /// subregisters that alias the register.
  80   ///
  81   /// \return false if no DWARF register exists for MachineReg.
  82   bool AddMachineRegPiece(unsigned MachineReg, unsigned PieceSizeInBits = 0,
  83                           unsigned PieceOffsetInBits = 0);
  84
  85   /// Emit a signed constant.
  86   void AddSignedConstant(int Value);
  87   /// Emit an unsigned constant.
  88   void AddUnsignedConstant(unsigned Value);
  89
  90   /// Emit an entire DIExpression on top of a machine register location.
  91   /// \param PieceOffsetInBits If this is one piece out of a fragmented
  92   /// location, this is the offset of the piece inside the entire variable.
  93   /// \return false if no DWARF register exists for MachineReg.
  94   bool AddMachineRegExpression(DIExpression Expr, unsigned MachineReg,
  95                                unsigned PieceOffsetInBits = 0);
  96   /// Emit a the operations in a DIExpression, starting from element I.
  97   /// \param PieceOffsetInBits If this is one piece out of a fragmented
  98   /// location, this is the offset of the piece inside the entire variable.
  99   void AddExpression(DIExpression Expr, unsigned PieceOffsetInBits = 0,
 100                      unsigned I = 0);
 101 };
 102
 103 /// DwarfExpression implementation for .debug_loc entries.
 104 class DebugLocDwarfExpression : public DwarfExpression {
 105   ByteStreamer &BS;
 106
 107 public:
 108   DebugLocDwarfExpression(const AsmPrinter &AP, ByteStreamer &BS)
 109       : DwarfExpression(AP), BS(BS) {}
 110
 111   void EmitOp(uint8_t Op, const char *Comment = nullptr) override;
 112   void EmitSigned(int Value) override;
 113   void EmitUnsigned(unsigned Value) override;
 114   bool isFrameRegister(unsigned MachineReg) override;
 115 };
 116
 117 /// DwarfExpression implementation for singular DW_AT_location.
 118 class DIEDwarfExpression : public DwarfExpression {
 119   DwarfUnit &DU;
 120   DIELoc &DIE;
 121
 122 public:
 123   DIEDwarfExpression(const AsmPrinter &AP, DwarfUnit &DU, DIELoc &DIE)
 124       : DwarfExpression(AP), DU(DU), DIE(DIE) {}
 125
 126   void EmitOp(uint8_t Op, const char *Comment = nullptr) override;
 127   void EmitSigned(int Value) override;
 128   void EmitUnsigned(unsigned Value) override;
 129   bool isFrameRegister(unsigned MachineReg) override;
 130 };
 131 }
 132
 133 #endif