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/FileSpecList.h"
14 #include "lldb/Core/Module.h"
15 #include "lldb/Core/ModuleSpec.h"
17 #include "lldb/Core/Section.h"
18 #include "lldb/Core/StreamFile.h"
19 #include "lldb/Symbol/ObjectFile.h"
20 #include "lldb/Target/Process.h"
22 #include "lldb/Target/Target.h"
23 #include "lldb/Utility/ArchSpec.h"
25 #include "lldb/Utility/FileSpec.h"
26 #include "lldb/Utility/Log.h"
28 #include "lldb/Utility/Timer.h"
29 #include "lldb/Utility/UUID.h"
30 #include "llvm/BinaryFormat/COFF.h"
31 
32 #include "llvm/Object/COFFImportFile.h"
33 #include "llvm/Support/Error.h"
34 #include "llvm/Support/MemoryBuffer.h"
35 
36 #define IMAGE_DOS_SIGNATURE 0x5A4D // MZ
37 #define IMAGE_NT_SIGNATURE 0x00004550 // PE00
38 #define OPT_HEADER_MAGIC_PE32 0x010b
39 #define OPT_HEADER_MAGIC_PE32_PLUS 0x020b
40 
41 using namespace lldb;
42 using namespace lldb_private;
43 
45 
46 static UUID GetCoffUUID(llvm::object::COFFObjectFile &coff_obj) {
47  const llvm::codeview::DebugInfo *pdb_info = nullptr;
48  llvm::StringRef pdb_file;
49 
50  if (!coff_obj.getDebugPDBInfo(pdb_info, pdb_file) && pdb_info) {
51  if (pdb_info->PDB70.CVSignature == llvm::OMF::Signature::PDB70) {
53  memcpy(&info.Uuid, pdb_info->PDB70.Signature, sizeof(info.Uuid));
54  info.Age = pdb_info->PDB70.Age;
55  return UUID::fromCvRecord(info);
56  }
57  }
58 
59  return UUID();
60 }
61 
63 
65  PluginManager::RegisterPlugin(
66  GetPluginNameStatic(), GetPluginDescriptionStatic(), CreateInstance,
67  CreateMemoryInstance, GetModuleSpecifications, SaveCore);
68 }
69 
71  PluginManager::UnregisterPlugin(CreateInstance);
72 }
73 
75  static ConstString g_name("pe-coff");
76  return g_name;
77 }
78 
80  return "Portable Executable and Common Object File Format object file reader "
81  "(32 and 64 bit)";
82 }
83 
84 ObjectFile *ObjectFilePECOFF::CreateInstance(const lldb::ModuleSP &module_sp,
85  DataBufferSP &data_sp,
86  lldb::offset_t data_offset,
87  const lldb_private::FileSpec *file_p,
88  lldb::offset_t file_offset,
89  lldb::offset_t length) {
90  FileSpec file = file_p ? *file_p : FileSpec();
91  if (!data_sp) {
92  data_sp = MapFileData(file, length, file_offset);
93  if (!data_sp)
94  return nullptr;
95  data_offset = 0;
96  }
97 
99  return nullptr;
100 
101  // Update the data to contain the entire file if it doesn't already
102  if (data_sp->GetByteSize() < length) {
103  data_sp = MapFileData(file, length, file_offset);
104  if (!data_sp)
105  return nullptr;
106  }
107 
108  auto objfile_up = std::make_unique<ObjectFilePECOFF>(
109  module_sp, data_sp, data_offset, file_p, file_offset, length);
110  if (!objfile_up || !objfile_up->ParseHeader())
111  return nullptr;
112 
113  // Cache coff binary.
114  if (!objfile_up->CreateBinary())
115  return nullptr;
116  return objfile_up.release();
117 }
118 
120  const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
121  const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) {
122  if (!data_sp || !ObjectFilePECOFF::MagicBytesMatch(data_sp))
123  return nullptr;
124  auto objfile_up = std::make_unique<ObjectFilePECOFF>(
125  module_sp, data_sp, process_sp, header_addr);
126  if (objfile_up.get() && objfile_up->ParseHeader()) {
127  return objfile_up.release();
128  }
129  return nullptr;
130 }
131 
133  const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
134  lldb::offset_t data_offset, lldb::offset_t file_offset,
136  const size_t initial_count = specs.GetSize();
137  if (!data_sp || !ObjectFilePECOFF::MagicBytesMatch(data_sp))
138  return initial_count;
139 
141 
142  if (data_sp->GetByteSize() < length)
143  if (DataBufferSP full_sp = MapFileData(file, -1, file_offset))
144  data_sp = std::move(full_sp);
145  auto binary = llvm::object::createBinary(llvm::MemoryBufferRef(
146  toStringRef(data_sp->GetData()), file.GetFilename().GetStringRef()));
147 
148  if (!binary) {
149  LLDB_LOG_ERROR(log, binary.takeError(),
150  "Failed to create binary for file ({1}): {0}", file);
151  return initial_count;
152  }
153 
154  auto *COFFObj = llvm::dyn_cast<llvm::object::COFFObjectFile>(binary->get());
155  if (!COFFObj)
156  return initial_count;
157 
158  ModuleSpec module_spec(file);
159  ArchSpec &spec = module_spec.GetArchitecture();
160  lldb_private::UUID &uuid = module_spec.GetUUID();
161  if (!uuid.IsValid())
162  uuid = GetCoffUUID(*COFFObj);
163 
164  switch (COFFObj->getMachine()) {
165  case MachineAmd64:
166  spec.SetTriple("x86_64-pc-windows");
167  specs.Append(module_spec);
168  break;
169  case MachineX86:
170  spec.SetTriple("i386-pc-windows");
171  specs.Append(module_spec);
172  spec.SetTriple("i686-pc-windows");
173  specs.Append(module_spec);
174  break;
175  case MachineArmNt:
176  spec.SetTriple("armv7-pc-windows");
177  specs.Append(module_spec);
178  break;
179  case MachineArm64:
180  spec.SetTriple("aarch64-pc-windows");
181  specs.Append(module_spec);
182  break;
183  default:
184  break;
185  }
186 
187  return specs.GetSize() - initial_count;
188 }
189 
190 bool ObjectFilePECOFF::SaveCore(const lldb::ProcessSP &process_sp,
191  const lldb_private::FileSpec &outfile,
192  lldb::SaveCoreStyle &core_style,
194  core_style = eSaveCoreFull;
195  return SaveMiniDump(process_sp, outfile, error);
196 }
197 
198 bool ObjectFilePECOFF::MagicBytesMatch(DataBufferSP &data_sp) {
199  DataExtractor data(data_sp, eByteOrderLittle, 4);
200  lldb::offset_t offset = 0;
201  uint16_t magic = data.GetU16(&offset);
202  return magic == IMAGE_DOS_SIGNATURE;
203 }
204 
206  // TODO: We need to complete this mapping of COFF symbol types to LLDB ones.
207  // For now, here's a hack to make sure our function have types.
208  const auto complex_type =
209  coff_symbol_type >> llvm::COFF::SCT_COMPLEX_TYPE_SHIFT;
210  if (complex_type == llvm::COFF::IMAGE_SYM_DTYPE_FUNCTION) {
211  return lldb::eSymbolTypeCode;
212  }
214 }
215 
217  if (m_binary)
218  return true;
219 
221 
222  auto binary = llvm::object::createBinary(llvm::MemoryBufferRef(
223  toStringRef(m_data.GetData()), m_file.GetFilename().GetStringRef()));
224  if (!binary) {
225  LLDB_LOG_ERROR(log, binary.takeError(),
226  "Failed to create binary for file ({1}): {0}", m_file);
227  return false;
228  }
229 
230  // Make sure we only handle COFF format.
231  m_binary =
232  llvm::unique_dyn_cast<llvm::object::COFFObjectFile>(std::move(*binary));
233  if (!m_binary)
234  return false;
235 
236  LLDB_LOG(log, "this = {0}, module = {1} ({2}), file = {3}, binary = {4}",
237  this, GetModule().get(), GetModule()->GetSpecificationDescription(),
238  m_file.GetPath(), m_binary.get());
239  return true;
240 }
241 
242 ObjectFilePECOFF::ObjectFilePECOFF(const lldb::ModuleSP &module_sp,
243  DataBufferSP &data_sp,
244  lldb::offset_t data_offset,
245  const FileSpec *file,
246  lldb::offset_t file_offset,
247  lldb::offset_t length)
248  : ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset),
249  m_dos_header(), m_coff_header(), m_sect_headers(),
250  m_entry_point_address(), m_deps_filespec() {
251  ::memset(&m_dos_header, 0, sizeof(m_dos_header));
252  ::memset(&m_coff_header, 0, sizeof(m_coff_header));
253 }
254 
255 ObjectFilePECOFF::ObjectFilePECOFF(const lldb::ModuleSP &module_sp,
256  DataBufferSP &header_data_sp,
257  const lldb::ProcessSP &process_sp,
258  addr_t header_addr)
259  : ObjectFile(module_sp, process_sp, header_addr, header_data_sp),
260  m_dos_header(), m_coff_header(), m_sect_headers(),
261  m_entry_point_address(), m_deps_filespec() {
262  ::memset(&m_dos_header, 0, sizeof(m_dos_header));
263  ::memset(&m_coff_header, 0, sizeof(m_coff_header));
264 }
265 
267 
269  ModuleSP module_sp(GetModule());
270  if (module_sp) {
271  std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
272  m_sect_headers.clear();
274  lldb::offset_t offset = 0;
275 
277  offset = m_dos_header.e_lfanew;
278  uint32_t pe_signature = m_data.GetU32(&offset);
279  if (pe_signature != IMAGE_NT_SIGNATURE)
280  return false;
281  if (ParseCOFFHeader(m_data, &offset, m_coff_header)) {
282  if (m_coff_header.hdrsize > 0)
283  ParseCOFFOptionalHeader(&offset);
284  ParseSectionHeaders(offset);
285  }
287  return true;
288  }
289  }
290  return false;
291 }
292 
294  bool value_is_offset) {
295  bool changed = false;
296  ModuleSP module_sp = GetModule();
297  if (module_sp) {
298  size_t num_loaded_sections = 0;
299  SectionList *section_list = GetSectionList();
300  if (section_list) {
301  if (!value_is_offset) {
302  value -= m_image_base;
303  }
304 
305  const size_t num_sections = section_list->GetSize();
306  size_t sect_idx = 0;
307 
308  for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
309  // Iterate through the object file sections to find all of the sections
310  // that have SHF_ALLOC in their flag bits.
311  SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
312  if (section_sp && !section_sp->IsThreadSpecific()) {
314  section_sp, section_sp->GetFileAddress() + value))
315  ++num_loaded_sections;
316  }
317  }
318  changed = num_loaded_sections > 0;
319  }
320  }
321  return changed;
322 }
323 
325 
327  return (m_coff_header.flags & llvm::COFF::IMAGE_FILE_DLL) == 0;
328 }
329 
332  return 8;
334  return 4;
335  return 4;
336 }
337 
338 // NeedsEndianSwap
339 //
340 // Return true if an endian swap needs to occur when extracting data from this
341 // file.
343 #if defined(__LITTLE_ENDIAN__)
344  return false;
345 #else
346  return true;
347 #endif
348 }
349 // ParseDOSHeader
352  bool success = false;
353  lldb::offset_t offset = 0;
354  success = data.ValidOffsetForDataOfSize(0, sizeof(dos_header));
355 
356  if (success) {
357  dos_header.e_magic = data.GetU16(&offset); // Magic number
359 
360  if (success) {
361  dos_header.e_cblp = data.GetU16(&offset); // Bytes on last page of file
362  dos_header.e_cp = data.GetU16(&offset); // Pages in file
363  dos_header.e_crlc = data.GetU16(&offset); // Relocations
365  data.GetU16(&offset); // Size of header in paragraphs
367  data.GetU16(&offset); // Minimum extra paragraphs needed
369  data.GetU16(&offset); // Maximum extra paragraphs needed
370  dos_header.e_ss = data.GetU16(&offset); // Initial (relative) SS value
371  dos_header.e_sp = data.GetU16(&offset); // Initial SP value
372  dos_header.e_csum = data.GetU16(&offset); // Checksum
373  dos_header.e_ip = data.GetU16(&offset); // Initial IP value
374  dos_header.e_cs = data.GetU16(&offset); // Initial (relative) CS value
376  data.GetU16(&offset); // File address of relocation table
377  dos_header.e_ovno = data.GetU16(&offset); // Overlay number
378 
379  dos_header.e_res[0] = data.GetU16(&offset); // Reserved words
380  dos_header.e_res[1] = data.GetU16(&offset); // Reserved words
381  dos_header.e_res[2] = data.GetU16(&offset); // Reserved words
382  dos_header.e_res[3] = data.GetU16(&offset); // Reserved words
383 
385  data.GetU16(&offset); // OEM identifier (for e_oeminfo)
387  data.GetU16(&offset); // OEM information; e_oemid specific
388  dos_header.e_res2[0] = data.GetU16(&offset); // Reserved words
389  dos_header.e_res2[1] = data.GetU16(&offset); // Reserved words
390  dos_header.e_res2[2] = data.GetU16(&offset); // Reserved words
391  dos_header.e_res2[3] = data.GetU16(&offset); // Reserved words
392  dos_header.e_res2[4] = data.GetU16(&offset); // Reserved words
393  dos_header.e_res2[5] = data.GetU16(&offset); // Reserved words
394  dos_header.e_res2[6] = data.GetU16(&offset); // Reserved words
395  dos_header.e_res2[7] = data.GetU16(&offset); // Reserved words
396  dos_header.e_res2[8] = data.GetU16(&offset); // Reserved words
397  dos_header.e_res2[9] = data.GetU16(&offset); // Reserved words
398 
400  data.GetU32(&offset); // File address of new exe header
401  }
402  }
403  if (!success)
404  memset(&dos_header, 0, sizeof(dos_header));
405  return success;
406 }
407 
408 // ParserCOFFHeader
410  lldb::offset_t *offset_ptr,
412  bool success =
413  data.ValidOffsetForDataOfSize(*offset_ptr, sizeof(coff_header));
414  if (success) {
415  coff_header.machine = data.GetU16(offset_ptr);
416  coff_header.nsects = data.GetU16(offset_ptr);
417  coff_header.modtime = data.GetU32(offset_ptr);
418  coff_header.symoff = data.GetU32(offset_ptr);
419  coff_header.nsyms = data.GetU32(offset_ptr);
420  coff_header.hdrsize = data.GetU16(offset_ptr);
421  coff_header.flags = data.GetU16(offset_ptr);
422  }
423  if (!success)
424  memset(&coff_header, 0, sizeof(coff_header));
425  return success;
426 }
427 
429  bool success = false;
430  const lldb::offset_t end_offset = *offset_ptr + m_coff_header.hdrsize;
431  if (*offset_ptr < end_offset) {
432  success = true;
433  m_coff_header_opt.magic = m_data.GetU16(offset_ptr);
438  m_coff_header_opt.bss_size = m_data.GetU32(offset_ptr);
439  m_coff_header_opt.entry = m_data.GetU32(offset_ptr);
441 
442  const uint32_t addr_byte_size = GetAddressByteSize();
443 
444  if (*offset_ptr < end_offset) {
446  // PE32 only
448  } else
450 
451  if (*offset_ptr < end_offset) {
453  m_data.GetMaxU64(offset_ptr, addr_byte_size);
465  m_coff_header_opt.checksum = m_data.GetU32(offset_ptr);
469  m_data.GetMaxU64(offset_ptr, addr_byte_size);
471  m_data.GetMaxU64(offset_ptr, addr_byte_size);
473  m_data.GetMaxU64(offset_ptr, addr_byte_size);
475  m_data.GetMaxU64(offset_ptr, addr_byte_size);
477  uint32_t num_data_dir_entries = m_data.GetU32(offset_ptr);
479  m_coff_header_opt.data_dirs.resize(num_data_dir_entries);
480  uint32_t i;
481  for (i = 0; i < num_data_dir_entries; i++) {
482  m_coff_header_opt.data_dirs[i].vmaddr = m_data.GetU32(offset_ptr);
483  m_coff_header_opt.data_dirs[i].vmsize = m_data.GetU32(offset_ptr);
484  }
485 
487  }
488  }
489  }
490  // Make sure we are on track for section data which follows
491  *offset_ptr = end_offset;
492  return success;
493 }
494 
496  return addr.GetFileAddress() - m_image_base;
497 }
498 
500  SectionList *sect_list = GetSectionList();
501  if (!sect_list)
502  return Address(GetFileAddress(rva));
503 
504  return Address(GetFileAddress(rva), sect_list);
505 }
506 
508  return m_image_base + rva;
509 }
510 
512  if (!size)
513  return {};
514 
515  if (m_data.ValidOffsetForDataOfSize(offset, size))
516  return DataExtractor(m_data, offset, size);
517 
518  ProcessSP process_sp(m_process_wp.lock());
519  DataExtractor data;
520  if (process_sp) {
521  auto data_up = std::make_unique<DataBufferHeap>(size, 0);
522  Status readmem_error;
523  size_t bytes_read =
524  process_sp->ReadMemory(m_image_base + offset, data_up->GetBytes(),
525  data_up->GetByteSize(), readmem_error);
526  if (bytes_read == size) {
527  DataBufferSP buffer_sp(data_up.release());
528  data.SetData(buffer_sp, 0, buffer_sp->GetByteSize());
529  }
530  }
531  return data;
532 }
533 
535  Address addr = GetAddress(rva);
536  SectionSP sect = addr.GetSection();
537  if (!sect)
538  return {};
539  rva = sect->GetFileOffset() + addr.GetOffset();
540 
541  return ReadImageData(rva, size);
542 }
543 
544 // ParseSectionHeaders
546  uint32_t section_header_data_offset) {
547  const uint32_t nsects = m_coff_header.nsects;
548  m_sect_headers.clear();
549 
550  if (nsects > 0) {
551  const size_t section_header_byte_size = nsects * sizeof(section_header_t);
552  DataExtractor section_header_data =
553  ReadImageData(section_header_data_offset, section_header_byte_size);
554 
555  lldb::offset_t offset = 0;
556  if (section_header_data.ValidOffsetForDataOfSize(
557  offset, section_header_byte_size)) {
558  m_sect_headers.resize(nsects);
559 
560  for (uint32_t idx = 0; idx < nsects; ++idx) {
561  const void *name_data = section_header_data.GetData(&offset, 8);
562  if (name_data) {
563  memcpy(m_sect_headers[idx].name, name_data, 8);
564  m_sect_headers[idx].vmsize = section_header_data.GetU32(&offset);
565  m_sect_headers[idx].vmaddr = section_header_data.GetU32(&offset);
566  m_sect_headers[idx].size = section_header_data.GetU32(&offset);
567  m_sect_headers[idx].offset = section_header_data.GetU32(&offset);
568  m_sect_headers[idx].reloff = section_header_data.GetU32(&offset);
569  m_sect_headers[idx].lineoff = section_header_data.GetU32(&offset);
570  m_sect_headers[idx].nreloc = section_header_data.GetU16(&offset);
571  m_sect_headers[idx].nline = section_header_data.GetU16(&offset);
572  m_sect_headers[idx].flags = section_header_data.GetU32(&offset);
573  }
574  }
575  }
576  }
577 
578  return !m_sect_headers.empty();
579 }
580 
582  llvm::StringRef hdr_name(sect.name, llvm::array_lengthof(sect.name));
583  hdr_name = hdr_name.split('\0').first;
584  if (hdr_name.consume_front("/")) {
585  lldb::offset_t stroff;
586  if (!to_integer(hdr_name, stroff, 10))
587  return "";
588  lldb::offset_t string_file_offset =
589  m_coff_header.symoff + (m_coff_header.nsyms * 18) + stroff;
590  if (const char *name = m_data.GetCStr(&string_file_offset))
591  return name;
592  return "";
593  }
594  return hdr_name;
595 }
596 
597 // GetNListSymtab
599  ModuleSP module_sp(GetModule());
600  if (module_sp) {
601  std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
602  if (m_symtab_up == nullptr) {
603  SectionList *sect_list = GetSectionList();
604  m_symtab_up = std::make_unique<Symtab>(this);
605  std::lock_guard<std::recursive_mutex> guard(m_symtab_up->GetMutex());
606 
607  const uint32_t num_syms = m_coff_header.nsyms;
608 
609  if (m_file && num_syms > 0 && m_coff_header.symoff > 0) {
610  const uint32_t symbol_size = 18;
611  const size_t symbol_data_size = num_syms * symbol_size;
612  // Include the 4-byte string table size at the end of the symbols
613  DataExtractor symtab_data =
614  ReadImageData(m_coff_header.symoff, symbol_data_size + 4);
615  lldb::offset_t offset = symbol_data_size;
616  const uint32_t strtab_size = symtab_data.GetU32(&offset);
617  if (strtab_size > 0) {
618  DataExtractor strtab_data = ReadImageData(
619  m_coff_header.symoff + symbol_data_size, strtab_size);
620 
621  offset = 0;
622  std::string symbol_name;
623  Symbol *symbols = m_symtab_up->Resize(num_syms);
624  for (uint32_t i = 0; i < num_syms; ++i) {
625  coff_symbol_t symbol;
626  const uint32_t symbol_offset = offset;
627  const char *symbol_name_cstr = nullptr;
628  // If the first 4 bytes of the symbol string are zero, then they
629  // are followed by a 4-byte string table offset. Else these
630  // 8 bytes contain the symbol name
631  if (symtab_data.GetU32(&offset) == 0) {
632  // Long string that doesn't fit into the symbol table name, so
633  // now we must read the 4 byte string table offset
634  uint32_t strtab_offset = symtab_data.GetU32(&offset);
635  symbol_name_cstr = strtab_data.PeekCStr(strtab_offset);
636  symbol_name.assign(symbol_name_cstr);
637  } else {
638  // Short string that fits into the symbol table name which is 8
639  // bytes
640  offset += sizeof(symbol.name) - 4; // Skip remaining
641  symbol_name_cstr = symtab_data.PeekCStr(symbol_offset);
642  if (symbol_name_cstr == nullptr)
643  break;
644  symbol_name.assign(symbol_name_cstr, sizeof(symbol.name));
645  }
646  symbol.value = symtab_data.GetU32(&offset);
647  symbol.sect = symtab_data.GetU16(&offset);
648  symbol.type = symtab_data.GetU16(&offset);
649  symbol.storage = symtab_data.GetU8(&offset);
650  symbol.naux = symtab_data.GetU8(&offset);
651  symbols[i].GetMangled().SetValue(ConstString(symbol_name.c_str()));
652  if ((int16_t)symbol.sect >= 1) {
653  Address symbol_addr(sect_list->FindSectionByID(symbol.sect),
654  symbol.value);
655  symbols[i].GetAddressRef() = symbol_addr;
656  symbols[i].SetType(MapSymbolType(symbol.type));
657  }
658 
659  if (symbol.naux > 0) {
660  i += symbol.naux;
661  offset += symbol.naux * symbol_size;
662  }
663  }
664  }
665  }
666 
667  // Read export header
671  export_directory_entry export_table;
672  uint32_t data_start =
674 
675  DataExtractor symtab_data = ReadImageDataByRVA(
676  data_start, m_coff_header_opt.data_dirs[0].vmsize);
677  lldb::offset_t offset = 0;
678 
679  // Read export_table header
680  export_table.characteristics = symtab_data.GetU32(&offset);
681  export_table.time_date_stamp = symtab_data.GetU32(&offset);
682  export_table.major_version = symtab_data.GetU16(&offset);
683  export_table.minor_version = symtab_data.GetU16(&offset);
684  export_table.name = symtab_data.GetU32(&offset);
685  export_table.base = symtab_data.GetU32(&offset);
686  export_table.number_of_functions = symtab_data.GetU32(&offset);
687  export_table.number_of_names = symtab_data.GetU32(&offset);
688  export_table.address_of_functions = symtab_data.GetU32(&offset);
689  export_table.address_of_names = symtab_data.GetU32(&offset);
690  export_table.address_of_name_ordinals = symtab_data.GetU32(&offset);
691 
692  bool has_ordinal = export_table.address_of_name_ordinals != 0;
693 
694  lldb::offset_t name_offset = export_table.address_of_names - data_start;
695  lldb::offset_t name_ordinal_offset =
696  export_table.address_of_name_ordinals - data_start;
697 
698  Symbol *symbols = m_symtab_up->Resize(export_table.number_of_names);
699 
700  std::string symbol_name;
701 
702  // Read each export table entry
703  for (size_t i = 0; i < export_table.number_of_names; ++i) {
704  uint32_t name_ordinal =
705  has_ordinal ? symtab_data.GetU16(&name_ordinal_offset) : i;
706  uint32_t name_address = symtab_data.GetU32(&name_offset);
707 
708  const char *symbol_name_cstr =
709  symtab_data.PeekCStr(name_address - data_start);
710  symbol_name.assign(symbol_name_cstr);
711 
712  lldb::offset_t function_offset = export_table.address_of_functions -
713  data_start +
714  sizeof(uint32_t) * name_ordinal;
715  uint32_t function_rva = symtab_data.GetU32(&function_offset);
716 
717  Address symbol_addr(m_coff_header_opt.image_base + function_rva,
718  sect_list);
719  symbols[i].GetMangled().SetValue(ConstString(symbol_name.c_str()));
720  symbols[i].GetAddressRef() = symbol_addr;
721  symbols[i].SetType(lldb::eSymbolTypeCode);
722  symbols[i].SetDebug(true);
723  }
724  }
725  m_symtab_up->CalculateSymbolSizes();
726  }
727  }
728  return m_symtab_up.get();
729 }
730 
731 std::unique_ptr<CallFrameInfo> ObjectFilePECOFF::CreateCallFrameInfo() {
733  return {};
734 
735  data_directory data_dir_exception =
737  if (!data_dir_exception.vmaddr)
738  return {};
739 
740  if (m_coff_header.machine != llvm::COFF::IMAGE_FILE_MACHINE_AMD64)
741  return {};
742 
743  return std::make_unique<PECallFrameInfo>(*this, data_dir_exception.vmaddr,
744  data_dir_exception.vmsize);
745 }
746 
748  // TODO: determine this for COFF
749  return false;
750 }
751 
753  const section_header_t &sect) {
754  ConstString const_sect_name(sect_name);
755  static ConstString g_code_sect_name(".code");
756  static ConstString g_CODE_sect_name("CODE");
757  static ConstString g_data_sect_name(".data");
758  static ConstString g_DATA_sect_name("DATA");
759  static ConstString g_bss_sect_name(".bss");
760  static ConstString g_BSS_sect_name("BSS");
761 
762  if (sect.flags & llvm::COFF::IMAGE_SCN_CNT_CODE &&
763  ((const_sect_name == g_code_sect_name) ||
764  (const_sect_name == g_CODE_sect_name))) {
765  return eSectionTypeCode;
766  }
767  if (sect.flags & llvm::COFF::IMAGE_SCN_CNT_INITIALIZED_DATA &&
768  ((const_sect_name == g_data_sect_name) ||
769  (const_sect_name == g_DATA_sect_name))) {
770  if (sect.size == 0 && sect.offset == 0)
771  return eSectionTypeZeroFill;
772  else
773  return eSectionTypeData;
774  }
775  if (sect.flags & llvm::COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA &&
776  ((const_sect_name == g_bss_sect_name) ||
777  (const_sect_name == g_BSS_sect_name))) {
778  if (sect.size == 0)
779  return eSectionTypeZeroFill;
780  else
781  return eSectionTypeData;
782  }
783 
784  SectionType section_type =
785  llvm::StringSwitch<SectionType>(sect_name)
786  .Case(".debug", eSectionTypeDebug)
787  .Case(".stabstr", eSectionTypeDataCString)
788  .Case(".reloc", eSectionTypeOther)
789  .Case(".debug_abbrev", eSectionTypeDWARFDebugAbbrev)
790  .Case(".debug_aranges", eSectionTypeDWARFDebugAranges)
791  .Case(".debug_frame", eSectionTypeDWARFDebugFrame)
792  .Case(".debug_info", eSectionTypeDWARFDebugInfo)
793  .Case(".debug_line", eSectionTypeDWARFDebugLine)
794  .Case(".debug_loc", eSectionTypeDWARFDebugLoc)
795  .Case(".debug_loclists", eSectionTypeDWARFDebugLocLists)
796  .Case(".debug_macinfo", eSectionTypeDWARFDebugMacInfo)
797  .Case(".debug_names", eSectionTypeDWARFDebugNames)
798  .Case(".debug_pubnames", eSectionTypeDWARFDebugPubNames)
799  .Case(".debug_pubtypes", eSectionTypeDWARFDebugPubTypes)
800  .Case(".debug_ranges", eSectionTypeDWARFDebugRanges)
801  .Case(".debug_str", eSectionTypeDWARFDebugStr)
802  .Case(".debug_types", eSectionTypeDWARFDebugTypes)
803  // .eh_frame can be truncated to 8 chars.
804  .Cases(".eh_frame", ".eh_fram", eSectionTypeEHFrame)
805  .Case(".gosymtab", eSectionTypeGoSymtab)
806  .Default(eSectionTypeInvalid);
807  if (section_type != eSectionTypeInvalid)
808  return section_type;
809 
810  if (sect.flags & llvm::COFF::IMAGE_SCN_CNT_CODE)
811  return eSectionTypeCode;
812  if (sect.flags & llvm::COFF::IMAGE_SCN_CNT_INITIALIZED_DATA)
813  return eSectionTypeData;
814  if (sect.flags & llvm::COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA) {
815  if (sect.size == 0)
816  return eSectionTypeZeroFill;
817  else
818  return eSectionTypeData;
819  }
820  return eSectionTypeOther;
821 }
822 
823 void ObjectFilePECOFF::CreateSections(SectionList &unified_section_list) {
824  if (m_sections_up)
825  return;
826  m_sections_up = std::make_unique<SectionList>();
827  ModuleSP module_sp(GetModule());
828  if (module_sp) {
829  std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
830 
831  SectionSP header_sp = std::make_shared<Section>(
832  module_sp, this, ~user_id_t(0), ConstString("PECOFF header"),
835  /*file_offset*/ 0, m_coff_header_opt.header_size,
837  /*flags*/ 0);
838  header_sp->SetPermissions(ePermissionsReadable);
839  m_sections_up->AddSection(header_sp);
840  unified_section_list.AddSection(header_sp);
841 
842  const uint32_t nsects = m_sect_headers.size();
843  ModuleSP module_sp(GetModule());
844  for (uint32_t idx = 0; idx < nsects; ++idx) {
845  llvm::StringRef sect_name = GetSectionName(m_sect_headers[idx]);
846  ConstString const_sect_name(sect_name);
847  SectionType section_type = GetSectionType(sect_name, m_sect_headers[idx]);
848 
849  SectionSP section_sp(new Section(
850  module_sp, // Module to which this section belongs
851  this, // Object file to which this section belongs
852  idx + 1, // Section ID is the 1 based section index.
853  const_sect_name, // Name of this section
854  section_type,
856  m_sect_headers[idx].vmaddr, // File VM address == addresses as
857  // they are found in the object file
858  m_sect_headers[idx].vmsize, // VM size in bytes of this section
859  m_sect_headers[idx]
860  .offset, // Offset to the data for this section in the file
861  m_sect_headers[idx]
862  .size, // Size in bytes of this section as found in the file
863  m_coff_header_opt.sect_alignment, // Section alignment
864  m_sect_headers[idx].flags)); // Flags for this section
865 
866  uint32_t permissions = 0;
867  if (m_sect_headers[idx].flags & llvm::COFF::IMAGE_SCN_MEM_EXECUTE)
868  permissions |= ePermissionsExecutable;
869  if (m_sect_headers[idx].flags & llvm::COFF::IMAGE_SCN_MEM_READ)
870  permissions |= ePermissionsReadable;
871  if (m_sect_headers[idx].flags & llvm::COFF::IMAGE_SCN_MEM_WRITE)
872  permissions |= ePermissionsWritable;
873  section_sp->SetPermissions(permissions);
874 
875  m_sections_up->AddSection(section_sp);
876  unified_section_list.AddSection(section_sp);
877  }
878  }
879 }
880 
882  if (m_uuid.IsValid())
883  return m_uuid;
884 
885  if (!CreateBinary())
886  return UUID();
887 
889  return m_uuid;
890 }
891 
893  ModuleSP module_sp(GetModule());
894  if (!module_sp)
895  return 0;
896 
897  std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
898  if (m_deps_filespec)
899  return m_deps_filespec->GetSize();
900 
901  // Cache coff binary if it is not done yet.
902  if (!CreateBinary())
903  return 0;
904 
906  LLDB_LOG(log, "this = {0}, module = {1} ({2}), file = {3}, binary = {4}",
907  this, GetModule().get(), GetModule()->GetSpecificationDescription(),
908  m_file.GetPath(), m_binary.get());
909 
910  m_deps_filespec = FileSpecList();
911 
912  for (const auto &entry : m_binary->import_directories()) {
913  llvm::StringRef dll_name;
914  // Report a bogus entry.
915  if (llvm::Error e = entry.getName(dll_name)) {
916  LLDB_LOGF(log,
917  "ObjectFilePECOFF::ParseDependentModules() - failed to get "
918  "import directory entry name: %s",
919  llvm::toString(std::move(e)).c_str());
920  continue;
921  }
922 
923  // At this moment we only have the base name of the DLL. The full path can
924  // only be seen after the dynamic loading. Our best guess is Try to get it
925  // with the help of the object file's directory.
926  llvm::SmallString<128> dll_fullpath;
927  FileSpec dll_specs(dll_name);
929 
930  if (!llvm::sys::fs::real_path(dll_specs.GetPath(), dll_fullpath))
931  m_deps_filespec->EmplaceBack(dll_fullpath);
932  else {
933  // Known DLLs or DLL not found in the object file directory.
934  m_deps_filespec->EmplaceBack(dll_name);
935  }
936  }
937  return m_deps_filespec->GetSize();
938 }
939 
941  auto num_modules = ParseDependentModules();
942  auto original_size = files.GetSize();
943 
944  for (unsigned i = 0; i < num_modules; ++i)
945  files.AppendIfUnique(m_deps_filespec->GetFileSpecAtIndex(i));
946 
947  return files.GetSize() - original_size;
948 }
949 
952  return m_entry_point_address;
953 
954  if (!ParseHeader() || !IsExecutable())
955  return m_entry_point_address;
956 
957  SectionList *section_list = GetSectionList();
959 
960  if (!section_list)
961  m_entry_point_address.SetOffset(file_addr);
962  else
964  section_list);
965  return m_entry_point_address;
966 }
967 
969  return Address(GetSectionList()->GetSectionAtIndex(0), 0);
970 }
971 
972 // Dump
973 //
974 // Dump the specifics of the runtime file container (such as any headers
975 // segments, sections, etc).
977  ModuleSP module_sp(GetModule());
978  if (module_sp) {
979  std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
980  s->Printf("%p: ", static_cast<void *>(this));
981  s->Indent();
982  s->PutCString("ObjectFilePECOFF");
983 
984  ArchSpec header_arch = GetArchitecture();
985 
986  *s << ", file = '" << m_file
987  << "', arch = " << header_arch.GetArchitectureName() << "\n";
988 
989  SectionList *sections = GetSectionList();
990  if (sections)
991  sections->Dump(s->AsRawOstream(), s->GetIndentLevel(), nullptr, true,
992  UINT32_MAX);
993 
994  if (m_symtab_up)
995  m_symtab_up->Dump(s, nullptr, eSortOrderNone);
996 
997  if (m_dos_header.e_magic)
999  if (m_coff_header.machine) {
1001  if (m_coff_header.hdrsize)
1003  }
1004  s->EOL();
1005  DumpSectionHeaders(s);
1006  s->EOL();
1007 
1009  s->EOL();
1010  }
1011 }
1012 
1013 // DumpDOSHeader
1014 //
1015 // Dump the MS-DOS header to the specified output stream
1017  s->PutCString("MSDOS Header\n");
1018  s->Printf(" e_magic = 0x%4.4x\n", header.e_magic);
1019  s->Printf(" e_cblp = 0x%4.4x\n", header.e_cblp);
1020  s->Printf(" e_cp = 0x%4.4x\n", header.e_cp);
1021  s->Printf(" e_crlc = 0x%4.4x\n", header.e_crlc);
1022  s->Printf(" e_cparhdr = 0x%4.4x\n", header.e_cparhdr);
1023  s->Printf(" e_minalloc = 0x%4.4x\n", header.e_minalloc);
1024  s->Printf(" e_maxalloc = 0x%4.4x\n", header.e_maxalloc);
1025  s->Printf(" e_ss = 0x%4.4x\n", header.e_ss);
1026  s->Printf(" e_sp = 0x%4.4x\n", header.e_sp);
1027  s->Printf(" e_csum = 0x%4.4x\n", header.e_csum);
1028  s->Printf(" e_ip = 0x%4.4x\n", header.e_ip);
1029  s->Printf(" e_cs = 0x%4.4x\n", header.e_cs);
1030  s->Printf(" e_lfarlc = 0x%4.4x\n", header.e_lfarlc);
1031  s->Printf(" e_ovno = 0x%4.4x\n", header.e_ovno);
1032  s->Printf(" e_res[4] = { 0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x }\n",
1033  header.e_res[0], header.e_res[1], header.e_res[2], header.e_res[3]);
1034  s->Printf(" e_oemid = 0x%4.4x\n", header.e_oemid);
1035  s->Printf(" e_oeminfo = 0x%4.4x\n", header.e_oeminfo);
1036  s->Printf(" e_res2[10] = { 0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x, "
1037  "0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x }\n",
1038  header.e_res2[0], header.e_res2[1], header.e_res2[2],
1039  header.e_res2[3], header.e_res2[4], header.e_res2[5],
1040  header.e_res2[6], header.e_res2[7], header.e_res2[8],
1041  header.e_res2[9]);
1042  s->Printf(" e_lfanew = 0x%8.8x\n", header.e_lfanew);
1043 }
1044 
1045 // DumpCOFFHeader
1046 //
1047 // Dump the COFF header to the specified output stream
1049  s->PutCString("COFF Header\n");
1050  s->Printf(" machine = 0x%4.4x\n", header.machine);
1051  s->Printf(" nsects = 0x%4.4x\n", header.nsects);
1052  s->Printf(" modtime = 0x%8.8x\n", header.modtime);
1053  s->Printf(" symoff = 0x%8.8x\n", header.symoff);
1054  s->Printf(" nsyms = 0x%8.8x\n", header.nsyms);
1055  s->Printf(" hdrsize = 0x%4.4x\n", header.hdrsize);
1056 }
1057 
1058 // DumpOptCOFFHeader
1059 //
1060 // Dump the optional COFF header to the specified output stream
1062  const coff_opt_header_t &header) {
1063  s->PutCString("Optional COFF Header\n");
1064  s->Printf(" magic = 0x%4.4x\n", header.magic);
1065  s->Printf(" major_linker_version = 0x%2.2x\n",
1066  header.major_linker_version);
1067  s->Printf(" minor_linker_version = 0x%2.2x\n",
1068  header.minor_linker_version);
1069  s->Printf(" code_size = 0x%8.8x\n", header.code_size);
1070  s->Printf(" data_size = 0x%8.8x\n", header.data_size);
1071  s->Printf(" bss_size = 0x%8.8x\n", header.bss_size);
1072  s->Printf(" entry = 0x%8.8x\n", header.entry);
1073  s->Printf(" code_offset = 0x%8.8x\n", header.code_offset);
1074  s->Printf(" data_offset = 0x%8.8x\n", header.data_offset);
1075  s->Printf(" image_base = 0x%16.16" PRIx64 "\n",
1076  header.image_base);
1077  s->Printf(" sect_alignment = 0x%8.8x\n", header.sect_alignment);
1078  s->Printf(" file_alignment = 0x%8.8x\n", header.file_alignment);
1079  s->Printf(" major_os_system_version = 0x%4.4x\n",
1080  header.major_os_system_version);
1081  s->Printf(" minor_os_system_version = 0x%4.4x\n",
1082  header.minor_os_system_version);
1083  s->Printf(" major_image_version = 0x%4.4x\n",
1084  header.major_image_version);
1085  s->Printf(" minor_image_version = 0x%4.4x\n",
1086  header.minor_image_version);
1087  s->Printf(" major_subsystem_version = 0x%4.4x\n",
1088  header.major_subsystem_version);
1089  s->Printf(" minor_subsystem_version = 0x%4.4x\n",
1090  header.minor_subsystem_version);
1091  s->Printf(" reserved1 = 0x%8.8x\n", header.reserved1);
1092  s->Printf(" image_size = 0x%8.8x\n", header.image_size);
1093  s->Printf(" header_size = 0x%8.8x\n", header.header_size);
1094  s->Printf(" checksum = 0x%8.8x\n", header.checksum);
1095  s->Printf(" subsystem = 0x%4.4x\n", header.subsystem);
1096  s->Printf(" dll_flags = 0x%4.4x\n", header.dll_flags);
1097  s->Printf(" stack_reserve_size = 0x%16.16" PRIx64 "\n",
1098  header.stack_reserve_size);
1099  s->Printf(" stack_commit_size = 0x%16.16" PRIx64 "\n",
1100  header.stack_commit_size);
1101  s->Printf(" heap_reserve_size = 0x%16.16" PRIx64 "\n",
1102  header.heap_reserve_size);
1103  s->Printf(" heap_commit_size = 0x%16.16" PRIx64 "\n",
1104  header.heap_commit_size);
1105  s->Printf(" loader_flags = 0x%8.8x\n", header.loader_flags);
1106  s->Printf(" num_data_dir_entries = 0x%8.8x\n",
1107  (uint32_t)header.data_dirs.size());
1108  uint32_t i;
1109  for (i = 0; i < header.data_dirs.size(); i++) {
1110  s->Printf(" data_dirs[%2u] vmaddr = 0x%8.8x, vmsize = 0x%8.8x\n", i,
1111  header.data_dirs[i].vmaddr, header.data_dirs[i].vmsize);
1112  }
1113 }
1114 // DumpSectionHeader
1115 //
1116 // Dump a single ELF section header to the specified output stream
1118  const section_header_t &sh) {
1120  s->Printf("%-16s 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x 0x%4.4x "
1121  "0x%4.4x 0x%8.8x\n",
1122  name.c_str(), sh.vmaddr, sh.vmsize, sh.offset, sh.size, sh.reloff,
1123  sh.lineoff, sh.nreloc, sh.nline, sh.flags);
1124 }
1125 
1126 // DumpSectionHeaders
1127 //
1128 // Dump all of the ELF section header to the specified output stream
1130 
1131  s->PutCString("Section Headers\n");
1132  s->PutCString("IDX name vm addr vm size file off file "
1133  "size reloc off line off nreloc nline flags\n");
1134  s->PutCString("==== ---------------- ---------- ---------- ---------- "
1135  "---------- ---------- ---------- ------ ------ ----------\n");
1136 
1137  uint32_t idx = 0;
1138  SectionHeaderCollIter pos, end = m_sect_headers.end();
1139 
1140  for (pos = m_sect_headers.begin(); pos != end; ++pos, ++idx) {
1141  s->Printf("[%2u] ", idx);
1143  }
1144 }
1145 
1146 // DumpDependentModules
1147 //
1148 // Dump all of the dependent modules to the specified output stream
1150  auto num_modules = ParseDependentModules();
1151  if (num_modules > 0) {
1152  s->PutCString("Dependent Modules\n");
1153  for (unsigned i = 0; i < num_modules; ++i) {
1154  auto spec = m_deps_filespec->GetFileSpecAtIndex(i);
1155  s->Printf(" %s\n", spec.GetFilename().GetCString());
1156  }
1157  }
1158 }
1159 
1161  switch (m_coff_header_opt.subsystem) {
1162  case llvm::COFF::IMAGE_SUBSYSTEM_NATIVE:
1163  case llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_GUI:
1164  case llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_CUI:
1165  case llvm::COFF::IMAGE_SUBSYSTEM_NATIVE_WINDOWS:
1166  case llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
1167  case llvm::COFF::IMAGE_SUBSYSTEM_XBOX:
1168  case llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION:
1169  return true;
1170  default:
1171  return false;
1172  }
1173 }
1174 
1176  uint16_t machine = m_coff_header.machine;
1177  switch (machine) {
1178  default:
1179  break;
1180  case llvm::COFF::IMAGE_FILE_MACHINE_AMD64:
1181  case llvm::COFF::IMAGE_FILE_MACHINE_I386:
1182  case llvm::COFF::IMAGE_FILE_MACHINE_POWERPC:
1183  case llvm::COFF::IMAGE_FILE_MACHINE_POWERPCFP:
1184  case llvm::COFF::IMAGE_FILE_MACHINE_ARM:
1185  case llvm::COFF::IMAGE_FILE_MACHINE_ARMNT:
1186  case llvm::COFF::IMAGE_FILE_MACHINE_THUMB:
1187  case llvm::COFF::IMAGE_FILE_MACHINE_ARM64:
1188  ArchSpec arch;
1190  IsWindowsSubsystem() ? llvm::Triple::Win32
1191  : llvm::Triple::UnknownOS);
1192  return arch;
1193  }
1194  return ArchSpec();
1195 }
1196 
1198  if (m_coff_header.machine != 0) {
1199  if ((m_coff_header.flags & llvm::COFF::IMAGE_FILE_DLL) == 0)
1200  return eTypeExecutable;
1201  else
1202  return eTypeSharedLibrary;
1203  }
1204  return eTypeExecutable;
1205 }
1206 
1208 
1209 // PluginInterface protocol
1211 
lldb_private::SectionLoadList::SetSectionLoadAddress
bool SetSectionLoadAddress(const lldb::SectionSP &section_sp, lldb::addr_t load_addr, bool warn_multiple=false)
Definition: SectionLoadList.cpp:63
lldb_private::UUID::CvRecordPdb70::Age
llvm::support::ulittle32_t Age
Definition: UUID.h:36
ObjectFilePECOFF::section_header::offset
uint32_t offset
Definition: ObjectFilePECOFF.h:235
lldb_private::Symbol::SetDebug
void SetDebug(bool b)
Definition: Symbol.h:168
ObjectFilePECOFF::coff_symbol::sect
uint16_t sect
Definition: ObjectFilePECOFF.h:246
ObjectFilePECOFF::MagicBytesMatch
static bool MagicBytesMatch(lldb::DataBufferSP &data_sp)
Definition: ObjectFilePECOFF.cpp:198
ObjectFilePECOFF::coff_opt_header::checksum
uint32_t checksum
Definition: ObjectFilePECOFF.h:211
lldb_private::UUID
Definition: UUID.h:23
lldb::eSectionTypeDWARFDebugLoc
@ eSectionTypeDWARFDebugLoc
Definition: lldb-enumerations.h:670
ObjectFilePECOFF::coff_opt_header::stack_reserve_size
uint64_t stack_reserve_size
Definition: ObjectFilePECOFF.h:214
llvm
Definition: Debugger.h:49
ObjectFilePECOFF::NeedsEndianSwap
bool NeedsEndianSwap() const
Definition: ObjectFilePECOFF.cpp:342
ObjectFilePECOFF::dos_header::e_magic
uint16_t e_magic
Definition: ObjectFilePECOFF.h:152
ObjectFilePECOFF::dos_header::e_ip
uint16_t e_ip
Definition: ObjectFilePECOFF.h:162
ObjectFilePECOFF::data_directory::vmaddr
uint32_t vmaddr
Definition: ObjectFilePECOFF.h:184
ObjectFilePECOFF::~ObjectFilePECOFF
~ObjectFilePECOFF() override
lldb_private::ArchSpec
Definition: ArchSpec.h:33
lldb::eSectionTypeDebug
@ eSectionTypeDebug
Definition: lldb-enumerations.h:658
ObjectFilePECOFF::ReadImageData
lldb_private::DataExtractor ReadImageData(uint32_t offset, size_t size)
Definition: ObjectFilePECOFF.cpp:511
lldb_private::eArchTypeCOFF
@ eArchTypeCOFF
Definition: lldb-private-enumerations.h:65
lldb_private::Address::IsValid
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:332
ObjectFilePECOFF::dos_header::e_oeminfo
uint16_t e_oeminfo
Definition: ObjectFilePECOFF.h:168
ObjectFilePECOFF::dos_header::e_oemid
uint16_t e_oemid
Definition: ObjectFilePECOFF.h:167
lldb::eSymbolTypeCode
@ eSymbolTypeCode
Definition: lldb-enumerations.h:616
lldb_private::SectionList::Dump
void Dump(llvm::raw_ostream &s, unsigned indent, Target *target, bool show_header, uint32_t depth) const
Definition: Section.cpp:570
ObjectFilePECOFF::coff_opt_header::minor_os_system_version
uint16_t minor_os_system_version
Definition: ObjectFilePECOFF.h:203
lldb_private::UUID::CvRecordPdb70::Uuid
struct lldb_private::UUID::CvRecordPdb70::@45 Uuid
ObjectFilePECOFF::GetDependentModules
uint32_t GetDependentModules(lldb_private::FileSpecList &files) override
Definition: ObjectFilePECOFF.cpp:940
ObjectFilePECOFF::coff_header::modtime
uint32_t modtime
Definition: ObjectFilePECOFF.h:176
ModuleSpec.h
ObjectFilePECOFF::m_dos_header
dos_header_t m_dos_header
Definition: ObjectFilePECOFF.h:297
ObjectFilePECOFF::ObjectFilePECOFF
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)
ObjectFilePECOFF::ParseCOFFOptionalHeader
bool ParseCOFFOptionalHeader(lldb::offset_t *offset_ptr)
Definition: ObjectFilePECOFF.cpp:428
ObjectFilePECOFF::CreateSections
void CreateSections(lldb_private::SectionList &unified_section_list) override
Definition: ObjectFilePECOFF.cpp:823
ObjectFilePECOFF::section_header::size
uint32_t size
Definition: ObjectFilePECOFF.h:234
lldb_private::Symbol
Definition: Symbol.h:20
ObjectFilePECOFF::coff_opt_header::subsystem
uint16_t subsystem
Definition: ObjectFilePECOFF.h:212
UUID.h
ObjectFilePECOFF::dos_header::e_maxalloc
uint16_t e_maxalloc
Definition: ObjectFilePECOFF.h:158
lldb::eSymbolTypeInvalid
@ eSymbolTypeInvalid
Definition: lldb-enumerations.h:614
ObjectFilePECOFF::section_header::lineoff
uint32_t lineoff
Definition: ObjectFilePECOFF.h:237
lldb_private::ObjectFile::eTypeExecutable
@ eTypeExecutable
A normal executable.
Definition: ObjectFile.h:69
ObjectFilePECOFF::export_directory_entry::minor_version
uint16_t minor_version
Definition: ObjectFilePECOFF.h:256
OPT_HEADER_MAGIC_PE32
#define OPT_HEADER_MAGIC_PE32
Definition: ObjectFilePECOFF.cpp:38
lldb::eSectionTypeDWARFDebugAranges
@ eSectionTypeDWARFDebugAranges
Definition: lldb-enumerations.h:665
lldb_private::UUID::IsValid
bool IsValid() const
Definition: UUID.h:79
lldb_private::ObjectFile::m_process_wp
lldb::ProcessWP m_process_wp
Definition: ObjectFile.h:707
lldb_private::SectionList::GetSize
size_t GetSize() const
Definition: Section.h:74
lldb_private::ModuleSpecList
Definition: ModuleSpec.h:280
lldb_private::ModuleSpecList::Append
void Append(const ModuleSpec &spec)
Definition: ModuleSpec.h:313
ObjectFilePECOFF::GetUUID
lldb_private::UUID GetUUID() override
Gets the UUID for this object file.
Definition: ObjectFilePECOFF.cpp:881
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:249
lldb::eSectionTypeDWARFDebugRanges
@ eSectionTypeDWARFDebugRanges
Definition: lldb-enumerations.h:675
ObjectFilePECOFF::section_header
Definition: ObjectFilePECOFF.h:230
ObjectFilePECOFF::dos_header::e_res
uint16_t e_res[4]
Definition: ObjectFilePECOFF.h:166
ObjectFilePECOFF::data_directory::vmsize
uint32_t vmsize
Definition: ObjectFilePECOFF.h:185
ObjectFilePECOFF::DumpSectionHeaders
void DumpSectionHeaders(lldb_private::Stream *s)
Definition: ObjectFilePECOFF.cpp:1129
lldb::eSectionTypeDWARFDebugFrame
@ eSectionTypeDWARFDebugFrame
Definition: lldb-enumerations.h:667
Module.h
lldb::eSectionTypeDWARFDebugLine
@ eSectionTypeDWARFDebugLine
Definition: lldb-enumerations.h:669
lldb_private::ObjectFile::m_symtab_up
std::unique_ptr< lldb_private::Symtab > m_symtab_up
Definition: ObjectFile.h:710
ObjectFilePECOFF::export_directory_entry::time_date_stamp
uint32_t time_date_stamp
Definition: ObjectFilePECOFF.h:254
ObjectFilePECOFF::coff_opt_header::major_linker_version
uint8_t major_linker_version
Definition: ObjectFilePECOFF.h:190
lldb_private::ObjectFile::m_file
FileSpec m_file
Definition: ObjectFile.h:697
ObjectFilePECOFF::coff_symbol::name
char name[8]
Definition: ObjectFilePECOFF.h:244
ObjectFilePECOFF::GetAddressByteSize
uint32_t GetAddressByteSize() const override
Gets the address size in bytes for the current object file.
Definition: ObjectFilePECOFF.cpp:330
ObjectFilePECOFF::GetPluginDescriptionStatic
static const char * GetPluginDescriptionStatic()
Definition: ObjectFilePECOFF.cpp:79
SectionLoadList.h
lldb_private::Symbol::SetType
void SetType(lldb::SymbolType type)
Definition: Symbol.h:145
lldb_private::SectionList
Definition: Section.h:34
lldb::offset_t
uint64_t offset_t
Definition: lldb-types.h:87
ObjectFilePECOFF::coff_opt_header::sect_alignment
uint32_t sect_alignment
Definition: ObjectFilePECOFF.h:200
ObjectFilePECOFF::coff_opt_header::code_size
uint32_t code_size
Definition: ObjectFilePECOFF.h:192
ObjectFilePECOFF::Terminate
static void Terminate()
Definition: ObjectFilePECOFF.cpp:70
ObjectFilePECOFF::export_directory_entry::address_of_name_ordinals
uint32_t address_of_name_ordinals
Definition: ObjectFilePECOFF.h:263
lldb_private::Stream
Definition: Stream.h:28
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
LLDB_INVALID_CPUTYPE
#define LLDB_INVALID_CPUTYPE
Definition: lldb-defines.h:106
lldb_private::ObjectFile::Type
Type
Definition: ObjectFile.h:64
ObjectFilePECOFF::coff_opt_header::heap_reserve_size
uint64_t heap_reserve_size
Definition: ObjectFilePECOFF.h:216
ObjectFilePECOFF::dos_header
Definition: ObjectFilePECOFF.h:151
lldb_private::Target
Definition: Target.h:445
ObjectFilePECOFF::IsExecutable
bool IsExecutable() const override
Tells whether this object file is capable of being the main executable for a process.
Definition: ObjectFilePECOFF.cpp:326
Section.h
lldb_private::eSortOrderNone
@ eSortOrderNone
Definition: lldb-private-enumerations.h:110
ObjectFilePECOFF::dos_header::e_cparhdr
uint16_t e_cparhdr
Definition: ObjectFilePECOFF.h:156
lldb_private::DataExtractor::SetData
lldb::offset_t SetData(const void *bytes, lldb::offset_t length, lldb::ByteOrder byte_order)
Set data with a buffer that is caller owned.
Definition: DataExtractor.cpp:225
ObjectFilePECOFF::export_directory_entry::address_of_functions
uint32_t address_of_functions
Definition: ObjectFilePECOFF.h:261
ObjectFilePECOFF::CreateInstance
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)
Definition: ObjectFilePECOFF.cpp:84
ObjectFilePECOFF::Dump
void Dump(lldb_private::Stream *s) override
Dump a description of this object to a Stream.
Definition: ObjectFilePECOFF.cpp:976
ObjectFilePECOFF::GetSymtab
lldb_private::Symtab * GetSymtab() override
Gets the symbol table for the currently selected architecture (and object for archives).
Definition: ObjectFilePECOFF.cpp:598
Process.h
ObjectFilePECOFF::section_header::reloff
uint32_t reloff
Definition: ObjectFilePECOFF.h:236
ObjectFilePECOFF::coff_opt_header::image_size
uint32_t image_size
Definition: ObjectFilePECOFF.h:209
ObjectFilePECOFF::DumpDependentModules
void DumpDependentModules(lldb_private::Stream *s)
Definition: ObjectFilePECOFF.cpp:1149
lldb_private::DataExtractor::PeekCStr
const char * PeekCStr(lldb::offset_t offset) const
Peek at a C string at offset.
Definition: DataExtractor.cpp:834
ObjectFilePECOFF::coff_data_dir_exception_table
@ coff_data_dir_exception_table
Definition: ObjectFilePECOFF.h:227
ObjectFilePECOFF::coff_opt_header::minor_linker_version
uint8_t minor_linker_version
Definition: ObjectFilePECOFF.h:191
Target.h
lldb_private::ModuleSpec::GetUUID
UUID & GetUUID()
Definition: ModuleSpec.h:104
ObjectFilePECOFF::coff_opt_header::dll_flags
uint16_t dll_flags
Definition: ObjectFilePECOFF.h:213
ObjectFilePECOFF::coff_symbol::storage
uint8_t storage
Definition: ObjectFilePECOFF.h:248
lldb_private::DataExtractor::SetByteOrder
void SetByteOrder(lldb::ByteOrder byte_order)
Set the byte_order value.
Definition: DataExtractor.h:920
ObjectFilePECOFF::coff_opt_header::bss_size
uint32_t bss_size
Definition: ObjectFilePECOFF.h:194
lldb_private::SectionList::AddSection
size_t AddSection(const lldb::SectionSP &section_sp)
Definition: Section.cpp:407
GetCoffUUID
static UUID GetCoffUUID(llvm::object::COFFObjectFile &coff_obj)
Definition: ObjectFilePECOFF.cpp:46
lldb_private::FileSpec
Definition: FileSpec.h:56
ObjectFilePECOFF
Definition: ObjectFilePECOFF.h:17
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::ObjectFile::GetSectionList
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:583
ObjectFilePECOFF::m_sect_headers
SectionHeaderColl m_sect_headers
Definition: ObjectFilePECOFF.h:300
PECallFrameInfo.h
ObjectFilePECOFF::IsStripped
bool IsStripped() override
Detect if this object file has been stripped of local symbols.
Definition: ObjectFilePECOFF.cpp:747
lldb_private::ConstString::SetString
void SetString(const llvm::StringRef &s)
Definition: ConstString.cpp:306
lldb::eSectionTypeDWARFDebugAbbrev
@ eSectionTypeDWARFDebugAbbrev
Definition: lldb-enumerations.h:663
lldb_private::Stream::Indent
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
Definition: Stream.cpp:130
ObjectFilePECOFF::coff_opt_header::data_dirs
std::vector< data_directory > data_dirs
Definition: ObjectFilePECOFF.h:221
lldb_private::breakpad::toString
llvm::StringRef toString(Record::Kind K)
Definition: BreakpadRecords.cpp:483
lldb_private::DataExtractor
Definition: DataExtractor.h:48
lldb_private::ConstString::GetStringRef
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:202
Log.h
ObjectFilePECOFF::dos_header::e_res2
uint16_t e_res2[10]
Definition: ObjectFilePECOFF.h:169
ObjectFilePECOFF::coff_opt_header::minor_image_version
uint16_t minor_image_version
Definition: ObjectFilePECOFF.h:205
ObjectFilePECOFF::export_directory_entry::base
uint32_t base
Definition: ObjectFilePECOFF.h:258
ObjectFilePECOFF::coff_header
Definition: ObjectFilePECOFF.h:173
ObjectFilePECOFF::GetAddress
lldb_private::Address GetAddress(uint32_t rva)
Definition: ObjectFilePECOFF.cpp:499
lldb_private::ObjectFile::eStrataUser
@ eStrataUser
Definition: ObjectFile.h:88
ObjectFilePECOFF::coff_header::hdrsize
uint16_t hdrsize
Definition: ObjectFilePECOFF.h:179
lldb::eSectionTypeDWARFDebugStr
@ eSectionTypeDWARFDebugStr
Definition: lldb-enumerations.h:676
ObjectFilePECOFF::ParseDOSHeader
static bool ParseDOSHeader(lldb_private::DataExtractor &data, dos_header_t &dos_header)
Definition: ObjectFilePECOFF.cpp:350
ObjectFilePECOFF::coff_opt_header
Definition: ObjectFilePECOFF.h:188
ObjectFilePECOFF::CalculateStrata
ObjectFile::Strata CalculateStrata() override
The object file should be able to calculate the strata of the object file.
Definition: ObjectFilePECOFF.cpp:1207
lldb_private::ArchSpec::SetTriple
bool SetTriple(const llvm::Triple &triple)
Architecture triple setter.
Definition: ArchSpec.cpp:739
ObjectFilePECOFF::Initialize
static void Initialize()
Definition: ObjectFilePECOFF.cpp:64
ObjectFilePECOFF::m_coff_header
coff_header_t m_coff_header
Definition: ObjectFilePECOFF.h:298
ObjectFilePECOFF::export_directory_entry::number_of_names
uint32_t number_of_names
Definition: ObjectFilePECOFF.h:260
ObjectFilePECOFF::export_directory_entry::number_of_functions
uint32_t number_of_functions
Definition: ObjectFilePECOFF.h:259
ObjectFilePECOFF::coff_header::symoff
uint32_t symoff
Definition: ObjectFilePECOFF.h:177
ObjectFilePECOFF::GetFileAddress
lldb::addr_t GetFileAddress(uint32_t rva) const
Definition: ObjectFilePECOFF.cpp:507
lldb_private::DataExtractor::SetAddressByteSize
void SetAddressByteSize(uint32_t addr_size)
Set the address byte size.
Definition: DataExtractor.h:834
StreamString.h
ObjectFilePECOFF::dos_header::e_minalloc
uint16_t e_minalloc
Definition: ObjectFilePECOFF.h:157
lldb_private::Address::GetFileAddress
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:290
lldb_private::Symbol::GetAddressRef
Address & GetAddressRef()
Definition: Symbol.h:57
ObjectFilePECOFF::export_directory_entry
Definition: ObjectFilePECOFF.h:252
ObjectFilePECOFF::coff_data_dir_export_table
@ coff_data_dir_export_table
Definition: ObjectFilePECOFF.h:225
ObjectFilePECOFF::coff_opt_header::image_base
uint64_t image_base
Definition: ObjectFilePECOFF.h:199
ObjectFilePECOFF::dos_header::e_crlc
uint16_t e_crlc
Definition: ObjectFilePECOFF.h:155
ObjectFilePECOFF::CreateBinary
bool CreateBinary()
Definition: ObjectFilePECOFF.cpp:216
FileSpecList.h
lldb_private::ConstString
Definition: ConstString.h:40
IMAGE_NT_SIGNATURE
#define IMAGE_NT_SIGNATURE
Definition: ObjectFilePECOFF.cpp:37
ObjectFilePECOFF::coff_opt_header::major_subsystem_version
uint16_t major_subsystem_version
Definition: ObjectFilePECOFF.h:206
ObjectFilePECOFF::GetPluginNameStatic
static lldb_private::ConstString GetPluginNameStatic()
Definition: ObjectFilePECOFF.cpp:74
lldb::eSectionTypeDWARFDebugInfo
@ eSectionTypeDWARFDebugInfo
Definition: lldb-enumerations.h:668
lldb_private::DataExtractor::GetU8
uint8_t GetU8(lldb::offset_t *offset_ptr) const
Extract a uint8_t value from *offset_ptr.
Definition: DataExtractor.cpp:318
ObjectFilePECOFF::GetArchitecture
lldb_private::ArchSpec GetArchitecture() override
Get the ArchSpec for this object file.
Definition: ObjectFilePECOFF.cpp:1175
Timer.h
ObjectFilePECOFF::coff_opt_header::entry
uint32_t entry
Definition: ObjectFilePECOFF.h:195
ObjectFilePECOFF::dos_header::e_cp
uint16_t e_cp
Definition: ObjectFilePECOFF.h:154
ObjectFilePECOFF::dos_header::e_lfanew
uint32_t e_lfanew
Definition: ObjectFilePECOFF.h:170
lldb_private::GetLogIfAllCategoriesSet
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:58
ObjectFilePECOFF::ParseDependentModules
uint32_t ParseDependentModules()
Definition: ObjectFilePECOFF.cpp:892
lldb::eSectionTypeDWARFDebugTypes
@ eSectionTypeDWARFDebugTypes
DWARF .debug_types section.
Definition: lldb-enumerations.h:695
lldb_private::SectionList::GetSectionAtIndex
lldb::SectionSP GetSectionAtIndex(size_t idx) const
Definition: Section.cpp:476
lldb::eSectionTypeZeroFill
@ eSectionTypeZeroFill
Definition: lldb-enumerations.h:659
ObjectFilePECOFF::dos_header::e_lfarlc
uint16_t e_lfarlc
Definition: ObjectFilePECOFF.h:164
ObjectFilePECOFF::m_entry_point_address
lldb_private::Address m_entry_point_address
Definition: ObjectFilePECOFF.h:302
ObjectFilePECOFF::coff_opt_header::code_offset
uint32_t code_offset
Definition: ObjectFilePECOFF.h:196
lldb_private::Stream::GetIndentLevel
unsigned GetIndentLevel() const
Get the current indentation level.
Definition: Stream.cpp:160
lldb_private::ObjectFile::eTypeSharedLibrary
@ eTypeSharedLibrary
A shared library that can be used during execution.
Definition: ObjectFile.h:77
OPT_HEADER_MAGIC_PE32_PLUS
#define OPT_HEADER_MAGIC_PE32_PLUS
Definition: ObjectFilePECOFF.cpp:39
ObjectFilePECOFF::ReadImageDataByRVA
lldb_private::DataExtractor ReadImageDataByRVA(uint32_t rva, size_t size)
Definition: ObjectFilePECOFF.cpp:534
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:39
ObjectFilePECOFF::m_coff_header_opt
coff_opt_header_t m_coff_header_opt
Definition: ObjectFilePECOFF.h:299
lldb_private::Address::GetSection
lldb::SectionSP GetSection() const
Get const accessor for the section.
Definition: Address.h:416
ObjectFilePECOFF::coff_opt_header::heap_commit_size
uint64_t heap_commit_size
Definition: ObjectFilePECOFF.h:217
ObjectFilePECOFF::coff_symbol
Definition: ObjectFilePECOFF.h:243
ObjectFilePECOFF::CreateMemoryInstance
static lldb_private::ObjectFile * CreateMemoryInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp, const lldb::ProcessSP &process_sp, lldb::addr_t header_addr)
Definition: ObjectFilePECOFF.cpp:119
lldb_private::Symbol::GetMangled
Mangled & GetMangled()
Definition: Symbol.h:121
ObjectFilePECOFF::m_uuid
lldb_private::UUID m_uuid
Definition: ObjectFilePECOFF.h:305
ObjectFilePECOFF::dos_header::e_csum
uint16_t e_csum
Definition: ObjectFilePECOFF.h:161
lldb::SymbolType
SymbolType
Symbol types.
Definition: lldb-enumerations.h:612
ObjectFilePECOFF::coff_header::flags
uint16_t flags
Definition: ObjectFilePECOFF.h:180
WindowsMiniDump.h
ObjectFilePECOFF::coff_opt_header::magic
uint16_t magic
Definition: ObjectFilePECOFF.h:189
ObjectFilePECOFF::section_header::nline
uint16_t nline
Definition: ObjectFilePECOFF.h:239
ObjectFilePECOFF::export_directory_entry::major_version
uint16_t major_version
Definition: ObjectFilePECOFF.h:255
lldb::eSectionTypeData
@ eSectionTypeData
Definition: lldb-enumerations.h:650
ObjectFile.h
ObjectFilePECOFF::section_header::flags
uint32_t flags
Definition: ObjectFilePECOFF.h:240
IMAGE_DOS_SIGNATURE
#define IMAGE_DOS_SIGNATURE
Definition: ObjectFilePECOFF.cpp:36
lldb_private::Section
Definition: Section.h:96
ObjectFilePECOFF::coff_opt_header::loader_flags
uint32_t loader_flags
Definition: ObjectFilePECOFF.h:218
ObjectFilePECOFF::coff_opt_header::reserved1
uint32_t reserved1
Definition: ObjectFilePECOFF.h:208
lldb::eSectionTypeOther
@ eSectionTypeOther
Definition: lldb-enumerations.h:697
StreamFile.h
lldb::eSectionTypeCode
@ eSectionTypeCode
Definition: lldb-enumerations.h:648
lldb_private::ArchSpec::SetArchitecture
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:843
ObjectFilePECOFF::dos_header::e_ss
uint16_t e_ss
Definition: ObjectFilePECOFF.h:159
ObjectFilePECOFF::ParseCOFFHeader
static bool ParseCOFFHeader(lldb_private::DataExtractor &data, lldb::offset_t *offset_ptr, coff_header_t &coff_header)
Definition: ObjectFilePECOFF.cpp:409
lldb_private::ModuleSpec
Definition: ModuleSpec.h:26
ObjectFilePECOFF::DumpCOFFHeader
static void DumpCOFFHeader(lldb_private::Stream *s, const coff_header_t &header)
Definition: ObjectFilePECOFF.cpp:1048
ObjectFilePECOFF::coff_symbol::naux
uint8_t naux
Definition: ObjectFilePECOFF.h:249
ObjectFilePECOFF::dos_header::e_sp
uint16_t e_sp
Definition: ObjectFilePECOFF.h:160
ObjectFilePECOFF::DumpOptCOFFHeader
static void DumpOptCOFFHeader(lldb_private::Stream *s, const coff_opt_header_t &header)
Definition: ObjectFilePECOFF.cpp:1061
ObjectFilePECOFF::section_header_t
struct ObjectFilePECOFF::section_header section_header_t
lldb_private::Status
Definition: Status.h:44
ObjectFilePECOFF::export_directory_entry::address_of_names
uint32_t address_of_names
Definition: ObjectFilePECOFF.h:262
LIBLLDB_LOG_OBJECT
#define LIBLLDB_LOG_OBJECT
Definition: Logging.h:25
lldb::eSectionTypeEHFrame
@ eSectionTypeEHFrame
Definition: lldb-enumerations.h:686
ObjectFilePECOFF::coff_header::nsyms
uint32_t nsyms
Definition: ObjectFilePECOFF.h:178
lldb_private::ArchSpec::GetArchitectureName
const char * GetArchitectureName() const
Returns a static string representing the current architecture.
Definition: ArchSpec.cpp:538
lldb::eSaveCoreFull
@ eSaveCoreFull
Definition: lldb-enumerations.h:1138
lldb_private::Symtab
Definition: Symtab.h:22
ObjectFilePECOFF::export_directory_entry::characteristics
uint32_t characteristics
Definition: ObjectFilePECOFF.h:253
uint32_t
ObjectFilePECOFF::ID
static char ID
Definition: ObjectFilePECOFF.h:90
ObjectFilePECOFF::SaveCore
static bool SaveCore(const lldb::ProcessSP &process_sp, const lldb_private::FileSpec &outfile, lldb::SaveCoreStyle &core_style, lldb_private::Status &error)
Definition: ObjectFilePECOFF.cpp:190
lldb::SectionType
SectionType
Definition: lldb-enumerations.h:646
lldb_private::UUID::CvRecordPdb70
Definition: UUID.h:29
lldb_private::Address
Definition: Address.h:59
ObjectFilePECOFF::ParseSectionHeaders
bool ParseSectionHeaders(uint32_t offset)
Definition: ObjectFilePECOFF.cpp:545
lldb::eSectionTypeDWARFDebugPubTypes
@ eSectionTypeDWARFDebugPubTypes
Definition: lldb-enumerations.h:674
lldb::eSectionTypeDWARFDebugNames
@ eSectionTypeDWARFDebugNames
DWARF v5 .debug_names.
Definition: lldb-enumerations.h:696
lldb_private::DataExtractor::GetMaxU64
uint64_t GetMaxU64(lldb::offset_t *offset_ptr, size_t byte_size) const
Extract an unsigned integer of size byte_size from *offset_ptr.
Definition: DataExtractor.cpp:526
ObjectFilePECOFF::GetPluginVersion
uint32_t GetPluginVersion() override
Definition: ObjectFilePECOFF.cpp:1212
lldb_private::Stream::EOL
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:128
lldb::eSectionTypeDWARFDebugPubNames
@ eSectionTypeDWARFDebugPubNames
Definition: lldb-enumerations.h:673
ObjectFilePECOFF::SetLoadAddress
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...
Definition: ObjectFilePECOFF.cpp:293
lldb::eSectionTypeInvalid
@ eSectionTypeInvalid
Definition: lldb-enumerations.h:647
ObjectFilePECOFF::m_image_base
lldb::addr_t m_image_base
Definition: ObjectFilePECOFF.h:301
lldb::SaveCoreStyle
SaveCoreStyle
Definition: lldb-enumerations.h:1136
ObjectFilePECOFF::coff_opt_header::data_size
uint32_t data_size
Definition: ObjectFilePECOFF.h:193
lldb_private::Address::ResolveAddressUsingFileSections
bool ResolveAddressUsingFileSections(lldb::addr_t addr, const SectionList *sections)
Resolve a file virtual address using a section list.
Definition: Address.cpp:247
ObjectFilePECOFF::GetModuleSpecifications
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)
Definition: ObjectFilePECOFF.cpp:132
lldb::eSectionTypeDataCString
@ eSectionTypeDataCString
Inlined C string data.
Definition: lldb-enumerations.h:651
ObjectFilePECOFF::SectionHeaderCollIter
SectionHeaderColl::iterator SectionHeaderCollIter
Definition: ObjectFilePECOFF.h:291
ArchSpec.h
lldb_private::Stream::AsRawOstream
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition: Stream.h:357
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:31
lldb_private::ObjectFile::m_data
DataExtractor m_data
The data for this object file so things can be parsed lazily.
Definition: ObjectFile.h:706
ObjectFilePECOFF::coff_opt_header::header_size
uint32_t header_size
Definition: ObjectFilePECOFF.h:210
ObjectFilePECOFF::DumpSectionHeader
void DumpSectionHeader(lldb_private::Stream *s, const section_header_t &sh)
Definition: ObjectFilePECOFF.cpp:1117
ObjectFilePECOFF::CreateCallFrameInfo
std::unique_ptr< lldb_private::CallFrameInfo > CreateCallFrameInfo() override
Creates a plugin-specific call frame info.
Definition: ObjectFilePECOFF.cpp:731
lldb_private::ModuleChild::GetModule
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
Definition: ModuleChild.cpp:24
uint16_t
lldb_private::DataExtractor::GetU32
uint32_t GetU32(lldb::offset_t *offset_ptr) const
Extract a uint32_t value from *offset_ptr.
Definition: DataExtractor.cpp:427
lldb_private::SaveMiniDump
bool SaveMiniDump(const lldb::ProcessSP &process_sp, const lldb_private::FileSpec &outfile, lldb_private::Status &error)
Definition: WindowsMiniDump.cpp:23
ObjectFilePECOFF.h
PluginManager.h
lldb_private::Address::SetOffset
bool SetOffset(lldb::addr_t offset)
Set accessor for the offset.
Definition: Address.h:425
lldb_private::Target::GetSectionLoadList
SectionLoadList & GetSectionLoadList()
Definition: Target.h:1034
lldb_private::ConstString::GetCString
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:216
lldb_private::ModuleSpec::GetArchitecture
ArchSpec & GetArchitecture()
Definition: ModuleSpec.h:94
ObjectFilePECOFF::MapSymbolType
static lldb::SymbolType MapSymbolType(uint16_t coff_symbol_type)
Definition: ObjectFilePECOFF.cpp:205
ObjectFilePECOFF::DumpDOSHeader
static void DumpDOSHeader(lldb_private::Stream *s, const dos_header_t &header)
Definition: ObjectFilePECOFF.cpp:1016
LLDB_LOG
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:242
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb::user_id_t
uint64_t user_id_t
Definition: lldb-types.h:84
ObjectFilePECOFF::coff_opt_header::major_os_system_version
uint16_t major_os_system_version
Definition: ObjectFilePECOFF.h:202
ObjectFilePECOFF::section_header::vmsize
uint32_t vmsize
Definition: ObjectFilePECOFF.h:232
ObjectFilePECOFF::export_directory_entry::name
uint32_t name
Definition: ObjectFilePECOFF.h:257
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::DataExtractor::GetU16
uint16_t GetU16(lldb::offset_t *offset_ptr) const
Extract a uint16_t value from *offset_ptr.
Definition: DataExtractor.cpp:349
lldb_private::DataExtractor::GetCStr
const char * GetCStr(lldb::offset_t *offset_ptr) const
Extract a C string from *offset_ptr.
Definition: DataExtractor.cpp:786
Error
llvm::Error Error
Definition: UdtRecordCompleter.cpp:29
ObjectFilePECOFF::coff_symbol::value
uint32_t value
Definition: ObjectFilePECOFF.h:245
ObjectFilePECOFF::dos_header::e_cs
uint16_t e_cs
Definition: ObjectFilePECOFF.h:163
ObjectFilePECOFF::coff_opt_header::stack_commit_size
uint64_t stack_commit_size
Definition: ObjectFilePECOFF.h:215
ObjectFilePECOFF::GetBaseAddress
lldb_private::Address GetBaseAddress() override
Returns base address of this object file.
Definition: ObjectFilePECOFF.cpp:968
ObjectFilePECOFF::dos_header::e_ovno
uint16_t e_ovno
Definition: ObjectFilePECOFF.h:165
ObjectFilePECOFF::GetPluginName
lldb_private::ConstString GetPluginName() override
Definition: ObjectFilePECOFF.cpp:1210
FileSpec.h
ObjectFilePECOFF::CalculateType
ObjectFile::Type CalculateType() override
The object file should be able to calculate its type by looking at its file header and possibly the s...
Definition: ObjectFilePECOFF.cpp:1197
lldb_private::FileSpec::GetDirectory
ConstString & GetDirectory()
Directory string get accessor.
Definition: FileSpec.cpp:335
ObjectFilePECOFF::coff_header::nsects
uint16_t nsects
Definition: ObjectFilePECOFF.h:175
lldb_private::Address::GetOffset
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition: Address.h:306
ObjectFilePECOFF::coff_opt_header::file_alignment
uint32_t file_alignment
Definition: ObjectFilePECOFF.h:201
ObjectFilePECOFF::GetSectionName
llvm::StringRef GetSectionName(const section_header_t &sect)
Definition: ObjectFilePECOFF.cpp:581
ObjectFilePECOFF::GetEntryPointAddress
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...
Definition: ObjectFilePECOFF.cpp:950
lldb_private::ModuleSpecList::GetSize
size_t GetSize() const
Definition: ModuleSpec.h:303
LLDB_PLUGIN_DEFINE
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
lldb_private::Log
Definition: Log.h:49
ObjectFilePECOFF::m_binary
std::unique_ptr< llvm::object::COFFObjectFile > m_binary
Definition: ObjectFilePECOFF.h:304
lldb_private::Stream::PutCString
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
lldb::eSectionTypeDWARFDebugMacInfo
@ eSectionTypeDWARFDebugMacInfo
Definition: lldb-enumerations.h:671
ObjectFilePECOFF::coff_opt_header::minor_subsystem_version
uint16_t minor_subsystem_version
Definition: ObjectFilePECOFF.h:207
lldb_private::FileSpec::GetPath
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:348
ObjectFilePECOFF::coff_opt_header::major_image_version
uint16_t major_image_version
Definition: ObjectFilePECOFF.h:204
ObjectFilePECOFF::coff_header::machine
uint16_t machine
Definition: ObjectFilePECOFF.h:174
ObjectFilePECOFF::data_directory
Definition: ObjectFilePECOFF.h:183
lldb::eByteOrderLittle
@ eByteOrderLittle
Definition: lldb-enumerations.h:142
ObjectFilePECOFF::dos_header::e_cblp
uint16_t e_cblp
Definition: ObjectFilePECOFF.h:153
lldb_private::ObjectFile::Strata
Strata
Definition: ObjectFile.h:85
ObjectFilePECOFF::coff_opt_header::data_offset
uint32_t data_offset
Definition: ObjectFilePECOFF.h:197
lldb_private::DataExtractor::ValidOffsetForDataOfSize
bool ValidOffsetForDataOfSize(lldb::offset_t offset, lldb::offset_t length) const
Test the availability of length bytes of data from offset.
Definition: DataExtractor.h:954
lldb
Definition: SBAddress.h:15
ObjectFilePECOFF::m_deps_filespec
llvm::Optional< lldb_private::FileSpecList > m_deps_filespec
Definition: ObjectFilePECOFF.h:303
LLDB_LOG_ERROR
#define LLDB_LOG_ERROR(log, error,...)
Definition: Log.h:265
lldb_private::FileSpec::GetFilename
ConstString & GetFilename()
Filename string get accessor.
Definition: FileSpec.cpp:341
lldb::eSectionTypeDWARFDebugLocLists
@ eSectionTypeDWARFDebugLocLists
DWARF v5 .debug_loclists.
Definition: lldb-enumerations.h:700
lldb::eSectionTypeGoSymtab
@ eSectionTypeGoSymtab
Definition: lldb-enumerations.h:691
lldb_private::ObjectFile
Definition: ObjectFile.h:58
DataBufferHeap.h
lldb_private::SectionList::FindSectionByID
lldb::SectionSP FindSectionByID(lldb::user_id_t sect_id) const
Definition: Section.cpp:506
ObjectFilePECOFF::GetRVA
uint32_t GetRVA(const lldb_private::Address &addr) const
Definition: ObjectFilePECOFF.cpp:495
lldb_private::ObjectFile::m_sections_up
std::unique_ptr< lldb_private::SectionList > m_sections_up
Definition: ObjectFile.h:709
ObjectFilePECOFF::ParseHeader
bool ParseHeader() override
Attempts to parse the object header.
Definition: ObjectFilePECOFF.cpp:268
ObjectFilePECOFF::coff_symbol::type
uint16_t type
Definition: ObjectFilePECOFF.h:247
ObjectFilePECOFF::IsWindowsSubsystem
bool IsWindowsSubsystem()
Definition: ObjectFilePECOFF.cpp:1160
ObjectFilePECOFF::section_header::name
char name[8]
Definition: ObjectFilePECOFF.h:231
lldb::ByteOrder
ByteOrder
Byte ordering definitions.
Definition: lldb-enumerations.h:138
ObjectFilePECOFF::section_header::nreloc
uint16_t nreloc
Definition: ObjectFilePECOFF.h:238
ObjectFilePECOFF::section_header::vmaddr
uint32_t vmaddr
Definition: ObjectFilePECOFF.h:233
ObjectFilePECOFF::GetSectionType
static lldb::SectionType GetSectionType(llvm::StringRef sect_name, const section_header_t &sect)
Definition: ObjectFilePECOFF.cpp:752
ObjectFilePECOFF::GetByteOrder
lldb::ByteOrder GetByteOrder() const override
Gets whether endian swapping should occur when extracting data from this object file.
Definition: ObjectFilePECOFF.cpp:324