[llvm] r313253 - Revert "[dwarfdump] Add DWARF verifiers for address ranges"
David Blaikie via llvm-commits
llvm-commits at lists.llvm.org
Mon Sep 18 11:36:03 PDT 2017
Please mention in revert commit messages the reason for the revert - handy
for spectators and when looking back over the history to see why a change
might be problematic, etc.
On Thu, Sep 14, 2017 at 3:50 AM Jonas Devlieghere via llvm-commits <
llvm-commits at lists.llvm.org> wrote:
> Author: jdevlieghere
> Date: Thu Sep 14 03:49:15 2017
> New Revision: 313253
>
> URL: http://llvm.org/viewvc/llvm-project?rev=313253&view=rev
> Log:
> Revert "[dwarfdump] Add DWARF verifiers for address ranges"
>
> This reverts commit r313250.
>
> Modified:
> llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h
> llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDie.h
> llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFVerifier.h
> llvm/trunk/lib/DebugInfo/DWARF/DWARFVerifier.cpp
> llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
>
> Modified: llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h?rev=313253&r1=313252&r2=313253&view=diff
>
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h
> (original)
> +++ llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h Thu Sep
> 14 03:49:15 2017
> @@ -25,38 +25,8 @@ struct DWARFAddressRange {
> uint64_t LowPC;
> uint64_t HighPC;
> uint64_t SectionIndex;
> -
> - DWARFAddressRange() = default;
> -
> - /// Used for unit testing.
> - 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
> - /// dead-stripped ranges.
> - bool valid() const { return LowPC <= HighPC; }
> -
> - /// Returns true if [LowPC, HighPC) intersects with [RHS.LowPC,
> RHS.HighPC).
> - bool intersects(const DWARFAddressRange &RHS) const {
> - // Empty ranges can't intersect.
> - if (LowPC == HighPC || RHS.LowPC == RHS.HighPC)
> - return false;
> - return (LowPC < RHS.HighPC) && (HighPC > RHS.LowPC);
> - }
> -
> - /// Returns true if [LowPC, HighPC) fully contains [RHS.LowPC,
> RHS.HighPC).
> - bool contains(const DWARFAddressRange &RHS) const {
> - if (LowPC <= RHS.LowPC && RHS.LowPC <= HighPC)
> - return LowPC <= RHS.HighPC && RHS.HighPC <= HighPC;
> - return false;
> - }
> };
>
> -static inline bool operator<(const DWARFAddressRange &LHS,
> - const DWARFAddressRange &RHS) {
> - return std::tie(LHS.LowPC, LHS.HighPC) < std::tie(RHS.LowPC,
> RHS.HighPC);
> -}
> -
> /// DWARFAddressRangesVector - represents a set of absolute address
> ranges.
> using DWARFAddressRangesVector = std::vector<DWARFAddressRange>;
>
>
> Modified: llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDie.h
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDie.h?rev=313253&r1=313252&r2=313253&view=diff
>
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDie.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDie.h Thu Sep 14 03:49:15
> 2017
> @@ -308,10 +308,6 @@ inline bool operator!=(const DWARFDie &L
> return !(LHS == RHS);
> }
>
> -inline bool operator<(const DWARFDie &LHS, const DWARFDie &RHS) {
> - return LHS.getOffset() < RHS.getOffset();
> -}
> -
> class DWARFDie::iterator : public iterator_facade_base<iterator,
>
> std::forward_iterator_tag,
> const DWARFDie> {
>
> Modified: llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFVerifier.h
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFVerifier.h?rev=313253&r1=313252&r2=313253&view=diff
>
> ==============================================================================
> --- llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFVerifier.h (original)
> +++ llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFVerifier.h Thu Sep 14
> 03:49:15 2017
> @@ -11,8 +11,6 @@
> #define LLVM_DEBUGINFO_DWARF_DWARFVERIFIER_H
>
> #include "llvm/DebugInfo/DIContext.h"
> -#include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
> -#include "llvm/DebugInfo/DWARF/DWARFDie.h"
>
> #include <cstdint>
> #include <map>
> @@ -32,61 +30,6 @@ struct DWARFSection;
>
> /// A class that verifies DWARF debug information given a DWARF Context.
> class DWARFVerifier {
> -public:
> - /// A class that keeps the address range information for a single DIE.
> - struct DieRangeInfo {
> - DWARFDie Die;
> -
> - /// Sorted DWARFAddressRanges.
> - std::vector<DWARFAddressRange> Ranges;
> -
> - /// Sorted DWARFAddressRangeInfo.
> - std::set<DieRangeInfo> Children;
> -
> - DieRangeInfo() = default;
> - DieRangeInfo(DWARFDie Die) : Die(Die) {}
> -
> - /// Used for unit testing.
> - DieRangeInfo(std::vector<DWARFAddressRange> Ranges)
> - : Ranges(std::move(Ranges)) {}
> -
> - typedef std::vector<DWARFAddressRange>::const_iterator
> - address_range_iterator;
> - typedef std::set<DieRangeInfo>::const_iterator
> die_range_info_iterator;
> -
> - /// Inserts the address range. If the range overlaps with an existing
> - /// range, the range is *not* added and an iterator to the overlapping
> - /// range is returned.
> - ///
> - /// This is used for finding overlapping ranges within the same DIE.
> - address_range_iterator insert(const DWARFAddressRange &R);
> -
> - /// Finds an address range in the sorted vector of ranges.
> - address_range_iterator findRange(const DWARFAddressRange &R) const {
> - const auto Begin = Ranges.cbegin();
> - const auto End = Ranges.cend();
> - auto Iter = std::upper_bound(Begin, End, R);
> - if (Iter != Begin)
> - --Iter;
> - return Iter;
> - }
> -
> - /// Inserts the address range info. If any of its ranges overlaps
> with a
> - /// range in an existing range info, the range info is *not* added
> and an
> - /// iterator to the overlapping range info.
> - ///
> - /// This is used for finding overlapping children of the same DIE.
> - die_range_info_iterator insert(const DieRangeInfo &RI);
> -
> - /// Return true if ranges in this object contains all ranges within
> RHS.
> - bool contains(const DieRangeInfo &RHS) const;
> -
> - /// Return true if any range in this object intersects with any range
> in
> - /// RHS.
> - bool intersects(const DieRangeInfo &RHS) const;
> - };
> -
> -private:
> raw_ostream &OS;
> DWARFContext &DCtx;
> DIDumpOptions DumpOpts;
> @@ -141,7 +84,7 @@ private:
> /// - cases in which lowPC >= highPC
> ///
> /// \returns Number of errors that occured during verification.
> - unsigned verifyDieRanges(const DWARFDie &Die, DieRangeInfo &ParentRI);
> + unsigned verifyDieRanges(const DWARFDie &Die);
>
> /// Verifies the attribute's DWARF attribute and its value.
> ///
> @@ -253,11 +196,6 @@ public:
> bool handleAccelTables();
> };
>
> -static inline bool operator<(const DWARFVerifier::DieRangeInfo &LHS,
> - const DWARFVerifier::DieRangeInfo &RHS) {
> - return std::tie(LHS.Ranges, LHS.Die) < std::tie(RHS.Ranges, RHS.Die);
> -}
> -
> } // end namespace llvm
>
> #endif // LLVM_DEBUGINFO_DWARF_DWARFCONTEXT_H
>
> Modified: llvm/trunk/lib/DebugInfo/DWARF/DWARFVerifier.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/DWARF/DWARFVerifier.cpp?rev=313253&r1=313252&r2=313253&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/DebugInfo/DWARF/DWARFVerifier.cpp (original)
> +++ llvm/trunk/lib/DebugInfo/DWARF/DWARFVerifier.cpp Thu Sep 14 03:49:15
> 2017
> @@ -24,83 +24,6 @@ using namespace llvm;
> using namespace dwarf;
> using namespace object;
>
> -DWARFVerifier::DieRangeInfo::address_range_iterator
> -DWARFVerifier::DieRangeInfo::insert(const DWARFAddressRange &R) {
> - const auto Begin = Ranges.cbegin();
> - const auto End = Ranges.cend();
> - auto Pos = std::lower_bound(Begin, End, R);
> -
> - if (Pos != End) {
> - if (Pos->intersects(R))
> - return Pos;
> - if (Pos != Begin) {
> - auto Iter = Pos - 1;
> - if (Iter->intersects(R))
> - return Iter;
> - }
> - }
> -
> - Ranges.insert(Pos, R);
> - return Ranges.cend();
> -}
> -
> -DWARFVerifier::DieRangeInfo::die_range_info_iterator
> -DWARFVerifier::DieRangeInfo::insert(const DieRangeInfo &RI) {
> - const auto End = Children.end();
> - auto Iter = Children.begin();
> - while (Iter != End) {
> - if (Iter->intersects(RI))
> - return Iter;
> - ++Iter;
> - }
> - Children.insert(RI);
> - return Children.cend();
> -}
> -
> -bool DWARFVerifier::DieRangeInfo::contains(const DieRangeInfo &RHS) const
> {
> - // Both list of ranges are sorted so we can make this fast.
> -
> - if (Ranges.empty() || RHS.Ranges.empty())
> - return false;
> -
> - // Since the ranges are sorted we can advance where we start searching
> with
> - // this object's ranges as we traverse RHS.Ranges.
> - const auto End = Ranges.cend();
> - auto Iter = findRange(RHS.Ranges.front());
> -
> - // Now linearly walk the ranges in this object and see if they contain
> each
> - // ranges from RHS.Ranges.
> - for (const auto &R : RHS.Ranges) {
> - while (Iter != End) {
> - if (Iter->contains(R))
> - break;
> - ++Iter;
> - }
> - if (Iter == End)
> - return false;
> - }
> - return true;
> -}
> -
> -bool DWARFVerifier::DieRangeInfo::intersects(const DieRangeInfo &RHS)
> const {
> - if (Ranges.empty() || RHS.Ranges.empty())
> - return false;
> -
> - const auto End = Ranges.end();
> - auto Iter = findRange(RHS.Ranges.front());
> - for (const auto &R : RHS.Ranges) {
> - if (R.HighPC <= Iter->LowPC)
> - continue;
> - while (Iter != End) {
> - if (Iter->intersects(R))
> - return true;
> - ++Iter;
> - }
> - }
> -
> - return false;
> -}
> -
> bool DWARFVerifier::verifyUnitHeader(const DWARFDataExtractor
> DebugInfoData,
> uint32_t *Offset, unsigned UnitIndex,
> uint8_t &UnitType, bool
> &isUnitDWARF64) {
> @@ -171,15 +94,12 @@ bool DWARFVerifier::verifyUnitContents(D
> auto Die = Unit.getDIEAtIndex(I);
> if (Die.getTag() == DW_TAG_null)
> continue;
> + NumUnitErrors += verifyDieRanges(Die);
> for (auto AttrValue : Die.attributes()) {
> NumUnitErrors += verifyDebugInfoAttribute(Die, AttrValue);
> NumUnitErrors += verifyDebugInfoForm(Die, AttrValue);
> }
> }
> -
> - DieRangeInfo RI;
> - DWARFDie Die = Unit.getUnitDIE(/* ExtractUnitDIEOnly = */ false);
> - NumUnitErrors += verifyDieRanges(Die, RI);
> return NumUnitErrors == 0;
> }
>
> @@ -290,67 +210,16 @@ bool DWARFVerifier::handleDebugInfo() {
> return (isHeaderChainValid && NumDebugInfoErrors == 0);
> }
>
> -unsigned DWARFVerifier::verifyDieRanges(const DWARFDie &Die,
> - DieRangeInfo &ParentRI) {
> +unsigned DWARFVerifier::verifyDieRanges(const DWARFDie &Die) {
> unsigned NumErrors = 0;
> -
> - if (!Die.isValid())
> - return NumErrors;
> -
> - DWARFAddressRangesVector Ranges = Die.getAddressRanges();
> -
> - // Build RI for this DIE and check that ranges within this DIE do not
> - // overlap.
> - DieRangeInfo RI(Die);
> - for (auto Range : Ranges) {
> - if (!Range.valid()) {
> + for (auto Range : Die.getAddressRanges()) {
> + if (Range.LowPC >= Range.HighPC) {
> ++NumErrors;
> OS << format("error: Invalid address range [0x%08" PRIx64
> " - 0x%08" PRIx64 "].\n",
> Range.LowPC, Range.HighPC);
> - continue;
> }
> -
> - // Verify that ranges don't intersect.
> - const auto IntersectingRange = RI.insert(Range);
> - if (IntersectingRange != RI.Ranges.cend()) {
> - ++NumErrors;
> - OS << format("error: DIE has overlapping address ranges: [0x%08"
> PRIx64
> - " - 0x%08" PRIx64 "] and [0x%08" PRIx64 " - 0x%08"
> PRIx64
> - "].\n",
> - Range.LowPC, Range.HighPC, IntersectingRange->LowPC,
> - IntersectingRange->HighPC);
> - break;
> - }
> - }
> -
> - // Verify that children don't intersect.
> - const auto IntersectingChild = ParentRI.insert(RI);
> - if (IntersectingChild != ParentRI.Children.cend()) {
> - ++NumErrors;
> - OS << "error: DIEs have overlapping address ranges:";
> - Die.dump(OS, 0);
> - IntersectingChild->Die.dump(OS, 0);
> - OS << "\n";
> }
> -
> - // Verify that ranges are contained within their parent.
> - bool ShouldBeContained = !Ranges.empty() && !ParentRI.Ranges.empty() &&
> - !(Die.getTag() == DW_TAG_subprogram &&
> - ParentRI.Die.getTag() == DW_TAG_subprogram);
> - if (ShouldBeContained && !ParentRI.contains(RI)) {
> - ++NumErrors;
> - OS << "error: DIE address ranges are not "
> - "contained in its parent's ranges:";
> - Die.dump(OS, 0);
> - ParentRI.Die.dump(OS, 0);
> - OS << "\n";
> - }
> -
> - // Recursively check children.
> - for (DWARFDie Child : Die)
> - NumErrors += verifyDieRanges(Child, RI);
> -
> return NumErrors;
> }
>
>
> Modified: llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp?rev=313253&r1=313252&r2=313253&view=diff
>
> ==============================================================================
> --- llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp (original)
> +++ llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp Thu Sep 14
> 03:49:15 2017
> @@ -20,7 +20,6 @@
> #include "llvm/DebugInfo/DWARF/DWARFContext.h"
> #include "llvm/DebugInfo/DWARF/DWARFDie.h"
> #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
> -#include "llvm/DebugInfo/DWARF/DWARFVerifier.h"
> #include "llvm/MC/MCContext.h"
> #include "llvm/MC/MCSectionELF.h"
> #include "llvm/MC/MCStreamer.h"
> @@ -1673,15 +1672,9 @@ void VerifyError(DWARFContext &DwarfCont
> EXPECT_TRUE(Str.str().contains(Error));
> }
>
> -void VerifySuccess(DWARFContext &DwarfContext) {
> - SmallString<1024> Str;
> - raw_svector_ostream Strm(Str);
> - EXPECT_TRUE(DwarfContext.verify(Strm, DIDT_All));
> -}
> -
> TEST(DWARFDebugInfo, TestDwarfVerifyInvalidCURef) {
> // Create a single compile unit with a single function that has a
> DW_AT_type
> - // that is CU relative. The CU offset is not valid because it is larger
> than
> + // that is CU relative. The CU offset is not valid becuase it is larger
> than
> // the compile unit itself.
>
> const char *yamldata = R"(
> @@ -2354,643 +2347,4 @@ TEST(DWARFDebugInfo, TestErrorReportingP
> EXPECT_TRUE(Errors == 1);
> }
>
> -TEST(DWARFDebugInfo, TestDwarfVerifyCURangesIncomplete) {
> - // Create a single compile unit with a single function. The compile
> - // unit has a DW_AT_ranges attribute that doesn't fully contain the
> - // address range of the function. The verification should fail due to
> - // the CU ranges not containing all of the address ranges of all of the
> - // functions.
> - StringRef yamldata = R"(
> - debug_str:
> - - ''
> - - /tmp/main.c
> - debug_abbrev:
> - - Code: 0x00000001
> - Tag: DW_TAG_compile_unit
> - Children: DW_CHILDREN_yes
> - Attributes:
> - - Attribute: DW_AT_low_pc
> - Form: DW_FORM_addr
> - - Attribute: DW_AT_high_pc
> - Form: DW_FORM_addr
> - - Attribute: DW_AT_name
> - Form: DW_FORM_strp
> - - Code: 0x00000002
> - Tag: DW_TAG_subprogram
> - Children: DW_CHILDREN_no
> - Attributes:
> - - Attribute: DW_AT_low_pc
> - Form: DW_FORM_addr
> - - Attribute: DW_AT_high_pc
> - Form: DW_FORM_addr
> - debug_info:
> - - Length:
> - TotalLength: 46
> - Version: 4
> - AbbrOffset: 0
> - AddrSize: 8
> - Entries:
> - - AbbrCode: 0x00000001
> - Values:
> - - Value: 0x0000000000001000
> - - Value: 0x0000000000001500
> - - Value: 0x0000000000000001
> - - AbbrCode: 0x00000002
> - Values:
> - - Value: 0x0000000000001000
> - - Value: 0x0000000000002000
> - - AbbrCode: 0x00000000
> - Values:
> - )";
> - auto ErrOrSections = DWARFYAML::EmitDebugSections(yamldata);
> - ASSERT_TRUE((bool)ErrOrSections);
> - std::unique_ptr<DWARFContext> DwarfContext =
> - DWARFContext::create(*ErrOrSections, 8);
> - VerifyError(*DwarfContext, "error: DIE address ranges are not "
> - "contained in its parent's ranges:");
> -}
> -
> -TEST(DWARFDebugInfo, TestDwarfVerifyLexicalBlockRanges) {
> - // Create a single compile unit with a single function that has a
> lexical
> - // block whose address range is not contained in the function address
> range.
> - StringRef yamldata = R"(
> - debug_str:
> - - ''
> - - /tmp/main.c
> - - main
> - debug_abbrev:
> - - Code: 0x00000001
> - Tag: DW_TAG_compile_unit
> - Children: DW_CHILDREN_yes
> - Attributes:
> - - Attribute: DW_AT_name
> - Form: DW_FORM_strp
> - - Code: 0x00000002
> - Tag: DW_TAG_subprogram
> - Children: DW_CHILDREN_yes
> - Attributes:
> - - Attribute: DW_AT_name
> - Form: DW_FORM_strp
> - - Attribute: DW_AT_low_pc
> - Form: DW_FORM_addr
> - - Attribute: DW_AT_high_pc
> - Form: DW_FORM_addr
> - - Code: 0x00000003
> - Tag: DW_TAG_lexical_block
> - Children: DW_CHILDREN_no
> - Attributes:
> - - Attribute: DW_AT_low_pc
> - Form: DW_FORM_addr
> - - Attribute: DW_AT_high_pc
> - Form: DW_FORM_addr
> - debug_info:
> - - Length:
> - TotalLength: 52
> - Version: 4
> - AbbrOffset: 0
> - AddrSize: 8
> - Entries:
> - - AbbrCode: 0x00000001
> - Values:
> - - Value: 0x0000000000000001
> - - AbbrCode: 0x00000002
> - Values:
> - - Value: 0x000000000000000D
> - - Value: 0x0000000000001000
> - - Value: 0x0000000000002000
> - - AbbrCode: 0x00000003
> - Values:
> - - Value: 0x0000000000001000
> - - Value: 0x0000000000002001
> - - AbbrCode: 0x00000000
> - Values:
> - - AbbrCode: 0x00000000
> - Values:
> - )";
> - auto ErrOrSections = DWARFYAML::EmitDebugSections(yamldata);
> - ASSERT_TRUE((bool)ErrOrSections);
> - std::unique_ptr<DWARFContext> DwarfContext =
> - DWARFContext::create(*ErrOrSections, 8);
> - VerifyError(*DwarfContext, "error: DIE address ranges are not "
> - "contained in its parent's ranges:");
> -}
> -
> -TEST(DWARFDebugInfo, TestDwarfVerifyOverlappingFunctionRanges) {
> - // Create a single compile unit with a two functions that have
> overlapping
> - // address ranges.
> - StringRef yamldata = R"(
> - debug_str:
> - - ''
> - - /tmp/main.c
> - - main
> - - foo
> - debug_abbrev:
> - - Code: 0x00000001
> - Tag: DW_TAG_compile_unit
> - Children: DW_CHILDREN_yes
> - Attributes:
> - - Attribute: DW_AT_name
> - Form: DW_FORM_strp
> - - Code: 0x00000002
> - Tag: DW_TAG_subprogram
> - Children: DW_CHILDREN_no
> - Attributes:
> - - Attribute: DW_AT_name
> - Form: DW_FORM_strp
> - - Attribute: DW_AT_low_pc
> - Form: DW_FORM_addr
> - - Attribute: DW_AT_high_pc
> - Form: DW_FORM_addr
> - debug_info:
> - - Length:
> - TotalLength: 55
> - Version: 4
> - AbbrOffset: 0
> - AddrSize: 8
> - Entries:
> - - AbbrCode: 0x00000001
> - Values:
> - - Value: 0x0000000000000001
> - - AbbrCode: 0x00000002
> - Values:
> - - Value: 0x000000000000000D
> - - Value: 0x0000000000001000
> - - Value: 0x0000000000002000
> - - AbbrCode: 0x00000002
> - Values:
> - - Value: 0x0000000000000012
> - - Value: 0x0000000000001FFF
> - - Value: 0x0000000000002000
> - - AbbrCode: 0x00000000
> - Values:
> - )";
> - auto ErrOrSections = DWARFYAML::EmitDebugSections(yamldata);
> - ASSERT_TRUE((bool)ErrOrSections);
> - std::unique_ptr<DWARFContext> DwarfContext =
> - DWARFContext::create(*ErrOrSections, 8);
> - VerifyError(*DwarfContext, "error: DIEs have overlapping address
> ranges:");
> -}
> -
> -TEST(DWARFDebugInfo, TestDwarfVerifyOverlappingLexicalBlockRanges) {
> - // Create a single compile unit with a one function that has two lexical
> - // blocks with overlapping address ranges.
> - StringRef yamldata = R"(
> - debug_str:
> - - ''
> - - /tmp/main.c
> - - main
> - debug_abbrev:
> - - Code: 0x00000001
> - Tag: DW_TAG_compile_unit
> - Children: DW_CHILDREN_yes
> - Attributes:
> - - Attribute: DW_AT_low_pc
> - Form: DW_FORM_addr
> - - Attribute: DW_AT_high_pc
> - Form: DW_FORM_addr
> - - Attribute: DW_AT_name
> - Form: DW_FORM_strp
> - - Code: 0x00000002
> - Tag: DW_TAG_subprogram
> - Children: DW_CHILDREN_yes
> - Attributes:
> - - Attribute: DW_AT_name
> - Form: DW_FORM_strp
> - - Attribute: DW_AT_low_pc
> - Form: DW_FORM_addr
> - - Attribute: DW_AT_high_pc
> - Form: DW_FORM_addr
> - - Code: 0x00000003
> - Tag: DW_TAG_lexical_block
> - Children: DW_CHILDREN_no
> - Attributes:
> - - Attribute: DW_AT_low_pc
> - Form: DW_FORM_addr
> - - Attribute: DW_AT_high_pc
> - Form: DW_FORM_addr
> - debug_info:
> - - Length:
> - TotalLength: 85
> - Version: 4
> - AbbrOffset: 0
> - AddrSize: 8
> - Entries:
> - - AbbrCode: 0x00000001
> - Values:
> - - Value: 0x0000000000001000
> - - Value: 0x0000000000002000
> - - Value: 0x0000000000000001
> - - AbbrCode: 0x00000002
> - Values:
> - - Value: 0x000000000000000D
> - - Value: 0x0000000000001000
> - - Value: 0x0000000000002000
> - - AbbrCode: 0x00000003
> - Values:
> - - Value: 0x0000000000001100
> - - Value: 0x0000000000001300
> - - AbbrCode: 0x00000003
> - Values:
> - - Value: 0x00000000000012FF
> - - Value: 0x0000000000001300
> - - AbbrCode: 0x00000000
> - Values:
> - - AbbrCode: 0x00000000
> - Values:
> - )";
> - auto ErrOrSections = DWARFYAML::EmitDebugSections(yamldata);
> - ASSERT_TRUE((bool)ErrOrSections);
> - std::unique_ptr<DWARFContext> DwarfContext =
> - DWARFContext::create(*ErrOrSections, 8);
> - VerifyError(*DwarfContext, "error: DIEs have overlapping address
> ranges:");
> -}
> -
> -TEST(DWARFDebugInfo, TestDwarfVerifyInvalidDIERange) {
> - // Create a single compile unit with a single function that has an
> invalid
> - // address range where the high PC is smaller than the low PC.
> - StringRef yamldata = R"(
> - debug_str:
> - - ''
> - - /tmp/main.c
> - - main
> - debug_abbrev:
> - - Code: 0x00000001
> - Tag: DW_TAG_compile_unit
> - Children: DW_CHILDREN_yes
> - Attributes:
> - - Attribute: DW_AT_name
> - Form: DW_FORM_strp
> - - Code: 0x00000002
> - Tag: DW_TAG_subprogram
> - Children: DW_CHILDREN_no
> - Attributes:
> - - Attribute: DW_AT_name
> - Form: DW_FORM_strp
> - - Attribute: DW_AT_low_pc
> - Form: DW_FORM_addr
> - - Attribute: DW_AT_high_pc
> - Form: DW_FORM_addr
> - debug_info:
> - - Length:
> - TotalLength: 34
> - Version: 4
> - AbbrOffset: 0
> - AddrSize: 8
> - Entries:
> - - AbbrCode: 0x00000001
> - Values:
> - - Value: 0x0000000000000001
> - - AbbrCode: 0x00000002
> - Values:
> - - Value: 0x000000000000000D
> - - Value: 0x0000000000001000
> - - Value: 0x0000000000000900
> - - AbbrCode: 0x00000000
> - Values:
> - )";
> - auto ErrOrSections = DWARFYAML::EmitDebugSections(yamldata);
> - ASSERT_TRUE((bool)ErrOrSections);
> - std::unique_ptr<DWARFContext> DwarfContext =
> - DWARFContext::create(*ErrOrSections, 8);
> - VerifyError(*DwarfContext, "error: Invalid address range");
> -}
> -
> -TEST(DWARFDebugInfo, TestDwarfVerifyElidedDoesntFail) {
> - // Create a single compile unit with two functions: one that has a
> valid range
> - // and one whose low and high PC are the same. When the low and high PC
> are
> - // the same, this indicates the function was dead code stripped. We
> want to
> - // ensure that verification succeeds.
> - StringRef yamldata = R"(
> - debug_str:
> - - ''
> - - /tmp/main.c
> - - main
> - - elided
> - debug_abbrev:
> - - Code: 0x00000001
> - Tag: DW_TAG_compile_unit
> - Children: DW_CHILDREN_yes
> - Attributes:
> - - Attribute: DW_AT_low_pc
> - Form: DW_FORM_addr
> - - Attribute: DW_AT_high_pc
> - Form: DW_FORM_addr
> - - Attribute: DW_AT_name
> - Form: DW_FORM_strp
> - - Code: 0x00000002
> - Tag: DW_TAG_subprogram
> - Children: DW_CHILDREN_no
> - Attributes:
> - - Attribute: DW_AT_name
> - Form: DW_FORM_strp
> - - Attribute: DW_AT_low_pc
> - Form: DW_FORM_addr
> - - Attribute: DW_AT_high_pc
> - Form: DW_FORM_addr
> - debug_info:
> - - Length:
> - TotalLength: 71
> - Version: 4
> - AbbrOffset: 0
> - AddrSize: 8
> - Entries:
> - - AbbrCode: 0x00000001
> - Values:
> - - Value: 0x0000000000001000
> - - Value: 0x0000000000002000
> - - Value: 0x0000000000000001
> - - AbbrCode: 0x00000002
> - Values:
> - - Value: 0x000000000000000D
> - - Value: 0x0000000000001000
> - - Value: 0x0000000000002000
> - - AbbrCode: 0x00000002
> - Values:
> - - Value: 0x0000000000000012
> - - Value: 0x0000000000002000
> - - Value: 0x0000000000002000
> - - AbbrCode: 0x00000000
> - Values:
> - )";
> - auto ErrOrSections = DWARFYAML::EmitDebugSections(yamldata);
> - ASSERT_TRUE((bool)ErrOrSections);
> - std::unique_ptr<DWARFContext> DwarfContext =
> - DWARFContext::create(*ErrOrSections, 8);
> - VerifySuccess(*DwarfContext);
> -}
> -
> -TEST(DWARFDebugInfo, TestDwarfVerifyNestedFunctions) {
> - // Create a single compile unit with a nested function which is not
> contained
> - // in its parent. Although LLVM doesn't generate this, it is valid
> accoridng
> - // to the DWARF standard.
> - StringRef yamldata = R"(
> - debug_str:
> - - ''
> - - /tmp/main.c
> - - main
> - - nested
> - debug_abbrev:
> - - Code: 0x00000001
> - Tag: DW_TAG_compile_unit
> - Children: DW_CHILDREN_yes
> - Attributes:
> - - Attribute: DW_AT_low_pc
> - Form: DW_FORM_addr
> - - Attribute: DW_AT_high_pc
> - Form: DW_FORM_addr
> - - Attribute: DW_AT_name
> - Form: DW_FORM_strp
> - - Code: 0x00000002
> - Tag: DW_TAG_subprogram
> - Children: DW_CHILDREN_yes
> - Attributes:
> - - Attribute: DW_AT_name
> - Form: DW_FORM_strp
> - - Attribute: DW_AT_low_pc
> - Form: DW_FORM_addr
> - - Attribute: DW_AT_high_pc
> - Form: DW_FORM_addr
> - debug_info:
> - - Length:
> - TotalLength: 73
> - Version: 4
> - AbbrOffset: 0
> - AddrSize: 8
> - Entries:
> - - AbbrCode: 0x00000001
> - Values:
> - - Value: 0x0000000000001000
> - - Value: 0x0000000000002000
> - - Value: 0x0000000000000001
> - - AbbrCode: 0x00000002
> - Values:
> - - Value: 0x000000000000000D
> - - Value: 0x0000000000001000
> - - Value: 0x0000000000001500
> - - AbbrCode: 0x00000002
> - Values:
> - - Value: 0x0000000000000012
> - - Value: 0x0000000000001500
> - - Value: 0x0000000000002000
> - - AbbrCode: 0x00000000
> - Values:
> - - AbbrCode: 0x00000000
> - Values:
> - - AbbrCode: 0x00000000
> - Values:
> - )";
> - auto ErrOrSections = DWARFYAML::EmitDebugSections(yamldata);
> - ASSERT_TRUE((bool)ErrOrSections);
> - std::unique_ptr<DWARFContext> DwarfContext =
> - DWARFContext::create(*ErrOrSections, 8);
> - VerifySuccess(*DwarfContext);
> -}
> -
> -TEST(DWARFDebugInfo, TestDwarfRangesContains) {
> - DWARFAddressRange R(0x10, 0x20);
> -
> - //----------------------------------------------------------------------
> - // Test ranges that start before R...
> - //----------------------------------------------------------------------
> - // Other range ends before start of R
> - ASSERT_FALSE(R.contains({0x0f, 0x10}));
> - // Other range end address is start of a R
> - ASSERT_FALSE(R.contains({0x0f, 0x11}));
> - // Other range end address is at and of R
> - ASSERT_FALSE(R.contains({0x0f, 0x20}));
> - // Other range end address is past end of R
> - ASSERT_FALSE(R.contains({0x0f, 0x40}));
> -
> - //----------------------------------------------------------------------
> - // Test ranges that start at R's start address
> - //----------------------------------------------------------------------
> - // Ensure empty ranges matches
> - ASSERT_TRUE(R.contains({0x10, 0x10}));
> - // 1 byte of Range
> - ASSERT_TRUE(R.contains({0x10, 0x11}));
> - // same as Range
> - ASSERT_TRUE(R.contains({0x10, 0x20}));
> - // 1 byte past Range
> - ASSERT_FALSE(R.contains({0x10, 0x21}));
> -
> - //----------------------------------------------------------------------
> - // Test ranges that start inside Range
> - //----------------------------------------------------------------------
> - // empty in range
> - ASSERT_TRUE(R.contains({0x11, 0x11}));
> - // all in Range
> - ASSERT_TRUE(R.contains({0x11, 0x1f}));
> - // ends at end of Range
> - ASSERT_TRUE(R.contains({0x11, 0x20}));
> - // ends past Range
> - ASSERT_FALSE(R.contains({0x11, 0x21}));
> -
> - //----------------------------------------------------------------------
> - // Test ranges that start at last bytes of Range
> - //----------------------------------------------------------------------
> - // ends at end of Range
> - ASSERT_TRUE(R.contains({0x1f, 0x20}));
> - // ends past Range
> - ASSERT_FALSE(R.contains({0x1f, 0x21}));
> -
> - //----------------------------------------------------------------------
> - // Test ranges that start after Range
> - //----------------------------------------------------------------------
> - // empty considered in Range
> - ASSERT_TRUE(R.contains({0x20, 0x20}));
> - // valid past Range
> - ASSERT_FALSE(R.contains({0x20, 0x21}));
> -}
> -
> -TEST(DWARFDebugInfo, TestDWARFDieRangeInfoContains) {
> - DWARFVerifier::DieRangeInfo Ranges({{0x10, 0x20}, {0x30, 0x40}});
> -
> - ASSERT_FALSE(Ranges.contains({{{0x0f, 0x10}}}));
> - ASSERT_FALSE(Ranges.contains({{{0x20, 0x30}}}));
> - ASSERT_FALSE(Ranges.contains({{{0x40, 0x41}}}));
> - ASSERT_TRUE(Ranges.contains({{{0x10, 0x20}}}));
> - ASSERT_TRUE(Ranges.contains({{{0x11, 0x12}}}));
> - ASSERT_TRUE(Ranges.contains({{{0x1f, 0x20}}}));
> - ASSERT_TRUE(Ranges.contains({{{0x30, 0x40}}}));
> - ASSERT_TRUE(Ranges.contains({{{0x31, 0x32}}}));
> - ASSERT_TRUE(Ranges.contains({{{0x3f, 0x40}}}));
> - ASSERT_TRUE(Ranges.contains({{{0x10, 0x20}, {0x30, 0x40}}}));
> - ASSERT_TRUE(Ranges.contains({{{0x11, 0x12}, {0x31, 0x32}}}));
> - ASSERT_TRUE(Ranges.contains(
> - {{{0x11, 0x12}, {0x12, 0x13}, {0x31, 0x32}, {0x32, 0x33}}}));
> - ASSERT_FALSE(Ranges.contains({{{0x11, 0x12},
> - {0x12, 0x13},
> - {0x20, 0x21},
> - {0x31, 0x32},
> - {0x32, 0x33}}}));
> - ASSERT_FALSE(Ranges.contains(
> - {{{0x11, 0x12}, {0x12, 0x13}, {0x31, 0x32}, {0x32, 0x41}}}));
> -}
> -
> -namespace {
> -
> -void AssertRangesIntersect(const DWARFAddressRange &LHS,
> - const DWARFAddressRange &RHS) {
> - ASSERT_TRUE(LHS.intersects(RHS));
> - ASSERT_TRUE(RHS.intersects(LHS));
> -}
> -void AssertRangesDontIntersect(const DWARFAddressRange &LHS,
> - const DWARFAddressRange &RHS) {
> - ASSERT_FALSE(LHS.intersects(RHS));
> - ASSERT_FALSE(RHS.intersects(LHS));
> -}
> -
> -void AssertRangesIntersect(const DWARFVerifier::DieRangeInfo &LHS,
> - const DWARFAddressRangesVector &Ranges) {
> - DWARFVerifier::DieRangeInfo RHS(Ranges);
> - ASSERT_TRUE(LHS.intersects(RHS));
> - ASSERT_TRUE(RHS.intersects(LHS));
> -}
> -
> -void AssertRangesDontIntersect(const DWARFVerifier::DieRangeInfo &LHS,
> - const DWARFAddressRangesVector &Ranges) {
> - DWARFVerifier::DieRangeInfo RHS(Ranges);
> - ASSERT_FALSE(LHS.intersects(RHS));
> - ASSERT_FALSE(RHS.intersects(LHS));
> -}
> -
> -} // namespace
> -TEST(DWARFDebugInfo, TestDwarfRangesIntersect) {
> - DWARFAddressRange R(0x10, 0x20);
> -
> - //----------------------------------------------------------------------
> - // Test ranges that start before R...
> - //----------------------------------------------------------------------
> - // Other range ends before start of R
> - AssertRangesDontIntersect(R, {0x00, 0x10});
> - // Other range end address is start of a R
> - AssertRangesIntersect(R, {0x00, 0x11});
> - // Other range end address is in R
> - AssertRangesIntersect(R, {0x00, 0x15});
> - // Other range end address is at and of R
> - AssertRangesIntersect(R, {0x00, 0x20});
> - // Other range end address is past end of R
> - AssertRangesIntersect(R, {0x00, 0x40});
> -
> - //----------------------------------------------------------------------
> - // Test ranges that start at R's start address
> - //----------------------------------------------------------------------
> - // Ensure empty ranges doesn't match
> - AssertRangesDontIntersect(R, {0x10, 0x10});
> - // 1 byte of Range
> - AssertRangesIntersect(R, {0x10, 0x11});
> - // same as Range
> - AssertRangesIntersect(R, {0x10, 0x20});
> - // 1 byte past Range
> - AssertRangesIntersect(R, {0x10, 0x21});
> -
> - //----------------------------------------------------------------------
> - // Test ranges that start inside Range
> - //----------------------------------------------------------------------
> - // empty in range
> - AssertRangesDontIntersect(R, {0x11, 0x11});
> - // all in Range
> - AssertRangesIntersect(R, {0x11, 0x1f});
> - // ends at end of Range
> - AssertRangesIntersect(R, {0x11, 0x20});
> - // ends past Range
> - AssertRangesIntersect(R, {0x11, 0x21});
> -
> - //----------------------------------------------------------------------
> - // Test ranges that start at last bytes of Range
> - //----------------------------------------------------------------------
> - // ends at end of Range
> - AssertRangesIntersect(R, {0x1f, 0x20});
> - // ends past Range
> - AssertRangesIntersect(R, {0x1f, 0x21});
> -
> - //----------------------------------------------------------------------
> - // Test ranges that start after Range
> - //----------------------------------------------------------------------
> - // empty just past in Range
> - AssertRangesDontIntersect(R, {0x20, 0x20});
> - // valid past Range
> - AssertRangesDontIntersect(R, {0x20, 0x21});
> -}
> -
> -TEST(DWARFDebugInfo, TestDWARFDieRangeInfoIntersects) {
> -
> - DWARFVerifier::DieRangeInfo Ranges({{0x10, 0x20}, {0x30, 0x40}});
> -
> - // Test empty range
> - AssertRangesDontIntersect(Ranges, {});
> - // Test range that appears before all ranges in Ranges
> - AssertRangesDontIntersect(Ranges, {{0x00, 0x10}});
> - // Test range that appears between ranges in Ranges
> - AssertRangesDontIntersect(Ranges, {{0x20, 0x30}});
> - // Test range that appears after ranges in Ranges
> - AssertRangesDontIntersect(Ranges, {{0x40, 0x50}});
> -
> - // Test range that start before first range
> - AssertRangesIntersect(Ranges, {{0x00, 0x11}});
> - // Test range that start at first range
> - AssertRangesIntersect(Ranges, {{0x10, 0x11}});
> - // Test range that start in first range
> - AssertRangesIntersect(Ranges, {{0x11, 0x12}});
> - // Test range that start at end of first range
> - AssertRangesIntersect(Ranges, {{0x1f, 0x20}});
> - // Test range that starts at end of first range
> - AssertRangesDontIntersect(Ranges, {{0x20, 0x21}});
> - // Test range that starts at end of first range
> - AssertRangesIntersect(Ranges, {{0x20, 0x31}});
> -
> - // Test range that start before second range and ends before second
> - AssertRangesDontIntersect(Ranges, {{0x2f, 0x30}});
> - // Test range that start before second range and ends in second
> - AssertRangesIntersect(Ranges, {{0x2f, 0x31}});
> - // Test range that start at second range
> - AssertRangesIntersect(Ranges, {{0x30, 0x31}});
> - // Test range that start in second range
> - AssertRangesIntersect(Ranges, {{0x31, 0x32}});
> - // Test range that start at end of second range
> - AssertRangesIntersect(Ranges, {{0x3f, 0x40}});
> - // Test range that starts at end of second range
> - AssertRangesDontIntersect(Ranges, {{0x40, 0x41}});
> -}
> -
> } // end anonymous namespace
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20170918/888f3f31/attachment.html>
More information about the llvm-commits
mailing list