]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/windows-tdep.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
gdb: remove target_gdbarch
[thirdparty/binutils-gdb.git] / gdb / windows-tdep.c
CommitLineData
213516ef 1/* Copyright (C) 2008-2023 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"
bf31fd38 20#include "gdbsupport/gdb_obstack.h"
bfb87e33 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"
64870a42
YQ		 33#include "solib.h"
34#include "solib-target.h"
2938e6cf 35#include "gdbcore.h"
584cf46d
HD		 36#include "coff/internal.h"
37#include "libcoff.h"
38#include "solist.h"
711e434b 39
8db52437
SM		 40#define CYGWIN_DLL_NAME "cygwin1.dll"
41
559e7e50 42/* Windows signal numbers differ between MinGW flavors and between
0f2265e2
SM		 43 those and Cygwin. The below enumerations were gleaned from the
44 respective headers. */
45
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. */
559e7e50
EZ		 48
49enum
0f2265e2
SM		 50{
51 WINDOWS_SIGHUP = 1, /* MinGW-w64 */
52 WINDOWS_SIGINT = 2,
53 WINDOWS_SIGQUIT = 3, /* MinGW-w64 */
54 WINDOWS_SIGILL = 4,
55 WINDOWS_SIGTRAP = 5, /* MinGW-w64 */
56 WINDOWS_SIGIOT = 6, /* MinGW-w64 */
57 WINDOWS_SIGEMT = 7, /* MinGW-w64 */
58 WINDOWS_SIGFPE = 8,
59 WINDOWS_SIGKILL = 9, /* MinGW-w64 */
60 WINDOWS_SIGBUS = 10, /* MinGW-w64 */
61 WINDOWS_SIGSEGV = 11,
62 WINDOWS_SIGSYS = 12, /* MinGW-w64 */
63 WINDOWS_SIGPIPE = 13, /* MinGW-w64 */
64 WINDOWS_SIGALRM = 14, /* MinGW-w64 */
65 WINDOWS_SIGTERM = 15,
66 WINDOWS_SIGBREAK = 21,
67 WINDOWS_SIGABRT = 22,
68};
69
70/* Signal numbers for Cygwin. */
71
72enum
73{
74 CYGWIN_SIGHUP = 1,
75 CYGWIN_SIGINT = 2,
76 CYGWIN_SIGQUIT = 3,
77 CYGWIN_SIGILL = 4,
78 CYGWIN_SIGTRAP = 5,
79 CYGWIN_SIGABRT = 6,
80 CYGWIN_SIGEMT = 7,
81 CYGWIN_SIGFPE = 8,
82 CYGWIN_SIGKILL = 9,
83 CYGWIN_SIGBUS = 10,
84 CYGWIN_SIGSEGV = 11,
85 CYGWIN_SIGSYS = 12,
86 CYGWIN_SIGPIPE = 13,
87 CYGWIN_SIGALRM = 14,
88 CYGWIN_SIGTERM = 15,
89 CYGWIN_SIGURG = 16,
90 CYGWIN_SIGSTOP = 17,
91 CYGWIN_SIGTSTP = 18,
92 CYGWIN_SIGCONT = 19,
93 CYGWIN_SIGCHLD = 20,
94 CYGWIN_SIGTTIN = 21,
95 CYGWIN_SIGTTOU = 22,
96 CYGWIN_SIGIO = 23,
97 CYGWIN_SIGXCPU = 24,
98 CYGWIN_SIGXFSZ = 25,
99 CYGWIN_SIGVTALRM = 26,
100 CYGWIN_SIGPROF = 27,
101 CYGWIN_SIGWINCH = 28,
102 CYGWIN_SIGLOST = 29,
103 CYGWIN_SIGUSR1 = 30,
104 CYGWIN_SIGUSR2 = 31,
105};
559e7e50 106
e7d612ad
JT		 107/* These constants are defined by Cygwin's core_dump.h */
108static constexpr unsigned int NOTE_INFO_MODULE = 3;
109static constexpr unsigned int NOTE_INFO_MODULE64 = 4;
110
711e434b
PM		 111struct cmd_list_element *info_w32_cmdlist;
112
113typedef struct thread_information_block_32
114 {
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 */
129 }
130thread_information_32;
131
132typedef struct thread_information_block_64
133 {
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 */
148 }
149thread_information_64;
150
151
152static const char* TIB_NAME[] =
153 {
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 */
168 };
169
581e13c1
MS		 170static const int MAX_TIB32 =
171 sizeof (thread_information_32) / sizeof (uint32_t);
172static const int MAX_TIB64 =
173 sizeof (thread_information_64) / sizeof (uint64_t);
711e434b
PM		 174static const int FULL_TIB_SIZE = 0x1000;
175
491144b5 176static bool maint_display_all_tib = false;
711e434b 177
7928d571
HD		 178struct windows_gdbarch_data
179{
cb275538
TT		 180 struct type *siginfo_type = nullptr;
181 /* Type of thread information block. */
182 struct type *tib_ptr_type = nullptr;
7928d571
HD		 183};
184
cb275538
TT		 185static const registry<gdbarch>::key<windows_gdbarch_data>
186 windows_gdbarch_data_handle;
7928d571
HD		 187
188/* Get windows_gdbarch_data of an arch. */
189
190static struct windows_gdbarch_data *
191get_windows_gdbarch_data (struct gdbarch *gdbarch)
192{
cb275538
TT		 193 windows_gdbarch_data *result = windows_gdbarch_data_handle.get (gdbarch);
194 if (result == nullptr)
195 result = windows_gdbarch_data_handle.emplace (gdbarch);
196 return result;
7928d571
HD		 197}
198
711e434b
PM		 199/* Define Thread Local Base pointer type. */
200
201static struct type *
202windows_get_tlb_type (struct gdbarch *gdbarch)
203{
204 struct type *dword_ptr_type, *dword32_type, *void_ptr_type;
205 struct type *peb_ldr_type, *peb_ldr_ptr_type;
870f88f7 206 struct type *peb_type, *peb_ptr_type, *list_type;
711e434b
PM		 207 struct type *module_list_ptr_type;
208 struct type *tib_type, *seh_type, *tib_ptr_type, *seh_ptr_type;
e0cdfe3c
HD		 209 struct type *word_type, *wchar_type, *wchar_ptr_type;
210 struct type *uni_str_type, *rupp_type, *rupp_ptr_type;
711e434b 211
cd5900f3
HD		 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;
216
cc495054
TT		 217 type_allocator alloc (gdbarch);
218
2d39ccd3 219 dword_ptr_type = init_integer_type (alloc, gdbarch_ptr_bit (gdbarch),
711e434b 220 1, "DWORD_PTR");
2d39ccd3 221 dword32_type = init_integer_type (alloc, 32,
711e434b 222 1, "DWORD32");
2d39ccd3 223 word_type = init_integer_type (alloc, 16,
e0cdfe3c 224 1, "WORD");
2d39ccd3 225 wchar_type = init_integer_type (alloc, 16,
e0cdfe3c 226 1, "wchar_t");
711e434b 227 void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
9c794d2d
TT		 228 wchar_ptr_type = init_pointer_type (alloc, gdbarch_ptr_bit (gdbarch),
229 nullptr, wchar_type);
711e434b
PM		 230
231 /* list entry */
232
233 list_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
d0e39ea2 234 list_type->set_name (xstrdup ("list"));
711e434b 235
711e434b
PM		 236 module_list_ptr_type = void_ptr_type;
237
581e13c1
MS		 238 append_composite_type_field (list_type, "forward_list",
239 module_list_ptr_type);
711e434b
PM		 240 append_composite_type_field (list_type, "backward_list",
241 module_list_ptr_type);
242
243 /* Structured Exception Handler */
244
245 seh_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
d0e39ea2 246 seh_type->set_name (xstrdup ("seh"));
711e434b 247
cc495054
TT		 248 seh_ptr_type = alloc.new_type (TYPE_CODE_PTR,
249 void_ptr_type->length () * TARGET_CHAR_BIT,
250 NULL);
8a50fdce 251 seh_ptr_type->set_target_type (seh_type);
711e434b
PM		 252
253 append_composite_type_field (seh_type, "next_seh", seh_ptr_type);
e8e6c82e
PM		 254 append_composite_type_field (seh_type, "handler",
255 builtin_type (gdbarch)->builtin_func_ptr);
711e434b
PM		 256
257 /* struct _PEB_LDR_DATA */
258 peb_ldr_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
d0e39ea2 259 peb_ldr_type->set_name (xstrdup ("peb_ldr_data"));
711e434b
PM		 260
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",
268 void_ptr_type);
cc495054
TT		 269 peb_ldr_ptr_type = alloc.new_type (TYPE_CODE_PTR,
270 void_ptr_type->length () * TARGET_CHAR_BIT,
271 NULL);
8a50fdce 272 peb_ldr_ptr_type->set_target_type (peb_ldr_type);
711e434b 273
e0cdfe3c
HD		 274 /* struct UNICODE_STRING */
275 uni_str_type = arch_composite_type (gdbarch, "unicode_string",
276 TYPE_CODE_STRUCT);
277
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",
281 wchar_ptr_type,
df86565b 282 wchar_ptr_type->length ());
e0cdfe3c
HD		 283
284 /* struct _RTL_USER_PROCESS_PARAMETERS */
285 rupp_type = arch_composite_type (gdbarch, "rtl_user_process_parameters",
286 TYPE_CODE_STRUCT);
287
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",
295 void_ptr_type,
df86565b 296 void_ptr_type->length ());
e0cdfe3c
HD		 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",
301 void_ptr_type);
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",
316 uni_str_type,
df86565b 317 void_ptr_type->length ());
e0cdfe3c
HD		 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);
321
9c794d2d
TT		 322 rupp_ptr_type = init_pointer_type (alloc, gdbarch_ptr_bit (gdbarch),
323 nullptr, rupp_type);
e0cdfe3c 324
711e434b
PM		 325
326 /* struct process environment block */
327 peb_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
d0e39ea2 328 peb_type->set_name (xstrdup ("peb"));
711e434b
PM		 329
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);
e0cdfe3c 335 append_composite_type_field (peb_type, "process_parameters", rupp_ptr_type);
711e434b
PM		 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);
cc495054
TT		 339 peb_ptr_type = alloc.new_type (TYPE_CODE_PTR,
340 void_ptr_type->length () * TARGET_CHAR_BIT,
341 NULL);
8a50fdce 342 peb_ptr_type->set_target_type (peb_type);
711e434b
PM		 343
344
345 /* struct thread information block */
346 tib_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
d0e39ea2 347 tib_type->set_name (xstrdup ("tib"));
711e434b
PM		 348
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 */
581e13c1
MS		 352 append_composite_type_field (tib_type, "current_top_of_stack",
353 void_ptr_type);
711e434b
PM		 354 /* uint32_t current_bottom_of_stack; %fs:0x0008 */
355 append_composite_type_field (tib_type, "current_bottom_of_stack",
356 void_ptr_type);
357 /* uint32_t sub_system_tib; %fs:0x000c */
358 append_composite_type_field (tib_type, "sub_system_tib", void_ptr_type);
359
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 */
581e13c1
MS		 375 append_composite_type_field (tib_type, "thread_local_storage",
376 void_ptr_type);
711e434b
PM		 377 /* uint32_t process_environment_block; %fs:0x0030 */
378 append_composite_type_field (tib_type, "process_environment_block",
379 peb_ptr_type);
380 /* uint32_t last_error_number; %fs:0x0034 */
381 append_composite_type_field (tib_type, "last_error_number", dword_ptr_type);
382
cc495054
TT		 383 tib_ptr_type = alloc.new_type (TYPE_CODE_PTR,
384 void_ptr_type->length () * TARGET_CHAR_BIT,
385 NULL);
8a50fdce 386 tib_ptr_type->set_target_type (tib_type);
711e434b 387
cd5900f3 388 windows_gdbarch_data->tib_ptr_type = tib_ptr_type;
ea1fae46 389
711e434b
PM		 390 return tib_ptr_type;
391}
392
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. */
397
398/* This function implements the lval_computed support for reading a
399 $_tlb value. */
400
401static void
402tlb_value_read (struct value *val)
403{
404 CORE_ADDR tlb;
d0c97917 405 struct type *type = check_typedef (val->type ());
711e434b
PM		 406
407 if (!target_get_tib_address (inferior_ptid, &tlb))
408 error (_("Unable to read tlb"));
bbe912ba 409 store_typed_address (val->contents_raw ().data (), type, tlb);
711e434b
PM		 410}
411
412/* This function implements the lval_computed support for writing a
413 $_tlb value. */
414
415static void
416tlb_value_write (struct value *v, struct value *fromval)
417{
418 error (_("Impossible to change the Thread Local Base"));
419}
420
c8f2448a 421static const struct lval_funcs tlb_value_funcs =
711e434b
PM		 422 {
423 tlb_value_read,
424 tlb_value_write
425 };
426
427
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. */
431
432static struct value *
22d2b532 433tlb_make_value (struct gdbarch *gdbarch, struct internalvar *var, void *ignore)
711e434b 434{
841de120 435 if (target_has_stack () && inferior_ptid != null_ptid)
711e434b
PM		 436 {
437 struct type *type = windows_get_tlb_type (gdbarch);
b64e2602 438 return value::allocate_computed (type, &tlb_value_funcs, NULL);
711e434b
PM		 439 }
440
317c3ed9 441 return value::allocate (builtin_type (gdbarch)->builtin_void);
711e434b
PM		 442}
443
444
445/* Display thread information block of a given thread. */
446
447static int
448display_one_tib (ptid_t ptid)
449{
450 gdb_byte *tib = NULL;
451 gdb_byte *index;
452 CORE_ADDR thread_local_base;
453 ULONGEST i, val, max, max_name, size, tib_size;
99d9c3b9
SM		 454 ULONGEST sizeof_ptr = gdbarch_ptr_bit (current_inferior ()->arch ());
455 bfd_endian byte_order = gdbarch_byte_order (current_inferior ()->arch ());
711e434b
PM		 456
457 if (sizeof_ptr == 64)
458 {
459 size = sizeof (uint64_t);
460 tib_size = sizeof (thread_information_64);
461 max = MAX_TIB64;
462 }
463 else
464 {
465 size = sizeof (uint32_t);
466 tib_size = sizeof (thread_information_32);
467 max = MAX_TIB32;
468 }
469
470 max_name = max;
471
472 if (maint_display_all_tib)
473 {
474 tib_size = FULL_TIB_SIZE;
475 max = tib_size / size;
476 }
477
224c3ddb 478 tib = (gdb_byte *) alloca (tib_size);
711e434b
PM		 479
480 if (target_get_tib_address (ptid, &thread_local_base) == 0)
481 {
6cb06a8c
TT		 482 gdb_printf (_("Unable to get thread local base for %s\n"),
483 target_pid_to_str (ptid).c_str ());
711e434b
PM		 484 return -1;
485 }
486
328d42d8 487 if (target_read (current_inferior ()->top_target (), TARGET_OBJECT_MEMORY,
711e434b
PM		 488 NULL, tib, thread_local_base, tib_size) != tib_size)
489 {
6cb06a8c
TT		 490 gdb_printf (_("Unable to read thread information "
491 "block for %s at address %s\n"),
492 target_pid_to_str (ptid).c_str (),
99d9c3b9 493 paddress (current_inferior ()->arch (), thread_local_base));
711e434b
PM		 494 return -1;
495 }
496
6cb06a8c
TT		 497 gdb_printf (_("Thread Information Block %s at %s\n"),
498 target_pid_to_str (ptid).c_str (),
99d9c3b9 499 paddress (current_inferior ()->arch (), thread_local_base));
711e434b
PM		 500
501 index = (gdb_byte *) tib;
502
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++)
506 {
507 val = extract_unsigned_integer (index, size, byte_order);
508 if (i < max_name)
6cb06a8c 509 gdb_printf (_("%s is 0x%s\n"), TIB_NAME[i], phex (val, size));
711e434b 510 else if (val != 0)
6cb06a8c
TT		 511 gdb_printf (_("TIB[0x%s] is 0x%s\n"), phex (i * size, 2),
512 phex (val, size));
711e434b
PM		 513 index += size;
514 }
515 return 1;
516}
517
5d5658a1 518/* Display thread information block of the current thread. */
711e434b
PM		 519
520static void
c281872e 521display_tib (const char * args, int from_tty)
711e434b 522{
d7e15655 523 if (inferior_ptid != null_ptid)
711e434b
PM		 524 display_one_tib (inferior_ptid);
525}
bfb87e33
JB		 526
527void
dc05df57 528windows_xfer_shared_library (const char* so_name, CORE_ADDR load_addr,
c162ed3e 529 CORE_ADDR *text_offset_cached,
5af949e3 530 struct gdbarch *gdbarch, struct obstack *obstack)
bfb87e33 531{
c162ed3e 532 CORE_ADDR text_offset = text_offset_cached ? *text_offset_cached : 0;
3999122f 533
bfb87e33 534 obstack_grow_str (obstack, "<library name=\"");
5e187554
SM		 535 std::string p = xml_escape_text (so_name);
536 obstack_grow_str (obstack, p.c_str ());
5af949e3 537 obstack_grow_str (obstack, "\"><segment address=\"");
c162ed3e
HD		 538
539 if (!text_offset)
540 {
ad80db5b 541 gdb_bfd_ref_ptr dll (gdb_bfd_open (so_name, gnutarget));
c162ed3e
HD		 542 /* The following calls are OK even if dll is NULL.
543 The default value 0x1000 is returned by pe_text_section_offset
544 in that case. */
545 text_offset = pe_text_section_offset (dll.get ());
546 if (text_offset_cached)
547 *text_offset_cached = text_offset;
548 }
549
3999122f 550 obstack_grow_str (obstack, paddress (gdbarch, load_addr + text_offset));
bfb87e33
JB		 551 obstack_grow_str (obstack, "\"/></library>");
552}
711e434b 553
a8e1bb34
JB		 554/* Implement the "iterate_over_objfiles_in_search_order" gdbarch
555 method. It searches all objfiles, starting with CURRENT_OBJFILE
556 first (if not NULL).
557
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.
563
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. */
571
64870a42 572static void
a8e1bb34 573windows_iterate_over_objfiles_in_search_order
6e9cd73e
SM		 574 (gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype cb,
575 objfile *current_objfile)
a8e1bb34 576{
a8e1bb34
JB		 577 if (current_objfile)
578 {
6e9cd73e 579 if (cb (current_objfile))
a8e1bb34
JB		 580 return;
581 }
582
2030c079 583 for (objfile *objfile : current_program_space->objfiles ())
6e9cd73e
SM		 584 if (objfile != current_objfile)
585 {
586 if (cb (objfile))
587 return;
588 }
a8e1bb34
JB		 589}
590
711e434b
PM		 591static void
592show_maint_show_all_tib (struct ui_file *file, int from_tty,
593 struct cmd_list_element *c, const char *value)
594{
6cb06a8c
TT		 595 gdb_printf (file, _("Show all non-zero elements of "
596 "Thread Information Block is %s.\n"), value);
711e434b
PM		 597}
598
45e1f031
TT		 599
600static int w32_prefix_command_valid = 0;
601void
602init_w32_command_list (void)
603{
604 if (!w32_prefix_command_valid)
605 {
606 add_basic_prefix_cmd
607 ("w32", class_info,
608 _("Print information specific to Win32 debugging."),
2f822da5 609 &info_w32_cmdlist, 0, &infolist);
45e1f031
TT		 610 w32_prefix_command_valid = 1;
611 }
612}
613
0f2265e2 614/* Implementation of `gdbarch_gdb_signal_to_target' for Windows. */
559e7e50
EZ		 615
616static int
617windows_gdb_signal_to_target (struct gdbarch *gdbarch, enum gdb_signal signal)
618{
619 switch (signal)
620 {
621 case GDB_SIGNAL_0:
622 return 0;
623 case GDB_SIGNAL_HUP:
624 return WINDOWS_SIGHUP;
625 case GDB_SIGNAL_INT:
626 return WINDOWS_SIGINT;
627 case GDB_SIGNAL_QUIT:
628 return WINDOWS_SIGQUIT;
629 case GDB_SIGNAL_ILL:
630 return WINDOWS_SIGILL;
631 case GDB_SIGNAL_TRAP:
632 return WINDOWS_SIGTRAP;
633 case GDB_SIGNAL_ABRT:
634 return WINDOWS_SIGABRT;
635 case GDB_SIGNAL_EMT:
636 return WINDOWS_SIGEMT;
637 case GDB_SIGNAL_FPE:
638 return WINDOWS_SIGFPE;
639 case GDB_SIGNAL_KILL:
640 return WINDOWS_SIGKILL;
641 case GDB_SIGNAL_BUS:
642 return WINDOWS_SIGBUS;
643 case GDB_SIGNAL_SEGV:
644 return WINDOWS_SIGSEGV;
645 case GDB_SIGNAL_SYS:
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;
0f2265e2
SM		 653 }
654 return -1;
655}
656
657/* Implementation of `gdbarch_gdb_signal_to_target' for Cygwin. */
658
659static int
660cygwin_gdb_signal_to_target (struct gdbarch *gdbarch, enum gdb_signal signal)
661{
662 switch (signal)
663 {
664 case GDB_SIGNAL_0:
665 return 0;
666 case GDB_SIGNAL_HUP:
667 return CYGWIN_SIGHUP;
668 case GDB_SIGNAL_INT:
669 return CYGWIN_SIGINT;
670 case GDB_SIGNAL_QUIT:
671 return CYGWIN_SIGQUIT;
672 case GDB_SIGNAL_ILL:
673 return CYGWIN_SIGILL;
674 case GDB_SIGNAL_TRAP:
675 return CYGWIN_SIGTRAP;
676 case GDB_SIGNAL_ABRT:
677 return CYGWIN_SIGABRT;
678 case GDB_SIGNAL_EMT:
679 return CYGWIN_SIGEMT;
680 case GDB_SIGNAL_FPE:
681 return CYGWIN_SIGFPE;
682 case GDB_SIGNAL_KILL:
683 return CYGWIN_SIGKILL;
684 case GDB_SIGNAL_BUS:
685 return CYGWIN_SIGBUS;
686 case GDB_SIGNAL_SEGV:
687 return CYGWIN_SIGSEGV;
688 case GDB_SIGNAL_SYS:
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;
559e7e50 696 case GDB_SIGNAL_URG:
0f2265e2 697 return CYGWIN_SIGURG;
559e7e50 698 case GDB_SIGNAL_STOP:
0f2265e2 699 return CYGWIN_SIGSTOP;
559e7e50 700 case GDB_SIGNAL_TSTP:
0f2265e2 701 return CYGWIN_SIGTSTP;
559e7e50 702 case GDB_SIGNAL_CONT:
0f2265e2 703 return CYGWIN_SIGCONT;
559e7e50 704 case GDB_SIGNAL_CHLD:
0f2265e2 705 return CYGWIN_SIGCHLD;
559e7e50 706 case GDB_SIGNAL_TTIN:
0f2265e2 707 return CYGWIN_SIGTTIN;
559e7e50 708 case GDB_SIGNAL_TTOU:
0f2265e2 709 return CYGWIN_SIGTTOU;
559e7e50 710 case GDB_SIGNAL_IO:
0f2265e2 711 return CYGWIN_SIGIO;
559e7e50 712 case GDB_SIGNAL_XCPU:
0f2265e2 713 return CYGWIN_SIGXCPU;
559e7e50 714 case GDB_SIGNAL_XFSZ:
0f2265e2 715 return CYGWIN_SIGXFSZ;
559e7e50 716 case GDB_SIGNAL_VTALRM:
0f2265e2 717 return CYGWIN_SIGVTALRM;
559e7e50 718 case GDB_SIGNAL_PROF:
0f2265e2 719 return CYGWIN_SIGPROF;
559e7e50 720 case GDB_SIGNAL_WINCH:
0f2265e2 721 return CYGWIN_SIGWINCH;
559e7e50 722 case GDB_SIGNAL_PWR:
0f2265e2 723 return CYGWIN_SIGLOST;
559e7e50 724 case GDB_SIGNAL_USR1:
0f2265e2 725 return CYGWIN_SIGUSR1;
559e7e50 726 case GDB_SIGNAL_USR2:
0f2265e2 727 return CYGWIN_SIGUSR2;
559e7e50
EZ		 728 }
729 return -1;
730}
731
6bafc845
HD		 732struct enum_value_name
733{
734 uint32_t value;
735 const char *name;
736};
737
738/* Allocate a TYPE_CODE_ENUM type structure with its named values. */
739
740static struct type *
741create_enum (struct gdbarch *gdbarch, int bit, const char *name,
742 const struct enum_value_name *values, int count)
743{
744 struct type *type;
745 int i;
746
cc495054 747 type = type_allocator (gdbarch).new_type (TYPE_CODE_ENUM, bit, name);
2774f2da 748 type->alloc_fields (count);
653223d3 749 type->set_is_unsigned (true);
6bafc845
HD		 750
751 for (i = 0; i < count; i++)
01add95b 752 {
d3fd12df 753 type->field (i).set_name (values[i].name);
cd3f655c 754 type->field (i).set_loc_enumval (values[i].value);
01add95b 755 }
6bafc845
HD		 756
757 return type;
758}
759
760static const struct enum_value_name exception_values[] =
761{
762 { 0x40000015, "FATAL_APP_EXIT" },
9852ceef
HD		 763 { 0x4000001E, "WX86_SINGLE_STEP" },
764 { 0x4000001F, "WX86_BREAKPOINT" },
6bafc845
HD		 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" },
788};
789
790static const struct enum_value_name violation_values[] =
791{
792 { 0, "READ_ACCESS_VIOLATION" },
793 { 1, "WRITE_ACCESS_VIOLATION" },
794 { 8, "DATA_EXECUTION_PREVENTION_VIOLATION" },
795};
796
7928d571
HD		 797/* Implement the "get_siginfo_type" gdbarch method. */
798
799static struct type *
800windows_get_siginfo_type (struct gdbarch *gdbarch)
801{
802 struct windows_gdbarch_data *windows_gdbarch_data;
803 struct type *dword_type, *pvoid_type, *ulongptr_type;
6bafc845
HD		 804 struct type *code_enum, *violation_enum;
805 struct type *violation_type, *para_type, *siginfo_ptr_type, *siginfo_type;
7928d571
HD		 806
807 windows_gdbarch_data = get_windows_gdbarch_data (gdbarch);
808 if (windows_gdbarch_data->siginfo_type != NULL)
809 return windows_gdbarch_data->siginfo_type;
810
2d39ccd3
TT		 811 type_allocator alloc (gdbarch);
812 dword_type = init_integer_type (alloc, gdbarch_int_bit (gdbarch),
7928d571 813 1, "DWORD");
9c794d2d 814 pvoid_type = init_pointer_type (alloc, gdbarch_ptr_bit (gdbarch), "PVOID",
7928d571 815 builtin_type (gdbarch)->builtin_void);
2d39ccd3 816 ulongptr_type = init_integer_type (alloc, gdbarch_ptr_bit (gdbarch),
7928d571
HD		 817 1, "ULONG_PTR");
818
6bafc845
HD		 819 /* ExceptionCode value names */
820 code_enum = create_enum (gdbarch, gdbarch_int_bit (gdbarch),
821 "ExceptionCode", exception_values,
822 ARRAY_SIZE (exception_values));
823
824 /* ACCESS_VIOLATION type names */
825 violation_enum = create_enum (gdbarch, gdbarch_ptr_bit (gdbarch),
826 "ViolationType", violation_values,
827 ARRAY_SIZE (violation_values));
828
829 /* ACCESS_VIOLATION information */
830 violation_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
831 append_composite_type_field (violation_type, "Type", violation_enum);
832 append_composite_type_field (violation_type, "Address", pvoid_type);
833
834 /* Unnamed union of the documented field ExceptionInformation,
835 and the alternative AccessViolationInformation (which displays
836 human-readable values for ExceptionCode ACCESS_VIOLATION). */
837 para_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
838 append_composite_type_field (para_type, "ExceptionInformation",
839 lookup_array_range_type (ulongptr_type, 0, 14));
840 append_composite_type_field (para_type, "AccessViolationInformation",
841 violation_type);
842
7928d571
HD		 843 siginfo_type = arch_composite_type (gdbarch, "EXCEPTION_RECORD",
844 TYPE_CODE_STRUCT);
9c794d2d
TT		 845 siginfo_ptr_type = init_pointer_type (alloc, gdbarch_ptr_bit (gdbarch),
846 nullptr, siginfo_type);
7928d571 847
6bafc845
HD		 848 /* ExceptionCode is documented as type DWORD, but here a helper
849 enum type is used instead to display a human-readable value. */
850 append_composite_type_field (siginfo_type, "ExceptionCode", code_enum);
7928d571
HD		 851 append_composite_type_field (siginfo_type, "ExceptionFlags", dword_type);
852 append_composite_type_field (siginfo_type, "ExceptionRecord",
853 siginfo_ptr_type);
854 append_composite_type_field (siginfo_type, "ExceptionAddress",
855 pvoid_type);
856 append_composite_type_field (siginfo_type, "NumberParameters", dword_type);
857 /* The 64-bit variant needs some padding. */
6bafc845 858 append_composite_type_field_aligned (siginfo_type, "",
df86565b 859 para_type, ulongptr_type->length ());
7928d571
HD		 860
861 windows_gdbarch_data->siginfo_type = siginfo_type;
862
863 return siginfo_type;
864}
865
584cf46d
HD		 866/* Implement the "solib_create_inferior_hook" target_so_ops method. */
867
868static void
869windows_solib_create_inferior_hook (int from_tty)
870{
871 CORE_ADDR exec_base = 0;
872
873 /* Find base address of main executable in
874 TIB->process_environment_block->image_base_address. */
99d9c3b9 875 gdbarch *gdbarch = current_inferior ()->arch ();
584cf46d
HD		 876 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
877 int ptr_bytes;
878 int peb_offset; /* Offset of process_environment_block in TIB. */
879 int base_offset; /* Offset of image_base_address in PEB. */
880 if (gdbarch_ptr_bit (gdbarch) == 32)
881 {
882 ptr_bytes = 4;
883 peb_offset = 48;
884 base_offset = 8;
885 }
886 else
887 {
888 ptr_bytes = 8;
889 peb_offset = 96;
890 base_offset = 16;
891 }
892 CORE_ADDR tlb;
893 gdb_byte buf[8];
55f6301a 894 if (target_has_execution ()
b7d64b29 895 && target_get_tib_address (inferior_ptid, &tlb)
584cf46d
HD		 896 && !target_read_memory (tlb + peb_offset, buf, ptr_bytes))
897 {
898 CORE_ADDR peb = extract_unsigned_integer (buf, ptr_bytes, byte_order);
899 if (!target_read_memory (peb + base_offset, buf, ptr_bytes))
900 exec_base = extract_unsigned_integer (buf, ptr_bytes, byte_order);
901 }
902
903 /* Rebase executable if the base address changed because of ASLR. */
a42d7dd8 904 if (current_program_space->symfile_object_file != nullptr && exec_base != 0)
584cf46d 905 {
7e10abd1
TT		 906 CORE_ADDR vmaddr
907 = pe_data (current_program_space->exec_bfd ())->pe_opthdr.ImageBase;
584cf46d 908 if (vmaddr != exec_base)
a42d7dd8
TT		 909 objfile_rebase (current_program_space->symfile_object_file,
910 exec_base - vmaddr);
584cf46d
HD		 911 }
912}
913
914static struct target_so_ops windows_so_ops;
915
0f2265e2
SM		 916/* Common parts for gdbarch initialization for the Windows and Cygwin OS
917 ABIs. */
64870a42 918
0f2265e2
SM		 919static void
920windows_init_abi_common (struct gdbarch_info info, struct gdbarch *gdbarch)
64870a42 921{
53375380
PA		 922 set_gdbarch_wchar_bit (gdbarch, 16);
923 set_gdbarch_wchar_signed (gdbarch, 0);
924
64870a42
YQ		 925 /* Canonical paths on this target look like
926 `c:\Program Files\Foo App\mydll.dll', for example. */
927 set_gdbarch_has_dos_based_file_system (gdbarch, 1);
928
929 set_gdbarch_iterate_over_objfiles_in_search_order
930 (gdbarch, windows_iterate_over_objfiles_in_search_order);
931
584cf46d
HD		 932 windows_so_ops = solib_target_so_ops;
933 windows_so_ops.solib_create_inferior_hook
934 = windows_solib_create_inferior_hook;
9e468e95 935 set_gdbarch_so_ops (gdbarch, &windows_so_ops);
7928d571
HD		 936
937 set_gdbarch_get_siginfo_type (gdbarch, windows_get_siginfo_type);
64870a42
YQ		 938}
939
0f2265e2
SM		 940/* See windows-tdep.h. */
941void
942windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
943{
944 windows_init_abi_common (info, gdbarch);
945 set_gdbarch_gdb_signal_to_target (gdbarch, windows_gdb_signal_to_target);
946}
947
948/* See windows-tdep.h. */
949
950void
951cygwin_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
952{
953 windows_init_abi_common (info, gdbarch);
954 set_gdbarch_gdb_signal_to_target (gdbarch, cygwin_gdb_signal_to_target);
955}
956
22d2b532
SDJ		 957/* Implementation of `tlb' variable. */
958
959static const struct internalvar_funcs tlb_funcs =
960{
961 tlb_make_value,
962 NULL,
22d2b532
SDJ		 963};
964
8db52437
SM		 965/* Layout of an element of a PE's Import Directory Table. Based on:
966
967 https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#import-directory-table
968 */
969
970struct pe_import_directory_entry
971{
972 uint32_t import_lookup_table_rva;
973 uint32_t timestamp;
974 uint32_t forwarder_chain;
975 uint32_t name_rva;
976 uint32_t import_address_table_rva;
977};
978
979gdb_static_assert (sizeof (pe_import_directory_entry) == 20);
980
981/* See windows-tdep.h. */
982
983bool
984is_linked_with_cygwin_dll (bfd *abfd)
985{
986 /* The list of DLLs a PE is linked to is in the .idata section. See:
987
988 https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#the-idata-section
989 */
990 asection *idata_section = bfd_get_section_by_name (abfd, ".idata");
991 if (idata_section == nullptr)
992 return false;
993
00ac85d3
SM		 994 bfd_size_type idata_section_size = bfd_section_size (idata_section);
995 internal_extra_pe_aouthdr *pe_extra = &pe_data (abfd)->pe_opthdr;
996 bfd_vma import_table_va = pe_extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
997 bfd_vma idata_section_va = bfd_section_vma (idata_section);
998
999 /* The section's virtual address as reported by BFD has the image base applied,
1000 remove it. */
1001 gdb_assert (idata_section_va >= pe_extra->ImageBase);
1002 idata_section_va -= pe_extra->ImageBase;
1003
1004 bfd_vma idata_section_end_va = idata_section_va + idata_section_size;
1005
1006 /* Make sure that the import table is indeed within the .idata section's range. */
1007 if (import_table_va < idata_section_va
1008 || import_table_va >= idata_section_end_va)
1009 {
1010 warning (_("\
29136be7
AM		 1011%s: import table's virtual address (%s) is outside .idata \
1012section's range [%s, %s]."),
1013 bfd_get_filename (abfd), hex_string (import_table_va),
1014 hex_string (idata_section_va),
1015 hex_string (idata_section_end_va));
00ac85d3
SM		 1016 return false;
1017 }
1018
1019 /* The import table starts at this offset into the .idata section. */
1020 bfd_vma import_table_offset_in_sect = import_table_va - idata_section_va;
8db52437 1021
e0fc5c3f
SM		 1022 /* Get the section's data. */
1023 gdb::byte_vector idata_contents;
1024 if (!gdb_bfd_get_full_section_contents (abfd, idata_section, &idata_contents))
8db52437 1025 {
16197208
SM		 1026 warning (_("%s: failed to get contents of .idata section."),
1027 bfd_get_filename (abfd));
8db52437
SM		 1028 return false;
1029 }
1030
00ac85d3
SM		 1031 gdb_assert (idata_contents.size () == idata_section_size);
1032
1033 const gdb_byte *iter = idata_contents.data () + import_table_offset_in_sect;
1034 const gdb_byte *end = idata_contents.data () + idata_section_size;
8db52437
SM		 1035 const pe_import_directory_entry null_dir_entry = { 0 };
1036
1037 /* Iterate through all directory entries. */
1038 while (true)
1039 {
1040 /* Is there enough space left in the section for another entry? */
1041 if (iter + sizeof (pe_import_directory_entry) > end)
1042 {
16197208
SM		 1043 warning (_("%s: unexpected end of .idata section."),
1044 bfd_get_filename (abfd));
8db52437
SM		 1045 break;
1046 }
1047
1048 pe_import_directory_entry *dir_entry = (pe_import_directory_entry *) iter;
1049
1050 /* Is it the end of list marker? */
1051 if (memcmp (dir_entry, &null_dir_entry,
1052 sizeof (pe_import_directory_entry)) == 0)
1053 break;
1054
00ac85d3 1055 bfd_vma name_va = dir_entry->name_rva;
8db52437
SM		 1056
1057 /* If the name's virtual address is smaller than the section's virtual
dda83cd7 1058 address, there's a problem. */
00ac85d3 1059 if (name_va < idata_section_va || name_va >= idata_section_end_va)
8db52437
SM		 1060 {
1061 warning (_("\
29136be7
AM		 1062%s: name's virtual address (%s) is outside .idata section's \
1063range [%s, %s]."),
1064 bfd_get_filename (abfd), hex_string (name_va),
1065 hex_string (idata_section_va),
1066 hex_string (idata_section_end_va));
8db52437
SM		 1067 break;
1068 }
1069
00ac85d3 1070 const gdb_byte *name = &idata_contents[name_va - idata_section_va];
8db52437 1071
29514b87
TT		 1072 /* Make sure we don't overshoot the end of the section with the
1073 streq. */
1074 if (name + sizeof (CYGWIN_DLL_NAME) <= end)
1075 {
1076 /* Finally, check if this is the dll name we are looking for. */
1077 if (streq ((const char *) name, CYGWIN_DLL_NAME))
1078 return true;
1079 }
8db52437 1080
2836752f 1081 iter += sizeof (pe_import_directory_entry);
8db52437
SM		 1082 }
1083
29514b87 1084 return false;
8db52437
SM		 1085}
1086
62a5151b
JT		 1087struct cpms_data
1088{
1089 struct gdbarch *gdbarch;
1090 struct obstack *obstack;
1091 int module_count;
1092};
1093
1094static void
1095core_process_module_section (bfd *abfd, asection *sect, void *obj)
1096{
1097 struct cpms_data *data = (struct cpms_data *) obj;
1098 enum bfd_endian byte_order = gdbarch_byte_order (data->gdbarch);
1099
e7d612ad 1100 unsigned int data_type;
62a5151b
JT		 1101 char *module_name;
1102 size_t module_name_size;
e7d612ad 1103 size_t module_name_offset;
62a5151b
JT		 1104 CORE_ADDR base_addr;
1105
62a5151b
JT		 1106 if (!startswith (sect->name, ".module"))
1107 return;
1108
5bd1d4c1 1109 gdb::byte_vector buf (bfd_section_size (sect) + 1);
62a5151b 1110 if (!bfd_get_section_contents (abfd, sect,
5bd1d4c1
TT		 1111 buf.data (), 0, bfd_section_size (sect)))
1112 return;
1113 /* We're going to treat part of the buffer as a string, so make sure
1114 it is NUL-terminated. */
1115 buf.back () = 0;
62a5151b
JT		 1116
1117 /* A DWORD (data_type) followed by struct windows_core_module_info. */
5bd1d4c1
TT		 1118 if (bfd_section_size (sect) < 4)
1119 return;
1120 data_type = extract_unsigned_integer (buf.data (), 4, byte_order);
62a5151b 1121
e7d612ad
JT		 1122 if (data_type == NOTE_INFO_MODULE)
1123 {
e7d612ad 1124 module_name_offset = 12;
5bd1d4c1
TT		 1125 if (bfd_section_size (sect) < module_name_offset)
1126 return;
1127 base_addr = extract_unsigned_integer (&buf[4], 4, byte_order);
1128 module_name_size = extract_unsigned_integer (&buf[8], 4, byte_order);
e7d612ad
JT		 1129 }
1130 else if (data_type == NOTE_INFO_MODULE64)
1131 {
e7d612ad 1132 module_name_offset = 16;
5bd1d4c1
TT		 1133 if (bfd_section_size (sect) < module_name_offset)
1134 return;
1135 base_addr = extract_unsigned_integer (&buf[4], 8, byte_order);
1136 module_name_size = extract_unsigned_integer (&buf[12], 4, byte_order);
e7d612ad
JT		 1137 }
1138 else
5bd1d4c1 1139 return;
62a5151b 1140
e7d612ad 1141 if (module_name_offset + module_name_size > bfd_section_size (sect))
5bd1d4c1
TT		 1142 return;
1143 module_name = (char *) buf.data () + module_name_offset;
62a5151b
JT		 1144
1145 /* The first module is the .exe itself. */
1146 if (data->module_count != 0)
1147 windows_xfer_shared_library (module_name, base_addr,
1148 NULL, data->gdbarch, data->obstack);
1149 data->module_count++;
62a5151b
JT		 1150}
1151
1152ULONGEST
1153windows_core_xfer_shared_libraries (struct gdbarch *gdbarch,
1154 gdb_byte *readbuf,
1155 ULONGEST offset, ULONGEST len)
1156{
1157 struct obstack obstack;
1158 const char *buf;
1159 ULONGEST len_avail;
1160 struct cpms_data data = { gdbarch, &obstack, 0 };
1161
1162 obstack_init (&obstack);
1163 obstack_grow_str (&obstack, "<library-list>\n");
1164 bfd_map_over_sections (core_bfd,
1165 core_process_module_section,
1166 &data);
1167 obstack_grow_str0 (&obstack, "</library-list>\n");
1168
1169 buf = (const char *) obstack_finish (&obstack);
1170 len_avail = strlen (buf);
1171 if (offset >= len_avail)
1172 return 0;
1173
1174 if (len > len_avail - offset)
1175 len = len_avail - offset;
1176 memcpy (readbuf, buf + offset, len);
1177
1178 obstack_free (&obstack, NULL);
1179 return len;
1180}
1181
1182/* This is how we want PTIDs from core files to be printed. */
1183
1184std::string
1185windows_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
1186{
1187 if (ptid.lwp () != 0)
1188 return string_printf ("Thread 0x%lx", ptid.lwp ());
1189
1190 return normal_pid_to_str (ptid);
1191}
1192
6c265988 1193void _initialize_windows_tdep ();
711e434b 1194void
6c265988 1195_initialize_windows_tdep ()
711e434b 1196{
45e1f031 1197 init_w32_command_list ();
5e84b7ee
SM		 1198 cmd_list_element *info_w32_thread_information_block_cmd
1199 = add_cmd ("thread-information-block", class_info, display_tib,
1200 _("Display thread information block."),
1201 &info_w32_cmdlist);
1202 add_alias_cmd ("tib", info_w32_thread_information_block_cmd, class_info, 1,
711e434b
PM		 1203 &info_w32_cmdlist);
1204
1205 add_setshow_boolean_cmd ("show-all-tib", class_maintenance,
1206 &maint_display_all_tib, _("\
1207Set whether to display all non-zero fields of thread information block."), _("\
1208Show whether to display all non-zero fields of thread information block."), _("\
1209Use \"on\" to enable, \"off\" to disable.\n\
1210If enabled, all non-zero fields of thread information block are displayed,\n\
1211even if their meaning is unknown."),
1212 NULL,
1213 show_maint_show_all_tib,
1214 &maintenance_set_cmdlist,
1215 &maintenance_show_cmdlist);
1216
1217 /* Explicitly create without lookup, since that tries to create a
1218 value with a void typed value, and when we get here, gdbarch
1219 isn't initialized yet. At this point, we're quite sure there
1220 isn't another convenience variable of the same name. */
22d2b532 1221 create_internalvar_type_lazy ("_tlb", &tlb_funcs, NULL);
711e434b 1222}
A mirror of the official binutils-gdb repository