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   static const char test_pattern[] =
 987     "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
 988     "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
 989     "deadbeafdeadbeafdeadbeafdeadbeafdeadbeafdeadbeaf";
 990   struct utsname u;
 991   char cpuid_vendor[13];
 992   unsigned cpuid_max = 0, cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx;
 993   unsigned true_dos_version = _get_dos_version (1);
 994   unsigned advertized_dos_version = ((unsigned int)_osmajor << 8) | _osminor;
 995   int dpmi_flags;
 996   char dpmi_vendor_info[129];
 997   int dpmi_vendor_available;
 998   __dpmi_version_ret dpmi_version_data;
 999   long eflags;
1000   __dpmi_free_mem_info mem_info;
1001   __dpmi_regs regs;
1002
1003   cpuid_vendor[0] = '\0';
1004   if (uname (&u))
1005     strcpy (u.machine, "Unknown x86");
1006   else if (u.machine[0] == 'i' && u.machine[1] > 4)
1007     {
1008       /* CPUID with EAX = 0 returns the Vendor ID.  */
1009       __asm__ __volatile__ ("xorl   %%ebx, %%ebx;"
1010                             "xorl   %%ecx, %%ecx;"
1011                             "xorl   %%edx, %%edx;"
1012                             "movl   $0,    %%eax;"
1013                             "cpuid;"
1014                             "movl   %%ebx,  %0;"
1015                             "movl   %%edx,  %1;"
1016                             "movl   %%ecx,  %2;"
1017                             "movl   %%eax,  %3;"
1018                             : "=m" (cpuid_vendor[0]),
1019                               "=m" (cpuid_vendor[4]),
1020                               "=m" (cpuid_vendor[8]),
1021                               "=m" (cpuid_max)
1022                             :
1023                             : "%eax", "%ebx", "%ecx", "%edx");
1024       cpuid_vendor[12] = '\0';
1025     }
1026
1027   printf_filtered ("CPU Type.......................%s", u.machine);
1028   if (cpuid_vendor[0])
1029     printf_filtered (" (%s)", cpuid_vendor);
1030   puts_filtered ("\n");
1031
1032   /* CPUID with EAX = 1 returns processor signature and features.  */
1033   if (cpuid_max >= 1)
1034     {
1035       static char *brand_name[] = {
1036         "",
1037         " Celeron",
1038         " III",
1039         " III Xeon",
1040         "", "", "", "",
1041         " 4"
1042       };
1043       char cpu_string[80];
1044       char cpu_brand[20];
1045       unsigned brand_idx;
1046       int intel_p = strcmp (cpuid_vendor, "GenuineIntel") == 0;
1047       int amd_p = strcmp (cpuid_vendor, "AuthenticAMD") == 0;
1048       unsigned cpu_family, cpu_model;
1049
1050       __asm__ __volatile__ ("movl   $1, %%eax;"
1051                             "cpuid;"
1052                             : "=a" (cpuid_eax),
1053                               "=b" (cpuid_ebx),
1054                               "=d" (cpuid_edx)
1055                             :
1056                             : "%ecx");
1057       brand_idx = cpuid_ebx & 0xff;
1058       cpu_family = (cpuid_eax >> 8) & 0xf;
1059       cpu_model  = (cpuid_eax >> 4) & 0xf;
1060       cpu_brand[0] = '\0';
1061       if (intel_p)
1062         {
1063           if (brand_idx > 0
1064               && brand_idx < sizeof(brand_name)/sizeof(brand_name[0])
1065               && *brand_name[brand_idx])
1066             strcpy (cpu_brand, brand_name[brand_idx]);
1067           else if (cpu_family == 5)
1068             {
1069               if (((cpuid_eax >> 12) & 3) == 0 && cpu_model == 4)
1070                 strcpy (cpu_brand, " MMX");
1071               else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 1)
1072                 strcpy (cpu_brand, " OverDrive");
1073               else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 2)
1074                 strcpy (cpu_brand, " Dual");
1075             }
1076           else if (cpu_family == 6 && cpu_model < 8)
1077             {
1078               switch (cpu_model)
1079                 {
1080                   case 1:
1081                     strcpy (cpu_brand, " Pro");
1082                     break;
1083                   case 3:
1084                     strcpy (cpu_brand, " II");
1085                     break;
1086                   case 5:
1087                     strcpy (cpu_brand, " II Xeon");
1088                     break;
1089                   case 6:
1090                     strcpy (cpu_brand, " Celeron");
1091                     break;
1092                   case 7:
1093                     strcpy (cpu_brand, " III");
1094                     break;
1095                 }
1096             }
1097         }
1098       else if (amd_p)
1099         {
1100           switch (cpu_family)
1101             {
1102               case 4:
1103                 strcpy (cpu_brand, "486/5x86");
1104                 break;
1105               case 5:
1106                 switch (cpu_model)
1107                   {
1108                     case 0:
1109                     case 1:
1110                     case 2:
1111                     case 3:
1112                       strcpy (cpu_brand, "-K5");
1113                       break;
1114                     case 6:
1115                     case 7:
1116                       strcpy (cpu_brand, "-K6");
1117                       break;
1118                     case 8:
1119                       strcpy (cpu_brand, "-K6-2");
1120                       break;
1121                     case 9:
1122                       strcpy (cpu_brand, "-K6-III");
1123                       break;
1124                   }
1125                 break;
1126               case 6:
1127                 switch (cpu_model)
1128                   {
1129                     case 1:
1130                     case 2:
1131                     case 4:
1132                       strcpy (cpu_brand, " Athlon");
1133                       break;
1134                     case 3:
1135                       strcpy (cpu_brand, " Duron");
1136                       break;
1137                   }
1138                 break;
1139             }
1140         }
1141       sprintf (cpu_string, "%s%s Model %d Stepping %d",
1142                intel_p ? "Pentium" : (amd_p ? "AMD" : "ix86"),
1143                cpu_brand, cpu_model, cpuid_eax & 0xf);
1144       printfi_filtered (31, "%s\n", cpu_string);
1145       if (((cpuid_edx & (6 | (0x0d << 23))) != 0)
1146           || ((cpuid_edx & 1) == 0)
1147           || (amd_p && (cpuid_edx & (3 << 30)) != 0))
1148         {
1149           puts_filtered ("CPU Features...................");
1150           /* We only list features which might be useful in the DPMI
1151              environment.  */
1152           if ((cpuid_edx & 1) == 0)
1153             puts_filtered ("No FPU "); /* it's unusual to not have an FPU */
1154           if ((cpuid_edx & (1 << 1)) != 0)
1155             puts_filtered ("VME ");
1156           if ((cpuid_edx & (1 << 2)) != 0)
1157             puts_filtered ("DE ");
1158           if ((cpuid_edx & (1 << 4)) != 0)
1159             puts_filtered ("TSC ");
1160           if ((cpuid_edx & (1 << 23)) != 0)
1161             puts_filtered ("MMX ");
1162           if ((cpuid_edx & (1 << 25)) != 0)
1163             puts_filtered ("SSE ");
1164           if ((cpuid_edx & (1 << 26)) != 0)
1165             puts_filtered ("SSE2 ");
1166           if (amd_p)
1167             {
1168               if ((cpuid_edx & (1 << 31)) != 0)
1169                 puts_filtered ("3DNow! ");
1170               if ((cpuid_edx & (1 << 30)) != 0)
1171                 puts_filtered ("3DNow!Ext");
1172             }
1173           puts_filtered ("\n");
1174         }
1175     }
1176   puts_filtered ("\n");
1177   printf_filtered ("DOS Version....................%s %s.%s",
1178                    _os_flavor, u.release, u.version);
1179   if (true_dos_version != advertized_dos_version)
1180     printf_filtered (" (disguised as v%d.%d)", _osmajor, _osminor);
1181   puts_filtered ("\n");
1182   if (!windows_major)
1183     go32_get_windows_version ();
1184   if (windows_major != 0xff)
1185     {
1186       const char *windows_flavor;
1187
1188       printf_filtered ("Windows Version................%d.%02d (Windows ",
1189                        windows_major, windows_minor);
1190       switch (windows_major)
1191         {
1192           case 3:
1193             windows_flavor = "3.X";
1194             break;
1195           case 4:
1196             switch (windows_minor)
1197               {
1198                 case 0:
1199                   windows_flavor = "95, 95A, or 95B";
1200                   break;
1201                 case 3:
1202                   windows_flavor = "95B OSR2.1 or 95C OSR2.5";
1203                   break;
1204                 case 10:
1205                   windows_flavor = "98 or 98 SE";
1206                   break;
1207                 case 90:
1208                   windows_flavor = "ME";
1209                   break;
1210                 default:
1211                   windows_flavor = "9X";
1212                   break;
1213               }
1214             break;
1215           default:
1216             windows_flavor = "??";
1217             break;
1218         }
1219       printf_filtered ("%s)\n", windows_flavor);
1220     }
1221   else if (true_dos_version == 0x532 && advertized_dos_version == 0x500)
1222     printf_filtered ("Windows Version................Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
1223   puts_filtered ("\n");
1224   /* On some versions of Windows, __dpmi_get_capabilities returns
1225      zero, but the buffer is not filled with info, so we fill the
1226      buffer with a known pattern and test for it afterwards.  */
1227   memcpy (dpmi_vendor_info, test_pattern, sizeof(dpmi_vendor_info));
1228   dpmi_vendor_available =
1229     __dpmi_get_capabilities (&dpmi_flags, dpmi_vendor_info);
1230   if (dpmi_vendor_available == 0
1231       && memcmp (dpmi_vendor_info, test_pattern,
1232                  sizeof(dpmi_vendor_info)) != 0)
1233     {
1234       /* The DPMI spec says the vendor string should be ASCIIZ, but
1235          I don't trust the vendors to follow that...  */
1236       if (!memchr (&dpmi_vendor_info[2], 0, 126))
1237         dpmi_vendor_info[128] = '\0';
1238       printf_filtered ("DPMI Host......................%s v%d.%d (capabilities: %#x)\n",
1239                        &dpmi_vendor_info[2],
1240                        (unsigned)dpmi_vendor_info[0],
1241                        (unsigned)dpmi_vendor_info[1],
1242                        ((unsigned)dpmi_flags & 0x7f));
1243     }
1244   else
1245     printf_filtered ("DPMI Host......................(Info not available)\n");
1246   __dpmi_get_version (&dpmi_version_data);
1247   printf_filtered ("DPMI Version...................%d.%02d\n",
1248                    dpmi_version_data.major, dpmi_version_data.minor);
1249   printf_filtered ("DPMI Info......................%s-bit DPMI, with%s Virtual Memory support\n",
1250                    (dpmi_version_data.flags & 1) ? "32" : "16",
1251                    (dpmi_version_data.flags & 4) ? "" : "out");
1252   printfi_filtered (31, "Interrupts reflected to %s mode\n",
1253                    (dpmi_version_data.flags & 2) ? "V86" : "Real");
1254   printfi_filtered (31, "Processor type: i%d86\n",
1255                    dpmi_version_data.cpu);
1256   printfi_filtered (31, "PIC base interrupt: Master: %#x  Slave: %#x\n",
1257                    dpmi_version_data.master_pic, dpmi_version_data.slave_pic);
1258
1259   /* a_tss is only initialized when the debuggee is first run.  */
1260   if (prog_has_started)
1261     {
1262       __asm__ __volatile__ ("pushfl ; popl %0" : "=g" (eflags));
1263       printf_filtered ("Protection.....................Ring %d (in %s), with%s I/O protection\n",
1264                        a_tss.tss_cs & 3, (a_tss.tss_cs & 4) ? "LDT" : "GDT",
1265                        (a_tss.tss_cs & 3) > ((eflags >> 12) & 3) ? "" : "out");
1266     }
1267   puts_filtered ("\n");
1268   __dpmi_get_free_memory_information (&mem_info);
1269   print_mem (mem_info.total_number_of_physical_pages,
1270              "DPMI Total Physical Memory.....", 1);
1271   print_mem (mem_info.total_number_of_free_pages,
1272              "DPMI Free Physical Memory......", 1);
1273   print_mem (mem_info.size_of_paging_file_partition_in_pages,
1274              "DPMI Swap Space................", 1);
1275   print_mem (mem_info.linear_address_space_size_in_pages,
1276              "DPMI Total Linear Address Size.", 1);
1277   print_mem (mem_info.free_linear_address_space_in_pages,
1278              "DPMI Free Linear Address Size..", 1);
1279   print_mem (mem_info.largest_available_free_block_in_bytes,
1280              "DPMI Largest Free Memory Block.", 0);
1281
1282   regs.h.ah = 0x48;
1283   regs.x.bx = 0xffff;
1284   __dpmi_int (0x21, &regs);
1285   print_mem (regs.x.bx << 4, "Free DOS Memory................", 0);
1286   regs.x.ax = 0x5800;
1287   __dpmi_int (0x21, &regs);
1288   if ((regs.x.flags & 1) == 0)
1289     {
1290       static const char *dos_hilo[] = {
1291         "Low", "", "", "", "High", "", "", "", "High, then Low"
1292       };
1293       static const char *dos_fit[] = {
1294         "First", "Best", "Last"
1295       };
1296       int hilo_idx = (regs.x.ax >> 4) & 0x0f;
1297       int fit_idx  = regs.x.ax & 0x0f;
1298
1299       if (hilo_idx > 8)
1300         hilo_idx = 0;
1301       if (fit_idx > 2)
1302         fit_idx = 0;
1303       printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1304                        dos_hilo[hilo_idx], dos_fit[fit_idx]);
1305       regs.x.ax = 0x5802;
1306       __dpmi_int (0x21, &regs);
1307       if ((regs.x.flags & 1) != 0)
1308         regs.h.al = 0;
1309       printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1310                         regs.h.al == 0 ? "not " : "");
1311     }
1312 }
1313
1314 struct seg_descr {
1315   unsigned short limit0;
1316   unsigned short base0;
1317   unsigned char  base1;
1318   unsigned       stype:5;
1319   unsigned       dpl:2;
1320   unsigned       present:1;
1321   unsigned       limit1:4;
1322   unsigned       available:1;
1323   unsigned       dummy:1;
1324   unsigned       bit32:1;
1325   unsigned       page_granular:1;
1326   unsigned char  base2;
1327 } __attribute__ ((packed));
1328
1329 struct gate_descr {
1330   unsigned short offset0;
1331   unsigned short selector;
1332   unsigned       param_count:5;
1333   unsigned       dummy:3;
1334   unsigned       stype:5;
1335   unsigned       dpl:2;
1336   unsigned       present:1;
1337   unsigned short offset1;
1338 } __attribute__ ((packed));
1339
1340 /* Read LEN bytes starting at logical address ADDR, and put the result
1341    into DEST.  Return 1 if success, zero if not.  */
1342 static int
1343 read_memory_region (unsigned long addr, void *dest, size_t len)
1344 {
1345   unsigned long dos_ds_limit = __dpmi_get_segment_limit (_dos_ds);
1346   int retval = 1;
1347
1348   /* For the low memory, we can simply use _dos_ds.  */
1349   if (addr <= dos_ds_limit - len)
1350     dosmemget (addr, len, dest);
1351   else
1352     {
1353       /* For memory above 1MB we need to set up a special segment to
1354          be able to access that memory.  */
1355       int sel = __dpmi_allocate_ldt_descriptors (1);
1356
1357       if (sel <= 0)
1358         retval = 0;
1359       else
1360         {
1361           int access_rights = __dpmi_get_descriptor_access_rights (sel);
1362           size_t segment_limit = len - 1;
1363
1364           /* Make sure the crucial bits in the descriptor access
1365              rights are set correctly.  Some DPMI providers might barf
1366              if we set the segment limit to something that is not an
1367              integral multiple of 4KB pages if the granularity bit is
1368              not set to byte-granular, even though the DPMI spec says
1369              it's the host's responsibility to set that bit correctly.  */
1370           if (len > 1024 * 1024)
1371             {
1372               access_rights |= 0x8000;
1373               /* Page-granular segments should have the low 12 bits of
1374                  the limit set.  */
1375               segment_limit |= 0xfff;
1376             }
1377           else
1378             access_rights &= ~0x8000;
1379
1380           if (__dpmi_set_segment_base_address (sel, addr) != -1
1381               && __dpmi_set_descriptor_access_rights (sel, access_rights) != -1
1382               && __dpmi_set_segment_limit (sel, segment_limit) != -1
1383               /* W2K silently fails to set the segment limit, leaving
1384                  it at zero; this test avoids the resulting crash.  */
1385               && __dpmi_get_segment_limit (sel) >= segment_limit)
1386             movedata (sel, 0, _my_ds (), (unsigned)dest, len);
1387           else
1388             retval = 0;
1389
1390           __dpmi_free_ldt_descriptor (sel);
1391         }
1392     }
1393   return retval;
1394 }
1395
1396 /* Get a segment descriptor stored at index IDX in the descriptor
1397    table whose base address is TABLE_BASE.  Return the descriptor
1398    type, or -1 if failure.  */
1399 static int
1400 get_descriptor (unsigned long table_base, int idx, void *descr)
1401 {
1402   unsigned long addr = table_base + idx * 8; /* 8 bytes per entry */
1403
1404   if (read_memory_region (addr, descr, 8))
1405     return (int)((struct seg_descr *)descr)->stype;
1406   return -1;
1407 }
1408
1409 struct dtr_reg {
1410   unsigned short limit __attribute__((packed));
1411   unsigned long  base  __attribute__((packed));
1412 };
1413
1414 /* Display a segment descriptor stored at index IDX in a descriptor
1415    table whose type is TYPE and whose base address is BASE_ADDR.  If
1416    FORCE is non-zero, display even invalid descriptors.  */
1417 static void
1418 display_descriptor (unsigned type, unsigned long base_addr, int idx, int force)
1419 {
1420   struct seg_descr descr;
1421   struct gate_descr gate;
1422
1423   /* Get the descriptor from the table.  */
1424   if (idx == 0 && type == 0)
1425     puts_filtered ("0x000: null descriptor\n");
1426   else if (get_descriptor (base_addr, idx, &descr) != -1)
1427     {
1428       /* For each type of descriptor table, this has a bit set if the
1429          corresponding type of selectors is valid in that table.  */
1430       static unsigned allowed_descriptors[] = {
1431           0xffffdafeL,   /* GDT */
1432           0x0000c0e0L,   /* IDT */
1433           0xffffdafaL    /* LDT */
1434       };
1435
1436       /* If the program hasn't started yet, assume the debuggee will
1437          have the same CPL as the debugger.  */
1438       int cpl = prog_has_started ? (a_tss.tss_cs & 3) : _my_cs () & 3;
1439       unsigned long limit = (descr.limit1 << 16) | descr.limit0;
1440
1441       if (descr.present
1442           && (allowed_descriptors[type] & (1 << descr.stype)) != 0)
1443         {
1444           printf_filtered ("0x%03x: ",
1445                            type == 1
1446                            ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1447           if (descr.page_granular)
1448             limit = (limit << 12) | 0xfff; /* big segment: low 12 bit set */
1449           if (descr.stype == 1 || descr.stype == 2 || descr.stype == 3
1450               || descr.stype == 9 || descr.stype == 11
1451               || (descr.stype >= 16 && descr.stype < 32))
1452             printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1453                              descr.base2, descr.base1, descr.base0, limit);
1454
1455           switch (descr.stype)
1456             {
1457               case 1:
1458               case 3:
1459                 printf_filtered (" 16-bit TSS  (task %sactive)",
1460                                  descr.stype == 3 ? "" : "in");
1461                 break;
1462               case 2:
1463                 puts_filtered (" LDT");
1464                 break;
1465               case 4:
1466                 memcpy (&gate, &descr, sizeof gate);
1467                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1468                                  gate.selector, gate.offset1, gate.offset0);
1469                 printf_filtered (" 16-bit Call Gate (params=%d)",
1470                                  gate.param_count);
1471                 break;
1472               case 5:
1473                 printf_filtered ("TSS selector=0x%04x", descr.base0);
1474                 printfi_filtered (16, "Task Gate");
1475                 break;
1476               case 6:
1477               case 7:
1478                 memcpy (&gate, &descr, sizeof gate);
1479                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1480                                  gate.selector, gate.offset1, gate.offset0);
1481                 printf_filtered (" 16-bit %s Gate",
1482                                  descr.stype == 6 ? "Interrupt" : "Trap");
1483                 break;
1484               case 9:
1485               case 11:
1486                 printf_filtered (" 32-bit TSS (task %sactive)",
1487                                  descr.stype == 3 ? "" : "in");
1488                 break;
1489               case 12:
1490                 memcpy (&gate, &descr, sizeof gate);
1491                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1492                                  gate.selector, gate.offset1, gate.offset0);
1493                 printf_filtered (" 32-bit Call Gate (params=%d)",
1494                                  gate.param_count);
1495                 break;
1496               case 14:
1497               case 15:
1498                 memcpy (&gate, &descr, sizeof gate);
1499                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1500                                  gate.selector, gate.offset1, gate.offset0);
1501                 printf_filtered (" 32-bit %s Gate",
1502                                  descr.stype == 14 ? "Interrupt" : "Trap");
1503                 break;
1504               case 16:          /* data segments */
1505               case 17:
1506               case 18:
1507               case 19:
1508               case 20:
1509               case 21:
1510               case 22:
1511               case 23:
1512                 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1513                                  descr.bit32 ? "32" : "16",
1514                                  descr.stype & 2 ? "Read/Write," : "Read-Only, ",
1515                                  descr.stype & 4 ? "down" : "up",
1516                                  descr.stype & 1 ? "" : ", N.Acc");
1517                 break;
1518               case 24:          /* code segments */
1519               case 25:
1520               case 26:
1521               case 27:
1522               case 28:
1523               case 29:
1524               case 30:
1525               case 31:
1526                 printf_filtered (" %s-bit Code (%s,  %sConf%s)",
1527                                  descr.bit32 ? "32" : "16",
1528                                  descr.stype & 2 ? "Exec/Read" : "Exec-Only",
1529                                  descr.stype & 4 ? "" : "N.",
1530                                  descr.stype & 1 ? "" : ", N.Acc");
1531                 break;
1532               default:
1533                 printf_filtered ("Unknown type 0x%02x", descr.stype);
1534                 break;
1535             }
1536           puts_filtered ("\n");
1537         }
1538       else if (force)
1539         {
1540           printf_filtered ("0x%03x: ",
1541                            type == 1
1542                            ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1543           if (!descr.present)
1544             puts_filtered ("Segment not present\n");
1545           else
1546             printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1547                              descr.stype);
1548         }
1549     }
1550   else if (force)
1551     printf_filtered ("0x%03x: Cannot read this descriptor\n", idx);
1552 }
1553
1554 static void
1555 go32_sldt (char *arg, int from_tty)
1556 {
1557   struct dtr_reg gdtr;
1558   unsigned short ldtr = 0;
1559   int ldt_idx;
1560   struct seg_descr ldt_descr;
1561   long ldt_entry = -1L;
1562   int cpl = (prog_has_started ? a_tss.tss_cs : _my_cs ()) & 3;
1563
1564   if (arg && *arg)
1565     {
1566       while (*arg && isspace(*arg))
1567         arg++;
1568
1569       if (*arg)
1570         {
1571           ldt_entry = parse_and_eval_long (arg);
1572           if (ldt_entry < 0
1573               || (ldt_entry & 4) == 0
1574               || (ldt_entry & 3) != (cpl & 3))
1575             error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry);
1576         }
1577     }
1578
1579   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
1580   __asm__ __volatile__ ("sldt   %0" : "=m" (ldtr) : /* no inputs */ );
1581   ldt_idx = ldtr / 8;
1582   if (ldt_idx == 0)
1583     puts_filtered ("There is no LDT.\n");
1584   /* LDT's entry in the GDT must have the type LDT, which is 2.  */
1585   else if (get_descriptor (gdtr.base, ldt_idx, &ldt_descr) != 2)
1586     printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1587                      ldt_descr.base0
1588                      | (ldt_descr.base1 << 16)
1589                      | (ldt_descr.base2 << 24));
1590   else
1591     {
1592       unsigned base =
1593         ldt_descr.base0
1594         | (ldt_descr.base1 << 16)
1595         | (ldt_descr.base2 << 24);
1596       unsigned limit = ldt_descr.limit0 | (ldt_descr.limit1 << 16);
1597       int max_entry;
1598
1599       if (ldt_descr.page_granular)
1600         /* Page-granular segments must have the low 12 bits of their
1601            limit set.  */
1602         limit = (limit << 12) | 0xfff;
1603       /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1604          64KB.  */
1605       if (limit > 0xffff)
1606         limit = 0xffff;
1607
1608       max_entry = (limit + 1) / 8;
1609
1610       if (ldt_entry >= 0)
1611         {
1612           if (ldt_entry > limit)
1613             error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1614                    (unsigned long)ldt_entry, limit);
1615
1616           display_descriptor (ldt_descr.stype, base, ldt_entry / 8, 1);
1617         }
1618       else
1619         {
1620           int i;
1621
1622           for (i = 0; i < max_entry; i++)
1623             display_descriptor (ldt_descr.stype, base, i, 0);
1624         }
1625     }
1626 }
1627
1628 static void
1629 go32_sgdt (char *arg, int from_tty)
1630 {
1631   struct dtr_reg gdtr;
1632   long gdt_entry = -1L;
1633   int max_entry;
1634
1635   if (arg && *arg)
1636     {
1637       while (*arg && isspace(*arg))
1638         arg++;
1639
1640       if (*arg)
1641         {
1642           gdt_entry = parse_and_eval_long (arg);
1643           if (gdt_entry < 0 || (gdt_entry & 7) != 0)
1644             error (_("Invalid GDT entry 0x%03lx: not an integral multiple of 8."),
1645                    (unsigned long)gdt_entry);
1646         }
1647     }
1648
1649   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
1650   max_entry = (gdtr.limit + 1) / 8;
1651
1652   if (gdt_entry >= 0)
1653     {
1654       if (gdt_entry > gdtr.limit)
1655         error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1656                (unsigned long)gdt_entry, gdtr.limit);
1657
1658       display_descriptor (0, gdtr.base, gdt_entry / 8, 1);
1659     }
1660   else
1661     {
1662       int i;
1663
1664       for (i = 0; i < max_entry; i++)
1665         display_descriptor (0, gdtr.base, i, 0);
1666     }
1667 }
1668
1669 static void
1670 go32_sidt (char *arg, int from_tty)
1671 {
1672   struct dtr_reg idtr;
1673   long idt_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           idt_entry = parse_and_eval_long (arg);
1684           if (idt_entry < 0)
1685             error (_("Invalid (negative) IDT entry %ld."), idt_entry);
1686         }
1687     }
1688
1689   __asm__ __volatile__ ("sidt   %0" : "=m" (idtr) : /* no inputs */ );
1690   max_entry = (idtr.limit + 1) / 8;
1691   if (max_entry > 0x100)        /* no more than 256 entries */
1692     max_entry = 0x100;
1693
1694   if (idt_entry >= 0)
1695     {
1696       if (idt_entry > idtr.limit)
1697         error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1698                (unsigned long)idt_entry, idtr.limit);
1699
1700       display_descriptor (1, idtr.base, idt_entry, 1);
1701     }
1702   else
1703     {
1704       int i;
1705
1706       for (i = 0; i < max_entry; i++)
1707         display_descriptor (1, idtr.base, i, 0);
1708     }
1709 }
1710
1711 /* Cached linear address of the base of the page directory.  For
1712    now, available only under CWSDPMI.  Code based on ideas and
1713    suggestions from Charles Sandmann <sandmann@clio.rice.edu>.  */
1714 static unsigned long pdbr;
1715
1716 static unsigned long
1717 get_cr3 (void)
1718 {
1719   unsigned offset;
1720   unsigned taskreg;
1721   unsigned long taskbase, cr3;
1722   struct dtr_reg gdtr;
1723
1724   if (pdbr > 0 && pdbr <= 0xfffff)
1725     return pdbr;
1726
1727   /* Get the linear address of GDT and the Task Register.  */
1728   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
1729   __asm__ __volatile__ ("str    %0" : "=m" (taskreg) : /* no inputs */ );
1730
1731   /* Task Register is a segment selector for the TSS of the current
1732      task.  Therefore, it can be used as an index into the GDT to get
1733      at the segment descriptor for the TSS.  To get the index, reset
1734      the low 3 bits of the selector (which give the CPL).  Add 2 to the
1735      offset to point to the 3 low bytes of the base address.  */
1736   offset = gdtr.base + (taskreg & 0xfff8) + 2;
1737
1738
1739   /* CWSDPMI's task base is always under the 1MB mark.  */
1740   if (offset > 0xfffff)
1741     return 0;
1742
1743   _farsetsel (_dos_ds);
1744   taskbase  = _farnspeekl (offset) & 0xffffffU;
1745   taskbase += _farnspeekl (offset + 2) & 0xff000000U;
1746   if (taskbase > 0xfffff)
1747     return 0;
1748
1749   /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1750      offset 1Ch in the TSS.  */
1751   cr3 = _farnspeekl (taskbase + 0x1c) & ~0xfff;
1752   if (cr3 > 0xfffff)
1753     {
1754 #if 0  /* not fullly supported yet */
1755       /* The Page Directory is in UMBs.  In that case, CWSDPMI puts
1756          the first Page Table right below the Page Directory.  Thus,
1757          the first Page Table's entry for its own address and the Page
1758          Directory entry for that Page Table will hold the same
1759          physical address.  The loop below searches the entire UMB
1760          range of addresses for such an occurence.  */
1761       unsigned long addr, pte_idx;
1762
1763       for (addr = 0xb0000, pte_idx = 0xb0;
1764            pte_idx < 0xff;
1765            addr += 0x1000, pte_idx++)
1766         {
1767           if (((_farnspeekl (addr + 4 * pte_idx) & 0xfffff027) ==
1768                (_farnspeekl (addr + 0x1000) & 0xfffff027))
1769               && ((_farnspeekl (addr + 4 * pte_idx + 4) & 0xfffff000) == cr3))
1770             {
1771               cr3 = addr + 0x1000;
1772               break;
1773             }
1774         }
1775 #endif
1776
1777       if (cr3 > 0xfffff)
1778         cr3 = 0;
1779     }
1780
1781   return cr3;
1782 }
1783
1784 /* Return the N'th Page Directory entry.  */
1785 static unsigned long
1786 get_pde (int n)
1787 {
1788   unsigned long pde = 0;
1789
1790   if (pdbr && n >= 0 && n < 1024)
1791     {
1792       pde = _farpeekl (_dos_ds, pdbr + 4*n);
1793     }
1794   return pde;
1795 }
1796
1797 /* Return the N'th entry of the Page Table whose Page Directory entry
1798    is PDE.  */
1799 static unsigned long
1800 get_pte (unsigned long pde, int n)
1801 {
1802   unsigned long pte = 0;
1803
1804   /* pde & 0x80 tests the 4MB page bit.  We don't support 4MB
1805      page tables, for now.  */
1806   if ((pde & 1) && !(pde & 0x80) && n >= 0 && n < 1024)
1807     {
1808       pde &= ~0xfff;    /* clear non-address bits */
1809       pte = _farpeekl (_dos_ds, pde + 4*n);
1810     }
1811   return pte;
1812 }
1813
1814 /* Display a Page Directory or Page Table entry.  IS_DIR, if non-zero,
1815    says this is a Page Directory entry.  If FORCE is non-zero, display
1816    the entry even if its Present flag is off.  OFF is the offset of the
1817    address from the page's base address.  */
1818 static void
1819 display_ptable_entry (unsigned long entry, int is_dir, int force, unsigned off)
1820 {
1821   if ((entry & 1) != 0)
1822     {
1823       printf_filtered ("Base=0x%05lx000", entry >> 12);
1824       if ((entry & 0x100) && !is_dir)
1825         puts_filtered (" Global");
1826       if ((entry & 0x40) && !is_dir)
1827         puts_filtered (" Dirty");
1828       printf_filtered (" %sAcc.", (entry & 0x20) ? "" : "Not-");
1829       printf_filtered (" %sCached", (entry & 0x10) ? "" : "Not-");
1830       printf_filtered (" Write-%s", (entry & 8) ? "Thru" : "Back");
1831       printf_filtered (" %s", (entry & 4) ? "Usr" : "Sup");
1832       printf_filtered (" Read-%s", (entry & 2) ? "Write" : "Only");
1833       if (off)
1834         printf_filtered (" +0x%x", off);
1835       puts_filtered ("\n");
1836     }
1837   else if (force)
1838     printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1839                      is_dir ? " Table" : "", entry >> 1);
1840 }
1841
1842 static void
1843 go32_pde (char *arg, int from_tty)
1844 {
1845   long pde_idx = -1, i;
1846
1847   if (arg && *arg)
1848     {
1849       while (*arg && isspace(*arg))
1850         arg++;
1851
1852       if (*arg)
1853         {
1854           pde_idx = parse_and_eval_long (arg);
1855           if (pde_idx < 0 || pde_idx >= 1024)
1856             error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
1857         }
1858     }
1859
1860   pdbr = get_cr3 ();
1861   if (!pdbr)
1862     puts_filtered ("Access to Page Directories is not supported on this system.\n");
1863   else if (pde_idx >= 0)
1864     display_ptable_entry (get_pde (pde_idx), 1, 1, 0);
1865   else
1866     for (i = 0; i < 1024; i++)
1867       display_ptable_entry (get_pde (i), 1, 0, 0);
1868 }
1869
1870 /* A helper function to display entries in a Page Table pointed to by
1871    the N'th entry in the Page Directory.  If FORCE is non-zero, say
1872    something even if the Page Table is not accessible.  */
1873 static void
1874 display_page_table (long n, int force)
1875 {
1876   unsigned long pde = get_pde (n);
1877
1878   if ((pde & 1) != 0)
1879     {
1880       int i;
1881
1882       printf_filtered ("Page Table pointed to by Page Directory entry 0x%lx:\n", n);
1883       for (i = 0; i < 1024; i++)
1884         display_ptable_entry (get_pte (pde, i), 0, 0, 0);
1885       puts_filtered ("\n");
1886     }
1887   else if (force)
1888     printf_filtered ("Page Table not present; value=0x%lx.\n", pde >> 1);
1889 }
1890
1891 static void
1892 go32_pte (char *arg, int from_tty)
1893 {
1894   long pde_idx = -1L, i;
1895
1896   if (arg && *arg)
1897     {
1898       while (*arg && isspace(*arg))
1899         arg++;
1900
1901       if (*arg)
1902         {
1903           pde_idx = parse_and_eval_long (arg);
1904           if (pde_idx < 0 || pde_idx >= 1024)
1905             error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
1906         }
1907     }
1908
1909   pdbr = get_cr3 ();
1910   if (!pdbr)
1911     puts_filtered ("Access to Page Tables is not supported on this system.\n");
1912   else if (pde_idx >= 0)
1913     display_page_table (pde_idx, 1);
1914   else
1915     for (i = 0; i < 1024; i++)
1916       display_page_table (i, 0);
1917 }
1918
1919 static void
1920 go32_pte_for_address (char *arg, int from_tty)
1921 {
1922   CORE_ADDR addr = 0, i;
1923
1924   if (arg && *arg)
1925     {
1926       while (*arg && isspace(*arg))
1927         arg++;
1928
1929       if (*arg)
1930         addr = parse_and_eval_address (arg);
1931     }
1932   if (!addr)
1933     error_no_arg (_("linear address"));
1934
1935   pdbr = get_cr3 ();
1936   if (!pdbr)
1937     puts_filtered ("Access to Page Tables is not supported on this system.\n");
1938   else
1939     {
1940       int pde_idx = (addr >> 22) & 0x3ff;
1941       int pte_idx = (addr >> 12) & 0x3ff;
1942       unsigned offs = addr & 0xfff;
1943
1944       printf_filtered ("Page Table entry for address 0x%llx:\n",
1945                        (unsigned long long)addr);
1946       display_ptable_entry (get_pte (get_pde (pde_idx), pte_idx), 0, 1, offs);
1947     }
1948 }
1949
1950 static struct cmd_list_element *info_dos_cmdlist = NULL;
1951
1952 static void
1953 go32_info_dos_command (char *args, int from_tty)
1954 {
1955   help_list (info_dos_cmdlist, "info dos ", class_info, gdb_stdout);
1956 }
1957
1958 void
1959 _initialize_go32_nat (void)
1960 {
1961   init_go32_ops ();
1962   add_target (&go32_ops);
1963
1964   add_prefix_cmd ("dos", class_info, go32_info_dos_command, _("\
1965 Print information specific to DJGPP (aka MS-DOS) debugging."),
1966                   &info_dos_cmdlist, "info dos ", 0, &infolist);
1967
1968   add_cmd ("sysinfo", class_info, go32_sysinfo, _("\
1969 Display information about the target system, including CPU, OS, DPMI, etc."),
1970            &info_dos_cmdlist);
1971   add_cmd ("ldt", class_info, go32_sldt, _("\
1972 Display entries in the LDT (Local Descriptor Table).\n\
1973 Entry number (an expression) as an argument means display only that entry."),
1974            &info_dos_cmdlist);
1975   add_cmd ("gdt", class_info, go32_sgdt, _("\
1976 Display entries in the GDT (Global Descriptor Table).\n\
1977 Entry number (an expression) as an argument means display only that entry."),
1978            &info_dos_cmdlist);
1979   add_cmd ("idt", class_info, go32_sidt, _("\
1980 Display entries in the IDT (Interrupt Descriptor Table).\n\
1981 Entry number (an expression) as an argument means display only that entry."),
1982            &info_dos_cmdlist);
1983   add_cmd ("pde", class_info, go32_pde, _("\
1984 Display entries in the Page Directory.\n\
1985 Entry number (an expression) as an argument means display only that entry."),
1986            &info_dos_cmdlist);
1987   add_cmd ("pte", class_info, go32_pte, _("\
1988 Display entries in Page Tables.\n\
1989 Entry number (an expression) as an argument means display only entries\n\
1990 from the Page Table pointed to by the specified Page Directory entry."),
1991            &info_dos_cmdlist);
1992   add_cmd ("address-pte", class_info, go32_pte_for_address, _("\
1993 Display a Page Table entry for a linear address.\n\
1994 The address argument must be a linear address, after adding to\n\
1995 it the base address of the appropriate segment.\n\
1996 The base address of variables and functions in the debuggee's data\n\
1997 or code segment is stored in the variable __djgpp_base_address,\n\
1998 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
1999 For other segments, look up their base address in the output of\n\
2000 the `info dos ldt' command."),
2001            &info_dos_cmdlist);
2002 }
2003
2004 pid_t
2005 tcgetpgrp (int fd)
2006 {
2007   if (isatty (fd))
2008     return SOME_PID;
2009   errno = ENOTTY;
2010   return -1;
2011 }
2012
2013 int
2014 tcsetpgrp (int fd, pid_t pgid)
2015 {
2016   if (isatty (fd) && pgid == SOME_PID)
2017     return 0;
2018   errno = pgid == SOME_PID ? ENOTTY : ENOSYS;
2019   return -1;
2020 }