gdb/go32-nat.c

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