gdb/windows-tdep.c

   1 /* Copyright (C) 2008-2016 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), NULL);
 147   TYPE_TARGET_TYPE (seh_ptr_type) = seh_type;
 148
 149   append_composite_type_field (seh_type, "next_seh", seh_ptr_type);
 150   append_composite_type_field (seh_type, "handler",
 151                                builtin_type (gdbarch)->builtin_func_ptr);
 152
 153   /* struct _PEB_LDR_DATA */
 154   peb_ldr_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 155   TYPE_NAME (peb_ldr_type) = xstrdup ("peb_ldr_data");
 156
 157   append_composite_type_field (peb_ldr_type, "length", dword32_type);
 158   append_composite_type_field (peb_ldr_type, "initialized", dword32_type);
 159   append_composite_type_field (peb_ldr_type, "ss_handle", void_ptr_type);
 160   append_composite_type_field (peb_ldr_type, "in_load_order", list_type);
 161   append_composite_type_field (peb_ldr_type, "in_memory_order", list_type);
 162   append_composite_type_field (peb_ldr_type, "in_init_order", list_type);
 163   append_composite_type_field (peb_ldr_type, "entry_in_progress",
 164                                void_ptr_type);
 165   peb_ldr_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
 166                             TYPE_LENGTH (void_ptr_type), NULL);
 167   TYPE_TARGET_TYPE (peb_ldr_ptr_type) = peb_ldr_type;
 168
 169
 170   /* struct process environment block */
 171   peb_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 172   TYPE_NAME (peb_type) = xstrdup ("peb");
 173
 174   /* First bytes contain several flags.  */
 175   append_composite_type_field (peb_type, "flags", dword_ptr_type);
 176   append_composite_type_field (peb_type, "mutant", void_ptr_type);
 177   append_composite_type_field (peb_type, "image_base_address", void_ptr_type);
 178   append_composite_type_field (peb_type, "ldr", peb_ldr_ptr_type);
 179   append_composite_type_field (peb_type, "process_parameters", void_ptr_type);
 180   append_composite_type_field (peb_type, "sub_system_data", void_ptr_type);
 181   append_composite_type_field (peb_type, "process_heap", void_ptr_type);
 182   append_composite_type_field (peb_type, "fast_peb_lock", void_ptr_type);
 183   peb_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
 184                             TYPE_LENGTH (void_ptr_type), NULL);
 185   TYPE_TARGET_TYPE (peb_ptr_type) = peb_type;
 186
 187
 188   /* struct thread information block */
 189   tib_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 190   TYPE_NAME (tib_type) = xstrdup ("tib");
 191
 192   /* uint32_t current_seh;                      %fs:0x0000 */
 193   append_composite_type_field (tib_type, "current_seh", seh_ptr_type);
 194   /* uint32_t current_top_of_stack;             %fs:0x0004 */
 195   append_composite_type_field (tib_type, "current_top_of_stack",
 196                                void_ptr_type);
 197   /* uint32_t current_bottom_of_stack;          %fs:0x0008 */
 198   append_composite_type_field (tib_type, "current_bottom_of_stack",
 199                                void_ptr_type);
 200   /* uint32_t sub_system_tib;                   %fs:0x000c */
 201   append_composite_type_field (tib_type, "sub_system_tib", void_ptr_type);
 202
 203   /* uint32_t fiber_data;                       %fs:0x0010 */
 204   append_composite_type_field (tib_type, "fiber_data", void_ptr_type);
 205   /* uint32_t arbitrary_data_slot;              %fs:0x0014 */
 206   append_composite_type_field (tib_type, "arbitrary_data_slot", void_ptr_type);
 207   /* uint32_t linear_address_tib;               %fs:0x0018 */
 208   append_composite_type_field (tib_type, "linear_address_tib", void_ptr_type);
 209   /* uint32_t environment_pointer;              %fs:0x001c */
 210   append_composite_type_field (tib_type, "environment_pointer", void_ptr_type);
 211   /* uint32_t process_id;                       %fs:0x0020 */
 212   append_composite_type_field (tib_type, "process_id", dword_ptr_type);
 213   /* uint32_t current_thread_id;                %fs:0x0024 */
 214   append_composite_type_field (tib_type, "thread_id", dword_ptr_type);
 215   /* uint32_t active_rpc_handle;                %fs:0x0028 */
 216   append_composite_type_field (tib_type, "active_rpc_handle", dword_ptr_type);
 217   /* uint32_t thread_local_storage;             %fs:0x002c */
 218   append_composite_type_field (tib_type, "thread_local_storage",
 219                                void_ptr_type);
 220   /* uint32_t process_environment_block;        %fs:0x0030 */
 221   append_composite_type_field (tib_type, "process_environment_block",
 222                                peb_ptr_type);
 223   /* uint32_t last_error_number;                %fs:0x0034 */
 224   append_composite_type_field (tib_type, "last_error_number", dword_ptr_type);
 225
 226   tib_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
 227                             TYPE_LENGTH (void_ptr_type), NULL);
 228   TYPE_TARGET_TYPE (tib_ptr_type) = tib_type;
 229
 230   last_tlb_type = tib_ptr_type;
 231   last_gdbarch = gdbarch;
 232
 233   return tib_ptr_type;
 234 }
 235
 236 /* The $_tlb convenience variable is a bit special.  We don't know
 237    for sure the type of the value until we actually have a chance to
 238    fetch the data.  The type can change depending on gdbarch, so it is
 239    also dependent on which thread you have selected.  */
 240
 241 /* This function implements the lval_computed support for reading a
 242    $_tlb value.  */
 243
 244 static void
 245 tlb_value_read (struct value *val)
 246 {
 247   CORE_ADDR tlb;
 248   struct type *type = check_typedef (value_type (val));
 249
 250   if (!target_get_tib_address (inferior_ptid, &tlb))
 251     error (_("Unable to read tlb"));
 252   store_typed_address (value_contents_raw (val), type, tlb);
 253 }
 254
 255 /* This function implements the lval_computed support for writing a
 256    $_tlb value.  */
 257
 258 static void
 259 tlb_value_write (struct value *v, struct value *fromval)
 260 {
 261   error (_("Impossible to change the Thread Local Base"));
 262 }
 263
 264 static const struct lval_funcs tlb_value_funcs =
 265   {
 266     tlb_value_read,
 267     tlb_value_write
 268   };
 269
 270
 271 /* Return a new value with the correct type for the tlb object of
 272    the current thread using architecture GDBARCH.  Return a void value
 273    if there's no object available.  */
 274
 275 static struct value *
 276 tlb_make_value (struct gdbarch *gdbarch, struct internalvar *var, void *ignore)
 277 {
 278   if (target_has_stack && !ptid_equal (inferior_ptid, null_ptid))
 279     {
 280       struct type *type = windows_get_tlb_type (gdbarch);
 281       return allocate_computed_value (type, &tlb_value_funcs, NULL);
 282     }
 283
 284   return allocate_value (builtin_type (gdbarch)->builtin_void);
 285 }
 286
 287
 288 /* Display thread information block of a given thread.  */
 289
 290 static int
 291 display_one_tib (ptid_t ptid)
 292 {
 293   gdb_byte *tib = NULL;
 294   gdb_byte *index;
 295   CORE_ADDR thread_local_base;
 296   ULONGEST i, val, max, max_name, size, tib_size;
 297   ULONGEST sizeof_ptr = gdbarch_ptr_bit (target_gdbarch ());
 298   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 299
 300   if (sizeof_ptr == 64)
 301     {
 302       size = sizeof (uint64_t);
 303       tib_size = sizeof (thread_information_64);
 304       max = MAX_TIB64;
 305     }
 306   else
 307     {
 308       size = sizeof (uint32_t);
 309       tib_size = sizeof (thread_information_32);
 310       max = MAX_TIB32;
 311     }
 312
 313   max_name = max;
 314
 315   if (maint_display_all_tib)
 316     {
 317       tib_size = FULL_TIB_SIZE;
 318       max = tib_size / size;
 319     }
 320
 321   tib = (gdb_byte *) alloca (tib_size);
 322
 323   if (target_get_tib_address (ptid, &thread_local_base) == 0)
 324     {
 325       printf_filtered (_("Unable to get thread local base for %s\n"),
 326         target_pid_to_str (ptid));
 327       return -1;
 328     }
 329
 330   if (target_read (&current_target, TARGET_OBJECT_MEMORY,
 331                    NULL, tib, thread_local_base, tib_size) != tib_size)
 332     {
 333       printf_filtered (_("Unable to read thread information "
 334                          "block for %s at address %s\n"),
 335         target_pid_to_str (ptid),
 336         paddress (target_gdbarch (), thread_local_base));
 337       return -1;
 338     }
 339
 340   printf_filtered (_("Thread Information Block %s at %s\n"),
 341                    target_pid_to_str (ptid),
 342                    paddress (target_gdbarch (), thread_local_base));
 343
 344   index = (gdb_byte *) tib;
 345
 346   /* All fields have the size of a pointer, this allows to iterate
 347      using the same for loop for both layouts.  */
 348   for (i = 0; i < max; i++)
 349     {
 350       val = extract_unsigned_integer (index, size, byte_order);
 351       if (i < max_name)
 352         printf_filtered (_("%s is 0x%s\n"), TIB_NAME[i], phex (val, size));
 353       else if (val != 0)
 354         printf_filtered (_("TIB[0x%s] is 0x%s\n"), phex (i * size, 2),
 355                          phex (val, size));
 356       index += size;
 357     }
 358   return 1;
 359 }
 360
 361 /* Display thread information block of the current thread.  */
 362
 363 static void
 364 display_tib (char * args, int from_tty)
 365 {
 366   if (!ptid_equal (inferior_ptid, null_ptid))
 367     display_one_tib (inferior_ptid);
 368 }
 369
 370 void
 371 windows_xfer_shared_library (const char* so_name, CORE_ADDR load_addr,
 372                              struct gdbarch *gdbarch, struct obstack *obstack)
 373 {
 374   char *p;
 375   struct bfd * dll;
 376   CORE_ADDR text_offset;
 377
 378   obstack_grow_str (obstack, "<library name=\"");
 379   p = xml_escape_text (so_name);
 380   obstack_grow_str (obstack, p);
 381   xfree (p);
 382   obstack_grow_str (obstack, "\"><segment address=\"");
 383   dll = gdb_bfd_open (so_name, gnutarget, -1);
 384   /* The following calls are OK even if dll is NULL.
 385      The default value 0x1000 is returned by pe_text_section_offset
 386      in that case.  */
 387   text_offset = pe_text_section_offset (dll);
 388   gdb_bfd_unref (dll);
 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 (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   /* Canonical paths on this target look like
 472      `c:\Program Files\Foo App\mydll.dll', for example.  */
 473   set_gdbarch_has_dos_based_file_system (gdbarch, 1);
 474
 475   set_gdbarch_iterate_over_objfiles_in_search_order
 476     (gdbarch, windows_iterate_over_objfiles_in_search_order);
 477
 478   set_solib_ops (gdbarch, &solib_target_so_ops);
 479 }
 480
 481 /* Provide a prototype to silence -Wmissing-prototypes.  */
 482 extern initialize_file_ftype _initialize_windows_tdep;
 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 }