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 
19 AddressRange::AddressRange() : m_base_addr(), m_byte_size(0) {}
20 
21 AddressRange::AddressRange(addr_t file_addr, addr_t byte_size,
22                            const SectionList *section_list)
23     : m_base_addr(file_addr, section_list), m_byte_size(byte_size) {}
24 
25 AddressRange::AddressRange(const lldb::SectionSP &section, addr_t offset,
26                            addr_t byte_size)
27     : m_base_addr(section, offset), m_byte_size(byte_size) {}
28 
29 AddressRange::AddressRange(const Address &so_addr, addr_t byte_size)
30     : m_base_addr(so_addr), m_byte_size(byte_size) {}
31 
32 AddressRange::~AddressRange() {}
33 
34 // bool
35 // AddressRange::Contains (const Address &addr) const
36 //{
37 //    const addr_t byte_size = GetByteSize();
38 //    if (byte_size)
39 //        return addr.GetSection() == m_base_addr.GetSection() &&
40 //        (addr.GetOffset() - m_base_addr.GetOffset()) < byte_size;
41 //}
42 //
43 // bool
44 // AddressRange::Contains (const Address *addr) const
45 //{
46 //    if (addr)
47 //        return Contains (*addr);
48 //    return false;
49 //}
50 
51 bool AddressRange::ContainsFileAddress(const Address &addr) const {
52   if (addr.GetSection() == m_base_addr.GetSection())
53     return (addr.GetOffset() - m_base_addr.GetOffset()) < GetByteSize();
54   addr_t file_base_addr = GetBaseAddress().GetFileAddress();
55   if (file_base_addr == LLDB_INVALID_ADDRESS)
56     return false;
57 
58   addr_t file_addr = addr.GetFileAddress();
59   if (file_addr == LLDB_INVALID_ADDRESS)
60     return false;
61 
62   if (file_base_addr <= file_addr)
63     return (file_addr - file_base_addr) < GetByteSize();
64 
65   return false;
66 }
67 
68 bool AddressRange::ContainsFileAddress(addr_t file_addr) const {
69   if (file_addr == LLDB_INVALID_ADDRESS)
70     return false;
71 
72   addr_t file_base_addr = GetBaseAddress().GetFileAddress();
73   if (file_base_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 AddressRange::ContainsLoadAddress(const Address &addr,
83                                        Target *target) const {
84   if (addr.GetSection() == m_base_addr.GetSection())
85     return (addr.GetOffset() - m_base_addr.GetOffset()) < GetByteSize();
86   addr_t load_base_addr = GetBaseAddress().GetLoadAddress(target);
87   if (load_base_addr == LLDB_INVALID_ADDRESS)
88     return false;
89 
90   addr_t load_addr = addr.GetLoadAddress(target);
91   if (load_addr == LLDB_INVALID_ADDRESS)
92     return false;
93 
94   if (load_base_addr <= load_addr)
95     return (load_addr - load_base_addr) < GetByteSize();
96 
97   return false;
98 }
99 
100 bool AddressRange::ContainsLoadAddress(addr_t load_addr, Target *target) const {
101   if (load_addr == LLDB_INVALID_ADDRESS)
102     return false;
103 
104   addr_t load_base_addr = GetBaseAddress().GetLoadAddress(target);
105   if (load_base_addr == LLDB_INVALID_ADDRESS)
106     return false;
107 
108   if (load_base_addr <= load_addr)
109     return (load_addr - load_base_addr) < GetByteSize();
110 
111   return false;
112 }
113 
114 void AddressRange::Clear() {
115   m_base_addr.Clear();
116   m_byte_size = 0;
117 }
118 
119 bool AddressRange::Dump(Stream *s, Target *target, Address::DumpStyle style,
120                         Address::DumpStyle fallback_style) const {
121   addr_t vmaddr = LLDB_INVALID_ADDRESS;
122   int addr_size = sizeof(addr_t);
123   if (target)
124     addr_size = target->GetArchitecture().GetAddressByteSize();
125 
126   bool show_module = false;
127   switch (style) {
128   default:
129     break;
130   case Address::DumpStyleSectionNameOffset:
131   case Address::DumpStyleSectionPointerOffset:
132     s->PutChar('[');
133     m_base_addr.Dump(s, target, style, fallback_style);
134     s->PutChar('-');
135     s->Address(m_base_addr.GetOffset() + GetByteSize(), addr_size);
136     s->PutChar(')');
137     return true;
138     break;
139 
140   case Address::DumpStyleModuleWithFileAddress:
141     show_module = true;
142     LLVM_FALLTHROUGH;
143   case Address::DumpStyleFileAddress:
144     vmaddr = m_base_addr.GetFileAddress();
145     break;
146 
147   case Address::DumpStyleLoadAddress:
148     vmaddr = m_base_addr.GetLoadAddress(target);
149     break;
150   }
151 
152   if (vmaddr != LLDB_INVALID_ADDRESS) {
153     if (show_module) {
154       ModuleSP module_sp(GetBaseAddress().GetModule());
155       if (module_sp)
156         s->Printf("%s", module_sp->GetFileSpec().GetFilename().AsCString(
157                             "<Unknown>"));
158     }
159     s->AddressRange(vmaddr, vmaddr + GetByteSize(), addr_size);
160     return true;
161   } else if (fallback_style != Address::DumpStyleInvalid) {
162     return Dump(s, target, fallback_style, Address::DumpStyleInvalid);
163   }
164 
165   return false;
166 }
167 
168 void AddressRange::DumpDebug(Stream *s) const {
169   s->Printf("%p: AddressRange section = %p, offset = 0x%16.16" PRIx64
170             ", byte_size = 0x%16.16" PRIx64 "\n",
171             static_cast<const void *>(this),
172             static_cast<void *>(m_base_addr.GetSection().get()),
173             m_base_addr.GetOffset(), GetByteSize());
174 }
175 //
176 // bool
177 // lldb::operator==    (const AddressRange& lhs, const AddressRange& rhs)
178 //{
179 //    if (lhs.GetBaseAddress() == rhs.GetBaseAddress())
180 //        return lhs.GetByteSize() == rhs.GetByteSize();
181 //    return false;
182 //}
183