gdb/windows-tdep.c

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