mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-26 06:22:56 +02:00
523d44398e
emitDebugLocValue() into DwarfExpression. Ought to be NFC, but it actually uncovered a bug in the debug-loc-asan.ll testcase. The testcase checks that the address of variable "y" is stored at [RSP+16], which also lines up with the comment. It also check(ed) that the *value* of "y" is stored in RDI before that, but that is actually incorrect, since RDI is the very value that is stored in [RSP+16]. Here's the assembler output: movb 2147450880(%rcx), %r8b #DEBUG_VALUE: bar:y <- RDI cmpb $0, %r8b movq %rax, 32(%rsp) # 8-byte Spill movq %rsi, 24(%rsp) # 8-byte Spill movq %rdi, 16(%rsp) # 8-byte Spill .Ltmp3: #DEBUG_VALUE: bar:y <- [RSP+16] Fixed the comment to spell out the correct register and the check to expect an address rather than a value. Note that the range that is emitted for the RDI location was and is still wrong, it claims to begin at the function prologue, but really it should start where RDI is first assigned. llvm-svn: 225851
114 lines
4.4 KiB
C++
114 lines
4.4 KiB
C++
//===-- llvm/CodeGen/DwarfExpression.h - Dwarf Compile Unit ---*- C++ -*--===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file contains support for writing dwarf compile unit.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DWARFEXPRESSION_H
|
|
#define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFEXPRESSION_H
|
|
|
|
#include "llvm/Support/DataTypes.h"
|
|
#include "llvm/IR/DebugInfo.h"
|
|
|
|
namespace llvm {
|
|
|
|
class AsmPrinter;
|
|
class ByteStreamer;
|
|
class TargetRegisterInfo;
|
|
|
|
/// Base class containing the logic for constructing DWARF expressions
|
|
/// independently of whether they are emitted into a DIE or into a .debug_loc
|
|
/// entry.
|
|
class DwarfExpression {
|
|
protected:
|
|
const AsmPrinter &AP;
|
|
// Various convenience accessors that extract things out of AsmPrinter.
|
|
const TargetRegisterInfo *getTRI() const;
|
|
unsigned getDwarfVersion() const;
|
|
|
|
public:
|
|
DwarfExpression(const AsmPrinter &AP) : AP(AP) {}
|
|
virtual ~DwarfExpression() {}
|
|
|
|
/// Output a dwarf operand and an optional assembler comment.
|
|
virtual void EmitOp(uint8_t Op, const char *Comment = nullptr) = 0;
|
|
/// Emit a raw signed value.
|
|
virtual void EmitSigned(int Value) = 0;
|
|
/// Emit a raw unsigned value.
|
|
virtual void EmitUnsigned(unsigned Value) = 0;
|
|
/// Return whether the given machine register is the frame register in the
|
|
/// current function.
|
|
virtual bool isFrameRegister(unsigned MachineReg) = 0;
|
|
|
|
/// Emit a dwarf register operation.
|
|
void AddReg(int DwarfReg, const char *Comment = nullptr);
|
|
/// Emit an (double-)indirect dwarf register operation.
|
|
void AddRegIndirect(int DwarfReg, int Offset, bool Deref = false);
|
|
|
|
/// Emit a dwarf register operation for describing
|
|
/// - a small value occupying only part of a register or
|
|
/// - a register representing only part of a value.
|
|
void AddOpPiece(unsigned SizeInBits, unsigned OffsetInBits = 0);
|
|
/// Emit a shift-right dwarf expression.
|
|
void AddShr(unsigned ShiftBy);
|
|
|
|
/// Emit an indirect dwarf register operation for the given machine register.
|
|
/// Returns false if no DWARF register exists for MachineReg.
|
|
bool AddMachineRegIndirect(unsigned MachineReg, int Offset = 0);
|
|
|
|
/// \brief Emit a partial DWARF register operation.
|
|
/// \param MachineReg the register
|
|
/// \param PieceSizeInBits size and
|
|
/// \param PieceOffsetInBits offset of the piece in bits, if this is one
|
|
/// piece of an aggregate value.
|
|
///
|
|
/// If size and offset is zero an operation for the entire
|
|
/// register is emitted: Some targets do not provide a DWARF
|
|
/// register number for every register. If this is the case, this
|
|
/// function will attempt to emit a DWARF register by emitting a
|
|
/// piece of a super-register or by piecing together multiple
|
|
/// subregisters that alias the register.
|
|
void AddMachineRegPiece(unsigned MachineReg, unsigned PieceSizeInBits = 0,
|
|
unsigned PieceOffsetInBits = 0);
|
|
|
|
/// Emit a signed constant.
|
|
void AddSignedConstant(int Value);
|
|
/// Emit an unsigned constant.
|
|
void AddUnsignedConstant(unsigned Value);
|
|
|
|
/// Emit an entire DIExpression on top of a machine register location.
|
|
/// \param PieceOffsetInBits If this is one piece out of a fragmented
|
|
/// location, this is the offset of the piece inside the entire variable.
|
|
void AddMachineRegExpression(DIExpression Expr, unsigned MachineReg,
|
|
unsigned PieceOffsetInBits = 0);
|
|
/// Emit a the operations in a DIExpression, starting from element I.
|
|
/// \param PieceOffsetInBits If this is one piece out of a fragmented
|
|
/// location, this is the offset of the piece inside the entire variable.
|
|
void AddExpression(DIExpression Expr, unsigned PieceOffsetInBits = 0,
|
|
unsigned I = 0);
|
|
};
|
|
|
|
/// DwarfExpression implementation for .debug_loc entries.
|
|
class DebugLocDwarfExpression : public DwarfExpression {
|
|
ByteStreamer &BS;
|
|
|
|
public:
|
|
DebugLocDwarfExpression(const AsmPrinter &AP, ByteStreamer &BS)
|
|
: DwarfExpression(AP), BS(BS) {}
|
|
|
|
void EmitOp(uint8_t Op, const char *Comment = nullptr) override;
|
|
void EmitSigned(int Value) override;
|
|
void EmitUnsigned(unsigned Value) override;
|
|
bool isFrameRegister(unsigned MachineReg) override;
|
|
};
|
|
}
|
|
|
|
#endif
|