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