gdb/go32-nat.c

   1 /* Native debugging support for Intel x86 running DJGPP.
   2    Copyright (C) 1997, 1999, 2000, 2001, 2005, 2006, 2007, 2008
   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 ptid_t go32_wait (ptid_t ptid,
 175                                struct target_waitstatus *status);
 176 static void go32_fetch_registers (struct regcache *, int regno);
 177 static void store_register (const struct regcache *, int regno);
 178 static void go32_store_registers (struct regcache *, int regno);
 179 static void go32_prepare_to_store (struct regcache *);
 180 static int go32_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
 181                              int write,
 182                              struct mem_attrib *attrib,
 183                              struct target_ops *target);
 184 static void go32_files_info (struct target_ops *target);
 185 static void go32_stop (ptid_t);
 186 static void go32_kill_inferior (void);
 187 static void go32_create_inferior (char *exec_file, char *args, char **env, int from_tty);
 188 static void go32_mourn_inferior (void);
 189 static int go32_can_run (void);
 190
 191 static struct target_ops go32_ops;
 192 static void go32_terminal_init (void);
 193 static void go32_terminal_inferior (void);
 194 static void go32_terminal_ours (void);
 195
 196 #define r_ofs(x) (offsetof(TSS,x))
 197
 198 static struct
 199 {
 200   size_t tss_ofs;
 201   size_t size;
 202 }
 203 regno_mapping[] =
 204 {
 205   {r_ofs (tss_eax), 4}, /* normal registers, from a_tss */
 206   {r_ofs (tss_ecx), 4},
 207   {r_ofs (tss_edx), 4},
 208   {r_ofs (tss_ebx), 4},
 209   {r_ofs (tss_esp), 4},
 210   {r_ofs (tss_ebp), 4},
 211   {r_ofs (tss_esi), 4},
 212   {r_ofs (tss_edi), 4},
 213   {r_ofs (tss_eip), 4},
 214   {r_ofs (tss_eflags), 4},
 215   {r_ofs (tss_cs), 2},
 216   {r_ofs (tss_ss), 2},
 217   {r_ofs (tss_ds), 2},
 218   {r_ofs (tss_es), 2},
 219   {r_ofs (tss_fs), 2},
 220   {r_ofs (tss_gs), 2},
 221   {0, 10},              /* 8 FP registers, from npx.reg[] */
 222   {1, 10},
 223   {2, 10},
 224   {3, 10},
 225   {4, 10},
 226   {5, 10},
 227   {6, 10},
 228   {7, 10},
 229         /* The order of the next 7 registers must be consistent
 230            with their numbering in config/i386/tm-i386.h, which see.  */
 231   {0, 2},               /* control word, from npx */
 232   {4, 2},               /* status word, from npx */
 233   {8, 2},               /* tag word, from npx */
 234   {16, 2},              /* last FP exception CS from npx */
 235   {12, 4},              /* last FP exception EIP from npx */
 236   {24, 2},              /* last FP exception operand selector from npx */
 237   {20, 4},              /* last FP exception operand offset from npx */
 238   {18, 2}               /* last FP opcode from npx */
 239 };
 240
 241 static struct
 242   {
 243     int go32_sig;
 244     enum target_signal gdb_sig;
 245   }
 246 sig_map[] =
 247 {
 248   {0, TARGET_SIGNAL_FPE},
 249   {1, TARGET_SIGNAL_TRAP},
 250   /* Exception 2 is triggered by the NMI.  DJGPP handles it as SIGILL,
 251      but I think SIGBUS is better, since the NMI is usually activated
 252      as a result of a memory parity check failure.  */
 253   {2, TARGET_SIGNAL_BUS},
 254   {3, TARGET_SIGNAL_TRAP},
 255   {4, TARGET_SIGNAL_FPE},
 256   {5, TARGET_SIGNAL_SEGV},
 257   {6, TARGET_SIGNAL_ILL},
 258   {7, TARGET_SIGNAL_EMT},       /* no-coprocessor exception */
 259   {8, TARGET_SIGNAL_SEGV},
 260   {9, TARGET_SIGNAL_SEGV},
 261   {10, TARGET_SIGNAL_BUS},
 262   {11, TARGET_SIGNAL_SEGV},
 263   {12, TARGET_SIGNAL_SEGV},
 264   {13, TARGET_SIGNAL_SEGV},
 265   {14, TARGET_SIGNAL_SEGV},
 266   {16, TARGET_SIGNAL_FPE},
 267   {17, TARGET_SIGNAL_BUS},
 268   {31, TARGET_SIGNAL_ILL},
 269   {0x1b, TARGET_SIGNAL_INT},
 270   {0x75, TARGET_SIGNAL_FPE},
 271   {0x78, TARGET_SIGNAL_ALRM},
 272   {0x79, TARGET_SIGNAL_INT},
 273   {0x7a, TARGET_SIGNAL_QUIT},
 274   {-1, TARGET_SIGNAL_LAST}
 275 };
 276
 277 static struct {
 278   enum target_signal gdb_sig;
 279   int djgpp_excepno;
 280 } excepn_map[] = {
 281   {TARGET_SIGNAL_0, -1},
 282   {TARGET_SIGNAL_ILL, 6},       /* Invalid Opcode */
 283   {TARGET_SIGNAL_EMT, 7},       /* triggers SIGNOFP */
 284   {TARGET_SIGNAL_SEGV, 13},     /* GPF */
 285   {TARGET_SIGNAL_BUS, 17},      /* Alignment Check */
 286   /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
 287      details.  */
 288   {TARGET_SIGNAL_TERM, 0x1b},   /* triggers Ctrl-Break type of SIGINT */
 289   {TARGET_SIGNAL_FPE, 0x75},
 290   {TARGET_SIGNAL_INT, 0x79},
 291   {TARGET_SIGNAL_QUIT, 0x7a},
 292   {TARGET_SIGNAL_ALRM, 0x78},   /* triggers SIGTIMR */
 293   {TARGET_SIGNAL_PROF, 0x78},
 294   {TARGET_SIGNAL_LAST, -1}
 295 };
 296
 297 static void
 298 go32_open (char *name, int from_tty)
 299 {
 300   printf_unfiltered ("Done.  Use the \"run\" command to run the program.\n");
 301 }
 302
 303 static void
 304 go32_close (int quitting)
 305 {
 306 }
 307
 308 static void
 309 go32_attach (char *args, int from_tty)
 310 {
 311   error (_("\
 312 You cannot attach to a running program on this platform.\n\
 313 Use the `run' command to run DJGPP programs."));
 314 }
 315
 316 static void
 317 go32_detach (char *args, int from_tty)
 318 {
 319 }
 320
 321 static int resume_is_step;
 322 static int resume_signal = -1;
 323
 324 static void
 325 go32_resume (ptid_t ptid, int step, enum target_signal siggnal)
 326 {
 327   int i;
 328
 329   resume_is_step = step;
 330
 331   if (siggnal != TARGET_SIGNAL_0 && siggnal != TARGET_SIGNAL_TRAP)
 332   {
 333     for (i = 0, resume_signal = -1;
 334          excepn_map[i].gdb_sig != TARGET_SIGNAL_LAST; i++)
 335       if (excepn_map[i].gdb_sig == siggnal)
 336       {
 337         resume_signal = excepn_map[i].djgpp_excepno;
 338         break;
 339       }
 340     if (resume_signal == -1)
 341       printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
 342                          target_signal_to_name (siggnal));
 343   }
 344 }
 345
 346 static char child_cwd[FILENAME_MAX];
 347
 348 static ptid_t
 349 go32_wait (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 (void)
 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 (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   go32_ops.to_magic = OPS_MAGIC;
 914
 915   /* Initialize child's cwd as empty to be initialized when starting
 916      the child.  */
 917   *child_cwd = 0;
 918
 919   /* Initialize child's command line storage.  */
 920   if (redir_debug_init (&child_cmd) == -1)
 921     internal_error (__FILE__, __LINE__,
 922                     _("Cannot allocate redirection storage: not enough memory.\n"));
 923
 924   /* We are always processing GCC-compiled programs.  */
 925   processing_gcc_compilation = 2;
 926
 927   /* Override the default name of the GDB init file.  */
 928   strcpy (gdbinit, "gdb.ini");
 929 }
 930
 931 unsigned short windows_major, windows_minor;
 932
 933 /* Compute the version Windows reports via Int 2Fh/AX=1600h.  */
 934 static void
 935 go32_get_windows_version(void)
 936 {
 937   __dpmi_regs r;
 938
 939   r.x.ax = 0x1600;
 940   __dpmi_int(0x2f, &r);
 941   if (r.h.al > 2 && r.h.al != 0x80 && r.h.al != 0xff
 942       && (r.h.al > 3 || r.h.ah > 0))
 943     {
 944       windows_major = r.h.al;
 945       windows_minor = r.h.ah;
 946     }
 947   else
 948     windows_major = 0xff;       /* meaning no Windows */
 949 }
 950
 951 /* A subroutine of go32_sysinfo to display memory info.  */
 952 static void
 953 print_mem (unsigned long datum, const char *header, int in_pages_p)
 954 {
 955   if (datum != 0xffffffffUL)
 956     {
 957       if (in_pages_p)
 958         datum <<= 12;
 959       puts_filtered (header);
 960       if (datum > 1024)
 961         {
 962           printf_filtered ("%lu KB", datum >> 10);
 963           if (datum > 1024 * 1024)
 964             printf_filtered (" (%lu MB)", datum >> 20);
 965         }
 966       else
 967         printf_filtered ("%lu Bytes", datum);
 968       puts_filtered ("\n");
 969     }
 970 }
 971
 972 /* Display assorted information about the underlying OS.  */
 973 static void
 974 go32_sysinfo (char *arg, int from_tty)
 975 {
 976   struct utsname u;
 977   char cpuid_vendor[13];
 978   unsigned cpuid_max = 0, cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx;
 979   unsigned true_dos_version = _get_dos_version (1);
 980   unsigned advertized_dos_version = ((unsigned int)_osmajor << 8) | _osminor;
 981   int dpmi_flags;
 982   char dpmi_vendor_info[129];
 983   int dpmi_vendor_available =
 984     __dpmi_get_capabilities (&dpmi_flags, dpmi_vendor_info);
 985   __dpmi_version_ret dpmi_version_data;
 986   long eflags;
 987   __dpmi_free_mem_info mem_info;
 988   __dpmi_regs regs;
 989
 990   cpuid_vendor[0] = '\0';
 991   if (uname (&u))
 992     strcpy (u.machine, "Unknown x86");
 993   else if (u.machine[0] == 'i' && u.machine[1] > 4)
 994     {
 995       /* CPUID with EAX = 0 returns the Vendor ID.  */
 996       __asm__ __volatile__ ("xorl   %%ebx, %%ebx;"
 997                             "xorl   %%ecx, %%ecx;"
 998                             "xorl   %%edx, %%edx;"
 999                             "movl   $0,    %%eax;"
1000                             "cpuid;"
1001                             "movl   %%ebx,  %0;"
1002                             "movl   %%edx,  %1;"
1003                             "movl   %%ecx,  %2;"
1004                             "movl   %%eax,  %3;"
1005                             : "=m" (cpuid_vendor[0]),
1006                               "=m" (cpuid_vendor[4]),
1007                               "=m" (cpuid_vendor[8]),
1008                               "=m" (cpuid_max)
1009                             :
1010                             : "%eax", "%ebx", "%ecx", "%edx");
1011       cpuid_vendor[12] = '\0';
1012     }
1013
1014   printf_filtered ("CPU Type.......................%s", u.machine);
1015   if (cpuid_vendor[0])
1016     printf_filtered (" (%s)", cpuid_vendor);
1017   puts_filtered ("\n");
1018
1019   /* CPUID with EAX = 1 returns processor signature and features.  */
1020   if (cpuid_max >= 1)
1021     {
1022       static char *brand_name[] = {
1023         "",
1024         " Celeron",
1025         " III",
1026         " III Xeon",
1027         "", "", "", "",
1028         " 4"
1029       };
1030       char cpu_string[80];
1031       char cpu_brand[20];
1032       unsigned brand_idx;
1033       int intel_p = strcmp (cpuid_vendor, "GenuineIntel") == 0;
1034       int amd_p = strcmp (cpuid_vendor, "AuthenticAMD") == 0;
1035       unsigned cpu_family, cpu_model;
1036
1037       __asm__ __volatile__ ("movl   $1, %%eax;"
1038                             "cpuid;"
1039                             : "=a" (cpuid_eax),
1040                               "=b" (cpuid_ebx),
1041                               "=d" (cpuid_edx)
1042                             :
1043                             : "%ecx");
1044       brand_idx = cpuid_ebx & 0xff;
1045       cpu_family = (cpuid_eax >> 8) & 0xf;
1046       cpu_model  = (cpuid_eax >> 4) & 0xf;
1047       cpu_brand[0] = '\0';
1048       if (intel_p)
1049         {
1050           if (brand_idx > 0
1051               && brand_idx < sizeof(brand_name)/sizeof(brand_name[0])
1052               && *brand_name[brand_idx])
1053             strcpy (cpu_brand, brand_name[brand_idx]);
1054           else if (cpu_family == 5)
1055             {
1056               if (((cpuid_eax >> 12) & 3) == 0 && cpu_model == 4)
1057                 strcpy (cpu_brand, " MMX");
1058               else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 1)
1059                 strcpy (cpu_brand, " OverDrive");
1060               else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 2)
1061                 strcpy (cpu_brand, " Dual");
1062             }
1063           else if (cpu_family == 6 && cpu_model < 8)
1064             {
1065               switch (cpu_model)
1066                 {
1067                   case 1:
1068                     strcpy (cpu_brand, " Pro");
1069                     break;
1070                   case 3:
1071                     strcpy (cpu_brand, " II");
1072                     break;
1073                   case 5:
1074                     strcpy (cpu_brand, " II Xeon");
1075                     break;
1076                   case 6:
1077                     strcpy (cpu_brand, " Celeron");
1078                     break;
1079                   case 7:
1080                     strcpy (cpu_brand, " III");
1081                     break;
1082                 }
1083             }
1084         }
1085       else if (amd_p)
1086         {
1087           switch (cpu_family)
1088             {
1089               case 4:
1090                 strcpy (cpu_brand, "486/5x86");
1091                 break;
1092               case 5:
1093                 switch (cpu_model)
1094                   {
1095                     case 0:
1096                     case 1:
1097                     case 2:
1098                     case 3:
1099                       strcpy (cpu_brand, "-K5");
1100                       break;
1101                     case 6:
1102                     case 7:
1103                       strcpy (cpu_brand, "-K6");
1104                       break;
1105                     case 8:
1106                       strcpy (cpu_brand, "-K6-2");
1107                       break;
1108                     case 9:
1109                       strcpy (cpu_brand, "-K6-III");
1110                       break;
1111                   }
1112                 break;
1113               case 6:
1114                 switch (cpu_model)
1115                   {
1116                     case 1:
1117                     case 2:
1118                     case 4:
1119                       strcpy (cpu_brand, " Athlon");
1120                       break;
1121                     case 3:
1122                       strcpy (cpu_brand, " Duron");
1123                       break;
1124                   }
1125                 break;
1126             }
1127         }
1128       sprintf (cpu_string, "%s%s Model %d Stepping %d",
1129                intel_p ? "Pentium" : (amd_p ? "AMD" : "ix86"),
1130                cpu_brand, cpu_model, cpuid_eax & 0xf);
1131       printfi_filtered (31, "%s\n", cpu_string);
1132       if (((cpuid_edx & (6 | (0x0d << 23))) != 0)
1133           || ((cpuid_edx & 1) == 0)
1134           || (amd_p && (cpuid_edx & (3 << 30)) != 0))
1135         {
1136           puts_filtered ("CPU Features...................");
1137           /* We only list features which might be useful in the DPMI
1138              environment.  */
1139           if ((cpuid_edx & 1) == 0)
1140             puts_filtered ("No FPU "); /* it's unusual to not have an FPU */
1141           if ((cpuid_edx & (1 << 1)) != 0)
1142             puts_filtered ("VME ");
1143           if ((cpuid_edx & (1 << 2)) != 0)
1144             puts_filtered ("DE ");
1145           if ((cpuid_edx & (1 << 4)) != 0)
1146             puts_filtered ("TSC ");
1147           if ((cpuid_edx & (1 << 23)) != 0)
1148             puts_filtered ("MMX ");
1149           if ((cpuid_edx & (1 << 25)) != 0)
1150             puts_filtered ("SSE ");
1151           if ((cpuid_edx & (1 << 26)) != 0)
1152             puts_filtered ("SSE2 ");
1153           if (amd_p)
1154             {
1155               if ((cpuid_edx & (1 << 31)) != 0)
1156                 puts_filtered ("3DNow! ");
1157               if ((cpuid_edx & (1 << 30)) != 0)
1158                 puts_filtered ("3DNow!Ext");
1159             }
1160           puts_filtered ("\n");
1161         }
1162     }
1163   puts_filtered ("\n");
1164   printf_filtered ("DOS Version....................%s %s.%s",
1165                    _os_flavor, u.release, u.version);
1166   if (true_dos_version != advertized_dos_version)
1167     printf_filtered (" (disguised as v%d.%d)", _osmajor, _osminor);
1168   puts_filtered ("\n");
1169   if (!windows_major)
1170     go32_get_windows_version ();
1171   if (windows_major != 0xff)
1172     {
1173       const char *windows_flavor;
1174
1175       printf_filtered ("Windows Version................%d.%02d (Windows ",
1176                        windows_major, windows_minor);
1177       switch (windows_major)
1178         {
1179           case 3:
1180             windows_flavor = "3.X";
1181             break;
1182           case 4:
1183             switch (windows_minor)
1184               {
1185                 case 0:
1186                   windows_flavor = "95, 95A, or 95B";
1187                   break;
1188                 case 3:
1189                   windows_flavor = "95B OSR2.1 or 95C OSR2.5";
1190                   break;
1191                 case 10:
1192                   windows_flavor = "98 or 98 SE";
1193                   break;
1194                 case 90:
1195                   windows_flavor = "ME";
1196                   break;
1197                 default:
1198                   windows_flavor = "9X";
1199                   break;
1200               }
1201             break;
1202           default:
1203             windows_flavor = "??";
1204             break;
1205         }
1206       printf_filtered ("%s)\n", windows_flavor);
1207     }
1208   else if (true_dos_version == 0x532 && advertized_dos_version == 0x500)
1209     printf_filtered ("Windows Version................Windows NT or Windows 2000\n");
1210   puts_filtered ("\n");
1211   if (dpmi_vendor_available == 0)
1212     {
1213       /* The DPMI spec says the vendor string should be ASCIIZ, but
1214          I don't trust the vendors to follow that...  */
1215       if (!memchr (&dpmi_vendor_info[2], 0, 126))
1216         dpmi_vendor_info[128] = '\0';
1217       printf_filtered ("DPMI Host......................%s v%d.%d (capabilities: %#x)\n",
1218                        &dpmi_vendor_info[2],
1219                        (unsigned)dpmi_vendor_info[0],
1220                        (unsigned)dpmi_vendor_info[1],
1221                        ((unsigned)dpmi_flags & 0x7f));
1222     }
1223   __dpmi_get_version (&dpmi_version_data);
1224   printf_filtered ("DPMI Version...................%d.%02d\n",
1225                    dpmi_version_data.major, dpmi_version_data.minor);
1226   printf_filtered ("DPMI Info......................%s-bit DPMI, with%s Virtual Memory support\n",
1227                    (dpmi_version_data.flags & 1) ? "32" : "16",
1228                    (dpmi_version_data.flags & 4) ? "" : "out");
1229   printfi_filtered (31, "Interrupts reflected to %s mode\n",
1230                    (dpmi_version_data.flags & 2) ? "V86" : "Real");
1231   printfi_filtered (31, "Processor type: i%d86\n",
1232                    dpmi_version_data.cpu);
1233   printfi_filtered (31, "PIC base interrupt: Master: %#x  Slave: %#x\n",
1234                    dpmi_version_data.master_pic, dpmi_version_data.slave_pic);
1235
1236   /* a_tss is only initialized when the debuggee is first run.  */
1237   if (prog_has_started)
1238     {
1239       __asm__ __volatile__ ("pushfl ; popl %0" : "=g" (eflags));
1240       printf_filtered ("Protection.....................Ring %d (in %s), with%s I/O protection\n",
1241                        a_tss.tss_cs & 3, (a_tss.tss_cs & 4) ? "LDT" : "GDT",
1242                        (a_tss.tss_cs & 3) > ((eflags >> 12) & 3) ? "" : "out");
1243     }
1244   puts_filtered ("\n");
1245   __dpmi_get_free_memory_information (&mem_info);
1246   print_mem (mem_info.total_number_of_physical_pages,
1247              "DPMI Total Physical Memory.....", 1);
1248   print_mem (mem_info.total_number_of_free_pages,
1249              "DPMI Free Physical Memory......", 1);
1250   print_mem (mem_info.size_of_paging_file_partition_in_pages,
1251              "DPMI Swap Space................", 1);
1252   print_mem (mem_info.linear_address_space_size_in_pages,
1253              "DPMI Total Linear Address Size.", 1);
1254   print_mem (mem_info.free_linear_address_space_in_pages,
1255              "DPMI Free Linear Address Size..", 1);
1256   print_mem (mem_info.largest_available_free_block_in_bytes,
1257              "DPMI Largest Free Memory Block.", 0);
1258
1259   regs.h.ah = 0x48;
1260   regs.x.bx = 0xffff;
1261   __dpmi_int (0x21, &regs);
1262   print_mem (regs.x.bx << 4, "Free DOS Memory................", 0);
1263   regs.x.ax = 0x5800;
1264   __dpmi_int (0x21, &regs);
1265   if ((regs.x.flags & 1) == 0)
1266     {
1267       static const char *dos_hilo[] = {
1268         "Low", "", "", "", "High", "", "", "", "High, then Low"
1269       };
1270       static const char *dos_fit[] = {
1271         "First", "Best", "Last"
1272       };
1273       int hilo_idx = (regs.x.ax >> 4) & 0x0f;
1274       int fit_idx  = regs.x.ax & 0x0f;
1275
1276       if (hilo_idx > 8)
1277         hilo_idx = 0;
1278       if (fit_idx > 2)
1279         fit_idx = 0;
1280       printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1281                        dos_hilo[hilo_idx], dos_fit[fit_idx]);
1282       regs.x.ax = 0x5802;
1283       __dpmi_int (0x21, &regs);
1284       if ((regs.x.flags & 1) != 0)
1285         regs.h.al = 0;
1286       printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1287                         regs.h.al == 0 ? "not " : "");
1288     }
1289 }
1290
1291 struct seg_descr {
1292   unsigned short limit0;
1293   unsigned short base0;
1294   unsigned char  base1;
1295   unsigned       stype:5;
1296   unsigned       dpl:2;
1297   unsigned       present:1;
1298   unsigned       limit1:4;
1299   unsigned       available:1;
1300   unsigned       dummy:1;
1301   unsigned       bit32:1;
1302   unsigned       page_granular:1;
1303   unsigned char  base2;
1304 } __attribute__ ((packed));
1305
1306 struct gate_descr {
1307   unsigned short offset0;
1308   unsigned short selector;
1309   unsigned       param_count:5;
1310   unsigned       dummy:3;
1311   unsigned       stype:5;
1312   unsigned       dpl:2;
1313   unsigned       present:1;
1314   unsigned short offset1;
1315 } __attribute__ ((packed));
1316
1317 /* Read LEN bytes starting at logical address ADDR, and put the result
1318    into DEST.  Return 1 if success, zero if not.  */
1319 static int
1320 read_memory_region (unsigned long addr, void *dest, size_t len)
1321 {
1322   unsigned long dos_ds_limit = __dpmi_get_segment_limit (_dos_ds);
1323   int retval = 1;
1324
1325   /* For the low memory, we can simply use _dos_ds.  */
1326   if (addr <= dos_ds_limit - len)
1327     dosmemget (addr, len, dest);
1328   else
1329     {
1330       /* For memory above 1MB we need to set up a special segment to
1331          be able to access that memory.  */
1332       int sel = __dpmi_allocate_ldt_descriptors (1);
1333
1334       if (sel <= 0)
1335         retval = 0;
1336       else
1337         {
1338           int access_rights = __dpmi_get_descriptor_access_rights (sel);
1339           size_t segment_limit = len - 1;
1340
1341           /* Make sure the crucial bits in the descriptor access
1342              rights are set correctly.  Some DPMI providers might barf
1343              if we set the segment limit to something that is not an
1344              integral multiple of 4KB pages if the granularity bit is
1345              not set to byte-granular, even though the DPMI spec says
1346              it's the host's responsibility to set that bit correctly.  */
1347           if (len > 1024 * 1024)
1348             {
1349               access_rights |= 0x8000;
1350               /* Page-granular segments should have the low 12 bits of
1351                  the limit set.  */
1352               segment_limit |= 0xfff;
1353             }
1354           else
1355             access_rights &= ~0x8000;
1356
1357           if (__dpmi_set_segment_base_address (sel, addr) != -1
1358               && __dpmi_set_descriptor_access_rights (sel, access_rights) != -1
1359               && __dpmi_set_segment_limit (sel, segment_limit) != -1
1360               /* W2K silently fails to set the segment limit, leaving
1361                  it at zero; this test avoids the resulting crash.  */
1362               && __dpmi_get_segment_limit (sel) >= segment_limit)
1363             movedata (sel, 0, _my_ds (), (unsigned)dest, len);
1364           else
1365             retval = 0;
1366
1367           __dpmi_free_ldt_descriptor (sel);
1368         }
1369     }
1370   return retval;
1371 }
1372
1373 /* Get a segment descriptor stored at index IDX in the descriptor
1374    table whose base address is TABLE_BASE.  Return the descriptor
1375    type, or -1 if failure.  */
1376 static int
1377 get_descriptor (unsigned long table_base, int idx, void *descr)
1378 {
1379   unsigned long addr = table_base + idx * 8; /* 8 bytes per entry */
1380
1381   if (read_memory_region (addr, descr, 8))
1382     return (int)((struct seg_descr *)descr)->stype;
1383   return -1;
1384 }
1385
1386 struct dtr_reg {
1387   unsigned short limit __attribute__((packed));
1388   unsigned long  base  __attribute__((packed));
1389 };
1390
1391 /* Display a segment descriptor stored at index IDX in a descriptor
1392    table whose type is TYPE and whose base address is BASE_ADDR.  If
1393    FORCE is non-zero, display even invalid descriptors.  */
1394 static void
1395 display_descriptor (unsigned type, unsigned long base_addr, int idx, int force)
1396 {
1397   struct seg_descr descr;
1398   struct gate_descr gate;
1399
1400   /* Get the descriptor from the table.  */
1401   if (idx == 0 && type == 0)
1402     puts_filtered ("0x000: null descriptor\n");
1403   else if (get_descriptor (base_addr, idx, &descr) != -1)
1404     {
1405       /* For each type of descriptor table, this has a bit set if the
1406          corresponding type of selectors is valid in that table.  */
1407       static unsigned allowed_descriptors[] = {
1408           0xffffdafeL,   /* GDT */
1409           0x0000c0e0L,   /* IDT */
1410           0xffffdafaL    /* LDT */
1411       };
1412
1413       /* If the program hasn't started yet, assume the debuggee will
1414          have the same CPL as the debugger.  */
1415       int cpl = prog_has_started ? (a_tss.tss_cs & 3) : _my_cs () & 3;
1416       unsigned long limit = (descr.limit1 << 16) | descr.limit0;
1417
1418       if (descr.present
1419           && (allowed_descriptors[type] & (1 << descr.stype)) != 0)
1420         {
1421           printf_filtered ("0x%03x: ",
1422                            type == 1
1423                            ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1424           if (descr.page_granular)
1425             limit = (limit << 12) | 0xfff; /* big segment: low 12 bit set */
1426           if (descr.stype == 1 || descr.stype == 2 || descr.stype == 3
1427               || descr.stype == 9 || descr.stype == 11
1428               || (descr.stype >= 16 && descr.stype < 32))
1429             printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1430                              descr.base2, descr.base1, descr.base0, limit);
1431
1432           switch (descr.stype)
1433             {
1434               case 1:
1435               case 3:
1436                 printf_filtered (" 16-bit TSS  (task %sactive)",
1437                                  descr.stype == 3 ? "" : "in");
1438                 break;
1439               case 2:
1440                 puts_filtered (" LDT");
1441                 break;
1442               case 4:
1443                 memcpy (&gate, &descr, sizeof gate);
1444                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1445                                  gate.selector, gate.offset1, gate.offset0);
1446                 printf_filtered (" 16-bit Call Gate (params=%d)",
1447                                  gate.param_count);
1448                 break;
1449               case 5:
1450                 printf_filtered ("TSS selector=0x%04x", descr.base0);
1451                 printfi_filtered (16, "Task Gate");
1452                 break;
1453               case 6:
1454               case 7:
1455                 memcpy (&gate, &descr, sizeof gate);
1456                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1457                                  gate.selector, gate.offset1, gate.offset0);
1458                 printf_filtered (" 16-bit %s Gate",
1459                                  descr.stype == 6 ? "Interrupt" : "Trap");
1460                 break;
1461               case 9:
1462               case 11:
1463                 printf_filtered (" 32-bit TSS (task %sactive)",
1464                                  descr.stype == 3 ? "" : "in");
1465                 break;
1466               case 12:
1467                 memcpy (&gate, &descr, sizeof gate);
1468                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1469                                  gate.selector, gate.offset1, gate.offset0);
1470                 printf_filtered (" 32-bit Call Gate (params=%d)",
1471                                  gate.param_count);
1472                 break;
1473               case 14:
1474               case 15:
1475                 memcpy (&gate, &descr, sizeof gate);
1476                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1477                                  gate.selector, gate.offset1, gate.offset0);
1478                 printf_filtered (" 32-bit %s Gate",
1479                                  descr.stype == 14 ? "Interrupt" : "Trap");
1480                 break;
1481               case 16:          /* data segments */
1482               case 17:
1483               case 18:
1484               case 19:
1485               case 20:
1486               case 21:
1487               case 22:
1488               case 23:
1489                 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1490                                  descr.bit32 ? "32" : "16",
1491                                  descr.stype & 2 ? "Read/Write," : "Read-Only, ",
1492                                  descr.stype & 4 ? "down" : "up",
1493                                  descr.stype & 1 ? "" : ", N.Acc");
1494                 break;
1495               case 24:          /* code segments */
1496               case 25:
1497               case 26:
1498               case 27:
1499               case 28:
1500               case 29:
1501               case 30:
1502               case 31:
1503                 printf_filtered (" %s-bit Code (%s,  %sConf%s)",
1504                                  descr.bit32 ? "32" : "16",
1505                                  descr.stype & 2 ? "Exec/Read" : "Exec-Only",
1506                                  descr.stype & 4 ? "" : "N.",
1507                                  descr.stype & 1 ? "" : ", N.Acc");
1508                 break;
1509               default:
1510                 printf_filtered ("Unknown type 0x%02x", descr.stype);
1511                 break;
1512             }
1513           puts_filtered ("\n");
1514         }
1515       else if (force)
1516         {
1517           printf_filtered ("0x%03x: ",
1518                            type == 1
1519                            ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1520           if (!descr.present)
1521             puts_filtered ("Segment not present\n");
1522           else
1523             printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1524                              descr.stype);
1525         }
1526     }
1527   else if (force)
1528     printf_filtered ("0x%03x: Cannot read this descriptor\n", idx);
1529 }
1530
1531 static void
1532 go32_sldt (char *arg, int from_tty)
1533 {
1534   struct dtr_reg gdtr;
1535   unsigned short ldtr = 0;
1536   int ldt_idx;
1537   struct seg_descr ldt_descr;
1538   long ldt_entry = -1L;
1539   int cpl = (prog_has_started ? a_tss.tss_cs : _my_cs ()) & 3;
1540
1541   if (arg && *arg)
1542     {
1543       while (*arg && isspace(*arg))
1544         arg++;
1545
1546       if (*arg)
1547         {
1548           ldt_entry = parse_and_eval_long (arg);
1549           if (ldt_entry < 0
1550               || (ldt_entry & 4) == 0
1551               || (ldt_entry & 3) != (cpl & 3))
1552             error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry);
1553         }
1554     }
1555
1556   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
1557   __asm__ __volatile__ ("sldt   %0" : "=m" (ldtr) : /* no inputs */ );
1558   ldt_idx = ldtr / 8;
1559   if (ldt_idx == 0)
1560     puts_filtered ("There is no LDT.\n");
1561   /* LDT's entry in the GDT must have the type LDT, which is 2.  */
1562   else if (get_descriptor (gdtr.base, ldt_idx, &ldt_descr) != 2)
1563     printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1564                      ldt_descr.base0
1565                      | (ldt_descr.base1 << 16)
1566                      | (ldt_descr.base2 << 24));
1567   else
1568     {
1569       unsigned base =
1570         ldt_descr.base0
1571         | (ldt_descr.base1 << 16)
1572         | (ldt_descr.base2 << 24);
1573       unsigned limit = ldt_descr.limit0 | (ldt_descr.limit1 << 16);
1574       int max_entry;
1575
1576       if (ldt_descr.page_granular)
1577         /* Page-granular segments must have the low 12 bits of their
1578            limit set.  */
1579         limit = (limit << 12) | 0xfff;
1580       /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1581          64KB.  */
1582       if (limit > 0xffff)
1583         limit = 0xffff;
1584
1585       max_entry = (limit + 1) / 8;
1586
1587       if (ldt_entry >= 0)
1588         {
1589           if (ldt_entry > limit)
1590             error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1591                    (unsigned long)ldt_entry, limit);
1592
1593           display_descriptor (ldt_descr.stype, base, ldt_entry / 8, 1);
1594         }
1595       else
1596         {
1597           int i;
1598
1599           for (i = 0; i < max_entry; i++)
1600             display_descriptor (ldt_descr.stype, base, i, 0);
1601         }
1602     }
1603 }
1604
1605 static void
1606 go32_sgdt (char *arg, int from_tty)
1607 {
1608   struct dtr_reg gdtr;
1609   long gdt_entry = -1L;
1610   int max_entry;
1611
1612   if (arg && *arg)
1613     {
1614       while (*arg && isspace(*arg))
1615         arg++;
1616
1617       if (*arg)
1618         {
1619           gdt_entry = parse_and_eval_long (arg);
1620           if (gdt_entry < 0 || (gdt_entry & 7) != 0)
1621             error (_("Invalid GDT entry 0x%03lx: not an integral multiple of 8."),
1622                    (unsigned long)gdt_entry);
1623         }
1624     }
1625
1626   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
1627   max_entry = (gdtr.limit + 1) / 8;
1628
1629   if (gdt_entry >= 0)
1630     {
1631       if (gdt_entry > gdtr.limit)
1632         error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1633                (unsigned long)gdt_entry, gdtr.limit);
1634
1635       display_descriptor (0, gdtr.base, gdt_entry / 8, 1);
1636     }
1637   else
1638     {
1639       int i;
1640
1641       for (i = 0; i < max_entry; i++)
1642         display_descriptor (0, gdtr.base, i, 0);
1643     }
1644 }
1645
1646 static void
1647 go32_sidt (char *arg, int from_tty)
1648 {
1649   struct dtr_reg idtr;
1650   long idt_entry = -1L;
1651   int max_entry;
1652
1653   if (arg && *arg)
1654     {
1655       while (*arg && isspace(*arg))
1656         arg++;
1657
1658       if (*arg)
1659         {
1660           idt_entry = parse_and_eval_long (arg);
1661           if (idt_entry < 0)
1662             error (_("Invalid (negative) IDT entry %ld."), idt_entry);
1663         }
1664     }
1665
1666   __asm__ __volatile__ ("sidt   %0" : "=m" (idtr) : /* no inputs */ );
1667   max_entry = (idtr.limit + 1) / 8;
1668   if (max_entry > 0x100)        /* no more than 256 entries */
1669     max_entry = 0x100;
1670
1671   if (idt_entry >= 0)
1672     {
1673       if (idt_entry > idtr.limit)
1674         error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1675                (unsigned long)idt_entry, idtr.limit);
1676
1677       display_descriptor (1, idtr.base, idt_entry, 1);
1678     }
1679   else
1680     {
1681       int i;
1682
1683       for (i = 0; i < max_entry; i++)
1684         display_descriptor (1, idtr.base, i, 0);
1685     }
1686 }
1687
1688 /* Cached linear address of the base of the page directory.  For
1689    now, available only under CWSDPMI.  Code based on ideas and
1690    suggestions from Charles Sandmann <sandmann@clio.rice.edu>.  */
1691 static unsigned long pdbr;
1692
1693 static unsigned long
1694 get_cr3 (void)
1695 {
1696   unsigned offset;
1697   unsigned taskreg;
1698   unsigned long taskbase, cr3;
1699   struct dtr_reg gdtr;
1700
1701   if (pdbr > 0 && pdbr <= 0xfffff)
1702     return pdbr;
1703
1704   /* Get the linear address of GDT and the Task Register.  */
1705   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
1706   __asm__ __volatile__ ("str    %0" : "=m" (taskreg) : /* no inputs */ );
1707
1708   /* Task Register is a segment selector for the TSS of the current
1709      task.  Therefore, it can be used as an index into the GDT to get
1710      at the segment descriptor for the TSS.  To get the index, reset
1711      the low 3 bits of the selector (which give the CPL).  Add 2 to the
1712      offset to point to the 3 low bytes of the base address.  */
1713   offset = gdtr.base + (taskreg & 0xfff8) + 2;
1714
1715
1716   /* CWSDPMI's task base is always under the 1MB mark.  */
1717   if (offset > 0xfffff)
1718     return 0;
1719
1720   _farsetsel (_dos_ds);
1721   taskbase  = _farnspeekl (offset) & 0xffffffU;
1722   taskbase += _farnspeekl (offset + 2) & 0xff000000U;
1723   if (taskbase > 0xfffff)
1724     return 0;
1725
1726   /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1727      offset 1Ch in the TSS.  */
1728   cr3 = _farnspeekl (taskbase + 0x1c) & ~0xfff;
1729   if (cr3 > 0xfffff)
1730     {
1731 #if 0  /* not fullly supported yet */
1732       /* The Page Directory is in UMBs.  In that case, CWSDPMI puts
1733          the first Page Table right below the Page Directory.  Thus,
1734          the first Page Table's entry for its own address and the Page
1735          Directory entry for that Page Table will hold the same
1736          physical address.  The loop below searches the entire UMB
1737          range of addresses for such an occurence.  */
1738       unsigned long addr, pte_idx;
1739
1740       for (addr = 0xb0000, pte_idx = 0xb0;
1741            pte_idx < 0xff;
1742            addr += 0x1000, pte_idx++)
1743         {
1744           if (((_farnspeekl (addr + 4 * pte_idx) & 0xfffff027) ==
1745                (_farnspeekl (addr + 0x1000) & 0xfffff027))
1746               && ((_farnspeekl (addr + 4 * pte_idx + 4) & 0xfffff000) == cr3))
1747             {
1748               cr3 = addr + 0x1000;
1749               break;
1750             }
1751         }
1752 #endif
1753
1754       if (cr3 > 0xfffff)
1755         cr3 = 0;
1756     }
1757
1758   return cr3;
1759 }
1760
1761 /* Return the N'th Page Directory entry.  */
1762 static unsigned long
1763 get_pde (int n)
1764 {
1765   unsigned long pde = 0;
1766
1767   if (pdbr && n >= 0 && n < 1024)
1768     {
1769       pde = _farpeekl (_dos_ds, pdbr + 4*n);
1770     }
1771   return pde;
1772 }
1773
1774 /* Return the N'th entry of the Page Table whose Page Directory entry
1775    is PDE.  */
1776 static unsigned long
1777 get_pte (unsigned long pde, int n)
1778 {
1779   unsigned long pte = 0;
1780
1781   /* pde & 0x80 tests the 4MB page bit.  We don't support 4MB
1782      page tables, for now.  */
1783   if ((pde & 1) && !(pde & 0x80) && n >= 0 && n < 1024)
1784     {
1785       pde &= ~0xfff;    /* clear non-address bits */
1786       pte = _farpeekl (_dos_ds, pde + 4*n);
1787     }
1788   return pte;
1789 }
1790
1791 /* Display a Page Directory or Page Table entry.  IS_DIR, if non-zero,
1792    says this is a Page Directory entry.  If FORCE is non-zero, display
1793    the entry even if its Present flag is off.  OFF is the offset of the
1794    address from the page's base address.  */
1795 static void
1796 display_ptable_entry (unsigned long entry, int is_dir, int force, unsigned off)
1797 {
1798   if ((entry & 1) != 0)
1799     {
1800       printf_filtered ("Base=0x%05lx000", entry >> 12);
1801       if ((entry & 0x100) && !is_dir)
1802         puts_filtered (" Global");
1803       if ((entry & 0x40) && !is_dir)
1804         puts_filtered (" Dirty");
1805       printf_filtered (" %sAcc.", (entry & 0x20) ? "" : "Not-");
1806       printf_filtered (" %sCached", (entry & 0x10) ? "" : "Not-");
1807       printf_filtered (" Write-%s", (entry & 8) ? "Thru" : "Back");
1808       printf_filtered (" %s", (entry & 4) ? "Usr" : "Sup");
1809       printf_filtered (" Read-%s", (entry & 2) ? "Write" : "Only");
1810       if (off)
1811         printf_filtered (" +0x%x", off);
1812       puts_filtered ("\n");
1813     }
1814   else if (force)
1815     printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1816                      is_dir ? " Table" : "", entry >> 1);
1817 }
1818
1819 static void
1820 go32_pde (char *arg, int from_tty)
1821 {
1822   long pde_idx = -1, i;
1823
1824   if (arg && *arg)
1825     {
1826       while (*arg && isspace(*arg))
1827         arg++;
1828
1829       if (*arg)
1830         {
1831           pde_idx = parse_and_eval_long (arg);
1832           if (pde_idx < 0 || pde_idx >= 1024)
1833             error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
1834         }
1835     }
1836
1837   pdbr = get_cr3 ();
1838   if (!pdbr)
1839     puts_filtered ("Access to Page Directories is not supported on this system.\n");
1840   else if (pde_idx >= 0)
1841     display_ptable_entry (get_pde (pde_idx), 1, 1, 0);
1842   else
1843     for (i = 0; i < 1024; i++)
1844       display_ptable_entry (get_pde (i), 1, 0, 0);
1845 }
1846
1847 /* A helper function to display entries in a Page Table pointed to by
1848    the N'th entry in the Page Directory.  If FORCE is non-zero, say
1849    something even if the Page Table is not accessible.  */
1850 static void
1851 display_page_table (long n, int force)
1852 {
1853   unsigned long pde = get_pde (n);
1854
1855   if ((pde & 1) != 0)
1856     {
1857       int i;
1858
1859       printf_filtered ("Page Table pointed to by Page Directory entry 0x%lx:\n", n);
1860       for (i = 0; i < 1024; i++)
1861         display_ptable_entry (get_pte (pde, i), 0, 0, 0);
1862       puts_filtered ("\n");
1863     }
1864   else if (force)
1865     printf_filtered ("Page Table not present; value=0x%lx.\n", pde >> 1);
1866 }
1867
1868 static void
1869 go32_pte (char *arg, int from_tty)
1870 {
1871   long pde_idx = -1L, i;
1872
1873   if (arg && *arg)
1874     {
1875       while (*arg && isspace(*arg))
1876         arg++;
1877
1878       if (*arg)
1879         {
1880           pde_idx = parse_and_eval_long (arg);
1881           if (pde_idx < 0 || pde_idx >= 1024)
1882             error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
1883         }
1884     }
1885
1886   pdbr = get_cr3 ();
1887   if (!pdbr)
1888     puts_filtered ("Access to Page Tables is not supported on this system.\n");
1889   else if (pde_idx >= 0)
1890     display_page_table (pde_idx, 1);
1891   else
1892     for (i = 0; i < 1024; i++)
1893       display_page_table (i, 0);
1894 }
1895
1896 static void
1897 go32_pte_for_address (char *arg, int from_tty)
1898 {
1899   CORE_ADDR addr = 0, i;
1900
1901   if (arg && *arg)
1902     {
1903       while (*arg && isspace(*arg))
1904         arg++;
1905
1906       if (*arg)
1907         addr = parse_and_eval_address (arg);
1908     }
1909   if (!addr)
1910     error_no_arg (_("linear address"));
1911
1912   pdbr = get_cr3 ();
1913   if (!pdbr)
1914     puts_filtered ("Access to Page Tables is not supported on this system.\n");
1915   else
1916     {
1917       int pde_idx = (addr >> 22) & 0x3ff;
1918       int pte_idx = (addr >> 12) & 0x3ff;
1919       unsigned offs = addr & 0xfff;
1920
1921       printf_filtered ("Page Table entry for address 0x%llx:\n",
1922                        (unsigned long long)addr);
1923       display_ptable_entry (get_pte (get_pde (pde_idx), pte_idx), 0, 1, offs);
1924     }
1925 }
1926
1927 static struct cmd_list_element *info_dos_cmdlist = NULL;
1928
1929 static void
1930 go32_info_dos_command (char *args, int from_tty)
1931 {
1932   help_list (info_dos_cmdlist, "info dos ", class_info, gdb_stdout);
1933 }
1934
1935 void
1936 _initialize_go32_nat (void)
1937 {
1938   init_go32_ops ();
1939   add_target (&go32_ops);
1940
1941   add_prefix_cmd ("dos", class_info, go32_info_dos_command, _("\
1942 Print information specific to DJGPP (aka MS-DOS) debugging."),
1943                   &info_dos_cmdlist, "info dos ", 0, &infolist);
1944
1945   add_cmd ("sysinfo", class_info, go32_sysinfo, _("\
1946 Display information about the target system, including CPU, OS, DPMI, etc."),
1947            &info_dos_cmdlist);
1948   add_cmd ("ldt", class_info, go32_sldt, _("\
1949 Display entries in the LDT (Local Descriptor Table).\n\
1950 Entry number (an expression) as an argument means display only that entry."),
1951            &info_dos_cmdlist);
1952   add_cmd ("gdt", class_info, go32_sgdt, _("\
1953 Display entries in the GDT (Global Descriptor Table).\n\
1954 Entry number (an expression) as an argument means display only that entry."),
1955            &info_dos_cmdlist);
1956   add_cmd ("idt", class_info, go32_sidt, _("\
1957 Display entries in the IDT (Interrupt Descriptor Table).\n\
1958 Entry number (an expression) as an argument means display only that entry."),
1959            &info_dos_cmdlist);
1960   add_cmd ("pde", class_info, go32_pde, _("\
1961 Display entries in the Page Directory.\n\
1962 Entry number (an expression) as an argument means display only that entry."),
1963            &info_dos_cmdlist);
1964   add_cmd ("pte", class_info, go32_pte, _("\
1965 Display entries in Page Tables.\n\
1966 Entry number (an expression) as an argument means display only entries\n\
1967 from the Page Table pointed to by the specified Page Directory entry."),
1968            &info_dos_cmdlist);
1969   add_cmd ("address-pte", class_info, go32_pte_for_address, _("\
1970 Display a Page Table entry for a linear address.\n\
1971 The address argument must be a linear address, after adding to\n\
1972 it the base address of the appropriate segment.\n\
1973 The base address of variables and functions in the debuggee's data\n\
1974 or code segment is stored in the variable __djgpp_base_address,\n\
1975 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
1976 For other segments, look up their base address in the output of\n\
1977 the `info dos ldt' command."),
1978            &info_dos_cmdlist);
1979 }
1980
1981 pid_t
1982 tcgetpgrp (int fd)
1983 {
1984   if (isatty (fd))
1985     return SOME_PID;
1986   errno = ENOTTY;
1987   return -1;
1988 }
1989
1990 int
1991 tcsetpgrp (int fd, pid_t pgid)
1992 {
1993   if (isatty (fd) && pgid == SOME_PID)
1994     return 0;
1995   errno = pgid == SOME_PID ? ENOTTY : ENOSYS;
1996   return -1;
1997 }