Coverage Report

Created: 2022-01-18 06:27

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugArangeSet.cpp
Line
Count
Source (jump to first uncovered line)
1
//===-- DWARFDebugArangeSet.cpp -------------------------------------------===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
9
#include "DWARFDebugArangeSet.h"
10
#include "DWARFDataExtractor.h"
11
#include "LogChannelDWARF.h"
12
#include "llvm/Object/Error.h"
13
#include <cassert>
14
15
using namespace lldb_private;
16
17
DWARFDebugArangeSet::DWARFDebugArangeSet()
18
2.63k
    : m_offset(DW_INVALID_OFFSET), m_next_offset(DW_INVALID_OFFSET) {}
19
20
1.21k
void DWARFDebugArangeSet::Clear() {
21
1.21k
  m_offset = DW_INVALID_OFFSET;
22
1.21k
  m_next_offset = DW_INVALID_OFFSET;
23
1.21k
  m_header.length = 0;
24
1.21k
  m_header.version = 0;
25
1.21k
  m_header.cu_offset = 0;
26
1.21k
  m_header.addr_size = 0;
27
1.21k
  m_header.seg_size = 0;
28
1.21k
  m_arange_descriptors.clear();
29
1.21k
}
30
31
llvm::Error DWARFDebugArangeSet::extract(const DWARFDataExtractor &data,
32
1.21k
                                         lldb::offset_t *offset_ptr) {
33
1.21k
  assert(data.ValidOffset(*offset_ptr));
34
35
0
  m_arange_descriptors.clear();
36
1.21k
  m_offset = *offset_ptr;
37
38
  // 7.20 Address Range Table
39
  //
40
  // Each set of entries in the table of address ranges contained in the
41
  // .debug_aranges section begins with a header consisting of: a 4-byte
42
  // length containing the length of the set of entries for this compilation
43
  // unit, not including the length field itself; a 2-byte version identifier
44
  // containing the value 2 for DWARF Version 2; a 4-byte offset into
45
  // the.debug_infosection; a 1-byte unsigned integer containing the size in
46
  // bytes of an address (or the offset portion of an address for segmented
47
  // addressing) on the target system; and a 1-byte unsigned integer
48
  // containing the size in bytes of a segment descriptor on the target
49
  // system. This header is followed by a series of tuples. Each tuple
50
  // consists of an address and a length, each in the size appropriate for an
51
  // address on the target architecture.
52
1.21k
  m_header.length = data.GetDWARFInitialLength(offset_ptr);
53
  // The length could be 4 bytes or 12 bytes, so use the current offset to
54
  // determine the next offset correctly.
55
1.21k
  if (m_header.length > 0)
56
1.21k
    m_next_offset = *offset_ptr + m_header.length;
57
0
  else
58
0
    m_next_offset = DW_INVALID_OFFSET;
59
1.21k
  m_header.version = data.GetU16(offset_ptr);
60
1.21k
  m_header.cu_offset = data.GetDWARFOffset(offset_ptr);
61
1.21k
  m_header.addr_size = data.GetU8(offset_ptr);
62
1.21k
  m_header.seg_size = data.GetU8(offset_ptr);
63
64
  // Try to avoid reading invalid arange sets by making sure:
65
  // 1 - the version looks good
66
  // 2 - the address byte size looks plausible
67
  // 3 - the length seems to make sense
68
  // 4 - size looks plausible
69
  // 5 - the arange tuples do not contain a segment field
70
1.21k
  if (m_header.version < 2 || m_header.version > 5)
71
1
    return llvm::make_error<llvm::object::GenericBinaryError>(
72
1
        "Invalid arange header version");
73
74
1.21k
  if (m_header.addr_size != 4 && 
m_header.addr_size != 81.20k
)
75
0
    return llvm::make_error<llvm::object::GenericBinaryError>(
76
0
        "Invalid arange header address size");
77
78
1.21k
  if (m_header.length == 0)
79
0
    return llvm::make_error<llvm::object::GenericBinaryError>(
80
0
        "Invalid arange header length");
81
82
1.21k
  if (!data.ValidOffset(m_offset + sizeof(m_header.length) + m_header.length -
83
1.21k
                        1))
84
0
    return llvm::make_error<llvm::object::GenericBinaryError>(
85
0
        "Invalid arange header length");
86
87
1.21k
  if (m_header.seg_size)
88
1
    return llvm::make_error<llvm::object::GenericBinaryError>(
89
1
        "segmented arange entries are not supported");
90
91
  // The first tuple following the header in each set begins at an offset
92
  // that is a multiple of the size of a single tuple (that is, twice the
93
  // size of an address). The header is padded, if necessary, to the
94
  // appropriate boundary.
95
1.21k
  const uint32_t header_size = *offset_ptr - m_offset;
96
1.21k
  const uint32_t tuple_size = m_header.addr_size << 1;
97
1.21k
  uint32_t first_tuple_offset = 0;
98
2.43k
  while (first_tuple_offset < header_size)
99
1.21k
    first_tuple_offset += tuple_size;
100
101
1.21k
  *offset_ptr = m_offset + first_tuple_offset;
102
103
1.21k
  Descriptor arangeDescriptor;
104
105
1.21k
  static_assert(sizeof(arangeDescriptor.address) ==
106
1.21k
                    sizeof(arangeDescriptor.length),
107
1.21k
                "DWARFDebugArangeSet::Descriptor.address and "
108
1.21k
                "DWARFDebugArangeSet::Descriptor.length must have same size");
109
110
1.21k
  const lldb::offset_t next_offset = GetNextOffset();
111
1.21k
  assert(next_offset != DW_INVALID_OFFSET);
112
0
  uint32_t num_terminators = 0;
113
1.21k
  bool last_was_terminator = false;
114
32.4k
  while (*offset_ptr < next_offset) {
115
31.2k
    arangeDescriptor.address = data.GetMaxU64(offset_ptr, m_header.addr_size);
116
31.2k
    arangeDescriptor.length = data.GetMaxU64(offset_ptr, m_header.addr_size);
117
118
    // Each set of tuples is terminated by a 0 for the address and 0 for
119
    // the length. Some linkers can emit .debug_aranges with multiple
120
    // terminator pair entries that are still withing the length of the
121
    // DWARFDebugArangeSet. We want to be sure to parse all entries for
122
    // this DWARFDebugArangeSet so that we don't stop parsing early and end up
123
    // treating addresses as a header of the next DWARFDebugArangeSet. We also
124
    // need to make sure we parse all valid address pairs so we don't omit them
125
    // from the aranges result, so we can't stop at the first terminator entry
126
    // we find.
127
31.2k
    if (arangeDescriptor.address == 0 && 
arangeDescriptor.length == 01.21k
) {
128
1.21k
      ++num_terminators;
129
1.21k
      last_was_terminator = true;
130
30.0k
    } else {
131
30.0k
      last_was_terminator = false;
132
      // Only add .debug_aranges address entries that have a non zero size.
133
      // Some linkers will zero out the length field for some .debug_aranges
134
      // entries if they were stripped. We also could watch out for multiple
135
      // entries at address zero and remove those as well.
136
30.0k
      if (arangeDescriptor.length > 0)
137
30.0k
        m_arange_descriptors.push_back(arangeDescriptor);
138
30.0k
    }
139
31.2k
  }
140
1.21k
  if (num_terminators > 1) {
141
1
    Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
142
1
    LLDB_LOG(log,
143
1
             "warning: DWARFDebugArangeSet at %#" PRIx64 " contains %u "
144
1
             "terminator entries",
145
1
             m_offset, num_terminators);
146
1
  }
147
1.21k
  if (last_was_terminator)
148
1.21k
    return llvm::ErrorSuccess();
149
150
0
  return llvm::make_error<llvm::object::GenericBinaryError>(
151
0
      "arange descriptors not terminated by null entry");
152
1.21k
}
153
154
class DescriptorContainsAddress {
155
public:
156
0
  DescriptorContainsAddress(dw_addr_t address) : m_address(address) {}
157
0
  bool operator()(const DWARFDebugArangeSet::Descriptor &desc) const {
158
0
    return (m_address >= desc.address) &&
159
0
           (m_address < (desc.address + desc.length));
160
0
  }
161
162
private:
163
  const dw_addr_t m_address;
164
};
165
166
0
dw_offset_t DWARFDebugArangeSet::FindAddress(dw_addr_t address) const {
167
0
  DescriptorConstIter end = m_arange_descriptors.end();
168
0
  DescriptorConstIter pos =
169
0
      std::find_if(m_arange_descriptors.begin(), end,   // Range
170
0
                   DescriptorContainsAddress(address)); // Predicate
171
0
  if (pos != end)
172
0
    return m_header.cu_offset;
173
174
0
  return DW_INVALID_OFFSET;
175
0
}