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[4][4] =
 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 a 386 debug register can watch.  */
 874       size = size_try_array[len > 4 ? 3 : len - 1][align];
 875       if (what == wp_insert)
 876         status = go32_insert_aligned_watchpoint (waddr, addr, size, rw);
 877       else if (what == wp_remove)
 878         status = go32_remove_aligned_watchpoint (waddr, addr, size, rw);
 879       else if (what == wp_count)
 880         rv++;
 881       else
 882         status = EINVAL;
 883       /* We keep the loop going even after a failure, because some of
 884          the other aligned watchpoints might still succeed, e.g. if
 885          they watch addresses that are already watched, and thus just
 886          increment the reference counts of occupied debug registers.
 887          If we break out of the loop too early, we could cause those
 888          addresses watched by other watchpoints to be disabled when
 889          GDB reacts to our failure to insert this watchpoint and tries
 890          to remove it.  */
 891       if (status)
 892         rv = status;
 893       addr += size;
 894       len -= size;
 895     }
 896   return rv;
 897 }
 898
 899 /* Remove a watchpoint.  */
 900
 901 int
 902 go32_remove_watchpoint (int pid ATTRIBUTE_UNUSED, CORE_ADDR addr,
 903                         int len, int rw)
 904 {
 905   int ret = go32_remove_aligned_watchpoint (addr, addr, len, rw);
 906
 907   SHOW_DR (remove_watch, len);
 908   return ret;
 909 }
 910
 911 static int
 912 go32_remove_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr,
 913                                 int len, int rw)
 914 {
 915   int i;
 916   int read_write_bits, len_bits;
 917
 918   /* Values of rw: 0 - write, 1 - read, 2 - access (read and write).
 919      However, x86 doesn't support read-only data breakpoints.  */
 920   read_write_bits = rw ? DR_RW_READWRITE : DR_RW_WRITE;
 921
 922   switch (len)
 923     {
 924       case 4:
 925         len_bits = DR_LEN_4;
 926         break;
 927       case 2:
 928         len_bits = DR_LEN_2;
 929         break;
 930       case 1:
 931         len_bits = DR_LEN_1;
 932         break;
 933       default:
 934         /* The debug registers only have 2 bits for the length, so
 935            so this value will always fail the loop below.  */
 936         len_bits = 0x10;
 937     }
 938
 939   if (len == 2)
 940     {
 941       if (addr % 2)
 942         return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr,
 943                                                   len, rw);
 944     }
 945   else if (len == 4)
 946     {
 947       if (addr % 4)
 948         return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr,
 949                                                   len, rw);
 950     }
 951   else if (len != 1)
 952     return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr, len, rw);
 953
 954   for (i = 0; i <= 3; i++)
 955     {
 956       if (!IS_REG_FREE (i) && D_REGS[i] == addr
 957           && DR_DEF (i) == (unsigned)(len_bits | read_write_bits))
 958         {
 959           dr_ref_count[i]--;
 960           if (dr_ref_count[i] == 0)
 961             DISABLE_REG (i);
 962         }
 963     }
 964   RESET_LOCAL_EXACT ();
 965   RESET_GLOBAL_EXACT ();
 966
 967   return 0;
 968 }
 969
 970 /* Can we use debug registers to watch a region whose address is ADDR
 971    and whose length is LEN bytes?  */
 972
 973 int
 974 go32_region_ok_for_watchpoint (CORE_ADDR addr, int len)
 975 {
 976   /* Compute how many aligned watchpoints we would need to cover this
 977      region.  */
 978   int nregs = go32_handle_nonaligned_watchpoint (wp_count, addr, addr, len, 0);
 979
 980   return nregs <= 4 ? 1 : 0;
 981 }
 982
 983 /* Check if stopped by a data watchpoint.  If so, return the address
 984    whose access triggered the watchpoint.  */
 985
 986 CORE_ADDR
 987 go32_stopped_by_watchpoint (int pid ATTRIBUTE_UNUSED, int data_watchpoint)
 988 {
 989   int i, ret = 0;
 990   int status;
 991
 992   status = edi.dr[DR_STATUS];
 993   SHOW_DR (stopped_by, 0);
 994   for (i = 0; i <= 3; i++)
 995     {
 996       if (WATCH_HIT (i) && data_watchpoint)
 997         {
 998           SHOW_DR (WP_HIT, 0);
 999           ret = D_REGS[i];
1000         }
1001     }
1002
1003   return ret;
1004 }
1005
1006 /* Remove a breakpoint.  */
1007
1008 int
1009 go32_remove_hw_breakpoint (CORE_ADDR addr, void *shadow ATTRIBUTE_UNUSED)
1010 {
1011   int i;
1012   for (i = 0; i <= 3; i++)
1013     {
1014       if (!IS_REG_FREE (i) && D_REGS[i] == addr && DR_DEF (i) == 0)
1015         {
1016           dr_ref_count[i]--;
1017           if (dr_ref_count[i] == 0)
1018             DISABLE_REG (i);
1019         }
1020     }
1021   SHOW_DR (remove_hw, 0);
1022   return 0;
1023 }
1024
1025 int
1026 go32_insert_hw_breakpoint (CORE_ADDR addr, void *shadow ATTRIBUTE_UNUSED)
1027 {
1028   int i;
1029
1030   /* Look for an occupied debug register with the same address and the
1031      same RW and LEN definitions.  If we find one, we can use it for
1032      this breakpoint as well (and save a register).  */
1033   for (i = 0; i < 4; i++)
1034     {
1035       if (!IS_REG_FREE (i) && D_REGS[i] == addr && DR_DEF (i) == 0)
1036         {
1037           dr_ref_count[i]++;
1038           SHOW_DR (insert_hw, 0);
1039           return 0;
1040         }
1041     }
1042
1043   /* Look for a free debug register.  */
1044   for (i = 0; i <= 3; i++)
1045     {
1046       if (IS_REG_FREE (i))
1047         break;
1048     }
1049
1050   /* No more debug registers?  */
1051   if (i < 4)
1052     {
1053       SET_BREAK (i, addr);
1054       LOCAL_ENABLE_REG (i);
1055     }
1056   SHOW_DR (insert_hw, 0);
1057
1058   return i < 4 ? 0 : EBUSY;
1059 }
1060
1061 /* Put the device open on handle FD into either raw or cooked
1062    mode, return 1 if it was in raw mode, zero otherwise.  */
1063
1064 static int
1065 device_mode (int fd, int raw_p)
1066 {
1067   int oldmode, newmode;
1068   __dpmi_regs regs;
1069
1070   regs.x.ax = 0x4400;
1071   regs.x.bx = fd;
1072   __dpmi_int (0x21, &regs);
1073   if (regs.x.flags & 1)
1074     return -1;
1075   newmode = oldmode = regs.x.dx;
1076
1077   if (raw_p)
1078     newmode |= 0x20;
1079   else
1080     newmode &= ~0x20;
1081
1082   if (oldmode & 0x80)   /* Only for character dev */
1083   {
1084     regs.x.ax = 0x4401;
1085     regs.x.bx = fd;
1086     regs.x.dx = newmode & 0xff;   /* Force upper byte zero, else it fails */
1087     __dpmi_int (0x21, &regs);
1088     if (regs.x.flags & 1)
1089       return -1;
1090   }
1091   return (oldmode & 0x20) == 0x20;
1092 }
1093
1094
1095 static int inf_mode_valid = 0;
1096 static int inf_terminal_mode;
1097
1098 /* This semaphore is needed because, amazingly enough, GDB calls
1099    target.to_terminal_ours more than once after the inferior stops.
1100    But we need the information from the first call only, since the
1101    second call will always see GDB's own cooked terminal.  */
1102 static int terminal_is_ours = 1;
1103
1104 static void
1105 go32_terminal_init (void)
1106 {
1107   inf_mode_valid = 0;   /* reinitialize, in case they are restarting child */
1108   terminal_is_ours = 1;
1109 }
1110
1111 static void
1112 go32_terminal_info (char *args ATTRIBUTE_UNUSED, int from_tty ATTRIBUTE_UNUSED)
1113 {
1114   printf_unfiltered ("Inferior's terminal is in %s mode.\n",
1115                      !inf_mode_valid
1116                      ? "default" : inf_terminal_mode ? "raw" : "cooked");
1117
1118 #if __DJGPP_MINOR__ > 2
1119   if (child_cmd.redirection)
1120   {
1121     int i;
1122
1123     for (i = 0; i < DBG_HANDLES; i++)
1124     {
1125       if (child_cmd.redirection[i]->file_name)
1126         printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
1127                            i, child_cmd.redirection[i]->file_name);
1128       else if (_get_dev_info (child_cmd.redirection[i]->inf_handle) == -1)
1129         printf_unfiltered
1130           ("\tFile handle %d appears to be closed by inferior.\n", i);
1131       /* Mask off the raw/cooked bit when comparing device info words.  */
1132       else if ((_get_dev_info (child_cmd.redirection[i]->inf_handle) & 0xdf)
1133                != (_get_dev_info (i) & 0xdf))
1134         printf_unfiltered
1135           ("\tFile handle %d appears to be redirected by inferior.\n", i);
1136     }
1137   }
1138 #endif
1139 }
1140
1141 static void
1142 go32_terminal_inferior (void)
1143 {
1144   /* Redirect standard handles as child wants them.  */
1145   errno = 0;
1146   if (redir_to_child (&child_cmd) == -1)
1147   {
1148     redir_to_debugger (&child_cmd);
1149     error ("Cannot redirect standard handles for program: %s.",
1150            strerror (errno));
1151   }
1152   /* set the console device of the inferior to whatever mode
1153      (raw or cooked) we found it last time */
1154   if (terminal_is_ours)
1155   {
1156     if (inf_mode_valid)
1157       device_mode (0, inf_terminal_mode);
1158     terminal_is_ours = 0;
1159   }
1160 }
1161
1162 static void
1163 go32_terminal_ours (void)
1164 {
1165   /* Switch to cooked mode on the gdb terminal and save the inferior
1166      terminal mode to be restored when it is resumed */
1167   if (!terminal_is_ours)
1168   {
1169     inf_terminal_mode = device_mode (0, 0);
1170     if (inf_terminal_mode != -1)
1171       inf_mode_valid = 1;
1172     else
1173       /* If device_mode returned -1, we don't know what happens with
1174          handle 0 anymore, so make the info invalid.  */
1175       inf_mode_valid = 0;
1176     terminal_is_ours = 1;
1177
1178     /* Restore debugger's standard handles.  */
1179     errno = 0;
1180     if (redir_to_debugger (&child_cmd) == -1)
1181     {
1182       redir_to_child (&child_cmd);
1183       error ("Cannot redirect standard handles for debugger: %s.",
1184              strerror (errno));
1185     }
1186   }
1187 }
1188
1189 static void
1190 init_go32_ops (void)
1191 {
1192   go32_ops.to_shortname = "djgpp";
1193   go32_ops.to_longname = "djgpp target process";
1194   go32_ops.to_doc =
1195     "Program loaded by djgpp, when gdb is used as an external debugger";
1196   go32_ops.to_open = go32_open;
1197   go32_ops.to_close = go32_close;
1198   go32_ops.to_attach = go32_attach;
1199   go32_ops.to_detach = go32_detach;
1200   go32_ops.to_resume = go32_resume;
1201   go32_ops.to_wait = go32_wait;
1202   go32_ops.to_fetch_registers = go32_fetch_registers;
1203   go32_ops.to_store_registers = go32_store_registers;
1204   go32_ops.to_prepare_to_store = go32_prepare_to_store;
1205   go32_ops.to_xfer_memory = go32_xfer_memory;
1206   go32_ops.to_files_info = go32_files_info;
1207   go32_ops.to_insert_breakpoint = memory_insert_breakpoint;
1208   go32_ops.to_remove_breakpoint = memory_remove_breakpoint;
1209   go32_ops.to_terminal_init = go32_terminal_init;
1210   go32_ops.to_terminal_inferior = go32_terminal_inferior;
1211   go32_ops.to_terminal_ours_for_output = go32_terminal_ours;
1212   go32_ops.to_terminal_ours = go32_terminal_ours;
1213   go32_ops.to_terminal_info = go32_terminal_info;
1214   go32_ops.to_kill = go32_kill_inferior;
1215   go32_ops.to_create_inferior = go32_create_inferior;
1216   go32_ops.to_mourn_inferior = go32_mourn_inferior;
1217   go32_ops.to_can_run = go32_can_run;
1218   go32_ops.to_stop = go32_stop;
1219   go32_ops.to_stratum = process_stratum;
1220   go32_ops.to_has_all_memory = 1;
1221   go32_ops.to_has_memory = 1;
1222   go32_ops.to_has_stack = 1;
1223   go32_ops.to_has_registers = 1;
1224   go32_ops.to_has_execution = 1;
1225   go32_ops.to_magic = OPS_MAGIC;
1226
1227   /* Initialize child's cwd with the current one.  */
1228   getcwd (child_cwd, sizeof (child_cwd));
1229
1230   /* Initialize child's command line storage.  */
1231   if (redir_debug_init (&child_cmd) == -1)
1232     internal_error ("Cannot allocate redirection storage: not enough memory.\n");
1233
1234   /* We are always processing GCC-compiled programs.  */
1235   processing_gcc_compilation = 2;
1236 }
1237
1238 void
1239 _initialize_go32_nat (void)
1240 {
1241   init_go32_ops ();
1242   add_target (&go32_ops);
1243 }
1244
1245 pid_t
1246 tcgetpgrp (int fd)
1247 {
1248   if (isatty (fd))
1249     return SOME_PID;
1250   errno = ENOTTY;
1251   return -1;
1252 }
1253
1254 int
1255 tcsetpgrp (int fd, pid_t pgid)
1256 {
1257   if (isatty (fd) && pgid == SOME_PID)
1258     return 0;
1259   errno = pgid == SOME_PID ? ENOTTY : ENOSYS;
1260   return -1;
1261 }