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