Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1 | //===-- ObjectFile.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/lldb-private.h" |
Greg Clayton | e40b642 | 2011-09-18 18:59:15 +0000 | [diff] [blame] | 11 | #include "lldb/lldb-private-log.h" |
Greg Clayton | db2dc2b | 2012-01-12 05:25:17 +0000 | [diff] [blame] | 12 | #include "lldb/Core/DataBuffer.h" |
Greg Clayton | b5a8f14 | 2012-02-05 02:38:54 +0000 | [diff] [blame^] | 13 | #include "lldb/Core/DataBufferHeap.h" |
Greg Clayton | e40b642 | 2011-09-18 18:59:15 +0000 | [diff] [blame] | 14 | #include "lldb/Core/Log.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 15 | #include "lldb/Core/Module.h" |
| 16 | #include "lldb/Core/PluginManager.h" |
| 17 | #include "lldb/Core/RegularExpression.h" |
| 18 | #include "lldb/Core/Timer.h" |
| 19 | #include "lldb/Symbol/ObjectFile.h" |
| 20 | #include "lldb/Symbol/ObjectContainer.h" |
| 21 | #include "lldb/Symbol/SymbolFile.h" |
Greg Clayton | b5a8f14 | 2012-02-05 02:38:54 +0000 | [diff] [blame^] | 22 | #include "lldb/Target/Process.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 23 | |
| 24 | using namespace lldb; |
| 25 | using namespace lldb_private; |
| 26 | |
Greg Clayton | e40b642 | 2011-09-18 18:59:15 +0000 | [diff] [blame] | 27 | ObjectFileSP |
Greg Clayton | db2dc2b | 2012-01-12 05:25:17 +0000 | [diff] [blame] | 28 | ObjectFile::FindPlugin (Module* module, const FileSpec* file, addr_t file_offset, addr_t file_size, DataBufferSP &file_data_sp) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 29 | { |
| 30 | Timer scoped_timer (__PRETTY_FUNCTION__, |
| 31 | "ObjectFile::FindPlugin (module = %s/%s, file = %p, file_offset = 0x%z8.8x, file_size = 0x%z8.8x)", |
| 32 | module->GetFileSpec().GetDirectory().AsCString(), |
| 33 | module->GetFileSpec().GetFilename().AsCString(), |
| 34 | file, file_offset, file_size); |
Greg Clayton | e40b642 | 2011-09-18 18:59:15 +0000 | [diff] [blame] | 35 | ObjectFileSP object_file_sp; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 36 | |
| 37 | if (module != NULL) |
| 38 | { |
| 39 | if (file) |
| 40 | { |
Greg Clayton | db2dc2b | 2012-01-12 05:25:17 +0000 | [diff] [blame] | 41 | // Memory map the entire file contents |
| 42 | if (!file_data_sp) |
| 43 | { |
| 44 | assert (file_offset == 0); |
| 45 | file_data_sp = file->MemoryMapFileContents(file_offset, file_size); |
| 46 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 47 | |
Greg Clayton | db2dc2b | 2012-01-12 05:25:17 +0000 | [diff] [blame] | 48 | if (!file_data_sp || file_data_sp->GetByteSize() == 0) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 49 | { |
| 50 | // Check for archive file with format "/path/to/archive.a(object.o)" |
| 51 | char path_with_object[PATH_MAX*2]; |
| 52 | module->GetFileSpec().GetPath(path_with_object, sizeof(path_with_object)); |
| 53 | |
| 54 | RegularExpression g_object_regex("(.*)\\(([^\\)]+)\\)$"); |
| 55 | if (g_object_regex.Execute (path_with_object, 2)) |
| 56 | { |
| 57 | FileSpec archive_file; |
| 58 | std::string path; |
| 59 | std::string object; |
| 60 | if (g_object_regex.GetMatchAtIndex (path_with_object, 1, path) && |
| 61 | g_object_regex.GetMatchAtIndex (path_with_object, 2, object)) |
| 62 | { |
Greg Clayton | 537a7a8 | 2010-10-20 20:54:39 +0000 | [diff] [blame] | 63 | archive_file.SetFile (path.c_str(), false); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 64 | file_size = archive_file.GetByteSize(); |
| 65 | if (file_size > 0) |
Greg Clayton | db2dc2b | 2012-01-12 05:25:17 +0000 | [diff] [blame] | 66 | { |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 67 | module->SetFileSpecAndObjectName (archive_file, ConstString(object.c_str())); |
Greg Clayton | db2dc2b | 2012-01-12 05:25:17 +0000 | [diff] [blame] | 68 | file_data_sp = archive_file.MemoryMapFileContents(file_offset, file_size); |
| 69 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 70 | } |
| 71 | } |
| 72 | } |
| 73 | |
Greg Clayton | db2dc2b | 2012-01-12 05:25:17 +0000 | [diff] [blame] | 74 | if (file_data_sp && file_data_sp->GetByteSize() > 0) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 75 | { |
Greg Clayton | db2dc2b | 2012-01-12 05:25:17 +0000 | [diff] [blame] | 76 | uint32_t idx; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 77 | |
Greg Clayton | db2dc2b | 2012-01-12 05:25:17 +0000 | [diff] [blame] | 78 | // Check if this is a normal object file by iterating through |
| 79 | // all object file plugin instances. |
| 80 | ObjectFileCreateInstance create_object_file_callback; |
| 81 | for (idx = 0; (create_object_file_callback = PluginManager::GetObjectFileCreateCallbackAtIndex(idx)) != NULL; ++idx) |
| 82 | { |
| 83 | object_file_sp.reset (create_object_file_callback(module, file_data_sp, file, file_offset, file_size)); |
| 84 | if (object_file_sp.get()) |
| 85 | return object_file_sp; |
| 86 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 87 | |
Greg Clayton | db2dc2b | 2012-01-12 05:25:17 +0000 | [diff] [blame] | 88 | // Check if this is a object container by iterating through |
| 89 | // all object container plugin instances and then trying to get |
| 90 | // an object file from the container. |
| 91 | ObjectContainerCreateInstance create_object_container_callback; |
| 92 | for (idx = 0; (create_object_container_callback = PluginManager::GetObjectContainerCreateCallbackAtIndex(idx)) != NULL; ++idx) |
| 93 | { |
| 94 | std::auto_ptr<ObjectContainer> object_container_ap(create_object_container_callback(module, file_data_sp, file, file_offset, file_size)); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 95 | |
Greg Clayton | db2dc2b | 2012-01-12 05:25:17 +0000 | [diff] [blame] | 96 | if (object_container_ap.get()) |
| 97 | object_file_sp = object_container_ap->GetObjectFile(file); |
| 98 | |
| 99 | if (object_file_sp.get()) |
| 100 | return object_file_sp; |
| 101 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 102 | } |
| 103 | } |
| 104 | } |
Greg Clayton | e40b642 | 2011-09-18 18:59:15 +0000 | [diff] [blame] | 105 | // We didn't find it, so clear our shared pointer in case it |
| 106 | // contains anything and return an empty shared pointer |
| 107 | object_file_sp.reset(); |
| 108 | return object_file_sp; |
| 109 | } |
| 110 | |
Greg Clayton | b5a8f14 | 2012-02-05 02:38:54 +0000 | [diff] [blame^] | 111 | ObjectFileSP |
| 112 | ObjectFile::FindPlugin (Module* module, |
| 113 | const ProcessSP &process_sp, |
| 114 | lldb::addr_t header_addr, |
| 115 | DataBufferSP &file_data_sp) |
| 116 | { |
| 117 | Timer scoped_timer (__PRETTY_FUNCTION__, |
| 118 | "ObjectFile::FindPlugin (module = %s/%s, process = %p, header_addr = 0x%llx)", |
| 119 | module->GetFileSpec().GetDirectory().AsCString(), |
| 120 | module->GetFileSpec().GetFilename().AsCString(), |
| 121 | process_sp.get(), header_addr); |
| 122 | ObjectFileSP object_file_sp; |
| 123 | |
| 124 | if (module != NULL) |
| 125 | { |
| 126 | uint32_t idx; |
| 127 | |
| 128 | // Check if this is a normal object file by iterating through |
| 129 | // all object file plugin instances. |
| 130 | ObjectFileCreateMemoryInstance create_callback; |
| 131 | for (idx = 0; (create_callback = PluginManager::GetObjectFileCreateMemoryCallbackAtIndex(idx)) != NULL; ++idx) |
| 132 | { |
| 133 | object_file_sp.reset (create_callback(module, file_data_sp, process_sp, header_addr)); |
| 134 | if (object_file_sp.get()) |
| 135 | return object_file_sp; |
| 136 | } |
| 137 | |
| 138 | } |
| 139 | // We didn't find it, so clear our shared pointer in case it |
| 140 | // contains anything and return an empty shared pointer |
| 141 | object_file_sp.reset(); |
| 142 | return object_file_sp; |
| 143 | } |
| 144 | |
Greg Clayton | e40b642 | 2011-09-18 18:59:15 +0000 | [diff] [blame] | 145 | ObjectFile::ObjectFile (Module* module, |
| 146 | const FileSpec *file_spec_ptr, |
Greg Clayton | db2dc2b | 2012-01-12 05:25:17 +0000 | [diff] [blame] | 147 | addr_t file_offset, |
| 148 | addr_t file_size, |
| 149 | DataBufferSP& file_data_sp) : |
Greg Clayton | e40b642 | 2011-09-18 18:59:15 +0000 | [diff] [blame] | 150 | ModuleChild (module), |
| 151 | m_file (), // This file could be different from the original module's file |
| 152 | m_type (eTypeInvalid), |
| 153 | m_strata (eStrataInvalid), |
Greg Clayton | db2dc2b | 2012-01-12 05:25:17 +0000 | [diff] [blame] | 154 | m_offset (file_offset), |
| 155 | m_length (file_size), |
| 156 | m_data (), |
Greg Clayton | b5a8f14 | 2012-02-05 02:38:54 +0000 | [diff] [blame^] | 157 | m_unwind_table (*this), |
| 158 | m_process_wp(), |
| 159 | m_in_memory (false) |
Greg Clayton | e40b642 | 2011-09-18 18:59:15 +0000 | [diff] [blame] | 160 | { |
| 161 | if (file_spec_ptr) |
| 162 | m_file = *file_spec_ptr; |
Greg Clayton | db2dc2b | 2012-01-12 05:25:17 +0000 | [diff] [blame] | 163 | if (file_data_sp) |
| 164 | m_data.SetData (file_data_sp, file_offset, file_size); |
Greg Clayton | e40b642 | 2011-09-18 18:59:15 +0000 | [diff] [blame] | 165 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); |
| 166 | if (log) |
| 167 | { |
| 168 | if (m_file) |
| 169 | { |
| 170 | log->Printf ("%p ObjectFile::ObjectFile () module = %s/%s, file = %s/%s, offset = 0x%8.8llx, size = %llu\n", |
| 171 | this, |
| 172 | m_module->GetFileSpec().GetDirectory().AsCString(), |
| 173 | m_module->GetFileSpec().GetFilename().AsCString(), |
| 174 | m_file.GetDirectory().AsCString(), |
| 175 | m_file.GetFilename().AsCString(), |
| 176 | m_offset, |
| 177 | m_length); |
| 178 | } |
| 179 | else |
| 180 | { |
| 181 | log->Printf ("%p ObjectFile::ObjectFile () module = %s/%s, file = <NULL>, offset = 0x%8.8llx, size = %llu\n", |
| 182 | this, |
| 183 | m_module->GetFileSpec().GetDirectory().AsCString(), |
| 184 | m_module->GetFileSpec().GetFilename().AsCString(), |
| 185 | m_offset, |
| 186 | m_length); |
| 187 | } |
| 188 | } |
| 189 | } |
| 190 | |
Greg Clayton | b5a8f14 | 2012-02-05 02:38:54 +0000 | [diff] [blame^] | 191 | |
| 192 | ObjectFile::ObjectFile (Module* module, |
| 193 | const ProcessSP &process_sp, |
| 194 | lldb::addr_t header_addr, |
| 195 | DataBufferSP& header_data_sp) : |
| 196 | ModuleChild (module), |
| 197 | m_file (), |
| 198 | m_type (eTypeInvalid), |
| 199 | m_strata (eStrataInvalid), |
| 200 | m_offset (header_addr), |
| 201 | m_length (0), |
| 202 | m_data (), |
| 203 | m_unwind_table (*this), |
| 204 | m_process_wp (process_sp), |
| 205 | m_in_memory (true) |
| 206 | { |
| 207 | if (header_data_sp) |
| 208 | m_data.SetData (header_data_sp, 0, header_data_sp->GetByteSize()); |
| 209 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); |
| 210 | if (log) |
| 211 | { |
| 212 | log->Printf ("%p ObjectFile::ObjectFile () module = %s/%s, process = %p, header_addr = 0x%llx\n", |
| 213 | this, |
| 214 | m_module->GetFileSpec().GetDirectory().AsCString(), |
| 215 | m_module->GetFileSpec().GetFilename().AsCString(), |
| 216 | process_sp.get(), |
| 217 | m_offset); |
| 218 | } |
| 219 | } |
| 220 | |
| 221 | |
Greg Clayton | e40b642 | 2011-09-18 18:59:15 +0000 | [diff] [blame] | 222 | ObjectFile::~ObjectFile() |
| 223 | { |
| 224 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); |
| 225 | if (log) |
| 226 | { |
| 227 | if (m_file) |
| 228 | { |
| 229 | log->Printf ("%p ObjectFile::~ObjectFile () module = %s/%s, file = %s/%s, offset = 0x%8.8llx, size = %llu\n", |
| 230 | this, |
| 231 | m_module->GetFileSpec().GetDirectory().AsCString(), |
| 232 | m_module->GetFileSpec().GetFilename().AsCString(), |
| 233 | m_file.GetDirectory().AsCString(), |
| 234 | m_file.GetFilename().AsCString(), |
| 235 | m_offset, |
| 236 | m_length); |
| 237 | } |
| 238 | else |
| 239 | { |
| 240 | log->Printf ("%p ObjectFile::~ObjectFile () module = %s/%s, file = <NULL>, offset = 0x%8.8llx, size = %llu\n", |
| 241 | this, |
| 242 | m_module->GetFileSpec().GetDirectory().AsCString(), |
| 243 | m_module->GetFileSpec().GetFilename().AsCString(), |
| 244 | m_offset, |
| 245 | m_length); |
| 246 | } |
| 247 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 248 | } |
Jim Ingham | 7508e73 | 2010-08-09 23:31:02 +0000 | [diff] [blame] | 249 | |
| 250 | bool |
| 251 | ObjectFile::SetModulesArchitecture (const ArchSpec &new_arch) |
| 252 | { |
| 253 | return m_module->SetArchitecture (new_arch); |
| 254 | } |
| 255 | |
Greg Clayton | b344843 | 2011-03-24 21:19:54 +0000 | [diff] [blame] | 256 | AddressClass |
Greg Clayton | e40b642 | 2011-09-18 18:59:15 +0000 | [diff] [blame] | 257 | ObjectFile::GetAddressClass (addr_t file_addr) |
Greg Clayton | b1888f2 | 2011-03-19 01:12:21 +0000 | [diff] [blame] | 258 | { |
| 259 | Symtab *symtab = GetSymtab(); |
| 260 | if (symtab) |
| 261 | { |
| 262 | Symbol *symbol = symtab->FindSymbolContainingFileAddress(file_addr); |
| 263 | if (symbol) |
| 264 | { |
| 265 | const AddressRange *range_ptr = symbol->GetAddressRangePtr(); |
| 266 | if (range_ptr) |
| 267 | { |
| 268 | const Section *section = range_ptr->GetBaseAddress().GetSection(); |
| 269 | if (section) |
| 270 | { |
Greg Clayton | b344843 | 2011-03-24 21:19:54 +0000 | [diff] [blame] | 271 | const SectionType section_type = section->GetType(); |
Greg Clayton | b1888f2 | 2011-03-19 01:12:21 +0000 | [diff] [blame] | 272 | switch (section_type) |
| 273 | { |
| 274 | case eSectionTypeInvalid: return eAddressClassUnknown; |
| 275 | case eSectionTypeCode: return eAddressClassCode; |
| 276 | case eSectionTypeContainer: return eAddressClassUnknown; |
Greg Clayton | 24a6bd9 | 2011-10-27 17:55:14 +0000 | [diff] [blame] | 277 | case eSectionTypeData: |
| 278 | case eSectionTypeDataCString: |
| 279 | case eSectionTypeDataCStringPointers: |
| 280 | case eSectionTypeDataSymbolAddress: |
| 281 | case eSectionTypeData4: |
| 282 | case eSectionTypeData8: |
| 283 | case eSectionTypeData16: |
| 284 | case eSectionTypeDataPointers: |
| 285 | case eSectionTypeZeroFill: |
| 286 | case eSectionTypeDataObjCMessageRefs: |
| 287 | case eSectionTypeDataObjCCFStrings: |
| 288 | return eAddressClassData; |
| 289 | case eSectionTypeDebug: |
| 290 | case eSectionTypeDWARFDebugAbbrev: |
| 291 | case eSectionTypeDWARFDebugAranges: |
| 292 | case eSectionTypeDWARFDebugFrame: |
| 293 | case eSectionTypeDWARFDebugInfo: |
| 294 | case eSectionTypeDWARFDebugLine: |
| 295 | case eSectionTypeDWARFDebugLoc: |
| 296 | case eSectionTypeDWARFDebugMacInfo: |
| 297 | case eSectionTypeDWARFDebugPubNames: |
| 298 | case eSectionTypeDWARFDebugPubTypes: |
| 299 | case eSectionTypeDWARFDebugRanges: |
| 300 | case eSectionTypeDWARFDebugStr: |
| 301 | case eSectionTypeDWARFAppleNames: |
| 302 | case eSectionTypeDWARFAppleTypes: |
| 303 | case eSectionTypeDWARFAppleNamespaces: |
| 304 | case eSectionTypeDWARFAppleObjC: |
| 305 | return eAddressClassDebug; |
Greg Clayton | b1888f2 | 2011-03-19 01:12:21 +0000 | [diff] [blame] | 306 | case eSectionTypeEHFrame: return eAddressClassRuntime; |
| 307 | case eSectionTypeOther: return eAddressClassUnknown; |
| 308 | } |
| 309 | } |
| 310 | } |
| 311 | |
Greg Clayton | b344843 | 2011-03-24 21:19:54 +0000 | [diff] [blame] | 312 | const SymbolType symbol_type = symbol->GetType(); |
Greg Clayton | b1888f2 | 2011-03-19 01:12:21 +0000 | [diff] [blame] | 313 | switch (symbol_type) |
| 314 | { |
| 315 | case eSymbolTypeAny: return eAddressClassUnknown; |
| 316 | case eSymbolTypeAbsolute: return eAddressClassUnknown; |
Greg Clayton | b1888f2 | 2011-03-19 01:12:21 +0000 | [diff] [blame] | 317 | case eSymbolTypeCode: return eAddressClassCode; |
| 318 | case eSymbolTypeTrampoline: return eAddressClassCode; |
| 319 | case eSymbolTypeData: return eAddressClassData; |
| 320 | case eSymbolTypeRuntime: return eAddressClassRuntime; |
| 321 | case eSymbolTypeException: return eAddressClassRuntime; |
| 322 | case eSymbolTypeSourceFile: return eAddressClassDebug; |
| 323 | case eSymbolTypeHeaderFile: return eAddressClassDebug; |
| 324 | case eSymbolTypeObjectFile: return eAddressClassDebug; |
| 325 | case eSymbolTypeCommonBlock: return eAddressClassDebug; |
| 326 | case eSymbolTypeBlock: return eAddressClassDebug; |
| 327 | case eSymbolTypeLocal: return eAddressClassData; |
| 328 | case eSymbolTypeParam: return eAddressClassData; |
| 329 | case eSymbolTypeVariable: return eAddressClassData; |
| 330 | case eSymbolTypeVariableType: return eAddressClassDebug; |
| 331 | case eSymbolTypeLineEntry: return eAddressClassDebug; |
| 332 | case eSymbolTypeLineHeader: return eAddressClassDebug; |
| 333 | case eSymbolTypeScopeBegin: return eAddressClassDebug; |
| 334 | case eSymbolTypeScopeEnd: return eAddressClassDebug; |
| 335 | case eSymbolTypeAdditional: return eAddressClassUnknown; |
| 336 | case eSymbolTypeCompiler: return eAddressClassDebug; |
| 337 | case eSymbolTypeInstrumentation:return eAddressClassDebug; |
| 338 | case eSymbolTypeUndefined: return eAddressClassUnknown; |
Greg Clayton | 3f69eac | 2011-12-03 02:30:59 +0000 | [diff] [blame] | 339 | case eSymbolTypeObjCClass: return eAddressClassRuntime; |
| 340 | case eSymbolTypeObjCMetaClass: return eAddressClassRuntime; |
| 341 | case eSymbolTypeObjCIVar: return eAddressClassRuntime; |
Greg Clayton | b1888f2 | 2011-03-19 01:12:21 +0000 | [diff] [blame] | 342 | } |
| 343 | } |
| 344 | } |
| 345 | return eAddressClassUnknown; |
| 346 | } |
| 347 | |
Greg Clayton | b5a8f14 | 2012-02-05 02:38:54 +0000 | [diff] [blame^] | 348 | DataBufferSP |
| 349 | ObjectFile::ReadMemory (const ProcessSP &process_sp, lldb::addr_t addr, size_t byte_size) |
| 350 | { |
| 351 | DataBufferSP data_sp; |
| 352 | if (process_sp) |
| 353 | { |
| 354 | std::auto_ptr<DataBufferHeap> data_ap (new DataBufferHeap (byte_size, 0)); |
| 355 | Error error; |
| 356 | const size_t bytes_read = process_sp->ReadMemory (addr, |
| 357 | data_ap->GetBytes(), |
| 358 | data_ap->GetByteSize(), |
| 359 | error); |
| 360 | if (bytes_read == byte_size) |
| 361 | data_sp.reset (data_ap.release()); |
| 362 | } |
| 363 | return data_sp; |
| 364 | } |
| 365 | |
Greg Clayton | db2dc2b | 2012-01-12 05:25:17 +0000 | [diff] [blame] | 366 | size_t |
| 367 | ObjectFile::GetData (off_t offset, size_t length, DataExtractor &data) const |
| 368 | { |
| 369 | // The entire file has already been mmap'ed into m_data, so just copy from there |
| 370 | // as the back mmap buffer will be shared with shared pointers. |
| 371 | return data.SetData (m_data, offset, length); |
| 372 | } |
| 373 | |
| 374 | size_t |
| 375 | ObjectFile::CopyData (off_t offset, size_t length, void *dst) const |
| 376 | { |
| 377 | // The entire file has already been mmap'ed into m_data, so just copy from there |
| 378 | return m_data.CopyByteOrderedData (offset, length, dst, length, lldb::endian::InlHostByteOrder()); |
| 379 | } |
Greg Clayton | b1888f2 | 2011-03-19 01:12:21 +0000 | [diff] [blame] | 380 | |
Greg Clayton | b5a8f14 | 2012-02-05 02:38:54 +0000 | [diff] [blame^] | 381 | |
| 382 | size_t |
| 383 | ObjectFile::ReadSectionData (const Section *section, off_t section_offset, void *dst, size_t dst_len) const |
| 384 | { |
| 385 | if (m_in_memory) |
| 386 | { |
| 387 | ProcessSP process_sp (m_process_wp.lock()); |
| 388 | if (process_sp) |
| 389 | { |
| 390 | Error error; |
| 391 | return process_sp->ReadMemory (section->GetLoadBaseAddress (&process_sp->GetTarget()) + section_offset, dst, dst_len, error); |
| 392 | } |
| 393 | } |
| 394 | else |
| 395 | { |
| 396 | return CopyData (section->GetFileOffset() + section_offset, dst_len, dst); |
| 397 | } |
| 398 | return 0; |
| 399 | } |
| 400 | |
| 401 | //---------------------------------------------------------------------- |
| 402 | // Get the section data the file on disk |
| 403 | //---------------------------------------------------------------------- |
| 404 | size_t |
| 405 | ObjectFile::ReadSectionData (const Section *section, DataExtractor& section_data) const |
| 406 | { |
| 407 | if (m_in_memory) |
| 408 | { |
| 409 | ProcessSP process_sp (m_process_wp.lock()); |
| 410 | if (process_sp) |
| 411 | { |
| 412 | DataBufferSP data_sp (ReadMemory (process_sp, section->GetLoadBaseAddress (&process_sp->GetTarget()), section->GetByteSize())); |
| 413 | if (data_sp) |
| 414 | { |
| 415 | section_data.SetData (data_sp, 0, data_sp->GetByteSize()); |
| 416 | section_data.SetByteOrder (process_sp->GetByteOrder()); |
| 417 | section_data.SetAddressByteSize (process_sp->GetAddressByteSize()); |
| 418 | return section_data.GetByteSize(); |
| 419 | } |
| 420 | } |
| 421 | } |
| 422 | else |
| 423 | { |
| 424 | // The object file now contains a full mmap'ed copy of the object file data, so just use this |
| 425 | return MemoryMapSectionData (section, section_data); |
| 426 | } |
| 427 | section_data.Clear(); |
| 428 | return 0; |
| 429 | } |
| 430 | |
| 431 | size_t |
| 432 | ObjectFile::MemoryMapSectionData (const Section *section, DataExtractor& section_data) const |
| 433 | { |
| 434 | if (m_in_memory) |
| 435 | { |
| 436 | return ReadSectionData (section, section_data); |
| 437 | } |
| 438 | else |
| 439 | { |
| 440 | // The object file now contains a full mmap'ed copy of the object file data, so just use this |
| 441 | return GetData(section->GetFileOffset(), section->GetByteSize(), section_data); |
| 442 | } |
| 443 | section_data.Clear(); |
| 444 | return 0; |
| 445 | } |
| 446 | |