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