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