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/Core/Stream.h"
13 #include "lldb/Target/Process.h"
14 #include "lldb/Target/Target.h"
15
16 using namespace lldb;
17 using namespace lldb_private;
18
AddressRange()19 AddressRange::AddressRange () :
20 m_base_addr(),
21 m_byte_size(0)
22 {
23 }
24
AddressRange(addr_t file_addr,addr_t byte_size,const SectionList * section_list)25 AddressRange::AddressRange (addr_t file_addr, addr_t byte_size, const SectionList *section_list) :
26 m_base_addr(file_addr, section_list),
27 m_byte_size(byte_size)
28 {
29 }
30
AddressRange(const lldb::SectionSP & section,addr_t offset,addr_t byte_size)31 AddressRange::AddressRange (const lldb::SectionSP §ion, addr_t offset, addr_t byte_size) :
32 m_base_addr(section, offset),
33 m_byte_size(byte_size)
34 {
35 }
36
AddressRange(const Address & so_addr,addr_t byte_size)37 AddressRange::AddressRange (const Address& so_addr, addr_t byte_size) :
38 m_base_addr(so_addr),
39 m_byte_size(byte_size)
40 {
41 }
42
~AddressRange()43 AddressRange::~AddressRange ()
44 {
45 }
46
47 //bool
48 //AddressRange::Contains (const Address &addr) const
49 //{
50 // const addr_t byte_size = GetByteSize();
51 // if (byte_size)
52 // return addr.GetSection() == m_base_addr.GetSection() && (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
63 bool
ContainsFileAddress(const Address & addr) const64 AddressRange::ContainsFileAddress (const Address &addr) const
65 {
66 if (addr.GetSection() == m_base_addr.GetSection())
67 return (addr.GetOffset() - m_base_addr.GetOffset()) < GetByteSize();
68 addr_t file_base_addr = GetBaseAddress().GetFileAddress();
69 if (file_base_addr == LLDB_INVALID_ADDRESS)
70 return false;
71
72 addr_t file_addr = addr.GetFileAddress();
73 if (file_addr == LLDB_INVALID_ADDRESS)
74 return false;
75
76 if (file_base_addr <= file_addr)
77 return (file_addr - file_base_addr) < GetByteSize();
78
79 return false;
80 }
81
82 bool
ContainsFileAddress(addr_t file_addr) const83 AddressRange::ContainsFileAddress (addr_t file_addr) const
84 {
85 if (file_addr == LLDB_INVALID_ADDRESS)
86 return false;
87
88 addr_t file_base_addr = GetBaseAddress().GetFileAddress();
89 if (file_base_addr == LLDB_INVALID_ADDRESS)
90 return false;
91
92 if (file_base_addr <= file_addr)
93 return (file_addr - file_base_addr) < GetByteSize();
94
95 return false;
96 }
97
98
99 bool
ContainsLoadAddress(const Address & addr,Target * target) const100 AddressRange::ContainsLoadAddress (const Address &addr, Target *target) const
101 {
102 if (addr.GetSection() == m_base_addr.GetSection())
103 return (addr.GetOffset() - m_base_addr.GetOffset()) < GetByteSize();
104 addr_t load_base_addr = GetBaseAddress().GetLoadAddress(target);
105 if (load_base_addr == LLDB_INVALID_ADDRESS)
106 return false;
107
108 addr_t load_addr = addr.GetLoadAddress(target);
109 if (load_addr == LLDB_INVALID_ADDRESS)
110 return false;
111
112 if (load_base_addr <= load_addr)
113 return (load_addr - load_base_addr) < GetByteSize();
114
115 return false;
116 }
117
118 bool
ContainsLoadAddress(addr_t load_addr,Target * target) const119 AddressRange::ContainsLoadAddress (addr_t load_addr, Target *target) const
120 {
121 if (load_addr == LLDB_INVALID_ADDRESS)
122 return false;
123
124 addr_t load_base_addr = GetBaseAddress().GetLoadAddress(target);
125 if (load_base_addr == LLDB_INVALID_ADDRESS)
126 return false;
127
128 if (load_base_addr <= load_addr)
129 return (load_addr - load_base_addr) < GetByteSize();
130
131 return false;
132 }
133
134 void
Clear()135 AddressRange::Clear()
136 {
137 m_base_addr.Clear();
138 m_byte_size = 0;
139 }
140
141 bool
Dump(Stream * s,Target * target,Address::DumpStyle style,Address::DumpStyle fallback_style) const142 AddressRange::Dump(Stream *s, Target *target, Address::DumpStyle style, Address::DumpStyle fallback_style) const
143 {
144 addr_t vmaddr = LLDB_INVALID_ADDRESS;
145 int addr_size = sizeof (addr_t);
146 if (target)
147 addr_size = target->GetArchitecture().GetAddressByteSize ();
148
149 bool show_module = false;
150 switch (style)
151 {
152 default:
153 break;
154 case Address::DumpStyleSectionNameOffset:
155 case Address::DumpStyleSectionPointerOffset:
156 s->PutChar ('[');
157 m_base_addr.Dump(s, target, style, fallback_style);
158 s->PutChar ('-');
159 s->Address (m_base_addr.GetOffset() + GetByteSize(), addr_size);
160 s->PutChar (')');
161 return true;
162 break;
163
164 case Address::DumpStyleModuleWithFileAddress:
165 show_module = true;
166 // fall through
167 case Address::DumpStyleFileAddress:
168 vmaddr = m_base_addr.GetFileAddress();
169 break;
170
171 case Address::DumpStyleLoadAddress:
172 vmaddr = m_base_addr.GetLoadAddress(target);
173 break;
174 }
175
176 if (vmaddr != LLDB_INVALID_ADDRESS)
177 {
178 if (show_module)
179 {
180 ModuleSP module_sp (GetBaseAddress().GetModule());
181 if (module_sp)
182 s->Printf("%s", module_sp->GetFileSpec().GetFilename().AsCString());
183 }
184 s->AddressRange(vmaddr, vmaddr + GetByteSize(), addr_size);
185 return true;
186 }
187 else if (fallback_style != Address::DumpStyleInvalid)
188 {
189 return Dump(s, target, fallback_style, Address::DumpStyleInvalid);
190 }
191
192 return false;
193 }
194
195
196 void
DumpDebug(Stream * s) const197 AddressRange::DumpDebug (Stream *s) const
198 {
199 s->Printf("%p: AddressRange section = %p, offset = 0x%16.16" PRIx64 ", byte_size = 0x%16.16" PRIx64 "\n", this, m_base_addr.GetSection().get(), m_base_addr.GetOffset(), GetByteSize());
200 }
201 //
202 //bool
203 //lldb::operator== (const AddressRange& lhs, const AddressRange& rhs)
204 //{
205 // if (lhs.GetBaseAddress() == rhs.GetBaseAddress())
206 // return lhs.GetByteSize() == rhs.GetByteSize();
207 // return false;
208 //}
209