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