From 75212344d1ba448178adb2994cd35c98a6e84690 Mon Sep 17 00:00:00 2001 From: Adrian Prantl Date: Tue, 13 Jan 2015 00:04:06 +0000 Subject: [PATCH] Debug Info: Move support for constants into DwarfExpression. Move the declaration of DebugLocDwarfExpression into DwarfExpression.h because it needs to be accessed from AsmPrinterDwarf.cpp and DwarfDebug.cpp NFC. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@225734 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp | 20 ++++--------- lib/CodeGen/AsmPrinter/DwarfDebug.cpp | 25 ++++------------ lib/CodeGen/AsmPrinter/DwarfExpression.cpp | 35 +++++++++++++++++++--- lib/CodeGen/AsmPrinter/DwarfExpression.h | 22 ++++++++++++++ 4 files changed, 65 insertions(+), 37 deletions(-) diff --git a/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp b/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp index d3131541eb3..5d6a03080c4 100644 --- a/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp +++ b/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp @@ -32,32 +32,24 @@ using namespace llvm; #define DEBUG_TYPE "asm-printer" -/// 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) override; - void EmitSigned(int Value) override; - void EmitUnsigned(unsigned Value) override; - unsigned getFrameRegister() override { llvm_unreachable("not available"); }; -}; - void DebugLocDwarfExpression::EmitOp(uint8_t Op, const char *Comment) { BS.EmitInt8( Op, Comment ? Twine(Comment) + " " + dwarf::OperationEncodingString(Op) : dwarf::OperationEncodingString(Op)); } + void DebugLocDwarfExpression::EmitSigned(int Value) { BS.EmitSLEB128(Value, Twine(Value)); } + void DebugLocDwarfExpression::EmitUnsigned(unsigned Value) { BS.EmitULEB128(Value, Twine(Value)); } +unsigned DebugLocDwarfExpression::getFrameRegister() { + llvm_unreachable("not available"); +} + //===----------------------------------------------------------------------===// // Dwarf Emission Helper Routines //===----------------------------------------------------------------------===// diff --git a/lib/CodeGen/AsmPrinter/DwarfDebug.cpp b/lib/CodeGen/AsmPrinter/DwarfDebug.cpp index ff89643e81e..99f4d1c5d44 100644 --- a/lib/CodeGen/AsmPrinter/DwarfDebug.cpp +++ b/lib/CodeGen/AsmPrinter/DwarfDebug.cpp @@ -14,6 +14,7 @@ #include "DwarfDebug.h" #include "ByteStreamer.h" +#include "DwarfExpression.h" #include "DwarfCompileUnit.h" #include "DIEHash.h" #include "DwarfUnit.h" @@ -1717,29 +1718,15 @@ void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer, void DwarfDebug::emitDebugLocValue(ByteStreamer &Streamer, const DebugLocEntry::Value &Value) { DIVariable DV = Value.getVariable(); + DebugLocDwarfExpression Expr(*Asm, Streamer); // Regular entry. if (Value.isInt()) { DIBasicType BTy(resolve(DV.getType())); if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed || - BTy.getEncoding() == dwarf::DW_ATE_signed_char)) { - Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts"); - Streamer.EmitSLEB128(Value.getInt()); - } else { - Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu"); - Streamer.EmitULEB128(Value.getInt()); - } - // The proper way to describe a constant value is - // DW_OP_constu , DW_OP_stack_value. - // Unfortunately, DW_OP_stack_value was not available until DWARF-4, - // so we will continue to generate DW_OP_constu for DWARF-2 - // and DWARF-3. Technically, this is incorrect since DW_OP_const - // actually describes a value at a constant addess, not a constant value. - // However, in the past there was no better way to describe a constant - // value, so the producers and consumers started to rely on heuristics - // to disambiguate the value vs. location status of the expression. - // See PR21176 for more details. - if (getDwarfVersion() >= 4) - Streamer.EmitInt8(dwarf::DW_OP_stack_value, "DW_OP_stack_value"); + BTy.getEncoding() == dwarf::DW_ATE_signed_char)) + Expr.AddSignedConstant(Value.getInt()); + else + Expr.AddUnsignedConstant(Value.getInt()); } else if (Value.isLocation()) { MachineLocation Loc = Value.getLoc(); DIExpression Expr = Value.getExpression(); diff --git a/lib/CodeGen/AsmPrinter/DwarfExpression.cpp b/lib/CodeGen/AsmPrinter/DwarfExpression.cpp index 767846c224a..1df0ea4f79f 100644 --- a/lib/CodeGen/AsmPrinter/DwarfExpression.cpp +++ b/lib/CodeGen/AsmPrinter/DwarfExpression.cpp @@ -21,14 +21,17 @@ #include "llvm/Target/TargetRegisterInfo.h" #include "llvm/Target/TargetSubtargetInfo.h" - using namespace llvm; const TargetRegisterInfo *DwarfExpression::getTRI() const { return AP.TM.getSubtargetImpl()->getRegisterInfo(); } -void DwarfExpression::AddReg(int DwarfReg, const char* Comment) { +unsigned DwarfExpression::getDwarfVersion() const { + return AP.getDwarfDebug()->getDwarfVersion(); +} + +void DwarfExpression::AddReg(int DwarfReg, const char *Comment) { assert(DwarfReg >= 0 && "invalid negative dwarf register number"); if (DwarfReg < 32) { EmitOp(dwarf::DW_OP_reg0 + DwarfReg, Comment); @@ -51,8 +54,7 @@ void DwarfExpression::AddRegIndirect(int DwarfReg, int Offset, bool Deref) { EmitOp(dwarf::DW_OP_deref); } -void DwarfExpression::AddOpPiece(unsigned SizeInBits, - unsigned OffsetInBits) { +void DwarfExpression::AddOpPiece(unsigned SizeInBits, unsigned OffsetInBits) { assert(SizeInBits > 0 && "piece has size zero"); const unsigned SizeOfByte = 8; if (OffsetInBits > 0 || SizeInBits % SizeOfByte) { @@ -164,3 +166,28 @@ void DwarfExpression::AddMachineRegPiece(unsigned MachineReg, // FIXME: We have no reasonable way of handling errors in here. EmitOp(dwarf::DW_OP_nop, "nop (could not find a dwarf register number)"); } + +void DwarfExpression::AddSignedConstant(int Value) { + EmitOp(dwarf::DW_OP_consts); + EmitSigned(Value); + // The proper way to describe a constant value is + // DW_OP_constu , DW_OP_stack_value. + // Unfortunately, DW_OP_stack_value was not available until DWARF-4, + // so we will continue to generate DW_OP_constu for DWARF-2 + // and DWARF-3. Technically, this is incorrect since DW_OP_const + // actually describes a value at a constant addess, not a constant value. + // However, in the past there was no better way to describe a constant + // value, so the producers and consumers started to rely on heuristics + // to disambiguate the value vs. location status of the expression. + // See PR21176 for more details. + if (getDwarfVersion() >= 4) + EmitOp(dwarf::DW_OP_stack_value); +} + +void DwarfExpression::AddUnsignedConstant(unsigned Value) { + EmitOp(dwarf::DW_OP_constu); + EmitUnsigned(Value); + // cf. comment in DwarfExpression::AddSignedConstant(). + if (getDwarfVersion() >= 4) + EmitOp(dwarf::DW_OP_stack_value); +} diff --git a/lib/CodeGen/AsmPrinter/DwarfExpression.h b/lib/CodeGen/AsmPrinter/DwarfExpression.h index c02b4e197e7..9e93a573a3d 100644 --- a/lib/CodeGen/AsmPrinter/DwarfExpression.h +++ b/lib/CodeGen/AsmPrinter/DwarfExpression.h @@ -19,6 +19,7 @@ namespace llvm { class AsmPrinter; +class ByteStreamer; class TargetRegisterInfo; /// Base class containing the logic for constructing DWARF expressions @@ -29,6 +30,7 @@ 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) {} @@ -71,6 +73,26 @@ public: 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); +}; + + +/// 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) override; + void EmitSigned(int Value) override; + void EmitUnsigned(unsigned Value) override; + unsigned getFrameRegister() override; }; }