gdb/go32-nat.c

   1 /* Native debugging support for Intel x86 running DJGPP.
   2    Copyright 1997, 1999 Free Software Foundation, Inc.
   3    Written by Robert Hoehne.
   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 2 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, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include <fcntl.h>
  23
  24 #include "defs.h"
  25 #include "inferior.h"
  26 #include "gdb_wait.h"
  27 #include "gdbcore.h"
  28 #include "command.h"
  29 #include "floatformat.h"
  30 #include "buildsym.h"
  31
  32 #include <stdio.h>              /* required for __DJGPP_MINOR__ */
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <errno.h>
  36 #include <unistd.h>
  37 #include <io.h>
  38 #include <dpmi.h>
  39 #include <debug/v2load.h>
  40 #include <debug/dbgcom.h>
  41 #if __DJGPP_MINOR__ > 2
  42 #include <debug/redir.h>
  43 #endif
  44
  45 #if __DJGPP_MINOR__ < 3
  46 /* This code will be provided from DJGPP 2.03 on. Until then I code it
  47    here */
  48 typedef struct
  49   {
  50     unsigned short sig0;
  51     unsigned short sig1;
  52     unsigned short sig2;
  53     unsigned short sig3;
  54     unsigned short exponent:15;
  55     unsigned short sign:1;
  56   }
  57 NPXREG;
  58
  59 typedef struct
  60   {
  61     unsigned int control;
  62     unsigned int status;
  63     unsigned int tag;
  64     unsigned int eip;
  65     unsigned int cs;
  66     unsigned int dataptr;
  67     unsigned int datasel;
  68     NPXREG reg[8];
  69   }
  70 NPX;
  71
  72 static NPX npx;
  73
  74 static void save_npx (void);    /* Save the FPU of the debugged program */
  75 static void load_npx (void);    /* Restore the FPU of the debugged program */
  76
  77 /* ------------------------------------------------------------------------- */
  78 /* Store the contents of the NPX in the global variable `npx'.  */
  79 /* *INDENT-OFF* */
  80
  81 static void
  82 save_npx (void)
  83 {
  84   asm ("inb    $0xa0, %%al
  85        testb $0x20, %%al
  86        jz 1f
  87        xorb %% al, %%al
  88        outb %% al, $0xf0
  89        movb $0x20, %%al
  90        outb %% al, $0xa0
  91        outb %% al, $0x20
  92 1:
  93        fnsave % 0
  94        fwait "
  95 :     "=m" (npx)
  96 :                               /* No input */
  97 :     "%eax");
  98 }
  99
 100 /* *INDENT-ON* */
 101
 102
 103
 104
 105
 106 /* ------------------------------------------------------------------------- */
 107 /* Reload the contents of the NPX from the global variable `npx'.  */
 108
 109 static void
 110 load_npx (void)
 111 {
 112 asm ("frstor %0":"=m" (npx));
 113 }
 114 /* ------------------------------------------------------------------------- */
 115 /* Stubs for the missing redirection functions.  */
 116 typedef struct {
 117   char *command;
 118   int redirected;
 119 } cmdline_t;
 120
 121 void redir_cmdline_delete (cmdline_t *ptr) {ptr->redirected = 0;}
 122 int  redir_cmdline_parse (const char *args, cmdline_t *ptr)
 123 {
 124   return -1;
 125 }
 126 int redir_to_child (cmdline_t *ptr)
 127 {
 128   return 1;
 129 }
 130 int redir_to_debugger (cmdline_t *ptr)
 131 {
 132   return 1;
 133 }
 134 int redir_debug_init (cmdline_t *ptr) { return 0; }
 135 #endif /* __DJGPP_MINOR < 3 */
 136
 137 extern void _initialize_go32_nat (void);
 138
 139 typedef enum { wp_insert, wp_remove, wp_count } wp_op;
 140
 141 /* This holds the current reference counts for each debug register.  */
 142 static int dr_ref_count[4];
 143
 144 extern char **environ;
 145
 146 #define SOME_PID 42
 147
 148 static int prog_has_started = 0;
 149 static void go32_open (char *name, int from_tty);
 150 static void go32_close (int quitting);
 151 static void go32_attach (char *args, int from_tty);
 152 static void go32_detach (char *args, int from_tty);
 153 static void go32_resume (int pid, int step, enum target_signal siggnal);
 154 static int go32_wait (int pid, struct target_waitstatus *status);
 155 static void go32_fetch_registers (int regno);
 156 static void store_register (int regno);
 157 static void go32_store_registers (int regno);
 158 static void go32_prepare_to_store (void);
 159 static int go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
 160                              int write, struct target_ops *target);
 161 static void go32_files_info (struct target_ops *target);
 162 static void go32_stop (void);
 163 static void go32_kill_inferior (void);
 164 static void go32_create_inferior (char *exec_file, char *args, char **env);
 165 static void cleanup_dregs (void);
 166 static void go32_mourn_inferior (void);
 167 static int go32_can_run (void);
 168 static int go32_insert_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr,
 169                                            int len, int rw);
 170 static int go32_remove_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr,
 171                                            int len, int rw);
 172 static int go32_handle_nonaligned_watchpoint (wp_op what, CORE_ADDR waddr,
 173                                               CORE_ADDR addr, int len, int rw);
 174
 175 static struct target_ops go32_ops;
 176 static void go32_terminal_init (void);
 177 static void go32_terminal_inferior (void);
 178 static void go32_terminal_ours (void);
 179
 180 #define r_ofs(x) (offsetof(TSS,x))
 181
 182 static struct
 183 {
 184   size_t tss_ofs;
 185   size_t size;
 186 }
 187 regno_mapping[] =
 188 {
 189   {r_ofs (tss_eax), 4}, /* normal registers, from a_tss */
 190   {r_ofs (tss_ecx), 4},
 191   {r_ofs (tss_edx), 4},
 192   {r_ofs (tss_ebx), 4},
 193   {r_ofs (tss_esp), 4},
 194   {r_ofs (tss_ebp), 4},
 195   {r_ofs (tss_esi), 4},
 196   {r_ofs (tss_edi), 4},
 197   {r_ofs (tss_eip), 4},
 198   {r_ofs (tss_eflags), 4},
 199   {r_ofs (tss_cs), 2},
 200   {r_ofs (tss_ss), 2},
 201   {r_ofs (tss_ds), 2},
 202   {r_ofs (tss_es), 2},
 203   {r_ofs (tss_fs), 2},
 204   {r_ofs (tss_gs), 2},
 205   {0, 10},              /* 8 FP registers, from npx.reg[] */
 206   {1, 10},
 207   {2, 10},
 208   {3, 10},
 209   {4, 10},
 210   {5, 10},
 211   {6, 10},
 212   {7, 10},
 213         /* The order of the next 7 registers must be consistent
 214            with their numbering in config/i386/tm-i386.h, which see.  */
 215   {0, 2},               /* control word, from npx */
 216   {4, 2},               /* status word, from npx */
 217   {8, 2},               /* tag word, from npx */
 218   {16, 2},              /* last FP exception CS from npx */
 219   {12, 4},              /* last FP exception EIP from npx */
 220   {24, 2},              /* last FP exception operand selector from npx */
 221   {20, 4},              /* last FP exception operand offset from npx */
 222   {18, 2}               /* last FP opcode from npx */
 223 };
 224
 225 static struct
 226   {
 227     int go32_sig;
 228     enum target_signal gdb_sig;
 229   }
 230 sig_map[] =
 231 {
 232   {0, TARGET_SIGNAL_FPE},
 233   {1, TARGET_SIGNAL_TRAP},
 234   /* Exception 2 is triggered by the NMI.  DJGPP handles it as SIGILL,
 235      but I think SIGBUS is better, since the NMI is usually activated
 236      as a result of a memory parity check failure.  */
 237   {2, TARGET_SIGNAL_BUS},
 238   {3, TARGET_SIGNAL_TRAP},
 239   {4, TARGET_SIGNAL_FPE},
 240   {5, TARGET_SIGNAL_SEGV},
 241   {6, TARGET_SIGNAL_ILL},
 242   {7, TARGET_SIGNAL_EMT},       /* no-coprocessor exception */
 243   {8, TARGET_SIGNAL_SEGV},
 244   {9, TARGET_SIGNAL_SEGV},
 245   {10, TARGET_SIGNAL_BUS},
 246   {11, TARGET_SIGNAL_SEGV},
 247   {12, TARGET_SIGNAL_SEGV},
 248   {13, TARGET_SIGNAL_SEGV},
 249   {14, TARGET_SIGNAL_SEGV},
 250   {16, TARGET_SIGNAL_FPE},
 251   {17, TARGET_SIGNAL_BUS},
 252   {31, TARGET_SIGNAL_ILL},
 253   {0x1b, TARGET_SIGNAL_INT},
 254   {0x75, TARGET_SIGNAL_FPE},
 255   {0x78, TARGET_SIGNAL_ALRM},
 256   {0x79, TARGET_SIGNAL_INT},
 257   {0x7a, TARGET_SIGNAL_QUIT},
 258   {-1, TARGET_SIGNAL_LAST}
 259 };
 260
 261 static struct {
 262   enum target_signal gdb_sig;
 263   int djgpp_excepno;
 264 } excepn_map[] = {
 265   {TARGET_SIGNAL_0, -1},
 266   {TARGET_SIGNAL_ILL, 6},       /* Invalid Opcode */
 267   {TARGET_SIGNAL_EMT, 7},       /* triggers SIGNOFP */
 268   {TARGET_SIGNAL_SEGV, 13},     /* GPF */
 269   {TARGET_SIGNAL_BUS, 17},      /* Alignment Check */
 270   /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
 271      details.  */
 272   {TARGET_SIGNAL_TERM, 0x1b},   /* triggers Ctrl-Break type of SIGINT */
 273   {TARGET_SIGNAL_FPE, 0x75},
 274   {TARGET_SIGNAL_INT, 0x79},
 275   {TARGET_SIGNAL_QUIT, 0x7a},
 276   {TARGET_SIGNAL_ALRM, 0x78},   /* triggers SIGTIMR */
 277   {TARGET_SIGNAL_PROF, 0x78},
 278   {TARGET_SIGNAL_LAST, -1}
 279 };
 280
 281 static void
 282 go32_open (char *name ATTRIBUTE_UNUSED, int from_tty ATTRIBUTE_UNUSED)
 283 {
 284   printf_unfiltered ("Done.  Use the \"run\" command to run the program.\n");
 285 }
 286
 287 static void
 288 go32_close (int quitting ATTRIBUTE_UNUSED)
 289 {
 290 }
 291
 292 static void
 293 go32_attach (char *args ATTRIBUTE_UNUSED, int from_tty ATTRIBUTE_UNUSED)
 294 {
 295   error ("\
 296 You cannot attach to a running program on this platform.\n\
 297 Use the `run' command to run DJGPP programs.");
 298 }
 299
 300 static void
 301 go32_detach (char *args ATTRIBUTE_UNUSED, int from_tty ATTRIBUTE_UNUSED)
 302 {
 303 }
 304
 305 static int resume_is_step;
 306 static int resume_signal = -1;
 307
 308 static void
 309 go32_resume (int pid ATTRIBUTE_UNUSED, int step, enum target_signal siggnal)
 310 {
 311   int i;
 312
 313   resume_is_step = step;
 314
 315   if (siggnal != TARGET_SIGNAL_0 && siggnal != TARGET_SIGNAL_TRAP)
 316   {
 317     for (i = 0, resume_signal = -1;
 318          excepn_map[i].gdb_sig != TARGET_SIGNAL_LAST; i++)
 319       if (excepn_map[i].gdb_sig == siggnal)
 320       {
 321         resume_signal = excepn_map[i].djgpp_excepno;
 322         break;
 323       }
 324     if (resume_signal == -1)
 325       printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
 326                          target_signal_to_name (siggnal));
 327   }
 328 }
 329
 330 static char child_cwd[FILENAME_MAX];
 331
 332 static int
 333 go32_wait (int pid ATTRIBUTE_UNUSED, struct target_waitstatus *status)
 334 {
 335   int i;
 336   unsigned char saved_opcode;
 337   unsigned long INT3_addr = 0;
 338   int stepping_over_INT = 0;
 339
 340   a_tss.tss_eflags &= 0xfeff;   /* reset the single-step flag (TF) */
 341   if (resume_is_step)
 342     {
 343       /* If the next instruction is INT xx or INTO, we need to handle
 344          them specially.  Intel manuals say that these instructions
 345          reset the single-step flag (a.k.a. TF).  However, it seems
 346          that, at least in the DPMI environment, and at least when
 347          stepping over the DPMI interrupt 31h, the problem is having
 348          TF set at all when INT 31h is executed: the debuggee either
 349          crashes (and takes the system with it) or is killed by a
 350          SIGTRAP.
 351
 352          So we need to emulate single-step mode: we put an INT3 opcode
 353          right after the INT xx instruction, let the debuggee run
 354          until it hits INT3 and stops, then restore the original
 355          instruction which we overwrote with the INT3 opcode, and back
 356          up the debuggee's EIP to that instruction.  */
 357       read_child (a_tss.tss_eip, &saved_opcode, 1);
 358       if (saved_opcode == 0xCD || saved_opcode == 0xCE)
 359         {
 360           unsigned char INT3_opcode = 0xCC;
 361
 362           INT3_addr
 363             = saved_opcode == 0xCD ? a_tss.tss_eip + 2 : a_tss.tss_eip + 1;
 364           stepping_over_INT = 1;
 365           read_child (INT3_addr, &saved_opcode, 1);
 366           write_child (INT3_addr, &INT3_opcode, 1);
 367         }
 368       else
 369         a_tss.tss_eflags |= 0x0100; /* normal instruction: set TF */
 370     }
 371
 372   /* The special value FFFFh in tss_trap indicates to run_child that
 373      tss_irqn holds a signal to be delivered to the debuggee.  */
 374   if (resume_signal <= -1)
 375     {
 376       a_tss.tss_trap = 0;
 377       a_tss.tss_irqn = 0xff;
 378     }
 379   else
 380     {
 381       a_tss.tss_trap = 0xffff;  /* run_child looks for this */
 382       a_tss.tss_irqn = resume_signal;
 383     }
 384
 385   /* The child might change working directory behind our back.  The
 386      GDB users won't like the side effects of that when they work with
 387      relative file names, and GDB might be confused by its current
 388      directory not being in sync with the truth.  So we always make a
 389      point of changing back to where GDB thinks is its cwd, when we
 390      return control to the debugger, but restore child's cwd before we
 391      run it.  */
 392   chdir (child_cwd);
 393
 394 #if __DJGPP_MINOR__ < 3
 395   load_npx ();
 396 #endif
 397   run_child ();
 398 #if __DJGPP_MINOR__ < 3
 399   save_npx ();
 400 #endif
 401
 402   /* Did we step over an INT xx instruction?  */
 403   if (stepping_over_INT && a_tss.tss_eip == INT3_addr + 1)
 404     {
 405       /* Restore the original opcode.  */
 406       a_tss.tss_eip--;  /* EIP points *after* the INT3 instruction */
 407       write_child (a_tss.tss_eip, &saved_opcode, 1);
 408       /* Simulate a TRAP exception.  */
 409       a_tss.tss_irqn = 1;
 410       a_tss.tss_eflags |= 0x0100;
 411     }
 412
 413   getcwd (child_cwd, sizeof (child_cwd)); /* in case it has changed */
 414   chdir (current_directory);
 415
 416   if (a_tss.tss_irqn == 0x21)
 417     {
 418       status->kind = TARGET_WAITKIND_EXITED;
 419       status->value.integer = a_tss.tss_eax & 0xff;
 420     }
 421   else
 422     {
 423       status->value.sig = TARGET_SIGNAL_UNKNOWN;
 424       status->kind = TARGET_WAITKIND_STOPPED;
 425       for (i = 0; sig_map[i].go32_sig != -1; i++)
 426         {
 427           if (a_tss.tss_irqn == sig_map[i].go32_sig)
 428             {
 429 #if __DJGPP_MINOR__ < 3
 430               if ((status->value.sig = sig_map[i].gdb_sig) !=
 431                   TARGET_SIGNAL_TRAP)
 432                 status->kind = TARGET_WAITKIND_SIGNALLED;
 433 #else
 434               status->value.sig = sig_map[i].gdb_sig;
 435 #endif
 436               break;
 437             }
 438         }
 439     }
 440   return SOME_PID;
 441 }
 442
 443 static void
 444 go32_fetch_registers (int regno)
 445 {
 446   /*JHW */
 447   int end_reg = regno + 1;      /* just one reg initially */
 448
 449   if (regno < 0)                /* do the all registers */
 450     {
 451       regno = 0;                /* start at first register */
 452       /* # regs in table */
 453       end_reg = sizeof (regno_mapping) / sizeof (regno_mapping[0]);
 454     }
 455
 456   for (; regno < end_reg; regno++)
 457     {
 458       if (regno < 16)
 459         supply_register (regno,
 460                          (char *) &a_tss + regno_mapping[regno].tss_ofs);
 461       else if (regno < 24)
 462         supply_register (regno,
 463                          (char *) &npx.reg[regno_mapping[regno].tss_ofs]);
 464       else if (regno < 32)
 465         {
 466           unsigned regval;
 467
 468           switch (regno_mapping[regno].size)
 469             {
 470               case 2:
 471                 regval = *(unsigned short *)
 472                   ((char *) &npx + regno_mapping[regno].tss_ofs);
 473                 regval &= 0xffff;
 474                 if (regno == FOP_REGNUM && regval)
 475                   /* Feature: restore the 5 bits of the opcode
 476                      stripped by FSAVE/FNSAVE.  */
 477                   regval |= 0xd800;
 478                 break;
 479               case 4:
 480                 regval = *(unsigned *)
 481                   ((char *) &npx + regno_mapping[regno].tss_ofs);
 482                 break;
 483               default:
 484                 internal_error ("\
 485 Invalid native size for register no. %d in go32_fetch_register.", regno);
 486             }
 487           supply_register (regno, (char *) &regval);
 488         }
 489       else
 490         internal_error ("Invalid register no. %d in go32_fetch_register.",
 491                         regno);
 492     }
 493 }
 494
 495 static void
 496 store_register (int regno)
 497 {
 498   void *rp;
 499   void *v = (void *) &registers[REGISTER_BYTE (regno)];
 500
 501   if (regno < 16)
 502     rp = (char *) &a_tss + regno_mapping[regno].tss_ofs;
 503   else if (regno < 24)
 504     rp = (char *) &npx.reg[regno_mapping[regno].tss_ofs];
 505   else if (regno < 32)
 506     rp = (char *) &npx + regno_mapping[regno].tss_ofs;
 507   else
 508     internal_error ("Invalid register no. %d in store_register.", regno);
 509   memcpy (rp, v, regno_mapping[regno].size);
 510   if (regno == FOP_REGNUM)
 511     *(short *)rp &= 0x07ff; /* strip high 5 bits, in case they added them */
 512 }
 513
 514 static void
 515 go32_store_registers (int regno)
 516 {
 517   unsigned r;
 518
 519   if (regno >= 0)
 520     store_register (regno);
 521   else
 522     {
 523       for (r = 0; r < sizeof (regno_mapping) / sizeof (regno_mapping[0]); r++)
 524         store_register (r);
 525     }
 526 }
 527
 528 static void
 529 go32_prepare_to_store (void)
 530 {
 531 }
 532
 533 static int
 534 go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 535                   struct target_ops *target ATTRIBUTE_UNUSED)
 536 {
 537   if (write)
 538     {
 539       if (write_child (memaddr, myaddr, len))
 540         {
 541           return 0;
 542         }
 543       else
 544         {
 545           return len;
 546         }
 547     }
 548   else
 549     {
 550       if (read_child (memaddr, myaddr, len))
 551         {
 552           return 0;
 553         }
 554       else
 555         {
 556           return len;
 557         }
 558     }
 559 }
 560
 561 static cmdline_t child_cmd;     /* parsed child's command line kept here */
 562
 563 static void
 564 go32_files_info (struct target_ops *target ATTRIBUTE_UNUSED)
 565 {
 566   printf_unfiltered ("You are running a DJGPP V2 program.\n");
 567 }
 568
 569 static void
 570 go32_stop (void)
 571 {
 572   normal_stop ();
 573   cleanup_client ();
 574   inferior_pid = 0;
 575   prog_has_started = 0;
 576 }
 577
 578 static void
 579 go32_kill_inferior (void)
 580 {
 581   redir_cmdline_delete (&child_cmd);
 582   resume_signal = -1;
 583   resume_is_step = 0;
 584   unpush_target (&go32_ops);
 585 }
 586
 587 static void
 588 go32_create_inferior (char *exec_file, char *args, char **env)
 589 {
 590   jmp_buf start_state;
 591   char *cmdline;
 592   char **env_save = environ;
 593
 594   /* If no exec file handed to us, get it from the exec-file command -- with
 595      a good, common error message if none is specified.  */
 596   if (exec_file == 0)
 597     exec_file = get_exec_file (1);
 598
 599   if (prog_has_started)
 600     {
 601       go32_stop ();
 602       go32_kill_inferior ();
 603     }
 604   resume_signal = -1;
 605   resume_is_step = 0;
 606   /* Init command line storage.  */
 607   if (redir_debug_init (&child_cmd) == -1)
 608     internal_error ("Cannot allocate redirection storage: not enough memory.\n");
 609
 610   /* Parse the command line and create redirections.  */
 611   if (strpbrk (args, "<>"))
 612     {
 613       if (redir_cmdline_parse (args, &child_cmd) == 0)
 614         args = child_cmd.command;
 615       else
 616         error ("Syntax error in command line.");
 617     }
 618   else
 619     child_cmd.command = xstrdup (args);
 620
 621   cmdline = (char *) alloca (strlen (args) + 4);
 622   cmdline[0] = strlen (args);
 623   strcpy (cmdline + 1, args);
 624   cmdline[strlen (args) + 1] = 13;
 625
 626   environ = env;
 627
 628   if (v2loadimage (exec_file, cmdline, start_state))
 629     {
 630       environ = env_save;
 631       printf_unfiltered ("Load failed for image %s\n", exec_file);
 632       exit (1);
 633     }
 634   environ = env_save;
 635
 636   edi_init (start_state);
 637 #if __DJGPP_MINOR__ < 3
 638   save_npx ();
 639 #endif
 640
 641   inferior_pid = SOME_PID;
 642   push_target (&go32_ops);
 643   clear_proceed_status ();
 644   insert_breakpoints ();
 645   proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
 646   prog_has_started = 1;
 647 }
 648
 649 static void
 650 go32_mourn_inferior (void)
 651 {
 652   /* We need to make sure all the breakpoint enable bits in the DR7
 653      register are reset when the inferior exits.  Otherwise, if they
 654      rerun the inferior, the uncleared bits may cause random SIGTRAPs,
 655      failure to set more watchpoints, and other calamities.  It would
 656      be nice if GDB itself would take care to remove all breakpoints
 657      at all times, but it doesn't, probably under an assumption that
 658      the OS cleans up when the debuggee exits.  */
 659   cleanup_dregs ();
 660   go32_kill_inferior ();
 661   generic_mourn_inferior ();
 662 }
 663
 664 static int
 665 go32_can_run (void)
 666 {
 667   return 1;
 668 }
 669
 670 /* Hardware watchpoint support.  */
 671
 672 #define DR_STATUS 6
 673 #define DR_CONTROL 7
 674 #define DR_ENABLE_SIZE 2
 675 #define DR_LOCAL_ENABLE_SHIFT 0
 676 #define DR_GLOBAL_ENABLE_SHIFT 1
 677 #define DR_LOCAL_SLOWDOWN 0x100
 678 #define DR_GLOBAL_SLOWDOWN 0x200
 679 #define DR_CONTROL_SHIFT 16
 680 #define DR_CONTROL_SIZE 4
 681 #define DR_RW_READWRITE 0x3
 682 #define DR_RW_WRITE 0x1
 683 #define DR_CONTROL_MASK 0xf
 684 #define DR_ENABLE_MASK 0x3
 685 #define DR_LEN_1 0x0
 686 #define DR_LEN_2 0x4
 687 #define DR_LEN_4 0xc
 688
 689 #define D_REGS edi.dr
 690 #define CONTROL D_REGS[DR_CONTROL]
 691 #define STATUS D_REGS[DR_STATUS]
 692
 693 #define IS_REG_FREE(index) \
 694   (!(CONTROL & (3 << (DR_ENABLE_SIZE * (index)))))
 695
 696 #define LOCAL_ENABLE_REG(index) \
 697   (CONTROL |= (1 << (DR_LOCAL_ENABLE_SHIFT + DR_ENABLE_SIZE * (index))))
 698
 699 #define GLOBAL_ENABLE_REG(index) \
 700   (CONTROL |= (1 << (DR_GLOBAL_ENABLE_SHIFT + DR_ENABLE_SIZE * (index))))
 701
 702 #define DISABLE_REG(index) \
 703   (CONTROL &= ~(3 << (DR_ENABLE_SIZE * (index))))
 704
 705 #define SET_LOCAL_EXACT() \
 706   (CONTROL |= DR_LOCAL_SLOWDOWN)
 707
 708 #define SET_GLOBAL_EXACT() \
 709   (CONTROL |= DR_GLOBAL_SLOWDOWN)
 710
 711 #define RESET_LOCAL_EXACT() \
 712    (CONTROL &= ~(DR_LOCAL_SLOWDOWN))
 713
 714 #define RESET_GLOBAL_EXACT() \
 715    (CONTROL &= ~(DR_GLOBAL_SLOWDOWN))
 716
 717 #define SET_BREAK(index,address) \
 718   do {\
 719     CONTROL &= ~(DR_CONTROL_MASK << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index)));\
 720     D_REGS[index] = address;\
 721     dr_ref_count[index]++;\
 722   } while(0)
 723
 724 #define SET_WATCH(index,address,rw,len) \
 725   do {\
 726     SET_BREAK(index,address);\
 727     CONTROL |= ((len)|(rw)) << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index));\
 728   } while (0)
 729
 730 #define IS_WATCH(index) \
 731   (CONTROL & (DR_CONTROL_MASK << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE*(index))))
 732
 733 #define WATCH_HIT(index) ((STATUS & (1 << (index))) && IS_WATCH(index))
 734
 735 #define DR_DEF(index) \
 736   ((CONTROL >> (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index))) & 0x0f)
 737
 738
 739 #if 0 /* use debugging macro */
 740 #define SHOW_DR(text,len) \
 741 do { \
 742   if (!getenv ("GDB_SHOW_DR")) break; \
 743   fprintf(stderr,"%08x %08x ",edi.dr[7],edi.dr[6]); \
 744   fprintf(stderr,"%08x %d %08x %d ", \
 745           edi.dr[0],dr_ref_count[0],edi.dr[1],dr_ref_count[1]); \
 746   fprintf(stderr,"%08x %d %08x %d ", \
 747           edi.dr[2],dr_ref_count[2],edi.dr[3],dr_ref_count[3]); \
 748   fprintf(stderr,(len)?"(%s:%d)\n":"(%s)\n",#text,len); \
 749 } while (0)
 750 #else
 751 #define SHOW_DR(text,len) do {} while (0)
 752 #endif
 753
 754 static void
 755 cleanup_dregs (void)
 756 {
 757   int i;
 758
 759   CONTROL = 0;
 760   STATUS = 0;
 761   for (i = 0; i < 4; i++)
 762     {
 763       D_REGS[i] = 0;
 764       dr_ref_count[i] = 0;
 765     }
 766 }
 767
 768 /* Insert a watchpoint.  */
 769
 770 int
 771 go32_insert_watchpoint (int pid ATTRIBUTE_UNUSED, CORE_ADDR addr,
 772                         int len, int rw)
 773 {
 774   int ret = go32_insert_aligned_watchpoint (addr, addr, len, rw);
 775
 776   SHOW_DR (insert_watch, len);
 777   return ret;
 778 }
 779
 780 static int
 781 go32_insert_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr,
 782                                 int len, int rw)
 783 {
 784   int i;
 785   int read_write_bits, len_bits;
 786
 787   /* Values of rw: 0 - write, 1 - read, 2 - access (read and write).
 788      However, x86 doesn't support read-only data breakpoints.  */
 789   read_write_bits = rw ? DR_RW_READWRITE : DR_RW_WRITE;
 790
 791   switch (len)
 792   {
 793   case 4:
 794     len_bits = DR_LEN_4;
 795     break;
 796   case 2:
 797     len_bits = DR_LEN_2;
 798     break;
 799   case 1:
 800     len_bits = DR_LEN_1;
 801     break;
 802   default:
 803     /* The debug registers only have 2 bits for the length, so
 804        so this value will always fail the loop below.  */
 805     len_bits = 0x10;
 806   }
 807
 808   /* Look for an occupied debug register with the same address and the
 809      same RW and LEN definitions.  If we find one, we can use it for
 810      this watchpoint as well (and save a register).  */
 811   for (i = 0; i < 4; i++)
 812   {
 813     if (!IS_REG_FREE (i) && D_REGS[i] == addr
 814         && DR_DEF (i) == (unsigned)(len_bits | read_write_bits))
 815     {
 816       dr_ref_count[i]++;
 817       return 0;
 818     }
 819   }
 820
 821   /* Look for a free debug register.  */
 822   for (i = 0; i <= 3; i++)
 823   {
 824     if (IS_REG_FREE (i))
 825       break;
 826   }
 827
 828   /* No more debug registers!  */
 829   if (i > 3)
 830     return -1;
 831
 832   if (len == 2)
 833   {
 834     if (addr % 2)
 835       return go32_handle_nonaligned_watchpoint (wp_insert, waddr, addr,
 836                                                 len, rw);
 837   }
 838   else if (len == 4)
 839   {
 840     if (addr % 4)
 841       return go32_handle_nonaligned_watchpoint (wp_insert, waddr, addr,
 842                                                 len, rw);
 843   }
 844   else if (len != 1)
 845     return go32_handle_nonaligned_watchpoint (wp_insert, waddr, addr, len, rw);
 846
 847   SET_WATCH (i, addr, read_write_bits, len_bits);
 848   LOCAL_ENABLE_REG (i);
 849   SET_LOCAL_EXACT ();
 850   SET_GLOBAL_EXACT ();
 851   return 0;
 852 }
 853
 854 static int
 855 go32_handle_nonaligned_watchpoint (wp_op what, CORE_ADDR waddr, CORE_ADDR addr,
 856                                    int len, int rw)
 857 {
 858   int align;
 859   int size;
 860   int rv = 0, status = 0;
 861
 862   static int size_try_array[16] =
 863   {
 864     1, 1, 1, 1,                 /* trying size one */
 865     2, 1, 2, 1,                 /* trying size two */
 866     2, 1, 2, 1,                 /* trying size three */
 867     4, 1, 2, 1                  /* trying size four */
 868   };
 869
 870   while (len > 0)
 871     {
 872       align = addr % 4;
 873       /* Four is the maximum length for 386.  */
 874       size = (len > 4) ? 3 : len - 1;
 875       size = size_try_array[size * 4 + align];
 876       if (what == wp_insert)
 877         status = go32_insert_aligned_watchpoint (waddr, addr, size, rw);
 878       else if (what == wp_remove)
 879         status = go32_remove_aligned_watchpoint (waddr, addr, size, rw);
 880       else if (what == wp_count)
 881         rv++;
 882       else
 883         status = -1;
 884       /* We keep the loop going even after a failure, because some of
 885          the other aligned watchpoints might still succeed, e.g. if
 886          they watch addresses that are already watched, and thus just
 887          increment the reference counts of occupied debug registers.
 888          If we break out of the loop too early, we could cause those
 889          addresses watched by other watchpoints to be disabled when
 890          GDB reacts to our failure to insert this watchpoint and tries
 891          to remove it.  */
 892       if (status)
 893         rv = status;
 894       addr += size;
 895       len -= size;
 896     }
 897   return rv;
 898 }
 899
 900 /* Remove a watchpoint.  */
 901
 902 int
 903 go32_remove_watchpoint (int pid ATTRIBUTE_UNUSED, CORE_ADDR addr,
 904                         int len, int rw)
 905 {
 906   int ret = go32_remove_aligned_watchpoint (addr, addr, len, rw);
 907
 908   SHOW_DR (remove_watch, len);
 909   return ret;
 910 }
 911
 912 static int
 913 go32_remove_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr,
 914                                 int len, int rw)
 915 {
 916   int i;
 917   int read_write_bits, len_bits;
 918
 919   /* Values of rw: 0 - write, 1 - read, 2 - access (read and write).
 920      However, x86 doesn't support read-only data breakpoints.  */
 921   read_write_bits = rw ? DR_RW_READWRITE : DR_RW_WRITE;
 922
 923   switch (len)
 924     {
 925       case 4:
 926         len_bits = DR_LEN_4;
 927         break;
 928       case 2:
 929         len_bits = DR_LEN_2;
 930         break;
 931       case 1:
 932         len_bits = DR_LEN_1;
 933         break;
 934       default:
 935         /* The debug registers only have 2 bits for the length, so
 936            so this value will always fail the loop below.  */
 937         len_bits = 0x10;
 938     }
 939
 940   if (len == 2)
 941     {
 942       if (addr % 2)
 943         return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr,
 944                                                   len, rw);
 945     }
 946   else if (len == 4)
 947     {
 948       if (addr % 4)
 949         return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr,
 950                                                   len, rw);
 951     }
 952   else if (len != 1)
 953     return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr, len, rw);
 954
 955   for (i = 0; i <= 3; i++)
 956     {
 957       if (!IS_REG_FREE (i) && D_REGS[i] == addr
 958           && DR_DEF (i) == (unsigned)(len_bits | read_write_bits))
 959         {
 960           dr_ref_count[i]--;
 961           if (dr_ref_count[i] == 0)
 962             DISABLE_REG (i);
 963         }
 964     }
 965   RESET_LOCAL_EXACT ();
 966   RESET_GLOBAL_EXACT ();
 967
 968   return 0;
 969 }
 970
 971 /* Can we use debug registers to watch a region whose address is ADDR
 972    and whose length is LEN bytes?  */
 973
 974 int
 975 go32_region_ok_for_watchpoint (CORE_ADDR addr, int len)
 976 {
 977   /* Compute how many aligned watchpoints we would need to cover this
 978      region.  */
 979   int nregs = go32_handle_nonaligned_watchpoint (wp_count, addr, addr, len, 0);
 980
 981   return nregs <= 4 ? 1 : 0;
 982 }
 983
 984 /* Check if stopped by a data watchpoint.  If so, return the address
 985    whose access triggered the watchpoint.  */
 986
 987 CORE_ADDR
 988 go32_stopped_by_watchpoint (int pid ATTRIBUTE_UNUSED, int data_watchpoint)
 989 {
 990   int i, ret = 0;
 991   int status;
 992
 993   status = edi.dr[DR_STATUS];
 994   SHOW_DR (stopped_by, 0);
 995   for (i = 0; i <= 3; i++)
 996     {
 997       if (WATCH_HIT (i) && data_watchpoint)
 998         {
 999           SHOW_DR (WP_HIT, 0);
1000           ret = D_REGS[i];
1001         }
1002     }
1003
1004   return ret;
1005 }
1006
1007 /* Remove a breakpoint.  */
1008
1009 int
1010 go32_remove_hw_breakpoint (CORE_ADDR addr, void *shadow ATTRIBUTE_UNUSED)
1011 {
1012   int i;
1013   for (i = 0; i <= 3; i++)
1014     {
1015       if (!IS_REG_FREE (i) && D_REGS[i] == addr && DR_DEF (i) == 0)
1016         {
1017           dr_ref_count[i]--;
1018           if (dr_ref_count[i] == 0)
1019             DISABLE_REG (i);
1020         }
1021     }
1022   SHOW_DR (remove_hw, 0);
1023   return 0;
1024 }
1025
1026 int
1027 go32_insert_hw_breakpoint (CORE_ADDR addr, void *shadow ATTRIBUTE_UNUSED)
1028 {
1029   int i;
1030
1031   /* Look for an occupied debug register with the same address and the
1032      same RW and LEN definitions.  If we find one, we can use it for
1033      this breakpoint as well (and save a register).  */
1034   for (i = 0; i < 4; i++)
1035     {
1036       if (!IS_REG_FREE (i) && D_REGS[i] == addr && DR_DEF (i) == 0)
1037         {
1038           dr_ref_count[i]++;
1039           SHOW_DR (insert_hw, 0);
1040           return 0;
1041         }
1042     }
1043
1044   /* Look for a free debug register.  */
1045   for (i = 0; i <= 3; i++)
1046     {
1047       if (IS_REG_FREE (i))
1048         break;
1049     }
1050
1051   /* No more debug registers?  */
1052   if (i < 4)
1053     {
1054       SET_BREAK (i, addr);
1055       LOCAL_ENABLE_REG (i);
1056     }
1057   SHOW_DR (insert_hw, 0);
1058
1059   return i < 4 ? 0 : -1;
1060 }
1061
1062 /* Put the device open on handle FD into either raw or cooked
1063    mode, return 1 if it was in raw mode, zero otherwise.  */
1064
1065 static int
1066 device_mode (int fd, int raw_p)
1067 {
1068   int oldmode, newmode;
1069   __dpmi_regs regs;
1070
1071   regs.x.ax = 0x4400;
1072   regs.x.bx = fd;
1073   __dpmi_int (0x21, &regs);
1074   if (regs.x.flags & 1)
1075     return -1;
1076   newmode = oldmode = regs.x.dx;
1077
1078   if (raw_p)
1079     newmode |= 0x20;
1080   else
1081     newmode &= ~0x20;
1082
1083   if (oldmode & 0x80)   /* Only for character dev */
1084   {
1085     regs.x.ax = 0x4401;
1086     regs.x.bx = fd;
1087     regs.x.dx = newmode & 0xff;   /* Force upper byte zero, else it fails */
1088     __dpmi_int (0x21, &regs);
1089     if (regs.x.flags & 1)
1090       return -1;
1091   }
1092   return (oldmode & 0x20) == 0x20;
1093 }
1094
1095
1096 static int inf_mode_valid = 0;
1097 static int inf_terminal_mode;
1098
1099 /* This semaphore is needed because, amazingly enough, GDB calls
1100    target.to_terminal_ours more than once after the inferior stops.
1101    But we need the information from the first call only, since the
1102    second call will always see GDB's own cooked terminal.  */
1103 static int terminal_is_ours = 1;
1104
1105 static void
1106 go32_terminal_init (void)
1107 {
1108   inf_mode_valid = 0;   /* reinitialize, in case they are restarting child */
1109   terminal_is_ours = 1;
1110 }
1111
1112 static void
1113 go32_terminal_info (char *args ATTRIBUTE_UNUSED, int from_tty ATTRIBUTE_UNUSED)
1114 {
1115   printf_unfiltered ("Inferior's terminal is in %s mode.\n",
1116                      !inf_mode_valid
1117                      ? "default" : inf_terminal_mode ? "raw" : "cooked");
1118
1119 #if __DJGPP_MINOR__ > 2
1120   if (child_cmd.redirection)
1121   {
1122     int i;
1123
1124     for (i = 0; i < DBG_HANDLES; i++)
1125     {
1126       if (child_cmd.redirection[i]->file_name)
1127         printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
1128                            i, child_cmd.redirection[i]->file_name);
1129       else if (_get_dev_info (child_cmd.redirection[i]->inf_handle) == -1)
1130         printf_unfiltered
1131           ("\tFile handle %d appears to be closed by inferior.\n", i);
1132       /* Mask off the raw/cooked bit when comparing device info words.  */
1133       else if ((_get_dev_info (child_cmd.redirection[i]->inf_handle) & 0xdf)
1134                != (_get_dev_info (i) & 0xdf))
1135         printf_unfiltered
1136           ("\tFile handle %d appears to be redirected by inferior.\n", i);
1137     }
1138   }
1139 #endif
1140 }
1141
1142 static void
1143 go32_terminal_inferior (void)
1144 {
1145   /* Redirect standard handles as child wants them.  */
1146   errno = 0;
1147   if (redir_to_child (&child_cmd) == -1)
1148   {
1149     redir_to_debugger (&child_cmd);
1150     error ("Cannot redirect standard handles for program: %s.",
1151            strerror (errno));
1152   }
1153   /* set the console device of the inferior to whatever mode
1154      (raw or cooked) we found it last time */
1155   if (terminal_is_ours)
1156   {
1157     if (inf_mode_valid)
1158       device_mode (0, inf_terminal_mode);
1159     terminal_is_ours = 0;
1160   }
1161 }
1162
1163 static void
1164 go32_terminal_ours (void)
1165 {
1166   /* Switch to cooked mode on the gdb terminal and save the inferior
1167      terminal mode to be restored when it is resumed */
1168   if (!terminal_is_ours)
1169   {
1170     inf_terminal_mode = device_mode (0, 0);
1171     if (inf_terminal_mode != -1)
1172       inf_mode_valid = 1;
1173     else
1174       /* If device_mode returned -1, we don't know what happens with
1175          handle 0 anymore, so make the info invalid.  */
1176       inf_mode_valid = 0;
1177     terminal_is_ours = 1;
1178
1179     /* Restore debugger's standard handles.  */
1180     errno = 0;
1181     if (redir_to_debugger (&child_cmd) == -1)
1182     {
1183       redir_to_child (&child_cmd);
1184       error ("Cannot redirect standard handles for debugger: %s.",
1185              strerror (errno));
1186     }
1187   }
1188 }
1189
1190 static void
1191 init_go32_ops (void)
1192 {
1193   go32_ops.to_shortname = "djgpp";
1194   go32_ops.to_longname = "djgpp target process";
1195   go32_ops.to_doc =
1196     "Program loaded by djgpp, when gdb is used as an external debugger";
1197   go32_ops.to_open = go32_open;
1198   go32_ops.to_close = go32_close;
1199   go32_ops.to_attach = go32_attach;
1200   go32_ops.to_detach = go32_detach;
1201   go32_ops.to_resume = go32_resume;
1202   go32_ops.to_wait = go32_wait;
1203   go32_ops.to_fetch_registers = go32_fetch_registers;
1204   go32_ops.to_store_registers = go32_store_registers;
1205   go32_ops.to_prepare_to_store = go32_prepare_to_store;
1206   go32_ops.to_xfer_memory = go32_xfer_memory;
1207   go32_ops.to_files_info = go32_files_info;
1208   go32_ops.to_insert_breakpoint = memory_insert_breakpoint;
1209   go32_ops.to_remove_breakpoint = memory_remove_breakpoint;
1210   go32_ops.to_terminal_init = go32_terminal_init;
1211   go32_ops.to_terminal_inferior = go32_terminal_inferior;
1212   go32_ops.to_terminal_ours_for_output = go32_terminal_ours;
1213   go32_ops.to_terminal_ours = go32_terminal_ours;
1214   go32_ops.to_terminal_info = go32_terminal_info;
1215   go32_ops.to_kill = go32_kill_inferior;
1216   go32_ops.to_create_inferior = go32_create_inferior;
1217   go32_ops.to_mourn_inferior = go32_mourn_inferior;
1218   go32_ops.to_can_run = go32_can_run;
1219   go32_ops.to_stop = go32_stop;
1220   go32_ops.to_stratum = process_stratum;
1221   go32_ops.to_has_all_memory = 1;
1222   go32_ops.to_has_memory = 1;
1223   go32_ops.to_has_stack = 1;
1224   go32_ops.to_has_registers = 1;
1225   go32_ops.to_has_execution = 1;
1226   go32_ops.to_magic = OPS_MAGIC;
1227
1228   /* Initialize child's cwd with the current one.  */
1229   getcwd (child_cwd, sizeof (child_cwd));
1230
1231   /* Initialize child's command line storage.  */
1232   if (redir_debug_init (&child_cmd) == -1)
1233     internal_error ("Cannot allocate redirection storage: not enough memory.\n");
1234
1235   /* We are always processing GCC-compiled programs.  */
1236   processing_gcc_compilation = 2;
1237 }
1238
1239 void
1240 _initialize_go32_nat (void)
1241 {
1242   init_go32_ops ();
1243   add_target (&go32_ops);
1244 }
1245
1246 pid_t
1247 tcgetpgrp (int fd)
1248 {
1249   if (isatty (fd))
1250     return SOME_PID;
1251   errno = ENOTTY;
1252   return -1;
1253 }
1254
1255 int
1256 tcsetpgrp (int fd, pid_t pgid)
1257 {
1258   if (isatty (fd) && pgid == SOME_PID)
1259     return 0;
1260   errno = pgid == SOME_PID ? ENOTTY : ENOSYS;
1261   return -1;
1262 }