LLDB mainline
ObjectFilePECOFF.cpp
Go to the documentation of this file.
1//===-- ObjectFilePECOFF.cpp ----------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "ObjectFilePECOFF.h"
10#include "PECallFrameInfo.h"
11#include "WindowsMiniDump.h"
12
13#include "lldb/Core/Module.h"
16#include "lldb/Core/Section.h"
21#include "lldb/Target/Process.h"
23#include "lldb/Target/Target.h"
29#include "lldb/Utility/Log.h"
31#include "lldb/Utility/Timer.h"
32#include "lldb/Utility/UUID.h"
33
34#include "llvm/BinaryFormat/COFF.h"
35#include "llvm/Object/COFFImportFile.h"
36#include "llvm/Support/CRC.h"
37#include "llvm/Support/Error.h"
38#include "llvm/Support/FormatAdapters.h"
39#include "llvm/Support/MemoryBuffer.h"
40#include "llvm/TargetParser/Host.h"
41#include <optional>
42
43#define IMAGE_DOS_SIGNATURE 0x5A4D // MZ
44#define IMAGE_NT_SIGNATURE 0x00004550 // PE00
45#define OPT_HEADER_MAGIC_PE32 0x010b
46#define OPT_HEADER_MAGIC_PE32_PLUS 0x020b
47
48using namespace lldb;
49using namespace lldb_private;
50
52
53namespace {
54
55static constexpr OptionEnumValueElement g_abi_enums[] = {
56 {
57 llvm::Triple::UnknownEnvironment,
58 "default",
59 "Use default target (if it is Windows) or MSVC",
60 },
61 {
62 llvm::Triple::MSVC,
63 "msvc",
64 "MSVC ABI",
65 },
66 {
67 llvm::Triple::GNU,
68 "gnu",
69 "MinGW / Itanium ABI",
70 },
71};
72
73#define LLDB_PROPERTIES_objectfilepecoff
74#include "ObjectFilePECOFFProperties.inc"
75
76enum {
77#define LLDB_PROPERTIES_objectfilepecoff
78#include "ObjectFilePECOFFPropertiesEnum.inc"
79};
80
81class PluginProperties : public Properties {
82public:
83 static ConstString GetSettingName() {
85 }
86
87 PluginProperties() {
88 m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
89 m_collection_sp->Initialize(g_objectfilepecoff_properties);
90 }
91
92 llvm::Triple::EnvironmentType ABI() const {
93 return GetPropertyAtIndexAs<llvm::Triple::EnvironmentType>(
94 ePropertyABI, llvm::Triple::UnknownEnvironment);
95 }
96
97 OptionValueDictionary *ModuleABIMap() const {
98 return m_collection_sp->GetPropertyAtIndexAsOptionValueDictionary(
99 ePropertyModuleABIMap);
100 }
101};
102
103} // namespace
104
105static PluginProperties &GetGlobalPluginProperties() {
106 static PluginProperties g_settings;
107 return g_settings;
108}
109
110static bool GetDebugLinkContents(const llvm::object::COFFObjectFile &coff_obj,
111 std::string &gnu_debuglink_file,
112 uint32_t &gnu_debuglink_crc) {
113 static ConstString g_sect_name_gnu_debuglink(".gnu_debuglink");
114 for (const auto &section : coff_obj.sections()) {
115 auto name = section.getName();
116 if (!name) {
117 llvm::consumeError(name.takeError());
118 continue;
119 }
120 if (*name == g_sect_name_gnu_debuglink.GetStringRef()) {
121 auto content = section.getContents();
122 if (!content) {
123 llvm::consumeError(content.takeError());
124 return false;
125 }
126 DataExtractor data(
127 content->data(), content->size(),
128 coff_obj.isLittleEndian() ? eByteOrderLittle : eByteOrderBig, 4);
129 lldb::offset_t gnu_debuglink_offset = 0;
130 gnu_debuglink_file = data.GetCStr(&gnu_debuglink_offset);
131 // Align to the next 4-byte offset
132 gnu_debuglink_offset = llvm::alignTo(gnu_debuglink_offset, 4);
133 data.GetU32(&gnu_debuglink_offset, &gnu_debuglink_crc, 1);
134 return true;
135 }
136 }
137 return false;
138}
139
140static UUID GetCoffUUID(llvm::object::COFFObjectFile &coff_obj) {
141 const llvm::codeview::DebugInfo *pdb_info = nullptr;
142 llvm::StringRef pdb_file;
143
144 // First, prefer to use the PDB build id. LLD generates this even for mingw
145 // targets without PDB output, and it does not get stripped either.
146 if (!coff_obj.getDebugPDBInfo(pdb_info, pdb_file) && pdb_info) {
147 if (pdb_info->PDB70.CVSignature == llvm::OMF::Signature::PDB70) {
149 memcpy(&info.Uuid, pdb_info->PDB70.Signature, sizeof(info.Uuid));
150 info.Age = pdb_info->PDB70.Age;
151 return UUID(info);
152 }
153 }
154
155 std::string gnu_debuglink_file;
156 uint32_t gnu_debuglink_crc;
157
158 // The GNU linker normally does not write a PDB build id (unless requested
159 // with the --build-id option), so we should fall back to using the crc
160 // from .gnu_debuglink if it exists, just like how ObjectFileELF does it.
161 if (!GetDebugLinkContents(coff_obj, gnu_debuglink_file, gnu_debuglink_crc)) {
162 // If there is no .gnu_debuglink section, then this may be an object
163 // containing DWARF debug info for .gnu_debuglink, so calculate the crc of
164 // the object itself.
165 auto raw_data = coff_obj.getData();
167 "Calculating module crc32 %s with size %" PRIu64 " KiB",
168 FileSpec(coff_obj.getFileName()).GetFilename().AsCString(),
169 static_cast<lldb::offset_t>(raw_data.size()) / 1024);
170 gnu_debuglink_crc = llvm::crc32(0, llvm::arrayRefFromStringRef(raw_data));
171 }
172 // Use 4 bytes of crc from the .gnu_debuglink section.
173 llvm::support::ulittle32_t data(gnu_debuglink_crc);
174 return UUID(&data, sizeof(data));
175}
176
178
184}
185
188 debugger, PluginProperties::GetSettingName())) {
189 const bool is_global_setting = true;
191 debugger, GetGlobalPluginProperties().GetValueProperties(),
192 "Properties for the PE/COFF object-file plug-in.", is_global_setting);
193 }
194}
195
198}
199
201 return "Portable Executable and Common Object File Format object file reader "
202 "(32 and 64 bit)";
203}
204
206 const lldb::ModuleSP &module_sp, DataBufferSP data_sp,
207 lldb::offset_t data_offset, const lldb_private::FileSpec *file_p,
208 lldb::offset_t file_offset, lldb::offset_t length) {
209 FileSpec file = file_p ? *file_p : FileSpec();
210 if (!data_sp) {
211 data_sp = MapFileData(file, length, file_offset);
212 if (!data_sp)
213 return nullptr;
214 data_offset = 0;
215 }
216
218 return nullptr;
219
220 // Update the data to contain the entire file if it doesn't already
221 if (data_sp->GetByteSize() < length) {
222 data_sp = MapFileData(file, length, file_offset);
223 if (!data_sp)
224 return nullptr;
225 }
226
227 auto objfile_up = std::make_unique<ObjectFilePECOFF>(
228 module_sp, data_sp, data_offset, file_p, file_offset, length);
229 if (!objfile_up || !objfile_up->ParseHeader())
230 return nullptr;
231
232 // Cache coff binary.
233 if (!objfile_up->CreateBinary())
234 return nullptr;
235 return objfile_up.release();
236}
237
239 const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp,
240 const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) {
241 if (!data_sp || !ObjectFilePECOFF::MagicBytesMatch(data_sp))
242 return nullptr;
243 auto objfile_up = std::make_unique<ObjectFilePECOFF>(
244 module_sp, data_sp, process_sp, header_addr);
245 if (objfile_up.get() && objfile_up->ParseHeader()) {
246 return objfile_up.release();
247 }
248 return nullptr;
249}
250
252 const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
253 lldb::offset_t data_offset, lldb::offset_t file_offset,
255 const size_t initial_count = specs.GetSize();
256 if (!data_sp || !ObjectFilePECOFF::MagicBytesMatch(data_sp))
257 return initial_count;
258
259 Log *log = GetLog(LLDBLog::Object);
260
261 if (data_sp->GetByteSize() < length)
262 if (DataBufferSP full_sp = MapFileData(file, -1, file_offset))
263 data_sp = std::move(full_sp);
264 auto binary = llvm::object::createBinary(llvm::MemoryBufferRef(
265 toStringRef(data_sp->GetData()), file.GetFilename().GetStringRef()));
266
267 if (!binary) {
268 LLDB_LOG_ERROR(log, binary.takeError(),
269 "Failed to create binary for file ({1}): {0}", file);
270 return initial_count;
271 }
272
273 auto *COFFObj = llvm::dyn_cast<llvm::object::COFFObjectFile>(binary->get());
274 if (!COFFObj)
275 return initial_count;
276
277 ModuleSpec module_spec(file);
278 ArchSpec &spec = module_spec.GetArchitecture();
279 lldb_private::UUID &uuid = module_spec.GetUUID();
280 if (!uuid.IsValid())
281 uuid = GetCoffUUID(*COFFObj);
282
283 static llvm::Triple::EnvironmentType default_env = [] {
284 auto def_target = llvm::Triple(
285 llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple()));
286 if (def_target.getOS() == llvm::Triple::Win32 &&
287 def_target.getEnvironment() != llvm::Triple::UnknownEnvironment)
288 return def_target.getEnvironment();
289 return llvm::Triple::MSVC;
290 }();
291
292 // Check for a module-specific override.
293 OptionValueSP module_env_option;
294 const auto *map = GetGlobalPluginProperties().ModuleABIMap();
295 if (map->GetNumValues() > 0) {
296 // Step 1: Try with the exact file name.
297 auto name = file.GetFilename();
298 module_env_option = map->GetValueForKey(name);
299 if (!module_env_option) {
300 // Step 2: Try with the file name in lowercase.
301 auto name_lower = name.GetStringRef().lower();
302 module_env_option = map->GetValueForKey(llvm::StringRef(name_lower));
303 }
304 if (!module_env_option) {
305 // Step 3: Try with the file name with ".debug" suffix stripped.
306 auto name_stripped = name.GetStringRef();
307 if (name_stripped.consume_back_insensitive(".debug")) {
308 module_env_option = map->GetValueForKey(name_stripped);
309 if (!module_env_option) {
310 // Step 4: Try with the file name in lowercase with ".debug" suffix
311 // stripped.
312 auto name_lower = name_stripped.lower();
313 module_env_option = map->GetValueForKey(llvm::StringRef(name_lower));
314 }
315 }
316 }
317 }
318 llvm::Triple::EnvironmentType env;
319 if (module_env_option)
320 env =
321 module_env_option->GetValueAs<llvm::Triple::EnvironmentType>().value_or(
322 static_cast<llvm::Triple::EnvironmentType>(0));
323 else
324 env = GetGlobalPluginProperties().ABI();
325
326 if (env == llvm::Triple::UnknownEnvironment)
327 env = default_env;
328
329 switch (COFFObj->getMachine()) {
330 case MachineAmd64:
331 spec.SetTriple("x86_64-pc-windows");
332 spec.GetTriple().setEnvironment(env);
333 specs.Append(module_spec);
334 break;
335 case MachineX86:
336 spec.SetTriple("i386-pc-windows");
337 spec.GetTriple().setEnvironment(env);
338 specs.Append(module_spec);
339 break;
340 case MachineArmNt:
341 spec.SetTriple("armv7-pc-windows");
342 spec.GetTriple().setEnvironment(env);
343 specs.Append(module_spec);
344 break;
345 case MachineArm64:
346 spec.SetTriple("aarch64-pc-windows");
347 spec.GetTriple().setEnvironment(env);
348 specs.Append(module_spec);
349 break;
350 default:
351 break;
352 }
353
354 return specs.GetSize() - initial_count;
355}
356
357bool ObjectFilePECOFF::SaveCore(const lldb::ProcessSP &process_sp,
358 const lldb_private::FileSpec &outfile,
359 lldb::SaveCoreStyle &core_style,
361 core_style = eSaveCoreFull;
362 return SaveMiniDump(process_sp, outfile, error);
363}
364
365bool ObjectFilePECOFF::MagicBytesMatch(DataBufferSP data_sp) {
366 DataExtractor data(data_sp, eByteOrderLittle, 4);
367 lldb::offset_t offset = 0;
368 uint16_t magic = data.GetU16(&offset);
369 return magic == IMAGE_DOS_SIGNATURE;
370}
371
373 // TODO: We need to complete this mapping of COFF symbol types to LLDB ones.
374 // For now, here's a hack to make sure our function have types.
375 const auto complex_type =
376 coff_symbol_type >> llvm::COFF::SCT_COMPLEX_TYPE_SHIFT;
377 if (complex_type == llvm::COFF::IMAGE_SYM_DTYPE_FUNCTION) {
379 }
380 const auto base_type = coff_symbol_type & 0xff;
381 if (base_type == llvm::COFF::IMAGE_SYM_TYPE_NULL &&
382 complex_type == llvm::COFF::IMAGE_SYM_DTYPE_NULL) {
383 // Unknown type. LLD and GNU ld uses this for variables on MinGW, so
384 // consider these symbols to be data to enable printing.
386 }
388}
389
391 if (m_binary)
392 return true;
393
394 Log *log = GetLog(LLDBLog::Object);
395
396 auto binary = llvm::object::createBinary(llvm::MemoryBufferRef(
397 toStringRef(m_data.GetData()), m_file.GetFilename().GetStringRef()));
398 if (!binary) {
399 LLDB_LOG_ERROR(log, binary.takeError(),
400 "Failed to create binary for file ({1}): {0}", m_file);
401 return false;
402 }
403
404 // Make sure we only handle COFF format.
405 m_binary =
406 llvm::unique_dyn_cast<llvm::object::COFFObjectFile>(std::move(*binary));
407 if (!m_binary)
408 return false;
409
410 LLDB_LOG(log, "this = {0}, module = {1} ({2}), file = {3}, binary = {4}",
411 this, GetModule().get(), GetModule()->GetSpecificationDescription(),
412 m_file.GetPath(), m_binary.get());
413 return true;
414}
415
416ObjectFilePECOFF::ObjectFilePECOFF(const lldb::ModuleSP &module_sp,
417 DataBufferSP data_sp,
418 lldb::offset_t data_offset,
419 const FileSpec *file,
420 lldb::offset_t file_offset,
421 lldb::offset_t length)
422 : ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset),
423 m_dos_header(), m_coff_header(), m_coff_header_opt(), m_sect_headers(),
424 m_image_base(LLDB_INVALID_ADDRESS), m_entry_point_address(),
425 m_deps_filespec() {}
426
427ObjectFilePECOFF::ObjectFilePECOFF(const lldb::ModuleSP &module_sp,
428 WritableDataBufferSP header_data_sp,
429 const lldb::ProcessSP &process_sp,
430 addr_t header_addr)
431 : ObjectFile(module_sp, process_sp, header_addr, header_data_sp),
432 m_dos_header(), m_coff_header(), m_coff_header_opt(), m_sect_headers(),
433 m_image_base(LLDB_INVALID_ADDRESS), m_entry_point_address(),
434 m_deps_filespec() {}
435
437
439 ModuleSP module_sp(GetModule());
440 if (module_sp) {
441 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
442 m_sect_headers.clear();
444 lldb::offset_t offset = 0;
445
447 offset = m_dos_header.e_lfanew;
448 uint32_t pe_signature = m_data.GetU32(&offset);
449 if (pe_signature != IMAGE_NT_SIGNATURE)
450 return false;
451 if (ParseCOFFHeader(m_data, &offset, m_coff_header)) {
452 if (m_coff_header.hdrsize > 0)
454 ParseSectionHeaders(offset);
455 }
457 return true;
458 }
459 }
460 return false;
461}
462
464 bool value_is_offset) {
465 bool changed = false;
466 ModuleSP module_sp = GetModule();
467 if (module_sp) {
468 size_t num_loaded_sections = 0;
469 SectionList *section_list = GetSectionList();
470 if (section_list) {
471 if (!value_is_offset) {
472 value -= m_image_base;
473 }
474
475 const size_t num_sections = section_list->GetSize();
476 size_t sect_idx = 0;
477
478 for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
479 // Iterate through the object file sections to find all of the sections
480 // that have SHF_ALLOC in their flag bits.
481 SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
482 if (section_sp && !section_sp->IsThreadSpecific()) {
484 section_sp, section_sp->GetFileAddress() + value))
485 ++num_loaded_sections;
486 }
487 }
488 changed = num_loaded_sections > 0;
489 }
490 }
491 return changed;
492}
493
495
497 return (m_coff_header.flags & llvm::COFF::IMAGE_FILE_DLL) == 0;
498}
499
502 return 8;
504 return 4;
505 return 4;
506}
507
508// NeedsEndianSwap
509//
510// Return true if an endian swap needs to occur when extracting data from this
511// file.
513#if defined(__LITTLE_ENDIAN__)
514 return false;
515#else
516 return true;
517#endif
518}
519// ParseDOSHeader
522 bool success = false;
523 lldb::offset_t offset = 0;
524 success = data.ValidOffsetForDataOfSize(0, sizeof(dos_header));
525
526 if (success) {
527 dos_header.e_magic = data.GetU16(&offset); // Magic number
529
530 if (success) {
531 dos_header.e_cblp = data.GetU16(&offset); // Bytes on last page of file
532 dos_header.e_cp = data.GetU16(&offset); // Pages in file
533 dos_header.e_crlc = data.GetU16(&offset); // Relocations
535 data.GetU16(&offset); // Size of header in paragraphs
537 data.GetU16(&offset); // Minimum extra paragraphs needed
539 data.GetU16(&offset); // Maximum extra paragraphs needed
540 dos_header.e_ss = data.GetU16(&offset); // Initial (relative) SS value
541 dos_header.e_sp = data.GetU16(&offset); // Initial SP value
542 dos_header.e_csum = data.GetU16(&offset); // Checksum
543 dos_header.e_ip = data.GetU16(&offset); // Initial IP value
544 dos_header.e_cs = data.GetU16(&offset); // Initial (relative) CS value
546 data.GetU16(&offset); // File address of relocation table
547 dos_header.e_ovno = data.GetU16(&offset); // Overlay number
548
549 dos_header.e_res[0] = data.GetU16(&offset); // Reserved words
550 dos_header.e_res[1] = data.GetU16(&offset); // Reserved words
551 dos_header.e_res[2] = data.GetU16(&offset); // Reserved words
552 dos_header.e_res[3] = data.GetU16(&offset); // Reserved words
553
555 data.GetU16(&offset); // OEM identifier (for e_oeminfo)
557 data.GetU16(&offset); // OEM information; e_oemid specific
558 dos_header.e_res2[0] = data.GetU16(&offset); // Reserved words
559 dos_header.e_res2[1] = data.GetU16(&offset); // Reserved words
560 dos_header.e_res2[2] = data.GetU16(&offset); // Reserved words
561 dos_header.e_res2[3] = data.GetU16(&offset); // Reserved words
562 dos_header.e_res2[4] = data.GetU16(&offset); // Reserved words
563 dos_header.e_res2[5] = data.GetU16(&offset); // Reserved words
564 dos_header.e_res2[6] = data.GetU16(&offset); // Reserved words
565 dos_header.e_res2[7] = data.GetU16(&offset); // Reserved words
566 dos_header.e_res2[8] = data.GetU16(&offset); // Reserved words
567 dos_header.e_res2[9] = data.GetU16(&offset); // Reserved words
568
570 data.GetU32(&offset); // File address of new exe header
571 }
572 }
573 if (!success)
574 memset(&dos_header, 0, sizeof(dos_header));
575 return success;
576}
577
578// ParserCOFFHeader
580 lldb::offset_t *offset_ptr,
582 bool success =
583 data.ValidOffsetForDataOfSize(*offset_ptr, sizeof(coff_header));
584 if (success) {
585 coff_header.machine = data.GetU16(offset_ptr);
586 coff_header.nsects = data.GetU16(offset_ptr);
587 coff_header.modtime = data.GetU32(offset_ptr);
588 coff_header.symoff = data.GetU32(offset_ptr);
589 coff_header.nsyms = data.GetU32(offset_ptr);
590 coff_header.hdrsize = data.GetU16(offset_ptr);
591 coff_header.flags = data.GetU16(offset_ptr);
592 }
593 if (!success)
594 memset(&coff_header, 0, sizeof(coff_header));
595 return success;
596}
597
599 bool success = false;
600 const lldb::offset_t end_offset = *offset_ptr + m_coff_header.hdrsize;
601 if (*offset_ptr < end_offset) {
602 success = true;
603 m_coff_header_opt.magic = m_data.GetU16(offset_ptr);
609 m_coff_header_opt.entry = m_data.GetU32(offset_ptr);
611
612 const uint32_t addr_byte_size = GetAddressByteSize();
613
614 if (*offset_ptr < end_offset) {
616 // PE32 only
618 } else
620
621 if (*offset_ptr < end_offset) {
623 m_data.GetMaxU64(offset_ptr, addr_byte_size);
639 m_data.GetMaxU64(offset_ptr, addr_byte_size);
641 m_data.GetMaxU64(offset_ptr, addr_byte_size);
643 m_data.GetMaxU64(offset_ptr, addr_byte_size);
645 m_data.GetMaxU64(offset_ptr, addr_byte_size);
647 uint32_t num_data_dir_entries = m_data.GetU32(offset_ptr);
649 m_coff_header_opt.data_dirs.resize(num_data_dir_entries);
650 uint32_t i;
651 for (i = 0; i < num_data_dir_entries; i++) {
652 m_coff_header_opt.data_dirs[i].vmaddr = m_data.GetU32(offset_ptr);
653 m_coff_header_opt.data_dirs[i].vmsize = m_data.GetU32(offset_ptr);
654 }
655
657 }
658 }
659 }
660 // Make sure we are on track for section data which follows
661 *offset_ptr = end_offset;
662 return success;
663}
664
666 return addr.GetFileAddress() - m_image_base;
667}
668
670 SectionList *sect_list = GetSectionList();
671 if (!sect_list)
672 return Address(GetFileAddress(rva));
673
674 return Address(GetFileAddress(rva), sect_list);
675}
676
678 return m_image_base + rva;
679}
680
682 if (!size)
683 return {};
684
685 if (m_data.ValidOffsetForDataOfSize(offset, size))
686 return DataExtractor(m_data, offset, size);
687
688 ProcessSP process_sp(m_process_wp.lock());
689 DataExtractor data;
690 if (process_sp) {
691 auto data_up = std::make_unique<DataBufferHeap>(size, 0);
692 Status readmem_error;
693 size_t bytes_read =
694 process_sp->ReadMemory(m_image_base + offset, data_up->GetBytes(),
695 data_up->GetByteSize(), readmem_error);
696 if (bytes_read == size) {
697 DataBufferSP buffer_sp(data_up.release());
698 data.SetData(buffer_sp, 0, buffer_sp->GetByteSize());
699 }
700 }
701 return data;
702}
703
705 Address addr = GetAddress(rva);
706 SectionSP sect = addr.GetSection();
707 if (!sect)
708 return {};
709 rva = sect->GetFileOffset() + addr.GetOffset();
710
711 return ReadImageData(rva, size);
712}
713
714// ParseSectionHeaders
716 uint32_t section_header_data_offset) {
717 const uint32_t nsects = m_coff_header.nsects;
718 m_sect_headers.clear();
719
720 if (nsects > 0) {
721 const size_t section_header_byte_size = nsects * sizeof(section_header_t);
722 DataExtractor section_header_data =
723 ReadImageData(section_header_data_offset, section_header_byte_size);
724
725 lldb::offset_t offset = 0;
726 if (section_header_data.ValidOffsetForDataOfSize(
727 offset, section_header_byte_size)) {
728 m_sect_headers.resize(nsects);
729
730 for (uint32_t idx = 0; idx < nsects; ++idx) {
731 const void *name_data = section_header_data.GetData(&offset, 8);
732 if (name_data) {
733 memcpy(m_sect_headers[idx].name, name_data, 8);
734 m_sect_headers[idx].vmsize = section_header_data.GetU32(&offset);
735 m_sect_headers[idx].vmaddr = section_header_data.GetU32(&offset);
736 m_sect_headers[idx].size = section_header_data.GetU32(&offset);
737 m_sect_headers[idx].offset = section_header_data.GetU32(&offset);
738 m_sect_headers[idx].reloff = section_header_data.GetU32(&offset);
739 m_sect_headers[idx].lineoff = section_header_data.GetU32(&offset);
740 m_sect_headers[idx].nreloc = section_header_data.GetU16(&offset);
741 m_sect_headers[idx].nline = section_header_data.GetU16(&offset);
742 m_sect_headers[idx].flags = section_header_data.GetU32(&offset);
743 }
744 }
745 }
746 }
747
748 return !m_sect_headers.empty();
749}
750
752 llvm::StringRef hdr_name(sect.name, std::size(sect.name));
753 hdr_name = hdr_name.split('\0').first;
754 if (hdr_name.consume_front("/")) {
755 lldb::offset_t stroff;
756 if (!to_integer(hdr_name, stroff, 10))
757 return "";
758 lldb::offset_t string_file_offset =
759 m_coff_header.symoff + (m_coff_header.nsyms * 18) + stroff;
760 if (const char *name = m_data.GetCStr(&string_file_offset))
761 return name;
762 return "";
763 }
764 return hdr_name;
765}
766
768 SectionList *sect_list = GetSectionList();
769 rva_symbol_list_t sorted_exports = AppendFromExportTable(sect_list, symtab);
770 AppendFromCOFFSymbolTable(sect_list, symtab, sorted_exports);
771}
772
773static bool RVASymbolListCompareRVA(const std::pair<uint32_t, uint32_t> &a,
774 const std::pair<uint32_t, uint32_t> &b) {
775 return a.first < b.first;
776}
777
779 SectionList *sect_list, Symtab &symtab,
780 const ObjectFilePECOFF::rva_symbol_list_t &sorted_exports) {
781 const uint32_t num_syms = m_binary->getNumberOfSymbols();
782 if (num_syms == 0)
783 return;
784 // Check that this is not a bigobj; we do not support bigobj.
785 if (m_binary->getSymbolTableEntrySize() !=
786 sizeof(llvm::object::coff_symbol16))
787 return;
788
789 Log *log = GetLog(LLDBLog::Object);
790 symtab.Reserve(symtab.GetNumSymbols() + num_syms);
791 for (const auto &sym_ref : m_binary->symbols()) {
792 const auto coff_sym_ref = m_binary->getCOFFSymbol(sym_ref);
793 auto name_or_error = sym_ref.getName();
794 if (auto err = name_or_error.takeError()) {
795 LLDB_LOG(log,
796 "ObjectFilePECOFF::AppendFromCOFFSymbolTable - failed to get "
797 "symbol table entry name: {0}",
798 llvm::fmt_consume(std::move(err)));
799 continue;
800 }
801 const llvm::StringRef sym_name = *name_or_error;
802 Symbol symbol;
803 symbol.GetMangled().SetValue(ConstString(sym_name));
804 int16_t section_number =
805 static_cast<int16_t>(coff_sym_ref.getSectionNumber());
806 if (section_number >= 1) {
807 symbol.GetAddressRef() = Address(
808 sect_list->FindSectionByID(section_number), coff_sym_ref.getValue());
809 const auto symbol_type = MapSymbolType(coff_sym_ref.getType());
810 symbol.SetType(symbol_type);
811
812 // Check for duplicate of exported symbols:
813 const uint32_t symbol_rva = symbol.GetAddressRef().GetFileAddress() -
815 const auto &first_match = std::lower_bound(
816 sorted_exports.begin(), sorted_exports.end(),
817 std::make_pair(symbol_rva, 0), RVASymbolListCompareRVA);
818 for (auto it = first_match;
819 it != sorted_exports.end() && it->first == symbol_rva; ++it) {
820 Symbol *exported = symtab.SymbolAtIndex(it->second);
821 if (symbol_type != lldb::eSymbolTypeInvalid)
822 exported->SetType(symbol_type);
823 if (exported->GetMangled() == symbol.GetMangled()) {
824 symbol.SetExternal(true);
825 // We don't want the symbol to be duplicated (e.g. when running
826 // `disas -n func`), but we also don't want to erase this entry (to
827 // preserve the original symbol order), so we mark it as additional.
829 } else {
830 // It is possible for a symbol to be exported in a different name
831 // from its original. In this case keep both entries so lookup using
832 // either names will work. If this symbol has an invalid type, replace
833 // it with the type from the export symbol.
834 if (symbol.GetType() == lldb::eSymbolTypeInvalid)
835 symbol.SetType(exported->GetType());
836 }
837 }
838 } else if (section_number == llvm::COFF::IMAGE_SYM_ABSOLUTE) {
839 symbol.GetAddressRef() = Address(coff_sym_ref.getValue());
841 }
842 symtab.AddSymbol(symbol);
843 }
844}
845
848 Symtab &symtab) {
849 const auto *export_table = m_binary->getExportTable();
850 if (!export_table)
851 return {};
852 const uint32_t num_syms = export_table->AddressTableEntries;
853 if (num_syms == 0)
854 return {};
855
856 Log *log = GetLog(LLDBLog::Object);
857 rva_symbol_list_t export_list;
858 symtab.Reserve(symtab.GetNumSymbols() + num_syms);
859 // Read each export table entry, ordered by ordinal instead of by name.
860 for (const auto &entry : m_binary->export_directories()) {
861 llvm::StringRef sym_name;
862 if (auto err = entry.getSymbolName(sym_name)) {
863 if (log)
864 log->Format(
865 __FILE__, __func__,
866 "ObjectFilePECOFF::AppendFromExportTable - failed to get export "
867 "table entry name: {0}",
868 llvm::fmt_consume(std::move(err)));
869 else
870 llvm::consumeError(std::move(err));
871 continue;
872 }
873 Symbol symbol;
874 // Note: symbol name may be empty if it is only exported by ordinal.
875 symbol.GetMangled().SetValue(ConstString(sym_name));
876
877 uint32_t ordinal;
878 llvm::cantFail(entry.getOrdinal(ordinal));
879 symbol.SetID(ordinal);
880
881 bool is_forwarder;
882 llvm::cantFail(entry.isForwarder(is_forwarder));
883 if (is_forwarder) {
884 // Forwarder exports are redirected by the loader transparently, but keep
885 // it in symtab and make a note using the symbol name.
886 llvm::StringRef forwarder_name;
887 if (auto err = entry.getForwardTo(forwarder_name)) {
888 if (log)
889 log->Format(__FILE__, __func__,
890 "ObjectFilePECOFF::AppendFromExportTable - failed to get "
891 "forwarder name of forwarder export '{0}': {1}",
892 sym_name, llvm::fmt_consume(std::move(err)));
893 else
894 llvm::consumeError(std::move(err));
895 continue;
896 }
897 llvm::SmallString<256> new_name = {symbol.GetDisplayName().GetStringRef(),
898 " (forwarded to ", forwarder_name,
899 ")"};
900 symbol.GetMangled().SetDemangledName(ConstString(new_name.str()));
902 }
903
904 uint32_t function_rva;
905 if (auto err = entry.getExportRVA(function_rva)) {
906 if (log)
907 log->Format(__FILE__, __func__,
908 "ObjectFilePECOFF::AppendFromExportTable - failed to get "
909 "address of export entry '{0}': {1}",
910 sym_name, llvm::fmt_consume(std::move(err)));
911 else
912 llvm::consumeError(std::move(err));
913 continue;
914 }
915 // Skip the symbol if it doesn't look valid.
916 if (function_rva == 0 && sym_name.empty())
917 continue;
918 symbol.GetAddressRef() =
919 Address(m_coff_header_opt.image_base + function_rva, sect_list);
920
921 // An exported symbol may be either code or data. Guess by checking whether
922 // the section containing the symbol is executable.
924 if (!is_forwarder)
925 if (auto section_sp = symbol.GetAddressRef().GetSection())
926 if (section_sp->GetPermissions() & ePermissionsExecutable)
928 symbol.SetExternal(true);
929 uint32_t idx = symtab.AddSymbol(symbol);
930 export_list.push_back(std::make_pair(function_rva, idx));
931 }
932 std::stable_sort(export_list.begin(), export_list.end(),
934 return export_list;
935}
936
937std::unique_ptr<CallFrameInfo> ObjectFilePECOFF::CreateCallFrameInfo() {
938 if (llvm::COFF::EXCEPTION_TABLE >= m_coff_header_opt.data_dirs.size())
939 return {};
940
941 data_directory data_dir_exception =
942 m_coff_header_opt.data_dirs[llvm::COFF::EXCEPTION_TABLE];
943 if (!data_dir_exception.vmaddr)
944 return {};
945
946 if (m_coff_header.machine != llvm::COFF::IMAGE_FILE_MACHINE_AMD64)
947 return {};
948
949 return std::make_unique<PECallFrameInfo>(*this, data_dir_exception.vmaddr,
950 data_dir_exception.vmsize);
951}
952
954 // TODO: determine this for COFF
955 return false;
956}
957
959 const section_header_t &sect) {
960 ConstString const_sect_name(sect_name);
961 static ConstString g_code_sect_name(".code");
962 static ConstString g_CODE_sect_name("CODE");
963 static ConstString g_data_sect_name(".data");
964 static ConstString g_DATA_sect_name("DATA");
965 static ConstString g_bss_sect_name(".bss");
966 static ConstString g_BSS_sect_name("BSS");
967
968 if (sect.flags & llvm::COFF::IMAGE_SCN_CNT_CODE &&
969 ((const_sect_name == g_code_sect_name) ||
970 (const_sect_name == g_CODE_sect_name))) {
971 return eSectionTypeCode;
972 }
973 if (sect.flags & llvm::COFF::IMAGE_SCN_CNT_INITIALIZED_DATA &&
974 ((const_sect_name == g_data_sect_name) ||
975 (const_sect_name == g_DATA_sect_name))) {
976 if (sect.size == 0 && sect.offset == 0)
978 else
979 return eSectionTypeData;
980 }
981 if (sect.flags & llvm::COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA &&
982 ((const_sect_name == g_bss_sect_name) ||
983 (const_sect_name == g_BSS_sect_name))) {
984 if (sect.size == 0)
986 else
987 return eSectionTypeData;
988 }
989
990 SectionType section_type =
991 llvm::StringSwitch<SectionType>(sect_name)
992 .Case(".debug", eSectionTypeDebug)
993 .Case(".stabstr", eSectionTypeDataCString)
994 .Case(".reloc", eSectionTypeOther)
995 .Case(".debug_abbrev", eSectionTypeDWARFDebugAbbrev)
996 .Case(".debug_aranges", eSectionTypeDWARFDebugAranges)
997 .Case(".debug_frame", eSectionTypeDWARFDebugFrame)
998 .Case(".debug_info", eSectionTypeDWARFDebugInfo)
999 .Case(".debug_line", eSectionTypeDWARFDebugLine)
1000 .Case(".debug_loc", eSectionTypeDWARFDebugLoc)
1001 .Case(".debug_loclists", eSectionTypeDWARFDebugLocLists)
1002 .Case(".debug_macinfo", eSectionTypeDWARFDebugMacInfo)
1003 .Case(".debug_names", eSectionTypeDWARFDebugNames)
1004 .Case(".debug_pubnames", eSectionTypeDWARFDebugPubNames)
1005 .Case(".debug_pubtypes", eSectionTypeDWARFDebugPubTypes)
1006 .Case(".debug_ranges", eSectionTypeDWARFDebugRanges)
1007 .Case(".debug_str", eSectionTypeDWARFDebugStr)
1008 .Case(".debug_types", eSectionTypeDWARFDebugTypes)
1009 // .eh_frame can be truncated to 8 chars.
1010 .Cases(".eh_frame", ".eh_fram", eSectionTypeEHFrame)
1011 .Case(".gosymtab", eSectionTypeGoSymtab)
1012 .Default(eSectionTypeInvalid);
1013 if (section_type != eSectionTypeInvalid)
1014 return section_type;
1015
1016 if (sect.flags & llvm::COFF::IMAGE_SCN_CNT_CODE)
1017 return eSectionTypeCode;
1018 if (sect.flags & llvm::COFF::IMAGE_SCN_CNT_INITIALIZED_DATA)
1019 return eSectionTypeData;
1020 if (sect.flags & llvm::COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA) {
1021 if (sect.size == 0)
1022 return eSectionTypeZeroFill;
1023 else
1024 return eSectionTypeData;
1025 }
1026 return eSectionTypeOther;
1027}
1028
1030 if (m_sections_up)
1031 return;
1032 m_sections_up = std::make_unique<SectionList>();
1033 ModuleSP module_sp(GetModule());
1034 if (module_sp) {
1035 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
1036
1037 SectionSP header_sp = std::make_shared<Section>(
1038 module_sp, this, ~user_id_t(0), ConstString("PECOFF header"),
1041 /*file_offset*/ 0, m_coff_header_opt.header_size,
1043 /*flags*/ 0);
1044 header_sp->SetPermissions(ePermissionsReadable);
1045 m_sections_up->AddSection(header_sp);
1046 unified_section_list.AddSection(header_sp);
1047
1048 const uint32_t nsects = m_sect_headers.size();
1049 for (uint32_t idx = 0; idx < nsects; ++idx) {
1050 llvm::StringRef sect_name = GetSectionName(m_sect_headers[idx]);
1051 ConstString const_sect_name(sect_name);
1052 SectionType section_type = GetSectionType(sect_name, m_sect_headers[idx]);
1053
1054 SectionSP section_sp(new Section(
1055 module_sp, // Module to which this section belongs
1056 this, // Object file to which this section belongs
1057 idx + 1, // Section ID is the 1 based section index.
1058 const_sect_name, // Name of this section
1059 section_type,
1061 m_sect_headers[idx].vmaddr, // File VM address == addresses as
1062 // they are found in the object file
1063 m_sect_headers[idx].vmsize, // VM size in bytes of this section
1064 m_sect_headers[idx]
1065 .offset, // Offset to the data for this section in the file
1066 m_sect_headers[idx]
1067 .size, // Size in bytes of this section as found in the file
1068 m_coff_header_opt.sect_alignment, // Section alignment
1069 m_sect_headers[idx].flags)); // Flags for this section
1070
1071 uint32_t permissions = 0;
1072 if (m_sect_headers[idx].flags & llvm::COFF::IMAGE_SCN_MEM_EXECUTE)
1073 permissions |= ePermissionsExecutable;
1074 if (m_sect_headers[idx].flags & llvm::COFF::IMAGE_SCN_MEM_READ)
1075 permissions |= ePermissionsReadable;
1076 if (m_sect_headers[idx].flags & llvm::COFF::IMAGE_SCN_MEM_WRITE)
1077 permissions |= ePermissionsWritable;
1078 section_sp->SetPermissions(permissions);
1079
1080 m_sections_up->AddSection(section_sp);
1081 unified_section_list.AddSection(section_sp);
1082 }
1083 }
1084}
1085
1087 if (m_uuid.IsValid())
1088 return m_uuid;
1089
1090 if (!CreateBinary())
1091 return UUID();
1092
1094 return m_uuid;
1095}
1096
1097std::optional<FileSpec> ObjectFilePECOFF::GetDebugLink() {
1098 std::string gnu_debuglink_file;
1099 uint32_t gnu_debuglink_crc;
1100 if (GetDebugLinkContents(*m_binary, gnu_debuglink_file, gnu_debuglink_crc))
1101 return FileSpec(gnu_debuglink_file);
1102 return std::nullopt;
1103}
1104
1106 ModuleSP module_sp(GetModule());
1107 if (!module_sp)
1108 return 0;
1109
1110 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
1111 if (m_deps_filespec)
1112 return m_deps_filespec->GetSize();
1113
1114 // Cache coff binary if it is not done yet.
1115 if (!CreateBinary())
1116 return 0;
1117
1118 Log *log = GetLog(LLDBLog::Object);
1119 LLDB_LOG(log, "this = {0}, module = {1} ({2}), file = {3}, binary = {4}",
1120 this, GetModule().get(), GetModule()->GetSpecificationDescription(),
1121 m_file.GetPath(), m_binary.get());
1122
1124
1125 for (const auto &entry : m_binary->import_directories()) {
1126 llvm::StringRef dll_name;
1127 // Report a bogus entry.
1128 if (llvm::Error e = entry.getName(dll_name)) {
1129 LLDB_LOGF(log,
1130 "ObjectFilePECOFF::ParseDependentModules() - failed to get "
1131 "import directory entry name: %s",
1132 llvm::toString(std::move(e)).c_str());
1133 continue;
1134 }
1135
1136 // At this moment we only have the base name of the DLL. The full path can
1137 // only be seen after the dynamic loading. Our best guess is Try to get it
1138 // with the help of the object file's directory.
1139 llvm::SmallString<128> dll_fullpath;
1140 FileSpec dll_specs(dll_name);
1141 dll_specs.SetDirectory(m_file.GetDirectory());
1142
1143 if (!llvm::sys::fs::real_path(dll_specs.GetPath(), dll_fullpath))
1144 m_deps_filespec->EmplaceBack(dll_fullpath);
1145 else {
1146 // Known DLLs or DLL not found in the object file directory.
1147 m_deps_filespec->EmplaceBack(dll_name);
1148 }
1149 }
1150 return m_deps_filespec->GetSize();
1151}
1152
1154 auto num_modules = ParseDependentModules();
1155 auto original_size = files.GetSize();
1156
1157 for (unsigned i = 0; i < num_modules; ++i)
1158 files.AppendIfUnique(m_deps_filespec->GetFileSpecAtIndex(i));
1159
1160 return files.GetSize() - original_size;
1161}
1162
1165 return m_entry_point_address;
1166
1167 if (!ParseHeader() || !IsExecutable())
1168 return m_entry_point_address;
1169
1170 SectionList *section_list = GetSectionList();
1172
1173 if (!section_list)
1175 else
1177 section_list);
1178 return m_entry_point_address;
1179}
1180
1182 return Address(GetSectionList()->GetSectionAtIndex(0), 0);
1183}
1184
1185// Dump
1186//
1187// Dump the specifics of the runtime file container (such as any headers
1188// segments, sections, etc).
1190 ModuleSP module_sp(GetModule());
1191 if (module_sp) {
1192 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
1193 s->Printf("%p: ", static_cast<void *>(this));
1194 s->Indent();
1195 s->PutCString("ObjectFilePECOFF");
1196
1197 ArchSpec header_arch = GetArchitecture();
1198
1199 *s << ", file = '" << m_file
1200 << "', arch = " << header_arch.GetArchitectureName() << "\n";
1201
1202 SectionList *sections = GetSectionList();
1203 if (sections)
1204 sections->Dump(s->AsRawOstream(), s->GetIndentLevel(), nullptr, true,
1205 UINT32_MAX);
1206
1207 if (m_symtab_up)
1208 m_symtab_up->Dump(s, nullptr, eSortOrderNone);
1209
1212 if (m_coff_header.machine) {
1216 }
1217 s->EOL();
1219 s->EOL();
1220
1222 s->EOL();
1223 }
1224}
1225
1226// DumpDOSHeader
1227//
1228// Dump the MS-DOS header to the specified output stream
1230 s->PutCString("MSDOS Header\n");
1231 s->Printf(" e_magic = 0x%4.4x\n", header.e_magic);
1232 s->Printf(" e_cblp = 0x%4.4x\n", header.e_cblp);
1233 s->Printf(" e_cp = 0x%4.4x\n", header.e_cp);
1234 s->Printf(" e_crlc = 0x%4.4x\n", header.e_crlc);
1235 s->Printf(" e_cparhdr = 0x%4.4x\n", header.e_cparhdr);
1236 s->Printf(" e_minalloc = 0x%4.4x\n", header.e_minalloc);
1237 s->Printf(" e_maxalloc = 0x%4.4x\n", header.e_maxalloc);
1238 s->Printf(" e_ss = 0x%4.4x\n", header.e_ss);
1239 s->Printf(" e_sp = 0x%4.4x\n", header.e_sp);
1240 s->Printf(" e_csum = 0x%4.4x\n", header.e_csum);
1241 s->Printf(" e_ip = 0x%4.4x\n", header.e_ip);
1242 s->Printf(" e_cs = 0x%4.4x\n", header.e_cs);
1243 s->Printf(" e_lfarlc = 0x%4.4x\n", header.e_lfarlc);
1244 s->Printf(" e_ovno = 0x%4.4x\n", header.e_ovno);
1245 s->Printf(" e_res[4] = { 0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x }\n",
1246 header.e_res[0], header.e_res[1], header.e_res[2], header.e_res[3]);
1247 s->Printf(" e_oemid = 0x%4.4x\n", header.e_oemid);
1248 s->Printf(" e_oeminfo = 0x%4.4x\n", header.e_oeminfo);
1249 s->Printf(" e_res2[10] = { 0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x, "
1250 "0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x }\n",
1251 header.e_res2[0], header.e_res2[1], header.e_res2[2],
1252 header.e_res2[3], header.e_res2[4], header.e_res2[5],
1253 header.e_res2[6], header.e_res2[7], header.e_res2[8],
1254 header.e_res2[9]);
1255 s->Printf(" e_lfanew = 0x%8.8x\n", header.e_lfanew);
1256}
1257
1258// DumpCOFFHeader
1259//
1260// Dump the COFF header to the specified output stream
1262 s->PutCString("COFF Header\n");
1263 s->Printf(" machine = 0x%4.4x\n", header.machine);
1264 s->Printf(" nsects = 0x%4.4x\n", header.nsects);
1265 s->Printf(" modtime = 0x%8.8x\n", header.modtime);
1266 s->Printf(" symoff = 0x%8.8x\n", header.symoff);
1267 s->Printf(" nsyms = 0x%8.8x\n", header.nsyms);
1268 s->Printf(" hdrsize = 0x%4.4x\n", header.hdrsize);
1269}
1270
1271// DumpOptCOFFHeader
1272//
1273// Dump the optional COFF header to the specified output stream
1275 const coff_opt_header_t &header) {
1276 s->PutCString("Optional COFF Header\n");
1277 s->Printf(" magic = 0x%4.4x\n", header.magic);
1278 s->Printf(" major_linker_version = 0x%2.2x\n",
1279 header.major_linker_version);
1280 s->Printf(" minor_linker_version = 0x%2.2x\n",
1281 header.minor_linker_version);
1282 s->Printf(" code_size = 0x%8.8x\n", header.code_size);
1283 s->Printf(" data_size = 0x%8.8x\n", header.data_size);
1284 s->Printf(" bss_size = 0x%8.8x\n", header.bss_size);
1285 s->Printf(" entry = 0x%8.8x\n", header.entry);
1286 s->Printf(" code_offset = 0x%8.8x\n", header.code_offset);
1287 s->Printf(" data_offset = 0x%8.8x\n", header.data_offset);
1288 s->Printf(" image_base = 0x%16.16" PRIx64 "\n",
1289 header.image_base);
1290 s->Printf(" sect_alignment = 0x%8.8x\n", header.sect_alignment);
1291 s->Printf(" file_alignment = 0x%8.8x\n", header.file_alignment);
1292 s->Printf(" major_os_system_version = 0x%4.4x\n",
1294 s->Printf(" minor_os_system_version = 0x%4.4x\n",
1296 s->Printf(" major_image_version = 0x%4.4x\n",
1297 header.major_image_version);
1298 s->Printf(" minor_image_version = 0x%4.4x\n",
1299 header.minor_image_version);
1300 s->Printf(" major_subsystem_version = 0x%4.4x\n",
1302 s->Printf(" minor_subsystem_version = 0x%4.4x\n",
1304 s->Printf(" reserved1 = 0x%8.8x\n", header.reserved1);
1305 s->Printf(" image_size = 0x%8.8x\n", header.image_size);
1306 s->Printf(" header_size = 0x%8.8x\n", header.header_size);
1307 s->Printf(" checksum = 0x%8.8x\n", header.checksum);
1308 s->Printf(" subsystem = 0x%4.4x\n", header.subsystem);
1309 s->Printf(" dll_flags = 0x%4.4x\n", header.dll_flags);
1310 s->Printf(" stack_reserve_size = 0x%16.16" PRIx64 "\n",
1311 header.stack_reserve_size);
1312 s->Printf(" stack_commit_size = 0x%16.16" PRIx64 "\n",
1313 header.stack_commit_size);
1314 s->Printf(" heap_reserve_size = 0x%16.16" PRIx64 "\n",
1315 header.heap_reserve_size);
1316 s->Printf(" heap_commit_size = 0x%16.16" PRIx64 "\n",
1317 header.heap_commit_size);
1318 s->Printf(" loader_flags = 0x%8.8x\n", header.loader_flags);
1319 s->Printf(" num_data_dir_entries = 0x%8.8x\n",
1320 (uint32_t)header.data_dirs.size());
1321 uint32_t i;
1322 for (i = 0; i < header.data_dirs.size(); i++) {
1323 s->Printf(" data_dirs[%2u] vmaddr = 0x%8.8x, vmsize = 0x%8.8x\n", i,
1324 header.data_dirs[i].vmaddr, header.data_dirs[i].vmsize);
1325 }
1326}
1327// DumpSectionHeader
1328//
1329// Dump a single ELF section header to the specified output stream
1331 const section_header_t &sh) {
1332 std::string name = std::string(GetSectionName(sh));
1333 s->Printf("%-16s 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x 0x%4.4x "
1334 "0x%4.4x 0x%8.8x\n",
1335 name.c_str(), sh.vmaddr, sh.vmsize, sh.offset, sh.size, sh.reloff,
1336 sh.lineoff, sh.nreloc, sh.nline, sh.flags);
1337}
1338
1339// DumpSectionHeaders
1340//
1341// Dump all of the ELF section header to the specified output stream
1343
1344 s->PutCString("Section Headers\n");
1345 s->PutCString("IDX name vm addr vm size file off file "
1346 "size reloc off line off nreloc nline flags\n");
1347 s->PutCString("==== ---------------- ---------- ---------- ---------- "
1348 "---------- ---------- ---------- ------ ------ ----------\n");
1349
1350 uint32_t idx = 0;
1351 SectionHeaderCollIter pos, end = m_sect_headers.end();
1352
1353 for (pos = m_sect_headers.begin(); pos != end; ++pos, ++idx) {
1354 s->Printf("[%2u] ", idx);
1356 }
1357}
1358
1359// DumpDependentModules
1360//
1361// Dump all of the dependent modules to the specified output stream
1363 auto num_modules = ParseDependentModules();
1364 if (num_modules > 0) {
1365 s->PutCString("Dependent Modules\n");
1366 for (unsigned i = 0; i < num_modules; ++i) {
1367 auto spec = m_deps_filespec->GetFileSpecAtIndex(i);
1368 s->Printf(" %s\n", spec.GetFilename().GetCString());
1369 }
1370 }
1371}
1372
1374 switch (m_coff_header_opt.subsystem) {
1375 case llvm::COFF::IMAGE_SUBSYSTEM_NATIVE:
1376 case llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_GUI:
1377 case llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_CUI:
1378 case llvm::COFF::IMAGE_SUBSYSTEM_NATIVE_WINDOWS:
1379 case llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
1380 case llvm::COFF::IMAGE_SUBSYSTEM_XBOX:
1381 case llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION:
1382 return true;
1383 default:
1384 return false;
1385 }
1386}
1387
1389 uint16_t machine = m_coff_header.machine;
1390 switch (machine) {
1391 default:
1392 break;
1393 case llvm::COFF::IMAGE_FILE_MACHINE_AMD64:
1394 case llvm::COFF::IMAGE_FILE_MACHINE_I386:
1395 case llvm::COFF::IMAGE_FILE_MACHINE_POWERPC:
1396 case llvm::COFF::IMAGE_FILE_MACHINE_POWERPCFP:
1397 case llvm::COFF::IMAGE_FILE_MACHINE_ARM:
1398 case llvm::COFF::IMAGE_FILE_MACHINE_ARMNT:
1399 case llvm::COFF::IMAGE_FILE_MACHINE_THUMB:
1400 case llvm::COFF::IMAGE_FILE_MACHINE_ARM64:
1401 ArchSpec arch;
1403 IsWindowsSubsystem() ? llvm::Triple::Win32
1404 : llvm::Triple::UnknownOS);
1405 return arch;
1406 }
1407 return ArchSpec();
1408}
1409
1411 if (m_coff_header.machine != 0) {
1412 if ((m_coff_header.flags & llvm::COFF::IMAGE_FILE_DLL) == 0)
1413 return eTypeExecutable;
1414 else
1415 return eTypeSharedLibrary;
1416 }
1417 return eTypeExecutable;
1418}
1419
static llvm::raw_ostream & error(Stream &strm)
static PluginProperties & GetGlobalPluginProperties()
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:342
#define LLDB_LOGF(log,...)
Definition: Log.h:349
#define LLDB_LOG_ERROR(log, error,...)
Definition: Log.h:365
static PluginProperties & GetGlobalPluginProperties()
#define OPT_HEADER_MAGIC_PE32
#define OPT_HEADER_MAGIC_PE32_PLUS
static bool RVASymbolListCompareRVA(const std::pair< uint32_t, uint32_t > &a, const std::pair< uint32_t, uint32_t > &b)
#define IMAGE_NT_SIGNATURE
static UUID GetCoffUUID(llvm::object::COFFObjectFile &coff_obj)
static bool GetDebugLinkContents(const llvm::object::COFFObjectFile &coff_obj, std::string &gnu_debuglink_file, uint32_t &gnu_debuglink_crc)
#define IMAGE_DOS_SIGNATURE
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
#define LLDB_SCOPED_TIMERF(...)
Definition: Timer.h:86
ObjectFile::Strata CalculateStrata() override
The object file should be able to calculate the strata of the object file.
static bool SaveCore(const lldb::ProcessSP &process_sp, const lldb_private::FileSpec &outfile, lldb::SaveCoreStyle &core_style, lldb_private::Status &error)
bool IsExecutable() const override
Tells whether this object file is capable of being the main executable for a process.
void DumpSectionHeaders(lldb_private::Stream *s)
std::unique_ptr< llvm::object::COFFObjectFile > m_binary
dos_header_t m_dos_header
lldb_private::DataExtractor ReadImageDataByRVA(uint32_t rva, size_t size)
llvm::StringRef GetSectionName(const section_header_t &sect)
lldb_private::Address GetEntryPointAddress() override
Returns the address of the Entry Point in this object file - if the object file doesn't have an entry...
std::optional< lldb_private::FileSpecList > m_deps_filespec
~ObjectFilePECOFF() override
static bool ParseDOSHeader(lldb_private::DataExtractor &data, dos_header_t &dos_header)
uint32_t GetDependentModules(lldb_private::FileSpecList &files) override
Extract the dependent modules from an object file.
lldb_private::Address GetBaseAddress() override
Returns base address of this object file.
lldb::addr_t m_image_base
void DumpSectionHeader(lldb_private::Stream *s, const section_header_t &sh)
std::unique_ptr< lldb_private::CallFrameInfo > CreateCallFrameInfo() override
Creates a plugin-specific call frame info.
static void DebuggerInitialize(lldb_private::Debugger &debugger)
ObjectFilePECOFF(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp, lldb::offset_t data_offset, const lldb_private::FileSpec *file, lldb::offset_t file_offset, lldb::offset_t length)
ObjectFile::Type CalculateType() override
The object file should be able to calculate its type by looking at its file header and possibly the s...
lldb_private::ArchSpec GetArchitecture() override
Get the ArchSpec for this object file.
static void DumpCOFFHeader(lldb_private::Stream *s, const coff_header_t &header)
bool ParseHeader() override
Attempts to parse the object header.
struct ObjectFilePECOFF::section_header section_header_t
void DumpDependentModules(lldb_private::Stream *s)
lldb_private::UUID m_uuid
lldb_private::UUID GetUUID() override
Gets the UUID for this object file.
std::vector< std::pair< uint32_t, uint32_t > > rva_symbol_list_t
static llvm::StringRef GetPluginNameStatic()
bool SetLoadAddress(lldb_private::Target &target, lldb::addr_t value, bool value_is_offset) override
Sets the load address for an entire module, assuming a rigid slide of sections, if possible in the im...
SectionHeaderColl::iterator SectionHeaderCollIter
SectionHeaderColl m_sect_headers
static lldb_private::ObjectFile * CreateMemoryInstance(const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp, const lldb::ProcessSP &process_sp, lldb::addr_t header_addr)
static llvm::StringRef GetPluginDescriptionStatic()
coff_opt_header_t m_coff_header_opt
bool ParseCOFFOptionalHeader(lldb::offset_t *offset_ptr)
bool IsStripped() override
Detect if this object file has been stripped of local symbols.
uint32_t ParseDependentModules()
bool NeedsEndianSwap() const
lldb::addr_t GetFileAddress(uint32_t rva) const
void ParseSymtab(lldb_private::Symtab &symtab) override
Parse the symbol table into the provides symbol table object.
void CreateSections(lldb_private::SectionList &unified_section_list) override
void Dump(lldb_private::Stream *s) override
Dump a description of this object to a Stream.
rva_symbol_list_t AppendFromExportTable(lldb_private::SectionList *sect_list, lldb_private::Symtab &symtab)
coff_header_t m_coff_header
lldb_private::Address GetAddress(uint32_t rva)
static void Initialize()
lldb::ByteOrder GetByteOrder() const override
Gets whether endian swapping should occur when extracting data from this object file.
lldb_private::DataExtractor ReadImageData(uint32_t offset, size_t size)
void AppendFromCOFFSymbolTable(lldb_private::SectionList *sect_list, lldb_private::Symtab &symtab, const rva_symbol_list_t &sorted_exports)
std::optional< lldb_private::FileSpec > GetDebugLink()
Return the contents of the .gnu_debuglink section, if the object file contains it.
bool ParseSectionHeaders(uint32_t offset)
static lldb::SymbolType MapSymbolType(uint16_t coff_symbol_type)
uint32_t GetRVA(const lldb_private::Address &addr) const
uint32_t GetAddressByteSize() const override
Gets the address size in bytes for the current object file.
static void DumpOptCOFFHeader(lldb_private::Stream *s, const coff_opt_header_t &header)
static lldb::SectionType GetSectionType(llvm::StringRef sect_name, const section_header_t &sect)
static ObjectFile * CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp, lldb::offset_t data_offset, const lldb_private::FileSpec *file, lldb::offset_t offset, lldb::offset_t length)
static bool ParseCOFFHeader(lldb_private::DataExtractor &data, lldb::offset_t *offset_ptr, coff_header_t &coff_header)
static bool MagicBytesMatch(lldb::DataBufferSP data_sp)
static void Terminate()
lldb_private::Address m_entry_point_address
static void DumpDOSHeader(lldb_private::Stream *s, const dos_header_t &header)
static size_t GetModuleSpecifications(const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp, lldb::offset_t data_offset, lldb::offset_t file_offset, lldb::offset_t length, lldb_private::ModuleSpecList &specs)
A section + offset based address class.
Definition: Address.h:59
bool ResolveAddressUsingFileSections(lldb::addr_t addr, const SectionList *sections)
Resolve a file virtual address using a section list.
Definition: Address.cpp:248
lldb::SectionSP GetSection() const
Get const accessor for the section.
Definition: Address.h:429
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:291
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition: Address.h:319
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:345
bool SetOffset(lldb::addr_t offset)
Set accessor for the offset.
Definition: Address.h:438
An architecture specification class.
Definition: ArchSpec.h:31
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:450
bool SetTriple(const llvm::Triple &triple)
Architecture triple setter.
Definition: ArchSpec.cpp:747
bool SetArchitecture(ArchitectureType arch_type, uint32_t cpu, uint32_t sub, uint32_t os=0)
Change the architecture object type, CPU type and OS type.
Definition: ArchSpec.cpp:851
const char * GetArchitectureName() const
Returns a static string representing the current architecture.
Definition: ArchSpec.cpp:552
A uniqued constant string class.
Definition: ConstString.h:40
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:198
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:207
An data extractor class.
Definition: DataExtractor.h:48
const char * GetCStr(lldb::offset_t *offset_ptr) const
Extract a C string from *offset_ptr.
bool ValidOffsetForDataOfSize(lldb::offset_t offset, lldb::offset_t length) const
Test the availability of length bytes of data from offset.
const void * GetData(lldb::offset_t *offset_ptr, lldb::offset_t length) const
Extract length bytes from *offset_ptr.
void SetByteOrder(lldb::ByteOrder byte_order)
Set the byte_order value.
uint32_t GetU32(lldb::offset_t *offset_ptr) const
Extract a uint32_t value from *offset_ptr.
uint16_t GetU16(lldb::offset_t *offset_ptr) const
Extract a uint16_t value from *offset_ptr.
lldb::offset_t SetData(const void *bytes, lldb::offset_t length, lldb::ByteOrder byte_order)
Set data with a buffer that is caller owned.
uint64_t GetMaxU64(lldb::offset_t *offset_ptr, size_t byte_size) const
Extract an unsigned integer of size byte_size from *offset_ptr.
void SetAddressByteSize(uint32_t addr_size)
Set the address byte size.
uint8_t GetU8(lldb::offset_t *offset_ptr) const
Extract a uint8_t value from *offset_ptr.
A class to manage flag bits.
Definition: Debugger.h:78
A file collection class.
Definition: FileSpecList.h:24
size_t GetSize() const
Get the number of files in the file list.
bool AppendIfUnique(const FileSpec &file)
Append a FileSpec object if unique.
A file utility class.
Definition: FileSpec.h:56
void SetDirectory(ConstString directory)
Directory string set accessor.
Definition: FileSpec.cpp:334
const ConstString & GetFilename() const
Filename string const get accessor.
Definition: FileSpec.h:240
const ConstString & GetDirectory() const
Directory string const get accessor.
Definition: FileSpec.h:223
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:366
void Format(llvm::StringRef file, llvm::StringRef function, const char *format, Args &&... args)
Definition: Log.h:221
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
Definition: ModuleChild.cpp:24
void Append(const ModuleSpec &spec)
Definition: ModuleSpec.h:308
ArchSpec & GetArchitecture()
Definition: ModuleSpec.h:89
A plug-in interface definition class for object file parsers.
Definition: ObjectFile.h:43
DataExtractor m_data
The data for this object file so things can be parsed lazily.
Definition: ObjectFile.h:725
std::unique_ptr< lldb_private::SectionList > m_sections_up
Definition: ObjectFile.h:729
static lldb::DataBufferSP MapFileData(const FileSpec &file, uint64_t Size, uint64_t Offset)
Definition: ObjectFile.cpp:659
std::unique_ptr< lldb_private::Symtab > m_symtab_up
Definition: ObjectFile.h:730
@ eTypeExecutable
A normal executable.
Definition: ObjectFile.h:52
@ eTypeSharedLibrary
A shared library that can be used during execution.
Definition: ObjectFile.h:60
virtual SectionList * GetSectionList(bool update_module_section_list=true)
Gets the section list for the currently selected architecture (and object for archives).
Definition: ObjectFile.cpp:588
lldb::ProcessWP m_process_wp
Definition: ObjectFile.h:726
static lldb::OptionValuePropertiesSP GetSettingForObjectFilePlugin(Debugger &debugger, ConstString setting_name)
static bool CreateSettingForObjectFilePlugin(Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, llvm::StringRef description, bool is_global_property)
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
static bool UnregisterPlugin(ABICreateInstance create_callback)
lldb::SectionSP FindSectionByID(lldb::user_id_t sect_id) const
Definition: Section.cpp:568
size_t GetSize() const
Definition: Section.h:75
size_t AddSection(const lldb::SectionSP &section_sp)
Definition: Section.cpp:469
void Dump(llvm::raw_ostream &s, unsigned indent, Target *target, bool show_header, uint32_t depth) const
Definition: Section.cpp:632
lldb::SectionSP GetSectionAtIndex(size_t idx) const
Definition: Section.cpp:538
bool SetSectionLoadAddress(const lldb::SectionSP &section_sp, lldb::addr_t load_addr, bool warn_multiple=false)
An error handling class.
Definition: Status.h:44
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition: Stream.h:357
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
Definition: Stream.cpp:130
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:128
unsigned GetIndentLevel() const
Get the current indentation level.
Definition: Stream.cpp:160
void SetType(lldb::SymbolType type)
Definition: Symbol.h:169
Mangled & GetMangled()
Definition: Symbol.h:145
Address & GetAddressRef()
Definition: Symbol.h:71
lldb::SymbolType GetType() const
Definition: Symbol.h:167
void SetDemangledNameIsSynthesized(bool b)
Definition: Symbol.h:227
ConstString GetDisplayName() const
Definition: Symbol.cpp:171
void SetExternal(bool b)
Definition: Symbol.h:196
void SetID(uint32_t uid)
Definition: Symbol.h:143
Symbol * SymbolAtIndex(size_t idx)
Definition: Symtab.cpp:217
uint32_t AddSymbol(const Symbol &symbol)
Definition: Symtab.cpp:64
size_t GetNumSymbols() const
Definition: Symtab.cpp:77
void Reserve(size_t count)
Definition: Symtab.cpp:51
SectionLoadList & GetSectionLoadList()
Definition: Target.h:1120
bool IsValid() const
Definition: UUID.h:69
#define LLDB_INVALID_CPUTYPE
Definition: lldb-defines.h:95
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:74
#define UINT32_MAX
Definition: lldb-defines.h:19
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:314
bool SaveMiniDump(const lldb::ProcessSP &process_sp, const lldb_private::FileSpec &outfile, lldb_private::Status &error)
Definition: SBAddress.h:15
uint64_t offset_t
Definition: lldb-types.h:83
SymbolType
Symbol types.
@ eSymbolTypeInvalid
@ eSymbolTypeAbsolute
@ eSymbolTypeAdditional
When symbols take more than one entry, the extra entries get this type.
ByteOrder
Byte ordering definitions.
@ eByteOrderLittle
uint64_t user_id_t
Definition: lldb-types.h:80
uint64_t addr_t
Definition: lldb-types.h:79
@ eSectionTypeData
@ eSectionTypeInvalid
@ eSectionTypeDWARFDebugPubNames
@ eSectionTypeZeroFill
@ eSectionTypeDWARFDebugFrame
@ eSectionTypeDWARFDebugLocLists
DWARF v5 .debug_loclists.
@ eSectionTypeDWARFDebugTypes
DWARF .debug_types section.
@ eSectionTypeDWARFDebugMacInfo
@ eSectionTypeOther
@ eSectionTypeDWARFDebugNames
DWARF v5 .debug_names.
@ eSectionTypeEHFrame
@ eSectionTypeDWARFDebugInfo
@ eSectionTypeDWARFDebugRanges
@ eSectionTypeGoSymtab
@ eSectionTypeDWARFDebugLine
@ eSectionTypeDWARFDebugPubTypes
@ eSectionTypeDWARFDebugStr
@ eSectionTypeDWARFDebugLoc
@ eSectionTypeCode
@ eSectionTypeDebug
@ eSectionTypeDWARFDebugAranges
@ eSectionTypeDWARFDebugAbbrev
@ eSectionTypeDataCString
Inlined C string data.
std::vector< data_directory > data_dirs
struct lldb_private::UUID::CvRecordPdb70::@43 Uuid
llvm::support::ulittle32_t Age
Definition: UUID.h:46