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