1 /* Native debugging support for Intel x86 running DJGPP.
2 Copyright (C) 1997, 1999, 2000, 2001, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
4 Written by Robert Hoehne.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 /* To whomever it may concern, here's a general description of how
22 debugging in DJGPP works, and the special quirks GDB does to
25 When the DJGPP port of GDB is debugging a DJGPP program natively,
26 there aren't 2 separate processes, the debuggee and GDB itself, as
27 on other systems. (This is DOS, where there can only be one active
28 process at any given time, remember?) Instead, GDB and the
29 debuggee live in the same process. So when GDB calls
30 go32_create_inferior below, and that function calls edi_init from
31 the DJGPP debug support library libdbg.a, we load the debuggee's
32 executable file into GDB's address space, set it up for execution
33 as the stub loader (a short real-mode program prepended to each
34 DJGPP executable) normally would, and do a lot of preparations for
35 swapping between GDB's and debuggee's internal state, primarily wrt
36 the exception handlers. This swapping happens every time we resume
37 the debuggee or switch back to GDB's code, and it includes:
39 . swapping all the segment registers
40 . swapping the PSP (the Program Segment Prefix)
41 . swapping the signal handlers
42 . swapping the exception handlers
43 . swapping the FPU status
44 . swapping the 3 standard file handles (more about this below)
46 Then running the debuggee simply means longjmp into it where its PC
47 is and let it run until it stops for some reason. When it stops,
48 GDB catches the exception that stopped it and longjmp's back into
49 its own code. All the possible exit points of the debuggee are
50 watched; for example, the normal exit point is recognized because a
51 DOS program issues a special system call to exit. If one of those
52 exit points is hit, we mourn the inferior and clean up after it.
53 Cleaning up is very important, even if the process exits normally,
54 because otherwise we might leave behind traces of previous
55 execution, and in several cases GDB itself might be left hosed,
56 because all the exception handlers were not restored.
58 Swapping of the standard handles (in redir_to_child and
59 redir_to_debugger) is needed because, since both GDB and the
60 debuggee live in the same process, as far as the OS is concerned,
61 the share the same file table. This means that the standard
62 handles 0, 1, and 2 point to the same file table entries, and thus
63 are connected to the same devices. Therefore, if the debugger
64 redirects its standard output, the standard output of the debuggee
65 is also automagically redirected to the same file/device!
66 Similarly, if the debuggee redirects its stdout to a file, you
67 won't be able to see debugger's output (it will go to the same file
68 where the debuggee has its output); and if the debuggee closes its
69 standard input, you will lose the ability to talk to debugger!
71 For this reason, every time the debuggee is about to be resumed, we
72 call redir_to_child, which redirects the standard handles to where
73 the debuggee expects them to be. When the debuggee stops and GDB
74 regains control, we call redir_to_debugger, which redirects those 3
75 handles back to where GDB expects.
77 Note that only the first 3 handles are swapped, so if the debuggee
78 redirects or closes any other handles, GDB will not notice. In
79 particular, the exit code of a DJGPP program forcibly closes all
80 file handles beyond the first 3 ones, so when the debuggee exits,
81 GDB currently loses its stdaux and stdprn streams. Fortunately,
82 GDB does not use those as of this writing, and will never need
89 #include "gdbthread.h"
94 #include "floatformat.h"
96 #include "i387-tdep.h"
97 #include "i386-tdep.h"
100 #include "gdb_string.h"
103 #include <stdio.h> /* might be required for __DJGPP_MINOR__ */
108 #include <sys/utsname.h>
113 #include <sys/farptr.h>
114 #include <debug/v2load.h>
115 #include <debug/dbgcom.h>
116 #if __DJGPP_MINOR__ > 2
117 #include <debug/redir.h>
120 #include <langinfo.h>
122 #if __DJGPP_MINOR__ < 3
123 /* This code will be provided from DJGPP 2.03 on. Until then I code it
131 unsigned short exponent:15;
132 unsigned short sign:1;
138 unsigned int control;
143 unsigned int dataptr;
144 unsigned int datasel;
151 static void save_npx (void); /* Save the FPU of the debugged program */
152 static void load_npx (void); /* Restore the FPU of the debugged program */
154 /* ------------------------------------------------------------------------- */
155 /* Store the contents of the NPX in the global variable `npx'. */
161 asm ("inb $0xa0, %%al \n\
162 testb $0x20, %%al \n\
180 /* ------------------------------------------------------------------------- */
181 /* Reload the contents of the NPX from the global variable `npx'. */
186 asm ("frstor %0":"=m" (npx));
188 /* ------------------------------------------------------------------------- */
189 /* Stubs for the missing redirection functions. */
196 redir_cmdline_delete (cmdline_t *ptr)
202 redir_cmdline_parse (const char *args, cmdline_t *ptr)
208 redir_to_child (cmdline_t *ptr)
214 redir_to_debugger (cmdline_t *ptr)
220 redir_debug_init (cmdline_t *ptr)
224 #endif /* __DJGPP_MINOR < 3 */
226 typedef enum { wp_insert, wp_remove, wp_count } wp_op;
228 /* This holds the current reference counts for each debug register. */
229 static int dr_ref_count[4];
233 static int prog_has_started = 0;
234 static void go32_open (char *name, int from_tty);
235 static void go32_close (int quitting);
236 static void go32_attach (struct target_ops *ops, char *args, int from_tty);
237 static void go32_detach (struct target_ops *ops, char *args, int from_tty);
238 static void go32_resume (struct target_ops *ops,
239 ptid_t ptid, int step,
240 enum target_signal siggnal);
241 static void go32_fetch_registers (struct target_ops *ops,
242 struct regcache *, int regno);
243 static void store_register (const struct regcache *, int regno);
244 static void go32_store_registers (struct target_ops *ops,
245 struct regcache *, int regno);
246 static void go32_prepare_to_store (struct regcache *);
247 static int go32_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
249 struct mem_attrib *attrib,
250 struct target_ops *target);
251 static void go32_files_info (struct target_ops *target);
252 static void go32_stop (ptid_t);
253 static void go32_kill_inferior (struct target_ops *ops);
254 static void go32_create_inferior (struct target_ops *ops, char *exec_file,
255 char *args, char **env, int from_tty);
256 static void go32_mourn_inferior (struct target_ops *ops);
257 static int go32_can_run (void);
259 static struct target_ops go32_ops;
260 static void go32_terminal_init (void);
261 static void go32_terminal_inferior (void);
262 static void go32_terminal_ours (void);
264 #define r_ofs(x) (offsetof(TSS,x))
273 {r_ofs (tss_eax), 4}, /* normal registers, from a_tss */
274 {r_ofs (tss_ecx), 4},
275 {r_ofs (tss_edx), 4},
276 {r_ofs (tss_ebx), 4},
277 {r_ofs (tss_esp), 4},
278 {r_ofs (tss_ebp), 4},
279 {r_ofs (tss_esi), 4},
280 {r_ofs (tss_edi), 4},
281 {r_ofs (tss_eip), 4},
282 {r_ofs (tss_eflags), 4},
289 {0, 10}, /* 8 FP registers, from npx.reg[] */
297 /* The order of the next 7 registers must be consistent
298 with their numbering in config/i386/tm-i386.h, which see. */
299 {0, 2}, /* control word, from npx */
300 {4, 2}, /* status word, from npx */
301 {8, 2}, /* tag word, from npx */
302 {16, 2}, /* last FP exception CS from npx */
303 {12, 4}, /* last FP exception EIP from npx */
304 {24, 2}, /* last FP exception operand selector from npx */
305 {20, 4}, /* last FP exception operand offset from npx */
306 {18, 2} /* last FP opcode from npx */
312 enum target_signal gdb_sig;
316 {0, TARGET_SIGNAL_FPE},
317 {1, TARGET_SIGNAL_TRAP},
318 /* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
319 but I think SIGBUS is better, since the NMI is usually activated
320 as a result of a memory parity check failure. */
321 {2, TARGET_SIGNAL_BUS},
322 {3, TARGET_SIGNAL_TRAP},
323 {4, TARGET_SIGNAL_FPE},
324 {5, TARGET_SIGNAL_SEGV},
325 {6, TARGET_SIGNAL_ILL},
326 {7, TARGET_SIGNAL_EMT}, /* no-coprocessor exception */
327 {8, TARGET_SIGNAL_SEGV},
328 {9, TARGET_SIGNAL_SEGV},
329 {10, TARGET_SIGNAL_BUS},
330 {11, TARGET_SIGNAL_SEGV},
331 {12, TARGET_SIGNAL_SEGV},
332 {13, TARGET_SIGNAL_SEGV},
333 {14, TARGET_SIGNAL_SEGV},
334 {16, TARGET_SIGNAL_FPE},
335 {17, TARGET_SIGNAL_BUS},
336 {31, TARGET_SIGNAL_ILL},
337 {0x1b, TARGET_SIGNAL_INT},
338 {0x75, TARGET_SIGNAL_FPE},
339 {0x78, TARGET_SIGNAL_ALRM},
340 {0x79, TARGET_SIGNAL_INT},
341 {0x7a, TARGET_SIGNAL_QUIT},
342 {-1, TARGET_SIGNAL_LAST}
346 enum target_signal gdb_sig;
349 {TARGET_SIGNAL_0, -1},
350 {TARGET_SIGNAL_ILL, 6}, /* Invalid Opcode */
351 {TARGET_SIGNAL_EMT, 7}, /* triggers SIGNOFP */
352 {TARGET_SIGNAL_SEGV, 13}, /* GPF */
353 {TARGET_SIGNAL_BUS, 17}, /* Alignment Check */
354 /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
356 {TARGET_SIGNAL_TERM, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
357 {TARGET_SIGNAL_FPE, 0x75},
358 {TARGET_SIGNAL_INT, 0x79},
359 {TARGET_SIGNAL_QUIT, 0x7a},
360 {TARGET_SIGNAL_ALRM, 0x78}, /* triggers SIGTIMR */
361 {TARGET_SIGNAL_PROF, 0x78},
362 {TARGET_SIGNAL_LAST, -1}
366 go32_open (char *name, int from_tty)
368 printf_unfiltered ("Done. Use the \"run\" command to run the program.\n");
372 go32_close (int quitting)
377 go32_attach (struct target_ops *ops, char *args, int from_tty)
380 You cannot attach to a running program on this platform.\n\
381 Use the `run' command to run DJGPP programs."));
385 go32_detach (struct target_ops *ops, char *args, int from_tty)
389 static int resume_is_step;
390 static int resume_signal = -1;
393 go32_resume (struct target_ops *ops,
394 ptid_t ptid, int step, enum target_signal siggnal)
398 resume_is_step = step;
400 if (siggnal != TARGET_SIGNAL_0 && siggnal != TARGET_SIGNAL_TRAP)
402 for (i = 0, resume_signal = -1;
403 excepn_map[i].gdb_sig != TARGET_SIGNAL_LAST; i++)
404 if (excepn_map[i].gdb_sig == siggnal)
406 resume_signal = excepn_map[i].djgpp_excepno;
409 if (resume_signal == -1)
410 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
411 target_signal_to_name (siggnal));
415 static char child_cwd[FILENAME_MAX];
418 go32_wait (struct target_ops *ops,
419 ptid_t ptid, struct target_waitstatus *status)
422 unsigned char saved_opcode;
423 unsigned long INT3_addr = 0;
424 int stepping_over_INT = 0;
426 a_tss.tss_eflags &= 0xfeff; /* reset the single-step flag (TF) */
429 /* If the next instruction is INT xx or INTO, we need to handle
430 them specially. Intel manuals say that these instructions
431 reset the single-step flag (a.k.a. TF). However, it seems
432 that, at least in the DPMI environment, and at least when
433 stepping over the DPMI interrupt 31h, the problem is having
434 TF set at all when INT 31h is executed: the debuggee either
435 crashes (and takes the system with it) or is killed by a
438 So we need to emulate single-step mode: we put an INT3 opcode
439 right after the INT xx instruction, let the debuggee run
440 until it hits INT3 and stops, then restore the original
441 instruction which we overwrote with the INT3 opcode, and back
442 up the debuggee's EIP to that instruction. */
443 read_child (a_tss.tss_eip, &saved_opcode, 1);
444 if (saved_opcode == 0xCD || saved_opcode == 0xCE)
446 unsigned char INT3_opcode = 0xCC;
449 = saved_opcode == 0xCD ? a_tss.tss_eip + 2 : a_tss.tss_eip + 1;
450 stepping_over_INT = 1;
451 read_child (INT3_addr, &saved_opcode, 1);
452 write_child (INT3_addr, &INT3_opcode, 1);
455 a_tss.tss_eflags |= 0x0100; /* normal instruction: set TF */
458 /* The special value FFFFh in tss_trap indicates to run_child that
459 tss_irqn holds a signal to be delivered to the debuggee. */
460 if (resume_signal <= -1)
463 a_tss.tss_irqn = 0xff;
467 a_tss.tss_trap = 0xffff; /* run_child looks for this */
468 a_tss.tss_irqn = resume_signal;
471 /* The child might change working directory behind our back. The
472 GDB users won't like the side effects of that when they work with
473 relative file names, and GDB might be confused by its current
474 directory not being in sync with the truth. So we always make a
475 point of changing back to where GDB thinks is its cwd, when we
476 return control to the debugger, but restore child's cwd before we
478 /* Initialize child_cwd, before the first call to run_child and not
479 in the initialization, so the child get also the changed directory
480 set with the gdb-command "cd ..." */
482 /* Initialize child's cwd with the current one. */
483 getcwd (child_cwd, sizeof (child_cwd));
487 #if __DJGPP_MINOR__ < 3
491 #if __DJGPP_MINOR__ < 3
495 /* Did we step over an INT xx instruction? */
496 if (stepping_over_INT && a_tss.tss_eip == INT3_addr + 1)
498 /* Restore the original opcode. */
499 a_tss.tss_eip--; /* EIP points *after* the INT3 instruction */
500 write_child (a_tss.tss_eip, &saved_opcode, 1);
501 /* Simulate a TRAP exception. */
503 a_tss.tss_eflags |= 0x0100;
506 getcwd (child_cwd, sizeof (child_cwd)); /* in case it has changed */
507 chdir (current_directory);
509 if (a_tss.tss_irqn == 0x21)
511 status->kind = TARGET_WAITKIND_EXITED;
512 status->value.integer = a_tss.tss_eax & 0xff;
516 status->value.sig = TARGET_SIGNAL_UNKNOWN;
517 status->kind = TARGET_WAITKIND_STOPPED;
518 for (i = 0; sig_map[i].go32_sig != -1; i++)
520 if (a_tss.tss_irqn == sig_map[i].go32_sig)
522 #if __DJGPP_MINOR__ < 3
523 if ((status->value.sig = sig_map[i].gdb_sig) !=
525 status->kind = TARGET_WAITKIND_SIGNALLED;
527 status->value.sig = sig_map[i].gdb_sig;
533 return pid_to_ptid (SOME_PID);
537 fetch_register (struct regcache *regcache, int regno)
539 struct gdbarch *gdbarch = get_regcache_arch (regcache);
540 if (regno < gdbarch_fp0_regnum (gdbarch))
541 regcache_raw_supply (regcache, regno,
542 (char *) &a_tss + regno_mapping[regno].tss_ofs);
543 else if (i386_fp_regnum_p (gdbarch, regno) || i386_fpc_regnum_p (gdbarch, regno))
544 i387_supply_fsave (regcache, regno, &npx);
546 internal_error (__FILE__, __LINE__,
547 _("Invalid register no. %d in fetch_register."), regno);
551 go32_fetch_registers (struct target_ops *ops,
552 struct regcache *regcache, int regno)
555 fetch_register (regcache, regno);
559 regno < gdbarch_fp0_regnum (get_regcache_arch (regcache));
561 fetch_register (regcache, regno);
562 i387_supply_fsave (regcache, -1, &npx);
567 store_register (const struct regcache *regcache, int regno)
569 struct gdbarch *gdbarch = get_regcache_arch (regcache);
570 if (regno < gdbarch_fp0_regnum (gdbarch))
571 regcache_raw_collect (regcache, regno,
572 (char *) &a_tss + regno_mapping[regno].tss_ofs);
573 else if (i386_fp_regnum_p (gdbarch, regno) || i386_fpc_regnum_p (gdbarch, regno))
574 i387_collect_fsave (regcache, regno, &npx);
576 internal_error (__FILE__, __LINE__,
577 _("Invalid register no. %d in store_register."), regno);
581 go32_store_registers (struct target_ops *ops,
582 struct regcache *regcache, int regno)
587 store_register (regcache, regno);
590 for (r = 0; r < gdbarch_fp0_regnum (get_regcache_arch (regcache)); r++)
591 store_register (regcache, r);
592 i387_collect_fsave (regcache, -1, &npx);
597 go32_prepare_to_store (struct regcache *regcache)
602 go32_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
603 struct mem_attrib *attrib, struct target_ops *target)
607 if (write_child (memaddr, myaddr, len))
618 if (read_child (memaddr, myaddr, len))
629 static cmdline_t child_cmd; /* parsed child's command line kept here */
632 go32_files_info (struct target_ops *target)
634 printf_unfiltered ("You are running a DJGPP V2 program.\n");
638 go32_stop (ptid_t ptid)
642 ptid = inferior_ptid;
643 inferior_ptid = null_ptid;
644 delete_thread_silent (ptid);
645 prog_has_started = 0;
649 go32_kill_inferior (struct target_ops *ops)
651 redir_cmdline_delete (&child_cmd);
654 if (!ptid_equal (inferior_ptid, null_ptid))
655 delete_thread_silent (inferior_ptid);
656 unpush_target (&go32_ops);
660 go32_create_inferior (struct target_ops *ops, char *exec_file,
661 char *args, char **env, int from_tty)
663 extern char **environ;
666 char **env_save = environ;
669 /* If no exec file handed to us, get it from the exec-file command -- with
670 a good, common error message if none is specified. */
672 exec_file = get_exec_file (1);
674 if (prog_has_started)
676 go32_stop (inferior_ptid);
677 go32_kill_inferior (ops);
682 /* Initialize child's cwd as empty to be initialized when starting
686 /* Init command line storage. */
687 if (redir_debug_init (&child_cmd) == -1)
688 internal_error (__FILE__, __LINE__,
689 _("Cannot allocate redirection storage: not enough memory.\n"));
691 /* Parse the command line and create redirections. */
692 if (strpbrk (args, "<>"))
694 if (redir_cmdline_parse (args, &child_cmd) == 0)
695 args = child_cmd.command;
697 error (_("Syntax error in command line."));
700 child_cmd.command = xstrdup (args);
702 cmdlen = strlen (args);
703 /* v2loadimage passes command lines via DOS memory, so it cannot
704 possibly handle commands longer than 1MB. */
705 if (cmdlen > 1024*1024)
706 error (_("Command line too long."));
708 cmdline = xmalloc (cmdlen + 4);
709 strcpy (cmdline + 1, args);
710 /* If the command-line length fits into DOS 126-char limits, use the
711 DOS command tail format; otherwise, tell v2loadimage to pass it
712 through a buffer in conventional memory. */
715 cmdline[0] = strlen (args);
716 cmdline[cmdlen + 1] = 13;
719 cmdline[0] = 0xff; /* signal v2loadimage it's a long command */
723 if (v2loadimage (exec_file, cmdline, start_state))
726 printf_unfiltered ("Load failed for image %s\n", exec_file);
732 edi_init (start_state);
733 #if __DJGPP_MINOR__ < 3
737 inferior_ptid = pid_to_ptid (SOME_PID);
738 add_inferior_silent (SOME_PID);
740 push_target (&go32_ops);
742 add_thread_silent (inferior_ptid);
744 clear_proceed_status ();
745 insert_breakpoints ();
746 prog_has_started = 1;
750 go32_mourn_inferior (struct target_ops *ops)
752 /* We need to make sure all the breakpoint enable bits in the DR7
753 register are reset when the inferior exits. Otherwise, if they
754 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
755 failure to set more watchpoints, and other calamities. It would
756 be nice if GDB itself would take care to remove all breakpoints
757 at all times, but it doesn't, probably under an assumption that
758 the OS cleans up when the debuggee exits. */
759 i386_cleanup_dregs ();
760 go32_kill_inferior (ops);
761 generic_mourn_inferior ();
770 /* Hardware watchpoint support. */
772 #define D_REGS edi.dr
773 #define CONTROL D_REGS[7]
774 #define STATUS D_REGS[6]
776 /* Pass the address ADDR to the inferior in the I'th debug register.
777 Here we just store the address in D_REGS, the watchpoint will be
778 actually set up when go32_wait runs the debuggee. */
780 go32_set_dr (int i, CORE_ADDR addr)
783 internal_error (__FILE__, __LINE__,
784 _("Invalid register %d in go32_set_dr.\n"), i);
788 /* Pass the value VAL to the inferior in the DR7 debug control
789 register. Here we just store the address in D_REGS, the watchpoint
790 will be actually set up when go32_wait runs the debuggee. */
792 go32_set_dr7 (unsigned val)
797 /* Get the value of the DR6 debug status register from the inferior.
798 Here we just return the value stored in D_REGS, as we've got it
799 from the last go32_wait call. */
806 /* Put the device open on handle FD into either raw or cooked
807 mode, return 1 if it was in raw mode, zero otherwise. */
810 device_mode (int fd, int raw_p)
812 int oldmode, newmode;
817 __dpmi_int (0x21, ®s);
818 if (regs.x.flags & 1)
820 newmode = oldmode = regs.x.dx;
827 if (oldmode & 0x80) /* Only for character dev */
831 regs.x.dx = newmode & 0xff; /* Force upper byte zero, else it fails */
832 __dpmi_int (0x21, ®s);
833 if (regs.x.flags & 1)
836 return (oldmode & 0x20) == 0x20;
840 static int inf_mode_valid = 0;
841 static int inf_terminal_mode;
843 /* This semaphore is needed because, amazingly enough, GDB calls
844 target.to_terminal_ours more than once after the inferior stops.
845 But we need the information from the first call only, since the
846 second call will always see GDB's own cooked terminal. */
847 static int terminal_is_ours = 1;
850 go32_terminal_init (void)
852 inf_mode_valid = 0; /* reinitialize, in case they are restarting child */
853 terminal_is_ours = 1;
857 go32_terminal_info (char *args, int from_tty)
859 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
861 ? "default" : inf_terminal_mode ? "raw" : "cooked");
863 #if __DJGPP_MINOR__ > 2
864 if (child_cmd.redirection)
868 for (i = 0; i < DBG_HANDLES; i++)
870 if (child_cmd.redirection[i]->file_name)
871 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
872 i, child_cmd.redirection[i]->file_name);
873 else if (_get_dev_info (child_cmd.redirection[i]->inf_handle) == -1)
875 ("\tFile handle %d appears to be closed by inferior.\n", i);
876 /* Mask off the raw/cooked bit when comparing device info words. */
877 else if ((_get_dev_info (child_cmd.redirection[i]->inf_handle) & 0xdf)
878 != (_get_dev_info (i) & 0xdf))
880 ("\tFile handle %d appears to be redirected by inferior.\n", i);
887 go32_terminal_inferior (void)
889 /* Redirect standard handles as child wants them. */
891 if (redir_to_child (&child_cmd) == -1)
893 redir_to_debugger (&child_cmd);
894 error (_("Cannot redirect standard handles for program: %s."),
895 safe_strerror (errno));
897 /* set the console device of the inferior to whatever mode
898 (raw or cooked) we found it last time */
899 if (terminal_is_ours)
902 device_mode (0, inf_terminal_mode);
903 terminal_is_ours = 0;
908 go32_terminal_ours (void)
910 /* Switch to cooked mode on the gdb terminal and save the inferior
911 terminal mode to be restored when it is resumed */
912 if (!terminal_is_ours)
914 inf_terminal_mode = device_mode (0, 0);
915 if (inf_terminal_mode != -1)
918 /* If device_mode returned -1, we don't know what happens with
919 handle 0 anymore, so make the info invalid. */
921 terminal_is_ours = 1;
923 /* Restore debugger's standard handles. */
925 if (redir_to_debugger (&child_cmd) == -1)
927 redir_to_child (&child_cmd);
928 error (_("Cannot redirect standard handles for debugger: %s."),
929 safe_strerror (errno));
935 go32_thread_alive (struct target_ops *ops, ptid_t ptid)
937 return !ptid_equal (inferior_ptid, null_ptid);
941 go32_pid_to_str (struct target_ops *ops, ptid_t ptid)
943 return normal_pid_to_str (ptid);
949 go32_ops.to_shortname = "djgpp";
950 go32_ops.to_longname = "djgpp target process";
952 "Program loaded by djgpp, when gdb is used as an external debugger";
953 go32_ops.to_open = go32_open;
954 go32_ops.to_close = go32_close;
955 go32_ops.to_attach = go32_attach;
956 go32_ops.to_detach = go32_detach;
957 go32_ops.to_resume = go32_resume;
958 go32_ops.to_wait = go32_wait;
959 go32_ops.to_fetch_registers = go32_fetch_registers;
960 go32_ops.to_store_registers = go32_store_registers;
961 go32_ops.to_prepare_to_store = go32_prepare_to_store;
962 go32_ops.deprecated_xfer_memory = go32_xfer_memory;
963 go32_ops.to_files_info = go32_files_info;
964 go32_ops.to_insert_breakpoint = memory_insert_breakpoint;
965 go32_ops.to_remove_breakpoint = memory_remove_breakpoint;
966 go32_ops.to_terminal_init = go32_terminal_init;
967 go32_ops.to_terminal_inferior = go32_terminal_inferior;
968 go32_ops.to_terminal_ours_for_output = go32_terminal_ours;
969 go32_ops.to_terminal_ours = go32_terminal_ours;
970 go32_ops.to_terminal_info = go32_terminal_info;
971 go32_ops.to_kill = go32_kill_inferior;
972 go32_ops.to_create_inferior = go32_create_inferior;
973 go32_ops.to_mourn_inferior = go32_mourn_inferior;
974 go32_ops.to_can_run = go32_can_run;
975 go32_ops.to_stop = go32_stop;
976 go32_ops.to_thread_alive = go32_thread_alive;
977 go32_ops.to_pid_to_str = go32_pid_to_str;
978 go32_ops.to_stratum = process_stratum;
979 go32_ops.to_has_all_memory = 1;
980 go32_ops.to_has_memory = 1;
981 go32_ops.to_has_stack = 1;
982 go32_ops.to_has_registers = 1;
983 go32_ops.to_has_execution = 1;
985 i386_use_watchpoints (&go32_ops);
987 go32_ops.to_magic = OPS_MAGIC;
989 /* Initialize child's cwd as empty to be initialized when starting
993 /* Initialize child's command line storage. */
994 if (redir_debug_init (&child_cmd) == -1)
995 internal_error (__FILE__, __LINE__,
996 _("Cannot allocate redirection storage: not enough memory.\n"));
998 /* We are always processing GCC-compiled programs. */
999 processing_gcc_compilation = 2;
1001 /* Override the default name of the GDB init file. */
1002 strcpy (gdbinit, "gdb.ini");
1005 /* Return the current DOS codepage number. */
1012 __dpmi_int (0x21, ®s);
1013 if (!(regs.x.flags & 1))
1014 return regs.x.bx & 0xffff;
1016 return 437; /* default */
1019 /* Limited emulation of `nl_langinfo', for charset.c. */
1021 nl_langinfo (nl_item item)
1029 /* 8 is enough for SHORT_MAX + "CP" + null. */
1031 int blen = sizeof (buf);
1032 int needed = snprintf (buf, blen, "CP%d", dos_codepage ());
1034 if (needed > blen) /* should never happen */
1036 retval = xstrdup (buf);
1040 retval = xstrdup ("");
1046 unsigned short windows_major, windows_minor;
1048 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */
1050 go32_get_windows_version(void)
1055 __dpmi_int(0x2f, &r);
1056 if (r.h.al > 2 && r.h.al != 0x80 && r.h.al != 0xff
1057 && (r.h.al > 3 || r.h.ah > 0))
1059 windows_major = r.h.al;
1060 windows_minor = r.h.ah;
1063 windows_major = 0xff; /* meaning no Windows */
1066 /* A subroutine of go32_sysinfo to display memory info. */
1068 print_mem (unsigned long datum, const char *header, int in_pages_p)
1070 if (datum != 0xffffffffUL)
1074 puts_filtered (header);
1077 printf_filtered ("%lu KB", datum >> 10);
1078 if (datum > 1024 * 1024)
1079 printf_filtered (" (%lu MB)", datum >> 20);
1082 printf_filtered ("%lu Bytes", datum);
1083 puts_filtered ("\n");
1087 /* Display assorted information about the underlying OS. */
1089 go32_sysinfo (char *arg, int from_tty)
1091 static const char test_pattern[] =
1092 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1093 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1094 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeafdeadbeaf";
1096 char cpuid_vendor[13];
1097 unsigned cpuid_max = 0, cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx;
1098 unsigned true_dos_version = _get_dos_version (1);
1099 unsigned advertized_dos_version = ((unsigned int)_osmajor << 8) | _osminor;
1101 char dpmi_vendor_info[129];
1102 int dpmi_vendor_available;
1103 __dpmi_version_ret dpmi_version_data;
1105 __dpmi_free_mem_info mem_info;
1108 cpuid_vendor[0] = '\0';
1110 strcpy (u.machine, "Unknown x86");
1111 else if (u.machine[0] == 'i' && u.machine[1] > 4)
1113 /* CPUID with EAX = 0 returns the Vendor ID. */
1114 __asm__ __volatile__ ("xorl %%ebx, %%ebx;"
1115 "xorl %%ecx, %%ecx;"
1116 "xorl %%edx, %%edx;"
1123 : "=m" (cpuid_vendor[0]),
1124 "=m" (cpuid_vendor[4]),
1125 "=m" (cpuid_vendor[8]),
1128 : "%eax", "%ebx", "%ecx", "%edx");
1129 cpuid_vendor[12] = '\0';
1132 printf_filtered ("CPU Type.......................%s", u.machine);
1133 if (cpuid_vendor[0])
1134 printf_filtered (" (%s)", cpuid_vendor);
1135 puts_filtered ("\n");
1137 /* CPUID with EAX = 1 returns processor signature and features. */
1140 static char *brand_name[] = {
1148 char cpu_string[80];
1151 int intel_p = strcmp (cpuid_vendor, "GenuineIntel") == 0;
1152 int amd_p = strcmp (cpuid_vendor, "AuthenticAMD") == 0;
1153 unsigned cpu_family, cpu_model;
1155 __asm__ __volatile__ ("movl $1, %%eax;"
1162 brand_idx = cpuid_ebx & 0xff;
1163 cpu_family = (cpuid_eax >> 8) & 0xf;
1164 cpu_model = (cpuid_eax >> 4) & 0xf;
1165 cpu_brand[0] = '\0';
1169 && brand_idx < sizeof(brand_name)/sizeof(brand_name[0])
1170 && *brand_name[brand_idx])
1171 strcpy (cpu_brand, brand_name[brand_idx]);
1172 else if (cpu_family == 5)
1174 if (((cpuid_eax >> 12) & 3) == 0 && cpu_model == 4)
1175 strcpy (cpu_brand, " MMX");
1176 else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 1)
1177 strcpy (cpu_brand, " OverDrive");
1178 else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 2)
1179 strcpy (cpu_brand, " Dual");
1181 else if (cpu_family == 6 && cpu_model < 8)
1186 strcpy (cpu_brand, " Pro");
1189 strcpy (cpu_brand, " II");
1192 strcpy (cpu_brand, " II Xeon");
1195 strcpy (cpu_brand, " Celeron");
1198 strcpy (cpu_brand, " III");
1208 strcpy (cpu_brand, "486/5x86");
1217 strcpy (cpu_brand, "-K5");
1221 strcpy (cpu_brand, "-K6");
1224 strcpy (cpu_brand, "-K6-2");
1227 strcpy (cpu_brand, "-K6-III");
1237 strcpy (cpu_brand, " Athlon");
1240 strcpy (cpu_brand, " Duron");
1246 sprintf (cpu_string, "%s%s Model %d Stepping %d",
1247 intel_p ? "Pentium" : (amd_p ? "AMD" : "ix86"),
1248 cpu_brand, cpu_model, cpuid_eax & 0xf);
1249 printfi_filtered (31, "%s\n", cpu_string);
1250 if (((cpuid_edx & (6 | (0x0d << 23))) != 0)
1251 || ((cpuid_edx & 1) == 0)
1252 || (amd_p && (cpuid_edx & (3 << 30)) != 0))
1254 puts_filtered ("CPU Features...................");
1255 /* We only list features which might be useful in the DPMI
1257 if ((cpuid_edx & 1) == 0)
1258 puts_filtered ("No FPU "); /* it's unusual to not have an FPU */
1259 if ((cpuid_edx & (1 << 1)) != 0)
1260 puts_filtered ("VME ");
1261 if ((cpuid_edx & (1 << 2)) != 0)
1262 puts_filtered ("DE ");
1263 if ((cpuid_edx & (1 << 4)) != 0)
1264 puts_filtered ("TSC ");
1265 if ((cpuid_edx & (1 << 23)) != 0)
1266 puts_filtered ("MMX ");
1267 if ((cpuid_edx & (1 << 25)) != 0)
1268 puts_filtered ("SSE ");
1269 if ((cpuid_edx & (1 << 26)) != 0)
1270 puts_filtered ("SSE2 ");
1273 if ((cpuid_edx & (1 << 31)) != 0)
1274 puts_filtered ("3DNow! ");
1275 if ((cpuid_edx & (1 << 30)) != 0)
1276 puts_filtered ("3DNow!Ext");
1278 puts_filtered ("\n");
1281 puts_filtered ("\n");
1282 printf_filtered ("DOS Version....................%s %s.%s",
1283 _os_flavor, u.release, u.version);
1284 if (true_dos_version != advertized_dos_version)
1285 printf_filtered (" (disguised as v%d.%d)", _osmajor, _osminor);
1286 puts_filtered ("\n");
1288 go32_get_windows_version ();
1289 if (windows_major != 0xff)
1291 const char *windows_flavor;
1293 printf_filtered ("Windows Version................%d.%02d (Windows ",
1294 windows_major, windows_minor);
1295 switch (windows_major)
1298 windows_flavor = "3.X";
1301 switch (windows_minor)
1304 windows_flavor = "95, 95A, or 95B";
1307 windows_flavor = "95B OSR2.1 or 95C OSR2.5";
1310 windows_flavor = "98 or 98 SE";
1313 windows_flavor = "ME";
1316 windows_flavor = "9X";
1321 windows_flavor = "??";
1324 printf_filtered ("%s)\n", windows_flavor);
1326 else if (true_dos_version == 0x532 && advertized_dos_version == 0x500)
1327 printf_filtered ("Windows Version................Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
1328 puts_filtered ("\n");
1329 /* On some versions of Windows, __dpmi_get_capabilities returns
1330 zero, but the buffer is not filled with info, so we fill the
1331 buffer with a known pattern and test for it afterwards. */
1332 memcpy (dpmi_vendor_info, test_pattern, sizeof(dpmi_vendor_info));
1333 dpmi_vendor_available =
1334 __dpmi_get_capabilities (&dpmi_flags, dpmi_vendor_info);
1335 if (dpmi_vendor_available == 0
1336 && memcmp (dpmi_vendor_info, test_pattern,
1337 sizeof(dpmi_vendor_info)) != 0)
1339 /* The DPMI spec says the vendor string should be ASCIIZ, but
1340 I don't trust the vendors to follow that... */
1341 if (!memchr (&dpmi_vendor_info[2], 0, 126))
1342 dpmi_vendor_info[128] = '\0';
1343 printf_filtered ("DPMI Host......................%s v%d.%d (capabilities: %#x)\n",
1344 &dpmi_vendor_info[2],
1345 (unsigned)dpmi_vendor_info[0],
1346 (unsigned)dpmi_vendor_info[1],
1347 ((unsigned)dpmi_flags & 0x7f));
1350 printf_filtered ("DPMI Host......................(Info not available)\n");
1351 __dpmi_get_version (&dpmi_version_data);
1352 printf_filtered ("DPMI Version...................%d.%02d\n",
1353 dpmi_version_data.major, dpmi_version_data.minor);
1354 printf_filtered ("DPMI Info......................%s-bit DPMI, with%s Virtual Memory support\n",
1355 (dpmi_version_data.flags & 1) ? "32" : "16",
1356 (dpmi_version_data.flags & 4) ? "" : "out");
1357 printfi_filtered (31, "Interrupts reflected to %s mode\n",
1358 (dpmi_version_data.flags & 2) ? "V86" : "Real");
1359 printfi_filtered (31, "Processor type: i%d86\n",
1360 dpmi_version_data.cpu);
1361 printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
1362 dpmi_version_data.master_pic, dpmi_version_data.slave_pic);
1364 /* a_tss is only initialized when the debuggee is first run. */
1365 if (prog_has_started)
1367 __asm__ __volatile__ ("pushfl ; popl %0" : "=g" (eflags));
1368 printf_filtered ("Protection.....................Ring %d (in %s), with%s I/O protection\n",
1369 a_tss.tss_cs & 3, (a_tss.tss_cs & 4) ? "LDT" : "GDT",
1370 (a_tss.tss_cs & 3) > ((eflags >> 12) & 3) ? "" : "out");
1372 puts_filtered ("\n");
1373 __dpmi_get_free_memory_information (&mem_info);
1374 print_mem (mem_info.total_number_of_physical_pages,
1375 "DPMI Total Physical Memory.....", 1);
1376 print_mem (mem_info.total_number_of_free_pages,
1377 "DPMI Free Physical Memory......", 1);
1378 print_mem (mem_info.size_of_paging_file_partition_in_pages,
1379 "DPMI Swap Space................", 1);
1380 print_mem (mem_info.linear_address_space_size_in_pages,
1381 "DPMI Total Linear Address Size.", 1);
1382 print_mem (mem_info.free_linear_address_space_in_pages,
1383 "DPMI Free Linear Address Size..", 1);
1384 print_mem (mem_info.largest_available_free_block_in_bytes,
1385 "DPMI Largest Free Memory Block.", 0);
1389 __dpmi_int (0x21, ®s);
1390 print_mem (regs.x.bx << 4, "Free DOS Memory................", 0);
1392 __dpmi_int (0x21, ®s);
1393 if ((regs.x.flags & 1) == 0)
1395 static const char *dos_hilo[] = {
1396 "Low", "", "", "", "High", "", "", "", "High, then Low"
1398 static const char *dos_fit[] = {
1399 "First", "Best", "Last"
1401 int hilo_idx = (regs.x.ax >> 4) & 0x0f;
1402 int fit_idx = regs.x.ax & 0x0f;
1408 printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1409 dos_hilo[hilo_idx], dos_fit[fit_idx]);
1411 __dpmi_int (0x21, ®s);
1412 if ((regs.x.flags & 1) != 0)
1414 printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1415 regs.h.al == 0 ? "not " : "");
1420 unsigned short limit0;
1421 unsigned short base0;
1422 unsigned char base1;
1427 unsigned available:1;
1430 unsigned page_granular:1;
1431 unsigned char base2;
1432 } __attribute__ ((packed));
1435 unsigned short offset0;
1436 unsigned short selector;
1437 unsigned param_count:5;
1442 unsigned short offset1;
1443 } __attribute__ ((packed));
1445 /* Read LEN bytes starting at logical address ADDR, and put the result
1446 into DEST. Return 1 if success, zero if not. */
1448 read_memory_region (unsigned long addr, void *dest, size_t len)
1450 unsigned long dos_ds_limit = __dpmi_get_segment_limit (_dos_ds);
1453 /* For the low memory, we can simply use _dos_ds. */
1454 if (addr <= dos_ds_limit - len)
1455 dosmemget (addr, len, dest);
1458 /* For memory above 1MB we need to set up a special segment to
1459 be able to access that memory. */
1460 int sel = __dpmi_allocate_ldt_descriptors (1);
1466 int access_rights = __dpmi_get_descriptor_access_rights (sel);
1467 size_t segment_limit = len - 1;
1469 /* Make sure the crucial bits in the descriptor access
1470 rights are set correctly. Some DPMI providers might barf
1471 if we set the segment limit to something that is not an
1472 integral multiple of 4KB pages if the granularity bit is
1473 not set to byte-granular, even though the DPMI spec says
1474 it's the host's responsibility to set that bit correctly. */
1475 if (len > 1024 * 1024)
1477 access_rights |= 0x8000;
1478 /* Page-granular segments should have the low 12 bits of
1480 segment_limit |= 0xfff;
1483 access_rights &= ~0x8000;
1485 if (__dpmi_set_segment_base_address (sel, addr) != -1
1486 && __dpmi_set_descriptor_access_rights (sel, access_rights) != -1
1487 && __dpmi_set_segment_limit (sel, segment_limit) != -1
1488 /* W2K silently fails to set the segment limit, leaving
1489 it at zero; this test avoids the resulting crash. */
1490 && __dpmi_get_segment_limit (sel) >= segment_limit)
1491 movedata (sel, 0, _my_ds (), (unsigned)dest, len);
1495 __dpmi_free_ldt_descriptor (sel);
1501 /* Get a segment descriptor stored at index IDX in the descriptor
1502 table whose base address is TABLE_BASE. Return the descriptor
1503 type, or -1 if failure. */
1505 get_descriptor (unsigned long table_base, int idx, void *descr)
1507 unsigned long addr = table_base + idx * 8; /* 8 bytes per entry */
1509 if (read_memory_region (addr, descr, 8))
1510 return (int)((struct seg_descr *)descr)->stype;
1515 unsigned short limit __attribute__((packed));
1516 unsigned long base __attribute__((packed));
1519 /* Display a segment descriptor stored at index IDX in a descriptor
1520 table whose type is TYPE and whose base address is BASE_ADDR. If
1521 FORCE is non-zero, display even invalid descriptors. */
1523 display_descriptor (unsigned type, unsigned long base_addr, int idx, int force)
1525 struct seg_descr descr;
1526 struct gate_descr gate;
1528 /* Get the descriptor from the table. */
1529 if (idx == 0 && type == 0)
1530 puts_filtered ("0x000: null descriptor\n");
1531 else if (get_descriptor (base_addr, idx, &descr) != -1)
1533 /* For each type of descriptor table, this has a bit set if the
1534 corresponding type of selectors is valid in that table. */
1535 static unsigned allowed_descriptors[] = {
1536 0xffffdafeL, /* GDT */
1537 0x0000c0e0L, /* IDT */
1538 0xffffdafaL /* LDT */
1541 /* If the program hasn't started yet, assume the debuggee will
1542 have the same CPL as the debugger. */
1543 int cpl = prog_has_started ? (a_tss.tss_cs & 3) : _my_cs () & 3;
1544 unsigned long limit = (descr.limit1 << 16) | descr.limit0;
1547 && (allowed_descriptors[type] & (1 << descr.stype)) != 0)
1549 printf_filtered ("0x%03x: ",
1551 ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1552 if (descr.page_granular)
1553 limit = (limit << 12) | 0xfff; /* big segment: low 12 bit set */
1554 if (descr.stype == 1 || descr.stype == 2 || descr.stype == 3
1555 || descr.stype == 9 || descr.stype == 11
1556 || (descr.stype >= 16 && descr.stype < 32))
1557 printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1558 descr.base2, descr.base1, descr.base0, limit);
1560 switch (descr.stype)
1564 printf_filtered (" 16-bit TSS (task %sactive)",
1565 descr.stype == 3 ? "" : "in");
1568 puts_filtered (" LDT");
1571 memcpy (&gate, &descr, sizeof gate);
1572 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1573 gate.selector, gate.offset1, gate.offset0);
1574 printf_filtered (" 16-bit Call Gate (params=%d)",
1578 printf_filtered ("TSS selector=0x%04x", descr.base0);
1579 printfi_filtered (16, "Task Gate");
1583 memcpy (&gate, &descr, sizeof gate);
1584 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1585 gate.selector, gate.offset1, gate.offset0);
1586 printf_filtered (" 16-bit %s Gate",
1587 descr.stype == 6 ? "Interrupt" : "Trap");
1591 printf_filtered (" 32-bit TSS (task %sactive)",
1592 descr.stype == 3 ? "" : "in");
1595 memcpy (&gate, &descr, sizeof gate);
1596 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1597 gate.selector, gate.offset1, gate.offset0);
1598 printf_filtered (" 32-bit Call Gate (params=%d)",
1603 memcpy (&gate, &descr, sizeof gate);
1604 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1605 gate.selector, gate.offset1, gate.offset0);
1606 printf_filtered (" 32-bit %s Gate",
1607 descr.stype == 14 ? "Interrupt" : "Trap");
1609 case 16: /* data segments */
1617 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1618 descr.bit32 ? "32" : "16",
1619 descr.stype & 2 ? "Read/Write," : "Read-Only, ",
1620 descr.stype & 4 ? "down" : "up",
1621 descr.stype & 1 ? "" : ", N.Acc");
1623 case 24: /* code segments */
1631 printf_filtered (" %s-bit Code (%s, %sConf%s)",
1632 descr.bit32 ? "32" : "16",
1633 descr.stype & 2 ? "Exec/Read" : "Exec-Only",
1634 descr.stype & 4 ? "" : "N.",
1635 descr.stype & 1 ? "" : ", N.Acc");
1638 printf_filtered ("Unknown type 0x%02x", descr.stype);
1641 puts_filtered ("\n");
1645 printf_filtered ("0x%03x: ",
1647 ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1649 puts_filtered ("Segment not present\n");
1651 printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1656 printf_filtered ("0x%03x: Cannot read this descriptor\n", idx);
1660 go32_sldt (char *arg, int from_tty)
1662 struct dtr_reg gdtr;
1663 unsigned short ldtr = 0;
1665 struct seg_descr ldt_descr;
1666 long ldt_entry = -1L;
1667 int cpl = (prog_has_started ? a_tss.tss_cs : _my_cs ()) & 3;
1671 while (*arg && isspace(*arg))
1676 ldt_entry = parse_and_eval_long (arg);
1678 || (ldt_entry & 4) == 0
1679 || (ldt_entry & 3) != (cpl & 3))
1680 error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry);
1684 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1685 __asm__ __volatile__ ("sldt %0" : "=m" (ldtr) : /* no inputs */ );
1688 puts_filtered ("There is no LDT.\n");
1689 /* LDT's entry in the GDT must have the type LDT, which is 2. */
1690 else if (get_descriptor (gdtr.base, ldt_idx, &ldt_descr) != 2)
1691 printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1693 | (ldt_descr.base1 << 16)
1694 | (ldt_descr.base2 << 24));
1699 | (ldt_descr.base1 << 16)
1700 | (ldt_descr.base2 << 24);
1701 unsigned limit = ldt_descr.limit0 | (ldt_descr.limit1 << 16);
1704 if (ldt_descr.page_granular)
1705 /* Page-granular segments must have the low 12 bits of their
1707 limit = (limit << 12) | 0xfff;
1708 /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1713 max_entry = (limit + 1) / 8;
1717 if (ldt_entry > limit)
1718 error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1719 (unsigned long)ldt_entry, limit);
1721 display_descriptor (ldt_descr.stype, base, ldt_entry / 8, 1);
1727 for (i = 0; i < max_entry; i++)
1728 display_descriptor (ldt_descr.stype, base, i, 0);
1734 go32_sgdt (char *arg, int from_tty)
1736 struct dtr_reg gdtr;
1737 long gdt_entry = -1L;
1742 while (*arg && isspace(*arg))
1747 gdt_entry = parse_and_eval_long (arg);
1748 if (gdt_entry < 0 || (gdt_entry & 7) != 0)
1749 error (_("Invalid GDT entry 0x%03lx: not an integral multiple of 8."),
1750 (unsigned long)gdt_entry);
1754 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1755 max_entry = (gdtr.limit + 1) / 8;
1759 if (gdt_entry > gdtr.limit)
1760 error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1761 (unsigned long)gdt_entry, gdtr.limit);
1763 display_descriptor (0, gdtr.base, gdt_entry / 8, 1);
1769 for (i = 0; i < max_entry; i++)
1770 display_descriptor (0, gdtr.base, i, 0);
1775 go32_sidt (char *arg, int from_tty)
1777 struct dtr_reg idtr;
1778 long idt_entry = -1L;
1783 while (*arg && isspace(*arg))
1788 idt_entry = parse_and_eval_long (arg);
1790 error (_("Invalid (negative) IDT entry %ld."), idt_entry);
1794 __asm__ __volatile__ ("sidt %0" : "=m" (idtr) : /* no inputs */ );
1795 max_entry = (idtr.limit + 1) / 8;
1796 if (max_entry > 0x100) /* no more than 256 entries */
1801 if (idt_entry > idtr.limit)
1802 error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1803 (unsigned long)idt_entry, idtr.limit);
1805 display_descriptor (1, idtr.base, idt_entry, 1);
1811 for (i = 0; i < max_entry; i++)
1812 display_descriptor (1, idtr.base, i, 0);
1816 /* Cached linear address of the base of the page directory. For
1817 now, available only under CWSDPMI. Code based on ideas and
1818 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
1819 static unsigned long pdbr;
1821 static unsigned long
1826 unsigned long taskbase, cr3;
1827 struct dtr_reg gdtr;
1829 if (pdbr > 0 && pdbr <= 0xfffff)
1832 /* Get the linear address of GDT and the Task Register. */
1833 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1834 __asm__ __volatile__ ("str %0" : "=m" (taskreg) : /* no inputs */ );
1836 /* Task Register is a segment selector for the TSS of the current
1837 task. Therefore, it can be used as an index into the GDT to get
1838 at the segment descriptor for the TSS. To get the index, reset
1839 the low 3 bits of the selector (which give the CPL). Add 2 to the
1840 offset to point to the 3 low bytes of the base address. */
1841 offset = gdtr.base + (taskreg & 0xfff8) + 2;
1844 /* CWSDPMI's task base is always under the 1MB mark. */
1845 if (offset > 0xfffff)
1848 _farsetsel (_dos_ds);
1849 taskbase = _farnspeekl (offset) & 0xffffffU;
1850 taskbase += _farnspeekl (offset + 2) & 0xff000000U;
1851 if (taskbase > 0xfffff)
1854 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1855 offset 1Ch in the TSS. */
1856 cr3 = _farnspeekl (taskbase + 0x1c) & ~0xfff;
1859 #if 0 /* not fullly supported yet */
1860 /* The Page Directory is in UMBs. In that case, CWSDPMI puts
1861 the first Page Table right below the Page Directory. Thus,
1862 the first Page Table's entry for its own address and the Page
1863 Directory entry for that Page Table will hold the same
1864 physical address. The loop below searches the entire UMB
1865 range of addresses for such an occurence. */
1866 unsigned long addr, pte_idx;
1868 for (addr = 0xb0000, pte_idx = 0xb0;
1870 addr += 0x1000, pte_idx++)
1872 if (((_farnspeekl (addr + 4 * pte_idx) & 0xfffff027) ==
1873 (_farnspeekl (addr + 0x1000) & 0xfffff027))
1874 && ((_farnspeekl (addr + 4 * pte_idx + 4) & 0xfffff000) == cr3))
1876 cr3 = addr + 0x1000;
1889 /* Return the N'th Page Directory entry. */
1890 static unsigned long
1893 unsigned long pde = 0;
1895 if (pdbr && n >= 0 && n < 1024)
1897 pde = _farpeekl (_dos_ds, pdbr + 4*n);
1902 /* Return the N'th entry of the Page Table whose Page Directory entry
1904 static unsigned long
1905 get_pte (unsigned long pde, int n)
1907 unsigned long pte = 0;
1909 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
1910 page tables, for now. */
1911 if ((pde & 1) && !(pde & 0x80) && n >= 0 && n < 1024)
1913 pde &= ~0xfff; /* clear non-address bits */
1914 pte = _farpeekl (_dos_ds, pde + 4*n);
1919 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
1920 says this is a Page Directory entry. If FORCE is non-zero, display
1921 the entry even if its Present flag is off. OFF is the offset of the
1922 address from the page's base address. */
1924 display_ptable_entry (unsigned long entry, int is_dir, int force, unsigned off)
1926 if ((entry & 1) != 0)
1928 printf_filtered ("Base=0x%05lx000", entry >> 12);
1929 if ((entry & 0x100) && !is_dir)
1930 puts_filtered (" Global");
1931 if ((entry & 0x40) && !is_dir)
1932 puts_filtered (" Dirty");
1933 printf_filtered (" %sAcc.", (entry & 0x20) ? "" : "Not-");
1934 printf_filtered (" %sCached", (entry & 0x10) ? "" : "Not-");
1935 printf_filtered (" Write-%s", (entry & 8) ? "Thru" : "Back");
1936 printf_filtered (" %s", (entry & 4) ? "Usr" : "Sup");
1937 printf_filtered (" Read-%s", (entry & 2) ? "Write" : "Only");
1939 printf_filtered (" +0x%x", off);
1940 puts_filtered ("\n");
1943 printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1944 is_dir ? " Table" : "", entry >> 1);
1948 go32_pde (char *arg, int from_tty)
1950 long pde_idx = -1, i;
1954 while (*arg && isspace(*arg))
1959 pde_idx = parse_and_eval_long (arg);
1960 if (pde_idx < 0 || pde_idx >= 1024)
1961 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
1967 puts_filtered ("Access to Page Directories is not supported on this system.\n");
1968 else if (pde_idx >= 0)
1969 display_ptable_entry (get_pde (pde_idx), 1, 1, 0);
1971 for (i = 0; i < 1024; i++)
1972 display_ptable_entry (get_pde (i), 1, 0, 0);
1975 /* A helper function to display entries in a Page Table pointed to by
1976 the N'th entry in the Page Directory. If FORCE is non-zero, say
1977 something even if the Page Table is not accessible. */
1979 display_page_table (long n, int force)
1981 unsigned long pde = get_pde (n);
1987 printf_filtered ("Page Table pointed to by Page Directory entry 0x%lx:\n", n);
1988 for (i = 0; i < 1024; i++)
1989 display_ptable_entry (get_pte (pde, i), 0, 0, 0);
1990 puts_filtered ("\n");
1993 printf_filtered ("Page Table not present; value=0x%lx.\n", pde >> 1);
1997 go32_pte (char *arg, int from_tty)
1999 long pde_idx = -1L, i;
2003 while (*arg && isspace(*arg))
2008 pde_idx = parse_and_eval_long (arg);
2009 if (pde_idx < 0 || pde_idx >= 1024)
2010 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
2016 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2017 else if (pde_idx >= 0)
2018 display_page_table (pde_idx, 1);
2020 for (i = 0; i < 1024; i++)
2021 display_page_table (i, 0);
2025 go32_pte_for_address (char *arg, int from_tty)
2027 CORE_ADDR addr = 0, i;
2031 while (*arg && isspace(*arg))
2035 addr = parse_and_eval_address (arg);
2038 error_no_arg (_("linear address"));
2042 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2045 int pde_idx = (addr >> 22) & 0x3ff;
2046 int pte_idx = (addr >> 12) & 0x3ff;
2047 unsigned offs = addr & 0xfff;
2049 printf_filtered ("Page Table entry for address 0x%llx:\n",
2050 (unsigned long long)addr);
2051 display_ptable_entry (get_pte (get_pde (pde_idx), pte_idx), 0, 1, offs);
2055 static struct cmd_list_element *info_dos_cmdlist = NULL;
2058 go32_info_dos_command (char *args, int from_tty)
2060 help_list (info_dos_cmdlist, "info dos ", class_info, gdb_stdout);
2064 _initialize_go32_nat (void)
2067 add_target (&go32_ops);
2069 add_prefix_cmd ("dos", class_info, go32_info_dos_command, _("\
2070 Print information specific to DJGPP (aka MS-DOS) debugging."),
2071 &info_dos_cmdlist, "info dos ", 0, &infolist);
2073 add_cmd ("sysinfo", class_info, go32_sysinfo, _("\
2074 Display information about the target system, including CPU, OS, DPMI, etc."),
2076 add_cmd ("ldt", class_info, go32_sldt, _("\
2077 Display entries in the LDT (Local Descriptor Table).\n\
2078 Entry number (an expression) as an argument means display only that entry."),
2080 add_cmd ("gdt", class_info, go32_sgdt, _("\
2081 Display entries in the GDT (Global Descriptor Table).\n\
2082 Entry number (an expression) as an argument means display only that entry."),
2084 add_cmd ("idt", class_info, go32_sidt, _("\
2085 Display entries in the IDT (Interrupt Descriptor Table).\n\
2086 Entry number (an expression) as an argument means display only that entry."),
2088 add_cmd ("pde", class_info, go32_pde, _("\
2089 Display entries in the Page Directory.\n\
2090 Entry number (an expression) as an argument means display only that entry."),
2092 add_cmd ("pte", class_info, go32_pte, _("\
2093 Display entries in Page Tables.\n\
2094 Entry number (an expression) as an argument means display only entries\n\
2095 from the Page Table pointed to by the specified Page Directory entry."),
2097 add_cmd ("address-pte", class_info, go32_pte_for_address, _("\
2098 Display a Page Table entry for a linear address.\n\
2099 The address argument must be a linear address, after adding to\n\
2100 it the base address of the appropriate segment.\n\
2101 The base address of variables and functions in the debuggee's data\n\
2102 or code segment is stored in the variable __djgpp_base_address,\n\
2103 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
2104 For other segments, look up their base address in the output of\n\
2105 the `info dos ldt' command."),
2119 tcsetpgrp (int fd, pid_t pgid)
2121 if (isatty (fd) && pgid == SOME_PID)
2123 errno = pgid == SOME_PID ? ENOTTY : ENOSYS;