gdb/windows-tdep.c

   1 /* Copyright (C) 2008-2018 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 int maint_display_all_tib = 0;
 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 && !ptid_equal (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));
 331       return -1;
 332     }
 333
 334   if (target_read (&current_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),
 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),
 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 (!ptid_equal (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   struct objfile *objfile;
 419
 420   if (current_objfile)
 421     {
 422       stop = cb (current_objfile, cb_data);
 423       if (stop)
 424         return;
 425     }
 426
 427   ALL_OBJFILES (objfile)
 428     {
 429       if (objfile != current_objfile)
 430         {
 431           stop = cb (objfile, cb_data);
 432           if (stop)
 433             return;
 434         }
 435     }
 436 }
 437
 438 static void
 439 show_maint_show_all_tib (struct ui_file *file, int from_tty,
 440                 struct cmd_list_element *c, const char *value)
 441 {
 442   fprintf_filtered (file, _("Show all non-zero elements of "
 443                             "Thread Information Block is %s.\n"), value);
 444 }
 445
 446 static void
 447 info_w32_command (const char *args, int from_tty)
 448 {
 449   help_list (info_w32_cmdlist, "info w32 ", class_info, gdb_stdout);
 450 }
 451
 452 static int w32_prefix_command_valid = 0;
 453 void
 454 init_w32_command_list (void)
 455 {
 456   if (!w32_prefix_command_valid)
 457     {
 458       add_prefix_cmd ("w32", class_info, info_w32_command,
 459                       _("Print information specific to Win32 debugging."),
 460                       &info_w32_cmdlist, "info w32 ", 0, &infolist);
 461       w32_prefix_command_valid = 1;
 462     }
 463 }
 464
 465 /* To be called from the various GDB_OSABI_CYGWIN handlers for the
 466    various Windows architectures and machine types.  */
 467
 468 void
 469 windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 470 {
 471   set_gdbarch_wchar_bit (gdbarch, 16);
 472   set_gdbarch_wchar_signed (gdbarch, 0);
 473
 474   /* Canonical paths on this target look like
 475      `c:\Program Files\Foo App\mydll.dll', for example.  */
 476   set_gdbarch_has_dos_based_file_system (gdbarch, 1);
 477
 478   set_gdbarch_iterate_over_objfiles_in_search_order
 479     (gdbarch, windows_iterate_over_objfiles_in_search_order);
 480
 481   set_solib_ops (gdbarch, &solib_target_so_ops);
 482 }
 483
 484 /* Implementation of `tlb' variable.  */
 485
 486 static const struct internalvar_funcs tlb_funcs =
 487 {
 488   tlb_make_value,
 489   NULL,
 490   NULL
 491 };
 492
 493 void
 494 _initialize_windows_tdep (void)
 495 {
 496   init_w32_command_list ();
 497   add_cmd ("thread-information-block", class_info, display_tib,
 498            _("Display thread information block."),
 499            &info_w32_cmdlist);
 500   add_alias_cmd ("tib", "thread-information-block", class_info, 1,
 501                  &info_w32_cmdlist);
 502
 503   add_setshow_boolean_cmd ("show-all-tib", class_maintenance,
 504                            &maint_display_all_tib, _("\
 505 Set whether to display all non-zero fields of thread information block."), _("\
 506 Show whether to display all non-zero fields of thread information block."), _("\
 507 Use \"on\" to enable, \"off\" to disable.\n\
 508 If enabled, all non-zero fields of thread information block are displayed,\n\
 509 even if their meaning is unknown."),
 510                            NULL,
 511                            show_maint_show_all_tib,
 512                            &maintenance_set_cmdlist,
 513                            &maintenance_show_cmdlist);
 514
 515   /* Explicitly create without lookup, since that tries to create a
 516      value with a void typed value, and when we get here, gdbarch
 517      isn't initialized yet.  At this point, we're quite sure there
 518      isn't another convenience variable of the same name.  */
 519   create_internalvar_type_lazy ("_tlb", &tlb_funcs, NULL);
 520 }