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