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