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/IR/DebugInfo.h" 18 #include "llvm/Support/DataTypes.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 ≈ 34 // Various convenience accessors that extract things out of AsmPrinter. 35 const TargetRegisterInfo *getTRI() const; 36 unsigned getDwarfVersion() const; 37 38 public: DwarfExpression(const AsmPrinter & AP)39 DwarfExpression(const AsmPrinter &AP) : AP(AP) {} ~DwarfExpression()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: DebugLocDwarfExpression(const AsmPrinter & AP,ByteStreamer & BS)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 ¨ 121 122 public: DIEDwarfExpression(const AsmPrinter & AP,DwarfUnit & DU,DIELoc & DIE)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 134