gdb/go32-nat.c

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