maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Revert rGc0f6ad7d1f3c : "DWARF location lists: Add section index dumping" 

This reverts commit c0f6ad7d1f to fix the buildbots.
This commit is contained in:
Simon Pilgrim 2019-11-18 13:26:32 +00:00
parent ae31c7299b
commit c070a27acc
13 changed files with 48 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
llvm/include/llvm/DebugInfo/DWARF/DWARFAddressRange.h
View File

@ -17,7 +17,6 @@
namespace llvm {
class raw_ostream;
class DWARFObject;
struct DWARFAddressRange {
uint64_t LowPC;
@ -27,9 +26,7 @@ struct DWARFAddressRange {
DWARFAddressRange() = default;
/// Used for unit testing.
DWARFAddressRange(
uint64_t LowPC, uint64_t HighPC,
uint64_t SectionIndex = object::SectionedAddress::UndefSection)
DWARFAddressRange(uint64_t LowPC, uint64_t HighPC, uint64_t SectionIndex = 0)
: LowPC(LowPC), HighPC(HighPC), SectionIndex(SectionIndex) {}
/// Returns true if LowPC is smaller or equal to HighPC. This accounts for
@ -45,8 +42,8 @@ struct DWARFAddressRange {
return LowPC < RHS.HighPC && RHS.LowPC < HighPC;
}
void dump(raw_ostream &OS, uint32_t AddressSize, DIDumpOptions DumpOpts = {},
const DWARFObject *Obj = nullptr) const;
void dump(raw_ostream &OS, uint32_t AddressSize,
DIDumpOptions DumpOpts = {}) const;
};
static inline bool operator<(const DWARFAddressRange &LHS,

8
llvm/lib/DebugInfo/DWARF/DWARFAddressRange.cpp
View File

@ -7,23 +7,19 @@
//===----------------------------------------------------------------------===//
#include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
void DWARFAddressRange::dump(raw_ostream &OS, uint32_t AddressSize,
DIDumpOptions DumpOpts,
const DWARFObject *Obj) const {
DIDumpOptions DumpOpts) const {
OS << (DumpOpts.DisplayRawContents ? " " : "[");
OS << format("0x%*.*" PRIx64 ", ", AddressSize * 2, AddressSize * 2, LowPC)
<< format("0x%*.*" PRIx64, AddressSize * 2, AddressSize * 2, HighPC);
OS << (DumpOpts.DisplayRawContents ? "" : ")");
if (Obj)
DWARFFormValue::dumpAddressSection(*Obj, OS, DumpOpts, SectionIndex);
}
raw_ostream &llvm::operator<<(raw_ostream &OS, const DWARFAddressRange &R) {

13
llvm/lib/DebugInfo/DWARF/DWARFContext.cpp
View File

@ -388,20 +388,16 @@ void DWARFContext::dump(
dumpDebugType(".debug_types.dwo", dwo_types_section_units());
}
DIDumpOptions LLDumpOpts = DumpOpts;
if (LLDumpOpts.Verbose)
LLDumpOpts.DisplayRawContents = true;
if (const auto *Off = shouldDump(Explicit, ".debug_loc", DIDT_ID_DebugLoc,
DObj->getLocSection().Data)) {
getDebugLoc()->dump(OS, getRegisterInfo(), LLDumpOpts, *Off);
getDebugLoc()->dump(OS, getRegisterInfo(), DumpOpts, *Off);
}
if (const auto *Off =
shouldDump(Explicit, ".debug_loclists", DIDT_ID_DebugLoclists,
DObj->getLoclistsSection().Data)) {
DWARFDataExtractor Data(*DObj, DObj->getLoclistsSection(), isLittleEndian(),
0);
dumpLoclistsSection(OS, LLDumpOpts, Data, getRegisterInfo(), *Off);
dumpLoclistsSection(OS, DumpOpts, Data, getRegisterInfo(), *Off);
}
if (const auto *Off =
shouldDump(ExplicitDWO, ".debug_loc.dwo", DIDT_ID_DebugLoc,
@ -413,11 +409,10 @@ void DWARFContext::dump(
uint64_t Offset = **Off;
Loc.dumpLocationList(&Offset, OS,
/*BaseAddr=*/None, getRegisterInfo(), nullptr,
LLDumpOpts, /*Indent=*/0);
DumpOpts, /*Indent=*/0);
OS << "\n";
} else {
Loc.dumpRange(0, Data.getData().size(), OS, getRegisterInfo(),
LLDumpOpts);
Loc.dumpRange(0, Data.getData().size(), OS, getRegisterInfo(), DumpOpts);
}
}

12
llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp
View File

@ -115,20 +115,14 @@ bool DWARFLocationTable::dumpLocationList(uint64_t *Offset, raw_ostream &OS,
OS << format("0x%8.8" PRIx64 ": ", *Offset);
Error E = visitLocationList(Offset, [&](const DWARFLocationEntry &E) {
Expected<Optional<DWARFLocationExpression>> Loc = Interp.Interpret(E);
if (!Loc || DumpOpts.DisplayRawContents)
if (!Loc || DumpOpts.Verbose)
dumpRawEntry(E, OS, Indent);
if (Loc && *Loc) {
OS << "\n";
OS.indent(Indent);
if (DumpOpts.DisplayRawContents)
if (DumpOpts.Verbose)
OS << " => ";
DIDumpOptions RangeDumpOpts(DumpOpts);
RangeDumpOpts.DisplayRawContents = false;
const DWARFObject *Obj = nullptr;
if (U)
Obj = &U->getContext().getDWARFObj();
Loc.get()->Range->dump(OS, Data.getAddressSize(), RangeDumpOpts, Obj);
Loc.get()->Range->dump(OS, Data.getAddressSize(), DumpOpts);
}
if (!Loc)
consumeError(Loc.takeError());

13
llvm/lib/DebugInfo/DWARF/DWARFDie.cpp
View File

@ -62,10 +62,16 @@ static void dumpRanges(const DWARFObject &Obj, raw_ostream &OS,
if (!DumpOpts.ShowAddresses)
return;
ArrayRef<SectionName> SectionNames;
if (DumpOpts.Verbose)
SectionNames = Obj.getSectionNames();
for (const DWARFAddressRange &R : Ranges) {
OS << '\n';
OS.indent(Indent);
R.dump(OS, AddressSize, DumpOpts, &Obj);
R.dump(OS, AddressSize);
DWARFFormValue::dumpAddressSection(Obj, OS, DumpOpts, R.SectionIndex);
}
}
@ -85,6 +91,9 @@ static void dumpLocation(raw_ostream &OS, DWARFFormValue &FormValue,
}
if (FormValue.isFormClass(DWARFFormValue::FC_SectionOffset)) {
auto LLDumpOpts = DumpOpts;
LLDumpOpts.Verbose = false;
uint64_t Offset = *FormValue.getAsSectionOffset();
if (FormValue.getForm() == DW_FORM_loclistx) {
@ -95,7 +104,7 @@ static void dumpLocation(raw_ostream &OS, DWARFFormValue &FormValue,
return;
}
U->getLocationTable().dumpLocationList(&Offset, OS, U->getBaseAddress(),
MRI, U, DumpOpts, Indent);
MRI, U, LLDumpOpts, Indent);
return;
}

9
llvm/test/CodeGen/X86/debug-loclists.ll
View File

@ -3,18 +3,19 @@
; CHECK: DW_TAG_variable
; CHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x0) loclist = 0x00000018:
; CHECK-NEXT: [0x0000000000000000, 0x0000000000000003) ".text._Z2f1ii": DW_OP_consts +3, DW_OP_stack_value
; CHECK-NEXT: [0x0000000000000003, 0x0000000000000004) ".text._Z2f1ii": DW_OP_consts +4, DW_OP_stack_value)
; CHECK-NEXT: [0x0000000000000000, 0x0000000000000003): DW_OP_consts +3, DW_OP_stack_value
; CHECK-NEXT: [0x0000000000000003, 0x0000000000000004): DW_OP_consts +4, DW_OP_stack_value)
; CHECK-NEXT: DW_AT_name {{.*}} "y"
; CHECK: DW_TAG_variable
; CHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x1) loclist = 0x00000029:
; CHECK-NEXT: [0x0000000000000000, 0x0000000000000003) ".text._Z2f1ii": DW_OP_consts +5, DW_OP_stack_value)
; CHECK-NEXT: [0x0000000000000000, 0x0000000000000003): DW_OP_consts +5, DW_OP_stack_value)
; CHECK-NEXT: DW_AT_name {{.*}} "x"
; CHECK: DW_TAG_variable
; FIXME: Use DW_FORM_loclistx to reduce relocations
; CHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x2) loclist = 0x00000031:
; CHECK-NEXT: [0x0000000000000003, 0x0000000000000004) ".text._Z2f1ii": DW_OP_reg0 RAX)
; CHECK-NEXT: [0x0000000000000003, 0x0000000000000004): DW_OP_reg0 RAX)
; CHECK-NEXT: DW_AT_name {{.*}} "r"
; CHECK: .debug_loclists contents:

