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
16using namespace lldb;
17using namespace lldb_private;
18
19AddressRange::AddressRange () :
20    m_base_addr(),
21    m_byte_size(0)
22{
23}
24
25AddressRange::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
31AddressRange::AddressRange (const lldb::SectionSP &section, addr_t offset, addr_t byte_size) :
32    m_base_addr(section, offset),
33    m_byte_size(byte_size)
34{
35}
36
37AddressRange::AddressRange (const Address& so_addr, addr_t byte_size) :
38    m_base_addr(so_addr),
39    m_byte_size(byte_size)
40{
41}
42
43AddressRange::~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
63bool
64AddressRange::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
82bool
83AddressRange::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
99bool
100AddressRange::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
118bool
119AddressRange::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
134void
135AddressRange::Clear()
136{
137    m_base_addr.Clear();
138    m_byte_size = 0;
139}
140
141bool
142AddressRange::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
196void
197AddressRange::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