1 /* Copyright (C) 2008-2017 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 "gdb_obstack.h"
21 #include "xml-support.h"
28 #include "gdbthread.h"
31 #include "coff-pe-read.h"
33 #include "complaints.h"
35 #include "solib-target.h"
38 struct cmd_list_element *info_w32_cmdlist;
40 typedef struct thread_information_block_32
42 uint32_t current_seh; /* %fs:0x0000 */
43 uint32_t current_top_of_stack; /* %fs:0x0004 */
44 uint32_t current_bottom_of_stack; /* %fs:0x0008 */
45 uint32_t sub_system_tib; /* %fs:0x000c */
46 uint32_t fiber_data; /* %fs:0x0010 */
47 uint32_t arbitrary_data_slot; /* %fs:0x0014 */
48 uint32_t linear_address_tib; /* %fs:0x0018 */
49 uint32_t environment_pointer; /* %fs:0x001c */
50 uint32_t process_id; /* %fs:0x0020 */
51 uint32_t current_thread_id; /* %fs:0x0024 */
52 uint32_t active_rpc_handle; /* %fs:0x0028 */
53 uint32_t thread_local_storage; /* %fs:0x002c */
54 uint32_t process_environment_block; /* %fs:0x0030 */
55 uint32_t last_error_number; /* %fs:0x0034 */
57 thread_information_32;
59 typedef struct thread_information_block_64
61 uint64_t current_seh; /* %gs:0x0000 */
62 uint64_t current_top_of_stack; /* %gs:0x0008 */
63 uint64_t current_bottom_of_stack; /* %gs:0x0010 */
64 uint64_t sub_system_tib; /* %gs:0x0018 */
65 uint64_t fiber_data; /* %gs:0x0020 */
66 uint64_t arbitrary_data_slot; /* %gs:0x0028 */
67 uint64_t linear_address_tib; /* %gs:0x0030 */
68 uint64_t environment_pointer; /* %gs:0x0038 */
69 uint64_t process_id; /* %gs:0x0040 */
70 uint64_t current_thread_id; /* %gs:0x0048 */
71 uint64_t active_rpc_handle; /* %gs:0x0050 */
72 uint64_t thread_local_storage; /* %gs:0x0058 */
73 uint64_t process_environment_block; /* %gs:0x0060 */
74 uint64_t last_error_number; /* %gs:0x0068 */
76 thread_information_64;
79 static const char* TIB_NAME[] =
81 " current_seh ", /* %fs:0x0000 */
82 " current_top_of_stack ", /* %fs:0x0004 */
83 " current_bottom_of_stack ", /* %fs:0x0008 */
84 " sub_system_tib ", /* %fs:0x000c */
85 " fiber_data ", /* %fs:0x0010 */
86 " arbitrary_data_slot ", /* %fs:0x0014 */
87 " linear_address_tib ", /* %fs:0x0018 */
88 " environment_pointer ", /* %fs:0x001c */
89 " process_id ", /* %fs:0x0020 */
90 " current_thread_id ", /* %fs:0x0024 */
91 " active_rpc_handle ", /* %fs:0x0028 */
92 " thread_local_storage ", /* %fs:0x002c */
93 " process_environment_block ", /* %fs:0x0030 */
94 " last_error_number " /* %fs:0x0034 */
97 static const int MAX_TIB32 =
98 sizeof (thread_information_32) / sizeof (uint32_t);
99 static const int MAX_TIB64 =
100 sizeof (thread_information_64) / sizeof (uint64_t);
101 static const int FULL_TIB_SIZE = 0x1000;
103 static int maint_display_all_tib = 0;
105 /* Define Thread Local Base pointer type. */
108 windows_get_tlb_type (struct gdbarch *gdbarch)
110 static struct gdbarch *last_gdbarch = NULL;
111 static struct type *last_tlb_type = NULL;
112 struct type *dword_ptr_type, *dword32_type, *void_ptr_type;
113 struct type *peb_ldr_type, *peb_ldr_ptr_type;
114 struct type *peb_type, *peb_ptr_type, *list_type;
115 struct type *module_list_ptr_type;
116 struct type *tib_type, *seh_type, *tib_ptr_type, *seh_ptr_type;
118 /* Do not rebuild type if same gdbarch as last time. */
119 if (last_tlb_type && last_gdbarch == gdbarch)
120 return last_tlb_type;
122 dword_ptr_type = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch),
124 dword32_type = arch_integer_type (gdbarch, 32,
126 void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
130 list_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
131 TYPE_NAME (list_type) = xstrdup ("list");
133 module_list_ptr_type = void_ptr_type;
135 append_composite_type_field (list_type, "forward_list",
136 module_list_ptr_type);
137 append_composite_type_field (list_type, "backward_list",
138 module_list_ptr_type);
140 /* Structured Exception Handler */
142 seh_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
143 TYPE_NAME (seh_type) = xstrdup ("seh");
145 seh_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
146 TYPE_LENGTH (void_ptr_type), NULL);
147 TYPE_TARGET_TYPE (seh_ptr_type) = seh_type;
149 append_composite_type_field (seh_type, "next_seh", seh_ptr_type);
150 append_composite_type_field (seh_type, "handler",
151 builtin_type (gdbarch)->builtin_func_ptr);
153 /* struct _PEB_LDR_DATA */
154 peb_ldr_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
155 TYPE_NAME (peb_ldr_type) = xstrdup ("peb_ldr_data");
157 append_composite_type_field (peb_ldr_type, "length", dword32_type);
158 append_composite_type_field (peb_ldr_type, "initialized", dword32_type);
159 append_composite_type_field (peb_ldr_type, "ss_handle", void_ptr_type);
160 append_composite_type_field (peb_ldr_type, "in_load_order", list_type);
161 append_composite_type_field (peb_ldr_type, "in_memory_order", list_type);
162 append_composite_type_field (peb_ldr_type, "in_init_order", list_type);
163 append_composite_type_field (peb_ldr_type, "entry_in_progress",
165 peb_ldr_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
166 TYPE_LENGTH (void_ptr_type), NULL);
167 TYPE_TARGET_TYPE (peb_ldr_ptr_type) = peb_ldr_type;
170 /* struct process environment block */
171 peb_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
172 TYPE_NAME (peb_type) = xstrdup ("peb");
174 /* First bytes contain several flags. */
175 append_composite_type_field (peb_type, "flags", dword_ptr_type);
176 append_composite_type_field (peb_type, "mutant", void_ptr_type);
177 append_composite_type_field (peb_type, "image_base_address", void_ptr_type);
178 append_composite_type_field (peb_type, "ldr", peb_ldr_ptr_type);
179 append_composite_type_field (peb_type, "process_parameters", void_ptr_type);
180 append_composite_type_field (peb_type, "sub_system_data", void_ptr_type);
181 append_composite_type_field (peb_type, "process_heap", void_ptr_type);
182 append_composite_type_field (peb_type, "fast_peb_lock", void_ptr_type);
183 peb_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
184 TYPE_LENGTH (void_ptr_type), NULL);
185 TYPE_TARGET_TYPE (peb_ptr_type) = peb_type;
188 /* struct thread information block */
189 tib_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
190 TYPE_NAME (tib_type) = xstrdup ("tib");
192 /* uint32_t current_seh; %fs:0x0000 */
193 append_composite_type_field (tib_type, "current_seh", seh_ptr_type);
194 /* uint32_t current_top_of_stack; %fs:0x0004 */
195 append_composite_type_field (tib_type, "current_top_of_stack",
197 /* uint32_t current_bottom_of_stack; %fs:0x0008 */
198 append_composite_type_field (tib_type, "current_bottom_of_stack",
200 /* uint32_t sub_system_tib; %fs:0x000c */
201 append_composite_type_field (tib_type, "sub_system_tib", void_ptr_type);
203 /* uint32_t fiber_data; %fs:0x0010 */
204 append_composite_type_field (tib_type, "fiber_data", void_ptr_type);
205 /* uint32_t arbitrary_data_slot; %fs:0x0014 */
206 append_composite_type_field (tib_type, "arbitrary_data_slot", void_ptr_type);
207 /* uint32_t linear_address_tib; %fs:0x0018 */
208 append_composite_type_field (tib_type, "linear_address_tib", void_ptr_type);
209 /* uint32_t environment_pointer; %fs:0x001c */
210 append_composite_type_field (tib_type, "environment_pointer", void_ptr_type);
211 /* uint32_t process_id; %fs:0x0020 */
212 append_composite_type_field (tib_type, "process_id", dword_ptr_type);
213 /* uint32_t current_thread_id; %fs:0x0024 */
214 append_composite_type_field (tib_type, "thread_id", dword_ptr_type);
215 /* uint32_t active_rpc_handle; %fs:0x0028 */
216 append_composite_type_field (tib_type, "active_rpc_handle", dword_ptr_type);
217 /* uint32_t thread_local_storage; %fs:0x002c */
218 append_composite_type_field (tib_type, "thread_local_storage",
220 /* uint32_t process_environment_block; %fs:0x0030 */
221 append_composite_type_field (tib_type, "process_environment_block",
223 /* uint32_t last_error_number; %fs:0x0034 */
224 append_composite_type_field (tib_type, "last_error_number", dword_ptr_type);
226 tib_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
227 TYPE_LENGTH (void_ptr_type), NULL);
228 TYPE_TARGET_TYPE (tib_ptr_type) = tib_type;
230 last_tlb_type = tib_ptr_type;
231 last_gdbarch = gdbarch;
236 /* The $_tlb convenience variable is a bit special. We don't know
237 for sure the type of the value until we actually have a chance to
238 fetch the data. The type can change depending on gdbarch, so it is
239 also dependent on which thread you have selected. */
241 /* This function implements the lval_computed support for reading a
245 tlb_value_read (struct value *val)
248 struct type *type = check_typedef (value_type (val));
250 if (!target_get_tib_address (inferior_ptid, &tlb))
251 error (_("Unable to read tlb"));
252 store_typed_address (value_contents_raw (val), type, tlb);
255 /* This function implements the lval_computed support for writing a
259 tlb_value_write (struct value *v, struct value *fromval)
261 error (_("Impossible to change the Thread Local Base"));
264 static const struct lval_funcs tlb_value_funcs =
271 /* Return a new value with the correct type for the tlb object of
272 the current thread using architecture GDBARCH. Return a void value
273 if there's no object available. */
275 static struct value *
276 tlb_make_value (struct gdbarch *gdbarch, struct internalvar *var, void *ignore)
278 if (target_has_stack && !ptid_equal (inferior_ptid, null_ptid))
280 struct type *type = windows_get_tlb_type (gdbarch);
281 return allocate_computed_value (type, &tlb_value_funcs, NULL);
284 return allocate_value (builtin_type (gdbarch)->builtin_void);
288 /* Display thread information block of a given thread. */
291 display_one_tib (ptid_t ptid)
293 gdb_byte *tib = NULL;
295 CORE_ADDR thread_local_base;
296 ULONGEST i, val, max, max_name, size, tib_size;
297 ULONGEST sizeof_ptr = gdbarch_ptr_bit (target_gdbarch ());
298 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
300 if (sizeof_ptr == 64)
302 size = sizeof (uint64_t);
303 tib_size = sizeof (thread_information_64);
308 size = sizeof (uint32_t);
309 tib_size = sizeof (thread_information_32);
315 if (maint_display_all_tib)
317 tib_size = FULL_TIB_SIZE;
318 max = tib_size / size;
321 tib = (gdb_byte *) alloca (tib_size);
323 if (target_get_tib_address (ptid, &thread_local_base) == 0)
325 printf_filtered (_("Unable to get thread local base for %s\n"),
326 target_pid_to_str (ptid));
330 if (target_read (¤t_target, TARGET_OBJECT_MEMORY,
331 NULL, tib, thread_local_base, tib_size) != tib_size)
333 printf_filtered (_("Unable to read thread information "
334 "block for %s at address %s\n"),
335 target_pid_to_str (ptid),
336 paddress (target_gdbarch (), thread_local_base));
340 printf_filtered (_("Thread Information Block %s at %s\n"),
341 target_pid_to_str (ptid),
342 paddress (target_gdbarch (), thread_local_base));
344 index = (gdb_byte *) tib;
346 /* All fields have the size of a pointer, this allows to iterate
347 using the same for loop for both layouts. */
348 for (i = 0; i < max; i++)
350 val = extract_unsigned_integer (index, size, byte_order);
352 printf_filtered (_("%s is 0x%s\n"), TIB_NAME[i], phex (val, size));
354 printf_filtered (_("TIB[0x%s] is 0x%s\n"), phex (i * size, 2),
361 /* Display thread information block of the current thread. */
364 display_tib (char * args, int from_tty)
366 if (!ptid_equal (inferior_ptid, null_ptid))
367 display_one_tib (inferior_ptid);
371 windows_xfer_shared_library (const char* so_name, CORE_ADDR load_addr,
372 struct gdbarch *gdbarch, struct obstack *obstack)
375 CORE_ADDR text_offset;
377 obstack_grow_str (obstack, "<library name=\"");
378 p = xml_escape_text (so_name);
379 obstack_grow_str (obstack, p);
381 obstack_grow_str (obstack, "\"><segment address=\"");
382 gdb_bfd_ref_ptr dll (gdb_bfd_open (so_name, gnutarget, -1));
383 /* The following calls are OK even if dll is NULL.
384 The default value 0x1000 is returned by pe_text_section_offset
386 text_offset = pe_text_section_offset (dll.get ());
387 obstack_grow_str (obstack, paddress (gdbarch, load_addr + text_offset));
388 obstack_grow_str (obstack, "\"/></library>");
391 /* Implement the "iterate_over_objfiles_in_search_order" gdbarch
392 method. It searches all objfiles, starting with CURRENT_OBJFILE
395 On Windows, the system behaves a little differently when two
396 objfiles each define a global symbol using the same name, compared
397 to other platforms such as GNU/Linux for instance. On GNU/Linux,
398 all instances of the symbol effectively get merged into a single
399 one, but on Windows, they remain distinct.
401 As a result, it usually makes sense to start global symbol searches
402 with the current objfile before expanding it to all other objfiles.
403 This helps for instance when a user debugs some code in a DLL that
404 refers to a global variable defined inside that DLL. When trying
405 to print the value of that global variable, it would be unhelpful
406 to print the value of another global variable defined with the same
407 name, but in a different DLL. */
410 windows_iterate_over_objfiles_in_search_order
411 (struct gdbarch *gdbarch,
412 iterate_over_objfiles_in_search_order_cb_ftype *cb,
413 void *cb_data, struct objfile *current_objfile)
416 struct objfile *objfile;
420 stop = cb (current_objfile, cb_data);
425 ALL_OBJFILES (objfile)
427 if (objfile != current_objfile)
429 stop = cb (objfile, cb_data);
437 show_maint_show_all_tib (struct ui_file *file, int from_tty,
438 struct cmd_list_element *c, const char *value)
440 fprintf_filtered (file, _("Show all non-zero elements of "
441 "Thread Information Block is %s.\n"), value);
445 info_w32_command (char *args, int from_tty)
447 help_list (info_w32_cmdlist, "info w32 ", class_info, gdb_stdout);
450 static int w32_prefix_command_valid = 0;
452 init_w32_command_list (void)
454 if (!w32_prefix_command_valid)
456 add_prefix_cmd ("w32", class_info, info_w32_command,
457 _("Print information specific to Win32 debugging."),
458 &info_w32_cmdlist, "info w32 ", 0, &infolist);
459 w32_prefix_command_valid = 1;
463 /* To be called from the various GDB_OSABI_CYGWIN handlers for the
464 various Windows architectures and machine types. */
467 windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
469 set_gdbarch_wchar_bit (gdbarch, 16);
470 set_gdbarch_wchar_signed (gdbarch, 0);
472 /* Canonical paths on this target look like
473 `c:\Program Files\Foo App\mydll.dll', for example. */
474 set_gdbarch_has_dos_based_file_system (gdbarch, 1);
476 set_gdbarch_iterate_over_objfiles_in_search_order
477 (gdbarch, windows_iterate_over_objfiles_in_search_order);
479 set_solib_ops (gdbarch, &solib_target_so_ops);
482 /* Provide a prototype to silence -Wmissing-prototypes. */
483 extern initialize_file_ftype _initialize_windows_tdep;
485 /* Implementation of `tlb' variable. */
487 static const struct internalvar_funcs tlb_funcs =
495 _initialize_windows_tdep (void)
497 init_w32_command_list ();
498 add_cmd ("thread-information-block", class_info, display_tib,
499 _("Display thread information block."),
501 add_alias_cmd ("tib", "thread-information-block", class_info, 1,
504 add_setshow_boolean_cmd ("show-all-tib", class_maintenance,
505 &maint_display_all_tib, _("\
506 Set whether to display all non-zero fields of thread information block."), _("\
507 Show whether to display all non-zero fields of thread information block."), _("\
508 Use \"on\" to enable, \"off\" to disable.\n\
509 If enabled, all non-zero fields of thread information block are displayed,\n\
510 even if their meaning is unknown."),
512 show_maint_show_all_tib,
513 &maintenance_set_cmdlist,
514 &maintenance_show_cmdlist);
516 /* Explicitly create without lookup, since that tries to create a
517 value with a void typed value, and when we get here, gdbarch
518 isn't initialized yet. At this point, we're quite sure there
519 isn't another convenience variable of the same name. */
520 create_internalvar_type_lazy ("_tlb", &tlb_funcs, NULL);