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             movedata (sel, 0, _my_ds (), (unsigned)dest, len);
1336           else
1337             retval = 0;
1338
1339           __dpmi_free_ldt_descriptor (sel);
1340         }
1341     }
1342   return retval;
1343 }
1344
1345 /* Get a segment descriptor stored at index IDX in the descriptor
1346    table whose base address is TABLE_BASE.  Return the descriptor
1347    type, or -1 if failure.  */
1348 static int
1349 get_descriptor (unsigned long table_base, int idx, void *descr)
1350 {
1351   unsigned long addr = table_base + idx * 8; /* 8 bytes per entry */
1352
1353   if (read_memory_region (addr, descr, 8))
1354     return (int)((struct seg_descr *)descr)->stype;
1355   return -1;
1356 }
1357
1358 struct dtr_reg {
1359   unsigned short limit __attribute__((packed));
1360   unsigned long  base  __attribute__((packed));
1361 };
1362
1363 /* Display a segment descriptor stored at index IDX in a descriptor
1364    table whose type is TYPE and whose base address is BASE_ADDR.  If
1365    FORCE is non-zero, display even invalid descriptors.  */
1366 static void
1367 display_descriptor (unsigned type, unsigned long base_addr, int idx, int force)
1368 {
1369   struct seg_descr descr;
1370   struct gate_descr gate;
1371
1372   /* Get the descriptor from the table.  */
1373   if (idx == 0 && type == 0)
1374     puts_filtered ("0x000: null descriptor\n");
1375   else if (get_descriptor (base_addr, idx, &descr) != -1)
1376     {
1377       /* For each type of descriptor table, this has a bit set if the
1378          corresponding type of selectors is valid in that table.  */
1379       static unsigned allowed_descriptors[] = {
1380           0xffffdafeL,   /* GDT */
1381           0x0000c0e0L,   /* IDT */
1382           0xffffdafaL    /* LDT */
1383       };
1384
1385       /* If the program hasn't started yet, assume the debuggee will
1386          have the same CPL as the debugger.  */
1387       int cpl = prog_has_started ? (a_tss.tss_cs & 3) : _my_cs () & 3;
1388       unsigned long limit = (descr.limit1 << 16) | descr.limit0;
1389
1390       if (descr.present
1391           && (allowed_descriptors[type] & (1 << descr.stype)) != 0)
1392         {
1393           printf_filtered ("0x%03x: ",
1394                            type == 1
1395                            ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1396           if (descr.page_granular)
1397             limit = (limit << 12) | 0xfff; /* big segment: low 12 bit set */
1398           if (descr.stype == 1 || descr.stype == 2 || descr.stype == 3
1399               || descr.stype == 9 || descr.stype == 11
1400               || (descr.stype >= 16 && descr.stype < 32))
1401             printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1402                              descr.base2, descr.base1, descr.base0, limit);
1403
1404           switch (descr.stype)
1405             {
1406               case 1:
1407               case 3:
1408                 printf_filtered (" 16-bit TSS  (task %sactive)",
1409                                  descr.stype == 3 ? "" : "in");
1410                 break;
1411               case 2:
1412                 puts_filtered (" LDT");
1413                 break;
1414               case 4:
1415                 memcpy (&gate, &descr, sizeof gate);
1416                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1417                                  gate.selector, gate.offset1, gate.offset0);
1418                 printf_filtered (" 16-bit Call Gate (params=%d)",
1419                                  gate.param_count);
1420                 break;
1421               case 5:
1422                 printf_filtered ("TSS selector=0x%04x", descr.base0);
1423                 printfi_filtered (16, "Task Gate");
1424                 break;
1425               case 6:
1426               case 7:
1427                 memcpy (&gate, &descr, sizeof gate);
1428                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1429                                  gate.selector, gate.offset1, gate.offset0);
1430                 printf_filtered (" 16-bit %s Gate",
1431                                  descr.stype == 6 ? "Interrupt" : "Trap");
1432                 break;
1433               case 9:
1434               case 11:
1435                 printf_filtered (" 32-bit TSS (task %sactive)",
1436                                  descr.stype == 3 ? "" : "in");
1437                 break;
1438               case 12:
1439                 memcpy (&gate, &descr, sizeof gate);
1440                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1441                                  gate.selector, gate.offset1, gate.offset0);
1442                 printf_filtered (" 32-bit Call Gate (params=%d)",
1443                                  gate.param_count);
1444                 break;
1445               case 14:
1446               case 15:
1447                 memcpy (&gate, &descr, sizeof gate);
1448                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1449                                  gate.selector, gate.offset1, gate.offset0);
1450                 printf_filtered (" 32-bit %s Gate",
1451                                  descr.stype == 14 ? "Interrupt" : "Trap");
1452                 break;
1453               case 16:          /* data segments */
1454               case 17:
1455               case 18:
1456               case 19:
1457               case 20:
1458               case 21:
1459               case 22:
1460               case 23:
1461                 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1462                                  descr.bit32 ? "32" : "16",
1463                                  descr.stype & 2 ? "Read/Write," : "Read-Only, ",
1464                                  descr.stype & 4 ? "down" : "up",
1465                                  descr.stype & 1 ? "" : ", N.Acc");
1466                 break;
1467               case 24:          /* code segments */
1468               case 25:
1469               case 26:
1470               case 27:
1471               case 28:
1472               case 29:
1473               case 30:
1474               case 31:
1475                 printf_filtered (" %s-bit Code (%s,  %sConf%s)",
1476                                  descr.bit32 ? "32" : "16",
1477                                  descr.stype & 2 ? "Exec/Read" : "Exec-Only",
1478                                  descr.stype & 4 ? "" : "N.",
1479                                  descr.stype & 1 ? "" : ", N.Acc");
1480                 break;
1481               default:
1482                 printf_filtered ("Unknown type 0x%02x", descr.stype);
1483                 break;
1484             }
1485           puts_filtered ("\n");
1486         }
1487       else if (force)
1488         {
1489           printf_filtered ("0x%03x: ",
1490                            type == 1
1491                            ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1492           if (!descr.present)
1493             puts_filtered ("Segment not present\n");
1494           else
1495             printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1496                              descr.stype);
1497         }
1498     }
1499   else if (force)
1500     printf_filtered ("0x%03x: Cannot read this descriptor\n", idx);
1501 }
1502
1503 static void
1504 go32_sldt (char *arg, int from_tty)
1505 {
1506   struct dtr_reg gdtr;
1507   unsigned short ldtr = 0;
1508   int ldt_idx;
1509   struct seg_descr ldt_descr;
1510   long ldt_entry = -1L;
1511   int cpl = (prog_has_started ? a_tss.tss_cs : _my_cs ()) & 3;
1512
1513   if (arg && *arg)
1514     {
1515       while (*arg && isspace(*arg))
1516         arg++;
1517
1518       if (*arg)
1519         {
1520           ldt_entry = parse_and_eval_long (arg);
1521           if (ldt_entry < 0
1522               || (ldt_entry & 4) == 0
1523               || (ldt_entry & 3) != (cpl & 3))
1524             error ("Invalid LDT entry 0x%03x.", ldt_entry);
1525         }
1526     }
1527
1528   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
1529   __asm__ __volatile__ ("sldt   %0" : "=m" (ldtr) : /* no inputs */ );
1530   ldt_idx = ldtr / 8;
1531   if (ldt_idx == 0)
1532     puts_filtered ("There is no LDT.\n");
1533   /* LDT's entry in the GDT must have the type LDT, which is 2.  */
1534   else if (get_descriptor (gdtr.base, ldt_idx, &ldt_descr) != 2)
1535     printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1536                      ldt_descr.base0
1537                      | (ldt_descr.base1 << 16)
1538                      | (ldt_descr.base2 << 24));
1539   else
1540     {
1541       unsigned base =
1542         ldt_descr.base0
1543         | (ldt_descr.base1 << 16)
1544         | (ldt_descr.base2 << 24);
1545       unsigned limit = ldt_descr.limit0 | (ldt_descr.limit1 << 16);
1546       int max_entry;
1547
1548       if (ldt_descr.page_granular)
1549         /* Page-granular segments must have the low 12 bits of their
1550            limit set.  */
1551         limit = (limit << 12) | 0xfff;
1552       /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1553          64KB.  */
1554       if (limit > 0xffff)
1555         limit = 0xffff;
1556
1557       max_entry = (limit + 1) / 8;
1558
1559       if (ldt_entry >= 0)
1560         {
1561           if (ldt_entry > limit)
1562             error ("Invalid LDT entry %#x: outside valid limits [0..%#x]",
1563                    ldt_entry, limit);
1564
1565           display_descriptor (ldt_descr.stype, base, ldt_entry / 8, 1);
1566         }
1567       else
1568         {
1569           int i;
1570
1571           for (i = 0; i < max_entry; i++)
1572             display_descriptor (ldt_descr.stype, base, i, 0);
1573         }
1574     }
1575 }
1576
1577 static void
1578 go32_sgdt (char *arg, int from_tty)
1579 {
1580   struct dtr_reg gdtr;
1581   long gdt_entry = -1L;
1582   int max_entry;
1583
1584   if (arg && *arg)
1585     {
1586       while (*arg && isspace(*arg))
1587         arg++;
1588
1589       if (*arg)
1590         {
1591           gdt_entry = parse_and_eval_long (arg);
1592           if (gdt_entry < 0 || (gdt_entry & 7) != 0)
1593             error ("Invalid GDT entry 0x%03x: not an integral multiple of 8.",
1594                    gdt_entry);
1595         }
1596     }
1597
1598   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
1599   max_entry = (gdtr.limit + 1) / 8;
1600
1601   if (gdt_entry >= 0)
1602     {
1603       if (gdt_entry > gdtr.limit)
1604         error ("Invalid GDT entry %#x: outside valid limits [0..%#x]",
1605                gdt_entry, gdtr.limit);
1606
1607       display_descriptor (0, gdtr.base, gdt_entry / 8, 1);
1608     }
1609   else
1610     {
1611       int i;
1612
1613       for (i = 0; i < max_entry; i++)
1614         display_descriptor (0, gdtr.base, i, 0);
1615     }
1616 }
1617
1618 static void
1619 go32_sidt (char *arg, int from_tty)
1620 {
1621   struct dtr_reg idtr;
1622   long idt_entry = -1L;
1623   int max_entry;
1624
1625   if (arg && *arg)
1626     {
1627       while (*arg && isspace(*arg))
1628         arg++;
1629
1630       if (*arg)
1631         {
1632           idt_entry = parse_and_eval_long (arg);
1633           if (idt_entry < 0)
1634             error ("Invalid (negative) IDT entry %d.", idt_entry);
1635         }
1636     }
1637
1638   __asm__ __volatile__ ("sidt   %0" : "=m" (idtr) : /* no inputs */ );
1639   max_entry = (idtr.limit + 1) / 8;
1640   if (max_entry > 0x100)        /* no more than 256 entries */
1641     max_entry = 0x100;
1642
1643   if (idt_entry >= 0)
1644     {
1645       if (idt_entry > idtr.limit)
1646         error ("Invalid IDT entry %#x: outside valid limits [0..%#x]",
1647                idt_entry, idtr.limit);
1648
1649       display_descriptor (1, idtr.base, idt_entry, 1);
1650     }
1651   else
1652     {
1653       int i;
1654
1655       for (i = 0; i < max_entry; i++)
1656         display_descriptor (1, idtr.base, i, 0);
1657     }
1658 }
1659
1660 /* Cached linear address of the base of the page directory.  For
1661    now, available only under CWSDPMI.  Code based on ideas and
1662    suggestions from Charles Sandmann <sandmann@clio.rice.edu>.  */
1663 static unsigned long pdbr;
1664
1665 static unsigned long
1666 get_cr3 (void)
1667 {
1668   unsigned offset;
1669   unsigned taskreg;
1670   unsigned long taskbase, cr3;
1671   struct dtr_reg gdtr;
1672
1673   if (pdbr > 0 && pdbr <= 0xfffff)
1674     return pdbr;
1675
1676   /* Get the linear address of GDT and the Task Register.  */
1677   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
1678   __asm__ __volatile__ ("str    %0" : "=m" (taskreg) : /* no inputs */ );
1679
1680   /* Task Register is a segment selector for the TSS of the current
1681      task.  Therefore, it can be used as an index into the GDT to get
1682      at the segment descriptor for the TSS.  To get the index, reset
1683      the low 3 bits of the selector (which give the CPL).  Add 2 to the
1684      offset to point to the 3 low bytes of the base address.  */
1685   offset = gdtr.base + (taskreg & 0xfff8) + 2;
1686
1687
1688   /* CWSDPMI's task base is always under the 1MB mark.  */
1689   if (offset > 0xfffff)
1690     return 0;
1691
1692   _farsetsel (_dos_ds);
1693   taskbase  = _farnspeekl (offset) & 0xffffffU;
1694   taskbase += _farnspeekl (offset + 2) & 0xff000000U;
1695   if (taskbase > 0xfffff)
1696     return 0;
1697
1698   /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1699      offset 1Ch in the TSS.  */
1700   cr3 = _farnspeekl (taskbase + 0x1c) & ~0xfff;
1701   if (cr3 > 0xfffff)
1702     {
1703       /* The Page Directory is in UMBs.  In that case, CWSDPMI puts
1704          the first Page Table right below the Page Directory.  Thus,
1705          the first Page Table's entry for its own address and the Page
1706          Directory entry for that Page Table will hold the same
1707          physical address.  The loop below searches the entire UMB
1708          range of addresses for such an occurence.  */
1709       unsigned long addr, pte_idx;
1710
1711       for (addr = 0xb0000, pte_idx = 0xb0;
1712            pte_idx < 0xff;
1713            addr += 0x1000, pte_idx++)
1714         {
1715           if (((_farnspeekl (addr + 4 * pte_idx) & 0xfffff027) ==
1716                (_farnspeekl (addr + 0x1000) & 0xfffff027))
1717               && ((_farnspeekl (addr + 4 * pte_idx + 4) & 0xfffff000) == cr3))
1718             {
1719               cr3 = addr + 0x1000;
1720               break;
1721             }
1722         }
1723
1724       if (cr3 > 0xfffff)
1725         cr3 = 0;
1726     }
1727
1728   return cr3;
1729 }
1730
1731 /* Return the N'th Page Directory entry.  */
1732 static unsigned long
1733 get_pde (int n)
1734 {
1735   unsigned long pde = 0;
1736
1737   if (pdbr && n >= 0 && n < 1024)
1738     {
1739       pde = _farpeekl (_dos_ds, pdbr + 4*n);
1740     }
1741   return pde;
1742 }
1743
1744 /* Return the N'th entry of the Page Table whose Page Directory entry
1745    is PDE.  */
1746 static unsigned long
1747 get_pte (unsigned long pde, int n)
1748 {
1749   unsigned long pte = 0;
1750
1751   /* pde & 0x80 tests the 4MB page bit.  We don't support 4MB
1752      page tables, for now.  */
1753   if ((pde & 1) && !(pde & 0x80) && n >= 0 && n < 1024)
1754     {
1755       pde &= ~0xfff;    /* clear non-address bits */
1756       pte = _farpeekl (_dos_ds, pde + 4*n);
1757     }
1758   return pte;
1759 }
1760
1761 /* Display a Page Directory or Page Table entry.  IS_DIR, if non-zero,
1762    says this is a Page Directory entry.  If FORCE is non-zero, display
1763    the entry even if its Present flag is off.  OFF is the offset of the
1764    address from the page's base address.  */
1765 static void
1766 display_ptable_entry (unsigned long entry, int is_dir, int force, unsigned off)
1767 {
1768   if ((entry & 1) != 0)
1769     {
1770       printf_filtered ("Base=0x%05lx000", entry >> 12);
1771       if ((entry & 0x100) && !is_dir)
1772         puts_filtered (" Global");
1773       if ((entry & 0x40) && !is_dir)
1774         puts_filtered (" Dirty");
1775       printf_filtered (" %sAcc.", (entry & 0x20) ? "" : "Not-");
1776       printf_filtered (" %sCached", (entry & 0x10) ? "" : "Not-");
1777       printf_filtered (" Write-%s", (entry & 8) ? "Thru" : "Back");
1778       printf_filtered (" %s", (entry & 4) ? "Usr" : "Sup");
1779       printf_filtered (" Read-%s", (entry & 2) ? "Write" : "Only");
1780       if (off)
1781         printf_filtered (" +0x%x", off);
1782       puts_filtered ("\n");
1783     }
1784   else if (force)
1785     printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1786                      is_dir ? " Table" : "", entry >> 1);
1787 }
1788
1789 static void
1790 go32_pde (char *arg, int from_tty)
1791 {
1792   long pde_idx = -1, i;
1793
1794   if (arg && *arg)
1795     {
1796       while (*arg && isspace(*arg))
1797         arg++;
1798
1799       if (*arg)
1800         {
1801           pde_idx = parse_and_eval_long (arg);
1802           if (pde_idx < 0 || pde_idx >= 1024)
1803             error ("Entry %ld is outside valid limits [0..1023].", pde_idx);
1804         }
1805     }
1806
1807   pdbr = get_cr3 ();
1808   if (!pdbr)
1809     puts_filtered ("Access to Page Directories is not supported on this system.\n");
1810   else if (pde_idx >= 0)
1811     display_ptable_entry (get_pde (pde_idx), 1, 1, 0);
1812   else
1813     for (i = 0; i < 1024; i++)
1814       display_ptable_entry (get_pde (i), 1, 0, 0);
1815 }
1816
1817 /* A helper function to display entries in a Page Table pointed to by
1818    the N'th entry in the Page Directory.  If FORCE is non-zero, say
1819    something even if the Page Table is not accessible.  */
1820 static void
1821 display_page_table (long n, int force)
1822 {
1823   unsigned long pde = get_pde (n);
1824
1825   if ((pde & 1) != 0)
1826     {
1827       int i;
1828
1829       printf_filtered ("Page Table pointed to by Page Directory entry 0x%lx:\n", n);
1830       for (i = 0; i < 1024; i++)
1831         display_ptable_entry (get_pte (pde, i), 0, 0, 0);
1832       puts_filtered ("\n");
1833     }
1834   else if (force)
1835     printf_filtered ("Page Table not present; value=0x%lx.\n", pde >> 1);
1836 }
1837
1838 static void
1839 go32_pte (char *arg, int from_tty)
1840 {
1841   long pde_idx = -1, i;
1842
1843   if (arg && *arg)
1844     {
1845       while (*arg && isspace(*arg))
1846         arg++;
1847
1848       if (*arg)
1849         {
1850           pde_idx = parse_and_eval_long (arg);
1851           if (pde_idx < 0 || pde_idx >= 1024)
1852             error ("Entry %d is outside valid limits [0..1023].", pde_idx);
1853         }
1854     }
1855
1856   pdbr = get_cr3 ();
1857   if (!pdbr)
1858     puts_filtered ("Access to Page Tables is not supported on this system.\n");
1859   else if (pde_idx >= 0)
1860     display_page_table (pde_idx, 1);
1861   else
1862     for (i = 0; i < 1024; i++)
1863       display_page_table (i, 0);
1864 }
1865
1866 static void
1867 go32_pte_for_address (char *arg, int from_tty)
1868 {
1869   CORE_ADDR addr = 0, i;
1870
1871   if (arg && *arg)
1872     {
1873       while (*arg && isspace(*arg))
1874         arg++;
1875
1876       if (*arg)
1877         addr = parse_and_eval_address (arg);
1878     }
1879   if (!addr)
1880     error_no_arg ("linear address");
1881
1882   pdbr = get_cr3 ();
1883   if (!pdbr)
1884     puts_filtered ("Access to Page Tables is not supported on this system.\n");
1885   else
1886     {
1887       int pde_idx = (addr >> 22) & 0x3ff;
1888       int pte_idx = (addr >> 12) & 0x3ff;
1889       unsigned offs = addr & 0xfff;
1890
1891       printf_filtered ("Page Table entry for address 0x%llx:\n",
1892                        (unsigned long long)addr);
1893       display_ptable_entry (get_pte (get_pde (pde_idx), pte_idx), 0, 1, offs);
1894     }
1895 }
1896
1897 static struct cmd_list_element *info_dos_cmdlist = NULL;
1898
1899 static void
1900 go32_info_dos_command (char *args, int from_tty)
1901 {
1902   help_list (info_dos_cmdlist, "info dos ", class_info, gdb_stdout);
1903 }
1904
1905 void
1906 _initialize_go32_nat (void)
1907 {
1908   init_go32_ops ();
1909   add_target (&go32_ops);
1910
1911   add_prefix_cmd ("dos", class_info, go32_info_dos_command,
1912                   "Print information specific to DJGPP (a.k.a. MS-DOS) debugging.",
1913                   &info_dos_cmdlist, "info dos ", 0, &infolist);
1914
1915   add_cmd ("sysinfo", class_info, go32_sysinfo,
1916             "Display information about the target system, including CPU, OS, DPMI, etc.",
1917            &info_dos_cmdlist);
1918   add_cmd ("ldt", class_info, go32_sldt,
1919            "Display entries in the LDT (Local Descriptor Table).\n"
1920            "Entry number (an expression) as an argument means display only that entry.",
1921            &info_dos_cmdlist);
1922   add_cmd ("gdt", class_info, go32_sgdt,
1923            "Display entries in the GDT (Global Descriptor Table).\n"
1924            "Entry number (an expression) as an argument means display only that entry.",
1925            &info_dos_cmdlist);
1926   add_cmd ("idt", class_info, go32_sidt,
1927            "Display entries in the IDT (Interrupt Descriptor Table).\n"
1928            "Entry number (an expression) as an argument means display only that entry.",
1929            &info_dos_cmdlist);
1930   add_cmd ("pde", class_info, go32_pde,
1931            "Display entries in the Page Directory.\n"
1932            "Entry number (an expression) as an argument means display only that entry.",
1933            &info_dos_cmdlist);
1934   add_cmd ("pte", class_info, go32_pte,
1935            "Display entries in Page Tables.\n"
1936            "Entry number (an expression) as an argument means display only entries\n"
1937            "from the Page Table pointed to by the specified Page Directory entry.",
1938            &info_dos_cmdlist);
1939   add_cmd ("address-pte", class_info, go32_pte_for_address,
1940            "Display a Page Table entry for a linear address.\n"
1941            "The address argument must be a linear address, after adding to\n"
1942            "it the base address of the appropriate segment.\n"
1943            "The base address of variables and functions in the debuggee's data\n"
1944            "or code segment is stored in the variable __djgpp_base_address,\n"
1945            "so use `__djgpp_base_address + (char *)&var' as the argument.\n"
1946            "For other segments, look up their base address in the output of\n"
1947            "the `info dos ldt' command.",
1948            &info_dos_cmdlist);
1949 }
1950
1951 pid_t
1952 tcgetpgrp (int fd)
1953 {
1954   if (isatty (fd))
1955     return SOME_PID;
1956   errno = ENOTTY;
1957   return -1;
1958 }
1959
1960 int
1961 tcsetpgrp (int fd, pid_t pgid)
1962 {
1963   if (isatty (fd) && pgid == SOME_PID)
1964     return 0;
1965   errno = pgid == SOME_PID ? ENOTTY : ENOSYS;
1966   return -1;
1967 }