gdb/i386-gnu-nat.c

   1 /* Low level interface to i386 running the GNU Hurd.
   2
   3    Copyright (C) 1992-2022 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /* Include this first, to pick up the <mach.h> 'thread_info' diversion.  */
  21 #include "gnu-nat.h"
  22
  23 /* Mach/Hurd headers are not yet ready for C++ compilation.  */
  24 extern "C"
  25 {
  26 #include <mach.h>
  27 #include <mach_error.h>
  28 #include <mach/message.h>
  29 #include <mach/exception.h>
  30 }
  31
  32 #include "defs.h"
  33 #include "x86-nat.h"
  34 #include "inferior.h"
  35 #include "floatformat.h"
  36 #include "regcache.h"
  37
  38 #include "i386-tdep.h"
  39
  40 #include "inf-child.h"
  41 #include "i387-tdep.h"
  42
  43 /* Offset to the thread_state_t location where REG is stored.  */
  44 #define REG_OFFSET(reg) offsetof (struct i386_thread_state, reg)
  45
  46 /* At REG_OFFSET[N] is the offset to the thread_state_t location where
  47    the GDB register N is stored.  */
  48 static int reg_offset[] =
  49 {
  50   REG_OFFSET (eax), REG_OFFSET (ecx), REG_OFFSET (edx), REG_OFFSET (ebx),
  51   REG_OFFSET (uesp), REG_OFFSET (ebp), REG_OFFSET (esi), REG_OFFSET (edi),
  52   REG_OFFSET (eip), REG_OFFSET (efl), REG_OFFSET (cs), REG_OFFSET (ss),
  53   REG_OFFSET (ds), REG_OFFSET (es), REG_OFFSET (fs), REG_OFFSET (gs)
  54 };
  55
  56 #define REG_ADDR(state, regnum) ((char *)(state) + reg_offset[regnum])
  57
  58 \f
  59
  60 /* The i386 GNU Hurd target.  */
  61
  62 #ifdef i386_DEBUG_STATE
  63 using gnu_base_target = x86_nat_target<gnu_nat_target>;
  64 #else
  65 using gnu_base_target = gnu_nat_target;
  66 #endif
  67
  68 struct i386_gnu_nat_target final : public gnu_base_target
  69 {
  70   void fetch_registers (struct regcache *, int) override;
  71   void store_registers (struct regcache *, int) override;
  72 };
  73
  74 static i386_gnu_nat_target the_i386_gnu_nat_target;
  75
  76 /* Get the whole floating-point state of THREAD and record the values
  77    of the corresponding (pseudo) registers.  */
  78
  79 static void
  80 fetch_fpregs (struct regcache *regcache, struct proc *thread)
  81 {
  82   mach_msg_type_number_t count = i386_FLOAT_STATE_COUNT;
  83   struct i386_float_state state;
  84   kern_return_t err;
  85
  86   err = thread_get_state (thread->port, i386_FLOAT_STATE,
  87                           (thread_state_t) &state, &count);
  88   if (err)
  89     {
  90       warning (_("Couldn't fetch floating-point state from %s"),
  91                proc_string (thread));
  92       return;
  93     }
  94
  95   if (!state.initialized)
  96     {
  97       /* The floating-point state isn't initialized.  */
  98       i387_supply_fsave (regcache, -1, NULL);
  99     }
 100   else
 101     {
 102       /* Supply the floating-point registers.  */
 103       i387_supply_fsave (regcache, -1, state.hw_state);
 104     }
 105 }
 106
 107 /* Fetch register REGNO, or all regs if REGNO is -1.  */
 108 void
 109 i386_gnu_nat_target::fetch_registers (struct regcache *regcache, int regno)
 110 {
 111   struct proc *thread;
 112   ptid_t ptid = regcache->ptid ();
 113
 114   /* Make sure we know about new threads.  */
 115   inf_update_procs (gnu_current_inf);
 116
 117   thread = inf_tid_to_thread (gnu_current_inf, ptid.lwp ());
 118   if (!thread)
 119     error (_("Can't fetch registers from thread %s: No such thread"),
 120            target_pid_to_str (ptid).c_str ());
 121
 122   if (regno < I386_NUM_GREGS || regno == -1)
 123     {
 124       thread_state_t state;
 125
 126       /* This does the dirty work for us.  */
 127       state = proc_get_state (thread, 0);
 128       if (!state)
 129         {
 130           warning (_("Couldn't fetch registers from %s"),
 131                    proc_string (thread));
 132           return;
 133         }
 134
 135       if (regno == -1)
 136         {
 137           int i;
 138
 139           proc_debug (thread, "fetching all register");
 140
 141           for (i = 0; i < I386_NUM_GREGS; i++)
 142             regcache->raw_supply (i, REG_ADDR (state, i));
 143           thread->fetched_regs = ~0;
 144         }
 145       else
 146         {
 147           proc_debug (thread, "fetching register %s",
 148                       gdbarch_register_name (regcache->arch (),
 149                                              regno));
 150
 151           regcache->raw_supply (regno, REG_ADDR (state, regno));
 152           thread->fetched_regs |= (1 << regno);
 153         }
 154     }
 155
 156   if (regno >= I386_NUM_GREGS || regno == -1)
 157     {
 158       proc_debug (thread, "fetching floating-point registers");
 159
 160       fetch_fpregs (regcache, thread);
 161     }
 162 }
 163 \f
 164
 165 /* Store the whole floating-point state into THREAD using information
 166    from the corresponding (pseudo) registers.  */
 167 static void
 168 store_fpregs (const struct regcache *regcache, struct proc *thread, int regno)
 169 {
 170   mach_msg_type_number_t count = i386_FLOAT_STATE_COUNT;
 171   struct i386_float_state state;
 172   kern_return_t err;
 173
 174   err = thread_get_state (thread->port, i386_FLOAT_STATE,
 175                           (thread_state_t) &state, &count);
 176   if (err)
 177     {
 178       warning (_("Couldn't fetch floating-point state from %s"),
 179                proc_string (thread));
 180       return;
 181     }
 182
 183   /* FIXME: kettenis/2001-07-15: Is this right?  Should we somehow
 184      take into account DEPRECATED_REGISTER_VALID like the old code did?  */
 185   i387_collect_fsave (regcache, regno, state.hw_state);
 186
 187   err = thread_set_state (thread->port, i386_FLOAT_STATE,
 188                           (thread_state_t) &state, i386_FLOAT_STATE_COUNT);
 189   if (err)
 190     {
 191       warning (_("Couldn't store floating-point state into %s"),
 192                proc_string (thread));
 193       return;
 194     }
 195 }
 196
 197 /* Store at least register REGNO, or all regs if REGNO == -1.  */
 198 void
 199 i386_gnu_nat_target::store_registers (struct regcache *regcache, int regno)
 200 {
 201   struct proc *thread;
 202   struct gdbarch *gdbarch = regcache->arch ();
 203   ptid_t ptid = regcache->ptid ();
 204
 205   /* Make sure we know about new threads.  */
 206   inf_update_procs (gnu_current_inf);
 207
 208   thread = inf_tid_to_thread (gnu_current_inf, ptid.lwp ());
 209   if (!thread)
 210     error (_("Couldn't store registers into thread %s: No such thread"),
 211            target_pid_to_str (ptid).c_str ());
 212
 213   if (regno < I386_NUM_GREGS || regno == -1)
 214     {
 215       thread_state_t state;
 216       thread_state_data_t old_state;
 217       int was_aborted = thread->aborted;
 218       int was_valid = thread->state_valid;
 219       int trace;
 220
 221       if (!was_aborted && was_valid)
 222         memcpy (&old_state, &thread->state, sizeof (old_state));
 223
 224       state = proc_get_state (thread, 1);
 225       if (!state)
 226         {
 227           warning (_("Couldn't store registers into %s"),
 228                    proc_string (thread));
 229           return;
 230         }
 231
 232       /* Save the T bit.  We might try to restore the %eflags register
 233          below, but changing the T bit would seriously confuse GDB.  */
 234       trace = ((struct i386_thread_state *)state)->efl & 0x100;
 235
 236       if (!was_aborted && was_valid)
 237         /* See which registers have changed after aborting the thread.  */
 238         {
 239           int check_regno;
 240
 241           for (check_regno = 0; check_regno < I386_NUM_GREGS; check_regno++)
 242             if ((thread->fetched_regs & (1 << check_regno))
 243                 && memcpy (REG_ADDR (&old_state, check_regno),
 244                            REG_ADDR (state, check_regno),
 245                            register_size (gdbarch, check_regno)))
 246               /* Register CHECK_REGNO has changed!  Ack!  */
 247               {
 248                 warning (_("Register %s changed after the thread was aborted"),
 249                          gdbarch_register_name (gdbarch, check_regno));
 250                 if (regno >= 0 && regno != check_regno)
 251                   /* Update GDB's copy of the register.  */
 252                   regcache->raw_supply (check_regno,
 253                                         REG_ADDR (state, check_regno));
 254                 else
 255                   warning (_("... also writing this register!  "
 256                              "Suspicious..."));
 257               }
 258         }
 259
 260       if (regno == -1)
 261         {
 262           int i;
 263
 264           proc_debug (thread, "storing all registers");
 265
 266           for (i = 0; i < I386_NUM_GREGS; i++)
 267             if (REG_VALID == regcache->get_register_status (i))
 268               regcache->raw_collect (i, REG_ADDR (state, i));
 269         }
 270       else
 271         {
 272           proc_debug (thread, "storing register %s",
 273                       gdbarch_register_name (gdbarch, regno));
 274
 275           gdb_assert (REG_VALID == regcache->get_register_status (regno));
 276           regcache->raw_collect (regno, REG_ADDR (state, regno));
 277         }
 278
 279       /* Restore the T bit.  */
 280       ((struct i386_thread_state *)state)->efl &= ~0x100;
 281       ((struct i386_thread_state *)state)->efl |= trace;
 282     }
 283
 284   if (regno >= I386_NUM_GREGS || regno == -1)
 285     {
 286       proc_debug (thread, "storing floating-point registers");
 287
 288       store_fpregs (regcache, thread, regno);
 289     }
 290 }
 291
 292 \f
 293 /* Support for debug registers.  */
 294
 295 #ifdef i386_DEBUG_STATE
 296 /* Get debug registers for thread THREAD.  */
 297
 298 static void
 299 i386_gnu_dr_get (struct i386_debug_state *regs, struct proc *thread)
 300 {
 301   mach_msg_type_number_t count = i386_DEBUG_STATE_COUNT;
 302   kern_return_t err;
 303
 304   err = thread_get_state (thread->port, i386_DEBUG_STATE,
 305                           (thread_state_t) regs, &count);
 306   if (err != 0 || count != i386_DEBUG_STATE_COUNT)
 307     warning (_("Couldn't fetch debug state from %s"),
 308              proc_string (thread));
 309 }
 310
 311 /* Set debug registers for thread THREAD.  */
 312
 313 static void
 314 i386_gnu_dr_set (const struct i386_debug_state *regs, struct proc *thread)
 315 {
 316   kern_return_t err;
 317
 318   err = thread_set_state (thread->port, i386_DEBUG_STATE,
 319                           (thread_state_t) regs, i386_DEBUG_STATE_COUNT);
 320   if (err != 0)
 321     warning (_("Couldn't store debug state into %s"),
 322              proc_string (thread));
 323 }
 324
 325 /* Set DR_CONTROL in THREAD.  */
 326
 327 static void
 328 i386_gnu_dr_set_control_one (struct proc *thread, void *arg)
 329 {
 330   unsigned long *control = (unsigned long *) arg;
 331   struct i386_debug_state regs;
 332
 333   i386_gnu_dr_get (&regs, thread);
 334   regs.dr[DR_CONTROL] = *control;
 335   i386_gnu_dr_set (&regs, thread);
 336 }
 337
 338 /* Set DR_CONTROL to CONTROL in all threads.  */
 339
 340 static void
 341 i386_gnu_dr_set_control (unsigned long control)
 342 {
 343   inf_update_procs (gnu_current_inf);
 344   inf_threads (gnu_current_inf, i386_gnu_dr_set_control_one, &control);
 345 }
 346
 347 /* Parameters to set a debugging address.  */
 348
 349 struct reg_addr
 350 {
 351   int regnum;           /* Register number (zero based).  */
 352   CORE_ADDR addr;       /* Address.  */
 353 };
 354
 355 /* Set address REGNUM (zero based) to ADDR in THREAD.  */
 356
 357 static void
 358 i386_gnu_dr_set_addr_one (struct proc *thread, void *arg)
 359 {
 360   struct reg_addr *reg_addr = (struct reg_addr *) arg;
 361   struct i386_debug_state regs;
 362
 363   i386_gnu_dr_get (&regs, thread);
 364   regs.dr[reg_addr->regnum] = reg_addr->addr;
 365   i386_gnu_dr_set (&regs, thread);
 366 }
 367
 368 /* Set address REGNUM (zero based) to ADDR in all threads.  */
 369
 370 static void
 371 i386_gnu_dr_set_addr (int regnum, CORE_ADDR addr)
 372 {
 373   struct reg_addr reg_addr;
 374
 375   gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
 376
 377   reg_addr.regnum = regnum;
 378   reg_addr.addr = addr;
 379
 380   inf_update_procs (gnu_current_inf);
 381   inf_threads (gnu_current_inf, i386_gnu_dr_set_addr_one, &reg_addr);
 382 }
 383
 384 /* Get debug register REGNUM value from only the one LWP of PTID.  */
 385
 386 static unsigned long
 387 i386_gnu_dr_get_reg (ptid_t ptid, int regnum)
 388 {
 389   struct i386_debug_state regs;
 390   struct proc *thread;
 391
 392   /* Make sure we know about new threads.  */
 393   inf_update_procs (gnu_current_inf);
 394
 395   thread = inf_tid_to_thread (gnu_current_inf, ptid.lwp ());
 396   i386_gnu_dr_get (&regs, thread);
 397
 398   return regs.dr[regnum];
 399 }
 400
 401 /* Return the inferior's debug register REGNUM.  */
 402
 403 static CORE_ADDR
 404 i386_gnu_dr_get_addr (int regnum)
 405 {
 406   gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
 407
 408   return i386_gnu_dr_get_reg (inferior_ptid, regnum);
 409 }
 410
 411 /* Get DR_STATUS from only the one thread of INFERIOR_PTID.  */
 412
 413 static unsigned long
 414 i386_gnu_dr_get_status (void)
 415 {
 416   return i386_gnu_dr_get_reg (inferior_ptid, DR_STATUS);
 417 }
 418
 419 /* Return the inferior's DR7 debug control register.  */
 420
 421 static unsigned long
 422 i386_gnu_dr_get_control (void)
 423 {
 424   return i386_gnu_dr_get_reg (inferior_ptid, DR_CONTROL);
 425 }
 426 #endif /* i386_DEBUG_STATE */
 427
 428 void _initialize_i386gnu_nat ();
 429 void
 430 _initialize_i386gnu_nat ()
 431 {
 432 #ifdef i386_DEBUG_STATE
 433   x86_dr_low.set_control = i386_gnu_dr_set_control;
 434   gdb_assert (DR_FIRSTADDR == 0 && DR_LASTADDR < i386_DEBUG_STATE_COUNT);
 435   x86_dr_low.set_addr = i386_gnu_dr_set_addr;
 436   x86_dr_low.get_addr = i386_gnu_dr_get_addr;
 437   x86_dr_low.get_status = i386_gnu_dr_get_status;
 438   x86_dr_low.get_control = i386_gnu_dr_get_control;
 439   x86_set_debug_register_length (4);
 440 #endif /* i386_DEBUG_STATE */
 441
 442   gnu_target = &the_i386_gnu_nat_target;
 443
 444   /* Register the target.  */
 445   add_inf_child_target (&the_i386_gnu_nat_target);
 446 }