gdb/go32-nat.c

   1 /* Native debugging support for Intel x86 running DJGPP.
   2    Copyright (C) 1997, 1999, 2000, 2001, 2005, 2006, 2007, 2008, 2009
   3    Free Software Foundation, Inc.
   4    Written by Robert Hoehne.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include <fcntl.h>
  22
  23 #include "defs.h"
  24 #include "inferior.h"
  25 #include "gdbthread.h"
  26 #include "gdb_wait.h"
  27 #include "gdbcore.h"
  28 #include "command.h"
  29 #include "gdbcmd.h"
  30 #include "floatformat.h"
  31 #include "buildsym.h"
  32 #include "i387-tdep.h"
  33 #include "i386-tdep.h"
  34 #include "value.h"
  35 #include "regcache.h"
  36 #include "gdb_string.h"
  37 #include "top.h"
  38
  39 #include <stdio.h>              /* might be required for __DJGPP_MINOR__ */
  40 #include <stdlib.h>
  41 #include <ctype.h>
  42 #include <errno.h>
  43 #include <unistd.h>
  44 #include <sys/utsname.h>
  45 #include <io.h>
  46 #include <dos.h>
  47 #include <dpmi.h>
  48 #include <go32.h>
  49 #include <sys/farptr.h>
  50 #include <debug/v2load.h>
  51 #include <debug/dbgcom.h>
  52 #if __DJGPP_MINOR__ > 2
  53 #include <debug/redir.h>
  54 #endif
  55
  56 #if __DJGPP_MINOR__ < 3
  57 /* This code will be provided from DJGPP 2.03 on. Until then I code it
  58    here */
  59 typedef struct
  60   {
  61     unsigned short sig0;
  62     unsigned short sig1;
  63     unsigned short sig2;
  64     unsigned short sig3;
  65     unsigned short exponent:15;
  66     unsigned short sign:1;
  67   }
  68 NPXREG;
  69
  70 typedef struct
  71   {
  72     unsigned int control;
  73     unsigned int status;
  74     unsigned int tag;
  75     unsigned int eip;
  76     unsigned int cs;
  77     unsigned int dataptr;
  78     unsigned int datasel;
  79     NPXREG reg[8];
  80   }
  81 NPX;
  82
  83 static NPX npx;
  84
  85 static void save_npx (void);    /* Save the FPU of the debugged program */
  86 static void load_npx (void);    /* Restore the FPU of the debugged program */
  87
  88 /* ------------------------------------------------------------------------- */
  89 /* Store the contents of the NPX in the global variable `npx'.  */
  90 /* *INDENT-OFF* */
  91
  92 static void
  93 save_npx (void)
  94 {
  95   asm ("inb    $0xa0, %%al  \n\
  96        testb $0x20, %%al    \n\
  97        jz 1f                \n\
  98        xorb %%al, %%al      \n\
  99        outb %%al, $0xf0     \n\
 100        movb $0x20, %%al     \n\
 101        outb %%al, $0xa0     \n\
 102        outb %%al, $0x20     \n\
 103 1:                          \n\
 104        fnsave %0            \n\
 105        fwait "
 106 :     "=m" (npx)
 107 :                               /* No input */
 108 :     "%eax");
 109 }
 110
 111 /* *INDENT-ON* */
 112
 113
 114 /* ------------------------------------------------------------------------- */
 115 /* Reload the contents of the NPX from the global variable `npx'.  */
 116
 117 static void
 118 load_npx (void)
 119 {
 120   asm ("frstor %0":"=m" (npx));
 121 }
 122 /* ------------------------------------------------------------------------- */
 123 /* Stubs for the missing redirection functions.  */
 124 typedef struct {
 125   char *command;
 126   int redirected;
 127 } cmdline_t;
 128
 129 void
 130 redir_cmdline_delete (cmdline_t *ptr)
 131 {
 132   ptr->redirected = 0;
 133 }
 134
 135 int
 136 redir_cmdline_parse (const char *args, cmdline_t *ptr)
 137 {
 138   return -1;
 139 }
 140
 141 int
 142 redir_to_child (cmdline_t *ptr)
 143 {
 144   return 1;
 145 }
 146
 147 int
 148 redir_to_debugger (cmdline_t *ptr)
 149 {
 150   return 1;
 151 }
 152
 153 int
 154 redir_debug_init (cmdline_t *ptr)
 155 {
 156   return 0;
 157 }
 158 #endif /* __DJGPP_MINOR < 3 */
 159
 160 typedef enum { wp_insert, wp_remove, wp_count } wp_op;
 161
 162 /* This holds the current reference counts for each debug register.  */
 163 static int dr_ref_count[4];
 164
 165 #define SOME_PID 42
 166
 167 static int prog_has_started = 0;
 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 (ptid_t ptid, int step,
 173                          enum target_signal siggnal);
 174 static void go32_fetch_registers (struct regcache *, int regno);
 175 static void store_register (const struct regcache *, int regno);
 176 static void go32_store_registers (struct regcache *, int regno);
 177 static void go32_prepare_to_store (struct regcache *);
 178 static int go32_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
 179                              int write,
 180                              struct mem_attrib *attrib,
 181                              struct target_ops *target);
 182 static void go32_files_info (struct target_ops *target);
 183 static void go32_stop (ptid_t);
 184 static void go32_kill_inferior (void);
 185 static void go32_create_inferior (struct target_ops *ops, char *exec_file,
 186                                   char *args, char **env, int from_tty);
 187 static void go32_mourn_inferior (struct target_ops *ops);
 188 static int go32_can_run (void);
 189
 190 static struct target_ops go32_ops;
 191 static void go32_terminal_init (void);
 192 static void go32_terminal_inferior (void);
 193 static void go32_terminal_ours (void);
 194
 195 #define r_ofs(x) (offsetof(TSS,x))
 196
 197 static struct
 198 {
 199   size_t tss_ofs;
 200   size_t size;
 201 }
 202 regno_mapping[] =
 203 {
 204   {r_ofs (tss_eax), 4}, /* normal registers, from a_tss */
 205   {r_ofs (tss_ecx), 4},
 206   {r_ofs (tss_edx), 4},
 207   {r_ofs (tss_ebx), 4},
 208   {r_ofs (tss_esp), 4},
 209   {r_ofs (tss_ebp), 4},
 210   {r_ofs (tss_esi), 4},
 211   {r_ofs (tss_edi), 4},
 212   {r_ofs (tss_eip), 4},
 213   {r_ofs (tss_eflags), 4},
 214   {r_ofs (tss_cs), 2},
 215   {r_ofs (tss_ss), 2},
 216   {r_ofs (tss_ds), 2},
 217   {r_ofs (tss_es), 2},
 218   {r_ofs (tss_fs), 2},
 219   {r_ofs (tss_gs), 2},
 220   {0, 10},              /* 8 FP registers, from npx.reg[] */
 221   {1, 10},
 222   {2, 10},
 223   {3, 10},
 224   {4, 10},
 225   {5, 10},
 226   {6, 10},
 227   {7, 10},
 228         /* The order of the next 7 registers must be consistent
 229            with their numbering in config/i386/tm-i386.h, which see.  */
 230   {0, 2},               /* control word, from npx */
 231   {4, 2},               /* status word, from npx */
 232   {8, 2},               /* tag word, from npx */
 233   {16, 2},              /* last FP exception CS from npx */
 234   {12, 4},              /* last FP exception EIP from npx */
 235   {24, 2},              /* last FP exception operand selector from npx */
 236   {20, 4},              /* last FP exception operand offset from npx */
 237   {18, 2}               /* last FP opcode from npx */
 238 };
 239
 240 static struct
 241   {
 242     int go32_sig;
 243     enum target_signal gdb_sig;
 244   }
 245 sig_map[] =
 246 {
 247   {0, TARGET_SIGNAL_FPE},
 248   {1, TARGET_SIGNAL_TRAP},
 249   /* Exception 2 is triggered by the NMI.  DJGPP handles it as SIGILL,
 250      but I think SIGBUS is better, since the NMI is usually activated
 251      as a result of a memory parity check failure.  */
 252   {2, TARGET_SIGNAL_BUS},
 253   {3, TARGET_SIGNAL_TRAP},
 254   {4, TARGET_SIGNAL_FPE},
 255   {5, TARGET_SIGNAL_SEGV},
 256   {6, TARGET_SIGNAL_ILL},
 257   {7, TARGET_SIGNAL_EMT},       /* no-coprocessor exception */
 258   {8, TARGET_SIGNAL_SEGV},
 259   {9, TARGET_SIGNAL_SEGV},
 260   {10, TARGET_SIGNAL_BUS},
 261   {11, TARGET_SIGNAL_SEGV},
 262   {12, TARGET_SIGNAL_SEGV},
 263   {13, TARGET_SIGNAL_SEGV},
 264   {14, TARGET_SIGNAL_SEGV},
 265   {16, TARGET_SIGNAL_FPE},
 266   {17, TARGET_SIGNAL_BUS},
 267   {31, TARGET_SIGNAL_ILL},
 268   {0x1b, TARGET_SIGNAL_INT},
 269   {0x75, TARGET_SIGNAL_FPE},
 270   {0x78, TARGET_SIGNAL_ALRM},
 271   {0x79, TARGET_SIGNAL_INT},
 272   {0x7a, TARGET_SIGNAL_QUIT},
 273   {-1, TARGET_SIGNAL_LAST}
 274 };
 275
 276 static struct {
 277   enum target_signal gdb_sig;
 278   int djgpp_excepno;
 279 } excepn_map[] = {
 280   {TARGET_SIGNAL_0, -1},
 281   {TARGET_SIGNAL_ILL, 6},       /* Invalid Opcode */
 282   {TARGET_SIGNAL_EMT, 7},       /* triggers SIGNOFP */
 283   {TARGET_SIGNAL_SEGV, 13},     /* GPF */
 284   {TARGET_SIGNAL_BUS, 17},      /* Alignment Check */
 285   /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
 286      details.  */
 287   {TARGET_SIGNAL_TERM, 0x1b},   /* triggers Ctrl-Break type of SIGINT */
 288   {TARGET_SIGNAL_FPE, 0x75},
 289   {TARGET_SIGNAL_INT, 0x79},
 290   {TARGET_SIGNAL_QUIT, 0x7a},
 291   {TARGET_SIGNAL_ALRM, 0x78},   /* triggers SIGTIMR */
 292   {TARGET_SIGNAL_PROF, 0x78},
 293   {TARGET_SIGNAL_LAST, -1}
 294 };
 295
 296 static void
 297 go32_open (char *name, int from_tty)
 298 {
 299   printf_unfiltered ("Done.  Use the \"run\" command to run the program.\n");
 300 }
 301
 302 static void
 303 go32_close (int quitting)
 304 {
 305 }
 306
 307 static void
 308 go32_attach (struct target_ops *ops, char *args, int from_tty)
 309 {
 310   error (_("\
 311 You cannot attach to a running program on this platform.\n\
 312 Use the `run' command to run DJGPP programs."));
 313 }
 314
 315 static void
 316 go32_detach (struct target_ops *ops, char *args, int from_tty)
 317 {
 318 }
 319
 320 static int resume_is_step;
 321 static int resume_signal = -1;
 322
 323 static void
 324 go32_resume (ptid_t ptid, int step, enum target_signal siggnal)
 325 {
 326   int i;
 327
 328   resume_is_step = step;
 329
 330   if (siggnal != TARGET_SIGNAL_0 && siggnal != TARGET_SIGNAL_TRAP)
 331   {
 332     for (i = 0, resume_signal = -1;
 333          excepn_map[i].gdb_sig != TARGET_SIGNAL_LAST; i++)
 334       if (excepn_map[i].gdb_sig == siggnal)
 335       {
 336         resume_signal = excepn_map[i].djgpp_excepno;
 337         break;
 338       }
 339     if (resume_signal == -1)
 340       printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
 341                          target_signal_to_name (siggnal));
 342   }
 343 }
 344
 345 static char child_cwd[FILENAME_MAX];
 346
 347 static ptid_t
 348 go32_wait (struct target_ops *ops,
 349            ptid_t ptid, struct target_waitstatus *status)
 350 {
 351   int i;
 352   unsigned char saved_opcode;
 353   unsigned long INT3_addr = 0;
 354   int stepping_over_INT = 0;
 355
 356   a_tss.tss_eflags &= 0xfeff;   /* reset the single-step flag (TF) */
 357   if (resume_is_step)
 358     {
 359       /* If the next instruction is INT xx or INTO, we need to handle
 360          them specially.  Intel manuals say that these instructions
 361          reset the single-step flag (a.k.a. TF).  However, it seems
 362          that, at least in the DPMI environment, and at least when
 363          stepping over the DPMI interrupt 31h, the problem is having
 364          TF set at all when INT 31h is executed: the debuggee either
 365          crashes (and takes the system with it) or is killed by a
 366          SIGTRAP.
 367
 368          So we need to emulate single-step mode: we put an INT3 opcode
 369          right after the INT xx instruction, let the debuggee run
 370          until it hits INT3 and stops, then restore the original
 371          instruction which we overwrote with the INT3 opcode, and back
 372          up the debuggee's EIP to that instruction.  */
 373       read_child (a_tss.tss_eip, &saved_opcode, 1);
 374       if (saved_opcode == 0xCD || saved_opcode == 0xCE)
 375         {
 376           unsigned char INT3_opcode = 0xCC;
 377
 378           INT3_addr
 379             = saved_opcode == 0xCD ? a_tss.tss_eip + 2 : a_tss.tss_eip + 1;
 380           stepping_over_INT = 1;
 381           read_child (INT3_addr, &saved_opcode, 1);
 382           write_child (INT3_addr, &INT3_opcode, 1);
 383         }
 384       else
 385         a_tss.tss_eflags |= 0x0100; /* normal instruction: set TF */
 386     }
 387
 388   /* The special value FFFFh in tss_trap indicates to run_child that
 389      tss_irqn holds a signal to be delivered to the debuggee.  */
 390   if (resume_signal <= -1)
 391     {
 392       a_tss.tss_trap = 0;
 393       a_tss.tss_irqn = 0xff;
 394     }
 395   else
 396     {
 397       a_tss.tss_trap = 0xffff;  /* run_child looks for this */
 398       a_tss.tss_irqn = resume_signal;
 399     }
 400
 401   /* The child might change working directory behind our back.  The
 402      GDB users won't like the side effects of that when they work with
 403      relative file names, and GDB might be confused by its current
 404      directory not being in sync with the truth.  So we always make a
 405      point of changing back to where GDB thinks is its cwd, when we
 406      return control to the debugger, but restore child's cwd before we
 407      run it.  */
 408   /* Initialize child_cwd, before the first call to run_child and not
 409      in the initialization, so the child get also the changed directory
 410      set with the gdb-command "cd ..." */
 411   if (!*child_cwd)
 412     /* Initialize child's cwd with the current one.  */
 413     getcwd (child_cwd, sizeof (child_cwd));
 414
 415   chdir (child_cwd);
 416
 417 #if __DJGPP_MINOR__ < 3
 418   load_npx ();
 419 #endif
 420   run_child ();
 421 #if __DJGPP_MINOR__ < 3
 422   save_npx ();
 423 #endif
 424
 425   /* Did we step over an INT xx instruction?  */
 426   if (stepping_over_INT && a_tss.tss_eip == INT3_addr + 1)
 427     {
 428       /* Restore the original opcode.  */
 429       a_tss.tss_eip--;  /* EIP points *after* the INT3 instruction */
 430       write_child (a_tss.tss_eip, &saved_opcode, 1);
 431       /* Simulate a TRAP exception.  */
 432       a_tss.tss_irqn = 1;
 433       a_tss.tss_eflags |= 0x0100;
 434     }
 435
 436   getcwd (child_cwd, sizeof (child_cwd)); /* in case it has changed */
 437   chdir (current_directory);
 438
 439   if (a_tss.tss_irqn == 0x21)
 440     {
 441       status->kind = TARGET_WAITKIND_EXITED;
 442       status->value.integer = a_tss.tss_eax & 0xff;
 443     }
 444   else
 445     {
 446       status->value.sig = TARGET_SIGNAL_UNKNOWN;
 447       status->kind = TARGET_WAITKIND_STOPPED;
 448       for (i = 0; sig_map[i].go32_sig != -1; i++)
 449         {
 450           if (a_tss.tss_irqn == sig_map[i].go32_sig)
 451             {
 452 #if __DJGPP_MINOR__ < 3
 453               if ((status->value.sig = sig_map[i].gdb_sig) !=
 454                   TARGET_SIGNAL_TRAP)
 455                 status->kind = TARGET_WAITKIND_SIGNALLED;
 456 #else
 457               status->value.sig = sig_map[i].gdb_sig;
 458 #endif
 459               break;
 460             }
 461         }
 462     }
 463   return pid_to_ptid (SOME_PID);
 464 }
 465
 466 static void
 467 fetch_register (struct regcache *regcache, int regno)
 468 {
 469   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 470   if (regno < gdbarch_fp0_regnum (gdbarch))
 471     regcache_raw_supply (regcache, regno,
 472                          (char *) &a_tss + regno_mapping[regno].tss_ofs);
 473   else if (i386_fp_regnum_p (gdbarch, regno) || i386_fpc_regnum_p (gdbarch, regno))
 474     i387_supply_fsave (regcache, regno, &npx);
 475   else
 476     internal_error (__FILE__, __LINE__,
 477                     _("Invalid register no. %d in fetch_register."), regno);
 478 }
 479
 480 static void
 481 go32_fetch_registers (struct regcache *regcache, int regno)
 482 {
 483   if (regno >= 0)
 484     fetch_register (regcache, regno);
 485   else
 486     {
 487       for (regno = 0;
 488            regno < gdbarch_fp0_regnum (get_regcache_arch (regcache));
 489            regno++)
 490         fetch_register (regcache, regno);
 491       i387_supply_fsave (regcache, -1, &npx);
 492     }
 493 }
 494
 495 static void
 496 store_register (const struct regcache *regcache, int regno)
 497 {
 498   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 499   if (regno < gdbarch_fp0_regnum (gdbarch))
 500     regcache_raw_collect (regcache, regno,
 501                           (char *) &a_tss + regno_mapping[regno].tss_ofs);
 502   else if (i386_fp_regnum_p (gdbarch, regno) || i386_fpc_regnum_p (gdbarch, regno))
 503     i387_collect_fsave (regcache, regno, &npx);
 504   else
 505     internal_error (__FILE__, __LINE__,
 506                     _("Invalid register no. %d in store_register."), regno);
 507 }
 508
 509 static void
 510 go32_store_registers (struct regcache *regcache, int regno)
 511 {
 512   unsigned r;
 513
 514   if (regno >= 0)
 515     store_register (regcache, regno);
 516   else
 517     {
 518       for (r = 0; r < gdbarch_fp0_regnum (get_regcache_arch (regcache)); r++)
 519         store_register (regcache, r);
 520       i387_collect_fsave (regcache, -1, &npx);
 521     }
 522 }
 523
 524 static void
 525 go32_prepare_to_store (struct regcache *regcache)
 526 {
 527 }
 528
 529 static int
 530 go32_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
 531                   struct mem_attrib *attrib, struct target_ops *target)
 532 {
 533   if (write)
 534     {
 535       if (write_child (memaddr, myaddr, len))
 536         {
 537           return 0;
 538         }
 539       else
 540         {
 541           return len;
 542         }
 543     }
 544   else
 545     {
 546       if (read_child (memaddr, myaddr, len))
 547         {
 548           return 0;
 549         }
 550       else
 551         {
 552           return len;
 553         }
 554     }
 555 }
 556
 557 static cmdline_t child_cmd;     /* parsed child's command line kept here */
 558
 559 static void
 560 go32_files_info (struct target_ops *target)
 561 {
 562   printf_unfiltered ("You are running a DJGPP V2 program.\n");
 563 }
 564
 565 static void
 566 go32_stop (ptid_t ptid)
 567 {
 568   normal_stop ();
 569   cleanup_client ();
 570   ptid = inferior_ptid;
 571   inferior_ptid = null_ptid;
 572   delete_thread_silent (ptid);
 573   prog_has_started = 0;
 574 }
 575
 576 static void
 577 go32_kill_inferior (void)
 578 {
 579   redir_cmdline_delete (&child_cmd);
 580   resume_signal = -1;
 581   resume_is_step = 0;
 582   if (!ptid_equal (inferior_ptid, null_ptid))
 583     delete_thread_silent (inferior_ptid);
 584   unpush_target (&go32_ops);
 585 }
 586
 587 static void
 588 go32_create_inferior (char *exec_file, char *args, char **env, int from_tty)
 589 {
 590   extern char **environ;
 591   jmp_buf start_state;
 592   char *cmdline;
 593   char **env_save = environ;
 594   size_t cmdlen;
 595
 596   /* If no exec file handed to us, get it from the exec-file command -- with
 597      a good, common error message if none is specified.  */
 598   if (exec_file == 0)
 599     exec_file = get_exec_file (1);
 600
 601   if (prog_has_started)
 602     {
 603       go32_stop (inferior_ptid);
 604       go32_kill_inferior ();
 605     }
 606   resume_signal = -1;
 607   resume_is_step = 0;
 608
 609   /* Initialize child's cwd as empty to be initialized when starting
 610      the child.  */
 611   *child_cwd = 0;
 612
 613   /* Init command line storage.  */
 614   if (redir_debug_init (&child_cmd) == -1)
 615     internal_error (__FILE__, __LINE__,
 616                     _("Cannot allocate redirection storage: not enough memory.\n"));
 617
 618   /* Parse the command line and create redirections.  */
 619   if (strpbrk (args, "<>"))
 620     {
 621       if (redir_cmdline_parse (args, &child_cmd) == 0)
 622         args = child_cmd.command;
 623       else
 624         error (_("Syntax error in command line."));
 625     }
 626   else
 627     child_cmd.command = xstrdup (args);
 628
 629   cmdlen = strlen (args);
 630   /* v2loadimage passes command lines via DOS memory, so it cannot
 631      possibly handle commands longer than 1MB.  */
 632   if (cmdlen > 1024*1024)
 633     error (_("Command line too long."));
 634
 635   cmdline = xmalloc (cmdlen + 4);
 636   strcpy (cmdline + 1, args);
 637   /* If the command-line length fits into DOS 126-char limits, use the
 638      DOS command tail format; otherwise, tell v2loadimage to pass it
 639      through a buffer in conventional memory.  */
 640   if (cmdlen < 127)
 641     {
 642       cmdline[0] = strlen (args);
 643       cmdline[cmdlen + 1] = 13;
 644     }
 645   else
 646     cmdline[0] = 0xff;  /* signal v2loadimage it's a long command */
 647
 648   environ = env;
 649
 650   if (v2loadimage (exec_file, cmdline, start_state))
 651     {
 652       environ = env_save;
 653       printf_unfiltered ("Load failed for image %s\n", exec_file);
 654       exit (1);
 655     }
 656   environ = env_save;
 657   xfree (cmdline);
 658
 659   edi_init (start_state);
 660 #if __DJGPP_MINOR__ < 3
 661   save_npx ();
 662 #endif
 663
 664   inferior_ptid = pid_to_ptid (SOME_PID);
 665   add_inferior_silent (SOME_PID);
 666
 667   push_target (&go32_ops);
 668
 669   add_thread_silent (inferior_ptid);
 670
 671   clear_proceed_status ();
 672   insert_breakpoints ();
 673   prog_has_started = 1;
 674 }
 675
 676 static void
 677 go32_mourn_inferior (struct target_ops *ops)
 678 {
 679   /* We need to make sure all the breakpoint enable bits in the DR7
 680      register are reset when the inferior exits.  Otherwise, if they
 681      rerun the inferior, the uncleared bits may cause random SIGTRAPs,
 682      failure to set more watchpoints, and other calamities.  It would
 683      be nice if GDB itself would take care to remove all breakpoints
 684      at all times, but it doesn't, probably under an assumption that
 685      the OS cleans up when the debuggee exits.  */
 686   i386_cleanup_dregs ();
 687   go32_kill_inferior ();
 688   generic_mourn_inferior ();
 689 }
 690
 691 static int
 692 go32_can_run (void)
 693 {
 694   return 1;
 695 }
 696
 697 /* Hardware watchpoint support.  */
 698
 699 #define D_REGS edi.dr
 700 #define CONTROL D_REGS[7]
 701 #define STATUS D_REGS[6]
 702
 703 /* Pass the address ADDR to the inferior in the I'th debug register.
 704    Here we just store the address in D_REGS, the watchpoint will be
 705    actually set up when go32_wait runs the debuggee.  */
 706 void
 707 go32_set_dr (int i, CORE_ADDR addr)
 708 {
 709   if (i < 0 || i > 3)
 710     internal_error (__FILE__, __LINE__,
 711                     _("Invalid register %d in go32_set_dr.\n"), i);
 712   D_REGS[i] = addr;
 713 }
 714
 715 /* Pass the value VAL to the inferior in the DR7 debug control
 716    register.  Here we just store the address in D_REGS, the watchpoint
 717    will be actually set up when go32_wait runs the debuggee.  */
 718 void
 719 go32_set_dr7 (unsigned val)
 720 {
 721   CONTROL = val;
 722 }
 723
 724 /* Get the value of the DR6 debug status register from the inferior.
 725    Here we just return the value stored in D_REGS, as we've got it
 726    from the last go32_wait call.  */
 727 unsigned
 728 go32_get_dr6 (void)
 729 {
 730   return STATUS;
 731 }
 732
 733 /* Put the device open on handle FD into either raw or cooked
 734    mode, return 1 if it was in raw mode, zero otherwise.  */
 735
 736 static int
 737 device_mode (int fd, int raw_p)
 738 {
 739   int oldmode, newmode;
 740   __dpmi_regs regs;
 741
 742   regs.x.ax = 0x4400;
 743   regs.x.bx = fd;
 744   __dpmi_int (0x21, &regs);
 745   if (regs.x.flags & 1)
 746     return -1;
 747   newmode = oldmode = regs.x.dx;
 748
 749   if (raw_p)
 750     newmode |= 0x20;
 751   else
 752     newmode &= ~0x20;
 753
 754   if (oldmode & 0x80)   /* Only for character dev */
 755   {
 756     regs.x.ax = 0x4401;
 757     regs.x.bx = fd;
 758     regs.x.dx = newmode & 0xff;   /* Force upper byte zero, else it fails */
 759     __dpmi_int (0x21, &regs);
 760     if (regs.x.flags & 1)
 761       return -1;
 762   }
 763   return (oldmode & 0x20) == 0x20;
 764 }
 765
 766
 767 static int inf_mode_valid = 0;
 768 static int inf_terminal_mode;
 769
 770 /* This semaphore is needed because, amazingly enough, GDB calls
 771    target.to_terminal_ours more than once after the inferior stops.
 772    But we need the information from the first call only, since the
 773    second call will always see GDB's own cooked terminal.  */
 774 static int terminal_is_ours = 1;
 775
 776 static void
 777 go32_terminal_init (void)
 778 {
 779   inf_mode_valid = 0;   /* reinitialize, in case they are restarting child */
 780   terminal_is_ours = 1;
 781 }
 782
 783 static void
 784 go32_terminal_info (char *args, int from_tty)
 785 {
 786   printf_unfiltered ("Inferior's terminal is in %s mode.\n",
 787                      !inf_mode_valid
 788                      ? "default" : inf_terminal_mode ? "raw" : "cooked");
 789
 790 #if __DJGPP_MINOR__ > 2
 791   if (child_cmd.redirection)
 792   {
 793     int i;
 794
 795     for (i = 0; i < DBG_HANDLES; i++)
 796     {
 797       if (child_cmd.redirection[i]->file_name)
 798         printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
 799                            i, child_cmd.redirection[i]->file_name);
 800       else if (_get_dev_info (child_cmd.redirection[i]->inf_handle) == -1)
 801         printf_unfiltered
 802           ("\tFile handle %d appears to be closed by inferior.\n", i);
 803       /* Mask off the raw/cooked bit when comparing device info words.  */
 804       else if ((_get_dev_info (child_cmd.redirection[i]->inf_handle) & 0xdf)
 805                != (_get_dev_info (i) & 0xdf))
 806         printf_unfiltered
 807           ("\tFile handle %d appears to be redirected by inferior.\n", i);
 808     }
 809   }
 810 #endif
 811 }
 812
 813 static void
 814 go32_terminal_inferior (void)
 815 {
 816   /* Redirect standard handles as child wants them.  */
 817   errno = 0;
 818   if (redir_to_child (&child_cmd) == -1)
 819   {
 820     redir_to_debugger (&child_cmd);
 821     error (_("Cannot redirect standard handles for program: %s."),
 822            safe_strerror (errno));
 823   }
 824   /* set the console device of the inferior to whatever mode
 825      (raw or cooked) we found it last time */
 826   if (terminal_is_ours)
 827   {
 828     if (inf_mode_valid)
 829       device_mode (0, inf_terminal_mode);
 830     terminal_is_ours = 0;
 831   }
 832 }
 833
 834 static void
 835 go32_terminal_ours (void)
 836 {
 837   /* Switch to cooked mode on the gdb terminal and save the inferior
 838      terminal mode to be restored when it is resumed */
 839   if (!terminal_is_ours)
 840   {
 841     inf_terminal_mode = device_mode (0, 0);
 842     if (inf_terminal_mode != -1)
 843       inf_mode_valid = 1;
 844     else
 845       /* If device_mode returned -1, we don't know what happens with
 846          handle 0 anymore, so make the info invalid.  */
 847       inf_mode_valid = 0;
 848     terminal_is_ours = 1;
 849
 850     /* Restore debugger's standard handles.  */
 851     errno = 0;
 852     if (redir_to_debugger (&child_cmd) == -1)
 853     {
 854       redir_to_child (&child_cmd);
 855       error (_("Cannot redirect standard handles for debugger: %s."),
 856              safe_strerror (errno));
 857     }
 858   }
 859 }
 860
 861 static int
 862 go32_thread_alive (ptid_t ptid)
 863 {
 864   return 1;
 865 }
 866
 867 static char *
 868 go32_pid_to_str (struct target_ops *ops, ptid_t ptid)
 869 {
 870   static char buf[64];
 871   xsnprintf (buf, sizeof buf, "Thread <main>");
 872   return buf;
 873 }
 874
 875 static void
 876 init_go32_ops (void)
 877 {
 878   go32_ops.to_shortname = "djgpp";
 879   go32_ops.to_longname = "djgpp target process";
 880   go32_ops.to_doc =
 881     "Program loaded by djgpp, when gdb is used as an external debugger";
 882   go32_ops.to_open = go32_open;
 883   go32_ops.to_close = go32_close;
 884   go32_ops.to_attach = go32_attach;
 885   go32_ops.to_detach = go32_detach;
 886   go32_ops.to_resume = go32_resume;
 887   go32_ops.to_wait = go32_wait;
 888   go32_ops.to_fetch_registers = go32_fetch_registers;
 889   go32_ops.to_store_registers = go32_store_registers;
 890   go32_ops.to_prepare_to_store = go32_prepare_to_store;
 891   go32_ops.deprecated_xfer_memory = go32_xfer_memory;
 892   go32_ops.to_files_info = go32_files_info;
 893   go32_ops.to_insert_breakpoint = memory_insert_breakpoint;
 894   go32_ops.to_remove_breakpoint = memory_remove_breakpoint;
 895   go32_ops.to_terminal_init = go32_terminal_init;
 896   go32_ops.to_terminal_inferior = go32_terminal_inferior;
 897   go32_ops.to_terminal_ours_for_output = go32_terminal_ours;
 898   go32_ops.to_terminal_ours = go32_terminal_ours;
 899   go32_ops.to_terminal_info = go32_terminal_info;
 900   go32_ops.to_kill = go32_kill_inferior;
 901   go32_ops.to_create_inferior = go32_create_inferior;
 902   go32_ops.to_mourn_inferior = go32_mourn_inferior;
 903   go32_ops.to_can_run = go32_can_run;
 904   go32_ops.to_stop = go32_stop;
 905   go32_ops.to_thread_alive = go32_thread_alive;
 906   go32_ops.to_pid_to_str = go32_pid_to_str;
 907   go32_ops.to_stratum = process_stratum;
 908   go32_ops.to_has_all_memory = 1;
 909   go32_ops.to_has_memory = 1;
 910   go32_ops.to_has_stack = 1;
 911   go32_ops.to_has_registers = 1;
 912   go32_ops.to_has_execution = 1;
 913
 914   i386_use_watchpoints (&go32_ops);
 915
 916   go32_ops.to_magic = OPS_MAGIC;
 917
 918   /* Initialize child's cwd as empty to be initialized when starting
 919      the child.  */
 920   *child_cwd = 0;
 921
 922   /* Initialize child's command line storage.  */
 923   if (redir_debug_init (&child_cmd) == -1)
 924     internal_error (__FILE__, __LINE__,
 925                     _("Cannot allocate redirection storage: not enough memory.\n"));
 926
 927   /* We are always processing GCC-compiled programs.  */
 928   processing_gcc_compilation = 2;
 929
 930   /* Override the default name of the GDB init file.  */
 931   strcpy (gdbinit, "gdb.ini");
 932 }
 933
 934 unsigned short windows_major, windows_minor;
 935
 936 /* Compute the version Windows reports via Int 2Fh/AX=1600h.  */
 937 static void
 938 go32_get_windows_version(void)
 939 {
 940   __dpmi_regs r;
 941
 942   r.x.ax = 0x1600;
 943   __dpmi_int(0x2f, &r);
 944   if (r.h.al > 2 && r.h.al != 0x80 && r.h.al != 0xff
 945       && (r.h.al > 3 || r.h.ah > 0))
 946     {
 947       windows_major = r.h.al;
 948       windows_minor = r.h.ah;
 949     }
 950   else
 951     windows_major = 0xff;       /* meaning no Windows */
 952 }
 953
 954 /* A subroutine of go32_sysinfo to display memory info.  */
 955 static void
 956 print_mem (unsigned long datum, const char *header, int in_pages_p)
 957 {
 958   if (datum != 0xffffffffUL)
 959     {
 960       if (in_pages_p)
 961         datum <<= 12;
 962       puts_filtered (header);
 963       if (datum > 1024)
 964         {
 965           printf_filtered ("%lu KB", datum >> 10);
 966           if (datum > 1024 * 1024)
 967             printf_filtered (" (%lu MB)", datum >> 20);
 968         }
 969       else
 970         printf_filtered ("%lu Bytes", datum);
 971       puts_filtered ("\n");
 972     }
 973 }
 974
 975 /* Display assorted information about the underlying OS.  */
 976 static void
 977 go32_sysinfo (char *arg, int from_tty)
 978 {
 979   struct utsname u;
 980   char cpuid_vendor[13];
 981   unsigned cpuid_max = 0, cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx;
 982   unsigned true_dos_version = _get_dos_version (1);
 983   unsigned advertized_dos_version = ((unsigned int)_osmajor << 8) | _osminor;
 984   int dpmi_flags;
 985   char dpmi_vendor_info[129];
 986   int dpmi_vendor_available =
 987     __dpmi_get_capabilities (&dpmi_flags, dpmi_vendor_info);
 988   __dpmi_version_ret dpmi_version_data;
 989   long eflags;
 990   __dpmi_free_mem_info mem_info;
 991   __dpmi_regs regs;
 992
 993   cpuid_vendor[0] = '\0';
 994   if (uname (&u))
 995     strcpy (u.machine, "Unknown x86");
 996   else if (u.machine[0] == 'i' && u.machine[1] > 4)
 997     {
 998       /* CPUID with EAX = 0 returns the Vendor ID.  */
 999       __asm__ __volatile__ ("xorl   %%ebx, %%ebx;"
1000                             "xorl   %%ecx, %%ecx;"
1001                             "xorl   %%edx, %%edx;"
1002                             "movl   $0,    %%eax;"
1003                             "cpuid;"
1004                             "movl   %%ebx,  %0;"
1005                             "movl   %%edx,  %1;"
1006                             "movl   %%ecx,  %2;"
1007                             "movl   %%eax,  %3;"
1008                             : "=m" (cpuid_vendor[0]),
1009                               "=m" (cpuid_vendor[4]),
1010                               "=m" (cpuid_vendor[8]),
1011                               "=m" (cpuid_max)
1012                             :
1013                             : "%eax", "%ebx", "%ecx", "%edx");
1014       cpuid_vendor[12] = '\0';
1015     }
1016
1017   printf_filtered ("CPU Type.......................%s", u.machine);
1018   if (cpuid_vendor[0])
1019     printf_filtered (" (%s)", cpuid_vendor);
1020   puts_filtered ("\n");
1021
1022   /* CPUID with EAX = 1 returns processor signature and features.  */
1023   if (cpuid_max >= 1)
1024     {
1025       static char *brand_name[] = {
1026         "",
1027         " Celeron",
1028         " III",
1029         " III Xeon",
1030         "", "", "", "",
1031         " 4"
1032       };
1033       char cpu_string[80];
1034       char cpu_brand[20];
1035       unsigned brand_idx;
1036       int intel_p = strcmp (cpuid_vendor, "GenuineIntel") == 0;
1037       int amd_p = strcmp (cpuid_vendor, "AuthenticAMD") == 0;
1038       unsigned cpu_family, cpu_model;
1039
1040       __asm__ __volatile__ ("movl   $1, %%eax;"
1041                             "cpuid;"
1042                             : "=a" (cpuid_eax),
1043                               "=b" (cpuid_ebx),
1044                               "=d" (cpuid_edx)
1045                             :
1046                             : "%ecx");
1047       brand_idx = cpuid_ebx & 0xff;
1048       cpu_family = (cpuid_eax >> 8) & 0xf;
1049       cpu_model  = (cpuid_eax >> 4) & 0xf;
1050       cpu_brand[0] = '\0';
1051       if (intel_p)
1052         {
1053           if (brand_idx > 0
1054               && brand_idx < sizeof(brand_name)/sizeof(brand_name[0])
1055               && *brand_name[brand_idx])
1056             strcpy (cpu_brand, brand_name[brand_idx]);
1057           else if (cpu_family == 5)
1058             {
1059               if (((cpuid_eax >> 12) & 3) == 0 && cpu_model == 4)
1060                 strcpy (cpu_brand, " MMX");
1061               else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 1)
1062                 strcpy (cpu_brand, " OverDrive");
1063               else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 2)
1064                 strcpy (cpu_brand, " Dual");
1065             }
1066           else if (cpu_family == 6 && cpu_model < 8)
1067             {
1068               switch (cpu_model)
1069                 {
1070                   case 1:
1071                     strcpy (cpu_brand, " Pro");
1072                     break;
1073                   case 3:
1074                     strcpy (cpu_brand, " II");
1075                     break;
1076                   case 5:
1077                     strcpy (cpu_brand, " II Xeon");
1078                     break;
1079                   case 6:
1080                     strcpy (cpu_brand, " Celeron");
1081                     break;
1082                   case 7:
1083                     strcpy (cpu_brand, " III");
1084                     break;
1085                 }
1086             }
1087         }
1088       else if (amd_p)
1089         {
1090           switch (cpu_family)
1091             {
1092               case 4:
1093                 strcpy (cpu_brand, "486/5x86");
1094                 break;
1095               case 5:
1096                 switch (cpu_model)
1097                   {
1098                     case 0:
1099                     case 1:
1100                     case 2:
1101                     case 3:
1102                       strcpy (cpu_brand, "-K5");
1103                       break;
1104                     case 6:
1105                     case 7:
1106                       strcpy (cpu_brand, "-K6");
1107                       break;
1108                     case 8:
1109                       strcpy (cpu_brand, "-K6-2");
1110                       break;
1111                     case 9:
1112                       strcpy (cpu_brand, "-K6-III");
1113                       break;
1114                   }
1115                 break;
1116               case 6:
1117                 switch (cpu_model)
1118                   {
1119                     case 1:
1120                     case 2:
1121                     case 4:
1122                       strcpy (cpu_brand, " Athlon");
1123                       break;
1124                     case 3:
1125                       strcpy (cpu_brand, " Duron");
1126                       break;
1127                   }
1128                 break;
1129             }
1130         }
1131       sprintf (cpu_string, "%s%s Model %d Stepping %d",
1132                intel_p ? "Pentium" : (amd_p ? "AMD" : "ix86"),
1133                cpu_brand, cpu_model, cpuid_eax & 0xf);
1134       printfi_filtered (31, "%s\n", cpu_string);
1135       if (((cpuid_edx & (6 | (0x0d << 23))) != 0)
1136           || ((cpuid_edx & 1) == 0)
1137           || (amd_p && (cpuid_edx & (3 << 30)) != 0))
1138         {
1139           puts_filtered ("CPU Features...................");
1140           /* We only list features which might be useful in the DPMI
1141              environment.  */
1142           if ((cpuid_edx & 1) == 0)
1143             puts_filtered ("No FPU "); /* it's unusual to not have an FPU */
1144           if ((cpuid_edx & (1 << 1)) != 0)
1145             puts_filtered ("VME ");
1146           if ((cpuid_edx & (1 << 2)) != 0)
1147             puts_filtered ("DE ");
1148           if ((cpuid_edx & (1 << 4)) != 0)
1149             puts_filtered ("TSC ");
1150           if ((cpuid_edx & (1 << 23)) != 0)
1151             puts_filtered ("MMX ");
1152           if ((cpuid_edx & (1 << 25)) != 0)
1153             puts_filtered ("SSE ");
1154           if ((cpuid_edx & (1 << 26)) != 0)
1155             puts_filtered ("SSE2 ");
1156           if (amd_p)
1157             {
1158               if ((cpuid_edx & (1 << 31)) != 0)
1159                 puts_filtered ("3DNow! ");
1160               if ((cpuid_edx & (1 << 30)) != 0)
1161                 puts_filtered ("3DNow!Ext");
1162             }
1163           puts_filtered ("\n");
1164         }
1165     }
1166   puts_filtered ("\n");
1167   printf_filtered ("DOS Version....................%s %s.%s",
1168                    _os_flavor, u.release, u.version);
1169   if (true_dos_version != advertized_dos_version)
1170     printf_filtered (" (disguised as v%d.%d)", _osmajor, _osminor);
1171   puts_filtered ("\n");
1172   if (!windows_major)
1173     go32_get_windows_version ();
1174   if (windows_major != 0xff)
1175     {
1176       const char *windows_flavor;
1177
1178       printf_filtered ("Windows Version................%d.%02d (Windows ",
1179                        windows_major, windows_minor);
1180       switch (windows_major)
1181         {
1182           case 3:
1183             windows_flavor = "3.X";
1184             break;
1185           case 4:
1186             switch (windows_minor)
1187               {
1188                 case 0:
1189                   windows_flavor = "95, 95A, or 95B";
1190                   break;
1191                 case 3:
1192                   windows_flavor = "95B OSR2.1 or 95C OSR2.5";
1193                   break;
1194                 case 10:
1195                   windows_flavor = "98 or 98 SE";
1196                   break;
1197                 case 90:
1198                   windows_flavor = "ME";
1199                   break;
1200                 default:
1201                   windows_flavor = "9X";
1202                   break;
1203               }
1204             break;
1205           default:
1206             windows_flavor = "??";
1207             break;
1208         }
1209       printf_filtered ("%s)\n", windows_flavor);
1210     }
1211   else if (true_dos_version == 0x532 && advertized_dos_version == 0x500)
1212     printf_filtered ("Windows Version................Windows NT or Windows 2000\n");
1213   puts_filtered ("\n");
1214   if (dpmi_vendor_available == 0)
1215     {
1216       /* The DPMI spec says the vendor string should be ASCIIZ, but
1217          I don't trust the vendors to follow that...  */
1218       if (!memchr (&dpmi_vendor_info[2], 0, 126))
1219         dpmi_vendor_info[128] = '\0';
1220       printf_filtered ("DPMI Host......................%s v%d.%d (capabilities: %#x)\n",
1221                        &dpmi_vendor_info[2],
1222                        (unsigned)dpmi_vendor_info[0],
1223                        (unsigned)dpmi_vendor_info[1],
1224                        ((unsigned)dpmi_flags & 0x7f));
1225     }
1226   __dpmi_get_version (&dpmi_version_data);
1227   printf_filtered ("DPMI Version...................%d.%02d\n",
1228                    dpmi_version_data.major, dpmi_version_data.minor);
1229   printf_filtered ("DPMI Info......................%s-bit DPMI, with%s Virtual Memory support\n",
1230                    (dpmi_version_data.flags & 1) ? "32" : "16",
1231                    (dpmi_version_data.flags & 4) ? "" : "out");
1232   printfi_filtered (31, "Interrupts reflected to %s mode\n",
1233                    (dpmi_version_data.flags & 2) ? "V86" : "Real");
1234   printfi_filtered (31, "Processor type: i%d86\n",
1235                    dpmi_version_data.cpu);
1236   printfi_filtered (31, "PIC base interrupt: Master: %#x  Slave: %#x\n",
1237                    dpmi_version_data.master_pic, dpmi_version_data.slave_pic);
1238
1239   /* a_tss is only initialized when the debuggee is first run.  */
1240   if (prog_has_started)
1241     {
1242       __asm__ __volatile__ ("pushfl ; popl %0" : "=g" (eflags));
1243       printf_filtered ("Protection.....................Ring %d (in %s), with%s I/O protection\n",
1244                        a_tss.tss_cs & 3, (a_tss.tss_cs & 4) ? "LDT" : "GDT",
1245                        (a_tss.tss_cs & 3) > ((eflags >> 12) & 3) ? "" : "out");
1246     }
1247   puts_filtered ("\n");
1248   __dpmi_get_free_memory_information (&mem_info);
1249   print_mem (mem_info.total_number_of_physical_pages,
1250              "DPMI Total Physical Memory.....", 1);
1251   print_mem (mem_info.total_number_of_free_pages,
1252              "DPMI Free Physical Memory......", 1);
1253   print_mem (mem_info.size_of_paging_file_partition_in_pages,
1254              "DPMI Swap Space................", 1);
1255   print_mem (mem_info.linear_address_space_size_in_pages,
1256              "DPMI Total Linear Address Size.", 1);
1257   print_mem (mem_info.free_linear_address_space_in_pages,
1258              "DPMI Free Linear Address Size..", 1);
1259   print_mem (mem_info.largest_available_free_block_in_bytes,
1260              "DPMI Largest Free Memory Block.", 0);
1261
1262   regs.h.ah = 0x48;
1263   regs.x.bx = 0xffff;
1264   __dpmi_int (0x21, &regs);
1265   print_mem (regs.x.bx << 4, "Free DOS Memory................", 0);
1266   regs.x.ax = 0x5800;
1267   __dpmi_int (0x21, &regs);
1268   if ((regs.x.flags & 1) == 0)
1269     {
1270       static const char *dos_hilo[] = {
1271         "Low", "", "", "", "High", "", "", "", "High, then Low"
1272       };
1273       static const char *dos_fit[] = {
1274         "First", "Best", "Last"
1275       };
1276       int hilo_idx = (regs.x.ax >> 4) & 0x0f;
1277       int fit_idx  = regs.x.ax & 0x0f;
1278
1279       if (hilo_idx > 8)
1280         hilo_idx = 0;
1281       if (fit_idx > 2)
1282         fit_idx = 0;
1283       printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1284                        dos_hilo[hilo_idx], dos_fit[fit_idx]);
1285       regs.x.ax = 0x5802;
1286       __dpmi_int (0x21, &regs);
1287       if ((regs.x.flags & 1) != 0)
1288         regs.h.al = 0;
1289       printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1290                         regs.h.al == 0 ? "not " : "");
1291     }
1292 }
1293
1294 struct seg_descr {
1295   unsigned short limit0;
1296   unsigned short base0;
1297   unsigned char  base1;
1298   unsigned       stype:5;
1299   unsigned       dpl:2;
1300   unsigned       present:1;
1301   unsigned       limit1:4;
1302   unsigned       available:1;
1303   unsigned       dummy:1;
1304   unsigned       bit32:1;
1305   unsigned       page_granular:1;
1306   unsigned char  base2;
1307 } __attribute__ ((packed));
1308
1309 struct gate_descr {
1310   unsigned short offset0;
1311   unsigned short selector;
1312   unsigned       param_count:5;
1313   unsigned       dummy:3;
1314   unsigned       stype:5;
1315   unsigned       dpl:2;
1316   unsigned       present:1;
1317   unsigned short offset1;
1318 } __attribute__ ((packed));
1319
1320 /* Read LEN bytes starting at logical address ADDR, and put the result
1321    into DEST.  Return 1 if success, zero if not.  */
1322 static int
1323 read_memory_region (unsigned long addr, void *dest, size_t len)
1324 {
1325   unsigned long dos_ds_limit = __dpmi_get_segment_limit (_dos_ds);
1326   int retval = 1;
1327
1328   /* For the low memory, we can simply use _dos_ds.  */
1329   if (addr <= dos_ds_limit - len)
1330     dosmemget (addr, len, dest);
1331   else
1332     {
1333       /* For memory above 1MB we need to set up a special segment to
1334          be able to access that memory.  */
1335       int sel = __dpmi_allocate_ldt_descriptors (1);
1336
1337       if (sel <= 0)
1338         retval = 0;
1339       else
1340         {
1341           int access_rights = __dpmi_get_descriptor_access_rights (sel);
1342           size_t segment_limit = len - 1;
1343
1344           /* Make sure the crucial bits in the descriptor access
1345              rights are set correctly.  Some DPMI providers might barf
1346              if we set the segment limit to something that is not an
1347              integral multiple of 4KB pages if the granularity bit is
1348              not set to byte-granular, even though the DPMI spec says
1349              it's the host's responsibility to set that bit correctly.  */
1350           if (len > 1024 * 1024)
1351             {
1352               access_rights |= 0x8000;
1353               /* Page-granular segments should have the low 12 bits of
1354                  the limit set.  */
1355               segment_limit |= 0xfff;
1356             }
1357           else
1358             access_rights &= ~0x8000;
1359
1360           if (__dpmi_set_segment_base_address (sel, addr) != -1
1361               && __dpmi_set_descriptor_access_rights (sel, access_rights) != -1
1362               && __dpmi_set_segment_limit (sel, segment_limit) != -1
1363               /* W2K silently fails to set the segment limit, leaving
1364                  it at zero; this test avoids the resulting crash.  */
1365               && __dpmi_get_segment_limit (sel) >= segment_limit)
1366             movedata (sel, 0, _my_ds (), (unsigned)dest, len);
1367           else
1368             retval = 0;
1369
1370           __dpmi_free_ldt_descriptor (sel);
1371         }
1372     }
1373   return retval;
1374 }
1375
1376 /* Get a segment descriptor stored at index IDX in the descriptor
1377    table whose base address is TABLE_BASE.  Return the descriptor
1378    type, or -1 if failure.  */
1379 static int
1380 get_descriptor (unsigned long table_base, int idx, void *descr)
1381 {
1382   unsigned long addr = table_base + idx * 8; /* 8 bytes per entry */
1383
1384   if (read_memory_region (addr, descr, 8))
1385     return (int)((struct seg_descr *)descr)->stype;
1386   return -1;
1387 }
1388
1389 struct dtr_reg {
1390   unsigned short limit __attribute__((packed));
1391   unsigned long  base  __attribute__((packed));
1392 };
1393
1394 /* Display a segment descriptor stored at index IDX in a descriptor
1395    table whose type is TYPE and whose base address is BASE_ADDR.  If
1396    FORCE is non-zero, display even invalid descriptors.  */
1397 static void
1398 display_descriptor (unsigned type, unsigned long base_addr, int idx, int force)
1399 {
1400   struct seg_descr descr;
1401   struct gate_descr gate;
1402
1403   /* Get the descriptor from the table.  */
1404   if (idx == 0 && type == 0)
1405     puts_filtered ("0x000: null descriptor\n");
1406   else if (get_descriptor (base_addr, idx, &descr) != -1)
1407     {
1408       /* For each type of descriptor table, this has a bit set if the
1409          corresponding type of selectors is valid in that table.  */
1410       static unsigned allowed_descriptors[] = {
1411           0xffffdafeL,   /* GDT */
1412           0x0000c0e0L,   /* IDT */
1413           0xffffdafaL    /* LDT */
1414       };
1415
1416       /* If the program hasn't started yet, assume the debuggee will
1417          have the same CPL as the debugger.  */
1418       int cpl = prog_has_started ? (a_tss.tss_cs & 3) : _my_cs () & 3;
1419       unsigned long limit = (descr.limit1 << 16) | descr.limit0;
1420
1421       if (descr.present
1422           && (allowed_descriptors[type] & (1 << descr.stype)) != 0)
1423         {
1424           printf_filtered ("0x%03x: ",
1425                            type == 1
1426                            ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1427           if (descr.page_granular)
1428             limit = (limit << 12) | 0xfff; /* big segment: low 12 bit set */
1429           if (descr.stype == 1 || descr.stype == 2 || descr.stype == 3
1430               || descr.stype == 9 || descr.stype == 11
1431               || (descr.stype >= 16 && descr.stype < 32))
1432             printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1433                              descr.base2, descr.base1, descr.base0, limit);
1434
1435           switch (descr.stype)
1436             {
1437               case 1:
1438               case 3:
1439                 printf_filtered (" 16-bit TSS  (task %sactive)",
1440                                  descr.stype == 3 ? "" : "in");
1441                 break;
1442               case 2:
1443                 puts_filtered (" LDT");
1444                 break;
1445               case 4:
1446                 memcpy (&gate, &descr, sizeof gate);
1447                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1448                                  gate.selector, gate.offset1, gate.offset0);
1449                 printf_filtered (" 16-bit Call Gate (params=%d)",
1450                                  gate.param_count);
1451                 break;
1452               case 5:
1453                 printf_filtered ("TSS selector=0x%04x", descr.base0);
1454                 printfi_filtered (16, "Task Gate");
1455                 break;
1456               case 6:
1457               case 7:
1458                 memcpy (&gate, &descr, sizeof gate);
1459                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1460                                  gate.selector, gate.offset1, gate.offset0);
1461                 printf_filtered (" 16-bit %s Gate",
1462                                  descr.stype == 6 ? "Interrupt" : "Trap");
1463                 break;
1464               case 9:
1465               case 11:
1466                 printf_filtered (" 32-bit TSS (task %sactive)",
1467                                  descr.stype == 3 ? "" : "in");
1468                 break;
1469               case 12:
1470                 memcpy (&gate, &descr, sizeof gate);
1471                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1472                                  gate.selector, gate.offset1, gate.offset0);
1473                 printf_filtered (" 32-bit Call Gate (params=%d)",
1474                                  gate.param_count);
1475                 break;
1476               case 14:
1477               case 15:
1478                 memcpy (&gate, &descr, sizeof gate);
1479                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1480                                  gate.selector, gate.offset1, gate.offset0);
1481                 printf_filtered (" 32-bit %s Gate",
1482                                  descr.stype == 14 ? "Interrupt" : "Trap");
1483                 break;
1484               case 16:          /* data segments */
1485               case 17:
1486               case 18:
1487               case 19:
1488               case 20:
1489               case 21:
1490               case 22:
1491               case 23:
1492                 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1493                                  descr.bit32 ? "32" : "16",
1494                                  descr.stype & 2 ? "Read/Write," : "Read-Only, ",
1495                                  descr.stype & 4 ? "down" : "up",
1496                                  descr.stype & 1 ? "" : ", N.Acc");
1497                 break;
1498               case 24:          /* code segments */
1499               case 25:
1500               case 26:
1501               case 27:
1502               case 28:
1503               case 29:
1504               case 30:
1505               case 31:
1506                 printf_filtered (" %s-bit Code (%s,  %sConf%s)",
1507                                  descr.bit32 ? "32" : "16",
1508                                  descr.stype & 2 ? "Exec/Read" : "Exec-Only",
1509                                  descr.stype & 4 ? "" : "N.",
1510                                  descr.stype & 1 ? "" : ", N.Acc");
1511                 break;
1512               default:
1513                 printf_filtered ("Unknown type 0x%02x", descr.stype);
1514                 break;
1515             }
1516           puts_filtered ("\n");
1517         }
1518       else if (force)
1519         {
1520           printf_filtered ("0x%03x: ",
1521                            type == 1
1522                            ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1523           if (!descr.present)
1524             puts_filtered ("Segment not present\n");
1525           else
1526             printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1527                              descr.stype);
1528         }
1529     }
1530   else if (force)
1531     printf_filtered ("0x%03x: Cannot read this descriptor\n", idx);
1532 }
1533
1534 static void
1535 go32_sldt (char *arg, int from_tty)
1536 {
1537   struct dtr_reg gdtr;
1538   unsigned short ldtr = 0;
1539   int ldt_idx;
1540   struct seg_descr ldt_descr;
1541   long ldt_entry = -1L;
1542   int cpl = (prog_has_started ? a_tss.tss_cs : _my_cs ()) & 3;
1543
1544   if (arg && *arg)
1545     {
1546       while (*arg && isspace(*arg))
1547         arg++;
1548
1549       if (*arg)
1550         {
1551           ldt_entry = parse_and_eval_long (arg);
1552           if (ldt_entry < 0
1553               || (ldt_entry & 4) == 0
1554               || (ldt_entry & 3) != (cpl & 3))
1555             error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry);
1556         }
1557     }
1558
1559   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
1560   __asm__ __volatile__ ("sldt   %0" : "=m" (ldtr) : /* no inputs */ );
1561   ldt_idx = ldtr / 8;
1562   if (ldt_idx == 0)
1563     puts_filtered ("There is no LDT.\n");
1564   /* LDT's entry in the GDT must have the type LDT, which is 2.  */
1565   else if (get_descriptor (gdtr.base, ldt_idx, &ldt_descr) != 2)
1566     printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1567                      ldt_descr.base0
1568                      | (ldt_descr.base1 << 16)
1569                      | (ldt_descr.base2 << 24));
1570   else
1571     {
1572       unsigned base =
1573         ldt_descr.base0
1574         | (ldt_descr.base1 << 16)
1575         | (ldt_descr.base2 << 24);
1576       unsigned limit = ldt_descr.limit0 | (ldt_descr.limit1 << 16);
1577       int max_entry;
1578
1579       if (ldt_descr.page_granular)
1580         /* Page-granular segments must have the low 12 bits of their
1581            limit set.  */
1582         limit = (limit << 12) | 0xfff;
1583       /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1584          64KB.  */
1585       if (limit > 0xffff)
1586         limit = 0xffff;
1587
1588       max_entry = (limit + 1) / 8;
1589
1590       if (ldt_entry >= 0)
1591         {
1592           if (ldt_entry > limit)
1593             error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1594                    (unsigned long)ldt_entry, limit);
1595
1596           display_descriptor (ldt_descr.stype, base, ldt_entry / 8, 1);
1597         }
1598       else
1599         {
1600           int i;
1601
1602           for (i = 0; i < max_entry; i++)
1603             display_descriptor (ldt_descr.stype, base, i, 0);
1604         }
1605     }
1606 }
1607
1608 static void
1609 go32_sgdt (char *arg, int from_tty)
1610 {
1611   struct dtr_reg gdtr;
1612   long gdt_entry = -1L;
1613   int max_entry;
1614
1615   if (arg && *arg)
1616     {
1617       while (*arg && isspace(*arg))
1618         arg++;
1619
1620       if (*arg)
1621         {
1622           gdt_entry = parse_and_eval_long (arg);
1623           if (gdt_entry < 0 || (gdt_entry & 7) != 0)
1624             error (_("Invalid GDT entry 0x%03lx: not an integral multiple of 8."),
1625                    (unsigned long)gdt_entry);
1626         }
1627     }
1628
1629   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
1630   max_entry = (gdtr.limit + 1) / 8;
1631
1632   if (gdt_entry >= 0)
1633     {
1634       if (gdt_entry > gdtr.limit)
1635         error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1636                (unsigned long)gdt_entry, gdtr.limit);
1637
1638       display_descriptor (0, gdtr.base, gdt_entry / 8, 1);
1639     }
1640   else
1641     {
1642       int i;
1643
1644       for (i = 0; i < max_entry; i++)
1645         display_descriptor (0, gdtr.base, i, 0);
1646     }
1647 }
1648
1649 static void
1650 go32_sidt (char *arg, int from_tty)
1651 {
1652   struct dtr_reg idtr;
1653   long idt_entry = -1L;
1654   int max_entry;
1655
1656   if (arg && *arg)
1657     {
1658       while (*arg && isspace(*arg))
1659         arg++;
1660
1661       if (*arg)
1662         {
1663           idt_entry = parse_and_eval_long (arg);
1664           if (idt_entry < 0)
1665             error (_("Invalid (negative) IDT entry %ld."), idt_entry);
1666         }
1667     }
1668
1669   __asm__ __volatile__ ("sidt   %0" : "=m" (idtr) : /* no inputs */ );
1670   max_entry = (idtr.limit + 1) / 8;
1671   if (max_entry > 0x100)        /* no more than 256 entries */
1672     max_entry = 0x100;
1673
1674   if (idt_entry >= 0)
1675     {
1676       if (idt_entry > idtr.limit)
1677         error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1678                (unsigned long)idt_entry, idtr.limit);
1679
1680       display_descriptor (1, idtr.base, idt_entry, 1);
1681     }
1682   else
1683     {
1684       int i;
1685
1686       for (i = 0; i < max_entry; i++)
1687         display_descriptor (1, idtr.base, i, 0);
1688     }
1689 }
1690
1691 /* Cached linear address of the base of the page directory.  For
1692    now, available only under CWSDPMI.  Code based on ideas and
1693    suggestions from Charles Sandmann <sandmann@clio.rice.edu>.  */
1694 static unsigned long pdbr;
1695
1696 static unsigned long
1697 get_cr3 (void)
1698 {
1699   unsigned offset;
1700   unsigned taskreg;
1701   unsigned long taskbase, cr3;
1702   struct dtr_reg gdtr;
1703
1704   if (pdbr > 0 && pdbr <= 0xfffff)
1705     return pdbr;
1706
1707   /* Get the linear address of GDT and the Task Register.  */
1708   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
1709   __asm__ __volatile__ ("str    %0" : "=m" (taskreg) : /* no inputs */ );
1710
1711   /* Task Register is a segment selector for the TSS of the current
1712      task.  Therefore, it can be used as an index into the GDT to get
1713      at the segment descriptor for the TSS.  To get the index, reset
1714      the low 3 bits of the selector (which give the CPL).  Add 2 to the
1715      offset to point to the 3 low bytes of the base address.  */
1716   offset = gdtr.base + (taskreg & 0xfff8) + 2;
1717
1718
1719   /* CWSDPMI's task base is always under the 1MB mark.  */
1720   if (offset > 0xfffff)
1721     return 0;
1722
1723   _farsetsel (_dos_ds);
1724   taskbase  = _farnspeekl (offset) & 0xffffffU;
1725   taskbase += _farnspeekl (offset + 2) & 0xff000000U;
1726   if (taskbase > 0xfffff)
1727     return 0;
1728
1729   /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1730      offset 1Ch in the TSS.  */
1731   cr3 = _farnspeekl (taskbase + 0x1c) & ~0xfff;
1732   if (cr3 > 0xfffff)
1733     {
1734 #if 0  /* not fullly supported yet */
1735       /* The Page Directory is in UMBs.  In that case, CWSDPMI puts
1736          the first Page Table right below the Page Directory.  Thus,
1737          the first Page Table's entry for its own address and the Page
1738          Directory entry for that Page Table will hold the same
1739          physical address.  The loop below searches the entire UMB
1740          range of addresses for such an occurence.  */
1741       unsigned long addr, pte_idx;
1742
1743       for (addr = 0xb0000, pte_idx = 0xb0;
1744            pte_idx < 0xff;
1745            addr += 0x1000, pte_idx++)
1746         {
1747           if (((_farnspeekl (addr + 4 * pte_idx) & 0xfffff027) ==
1748                (_farnspeekl (addr + 0x1000) & 0xfffff027))
1749               && ((_farnspeekl (addr + 4 * pte_idx + 4) & 0xfffff000) == cr3))
1750             {
1751               cr3 = addr + 0x1000;
1752               break;
1753             }
1754         }
1755 #endif
1756
1757       if (cr3 > 0xfffff)
1758         cr3 = 0;
1759     }
1760
1761   return cr3;
1762 }
1763
1764 /* Return the N'th Page Directory entry.  */
1765 static unsigned long
1766 get_pde (int n)
1767 {
1768   unsigned long pde = 0;
1769
1770   if (pdbr && n >= 0 && n < 1024)
1771     {
1772       pde = _farpeekl (_dos_ds, pdbr + 4*n);
1773     }
1774   return pde;
1775 }
1776
1777 /* Return the N'th entry of the Page Table whose Page Directory entry
1778    is PDE.  */
1779 static unsigned long
1780 get_pte (unsigned long pde, int n)
1781 {
1782   unsigned long pte = 0;
1783
1784   /* pde & 0x80 tests the 4MB page bit.  We don't support 4MB
1785      page tables, for now.  */
1786   if ((pde & 1) && !(pde & 0x80) && n >= 0 && n < 1024)
1787     {
1788       pde &= ~0xfff;    /* clear non-address bits */
1789       pte = _farpeekl (_dos_ds, pde + 4*n);
1790     }
1791   return pte;
1792 }
1793
1794 /* Display a Page Directory or Page Table entry.  IS_DIR, if non-zero,
1795    says this is a Page Directory entry.  If FORCE is non-zero, display
1796    the entry even if its Present flag is off.  OFF is the offset of the
1797    address from the page's base address.  */
1798 static void
1799 display_ptable_entry (unsigned long entry, int is_dir, int force, unsigned off)
1800 {
1801   if ((entry & 1) != 0)
1802     {
1803       printf_filtered ("Base=0x%05lx000", entry >> 12);
1804       if ((entry & 0x100) && !is_dir)
1805         puts_filtered (" Global");
1806       if ((entry & 0x40) && !is_dir)
1807         puts_filtered (" Dirty");
1808       printf_filtered (" %sAcc.", (entry & 0x20) ? "" : "Not-");
1809       printf_filtered (" %sCached", (entry & 0x10) ? "" : "Not-");
1810       printf_filtered (" Write-%s", (entry & 8) ? "Thru" : "Back");
1811       printf_filtered (" %s", (entry & 4) ? "Usr" : "Sup");
1812       printf_filtered (" Read-%s", (entry & 2) ? "Write" : "Only");
1813       if (off)
1814         printf_filtered (" +0x%x", off);
1815       puts_filtered ("\n");
1816     }
1817   else if (force)
1818     printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1819                      is_dir ? " Table" : "", entry >> 1);
1820 }
1821
1822 static void
1823 go32_pde (char *arg, int from_tty)
1824 {
1825   long pde_idx = -1, i;
1826
1827   if (arg && *arg)
1828     {
1829       while (*arg && isspace(*arg))
1830         arg++;
1831
1832       if (*arg)
1833         {
1834           pde_idx = parse_and_eval_long (arg);
1835           if (pde_idx < 0 || pde_idx >= 1024)
1836             error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
1837         }
1838     }
1839
1840   pdbr = get_cr3 ();
1841   if (!pdbr)
1842     puts_filtered ("Access to Page Directories is not supported on this system.\n");
1843   else if (pde_idx >= 0)
1844     display_ptable_entry (get_pde (pde_idx), 1, 1, 0);
1845   else
1846     for (i = 0; i < 1024; i++)
1847       display_ptable_entry (get_pde (i), 1, 0, 0);
1848 }
1849
1850 /* A helper function to display entries in a Page Table pointed to by
1851    the N'th entry in the Page Directory.  If FORCE is non-zero, say
1852    something even if the Page Table is not accessible.  */
1853 static void
1854 display_page_table (long n, int force)
1855 {
1856   unsigned long pde = get_pde (n);
1857
1858   if ((pde & 1) != 0)
1859     {
1860       int i;
1861
1862       printf_filtered ("Page Table pointed to by Page Directory entry 0x%lx:\n", n);
1863       for (i = 0; i < 1024; i++)
1864         display_ptable_entry (get_pte (pde, i), 0, 0, 0);
1865       puts_filtered ("\n");
1866     }
1867   else if (force)
1868     printf_filtered ("Page Table not present; value=0x%lx.\n", pde >> 1);
1869 }
1870
1871 static void
1872 go32_pte (char *arg, int from_tty)
1873 {
1874   long pde_idx = -1L, i;
1875
1876   if (arg && *arg)
1877     {
1878       while (*arg && isspace(*arg))
1879         arg++;
1880
1881       if (*arg)
1882         {
1883           pde_idx = parse_and_eval_long (arg);
1884           if (pde_idx < 0 || pde_idx >= 1024)
1885             error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
1886         }
1887     }
1888
1889   pdbr = get_cr3 ();
1890   if (!pdbr)
1891     puts_filtered ("Access to Page Tables is not supported on this system.\n");
1892   else if (pde_idx >= 0)
1893     display_page_table (pde_idx, 1);
1894   else
1895     for (i = 0; i < 1024; i++)
1896       display_page_table (i, 0);
1897 }
1898
1899 static void
1900 go32_pte_for_address (char *arg, int from_tty)
1901 {
1902   CORE_ADDR addr = 0, i;
1903
1904   if (arg && *arg)
1905     {
1906       while (*arg && isspace(*arg))
1907         arg++;
1908
1909       if (*arg)
1910         addr = parse_and_eval_address (arg);
1911     }
1912   if (!addr)
1913     error_no_arg (_("linear address"));
1914
1915   pdbr = get_cr3 ();
1916   if (!pdbr)
1917     puts_filtered ("Access to Page Tables is not supported on this system.\n");
1918   else
1919     {
1920       int pde_idx = (addr >> 22) & 0x3ff;
1921       int pte_idx = (addr >> 12) & 0x3ff;
1922       unsigned offs = addr & 0xfff;
1923
1924       printf_filtered ("Page Table entry for address 0x%llx:\n",
1925                        (unsigned long long)addr);
1926       display_ptable_entry (get_pte (get_pde (pde_idx), pte_idx), 0, 1, offs);
1927     }
1928 }
1929
1930 static struct cmd_list_element *info_dos_cmdlist = NULL;
1931
1932 static void
1933 go32_info_dos_command (char *args, int from_tty)
1934 {
1935   help_list (info_dos_cmdlist, "info dos ", class_info, gdb_stdout);
1936 }
1937
1938 void
1939 _initialize_go32_nat (void)
1940 {
1941   init_go32_ops ();
1942   add_target (&go32_ops);
1943
1944   add_prefix_cmd ("dos", class_info, go32_info_dos_command, _("\
1945 Print information specific to DJGPP (aka MS-DOS) debugging."),
1946                   &info_dos_cmdlist, "info dos ", 0, &infolist);
1947
1948   add_cmd ("sysinfo", class_info, go32_sysinfo, _("\
1949 Display information about the target system, including CPU, OS, DPMI, etc."),
1950            &info_dos_cmdlist);
1951   add_cmd ("ldt", class_info, go32_sldt, _("\
1952 Display entries in the LDT (Local Descriptor Table).\n\
1953 Entry number (an expression) as an argument means display only that entry."),
1954            &info_dos_cmdlist);
1955   add_cmd ("gdt", class_info, go32_sgdt, _("\
1956 Display entries in the GDT (Global Descriptor Table).\n\
1957 Entry number (an expression) as an argument means display only that entry."),
1958            &info_dos_cmdlist);
1959   add_cmd ("idt", class_info, go32_sidt, _("\
1960 Display entries in the IDT (Interrupt Descriptor Table).\n\
1961 Entry number (an expression) as an argument means display only that entry."),
1962            &info_dos_cmdlist);
1963   add_cmd ("pde", class_info, go32_pde, _("\
1964 Display entries in the Page Directory.\n\
1965 Entry number (an expression) as an argument means display only that entry."),
1966            &info_dos_cmdlist);
1967   add_cmd ("pte", class_info, go32_pte, _("\
1968 Display entries in Page Tables.\n\
1969 Entry number (an expression) as an argument means display only entries\n\
1970 from the Page Table pointed to by the specified Page Directory entry."),
1971            &info_dos_cmdlist);
1972   add_cmd ("address-pte", class_info, go32_pte_for_address, _("\
1973 Display a Page Table entry for a linear address.\n\
1974 The address argument must be a linear address, after adding to\n\
1975 it the base address of the appropriate segment.\n\
1976 The base address of variables and functions in the debuggee's data\n\
1977 or code segment is stored in the variable __djgpp_base_address,\n\
1978 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
1979 For other segments, look up their base address in the output of\n\
1980 the `info dos ldt' command."),
1981            &info_dos_cmdlist);
1982 }
1983
1984 pid_t
1985 tcgetpgrp (int fd)
1986 {
1987   if (isatty (fd))
1988     return SOME_PID;
1989   errno = ENOTTY;
1990   return -1;
1991 }
1992
1993 int
1994 tcsetpgrp (int fd, pid_t pgid)
1995 {
1996   if (isatty (fd) && pgid == SOME_PID)
1997     return 0;
1998   errno = pgid == SOME_PID ? ENOTTY : ENOSYS;
1999   return -1;
2000 }