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