gdb/windows-tdep.c

   1 /* Copyright (C) 2008-2023 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 struct windows_gdbarch_data
 179 {
 180   struct type *siginfo_type = nullptr;
 181   /* Type of thread information block.  */
 182   struct type *tib_ptr_type = nullptr;
 183 };
 184
 185 static const registry<gdbarch>::key<windows_gdbarch_data>
 186      windows_gdbarch_data_handle;
 187
 188 /* Get windows_gdbarch_data of an arch.  */
 189
 190 static struct windows_gdbarch_data *
 191 get_windows_gdbarch_data (struct gdbarch *gdbarch)
 192 {
 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;
 197 }
 198
 199 /* Define Thread Local Base pointer type.  */
 200
 201 static struct type *
 202 windows_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;
 206   struct type *peb_type, *peb_ptr_type, *list_type;
 207   struct type *module_list_ptr_type;
 208   struct type *tib_type, *seh_type, *tib_ptr_type, *seh_ptr_type;
 209   struct type *word_type, *wchar_type, *wchar_ptr_type;
 210   struct type *uni_str_type, *rupp_type, *rupp_ptr_type;
 211
 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
 217   type_allocator alloc (gdbarch);
 218
 219   dword_ptr_type = init_integer_type (alloc, gdbarch_ptr_bit (gdbarch),
 220                                  1, "DWORD_PTR");
 221   dword32_type = init_integer_type (alloc, 32,
 222                                  1, "DWORD32");
 223   word_type = init_integer_type (alloc, 16,
 224                                  1, "WORD");
 225   wchar_type = init_integer_type (alloc, 16,
 226                                   1, "wchar_t");
 227   void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
 228   wchar_ptr_type = init_pointer_type (alloc, gdbarch_ptr_bit (gdbarch),
 229                                       nullptr, wchar_type);
 230
 231   /* list entry */
 232
 233   list_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 234   list_type->set_name (xstrdup ("list"));
 235
 236   module_list_ptr_type = void_ptr_type;
 237
 238   append_composite_type_field (list_type, "forward_list",
 239                                module_list_ptr_type);
 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);
 246   seh_type->set_name (xstrdup ("seh"));
 247
 248   seh_ptr_type = alloc.new_type (TYPE_CODE_PTR,
 249                                  void_ptr_type->length () * TARGET_CHAR_BIT,
 250                                  NULL);
 251   seh_ptr_type->set_target_type (seh_type);
 252
 253   append_composite_type_field (seh_type, "next_seh", seh_ptr_type);
 254   append_composite_type_field (seh_type, "handler",
 255                                builtin_type (gdbarch)->builtin_func_ptr);
 256
 257   /* struct _PEB_LDR_DATA */
 258   peb_ldr_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 259   peb_ldr_type->set_name (xstrdup ("peb_ldr_data"));
 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);
 269   peb_ldr_ptr_type = alloc.new_type (TYPE_CODE_PTR,
 270                                      void_ptr_type->length () * TARGET_CHAR_BIT,
 271                                      NULL);
 272   peb_ldr_ptr_type->set_target_type (peb_ldr_type);
 273
 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,
 282                                        wchar_ptr_type->length ());
 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,
 296                                        void_ptr_type->length ());
 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,
 317                                        void_ptr_type->length ());
 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
 322   rupp_ptr_type = init_pointer_type (alloc, gdbarch_ptr_bit (gdbarch),
 323                                      nullptr, rupp_type);
 324
 325
 326   /* struct process environment block */
 327   peb_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 328   peb_type->set_name (xstrdup ("peb"));
 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);
 335   append_composite_type_field (peb_type, "process_parameters", rupp_ptr_type);
 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);
 339   peb_ptr_type = alloc.new_type (TYPE_CODE_PTR,
 340                                  void_ptr_type->length () * TARGET_CHAR_BIT,
 341                                  NULL);
 342   peb_ptr_type->set_target_type (peb_type);
 343
 344
 345   /* struct thread information block */
 346   tib_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 347   tib_type->set_name (xstrdup ("tib"));
 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 */
 352   append_composite_type_field (tib_type, "current_top_of_stack",
 353                                void_ptr_type);
 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 */
 375   append_composite_type_field (tib_type, "thread_local_storage",
 376                                void_ptr_type);
 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
 383   tib_ptr_type = alloc.new_type (TYPE_CODE_PTR,
 384                                  void_ptr_type->length () * TARGET_CHAR_BIT,
 385                                  NULL);
 386   tib_ptr_type->set_target_type (tib_type);
 387
 388   windows_gdbarch_data->tib_ptr_type = tib_ptr_type;
 389
 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
 401 static void
 402 tlb_value_read (struct value *val)
 403 {
 404   CORE_ADDR tlb;
 405   struct type *type = check_typedef (val->type ());
 406
 407   if (!target_get_tib_address (inferior_ptid, &tlb))
 408     error (_("Unable to read tlb"));
 409   store_typed_address (val->contents_raw ().data (), type, tlb);
 410 }
 411
 412 /* This function implements the lval_computed support for writing a
 413    $_tlb value.  */
 414
 415 static void
 416 tlb_value_write (struct value *v, struct value *fromval)
 417 {
 418   error (_("Impossible to change the Thread Local Base"));
 419 }
 420
 421 static const struct lval_funcs tlb_value_funcs =
 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
 432 static struct value *
 433 tlb_make_value (struct gdbarch *gdbarch, struct internalvar *var, void *ignore)
 434 {
 435   if (target_has_stack () && inferior_ptid != null_ptid)
 436     {
 437       struct type *type = windows_get_tlb_type (gdbarch);
 438       return value::allocate_computed (type, &tlb_value_funcs, NULL);
 439     }
 440
 441   return value::allocate (builtin_type (gdbarch)->builtin_void);
 442 }
 443
 444
 445 /* Display thread information block of a given thread.  */
 446
 447 static int
 448 display_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;
 454   ULONGEST sizeof_ptr = gdbarch_ptr_bit (current_inferior ()->arch ());
 455   bfd_endian byte_order = gdbarch_byte_order (current_inferior ()->arch ());
 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
 478   tib = (gdb_byte *) alloca (tib_size);
 479
 480   if (target_get_tib_address (ptid, &thread_local_base) == 0)
 481     {
 482       gdb_printf (_("Unable to get thread local base for %s\n"),
 483                   target_pid_to_str (ptid).c_str ());
 484       return -1;
 485     }
 486
 487   if (target_read (current_inferior ()->top_target (), TARGET_OBJECT_MEMORY,
 488                    NULL, tib, thread_local_base, tib_size) != tib_size)
 489     {
 490       gdb_printf (_("Unable to read thread information "
 491                     "block for %s at address %s\n"),
 492                   target_pid_to_str (ptid).c_str (),
 493                   paddress (current_inferior ()->arch (), thread_local_base));
 494       return -1;
 495     }
 496
 497   gdb_printf (_("Thread Information Block %s at %s\n"),
 498               target_pid_to_str (ptid).c_str (),
 499               paddress (current_inferior ()->arch (), thread_local_base));
 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)
 509         gdb_printf (_("%s is 0x%s\n"), TIB_NAME[i], phex (val, size));
 510       else if (val != 0)
 511         gdb_printf (_("TIB[0x%s] is 0x%s\n"), phex (i * size, 2),
 512                     phex (val, size));
 513       index += size;
 514     }
 515   return 1;
 516 }
 517
 518 /* Display thread information block of the current thread.  */
 519
 520 static void
 521 display_tib (const char * args, int from_tty)
 522 {
 523   if (inferior_ptid != null_ptid)
 524     display_one_tib (inferior_ptid);
 525 }
 526
 527 void
 528 windows_xfer_shared_library (const char* so_name, CORE_ADDR load_addr,
 529                              CORE_ADDR *text_offset_cached,
 530                              struct gdbarch *gdbarch, struct obstack *obstack)
 531 {
 532   CORE_ADDR text_offset = text_offset_cached ? *text_offset_cached : 0;
 533
 534   obstack_grow_str (obstack, "<library name=\"");
 535   std::string p = xml_escape_text (so_name);
 536   obstack_grow_str (obstack, p.c_str ());
 537   obstack_grow_str (obstack, "\"><segment address=\"");
 538
 539   if (!text_offset)
 540     {
 541       gdb_bfd_ref_ptr dll (gdb_bfd_open (so_name, gnutarget));
 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
 550   obstack_grow_str (obstack, paddress (gdbarch, load_addr + text_offset));
 551   obstack_grow_str (obstack, "\"/></library>");
 552 }
 553
 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
 572 static void
 573 windows_iterate_over_objfiles_in_search_order
 574   (gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype cb,
 575    objfile *current_objfile)
 576 {
 577   if (current_objfile)
 578     {
 579       if (cb (current_objfile))
 580         return;
 581     }
 582
 583   for (objfile *objfile : current_program_space->objfiles ())
 584     if (objfile != current_objfile)
 585       {
 586         if (cb (objfile))
 587           return;
 588       }
 589 }
 590
 591 static void
 592 show_maint_show_all_tib (struct ui_file *file, int from_tty,
 593                 struct cmd_list_element *c, const char *value)
 594 {
 595   gdb_printf (file, _("Show all non-zero elements of "
 596                       "Thread Information Block is %s.\n"), value);
 597 }
 598
 599
 600 static int w32_prefix_command_valid = 0;
 601 void
 602 init_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."),
 609          &info_w32_cmdlist, 0, &infolist);
 610       w32_prefix_command_valid = 1;
 611     }
 612 }
 613
 614 /* Implementation of `gdbarch_gdb_signal_to_target' for Windows.  */
 615
 616 static int
 617 windows_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;
 653     }
 654   return -1;
 655 }
 656
 657 /* Implementation of `gdbarch_gdb_signal_to_target' for Cygwin.  */
 658
 659 static int
 660 cygwin_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;
 696     case GDB_SIGNAL_URG:
 697       return CYGWIN_SIGURG;
 698     case GDB_SIGNAL_STOP:
 699       return CYGWIN_SIGSTOP;
 700     case GDB_SIGNAL_TSTP:
 701       return CYGWIN_SIGTSTP;
 702     case GDB_SIGNAL_CONT:
 703       return CYGWIN_SIGCONT;
 704     case GDB_SIGNAL_CHLD:
 705       return CYGWIN_SIGCHLD;
 706     case GDB_SIGNAL_TTIN:
 707       return CYGWIN_SIGTTIN;
 708     case GDB_SIGNAL_TTOU:
 709       return CYGWIN_SIGTTOU;
 710     case GDB_SIGNAL_IO:
 711       return CYGWIN_SIGIO;
 712     case GDB_SIGNAL_XCPU:
 713       return CYGWIN_SIGXCPU;
 714     case GDB_SIGNAL_XFSZ:
 715       return CYGWIN_SIGXFSZ;
 716     case GDB_SIGNAL_VTALRM:
 717       return CYGWIN_SIGVTALRM;
 718     case GDB_SIGNAL_PROF:
 719       return CYGWIN_SIGPROF;
 720     case GDB_SIGNAL_WINCH:
 721       return CYGWIN_SIGWINCH;
 722     case GDB_SIGNAL_PWR:
 723       return CYGWIN_SIGLOST;
 724     case GDB_SIGNAL_USR1:
 725       return CYGWIN_SIGUSR1;
 726     case GDB_SIGNAL_USR2:
 727       return CYGWIN_SIGUSR2;
 728     }
 729   return -1;
 730 }
 731
 732 struct 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
 740 static struct type *
 741 create_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
 747   type = type_allocator (gdbarch).new_type (TYPE_CODE_ENUM, bit, name);
 748   type->alloc_fields (count);
 749   type->set_is_unsigned (true);
 750
 751   for (i = 0; i < count; i++)
 752     {
 753       type->field (i).set_name (values[i].name);
 754       type->field (i).set_loc_enumval (values[i].value);
 755     }
 756
 757   return type;
 758 }
 759
 760 static const struct enum_value_name exception_values[] =
 761 {
 762   { 0x40000015, "FATAL_APP_EXIT" },
 763   { 0x4000001E, "WX86_SINGLE_STEP" },
 764   { 0x4000001F, "WX86_BREAKPOINT" },
 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
 790 static 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
 797 /* Implement the "get_siginfo_type" gdbarch method.  */
 798
 799 static struct type *
 800 windows_get_siginfo_type (struct gdbarch *gdbarch)
 801 {
 802   struct windows_gdbarch_data *windows_gdbarch_data;
 803   struct type *dword_type, *pvoid_type, *ulongptr_type;
 804   struct type *code_enum, *violation_enum;
 805   struct type *violation_type, *para_type, *siginfo_ptr_type, *siginfo_type;
 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
 811   type_allocator alloc (gdbarch);
 812   dword_type = init_integer_type (alloc, gdbarch_int_bit (gdbarch),
 813                                   1, "DWORD");
 814   pvoid_type = init_pointer_type (alloc, gdbarch_ptr_bit (gdbarch), "PVOID",
 815                                   builtin_type (gdbarch)->builtin_void);
 816   ulongptr_type = init_integer_type (alloc, gdbarch_ptr_bit (gdbarch),
 817                                      1, "ULONG_PTR");
 818
 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
 843   siginfo_type = arch_composite_type (gdbarch, "EXCEPTION_RECORD",
 844                                       TYPE_CODE_STRUCT);
 845   siginfo_ptr_type = init_pointer_type (alloc, gdbarch_ptr_bit (gdbarch),
 846                                         nullptr, siginfo_type);
 847
 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);
 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.  */
 858   append_composite_type_field_aligned (siginfo_type, "",
 859                                        para_type, ulongptr_type->length ());
 860
 861   windows_gdbarch_data->siginfo_type = siginfo_type;
 862
 863   return siginfo_type;
 864 }
 865
 866 /* Implement the "solib_create_inferior_hook" target_so_ops method.  */
 867
 868 static void
 869 windows_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.  */
 875   gdbarch *gdbarch = current_inferior ()->arch ();
 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];
 894   if (target_has_execution ()
 895       && target_get_tib_address (inferior_ptid, &tlb)
 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.  */
 904   if (current_program_space->symfile_object_file != nullptr && exec_base != 0)
 905     {
 906       CORE_ADDR vmaddr
 907         = pe_data (current_program_space->exec_bfd ())->pe_opthdr.ImageBase;
 908       if (vmaddr != exec_base)
 909         objfile_rebase (current_program_space->symfile_object_file,
 910                         exec_base - vmaddr);
 911     }
 912 }
 913
 914 static struct target_so_ops windows_so_ops;
 915
 916 /* Common parts for gdbarch initialization for the Windows and Cygwin OS
 917    ABIs.  */
 918
 919 static void
 920 windows_init_abi_common (struct gdbarch_info info, struct gdbarch *gdbarch)
 921 {
 922   set_gdbarch_wchar_bit (gdbarch, 16);
 923   set_gdbarch_wchar_signed (gdbarch, 0);
 924
 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
 932   windows_so_ops = solib_target_so_ops;
 933   windows_so_ops.solib_create_inferior_hook
 934     = windows_solib_create_inferior_hook;
 935   set_gdbarch_so_ops (gdbarch, &windows_so_ops);
 936
 937   set_gdbarch_get_siginfo_type (gdbarch, windows_get_siginfo_type);
 938 }
 939
 940 /* See windows-tdep.h.  */
 941 void
 942 windows_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
 950 void
 951 cygwin_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
 957 /* Implementation of `tlb' variable.  */
 958
 959 static const struct internalvar_funcs tlb_funcs =
 960 {
 961   tlb_make_value,
 962   NULL,
 963 };
 964
 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
 970 struct 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
 979 gdb_static_assert (sizeof (pe_import_directory_entry) == 20);
 980
 981 /* See windows-tdep.h.  */
 982
 983 bool
 984 is_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
 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 (_("\
1011 %s: import table's virtual address (%s) is outside .idata \
1012 section'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));
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;
1021
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))
1025     {
1026       warning (_("%s: failed to get contents of .idata section."),
1027                bfd_get_filename (abfd));
1028       return false;
1029     }
1030
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;
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         {
1043           warning (_("%s: unexpected end of .idata section."),
1044                    bfd_get_filename (abfd));
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
1055       bfd_vma name_va = dir_entry->name_rva;
1056
1057       /* If the name's virtual address is smaller than the section's virtual
1058          address, there's a problem.  */
1059       if (name_va < idata_section_va || name_va >= idata_section_end_va)
1060         {
1061           warning (_("\
1062 %s: name's virtual address (%s) is outside .idata section's \
1063 range [%s, %s]."),
1064                    bfd_get_filename (abfd), hex_string (name_va),
1065                    hex_string (idata_section_va),
1066                    hex_string (idata_section_end_va));
1067           break;
1068         }
1069
1070       const gdb_byte *name = &idata_contents[name_va - idata_section_va];
1071
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         }
1080
1081       iter += sizeof (pe_import_directory_entry);
1082     }
1083
1084   return false;
1085 }
1086
1087 struct cpms_data
1088 {
1089   struct gdbarch *gdbarch;
1090   struct obstack *obstack;
1091   int module_count;
1092 };
1093
1094 static void
1095 core_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
1100   unsigned int data_type;
1101   char *module_name;
1102   size_t module_name_size;
1103   size_t module_name_offset;
1104   CORE_ADDR base_addr;
1105
1106   if (!startswith (sect->name, ".module"))
1107     return;
1108
1109   gdb::byte_vector buf (bfd_section_size (sect) + 1);
1110   if (!bfd_get_section_contents (abfd, sect,
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;
1116
1117   /* A DWORD (data_type) followed by struct windows_core_module_info.  */
1118   if (bfd_section_size (sect) < 4)
1119     return;
1120   data_type = extract_unsigned_integer (buf.data (), 4, byte_order);
1121
1122   if (data_type == NOTE_INFO_MODULE)
1123     {
1124       module_name_offset = 12;
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);
1129     }
1130   else if (data_type == NOTE_INFO_MODULE64)
1131     {
1132       module_name_offset = 16;
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);
1137     }
1138   else
1139     return;
1140
1141   if (module_name_offset + module_name_size > bfd_section_size (sect))
1142     return;
1143   module_name = (char *) buf.data () + module_name_offset;
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++;
1150 }
1151
1152 ULONGEST
1153 windows_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
1184 std::string
1185 windows_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
1193 void _initialize_windows_tdep ();
1194 void
1195 _initialize_windows_tdep ()
1196 {
1197   init_w32_command_list ();
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,
1203                  &info_w32_cmdlist);
1204
1205   add_setshow_boolean_cmd ("show-all-tib", class_maintenance,
1206                            &maint_display_all_tib, _("\
1207 Set whether to display all non-zero fields of thread information block."), _("\
1208 Show whether to display all non-zero fields of thread information block."), _("\
1209 Use \"on\" to enable, \"off\" to disable.\n\
1210 If enabled, all non-zero fields of thread information block are displayed,\n\
1211 even 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.  */
1221   create_internalvar_type_lazy ("_tlb", &tlb_funcs, NULL);
1222 }