gdb/windows-tdep.c

   1 /* Copyright (C) 2008-2020 Free Software Foundation, Inc.
   2
   3    This file is part of GDB.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 #include "defs.h"
  19 #include "windows-tdep.h"
  20 #include "gdb_obstack.h"
  21 #include "xml-support.h"
  22 #include "gdbarch.h"
  23 #include "target.h"
  24 #include "value.h"
  25 #include "inferior.h"
  26 #include "command.h"
  27 #include "gdbcmd.h"
  28 #include "gdbthread.h"
  29 #include "objfiles.h"
  30 #include "symfile.h"
  31 #include "coff-pe-read.h"
  32 #include "gdb_bfd.h"
  33 #include "complaints.h"
  34 #include "solib.h"
  35 #include "solib-target.h"
  36 #include "gdbcore.h"
  37
  38 struct cmd_list_element *info_w32_cmdlist;
  39
  40 typedef struct thread_information_block_32
  41   {
  42     uint32_t current_seh;                       /* %fs:0x0000 */
  43     uint32_t current_top_of_stack;              /* %fs:0x0004 */
  44     uint32_t current_bottom_of_stack;           /* %fs:0x0008 */
  45     uint32_t sub_system_tib;                    /* %fs:0x000c */
  46     uint32_t fiber_data;                        /* %fs:0x0010 */
  47     uint32_t arbitrary_data_slot;               /* %fs:0x0014 */
  48     uint32_t linear_address_tib;                /* %fs:0x0018 */
  49     uint32_t environment_pointer;               /* %fs:0x001c */
  50     uint32_t process_id;                        /* %fs:0x0020 */
  51     uint32_t current_thread_id;                 /* %fs:0x0024 */
  52     uint32_t active_rpc_handle;                 /* %fs:0x0028 */
  53     uint32_t thread_local_storage;              /* %fs:0x002c */
  54     uint32_t process_environment_block;         /* %fs:0x0030 */
  55     uint32_t last_error_number;                 /* %fs:0x0034 */
  56   }
  57 thread_information_32;
  58
  59 typedef struct thread_information_block_64
  60   {
  61     uint64_t current_seh;                       /* %gs:0x0000 */
  62     uint64_t current_top_of_stack;              /* %gs:0x0008 */
  63     uint64_t current_bottom_of_stack;           /* %gs:0x0010 */
  64     uint64_t sub_system_tib;                    /* %gs:0x0018 */
  65     uint64_t fiber_data;                        /* %gs:0x0020 */
  66     uint64_t arbitrary_data_slot;               /* %gs:0x0028 */
  67     uint64_t linear_address_tib;                /* %gs:0x0030 */
  68     uint64_t environment_pointer;               /* %gs:0x0038 */
  69     uint64_t process_id;                        /* %gs:0x0040 */
  70     uint64_t current_thread_id;                 /* %gs:0x0048 */
  71     uint64_t active_rpc_handle;                 /* %gs:0x0050 */
  72     uint64_t thread_local_storage;              /* %gs:0x0058 */
  73     uint64_t process_environment_block;         /* %gs:0x0060 */
  74     uint64_t last_error_number;                 /* %gs:0x0068 */
  75   }
  76 thread_information_64;
  77
  78
  79 static const char* TIB_NAME[] =
  80   {
  81     " current_seh                 ",    /* %fs:0x0000 */
  82     " current_top_of_stack        ",    /* %fs:0x0004 */
  83     " current_bottom_of_stack     ",    /* %fs:0x0008 */
  84     " sub_system_tib              ",    /* %fs:0x000c */
  85     " fiber_data                  ",    /* %fs:0x0010 */
  86     " arbitrary_data_slot         ",    /* %fs:0x0014 */
  87     " linear_address_tib          ",    /* %fs:0x0018 */
  88     " environment_pointer         ",    /* %fs:0x001c */
  89     " process_id                  ",    /* %fs:0x0020 */
  90     " current_thread_id           ",    /* %fs:0x0024 */
  91     " active_rpc_handle           ",    /* %fs:0x0028 */
  92     " thread_local_storage        ",    /* %fs:0x002c */
  93     " process_environment_block   ",    /* %fs:0x0030 */
  94     " last_error_number           "     /* %fs:0x0034 */
  95   };
  96
  97 static const int MAX_TIB32 =
  98   sizeof (thread_information_32) / sizeof (uint32_t);
  99 static const int MAX_TIB64 =
 100   sizeof (thread_information_64) / sizeof (uint64_t);
 101 static const int FULL_TIB_SIZE = 0x1000;
 102
 103 static bool maint_display_all_tib = false;
 104
 105 /* Define Thread Local Base pointer type.  */
 106
 107 static struct type *
 108 windows_get_tlb_type (struct gdbarch *gdbarch)
 109 {
 110   static struct gdbarch *last_gdbarch = NULL;
 111   static struct type *last_tlb_type = NULL;
 112   struct type *dword_ptr_type, *dword32_type, *void_ptr_type;
 113   struct type *peb_ldr_type, *peb_ldr_ptr_type;
 114   struct type *peb_type, *peb_ptr_type, *list_type;
 115   struct type *module_list_ptr_type;
 116   struct type *tib_type, *seh_type, *tib_ptr_type, *seh_ptr_type;
 117
 118   /* Do not rebuild type if same gdbarch as last time.  */
 119   if (last_tlb_type && last_gdbarch == gdbarch)
 120     return last_tlb_type;
 121
 122   dword_ptr_type = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch),
 123                                  1, "DWORD_PTR");
 124   dword32_type = arch_integer_type (gdbarch, 32,
 125                                  1, "DWORD32");
 126   void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
 127
 128   /* list entry */
 129
 130   list_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 131   TYPE_NAME (list_type) = xstrdup ("list");
 132
 133   module_list_ptr_type = void_ptr_type;
 134
 135   append_composite_type_field (list_type, "forward_list",
 136                                module_list_ptr_type);
 137   append_composite_type_field (list_type, "backward_list",
 138                                module_list_ptr_type);
 139
 140   /* Structured Exception Handler */
 141
 142   seh_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 143   TYPE_NAME (seh_type) = xstrdup ("seh");
 144
 145   seh_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
 146                             TYPE_LENGTH (void_ptr_type) * TARGET_CHAR_BIT,
 147                             NULL);
 148   TYPE_TARGET_TYPE (seh_ptr_type) = seh_type;
 149
 150   append_composite_type_field (seh_type, "next_seh", seh_ptr_type);
 151   append_composite_type_field (seh_type, "handler",
 152                                builtin_type (gdbarch)->builtin_func_ptr);
 153
 154   /* struct _PEB_LDR_DATA */
 155   peb_ldr_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 156   TYPE_NAME (peb_ldr_type) = xstrdup ("peb_ldr_data");
 157
 158   append_composite_type_field (peb_ldr_type, "length", dword32_type);
 159   append_composite_type_field (peb_ldr_type, "initialized", dword32_type);
 160   append_composite_type_field (peb_ldr_type, "ss_handle", void_ptr_type);
 161   append_composite_type_field (peb_ldr_type, "in_load_order", list_type);
 162   append_composite_type_field (peb_ldr_type, "in_memory_order", list_type);
 163   append_composite_type_field (peb_ldr_type, "in_init_order", list_type);
 164   append_composite_type_field (peb_ldr_type, "entry_in_progress",
 165                                void_ptr_type);
 166   peb_ldr_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
 167                                 TYPE_LENGTH (void_ptr_type) * TARGET_CHAR_BIT,
 168                                 NULL);
 169   TYPE_TARGET_TYPE (peb_ldr_ptr_type) = peb_ldr_type;
 170
 171
 172   /* struct process environment block */
 173   peb_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 174   TYPE_NAME (peb_type) = xstrdup ("peb");
 175
 176   /* First bytes contain several flags.  */
 177   append_composite_type_field (peb_type, "flags", dword_ptr_type);
 178   append_composite_type_field (peb_type, "mutant", void_ptr_type);
 179   append_composite_type_field (peb_type, "image_base_address", void_ptr_type);
 180   append_composite_type_field (peb_type, "ldr", peb_ldr_ptr_type);
 181   append_composite_type_field (peb_type, "process_parameters", void_ptr_type);
 182   append_composite_type_field (peb_type, "sub_system_data", void_ptr_type);
 183   append_composite_type_field (peb_type, "process_heap", void_ptr_type);
 184   append_composite_type_field (peb_type, "fast_peb_lock", void_ptr_type);
 185   peb_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
 186                             TYPE_LENGTH (void_ptr_type) * TARGET_CHAR_BIT,
 187                             NULL);
 188   TYPE_TARGET_TYPE (peb_ptr_type) = peb_type;
 189
 190
 191   /* struct thread information block */
 192   tib_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 193   TYPE_NAME (tib_type) = xstrdup ("tib");
 194
 195   /* uint32_t current_seh;                      %fs:0x0000 */
 196   append_composite_type_field (tib_type, "current_seh", seh_ptr_type);
 197   /* uint32_t current_top_of_stack;             %fs:0x0004 */
 198   append_composite_type_field (tib_type, "current_top_of_stack",
 199                                void_ptr_type);
 200   /* uint32_t current_bottom_of_stack;          %fs:0x0008 */
 201   append_composite_type_field (tib_type, "current_bottom_of_stack",
 202                                void_ptr_type);
 203   /* uint32_t sub_system_tib;                   %fs:0x000c */
 204   append_composite_type_field (tib_type, "sub_system_tib", void_ptr_type);
 205
 206   /* uint32_t fiber_data;                       %fs:0x0010 */
 207   append_composite_type_field (tib_type, "fiber_data", void_ptr_type);
 208   /* uint32_t arbitrary_data_slot;              %fs:0x0014 */
 209   append_composite_type_field (tib_type, "arbitrary_data_slot", void_ptr_type);
 210   /* uint32_t linear_address_tib;               %fs:0x0018 */
 211   append_composite_type_field (tib_type, "linear_address_tib", void_ptr_type);
 212   /* uint32_t environment_pointer;              %fs:0x001c */
 213   append_composite_type_field (tib_type, "environment_pointer", void_ptr_type);
 214   /* uint32_t process_id;                       %fs:0x0020 */
 215   append_composite_type_field (tib_type, "process_id", dword_ptr_type);
 216   /* uint32_t current_thread_id;                %fs:0x0024 */
 217   append_composite_type_field (tib_type, "thread_id", dword_ptr_type);
 218   /* uint32_t active_rpc_handle;                %fs:0x0028 */
 219   append_composite_type_field (tib_type, "active_rpc_handle", dword_ptr_type);
 220   /* uint32_t thread_local_storage;             %fs:0x002c */
 221   append_composite_type_field (tib_type, "thread_local_storage",
 222                                void_ptr_type);
 223   /* uint32_t process_environment_block;        %fs:0x0030 */
 224   append_composite_type_field (tib_type, "process_environment_block",
 225                                peb_ptr_type);
 226   /* uint32_t last_error_number;                %fs:0x0034 */
 227   append_composite_type_field (tib_type, "last_error_number", dword_ptr_type);
 228
 229   tib_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
 230                             TYPE_LENGTH (void_ptr_type) * TARGET_CHAR_BIT,
 231                             NULL);
 232   TYPE_TARGET_TYPE (tib_ptr_type) = tib_type;
 233
 234   last_tlb_type = tib_ptr_type;
 235   last_gdbarch = gdbarch;
 236
 237   return tib_ptr_type;
 238 }
 239
 240 /* The $_tlb convenience variable is a bit special.  We don't know
 241    for sure the type of the value until we actually have a chance to
 242    fetch the data.  The type can change depending on gdbarch, so it is
 243    also dependent on which thread you have selected.  */
 244
 245 /* This function implements the lval_computed support for reading a
 246    $_tlb value.  */
 247
 248 static void
 249 tlb_value_read (struct value *val)
 250 {
 251   CORE_ADDR tlb;
 252   struct type *type = check_typedef (value_type (val));
 253
 254   if (!target_get_tib_address (inferior_ptid, &tlb))
 255     error (_("Unable to read tlb"));
 256   store_typed_address (value_contents_raw (val), type, tlb);
 257 }
 258
 259 /* This function implements the lval_computed support for writing a
 260    $_tlb value.  */
 261
 262 static void
 263 tlb_value_write (struct value *v, struct value *fromval)
 264 {
 265   error (_("Impossible to change the Thread Local Base"));
 266 }
 267
 268 static const struct lval_funcs tlb_value_funcs =
 269   {
 270     tlb_value_read,
 271     tlb_value_write
 272   };
 273
 274
 275 /* Return a new value with the correct type for the tlb object of
 276    the current thread using architecture GDBARCH.  Return a void value
 277    if there's no object available.  */
 278
 279 static struct value *
 280 tlb_make_value (struct gdbarch *gdbarch, struct internalvar *var, void *ignore)
 281 {
 282   if (target_has_stack && inferior_ptid != null_ptid)
 283     {
 284       struct type *type = windows_get_tlb_type (gdbarch);
 285       return allocate_computed_value (type, &tlb_value_funcs, NULL);
 286     }
 287
 288   return allocate_value (builtin_type (gdbarch)->builtin_void);
 289 }
 290
 291
 292 /* Display thread information block of a given thread.  */
 293
 294 static int
 295 display_one_tib (ptid_t ptid)
 296 {
 297   gdb_byte *tib = NULL;
 298   gdb_byte *index;
 299   CORE_ADDR thread_local_base;
 300   ULONGEST i, val, max, max_name, size, tib_size;
 301   ULONGEST sizeof_ptr = gdbarch_ptr_bit (target_gdbarch ());
 302   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 303
 304   if (sizeof_ptr == 64)
 305     {
 306       size = sizeof (uint64_t);
 307       tib_size = sizeof (thread_information_64);
 308       max = MAX_TIB64;
 309     }
 310   else
 311     {
 312       size = sizeof (uint32_t);
 313       tib_size = sizeof (thread_information_32);
 314       max = MAX_TIB32;
 315     }
 316
 317   max_name = max;
 318
 319   if (maint_display_all_tib)
 320     {
 321       tib_size = FULL_TIB_SIZE;
 322       max = tib_size / size;
 323     }
 324
 325   tib = (gdb_byte *) alloca (tib_size);
 326
 327   if (target_get_tib_address (ptid, &thread_local_base) == 0)
 328     {
 329       printf_filtered (_("Unable to get thread local base for %s\n"),
 330                        target_pid_to_str (ptid).c_str ());
 331       return -1;
 332     }
 333
 334   if (target_read (current_top_target (), TARGET_OBJECT_MEMORY,
 335                    NULL, tib, thread_local_base, tib_size) != tib_size)
 336     {
 337       printf_filtered (_("Unable to read thread information "
 338                          "block for %s at address %s\n"),
 339                        target_pid_to_str (ptid).c_str (),
 340                        paddress (target_gdbarch (), thread_local_base));
 341       return -1;
 342     }
 343
 344   printf_filtered (_("Thread Information Block %s at %s\n"),
 345                    target_pid_to_str (ptid).c_str (),
 346                    paddress (target_gdbarch (), thread_local_base));
 347
 348   index = (gdb_byte *) tib;
 349
 350   /* All fields have the size of a pointer, this allows to iterate
 351      using the same for loop for both layouts.  */
 352   for (i = 0; i < max; i++)
 353     {
 354       val = extract_unsigned_integer (index, size, byte_order);
 355       if (i < max_name)
 356         printf_filtered (_("%s is 0x%s\n"), TIB_NAME[i], phex (val, size));
 357       else if (val != 0)
 358         printf_filtered (_("TIB[0x%s] is 0x%s\n"), phex (i * size, 2),
 359                          phex (val, size));
 360       index += size;
 361     }
 362   return 1;
 363 }
 364
 365 /* Display thread information block of the current thread.  */
 366
 367 static void
 368 display_tib (const char * args, int from_tty)
 369 {
 370   if (inferior_ptid != null_ptid)
 371     display_one_tib (inferior_ptid);
 372 }
 373
 374 void
 375 windows_xfer_shared_library (const char* so_name, CORE_ADDR load_addr,
 376                              struct gdbarch *gdbarch, struct obstack *obstack)
 377 {
 378   CORE_ADDR text_offset;
 379
 380   obstack_grow_str (obstack, "<library name=\"");
 381   std::string p = xml_escape_text (so_name);
 382   obstack_grow_str (obstack, p.c_str ());
 383   obstack_grow_str (obstack, "\"><segment address=\"");
 384   gdb_bfd_ref_ptr dll (gdb_bfd_open (so_name, gnutarget, -1));
 385   /* The following calls are OK even if dll is NULL.
 386      The default value 0x1000 is returned by pe_text_section_offset
 387      in that case.  */
 388   text_offset = pe_text_section_offset (dll.get ());
 389   obstack_grow_str (obstack, paddress (gdbarch, load_addr + text_offset));
 390   obstack_grow_str (obstack, "\"/></library>");
 391 }
 392
 393 /* Implement the "iterate_over_objfiles_in_search_order" gdbarch
 394    method.  It searches all objfiles, starting with CURRENT_OBJFILE
 395    first (if not NULL).
 396
 397    On Windows, the system behaves a little differently when two
 398    objfiles each define a global symbol using the same name, compared
 399    to other platforms such as GNU/Linux for instance.  On GNU/Linux,
 400    all instances of the symbol effectively get merged into a single
 401    one, but on Windows, they remain distinct.
 402
 403    As a result, it usually makes sense to start global symbol searches
 404    with the current objfile before expanding it to all other objfiles.
 405    This helps for instance when a user debugs some code in a DLL that
 406    refers to a global variable defined inside that DLL.  When trying
 407    to print the value of that global variable, it would be unhelpful
 408    to print the value of another global variable defined with the same
 409    name, but in a different DLL.  */
 410
 411 static void
 412 windows_iterate_over_objfiles_in_search_order
 413   (struct gdbarch *gdbarch,
 414    iterate_over_objfiles_in_search_order_cb_ftype *cb,
 415    void *cb_data, struct objfile *current_objfile)
 416 {
 417   int stop;
 418
 419   if (current_objfile)
 420     {
 421       stop = cb (current_objfile, cb_data);
 422       if (stop)
 423         return;
 424     }
 425
 426   for (objfile *objfile : current_program_space->objfiles ())
 427     {
 428       if (objfile != current_objfile)
 429         {
 430           stop = cb (objfile, cb_data);
 431           if (stop)
 432             return;
 433         }
 434     }
 435 }
 436
 437 static void
 438 show_maint_show_all_tib (struct ui_file *file, int from_tty,
 439                 struct cmd_list_element *c, const char *value)
 440 {
 441   fprintf_filtered (file, _("Show all non-zero elements of "
 442                             "Thread Information Block is %s.\n"), value);
 443 }
 444
 445 static void
 446 info_w32_command (const char *args, int from_tty)
 447 {
 448   help_list (info_w32_cmdlist, "info w32 ", class_info, gdb_stdout);
 449 }
 450
 451 static int w32_prefix_command_valid = 0;
 452 void
 453 init_w32_command_list (void)
 454 {
 455   if (!w32_prefix_command_valid)
 456     {
 457       add_prefix_cmd ("w32", class_info, info_w32_command,
 458                       _("Print information specific to Win32 debugging."),
 459                       &info_w32_cmdlist, "info w32 ", 0, &infolist);
 460       w32_prefix_command_valid = 1;
 461     }
 462 }
 463
 464 /* To be called from the various GDB_OSABI_CYGWIN handlers for the
 465    various Windows architectures and machine types.  */
 466
 467 void
 468 windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 469 {
 470   set_gdbarch_wchar_bit (gdbarch, 16);
 471   set_gdbarch_wchar_signed (gdbarch, 0);
 472
 473   /* Canonical paths on this target look like
 474      `c:\Program Files\Foo App\mydll.dll', for example.  */
 475   set_gdbarch_has_dos_based_file_system (gdbarch, 1);
 476
 477   set_gdbarch_iterate_over_objfiles_in_search_order
 478     (gdbarch, windows_iterate_over_objfiles_in_search_order);
 479
 480   set_solib_ops (gdbarch, &solib_target_so_ops);
 481 }
 482
 483 /* Implementation of `tlb' variable.  */
 484
 485 static const struct internalvar_funcs tlb_funcs =
 486 {
 487   tlb_make_value,
 488   NULL,
 489   NULL
 490 };
 491
 492 void
 493 _initialize_windows_tdep (void)
 494 {
 495   init_w32_command_list ();
 496   add_cmd ("thread-information-block", class_info, display_tib,
 497            _("Display thread information block."),
 498            &info_w32_cmdlist);
 499   add_alias_cmd ("tib", "thread-information-block", class_info, 1,
 500                  &info_w32_cmdlist);
 501
 502   add_setshow_boolean_cmd ("show-all-tib", class_maintenance,
 503                            &maint_display_all_tib, _("\
 504 Set whether to display all non-zero fields of thread information block."), _("\
 505 Show whether to display all non-zero fields of thread information block."), _("\
 506 Use \"on\" to enable, \"off\" to disable.\n\
 507 If enabled, all non-zero fields of thread information block are displayed,\n\
 508 even if their meaning is unknown."),
 509                            NULL,
 510                            show_maint_show_all_tib,
 511                            &maintenance_set_cmdlist,
 512                            &maintenance_show_cmdlist);
 513
 514   /* Explicitly create without lookup, since that tries to create a
 515      value with a void typed value, and when we get here, gdbarch
 516      isn't initialized yet.  At this point, we're quite sure there
 517      isn't another convenience variable of the same name.  */
 518   create_internalvar_type_lazy ("_tlb", &tlb_funcs, NULL);
 519 }