GDB (xrefs)

/tmp/gdb-8.1/gdb/go32-nat.c
Go to the documentation of this file.
1 /* Native debugging support for Intel x86 running DJGPP.
2 Copyright (C) 1997-2018 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 }
error_no_arg
void error_no_arg(const char *why)
Definition: cli-cmds.c:185
gdbarch
Definition: gdbarch.c:127
top.h
string
const char * string
Definition: signals.c:50
add_target
void add_target(struct target_ops *t)
Definition: target.c:395
i387_collect_fsave
void i387_collect_fsave(const struct regcache *regcache, int regnum, void *fsave)
Definition: i387-tdep.c:493
go32_thread_alive
static int go32_thread_alive(struct target_ops *ops, ptid_t ptid)
Definition: go32-nat.c:941
hex_string
char * hex_string(LONGEST num)
Definition: print-utils.c:220
read_memory_region
static int read_memory_region(unsigned long addr, void *dest, size_t len)
Definition: go32-nat.c:1448
nl_item
int nl_item
Definition: nl_types.h:23
display_descriptor
static void display_descriptor(unsigned type, unsigned long base_addr, int idx, int force)
Definition: go32-nat.c:1523
x86_cpuid
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
redir_debug_init
int redir_debug_init(cmdline_t *ptr)
Definition: go32-nat.c:221
gate_descr::selector
unsigned short selector
Definition: go32-nat.c:1436
go32_wait
static ptid_t go32_wait(struct target_ops *ops, ptid_t ptid, struct target_waitstatus *status, int options)
Definition: go32-nat.c:375
go32_set_dr7
static void go32_set_dr7(unsigned long val)
Definition: go32-nat.c:775
windows_minor
unsigned short windows_minor
Definition: go32-nat.c:1021
target_waitstatus
Definition: waitstatus.h:104
load_npx
static void load_npx(void)
Definition: go32-nat.c:185
go32_info_dos_command
static void go32_info_dos_command(const char *args, int from_tty)
Definition: go32-nat.c:2056
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
go32_store_registers
static void go32_store_registers(struct target_ops *ops, struct regcache *regcache, int regno)
Definition: go32-nat.c:540
insert_breakpoints
void insert_breakpoints(void)
Definition: breakpoint.c:2845
resume_is_step
static int resume_is_step
Definition: go32-nat.c:346
command.h
print_mem
static void print_mem(unsigned long datum, const char *header, int in_pages_p)
Definition: go32-nat.c:1043
xfree
void xfree(void *)
go32_fetch_registers
static void go32_fetch_registers(struct target_ops *ops, struct regcache *regcache, int regno)
Definition: go32-nat.c:509
seg_descr::present
unsigned present
Definition: go32-nat.c:1425
go32_get_dr7
static unsigned long go32_get_dr7(void)
Definition: go32-nat.c:794
NPXREG::sig0
unsigned short sig0
Definition: go32-nat.c:128
terminal_is_ours
static int terminal_is_ours
Definition: go32-nat.c:853
cmd_list_element
Definition: cli-decode.h:46
if
if(!(yy_init))
Definition: ada-lex.c:1075
processing_gcc_compilation
EXTERN unsigned char processing_gcc_compilation
Definition: buildsym.h:81
gate_descr::offset0
unsigned short offset0
Definition: go32-nat.c:1435
SOME_PID
#define SOME_PID
Definition: go32-nat.c:232
go32_set_dr
static void go32_set_dr(int i, CORE_ADDR addr)
Definition: go32-nat.c:763
seg_descr::base1
unsigned char base1
Definition: go32-nat.c:1422
target_ops::to_terminal_init
void(* to_terminal_init)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:560
push_target
void push_target(struct target_ops *t)
Definition: target.c:642
delete_thread_silent
void delete_thread_silent(ptid_t)
Definition: thread.c:482
get_exec_file
char * get_exec_file(int err)
Definition: corefile.c:167
cmdline_t
Definition: go32-nat.c:191
D_REGS
#define D_REGS
Definition: go32-nat.c:755
display_ptable_entry
static void display_ptable_entry(unsigned long entry, int is_dir, int force, unsigned off)
Definition: go32-nat.c:1923
go32_terminal_info
static void go32_terminal_info(struct target_ops *self, const char *args, int from_tty)
Definition: go32-nat.c:863
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
target_ops::to_terminal_ours_for_output
void(* to_terminal_ours_for_output)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:564
dr_ref_count
static int dr_ref_count[4]
Definition: go32-nat.c:230
generic_mourn_inferior
void generic_mourn_inferior(void)
Definition: target.c:3198
inferior
Definition: inferior.h:310
target_ops::to_pid_to_str
const char *(* to_pid_to_str)(struct target_ops *, ptid_t) TARGET_DEFAULT_FUNC(default_pid_to_str)
Definition: target.h:630
inf_terminal_mode
static int inf_terminal_mode
Definition: go32-nat.c:847
_initialize_go32_nat
void _initialize_go32_nat(void)
Definition: go32-nat.c:2062
display_page_table
static void display_page_table(long n, int force)
Definition: go32-nat.c:1978
add_cmd
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:262
NPX
Definition: go32-nat.c:137
r_ofs
#define r_ofs(x)
Definition: go32-nat.c:237
i386_fp_regnum_p
int i386_fp_regnum_p(struct gdbarch *gdbarch, int regnum)
Definition: i386-tdep.c:367
sig_map
static struct @71 sig_map[]
cmdline_t::redirected
int redirected
Definition: go32-nat.c:193
go32_sysinfo
static void go32_sysinfo(const char *arg, int from_tty)
Definition: go32-nat.c:1064
seg_descr::stype
unsigned stype
Definition: go32-nat.c:1423
wp_remove
Definition: go32-nat.c:227
seg_descr::base0
unsigned short base0
Definition: go32-nat.c:1421
i387_supply_fsave
void i387_supply_fsave(struct regcache *regcache, int regnum, const void *fsave)
Definition: i387-tdep.c:438
skip_spaces
char * skip_spaces(char *chp)
Definition: common-utils.c:337
go32_get_dr
static CORE_ADDR go32_get_dr(int i)
Definition: go32-nat.c:804
_
#define _(String)
Definition: gdb_locale.h:35
x86_dr_low_type::set_control
void(* set_control)(unsigned long)
Definition: x86-dregs.h:44
defs.h
go32_pte
static void go32_pte(const char *arg, int from_tty)
Definition: go32-nat.c:1997
redir_to_debugger
int redir_to_debugger(cmdline_t *ptr)
Definition: go32-nat.c:215
x86_dr_low
struct x86_dr_low_type x86_dr_low
Definition: x86-nat.c:37
inf_child_maybe_unpush_target
void inf_child_maybe_unpush_target(struct target_ops *ops)
Definition: inf-child.c:172
go32_files_info
static void go32_files_info(struct target_ops *target)
Definition: go32-nat.c:622
x86_dr_low_type::get_addr
CORE_ADDR(* get_addr)(int)
Definition: x86-dregs.h:52
arm-linux.inf
inf
Definition: arm-linux.py:13
my_write_child
static int my_write_child(unsigned child_addr, const void *buf, unsigned len)
Definition: go32-nat.c:559
class_info
Definition: command.h:42
djgpp_excepno
int djgpp_excepno
Definition: go32-nat.c:320
device_mode
static int device_mode(int fd, int raw_p)
Definition: go32-nat.c:816
i386_fpc_regnum_p
int i386_fpc_regnum_p(struct gdbarch *gdbarch, int regnum)
Definition: i386-tdep.c:379
seg_descr::limit0
unsigned short limit0
Definition: go32-nat.c:1420
printf_filtered
void printf_filtered(const char *format,...)
Definition: utils.c:2045
nl_langinfo
char * nl_langinfo(nl_item item)
Definition: go32-nat.c:996
target_ops::to_files_info
void(* to_files_info)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:464
add_prefix_cmd
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_const_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:367
seg_descr::page_granular
unsigned page_granular
Definition: go32-nat.c:1430
seg_descr::limit1
unsigned limit1
Definition: go32-nat.c:1426
normal_pid_to_str
const char * normal_pid_to_str(ptid_t ptid)
Definition: target.c:3234
NPX::dataptr
unsigned int dataptr
Definition: go32-nat.c:144
TARGET_WAITKIND_SIGNALLED
Definition: waitstatus.h:39
go32_terminal_inferior
static void go32_terminal_inferior(struct target_ops *self)
Definition: go32-nat.c:893
infolist
struct cmd_list_element * infolist
Definition: cli-cmds.c:83
x86_dr_low_type::set_addr
void(* set_addr)(int, CORE_ADDR)
Definition: x86-dregs.h:48
get_pte
static unsigned long get_pte(unsigned long pde, int n)
Definition: go32-nat.c:1904
go32_pde
static void go32_pde(const char *arg, int from_tty)
Definition: go32-nat.c:1947
fetch_register
static void fetch_register(struct regcache *regcache, int regno)
Definition: go32-nat.c:494
dos_codepage
static int dos_codepage(void)
Definition: go32-nat.c:982
CODESET
Definition: langinfo.h:26
go32_xfer_partial
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
get_descriptor
static int get_descriptor(unsigned long table_base, int idx, void *descr)
Definition: go32-nat.c:1505
x86_dr_low_type::get_status
unsigned long(* get_status)(void)
Definition: x86-dregs.h:56
target_ops
Definition: target.h:412
redir_cmdline_parse
int redir_cmdline_parse(const char *args, cmdline_t *ptr)
Definition: go32-nat.c:203
NPXREG::sig2
unsigned short sig2
Definition: go32-nat.c:130
TARGET_OBJECT_MEMORY
Definition: target.h:139
resume_signal
static int resume_signal
Definition: go32-nat.c:347
regcache.h
buildsym.h
seg_descr::available
unsigned available
Definition: go32-nat.c:1427
ptid_t
Definition: ptid.h:35
target_ops::to_resume
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:447
NPXREG::sig1
unsigned short sig1
Definition: go32-nat.c:129
cli-utils.h
puts_filtered
void puts_filtered(const char *string)
Definition: utils.c:2085
child_cmd
static cmdline_t child_cmd
Definition: go32-nat.c:619
pid_to_ptid
ptid_t pid_to_ptid(int pid)
Definition: ptid.c:39
gdbthread.h
inferior.h
TARGET_XFER_OK
Definition: target.h:209
target_xfer_status
target_xfer_status
Definition: target.h:206
langinfo.h
windows_major
unsigned short windows_major
Definition: go32-nat.c:1021
infrun.h
type
Definition: gdbtypes.h:749
x86-nat.h
dtr_reg::__attribute__
unsigned short limit __attribute__((packed))
inf
Definition: gnu-nat.c:174
wp_insert
Definition: go32-nat.c:227
seg_descr::dpl
unsigned dpl
Definition: go32-nat.c:1424
go32_get_windows_version
static void go32_get_windows_version(void)
Definition: go32-nat.c:1025
go32_sldt
static void go32_sldt(const char *arg, int from_tty)
Definition: go32-nat.c:1661
gate_descr::stype
unsigned stype
Definition: go32-nat.c:1439
dtr_reg
Definition: go32-nat.c:1514
status
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition: gnu-nat.c:1822
go32_sig
int go32_sig
Definition: go32-nat.c:284
info_dos_cmdlist
static struct cmd_list_element * info_dos_cmdlist
Definition: go32-nat.c:2053
NPX::eip
unsigned int eip
Definition: go32-nat.c:142
add_thread_silent
struct thread_info * add_thread_silent(ptid_t ptid)
Definition: thread.c:266
gdb_signal_to_name
const char * gdb_signal_to_name(enum gdb_signal)
Definition: signals.c:78
NPX::status
unsigned int status
Definition: go32-nat.c:140
target_ops::to_xfer_partial
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:739
gate_descr
Definition: go32-nat.c:1434
gate_descr::offset1
unsigned short offset1
Definition: go32-nat.c:1442
printf_unfiltered
void printf_unfiltered(const char *format,...)
Definition: utils.c:2056
NPXREG::sig3
unsigned short sig3
Definition: go32-nat.c:131
printfi_filtered
void printfi_filtered(int spaces, const char *format,...)
Definition: utils.c:2069
go32_xfer_memory
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
__attribute__
struct dtr_reg __attribute__
xmalloc
void * xmalloc(YYSIZE_T)
x86_dr_low_type::get_control
unsigned long(* get_control)(void)
Definition: x86-dregs.h:60
gdb_sig
enum gdb_signal gdb_sig
Definition: go32-nat.c:285
target_object
target_object
Definition: target.h:132
target_is_pushed
int target_is_pushed(struct target_ops *t)
Definition: target.c:767
reg
Definition: regdef.h:22
redir_cmdline_delete
void redir_cmdline_delete(cmdline_t *ptr)
Definition: go32-nat.c:197
go32_kill_inferior
static void go32_kill_inferior(struct target_ops *ops)
Definition: go32-nat.c:628
xrealloc
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:52
go32_create_inferior
static void go32_create_inferior(struct target_ops *ops, const char *exec_file, const std::string &allargs, char **env, int from_tty)
Definition: go32-nat.c:634
current_directory
char * current_directory
Definition: top.c:133
NPX::tag
unsigned int tag
Definition: go32-nat.c:141
environ
char ** environ
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
inf_child_target
struct target_ops * inf_child_target(void)
Definition: inf-child.c:393
go32_sgdt
static void go32_sgdt(const char *arg, int from_tty)
Definition: go32-nat.c:1734
help_list
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1071
excepn_map
static struct @72 excepn_map[]
CONTROL
#define CONTROL
Definition: go32-nat.c:756
null_ptid
ptid_t null_ptid
Definition: ptid.c:25
NPX::cs
unsigned int cs
Definition: go32-nat.c:143
target_ops::to_fetch_registers
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:457
target_ops::to_mourn_inferior
void(* to_mourn_inferior)(struct target_ops *) TARGET_DEFAULT_FUNC(default_mourn_inferior)
Definition: target.h:606
NPXREG
Definition: go32-nat.c:126
seg_descr::bit32
unsigned bit32
Definition: go32-nat.c:1429
prog_has_started
static int prog_has_started
Definition: go32-nat.c:234
go32_sidt
static void go32_sidt(const char *arg, int from_tty)
Definition: go32-nat.c:1775
pdbr
static unsigned long pdbr
Definition: go32-nat.c:1818
gdbarch_fp0_regnum
int gdbarch_fp0_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:2197
STATUS
#define STATUS
Definition: go32-nat.c:757
gdbcore.h
child_cwd
static char child_cwd[FILENAME_MAX]
Definition: go32-nat.c:372
xsnprintf
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
parse_and_eval_address
CORE_ADDR parse_and_eval_address(const char *exp)
Definition: eval.c:101
clear_proceed_status
void clear_proceed_status(int step)
Definition: infrun.c:2860
target_ops::to_kill
void(* to_kill)(struct target_ops *) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:570
x86-cpuid.h
redir_to_child
int redir_to_child(cmdline_t *ptr)
Definition: go32-nat.c:209
inferior_ptid
ptid_t inferior_ptid
Definition: infcmd.c:94
store_register
static void store_register(const struct regcache *regcache, int regno)
Definition: go32-nat.c:525
safe_strerror
char * safe_strerror(int)
Definition: mingw-strerror.c:32
seg_descr
Definition: go32-nat.c:1419
offset
int offset
Definition: agent.c:65
TARGET_WAITKIND_EXITED
Definition: waitstatus.h:31
buffer
Definition: buffer.h:23
regcache::arch
gdbarch * arch() const
Definition: regcache.c:221
NPX::datasel
unsigned int datasel
Definition: go32-nat.c:145
value.h
gate_descr::present
unsigned present
Definition: go32-nat.c:1441
gate_descr::param_count
unsigned param_count
Definition: go32-nat.c:1437
save_npx
static void save_npx(void)
Definition: go32-nat.c:160
target_ops::to_terminal_ours
void(* to_terminal_ours)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:566
ptid_equal
int ptid_equal(const ptid_t &ptid1, const ptid_t &ptid2)
Definition: ptid.c:71
current_inferior
struct inferior * current_inferior(void)
Definition: inferior.c:58
regcache_raw_supply
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1004
target_ops::to_terminal_inferior
void(* to_terminal_inferior)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:562
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
x86_set_debug_register_length
void x86_set_debug_register_length(int len)
Definition: x86-nat.c:303
regcache
Definition: regcache.h:232
gdb_wait.h
get_pde
static unsigned long get_pde(int n)
Definition: go32-nat.c:1890
inf-child.h
L
Definition: ia64-tdep.c:84
regcache_raw_collect
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
Definition: regcache.c:1085
wp_op
wp_op
Definition: go32-nat.c:227
x86_use_watchpoints
void x86_use_watchpoints(struct target_ops *t)
Definition: x86-nat.c:285
inferior::args
char * args
Definition: inferior.h:352
tcsetpgrp
int tcsetpgrp(int fd, pid_t pgid)
Definition: go32-nat.c:2139
tcgetpgrp
pid_t tcgetpgrp(int fd)
Definition: go32-nat.c:2130
target_ops::to_create_inferior
void(* to_create_inferior)(struct target_ops *, const char *, const std::string &, char **, int)
Definition: target.h:579
regno_mapping
static struct @70 regno_mapping[]
target_ops::to_thread_alive
int(* to_thread_alive)(struct target_ops *, ptid_t ptid) TARGET_DEFAULT_RETURN(0)
Definition: target.h:626
go32_terminal_ours
static void go32_terminal_ours(struct target_ops *self)
Definition: go32-nat.c:914
go32_terminal_init
static void go32_terminal_init(struct target_ops *self)
Definition: go32-nat.c:856
target_ops::to_attach
void(* to_attach)(struct target_ops *ops, const char *, int)
Definition: target.h:440
go32_resume
static void go32_resume(struct target_ops *ops, ptid_t ptid, int step, enum gdb_signal siggnal)
Definition: go32-nat.c:350
go32_pte_for_address
static void go32_pte_for_address(const char *arg, int from_tty)
Definition: go32-nat.c:2024
go32_get_dr6
static unsigned long go32_get_dr6(void)
Definition: go32-nat.c:784
NPXREG::exponent
unsigned short exponent
Definition: go32-nat.c:132
x86_cleanup_dregs
void x86_cleanup_dregs(void)
Definition: x86-nat.c:139
inf_mode_valid
static int inf_mode_valid
Definition: go32-nat.c:846
go32_pid_to_str
static const char * go32_pid_to_str(struct target_ops *ops, ptid_t ptid)
Definition: go32-nat.c:947
seg_descr::base2
unsigned char base2
Definition: go32-nat.c:1431
i386-tdep.h
gate_descr::dpl
unsigned dpl
Definition: go32-nat.c:1440
i387-tdep.h
target_ops::to_store_registers
void(* to_store_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:459
cmdline_t::command
char * command
Definition: go32-nat.c:192
go32_mourn_inferior
static void go32_mourn_inferior(struct target_ops *ops)
Definition: go32-nat.c:725
target_ops::to_wait
ptid_t(* to_wait)(struct target_ops *, ptid_t, struct target_waitstatus *, int TARGET_DEBUG_PRINTER(target_debug_print_options)) TARGET_DEFAULT_FUNC(default_target_wait)
Definition: target.h:453
TARGET_WAITKIND_STOPPED
Definition: waitstatus.h:35
wp_count
Definition: go32-nat.c:227
go32_target
static struct target_ops * go32_target(void)
Definition: go32-nat.c:955
gdbcmd.h
error
void error(const char *fmt,...)
Definition: errors.c:38
size
size_t size
Definition: go32-nat.c:242
gate_descr::dummy
unsigned dummy
Definition: go32-nat.c:1438
TARGET_XFER_E_IO
Definition: target.h:220
target_ops::beneath
struct target_ops * beneath
Definition: target.h:414
get_cr3
static unsigned long get_cr3(void)
Definition: go32-nat.c:1821
inferior_appeared
void inferior_appeared(struct inferior *inf, int pid)
Definition: inferior.c:268
NPX::control
unsigned int control
Definition: go32-nat.c:139
target_ops::to_terminal_info
void(* to_terminal_info)(struct target_ops *, const char *, int) TARGET_DEFAULT_FUNC(default_terminal_info)
Definition: target.h:568
go32_attach
static void go32_attach(struct target_ops *ops, const char *args, int from_tty)
Definition: go32-nat.c:339
NPXREG::sign
unsigned short sign
Definition: go32-nat.c:133
tss_ofs
size_t tss_ofs
Definition: go32-nat.c:241
seg_descr::dummy
unsigned dummy
Definition: go32-nat.c:1428
gdb_stdout
#define gdb_stdout
Definition: utils.h:340
npx
static NPX npx
Definition: go32-nat.c:150
parse_and_eval_long
LONGEST parse_and_eval_long(const char *exp)
Definition: eval.c:111