4
llvm/test/DebugInfo/ARM/PR26163.ll
View File

@ -1,4 +1,4 @@
; RUN: llc -filetype=obj -o - < %s | llvm-dwarfdump -debug-info - | FileCheck %s
; RUN: llc -filetype=obj -o - < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
;
; Checks that we're omitting the first range, as it is empty, and that we're
; emitting one that spans the rest of the function. In this case, the first
@ -10,7 +10,7 @@
;
; CHECK: DW_TAG_inlined_subroutine
; CHECK: DW_TAG_variable
; CHECK: DW_AT_location ({{.*}}
; CHECK: DW_AT_location [DW_FORM_sec_offset] ({{.*}}
; CHECK-NEXT: [0x00000004, 0x00000014): DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4)
; Created form the following test case (PR26163) with

8
llvm/test/DebugInfo/Mips/dsr-fixed-objects.ll
View File

@ -24,8 +24,8 @@ declare void @foo(i32*)
; CHECK: DW_AT_name {{.*}}"e"
; CHECK: DW_TAG_variable
; CHECK-NEXT: DW_AT_location [DW_FORM_sec_offset] (
; CHECK-NEXT: [0x00000028, 0x0000002c) ".text": DW_OP_reg1 AT_64
; CHECK-NEXT: [0x0000002c, 0x00000048) ".text": DW_OP_breg29 SP_64+16)
; CHECK-NEXT: [0x00000028, 0x0000002c): DW_OP_reg1 AT_64
; CHECK-NEXT: [0x0000002c, 0x00000048): DW_OP_breg29 SP_64+16)
; CHECK-NEXT: DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000006b] = "x")
define i32 @f0(i32 signext %a, i32 signext %b, i32 signext %c, i32 signext %d, i32 signext %e) !dbg !4 {
@ -55,8 +55,8 @@ entry:
; CHECK: DW_TAG_variable
; CHECK-NEXT: DW_AT_location [DW_FORM_sec_offset] (
; CHECK-NEXT: [0x00000080, 0x00000084) ".text": DW_OP_reg1 AT_64
; CHECK-NEXT: [0x00000084, 0x00000098) ".text": DW_OP_breg29 SP_64+16)
; CHECK-NEXT: [0x00000080, 0x00000084): DW_OP_reg1 AT_64
; CHECK-NEXT: [0x00000084, 0x00000098): DW_OP_breg29 SP_64+16)
; CHECK-NEXT: DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000006b] = "x")
define i32 @f1(i32 signext %a, i32 signext %b, i32 signext %c, i32 signext %d, i32 signext %e) !dbg !15 {

4
llvm/test/DebugInfo/X86/DW_AT_location-reference.ll
View File

@ -33,8 +33,8 @@
; CHECK: DW_TAG_variable
; CHECK-NEXT: DW_AT_location [DW_FORM_sec_offset] (0x00000000
; Check that the location contains only 2 ranges.
; CHECK-NEXT: [0x{{[0-9a-f]*}}, 0x{{[0-9a-f]*}})
; CHECK-NEXT: [0x{{[0-9a-f]*}}, 0x{{[0-9a-f]*}}){{.*}})
; CHECK-NEXT: [0x{{[0-9a-f]*}}, 0x{{[0-9a-f]*}}):
; CHECK-NEXT: [0x{{[0-9a-f]*}}, 0x{{[0-9a-f]*}}): {{.*}})
; CHECK-NEXT: DW_AT_name {{.*}} "x"
; CHECK-NEXT: DW_AT_decl_file
; CHECK-NEXT: DW_AT_decl_line

