X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fwindows-tdep.c;h=aa0adeba99b7a9358ba09e3a5a0db32e8a6ce8e8;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=ad65b1b40305ed3c8372399e282bf6bfbdea6510;hpb=7928d571c5f742a10d98b0de0ef85284c5959845;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/windows-tdep.c b/gdb/windows-tdep.c index ad65b1b403..aa0adeba99 100644 --- a/gdb/windows-tdep.c +++ b/gdb/windows-tdep.c @@ -34,57 +34,76 @@ #include "solib.h" #include "solib-target.h" #include "gdbcore.h" +#include "coff/internal.h" +#include "libcoff.h" +#include "solist.h" + +#define CYGWIN_DLL_NAME "cygwin1.dll" /* Windows signal numbers differ between MinGW flavors and between - those and Cygwin. The below enumeration was gleaned from the - respective headers; the ones marked with MinGW64/Cygwin are defined - only by MinGW64 and Cygwin, not by mingw.org's MinGW. FIXME: We - should really have distinct MinGW vs Cygwin OSABIs, and two - separate enums, selected at runtime. */ + those and Cygwin. The below enumerations were gleaned from the + respective headers. */ + +/* Signal numbers for the various MinGW flavors. The ones marked with + MinGW-w64 are defined by MinGW-w64, not by mingw.org's MinGW. */ enum - { - WINDOWS_SIGHUP = 1, /* MinGW64/Cygwin */ - WINDOWS_SIGINT = 2, - WINDOWS_SIGQUIT = 3, /* MinGW64/Cygwin */ - WINDOWS_SIGILL = 4, - WINDOWS_SIGTRAP = 5, /* MinGW64/Cygwin */ -#ifdef __CYGWIN__ - WINDOWS_SIGABRT = 6, -#else - WINDOWS_SIGIOT = 6, /* MinGW64 */ -#endif - WINDOWS_SIGEMT = 7, /* MinGW64/Cygwin */ - WINDOWS_SIGFPE = 8, - WINDOWS_SIGKILL = 9, /* MinGW64/Cygwin */ - WINDOWS_SIGBUS = 10, /* MinGW64/Cygwin */ - WINDOWS_SIGSEGV = 11, - WINDOWS_SIGSYS = 12, /* MinGW64/Cygwin */ - WINDOWS_SIGPIPE = 13,/* MinGW64/Cygwin */ - WINDOWS_SIGALRM = 14,/* MinGW64/Cygwin */ - WINDOWS_SIGTERM = 15, -#ifdef __CYGWIN__ - WINDOWS_SIGURG = 16, - WINDOWS_SIGSTOP = 17, - WINDOWS_SIGTSTP = 18, - WINDOWS_SIGCONT = 19, - WINDOWS_SIGCHLD = 20, - WINDOWS_SIGTTIN = 21, - WINDOWS_SIGTTOU = 22, - WINDOWS_SIGIO = 23, - WINDOWS_SIGXCPU = 24, - WINDOWS_SIGXFSZ = 25, - WINDOWS_SIGVTALRM = 26, - WINDOWS_SIGPROF = 27, - WINDOWS_SIGWINCH = 28, - WINDOWS_SIGLOST = 29, - WINDOWS_SIGUSR1 = 30, - WINDOWS_SIGUSR2 = 31 -#else - WINDOWS_SIGBREAK = 21, - WINDOWS_SIGABRT = 22 -#endif - }; +{ + WINDOWS_SIGHUP = 1, /* MinGW-w64 */ + WINDOWS_SIGINT = 2, + WINDOWS_SIGQUIT = 3, /* MinGW-w64 */ + WINDOWS_SIGILL = 4, + WINDOWS_SIGTRAP = 5, /* MinGW-w64 */ + WINDOWS_SIGIOT = 6, /* MinGW-w64 */ + WINDOWS_SIGEMT = 7, /* MinGW-w64 */ + WINDOWS_SIGFPE = 8, + WINDOWS_SIGKILL = 9, /* MinGW-w64 */ + WINDOWS_SIGBUS = 10, /* MinGW-w64 */ + WINDOWS_SIGSEGV = 11, + WINDOWS_SIGSYS = 12, /* MinGW-w64 */ + WINDOWS_SIGPIPE = 13, /* MinGW-w64 */ + WINDOWS_SIGALRM = 14, /* MinGW-w64 */ + WINDOWS_SIGTERM = 15, + WINDOWS_SIGBREAK = 21, + WINDOWS_SIGABRT = 22, +}; + +/* Signal numbers for Cygwin. */ + +enum +{ + CYGWIN_SIGHUP = 1, + CYGWIN_SIGINT = 2, + CYGWIN_SIGQUIT = 3, + CYGWIN_SIGILL = 4, + CYGWIN_SIGTRAP = 5, + CYGWIN_SIGABRT = 6, + CYGWIN_SIGEMT = 7, + CYGWIN_SIGFPE = 8, + CYGWIN_SIGKILL = 9, + CYGWIN_SIGBUS = 10, + CYGWIN_SIGSEGV = 11, + CYGWIN_SIGSYS = 12, + CYGWIN_SIGPIPE = 13, + CYGWIN_SIGALRM = 14, + CYGWIN_SIGTERM = 15, + CYGWIN_SIGURG = 16, + CYGWIN_SIGSTOP = 17, + CYGWIN_SIGTSTP = 18, + CYGWIN_SIGCONT = 19, + CYGWIN_SIGCHLD = 20, + CYGWIN_SIGTTIN = 21, + CYGWIN_SIGTTOU = 22, + CYGWIN_SIGIO = 23, + CYGWIN_SIGXCPU = 24, + CYGWIN_SIGXFSZ = 25, + CYGWIN_SIGVTALRM = 26, + CYGWIN_SIGPROF = 27, + CYGWIN_SIGWINCH = 28, + CYGWIN_SIGLOST = 29, + CYGWIN_SIGUSR1 = 30, + CYGWIN_SIGUSR2 = 31, +}; struct cmd_list_element *info_w32_cmdlist; @@ -158,6 +177,7 @@ static struct gdbarch_data *windows_gdbarch_data_handle; struct windows_gdbarch_data { struct type *siginfo_type; + struct type *tib_ptr_type; /* Type of thread information block */ }; /* Allocate windows_gdbarch_data for an arch. */ @@ -182,8 +202,6 @@ get_windows_gdbarch_data (struct gdbarch *gdbarch) static struct type * windows_get_tlb_type (struct gdbarch *gdbarch) { - static struct gdbarch *last_gdbarch = NULL; - static struct type *last_tlb_type = NULL; struct type *dword_ptr_type, *dword32_type, *void_ptr_type; struct type *peb_ldr_type, *peb_ldr_ptr_type; struct type *peb_type, *peb_ptr_type, *list_type; @@ -192,10 +210,11 @@ windows_get_tlb_type (struct gdbarch *gdbarch) struct type *word_type, *wchar_type, *wchar_ptr_type; struct type *uni_str_type, *rupp_type, *rupp_ptr_type; - /* Do not rebuild type if same gdbarch as last time. */ - if (last_tlb_type && last_gdbarch == gdbarch) - return last_tlb_type; - + windows_gdbarch_data *windows_gdbarch_data + = get_windows_gdbarch_data (gdbarch); + if (windows_gdbarch_data->tib_ptr_type != nullptr) + return windows_gdbarch_data->tib_ptr_type; + dword_ptr_type = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "DWORD_PTR"); dword32_type = arch_integer_type (gdbarch, 32, @@ -211,7 +230,7 @@ windows_get_tlb_type (struct gdbarch *gdbarch) /* list entry */ list_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); - TYPE_NAME (list_type) = xstrdup ("list"); + list_type->set_name (xstrdup ("list")); module_list_ptr_type = void_ptr_type; @@ -223,7 +242,7 @@ windows_get_tlb_type (struct gdbarch *gdbarch) /* Structured Exception Handler */ seh_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); - TYPE_NAME (seh_type) = xstrdup ("seh"); + seh_type->set_name (xstrdup ("seh")); seh_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR, TYPE_LENGTH (void_ptr_type) * TARGET_CHAR_BIT, @@ -236,7 +255,7 @@ windows_get_tlb_type (struct gdbarch *gdbarch) /* struct _PEB_LDR_DATA */ peb_ldr_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); - TYPE_NAME (peb_ldr_type) = xstrdup ("peb_ldr_data"); + peb_ldr_type->set_name (xstrdup ("peb_ldr_data")); append_composite_type_field (peb_ldr_type, "length", dword32_type); append_composite_type_field (peb_ldr_type, "initialized", dword32_type); @@ -305,7 +324,7 @@ windows_get_tlb_type (struct gdbarch *gdbarch) /* struct process environment block */ peb_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); - TYPE_NAME (peb_type) = xstrdup ("peb"); + peb_type->set_name (xstrdup ("peb")); /* First bytes contain several flags. */ append_composite_type_field (peb_type, "flags", dword_ptr_type); @@ -324,7 +343,7 @@ windows_get_tlb_type (struct gdbarch *gdbarch) /* struct thread information block */ tib_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); - TYPE_NAME (tib_type) = xstrdup ("tib"); + tib_type->set_name (xstrdup ("tib")); /* uint32_t current_seh; %fs:0x0000 */ append_composite_type_field (tib_type, "current_seh", seh_ptr_type); @@ -365,8 +384,7 @@ windows_get_tlb_type (struct gdbarch *gdbarch) NULL); TYPE_TARGET_TYPE (tib_ptr_type) = tib_type; - last_tlb_type = tib_ptr_type; - last_gdbarch = gdbarch; + windows_gdbarch_data->tib_ptr_type = tib_ptr_type; return tib_ptr_type; } @@ -519,7 +537,7 @@ windows_xfer_shared_library (const char* so_name, CORE_ADDR load_addr, if (!text_offset) { - gdb_bfd_ref_ptr dll (gdb_bfd_open (so_name, gnutarget, -1)); + gdb_bfd_ref_ptr dll (gdb_bfd_open (so_name, gnutarget)); /* The following calls are OK even if dll is NULL. The default value 0x1000 is returned by pe_text_section_offset in that case. */ @@ -584,11 +602,6 @@ show_maint_show_all_tib (struct ui_file *file, int from_tty, "Thread Information Block is %s.\n"), value); } -static void -info_w32_command (const char *args, int from_tty) -{ - help_list (info_w32_cmdlist, "info w32 ", class_info, gdb_stdout); -} static int w32_prefix_command_valid = 0; void @@ -596,14 +609,15 @@ init_w32_command_list (void) { if (!w32_prefix_command_valid) { - add_prefix_cmd ("w32", class_info, info_w32_command, - _("Print information specific to Win32 debugging."), - &info_w32_cmdlist, "info w32 ", 0, &infolist); + add_basic_prefix_cmd + ("w32", class_info, + _("Print information specific to Win32 debugging."), + &info_w32_cmdlist, "info w32 ", 0, &infolist); w32_prefix_command_valid = 1; } } -/* Implementation of `gdbarch_gdb_signal_to_target'. */ +/* Implementation of `gdbarch_gdb_signal_to_target' for Windows. */ static int windows_gdb_signal_to_target (struct gdbarch *gdbarch, enum gdb_signal signal) @@ -642,44 +656,152 @@ windows_gdb_signal_to_target (struct gdbarch *gdbarch, enum gdb_signal signal) return WINDOWS_SIGALRM; case GDB_SIGNAL_TERM: return WINDOWS_SIGTERM; -#ifdef __CYGWIN__ + } + return -1; +} + +/* Implementation of `gdbarch_gdb_signal_to_target' for Cygwin. */ + +static int +cygwin_gdb_signal_to_target (struct gdbarch *gdbarch, enum gdb_signal signal) +{ + switch (signal) + { + case GDB_SIGNAL_0: + return 0; + case GDB_SIGNAL_HUP: + return CYGWIN_SIGHUP; + case GDB_SIGNAL_INT: + return CYGWIN_SIGINT; + case GDB_SIGNAL_QUIT: + return CYGWIN_SIGQUIT; + case GDB_SIGNAL_ILL: + return CYGWIN_SIGILL; + case GDB_SIGNAL_TRAP: + return CYGWIN_SIGTRAP; + case GDB_SIGNAL_ABRT: + return CYGWIN_SIGABRT; + case GDB_SIGNAL_EMT: + return CYGWIN_SIGEMT; + case GDB_SIGNAL_FPE: + return CYGWIN_SIGFPE; + case GDB_SIGNAL_KILL: + return CYGWIN_SIGKILL; + case GDB_SIGNAL_BUS: + return CYGWIN_SIGBUS; + case GDB_SIGNAL_SEGV: + return CYGWIN_SIGSEGV; + case GDB_SIGNAL_SYS: + return CYGWIN_SIGSYS; + case GDB_SIGNAL_PIPE: + return CYGWIN_SIGPIPE; + case GDB_SIGNAL_ALRM: + return CYGWIN_SIGALRM; + case GDB_SIGNAL_TERM: + return CYGWIN_SIGTERM; case GDB_SIGNAL_URG: - return WINDOWS_SIGURG; + return CYGWIN_SIGURG; case GDB_SIGNAL_STOP: - return WINDOWS_SIGSTOP; + return CYGWIN_SIGSTOP; case GDB_SIGNAL_TSTP: - return WINDOWS_SIGTSTP; + return CYGWIN_SIGTSTP; case GDB_SIGNAL_CONT: - return WINDOWS_SIGCONT; + return CYGWIN_SIGCONT; case GDB_SIGNAL_CHLD: - return WINDOWS_SIGCHLD; + return CYGWIN_SIGCHLD; case GDB_SIGNAL_TTIN: - return WINDOWS_SIGTTIN; + return CYGWIN_SIGTTIN; case GDB_SIGNAL_TTOU: - return WINDOWS_SIGTTOU; + return CYGWIN_SIGTTOU; case GDB_SIGNAL_IO: - return WINDOWS_SIGIO; + return CYGWIN_SIGIO; case GDB_SIGNAL_XCPU: - return WINDOWS_SIGXCPU; + return CYGWIN_SIGXCPU; case GDB_SIGNAL_XFSZ: - return WINDOWS_SIGXFSZ; + return CYGWIN_SIGXFSZ; case GDB_SIGNAL_VTALRM: - return WINDOWS_SIGVTALRM; + return CYGWIN_SIGVTALRM; case GDB_SIGNAL_PROF: - return WINDOWS_SIGPROF; + return CYGWIN_SIGPROF; case GDB_SIGNAL_WINCH: - return WINDOWS_SIGWINCH; + return CYGWIN_SIGWINCH; case GDB_SIGNAL_PWR: - return WINDOWS_SIGLOST; + return CYGWIN_SIGLOST; case GDB_SIGNAL_USR1: - return WINDOWS_SIGUSR1; + return CYGWIN_SIGUSR1; case GDB_SIGNAL_USR2: - return WINDOWS_SIGUSR2; -#endif /* __CYGWIN__ */ + return CYGWIN_SIGUSR2; } return -1; } +struct enum_value_name +{ + uint32_t value; + const char *name; +}; + +/* Allocate a TYPE_CODE_ENUM type structure with its named values. */ + +static struct type * +create_enum (struct gdbarch *gdbarch, int bit, const char *name, + const struct enum_value_name *values, int count) +{ + struct type *type; + int i; + + type = arch_type (gdbarch, TYPE_CODE_ENUM, bit, name); + type->set_num_fields (count); + type->set_fields + ((struct field *) TYPE_ZALLOC (type, sizeof (struct field) * count)); + TYPE_UNSIGNED (type) = 1; + + for (i = 0; i < count; i++) + { + TYPE_FIELD_NAME (type, i) = values[i].name; + SET_FIELD_ENUMVAL (type->field (i), values[i].value); + } + + return type; +} + +static const struct enum_value_name exception_values[] = +{ + { 0x40000015, "FATAL_APP_EXIT" }, + { 0x4000001E, "WX86_SINGLE_STEP" }, + { 0x4000001F, "WX86_BREAKPOINT" }, + { 0x40010005, "DBG_CONTROL_C" }, + { 0x40010008, "DBG_CONTROL_BREAK" }, + { 0x80000002, "DATATYPE_MISALIGNMENT" }, + { 0x80000003, "BREAKPOINT" }, + { 0x80000004, "SINGLE_STEP" }, + { 0xC0000005, "ACCESS_VIOLATION" }, + { 0xC0000006, "IN_PAGE_ERROR" }, + { 0xC000001D, "ILLEGAL_INSTRUCTION" }, + { 0xC0000025, "NONCONTINUABLE_EXCEPTION" }, + { 0xC0000026, "INVALID_DISPOSITION" }, + { 0xC000008C, "ARRAY_BOUNDS_EXCEEDED" }, + { 0xC000008D, "FLOAT_DENORMAL_OPERAND" }, + { 0xC000008E, "FLOAT_DIVIDE_BY_ZERO" }, + { 0xC000008F, "FLOAT_INEXACT_RESULT" }, + { 0xC0000090, "FLOAT_INVALID_OPERATION" }, + { 0xC0000091, "FLOAT_OVERFLOW" }, + { 0xC0000092, "FLOAT_STACK_CHECK" }, + { 0xC0000093, "FLOAT_UNDERFLOW" }, + { 0xC0000094, "INTEGER_DIVIDE_BY_ZERO" }, + { 0xC0000095, "INTEGER_OVERFLOW" }, + { 0xC0000096, "PRIV_INSTRUCTION" }, + { 0xC00000FD, "STACK_OVERFLOW" }, + { 0xC0000409, "FAST_FAIL" }, +}; + +static const struct enum_value_name violation_values[] = +{ + { 0, "READ_ACCESS_VIOLATION" }, + { 1, "WRITE_ACCESS_VIOLATION" }, + { 8, "DATA_EXECUTION_PREVENTION_VIOLATION" }, +}; + /* Implement the "get_siginfo_type" gdbarch method. */ static struct type * @@ -687,7 +809,8 @@ windows_get_siginfo_type (struct gdbarch *gdbarch) { struct windows_gdbarch_data *windows_gdbarch_data; struct type *dword_type, *pvoid_type, *ulongptr_type; - struct type *siginfo_ptr_type, *siginfo_type; + struct type *code_enum, *violation_enum; + struct type *violation_type, *para_type, *siginfo_ptr_type, *siginfo_type; windows_gdbarch_data = get_windows_gdbarch_data (gdbarch); if (windows_gdbarch_data->siginfo_type != NULL) @@ -700,12 +823,38 @@ windows_get_siginfo_type (struct gdbarch *gdbarch) ulongptr_type = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "ULONG_PTR"); + /* ExceptionCode value names */ + code_enum = create_enum (gdbarch, gdbarch_int_bit (gdbarch), + "ExceptionCode", exception_values, + ARRAY_SIZE (exception_values)); + + /* ACCESS_VIOLATION type names */ + violation_enum = create_enum (gdbarch, gdbarch_ptr_bit (gdbarch), + "ViolationType", violation_values, + ARRAY_SIZE (violation_values)); + + /* ACCESS_VIOLATION information */ + violation_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); + append_composite_type_field (violation_type, "Type", violation_enum); + append_composite_type_field (violation_type, "Address", pvoid_type); + + /* Unnamed union of the documented field ExceptionInformation, + and the alternative AccessViolationInformation (which displays + human-readable values for ExceptionCode ACCESS_VIOLATION). */ + para_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION); + append_composite_type_field (para_type, "ExceptionInformation", + lookup_array_range_type (ulongptr_type, 0, 14)); + append_composite_type_field (para_type, "AccessViolationInformation", + violation_type); + siginfo_type = arch_composite_type (gdbarch, "EXCEPTION_RECORD", TYPE_CODE_STRUCT); siginfo_ptr_type = arch_pointer_type (gdbarch, gdbarch_ptr_bit (gdbarch), NULL, siginfo_type); - append_composite_type_field (siginfo_type, "ExceptionCode", dword_type); + /* ExceptionCode is documented as type DWORD, but here a helper + enum type is used instead to display a human-readable value. */ + append_composite_type_field (siginfo_type, "ExceptionCode", code_enum); append_composite_type_field (siginfo_type, "ExceptionFlags", dword_type); append_composite_type_field (siginfo_type, "ExceptionRecord", siginfo_ptr_type); @@ -713,21 +862,67 @@ windows_get_siginfo_type (struct gdbarch *gdbarch) pvoid_type); append_composite_type_field (siginfo_type, "NumberParameters", dword_type); /* The 64-bit variant needs some padding. */ - append_composite_type_field_aligned (siginfo_type, "ExceptionInformation", - lookup_array_range_type (ulongptr_type, - 0, 14), - TYPE_LENGTH (ulongptr_type)); + append_composite_type_field_aligned (siginfo_type, "", + para_type, TYPE_LENGTH (ulongptr_type)); windows_gdbarch_data->siginfo_type = siginfo_type; return siginfo_type; } -/* To be called from the various GDB_OSABI_CYGWIN handlers for the - various Windows architectures and machine types. */ +/* Implement the "solib_create_inferior_hook" target_so_ops method. */ -void -windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) +static void +windows_solib_create_inferior_hook (int from_tty) +{ + CORE_ADDR exec_base = 0; + + /* Find base address of main executable in + TIB->process_environment_block->image_base_address. */ + struct gdbarch *gdbarch = target_gdbarch (); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + int ptr_bytes; + int peb_offset; /* Offset of process_environment_block in TIB. */ + int base_offset; /* Offset of image_base_address in PEB. */ + if (gdbarch_ptr_bit (gdbarch) == 32) + { + ptr_bytes = 4; + peb_offset = 48; + base_offset = 8; + } + else + { + ptr_bytes = 8; + peb_offset = 96; + base_offset = 16; + } + CORE_ADDR tlb; + gdb_byte buf[8]; + if (target_has_execution + && target_get_tib_address (inferior_ptid, &tlb) + && !target_read_memory (tlb + peb_offset, buf, ptr_bytes)) + { + CORE_ADDR peb = extract_unsigned_integer (buf, ptr_bytes, byte_order); + if (!target_read_memory (peb + base_offset, buf, ptr_bytes)) + exec_base = extract_unsigned_integer (buf, ptr_bytes, byte_order); + } + + /* Rebase executable if the base address changed because of ASLR. */ + if (symfile_objfile != nullptr && exec_base != 0) + { + CORE_ADDR vmaddr = pe_data (exec_bfd)->pe_opthdr.ImageBase; + if (vmaddr != exec_base) + objfile_rebase (symfile_objfile, exec_base - vmaddr); + } +} + +static struct target_so_ops windows_so_ops; + +/* Common parts for gdbarch initialization for the Windows and Cygwin OS + ABIs. */ + +static void +windows_init_abi_common (struct gdbarch_info info, struct gdbarch *gdbarch) { set_gdbarch_wchar_bit (gdbarch, 16); set_gdbarch_wchar_signed (gdbarch, 0); @@ -739,11 +934,29 @@ windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) set_gdbarch_iterate_over_objfiles_in_search_order (gdbarch, windows_iterate_over_objfiles_in_search_order); + windows_so_ops = solib_target_so_ops; + windows_so_ops.solib_create_inferior_hook + = windows_solib_create_inferior_hook; + set_solib_ops (gdbarch, &windows_so_ops); + + set_gdbarch_get_siginfo_type (gdbarch, windows_get_siginfo_type); +} + +/* See windows-tdep.h. */ +void +windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) +{ + windows_init_abi_common (info, gdbarch); set_gdbarch_gdb_signal_to_target (gdbarch, windows_gdb_signal_to_target); +} - set_solib_ops (gdbarch, &solib_target_so_ops); +/* See windows-tdep.h. */ - set_gdbarch_get_siginfo_type (gdbarch, windows_get_siginfo_type); +void +cygwin_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) +{ + windows_init_abi_common (info, gdbarch); + set_gdbarch_gdb_signal_to_target (gdbarch, cygwin_gdb_signal_to_target); } /* Implementation of `tlb' variable. */ @@ -755,6 +968,126 @@ static const struct internalvar_funcs tlb_funcs = NULL }; +/* Layout of an element of a PE's Import Directory Table. Based on: + + https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#import-directory-table + */ + +struct pe_import_directory_entry +{ + uint32_t import_lookup_table_rva; + uint32_t timestamp; + uint32_t forwarder_chain; + uint32_t name_rva; + uint32_t import_address_table_rva; +}; + +gdb_static_assert (sizeof (pe_import_directory_entry) == 20); + +/* See windows-tdep.h. */ + +bool +is_linked_with_cygwin_dll (bfd *abfd) +{ + /* The list of DLLs a PE is linked to is in the .idata section. See: + + https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#the-idata-section + */ + asection *idata_section = bfd_get_section_by_name (abfd, ".idata"); + if (idata_section == nullptr) + return false; + + bfd_size_type idata_section_size = bfd_section_size (idata_section); + internal_extra_pe_aouthdr *pe_extra = &pe_data (abfd)->pe_opthdr; + bfd_vma import_table_va = pe_extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress; + bfd_vma idata_section_va = bfd_section_vma (idata_section); + + /* The section's virtual address as reported by BFD has the image base applied, + remove it. */ + gdb_assert (idata_section_va >= pe_extra->ImageBase); + idata_section_va -= pe_extra->ImageBase; + + bfd_vma idata_section_end_va = idata_section_va + idata_section_size; + + /* Make sure that the import table is indeed within the .idata section's range. */ + if (import_table_va < idata_section_va + || import_table_va >= idata_section_end_va) + { + warning (_("\ +%s: import table's virtual address (0x%" BFD_VMA_FMT "x) is outside .idata \ +section's range [0x%" BFD_VMA_FMT "x, 0x%" BFD_VMA_FMT "x[."), + bfd_get_filename (abfd), import_table_va, idata_section_va, + idata_section_end_va); + return false; + } + + /* The import table starts at this offset into the .idata section. */ + bfd_vma import_table_offset_in_sect = import_table_va - idata_section_va; + + /* Get the section's data. */ + gdb::byte_vector idata_contents; + if (!gdb_bfd_get_full_section_contents (abfd, idata_section, &idata_contents)) + { + warning (_("%s: failed to get contents of .idata section."), + bfd_get_filename (abfd)); + return false; + } + + gdb_assert (idata_contents.size () == idata_section_size); + + const gdb_byte *iter = idata_contents.data () + import_table_offset_in_sect; + const gdb_byte *end = idata_contents.data () + idata_section_size; + const pe_import_directory_entry null_dir_entry = { 0 }; + + /* Iterate through all directory entries. */ + while (true) + { + /* Is there enough space left in the section for another entry? */ + if (iter + sizeof (pe_import_directory_entry) > end) + { + warning (_("%s: unexpected end of .idata section."), + bfd_get_filename (abfd)); + break; + } + + pe_import_directory_entry *dir_entry = (pe_import_directory_entry *) iter; + + /* Is it the end of list marker? */ + if (memcmp (dir_entry, &null_dir_entry, + sizeof (pe_import_directory_entry)) == 0) + break; + + bfd_vma name_va = dir_entry->name_rva; + + /* If the name's virtual address is smaller than the section's virtual + address, there's a problem. */ + if (name_va < idata_section_va || name_va >= idata_section_end_va) + { + warning (_("\ +%s: name's virtual address (0x%" BFD_VMA_FMT "x) is outside .idata section's \ +range [0x%" BFD_VMA_FMT "x, 0x%" BFD_VMA_FMT "x[."), + bfd_get_filename (abfd), name_va, idata_section_va, + idata_section_end_va); + break; + } + + const gdb_byte *name = &idata_contents[name_va - idata_section_va]; + + /* Make sure we don't overshoot the end of the section with the + streq. */ + if (name + sizeof (CYGWIN_DLL_NAME) <= end) + { + /* Finally, check if this is the dll name we are looking for. */ + if (streq ((const char *) name, CYGWIN_DLL_NAME)) + return true; + } + + iter += sizeof (pe_import_directory_entry); + } + + return false; +} + void _initialize_windows_tdep (); void _initialize_windows_tdep ()