projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Use enums for human-readable exception information.
[deliverable/binutils-gdb.git] / gdb / windows-tdep.c
CommitLineData
b811d2c2 1/* Copyright (C) 2008-2020 Free Software Foundation, Inc.
bfb87e33
JB		 2
3 This file is part of GDB.
4
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.
9
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.
14
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/>. */
17
18#include "defs.h"
31b060a2 19#include "windows-tdep.h"
bfb87e33
JB		 20#include "gdb_obstack.h"
21#include "xml-support.h"
711e434b
PM		 22#include "gdbarch.h"
23#include "target.h"
24#include "value.h"
25#include "inferior.h"
26#include "command.h"
27#include "gdbcmd.h"
28#include "gdbthread.h"
a8e1bb34 29#include "objfiles.h"
3999122f
PM		 30#include "symfile.h"
31#include "coff-pe-read.h"
32#include "gdb_bfd.h"
33#include "complaints.h"
64870a42
YQ		 34#include "solib.h"
35#include "solib-target.h"
2938e6cf 36#include "gdbcore.h"
711e434b 37
559e7e50
EZ		 38/* Windows signal numbers differ between MinGW flavors and between
39 those and Cygwin. The below enumeration was gleaned from the
40 respective headers; the ones marked with MinGW64/Cygwin are defined
41 only by MinGW64 and Cygwin, not by mingw.org's MinGW. FIXME: We
42 should really have distinct MinGW vs Cygwin OSABIs, and two
43 separate enums, selected at runtime. */
44
45enum
46 {
47 WINDOWS_SIGHUP = 1, /* MinGW64/Cygwin */
48 WINDOWS_SIGINT = 2,
49 WINDOWS_SIGQUIT = 3, /* MinGW64/Cygwin */
50 WINDOWS_SIGILL = 4,
51 WINDOWS_SIGTRAP = 5, /* MinGW64/Cygwin */
52#ifdef __CYGWIN__
89a65580 53 WINDOWS_SIGABRT = 6,
559e7e50
EZ		 54#else
55 WINDOWS_SIGIOT = 6, /* MinGW64 */
56#endif
57 WINDOWS_SIGEMT = 7, /* MinGW64/Cygwin */
58 WINDOWS_SIGFPE = 8,
59 WINDOWS_SIGKILL = 9, /* MinGW64/Cygwin */
60 WINDOWS_SIGBUS = 10, /* MinGW64/Cygwin */
61 WINDOWS_SIGSEGV = 11,
62 WINDOWS_SIGSYS = 12, /* MinGW64/Cygwin */
63 WINDOWS_SIGPIPE = 13,/* MinGW64/Cygwin */
64 WINDOWS_SIGALRM = 14,/* MinGW64/Cygwin */
65 WINDOWS_SIGTERM = 15,
66#ifdef __CYGWIN__
67 WINDOWS_SIGURG = 16,
68 WINDOWS_SIGSTOP = 17,
69 WINDOWS_SIGTSTP = 18,
70 WINDOWS_SIGCONT = 19,
71 WINDOWS_SIGCHLD = 20,
72 WINDOWS_SIGTTIN = 21,
73 WINDOWS_SIGTTOU = 22,
74 WINDOWS_SIGIO = 23,
75 WINDOWS_SIGXCPU = 24,
76 WINDOWS_SIGXFSZ = 25,
77 WINDOWS_SIGVTALRM = 26,
78 WINDOWS_SIGPROF = 27,
79 WINDOWS_SIGWINCH = 28,
80 WINDOWS_SIGLOST = 29,
81 WINDOWS_SIGUSR1 = 30,
82 WINDOWS_SIGUSR2 = 31
83#else
84 WINDOWS_SIGBREAK = 21,
85 WINDOWS_SIGABRT = 22
86#endif
87 };
88
711e434b
PM		 89struct cmd_list_element *info_w32_cmdlist;
90
91typedef struct thread_information_block_32
92 {
93 uint32_t current_seh; /* %fs:0x0000 */
94 uint32_t current_top_of_stack; /* %fs:0x0004 */
95 uint32_t current_bottom_of_stack; /* %fs:0x0008 */
96 uint32_t sub_system_tib; /* %fs:0x000c */
97 uint32_t fiber_data; /* %fs:0x0010 */
98 uint32_t arbitrary_data_slot; /* %fs:0x0014 */
99 uint32_t linear_address_tib; /* %fs:0x0018 */
100 uint32_t environment_pointer; /* %fs:0x001c */
101 uint32_t process_id; /* %fs:0x0020 */
102 uint32_t current_thread_id; /* %fs:0x0024 */
103 uint32_t active_rpc_handle; /* %fs:0x0028 */
104 uint32_t thread_local_storage; /* %fs:0x002c */
105 uint32_t process_environment_block; /* %fs:0x0030 */
106 uint32_t last_error_number; /* %fs:0x0034 */
107 }
108thread_information_32;
109
110typedef struct thread_information_block_64
111 {
112 uint64_t current_seh; /* %gs:0x0000 */
113 uint64_t current_top_of_stack; /* %gs:0x0008 */
114 uint64_t current_bottom_of_stack; /* %gs:0x0010 */
115 uint64_t sub_system_tib; /* %gs:0x0018 */
116 uint64_t fiber_data; /* %gs:0x0020 */
117 uint64_t arbitrary_data_slot; /* %gs:0x0028 */
118 uint64_t linear_address_tib; /* %gs:0x0030 */
119 uint64_t environment_pointer; /* %gs:0x0038 */
120 uint64_t process_id; /* %gs:0x0040 */
121 uint64_t current_thread_id; /* %gs:0x0048 */
122 uint64_t active_rpc_handle; /* %gs:0x0050 */
123 uint64_t thread_local_storage; /* %gs:0x0058 */
124 uint64_t process_environment_block; /* %gs:0x0060 */
125 uint64_t last_error_number; /* %gs:0x0068 */
126 }
127thread_information_64;
128
129
130static const char* TIB_NAME[] =
131 {
132 " current_seh ", /* %fs:0x0000 */
133 " current_top_of_stack ", /* %fs:0x0004 */
134 " current_bottom_of_stack ", /* %fs:0x0008 */
135 " sub_system_tib ", /* %fs:0x000c */
136 " fiber_data ", /* %fs:0x0010 */
137 " arbitrary_data_slot ", /* %fs:0x0014 */
138 " linear_address_tib ", /* %fs:0x0018 */
139 " environment_pointer ", /* %fs:0x001c */
140 " process_id ", /* %fs:0x0020 */
141 " current_thread_id ", /* %fs:0x0024 */
142 " active_rpc_handle ", /* %fs:0x0028 */
143 " thread_local_storage ", /* %fs:0x002c */
144 " process_environment_block ", /* %fs:0x0030 */
145 " last_error_number " /* %fs:0x0034 */
146 };
147
581e13c1
MS		 148static const int MAX_TIB32 =
149 sizeof (thread_information_32) / sizeof (uint32_t);
150static const int MAX_TIB64 =
151 sizeof (thread_information_64) / sizeof (uint64_t);
711e434b
PM		 152static const int FULL_TIB_SIZE = 0x1000;
153
491144b5 154static bool maint_display_all_tib = false;
711e434b 155
7928d571
HD		 156static struct gdbarch_data *windows_gdbarch_data_handle;
157
158struct windows_gdbarch_data
159{
160 struct type *siginfo_type;
161};
162
163/* Allocate windows_gdbarch_data for an arch. */
164
165static void *
166init_windows_gdbarch_data (struct gdbarch *gdbarch)
167{
168 return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct windows_gdbarch_data);
169}
170
171/* Get windows_gdbarch_data of an arch. */
172
173static struct windows_gdbarch_data *
174get_windows_gdbarch_data (struct gdbarch *gdbarch)
175{
176 return ((struct windows_gdbarch_data *)
177 gdbarch_data (gdbarch, windows_gdbarch_data_handle));
178}
179
711e434b
PM		 180/* Define Thread Local Base pointer type. */
181
182static struct type *
183windows_get_tlb_type (struct gdbarch *gdbarch)
184{
ea1fae46
PM		 185 static struct gdbarch *last_gdbarch = NULL;
186 static struct type *last_tlb_type = NULL;
711e434b
PM		 187 struct type *dword_ptr_type, *dword32_type, *void_ptr_type;
188 struct type *peb_ldr_type, *peb_ldr_ptr_type;
870f88f7 189 struct type *peb_type, *peb_ptr_type, *list_type;
711e434b
PM		 190 struct type *module_list_ptr_type;
191 struct type *tib_type, *seh_type, *tib_ptr_type, *seh_ptr_type;
e0cdfe3c
HD		 192 struct type *word_type, *wchar_type, *wchar_ptr_type;
193 struct type *uni_str_type, *rupp_type, *rupp_ptr_type;
711e434b 194
ea1fae46
PM		 195 /* Do not rebuild type if same gdbarch as last time. */
196 if (last_tlb_type && last_gdbarch == gdbarch)
197 return last_tlb_type;
198
711e434b
PM		 199 dword_ptr_type = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch),
200 1, "DWORD_PTR");
201 dword32_type = arch_integer_type (gdbarch, 32,
202 1, "DWORD32");
e0cdfe3c
HD		 203 word_type = arch_integer_type (gdbarch, 16,
204 1, "WORD");
205 wchar_type = arch_integer_type (gdbarch, 16,
206 1, "wchar_t");
711e434b 207 void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
e0cdfe3c
HD		 208 wchar_ptr_type = arch_pointer_type (gdbarch, gdbarch_ptr_bit (gdbarch),
209 NULL, wchar_type);
711e434b
PM		 210
211 /* list entry */
212
213 list_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
214 TYPE_NAME (list_type) = xstrdup ("list");
215
711e434b
PM		 216 module_list_ptr_type = void_ptr_type;
217
581e13c1
MS		 218 append_composite_type_field (list_type, "forward_list",
219 module_list_ptr_type);
711e434b
PM		 220 append_composite_type_field (list_type, "backward_list",
221 module_list_ptr_type);
222
223 /* Structured Exception Handler */
224
225 seh_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
226 TYPE_NAME (seh_type) = xstrdup ("seh");
227
228 seh_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
77b7c781
UW		 229 TYPE_LENGTH (void_ptr_type) * TARGET_CHAR_BIT,
230 NULL);
711e434b
PM		 231 TYPE_TARGET_TYPE (seh_ptr_type) = seh_type;
232
233 append_composite_type_field (seh_type, "next_seh", seh_ptr_type);
e8e6c82e
PM		 234 append_composite_type_field (seh_type, "handler",
235 builtin_type (gdbarch)->builtin_func_ptr);
711e434b
PM		 236
237 /* struct _PEB_LDR_DATA */
238 peb_ldr_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
239 TYPE_NAME (peb_ldr_type) = xstrdup ("peb_ldr_data");
240
241 append_composite_type_field (peb_ldr_type, "length", dword32_type);
242 append_composite_type_field (peb_ldr_type, "initialized", dword32_type);
243 append_composite_type_field (peb_ldr_type, "ss_handle", void_ptr_type);
244 append_composite_type_field (peb_ldr_type, "in_load_order", list_type);
245 append_composite_type_field (peb_ldr_type, "in_memory_order", list_type);
246 append_composite_type_field (peb_ldr_type, "in_init_order", list_type);
247 append_composite_type_field (peb_ldr_type, "entry_in_progress",
248 void_ptr_type);
249 peb_ldr_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
77b7c781
UW		 250 TYPE_LENGTH (void_ptr_type) * TARGET_CHAR_BIT,
251 NULL);
711e434b
PM		 252 TYPE_TARGET_TYPE (peb_ldr_ptr_type) = peb_ldr_type;
253
e0cdfe3c
HD		 254 /* struct UNICODE_STRING */
255 uni_str_type = arch_composite_type (gdbarch, "unicode_string",
256 TYPE_CODE_STRUCT);
257
258 append_composite_type_field (uni_str_type, "length", word_type);
259 append_composite_type_field (uni_str_type, "maximum_length", word_type);
260 append_composite_type_field_aligned (uni_str_type, "buffer",
261 wchar_ptr_type,
262 TYPE_LENGTH (wchar_ptr_type));
263
264 /* struct _RTL_USER_PROCESS_PARAMETERS */
265 rupp_type = arch_composite_type (gdbarch, "rtl_user_process_parameters",
266 TYPE_CODE_STRUCT);
267
268 append_composite_type_field (rupp_type, "maximum_length", dword32_type);
269 append_composite_type_field (rupp_type, "length", dword32_type);
270 append_composite_type_field (rupp_type, "flags", dword32_type);
271 append_composite_type_field (rupp_type, "debug_flags", dword32_type);
272 append_composite_type_field (rupp_type, "console_handle", void_ptr_type);
273 append_composite_type_field (rupp_type, "console_flags", dword32_type);
274 append_composite_type_field_aligned (rupp_type, "standard_input",
275 void_ptr_type,
276 TYPE_LENGTH (void_ptr_type));
277 append_composite_type_field (rupp_type, "standard_output", void_ptr_type);
278 append_composite_type_field (rupp_type, "standard_error", void_ptr_type);
279 append_composite_type_field (rupp_type, "current_directory", uni_str_type);
280 append_composite_type_field (rupp_type, "current_directory_handle",
281 void_ptr_type);
282 append_composite_type_field (rupp_type, "dll_path", uni_str_type);
283 append_composite_type_field (rupp_type, "image_path_name", uni_str_type);
284 append_composite_type_field (rupp_type, "command_line", uni_str_type);
285 append_composite_type_field (rupp_type, "environment", void_ptr_type);
286 append_composite_type_field (rupp_type, "starting_x", dword32_type);
287 append_composite_type_field (rupp_type, "starting_y", dword32_type);
288 append_composite_type_field (rupp_type, "count_x", dword32_type);
289 append_composite_type_field (rupp_type, "count_y", dword32_type);
290 append_composite_type_field (rupp_type, "count_chars_x", dword32_type);
291 append_composite_type_field (rupp_type, "count_chars_y", dword32_type);
292 append_composite_type_field (rupp_type, "fill_attribute", dword32_type);
293 append_composite_type_field (rupp_type, "window_flags", dword32_type);
294 append_composite_type_field (rupp_type, "show_window_flags", dword32_type);
295 append_composite_type_field_aligned (rupp_type, "window_title",
296 uni_str_type,
297 TYPE_LENGTH (void_ptr_type));
298 append_composite_type_field (rupp_type, "desktop_info", uni_str_type);
299 append_composite_type_field (rupp_type, "shell_info", uni_str_type);
300 append_composite_type_field (rupp_type, "runtime_data", uni_str_type);
301
302 rupp_ptr_type = arch_pointer_type (gdbarch, gdbarch_ptr_bit (gdbarch),
303 NULL, rupp_type);
304
711e434b
PM		 305
306 /* struct process environment block */
307 peb_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
308 TYPE_NAME (peb_type) = xstrdup ("peb");
309
310 /* First bytes contain several flags. */
311 append_composite_type_field (peb_type, "flags", dword_ptr_type);
312 append_composite_type_field (peb_type, "mutant", void_ptr_type);
313 append_composite_type_field (peb_type, "image_base_address", void_ptr_type);
314 append_composite_type_field (peb_type, "ldr", peb_ldr_ptr_type);
e0cdfe3c 315 append_composite_type_field (peb_type, "process_parameters", rupp_ptr_type);
711e434b
PM		 316 append_composite_type_field (peb_type, "sub_system_data", void_ptr_type);
317 append_composite_type_field (peb_type, "process_heap", void_ptr_type);
318 append_composite_type_field (peb_type, "fast_peb_lock", void_ptr_type);
319 peb_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
77b7c781
UW		 320 TYPE_LENGTH (void_ptr_type) * TARGET_CHAR_BIT,
321 NULL);
711e434b
PM		 322 TYPE_TARGET_TYPE (peb_ptr_type) = peb_type;
323
324
325 /* struct thread information block */
326 tib_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
327 TYPE_NAME (tib_type) = xstrdup ("tib");
328
329 /* uint32_t current_seh; %fs:0x0000 */
330 append_composite_type_field (tib_type, "current_seh", seh_ptr_type);
331 /* uint32_t current_top_of_stack; %fs:0x0004 */
581e13c1
MS		 332 append_composite_type_field (tib_type, "current_top_of_stack",
333 void_ptr_type);
711e434b
PM		 334 /* uint32_t current_bottom_of_stack; %fs:0x0008 */
335 append_composite_type_field (tib_type, "current_bottom_of_stack",
336 void_ptr_type);
337 /* uint32_t sub_system_tib; %fs:0x000c */
338 append_composite_type_field (tib_type, "sub_system_tib", void_ptr_type);
339
340 /* uint32_t fiber_data; %fs:0x0010 */
341 append_composite_type_field (tib_type, "fiber_data", void_ptr_type);
342 /* uint32_t arbitrary_data_slot; %fs:0x0014 */
343 append_composite_type_field (tib_type, "arbitrary_data_slot", void_ptr_type);
344 /* uint32_t linear_address_tib; %fs:0x0018 */
345 append_composite_type_field (tib_type, "linear_address_tib", void_ptr_type);
346 /* uint32_t environment_pointer; %fs:0x001c */
347 append_composite_type_field (tib_type, "environment_pointer", void_ptr_type);
348 /* uint32_t process_id; %fs:0x0020 */
349 append_composite_type_field (tib_type, "process_id", dword_ptr_type);
350 /* uint32_t current_thread_id; %fs:0x0024 */
351 append_composite_type_field (tib_type, "thread_id", dword_ptr_type);
352 /* uint32_t active_rpc_handle; %fs:0x0028 */
353 append_composite_type_field (tib_type, "active_rpc_handle", dword_ptr_type);
354 /* uint32_t thread_local_storage; %fs:0x002c */
581e13c1
MS		 355 append_composite_type_field (tib_type, "thread_local_storage",
356 void_ptr_type);
711e434b
PM		 357 /* uint32_t process_environment_block; %fs:0x0030 */
358 append_composite_type_field (tib_type, "process_environment_block",
359 peb_ptr_type);
360 /* uint32_t last_error_number; %fs:0x0034 */
361 append_composite_type_field (tib_type, "last_error_number", dword_ptr_type);
362
363 tib_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
77b7c781
UW		 364 TYPE_LENGTH (void_ptr_type) * TARGET_CHAR_BIT,
365 NULL);
711e434b
PM		 366 TYPE_TARGET_TYPE (tib_ptr_type) = tib_type;
367
ea1fae46
PM		 368 last_tlb_type = tib_ptr_type;
369 last_gdbarch = gdbarch;
370
711e434b
PM		 371 return tib_ptr_type;
372}
373
374/* The $_tlb convenience variable is a bit special. We don't know
375 for sure the type of the value until we actually have a chance to
376 fetch the data. The type can change depending on gdbarch, so it is
377 also dependent on which thread you have selected. */
378
379/* This function implements the lval_computed support for reading a
380 $_tlb value. */
381
382static void
383tlb_value_read (struct value *val)
384{
385 CORE_ADDR tlb;
386 struct type *type = check_typedef (value_type (val));
387
388 if (!target_get_tib_address (inferior_ptid, &tlb))
389 error (_("Unable to read tlb"));
390 store_typed_address (value_contents_raw (val), type, tlb);
391}
392
393/* This function implements the lval_computed support for writing a
394 $_tlb value. */
395
396static void
397tlb_value_write (struct value *v, struct value *fromval)
398{
399 error (_("Impossible to change the Thread Local Base"));
400}
401
c8f2448a 402static const struct lval_funcs tlb_value_funcs =
711e434b
PM		 403 {
404 tlb_value_read,
405 tlb_value_write
406 };
407
408
409/* Return a new value with the correct type for the tlb object of
410 the current thread using architecture GDBARCH. Return a void value
411 if there's no object available. */
412
413static struct value *
22d2b532 414tlb_make_value (struct gdbarch *gdbarch, struct internalvar *var, void *ignore)
711e434b 415{
d7e15655 416 if (target_has_stack && inferior_ptid != null_ptid)
711e434b
PM		 417 {
418 struct type *type = windows_get_tlb_type (gdbarch);
419 return allocate_computed_value (type, &tlb_value_funcs, NULL);
420 }
421
422 return allocate_value (builtin_type (gdbarch)->builtin_void);
423}
424
425
426/* Display thread information block of a given thread. */
427
428static int
429display_one_tib (ptid_t ptid)
430{
431 gdb_byte *tib = NULL;
432 gdb_byte *index;
433 CORE_ADDR thread_local_base;
434 ULONGEST i, val, max, max_name, size, tib_size;
f5656ead
TT		 435 ULONGEST sizeof_ptr = gdbarch_ptr_bit (target_gdbarch ());
436 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
711e434b
PM		 437
438 if (sizeof_ptr == 64)
439 {
440 size = sizeof (uint64_t);
441 tib_size = sizeof (thread_information_64);
442 max = MAX_TIB64;
443 }
444 else
445 {
446 size = sizeof (uint32_t);
447 tib_size = sizeof (thread_information_32);
448 max = MAX_TIB32;
449 }
450
451 max_name = max;
452
453 if (maint_display_all_tib)
454 {
455 tib_size = FULL_TIB_SIZE;
456 max = tib_size / size;
457 }
458
224c3ddb 459 tib = (gdb_byte *) alloca (tib_size);
711e434b
PM		 460
461 if (target_get_tib_address (ptid, &thread_local_base) == 0)
462 {
463 printf_filtered (_("Unable to get thread local base for %s\n"),
a068643d 464 target_pid_to_str (ptid).c_str ());
711e434b
PM		 465 return -1;
466 }
467
8b88a78e 468 if (target_read (current_top_target (), TARGET_OBJECT_MEMORY,
711e434b
PM		 469 NULL, tib, thread_local_base, tib_size) != tib_size)
470 {
581e13c1
MS		 471 printf_filtered (_("Unable to read thread information "
472 "block for %s at address %s\n"),
a068643d
TT		 473 target_pid_to_str (ptid).c_str (),
474 paddress (target_gdbarch (), thread_local_base));
711e434b
PM		 475 return -1;
476 }
477
478 printf_filtered (_("Thread Information Block %s at %s\n"),
a068643d 479 target_pid_to_str (ptid).c_str (),
f5656ead 480 paddress (target_gdbarch (), thread_local_base));
711e434b
PM		 481
482 index = (gdb_byte *) tib;
483
484 /* All fields have the size of a pointer, this allows to iterate
485 using the same for loop for both layouts. */
486 for (i = 0; i < max; i++)
487 {
488 val = extract_unsigned_integer (index, size, byte_order);
489 if (i < max_name)
490 printf_filtered (_("%s is 0x%s\n"), TIB_NAME[i], phex (val, size));
491 else if (val != 0)
492 printf_filtered (_("TIB[0x%s] is 0x%s\n"), phex (i * size, 2),
493 phex (val, size));
494 index += size;
495 }
496 return 1;
497}
498
5d5658a1 499/* Display thread information block of the current thread. */
711e434b
PM		 500
501static void
c281872e 502display_tib (const char * args, int from_tty)
711e434b 503{
d7e15655 504 if (inferior_ptid != null_ptid)
711e434b
PM		 505 display_one_tib (inferior_ptid);
506}
bfb87e33
JB		 507
508void
dc05df57 509windows_xfer_shared_library (const char* so_name, CORE_ADDR load_addr,
c162ed3e 510 CORE_ADDR *text_offset_cached,
5af949e3 511 struct gdbarch *gdbarch, struct obstack *obstack)
bfb87e33 512{
c162ed3e 513 CORE_ADDR text_offset = text_offset_cached ? *text_offset_cached : 0;
3999122f 514
bfb87e33 515 obstack_grow_str (obstack, "<library name=\"");
5e187554
SM		 516 std::string p = xml_escape_text (so_name);
517 obstack_grow_str (obstack, p.c_str ());
5af949e3 518 obstack_grow_str (obstack, "\"><segment address=\"");
c162ed3e
HD		 519
520 if (!text_offset)
521 {
522 gdb_bfd_ref_ptr dll (gdb_bfd_open (so_name, gnutarget, -1));
523 /* The following calls are OK even if dll is NULL.
524 The default value 0x1000 is returned by pe_text_section_offset
525 in that case. */
526 text_offset = pe_text_section_offset (dll.get ());
527 if (text_offset_cached)
528 *text_offset_cached = text_offset;
529 }
530
3999122f 531 obstack_grow_str (obstack, paddress (gdbarch, load_addr + text_offset));
bfb87e33
JB		 532 obstack_grow_str (obstack, "\"/></library>");
533}
711e434b 534
a8e1bb34
JB		 535/* Implement the "iterate_over_objfiles_in_search_order" gdbarch
536 method. It searches all objfiles, starting with CURRENT_OBJFILE
537 first (if not NULL).
538
539 On Windows, the system behaves a little differently when two
540 objfiles each define a global symbol using the same name, compared
541 to other platforms such as GNU/Linux for instance. On GNU/Linux,
542 all instances of the symbol effectively get merged into a single
543 one, but on Windows, they remain distinct.
544
545 As a result, it usually makes sense to start global symbol searches
546 with the current objfile before expanding it to all other objfiles.
547 This helps for instance when a user debugs some code in a DLL that
548 refers to a global variable defined inside that DLL. When trying
549 to print the value of that global variable, it would be unhelpful
550 to print the value of another global variable defined with the same
551 name, but in a different DLL. */
552
64870a42 553static void
a8e1bb34
JB		 554windows_iterate_over_objfiles_in_search_order
555 (struct gdbarch *gdbarch,
556 iterate_over_objfiles_in_search_order_cb_ftype *cb,
557 void *cb_data, struct objfile *current_objfile)
558{
559 int stop;
a8e1bb34
JB		 560
561 if (current_objfile)
562 {
563 stop = cb (current_objfile, cb_data);
564 if (stop)
565 return;
566 }
567
2030c079 568 for (objfile *objfile : current_program_space->objfiles ())
a8e1bb34
JB		 569 {
570 if (objfile != current_objfile)
571 {
572 stop = cb (objfile, cb_data);
573 if (stop)
574 return;
575 }
576 }
577}
578
711e434b
PM		 579static void
580show_maint_show_all_tib (struct ui_file *file, int from_tty,
581 struct cmd_list_element *c, const char *value)
582{
581e13c1
MS		 583 fprintf_filtered (file, _("Show all non-zero elements of "
584 "Thread Information Block is %s.\n"), value);
711e434b
PM		 585}
586
587static void
981a3fb3 588info_w32_command (const char *args, int from_tty)
711e434b
PM		 589{
590 help_list (info_w32_cmdlist, "info w32 ", class_info, gdb_stdout);
591}
592
593static int w32_prefix_command_valid = 0;
594void
595init_w32_command_list (void)
596{
597 if (!w32_prefix_command_valid)
598 {
599 add_prefix_cmd ("w32", class_info, info_w32_command,
600 _("Print information specific to Win32 debugging."),
601 &info_w32_cmdlist, "info w32 ", 0, &infolist);
602 w32_prefix_command_valid = 1;
603 }
604}
605
559e7e50
EZ		 606/* Implementation of `gdbarch_gdb_signal_to_target'. */
607
608static int
609windows_gdb_signal_to_target (struct gdbarch *gdbarch, enum gdb_signal signal)
610{
611 switch (signal)
612 {
613 case GDB_SIGNAL_0:
614 return 0;
615 case GDB_SIGNAL_HUP:
616 return WINDOWS_SIGHUP;
617 case GDB_SIGNAL_INT:
618 return WINDOWS_SIGINT;
619 case GDB_SIGNAL_QUIT:
620 return WINDOWS_SIGQUIT;
621 case GDB_SIGNAL_ILL:
622 return WINDOWS_SIGILL;
623 case GDB_SIGNAL_TRAP:
624 return WINDOWS_SIGTRAP;
625 case GDB_SIGNAL_ABRT:
626 return WINDOWS_SIGABRT;
627 case GDB_SIGNAL_EMT:
628 return WINDOWS_SIGEMT;
629 case GDB_SIGNAL_FPE:
630 return WINDOWS_SIGFPE;
631 case GDB_SIGNAL_KILL:
632 return WINDOWS_SIGKILL;
633 case GDB_SIGNAL_BUS:
634 return WINDOWS_SIGBUS;
635 case GDB_SIGNAL_SEGV:
636 return WINDOWS_SIGSEGV;
637 case GDB_SIGNAL_SYS:
638 return WINDOWS_SIGSYS;
639 case GDB_SIGNAL_PIPE:
640 return WINDOWS_SIGPIPE;
641 case GDB_SIGNAL_ALRM:
642 return WINDOWS_SIGALRM;
643 case GDB_SIGNAL_TERM:
644 return WINDOWS_SIGTERM;
645#ifdef __CYGWIN__
646 case GDB_SIGNAL_URG:
647 return WINDOWS_SIGURG;
648 case GDB_SIGNAL_STOP:
649 return WINDOWS_SIGSTOP;
650 case GDB_SIGNAL_TSTP:
651 return WINDOWS_SIGTSTP;
652 case GDB_SIGNAL_CONT:
653 return WINDOWS_SIGCONT;
654 case GDB_SIGNAL_CHLD:
655 return WINDOWS_SIGCHLD;
656 case GDB_SIGNAL_TTIN:
657 return WINDOWS_SIGTTIN;
658 case GDB_SIGNAL_TTOU:
659 return WINDOWS_SIGTTOU;
660 case GDB_SIGNAL_IO:
661 return WINDOWS_SIGIO;
662 case GDB_SIGNAL_XCPU:
663 return WINDOWS_SIGXCPU;
664 case GDB_SIGNAL_XFSZ:
665 return WINDOWS_SIGXFSZ;
666 case GDB_SIGNAL_VTALRM:
667 return WINDOWS_SIGVTALRM;
668 case GDB_SIGNAL_PROF:
669 return WINDOWS_SIGPROF;
670 case GDB_SIGNAL_WINCH:
671 return WINDOWS_SIGWINCH;
672 case GDB_SIGNAL_PWR:
673 return WINDOWS_SIGLOST;
674 case GDB_SIGNAL_USR1:
675 return WINDOWS_SIGUSR1;
676 case GDB_SIGNAL_USR2:
677 return WINDOWS_SIGUSR2;
678#endif /* __CYGWIN__ */
679 }
680 return -1;
681}
682
6bafc845
HD		 683struct enum_value_name
684{
685 uint32_t value;
686 const char *name;
687};
688
689/* Allocate a TYPE_CODE_ENUM type structure with its named values. */
690
691static struct type *
692create_enum (struct gdbarch *gdbarch, int bit, const char *name,
693 const struct enum_value_name *values, int count)
694{
695 struct type *type;
696 int i;
697
698 type = arch_type (gdbarch, TYPE_CODE_ENUM, bit, name);
699 TYPE_NFIELDS (type) = count;
700 TYPE_FIELDS (type) = (struct field *)
701 TYPE_ZALLOC (type, sizeof (struct field) * count);
702 TYPE_UNSIGNED (type) = 1;
703
704 for (i = 0; i < count; i++)
705 {
706 TYPE_FIELD_NAME (type, i) = values[i].name;
707 SET_FIELD_ENUMVAL (TYPE_FIELD (type, i), values[i].value);
708 }
709
710 return type;
711}
712
713static const struct enum_value_name exception_values[] =
714{
715 { 0x40000015, "FATAL_APP_EXIT" },
716 { 0x40010005, "DBG_CONTROL_C" },
717 { 0x40010008, "DBG_CONTROL_BREAK" },
718 { 0x80000002, "DATATYPE_MISALIGNMENT" },
719 { 0x80000003, "BREAKPOINT" },
720 { 0x80000004, "SINGLE_STEP" },
721 { 0xC0000005, "ACCESS_VIOLATION" },
722 { 0xC0000006, "IN_PAGE_ERROR" },
723 { 0xC000001D, "ILLEGAL_INSTRUCTION" },
724 { 0xC0000025, "NONCONTINUABLE_EXCEPTION" },
725 { 0xC0000026, "INVALID_DISPOSITION" },
726 { 0xC000008C, "ARRAY_BOUNDS_EXCEEDED" },
727 { 0xC000008D, "FLOAT_DENORMAL_OPERAND" },
728 { 0xC000008E, "FLOAT_DIVIDE_BY_ZERO" },
729 { 0xC000008F, "FLOAT_INEXACT_RESULT" },
730 { 0xC0000090, "FLOAT_INVALID_OPERATION" },
731 { 0xC0000091, "FLOAT_OVERFLOW" },
732 { 0xC0000092, "FLOAT_STACK_CHECK" },
733 { 0xC0000093, "FLOAT_UNDERFLOW" },
734 { 0xC0000094, "INTEGER_DIVIDE_BY_ZERO" },
735 { 0xC0000095, "INTEGER_OVERFLOW" },
736 { 0xC0000096, "PRIV_INSTRUCTION" },
737 { 0xC00000FD, "STACK_OVERFLOW" },
738 { 0xC0000409, "FAST_FAIL" },
739};
740
741static const struct enum_value_name violation_values[] =
742{
743 { 0, "READ_ACCESS_VIOLATION" },
744 { 1, "WRITE_ACCESS_VIOLATION" },
745 { 8, "DATA_EXECUTION_PREVENTION_VIOLATION" },
746};
747
7928d571
HD		 748/* Implement the "get_siginfo_type" gdbarch method. */
749
750static struct type *
751windows_get_siginfo_type (struct gdbarch *gdbarch)
752{
753 struct windows_gdbarch_data *windows_gdbarch_data;
754 struct type *dword_type, *pvoid_type, *ulongptr_type;
6bafc845
HD		 755 struct type *code_enum, *violation_enum;
756 struct type *violation_type, *para_type, *siginfo_ptr_type, *siginfo_type;
7928d571
HD		 757
758 windows_gdbarch_data = get_windows_gdbarch_data (gdbarch);
759 if (windows_gdbarch_data->siginfo_type != NULL)
760 return windows_gdbarch_data->siginfo_type;
761
762 dword_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
763 1, "DWORD");
764 pvoid_type = arch_pointer_type (gdbarch, gdbarch_ptr_bit (gdbarch), "PVOID",
765 builtin_type (gdbarch)->builtin_void);
766 ulongptr_type = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch),
767 1, "ULONG_PTR");
768
6bafc845
HD		 769 /* ExceptionCode value names */
770 code_enum = create_enum (gdbarch, gdbarch_int_bit (gdbarch),
771 "ExceptionCode", exception_values,
772 ARRAY_SIZE (exception_values));
773
774 /* ACCESS_VIOLATION type names */
775 violation_enum = create_enum (gdbarch, gdbarch_ptr_bit (gdbarch),
776 "ViolationType", violation_values,
777 ARRAY_SIZE (violation_values));
778
779 /* ACCESS_VIOLATION information */
780 violation_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
781 append_composite_type_field (violation_type, "Type", violation_enum);
782 append_composite_type_field (violation_type, "Address", pvoid_type);
783
784 /* Unnamed union of the documented field ExceptionInformation,
785 and the alternative AccessViolationInformation (which displays
786 human-readable values for ExceptionCode ACCESS_VIOLATION). */
787 para_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
788 append_composite_type_field (para_type, "ExceptionInformation",
789 lookup_array_range_type (ulongptr_type, 0, 14));
790 append_composite_type_field (para_type, "AccessViolationInformation",
791 violation_type);
792
7928d571
HD		 793 siginfo_type = arch_composite_type (gdbarch, "EXCEPTION_RECORD",
794 TYPE_CODE_STRUCT);
795 siginfo_ptr_type = arch_pointer_type (gdbarch, gdbarch_ptr_bit (gdbarch),
796 NULL, siginfo_type);
797
6bafc845
HD		 798 /* ExceptionCode is documented as type DWORD, but here a helper
799 enum type is used instead to display a human-readable value. */
800 append_composite_type_field (siginfo_type, "ExceptionCode", code_enum);
7928d571
HD		 801 append_composite_type_field (siginfo_type, "ExceptionFlags", dword_type);
802 append_composite_type_field (siginfo_type, "ExceptionRecord",
803 siginfo_ptr_type);
804 append_composite_type_field (siginfo_type, "ExceptionAddress",
805 pvoid_type);
806 append_composite_type_field (siginfo_type, "NumberParameters", dword_type);
807 /* The 64-bit variant needs some padding. */
6bafc845
HD		 808 append_composite_type_field_aligned (siginfo_type, "",
809 para_type, TYPE_LENGTH (ulongptr_type));
7928d571
HD		 810
811 windows_gdbarch_data->siginfo_type = siginfo_type;
812
813 return siginfo_type;
814}
815
64870a42
YQ		 816/* To be called from the various GDB_OSABI_CYGWIN handlers for the
817 various Windows architectures and machine types. */
818
819void
820windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
821{
53375380
PA		 822 set_gdbarch_wchar_bit (gdbarch, 16);
823 set_gdbarch_wchar_signed (gdbarch, 0);
824
64870a42
YQ		 825 /* Canonical paths on this target look like
826 `c:\Program Files\Foo App\mydll.dll', for example. */
827 set_gdbarch_has_dos_based_file_system (gdbarch, 1);
828
829 set_gdbarch_iterate_over_objfiles_in_search_order
830 (gdbarch, windows_iterate_over_objfiles_in_search_order);
831
559e7e50
EZ		 832 set_gdbarch_gdb_signal_to_target (gdbarch, windows_gdb_signal_to_target);
833
64870a42 834 set_solib_ops (gdbarch, &solib_target_so_ops);
7928d571
HD		 835
836 set_gdbarch_get_siginfo_type (gdbarch, windows_get_siginfo_type);
64870a42
YQ		 837}
838
22d2b532
SDJ		 839/* Implementation of `tlb' variable. */
840
841static const struct internalvar_funcs tlb_funcs =
842{
843 tlb_make_value,
844 NULL,
845 NULL
846};
847
6c265988 848void _initialize_windows_tdep ();
711e434b 849void
6c265988 850_initialize_windows_tdep ()
711e434b 851{
7928d571
HD		 852 windows_gdbarch_data_handle
853 = gdbarch_data_register_post_init (init_windows_gdbarch_data);
854
711e434b
PM		 855 init_w32_command_list ();
856 add_cmd ("thread-information-block", class_info, display_tib,
857 _("Display thread information block."),
858 &info_w32_cmdlist);
859 add_alias_cmd ("tib", "thread-information-block", class_info, 1,
860 &info_w32_cmdlist);
861
862 add_setshow_boolean_cmd ("show-all-tib", class_maintenance,
863 &maint_display_all_tib, _("\
864Set whether to display all non-zero fields of thread information block."), _("\
865Show whether to display all non-zero fields of thread information block."), _("\
866Use \"on\" to enable, \"off\" to disable.\n\
867If enabled, all non-zero fields of thread information block are displayed,\n\
868even if their meaning is unknown."),
869 NULL,
870 show_maint_show_all_tib,
871 &maintenance_set_cmdlist,
872 &maintenance_show_cmdlist);
873
874 /* Explicitly create without lookup, since that tries to create a
875 value with a void typed value, and when we get here, gdbarch
876 isn't initialized yet. At this point, we're quite sure there
877 isn't another convenience variable of the same name. */
22d2b532 878 create_internalvar_type_lazy ("_tlb", &tlb_funcs, NULL);
711e434b 879}
GDB Binutils - Deliverables
This page took 1.352159 seconds and 4 git commands to generate.