4
llvm/test/DebugInfo/X86/dbg-value-frame-index.ll
View File

@ -1,6 +1,6 @@
; RUN: llc -mtriple=x86_64-unknown-unknown -o - %s | FileCheck %s
; RUN: llc -mtriple=x86_64-unknown-unknown -filetype=obj < %s \
; RUN: | llvm-dwarfdump - | FileCheck %s --check-prefix=DWARF
; RUN: | llvm-dwarfdump -v - | FileCheck %s --check-prefix=DWARF
define i1 @test() !dbg !4 {
entry:
@ -22,7 +22,7 @@ while.end:
; CHECK-LABEL: test
; To get the value of the variable, we need to do [$rsp+8], i.e:
; CHECK: #DEBUG_VALUE: test:w <- [DW_OP_plus_uconst 8, DW_OP_deref] $rsp
; DWARF: DW_AT_location (
; DWARF: DW_AT_location [DW_FORM_sec_offset] (
; DWARF-NEXT: [{{.*}}, {{.*}}): DW_OP_breg7 RSP+8)
; Note: A previous version of this test checked for `[DW_OP_plus_uconst 8] [$rsp+0]`,

6
llvm/test/DebugInfo/X86/dbg-value-regmask-clobber.ll
View File

@ -1,5 +1,5 @@
; RUN: llc < %s | FileCheck %s --check-prefix=ASM
; RUN: llc < %s -filetype=obj | llvm-dwarfdump - | FileCheck %s --check-prefix=DWARF
; RUN: llc < %s -filetype=obj | llvm-dwarfdump -v - | FileCheck %s --check-prefix=DWARF
; Values in registers should be clobbered by calls, which use a regmask instead
; of individual register def operands.
@ -22,9 +22,9 @@
; argc is the first formal parameter.
; DWARF: .debug_info contents:
; DWARF: DW_TAG_formal_parameter
; DWARF-NEXT: DW_AT_location ({{0x.*}}
; DWARF-NEXT: DW_AT_location [DW_FORM_sec_offset] ({{0x.*}}
; DWARF-NEXT: [0x0000000000000000, 0x0000000000000013): DW_OP_reg2 RCX)
; DWARF-NEXT: DW_AT_name ("argc")
; DWARF-NEXT: DW_AT_name [DW_FORM_strp] {{.*}} "argc"
; ModuleID = 't.cpp'
source_filename = "test/DebugInfo/X86/dbg-value-regmask-clobber.ll"

6
llvm/test/DebugInfo/X86/debug-loc-frame.ll
View File

@ -4,7 +4,7 @@
; for the stack location directly instead of generating a register+offset indirection.
; RUN: llc -O2 -filetype=obj -disable-post-ra -mtriple=x86_64-unknown-linux-gnu < %s \
; RUN: | llvm-dwarfdump - | FileCheck %s
; RUN: | llvm-dwarfdump -v - | FileCheck %s
;
; int data = 17;
; int sum = 0;
@ -26,7 +26,7 @@
; CHECK: DW_TAG_subprogram
; CHECK-NOT: NULL
; CHECK: DW_TAG_variable
; CHECK: DW_AT_location ({{.*}}
; CHECK: DW_AT_location [DW_FORM_sec_offset] ({{.*}}
; CHECK-NEXT: [{{0x.*}}, {{0x.*}}): DW_OP_reg0 RAX
;
; Note: This is a location, so we don't want an extra DW_OP_deref at the end.
@ -36,7 +36,7 @@
; ... [rsp+4] DW_OP_deref
;
; CHECK-NEXT: [{{0x.*}}, {{0x.*}}): DW_OP_breg7 RSP+4)
; CHECK-NEXT: DW_AT_name ("val")
; CHECK-NEXT: DW_AT_name {{.*}}"val"
; ModuleID = 'frame.c'
source_filename = "frame.c"

8
llvm/test/DebugInfo/X86/debug-loc-offset.mir
View File

@ -42,8 +42,8 @@
# CHECK: DW_TAG_formal_parameter
# CHECK-NOT: DW_TAG
# CHECK: DW_AT_location [DW_FORM_sec_offset] ({{.*}}
# CHECK-NEXT: [0x00000029, 0x00000037) ".text": DW_OP_breg0 EAX+0, DW_OP_deref
# CHECK-NEXT: [0x00000037, 0x00000063) ".text": DW_OP_breg5 EBP-8, DW_OP_deref, DW_OP_deref
# CHECK-NEXT: [0x00000029, 0x00000037): DW_OP_breg0 EAX+0, DW_OP_deref
# CHECK-NEXT: [0x00000037, 0x00000063): DW_OP_breg5 EBP-8, DW_OP_deref, DW_OP_deref
# CHECK-NEXT: DW_AT_name [DW_FORM_strp]{{.*}}"a"
#
# CHECK: DW_TAG_variable
@ -61,8 +61,8 @@
# CHECK: DW_TAG_formal_parameter
# CHECK-NOT: DW_TAG
# CHECK: DW_AT_location [DW_FORM_sec_offset] ({{.*}}
# CHECK-NEXT: [0x00000000, 0x0000000a) ".text": DW_OP_consts +0, DW_OP_stack_value
# CHECK-NEXT: [0x0000000a, 0x00000017) ".text": DW_OP_consts +1, DW_OP_stack_value)
# CHECK-NEXT: [0x00000000, 0x0000000a): DW_OP_consts +0, DW_OP_stack_value
# CHECK-NEXT: [0x0000000a, 0x00000017): DW_OP_consts +1, DW_OP_stack_value)
# CHECK-NEXT: DW_AT_name [DW_FORM_strp]{{.*}}"b"
#
# CHECK: .debug_loc contents: