gdb/mips-linux-nat.c

   1 /* Native-dependent code for GNU/Linux on MIPS processors.
   2
   3    Copyright (C) 2001-2018 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 "command.h"
  22 #include "gdbcmd.h"
  23 #include "inferior.h"
  24 #include "mips-tdep.h"
  25 #include "target.h"
  26 #include "regcache.h"
  27 #include "linux-nat-trad.h"
  28 #include "mips-linux-tdep.h"
  29 #include "target-descriptions.h"
  30
  31 #include "gdb_proc_service.h"
  32 #include "gregset.h"
  33
  34 #include <sgidefs.h>
  35 #include "nat/gdb_ptrace.h"
  36 #include <asm/ptrace.h>
  37 #include "inf-ptrace.h"
  38
  39 #include "nat/mips-linux-watch.h"
  40
  41 #ifndef PTRACE_GET_THREAD_AREA
  42 #define PTRACE_GET_THREAD_AREA 25
  43 #endif
  44
  45 class mips_linux_nat_target final : public linux_nat_trad_target
  46 {
  47 public:
  48   /* Add our register access methods.  */
  49   void fetch_registers (struct regcache *, int) override;
  50   void store_registers (struct regcache *, int) override;
  51
  52   void close () override;
  53
  54   int can_use_hw_breakpoint (enum bptype, int, int) override;
  55
  56   int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
  57                          struct expression *) override;
  58
  59   int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
  60                          struct expression *) override;
  61
  62   bool stopped_by_watchpoint () override;
  63
  64   bool stopped_data_address (CORE_ADDR *) override;
  65
  66   int region_ok_for_hw_watchpoint (CORE_ADDR, int) override;
  67
  68   const struct target_desc *read_description () override;
  69
  70 protected:
  71   /* Override linux_nat_trad_target methods.  */
  72   CORE_ADDR register_u_offset (struct gdbarch *gdbarch,
  73                                int regno, int store_p) override;
  74
  75   /* Override linux_nat_target low methods.  */
  76   void low_new_thread (struct lwp_info *lp) override;
  77
  78 private:
  79   /* Helpers.  See definitions.  */
  80   void mips64_regsets_store_registers (struct regcache *regcache,
  81                                        int regno);
  82   void mips64_regsets_fetch_registers (struct regcache *regcache,
  83                                        int regno);
  84 };
  85
  86 static mips_linux_nat_target the_mips_linux_nat_target;
  87
  88 /* Assume that we have PTRACE_GETREGS et al. support.  If we do not,
  89    we'll clear this and use PTRACE_PEEKUSER instead.  */
  90 static int have_ptrace_regsets = 1;
  91
  92 /* Map gdb internal register number to ptrace ``address''.
  93    These ``addresses'' are normally defined in <asm/ptrace.h>.
  94
  95    ptrace does not provide a way to read (or set) MIPS_PS_REGNUM,
  96    and there's no point in reading or setting MIPS_ZERO_REGNUM.
  97    We also can not set BADVADDR, CAUSE, or FCRIR via ptrace().  */
  98
  99 static CORE_ADDR
 100 mips_linux_register_addr (struct gdbarch *gdbarch, int regno, int store)
 101 {
 102   CORE_ADDR regaddr;
 103
 104   if (regno < 0 || regno >= gdbarch_num_regs (gdbarch))
 105     error (_("Bogon register number %d."), regno);
 106
 107   if (regno > MIPS_ZERO_REGNUM && regno < MIPS_ZERO_REGNUM + 32)
 108     regaddr = regno;
 109   else if ((regno >= mips_regnum (gdbarch)->fp0)
 110            && (regno < mips_regnum (gdbarch)->fp0 + 32))
 111     regaddr = FPR_BASE + (regno - mips_regnum (gdbarch)->fp0);
 112   else if (regno == mips_regnum (gdbarch)->pc)
 113     regaddr = PC;
 114   else if (regno == mips_regnum (gdbarch)->cause)
 115     regaddr = store? (CORE_ADDR) -1 : CAUSE;
 116   else if (regno == mips_regnum (gdbarch)->badvaddr)
 117     regaddr = store? (CORE_ADDR) -1 : BADVADDR;
 118   else if (regno == mips_regnum (gdbarch)->lo)
 119     regaddr = MMLO;
 120   else if (regno == mips_regnum (gdbarch)->hi)
 121     regaddr = MMHI;
 122   else if (regno == mips_regnum (gdbarch)->fp_control_status)
 123     regaddr = FPC_CSR;
 124   else if (regno == mips_regnum (gdbarch)->fp_implementation_revision)
 125     regaddr = store? (CORE_ADDR) -1 : FPC_EIR;
 126   else if (mips_regnum (gdbarch)->dspacc != -1
 127            && regno >= mips_regnum (gdbarch)->dspacc
 128            && regno < mips_regnum (gdbarch)->dspacc + 6)
 129     regaddr = DSP_BASE + (regno - mips_regnum (gdbarch)->dspacc);
 130   else if (regno == mips_regnum (gdbarch)->dspctl)
 131     regaddr = DSP_CONTROL;
 132   else if (mips_linux_restart_reg_p (gdbarch) && regno == MIPS_RESTART_REGNUM)
 133     regaddr = 0;
 134   else
 135     regaddr = (CORE_ADDR) -1;
 136
 137   return regaddr;
 138 }
 139
 140 static CORE_ADDR
 141 mips64_linux_register_addr (struct gdbarch *gdbarch, int regno, int store)
 142 {
 143   CORE_ADDR regaddr;
 144
 145   if (regno < 0 || regno >= gdbarch_num_regs (gdbarch))
 146     error (_("Bogon register number %d."), regno);
 147
 148   /* On n32 we can't access 64-bit registers via PTRACE_PEEKUSR
 149      or PTRACE_POKEUSR.  */
 150   if (register_size (gdbarch, regno) > sizeof (PTRACE_TYPE_RET))
 151     return (CORE_ADDR) -1;
 152
 153   if (regno > MIPS_ZERO_REGNUM && regno < MIPS_ZERO_REGNUM + 32)
 154     regaddr = regno;
 155   else if ((regno >= mips_regnum (gdbarch)->fp0)
 156            && (regno < mips_regnum (gdbarch)->fp0 + 32))
 157     regaddr = MIPS64_FPR_BASE + (regno - gdbarch_fp0_regnum (gdbarch));
 158   else if (regno == mips_regnum (gdbarch)->pc)
 159     regaddr = MIPS64_PC;
 160   else if (regno == mips_regnum (gdbarch)->cause)
 161     regaddr = store? (CORE_ADDR) -1 : MIPS64_CAUSE;
 162   else if (regno == mips_regnum (gdbarch)->badvaddr)
 163     regaddr = store? (CORE_ADDR) -1 : MIPS64_BADVADDR;
 164   else if (regno == mips_regnum (gdbarch)->lo)
 165     regaddr = MIPS64_MMLO;
 166   else if (regno == mips_regnum (gdbarch)->hi)
 167     regaddr = MIPS64_MMHI;
 168   else if (regno == mips_regnum (gdbarch)->fp_control_status)
 169     regaddr = MIPS64_FPC_CSR;
 170   else if (regno == mips_regnum (gdbarch)->fp_implementation_revision)
 171     regaddr = store? (CORE_ADDR) -1 : MIPS64_FPC_EIR;
 172   else if (mips_regnum (gdbarch)->dspacc != -1
 173            && regno >= mips_regnum (gdbarch)->dspacc
 174            && regno < mips_regnum (gdbarch)->dspacc + 6)
 175     regaddr = DSP_BASE + (regno - mips_regnum (gdbarch)->dspacc);
 176   else if (regno == mips_regnum (gdbarch)->dspctl)
 177     regaddr = DSP_CONTROL;
 178   else if (mips_linux_restart_reg_p (gdbarch) && regno == MIPS_RESTART_REGNUM)
 179     regaddr = 0;
 180   else
 181     regaddr = (CORE_ADDR) -1;
 182
 183   return regaddr;
 184 }
 185
 186 /* Fetch the thread-local storage pointer for libthread_db.  */
 187
 188 ps_err_e
 189 ps_get_thread_area (struct ps_prochandle *ph,
 190                     lwpid_t lwpid, int idx, void **base)
 191 {
 192   if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, NULL, base) != 0)
 193     return PS_ERR;
 194
 195   /* IDX is the bias from the thread pointer to the beginning of the
 196      thread descriptor.  It has to be subtracted due to implementation
 197      quirks in libthread_db.  */
 198   *base = (void *) ((char *)*base - idx);
 199
 200   return PS_OK;
 201 }
 202
 203 /* Wrapper functions.  These are only used by libthread_db.  */
 204
 205 void
 206 supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
 207 {
 208   if (mips_isa_regsize (regcache->arch ()) == 4)
 209     mips_supply_gregset (regcache, (const mips_elf_gregset_t *) gregsetp);
 210   else
 211     mips64_supply_gregset (regcache, (const mips64_elf_gregset_t *) gregsetp);
 212 }
 213
 214 void
 215 fill_gregset (const struct regcache *regcache,
 216               gdb_gregset_t *gregsetp, int regno)
 217 {
 218   if (mips_isa_regsize (regcache->arch ()) == 4)
 219     mips_fill_gregset (regcache, (mips_elf_gregset_t *) gregsetp, regno);
 220   else
 221     mips64_fill_gregset (regcache, (mips64_elf_gregset_t *) gregsetp, regno);
 222 }
 223
 224 void
 225 supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
 226 {
 227   if (mips_isa_regsize (regcache->arch ()) == 4)
 228     mips_supply_fpregset (regcache, (const mips_elf_fpregset_t *) fpregsetp);
 229   else
 230     mips64_supply_fpregset (regcache,
 231                             (const mips64_elf_fpregset_t *) fpregsetp);
 232 }
 233
 234 void
 235 fill_fpregset (const struct regcache *regcache,
 236                gdb_fpregset_t *fpregsetp, int regno)
 237 {
 238   if (mips_isa_regsize (regcache->arch ()) == 4)
 239     mips_fill_fpregset (regcache, (mips_elf_fpregset_t *) fpregsetp, regno);
 240   else
 241     mips64_fill_fpregset (regcache,
 242                           (mips64_elf_fpregset_t *) fpregsetp, regno);
 243 }
 244
 245
 246 /* Fetch REGNO (or all registers if REGNO == -1) from the target
 247    using PTRACE_GETREGS et al.  */
 248
 249 void
 250 mips_linux_nat_target::mips64_regsets_fetch_registers
 251   (struct regcache *regcache, int regno)
 252 {
 253   struct gdbarch *gdbarch = regcache->arch ();
 254   int is_fp, is_dsp;
 255   int have_dsp;
 256   int regi;
 257   int tid;
 258
 259   if (regno >= mips_regnum (gdbarch)->fp0
 260       && regno <= mips_regnum (gdbarch)->fp0 + 32)
 261     is_fp = 1;
 262   else if (regno == mips_regnum (gdbarch)->fp_control_status)
 263     is_fp = 1;
 264   else if (regno == mips_regnum (gdbarch)->fp_implementation_revision)
 265     is_fp = 1;
 266   else
 267     is_fp = 0;
 268
 269   /* DSP registers are optional and not a part of any set.  */
 270   have_dsp = mips_regnum (gdbarch)->dspctl != -1;
 271   if (!have_dsp)
 272     is_dsp = 0;
 273   else if (regno >= mips_regnum (gdbarch)->dspacc
 274       && regno < mips_regnum (gdbarch)->dspacc + 6)
 275     is_dsp = 1;
 276   else if (regno == mips_regnum (gdbarch)->dspctl)
 277     is_dsp = 1;
 278   else
 279     is_dsp = 0;
 280
 281   tid = get_ptrace_pid (regcache_get_ptid (regcache));
 282
 283   if (regno == -1 || (!is_fp && !is_dsp))
 284     {
 285       mips64_elf_gregset_t regs;
 286
 287       if (ptrace (PTRACE_GETREGS, tid, 0L, (PTRACE_TYPE_ARG3) &regs) == -1)
 288         {
 289           if (errno == EIO)
 290             {
 291               have_ptrace_regsets = 0;
 292               return;
 293             }
 294           perror_with_name (_("Couldn't get registers"));
 295         }
 296
 297       mips64_supply_gregset (regcache,
 298                              (const mips64_elf_gregset_t *) &regs);
 299     }
 300
 301   if (regno == -1 || is_fp)
 302     {
 303       mips64_elf_fpregset_t fp_regs;
 304
 305       if (ptrace (PTRACE_GETFPREGS, tid, 0L,
 306                   (PTRACE_TYPE_ARG3) &fp_regs) == -1)
 307         {
 308           if (errno == EIO)
 309             {
 310               have_ptrace_regsets = 0;
 311               return;
 312             }
 313           perror_with_name (_("Couldn't get FP registers"));
 314         }
 315
 316       mips64_supply_fpregset (regcache,
 317                               (const mips64_elf_fpregset_t *) &fp_regs);
 318     }
 319
 320   if (is_dsp)
 321     linux_nat_trad_target::fetch_registers (regcache, regno);
 322   else if (regno == -1 && have_dsp)
 323     {
 324       for (regi = mips_regnum (gdbarch)->dspacc;
 325            regi < mips_regnum (gdbarch)->dspacc + 6;
 326            regi++)
 327         linux_nat_trad_target::fetch_registers (regcache, regi);
 328       linux_nat_trad_target::fetch_registers (regcache,
 329                                               mips_regnum (gdbarch)->dspctl);
 330     }
 331 }
 332
 333 /* Store REGNO (or all registers if REGNO == -1) to the target
 334    using PTRACE_SETREGS et al.  */
 335
 336 void
 337 mips_linux_nat_target::mips64_regsets_store_registers
 338   (struct regcache *regcache, int regno)
 339 {
 340   struct gdbarch *gdbarch = regcache->arch ();
 341   int is_fp, is_dsp;
 342   int have_dsp;
 343   int regi;
 344   int tid;
 345
 346   if (regno >= mips_regnum (gdbarch)->fp0
 347       && regno <= mips_regnum (gdbarch)->fp0 + 32)
 348     is_fp = 1;
 349   else if (regno == mips_regnum (gdbarch)->fp_control_status)
 350     is_fp = 1;
 351   else if (regno == mips_regnum (gdbarch)->fp_implementation_revision)
 352     is_fp = 1;
 353   else
 354     is_fp = 0;
 355
 356   /* DSP registers are optional and not a part of any set.  */
 357   have_dsp = mips_regnum (gdbarch)->dspctl != -1;
 358   if (!have_dsp)
 359     is_dsp = 0;
 360   else if (regno >= mips_regnum (gdbarch)->dspacc
 361       && regno < mips_regnum (gdbarch)->dspacc + 6)
 362     is_dsp = 1;
 363   else if (regno == mips_regnum (gdbarch)->dspctl)
 364     is_dsp = 1;
 365   else
 366     is_dsp = 0;
 367
 368   tid = get_ptrace_pid (regcache_get_ptid (regcache));
 369
 370   if (regno == -1 || (!is_fp && !is_dsp))
 371     {
 372       mips64_elf_gregset_t regs;
 373
 374       if (ptrace (PTRACE_GETREGS, tid, 0L, (PTRACE_TYPE_ARG3) &regs) == -1)
 375         perror_with_name (_("Couldn't get registers"));
 376
 377       mips64_fill_gregset (regcache, &regs, regno);
 378
 379       if (ptrace (PTRACE_SETREGS, tid, 0L, (PTRACE_TYPE_ARG3) &regs) == -1)
 380         perror_with_name (_("Couldn't set registers"));
 381     }
 382
 383   if (regno == -1 || is_fp)
 384     {
 385       mips64_elf_fpregset_t fp_regs;
 386
 387       if (ptrace (PTRACE_GETFPREGS, tid, 0L,
 388                   (PTRACE_TYPE_ARG3) &fp_regs) == -1)
 389         perror_with_name (_("Couldn't get FP registers"));
 390
 391       mips64_fill_fpregset (regcache, &fp_regs, regno);
 392
 393       if (ptrace (PTRACE_SETFPREGS, tid, 0L,
 394                   (PTRACE_TYPE_ARG3) &fp_regs) == -1)
 395         perror_with_name (_("Couldn't set FP registers"));
 396     }
 397
 398   if (is_dsp)
 399     linux_nat_trad_target::store_registers (regcache, regno);
 400   else if (regno == -1 && have_dsp)
 401     {
 402       for (regi = mips_regnum (gdbarch)->dspacc;
 403            regi < mips_regnum (gdbarch)->dspacc + 6;
 404            regi++)
 405         linux_nat_trad_target::store_registers (regcache, regi);
 406       linux_nat_trad_target::store_registers (regcache,
 407                                               mips_regnum (gdbarch)->dspctl);
 408     }
 409 }
 410
 411 /* Fetch REGNO (or all registers if REGNO == -1) from the target
 412    using any working method.  */
 413
 414 void
 415 mips_linux_nat_target::fetch_registers (struct regcache *regcache, int regnum)
 416 {
 417   /* Unless we already know that PTRACE_GETREGS does not work, try it.  */
 418   if (have_ptrace_regsets)
 419     mips64_regsets_fetch_registers (regcache, regnum);
 420
 421   /* If we know, or just found out, that PTRACE_GETREGS does not work, fall
 422      back to PTRACE_PEEKUSER.  */
 423   if (!have_ptrace_regsets)
 424     {
 425       linux_nat_trad_target::fetch_registers (regcache, regnum);
 426
 427       /* Fill the inaccessible zero register with zero.  */
 428       if (regnum == MIPS_ZERO_REGNUM || regnum == -1)
 429         regcache->raw_supply_zeroed (MIPS_ZERO_REGNUM);
 430     }
 431 }
 432
 433 /* Store REGNO (or all registers if REGNO == -1) to the target
 434    using any working method.  */
 435
 436 void
 437 mips_linux_nat_target::store_registers (struct regcache *regcache, int regnum)
 438 {
 439   /* Unless we already know that PTRACE_GETREGS does not work, try it.  */
 440   if (have_ptrace_regsets)
 441     mips64_regsets_store_registers (regcache, regnum);
 442
 443   /* If we know, or just found out, that PTRACE_GETREGS does not work, fall
 444      back to PTRACE_PEEKUSER.  */
 445   if (!have_ptrace_regsets)
 446     linux_nat_trad_target::store_registers (regcache, regnum);
 447 }
 448
 449 /* Return the address in the core dump or inferior of register
 450    REGNO.  */
 451
 452 CORE_ADDR
 453 mips_linux_nat_target::register_u_offset (struct gdbarch *gdbarch,
 454                                           int regno, int store_p)
 455 {
 456   if (mips_abi_regsize (gdbarch) == 8)
 457     return mips64_linux_register_addr (gdbarch, regno, store_p);
 458   else
 459     return mips_linux_register_addr (gdbarch, regno, store_p);
 460 }
 461
 462 const struct target_desc *
 463 mips_linux_nat_target::read_description ()
 464 {
 465   static int have_dsp = -1;
 466
 467   if (have_dsp < 0)
 468     {
 469       int tid;
 470
 471       tid = ptid_get_lwp (inferior_ptid);
 472       if (tid == 0)
 473         tid = ptid_get_pid (inferior_ptid);
 474
 475       errno = 0;
 476       ptrace (PTRACE_PEEKUSER, tid, DSP_CONTROL, 0);
 477       switch (errno)
 478         {
 479         case 0:
 480           have_dsp = 1;
 481           break;
 482         case EIO:
 483           have_dsp = 0;
 484           break;
 485         default:
 486           perror_with_name (_("Couldn't check DSP support"));
 487           break;
 488         }
 489     }
 490
 491   /* Report that target registers are a size we know for sure
 492      that we can get from ptrace.  */
 493   if (_MIPS_SIM == _ABIO32)
 494     return have_dsp ? tdesc_mips_dsp_linux : tdesc_mips_linux;
 495   else
 496     return have_dsp ? tdesc_mips64_dsp_linux : tdesc_mips64_linux;
 497 }
 498
 499 /* -1 if the kernel and/or CPU do not support watch registers.
 500     1 if watch_readback is valid and we can read style, num_valid
 501       and the masks.
 502     0 if we need to read the watch_readback.  */
 503
 504 static int watch_readback_valid;
 505
 506 /* Cached watch register read values.  */
 507
 508 static struct pt_watch_regs watch_readback;
 509
 510 static struct mips_watchpoint *current_watches;
 511
 512 /*  The current set of watch register values for writing the
 513     registers.  */
 514
 515 static struct pt_watch_regs watch_mirror;
 516
 517 static void
 518 mips_show_dr (const char *func, CORE_ADDR addr,
 519               int len, enum target_hw_bp_type type)
 520 {
 521   int i;
 522
 523   puts_unfiltered (func);
 524   if (addr || len)
 525     printf_unfiltered (" (addr=%s, len=%d, type=%s)",
 526                        paddress (target_gdbarch (), addr), len,
 527                        type == hw_write ? "data-write"
 528                        : (type == hw_read ? "data-read"
 529                           : (type == hw_access ? "data-read/write"
 530                              : (type == hw_execute ? "instruction-execute"
 531                                 : "??unknown??"))));
 532   puts_unfiltered (":\n");
 533
 534   for (i = 0; i < MAX_DEBUG_REGISTER; i++)
 535     printf_unfiltered ("\tDR%d: lo=%s, hi=%s\n", i,
 536                        paddress (target_gdbarch (),
 537                                  mips_linux_watch_get_watchlo (&watch_mirror,
 538                                                                i)),
 539                        paddress (target_gdbarch (),
 540                                  mips_linux_watch_get_watchhi (&watch_mirror,
 541                                                                i)));
 542 }
 543
 544 /* Target to_can_use_hw_breakpoint implementation.  Return 1 if we can
 545    handle the specified watch type.  */
 546
 547 int
 548 mips_linux_nat_target::can_use_hw_breakpoint (enum bptype type,
 549                                               int cnt, int ot)
 550 {
 551   int i;
 552   uint32_t wanted_mask, irw_mask;
 553
 554   if (!mips_linux_read_watch_registers (ptid_get_lwp (inferior_ptid),
 555                                         &watch_readback,
 556                                         &watch_readback_valid, 0))
 557     return 0;
 558
 559    switch (type)
 560     {
 561     case bp_hardware_watchpoint:
 562       wanted_mask = W_MASK;
 563       break;
 564     case bp_read_watchpoint:
 565       wanted_mask = R_MASK;
 566       break;
 567     case bp_access_watchpoint:
 568       wanted_mask = R_MASK | W_MASK;
 569       break;
 570     default:
 571       return 0;
 572     }
 573
 574   for (i = 0;
 575        i < mips_linux_watch_get_num_valid (&watch_readback) && cnt;
 576        i++)
 577     {
 578       irw_mask = mips_linux_watch_get_irw_mask (&watch_readback, i);
 579       if ((irw_mask & wanted_mask) == wanted_mask)
 580         cnt--;
 581     }
 582   return (cnt == 0) ? 1 : 0;
 583 }
 584
 585 /* Target to_stopped_by_watchpoint implementation.  Return 1 if
 586    stopped by watchpoint.  The watchhi R and W bits indicate the watch
 587    register triggered.  */
 588
 589 bool
 590 mips_linux_nat_target::stopped_by_watchpoint ()
 591 {
 592   int n;
 593   int num_valid;
 594
 595   if (!mips_linux_read_watch_registers (ptid_get_lwp (inferior_ptid),
 596                                         &watch_readback,
 597                                         &watch_readback_valid, 1))
 598     return false;
 599
 600   num_valid = mips_linux_watch_get_num_valid (&watch_readback);
 601
 602   for (n = 0; n < MAX_DEBUG_REGISTER && n < num_valid; n++)
 603     if (mips_linux_watch_get_watchhi (&watch_readback, n) & (R_MASK | W_MASK))
 604       return true;
 605
 606   return false;
 607 }
 608
 609 /* Target to_stopped_data_address implementation.  Set the address
 610    where the watch triggered (if known).  Return 1 if the address was
 611    known.  */
 612
 613 bool
 614 mips_linux_nat_target::stopped_data_address (CORE_ADDR *paddr)
 615 {
 616   /* On mips we don't know the low order 3 bits of the data address,
 617      so we must return false.  */
 618   return false;
 619 }
 620
 621 /* Target to_region_ok_for_hw_watchpoint implementation.  Return 1 if
 622    the specified region can be covered by the watch registers.  */
 623
 624 int
 625 mips_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
 626 {
 627   struct pt_watch_regs dummy_regs;
 628   int i;
 629
 630   if (!mips_linux_read_watch_registers (ptid_get_lwp (inferior_ptid),
 631                                         &watch_readback,
 632                                         &watch_readback_valid, 0))
 633     return 0;
 634
 635   dummy_regs = watch_readback;
 636   /* Clear them out.  */
 637   for (i = 0; i < mips_linux_watch_get_num_valid (&dummy_regs); i++)
 638     mips_linux_watch_set_watchlo (&dummy_regs, i, 0);
 639   return mips_linux_watch_try_one_watch (&dummy_regs, addr, len, 0);
 640 }
 641
 642 /* Write the mirrored watch register values for each thread.  */
 643
 644 static int
 645 write_watchpoint_regs (void)
 646 {
 647   struct lwp_info *lp;
 648   int tid;
 649
 650   ALL_LWPS (lp)
 651     {
 652       tid = ptid_get_lwp (lp->ptid);
 653       if (ptrace (PTRACE_SET_WATCH_REGS, tid, &watch_mirror, NULL) == -1)
 654         perror_with_name (_("Couldn't write debug register"));
 655     }
 656   return 0;
 657 }
 658
 659 /* linux_nat_target::low_new_thread implementation.  Write the
 660    mirrored watch register values for the new thread.  */
 661
 662 void
 663 mips_linux_nat_target::low_new_thread (struct lwp_info *lp)
 664 {
 665   long tid = lp->ptid.lwp ();
 666
 667   if (!mips_linux_read_watch_registers (tid,
 668                                         &watch_readback,
 669                                         &watch_readback_valid, 0))
 670     return;
 671
 672   if (ptrace (PTRACE_SET_WATCH_REGS, tid, &watch_mirror, NULL) == -1)
 673     perror_with_name (_("Couldn't write debug register"));
 674 }
 675
 676 /* Target to_insert_watchpoint implementation.  Try to insert a new
 677    watch.  Return zero on success.  */
 678
 679 int
 680 mips_linux_nat_target::insert_watchpoint (CORE_ADDR addr, int len,
 681                                           enum target_hw_bp_type type,
 682                                           struct expression *cond)
 683 {
 684   struct pt_watch_regs regs;
 685   struct mips_watchpoint *new_watch;
 686   struct mips_watchpoint **pw;
 687
 688   int i;
 689   int retval;
 690
 691   if (!mips_linux_read_watch_registers (ptid_get_lwp (inferior_ptid),
 692                                         &watch_readback,
 693                                         &watch_readback_valid, 0))
 694     return -1;
 695
 696   if (len <= 0)
 697     return -1;
 698
 699   regs = watch_readback;
 700   /* Add the current watches.  */
 701   mips_linux_watch_populate_regs (current_watches, &regs);
 702
 703   /* Now try to add the new watch.  */
 704   if (!mips_linux_watch_try_one_watch (&regs, addr, len,
 705                                        mips_linux_watch_type_to_irw (type)))
 706     return -1;
 707
 708   /* It fit.  Stick it on the end of the list.  */
 709   new_watch = XNEW (struct mips_watchpoint);
 710   new_watch->addr = addr;
 711   new_watch->len = len;
 712   new_watch->type = type;
 713   new_watch->next = NULL;
 714
 715   pw = &current_watches;
 716   while (*pw != NULL)
 717     pw = &(*pw)->next;
 718   *pw = new_watch;
 719
 720   watch_mirror = regs;
 721   retval = write_watchpoint_regs ();
 722
 723   if (show_debug_regs)
 724     mips_show_dr ("insert_watchpoint", addr, len, type);
 725
 726   return retval;
 727 }
 728
 729 /* Target to_remove_watchpoint implementation.  Try to remove a watch.
 730    Return zero on success.  */
 731
 732 int
 733 mips_linux_nat_target::remove_watchpoint (CORE_ADDR addr, int len,
 734                                           enum target_hw_bp_type type,
 735                                           struct expression *cond)
 736 {
 737   int retval;
 738   int deleted_one;
 739
 740   struct mips_watchpoint **pw;
 741   struct mips_watchpoint *w;
 742
 743   /* Search for a known watch that matches.  Then unlink and free
 744      it.  */
 745   deleted_one = 0;
 746   pw = &current_watches;
 747   while ((w = *pw))
 748     {
 749       if (w->addr == addr && w->len == len && w->type == type)
 750         {
 751           *pw = w->next;
 752           xfree (w);
 753           deleted_one = 1;
 754           break;
 755         }
 756       pw = &(w->next);
 757     }
 758
 759   if (!deleted_one)
 760     return -1;  /* We don't know about it, fail doing nothing.  */
 761
 762   /* At this point watch_readback is known to be valid because we
 763      could not have added the watch without reading it.  */
 764   gdb_assert (watch_readback_valid == 1);
 765
 766   watch_mirror = watch_readback;
 767   mips_linux_watch_populate_regs (current_watches, &watch_mirror);
 768
 769   retval = write_watchpoint_regs ();
 770
 771   if (show_debug_regs)
 772     mips_show_dr ("remove_watchpoint", addr, len, type);
 773
 774   return retval;
 775 }
 776
 777 /* Target to_close implementation.  Free any watches and call the
 778    super implementation.  */
 779
 780 void
 781 mips_linux_nat_target::close ()
 782 {
 783   struct mips_watchpoint *w;
 784   struct mips_watchpoint *nw;
 785
 786   /* Clean out the current_watches list.  */
 787   w = current_watches;
 788   while (w)
 789     {
 790       nw = w->next;
 791       xfree (w);
 792       w = nw;
 793     }
 794   current_watches = NULL;
 795
 796   linux_nat_trad_target::close ();
 797 }
 798
 799 void
 800 _initialize_mips_linux_nat (void)
 801 {
 802   add_setshow_boolean_cmd ("show-debug-regs", class_maintenance,
 803                            &show_debug_regs, _("\
 804 Set whether to show variables that mirror the mips debug registers."), _("\
 805 Show whether to show variables that mirror the mips debug registers."), _("\
 806 Use \"on\" to enable, \"off\" to disable.\n\
 807 If enabled, the debug registers values are shown when GDB inserts\n\
 808 or removes a hardware breakpoint or watchpoint, and when the inferior\n\
 809 triggers a breakpoint or watchpoint."),
 810                            NULL,
 811                            NULL,
 812                            &maintenance_set_cmdlist,
 813                            &maintenance_show_cmdlist);
 814
 815   linux_target = &the_mips_linux_nat_target;
 816   add_inf_child_target (&the_mips_linux_nat_target);
 817 }