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