1 /* Copyright (C) 2008-2022 Free Software Foundation, Inc.
3 This file is part of GDB.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 #include "windows-tdep.h"
20 #include "gdbsupport/gdb_obstack.h"
21 #include "xml-support.h"
28 #include "gdbthread.h"
31 #include "coff-pe-read.h"
34 #include "solib-target.h"
36 #include "coff/internal.h"
40 #define CYGWIN_DLL_NAME "cygwin1.dll"
42 /* Windows signal numbers differ between MinGW flavors and between
43 those and Cygwin. The below enumerations were gleaned from the
44 respective headers. */
46 /* Signal numbers for the various MinGW flavors. The ones marked with
47 MinGW-w64 are defined by MinGW-w64, not by mingw.org's MinGW. */
51 WINDOWS_SIGHUP
= 1, /* MinGW-w64 */
53 WINDOWS_SIGQUIT
= 3, /* MinGW-w64 */
55 WINDOWS_SIGTRAP
= 5, /* MinGW-w64 */
56 WINDOWS_SIGIOT
= 6, /* MinGW-w64 */
57 WINDOWS_SIGEMT
= 7, /* MinGW-w64 */
59 WINDOWS_SIGKILL
= 9, /* MinGW-w64 */
60 WINDOWS_SIGBUS
= 10, /* MinGW-w64 */
62 WINDOWS_SIGSYS
= 12, /* MinGW-w64 */
63 WINDOWS_SIGPIPE
= 13, /* MinGW-w64 */
64 WINDOWS_SIGALRM
= 14, /* MinGW-w64 */
66 WINDOWS_SIGBREAK
= 21,
70 /* Signal numbers for Cygwin. */
99 CYGWIN_SIGVTALRM
= 26,
101 CYGWIN_SIGWINCH
= 28,
107 /* These constants are defined by Cygwin's core_dump.h */
108 static constexpr unsigned int NOTE_INFO_MODULE
= 3;
109 static constexpr unsigned int NOTE_INFO_MODULE64
= 4;
111 struct cmd_list_element
*info_w32_cmdlist
;
113 typedef struct thread_information_block_32
115 uint32_t current_seh
; /* %fs:0x0000 */
116 uint32_t current_top_of_stack
; /* %fs:0x0004 */
117 uint32_t current_bottom_of_stack
; /* %fs:0x0008 */
118 uint32_t sub_system_tib
; /* %fs:0x000c */
119 uint32_t fiber_data
; /* %fs:0x0010 */
120 uint32_t arbitrary_data_slot
; /* %fs:0x0014 */
121 uint32_t linear_address_tib
; /* %fs:0x0018 */
122 uint32_t environment_pointer
; /* %fs:0x001c */
123 uint32_t process_id
; /* %fs:0x0020 */
124 uint32_t current_thread_id
; /* %fs:0x0024 */
125 uint32_t active_rpc_handle
; /* %fs:0x0028 */
126 uint32_t thread_local_storage
; /* %fs:0x002c */
127 uint32_t process_environment_block
; /* %fs:0x0030 */
128 uint32_t last_error_number
; /* %fs:0x0034 */
130 thread_information_32
;
132 typedef struct thread_information_block_64
134 uint64_t current_seh
; /* %gs:0x0000 */
135 uint64_t current_top_of_stack
; /* %gs:0x0008 */
136 uint64_t current_bottom_of_stack
; /* %gs:0x0010 */
137 uint64_t sub_system_tib
; /* %gs:0x0018 */
138 uint64_t fiber_data
; /* %gs:0x0020 */
139 uint64_t arbitrary_data_slot
; /* %gs:0x0028 */
140 uint64_t linear_address_tib
; /* %gs:0x0030 */
141 uint64_t environment_pointer
; /* %gs:0x0038 */
142 uint64_t process_id
; /* %gs:0x0040 */
143 uint64_t current_thread_id
; /* %gs:0x0048 */
144 uint64_t active_rpc_handle
; /* %gs:0x0050 */
145 uint64_t thread_local_storage
; /* %gs:0x0058 */
146 uint64_t process_environment_block
; /* %gs:0x0060 */
147 uint64_t last_error_number
; /* %gs:0x0068 */
149 thread_information_64
;
152 static const char* TIB_NAME
[] =
154 " current_seh ", /* %fs:0x0000 */
155 " current_top_of_stack ", /* %fs:0x0004 */
156 " current_bottom_of_stack ", /* %fs:0x0008 */
157 " sub_system_tib ", /* %fs:0x000c */
158 " fiber_data ", /* %fs:0x0010 */
159 " arbitrary_data_slot ", /* %fs:0x0014 */
160 " linear_address_tib ", /* %fs:0x0018 */
161 " environment_pointer ", /* %fs:0x001c */
162 " process_id ", /* %fs:0x0020 */
163 " current_thread_id ", /* %fs:0x0024 */
164 " active_rpc_handle ", /* %fs:0x0028 */
165 " thread_local_storage ", /* %fs:0x002c */
166 " process_environment_block ", /* %fs:0x0030 */
167 " last_error_number " /* %fs:0x0034 */
170 static const int MAX_TIB32
=
171 sizeof (thread_information_32
) / sizeof (uint32_t);
172 static const int MAX_TIB64
=
173 sizeof (thread_information_64
) / sizeof (uint64_t);
174 static const int FULL_TIB_SIZE
= 0x1000;
176 static bool maint_display_all_tib
= false;
178 struct windows_gdbarch_data
180 struct type
*siginfo_type
= nullptr;
181 /* Type of thread information block. */
182 struct type
*tib_ptr_type
= nullptr;
185 static const registry
<gdbarch
>::key
<windows_gdbarch_data
>
186 windows_gdbarch_data_handle
;
188 /* Get windows_gdbarch_data of an arch. */
190 static struct windows_gdbarch_data
*
191 get_windows_gdbarch_data (struct gdbarch
*gdbarch
)
193 windows_gdbarch_data
*result
= windows_gdbarch_data_handle
.get (gdbarch
);
194 if (result
== nullptr)
195 result
= windows_gdbarch_data_handle
.emplace (gdbarch
);
199 /* Define Thread Local Base pointer type. */
202 windows_get_tlb_type (struct gdbarch
*gdbarch
)
204 struct type
*dword_ptr_type
, *dword32_type
, *void_ptr_type
;
205 struct type
*peb_ldr_type
, *peb_ldr_ptr_type
;
206 struct type
*peb_type
, *peb_ptr_type
, *list_type
;
207 struct type
*module_list_ptr_type
;
208 struct type
*tib_type
, *seh_type
, *tib_ptr_type
, *seh_ptr_type
;
209 struct type
*word_type
, *wchar_type
, *wchar_ptr_type
;
210 struct type
*uni_str_type
, *rupp_type
, *rupp_ptr_type
;
212 windows_gdbarch_data
*windows_gdbarch_data
213 = get_windows_gdbarch_data (gdbarch
);
214 if (windows_gdbarch_data
->tib_ptr_type
!= nullptr)
215 return windows_gdbarch_data
->tib_ptr_type
;
217 dword_ptr_type
= arch_integer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
),
219 dword32_type
= arch_integer_type (gdbarch
, 32,
221 word_type
= arch_integer_type (gdbarch
, 16,
223 wchar_type
= arch_integer_type (gdbarch
, 16,
225 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
226 wchar_ptr_type
= arch_pointer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
),
231 list_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
232 list_type
->set_name (xstrdup ("list"));
234 module_list_ptr_type
= void_ptr_type
;
236 append_composite_type_field (list_type
, "forward_list",
237 module_list_ptr_type
);
238 append_composite_type_field (list_type
, "backward_list",
239 module_list_ptr_type
);
241 /* Structured Exception Handler */
243 seh_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
244 seh_type
->set_name (xstrdup ("seh"));
246 seh_ptr_type
= arch_type (gdbarch
, TYPE_CODE_PTR
,
247 void_ptr_type
->length () * TARGET_CHAR_BIT
,
249 seh_ptr_type
->set_target_type (seh_type
);
251 append_composite_type_field (seh_type
, "next_seh", seh_ptr_type
);
252 append_composite_type_field (seh_type
, "handler",
253 builtin_type (gdbarch
)->builtin_func_ptr
);
255 /* struct _PEB_LDR_DATA */
256 peb_ldr_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
257 peb_ldr_type
->set_name (xstrdup ("peb_ldr_data"));
259 append_composite_type_field (peb_ldr_type
, "length", dword32_type
);
260 append_composite_type_field (peb_ldr_type
, "initialized", dword32_type
);
261 append_composite_type_field (peb_ldr_type
, "ss_handle", void_ptr_type
);
262 append_composite_type_field (peb_ldr_type
, "in_load_order", list_type
);
263 append_composite_type_field (peb_ldr_type
, "in_memory_order", list_type
);
264 append_composite_type_field (peb_ldr_type
, "in_init_order", list_type
);
265 append_composite_type_field (peb_ldr_type
, "entry_in_progress",
267 peb_ldr_ptr_type
= arch_type (gdbarch
, TYPE_CODE_PTR
,
268 void_ptr_type
->length () * TARGET_CHAR_BIT
,
270 peb_ldr_ptr_type
->set_target_type (peb_ldr_type
);
272 /* struct UNICODE_STRING */
273 uni_str_type
= arch_composite_type (gdbarch
, "unicode_string",
276 append_composite_type_field (uni_str_type
, "length", word_type
);
277 append_composite_type_field (uni_str_type
, "maximum_length", word_type
);
278 append_composite_type_field_aligned (uni_str_type
, "buffer",
280 wchar_ptr_type
->length ());
282 /* struct _RTL_USER_PROCESS_PARAMETERS */
283 rupp_type
= arch_composite_type (gdbarch
, "rtl_user_process_parameters",
286 append_composite_type_field (rupp_type
, "maximum_length", dword32_type
);
287 append_composite_type_field (rupp_type
, "length", dword32_type
);
288 append_composite_type_field (rupp_type
, "flags", dword32_type
);
289 append_composite_type_field (rupp_type
, "debug_flags", dword32_type
);
290 append_composite_type_field (rupp_type
, "console_handle", void_ptr_type
);
291 append_composite_type_field (rupp_type
, "console_flags", dword32_type
);
292 append_composite_type_field_aligned (rupp_type
, "standard_input",
294 void_ptr_type
->length ());
295 append_composite_type_field (rupp_type
, "standard_output", void_ptr_type
);
296 append_composite_type_field (rupp_type
, "standard_error", void_ptr_type
);
297 append_composite_type_field (rupp_type
, "current_directory", uni_str_type
);
298 append_composite_type_field (rupp_type
, "current_directory_handle",
300 append_composite_type_field (rupp_type
, "dll_path", uni_str_type
);
301 append_composite_type_field (rupp_type
, "image_path_name", uni_str_type
);
302 append_composite_type_field (rupp_type
, "command_line", uni_str_type
);
303 append_composite_type_field (rupp_type
, "environment", void_ptr_type
);
304 append_composite_type_field (rupp_type
, "starting_x", dword32_type
);
305 append_composite_type_field (rupp_type
, "starting_y", dword32_type
);
306 append_composite_type_field (rupp_type
, "count_x", dword32_type
);
307 append_composite_type_field (rupp_type
, "count_y", dword32_type
);
308 append_composite_type_field (rupp_type
, "count_chars_x", dword32_type
);
309 append_composite_type_field (rupp_type
, "count_chars_y", dword32_type
);
310 append_composite_type_field (rupp_type
, "fill_attribute", dword32_type
);
311 append_composite_type_field (rupp_type
, "window_flags", dword32_type
);
312 append_composite_type_field (rupp_type
, "show_window_flags", dword32_type
);
313 append_composite_type_field_aligned (rupp_type
, "window_title",
315 void_ptr_type
->length ());
316 append_composite_type_field (rupp_type
, "desktop_info", uni_str_type
);
317 append_composite_type_field (rupp_type
, "shell_info", uni_str_type
);
318 append_composite_type_field (rupp_type
, "runtime_data", uni_str_type
);
320 rupp_ptr_type
= arch_pointer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
),
324 /* struct process environment block */
325 peb_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
326 peb_type
->set_name (xstrdup ("peb"));
328 /* First bytes contain several flags. */
329 append_composite_type_field (peb_type
, "flags", dword_ptr_type
);
330 append_composite_type_field (peb_type
, "mutant", void_ptr_type
);
331 append_composite_type_field (peb_type
, "image_base_address", void_ptr_type
);
332 append_composite_type_field (peb_type
, "ldr", peb_ldr_ptr_type
);
333 append_composite_type_field (peb_type
, "process_parameters", rupp_ptr_type
);
334 append_composite_type_field (peb_type
, "sub_system_data", void_ptr_type
);
335 append_composite_type_field (peb_type
, "process_heap", void_ptr_type
);
336 append_composite_type_field (peb_type
, "fast_peb_lock", void_ptr_type
);
337 peb_ptr_type
= arch_type (gdbarch
, TYPE_CODE_PTR
,
338 void_ptr_type
->length () * TARGET_CHAR_BIT
,
340 peb_ptr_type
->set_target_type (peb_type
);
343 /* struct thread information block */
344 tib_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
345 tib_type
->set_name (xstrdup ("tib"));
347 /* uint32_t current_seh; %fs:0x0000 */
348 append_composite_type_field (tib_type
, "current_seh", seh_ptr_type
);
349 /* uint32_t current_top_of_stack; %fs:0x0004 */
350 append_composite_type_field (tib_type
, "current_top_of_stack",
352 /* uint32_t current_bottom_of_stack; %fs:0x0008 */
353 append_composite_type_field (tib_type
, "current_bottom_of_stack",
355 /* uint32_t sub_system_tib; %fs:0x000c */
356 append_composite_type_field (tib_type
, "sub_system_tib", void_ptr_type
);
358 /* uint32_t fiber_data; %fs:0x0010 */
359 append_composite_type_field (tib_type
, "fiber_data", void_ptr_type
);
360 /* uint32_t arbitrary_data_slot; %fs:0x0014 */
361 append_composite_type_field (tib_type
, "arbitrary_data_slot", void_ptr_type
);
362 /* uint32_t linear_address_tib; %fs:0x0018 */
363 append_composite_type_field (tib_type
, "linear_address_tib", void_ptr_type
);
364 /* uint32_t environment_pointer; %fs:0x001c */
365 append_composite_type_field (tib_type
, "environment_pointer", void_ptr_type
);
366 /* uint32_t process_id; %fs:0x0020 */
367 append_composite_type_field (tib_type
, "process_id", dword_ptr_type
);
368 /* uint32_t current_thread_id; %fs:0x0024 */
369 append_composite_type_field (tib_type
, "thread_id", dword_ptr_type
);
370 /* uint32_t active_rpc_handle; %fs:0x0028 */
371 append_composite_type_field (tib_type
, "active_rpc_handle", dword_ptr_type
);
372 /* uint32_t thread_local_storage; %fs:0x002c */
373 append_composite_type_field (tib_type
, "thread_local_storage",
375 /* uint32_t process_environment_block; %fs:0x0030 */
376 append_composite_type_field (tib_type
, "process_environment_block",
378 /* uint32_t last_error_number; %fs:0x0034 */
379 append_composite_type_field (tib_type
, "last_error_number", dword_ptr_type
);
381 tib_ptr_type
= arch_type (gdbarch
, TYPE_CODE_PTR
,
382 void_ptr_type
->length () * TARGET_CHAR_BIT
,
384 tib_ptr_type
->set_target_type (tib_type
);
386 windows_gdbarch_data
->tib_ptr_type
= tib_ptr_type
;
391 /* The $_tlb convenience variable is a bit special. We don't know
392 for sure the type of the value until we actually have a chance to
393 fetch the data. The type can change depending on gdbarch, so it is
394 also dependent on which thread you have selected. */
396 /* This function implements the lval_computed support for reading a
400 tlb_value_read (struct value
*val
)
403 struct type
*type
= check_typedef (value_type (val
));
405 if (!target_get_tib_address (inferior_ptid
, &tlb
))
406 error (_("Unable to read tlb"));
407 store_typed_address (value_contents_raw (val
).data (), type
, tlb
);
410 /* This function implements the lval_computed support for writing a
414 tlb_value_write (struct value
*v
, struct value
*fromval
)
416 error (_("Impossible to change the Thread Local Base"));
419 static const struct lval_funcs tlb_value_funcs
=
426 /* Return a new value with the correct type for the tlb object of
427 the current thread using architecture GDBARCH. Return a void value
428 if there's no object available. */
430 static struct value
*
431 tlb_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
, void *ignore
)
433 if (target_has_stack () && inferior_ptid
!= null_ptid
)
435 struct type
*type
= windows_get_tlb_type (gdbarch
);
436 return allocate_computed_value (type
, &tlb_value_funcs
, NULL
);
439 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
443 /* Display thread information block of a given thread. */
446 display_one_tib (ptid_t ptid
)
448 gdb_byte
*tib
= NULL
;
450 CORE_ADDR thread_local_base
;
451 ULONGEST i
, val
, max
, max_name
, size
, tib_size
;
452 ULONGEST sizeof_ptr
= gdbarch_ptr_bit (target_gdbarch ());
453 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
455 if (sizeof_ptr
== 64)
457 size
= sizeof (uint64_t);
458 tib_size
= sizeof (thread_information_64
);
463 size
= sizeof (uint32_t);
464 tib_size
= sizeof (thread_information_32
);
470 if (maint_display_all_tib
)
472 tib_size
= FULL_TIB_SIZE
;
473 max
= tib_size
/ size
;
476 tib
= (gdb_byte
*) alloca (tib_size
);
478 if (target_get_tib_address (ptid
, &thread_local_base
) == 0)
480 gdb_printf (_("Unable to get thread local base for %s\n"),
481 target_pid_to_str (ptid
).c_str ());
485 if (target_read (current_inferior ()->top_target (), TARGET_OBJECT_MEMORY
,
486 NULL
, tib
, thread_local_base
, tib_size
) != tib_size
)
488 gdb_printf (_("Unable to read thread information "
489 "block for %s at address %s\n"),
490 target_pid_to_str (ptid
).c_str (),
491 paddress (target_gdbarch (), thread_local_base
));
495 gdb_printf (_("Thread Information Block %s at %s\n"),
496 target_pid_to_str (ptid
).c_str (),
497 paddress (target_gdbarch (), thread_local_base
));
499 index
= (gdb_byte
*) tib
;
501 /* All fields have the size of a pointer, this allows to iterate
502 using the same for loop for both layouts. */
503 for (i
= 0; i
< max
; i
++)
505 val
= extract_unsigned_integer (index
, size
, byte_order
);
507 gdb_printf (_("%s is 0x%s\n"), TIB_NAME
[i
], phex (val
, size
));
509 gdb_printf (_("TIB[0x%s] is 0x%s\n"), phex (i
* size
, 2),
516 /* Display thread information block of the current thread. */
519 display_tib (const char * args
, int from_tty
)
521 if (inferior_ptid
!= null_ptid
)
522 display_one_tib (inferior_ptid
);
526 windows_xfer_shared_library (const char* so_name
, CORE_ADDR load_addr
,
527 CORE_ADDR
*text_offset_cached
,
528 struct gdbarch
*gdbarch
, struct obstack
*obstack
)
530 CORE_ADDR text_offset
= text_offset_cached
? *text_offset_cached
: 0;
532 obstack_grow_str (obstack
, "<library name=\"");
533 std::string p
= xml_escape_text (so_name
);
534 obstack_grow_str (obstack
, p
.c_str ());
535 obstack_grow_str (obstack
, "\"><segment address=\"");
539 gdb_bfd_ref_ptr
dll (gdb_bfd_open (so_name
, gnutarget
));
540 /* The following calls are OK even if dll is NULL.
541 The default value 0x1000 is returned by pe_text_section_offset
543 text_offset
= pe_text_section_offset (dll
.get ());
544 if (text_offset_cached
)
545 *text_offset_cached
= text_offset
;
548 obstack_grow_str (obstack
, paddress (gdbarch
, load_addr
+ text_offset
));
549 obstack_grow_str (obstack
, "\"/></library>");
552 /* Implement the "iterate_over_objfiles_in_search_order" gdbarch
553 method. It searches all objfiles, starting with CURRENT_OBJFILE
556 On Windows, the system behaves a little differently when two
557 objfiles each define a global symbol using the same name, compared
558 to other platforms such as GNU/Linux for instance. On GNU/Linux,
559 all instances of the symbol effectively get merged into a single
560 one, but on Windows, they remain distinct.
562 As a result, it usually makes sense to start global symbol searches
563 with the current objfile before expanding it to all other objfiles.
564 This helps for instance when a user debugs some code in a DLL that
565 refers to a global variable defined inside that DLL. When trying
566 to print the value of that global variable, it would be unhelpful
567 to print the value of another global variable defined with the same
568 name, but in a different DLL. */
571 windows_iterate_over_objfiles_in_search_order
572 (gdbarch
*gdbarch
, iterate_over_objfiles_in_search_order_cb_ftype cb
,
573 objfile
*current_objfile
)
577 if (cb (current_objfile
))
581 for (objfile
*objfile
: current_program_space
->objfiles ())
582 if (objfile
!= current_objfile
)
590 show_maint_show_all_tib (struct ui_file
*file
, int from_tty
,
591 struct cmd_list_element
*c
, const char *value
)
593 gdb_printf (file
, _("Show all non-zero elements of "
594 "Thread Information Block is %s.\n"), value
);
598 static int w32_prefix_command_valid
= 0;
600 init_w32_command_list (void)
602 if (!w32_prefix_command_valid
)
606 _("Print information specific to Win32 debugging."),
607 &info_w32_cmdlist
, 0, &infolist
);
608 w32_prefix_command_valid
= 1;
612 /* Implementation of `gdbarch_gdb_signal_to_target' for Windows. */
615 windows_gdb_signal_to_target (struct gdbarch
*gdbarch
, enum gdb_signal signal
)
622 return WINDOWS_SIGHUP
;
624 return WINDOWS_SIGINT
;
625 case GDB_SIGNAL_QUIT
:
626 return WINDOWS_SIGQUIT
;
628 return WINDOWS_SIGILL
;
629 case GDB_SIGNAL_TRAP
:
630 return WINDOWS_SIGTRAP
;
631 case GDB_SIGNAL_ABRT
:
632 return WINDOWS_SIGABRT
;
634 return WINDOWS_SIGEMT
;
636 return WINDOWS_SIGFPE
;
637 case GDB_SIGNAL_KILL
:
638 return WINDOWS_SIGKILL
;
640 return WINDOWS_SIGBUS
;
641 case GDB_SIGNAL_SEGV
:
642 return WINDOWS_SIGSEGV
;
644 return WINDOWS_SIGSYS
;
645 case GDB_SIGNAL_PIPE
:
646 return WINDOWS_SIGPIPE
;
647 case GDB_SIGNAL_ALRM
:
648 return WINDOWS_SIGALRM
;
649 case GDB_SIGNAL_TERM
:
650 return WINDOWS_SIGTERM
;
655 /* Implementation of `gdbarch_gdb_signal_to_target' for Cygwin. */
658 cygwin_gdb_signal_to_target (struct gdbarch
*gdbarch
, enum gdb_signal signal
)
665 return CYGWIN_SIGHUP
;
667 return CYGWIN_SIGINT
;
668 case GDB_SIGNAL_QUIT
:
669 return CYGWIN_SIGQUIT
;
671 return CYGWIN_SIGILL
;
672 case GDB_SIGNAL_TRAP
:
673 return CYGWIN_SIGTRAP
;
674 case GDB_SIGNAL_ABRT
:
675 return CYGWIN_SIGABRT
;
677 return CYGWIN_SIGEMT
;
679 return CYGWIN_SIGFPE
;
680 case GDB_SIGNAL_KILL
:
681 return CYGWIN_SIGKILL
;
683 return CYGWIN_SIGBUS
;
684 case GDB_SIGNAL_SEGV
:
685 return CYGWIN_SIGSEGV
;
687 return CYGWIN_SIGSYS
;
688 case GDB_SIGNAL_PIPE
:
689 return CYGWIN_SIGPIPE
;
690 case GDB_SIGNAL_ALRM
:
691 return CYGWIN_SIGALRM
;
692 case GDB_SIGNAL_TERM
:
693 return CYGWIN_SIGTERM
;
695 return CYGWIN_SIGURG
;
696 case GDB_SIGNAL_STOP
:
697 return CYGWIN_SIGSTOP
;
698 case GDB_SIGNAL_TSTP
:
699 return CYGWIN_SIGTSTP
;
700 case GDB_SIGNAL_CONT
:
701 return CYGWIN_SIGCONT
;
702 case GDB_SIGNAL_CHLD
:
703 return CYGWIN_SIGCHLD
;
704 case GDB_SIGNAL_TTIN
:
705 return CYGWIN_SIGTTIN
;
706 case GDB_SIGNAL_TTOU
:
707 return CYGWIN_SIGTTOU
;
710 case GDB_SIGNAL_XCPU
:
711 return CYGWIN_SIGXCPU
;
712 case GDB_SIGNAL_XFSZ
:
713 return CYGWIN_SIGXFSZ
;
714 case GDB_SIGNAL_VTALRM
:
715 return CYGWIN_SIGVTALRM
;
716 case GDB_SIGNAL_PROF
:
717 return CYGWIN_SIGPROF
;
718 case GDB_SIGNAL_WINCH
:
719 return CYGWIN_SIGWINCH
;
721 return CYGWIN_SIGLOST
;
722 case GDB_SIGNAL_USR1
:
723 return CYGWIN_SIGUSR1
;
724 case GDB_SIGNAL_USR2
:
725 return CYGWIN_SIGUSR2
;
730 struct enum_value_name
736 /* Allocate a TYPE_CODE_ENUM type structure with its named values. */
739 create_enum (struct gdbarch
*gdbarch
, int bit
, const char *name
,
740 const struct enum_value_name
*values
, int count
)
745 type
= arch_type (gdbarch
, TYPE_CODE_ENUM
, bit
, name
);
746 type
->set_num_fields (count
);
748 ((struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
) * count
));
749 type
->set_is_unsigned (true);
751 for (i
= 0; i
< count
; i
++)
753 type
->field (i
).set_name (values
[i
].name
);
754 type
->field (i
).set_loc_enumval (values
[i
].value
);
760 static const struct enum_value_name exception_values
[] =
762 { 0x40000015, "FATAL_APP_EXIT" },
763 { 0x4000001E, "WX86_SINGLE_STEP" },
764 { 0x4000001F, "WX86_BREAKPOINT" },
765 { 0x40010005, "DBG_CONTROL_C" },
766 { 0x40010008, "DBG_CONTROL_BREAK" },
767 { 0x80000002, "DATATYPE_MISALIGNMENT" },
768 { 0x80000003, "BREAKPOINT" },
769 { 0x80000004, "SINGLE_STEP" },
770 { 0xC0000005, "ACCESS_VIOLATION" },
771 { 0xC0000006, "IN_PAGE_ERROR" },
772 { 0xC000001D, "ILLEGAL_INSTRUCTION" },
773 { 0xC0000025, "NONCONTINUABLE_EXCEPTION" },
774 { 0xC0000026, "INVALID_DISPOSITION" },
775 { 0xC000008C, "ARRAY_BOUNDS_EXCEEDED" },
776 { 0xC000008D, "FLOAT_DENORMAL_OPERAND" },
777 { 0xC000008E, "FLOAT_DIVIDE_BY_ZERO" },
778 { 0xC000008F, "FLOAT_INEXACT_RESULT" },
779 { 0xC0000090, "FLOAT_INVALID_OPERATION" },
780 { 0xC0000091, "FLOAT_OVERFLOW" },
781 { 0xC0000092, "FLOAT_STACK_CHECK" },
782 { 0xC0000093, "FLOAT_UNDERFLOW" },
783 { 0xC0000094, "INTEGER_DIVIDE_BY_ZERO" },
784 { 0xC0000095, "INTEGER_OVERFLOW" },
785 { 0xC0000096, "PRIV_INSTRUCTION" },
786 { 0xC00000FD, "STACK_OVERFLOW" },
787 { 0xC0000409, "FAST_FAIL" },
790 static const struct enum_value_name violation_values
[] =
792 { 0, "READ_ACCESS_VIOLATION" },
793 { 1, "WRITE_ACCESS_VIOLATION" },
794 { 8, "DATA_EXECUTION_PREVENTION_VIOLATION" },
797 /* Implement the "get_siginfo_type" gdbarch method. */
800 windows_get_siginfo_type (struct gdbarch
*gdbarch
)
802 struct windows_gdbarch_data
*windows_gdbarch_data
;
803 struct type
*dword_type
, *pvoid_type
, *ulongptr_type
;
804 struct type
*code_enum
, *violation_enum
;
805 struct type
*violation_type
, *para_type
, *siginfo_ptr_type
, *siginfo_type
;
807 windows_gdbarch_data
= get_windows_gdbarch_data (gdbarch
);
808 if (windows_gdbarch_data
->siginfo_type
!= NULL
)
809 return windows_gdbarch_data
->siginfo_type
;
811 dword_type
= arch_integer_type (gdbarch
, gdbarch_int_bit (gdbarch
),
813 pvoid_type
= arch_pointer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
), "PVOID",
814 builtin_type (gdbarch
)->builtin_void
);
815 ulongptr_type
= arch_integer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
),
818 /* ExceptionCode value names */
819 code_enum
= create_enum (gdbarch
, gdbarch_int_bit (gdbarch
),
820 "ExceptionCode", exception_values
,
821 ARRAY_SIZE (exception_values
));
823 /* ACCESS_VIOLATION type names */
824 violation_enum
= create_enum (gdbarch
, gdbarch_ptr_bit (gdbarch
),
825 "ViolationType", violation_values
,
826 ARRAY_SIZE (violation_values
));
828 /* ACCESS_VIOLATION information */
829 violation_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
830 append_composite_type_field (violation_type
, "Type", violation_enum
);
831 append_composite_type_field (violation_type
, "Address", pvoid_type
);
833 /* Unnamed union of the documented field ExceptionInformation,
834 and the alternative AccessViolationInformation (which displays
835 human-readable values for ExceptionCode ACCESS_VIOLATION). */
836 para_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
837 append_composite_type_field (para_type
, "ExceptionInformation",
838 lookup_array_range_type (ulongptr_type
, 0, 14));
839 append_composite_type_field (para_type
, "AccessViolationInformation",
842 siginfo_type
= arch_composite_type (gdbarch
, "EXCEPTION_RECORD",
844 siginfo_ptr_type
= arch_pointer_type (gdbarch
, gdbarch_ptr_bit (gdbarch
),
847 /* ExceptionCode is documented as type DWORD, but here a helper
848 enum type is used instead to display a human-readable value. */
849 append_composite_type_field (siginfo_type
, "ExceptionCode", code_enum
);
850 append_composite_type_field (siginfo_type
, "ExceptionFlags", dword_type
);
851 append_composite_type_field (siginfo_type
, "ExceptionRecord",
853 append_composite_type_field (siginfo_type
, "ExceptionAddress",
855 append_composite_type_field (siginfo_type
, "NumberParameters", dword_type
);
856 /* The 64-bit variant needs some padding. */
857 append_composite_type_field_aligned (siginfo_type
, "",
858 para_type
, ulongptr_type
->length ());
860 windows_gdbarch_data
->siginfo_type
= siginfo_type
;
865 /* Implement the "solib_create_inferior_hook" target_so_ops method. */
868 windows_solib_create_inferior_hook (int from_tty
)
870 CORE_ADDR exec_base
= 0;
872 /* Find base address of main executable in
873 TIB->process_environment_block->image_base_address. */
874 struct gdbarch
*gdbarch
= target_gdbarch ();
875 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
877 int peb_offset
; /* Offset of process_environment_block in TIB. */
878 int base_offset
; /* Offset of image_base_address in PEB. */
879 if (gdbarch_ptr_bit (gdbarch
) == 32)
893 if (target_has_execution ()
894 && target_get_tib_address (inferior_ptid
, &tlb
)
895 && !target_read_memory (tlb
+ peb_offset
, buf
, ptr_bytes
))
897 CORE_ADDR peb
= extract_unsigned_integer (buf
, ptr_bytes
, byte_order
);
898 if (!target_read_memory (peb
+ base_offset
, buf
, ptr_bytes
))
899 exec_base
= extract_unsigned_integer (buf
, ptr_bytes
, byte_order
);
902 /* Rebase executable if the base address changed because of ASLR. */
903 if (current_program_space
->symfile_object_file
!= nullptr && exec_base
!= 0)
906 = pe_data (current_program_space
->exec_bfd ())->pe_opthdr
.ImageBase
;
907 if (vmaddr
!= exec_base
)
908 objfile_rebase (current_program_space
->symfile_object_file
,
913 static struct target_so_ops windows_so_ops
;
915 /* Common parts for gdbarch initialization for the Windows and Cygwin OS
919 windows_init_abi_common (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
921 set_gdbarch_wchar_bit (gdbarch
, 16);
922 set_gdbarch_wchar_signed (gdbarch
, 0);
924 /* Canonical paths on this target look like
925 `c:\Program Files\Foo App\mydll.dll', for example. */
926 set_gdbarch_has_dos_based_file_system (gdbarch
, 1);
928 set_gdbarch_iterate_over_objfiles_in_search_order
929 (gdbarch
, windows_iterate_over_objfiles_in_search_order
);
931 windows_so_ops
= solib_target_so_ops
;
932 windows_so_ops
.solib_create_inferior_hook
933 = windows_solib_create_inferior_hook
;
934 set_gdbarch_so_ops (gdbarch
, &windows_so_ops
);
936 set_gdbarch_get_siginfo_type (gdbarch
, windows_get_siginfo_type
);
939 /* See windows-tdep.h. */
941 windows_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
943 windows_init_abi_common (info
, gdbarch
);
944 set_gdbarch_gdb_signal_to_target (gdbarch
, windows_gdb_signal_to_target
);
947 /* See windows-tdep.h. */
950 cygwin_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
952 windows_init_abi_common (info
, gdbarch
);
953 set_gdbarch_gdb_signal_to_target (gdbarch
, cygwin_gdb_signal_to_target
);
956 /* Implementation of `tlb' variable. */
958 static const struct internalvar_funcs tlb_funcs
=
964 /* Layout of an element of a PE's Import Directory Table. Based on:
966 https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#import-directory-table
969 struct pe_import_directory_entry
971 uint32_t import_lookup_table_rva
;
973 uint32_t forwarder_chain
;
975 uint32_t import_address_table_rva
;
978 gdb_static_assert (sizeof (pe_import_directory_entry
) == 20);
980 /* See windows-tdep.h. */
983 is_linked_with_cygwin_dll (bfd
*abfd
)
985 /* The list of DLLs a PE is linked to is in the .idata section. See:
987 https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#the-idata-section
989 asection
*idata_section
= bfd_get_section_by_name (abfd
, ".idata");
990 if (idata_section
== nullptr)
993 bfd_size_type idata_section_size
= bfd_section_size (idata_section
);
994 internal_extra_pe_aouthdr
*pe_extra
= &pe_data (abfd
)->pe_opthdr
;
995 bfd_vma import_table_va
= pe_extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
996 bfd_vma idata_section_va
= bfd_section_vma (idata_section
);
998 /* The section's virtual address as reported by BFD has the image base applied,
1000 gdb_assert (idata_section_va
>= pe_extra
->ImageBase
);
1001 idata_section_va
-= pe_extra
->ImageBase
;
1003 bfd_vma idata_section_end_va
= idata_section_va
+ idata_section_size
;
1005 /* Make sure that the import table is indeed within the .idata section's range. */
1006 if (import_table_va
< idata_section_va
1007 || import_table_va
>= idata_section_end_va
)
1010 %s: import table's virtual address (%s) is outside .idata \
1011 section's range [%s, %s]."),
1012 bfd_get_filename (abfd
), hex_string (import_table_va
),
1013 hex_string (idata_section_va
),
1014 hex_string (idata_section_end_va
));
1018 /* The import table starts at this offset into the .idata section. */
1019 bfd_vma import_table_offset_in_sect
= import_table_va
- idata_section_va
;
1021 /* Get the section's data. */
1022 gdb::byte_vector idata_contents
;
1023 if (!gdb_bfd_get_full_section_contents (abfd
, idata_section
, &idata_contents
))
1025 warning (_("%s: failed to get contents of .idata section."),
1026 bfd_get_filename (abfd
));
1030 gdb_assert (idata_contents
.size () == idata_section_size
);
1032 const gdb_byte
*iter
= idata_contents
.data () + import_table_offset_in_sect
;
1033 const gdb_byte
*end
= idata_contents
.data () + idata_section_size
;
1034 const pe_import_directory_entry null_dir_entry
= { 0 };
1036 /* Iterate through all directory entries. */
1039 /* Is there enough space left in the section for another entry? */
1040 if (iter
+ sizeof (pe_import_directory_entry
) > end
)
1042 warning (_("%s: unexpected end of .idata section."),
1043 bfd_get_filename (abfd
));
1047 pe_import_directory_entry
*dir_entry
= (pe_import_directory_entry
*) iter
;
1049 /* Is it the end of list marker? */
1050 if (memcmp (dir_entry
, &null_dir_entry
,
1051 sizeof (pe_import_directory_entry
)) == 0)
1054 bfd_vma name_va
= dir_entry
->name_rva
;
1056 /* If the name's virtual address is smaller than the section's virtual
1057 address, there's a problem. */
1058 if (name_va
< idata_section_va
|| name_va
>= idata_section_end_va
)
1061 %s: name's virtual address (%s) is outside .idata section's \
1063 bfd_get_filename (abfd
), hex_string (name_va
),
1064 hex_string (idata_section_va
),
1065 hex_string (idata_section_end_va
));
1069 const gdb_byte
*name
= &idata_contents
[name_va
- idata_section_va
];
1071 /* Make sure we don't overshoot the end of the section with the
1073 if (name
+ sizeof (CYGWIN_DLL_NAME
) <= end
)
1075 /* Finally, check if this is the dll name we are looking for. */
1076 if (streq ((const char *) name
, CYGWIN_DLL_NAME
))
1080 iter
+= sizeof (pe_import_directory_entry
);
1088 struct gdbarch
*gdbarch
;
1089 struct obstack
*obstack
;
1094 core_process_module_section (bfd
*abfd
, asection
*sect
, void *obj
)
1096 struct cpms_data
*data
= (struct cpms_data
*) obj
;
1097 enum bfd_endian byte_order
= gdbarch_byte_order (data
->gdbarch
);
1099 unsigned int data_type
;
1101 size_t module_name_size
;
1102 size_t module_name_offset
;
1103 CORE_ADDR base_addr
;
1105 if (!startswith (sect
->name
, ".module"))
1108 gdb::byte_vector
buf (bfd_section_size (sect
) + 1);
1109 if (!bfd_get_section_contents (abfd
, sect
,
1110 buf
.data (), 0, bfd_section_size (sect
)))
1112 /* We're going to treat part of the buffer as a string, so make sure
1113 it is NUL-terminated. */
1116 /* A DWORD (data_type) followed by struct windows_core_module_info. */
1117 if (bfd_section_size (sect
) < 4)
1119 data_type
= extract_unsigned_integer (buf
.data (), 4, byte_order
);
1121 if (data_type
== NOTE_INFO_MODULE
)
1123 module_name_offset
= 12;
1124 if (bfd_section_size (sect
) < module_name_offset
)
1126 base_addr
= extract_unsigned_integer (&buf
[4], 4, byte_order
);
1127 module_name_size
= extract_unsigned_integer (&buf
[8], 4, byte_order
);
1129 else if (data_type
== NOTE_INFO_MODULE64
)
1131 module_name_offset
= 16;
1132 if (bfd_section_size (sect
) < module_name_offset
)
1134 base_addr
= extract_unsigned_integer (&buf
[4], 8, byte_order
);
1135 module_name_size
= extract_unsigned_integer (&buf
[12], 4, byte_order
);
1140 if (module_name_offset
+ module_name_size
> bfd_section_size (sect
))
1142 module_name
= (char *) buf
.data () + module_name_offset
;
1144 /* The first module is the .exe itself. */
1145 if (data
->module_count
!= 0)
1146 windows_xfer_shared_library (module_name
, base_addr
,
1147 NULL
, data
->gdbarch
, data
->obstack
);
1148 data
->module_count
++;
1152 windows_core_xfer_shared_libraries (struct gdbarch
*gdbarch
,
1154 ULONGEST offset
, ULONGEST len
)
1156 struct obstack obstack
;
1159 struct cpms_data data
= { gdbarch
, &obstack
, 0 };
1161 obstack_init (&obstack
);
1162 obstack_grow_str (&obstack
, "<library-list>\n");
1163 bfd_map_over_sections (core_bfd
,
1164 core_process_module_section
,
1166 obstack_grow_str0 (&obstack
, "</library-list>\n");
1168 buf
= (const char *) obstack_finish (&obstack
);
1169 len_avail
= strlen (buf
);
1170 if (offset
>= len_avail
)
1173 if (len
> len_avail
- offset
)
1174 len
= len_avail
- offset
;
1175 memcpy (readbuf
, buf
+ offset
, len
);
1177 obstack_free (&obstack
, NULL
);
1181 /* This is how we want PTIDs from core files to be printed. */
1184 windows_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
1186 if (ptid
.lwp () != 0)
1187 return string_printf ("Thread 0x%lx", ptid
.lwp ());
1189 return normal_pid_to_str (ptid
);
1192 void _initialize_windows_tdep ();
1194 _initialize_windows_tdep ()
1196 init_w32_command_list ();
1197 cmd_list_element
*info_w32_thread_information_block_cmd
1198 = add_cmd ("thread-information-block", class_info
, display_tib
,
1199 _("Display thread information block."),
1201 add_alias_cmd ("tib", info_w32_thread_information_block_cmd
, class_info
, 1,
1204 add_setshow_boolean_cmd ("show-all-tib", class_maintenance
,
1205 &maint_display_all_tib
, _("\
1206 Set whether to display all non-zero fields of thread information block."), _("\
1207 Show whether to display all non-zero fields of thread information block."), _("\
1208 Use \"on\" to enable, \"off\" to disable.\n\
1209 If enabled, all non-zero fields of thread information block are displayed,\n\
1210 even if their meaning is unknown."),
1212 show_maint_show_all_tib
,
1213 &maintenance_set_cmdlist
,
1214 &maintenance_show_cmdlist
);
1216 /* Explicitly create without lookup, since that tries to create a
1217 value with a void typed value, and when we get here, gdbarch
1218 isn't initialized yet. At this point, we're quite sure there
1219 isn't another convenience variable of the same name. */
1220 create_internalvar_type_lazy ("_tlb", &tlb_funcs
, NULL
);