1 /* Native debugging support for Intel x86 running DJGPP.
2 Copyright (C) 1997-2018 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.
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/>. */
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
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:
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)
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.
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!
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.
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
91 #include "gdbthread.h"
96 #include "floatformat.h"
98 #include "i387-tdep.h"
99 #include "i386-tdep.h"
100 #include "nat/x86-cpuid.h"
102 #include "regcache.h"
104 #include "cli/cli-utils.h"
105 #include "inf-child.h"
109 #include <sys/utsname.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>
121 #include <langinfo.h>
123 #if __DJGPP_MINOR__ < 3
124 /* This code will be provided from DJGPP 2.03 on. Until then I code it
132 unsigned short exponent:15;
133 unsigned short sign:1;
139 unsigned int control;
144 unsigned int dataptr;
145 unsigned int datasel;
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. */
155 /* ------------------------------------------------------------------------- */
156 /* Store the contents of the NPX in the global variable `npx'. */
162 asm ("inb $0xa0, %%al \n\
163 testb $0x20, %%al \n\
181 /* ------------------------------------------------------------------------- */
182 /* Reload the contents of the NPX from the global variable `npx'. */
187 asm ("frstor %0":"=m" (npx));
189 /* ------------------------------------------------------------------------- */
190 /* Stubs for the missing redirection functions. */
197 redir_cmdline_delete (cmdline_t *ptr)
203 redir_cmdline_parse (const char *args, cmdline_t *ptr)
209 redir_to_child (cmdline_t *ptr)
215 redir_to_debugger (cmdline_t *ptr)
221 redir_debug_init (cmdline_t *ptr)
225 #endif /* __DJGPP_MINOR < 3 */
227 typedef enum { wp_insert, wp_remove, wp_count } wp_op;
229 /* This holds the current reference counts for each debug register. */
230 static int dr_ref_count[4];
234 static int prog_has_started = 0;
235 static void go32_mourn_inferior (struct target_ops *ops);
237 #define r_ofs(x) (offsetof(TSS,x))
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},
262 {0, 10}, /* 8 FP registers, from npx.reg[] */
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 */
285 enum gdb_signal gdb_sig;
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. */
295 {3, GDB_SIGNAL_TRAP},
297 {5, GDB_SIGNAL_SEGV},
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}
319 enum gdb_signal gdb_sig;
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
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}
339 go32_attach (struct target_ops *ops, const char *args, int from_tty)
342 You cannot attach to a running program on this platform.\n\
343 Use the `run' command to run DJGPP programs."));
346 static int resume_is_step;
347 static int resume_signal = -1;
350 go32_resume (struct target_ops *ops,
351 ptid_t ptid, int step, enum gdb_signal siggnal)
355 resume_is_step = step;
357 if (siggnal != GDB_SIGNAL_0 && siggnal != GDB_SIGNAL_TRAP)
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)
363 resume_signal = excepn_map[i].djgpp_excepno;
366 if (resume_signal == -1)
367 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
368 gdb_signal_to_name (siggnal));
372 static char child_cwd[FILENAME_MAX];
375 go32_wait (struct target_ops *ops,
376 ptid_t ptid, struct target_waitstatus *status, int options)
379 unsigned char saved_opcode;
380 unsigned long INT3_addr = 0;
381 int stepping_over_INT = 0;
383 a_tss.tss_eflags &= 0xfeff; /* Reset the single-step flag (TF). */
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
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)
403 unsigned char INT3_opcode = 0xCC;
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);
412 a_tss.tss_eflags |= 0x0100; /* normal instruction: set TF */
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)
420 a_tss.tss_irqn = 0xff;
424 a_tss.tss_trap = 0xffff; /* run_child looks for this. */
425 a_tss.tss_irqn = resume_signal;
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
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 ..." */
439 /* Initialize child's cwd with the current one. */
440 getcwd (child_cwd, sizeof (child_cwd));
444 #if __DJGPP_MINOR__ < 3
448 #if __DJGPP_MINOR__ < 3
452 /* Did we step over an INT xx instruction? */
453 if (stepping_over_INT && a_tss.tss_eip == INT3_addr + 1)
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. */
460 a_tss.tss_eflags |= 0x0100;
463 getcwd (child_cwd, sizeof (child_cwd)); /* in case it has changed */
464 chdir (current_directory);
466 if (a_tss.tss_irqn == 0x21)
468 status->kind = TARGET_WAITKIND_EXITED;
469 status->value.integer = a_tss.tss_eax & 0xff;
473 status->value.sig = GDB_SIGNAL_UNKNOWN;
474 status->kind = TARGET_WAITKIND_STOPPED;
475 for (i = 0; sig_map[i].go32_sig != -1; i++)
477 if (a_tss.tss_irqn == sig_map[i].go32_sig)
479 #if __DJGPP_MINOR__ < 3
480 if ((status->value.sig = sig_map[i].gdb_sig) !=
482 status->kind = TARGET_WAITKIND_SIGNALLED;
484 status->value.sig = sig_map[i].gdb_sig;
490 return pid_to_ptid (SOME_PID);
494 fetch_register (struct regcache *regcache, int regno)
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,
502 i387_supply_fsave (regcache, regno, &npx);
504 internal_error (__FILE__, __LINE__,
505 _("Invalid register no. %d in fetch_register."), regno);
509 go32_fetch_registers (struct target_ops *ops,
510 struct regcache *regcache, int regno)
513 fetch_register (regcache, regno);
517 regno < gdbarch_fp0_regnum (regcache->arch ());
519 fetch_register (regcache, regno);
520 i387_supply_fsave (regcache, -1, &npx);
525 store_register (const struct regcache *regcache, int regno)
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,
533 i387_collect_fsave (regcache, regno, &npx);
535 internal_error (__FILE__, __LINE__,
536 _("Invalid register no. %d in store_register."), regno);
540 go32_store_registers (struct target_ops *ops,
541 struct regcache *regcache, int regno)
546 store_register (regcache, regno);
549 for (r = 0; r < gdbarch_fp0_regnum (regcache->arch ()); r++)
550 store_register (regcache, r);
551 i387_collect_fsave (regcache, -1, &npx);
555 /* Const-correct version of DJGPP's write_child, which unfortunately
556 takes a non-const buffer pointer. */
559 my_write_child (unsigned child_addr, const void *buf, unsigned len)
561 static void *buffer = NULL;
562 static unsigned buffer_len = 0;
565 if (buffer_len < len)
567 buffer = xrealloc (buffer, len);
571 memcpy (buffer, buf, len);
572 res = write_child (child_addr, buffer, len);
576 /* Helper for go32_xfer_partial that handles memory transfers.
577 Arguments are like target_xfer_partial. */
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)
585 if (writebuf != NULL)
586 res = my_write_child (memaddr, writebuf, len);
588 res = read_child (memaddr, readbuf, len);
590 /* read_child and write_child return zero on success, non-zero on
593 return TARGET_XFER_E_IO;
596 return TARGET_XFER_OK;
599 /* Target to_xfer_partial implementation. */
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)
609 case TARGET_OBJECT_MEMORY:
610 return go32_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
613 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
614 readbuf, writebuf, offset, len,
619 static cmdline_t child_cmd; /* Parsed child's command line kept here. */
622 go32_files_info (struct target_ops *target)
624 printf_unfiltered ("You are running a DJGPP V2 program.\n");
628 go32_kill_inferior (struct target_ops *ops)
630 go32_mourn_inferior (ops);
634 go32_create_inferior (struct target_ops *ops,
635 const char *exec_file,
636 const std::string &allargs, char **env, int from_tty)
638 extern char **environ;
641 char **env_save = environ;
643 struct inferior *inf;
645 const char *args = allargs.c_str ();
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. */
650 exec_file = get_exec_file (1);
655 /* Initialize child's cwd as empty to be initialized when starting
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"));
665 /* Parse the command line and create redirections. */
666 if (strpbrk (args, "<>"))
668 if (redir_cmdline_parse (args, &child_cmd) == 0)
669 args = child_cmd.command;
671 error (_("Syntax error in command line."));
674 child_cmd.command = xstrdup (args);
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."));
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. */
689 cmdline[0] = strlen (args);
690 cmdline[cmdlen + 1] = 13;
693 cmdline[0] = 0xff; /* Signal v2loadimage it's a long command. */
697 result = v2loadimage (exec_file, cmdline, start_state);
703 error (_("Load failed for image %s"), exec_file);
705 edi_init (start_state);
706 #if __DJGPP_MINOR__ < 3
710 inferior_ptid = pid_to_ptid (SOME_PID);
711 inf = current_inferior ();
712 inferior_appeared (inf, SOME_PID);
714 if (!target_is_pushed (ops))
717 add_thread_silent (inferior_ptid);
719 clear_proceed_status (0);
720 insert_breakpoints ();
721 prog_has_started = 1;
725 go32_mourn_inferior (struct target_ops *ops)
729 redir_cmdline_delete (&child_cmd);
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 ();
744 ptid = inferior_ptid;
745 inferior_ptid = null_ptid;
746 delete_thread_silent (ptid);
747 prog_has_started = 0;
749 generic_mourn_inferior ();
750 inf_child_maybe_unpush_target (ops);
753 /* Hardware watchpoint support. */
755 #define D_REGS edi.dr
756 #define CONTROL D_REGS[7]
757 #define STATUS D_REGS[6]
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. */
763 go32_set_dr (int i, CORE_ADDR addr)
766 internal_error (__FILE__, __LINE__,
767 _("Invalid register %d in go32_set_dr.\n"), i);
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. */
775 go32_set_dr7 (unsigned long val)
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. */
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. */
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. */
807 internal_error (__FILE__, __LINE__,
808 _("Invalid register %d in go32_get_dr.\n"), i);
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. */
816 device_mode (int fd, int raw_p)
818 int oldmode, newmode;
823 __dpmi_int (0x21, ®s);
824 if (regs.x.flags & 1)
826 newmode = oldmode = regs.x.dx;
833 if (oldmode & 0x80) /* Only for character dev. */
837 regs.x.dx = newmode & 0xff; /* Force upper byte zero, else it fails. */
838 __dpmi_int (0x21, ®s);
839 if (regs.x.flags & 1)
842 return (oldmode & 0x20) == 0x20;
846 static int inf_mode_valid = 0;
847 static int inf_terminal_mode;
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;
856 go32_terminal_init (struct target_ops *self)
858 inf_mode_valid = 0; /* Reinitialize, in case they are restarting child. */
859 terminal_is_ours = 1;
863 go32_terminal_info (struct target_ops *self, const char *args, int from_tty)
865 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
867 ? "default" : inf_terminal_mode ? "raw" : "cooked");
869 #if __DJGPP_MINOR__ > 2
870 if (child_cmd.redirection)
874 for (i = 0; i < DBG_HANDLES; i++)
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)
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))
886 ("\tFile handle %d appears to be redirected by inferior.\n", i);
893 go32_terminal_inferior (struct target_ops *self)
895 /* Redirect standard handles as child wants them. */
897 if (redir_to_child (&child_cmd) == -1)
899 redir_to_debugger (&child_cmd);
900 error (_("Cannot redirect standard handles for program: %s."),
901 safe_strerror (errno));
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)
908 device_mode (0, inf_terminal_mode);
909 terminal_is_ours = 0;
914 go32_terminal_ours (struct target_ops *self)
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)
920 inf_terminal_mode = device_mode (0, 0);
921 if (inf_terminal_mode != -1)
924 /* If device_mode returned -1, we don't know what happens with
925 handle 0 anymore, so make the info invalid. */
927 terminal_is_ours = 1;
929 /* Restore debugger's standard handles. */
931 if (redir_to_debugger (&child_cmd) == -1)
933 redir_to_child (&child_cmd);
934 error (_("Cannot redirect standard handles for debugger: %s."),
935 safe_strerror (errno));
941 go32_pass_ctrlc (struct target_ops *self)
946 go32_thread_alive (struct target_ops *ops, ptid_t ptid)
948 return !ptid_equal (ptid, null_ptid);
952 go32_pid_to_str (struct target_ops *ops, ptid_t ptid)
954 return normal_pid_to_str (ptid);
957 /* Create a go32 target. */
959 static struct target_ops *
962 struct target_ops *t = inf_child_target ();
964 t->to_attach = go32_attach;
965 t->to_resume = go32_resume;
966 t->to_wait = go32_wait;
967 t->to_fetch_registers = go32_fetch_registers;
968 t->to_store_registers = go32_store_registers;
969 t->to_xfer_partial = go32_xfer_partial;
970 t->to_files_info = go32_files_info;
971 t->to_terminal_init = go32_terminal_init;
972 t->to_terminal_inferior = go32_terminal_inferior;
973 t->to_terminal_ours_for_output = go32_terminal_ours;
974 t->to_terminal_ours = go32_terminal_ours;
975 t->to_terminal_info = go32_terminal_info;
976 t->to_pass_ctrlc = go32_pass_ctrlc;
977 t->to_kill = go32_kill_inferior;
978 t->to_create_inferior = go32_create_inferior;
979 t->to_mourn_inferior = go32_mourn_inferior;
980 t->to_thread_alive = go32_thread_alive;
981 t->to_pid_to_str = go32_pid_to_str;
986 /* Return the current DOS codepage number. */
993 __dpmi_int (0x21, ®s);
994 if (!(regs.x.flags & 1))
995 return regs.x.bx & 0xffff;
997 return 437; /* default */
1000 /* Limited emulation of `nl_langinfo', for charset.c. */
1002 nl_langinfo (nl_item item)
1010 /* 8 is enough for SHORT_MAX + "CP" + null. */
1012 int blen = sizeof (buf);
1013 int needed = snprintf (buf, blen, "CP%d", dos_codepage ());
1015 if (needed > blen) /* Should never happen. */
1017 retval = xstrdup (buf);
1021 retval = xstrdup ("");
1027 unsigned short windows_major, windows_minor;
1029 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */
1031 go32_get_windows_version(void)
1036 __dpmi_int(0x2f, &r);
1037 if (r.h.al > 2 && r.h.al != 0x80 && r.h.al != 0xff
1038 && (r.h.al > 3 || r.h.ah > 0))
1040 windows_major = r.h.al;
1041 windows_minor = r.h.ah;
1044 windows_major = 0xff; /* meaning no Windows */
1047 /* A subroutine of go32_sysinfo to display memory info. */
1049 print_mem (unsigned long datum, const char *header, int in_pages_p)
1051 if (datum != 0xffffffffUL)
1055 puts_filtered (header);
1058 printf_filtered ("%lu KB", datum >> 10);
1059 if (datum > 1024 * 1024)
1060 printf_filtered (" (%lu MB)", datum >> 20);
1063 printf_filtered ("%lu Bytes", datum);
1064 puts_filtered ("\n");
1068 /* Display assorted information about the underlying OS. */
1070 go32_sysinfo (const char *arg, int from_tty)
1072 static const char test_pattern[] =
1073 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1074 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1075 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeafdeadbeaf";
1077 char cpuid_vendor[13];
1078 unsigned cpuid_max = 0, cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx;
1079 unsigned true_dos_version = _get_dos_version (1);
1080 unsigned advertized_dos_version = ((unsigned int)_osmajor << 8) | _osminor;
1082 char dpmi_vendor_info[129];
1083 int dpmi_vendor_available;
1084 __dpmi_version_ret dpmi_version_data;
1086 __dpmi_free_mem_info mem_info;
1089 cpuid_vendor[0] = '\0';
1091 strcpy (u.machine, "Unknown x86");
1092 else if (u.machine[0] == 'i' && u.machine[1] > 4)
1094 /* CPUID with EAX = 0 returns the Vendor ID. */
1096 /* Ideally we would use x86_cpuid(), but it needs someone to run
1097 native tests first to make sure things actually work. They should.
1098 http://sourceware.org/ml/gdb-patches/2013-05/msg00164.html */
1099 unsigned int eax, ebx, ecx, edx;
1101 if (x86_cpuid (0, &eax, &ebx, &ecx, &edx))
1104 memcpy (&vendor[0], &ebx, 4);
1105 memcpy (&vendor[4], &ecx, 4);
1106 memcpy (&vendor[8], &edx, 4);
1107 cpuid_vendor[12] = '\0';
1110 __asm__ __volatile__ ("xorl %%ebx, %%ebx;"
1111 "xorl %%ecx, %%ecx;"
1112 "xorl %%edx, %%edx;"
1119 : "=m" (cpuid_vendor[0]),
1120 "=m" (cpuid_vendor[4]),
1121 "=m" (cpuid_vendor[8]),
1124 : "%eax", "%ebx", "%ecx", "%edx");
1125 cpuid_vendor[12] = '\0';
1129 printf_filtered ("CPU Type.......................%s", u.machine);
1130 if (cpuid_vendor[0])
1131 printf_filtered (" (%s)", cpuid_vendor);
1132 puts_filtered ("\n");
1134 /* CPUID with EAX = 1 returns processor signature and features. */
1137 static const char *brand_name[] = {
1145 char cpu_string[80];
1148 int intel_p = strcmp (cpuid_vendor, "GenuineIntel") == 0;
1149 int amd_p = strcmp (cpuid_vendor, "AuthenticAMD") == 0;
1150 unsigned cpu_family, cpu_model;
1153 /* See comment above about cpuid usage. */
1154 x86_cpuid (1, &cpuid_eax, &cpuid_ebx, NULL, &cpuid_edx);
1156 __asm__ __volatile__ ("movl $1, %%eax;"
1164 brand_idx = cpuid_ebx & 0xff;
1165 cpu_family = (cpuid_eax >> 8) & 0xf;
1166 cpu_model = (cpuid_eax >> 4) & 0xf;
1167 cpu_brand[0] = '\0';
1171 && brand_idx < sizeof(brand_name)/sizeof(brand_name[0])
1172 && *brand_name[brand_idx])
1173 strcpy (cpu_brand, brand_name[brand_idx]);
1174 else if (cpu_family == 5)
1176 if (((cpuid_eax >> 12) & 3) == 0 && cpu_model == 4)
1177 strcpy (cpu_brand, " MMX");
1178 else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 1)
1179 strcpy (cpu_brand, " OverDrive");
1180 else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 2)
1181 strcpy (cpu_brand, " Dual");
1183 else if (cpu_family == 6 && cpu_model < 8)
1188 strcpy (cpu_brand, " Pro");
1191 strcpy (cpu_brand, " II");
1194 strcpy (cpu_brand, " II Xeon");
1197 strcpy (cpu_brand, " Celeron");
1200 strcpy (cpu_brand, " III");
1210 strcpy (cpu_brand, "486/5x86");
1219 strcpy (cpu_brand, "-K5");
1223 strcpy (cpu_brand, "-K6");
1226 strcpy (cpu_brand, "-K6-2");
1229 strcpy (cpu_brand, "-K6-III");
1239 strcpy (cpu_brand, " Athlon");
1242 strcpy (cpu_brand, " Duron");
1248 xsnprintf (cpu_string, sizeof (cpu_string), "%s%s Model %d Stepping %d",
1249 intel_p ? "Pentium" : (amd_p ? "AMD" : "ix86"),
1250 cpu_brand, cpu_model, cpuid_eax & 0xf);
1251 printfi_filtered (31, "%s\n", cpu_string);
1252 if (((cpuid_edx & (6 | (0x0d << 23))) != 0)
1253 || ((cpuid_edx & 1) == 0)
1254 || (amd_p && (cpuid_edx & (3 << 30)) != 0))
1256 puts_filtered ("CPU Features...................");
1257 /* We only list features which might be useful in the DPMI
1259 if ((cpuid_edx & 1) == 0)
1260 puts_filtered ("No FPU "); /* It's unusual to not have an FPU. */
1261 if ((cpuid_edx & (1 << 1)) != 0)
1262 puts_filtered ("VME ");
1263 if ((cpuid_edx & (1 << 2)) != 0)
1264 puts_filtered ("DE ");
1265 if ((cpuid_edx & (1 << 4)) != 0)
1266 puts_filtered ("TSC ");
1267 if ((cpuid_edx & (1 << 23)) != 0)
1268 puts_filtered ("MMX ");
1269 if ((cpuid_edx & (1 << 25)) != 0)
1270 puts_filtered ("SSE ");
1271 if ((cpuid_edx & (1 << 26)) != 0)
1272 puts_filtered ("SSE2 ");
1275 if ((cpuid_edx & (1 << 31)) != 0)
1276 puts_filtered ("3DNow! ");
1277 if ((cpuid_edx & (1 << 30)) != 0)
1278 puts_filtered ("3DNow!Ext");
1280 puts_filtered ("\n");
1283 puts_filtered ("\n");
1284 printf_filtered ("DOS Version....................%s %s.%s",
1285 _os_flavor, u.release, u.version);
1286 if (true_dos_version != advertized_dos_version)
1287 printf_filtered (" (disguised as v%d.%d)", _osmajor, _osminor);
1288 puts_filtered ("\n");
1290 go32_get_windows_version ();
1291 if (windows_major != 0xff)
1293 const char *windows_flavor;
1295 printf_filtered ("Windows Version................%d.%02d (Windows ",
1296 windows_major, windows_minor);
1297 switch (windows_major)
1300 windows_flavor = "3.X";
1303 switch (windows_minor)
1306 windows_flavor = "95, 95A, or 95B";
1309 windows_flavor = "95B OSR2.1 or 95C OSR2.5";
1312 windows_flavor = "98 or 98 SE";
1315 windows_flavor = "ME";
1318 windows_flavor = "9X";
1323 windows_flavor = "??";
1326 printf_filtered ("%s)\n", windows_flavor);
1328 else if (true_dos_version == 0x532 && advertized_dos_version == 0x500)
1329 printf_filtered ("Windows Version................"
1330 "Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
1331 puts_filtered ("\n");
1332 /* On some versions of Windows, __dpmi_get_capabilities returns
1333 zero, but the buffer is not filled with info, so we fill the
1334 buffer with a known pattern and test for it afterwards. */
1335 memcpy (dpmi_vendor_info, test_pattern, sizeof(dpmi_vendor_info));
1336 dpmi_vendor_available =
1337 __dpmi_get_capabilities (&dpmi_flags, dpmi_vendor_info);
1338 if (dpmi_vendor_available == 0
1339 && memcmp (dpmi_vendor_info, test_pattern,
1340 sizeof(dpmi_vendor_info)) != 0)
1342 /* The DPMI spec says the vendor string should be ASCIIZ, but
1343 I don't trust the vendors to follow that... */
1344 if (!memchr (&dpmi_vendor_info[2], 0, 126))
1345 dpmi_vendor_info[128] = '\0';
1346 printf_filtered ("DPMI Host......................"
1347 "%s v%d.%d (capabilities: %#x)\n",
1348 &dpmi_vendor_info[2],
1349 (unsigned)dpmi_vendor_info[0],
1350 (unsigned)dpmi_vendor_info[1],
1351 ((unsigned)dpmi_flags & 0x7f));
1354 printf_filtered ("DPMI Host......................(Info not available)\n");
1355 __dpmi_get_version (&dpmi_version_data);
1356 printf_filtered ("DPMI Version...................%d.%02d\n",
1357 dpmi_version_data.major, dpmi_version_data.minor);
1358 printf_filtered ("DPMI Info......................"
1359 "%s-bit DPMI, with%s Virtual Memory support\n",
1360 (dpmi_version_data.flags & 1) ? "32" : "16",
1361 (dpmi_version_data.flags & 4) ? "" : "out");
1362 printfi_filtered (31, "Interrupts reflected to %s mode\n",
1363 (dpmi_version_data.flags & 2) ? "V86" : "Real");
1364 printfi_filtered (31, "Processor type: i%d86\n",
1365 dpmi_version_data.cpu);
1366 printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
1367 dpmi_version_data.master_pic, dpmi_version_data.slave_pic);
1369 /* a_tss is only initialized when the debuggee is first run. */
1370 if (prog_has_started)
1372 __asm__ __volatile__ ("pushfl ; popl %0" : "=g" (eflags));
1373 printf_filtered ("Protection....................."
1374 "Ring %d (in %s), with%s I/O protection\n",
1375 a_tss.tss_cs & 3, (a_tss.tss_cs & 4) ? "LDT" : "GDT",
1376 (a_tss.tss_cs & 3) > ((eflags >> 12) & 3) ? "" : "out");
1378 puts_filtered ("\n");
1379 __dpmi_get_free_memory_information (&mem_info);
1380 print_mem (mem_info.total_number_of_physical_pages,
1381 "DPMI Total Physical Memory.....", 1);
1382 print_mem (mem_info.total_number_of_free_pages,
1383 "DPMI Free Physical Memory......", 1);
1384 print_mem (mem_info.size_of_paging_file_partition_in_pages,
1385 "DPMI Swap Space................", 1);
1386 print_mem (mem_info.linear_address_space_size_in_pages,
1387 "DPMI Total Linear Address Size.", 1);
1388 print_mem (mem_info.free_linear_address_space_in_pages,
1389 "DPMI Free Linear Address Size..", 1);
1390 print_mem (mem_info.largest_available_free_block_in_bytes,
1391 "DPMI Largest Free Memory Block.", 0);
1395 __dpmi_int (0x21, ®s);
1396 print_mem (regs.x.bx << 4, "Free DOS Memory................", 0);
1398 __dpmi_int (0x21, ®s);
1399 if ((regs.x.flags & 1) == 0)
1401 static const char *dos_hilo[] = {
1402 "Low", "", "", "", "High", "", "", "", "High, then Low"
1404 static const char *dos_fit[] = {
1405 "First", "Best", "Last"
1407 int hilo_idx = (regs.x.ax >> 4) & 0x0f;
1408 int fit_idx = regs.x.ax & 0x0f;
1414 printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1415 dos_hilo[hilo_idx], dos_fit[fit_idx]);
1417 __dpmi_int (0x21, ®s);
1418 if ((regs.x.flags & 1) != 0)
1420 printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1421 regs.h.al == 0 ? "not " : "");
1426 unsigned short limit0;
1427 unsigned short base0;
1428 unsigned char base1;
1433 unsigned available:1;
1436 unsigned page_granular:1;
1437 unsigned char base2;
1438 } __attribute__ ((packed));
1441 unsigned short offset0;
1442 unsigned short selector;
1443 unsigned param_count:5;
1448 unsigned short offset1;
1449 } __attribute__ ((packed));
1451 /* Read LEN bytes starting at logical address ADDR, and put the result
1452 into DEST. Return 1 if success, zero if not. */
1454 read_memory_region (unsigned long addr, void *dest, size_t len)
1456 unsigned long dos_ds_limit = __dpmi_get_segment_limit (_dos_ds);
1459 /* For the low memory, we can simply use _dos_ds. */
1460 if (addr <= dos_ds_limit - len)
1461 dosmemget (addr, len, dest);
1464 /* For memory above 1MB we need to set up a special segment to
1465 be able to access that memory. */
1466 int sel = __dpmi_allocate_ldt_descriptors (1);
1472 int access_rights = __dpmi_get_descriptor_access_rights (sel);
1473 size_t segment_limit = len - 1;
1475 /* Make sure the crucial bits in the descriptor access
1476 rights are set correctly. Some DPMI providers might barf
1477 if we set the segment limit to something that is not an
1478 integral multiple of 4KB pages if the granularity bit is
1479 not set to byte-granular, even though the DPMI spec says
1480 it's the host's responsibility to set that bit correctly. */
1481 if (len > 1024 * 1024)
1483 access_rights |= 0x8000;
1484 /* Page-granular segments should have the low 12 bits of
1486 segment_limit |= 0xfff;
1489 access_rights &= ~0x8000;
1491 if (__dpmi_set_segment_base_address (sel, addr) != -1
1492 && __dpmi_set_descriptor_access_rights (sel, access_rights) != -1
1493 && __dpmi_set_segment_limit (sel, segment_limit) != -1
1494 /* W2K silently fails to set the segment limit, leaving
1495 it at zero; this test avoids the resulting crash. */
1496 && __dpmi_get_segment_limit (sel) >= segment_limit)
1497 movedata (sel, 0, _my_ds (), (unsigned)dest, len);
1501 __dpmi_free_ldt_descriptor (sel);
1507 /* Get a segment descriptor stored at index IDX in the descriptor
1508 table whose base address is TABLE_BASE. Return the descriptor
1509 type, or -1 if failure. */
1511 get_descriptor (unsigned long table_base, int idx, void *descr)
1513 unsigned long addr = table_base + idx * 8; /* 8 bytes per entry */
1515 if (read_memory_region (addr, descr, 8))
1516 return (int)((struct seg_descr *)descr)->stype;
1521 unsigned short limit __attribute__((packed));
1522 unsigned long base __attribute__((packed));
1525 /* Display a segment descriptor stored at index IDX in a descriptor
1526 table whose type is TYPE and whose base address is BASE_ADDR. If
1527 FORCE is non-zero, display even invalid descriptors. */
1529 display_descriptor (unsigned type, unsigned long base_addr, int idx, int force)
1531 struct seg_descr descr;
1532 struct gate_descr gate;
1534 /* Get the descriptor from the table. */
1535 if (idx == 0 && type == 0)
1536 puts_filtered ("0x000: null descriptor\n");
1537 else if (get_descriptor (base_addr, idx, &descr) != -1)
1539 /* For each type of descriptor table, this has a bit set if the
1540 corresponding type of selectors is valid in that table. */
1541 static unsigned allowed_descriptors[] = {
1542 0xffffdafeL, /* GDT */
1543 0x0000c0e0L, /* IDT */
1544 0xffffdafaL /* LDT */
1547 /* If the program hasn't started yet, assume the debuggee will
1548 have the same CPL as the debugger. */
1549 int cpl = prog_has_started ? (a_tss.tss_cs & 3) : _my_cs () & 3;
1550 unsigned long limit = (descr.limit1 << 16) | descr.limit0;
1553 && (allowed_descriptors[type] & (1 << descr.stype)) != 0)
1555 printf_filtered ("0x%03x: ",
1557 ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1558 if (descr.page_granular)
1559 limit = (limit << 12) | 0xfff; /* big segment: low 12 bit set */
1560 if (descr.stype == 1 || descr.stype == 2 || descr.stype == 3
1561 || descr.stype == 9 || descr.stype == 11
1562 || (descr.stype >= 16 && descr.stype < 32))
1563 printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1564 descr.base2, descr.base1, descr.base0, limit);
1566 switch (descr.stype)
1570 printf_filtered (" 16-bit TSS (task %sactive)",
1571 descr.stype == 3 ? "" : "in");
1574 puts_filtered (" LDT");
1577 memcpy (&gate, &descr, sizeof gate);
1578 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1579 gate.selector, gate.offset1, gate.offset0);
1580 printf_filtered (" 16-bit Call Gate (params=%d)",
1584 printf_filtered ("TSS selector=0x%04x", descr.base0);
1585 printfi_filtered (16, "Task Gate");
1589 memcpy (&gate, &descr, sizeof gate);
1590 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1591 gate.selector, gate.offset1, gate.offset0);
1592 printf_filtered (" 16-bit %s Gate",
1593 descr.stype == 6 ? "Interrupt" : "Trap");
1597 printf_filtered (" 32-bit TSS (task %sactive)",
1598 descr.stype == 3 ? "" : "in");
1601 memcpy (&gate, &descr, sizeof gate);
1602 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1603 gate.selector, gate.offset1, gate.offset0);
1604 printf_filtered (" 32-bit Call Gate (params=%d)",
1609 memcpy (&gate, &descr, sizeof gate);
1610 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1611 gate.selector, gate.offset1, gate.offset0);
1612 printf_filtered (" 32-bit %s Gate",
1613 descr.stype == 14 ? "Interrupt" : "Trap");
1615 case 16: /* data segments */
1623 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1624 descr.bit32 ? "32" : "16",
1626 ? "Read/Write," : "Read-Only, ",
1627 descr.stype & 4 ? "down" : "up",
1628 descr.stype & 1 ? "" : ", N.Acc");
1630 case 24: /* code segments */
1638 printf_filtered (" %s-bit Code (%s, %sConf%s)",
1639 descr.bit32 ? "32" : "16",
1640 descr.stype & 2 ? "Exec/Read" : "Exec-Only",
1641 descr.stype & 4 ? "" : "N.",
1642 descr.stype & 1 ? "" : ", N.Acc");
1645 printf_filtered ("Unknown type 0x%02x", descr.stype);
1648 puts_filtered ("\n");
1652 printf_filtered ("0x%03x: ",
1654 ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1656 puts_filtered ("Segment not present\n");
1658 printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1663 printf_filtered ("0x%03x: Cannot read this descriptor\n", idx);
1667 go32_sldt (const char *arg, int from_tty)
1669 struct dtr_reg gdtr;
1670 unsigned short ldtr = 0;
1672 struct seg_descr ldt_descr;
1673 long ldt_entry = -1L;
1674 int cpl = (prog_has_started ? a_tss.tss_cs : _my_cs ()) & 3;
1678 arg = skip_spaces (arg);
1682 ldt_entry = parse_and_eval_long (arg);
1684 || (ldt_entry & 4) == 0
1685 || (ldt_entry & 3) != (cpl & 3))
1686 error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry);
1690 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1691 __asm__ __volatile__ ("sldt %0" : "=m" (ldtr) : /* no inputs */ );
1694 puts_filtered ("There is no LDT.\n");
1695 /* LDT's entry in the GDT must have the type LDT, which is 2. */
1696 else if (get_descriptor (gdtr.base, ldt_idx, &ldt_descr) != 2)
1697 printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1699 | (ldt_descr.base1 << 16)
1700 | (ldt_descr.base2 << 24));
1705 | (ldt_descr.base1 << 16)
1706 | (ldt_descr.base2 << 24);
1707 unsigned limit = ldt_descr.limit0 | (ldt_descr.limit1 << 16);
1710 if (ldt_descr.page_granular)
1711 /* Page-granular segments must have the low 12 bits of their
1713 limit = (limit << 12) | 0xfff;
1714 /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1719 max_entry = (limit + 1) / 8;
1723 if (ldt_entry > limit)
1724 error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1725 (unsigned long)ldt_entry, limit);
1727 display_descriptor (ldt_descr.stype, base, ldt_entry / 8, 1);
1733 for (i = 0; i < max_entry; i++)
1734 display_descriptor (ldt_descr.stype, base, i, 0);
1740 go32_sgdt (const char *arg, int from_tty)
1742 struct dtr_reg gdtr;
1743 long gdt_entry = -1L;
1748 arg = skip_spaces (arg);
1752 gdt_entry = parse_and_eval_long (arg);
1753 if (gdt_entry < 0 || (gdt_entry & 7) != 0)
1754 error (_("Invalid GDT entry 0x%03lx: "
1755 "not an integral multiple of 8."),
1756 (unsigned long)gdt_entry);
1760 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1761 max_entry = (gdtr.limit + 1) / 8;
1765 if (gdt_entry > gdtr.limit)
1766 error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1767 (unsigned long)gdt_entry, gdtr.limit);
1769 display_descriptor (0, gdtr.base, gdt_entry / 8, 1);
1775 for (i = 0; i < max_entry; i++)
1776 display_descriptor (0, gdtr.base, i, 0);
1781 go32_sidt (const char *arg, int from_tty)
1783 struct dtr_reg idtr;
1784 long idt_entry = -1L;
1789 arg = skip_spaces (arg);
1793 idt_entry = parse_and_eval_long (arg);
1795 error (_("Invalid (negative) IDT entry %ld."), idt_entry);
1799 __asm__ __volatile__ ("sidt %0" : "=m" (idtr) : /* no inputs */ );
1800 max_entry = (idtr.limit + 1) / 8;
1801 if (max_entry > 0x100) /* No more than 256 entries. */
1806 if (idt_entry > idtr.limit)
1807 error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1808 (unsigned long)idt_entry, idtr.limit);
1810 display_descriptor (1, idtr.base, idt_entry, 1);
1816 for (i = 0; i < max_entry; i++)
1817 display_descriptor (1, idtr.base, i, 0);
1821 /* Cached linear address of the base of the page directory. For
1822 now, available only under CWSDPMI. Code based on ideas and
1823 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
1824 static unsigned long pdbr;
1826 static unsigned long
1831 unsigned long taskbase, cr3;
1832 struct dtr_reg gdtr;
1834 if (pdbr > 0 && pdbr <= 0xfffff)
1837 /* Get the linear address of GDT and the Task Register. */
1838 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1839 __asm__ __volatile__ ("str %0" : "=m" (taskreg) : /* no inputs */ );
1841 /* Task Register is a segment selector for the TSS of the current
1842 task. Therefore, it can be used as an index into the GDT to get
1843 at the segment descriptor for the TSS. To get the index, reset
1844 the low 3 bits of the selector (which give the CPL). Add 2 to the
1845 offset to point to the 3 low bytes of the base address. */
1846 offset = gdtr.base + (taskreg & 0xfff8) + 2;
1849 /* CWSDPMI's task base is always under the 1MB mark. */
1850 if (offset > 0xfffff)
1853 _farsetsel (_dos_ds);
1854 taskbase = _farnspeekl (offset) & 0xffffffU;
1855 taskbase += _farnspeekl (offset + 2) & 0xff000000U;
1856 if (taskbase > 0xfffff)
1859 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1860 offset 1Ch in the TSS. */
1861 cr3 = _farnspeekl (taskbase + 0x1c) & ~0xfff;
1864 #if 0 /* Not fullly supported yet. */
1865 /* The Page Directory is in UMBs. In that case, CWSDPMI puts
1866 the first Page Table right below the Page Directory. Thus,
1867 the first Page Table's entry for its own address and the Page
1868 Directory entry for that Page Table will hold the same
1869 physical address. The loop below searches the entire UMB
1870 range of addresses for such an occurence. */
1871 unsigned long addr, pte_idx;
1873 for (addr = 0xb0000, pte_idx = 0xb0;
1875 addr += 0x1000, pte_idx++)
1877 if (((_farnspeekl (addr + 4 * pte_idx) & 0xfffff027) ==
1878 (_farnspeekl (addr + 0x1000) & 0xfffff027))
1879 && ((_farnspeekl (addr + 4 * pte_idx + 4) & 0xfffff000) == cr3))
1881 cr3 = addr + 0x1000;
1894 /* Return the N'th Page Directory entry. */
1895 static unsigned long
1898 unsigned long pde = 0;
1900 if (pdbr && n >= 0 && n < 1024)
1902 pde = _farpeekl (_dos_ds, pdbr + 4*n);
1907 /* Return the N'th entry of the Page Table whose Page Directory entry
1909 static unsigned long
1910 get_pte (unsigned long pde, int n)
1912 unsigned long pte = 0;
1914 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
1915 page tables, for now. */
1916 if ((pde & 1) && !(pde & 0x80) && n >= 0 && n < 1024)
1918 pde &= ~0xfff; /* Clear non-address bits. */
1919 pte = _farpeekl (_dos_ds, pde + 4*n);
1924 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
1925 says this is a Page Directory entry. If FORCE is non-zero, display
1926 the entry even if its Present flag is off. OFF is the offset of the
1927 address from the page's base address. */
1929 display_ptable_entry (unsigned long entry, int is_dir, int force, unsigned off)
1931 if ((entry & 1) != 0)
1933 printf_filtered ("Base=0x%05lx000", entry >> 12);
1934 if ((entry & 0x100) && !is_dir)
1935 puts_filtered (" Global");
1936 if ((entry & 0x40) && !is_dir)
1937 puts_filtered (" Dirty");
1938 printf_filtered (" %sAcc.", (entry & 0x20) ? "" : "Not-");
1939 printf_filtered (" %sCached", (entry & 0x10) ? "" : "Not-");
1940 printf_filtered (" Write-%s", (entry & 8) ? "Thru" : "Back");
1941 printf_filtered (" %s", (entry & 4) ? "Usr" : "Sup");
1942 printf_filtered (" Read-%s", (entry & 2) ? "Write" : "Only");
1944 printf_filtered (" +0x%x", off);
1945 puts_filtered ("\n");
1948 printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1949 is_dir ? " Table" : "", entry >> 1);
1953 go32_pde (const char *arg, int from_tty)
1955 long pde_idx = -1, i;
1959 arg = skip_spaces (arg);
1963 pde_idx = parse_and_eval_long (arg);
1964 if (pde_idx < 0 || pde_idx >= 1024)
1965 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
1971 puts_filtered ("Access to Page Directories is "
1972 "not supported on this system.\n");
1973 else if (pde_idx >= 0)
1974 display_ptable_entry (get_pde (pde_idx), 1, 1, 0);
1976 for (i = 0; i < 1024; i++)
1977 display_ptable_entry (get_pde (i), 1, 0, 0);
1980 /* A helper function to display entries in a Page Table pointed to by
1981 the N'th entry in the Page Directory. If FORCE is non-zero, say
1982 something even if the Page Table is not accessible. */
1984 display_page_table (long n, int force)
1986 unsigned long pde = get_pde (n);
1992 printf_filtered ("Page Table pointed to by "
1993 "Page Directory entry 0x%lx:\n", n);
1994 for (i = 0; i < 1024; i++)
1995 display_ptable_entry (get_pte (pde, i), 0, 0, 0);
1996 puts_filtered ("\n");
1999 printf_filtered ("Page Table not present; value=0x%lx.\n", pde >> 1);
2003 go32_pte (const char *arg, int from_tty)
2005 long pde_idx = -1L, i;
2009 arg = skip_spaces (arg);
2013 pde_idx = parse_and_eval_long (arg);
2014 if (pde_idx < 0 || pde_idx >= 1024)
2015 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
2021 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2022 else if (pde_idx >= 0)
2023 display_page_table (pde_idx, 1);
2025 for (i = 0; i < 1024; i++)
2026 display_page_table (i, 0);
2030 go32_pte_for_address (const char *arg, int from_tty)
2032 CORE_ADDR addr = 0, i;
2036 arg = skip_spaces (arg);
2039 addr = parse_and_eval_address (arg);
2042 error_no_arg (_("linear address"));
2046 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2049 int pde_idx = (addr >> 22) & 0x3ff;
2050 int pte_idx = (addr >> 12) & 0x3ff;
2051 unsigned offs = addr & 0xfff;
2053 printf_filtered ("Page Table entry for address %s:\n",
2055 display_ptable_entry (get_pte (get_pde (pde_idx), pte_idx), 0, 1, offs);
2059 static struct cmd_list_element *info_dos_cmdlist = NULL;
2062 go32_info_dos_command (const char *args, int from_tty)
2064 help_list (info_dos_cmdlist, "info dos ", class_info, gdb_stdout);
2068 _initialize_go32_nat (void)
2070 struct target_ops *t = go32_target ();
2072 x86_dr_low.set_control = go32_set_dr7;
2073 x86_dr_low.set_addr = go32_set_dr;
2074 x86_dr_low.get_status = go32_get_dr6;
2075 x86_dr_low.get_control = go32_get_dr7;
2076 x86_dr_low.get_addr = go32_get_dr;
2077 x86_set_debug_register_length (4);
2079 x86_use_watchpoints (t);
2082 /* Initialize child's cwd as empty to be initialized when starting
2086 /* Initialize child's command line storage. */
2087 if (redir_debug_init (&child_cmd) == -1)
2088 internal_error (__FILE__, __LINE__,
2089 _("Cannot allocate redirection storage: "
2090 "not enough memory.\n"));
2092 /* We are always processing GCC-compiled programs. */
2093 processing_gcc_compilation = 2;
2095 add_prefix_cmd ("dos", class_info, go32_info_dos_command, _("\
2096 Print information specific to DJGPP (aka MS-DOS) debugging."),
2097 &info_dos_cmdlist, "info dos ", 0, &infolist);
2099 add_cmd ("sysinfo", class_info, go32_sysinfo, _("\
2100 Display information about the target system, including CPU, OS, DPMI, etc."),
2102 add_cmd ("ldt", class_info, go32_sldt, _("\
2103 Display entries in the LDT (Local Descriptor Table).\n\
2104 Entry number (an expression) as an argument means display only that entry."),
2106 add_cmd ("gdt", class_info, go32_sgdt, _("\
2107 Display entries in the GDT (Global Descriptor Table).\n\
2108 Entry number (an expression) as an argument means display only that entry."),
2110 add_cmd ("idt", class_info, go32_sidt, _("\
2111 Display entries in the IDT (Interrupt Descriptor Table).\n\
2112 Entry number (an expression) as an argument means display only that entry."),
2114 add_cmd ("pde", class_info, go32_pde, _("\
2115 Display entries in the Page Directory.\n\
2116 Entry number (an expression) as an argument means display only that entry."),
2118 add_cmd ("pte", class_info, go32_pte, _("\
2119 Display entries in Page Tables.\n\
2120 Entry number (an expression) as an argument means display only entries\n\
2121 from the Page Table pointed to by the specified Page Directory entry."),
2123 add_cmd ("address-pte", class_info, go32_pte_for_address, _("\
2124 Display a Page Table entry for a linear address.\n\
2125 The address argument must be a linear address, after adding to\n\
2126 it the base address of the appropriate segment.\n\
2127 The base address of variables and functions in the debuggee's data\n\
2128 or code segment is stored in the variable __djgpp_base_address,\n\
2129 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
2130 For other segments, look up their base address in the output of\n\
2131 the `info dos ldt' command."),
2145 tcsetpgrp (int fd, pid_t pgid)
2147 if (isatty (fd) && pgid == SOME_PID)
2149 errno = pgid == SOME_PID ? ENOTTY : ENOSYS;