gdb/windows-tdep.c

   1 /* Copyright (C) 2008-2017 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   CORE_ADDR text_offset;
 376
 377   obstack_grow_str (obstack, "<library name=\"");
 378   p = xml_escape_text (so_name);
 379   obstack_grow_str (obstack, p);
 380   xfree (p);
 381   obstack_grow_str (obstack, "\"><segment address=\"");
 382   gdb_bfd_ref_ptr dll (gdb_bfd_open (so_name, gnutarget, -1));
 383   /* The following calls are OK even if dll is NULL.
 384      The default value 0x1000 is returned by pe_text_section_offset
 385      in that case.  */
 386   text_offset = pe_text_section_offset (dll.get ());
 387   obstack_grow_str (obstack, paddress (gdbarch, load_addr + text_offset));
 388   obstack_grow_str (obstack, "\"/></library>");
 389 }
 390
 391 /* Implement the "iterate_over_objfiles_in_search_order" gdbarch
 392    method.  It searches all objfiles, starting with CURRENT_OBJFILE
 393    first (if not NULL).
 394
 395    On Windows, the system behaves a little differently when two
 396    objfiles each define a global symbol using the same name, compared
 397    to other platforms such as GNU/Linux for instance.  On GNU/Linux,
 398    all instances of the symbol effectively get merged into a single
 399    one, but on Windows, they remain distinct.
 400
 401    As a result, it usually makes sense to start global symbol searches
 402    with the current objfile before expanding it to all other objfiles.
 403    This helps for instance when a user debugs some code in a DLL that
 404    refers to a global variable defined inside that DLL.  When trying
 405    to print the value of that global variable, it would be unhelpful
 406    to print the value of another global variable defined with the same
 407    name, but in a different DLL.  */
 408
 409 static void
 410 windows_iterate_over_objfiles_in_search_order
 411   (struct gdbarch *gdbarch,
 412    iterate_over_objfiles_in_search_order_cb_ftype *cb,
 413    void *cb_data, struct objfile *current_objfile)
 414 {
 415   int stop;
 416   struct objfile *objfile;
 417
 418   if (current_objfile)
 419     {
 420       stop = cb (current_objfile, cb_data);
 421       if (stop)
 422         return;
 423     }
 424
 425   ALL_OBJFILES (objfile)
 426     {
 427       if (objfile != current_objfile)
 428         {
 429           stop = cb (objfile, cb_data);
 430           if (stop)
 431             return;
 432         }
 433     }
 434 }
 435
 436 static void
 437 show_maint_show_all_tib (struct ui_file *file, int from_tty,
 438                 struct cmd_list_element *c, const char *value)
 439 {
 440   fprintf_filtered (file, _("Show all non-zero elements of "
 441                             "Thread Information Block is %s.\n"), value);
 442 }
 443
 444 static void
 445 info_w32_command (char *args, int from_tty)
 446 {
 447   help_list (info_w32_cmdlist, "info w32 ", class_info, gdb_stdout);
 448 }
 449
 450 static int w32_prefix_command_valid = 0;
 451 void
 452 init_w32_command_list (void)
 453 {
 454   if (!w32_prefix_command_valid)
 455     {
 456       add_prefix_cmd ("w32", class_info, info_w32_command,
 457                       _("Print information specific to Win32 debugging."),
 458                       &info_w32_cmdlist, "info w32 ", 0, &infolist);
 459       w32_prefix_command_valid = 1;
 460     }
 461 }
 462
 463 /* To be called from the various GDB_OSABI_CYGWIN handlers for the
 464    various Windows architectures and machine types.  */
 465
 466 void
 467 windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 468 {
 469   /* Canonical paths on this target look like
 470      `c:\Program Files\Foo App\mydll.dll', for example.  */
 471   set_gdbarch_has_dos_based_file_system (gdbarch, 1);
 472
 473   set_gdbarch_iterate_over_objfiles_in_search_order
 474     (gdbarch, windows_iterate_over_objfiles_in_search_order);
 475
 476   set_solib_ops (gdbarch, &solib_target_so_ops);
 477 }
 478
 479 /* Provide a prototype to silence -Wmissing-prototypes.  */
 480 extern initialize_file_ftype _initialize_windows_tdep;
 481
 482 /* Implementation of `tlb' variable.  */
 483
 484 static const struct internalvar_funcs tlb_funcs =
 485 {
 486   tlb_make_value,
 487   NULL,
 488   NULL
 489 };
 490
 491 void
 492 _initialize_windows_tdep (void)
 493 {
 494   init_w32_command_list ();
 495   add_cmd ("thread-information-block", class_info, display_tib,
 496            _("Display thread information block."),
 497            &info_w32_cmdlist);
 498   add_alias_cmd ("tib", "thread-information-block", class_info, 1,
 499                  &info_w32_cmdlist);
 500
 501   add_setshow_boolean_cmd ("show-all-tib", class_maintenance,
 502                            &maint_display_all_tib, _("\
 503 Set whether to display all non-zero fields of thread information block."), _("\
 504 Show whether to display all non-zero fields of thread information block."), _("\
 505 Use \"on\" to enable, \"off\" to disable.\n\
 506 If enabled, all non-zero fields of thread information block are displayed,\n\
 507 even if their meaning is unknown."),
 508                            NULL,
 509                            show_maint_show_all_tib,
 510                            &maintenance_set_cmdlist,
 511                            &maintenance_show_cmdlist);
 512
 513   /* Explicitly create without lookup, since that tries to create a
 514      value with a void typed value, and when we get here, gdbarch
 515      isn't initialized yet.  At this point, we're quite sure there
 516      isn't another convenience variable of the same name.  */
 517   create_internalvar_type_lazy ("_tlb", &tlb_funcs, NULL);
 518 }