DwarfExpression.h revision 277718 
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
20namespace llvm {
21
22class AsmPrinter;
23class ByteStreamer;
24class TargetRegisterInfo;
25class DwarfUnit;
26class 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.
31class DwarfExpression {
32protected:
33  const AsmPrinter ≈
34  // Various convenience accessors that extract things out of AsmPrinter.
35  const TargetRegisterInfo *getTRI() const;
36  unsigned getDwarfVersion() const;
37
38public:
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.
104class DebugLocDwarfExpression : public DwarfExpression {
105  ByteStreamer &BS;
106
107public:
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.
118class DIEDwarfExpression : public DwarfExpression {
119  DwarfUnit &DU;
120  DIELoc ¨
121
122public:
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