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