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