LLDB  mainline
DWARFDebugArangeSet.cpp
Go to the documentation of this file.
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 "llvm/Object/Error.h"
12 #include <cassert>
13 
14 using namespace lldb_private;
15 
17  : m_offset(DW_INVALID_OFFSET), m_header(), m_arange_descriptors() {
18  m_header.length = 0;
19  m_header.version = 0;
20  m_header.cu_offset = 0;
21  m_header.addr_size = 0;
22  m_header.seg_size = 0;
23 }
24 
27  m_header.length = 0;
28  m_header.version = 0;
29  m_header.cu_offset = 0;
30  m_header.addr_size = 0;
31  m_header.seg_size = 0;
32  m_arange_descriptors.clear();
33 }
34 
36  lldb::offset_t *offset_ptr) {
37  assert(data.ValidOffset(*offset_ptr));
38 
39  m_arange_descriptors.clear();
40  m_offset = *offset_ptr;
41 
42  // 7.20 Address Range Table
43  //
44  // Each set of entries in the table of address ranges contained in the
45  // .debug_aranges section begins with a header consisting of: a 4-byte
46  // length containing the length of the set of entries for this compilation
47  // unit, not including the length field itself; a 2-byte version identifier
48  // containing the value 2 for DWARF Version 2; a 4-byte offset into
49  // the.debug_infosection; a 1-byte unsigned integer containing the size in
50  // bytes of an address (or the offset portion of an address for segmented
51  // addressing) on the target system; and a 1-byte unsigned integer
52  // containing the size in bytes of a segment descriptor on the target
53  // system. This header is followed by a series of tuples. Each tuple
54  // consists of an address and a length, each in the size appropriate for an
55  // address on the target architecture.
56  m_header.length = data.GetDWARFInitialLength(offset_ptr);
57  m_header.version = data.GetU16(offset_ptr);
58  m_header.cu_offset = data.GetDWARFOffset(offset_ptr);
59  m_header.addr_size = data.GetU8(offset_ptr);
60  m_header.seg_size = data.GetU8(offset_ptr);
61 
62  // Try to avoid reading invalid arange sets by making sure:
63  // 1 - the version looks good
64  // 2 - the address byte size looks plausible
65  // 3 - the length seems to make sense
66  // 4 - size looks plausible
67  // 5 - the arange tuples do not contain a segment field
68  if (m_header.version < 2 || m_header.version > 5)
69  return llvm::make_error<llvm::object::GenericBinaryError>(
70  "Invalid arange header version");
71 
72  if (m_header.addr_size != 4 && m_header.addr_size != 8)
73  return llvm::make_error<llvm::object::GenericBinaryError>(
74  "Invalid arange header address size");
75 
76  if (m_header.length == 0)
77  return llvm::make_error<llvm::object::GenericBinaryError>(
78  "Invalid arange header length");
79 
80  if (!data.ValidOffset(m_offset + sizeof(m_header.length) + m_header.length -
81  1))
82  return llvm::make_error<llvm::object::GenericBinaryError>(
83  "Invalid arange header length");
84 
85  if (m_header.seg_size)
86  return llvm::make_error<llvm::object::GenericBinaryError>(
87  "segmented arange entries are not supported");
88 
89  // The first tuple following the header in each set begins at an offset
90  // that is a multiple of the size of a single tuple (that is, twice the
91  // size of an address). The header is padded, if necessary, to the
92  // appropriate boundary.
93  const uint32_t header_size = *offset_ptr - m_offset;
94  const uint32_t tuple_size = m_header.addr_size << 1;
95  uint32_t first_tuple_offset = 0;
96  while (first_tuple_offset < header_size)
97  first_tuple_offset += tuple_size;
98 
99  *offset_ptr = m_offset + first_tuple_offset;
100 
101  Descriptor arangeDescriptor;
102 
103  static_assert(sizeof(arangeDescriptor.address) ==
104  sizeof(arangeDescriptor.length),
105  "DWARFDebugArangeSet::Descriptor.address and "
106  "DWARFDebugArangeSet::Descriptor.length must have same size");
107 
108  while (data.ValidOffset(*offset_ptr)) {
109  arangeDescriptor.address = data.GetMaxU64(offset_ptr, m_header.addr_size);
110  arangeDescriptor.length = data.GetMaxU64(offset_ptr, m_header.addr_size);
111 
112  // Each set of tuples is terminated by a 0 for the address and 0 for
113  // the length.
114  if (!arangeDescriptor.address && !arangeDescriptor.length)
115  return llvm::ErrorSuccess();
116 
117  m_arange_descriptors.push_back(arangeDescriptor);
118  }
119 
120  return llvm::make_error<llvm::object::GenericBinaryError>(
121  "arange descriptors not terminated by null entry");
122 }
123 
125 public:
126  DescriptorContainsAddress(dw_addr_t address) : m_address(address) {}
127  bool operator()(const DWARFDebugArangeSet::Descriptor &desc) const {
128  return (m_address >= desc.address) &&
129  (m_address < (desc.address + desc.length));
130  }
131 
132 private:
134 };
135 
138  DescriptorConstIter pos =
139  std::find_if(m_arange_descriptors.begin(), end, // Range
140  DescriptorContainsAddress(address)); // Predicate
141  if (pos != end)
142  return m_header.cu_offset;
143 
144  return DW_INVALID_OFFSET;
145 }
A class that represents a running process on the host machine.
dw_offset_t FindAddress(dw_addr_t address) const
llvm::Error Error
uint64_t dw_addr_t
Definition: dwarf.h:26
DescriptorContainsAddress(dw_addr_t address)
uint64_t GetDWARFInitialLength(lldb::offset_t *offset_ptr) const
uint64_t offset_t
Definition: lldb-types.h:87
bool ValidOffset(lldb::offset_t offset) const
Test the validity of offset.
uint64_t GetMaxU64(lldb::offset_t *offset_ptr, size_t byte_size) const
Extract an unsigned integer of size byte_size from *offset_ptr.
llvm::Error extract(const lldb_private::DWARFDataExtractor &data, lldb::offset_t *offset_ptr)
DescriptorColl m_arange_descriptors
DescriptorColl::const_iterator DescriptorConstIter
bool operator()(const DWARFDebugArangeSet::Descriptor &desc) const
dw_offset_t GetDWARFOffset(lldb::offset_t *offset_ptr) const
#define DW_INVALID_OFFSET
Definition: dwarf.h:34
uint8_t GetU8(lldb::offset_t *offset_ptr) const
Extract a uint8_t value from *offset_ptr.
uint16_t GetU16(lldb::offset_t *offset_ptr) const
Extract a uint16_t value from *offset_ptr.