1 /* Copyright (C) 2008-2023 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 type_allocator
alloc (gdbarch
);
219 dword_ptr_type
= init_integer_type (alloc
, gdbarch_ptr_bit (gdbarch
),
221 dword32_type
= init_integer_type (alloc
, 32,
223 word_type
= init_integer_type (alloc
, 16,
225 wchar_type
= init_integer_type (alloc
, 16,
227 void_ptr_type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_void
);
228 wchar_ptr_type
= init_pointer_type (alloc
, gdbarch_ptr_bit (gdbarch
),
229 nullptr, wchar_type
);
233 list_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
234 list_type
->set_name (xstrdup ("list"));
236 module_list_ptr_type
= void_ptr_type
;
238 append_composite_type_field (list_type
, "forward_list",
239 module_list_ptr_type
);
240 append_composite_type_field (list_type
, "backward_list",
241 module_list_ptr_type
);
243 /* Structured Exception Handler */
245 seh_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
246 seh_type
->set_name (xstrdup ("seh"));
248 seh_ptr_type
= alloc
.new_type (TYPE_CODE_PTR
,
249 void_ptr_type
->length () * TARGET_CHAR_BIT
,
251 seh_ptr_type
->set_target_type (seh_type
);
253 append_composite_type_field (seh_type
, "next_seh", seh_ptr_type
);
254 append_composite_type_field (seh_type
, "handler",
255 builtin_type (gdbarch
)->builtin_func_ptr
);
257 /* struct _PEB_LDR_DATA */
258 peb_ldr_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
259 peb_ldr_type
->set_name (xstrdup ("peb_ldr_data"));
261 append_composite_type_field (peb_ldr_type
, "length", dword32_type
);
262 append_composite_type_field (peb_ldr_type
, "initialized", dword32_type
);
263 append_composite_type_field (peb_ldr_type
, "ss_handle", void_ptr_type
);
264 append_composite_type_field (peb_ldr_type
, "in_load_order", list_type
);
265 append_composite_type_field (peb_ldr_type
, "in_memory_order", list_type
);
266 append_composite_type_field (peb_ldr_type
, "in_init_order", list_type
);
267 append_composite_type_field (peb_ldr_type
, "entry_in_progress",
269 peb_ldr_ptr_type
= alloc
.new_type (TYPE_CODE_PTR
,
270 void_ptr_type
->length () * TARGET_CHAR_BIT
,
272 peb_ldr_ptr_type
->set_target_type (peb_ldr_type
);
274 /* struct UNICODE_STRING */
275 uni_str_type
= arch_composite_type (gdbarch
, "unicode_string",
278 append_composite_type_field (uni_str_type
, "length", word_type
);
279 append_composite_type_field (uni_str_type
, "maximum_length", word_type
);
280 append_composite_type_field_aligned (uni_str_type
, "buffer",
282 wchar_ptr_type
->length ());
284 /* struct _RTL_USER_PROCESS_PARAMETERS */
285 rupp_type
= arch_composite_type (gdbarch
, "rtl_user_process_parameters",
288 append_composite_type_field (rupp_type
, "maximum_length", dword32_type
);
289 append_composite_type_field (rupp_type
, "length", dword32_type
);
290 append_composite_type_field (rupp_type
, "flags", dword32_type
);
291 append_composite_type_field (rupp_type
, "debug_flags", dword32_type
);
292 append_composite_type_field (rupp_type
, "console_handle", void_ptr_type
);
293 append_composite_type_field (rupp_type
, "console_flags", dword32_type
);
294 append_composite_type_field_aligned (rupp_type
, "standard_input",
296 void_ptr_type
->length ());
297 append_composite_type_field (rupp_type
, "standard_output", void_ptr_type
);
298 append_composite_type_field (rupp_type
, "standard_error", void_ptr_type
);
299 append_composite_type_field (rupp_type
, "current_directory", uni_str_type
);
300 append_composite_type_field (rupp_type
, "current_directory_handle",
302 append_composite_type_field (rupp_type
, "dll_path", uni_str_type
);
303 append_composite_type_field (rupp_type
, "image_path_name", uni_str_type
);
304 append_composite_type_field (rupp_type
, "command_line", uni_str_type
);
305 append_composite_type_field (rupp_type
, "environment", void_ptr_type
);
306 append_composite_type_field (rupp_type
, "starting_x", dword32_type
);
307 append_composite_type_field (rupp_type
, "starting_y", dword32_type
);
308 append_composite_type_field (rupp_type
, "count_x", dword32_type
);
309 append_composite_type_field (rupp_type
, "count_y", dword32_type
);
310 append_composite_type_field (rupp_type
, "count_chars_x", dword32_type
);
311 append_composite_type_field (rupp_type
, "count_chars_y", dword32_type
);
312 append_composite_type_field (rupp_type
, "fill_attribute", dword32_type
);
313 append_composite_type_field (rupp_type
, "window_flags", dword32_type
);
314 append_composite_type_field (rupp_type
, "show_window_flags", dword32_type
);
315 append_composite_type_field_aligned (rupp_type
, "window_title",
317 void_ptr_type
->length ());
318 append_composite_type_field (rupp_type
, "desktop_info", uni_str_type
);
319 append_composite_type_field (rupp_type
, "shell_info", uni_str_type
);
320 append_composite_type_field (rupp_type
, "runtime_data", uni_str_type
);
322 rupp_ptr_type
= init_pointer_type (alloc
, gdbarch_ptr_bit (gdbarch
),
326 /* struct process environment block */
327 peb_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
328 peb_type
->set_name (xstrdup ("peb"));
330 /* First bytes contain several flags. */
331 append_composite_type_field (peb_type
, "flags", dword_ptr_type
);
332 append_composite_type_field (peb_type
, "mutant", void_ptr_type
);
333 append_composite_type_field (peb_type
, "image_base_address", void_ptr_type
);
334 append_composite_type_field (peb_type
, "ldr", peb_ldr_ptr_type
);
335 append_composite_type_field (peb_type
, "process_parameters", rupp_ptr_type
);
336 append_composite_type_field (peb_type
, "sub_system_data", void_ptr_type
);
337 append_composite_type_field (peb_type
, "process_heap", void_ptr_type
);
338 append_composite_type_field (peb_type
, "fast_peb_lock", void_ptr_type
);
339 peb_ptr_type
= alloc
.new_type (TYPE_CODE_PTR
,
340 void_ptr_type
->length () * TARGET_CHAR_BIT
,
342 peb_ptr_type
->set_target_type (peb_type
);
345 /* struct thread information block */
346 tib_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
347 tib_type
->set_name (xstrdup ("tib"));
349 /* uint32_t current_seh; %fs:0x0000 */
350 append_composite_type_field (tib_type
, "current_seh", seh_ptr_type
);
351 /* uint32_t current_top_of_stack; %fs:0x0004 */
352 append_composite_type_field (tib_type
, "current_top_of_stack",
354 /* uint32_t current_bottom_of_stack; %fs:0x0008 */
355 append_composite_type_field (tib_type
, "current_bottom_of_stack",
357 /* uint32_t sub_system_tib; %fs:0x000c */
358 append_composite_type_field (tib_type
, "sub_system_tib", void_ptr_type
);
360 /* uint32_t fiber_data; %fs:0x0010 */
361 append_composite_type_field (tib_type
, "fiber_data", void_ptr_type
);
362 /* uint32_t arbitrary_data_slot; %fs:0x0014 */
363 append_composite_type_field (tib_type
, "arbitrary_data_slot", void_ptr_type
);
364 /* uint32_t linear_address_tib; %fs:0x0018 */
365 append_composite_type_field (tib_type
, "linear_address_tib", void_ptr_type
);
366 /* uint32_t environment_pointer; %fs:0x001c */
367 append_composite_type_field (tib_type
, "environment_pointer", void_ptr_type
);
368 /* uint32_t process_id; %fs:0x0020 */
369 append_composite_type_field (tib_type
, "process_id", dword_ptr_type
);
370 /* uint32_t current_thread_id; %fs:0x0024 */
371 append_composite_type_field (tib_type
, "thread_id", dword_ptr_type
);
372 /* uint32_t active_rpc_handle; %fs:0x0028 */
373 append_composite_type_field (tib_type
, "active_rpc_handle", dword_ptr_type
);
374 /* uint32_t thread_local_storage; %fs:0x002c */
375 append_composite_type_field (tib_type
, "thread_local_storage",
377 /* uint32_t process_environment_block; %fs:0x0030 */
378 append_composite_type_field (tib_type
, "process_environment_block",
380 /* uint32_t last_error_number; %fs:0x0034 */
381 append_composite_type_field (tib_type
, "last_error_number", dword_ptr_type
);
383 tib_ptr_type
= alloc
.new_type (TYPE_CODE_PTR
,
384 void_ptr_type
->length () * TARGET_CHAR_BIT
,
386 tib_ptr_type
->set_target_type (tib_type
);
388 windows_gdbarch_data
->tib_ptr_type
= tib_ptr_type
;
393 /* The $_tlb convenience variable is a bit special. We don't know
394 for sure the type of the value until we actually have a chance to
395 fetch the data. The type can change depending on gdbarch, so it is
396 also dependent on which thread you have selected. */
398 /* This function implements the lval_computed support for reading a
402 tlb_value_read (struct value
*val
)
405 struct type
*type
= check_typedef (val
->type ());
407 if (!target_get_tib_address (inferior_ptid
, &tlb
))
408 error (_("Unable to read tlb"));
409 store_typed_address (val
->contents_raw ().data (), type
, tlb
);
412 /* This function implements the lval_computed support for writing a
416 tlb_value_write (struct value
*v
, struct value
*fromval
)
418 error (_("Impossible to change the Thread Local Base"));
421 static const struct lval_funcs tlb_value_funcs
=
428 /* Return a new value with the correct type for the tlb object of
429 the current thread using architecture GDBARCH. Return a void value
430 if there's no object available. */
432 static struct value
*
433 tlb_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
, void *ignore
)
435 if (target_has_stack () && inferior_ptid
!= null_ptid
)
437 struct type
*type
= windows_get_tlb_type (gdbarch
);
438 return value::allocate_computed (type
, &tlb_value_funcs
, NULL
);
441 return value::allocate (builtin_type (gdbarch
)->builtin_void
);
445 /* Display thread information block of a given thread. */
448 display_one_tib (ptid_t ptid
)
450 gdb_byte
*tib
= NULL
;
452 CORE_ADDR thread_local_base
;
453 ULONGEST i
, val
, max
, max_name
, size
, tib_size
;
454 ULONGEST sizeof_ptr
= gdbarch_ptr_bit (target_gdbarch ());
455 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
457 if (sizeof_ptr
== 64)
459 size
= sizeof (uint64_t);
460 tib_size
= sizeof (thread_information_64
);
465 size
= sizeof (uint32_t);
466 tib_size
= sizeof (thread_information_32
);
472 if (maint_display_all_tib
)
474 tib_size
= FULL_TIB_SIZE
;
475 max
= tib_size
/ size
;
478 tib
= (gdb_byte
*) alloca (tib_size
);
480 if (target_get_tib_address (ptid
, &thread_local_base
) == 0)
482 gdb_printf (_("Unable to get thread local base for %s\n"),
483 target_pid_to_str (ptid
).c_str ());
487 if (target_read (current_inferior ()->top_target (), TARGET_OBJECT_MEMORY
,
488 NULL
, tib
, thread_local_base
, tib_size
) != tib_size
)
490 gdb_printf (_("Unable to read thread information "
491 "block for %s at address %s\n"),
492 target_pid_to_str (ptid
).c_str (),
493 paddress (target_gdbarch (), thread_local_base
));
497 gdb_printf (_("Thread Information Block %s at %s\n"),
498 target_pid_to_str (ptid
).c_str (),
499 paddress (target_gdbarch (), thread_local_base
));
501 index
= (gdb_byte
*) tib
;
503 /* All fields have the size of a pointer, this allows to iterate
504 using the same for loop for both layouts. */
505 for (i
= 0; i
< max
; i
++)
507 val
= extract_unsigned_integer (index
, size
, byte_order
);
509 gdb_printf (_("%s is 0x%s\n"), TIB_NAME
[i
], phex (val
, size
));
511 gdb_printf (_("TIB[0x%s] is 0x%s\n"), phex (i
* size
, 2),
518 /* Display thread information block of the current thread. */
521 display_tib (const char * args
, int from_tty
)
523 if (inferior_ptid
!= null_ptid
)
524 display_one_tib (inferior_ptid
);
528 windows_xfer_shared_library (const char* so_name
, CORE_ADDR load_addr
,
529 CORE_ADDR
*text_offset_cached
,
530 struct gdbarch
*gdbarch
, struct obstack
*obstack
)
532 CORE_ADDR text_offset
= text_offset_cached
? *text_offset_cached
: 0;
534 obstack_grow_str (obstack
, "<library name=\"");
535 std::string p
= xml_escape_text (so_name
);
536 obstack_grow_str (obstack
, p
.c_str ());
537 obstack_grow_str (obstack
, "\"><segment address=\"");
541 gdb_bfd_ref_ptr
dll (gdb_bfd_open (so_name
, gnutarget
));
542 /* The following calls are OK even if dll is NULL.
543 The default value 0x1000 is returned by pe_text_section_offset
545 text_offset
= pe_text_section_offset (dll
.get ());
546 if (text_offset_cached
)
547 *text_offset_cached
= text_offset
;
550 obstack_grow_str (obstack
, paddress (gdbarch
, load_addr
+ text_offset
));
551 obstack_grow_str (obstack
, "\"/></library>");
554 /* Implement the "iterate_over_objfiles_in_search_order" gdbarch
555 method. It searches all objfiles, starting with CURRENT_OBJFILE
558 On Windows, the system behaves a little differently when two
559 objfiles each define a global symbol using the same name, compared
560 to other platforms such as GNU/Linux for instance. On GNU/Linux,
561 all instances of the symbol effectively get merged into a single
562 one, but on Windows, they remain distinct.
564 As a result, it usually makes sense to start global symbol searches
565 with the current objfile before expanding it to all other objfiles.
566 This helps for instance when a user debugs some code in a DLL that
567 refers to a global variable defined inside that DLL. When trying
568 to print the value of that global variable, it would be unhelpful
569 to print the value of another global variable defined with the same
570 name, but in a different DLL. */
573 windows_iterate_over_objfiles_in_search_order
574 (gdbarch
*gdbarch
, iterate_over_objfiles_in_search_order_cb_ftype cb
,
575 objfile
*current_objfile
)
579 if (cb (current_objfile
))
583 for (objfile
*objfile
: current_program_space
->objfiles ())
584 if (objfile
!= current_objfile
)
592 show_maint_show_all_tib (struct ui_file
*file
, int from_tty
,
593 struct cmd_list_element
*c
, const char *value
)
595 gdb_printf (file
, _("Show all non-zero elements of "
596 "Thread Information Block is %s.\n"), value
);
600 static int w32_prefix_command_valid
= 0;
602 init_w32_command_list (void)
604 if (!w32_prefix_command_valid
)
608 _("Print information specific to Win32 debugging."),
609 &info_w32_cmdlist
, 0, &infolist
);
610 w32_prefix_command_valid
= 1;
614 /* Implementation of `gdbarch_gdb_signal_to_target' for Windows. */
617 windows_gdb_signal_to_target (struct gdbarch
*gdbarch
, enum gdb_signal signal
)
624 return WINDOWS_SIGHUP
;
626 return WINDOWS_SIGINT
;
627 case GDB_SIGNAL_QUIT
:
628 return WINDOWS_SIGQUIT
;
630 return WINDOWS_SIGILL
;
631 case GDB_SIGNAL_TRAP
:
632 return WINDOWS_SIGTRAP
;
633 case GDB_SIGNAL_ABRT
:
634 return WINDOWS_SIGABRT
;
636 return WINDOWS_SIGEMT
;
638 return WINDOWS_SIGFPE
;
639 case GDB_SIGNAL_KILL
:
640 return WINDOWS_SIGKILL
;
642 return WINDOWS_SIGBUS
;
643 case GDB_SIGNAL_SEGV
:
644 return WINDOWS_SIGSEGV
;
646 return WINDOWS_SIGSYS
;
647 case GDB_SIGNAL_PIPE
:
648 return WINDOWS_SIGPIPE
;
649 case GDB_SIGNAL_ALRM
:
650 return WINDOWS_SIGALRM
;
651 case GDB_SIGNAL_TERM
:
652 return WINDOWS_SIGTERM
;
657 /* Implementation of `gdbarch_gdb_signal_to_target' for Cygwin. */
660 cygwin_gdb_signal_to_target (struct gdbarch
*gdbarch
, enum gdb_signal signal
)
667 return CYGWIN_SIGHUP
;
669 return CYGWIN_SIGINT
;
670 case GDB_SIGNAL_QUIT
:
671 return CYGWIN_SIGQUIT
;
673 return CYGWIN_SIGILL
;
674 case GDB_SIGNAL_TRAP
:
675 return CYGWIN_SIGTRAP
;
676 case GDB_SIGNAL_ABRT
:
677 return CYGWIN_SIGABRT
;
679 return CYGWIN_SIGEMT
;
681 return CYGWIN_SIGFPE
;
682 case GDB_SIGNAL_KILL
:
683 return CYGWIN_SIGKILL
;
685 return CYGWIN_SIGBUS
;
686 case GDB_SIGNAL_SEGV
:
687 return CYGWIN_SIGSEGV
;
689 return CYGWIN_SIGSYS
;
690 case GDB_SIGNAL_PIPE
:
691 return CYGWIN_SIGPIPE
;
692 case GDB_SIGNAL_ALRM
:
693 return CYGWIN_SIGALRM
;
694 case GDB_SIGNAL_TERM
:
695 return CYGWIN_SIGTERM
;
697 return CYGWIN_SIGURG
;
698 case GDB_SIGNAL_STOP
:
699 return CYGWIN_SIGSTOP
;
700 case GDB_SIGNAL_TSTP
:
701 return CYGWIN_SIGTSTP
;
702 case GDB_SIGNAL_CONT
:
703 return CYGWIN_SIGCONT
;
704 case GDB_SIGNAL_CHLD
:
705 return CYGWIN_SIGCHLD
;
706 case GDB_SIGNAL_TTIN
:
707 return CYGWIN_SIGTTIN
;
708 case GDB_SIGNAL_TTOU
:
709 return CYGWIN_SIGTTOU
;
712 case GDB_SIGNAL_XCPU
:
713 return CYGWIN_SIGXCPU
;
714 case GDB_SIGNAL_XFSZ
:
715 return CYGWIN_SIGXFSZ
;
716 case GDB_SIGNAL_VTALRM
:
717 return CYGWIN_SIGVTALRM
;
718 case GDB_SIGNAL_PROF
:
719 return CYGWIN_SIGPROF
;
720 case GDB_SIGNAL_WINCH
:
721 return CYGWIN_SIGWINCH
;
723 return CYGWIN_SIGLOST
;
724 case GDB_SIGNAL_USR1
:
725 return CYGWIN_SIGUSR1
;
726 case GDB_SIGNAL_USR2
:
727 return CYGWIN_SIGUSR2
;
732 struct enum_value_name
738 /* Allocate a TYPE_CODE_ENUM type structure with its named values. */
741 create_enum (struct gdbarch
*gdbarch
, int bit
, const char *name
,
742 const struct enum_value_name
*values
, int count
)
747 type
= type_allocator (gdbarch
).new_type (TYPE_CODE_ENUM
, bit
, name
);
748 type
->set_num_fields (count
);
750 ((struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
) * count
));
751 type
->set_is_unsigned (true);
753 for (i
= 0; i
< count
; i
++)
755 type
->field (i
).set_name (values
[i
].name
);
756 type
->field (i
).set_loc_enumval (values
[i
].value
);
762 static const struct enum_value_name exception_values
[] =
764 { 0x40000015, "FATAL_APP_EXIT" },
765 { 0x4000001E, "WX86_SINGLE_STEP" },
766 { 0x4000001F, "WX86_BREAKPOINT" },
767 { 0x40010005, "DBG_CONTROL_C" },
768 { 0x40010008, "DBG_CONTROL_BREAK" },
769 { 0x80000002, "DATATYPE_MISALIGNMENT" },
770 { 0x80000003, "BREAKPOINT" },
771 { 0x80000004, "SINGLE_STEP" },
772 { 0xC0000005, "ACCESS_VIOLATION" },
773 { 0xC0000006, "IN_PAGE_ERROR" },
774 { 0xC000001D, "ILLEGAL_INSTRUCTION" },
775 { 0xC0000025, "NONCONTINUABLE_EXCEPTION" },
776 { 0xC0000026, "INVALID_DISPOSITION" },
777 { 0xC000008C, "ARRAY_BOUNDS_EXCEEDED" },
778 { 0xC000008D, "FLOAT_DENORMAL_OPERAND" },
779 { 0xC000008E, "FLOAT_DIVIDE_BY_ZERO" },
780 { 0xC000008F, "FLOAT_INEXACT_RESULT" },
781 { 0xC0000090, "FLOAT_INVALID_OPERATION" },
782 { 0xC0000091, "FLOAT_OVERFLOW" },
783 { 0xC0000092, "FLOAT_STACK_CHECK" },
784 { 0xC0000093, "FLOAT_UNDERFLOW" },
785 { 0xC0000094, "INTEGER_DIVIDE_BY_ZERO" },
786 { 0xC0000095, "INTEGER_OVERFLOW" },
787 { 0xC0000096, "PRIV_INSTRUCTION" },
788 { 0xC00000FD, "STACK_OVERFLOW" },
789 { 0xC0000409, "FAST_FAIL" },
792 static const struct enum_value_name violation_values
[] =
794 { 0, "READ_ACCESS_VIOLATION" },
795 { 1, "WRITE_ACCESS_VIOLATION" },
796 { 8, "DATA_EXECUTION_PREVENTION_VIOLATION" },
799 /* Implement the "get_siginfo_type" gdbarch method. */
802 windows_get_siginfo_type (struct gdbarch
*gdbarch
)
804 struct windows_gdbarch_data
*windows_gdbarch_data
;
805 struct type
*dword_type
, *pvoid_type
, *ulongptr_type
;
806 struct type
*code_enum
, *violation_enum
;
807 struct type
*violation_type
, *para_type
, *siginfo_ptr_type
, *siginfo_type
;
809 windows_gdbarch_data
= get_windows_gdbarch_data (gdbarch
);
810 if (windows_gdbarch_data
->siginfo_type
!= NULL
)
811 return windows_gdbarch_data
->siginfo_type
;
813 type_allocator
alloc (gdbarch
);
814 dword_type
= init_integer_type (alloc
, gdbarch_int_bit (gdbarch
),
816 pvoid_type
= init_pointer_type (alloc
, gdbarch_ptr_bit (gdbarch
), "PVOID",
817 builtin_type (gdbarch
)->builtin_void
);
818 ulongptr_type
= init_integer_type (alloc
, gdbarch_ptr_bit (gdbarch
),
821 /* ExceptionCode value names */
822 code_enum
= create_enum (gdbarch
, gdbarch_int_bit (gdbarch
),
823 "ExceptionCode", exception_values
,
824 ARRAY_SIZE (exception_values
));
826 /* ACCESS_VIOLATION type names */
827 violation_enum
= create_enum (gdbarch
, gdbarch_ptr_bit (gdbarch
),
828 "ViolationType", violation_values
,
829 ARRAY_SIZE (violation_values
));
831 /* ACCESS_VIOLATION information */
832 violation_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
833 append_composite_type_field (violation_type
, "Type", violation_enum
);
834 append_composite_type_field (violation_type
, "Address", pvoid_type
);
836 /* Unnamed union of the documented field ExceptionInformation,
837 and the alternative AccessViolationInformation (which displays
838 human-readable values for ExceptionCode ACCESS_VIOLATION). */
839 para_type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
840 append_composite_type_field (para_type
, "ExceptionInformation",
841 lookup_array_range_type (ulongptr_type
, 0, 14));
842 append_composite_type_field (para_type
, "AccessViolationInformation",
845 siginfo_type
= arch_composite_type (gdbarch
, "EXCEPTION_RECORD",
847 siginfo_ptr_type
= init_pointer_type (alloc
, gdbarch_ptr_bit (gdbarch
),
848 nullptr, siginfo_type
);
850 /* ExceptionCode is documented as type DWORD, but here a helper
851 enum type is used instead to display a human-readable value. */
852 append_composite_type_field (siginfo_type
, "ExceptionCode", code_enum
);
853 append_composite_type_field (siginfo_type
, "ExceptionFlags", dword_type
);
854 append_composite_type_field (siginfo_type
, "ExceptionRecord",
856 append_composite_type_field (siginfo_type
, "ExceptionAddress",
858 append_composite_type_field (siginfo_type
, "NumberParameters", dword_type
);
859 /* The 64-bit variant needs some padding. */
860 append_composite_type_field_aligned (siginfo_type
, "",
861 para_type
, ulongptr_type
->length ());
863 windows_gdbarch_data
->siginfo_type
= siginfo_type
;
868 /* Implement the "solib_create_inferior_hook" target_so_ops method. */
871 windows_solib_create_inferior_hook (int from_tty
)
873 CORE_ADDR exec_base
= 0;
875 /* Find base address of main executable in
876 TIB->process_environment_block->image_base_address. */
877 struct gdbarch
*gdbarch
= target_gdbarch ();
878 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
880 int peb_offset
; /* Offset of process_environment_block in TIB. */
881 int base_offset
; /* Offset of image_base_address in PEB. */
882 if (gdbarch_ptr_bit (gdbarch
) == 32)
896 if (target_has_execution ()
897 && target_get_tib_address (inferior_ptid
, &tlb
)
898 && !target_read_memory (tlb
+ peb_offset
, buf
, ptr_bytes
))
900 CORE_ADDR peb
= extract_unsigned_integer (buf
, ptr_bytes
, byte_order
);
901 if (!target_read_memory (peb
+ base_offset
, buf
, ptr_bytes
))
902 exec_base
= extract_unsigned_integer (buf
, ptr_bytes
, byte_order
);
905 /* Rebase executable if the base address changed because of ASLR. */
906 if (current_program_space
->symfile_object_file
!= nullptr && exec_base
!= 0)
909 = pe_data (current_program_space
->exec_bfd ())->pe_opthdr
.ImageBase
;
910 if (vmaddr
!= exec_base
)
911 objfile_rebase (current_program_space
->symfile_object_file
,
916 static struct target_so_ops windows_so_ops
;
918 /* Common parts for gdbarch initialization for the Windows and Cygwin OS
922 windows_init_abi_common (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
924 set_gdbarch_wchar_bit (gdbarch
, 16);
925 set_gdbarch_wchar_signed (gdbarch
, 0);
927 /* Canonical paths on this target look like
928 `c:\Program Files\Foo App\mydll.dll', for example. */
929 set_gdbarch_has_dos_based_file_system (gdbarch
, 1);
931 set_gdbarch_iterate_over_objfiles_in_search_order
932 (gdbarch
, windows_iterate_over_objfiles_in_search_order
);
934 windows_so_ops
= solib_target_so_ops
;
935 windows_so_ops
.solib_create_inferior_hook
936 = windows_solib_create_inferior_hook
;
937 set_gdbarch_so_ops (gdbarch
, &windows_so_ops
);
939 set_gdbarch_get_siginfo_type (gdbarch
, windows_get_siginfo_type
);
942 /* See windows-tdep.h. */
944 windows_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
946 windows_init_abi_common (info
, gdbarch
);
947 set_gdbarch_gdb_signal_to_target (gdbarch
, windows_gdb_signal_to_target
);
950 /* See windows-tdep.h. */
953 cygwin_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
955 windows_init_abi_common (info
, gdbarch
);
956 set_gdbarch_gdb_signal_to_target (gdbarch
, cygwin_gdb_signal_to_target
);
959 /* Implementation of `tlb' variable. */
961 static const struct internalvar_funcs tlb_funcs
=
967 /* Layout of an element of a PE's Import Directory Table. Based on:
969 https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#import-directory-table
972 struct pe_import_directory_entry
974 uint32_t import_lookup_table_rva
;
976 uint32_t forwarder_chain
;
978 uint32_t import_address_table_rva
;
981 gdb_static_assert (sizeof (pe_import_directory_entry
) == 20);
983 /* See windows-tdep.h. */
986 is_linked_with_cygwin_dll (bfd
*abfd
)
988 /* The list of DLLs a PE is linked to is in the .idata section. See:
990 https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#the-idata-section
992 asection
*idata_section
= bfd_get_section_by_name (abfd
, ".idata");
993 if (idata_section
== nullptr)
996 bfd_size_type idata_section_size
= bfd_section_size (idata_section
);
997 internal_extra_pe_aouthdr
*pe_extra
= &pe_data (abfd
)->pe_opthdr
;
998 bfd_vma import_table_va
= pe_extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
999 bfd_vma idata_section_va
= bfd_section_vma (idata_section
);
1001 /* The section's virtual address as reported by BFD has the image base applied,
1003 gdb_assert (idata_section_va
>= pe_extra
->ImageBase
);
1004 idata_section_va
-= pe_extra
->ImageBase
;
1006 bfd_vma idata_section_end_va
= idata_section_va
+ idata_section_size
;
1008 /* Make sure that the import table is indeed within the .idata section's range. */
1009 if (import_table_va
< idata_section_va
1010 || import_table_va
>= idata_section_end_va
)
1013 %s: import table's virtual address (%s) is outside .idata \
1014 section's range [%s, %s]."),
1015 bfd_get_filename (abfd
), hex_string (import_table_va
),
1016 hex_string (idata_section_va
),
1017 hex_string (idata_section_end_va
));
1021 /* The import table starts at this offset into the .idata section. */
1022 bfd_vma import_table_offset_in_sect
= import_table_va
- idata_section_va
;
1024 /* Get the section's data. */
1025 gdb::byte_vector idata_contents
;
1026 if (!gdb_bfd_get_full_section_contents (abfd
, idata_section
, &idata_contents
))
1028 warning (_("%s: failed to get contents of .idata section."),
1029 bfd_get_filename (abfd
));
1033 gdb_assert (idata_contents
.size () == idata_section_size
);
1035 const gdb_byte
*iter
= idata_contents
.data () + import_table_offset_in_sect
;
1036 const gdb_byte
*end
= idata_contents
.data () + idata_section_size
;
1037 const pe_import_directory_entry null_dir_entry
= { 0 };
1039 /* Iterate through all directory entries. */
1042 /* Is there enough space left in the section for another entry? */
1043 if (iter
+ sizeof (pe_import_directory_entry
) > end
)
1045 warning (_("%s: unexpected end of .idata section."),
1046 bfd_get_filename (abfd
));
1050 pe_import_directory_entry
*dir_entry
= (pe_import_directory_entry
*) iter
;
1052 /* Is it the end of list marker? */
1053 if (memcmp (dir_entry
, &null_dir_entry
,
1054 sizeof (pe_import_directory_entry
)) == 0)
1057 bfd_vma name_va
= dir_entry
->name_rva
;
1059 /* If the name's virtual address is smaller than the section's virtual
1060 address, there's a problem. */
1061 if (name_va
< idata_section_va
|| name_va
>= idata_section_end_va
)
1064 %s: name's virtual address (%s) is outside .idata section's \
1066 bfd_get_filename (abfd
), hex_string (name_va
),
1067 hex_string (idata_section_va
),
1068 hex_string (idata_section_end_va
));
1072 const gdb_byte
*name
= &idata_contents
[name_va
- idata_section_va
];
1074 /* Make sure we don't overshoot the end of the section with the
1076 if (name
+ sizeof (CYGWIN_DLL_NAME
) <= end
)
1078 /* Finally, check if this is the dll name we are looking for. */
1079 if (streq ((const char *) name
, CYGWIN_DLL_NAME
))
1083 iter
+= sizeof (pe_import_directory_entry
);
1091 struct gdbarch
*gdbarch
;
1092 struct obstack
*obstack
;
1097 core_process_module_section (bfd
*abfd
, asection
*sect
, void *obj
)
1099 struct cpms_data
*data
= (struct cpms_data
*) obj
;
1100 enum bfd_endian byte_order
= gdbarch_byte_order (data
->gdbarch
);
1102 unsigned int data_type
;
1104 size_t module_name_size
;
1105 size_t module_name_offset
;
1106 CORE_ADDR base_addr
;
1108 if (!startswith (sect
->name
, ".module"))
1111 gdb::byte_vector
buf (bfd_section_size (sect
) + 1);
1112 if (!bfd_get_section_contents (abfd
, sect
,
1113 buf
.data (), 0, bfd_section_size (sect
)))
1115 /* We're going to treat part of the buffer as a string, so make sure
1116 it is NUL-terminated. */
1119 /* A DWORD (data_type) followed by struct windows_core_module_info. */
1120 if (bfd_section_size (sect
) < 4)
1122 data_type
= extract_unsigned_integer (buf
.data (), 4, byte_order
);
1124 if (data_type
== NOTE_INFO_MODULE
)
1126 module_name_offset
= 12;
1127 if (bfd_section_size (sect
) < module_name_offset
)
1129 base_addr
= extract_unsigned_integer (&buf
[4], 4, byte_order
);
1130 module_name_size
= extract_unsigned_integer (&buf
[8], 4, byte_order
);
1132 else if (data_type
== NOTE_INFO_MODULE64
)
1134 module_name_offset
= 16;
1135 if (bfd_section_size (sect
) < module_name_offset
)
1137 base_addr
= extract_unsigned_integer (&buf
[4], 8, byte_order
);
1138 module_name_size
= extract_unsigned_integer (&buf
[12], 4, byte_order
);
1143 if (module_name_offset
+ module_name_size
> bfd_section_size (sect
))
1145 module_name
= (char *) buf
.data () + module_name_offset
;
1147 /* The first module is the .exe itself. */
1148 if (data
->module_count
!= 0)
1149 windows_xfer_shared_library (module_name
, base_addr
,
1150 NULL
, data
->gdbarch
, data
->obstack
);
1151 data
->module_count
++;
1155 windows_core_xfer_shared_libraries (struct gdbarch
*gdbarch
,
1157 ULONGEST offset
, ULONGEST len
)
1159 struct obstack obstack
;
1162 struct cpms_data data
= { gdbarch
, &obstack
, 0 };
1164 obstack_init (&obstack
);
1165 obstack_grow_str (&obstack
, "<library-list>\n");
1166 bfd_map_over_sections (core_bfd
,
1167 core_process_module_section
,
1169 obstack_grow_str0 (&obstack
, "</library-list>\n");
1171 buf
= (const char *) obstack_finish (&obstack
);
1172 len_avail
= strlen (buf
);
1173 if (offset
>= len_avail
)
1176 if (len
> len_avail
- offset
)
1177 len
= len_avail
- offset
;
1178 memcpy (readbuf
, buf
+ offset
, len
);
1180 obstack_free (&obstack
, NULL
);
1184 /* This is how we want PTIDs from core files to be printed. */
1187 windows_core_pid_to_str (struct gdbarch
*gdbarch
, ptid_t ptid
)
1189 if (ptid
.lwp () != 0)
1190 return string_printf ("Thread 0x%lx", ptid
.lwp ());
1192 return normal_pid_to_str (ptid
);
1195 void _initialize_windows_tdep ();
1197 _initialize_windows_tdep ()
1199 init_w32_command_list ();
1200 cmd_list_element
*info_w32_thread_information_block_cmd
1201 = add_cmd ("thread-information-block", class_info
, display_tib
,
1202 _("Display thread information block."),
1204 add_alias_cmd ("tib", info_w32_thread_information_block_cmd
, class_info
, 1,
1207 add_setshow_boolean_cmd ("show-all-tib", class_maintenance
,
1208 &maint_display_all_tib
, _("\
1209 Set whether to display all non-zero fields of thread information block."), _("\
1210 Show whether to display all non-zero fields of thread information block."), _("\
1211 Use \"on\" to enable, \"off\" to disable.\n\
1212 If enabled, all non-zero fields of thread information block are displayed,\n\
1213 even if their meaning is unknown."),
1215 show_maint_show_all_tib
,
1216 &maintenance_set_cmdlist
,
1217 &maintenance_show_cmdlist
);
1219 /* Explicitly create without lookup, since that tries to create a
1220 value with a void typed value, and when we get here, gdbarch
1221 isn't initialized yet. At this point, we're quite sure there
1222 isn't another convenience variable of the same name. */
1223 create_internalvar_type_lazy ("_tlb", &tlb_funcs
, NULL
);