gdb/i386-nat.c

   1 /* Native-dependent code for the i386.
   2
   3    Copyright (C) 2001-2014 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 "defs.h"
  21 #include "i386-nat.h"
  22 #include "breakpoint.h"
  23 #include "command.h"
  24 #include "gdbcmd.h"
  25 #include "target.h"
  26 #include "gdb_assert.h"
  27 #include "inferior.h"
  28
  29 /* Support for hardware watchpoints and breakpoints using the i386
  30    debug registers.
  31
  32    This provides several functions for inserting and removing
  33    hardware-assisted breakpoints and watchpoints, testing if one or
  34    more of the watchpoints triggered and at what address, checking
  35    whether a given region can be watched, etc.
  36
  37    The functions below implement debug registers sharing by reference
  38    counts, and allow to watch regions up to 16 bytes long.  */
  39
  40 struct i386_dr_low_type i386_dr_low;
  41
  42
  43 /* Support for 8-byte wide hw watchpoints.  */
  44 #define TARGET_HAS_DR_LEN_8 (i386_dr_low.debug_register_length == 8)
  45
  46 /* DR7 Debug Control register fields.  */
  47
  48 /* How many bits to skip in DR7 to get to R/W and LEN fields.  */
  49 #define DR_CONTROL_SHIFT        16
  50 /* How many bits in DR7 per R/W and LEN field for each watchpoint.  */
  51 #define DR_CONTROL_SIZE         4
  52
  53 /* Watchpoint/breakpoint read/write fields in DR7.  */
  54 #define DR_RW_EXECUTE   (0x0)   /* Break on instruction execution.  */
  55 #define DR_RW_WRITE     (0x1)   /* Break on data writes.  */
  56 #define DR_RW_READ      (0x3)   /* Break on data reads or writes.  */
  57
  58 /* This is here for completeness.  No platform supports this
  59    functionality yet (as of March 2001).  Note that the DE flag in the
  60    CR4 register needs to be set to support this.  */
  61 #ifndef DR_RW_IORW
  62 #define DR_RW_IORW      (0x2)   /* Break on I/O reads or writes.  */
  63 #endif
  64
  65 /* Watchpoint/breakpoint length fields in DR7.  The 2-bit left shift
  66    is so we could OR this with the read/write field defined above.  */
  67 #define DR_LEN_1        (0x0 << 2) /* 1-byte region watch or breakpoint.  */
  68 #define DR_LEN_2        (0x1 << 2) /* 2-byte region watch.  */
  69 #define DR_LEN_4        (0x3 << 2) /* 4-byte region watch.  */
  70 #define DR_LEN_8        (0x2 << 2) /* 8-byte region watch (AMD64).  */
  71
  72 /* Local and Global Enable flags in DR7.
  73
  74    When the Local Enable flag is set, the breakpoint/watchpoint is
  75    enabled only for the current task; the processor automatically
  76    clears this flag on every task switch.  When the Global Enable flag
  77    is set, the breakpoint/watchpoint is enabled for all tasks; the
  78    processor never clears this flag.
  79
  80    Currently, all watchpoint are locally enabled.  If you need to
  81    enable them globally, read the comment which pertains to this in
  82    i386_insert_aligned_watchpoint below.  */
  83 #define DR_LOCAL_ENABLE_SHIFT   0 /* Extra shift to the local enable bit.  */
  84 #define DR_GLOBAL_ENABLE_SHIFT  1 /* Extra shift to the global enable bit.  */
  85 #define DR_ENABLE_SIZE          2 /* Two enable bits per debug register.  */
  86
  87 /* Local and global exact breakpoint enable flags (a.k.a. slowdown
  88    flags).  These are only required on i386, to allow detection of the
  89    exact instruction which caused a watchpoint to break; i486 and
  90    later processors do that automatically.  We set these flags for
  91    backwards compatibility.  */
  92 #define DR_LOCAL_SLOWDOWN       (0x100)
  93 #define DR_GLOBAL_SLOWDOWN      (0x200)
  94
  95 /* Fields reserved by Intel.  This includes the GD (General Detect
  96    Enable) flag, which causes a debug exception to be generated when a
  97    MOV instruction accesses one of the debug registers.
  98
  99    FIXME: My Intel manual says we should use 0xF800, not 0xFC00.  */
 100 #define DR_CONTROL_RESERVED     (0xFC00)
 101
 102 /* Auxiliary helper macros.  */
 103
 104 /* A value that masks all fields in DR7 that are reserved by Intel.  */
 105 #define I386_DR_CONTROL_MASK    (~DR_CONTROL_RESERVED)
 106
 107 /* The I'th debug register is vacant if its Local and Global Enable
 108    bits are reset in the Debug Control register.  */
 109 #define I386_DR_VACANT(state, i)                                        \
 110   (((state)->dr_control_mirror & (3 << (DR_ENABLE_SIZE * (i)))) == 0)
 111
 112 /* Locally enable the break/watchpoint in the I'th debug register.  */
 113 #define I386_DR_LOCAL_ENABLE(state, i) \
 114   do { \
 115     (state)->dr_control_mirror |= \
 116       (1 << (DR_LOCAL_ENABLE_SHIFT + DR_ENABLE_SIZE * (i))); \
 117   } while (0)
 118
 119 /* Globally enable the break/watchpoint in the I'th debug register.  */
 120 #define I386_DR_GLOBAL_ENABLE(state, i) \
 121   do { \
 122     (state)->dr_control_mirror |= \
 123       (1 << (DR_GLOBAL_ENABLE_SHIFT + DR_ENABLE_SIZE * (i))); \
 124   } while (0)
 125
 126 /* Disable the break/watchpoint in the I'th debug register.  */
 127 #define I386_DR_DISABLE(state, i) \
 128   do { \
 129     (state)->dr_control_mirror &= \
 130       ~(3 << (DR_ENABLE_SIZE * (i))); \
 131   } while (0)
 132
 133 /* Set in DR7 the RW and LEN fields for the I'th debug register.  */
 134 #define I386_DR_SET_RW_LEN(state, i, rwlen) \
 135   do { \
 136     (state)->dr_control_mirror &= \
 137       ~(0x0f << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (i))); \
 138     (state)->dr_control_mirror |= \
 139       ((rwlen) << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (i))); \
 140   } while (0)
 141
 142 /* Get from DR7 the RW and LEN fields for the I'th debug register.  */
 143 #define I386_DR_GET_RW_LEN(dr7, i) \
 144   (((dr7) \
 145     >> (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (i))) & 0x0f)
 146
 147 /* Mask that this I'th watchpoint has triggered.  */
 148 #define I386_DR_WATCH_MASK(i)   (1 << (i))
 149
 150 /* Did the watchpoint whose address is in the I'th register break?  */
 151 #define I386_DR_WATCH_HIT(dr6, i) ((dr6) & (1 << (i)))
 152
 153 /* A macro to loop over all debug registers.  */
 154 #define ALL_DEBUG_REGISTERS(i)  for (i = 0; i < DR_NADDR; i++)
 155
 156 /* Per-process data.  We don't bind this to a per-inferior registry
 157    because of targets like x86 GNU/Linux that need to keep track of
 158    processes that aren't bound to any inferior (e.g., fork children,
 159    checkpoints).  */
 160
 161 struct i386_process_info
 162 {
 163   /* Linked list.  */
 164   struct i386_process_info *next;
 165
 166   /* The process identifier.  */
 167   pid_t pid;
 168
 169   /* Copy of i386 hardware debug registers.  */
 170   struct i386_debug_reg_state state;
 171 };
 172
 173 static struct i386_process_info *i386_process_list = NULL;
 174
 175 /* Find process data for process PID.  */
 176
 177 static struct i386_process_info *
 178 i386_find_process_pid (pid_t pid)
 179 {
 180   struct i386_process_info *proc;
 181
 182   for (proc = i386_process_list; proc; proc = proc->next)
 183     if (proc->pid == pid)
 184       return proc;
 185
 186   return NULL;
 187 }
 188
 189 /* Add process data for process PID.  Returns newly allocated info
 190    object.  */
 191
 192 static struct i386_process_info *
 193 i386_add_process (pid_t pid)
 194 {
 195   struct i386_process_info *proc;
 196
 197   proc = xcalloc (1, sizeof (*proc));
 198   proc->pid = pid;
 199
 200   proc->next = i386_process_list;
 201   i386_process_list = proc;
 202
 203   return proc;
 204 }
 205
 206 /* Get data specific info for process PID, creating it if necessary.
 207    Never returns NULL.  */
 208
 209 static struct i386_process_info *
 210 i386_process_info_get (pid_t pid)
 211 {
 212   struct i386_process_info *proc;
 213
 214   proc = i386_find_process_pid (pid);
 215   if (proc == NULL)
 216     proc = i386_add_process (pid);
 217
 218   return proc;
 219 }
 220
 221 /* Get debug registers state for process PID.  */
 222
 223 struct i386_debug_reg_state *
 224 i386_debug_reg_state (pid_t pid)
 225 {
 226   return &i386_process_info_get (pid)->state;
 227 }
 228
 229 /* See declaration in i386-nat.h.  */
 230
 231 void
 232 i386_forget_process (pid_t pid)
 233 {
 234   struct i386_process_info *proc, **proc_link;
 235
 236   proc = i386_process_list;
 237   proc_link = &i386_process_list;
 238
 239   while (proc != NULL)
 240     {
 241       if (proc->pid == pid)
 242         {
 243           *proc_link = proc->next;
 244
 245           xfree (proc);
 246           return;
 247         }
 248
 249       proc_link = &proc->next;
 250       proc = *proc_link;
 251     }
 252 }
 253
 254 /* Whether or not to print the mirrored debug registers.  */
 255 static int maint_show_dr;
 256
 257 /* Types of operations supported by i386_handle_nonaligned_watchpoint.  */
 258 typedef enum { WP_INSERT, WP_REMOVE, WP_COUNT } i386_wp_op_t;
 259
 260 /* Internal functions.  */
 261
 262 /* Return the value of a 4-bit field for DR7 suitable for watching a
 263    region of LEN bytes for accesses of type TYPE.  LEN is assumed to
 264    have the value of 1, 2, or 4.  */
 265 static unsigned i386_length_and_rw_bits (int len, enum target_hw_bp_type type);
 266
 267 /* Insert a watchpoint at address ADDR, which is assumed to be aligned
 268    according to the length of the region to watch.  LEN_RW_BITS is the
 269    value of the bit-field from DR7 which describes the length and
 270    access type of the region to be watched by this watchpoint.  Return
 271    0 on success, -1 on failure.  */
 272 static int i386_insert_aligned_watchpoint (struct i386_debug_reg_state *state,
 273                                            CORE_ADDR addr,
 274                                            unsigned len_rw_bits);
 275
 276 /* Remove a watchpoint at address ADDR, which is assumed to be aligned
 277    according to the length of the region to watch.  LEN_RW_BITS is the
 278    value of the bits from DR7 which describes the length and access
 279    type of the region watched by this watchpoint.  Return 0 on
 280    success, -1 on failure.  */
 281 static int i386_remove_aligned_watchpoint (struct i386_debug_reg_state *state,
 282                                            CORE_ADDR addr,
 283                                            unsigned len_rw_bits);
 284
 285 /* Insert or remove a (possibly non-aligned) watchpoint, or count the
 286    number of debug registers required to watch a region at address
 287    ADDR whose length is LEN for accesses of type TYPE.  Return 0 on
 288    successful insertion or removal, a positive number when queried
 289    about the number of registers, or -1 on failure.  If WHAT is not a
 290    valid value, bombs through internal_error.  */
 291 static int i386_handle_nonaligned_watchpoint (struct i386_debug_reg_state *state,
 292                                               i386_wp_op_t what,
 293                                               CORE_ADDR addr, int len,
 294                                               enum target_hw_bp_type type);
 295
 296 /* Implementation.  */
 297
 298 /* Clear the reference counts and forget everything we knew about the
 299    debug registers.  */
 300
 301 void
 302 i386_cleanup_dregs (void)
 303 {
 304   /* Starting from scratch has the same effect.  */
 305   i386_forget_process (ptid_get_pid (inferior_ptid));
 306 }
 307
 308 /* Print the values of the mirrored debug registers.  This is called
 309    when maint_show_dr is non-zero.  To set that up, type "maint
 310    show-debug-regs" at GDB's prompt.  */
 311
 312 static void
 313 i386_show_dr (struct i386_debug_reg_state *state,
 314               const char *func, CORE_ADDR addr,
 315               int len, enum target_hw_bp_type type)
 316 {
 317   int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
 318   int i;
 319
 320   puts_unfiltered (func);
 321   if (addr || len)
 322     printf_unfiltered (" (addr=%lx, len=%d, type=%s)",
 323                        /* This code is for ia32, so casting CORE_ADDR
 324                           to unsigned long should be okay.  */
 325                        (unsigned long)addr, len,
 326                        type == hw_write ? "data-write"
 327                        : (type == hw_read ? "data-read"
 328                           : (type == hw_access ? "data-read/write"
 329                              : (type == hw_execute ? "instruction-execute"
 330                                 /* FIXME: if/when I/O read/write
 331                                    watchpoints are supported, add them
 332                                    here.  */
 333                                 : "??unknown??"))));
 334   puts_unfiltered (":\n");
 335   printf_unfiltered ("\tCONTROL (DR7): %s          STATUS (DR6): %s\n",
 336                      phex (state->dr_control_mirror, 8),
 337                      phex (state->dr_status_mirror, 8));
 338   ALL_DEBUG_REGISTERS(i)
 339     {
 340       printf_unfiltered ("\
 341 \tDR%d: addr=0x%s, ref.count=%d  DR%d: addr=0x%s, ref.count=%d\n",
 342                          i, phex (state->dr_mirror[i], addr_size),
 343                          state->dr_ref_count[i],
 344                          i + 1, phex (state->dr_mirror[i + 1], addr_size),
 345                          state->dr_ref_count[i+1]);
 346       i++;
 347     }
 348 }
 349
 350 /* Return the value of a 4-bit field for DR7 suitable for watching a
 351    region of LEN bytes for accesses of type TYPE.  LEN is assumed to
 352    have the value of 1, 2, or 4.  */
 353
 354 static unsigned
 355 i386_length_and_rw_bits (int len, enum target_hw_bp_type type)
 356 {
 357   unsigned rw;
 358
 359   switch (type)
 360     {
 361       case hw_execute:
 362         rw = DR_RW_EXECUTE;
 363         break;
 364       case hw_write:
 365         rw = DR_RW_WRITE;
 366         break;
 367       case hw_read:
 368         internal_error (__FILE__, __LINE__,
 369                         _("The i386 doesn't support "
 370                           "data-read watchpoints.\n"));
 371       case hw_access:
 372         rw = DR_RW_READ;
 373         break;
 374 #if 0
 375         /* Not yet supported.  */
 376       case hw_io_access:
 377         rw = DR_RW_IORW;
 378         break;
 379 #endif
 380       default:
 381         internal_error (__FILE__, __LINE__, _("\
 382 Invalid hardware breakpoint type %d in i386_length_and_rw_bits.\n"),
 383                         (int) type);
 384     }
 385
 386   switch (len)
 387     {
 388       case 1:
 389         return (DR_LEN_1 | rw);
 390       case 2:
 391         return (DR_LEN_2 | rw);
 392       case 4:
 393         return (DR_LEN_4 | rw);
 394       case 8:
 395         if (TARGET_HAS_DR_LEN_8)
 396           return (DR_LEN_8 | rw);
 397         /* ELSE FALL THROUGH */
 398       default:
 399         internal_error (__FILE__, __LINE__, _("\
 400 Invalid hardware breakpoint length %d in i386_length_and_rw_bits.\n"), len);
 401     }
 402 }
 403
 404 /* Insert a watchpoint at address ADDR, which is assumed to be aligned
 405    according to the length of the region to watch.  LEN_RW_BITS is the
 406    value of the bits from DR7 which describes the length and access
 407    type of the region to be watched by this watchpoint.  Return 0 on
 408    success, -1 on failure.  */
 409
 410 static int
 411 i386_insert_aligned_watchpoint (struct i386_debug_reg_state *state,
 412                                 CORE_ADDR addr, unsigned len_rw_bits)
 413 {
 414   int i;
 415
 416   if (!i386_dr_low.set_addr || !i386_dr_low.set_control)
 417     return -1;
 418
 419   /* First, look for an occupied debug register with the same address
 420      and the same RW and LEN definitions.  If we find one, we can
 421      reuse it for this watchpoint as well (and save a register).  */
 422   ALL_DEBUG_REGISTERS(i)
 423     {
 424       if (!I386_DR_VACANT (state, i)
 425           && state->dr_mirror[i] == addr
 426           && I386_DR_GET_RW_LEN (state->dr_control_mirror, i) == len_rw_bits)
 427         {
 428           state->dr_ref_count[i]++;
 429           return 0;
 430         }
 431     }
 432
 433   /* Next, look for a vacant debug register.  */
 434   ALL_DEBUG_REGISTERS(i)
 435     {
 436       if (I386_DR_VACANT (state, i))
 437         break;
 438     }
 439
 440   /* No more debug registers!  */
 441   if (i >= DR_NADDR)
 442     return -1;
 443
 444   /* Now set up the register I to watch our region.  */
 445
 446   /* Record the info in our local mirrored array.  */
 447   state->dr_mirror[i] = addr;
 448   state->dr_ref_count[i] = 1;
 449   I386_DR_SET_RW_LEN (state, i, len_rw_bits);
 450   /* Note: we only enable the watchpoint locally, i.e. in the current
 451      task.  Currently, no i386 target allows or supports global
 452      watchpoints; however, if any target would want that in the
 453      future, GDB should probably provide a command to control whether
 454      to enable watchpoints globally or locally, and the code below
 455      should use global or local enable and slow-down flags as
 456      appropriate.  */
 457   I386_DR_LOCAL_ENABLE (state, i);
 458   state->dr_control_mirror |= DR_LOCAL_SLOWDOWN;
 459   state->dr_control_mirror &= I386_DR_CONTROL_MASK;
 460
 461   return 0;
 462 }
 463
 464 /* Remove a watchpoint at address ADDR, which is assumed to be aligned
 465    according to the length of the region to watch.  LEN_RW_BITS is the
 466    value of the bits from DR7 which describes the length and access
 467    type of the region watched by this watchpoint.  Return 0 on
 468    success, -1 on failure.  */
 469
 470 static int
 471 i386_remove_aligned_watchpoint (struct i386_debug_reg_state *state,
 472                                 CORE_ADDR addr, unsigned len_rw_bits)
 473 {
 474   int i, retval = -1;
 475   int all_vacant = 1;
 476
 477   ALL_DEBUG_REGISTERS(i)
 478     {
 479       if (!I386_DR_VACANT (state, i)
 480           && state->dr_mirror[i] == addr
 481           && I386_DR_GET_RW_LEN (state->dr_control_mirror, i) == len_rw_bits)
 482         {
 483           if (--state->dr_ref_count[i] == 0) /* no longer in use?  */
 484             {
 485               /* Reset our mirror.  */
 486               state->dr_mirror[i] = 0;
 487               I386_DR_DISABLE (state, i);
 488               /* Even though not strictly necessary, clear out all
 489                  bits in DR_CONTROL related to this debug register.
 490                  Debug output is clearer when we don't have stale bits
 491                  in place.  This also allows the assertion below.  */
 492               I386_DR_SET_RW_LEN (state, i, 0);
 493             }
 494           retval = 0;
 495         }
 496
 497       if (!I386_DR_VACANT (state, i))
 498         all_vacant = 0;
 499     }
 500
 501   if (all_vacant)
 502     {
 503       /* Even though not strictly necessary, clear out all of
 504          DR_CONTROL, so that when we have no debug registers in use,
 505          we end up with DR_CONTROL == 0.  The Linux support relies on
 506          this for an optimization.  Plus, it makes for clearer debug
 507          output.  */
 508       state->dr_control_mirror &= ~DR_LOCAL_SLOWDOWN;
 509
 510       gdb_assert (state->dr_control_mirror == 0);
 511     }
 512   return retval;
 513 }
 514
 515 /* Insert or remove a (possibly non-aligned) watchpoint, or count the
 516    number of debug registers required to watch a region at address
 517    ADDR whose length is LEN for accesses of type TYPE.  Return 0 on
 518    successful insertion or removal, a positive number when queried
 519    about the number of registers, or -1 on failure.  If WHAT is not a
 520    valid value, bombs through internal_error.  */
 521
 522 static int
 523 i386_handle_nonaligned_watchpoint (struct i386_debug_reg_state *state,
 524                                    i386_wp_op_t what, CORE_ADDR addr, int len,
 525                                    enum target_hw_bp_type type)
 526 {
 527   int retval = 0;
 528   int max_wp_len = TARGET_HAS_DR_LEN_8 ? 8 : 4;
 529
 530   static int size_try_array[8][8] =
 531   {
 532     {1, 1, 1, 1, 1, 1, 1, 1},   /* Trying size one.  */
 533     {2, 1, 2, 1, 2, 1, 2, 1},   /* Trying size two.  */
 534     {2, 1, 2, 1, 2, 1, 2, 1},   /* Trying size three.  */
 535     {4, 1, 2, 1, 4, 1, 2, 1},   /* Trying size four.  */
 536     {4, 1, 2, 1, 4, 1, 2, 1},   /* Trying size five.  */
 537     {4, 1, 2, 1, 4, 1, 2, 1},   /* Trying size six.  */
 538     {4, 1, 2, 1, 4, 1, 2, 1},   /* Trying size seven.  */
 539     {8, 1, 2, 1, 4, 1, 2, 1},   /* Trying size eight.  */
 540   };
 541
 542   while (len > 0)
 543     {
 544       int align = addr % max_wp_len;
 545       /* Four (eight on AMD64) is the maximum length a debug register
 546          can watch.  */
 547       int try = (len > max_wp_len ? (max_wp_len - 1) : len - 1);
 548       int size = size_try_array[try][align];
 549
 550       if (what == WP_COUNT)
 551         {
 552           /* size_try_array[] is defined such that each iteration
 553              through the loop is guaranteed to produce an address and a
 554              size that can be watched with a single debug register.
 555              Thus, for counting the registers required to watch a
 556              region, we simply need to increment the count on each
 557              iteration.  */
 558           retval++;
 559         }
 560       else
 561         {
 562           unsigned len_rw = i386_length_and_rw_bits (size, type);
 563
 564           if (what == WP_INSERT)
 565             retval = i386_insert_aligned_watchpoint (state, addr, len_rw);
 566           else if (what == WP_REMOVE)
 567             retval = i386_remove_aligned_watchpoint (state, addr, len_rw);
 568           else
 569             internal_error (__FILE__, __LINE__, _("\
 570 Invalid value %d of operation in i386_handle_nonaligned_watchpoint.\n"),
 571                             (int)what);
 572           if (retval)
 573             break;
 574         }
 575
 576       addr += size;
 577       len -= size;
 578     }
 579
 580   return retval;
 581 }
 582
 583 /* Update the inferior's debug registers with the new debug registers
 584    state, in NEW_STATE, and then update our local mirror to match.  */
 585
 586 static void
 587 i386_update_inferior_debug_regs (struct i386_debug_reg_state *new_state)
 588 {
 589   struct i386_debug_reg_state *state
 590     = i386_debug_reg_state (ptid_get_pid (inferior_ptid));
 591   int i;
 592
 593   ALL_DEBUG_REGISTERS (i)
 594     {
 595       if (I386_DR_VACANT (new_state, i) != I386_DR_VACANT (state, i))
 596         i386_dr_low.set_addr (i, new_state->dr_mirror[i]);
 597       else
 598         gdb_assert (new_state->dr_mirror[i] == state->dr_mirror[i]);
 599     }
 600
 601   if (new_state->dr_control_mirror != state->dr_control_mirror)
 602     i386_dr_low.set_control (new_state->dr_control_mirror);
 603
 604   *state = *new_state;
 605 }
 606
 607 /* Insert a watchpoint to watch a memory region which starts at
 608    address ADDR and whose length is LEN bytes.  Watch memory accesses
 609    of the type TYPE.  Return 0 on success, -1 on failure.  */
 610
 611 static int
 612 i386_insert_watchpoint (struct target_ops *self,
 613                         CORE_ADDR addr, int len, int type,
 614                         struct expression *cond)
 615 {
 616   struct i386_debug_reg_state *state
 617     = i386_debug_reg_state (ptid_get_pid (inferior_ptid));
 618   int retval;
 619   /* Work on a local copy of the debug registers, and on success,
 620      commit the change back to the inferior.  */
 621   struct i386_debug_reg_state local_state = *state;
 622
 623   if (type == hw_read)
 624     return 1; /* unsupported */
 625
 626   if (((len != 1 && len !=2 && len !=4) && !(TARGET_HAS_DR_LEN_8 && len == 8))
 627       || addr % len != 0)
 628     retval = i386_handle_nonaligned_watchpoint (&local_state,
 629                                                 WP_INSERT, addr, len, type);
 630   else
 631     {
 632       unsigned len_rw = i386_length_and_rw_bits (len, type);
 633
 634       retval = i386_insert_aligned_watchpoint (&local_state,
 635                                                addr, len_rw);
 636     }
 637
 638   if (retval == 0)
 639     i386_update_inferior_debug_regs (&local_state);
 640
 641   if (maint_show_dr)
 642     i386_show_dr (state, "insert_watchpoint", addr, len, type);
 643
 644   return retval;
 645 }
 646
 647 /* Remove a watchpoint that watched the memory region which starts at
 648    address ADDR, whose length is LEN bytes, and for accesses of the
 649    type TYPE.  Return 0 on success, -1 on failure.  */
 650 static int
 651 i386_remove_watchpoint (struct target_ops *self,
 652                         CORE_ADDR addr, int len, int type,
 653                         struct expression *cond)
 654 {
 655   struct i386_debug_reg_state *state
 656     = i386_debug_reg_state (ptid_get_pid (inferior_ptid));
 657   int retval;
 658   /* Work on a local copy of the debug registers, and on success,
 659      commit the change back to the inferior.  */
 660   struct i386_debug_reg_state local_state = *state;
 661
 662   if (((len != 1 && len !=2 && len !=4) && !(TARGET_HAS_DR_LEN_8 && len == 8))
 663       || addr % len != 0)
 664     retval = i386_handle_nonaligned_watchpoint (&local_state,
 665                                                 WP_REMOVE, addr, len, type);
 666   else
 667     {
 668       unsigned len_rw = i386_length_and_rw_bits (len, type);
 669
 670       retval = i386_remove_aligned_watchpoint (&local_state,
 671                                                addr, len_rw);
 672     }
 673
 674   if (retval == 0)
 675     i386_update_inferior_debug_regs (&local_state);
 676
 677   if (maint_show_dr)
 678     i386_show_dr (state, "remove_watchpoint", addr, len, type);
 679
 680   return retval;
 681 }
 682
 683 /* Return non-zero if we can watch a memory region that starts at
 684    address ADDR and whose length is LEN bytes.  */
 685
 686 static int
 687 i386_region_ok_for_watchpoint (struct target_ops *self,
 688                                CORE_ADDR addr, int len)
 689 {
 690   struct i386_debug_reg_state *state
 691     = i386_debug_reg_state (ptid_get_pid (inferior_ptid));
 692   int nregs;
 693
 694   /* Compute how many aligned watchpoints we would need to cover this
 695      region.  */
 696   nregs = i386_handle_nonaligned_watchpoint (state,
 697                                              WP_COUNT, addr, len, hw_write);
 698   return nregs <= DR_NADDR ? 1 : 0;
 699 }
 700
 701 /* If the inferior has some watchpoint that triggered, set the
 702    address associated with that watchpoint and return non-zero.
 703    Otherwise, return zero.  */
 704
 705 static int
 706 i386_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
 707 {
 708   struct i386_debug_reg_state *state
 709     = i386_debug_reg_state (ptid_get_pid (inferior_ptid));
 710   CORE_ADDR addr = 0;
 711   int i;
 712   int rc = 0;
 713   /* The current thread's DR_STATUS.  We always need to read this to
 714      check whether some watchpoint caused the trap.  */
 715   unsigned status;
 716   /* We need DR_CONTROL as well, but only iff DR_STATUS indicates a
 717      data breakpoint trap.  Only fetch it when necessary, to avoid an
 718      unnecessary extra syscall when no watchpoint triggered.  */
 719   int control_p = 0;
 720   unsigned control = 0;
 721
 722   /* In non-stop/async, threads can be running while we change the
 723      STATE (and friends).  Say, we set a watchpoint, and let threads
 724      resume.  Now, say you delete the watchpoint, or add/remove
 725      watchpoints such that STATE changes while threads are running.
 726      On targets that support non-stop, inserting/deleting watchpoints
 727      updates the STATE only.  It does not update the real thread's
 728      debug registers; that's only done prior to resume.  Instead, if
 729      threads are running when the mirror changes, a temporary and
 730      transparent stop on all threads is forced so they can get their
 731      copy of the debug registers updated on re-resume.  Now, say,
 732      a thread hit a watchpoint before having been updated with the new
 733      STATE contents, and we haven't yet handled the corresponding
 734      SIGTRAP.  If we trusted STATE below, we'd mistake the real
 735      trapped address (from the last time we had updated debug
 736      registers in the thread) with whatever was currently in STATE.
 737      So to fix this, STATE always represents intention, what we _want_
 738      threads to have in debug registers.  To get at the address and
 739      cause of the trap, we need to read the state the thread still has
 740      in its debug registers.
 741
 742      In sum, always get the current debug register values the current
 743      thread has, instead of trusting the global mirror.  If the thread
 744      was running when we last changed watchpoints, the mirror no
 745      longer represents what was set in this thread's debug
 746      registers.  */
 747   status = i386_dr_low.get_status ();
 748
 749   ALL_DEBUG_REGISTERS(i)
 750     {
 751       if (!I386_DR_WATCH_HIT (status, i))
 752         continue;
 753
 754       if (!control_p)
 755         {
 756           control = i386_dr_low.get_control ();
 757           control_p = 1;
 758         }
 759
 760       /* This second condition makes sure DRi is set up for a data
 761          watchpoint, not a hardware breakpoint.  The reason is that
 762          GDB doesn't call the target_stopped_data_address method
 763          except for data watchpoints.  In other words, I'm being
 764          paranoiac.  */
 765       if (I386_DR_GET_RW_LEN (control, i) != 0)
 766         {
 767           addr = i386_dr_low.get_addr (i);
 768           rc = 1;
 769           if (maint_show_dr)
 770             i386_show_dr (state, "watchpoint_hit", addr, -1, hw_write);
 771         }
 772     }
 773   if (maint_show_dr && addr == 0)
 774     i386_show_dr (state, "stopped_data_addr", 0, 0, hw_write);
 775
 776   if (rc)
 777     *addr_p = addr;
 778   return rc;
 779 }
 780
 781 static int
 782 i386_stopped_by_watchpoint (struct target_ops *ops)
 783 {
 784   CORE_ADDR addr = 0;
 785   return i386_stopped_data_address (ops, &addr);
 786 }
 787
 788 /* Insert a hardware-assisted breakpoint at BP_TGT->placed_address.
 789    Return 0 on success, EBUSY on failure.  */
 790 static int
 791 i386_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *gdbarch,
 792                            struct bp_target_info *bp_tgt)
 793 {
 794   struct i386_debug_reg_state *state
 795     = i386_debug_reg_state (ptid_get_pid (inferior_ptid));
 796   unsigned len_rw = i386_length_and_rw_bits (1, hw_execute);
 797   CORE_ADDR addr = bp_tgt->placed_address;
 798   /* Work on a local copy of the debug registers, and on success,
 799      commit the change back to the inferior.  */
 800   struct i386_debug_reg_state local_state = *state;
 801   int retval = i386_insert_aligned_watchpoint (&local_state,
 802                                                addr, len_rw) ? EBUSY : 0;
 803
 804   if (retval == 0)
 805     i386_update_inferior_debug_regs (&local_state);
 806
 807   if (maint_show_dr)
 808     i386_show_dr (state, "insert_hwbp", addr, 1, hw_execute);
 809
 810   return retval;
 811 }
 812
 813 /* Remove a hardware-assisted breakpoint at BP_TGT->placed_address.
 814    Return 0 on success, -1 on failure.  */
 815
 816 static int
 817 i386_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *gdbarch,
 818                            struct bp_target_info *bp_tgt)
 819 {
 820   struct i386_debug_reg_state *state
 821     = i386_debug_reg_state (ptid_get_pid (inferior_ptid));
 822   unsigned len_rw = i386_length_and_rw_bits (1, hw_execute);
 823   CORE_ADDR addr = bp_tgt->placed_address;
 824   /* Work on a local copy of the debug registers, and on success,
 825      commit the change back to the inferior.  */
 826   struct i386_debug_reg_state local_state = *state;
 827   int retval = i386_remove_aligned_watchpoint (&local_state,
 828                                                addr, len_rw);
 829
 830   if (retval == 0)
 831     i386_update_inferior_debug_regs (&local_state);
 832
 833   if (maint_show_dr)
 834     i386_show_dr (state, "remove_hwbp", addr, 1, hw_execute);
 835
 836   return retval;
 837 }
 838
 839 /* Returns the number of hardware watchpoints of type TYPE that we can
 840    set.  Value is positive if we can set CNT watchpoints, zero if
 841    setting watchpoints of type TYPE is not supported, and negative if
 842    CNT is more than the maximum number of watchpoints of type TYPE
 843    that we can support.  TYPE is one of bp_hardware_watchpoint,
 844    bp_read_watchpoint, bp_write_watchpoint, or bp_hardware_breakpoint.
 845    CNT is the number of such watchpoints used so far (including this
 846    one).  OTHERTYPE is non-zero if other types of watchpoints are
 847    currently enabled.
 848
 849    We always return 1 here because we don't have enough information
 850    about possible overlap of addresses that they want to watch.  As an
 851    extreme example, consider the case where all the watchpoints watch
 852    the same address and the same region length: then we can handle a
 853    virtually unlimited number of watchpoints, due to debug register
 854    sharing implemented via reference counts in i386-nat.c.  */
 855
 856 static int
 857 i386_can_use_hw_breakpoint (struct target_ops *self,
 858                             int type, int cnt, int othertype)
 859 {
 860   return 1;
 861 }
 862
 863 static void
 864 add_show_debug_regs_command (void)
 865 {
 866   /* A maintenance command to enable printing the internal DRi mirror
 867      variables.  */
 868   add_setshow_boolean_cmd ("show-debug-regs", class_maintenance,
 869                            &maint_show_dr, _("\
 870 Set whether to show variables that mirror the x86 debug registers."), _("\
 871 Show whether to show variables that mirror the x86 debug registers."), _("\
 872 Use \"on\" to enable, \"off\" to disable.\n\
 873 If enabled, the debug registers values are shown when GDB inserts\n\
 874 or removes a hardware breakpoint or watchpoint, and when the inferior\n\
 875 triggers a breakpoint or watchpoint."),
 876                            NULL,
 877                            NULL,
 878                            &maintenance_set_cmdlist,
 879                            &maintenance_show_cmdlist);
 880 }
 881
 882 /* There are only two global functions left.  */
 883
 884 void
 885 i386_use_watchpoints (struct target_ops *t)
 886 {
 887   /* After a watchpoint trap, the PC points to the instruction after the
 888      one that caused the trap.  Therefore we don't need to step over it.
 889      But we do need to reset the status register to avoid another trap.  */
 890   t->to_have_continuable_watchpoint = 1;
 891
 892   t->to_can_use_hw_breakpoint = i386_can_use_hw_breakpoint;
 893   t->to_region_ok_for_hw_watchpoint = i386_region_ok_for_watchpoint;
 894   t->to_stopped_by_watchpoint = i386_stopped_by_watchpoint;
 895   t->to_stopped_data_address = i386_stopped_data_address;
 896   t->to_insert_watchpoint = i386_insert_watchpoint;
 897   t->to_remove_watchpoint = i386_remove_watchpoint;
 898   t->to_insert_hw_breakpoint = i386_insert_hw_breakpoint;
 899   t->to_remove_hw_breakpoint = i386_remove_hw_breakpoint;
 900 }
 901
 902 void
 903 i386_set_debug_register_length (int len)
 904 {
 905   /* This function should be called only once for each native target.  */
 906   gdb_assert (i386_dr_low.debug_register_length == 0);
 907   gdb_assert (len == 4 || len == 8);
 908   i386_dr_low.debug_register_length = len;
 909   add_show_debug_regs_command ();
 910 }