1 //===-- AddressRange.cpp ----------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "lldb/Core/AddressRange.h"
11 #include "lldb/Core/Module.h"
12 #include "lldb/Target/Target.h"
13 #include "lldb/Utility/ConstString.h"
14 #include "lldb/Utility/FileSpec.h"
15 #include "lldb/Utility/Stream.h"
16 #include "lldb/lldb-defines.h"
17
18 #include "llvm/Support/Compiler.h"
19
20 #include <memory>
21
22 #include <inttypes.h>
23
24 namespace lldb_private {
25 class SectionList;
26 }
27
28 using namespace lldb;
29 using namespace lldb_private;
30
AddressRange()31 AddressRange::AddressRange() : m_base_addr(), m_byte_size(0) {}
32
AddressRange(addr_t file_addr,addr_t byte_size,const SectionList * section_list)33 AddressRange::AddressRange(addr_t file_addr, addr_t byte_size,
34 const SectionList *section_list)
35 : m_base_addr(file_addr, section_list), m_byte_size(byte_size) {}
36
AddressRange(const lldb::SectionSP & section,addr_t offset,addr_t byte_size)37 AddressRange::AddressRange(const lldb::SectionSP §ion, addr_t offset,
38 addr_t byte_size)
39 : m_base_addr(section, offset), m_byte_size(byte_size) {}
40
AddressRange(const Address & so_addr,addr_t byte_size)41 AddressRange::AddressRange(const Address &so_addr, addr_t byte_size)
42 : m_base_addr(so_addr), m_byte_size(byte_size) {}
43
~AddressRange()44 AddressRange::~AddressRange() {}
45
46 // bool
47 // AddressRange::Contains (const Address &addr) const
48 //{
49 // const addr_t byte_size = GetByteSize();
50 // if (byte_size)
51 // return addr.GetSection() == m_base_addr.GetSection() &&
52 // (addr.GetOffset() - m_base_addr.GetOffset()) < byte_size;
53 //}
54 //
55 // bool
56 // AddressRange::Contains (const Address *addr) const
57 //{
58 // if (addr)
59 // return Contains (*addr);
60 // return false;
61 //}
62
ContainsFileAddress(const Address & addr) const63 bool AddressRange::ContainsFileAddress(const Address &addr) const {
64 if (addr.GetSection() == m_base_addr.GetSection())
65 return (addr.GetOffset() - m_base_addr.GetOffset()) < GetByteSize();
66 addr_t file_base_addr = GetBaseAddress().GetFileAddress();
67 if (file_base_addr == LLDB_INVALID_ADDRESS)
68 return false;
69
70 addr_t file_addr = addr.GetFileAddress();
71 if (file_addr == LLDB_INVALID_ADDRESS)
72 return false;
73
74 if (file_base_addr <= file_addr)
75 return (file_addr - file_base_addr) < GetByteSize();
76
77 return false;
78 }
79
ContainsFileAddress(addr_t file_addr) const80 bool AddressRange::ContainsFileAddress(addr_t file_addr) const {
81 if (file_addr == LLDB_INVALID_ADDRESS)
82 return false;
83
84 addr_t file_base_addr = GetBaseAddress().GetFileAddress();
85 if (file_base_addr == LLDB_INVALID_ADDRESS)
86 return false;
87
88 if (file_base_addr <= file_addr)
89 return (file_addr - file_base_addr) < GetByteSize();
90
91 return false;
92 }
93
ContainsLoadAddress(const Address & addr,Target * target) const94 bool AddressRange::ContainsLoadAddress(const Address &addr,
95 Target *target) const {
96 if (addr.GetSection() == m_base_addr.GetSection())
97 return (addr.GetOffset() - m_base_addr.GetOffset()) < GetByteSize();
98 addr_t load_base_addr = GetBaseAddress().GetLoadAddress(target);
99 if (load_base_addr == LLDB_INVALID_ADDRESS)
100 return false;
101
102 addr_t load_addr = addr.GetLoadAddress(target);
103 if (load_addr == LLDB_INVALID_ADDRESS)
104 return false;
105
106 if (load_base_addr <= load_addr)
107 return (load_addr - load_base_addr) < GetByteSize();
108
109 return false;
110 }
111
ContainsLoadAddress(addr_t load_addr,Target * target) const112 bool AddressRange::ContainsLoadAddress(addr_t load_addr, Target *target) const {
113 if (load_addr == LLDB_INVALID_ADDRESS)
114 return false;
115
116 addr_t load_base_addr = GetBaseAddress().GetLoadAddress(target);
117 if (load_base_addr == LLDB_INVALID_ADDRESS)
118 return false;
119
120 if (load_base_addr <= load_addr)
121 return (load_addr - load_base_addr) < GetByteSize();
122
123 return false;
124 }
125
Clear()126 void AddressRange::Clear() {
127 m_base_addr.Clear();
128 m_byte_size = 0;
129 }
130
Dump(Stream * s,Target * target,Address::DumpStyle style,Address::DumpStyle fallback_style) const131 bool AddressRange::Dump(Stream *s, Target *target, Address::DumpStyle style,
132 Address::DumpStyle fallback_style) const {
133 addr_t vmaddr = LLDB_INVALID_ADDRESS;
134 int addr_size = sizeof(addr_t);
135 if (target)
136 addr_size = target->GetArchitecture().GetAddressByteSize();
137
138 bool show_module = false;
139 switch (style) {
140 default:
141 break;
142 case Address::DumpStyleSectionNameOffset:
143 case Address::DumpStyleSectionPointerOffset:
144 s->PutChar('[');
145 m_base_addr.Dump(s, target, style, fallback_style);
146 s->PutChar('-');
147 s->Address(m_base_addr.GetOffset() + GetByteSize(), addr_size);
148 s->PutChar(')');
149 return true;
150 break;
151
152 case Address::DumpStyleModuleWithFileAddress:
153 show_module = true;
154 LLVM_FALLTHROUGH;
155 case Address::DumpStyleFileAddress:
156 vmaddr = m_base_addr.GetFileAddress();
157 break;
158
159 case Address::DumpStyleLoadAddress:
160 vmaddr = m_base_addr.GetLoadAddress(target);
161 break;
162 }
163
164 if (vmaddr != LLDB_INVALID_ADDRESS) {
165 if (show_module) {
166 ModuleSP module_sp(GetBaseAddress().GetModule());
167 if (module_sp)
168 s->Printf("%s", module_sp->GetFileSpec().GetFilename().AsCString(
169 "<Unknown>"));
170 }
171 s->AddressRange(vmaddr, vmaddr + GetByteSize(), addr_size);
172 return true;
173 } else if (fallback_style != Address::DumpStyleInvalid) {
174 return Dump(s, target, fallback_style, Address::DumpStyleInvalid);
175 }
176
177 return false;
178 }
179
DumpDebug(Stream * s) const180 void AddressRange::DumpDebug(Stream *s) const {
181 s->Printf("%p: AddressRange section = %p, offset = 0x%16.16" PRIx64
182 ", byte_size = 0x%16.16" PRIx64 "\n",
183 static_cast<const void *>(this),
184 static_cast<void *>(m_base_addr.GetSection().get()),
185 m_base_addr.GetOffset(), GetByteSize());
186 }
187 //
188 // bool
189 // lldb::operator== (const AddressRange& lhs, const AddressRange& rhs)
190 //{
191 // if (lhs.GetBaseAddress() == rhs.GetBaseAddress())
192 // return lhs.GetByteSize() == rhs.GetByteSize();
193 // return false;
194 //}
195