1 /* Copyright (C) 2008-2020 Free Software Foundation, Inc. 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" 19 #include "windows-tdep.h" 20 #include "gdb_obstack.h" 21 #include "xml-support.h" 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" 29 #include "objfiles.h" 30 #include "symfile.h" 31 #include "coff-pe-read.h" 32 #include "gdb_bfd.h" 33 #include "complaints.h" 34 #include "solib.h" 35 #include "solib-target.h" 36 #include "gdbcore.h" 37 #include "coff/internal.h" 38 #include "libcoff.h" 39 #include "solist.h" 40 41 #define CYGWIN_DLL_NAME "cygwin1.dll" 42 43 /* Windows signal numbers differ between MinGW flavors and between 44 those and Cygwin. The below enumerations were gleaned from the 45 respective headers. */ 46 47 /* Signal numbers for the various MinGW flavors. The ones marked with 48 MinGW-w64 are defined by MinGW-w64, not by mingw.org's MinGW. */ 49 50 enum 51 { 52 WINDOWS_SIGHUP = 1, /* MinGW-w64 */ 53 WINDOWS_SIGINT = 2, 54 WINDOWS_SIGQUIT = 3, /* MinGW-w64 */ 55 WINDOWS_SIGILL = 4, 56 WINDOWS_SIGTRAP = 5, /* MinGW-w64 */ 57 WINDOWS_SIGIOT = 6, /* MinGW-w64 */ 58 WINDOWS_SIGEMT = 7, /* MinGW-w64 */ 59 WINDOWS_SIGFPE = 8, 60 WINDOWS_SIGKILL = 9, /* MinGW-w64 */ 61 WINDOWS_SIGBUS = 10, /* MinGW-w64 */ 62 WINDOWS_SIGSEGV = 11, 63 WINDOWS_SIGSYS = 12, /* MinGW-w64 */ 64 WINDOWS_SIGPIPE = 13, /* MinGW-w64 */ 65 WINDOWS_SIGALRM = 14, /* MinGW-w64 */ 66 WINDOWS_SIGTERM = 15, 67 WINDOWS_SIGBREAK = 21, 68 WINDOWS_SIGABRT = 22, 69 }; 70 71 /* Signal numbers for Cygwin. */ 72 73 enum 74 { 75 CYGWIN_SIGHUP = 1, 76 CYGWIN_SIGINT = 2, 77 CYGWIN_SIGQUIT = 3, 78 CYGWIN_SIGILL = 4, 79 CYGWIN_SIGTRAP = 5, 80 CYGWIN_SIGABRT = 6, 81 CYGWIN_SIGEMT = 7, 82 CYGWIN_SIGFPE = 8, 83 CYGWIN_SIGKILL = 9, 84 CYGWIN_SIGBUS = 10, 85 CYGWIN_SIGSEGV = 11, 86 CYGWIN_SIGSYS = 12, 87 CYGWIN_SIGPIPE = 13, 88 CYGWIN_SIGALRM = 14, 89 CYGWIN_SIGTERM = 15, 90 CYGWIN_SIGURG = 16, 91 CYGWIN_SIGSTOP = 17, 92 CYGWIN_SIGTSTP = 18, 93 CYGWIN_SIGCONT = 19, 94 CYGWIN_SIGCHLD = 20, 95 CYGWIN_SIGTTIN = 21, 96 CYGWIN_SIGTTOU = 22, 97 CYGWIN_SIGIO = 23, 98 CYGWIN_SIGXCPU = 24, 99 CYGWIN_SIGXFSZ = 25, 100 CYGWIN_SIGVTALRM = 26, 101 CYGWIN_SIGPROF = 27, 102 CYGWIN_SIGWINCH = 28, 103 CYGWIN_SIGLOST = 29, 104 CYGWIN_SIGUSR1 = 30, 105 CYGWIN_SIGUSR2 = 31, 106 }; 107 108 struct cmd_list_element *info_w32_cmdlist; 109 110 typedef struct thread_information_block_32 111 { 112 uint32_t current_seh; /* %fs:0x0000 */ 113 uint32_t current_top_of_stack; /* %fs:0x0004 */ 114 uint32_t current_bottom_of_stack; /* %fs:0x0008 */ 115 uint32_t sub_system_tib; /* %fs:0x000c */ 116 uint32_t fiber_data; /* %fs:0x0010 */ 117 uint32_t arbitrary_data_slot; /* %fs:0x0014 */ 118 uint32_t linear_address_tib; /* %fs:0x0018 */ 119 uint32_t environment_pointer; /* %fs:0x001c */ 120 uint32_t process_id; /* %fs:0x0020 */ 121 uint32_t current_thread_id; /* %fs:0x0024 */ 122 uint32_t active_rpc_handle; /* %fs:0x0028 */ 123 uint32_t thread_local_storage; /* %fs:0x002c */ 124 uint32_t process_environment_block; /* %fs:0x0030 */ 125 uint32_t last_error_number; /* %fs:0x0034 */ 126 } 127 thread_information_32; 128 129 typedef struct thread_information_block_64 130 { 131 uint64_t current_seh; /* %gs:0x0000 */ 132 uint64_t current_top_of_stack; /* %gs:0x0008 */ 133 uint64_t current_bottom_of_stack; /* %gs:0x0010 */ 134 uint64_t sub_system_tib; /* %gs:0x0018 */ 135 uint64_t fiber_data; /* %gs:0x0020 */ 136 uint64_t arbitrary_data_slot; /* %gs:0x0028 */ 137 uint64_t linear_address_tib; /* %gs:0x0030 */ 138 uint64_t environment_pointer; /* %gs:0x0038 */ 139 uint64_t process_id; /* %gs:0x0040 */ 140 uint64_t current_thread_id; /* %gs:0x0048 */ 141 uint64_t active_rpc_handle; /* %gs:0x0050 */ 142 uint64_t thread_local_storage; /* %gs:0x0058 */ 143 uint64_t process_environment_block; /* %gs:0x0060 */ 144 uint64_t last_error_number; /* %gs:0x0068 */ 145 } 146 thread_information_64; 147 148 149 static const char* TIB_NAME[] = 150 { 151 " current_seh ", /* %fs:0x0000 */ 152 " current_top_of_stack ", /* %fs:0x0004 */ 153 " current_bottom_of_stack ", /* %fs:0x0008 */ 154 " sub_system_tib ", /* %fs:0x000c */ 155 " fiber_data ", /* %fs:0x0010 */ 156 " arbitrary_data_slot ", /* %fs:0x0014 */ 157 " linear_address_tib ", /* %fs:0x0018 */ 158 " environment_pointer ", /* %fs:0x001c */ 159 " process_id ", /* %fs:0x0020 */ 160 " current_thread_id ", /* %fs:0x0024 */ 161 " active_rpc_handle ", /* %fs:0x0028 */ 162 " thread_local_storage ", /* %fs:0x002c */ 163 " process_environment_block ", /* %fs:0x0030 */ 164 " last_error_number " /* %fs:0x0034 */ 165 }; 166 167 static const int MAX_TIB32 = 168 sizeof (thread_information_32) / sizeof (uint32_t); 169 static const int MAX_TIB64 = 170 sizeof (thread_information_64) / sizeof (uint64_t); 171 static const int FULL_TIB_SIZE = 0x1000; 172 173 static bool maint_display_all_tib = false; 174 175 static struct gdbarch_data *windows_gdbarch_data_handle; 176 177 struct windows_gdbarch_data 178 { 179 struct type *siginfo_type; 180 struct type *tib_ptr_type; /* Type of thread information block */ 181 }; 182 183 /* Allocate windows_gdbarch_data for an arch. */ 184 185 static void * 186 init_windows_gdbarch_data (struct gdbarch *gdbarch) 187 { 188 return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct windows_gdbarch_data); 189 } 190 191 /* Get windows_gdbarch_data of an arch. */ 192 193 static struct windows_gdbarch_data * 194 get_windows_gdbarch_data (struct gdbarch *gdbarch) 195 { 196 return ((struct windows_gdbarch_data *) 197 gdbarch_data (gdbarch, windows_gdbarch_data_handle)); 198 } 199 200 /* Define Thread Local Base pointer type. */ 201 202 static struct type * 203 windows_get_tlb_type (struct gdbarch *gdbarch) 204 { 205 struct type *dword_ptr_type, *dword32_type, *void_ptr_type; 206 struct type *peb_ldr_type, *peb_ldr_ptr_type; 207 struct type *peb_type, *peb_ptr_type, *list_type; 208 struct type *module_list_ptr_type; 209 struct type *tib_type, *seh_type, *tib_ptr_type, *seh_ptr_type; 210 struct type *word_type, *wchar_type, *wchar_ptr_type; 211 struct type *uni_str_type, *rupp_type, *rupp_ptr_type; 212 213 windows_gdbarch_data *windows_gdbarch_data 214 = get_windows_gdbarch_data (gdbarch); 215 if (windows_gdbarch_data->tib_ptr_type != nullptr) 216 return windows_gdbarch_data->tib_ptr_type; 217 218 dword_ptr_type = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 219 1, "DWORD_PTR"); 220 dword32_type = arch_integer_type (gdbarch, 32, 221 1, "DWORD32"); 222 word_type = arch_integer_type (gdbarch, 16, 223 1, "WORD"); 224 wchar_type = arch_integer_type (gdbarch, 16, 225 1, "wchar_t"); 226 void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void); 227 wchar_ptr_type = arch_pointer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 228 NULL, wchar_type); 229 230 /* list entry */ 231 232 list_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 233 list_type->set_name (xstrdup ("list")); 234 235 module_list_ptr_type = void_ptr_type; 236 237 append_composite_type_field (list_type, "forward_list", 238 module_list_ptr_type); 239 append_composite_type_field (list_type, "backward_list", 240 module_list_ptr_type); 241 242 /* Structured Exception Handler */ 243 244 seh_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 245 seh_type->set_name (xstrdup ("seh")); 246 247 seh_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR, 248 TYPE_LENGTH (void_ptr_type) * TARGET_CHAR_BIT, 249 NULL); 250 TYPE_TARGET_TYPE (seh_ptr_type) = seh_type; 251 252 append_composite_type_field (seh_type, "next_seh", seh_ptr_type); 253 append_composite_type_field (seh_type, "handler", 254 builtin_type (gdbarch)->builtin_func_ptr); 255 256 /* struct _PEB_LDR_DATA */ 257 peb_ldr_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 258 peb_ldr_type->set_name (xstrdup ("peb_ldr_data")); 259 260 append_composite_type_field (peb_ldr_type, "length", dword32_type); 261 append_composite_type_field (peb_ldr_type, "initialized", dword32_type); 262 append_composite_type_field (peb_ldr_type, "ss_handle", void_ptr_type); 263 append_composite_type_field (peb_ldr_type, "in_load_order", list_type); 264 append_composite_type_field (peb_ldr_type, "in_memory_order", list_type); 265 append_composite_type_field (peb_ldr_type, "in_init_order", list_type); 266 append_composite_type_field (peb_ldr_type, "entry_in_progress", 267 void_ptr_type); 268 peb_ldr_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR, 269 TYPE_LENGTH (void_ptr_type) * TARGET_CHAR_BIT, 270 NULL); 271 TYPE_TARGET_TYPE (peb_ldr_ptr_type) = peb_ldr_type; 272 273 /* struct UNICODE_STRING */ 274 uni_str_type = arch_composite_type (gdbarch, "unicode_string", 275 TYPE_CODE_STRUCT); 276 277 append_composite_type_field (uni_str_type, "length", word_type); 278 append_composite_type_field (uni_str_type, "maximum_length", word_type); 279 append_composite_type_field_aligned (uni_str_type, "buffer", 280 wchar_ptr_type, 281 TYPE_LENGTH (wchar_ptr_type)); 282 283 /* struct _RTL_USER_PROCESS_PARAMETERS */ 284 rupp_type = arch_composite_type (gdbarch, "rtl_user_process_parameters", 285 TYPE_CODE_STRUCT); 286 287 append_composite_type_field (rupp_type, "maximum_length", dword32_type); 288 append_composite_type_field (rupp_type, "length", dword32_type); 289 append_composite_type_field (rupp_type, "flags", dword32_type); 290 append_composite_type_field (rupp_type, "debug_flags", dword32_type); 291 append_composite_type_field (rupp_type, "console_handle", void_ptr_type); 292 append_composite_type_field (rupp_type, "console_flags", dword32_type); 293 append_composite_type_field_aligned (rupp_type, "standard_input", 294 void_ptr_type, 295 TYPE_LENGTH (void_ptr_type)); 296 append_composite_type_field (rupp_type, "standard_output", void_ptr_type); 297 append_composite_type_field (rupp_type, "standard_error", void_ptr_type); 298 append_composite_type_field (rupp_type, "current_directory", uni_str_type); 299 append_composite_type_field (rupp_type, "current_directory_handle", 300 void_ptr_type); 301 append_composite_type_field (rupp_type, "dll_path", uni_str_type); 302 append_composite_type_field (rupp_type, "image_path_name", uni_str_type); 303 append_composite_type_field (rupp_type, "command_line", uni_str_type); 304 append_composite_type_field (rupp_type, "environment", void_ptr_type); 305 append_composite_type_field (rupp_type, "starting_x", dword32_type); 306 append_composite_type_field (rupp_type, "starting_y", dword32_type); 307 append_composite_type_field (rupp_type, "count_x", dword32_type); 308 append_composite_type_field (rupp_type, "count_y", dword32_type); 309 append_composite_type_field (rupp_type, "count_chars_x", dword32_type); 310 append_composite_type_field (rupp_type, "count_chars_y", dword32_type); 311 append_composite_type_field (rupp_type, "fill_attribute", dword32_type); 312 append_composite_type_field (rupp_type, "window_flags", dword32_type); 313 append_composite_type_field (rupp_type, "show_window_flags", dword32_type); 314 append_composite_type_field_aligned (rupp_type, "window_title", 315 uni_str_type, 316 TYPE_LENGTH (void_ptr_type)); 317 append_composite_type_field (rupp_type, "desktop_info", uni_str_type); 318 append_composite_type_field (rupp_type, "shell_info", uni_str_type); 319 append_composite_type_field (rupp_type, "runtime_data", uni_str_type); 320 321 rupp_ptr_type = arch_pointer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 322 NULL, rupp_type); 323 324 325 /* struct process environment block */ 326 peb_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 327 peb_type->set_name (xstrdup ("peb")); 328 329 /* First bytes contain several flags. */ 330 append_composite_type_field (peb_type, "flags", dword_ptr_type); 331 append_composite_type_field (peb_type, "mutant", void_ptr_type); 332 append_composite_type_field (peb_type, "image_base_address", void_ptr_type); 333 append_composite_type_field (peb_type, "ldr", peb_ldr_ptr_type); 334 append_composite_type_field (peb_type, "process_parameters", rupp_ptr_type); 335 append_composite_type_field (peb_type, "sub_system_data", void_ptr_type); 336 append_composite_type_field (peb_type, "process_heap", void_ptr_type); 337 append_composite_type_field (peb_type, "fast_peb_lock", void_ptr_type); 338 peb_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR, 339 TYPE_LENGTH (void_ptr_type) * TARGET_CHAR_BIT, 340 NULL); 341 TYPE_TARGET_TYPE (peb_ptr_type) = peb_type; 342 343 344 /* struct thread information block */ 345 tib_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 346 tib_type->set_name (xstrdup ("tib")); 347 348 /* uint32_t current_seh; %fs:0x0000 */ 349 append_composite_type_field (tib_type, "current_seh", seh_ptr_type); 350 /* uint32_t current_top_of_stack; %fs:0x0004 */ 351 append_composite_type_field (tib_type, "current_top_of_stack", 352 void_ptr_type); 353 /* uint32_t current_bottom_of_stack; %fs:0x0008 */ 354 append_composite_type_field (tib_type, "current_bottom_of_stack", 355 void_ptr_type); 356 /* uint32_t sub_system_tib; %fs:0x000c */ 357 append_composite_type_field (tib_type, "sub_system_tib", void_ptr_type); 358 359 /* uint32_t fiber_data; %fs:0x0010 */ 360 append_composite_type_field (tib_type, "fiber_data", void_ptr_type); 361 /* uint32_t arbitrary_data_slot; %fs:0x0014 */ 362 append_composite_type_field (tib_type, "arbitrary_data_slot", void_ptr_type); 363 /* uint32_t linear_address_tib; %fs:0x0018 */ 364 append_composite_type_field (tib_type, "linear_address_tib", void_ptr_type); 365 /* uint32_t environment_pointer; %fs:0x001c */ 366 append_composite_type_field (tib_type, "environment_pointer", void_ptr_type); 367 /* uint32_t process_id; %fs:0x0020 */ 368 append_composite_type_field (tib_type, "process_id", dword_ptr_type); 369 /* uint32_t current_thread_id; %fs:0x0024 */ 370 append_composite_type_field (tib_type, "thread_id", dword_ptr_type); 371 /* uint32_t active_rpc_handle; %fs:0x0028 */ 372 append_composite_type_field (tib_type, "active_rpc_handle", dword_ptr_type); 373 /* uint32_t thread_local_storage; %fs:0x002c */ 374 append_composite_type_field (tib_type, "thread_local_storage", 375 void_ptr_type); 376 /* uint32_t process_environment_block; %fs:0x0030 */ 377 append_composite_type_field (tib_type, "process_environment_block", 378 peb_ptr_type); 379 /* uint32_t last_error_number; %fs:0x0034 */ 380 append_composite_type_field (tib_type, "last_error_number", dword_ptr_type); 381 382 tib_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR, 383 TYPE_LENGTH (void_ptr_type) * TARGET_CHAR_BIT, 384 NULL); 385 TYPE_TARGET_TYPE (tib_ptr_type) = tib_type; 386 387 windows_gdbarch_data->tib_ptr_type = tib_ptr_type; 388 389 return tib_ptr_type; 390 } 391 392 /* The $_tlb convenience variable is a bit special. We don't know 393 for sure the type of the value until we actually have a chance to 394 fetch the data. The type can change depending on gdbarch, so it is 395 also dependent on which thread you have selected. */ 396 397 /* This function implements the lval_computed support for reading a 398 $_tlb value. */ 399 400 static void 401 tlb_value_read (struct value *val) 402 { 403 CORE_ADDR tlb; 404 struct type *type = check_typedef (value_type (val)); 405 406 if (!target_get_tib_address (inferior_ptid, &tlb)) 407 error (_("Unable to read tlb")); 408 store_typed_address (value_contents_raw (val), type, tlb); 409 } 410 411 /* This function implements the lval_computed support for writing a 412 $_tlb value. */ 413 414 static void 415 tlb_value_write (struct value *v, struct value *fromval) 416 { 417 error (_("Impossible to change the Thread Local Base")); 418 } 419 420 static const struct lval_funcs tlb_value_funcs = 421 { 422 tlb_value_read, 423 tlb_value_write 424 }; 425 426 427 /* Return a new value with the correct type for the tlb object of 428 the current thread using architecture GDBARCH. Return a void value 429 if there's no object available. */ 430 431 static struct value * 432 tlb_make_value (struct gdbarch *gdbarch, struct internalvar *var, void *ignore) 433 { 434 if (target_has_stack && inferior_ptid != null_ptid) 435 { 436 struct type *type = windows_get_tlb_type (gdbarch); 437 return allocate_computed_value (type, &tlb_value_funcs, NULL); 438 } 439 440 return allocate_value (builtin_type (gdbarch)->builtin_void); 441 } 442 443 444 /* Display thread information block of a given thread. */ 445 446 static int 447 display_one_tib (ptid_t ptid) 448 { 449 gdb_byte *tib = NULL; 450 gdb_byte *index; 451 CORE_ADDR thread_local_base; 452 ULONGEST i, val, max, max_name, size, tib_size; 453 ULONGEST sizeof_ptr = gdbarch_ptr_bit (target_gdbarch ()); 454 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); 455 456 if (sizeof_ptr == 64) 457 { 458 size = sizeof (uint64_t); 459 tib_size = sizeof (thread_information_64); 460 max = MAX_TIB64; 461 } 462 else 463 { 464 size = sizeof (uint32_t); 465 tib_size = sizeof (thread_information_32); 466 max = MAX_TIB32; 467 } 468 469 max_name = max; 470 471 if (maint_display_all_tib) 472 { 473 tib_size = FULL_TIB_SIZE; 474 max = tib_size / size; 475 } 476 477 tib = (gdb_byte *) alloca (tib_size); 478 479 if (target_get_tib_address (ptid, &thread_local_base) == 0) 480 { 481 printf_filtered (_("Unable to get thread local base for %s\n"), 482 target_pid_to_str (ptid).c_str ()); 483 return -1; 484 } 485 486 if (target_read (current_top_target (), TARGET_OBJECT_MEMORY, 487 NULL, tib, thread_local_base, tib_size) != tib_size) 488 { 489 printf_filtered (_("Unable to read thread information " 490 "block for %s at address %s\n"), 491 target_pid_to_str (ptid).c_str (), 492 paddress (target_gdbarch (), thread_local_base)); 493 return -1; 494 } 495 496 printf_filtered (_("Thread Information Block %s at %s\n"), 497 target_pid_to_str (ptid).c_str (), 498 paddress (target_gdbarch (), thread_local_base)); 499 500 index = (gdb_byte *) tib; 501 502 /* All fields have the size of a pointer, this allows to iterate 503 using the same for loop for both layouts. */ 504 for (i = 0; i < max; i++) 505 { 506 val = extract_unsigned_integer (index, size, byte_order); 507 if (i < max_name) 508 printf_filtered (_("%s is 0x%s\n"), TIB_NAME[i], phex (val, size)); 509 else if (val != 0) 510 printf_filtered (_("TIB[0x%s] is 0x%s\n"), phex (i * size, 2), 511 phex (val, size)); 512 index += size; 513 } 514 return 1; 515 } 516 517 /* Display thread information block of the current thread. */ 518 519 static void 520 display_tib (const char * args, int from_tty) 521 { 522 if (inferior_ptid != null_ptid) 523 display_one_tib (inferior_ptid); 524 } 525 526 void 527 windows_xfer_shared_library (const char* so_name, CORE_ADDR load_addr, 528 CORE_ADDR *text_offset_cached, 529 struct gdbarch *gdbarch, struct obstack *obstack) 530 { 531 CORE_ADDR text_offset = text_offset_cached ? *text_offset_cached : 0; 532 533 obstack_grow_str (obstack, "<library name=\""); 534 std::string p = xml_escape_text (so_name); 535 obstack_grow_str (obstack, p.c_str ()); 536 obstack_grow_str (obstack, "\"><segment address=\""); 537 538 if (!text_offset) 539 { 540 gdb_bfd_ref_ptr dll (gdb_bfd_open (so_name, gnutarget)); 541 /* The following calls are OK even if dll is NULL. 542 The default value 0x1000 is returned by pe_text_section_offset 543 in that case. */ 544 text_offset = pe_text_section_offset (dll.get ()); 545 if (text_offset_cached) 546 *text_offset_cached = text_offset; 547 } 548 549 obstack_grow_str (obstack, paddress (gdbarch, load_addr + text_offset)); 550 obstack_grow_str (obstack, "\"/></library>"); 551 } 552 553 /* Implement the "iterate_over_objfiles_in_search_order" gdbarch 554 method. It searches all objfiles, starting with CURRENT_OBJFILE 555 first (if not NULL). 556 557 On Windows, the system behaves a little differently when two 558 objfiles each define a global symbol using the same name, compared 559 to other platforms such as GNU/Linux for instance. On GNU/Linux, 560 all instances of the symbol effectively get merged into a single 561 one, but on Windows, they remain distinct. 562 563 As a result, it usually makes sense to start global symbol searches 564 with the current objfile before expanding it to all other objfiles. 565 This helps for instance when a user debugs some code in a DLL that 566 refers to a global variable defined inside that DLL. When trying 567 to print the value of that global variable, it would be unhelpful 568 to print the value of another global variable defined with the same 569 name, but in a different DLL. */ 570 571 static void 572 windows_iterate_over_objfiles_in_search_order 573 (struct gdbarch *gdbarch, 574 iterate_over_objfiles_in_search_order_cb_ftype *cb, 575 void *cb_data, struct objfile *current_objfile) 576 { 577 int stop; 578 579 if (current_objfile) 580 { 581 stop = cb (current_objfile, cb_data); 582 if (stop) 583 return; 584 } 585 586 for (objfile *objfile : current_program_space->objfiles ()) 587 { 588 if (objfile != current_objfile) 589 { 590 stop = cb (objfile, cb_data); 591 if (stop) 592 return; 593 } 594 } 595 } 596 597 static void 598 show_maint_show_all_tib (struct ui_file *file, int from_tty, 599 struct cmd_list_element *c, const char *value) 600 { 601 fprintf_filtered (file, _("Show all non-zero elements of " 602 "Thread Information Block is %s.\n"), value); 603 } 604 605 606 static int w32_prefix_command_valid = 0; 607 void 608 init_w32_command_list (void) 609 { 610 if (!w32_prefix_command_valid) 611 { 612 add_basic_prefix_cmd 613 ("w32", class_info, 614 _("Print information specific to Win32 debugging."), 615 &info_w32_cmdlist, "info w32 ", 0, &infolist); 616 w32_prefix_command_valid = 1; 617 } 618 } 619 620 /* Implementation of `gdbarch_gdb_signal_to_target' for Windows. */ 621 622 static int 623 windows_gdb_signal_to_target (struct gdbarch *gdbarch, enum gdb_signal signal) 624 { 625 switch (signal) 626 { 627 case GDB_SIGNAL_0: 628 return 0; 629 case GDB_SIGNAL_HUP: 630 return WINDOWS_SIGHUP; 631 case GDB_SIGNAL_INT: 632 return WINDOWS_SIGINT; 633 case GDB_SIGNAL_QUIT: 634 return WINDOWS_SIGQUIT; 635 case GDB_SIGNAL_ILL: 636 return WINDOWS_SIGILL; 637 case GDB_SIGNAL_TRAP: 638 return WINDOWS_SIGTRAP; 639 case GDB_SIGNAL_ABRT: 640 return WINDOWS_SIGABRT; 641 case GDB_SIGNAL_EMT: 642 return WINDOWS_SIGEMT; 643 case GDB_SIGNAL_FPE: 644 return WINDOWS_SIGFPE; 645 case GDB_SIGNAL_KILL: 646 return WINDOWS_SIGKILL; 647 case GDB_SIGNAL_BUS: 648 return WINDOWS_SIGBUS; 649 case GDB_SIGNAL_SEGV: 650 return WINDOWS_SIGSEGV; 651 case GDB_SIGNAL_SYS: 652 return WINDOWS_SIGSYS; 653 case GDB_SIGNAL_PIPE: 654 return WINDOWS_SIGPIPE; 655 case GDB_SIGNAL_ALRM: 656 return WINDOWS_SIGALRM; 657 case GDB_SIGNAL_TERM: 658 return WINDOWS_SIGTERM; 659 } 660 return -1; 661 } 662 663 /* Implementation of `gdbarch_gdb_signal_to_target' for Cygwin. */ 664 665 static int 666 cygwin_gdb_signal_to_target (struct gdbarch *gdbarch, enum gdb_signal signal) 667 { 668 switch (signal) 669 { 670 case GDB_SIGNAL_0: 671 return 0; 672 case GDB_SIGNAL_HUP: 673 return CYGWIN_SIGHUP; 674 case GDB_SIGNAL_INT: 675 return CYGWIN_SIGINT; 676 case GDB_SIGNAL_QUIT: 677 return CYGWIN_SIGQUIT; 678 case GDB_SIGNAL_ILL: 679 return CYGWIN_SIGILL; 680 case GDB_SIGNAL_TRAP: 681 return CYGWIN_SIGTRAP; 682 case GDB_SIGNAL_ABRT: 683 return CYGWIN_SIGABRT; 684 case GDB_SIGNAL_EMT: 685 return CYGWIN_SIGEMT; 686 case GDB_SIGNAL_FPE: 687 return CYGWIN_SIGFPE; 688 case GDB_SIGNAL_KILL: 689 return CYGWIN_SIGKILL; 690 case GDB_SIGNAL_BUS: 691 return CYGWIN_SIGBUS; 692 case GDB_SIGNAL_SEGV: 693 return CYGWIN_SIGSEGV; 694 case GDB_SIGNAL_SYS: 695 return CYGWIN_SIGSYS; 696 case GDB_SIGNAL_PIPE: 697 return CYGWIN_SIGPIPE; 698 case GDB_SIGNAL_ALRM: 699 return CYGWIN_SIGALRM; 700 case GDB_SIGNAL_TERM: 701 return CYGWIN_SIGTERM; 702 case GDB_SIGNAL_URG: 703 return CYGWIN_SIGURG; 704 case GDB_SIGNAL_STOP: 705 return CYGWIN_SIGSTOP; 706 case GDB_SIGNAL_TSTP: 707 return CYGWIN_SIGTSTP; 708 case GDB_SIGNAL_CONT: 709 return CYGWIN_SIGCONT; 710 case GDB_SIGNAL_CHLD: 711 return CYGWIN_SIGCHLD; 712 case GDB_SIGNAL_TTIN: 713 return CYGWIN_SIGTTIN; 714 case GDB_SIGNAL_TTOU: 715 return CYGWIN_SIGTTOU; 716 case GDB_SIGNAL_IO: 717 return CYGWIN_SIGIO; 718 case GDB_SIGNAL_XCPU: 719 return CYGWIN_SIGXCPU; 720 case GDB_SIGNAL_XFSZ: 721 return CYGWIN_SIGXFSZ; 722 case GDB_SIGNAL_VTALRM: 723 return CYGWIN_SIGVTALRM; 724 case GDB_SIGNAL_PROF: 725 return CYGWIN_SIGPROF; 726 case GDB_SIGNAL_WINCH: 727 return CYGWIN_SIGWINCH; 728 case GDB_SIGNAL_PWR: 729 return CYGWIN_SIGLOST; 730 case GDB_SIGNAL_USR1: 731 return CYGWIN_SIGUSR1; 732 case GDB_SIGNAL_USR2: 733 return CYGWIN_SIGUSR2; 734 } 735 return -1; 736 } 737 738 struct enum_value_name 739 { 740 uint32_t value; 741 const char *name; 742 }; 743 744 /* Allocate a TYPE_CODE_ENUM type structure with its named values. */ 745 746 static struct type * 747 create_enum (struct gdbarch *gdbarch, int bit, const char *name, 748 const struct enum_value_name *values, int count) 749 { 750 struct type *type; 751 int i; 752 753 type = arch_type (gdbarch, TYPE_CODE_ENUM, bit, name); 754 type->set_num_fields (count); 755 type->set_fields 756 ((struct field *) TYPE_ZALLOC (type, sizeof (struct field) * count)); 757 TYPE_UNSIGNED (type) = 1; 758 759 for (i = 0; i < count; i++) 760 { 761 TYPE_FIELD_NAME (type, i) = values[i].name; 762 SET_FIELD_ENUMVAL (type->field (i), values[i].value); 763 } 764 765 return type; 766 } 767 768 static const struct enum_value_name exception_values[] = 769 { 770 { 0x40000015, "FATAL_APP_EXIT" }, 771 { 0x4000001E, "WX86_SINGLE_STEP" }, 772 { 0x4000001F, "WX86_BREAKPOINT" }, 773 { 0x40010005, "DBG_CONTROL_C" }, 774 { 0x40010008, "DBG_CONTROL_BREAK" }, 775 { 0x80000002, "DATATYPE_MISALIGNMENT" }, 776 { 0x80000003, "BREAKPOINT" }, 777 { 0x80000004, "SINGLE_STEP" }, 778 { 0xC0000005, "ACCESS_VIOLATION" }, 779 { 0xC0000006, "IN_PAGE_ERROR" }, 780 { 0xC000001D, "ILLEGAL_INSTRUCTION" }, 781 { 0xC0000025, "NONCONTINUABLE_EXCEPTION" }, 782 { 0xC0000026, "INVALID_DISPOSITION" }, 783 { 0xC000008C, "ARRAY_BOUNDS_EXCEEDED" }, 784 { 0xC000008D, "FLOAT_DENORMAL_OPERAND" }, 785 { 0xC000008E, "FLOAT_DIVIDE_BY_ZERO" }, 786 { 0xC000008F, "FLOAT_INEXACT_RESULT" }, 787 { 0xC0000090, "FLOAT_INVALID_OPERATION" }, 788 { 0xC0000091, "FLOAT_OVERFLOW" }, 789 { 0xC0000092, "FLOAT_STACK_CHECK" }, 790 { 0xC0000093, "FLOAT_UNDERFLOW" }, 791 { 0xC0000094, "INTEGER_DIVIDE_BY_ZERO" }, 792 { 0xC0000095, "INTEGER_OVERFLOW" }, 793 { 0xC0000096, "PRIV_INSTRUCTION" }, 794 { 0xC00000FD, "STACK_OVERFLOW" }, 795 { 0xC0000409, "FAST_FAIL" }, 796 }; 797 798 static const struct enum_value_name violation_values[] = 799 { 800 { 0, "READ_ACCESS_VIOLATION" }, 801 { 1, "WRITE_ACCESS_VIOLATION" }, 802 { 8, "DATA_EXECUTION_PREVENTION_VIOLATION" }, 803 }; 804 805 /* Implement the "get_siginfo_type" gdbarch method. */ 806 807 static struct type * 808 windows_get_siginfo_type (struct gdbarch *gdbarch) 809 { 810 struct windows_gdbarch_data *windows_gdbarch_data; 811 struct type *dword_type, *pvoid_type, *ulongptr_type; 812 struct type *code_enum, *violation_enum; 813 struct type *violation_type, *para_type, *siginfo_ptr_type, *siginfo_type; 814 815 windows_gdbarch_data = get_windows_gdbarch_data (gdbarch); 816 if (windows_gdbarch_data->siginfo_type != NULL) 817 return windows_gdbarch_data->siginfo_type; 818 819 dword_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 820 1, "DWORD"); 821 pvoid_type = arch_pointer_type (gdbarch, gdbarch_ptr_bit (gdbarch), "PVOID", 822 builtin_type (gdbarch)->builtin_void); 823 ulongptr_type = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 824 1, "ULONG_PTR"); 825 826 /* ExceptionCode value names */ 827 code_enum = create_enum (gdbarch, gdbarch_int_bit (gdbarch), 828 "ExceptionCode", exception_values, 829 ARRAY_SIZE (exception_values)); 830 831 /* ACCESS_VIOLATION type names */ 832 violation_enum = create_enum (gdbarch, gdbarch_ptr_bit (gdbarch), 833 "ViolationType", violation_values, 834 ARRAY_SIZE (violation_values)); 835 836 /* ACCESS_VIOLATION information */ 837 violation_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); 838 append_composite_type_field (violation_type, "Type", violation_enum); 839 append_composite_type_field (violation_type, "Address", pvoid_type); 840 841 /* Unnamed union of the documented field ExceptionInformation, 842 and the alternative AccessViolationInformation (which displays 843 human-readable values for ExceptionCode ACCESS_VIOLATION). */ 844 para_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION); 845 append_composite_type_field (para_type, "ExceptionInformation", 846 lookup_array_range_type (ulongptr_type, 0, 14)); 847 append_composite_type_field (para_type, "AccessViolationInformation", 848 violation_type); 849 850 siginfo_type = arch_composite_type (gdbarch, "EXCEPTION_RECORD", 851 TYPE_CODE_STRUCT); 852 siginfo_ptr_type = arch_pointer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 853 NULL, siginfo_type); 854 855 /* ExceptionCode is documented as type DWORD, but here a helper 856 enum type is used instead to display a human-readable value. */ 857 append_composite_type_field (siginfo_type, "ExceptionCode", code_enum); 858 append_composite_type_field (siginfo_type, "ExceptionFlags", dword_type); 859 append_composite_type_field (siginfo_type, "ExceptionRecord", 860 siginfo_ptr_type); 861 append_composite_type_field (siginfo_type, "ExceptionAddress", 862 pvoid_type); 863 append_composite_type_field (siginfo_type, "NumberParameters", dword_type); 864 /* The 64-bit variant needs some padding. */ 865 append_composite_type_field_aligned (siginfo_type, "", 866 para_type, TYPE_LENGTH (ulongptr_type)); 867 868 windows_gdbarch_data->siginfo_type = siginfo_type; 869 870 return siginfo_type; 871 } 872 873 /* Implement the "solib_create_inferior_hook" target_so_ops method. */ 874 875 static void 876 windows_solib_create_inferior_hook (int from_tty) 877 { 878 CORE_ADDR exec_base = 0; 879 880 /* Find base address of main executable in 881 TIB->process_environment_block->image_base_address. */ 882 struct gdbarch *gdbarch = target_gdbarch (); 883 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 884 int ptr_bytes; 885 int peb_offset; /* Offset of process_environment_block in TIB. */ 886 int base_offset; /* Offset of image_base_address in PEB. */ 887 if (gdbarch_ptr_bit (gdbarch) == 32) 888 { 889 ptr_bytes = 4; 890 peb_offset = 48; 891 base_offset = 8; 892 } 893 else 894 { 895 ptr_bytes = 8; 896 peb_offset = 96; 897 base_offset = 16; 898 } 899 CORE_ADDR tlb; 900 gdb_byte buf[8]; 901 if (target_has_execution 902 && target_get_tib_address (inferior_ptid, &tlb) 903 && !target_read_memory (tlb + peb_offset, buf, ptr_bytes)) 904 { 905 CORE_ADDR peb = extract_unsigned_integer (buf, ptr_bytes, byte_order); 906 if (!target_read_memory (peb + base_offset, buf, ptr_bytes)) 907 exec_base = extract_unsigned_integer (buf, ptr_bytes, byte_order); 908 } 909 910 /* Rebase executable if the base address changed because of ASLR. */ 911 if (symfile_objfile != nullptr && exec_base != 0) 912 { 913 CORE_ADDR vmaddr = pe_data (exec_bfd)->pe_opthdr.ImageBase; 914 if (vmaddr != exec_base) 915 objfile_rebase (symfile_objfile, exec_base - vmaddr); 916 } 917 } 918 919 static struct target_so_ops windows_so_ops; 920 921 /* Common parts for gdbarch initialization for the Windows and Cygwin OS 922 ABIs. */ 923 924 static void 925 windows_init_abi_common (struct gdbarch_info info, struct gdbarch *gdbarch) 926 { 927 set_gdbarch_wchar_bit (gdbarch, 16); 928 set_gdbarch_wchar_signed (gdbarch, 0); 929 930 /* Canonical paths on this target look like 931 `c:\Program Files\Foo App\mydll.dll', for example. */ 932 set_gdbarch_has_dos_based_file_system (gdbarch, 1); 933 934 set_gdbarch_iterate_over_objfiles_in_search_order 935 (gdbarch, windows_iterate_over_objfiles_in_search_order); 936 937 windows_so_ops = solib_target_so_ops; 938 windows_so_ops.solib_create_inferior_hook 939 = windows_solib_create_inferior_hook; 940 set_solib_ops (gdbarch, &windows_so_ops); 941 942 set_gdbarch_get_siginfo_type (gdbarch, windows_get_siginfo_type); 943 } 944 945 /* See windows-tdep.h. */ 946 void 947 windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) 948 { 949 windows_init_abi_common (info, gdbarch); 950 set_gdbarch_gdb_signal_to_target (gdbarch, windows_gdb_signal_to_target); 951 } 952 953 /* See windows-tdep.h. */ 954 955 void 956 cygwin_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) 957 { 958 windows_init_abi_common (info, gdbarch); 959 set_gdbarch_gdb_signal_to_target (gdbarch, cygwin_gdb_signal_to_target); 960 } 961 962 /* Implementation of `tlb' variable. */ 963 964 static const struct internalvar_funcs tlb_funcs = 965 { 966 tlb_make_value, 967 NULL, 968 NULL 969 }; 970 971 /* Layout of an element of a PE's Import Directory Table. Based on: 972 973 https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#import-directory-table 974 */ 975 976 struct pe_import_directory_entry 977 { 978 uint32_t import_lookup_table_rva; 979 uint32_t timestamp; 980 uint32_t forwarder_chain; 981 uint32_t name_rva; 982 uint32_t import_address_table_rva; 983 }; 984 985 gdb_static_assert (sizeof (pe_import_directory_entry) == 20); 986 987 /* See windows-tdep.h. */ 988 989 bool 990 is_linked_with_cygwin_dll (bfd *abfd) 991 { 992 /* The list of DLLs a PE is linked to is in the .idata section. See: 993 994 https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#the-idata-section 995 */ 996 asection *idata_section = bfd_get_section_by_name (abfd, ".idata"); 997 if (idata_section == nullptr) 998 return false; 999 1000 bfd_size_type idata_section_size = bfd_section_size (idata_section); 1001 internal_extra_pe_aouthdr *pe_extra = &pe_data (abfd)->pe_opthdr; 1002 bfd_vma import_table_va = pe_extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress; 1003 bfd_vma idata_section_va = bfd_section_vma (idata_section); 1004 1005 /* The section's virtual address as reported by BFD has the image base applied, 1006 remove it. */ 1007 gdb_assert (idata_section_va >= pe_extra->ImageBase); 1008 idata_section_va -= pe_extra->ImageBase; 1009 1010 bfd_vma idata_section_end_va = idata_section_va + idata_section_size; 1011 1012 /* Make sure that the import table is indeed within the .idata section's range. */ 1013 if (import_table_va < idata_section_va 1014 || import_table_va >= idata_section_end_va) 1015 { 1016 warning (_("\ 1017 %s: import table's virtual address (0x%" BFD_VMA_FMT "x) is outside .idata \ 1018 section's range [0x%" BFD_VMA_FMT "x, 0x%" BFD_VMA_FMT "x[."), 1019 bfd_get_filename (abfd), import_table_va, idata_section_va, 1020 idata_section_end_va); 1021 return false; 1022 } 1023 1024 /* The import table starts at this offset into the .idata section. */ 1025 bfd_vma import_table_offset_in_sect = import_table_va - idata_section_va; 1026 1027 /* Get the section's data. */ 1028 gdb::byte_vector idata_contents; 1029 if (!gdb_bfd_get_full_section_contents (abfd, idata_section, &idata_contents)) 1030 { 1031 warning (_("%s: failed to get contents of .idata section."), 1032 bfd_get_filename (abfd)); 1033 return false; 1034 } 1035 1036 gdb_assert (idata_contents.size () == idata_section_size); 1037 1038 const gdb_byte *iter = idata_contents.data () + import_table_offset_in_sect; 1039 const gdb_byte *end = idata_contents.data () + idata_section_size; 1040 const pe_import_directory_entry null_dir_entry = { 0 }; 1041 1042 /* Iterate through all directory entries. */ 1043 while (true) 1044 { 1045 /* Is there enough space left in the section for another entry? */ 1046 if (iter + sizeof (pe_import_directory_entry) > end) 1047 { 1048 warning (_("%s: unexpected end of .idata section."), 1049 bfd_get_filename (abfd)); 1050 break; 1051 } 1052 1053 pe_import_directory_entry *dir_entry = (pe_import_directory_entry *) iter; 1054 1055 /* Is it the end of list marker? */ 1056 if (memcmp (dir_entry, &null_dir_entry, 1057 sizeof (pe_import_directory_entry)) == 0) 1058 break; 1059 1060 bfd_vma name_va = dir_entry->name_rva; 1061 1062 /* If the name's virtual address is smaller than the section's virtual 1063 address, there's a problem. */ 1064 if (name_va < idata_section_va || name_va >= idata_section_end_va) 1065 { 1066 warning (_("\ 1067 %s: name's virtual address (0x%" BFD_VMA_FMT "x) is outside .idata section's \ 1068 range [0x%" BFD_VMA_FMT "x, 0x%" BFD_VMA_FMT "x[."), 1069 bfd_get_filename (abfd), name_va, idata_section_va, 1070 idata_section_end_va); 1071 break; 1072 } 1073 1074 const gdb_byte *name = &idata_contents[name_va - idata_section_va]; 1075 1076 /* Make sure we don't overshoot the end of the section with the 1077 streq. */ 1078 if (name + sizeof (CYGWIN_DLL_NAME) <= end) 1079 { 1080 /* Finally, check if this is the dll name we are looking for. */ 1081 if (streq ((const char *) name, CYGWIN_DLL_NAME)) 1082 return true; 1083 } 1084 1085 iter += sizeof (pe_import_directory_entry); 1086 } 1087 1088 return false; 1089 } 1090 1091 void _initialize_windows_tdep (); 1092 void 1093 _initialize_windows_tdep () 1094 { 1095 windows_gdbarch_data_handle 1096 = gdbarch_data_register_post_init (init_windows_gdbarch_data); 1097 1098 init_w32_command_list (); 1099 add_cmd ("thread-information-block", class_info, display_tib, 1100 _("Display thread information block."), 1101 &info_w32_cmdlist); 1102 add_alias_cmd ("tib", "thread-information-block", class_info, 1, 1103 &info_w32_cmdlist); 1104 1105 add_setshow_boolean_cmd ("show-all-tib", class_maintenance, 1106 &maint_display_all_tib, _("\ 1107 Set whether to display all non-zero fields of thread information block."), _("\ 1108 Show whether to display all non-zero fields of thread information block."), _("\ 1109 Use \"on\" to enable, \"off\" to disable.\n\ 1110 If enabled, all non-zero fields of thread information block are displayed,\n\ 1111 even if their meaning is unknown."), 1112 NULL, 1113 show_maint_show_all_tib, 1114 &maintenance_set_cmdlist, 1115 &maintenance_show_cmdlist); 1116 1117 /* Explicitly create without lookup, since that tries to create a 1118 value with a void typed value, and when we get here, gdbarch 1119 isn't initialized yet. At this point, we're quite sure there 1120 isn't another convenience variable of the same name. */ 1121 create_internalvar_type_lazy ("_tlb", &tlb_funcs, NULL); 1122 } 1123