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