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