Rename 32- and 64-bit Intel files from "i386" to "x86"
[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 "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   if (res <= 0)
591     return TARGET_XFER_E_IO;
592
593   *xfered_len = res;
594   return TARGET_XFER_OK;
595 }
596
597 /* Target to_xfer_partial implementation.  */
598
599 static enum target_xfer_status
600 go32_xfer_partial (struct target_ops *ops, enum target_object object,
601                    const char *annex, gdb_byte *readbuf,
602                    const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
603                    ULONGEST *xfered_len)
604 {
605   switch (object)
606     {
607     case TARGET_OBJECT_MEMORY:
608       return go32_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
609
610     default:
611       return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
612                                             readbuf, writebuf, offset, len,
613                                             xfered_len);
614     }
615 }
616
617 static cmdline_t child_cmd;     /* Parsed child's command line kept here.  */
618
619 static void
620 go32_files_info (struct target_ops *target)
621 {
622   printf_unfiltered ("You are running a DJGPP V2 program.\n");
623 }
624
625 static void
626 go32_kill_inferior (struct target_ops *ops)
627 {
628   go32_mourn_inferior (ops);
629 }
630
631 static void
632 go32_create_inferior (struct target_ops *ops, char *exec_file,
633                       char *args, char **env, int from_tty)
634 {
635   extern char **environ;
636   jmp_buf start_state;
637   char *cmdline;
638   char **env_save = environ;
639   size_t cmdlen;
640   struct inferior *inf;
641   int result;
642
643   /* If no exec file handed to us, get it from the exec-file command -- with
644      a good, common error message if none is specified.  */
645   if (exec_file == 0)
646     exec_file = get_exec_file (1);
647
648   resume_signal = -1;
649   resume_is_step = 0;
650
651   /* Initialize child's cwd as empty to be initialized when starting
652      the child.  */
653   *child_cwd = 0;
654
655   /* Init command line storage.  */
656   if (redir_debug_init (&child_cmd) == -1)
657     internal_error (__FILE__, __LINE__,
658                     _("Cannot allocate redirection storage: "
659                       "not enough memory.\n"));
660
661   /* Parse the command line and create redirections.  */
662   if (strpbrk (args, "<>"))
663     {
664       if (redir_cmdline_parse (args, &child_cmd) == 0)
665         args = child_cmd.command;
666       else
667         error (_("Syntax error in command line."));
668     }
669   else
670     child_cmd.command = xstrdup (args);
671
672   cmdlen = strlen (args);
673   /* v2loadimage passes command lines via DOS memory, so it cannot
674      possibly handle commands longer than 1MB.  */
675   if (cmdlen > 1024*1024)
676     error (_("Command line too long."));
677
678   cmdline = xmalloc (cmdlen + 4);
679   strcpy (cmdline + 1, args);
680   /* If the command-line length fits into DOS 126-char limits, use the
681      DOS command tail format; otherwise, tell v2loadimage to pass it
682      through a buffer in conventional memory.  */
683   if (cmdlen < 127)
684     {
685       cmdline[0] = strlen (args);
686       cmdline[cmdlen + 1] = 13;
687     }
688   else
689     cmdline[0] = 0xff;  /* Signal v2loadimage it's a long command.  */
690
691   environ = env;
692
693   result = v2loadimage (exec_file, cmdline, start_state);
694
695   environ = env_save;
696   xfree (cmdline);
697
698   if (result != 0)
699     error (_("Load failed for image %s", exec_file);
700
701   edi_init (start_state);
702 #if __DJGPP_MINOR__ < 3
703   save_npx ();
704 #endif
705
706   inferior_ptid = pid_to_ptid (SOME_PID);
707   inf = current_inferior ();
708   inferior_appeared (inf, SOME_PID);
709
710   if (!target_is_pushed (ops))
711     push_target (ops);
712
713   add_thread_silent (inferior_ptid);
714
715   clear_proceed_status (0);
716   insert_breakpoints ();
717   prog_has_started = 1;
718 }
719
720 static void
721 go32_mourn_inferior (struct target_ops *ops)
722 {
723   ptid_t ptid;
724
725   redir_cmdline_delete (&child_cmd);
726   resume_signal = -1;
727   resume_is_step = 0;
728
729   cleanup_client ();
730
731   /* We need to make sure all the breakpoint enable bits in the DR7
732      register are reset when the inferior exits.  Otherwise, if they
733      rerun the inferior, the uncleared bits may cause random SIGTRAPs,
734      failure to set more watchpoints, and other calamities.  It would
735      be nice if GDB itself would take care to remove all breakpoints
736      at all times, but it doesn't, probably under an assumption that
737      the OS cleans up when the debuggee exits.  */
738   x86_cleanup_dregs ();
739
740   ptid = inferior_ptid;
741   inferior_ptid = null_ptid;
742   delete_thread_silent (ptid);
743   prog_has_started = 0;
744
745   generic_mourn_inferior ();
746   inf_child_maybe_unpush_target (ops);
747 }
748
749 /* Hardware watchpoint support.  */
750
751 #define D_REGS edi.dr
752 #define CONTROL D_REGS[7]
753 #define STATUS D_REGS[6]
754
755 /* Pass the address ADDR to the inferior in the I'th debug register.
756    Here we just store the address in D_REGS, the watchpoint will be
757    actually set up when go32_wait runs the debuggee.  */
758 static void
759 go32_set_dr (int i, CORE_ADDR addr)
760 {
761   if (i < 0 || i > 3)
762     internal_error (__FILE__, __LINE__, 
763                     _("Invalid register %d in go32_set_dr.\n"), i);
764   D_REGS[i] = addr;
765 }
766
767 /* Pass the value VAL to the inferior in the DR7 debug control
768    register.  Here we just store the address in D_REGS, the watchpoint
769    will be actually set up when go32_wait runs the debuggee.  */
770 static void
771 go32_set_dr7 (unsigned long val)
772 {
773   CONTROL = val;
774 }
775
776 /* Get the value of the DR6 debug status register from the inferior.
777    Here we just return the value stored in D_REGS, as we've got it
778    from the last go32_wait call.  */
779 static unsigned long
780 go32_get_dr6 (void)
781 {
782   return STATUS;
783 }
784
785 /* Get the value of the DR7 debug status register from the inferior.
786    Here we just return the value stored in D_REGS, as we've got it
787    from the last go32_wait call.  */
788
789 static unsigned long
790 go32_get_dr7 (void)
791 {
792   return CONTROL;
793 }
794
795 /* Get the value of the DR debug register I from the inferior.  Here
796    we just return the value stored in D_REGS, as we've got it from the
797    last go32_wait call.  */
798
799 static CORE_ADDR
800 go32_get_dr (int i)
801 {
802   if (i < 0 || i > 3)
803     internal_error (__FILE__, __LINE__,
804                     _("Invalid register %d in go32_get_dr.\n"), i);
805   return D_REGS[i];
806 }
807
808 /* Put the device open on handle FD into either raw or cooked
809    mode, return 1 if it was in raw mode, zero otherwise.  */
810
811 static int
812 device_mode (int fd, int raw_p)
813 {
814   int oldmode, newmode;
815   __dpmi_regs regs;
816
817   regs.x.ax = 0x4400;
818   regs.x.bx = fd;
819   __dpmi_int (0x21, &regs);
820   if (regs.x.flags & 1)
821     return -1;
822   newmode = oldmode = regs.x.dx;
823
824   if (raw_p)
825     newmode |= 0x20;
826   else
827     newmode &= ~0x20;
828
829   if (oldmode & 0x80)   /* Only for character dev.  */
830   {
831     regs.x.ax = 0x4401;
832     regs.x.bx = fd;
833     regs.x.dx = newmode & 0xff;   /* Force upper byte zero, else it fails.  */
834     __dpmi_int (0x21, &regs);
835     if (regs.x.flags & 1)
836       return -1;
837   }
838   return (oldmode & 0x20) == 0x20;
839 }
840
841
842 static int inf_mode_valid = 0;
843 static int inf_terminal_mode;
844
845 /* This semaphore is needed because, amazingly enough, GDB calls
846    target.to_terminal_ours more than once after the inferior stops.
847    But we need the information from the first call only, since the
848    second call will always see GDB's own cooked terminal.  */
849 static int terminal_is_ours = 1;
850
851 static void
852 go32_terminal_init (struct target_ops *self)
853 {
854   inf_mode_valid = 0;   /* Reinitialize, in case they are restarting child.  */
855   terminal_is_ours = 1;
856 }
857
858 static void
859 go32_terminal_info (struct target_ops *self, const char *args, int from_tty)
860 {
861   printf_unfiltered ("Inferior's terminal is in %s mode.\n",
862                      !inf_mode_valid
863                      ? "default" : inf_terminal_mode ? "raw" : "cooked");
864
865 #if __DJGPP_MINOR__ > 2
866   if (child_cmd.redirection)
867   {
868     int i;
869
870     for (i = 0; i < DBG_HANDLES; i++)
871     {
872       if (child_cmd.redirection[i]->file_name)
873         printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
874                            i, child_cmd.redirection[i]->file_name);
875       else if (_get_dev_info (child_cmd.redirection[i]->inf_handle) == -1)
876         printf_unfiltered
877           ("\tFile handle %d appears to be closed by inferior.\n", i);
878       /* Mask off the raw/cooked bit when comparing device info words.  */
879       else if ((_get_dev_info (child_cmd.redirection[i]->inf_handle) & 0xdf)
880                != (_get_dev_info (i) & 0xdf))
881         printf_unfiltered
882           ("\tFile handle %d appears to be redirected by inferior.\n", i);
883     }
884   }
885 #endif
886 }
887
888 static void
889 go32_terminal_inferior (struct target_ops *self)
890 {
891   /* Redirect standard handles as child wants them.  */
892   errno = 0;
893   if (redir_to_child (&child_cmd) == -1)
894   {
895     redir_to_debugger (&child_cmd);
896     error (_("Cannot redirect standard handles for program: %s."),
897            safe_strerror (errno));
898   }
899   /* Set the console device of the inferior to whatever mode
900      (raw or cooked) we found it last time.  */
901   if (terminal_is_ours)
902   {
903     if (inf_mode_valid)
904       device_mode (0, inf_terminal_mode);
905     terminal_is_ours = 0;
906   }
907 }
908
909 static void
910 go32_terminal_ours (struct target_ops *self)
911 {
912   /* Switch to cooked mode on the gdb terminal and save the inferior
913      terminal mode to be restored when it is resumed.  */
914   if (!terminal_is_ours)
915   {
916     inf_terminal_mode = device_mode (0, 0);
917     if (inf_terminal_mode != -1)
918       inf_mode_valid = 1;
919     else
920       /* If device_mode returned -1, we don't know what happens with
921          handle 0 anymore, so make the info invalid.  */
922       inf_mode_valid = 0;
923     terminal_is_ours = 1;
924
925     /* Restore debugger's standard handles.  */
926     errno = 0;
927     if (redir_to_debugger (&child_cmd) == -1)
928     {
929       redir_to_child (&child_cmd);
930       error (_("Cannot redirect standard handles for debugger: %s."),
931              safe_strerror (errno));
932     }
933   }
934 }
935
936 static int
937 go32_thread_alive (struct target_ops *ops, ptid_t ptid)
938 {
939   return !ptid_equal (inferior_ptid, null_ptid);
940 }
941
942 static char *
943 go32_pid_to_str (struct target_ops *ops, ptid_t ptid)
944 {
945   return normal_pid_to_str (ptid);
946 }
947
948 /* Create a go32 target.  */
949
950 static struct target_ops *
951 go32_target (void)
952 {
953   struct target_ops *t = inf_child_target ();
954
955   t->to_attach = go32_attach;
956   t->to_resume = go32_resume;
957   t->to_wait = go32_wait;
958   t->to_fetch_registers = go32_fetch_registers;
959   t->to_store_registers = go32_store_registers;
960   t->to_xfer_partial = go32_xfer_partial;
961   t->to_files_info = go32_files_info;
962   t->to_terminal_init = go32_terminal_init;
963   t->to_terminal_inferior = go32_terminal_inferior;
964   t->to_terminal_ours_for_output = go32_terminal_ours;
965   t->to_terminal_ours = go32_terminal_ours;
966   t->to_terminal_info = go32_terminal_info;
967   t->to_kill = go32_kill_inferior;
968   t->to_create_inferior = go32_create_inferior;
969   t->to_mourn_inferior = go32_mourn_inferior;
970   t->to_thread_alive = go32_thread_alive;
971   t->to_pid_to_str = go32_pid_to_str;
972
973   return t;
974 }
975
976 /* Return the current DOS codepage number.  */
977 static int
978 dos_codepage (void)
979 {
980   __dpmi_regs regs;
981
982   regs.x.ax = 0x6601;
983   __dpmi_int (0x21, &regs);
984   if (!(regs.x.flags & 1))
985     return regs.x.bx & 0xffff;
986   else
987     return 437; /* default */
988 }
989
990 /* Limited emulation of `nl_langinfo', for charset.c.  */
991 char *
992 nl_langinfo (nl_item item)
993 {
994   char *retval;
995
996   switch (item)
997     {
998       case CODESET:
999         {
1000           /* 8 is enough for SHORT_MAX + "CP" + null.  */
1001           char buf[8];
1002           int blen = sizeof (buf);
1003           int needed = snprintf (buf, blen, "CP%d", dos_codepage ());
1004
1005           if (needed > blen)    /* Should never happen.  */
1006             buf[0] = 0;
1007           retval = xstrdup (buf);
1008         }
1009         break;
1010       default:
1011         retval = xstrdup ("");
1012         break;
1013     }
1014   return retval;
1015 }
1016
1017 unsigned short windows_major, windows_minor;
1018
1019 /* Compute the version Windows reports via Int 2Fh/AX=1600h.  */
1020 static void
1021 go32_get_windows_version(void)
1022 {
1023   __dpmi_regs r;
1024
1025   r.x.ax = 0x1600;
1026   __dpmi_int(0x2f, &r);
1027   if (r.h.al > 2 && r.h.al != 0x80 && r.h.al != 0xff
1028       && (r.h.al > 3 || r.h.ah > 0))
1029     {
1030       windows_major = r.h.al;
1031       windows_minor = r.h.ah;
1032     }
1033   else
1034     windows_major = 0xff;       /* meaning no Windows */
1035 }
1036
1037 /* A subroutine of go32_sysinfo to display memory info.  */
1038 static void
1039 print_mem (unsigned long datum, const char *header, int in_pages_p)
1040 {
1041   if (datum != 0xffffffffUL)
1042     {
1043       if (in_pages_p)
1044         datum <<= 12;
1045       puts_filtered (header);
1046       if (datum > 1024)
1047         {
1048           printf_filtered ("%lu KB", datum >> 10);
1049           if (datum > 1024 * 1024)
1050             printf_filtered (" (%lu MB)", datum >> 20);
1051         }
1052       else
1053         printf_filtered ("%lu Bytes", datum);
1054       puts_filtered ("\n");
1055     }
1056 }
1057
1058 /* Display assorted information about the underlying OS.  */
1059 static void
1060 go32_sysinfo (char *arg, int from_tty)
1061 {
1062   static const char test_pattern[] =
1063     "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1064     "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1065     "deadbeafdeadbeafdeadbeafdeadbeafdeadbeafdeadbeaf";
1066   struct utsname u;
1067   char cpuid_vendor[13];
1068   unsigned cpuid_max = 0, cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx;
1069   unsigned true_dos_version = _get_dos_version (1);
1070   unsigned advertized_dos_version = ((unsigned int)_osmajor << 8) | _osminor;
1071   int dpmi_flags;
1072   char dpmi_vendor_info[129];
1073   int dpmi_vendor_available;
1074   __dpmi_version_ret dpmi_version_data;
1075   long eflags;
1076   __dpmi_free_mem_info mem_info;
1077   __dpmi_regs regs;
1078
1079   cpuid_vendor[0] = '\0';
1080   if (uname (&u))
1081     strcpy (u.machine, "Unknown x86");
1082   else if (u.machine[0] == 'i' && u.machine[1] > 4)
1083     {
1084       /* CPUID with EAX = 0 returns the Vendor ID.  */
1085 #if 0
1086       /* Ideally we would use x86_cpuid(), but it needs someone to run
1087          native tests first to make sure things actually work.  They should.
1088          http://sourceware.org/ml/gdb-patches/2013-05/msg00164.html  */
1089       unsigned int eax, ebx, ecx, edx;
1090
1091       if (x86_cpuid (0, &eax, &ebx, &ecx, &edx))
1092         {
1093           cpuid_max = eax;
1094           memcpy (&vendor[0], &ebx, 4);
1095           memcpy (&vendor[4], &ecx, 4);
1096           memcpy (&vendor[8], &edx, 4);
1097           cpuid_vendor[12] = '\0';
1098         }
1099 #else
1100       __asm__ __volatile__ ("xorl   %%ebx, %%ebx;"
1101                             "xorl   %%ecx, %%ecx;"
1102                             "xorl   %%edx, %%edx;"
1103                             "movl   $0,    %%eax;"
1104                             "cpuid;"
1105                             "movl   %%ebx,  %0;"
1106                             "movl   %%edx,  %1;"
1107                             "movl   %%ecx,  %2;"
1108                             "movl   %%eax,  %3;"
1109                             : "=m" (cpuid_vendor[0]),
1110                               "=m" (cpuid_vendor[4]),
1111                               "=m" (cpuid_vendor[8]),
1112                               "=m" (cpuid_max)
1113                             :
1114                             : "%eax", "%ebx", "%ecx", "%edx");
1115       cpuid_vendor[12] = '\0';
1116 #endif
1117     }
1118
1119   printf_filtered ("CPU Type.......................%s", u.machine);
1120   if (cpuid_vendor[0])
1121     printf_filtered (" (%s)", cpuid_vendor);
1122   puts_filtered ("\n");
1123
1124   /* CPUID with EAX = 1 returns processor signature and features.  */
1125   if (cpuid_max >= 1)
1126     {
1127       static char *brand_name[] = {
1128         "",
1129         " Celeron",
1130         " III",
1131         " III Xeon",
1132         "", "", "", "",
1133         " 4"
1134       };
1135       char cpu_string[80];
1136       char cpu_brand[20];
1137       unsigned brand_idx;
1138       int intel_p = strcmp (cpuid_vendor, "GenuineIntel") == 0;
1139       int amd_p = strcmp (cpuid_vendor, "AuthenticAMD") == 0;
1140       unsigned cpu_family, cpu_model;
1141
1142 #if 0
1143       /* See comment above about cpuid usage.  */
1144       x86_cpuid (1, &cpuid_eax, &cpuid_ebx, NULL, &cpuid_edx);
1145 #else
1146       __asm__ __volatile__ ("movl   $1, %%eax;"
1147                             "cpuid;"
1148                             : "=a" (cpuid_eax),
1149                               "=b" (cpuid_ebx),
1150                               "=d" (cpuid_edx)
1151                             :
1152                             : "%ecx");
1153 #endif
1154       brand_idx = cpuid_ebx & 0xff;
1155       cpu_family = (cpuid_eax >> 8) & 0xf;
1156       cpu_model  = (cpuid_eax >> 4) & 0xf;
1157       cpu_brand[0] = '\0';
1158       if (intel_p)
1159         {
1160           if (brand_idx > 0
1161               && brand_idx < sizeof(brand_name)/sizeof(brand_name[0])
1162               && *brand_name[brand_idx])
1163             strcpy (cpu_brand, brand_name[brand_idx]);
1164           else if (cpu_family == 5)
1165             {
1166               if (((cpuid_eax >> 12) & 3) == 0 && cpu_model == 4)
1167                 strcpy (cpu_brand, " MMX");
1168               else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 1)
1169                 strcpy (cpu_brand, " OverDrive");
1170               else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 2)
1171                 strcpy (cpu_brand, " Dual");
1172             }
1173           else if (cpu_family == 6 && cpu_model < 8)
1174             {
1175               switch (cpu_model)
1176                 {
1177                   case 1:
1178                     strcpy (cpu_brand, " Pro");
1179                     break;
1180                   case 3:
1181                     strcpy (cpu_brand, " II");
1182                     break;
1183                   case 5:
1184                     strcpy (cpu_brand, " II Xeon");
1185                     break;
1186                   case 6:
1187                     strcpy (cpu_brand, " Celeron");
1188                     break;
1189                   case 7:
1190                     strcpy (cpu_brand, " III");
1191                     break;
1192                 }
1193             }
1194         }
1195       else if (amd_p)
1196         {
1197           switch (cpu_family)
1198             {
1199               case 4:
1200                 strcpy (cpu_brand, "486/5x86");
1201                 break;
1202               case 5:
1203                 switch (cpu_model)
1204                   {
1205                     case 0:
1206                     case 1:
1207                     case 2:
1208                     case 3:
1209                       strcpy (cpu_brand, "-K5");
1210                       break;
1211                     case 6:
1212                     case 7:
1213                       strcpy (cpu_brand, "-K6");
1214                       break;
1215                     case 8:
1216                       strcpy (cpu_brand, "-K6-2");
1217                       break;
1218                     case 9:
1219                       strcpy (cpu_brand, "-K6-III");
1220                       break;
1221                   }
1222                 break;
1223               case 6:
1224                 switch (cpu_model)
1225                   {
1226                     case 1:
1227                     case 2:
1228                     case 4:
1229                       strcpy (cpu_brand, " Athlon");
1230                       break;
1231                     case 3:
1232                       strcpy (cpu_brand, " Duron");
1233                       break;
1234                   }
1235                 break;
1236             }
1237         }
1238       xsnprintf (cpu_string, sizeof (cpu_string), "%s%s Model %d Stepping %d",
1239                  intel_p ? "Pentium" : (amd_p ? "AMD" : "ix86"),
1240                  cpu_brand, cpu_model, cpuid_eax & 0xf);
1241       printfi_filtered (31, "%s\n", cpu_string);
1242       if (((cpuid_edx & (6 | (0x0d << 23))) != 0)
1243           || ((cpuid_edx & 1) == 0)
1244           || (amd_p && (cpuid_edx & (3 << 30)) != 0))
1245         {
1246           puts_filtered ("CPU Features...................");
1247           /* We only list features which might be useful in the DPMI
1248              environment.  */
1249           if ((cpuid_edx & 1) == 0)
1250             puts_filtered ("No FPU "); /* It's unusual to not have an FPU.  */
1251           if ((cpuid_edx & (1 << 1)) != 0)
1252             puts_filtered ("VME ");
1253           if ((cpuid_edx & (1 << 2)) != 0)
1254             puts_filtered ("DE ");
1255           if ((cpuid_edx & (1 << 4)) != 0)
1256             puts_filtered ("TSC ");
1257           if ((cpuid_edx & (1 << 23)) != 0)
1258             puts_filtered ("MMX ");
1259           if ((cpuid_edx & (1 << 25)) != 0)
1260             puts_filtered ("SSE ");
1261           if ((cpuid_edx & (1 << 26)) != 0)
1262             puts_filtered ("SSE2 ");
1263           if (amd_p)
1264             {
1265               if ((cpuid_edx & (1 << 31)) != 0)
1266                 puts_filtered ("3DNow! ");
1267               if ((cpuid_edx & (1 << 30)) != 0)
1268                 puts_filtered ("3DNow!Ext");
1269             }
1270           puts_filtered ("\n");
1271         }
1272     }
1273   puts_filtered ("\n");
1274   printf_filtered ("DOS Version....................%s %s.%s",
1275                    _os_flavor, u.release, u.version);
1276   if (true_dos_version != advertized_dos_version)
1277     printf_filtered (" (disguised as v%d.%d)", _osmajor, _osminor);
1278   puts_filtered ("\n");
1279   if (!windows_major)
1280     go32_get_windows_version ();
1281   if (windows_major != 0xff)
1282     {
1283       const char *windows_flavor;
1284
1285       printf_filtered ("Windows Version................%d.%02d (Windows ",
1286                        windows_major, windows_minor);
1287       switch (windows_major)
1288         {
1289           case 3:
1290             windows_flavor = "3.X";
1291             break;
1292           case 4:
1293             switch (windows_minor)
1294               {
1295                 case 0:
1296                   windows_flavor = "95, 95A, or 95B";
1297                   break;
1298                 case 3:
1299                   windows_flavor = "95B OSR2.1 or 95C OSR2.5";
1300                   break;
1301                 case 10:
1302                   windows_flavor = "98 or 98 SE";
1303                   break;
1304                 case 90:
1305                   windows_flavor = "ME";
1306                   break;
1307                 default:
1308                   windows_flavor = "9X";
1309                   break;
1310               }
1311             break;
1312           default:
1313             windows_flavor = "??";
1314             break;
1315         }
1316       printf_filtered ("%s)\n", windows_flavor);
1317     }
1318   else if (true_dos_version == 0x532 && advertized_dos_version == 0x500)
1319     printf_filtered ("Windows Version................"
1320                      "Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
1321   puts_filtered ("\n");
1322   /* On some versions of Windows, __dpmi_get_capabilities returns
1323      zero, but the buffer is not filled with info, so we fill the
1324      buffer with a known pattern and test for it afterwards.  */
1325   memcpy (dpmi_vendor_info, test_pattern, sizeof(dpmi_vendor_info));
1326   dpmi_vendor_available =
1327     __dpmi_get_capabilities (&dpmi_flags, dpmi_vendor_info);
1328   if (dpmi_vendor_available == 0
1329       && memcmp (dpmi_vendor_info, test_pattern,
1330                  sizeof(dpmi_vendor_info)) != 0)
1331     {
1332       /* The DPMI spec says the vendor string should be ASCIIZ, but
1333          I don't trust the vendors to follow that...  */
1334       if (!memchr (&dpmi_vendor_info[2], 0, 126))
1335         dpmi_vendor_info[128] = '\0';
1336       printf_filtered ("DPMI Host......................"
1337                        "%s v%d.%d (capabilities: %#x)\n",
1338                        &dpmi_vendor_info[2],
1339                        (unsigned)dpmi_vendor_info[0],
1340                        (unsigned)dpmi_vendor_info[1],
1341                        ((unsigned)dpmi_flags & 0x7f));
1342     }
1343   else
1344     printf_filtered ("DPMI Host......................(Info not available)\n");
1345   __dpmi_get_version (&dpmi_version_data);
1346   printf_filtered ("DPMI Version...................%d.%02d\n",
1347                    dpmi_version_data.major, dpmi_version_data.minor);
1348   printf_filtered ("DPMI Info......................"
1349                    "%s-bit DPMI, with%s Virtual Memory support\n",
1350                    (dpmi_version_data.flags & 1) ? "32" : "16",
1351                    (dpmi_version_data.flags & 4) ? "" : "out");
1352   printfi_filtered (31, "Interrupts reflected to %s mode\n",
1353                    (dpmi_version_data.flags & 2) ? "V86" : "Real");
1354   printfi_filtered (31, "Processor type: i%d86\n",
1355                    dpmi_version_data.cpu);
1356   printfi_filtered (31, "PIC base interrupt: Master: %#x  Slave: %#x\n",
1357                    dpmi_version_data.master_pic, dpmi_version_data.slave_pic);
1358
1359   /* a_tss is only initialized when the debuggee is first run.  */
1360   if (prog_has_started)
1361     {
1362       __asm__ __volatile__ ("pushfl ; popl %0" : "=g" (eflags));
1363       printf_filtered ("Protection....................."
1364                        "Ring %d (in %s), with%s I/O protection\n",
1365                        a_tss.tss_cs & 3, (a_tss.tss_cs & 4) ? "LDT" : "GDT",
1366                        (a_tss.tss_cs & 3) > ((eflags >> 12) & 3) ? "" : "out");
1367     }
1368   puts_filtered ("\n");
1369   __dpmi_get_free_memory_information (&mem_info);
1370   print_mem (mem_info.total_number_of_physical_pages,
1371              "DPMI Total Physical Memory.....", 1);
1372   print_mem (mem_info.total_number_of_free_pages,
1373              "DPMI Free Physical Memory......", 1);
1374   print_mem (mem_info.size_of_paging_file_partition_in_pages,
1375              "DPMI Swap Space................", 1);
1376   print_mem (mem_info.linear_address_space_size_in_pages,
1377              "DPMI Total Linear Address Size.", 1);
1378   print_mem (mem_info.free_linear_address_space_in_pages,
1379              "DPMI Free Linear Address Size..", 1);
1380   print_mem (mem_info.largest_available_free_block_in_bytes,
1381              "DPMI Largest Free Memory Block.", 0);
1382
1383   regs.h.ah = 0x48;
1384   regs.x.bx = 0xffff;
1385   __dpmi_int (0x21, &regs);
1386   print_mem (regs.x.bx << 4, "Free DOS Memory................", 0);
1387   regs.x.ax = 0x5800;
1388   __dpmi_int (0x21, &regs);
1389   if ((regs.x.flags & 1) == 0)
1390     {
1391       static const char *dos_hilo[] = {
1392         "Low", "", "", "", "High", "", "", "", "High, then Low"
1393       };
1394       static const char *dos_fit[] = {
1395         "First", "Best", "Last"
1396       };
1397       int hilo_idx = (regs.x.ax >> 4) & 0x0f;
1398       int fit_idx  = regs.x.ax & 0x0f;
1399
1400       if (hilo_idx > 8)
1401         hilo_idx = 0;
1402       if (fit_idx > 2)
1403         fit_idx = 0;
1404       printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1405                        dos_hilo[hilo_idx], dos_fit[fit_idx]);
1406       regs.x.ax = 0x5802;
1407       __dpmi_int (0x21, &regs);
1408       if ((regs.x.flags & 1) != 0)
1409         regs.h.al = 0;
1410       printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1411                         regs.h.al == 0 ? "not " : "");
1412     }
1413 }
1414
1415 struct seg_descr {
1416   unsigned short limit0;
1417   unsigned short base0;
1418   unsigned char  base1;
1419   unsigned       stype:5;
1420   unsigned       dpl:2;
1421   unsigned       present:1;
1422   unsigned       limit1:4;
1423   unsigned       available:1;
1424   unsigned       dummy:1;
1425   unsigned       bit32:1;
1426   unsigned       page_granular:1;
1427   unsigned char  base2;
1428 } __attribute__ ((packed));
1429
1430 struct gate_descr {
1431   unsigned short offset0;
1432   unsigned short selector;
1433   unsigned       param_count:5;
1434   unsigned       dummy:3;
1435   unsigned       stype:5;
1436   unsigned       dpl:2;
1437   unsigned       present:1;
1438   unsigned short offset1;
1439 } __attribute__ ((packed));
1440
1441 /* Read LEN bytes starting at logical address ADDR, and put the result
1442    into DEST.  Return 1 if success, zero if not.  */
1443 static int
1444 read_memory_region (unsigned long addr, void *dest, size_t len)
1445 {
1446   unsigned long dos_ds_limit = __dpmi_get_segment_limit (_dos_ds);
1447   int retval = 1;
1448
1449   /* For the low memory, we can simply use _dos_ds.  */
1450   if (addr <= dos_ds_limit - len)
1451     dosmemget (addr, len, dest);
1452   else
1453     {
1454       /* For memory above 1MB we need to set up a special segment to
1455          be able to access that memory.  */
1456       int sel = __dpmi_allocate_ldt_descriptors (1);
1457
1458       if (sel <= 0)
1459         retval = 0;
1460       else
1461         {
1462           int access_rights = __dpmi_get_descriptor_access_rights (sel);
1463           size_t segment_limit = len - 1;
1464
1465           /* Make sure the crucial bits in the descriptor access
1466              rights are set correctly.  Some DPMI providers might barf
1467              if we set the segment limit to something that is not an
1468              integral multiple of 4KB pages if the granularity bit is
1469              not set to byte-granular, even though the DPMI spec says
1470              it's the host's responsibility to set that bit correctly.  */
1471           if (len > 1024 * 1024)
1472             {
1473               access_rights |= 0x8000;
1474               /* Page-granular segments should have the low 12 bits of
1475                  the limit set.  */
1476               segment_limit |= 0xfff;
1477             }
1478           else
1479             access_rights &= ~0x8000;
1480
1481           if (__dpmi_set_segment_base_address (sel, addr) != -1
1482               && __dpmi_set_descriptor_access_rights (sel, access_rights) != -1
1483               && __dpmi_set_segment_limit (sel, segment_limit) != -1
1484               /* W2K silently fails to set the segment limit, leaving
1485                  it at zero; this test avoids the resulting crash.  */
1486               && __dpmi_get_segment_limit (sel) >= segment_limit)
1487             movedata (sel, 0, _my_ds (), (unsigned)dest, len);
1488           else
1489             retval = 0;
1490
1491           __dpmi_free_ldt_descriptor (sel);
1492         }
1493     }
1494   return retval;
1495 }
1496
1497 /* Get a segment descriptor stored at index IDX in the descriptor
1498    table whose base address is TABLE_BASE.  Return the descriptor
1499    type, or -1 if failure.  */
1500 static int
1501 get_descriptor (unsigned long table_base, int idx, void *descr)
1502 {
1503   unsigned long addr = table_base + idx * 8; /* 8 bytes per entry */
1504
1505   if (read_memory_region (addr, descr, 8))
1506     return (int)((struct seg_descr *)descr)->stype;
1507   return -1;
1508 }
1509
1510 struct dtr_reg {
1511   unsigned short limit __attribute__((packed));
1512   unsigned long  base  __attribute__((packed));
1513 };
1514
1515 /* Display a segment descriptor stored at index IDX in a descriptor
1516    table whose type is TYPE and whose base address is BASE_ADDR.  If
1517    FORCE is non-zero, display even invalid descriptors.  */
1518 static void
1519 display_descriptor (unsigned type, unsigned long base_addr, int idx, int force)
1520 {
1521   struct seg_descr descr;
1522   struct gate_descr gate;
1523
1524   /* Get the descriptor from the table.  */
1525   if (idx == 0 && type == 0)
1526     puts_filtered ("0x000: null descriptor\n");
1527   else if (get_descriptor (base_addr, idx, &descr) != -1)
1528     {
1529       /* For each type of descriptor table, this has a bit set if the
1530          corresponding type of selectors is valid in that table.  */
1531       static unsigned allowed_descriptors[] = {
1532           0xffffdafeL,   /* GDT */
1533           0x0000c0e0L,   /* IDT */
1534           0xffffdafaL    /* LDT */
1535       };
1536
1537       /* If the program hasn't started yet, assume the debuggee will
1538          have the same CPL as the debugger.  */
1539       int cpl = prog_has_started ? (a_tss.tss_cs & 3) : _my_cs () & 3;
1540       unsigned long limit = (descr.limit1 << 16) | descr.limit0;
1541
1542       if (descr.present
1543           && (allowed_descriptors[type] & (1 << descr.stype)) != 0)
1544         {
1545           printf_filtered ("0x%03x: ",
1546                            type == 1
1547                            ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1548           if (descr.page_granular)
1549             limit = (limit << 12) | 0xfff; /* big segment: low 12 bit set */
1550           if (descr.stype == 1 || descr.stype == 2 || descr.stype == 3
1551               || descr.stype == 9 || descr.stype == 11
1552               || (descr.stype >= 16 && descr.stype < 32))
1553             printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1554                              descr.base2, descr.base1, descr.base0, limit);
1555
1556           switch (descr.stype)
1557             {
1558               case 1:
1559               case 3:
1560                 printf_filtered (" 16-bit TSS  (task %sactive)",
1561                                  descr.stype == 3 ? "" : "in");
1562                 break;
1563               case 2:
1564                 puts_filtered (" LDT");
1565                 break;
1566               case 4:
1567                 memcpy (&gate, &descr, sizeof gate);
1568                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1569                                  gate.selector, gate.offset1, gate.offset0);
1570                 printf_filtered (" 16-bit Call Gate (params=%d)",
1571                                  gate.param_count);
1572                 break;
1573               case 5:
1574                 printf_filtered ("TSS selector=0x%04x", descr.base0);
1575                 printfi_filtered (16, "Task Gate");
1576                 break;
1577               case 6:
1578               case 7:
1579                 memcpy (&gate, &descr, sizeof gate);
1580                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1581                                  gate.selector, gate.offset1, gate.offset0);
1582                 printf_filtered (" 16-bit %s Gate",
1583                                  descr.stype == 6 ? "Interrupt" : "Trap");
1584                 break;
1585               case 9:
1586               case 11:
1587                 printf_filtered (" 32-bit TSS (task %sactive)",
1588                                  descr.stype == 3 ? "" : "in");
1589                 break;
1590               case 12:
1591                 memcpy (&gate, &descr, sizeof gate);
1592                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1593                                  gate.selector, gate.offset1, gate.offset0);
1594                 printf_filtered (" 32-bit Call Gate (params=%d)",
1595                                  gate.param_count);
1596                 break;
1597               case 14:
1598               case 15:
1599                 memcpy (&gate, &descr, sizeof gate);
1600                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
1601                                  gate.selector, gate.offset1, gate.offset0);
1602                 printf_filtered (" 32-bit %s Gate",
1603                                  descr.stype == 14 ? "Interrupt" : "Trap");
1604                 break;
1605               case 16:          /* data segments */
1606               case 17:
1607               case 18:
1608               case 19:
1609               case 20:
1610               case 21:
1611               case 22:
1612               case 23:
1613                 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1614                                  descr.bit32 ? "32" : "16",
1615                                  descr.stype & 2
1616                                  ? "Read/Write," : "Read-Only, ",
1617                                  descr.stype & 4 ? "down" : "up",
1618                                  descr.stype & 1 ? "" : ", N.Acc");
1619                 break;
1620               case 24:          /* code segments */
1621               case 25:
1622               case 26:
1623               case 27:
1624               case 28:
1625               case 29:
1626               case 30:
1627               case 31:
1628                 printf_filtered (" %s-bit Code (%s,  %sConf%s)",
1629                                  descr.bit32 ? "32" : "16",
1630                                  descr.stype & 2 ? "Exec/Read" : "Exec-Only",
1631                                  descr.stype & 4 ? "" : "N.",
1632                                  descr.stype & 1 ? "" : ", N.Acc");
1633                 break;
1634               default:
1635                 printf_filtered ("Unknown type 0x%02x", descr.stype);
1636                 break;
1637             }
1638           puts_filtered ("\n");
1639         }
1640       else if (force)
1641         {
1642           printf_filtered ("0x%03x: ",
1643                            type == 1
1644                            ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1645           if (!descr.present)
1646             puts_filtered ("Segment not present\n");
1647           else
1648             printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1649                              descr.stype);
1650         }
1651     }
1652   else if (force)
1653     printf_filtered ("0x%03x: Cannot read this descriptor\n", idx);
1654 }
1655
1656 static void
1657 go32_sldt (char *arg, int from_tty)
1658 {
1659   struct dtr_reg gdtr;
1660   unsigned short ldtr = 0;
1661   int ldt_idx;
1662   struct seg_descr ldt_descr;
1663   long ldt_entry = -1L;
1664   int cpl = (prog_has_started ? a_tss.tss_cs : _my_cs ()) & 3;
1665
1666   if (arg && *arg)
1667     {
1668       arg = skip_spaces (arg);
1669
1670       if (*arg)
1671         {
1672           ldt_entry = parse_and_eval_long (arg);
1673           if (ldt_entry < 0
1674               || (ldt_entry & 4) == 0
1675               || (ldt_entry & 3) != (cpl & 3))
1676             error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry);
1677         }
1678     }
1679
1680   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
1681   __asm__ __volatile__ ("sldt   %0" : "=m" (ldtr) : /* no inputs */ );
1682   ldt_idx = ldtr / 8;
1683   if (ldt_idx == 0)
1684     puts_filtered ("There is no LDT.\n");
1685   /* LDT's entry in the GDT must have the type LDT, which is 2.  */
1686   else if (get_descriptor (gdtr.base, ldt_idx, &ldt_descr) != 2)
1687     printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1688                      ldt_descr.base0
1689                      | (ldt_descr.base1 << 16)
1690                      | (ldt_descr.base2 << 24));
1691   else
1692     {
1693       unsigned base =
1694         ldt_descr.base0
1695         | (ldt_descr.base1 << 16)
1696         | (ldt_descr.base2 << 24);
1697       unsigned limit = ldt_descr.limit0 | (ldt_descr.limit1 << 16);
1698       int max_entry;
1699
1700       if (ldt_descr.page_granular)
1701         /* Page-granular segments must have the low 12 bits of their
1702            limit set.  */
1703         limit = (limit << 12) | 0xfff;
1704       /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1705          64KB.  */
1706       if (limit > 0xffff)
1707         limit = 0xffff;
1708
1709       max_entry = (limit + 1) / 8;
1710
1711       if (ldt_entry >= 0)
1712         {
1713           if (ldt_entry > limit)
1714             error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1715                    (unsigned long)ldt_entry, limit);
1716
1717           display_descriptor (ldt_descr.stype, base, ldt_entry / 8, 1);
1718         }
1719       else
1720         {
1721           int i;
1722
1723           for (i = 0; i < max_entry; i++)
1724             display_descriptor (ldt_descr.stype, base, i, 0);
1725         }
1726     }
1727 }
1728
1729 static void
1730 go32_sgdt (char *arg, int from_tty)
1731 {
1732   struct dtr_reg gdtr;
1733   long gdt_entry = -1L;
1734   int max_entry;
1735
1736   if (arg && *arg)
1737     {
1738       arg = skip_spaces (arg);
1739
1740       if (*arg)
1741         {
1742           gdt_entry = parse_and_eval_long (arg);
1743           if (gdt_entry < 0 || (gdt_entry & 7) != 0)
1744             error (_("Invalid GDT entry 0x%03lx: "
1745                      "not an integral multiple of 8."),
1746                    (unsigned long)gdt_entry);
1747         }
1748     }
1749
1750   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
1751   max_entry = (gdtr.limit + 1) / 8;
1752
1753   if (gdt_entry >= 0)
1754     {
1755       if (gdt_entry > gdtr.limit)
1756         error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1757                (unsigned long)gdt_entry, gdtr.limit);
1758
1759       display_descriptor (0, gdtr.base, gdt_entry / 8, 1);
1760     }
1761   else
1762     {
1763       int i;
1764
1765       for (i = 0; i < max_entry; i++)
1766         display_descriptor (0, gdtr.base, i, 0);
1767     }
1768 }
1769
1770 static void
1771 go32_sidt (char *arg, int from_tty)
1772 {
1773   struct dtr_reg idtr;
1774   long idt_entry = -1L;
1775   int max_entry;
1776
1777   if (arg && *arg)
1778     {
1779       arg = skip_spaces (arg);
1780
1781       if (*arg)
1782         {
1783           idt_entry = parse_and_eval_long (arg);
1784           if (idt_entry < 0)
1785             error (_("Invalid (negative) IDT entry %ld."), idt_entry);
1786         }
1787     }
1788
1789   __asm__ __volatile__ ("sidt   %0" : "=m" (idtr) : /* no inputs */ );
1790   max_entry = (idtr.limit + 1) / 8;
1791   if (max_entry > 0x100)        /* No more than 256 entries.  */
1792     max_entry = 0x100;
1793
1794   if (idt_entry >= 0)
1795     {
1796       if (idt_entry > idtr.limit)
1797         error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1798                (unsigned long)idt_entry, idtr.limit);
1799
1800       display_descriptor (1, idtr.base, idt_entry, 1);
1801     }
1802   else
1803     {
1804       int i;
1805
1806       for (i = 0; i < max_entry; i++)
1807         display_descriptor (1, idtr.base, i, 0);
1808     }
1809 }
1810
1811 /* Cached linear address of the base of the page directory.  For
1812    now, available only under CWSDPMI.  Code based on ideas and
1813    suggestions from Charles Sandmann <sandmann@clio.rice.edu>.  */
1814 static unsigned long pdbr;
1815
1816 static unsigned long
1817 get_cr3 (void)
1818 {
1819   unsigned offset;
1820   unsigned taskreg;
1821   unsigned long taskbase, cr3;
1822   struct dtr_reg gdtr;
1823
1824   if (pdbr > 0 && pdbr <= 0xfffff)
1825     return pdbr;
1826
1827   /* Get the linear address of GDT and the Task Register.  */
1828   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
1829   __asm__ __volatile__ ("str    %0" : "=m" (taskreg) : /* no inputs */ );
1830
1831   /* Task Register is a segment selector for the TSS of the current
1832      task.  Therefore, it can be used as an index into the GDT to get
1833      at the segment descriptor for the TSS.  To get the index, reset
1834      the low 3 bits of the selector (which give the CPL).  Add 2 to the
1835      offset to point to the 3 low bytes of the base address.  */
1836   offset = gdtr.base + (taskreg & 0xfff8) + 2;
1837
1838
1839   /* CWSDPMI's task base is always under the 1MB mark.  */
1840   if (offset > 0xfffff)
1841     return 0;
1842
1843   _farsetsel (_dos_ds);
1844   taskbase  = _farnspeekl (offset) & 0xffffffU;
1845   taskbase += _farnspeekl (offset + 2) & 0xff000000U;
1846   if (taskbase > 0xfffff)
1847     return 0;
1848
1849   /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1850      offset 1Ch in the TSS.  */
1851   cr3 = _farnspeekl (taskbase + 0x1c) & ~0xfff;
1852   if (cr3 > 0xfffff)
1853     {
1854 #if 0  /* Not fullly supported yet.  */
1855       /* The Page Directory is in UMBs.  In that case, CWSDPMI puts
1856          the first Page Table right below the Page Directory.  Thus,
1857          the first Page Table's entry for its own address and the Page
1858          Directory entry for that Page Table will hold the same
1859          physical address.  The loop below searches the entire UMB
1860          range of addresses for such an occurence.  */
1861       unsigned long addr, pte_idx;
1862
1863       for (addr = 0xb0000, pte_idx = 0xb0;
1864            pte_idx < 0xff;
1865            addr += 0x1000, pte_idx++)
1866         {
1867           if (((_farnspeekl (addr + 4 * pte_idx) & 0xfffff027) ==
1868                (_farnspeekl (addr + 0x1000) & 0xfffff027))
1869               && ((_farnspeekl (addr + 4 * pte_idx + 4) & 0xfffff000) == cr3))
1870             {
1871               cr3 = addr + 0x1000;
1872               break;
1873             }
1874         }
1875 #endif
1876
1877       if (cr3 > 0xfffff)
1878         cr3 = 0;
1879     }
1880
1881   return cr3;
1882 }
1883
1884 /* Return the N'th Page Directory entry.  */
1885 static unsigned long
1886 get_pde (int n)
1887 {
1888   unsigned long pde = 0;
1889
1890   if (pdbr && n >= 0 && n < 1024)
1891     {
1892       pde = _farpeekl (_dos_ds, pdbr + 4*n);
1893     }
1894   return pde;
1895 }
1896
1897 /* Return the N'th entry of the Page Table whose Page Directory entry
1898    is PDE.  */
1899 static unsigned long
1900 get_pte (unsigned long pde, int n)
1901 {
1902   unsigned long pte = 0;
1903
1904   /* pde & 0x80 tests the 4MB page bit.  We don't support 4MB
1905      page tables, for now.  */
1906   if ((pde & 1) && !(pde & 0x80) && n >= 0 && n < 1024)
1907     {
1908       pde &= ~0xfff;    /* Clear non-address bits.  */
1909       pte = _farpeekl (_dos_ds, pde + 4*n);
1910     }
1911   return pte;
1912 }
1913
1914 /* Display a Page Directory or Page Table entry.  IS_DIR, if non-zero,
1915    says this is a Page Directory entry.  If FORCE is non-zero, display
1916    the entry even if its Present flag is off.  OFF is the offset of the
1917    address from the page's base address.  */
1918 static void
1919 display_ptable_entry (unsigned long entry, int is_dir, int force, unsigned off)
1920 {
1921   if ((entry & 1) != 0)
1922     {
1923       printf_filtered ("Base=0x%05lx000", entry >> 12);
1924       if ((entry & 0x100) && !is_dir)
1925         puts_filtered (" Global");
1926       if ((entry & 0x40) && !is_dir)
1927         puts_filtered (" Dirty");
1928       printf_filtered (" %sAcc.", (entry & 0x20) ? "" : "Not-");
1929       printf_filtered (" %sCached", (entry & 0x10) ? "" : "Not-");
1930       printf_filtered (" Write-%s", (entry & 8) ? "Thru" : "Back");
1931       printf_filtered (" %s", (entry & 4) ? "Usr" : "Sup");
1932       printf_filtered (" Read-%s", (entry & 2) ? "Write" : "Only");
1933       if (off)
1934         printf_filtered (" +0x%x", off);
1935       puts_filtered ("\n");
1936     }
1937   else if (force)
1938     printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1939                      is_dir ? " Table" : "", entry >> 1);
1940 }
1941
1942 static void
1943 go32_pde (char *arg, int from_tty)
1944 {
1945   long pde_idx = -1, i;
1946
1947   if (arg && *arg)
1948     {
1949       arg = skip_spaces (arg);
1950
1951       if (*arg)
1952         {
1953           pde_idx = parse_and_eval_long (arg);
1954           if (pde_idx < 0 || pde_idx >= 1024)
1955             error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
1956         }
1957     }
1958
1959   pdbr = get_cr3 ();
1960   if (!pdbr)
1961     puts_filtered ("Access to Page Directories is "
1962                    "not supported on this system.\n");
1963   else if (pde_idx >= 0)
1964     display_ptable_entry (get_pde (pde_idx), 1, 1, 0);
1965   else
1966     for (i = 0; i < 1024; i++)
1967       display_ptable_entry (get_pde (i), 1, 0, 0);
1968 }
1969
1970 /* A helper function to display entries in a Page Table pointed to by
1971    the N'th entry in the Page Directory.  If FORCE is non-zero, say
1972    something even if the Page Table is not accessible.  */
1973 static void
1974 display_page_table (long n, int force)
1975 {
1976   unsigned long pde = get_pde (n);
1977
1978   if ((pde & 1) != 0)
1979     {
1980       int i;
1981
1982       printf_filtered ("Page Table pointed to by "
1983                        "Page Directory entry 0x%lx:\n", n);
1984       for (i = 0; i < 1024; i++)
1985         display_ptable_entry (get_pte (pde, i), 0, 0, 0);
1986       puts_filtered ("\n");
1987     }
1988   else if (force)
1989     printf_filtered ("Page Table not present; value=0x%lx.\n", pde >> 1);
1990 }
1991
1992 static void
1993 go32_pte (char *arg, int from_tty)
1994 {
1995   long pde_idx = -1L, i;
1996
1997   if (arg && *arg)
1998     {
1999       arg = skip_spaces (arg);
2000
2001       if (*arg)
2002         {
2003           pde_idx = parse_and_eval_long (arg);
2004           if (pde_idx < 0 || pde_idx >= 1024)
2005             error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
2006         }
2007     }
2008
2009   pdbr = get_cr3 ();
2010   if (!pdbr)
2011     puts_filtered ("Access to Page Tables is not supported on this system.\n");
2012   else if (pde_idx >= 0)
2013     display_page_table (pde_idx, 1);
2014   else
2015     for (i = 0; i < 1024; i++)
2016       display_page_table (i, 0);
2017 }
2018
2019 static void
2020 go32_pte_for_address (char *arg, int from_tty)
2021 {
2022   CORE_ADDR addr = 0, i;
2023
2024   if (arg && *arg)
2025     {
2026       arg = skip_spaces (arg);
2027
2028       if (*arg)
2029         addr = parse_and_eval_address (arg);
2030     }
2031   if (!addr)
2032     error_no_arg (_("linear address"));
2033
2034   pdbr = get_cr3 ();
2035   if (!pdbr)
2036     puts_filtered ("Access to Page Tables is not supported on this system.\n");
2037   else
2038     {
2039       int pde_idx = (addr >> 22) & 0x3ff;
2040       int pte_idx = (addr >> 12) & 0x3ff;
2041       unsigned offs = addr & 0xfff;
2042
2043       printf_filtered ("Page Table entry for address %s:\n",
2044                        hex_string(addr));
2045       display_ptable_entry (get_pte (get_pde (pde_idx), pte_idx), 0, 1, offs);
2046     }
2047 }
2048
2049 static struct cmd_list_element *info_dos_cmdlist = NULL;
2050
2051 static void
2052 go32_info_dos_command (char *args, int from_tty)
2053 {
2054   help_list (info_dos_cmdlist, "info dos ", class_info, gdb_stdout);
2055 }
2056
2057 /* -Wmissing-prototypes */
2058 extern initialize_file_ftype _initialize_go32_nat;
2059
2060 void
2061 _initialize_go32_nat (void)
2062 {
2063   struct target_ops *t = go32_target ();
2064
2065   x86_dr_low.set_control = go32_set_dr7;
2066   x86_dr_low.set_addr = go32_set_dr;
2067   x86_dr_low.get_status = go32_get_dr6;
2068   x86_dr_low.get_control = go32_get_dr7;
2069   x86_dr_low.get_addr = go32_get_dr;
2070   x86_set_debug_register_length (4);
2071
2072   x86_use_watchpoints (t);
2073   add_target (t);
2074
2075   /* Initialize child's cwd as empty to be initialized when starting
2076      the child.  */
2077   *child_cwd = 0;
2078
2079   /* Initialize child's command line storage.  */
2080   if (redir_debug_init (&child_cmd) == -1)
2081     internal_error (__FILE__, __LINE__,
2082                     _("Cannot allocate redirection storage: "
2083                       "not enough memory.\n"));
2084
2085   /* We are always processing GCC-compiled programs.  */
2086   processing_gcc_compilation = 2;
2087
2088   add_prefix_cmd ("dos", class_info, go32_info_dos_command, _("\
2089 Print information specific to DJGPP (aka MS-DOS) debugging."),
2090                   &info_dos_cmdlist, "info dos ", 0, &infolist);
2091
2092   add_cmd ("sysinfo", class_info, go32_sysinfo, _("\
2093 Display information about the target system, including CPU, OS, DPMI, etc."),
2094            &info_dos_cmdlist);
2095   add_cmd ("ldt", class_info, go32_sldt, _("\
2096 Display entries in the LDT (Local Descriptor Table).\n\
2097 Entry number (an expression) as an argument means display only that entry."),
2098            &info_dos_cmdlist);
2099   add_cmd ("gdt", class_info, go32_sgdt, _("\
2100 Display entries in the GDT (Global Descriptor Table).\n\
2101 Entry number (an expression) as an argument means display only that entry."),
2102            &info_dos_cmdlist);
2103   add_cmd ("idt", class_info, go32_sidt, _("\
2104 Display entries in the IDT (Interrupt Descriptor Table).\n\
2105 Entry number (an expression) as an argument means display only that entry."),
2106            &info_dos_cmdlist);
2107   add_cmd ("pde", class_info, go32_pde, _("\
2108 Display entries in the Page Directory.\n\
2109 Entry number (an expression) as an argument means display only that entry."),
2110            &info_dos_cmdlist);
2111   add_cmd ("pte", class_info, go32_pte, _("\
2112 Display entries in Page Tables.\n\
2113 Entry number (an expression) as an argument means display only entries\n\
2114 from the Page Table pointed to by the specified Page Directory entry."),
2115            &info_dos_cmdlist);
2116   add_cmd ("address-pte", class_info, go32_pte_for_address, _("\
2117 Display a Page Table entry for a linear address.\n\
2118 The address argument must be a linear address, after adding to\n\
2119 it the base address of the appropriate segment.\n\
2120 The base address of variables and functions in the debuggee's data\n\
2121 or code segment is stored in the variable __djgpp_base_address,\n\
2122 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
2123 For other segments, look up their base address in the output of\n\
2124 the `info dos ldt' command."),
2125            &info_dos_cmdlist);
2126 }
2127
2128 pid_t
2129 tcgetpgrp (int fd)
2130 {
2131   if (isatty (fd))
2132     return SOME_PID;
2133   errno = ENOTTY;
2134   return -1;
2135 }
2136
2137 int
2138 tcsetpgrp (int fd, pid_t pgid)
2139 {
2140   if (isatty (fd) && pgid == SOME_PID)
2141     return 0;
2142   errno = pgid == SOME_PID ? ENOTTY : ENOSYS;
2143   return -1;
2144 }