1 /* Native debugging support for Intel x86 running DJGPP.
2 Copyright (C) 1997, 1999, 2000, 2001, 2005, 2006, 2007
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 2 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, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
31 #include "floatformat.h"
33 #include "i387-tdep.h"
34 #include "i386-tdep.h"
37 #include "gdb_string.h"
40 #include <stdio.h> /* might be required for __DJGPP_MINOR__ */
45 #include <sys/utsname.h>
50 #include <sys/farptr.h>
51 #include <debug/v2load.h>
52 #include <debug/dbgcom.h>
53 #if __DJGPP_MINOR__ > 2
54 #include <debug/redir.h>
57 #if __DJGPP_MINOR__ < 3
58 /* This code will be provided from DJGPP 2.03 on. Until then I code it
66 unsigned short exponent:15;
67 unsigned short sign:1;
86 static void save_npx (void); /* Save the FPU of the debugged program */
87 static void load_npx (void); /* Restore the FPU of the debugged program */
89 /* ------------------------------------------------------------------------- */
90 /* Store the contents of the NPX in the global variable `npx'. */
96 asm ("inb $0xa0, %%al \n\
115 /* ------------------------------------------------------------------------- */
116 /* Reload the contents of the NPX from the global variable `npx'. */
121 asm ("frstor %0":"=m" (npx));
123 /* ------------------------------------------------------------------------- */
124 /* Stubs for the missing redirection functions. */
131 redir_cmdline_delete (cmdline_t *ptr)
137 redir_cmdline_parse (const char *args, cmdline_t *ptr)
143 redir_to_child (cmdline_t *ptr)
149 redir_to_debugger (cmdline_t *ptr)
155 redir_debug_init (cmdline_t *ptr)
159 #endif /* __DJGPP_MINOR < 3 */
161 typedef enum { wp_insert, wp_remove, wp_count } wp_op;
163 /* This holds the current reference counts for each debug register. */
164 static int dr_ref_count[4];
168 static int prog_has_started = 0;
169 static void go32_open (char *name, int from_tty);
170 static void go32_close (int quitting);
171 static void go32_attach (char *args, int from_tty);
172 static void go32_detach (char *args, int from_tty);
173 static void go32_resume (ptid_t ptid, int step,
174 enum target_signal siggnal);
175 static ptid_t go32_wait (ptid_t ptid,
176 struct target_waitstatus *status);
177 static void go32_fetch_registers (struct regcache *, int regno);
178 static void store_register (const struct regcache *, int regno);
179 static void go32_store_registers (struct regcache *, int regno);
180 static void go32_prepare_to_store (void);
181 static int go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
183 struct mem_attrib *attrib,
184 struct target_ops *target);
185 static void go32_files_info (struct target_ops *target);
186 static void go32_stop (void);
187 static void go32_kill_inferior (void);
188 static void go32_create_inferior (char *exec_file, char *args, char **env, int from_tty);
189 static void go32_mourn_inferior (void);
190 static int go32_can_run (void);
192 static struct target_ops go32_ops;
193 static void go32_terminal_init (void);
194 static void go32_terminal_inferior (void);
195 static void go32_terminal_ours (void);
197 #define r_ofs(x) (offsetof(TSS,x))
206 {r_ofs (tss_eax), 4}, /* normal registers, from a_tss */
207 {r_ofs (tss_ecx), 4},
208 {r_ofs (tss_edx), 4},
209 {r_ofs (tss_ebx), 4},
210 {r_ofs (tss_esp), 4},
211 {r_ofs (tss_ebp), 4},
212 {r_ofs (tss_esi), 4},
213 {r_ofs (tss_edi), 4},
214 {r_ofs (tss_eip), 4},
215 {r_ofs (tss_eflags), 4},
222 {0, 10}, /* 8 FP registers, from npx.reg[] */
230 /* The order of the next 7 registers must be consistent
231 with their numbering in config/i386/tm-i386.h, which see. */
232 {0, 2}, /* control word, from npx */
233 {4, 2}, /* status word, from npx */
234 {8, 2}, /* tag word, from npx */
235 {16, 2}, /* last FP exception CS from npx */
236 {12, 4}, /* last FP exception EIP from npx */
237 {24, 2}, /* last FP exception operand selector from npx */
238 {20, 4}, /* last FP exception operand offset from npx */
239 {18, 2} /* last FP opcode from npx */
245 enum target_signal gdb_sig;
249 {0, TARGET_SIGNAL_FPE},
250 {1, TARGET_SIGNAL_TRAP},
251 /* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
252 but I think SIGBUS is better, since the NMI is usually activated
253 as a result of a memory parity check failure. */
254 {2, TARGET_SIGNAL_BUS},
255 {3, TARGET_SIGNAL_TRAP},
256 {4, TARGET_SIGNAL_FPE},
257 {5, TARGET_SIGNAL_SEGV},
258 {6, TARGET_SIGNAL_ILL},
259 {7, TARGET_SIGNAL_EMT}, /* no-coprocessor exception */
260 {8, TARGET_SIGNAL_SEGV},
261 {9, TARGET_SIGNAL_SEGV},
262 {10, TARGET_SIGNAL_BUS},
263 {11, TARGET_SIGNAL_SEGV},
264 {12, TARGET_SIGNAL_SEGV},
265 {13, TARGET_SIGNAL_SEGV},
266 {14, TARGET_SIGNAL_SEGV},
267 {16, TARGET_SIGNAL_FPE},
268 {17, TARGET_SIGNAL_BUS},
269 {31, TARGET_SIGNAL_ILL},
270 {0x1b, TARGET_SIGNAL_INT},
271 {0x75, TARGET_SIGNAL_FPE},
272 {0x78, TARGET_SIGNAL_ALRM},
273 {0x79, TARGET_SIGNAL_INT},
274 {0x7a, TARGET_SIGNAL_QUIT},
275 {-1, TARGET_SIGNAL_LAST}
279 enum target_signal gdb_sig;
282 {TARGET_SIGNAL_0, -1},
283 {TARGET_SIGNAL_ILL, 6}, /* Invalid Opcode */
284 {TARGET_SIGNAL_EMT, 7}, /* triggers SIGNOFP */
285 {TARGET_SIGNAL_SEGV, 13}, /* GPF */
286 {TARGET_SIGNAL_BUS, 17}, /* Alignment Check */
287 /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
289 {TARGET_SIGNAL_TERM, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
290 {TARGET_SIGNAL_FPE, 0x75},
291 {TARGET_SIGNAL_INT, 0x79},
292 {TARGET_SIGNAL_QUIT, 0x7a},
293 {TARGET_SIGNAL_ALRM, 0x78}, /* triggers SIGTIMR */
294 {TARGET_SIGNAL_PROF, 0x78},
295 {TARGET_SIGNAL_LAST, -1}
299 go32_open (char *name, int from_tty)
301 printf_unfiltered ("Done. Use the \"run\" command to run the program.\n");
305 go32_close (int quitting)
310 go32_attach (char *args, int from_tty)
313 You cannot attach to a running program on this platform.\n\
314 Use the `run' command to run DJGPP programs."));
318 go32_detach (char *args, int from_tty)
322 static int resume_is_step;
323 static int resume_signal = -1;
326 go32_resume (ptid_t ptid, int step, enum target_signal siggnal)
330 resume_is_step = step;
332 if (siggnal != TARGET_SIGNAL_0 && siggnal != TARGET_SIGNAL_TRAP)
334 for (i = 0, resume_signal = -1;
335 excepn_map[i].gdb_sig != TARGET_SIGNAL_LAST; i++)
336 if (excepn_map[i].gdb_sig == siggnal)
338 resume_signal = excepn_map[i].djgpp_excepno;
341 if (resume_signal == -1)
342 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
343 target_signal_to_name (siggnal));
347 static char child_cwd[FILENAME_MAX];
350 go32_wait (ptid_t ptid, struct target_waitstatus *status)
353 unsigned char saved_opcode;
354 unsigned long INT3_addr = 0;
355 int stepping_over_INT = 0;
357 a_tss.tss_eflags &= 0xfeff; /* reset the single-step flag (TF) */
360 /* If the next instruction is INT xx or INTO, we need to handle
361 them specially. Intel manuals say that these instructions
362 reset the single-step flag (a.k.a. TF). However, it seems
363 that, at least in the DPMI environment, and at least when
364 stepping over the DPMI interrupt 31h, the problem is having
365 TF set at all when INT 31h is executed: the debuggee either
366 crashes (and takes the system with it) or is killed by a
369 So we need to emulate single-step mode: we put an INT3 opcode
370 right after the INT xx instruction, let the debuggee run
371 until it hits INT3 and stops, then restore the original
372 instruction which we overwrote with the INT3 opcode, and back
373 up the debuggee's EIP to that instruction. */
374 read_child (a_tss.tss_eip, &saved_opcode, 1);
375 if (saved_opcode == 0xCD || saved_opcode == 0xCE)
377 unsigned char INT3_opcode = 0xCC;
380 = saved_opcode == 0xCD ? a_tss.tss_eip + 2 : a_tss.tss_eip + 1;
381 stepping_over_INT = 1;
382 read_child (INT3_addr, &saved_opcode, 1);
383 write_child (INT3_addr, &INT3_opcode, 1);
386 a_tss.tss_eflags |= 0x0100; /* normal instruction: set TF */
389 /* The special value FFFFh in tss_trap indicates to run_child that
390 tss_irqn holds a signal to be delivered to the debuggee. */
391 if (resume_signal <= -1)
394 a_tss.tss_irqn = 0xff;
398 a_tss.tss_trap = 0xffff; /* run_child looks for this */
399 a_tss.tss_irqn = resume_signal;
402 /* The child might change working directory behind our back. The
403 GDB users won't like the side effects of that when they work with
404 relative file names, and GDB might be confused by its current
405 directory not being in sync with the truth. So we always make a
406 point of changing back to where GDB thinks is its cwd, when we
407 return control to the debugger, but restore child's cwd before we
409 /* Initialize child_cwd, before the first call to run_child and not
410 in the initialization, so the child get also the changed directory
411 set with the gdb-command "cd ..." */
413 /* Initialize child's cwd with the current one. */
414 getcwd (child_cwd, sizeof (child_cwd));
418 #if __DJGPP_MINOR__ < 3
422 #if __DJGPP_MINOR__ < 3
426 /* Did we step over an INT xx instruction? */
427 if (stepping_over_INT && a_tss.tss_eip == INT3_addr + 1)
429 /* Restore the original opcode. */
430 a_tss.tss_eip--; /* EIP points *after* the INT3 instruction */
431 write_child (a_tss.tss_eip, &saved_opcode, 1);
432 /* Simulate a TRAP exception. */
434 a_tss.tss_eflags |= 0x0100;
437 getcwd (child_cwd, sizeof (child_cwd)); /* in case it has changed */
438 chdir (current_directory);
440 if (a_tss.tss_irqn == 0x21)
442 status->kind = TARGET_WAITKIND_EXITED;
443 status->value.integer = a_tss.tss_eax & 0xff;
447 status->value.sig = TARGET_SIGNAL_UNKNOWN;
448 status->kind = TARGET_WAITKIND_STOPPED;
449 for (i = 0; sig_map[i].go32_sig != -1; i++)
451 if (a_tss.tss_irqn == sig_map[i].go32_sig)
453 #if __DJGPP_MINOR__ < 3
454 if ((status->value.sig = sig_map[i].gdb_sig) !=
456 status->kind = TARGET_WAITKIND_SIGNALLED;
458 status->value.sig = sig_map[i].gdb_sig;
464 return pid_to_ptid (SOME_PID);
468 fetch_register (struct regcache *regcache, int regno)
470 if (regno < FP0_REGNUM)
471 regcache_raw_supply (regcache, regno,
472 (char *) &a_tss + regno_mapping[regno].tss_ofs);
473 else if (i386_fp_regnum_p (regno) || i386_fpc_regnum_p (regno))
474 i387_supply_fsave (regcache, regno, &npx);
476 internal_error (__FILE__, __LINE__,
477 _("Invalid register no. %d in fetch_register."), regno);
481 go32_fetch_registers (struct regcache *regcache, int regno)
484 fetch_register (regcache, regno);
487 for (regno = 0; regno < FP0_REGNUM; regno++)
488 fetch_register (regcache, regno);
489 i387_supply_fsave (regcache, -1, &npx);
494 store_register (const struct regcache *regcache, int regno)
496 if (regno < FP0_REGNUM)
497 regcache_raw_collect (regcache, regno,
498 (char *) &a_tss + regno_mapping[regno].tss_ofs);
499 else if (i386_fp_regnum_p (regno) || i386_fpc_regnum_p (regno))
500 i387_collect_fsave (regcache, regno, &npx);
502 internal_error (__FILE__, __LINE__,
503 _("Invalid register no. %d in store_register."), regno);
507 go32_store_registers (struct regcache *regcache, int regno)
512 store_register (regcache, regno);
515 for (r = 0; r < FP0_REGNUM; r++)
516 store_register (regcache, r);
517 i387_collect_fsave (regcache, -1, &npx);
522 go32_prepare_to_store (void)
527 go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
528 struct mem_attrib *attrib, struct target_ops *target)
532 if (write_child (memaddr, myaddr, len))
543 if (read_child (memaddr, myaddr, len))
554 static cmdline_t child_cmd; /* parsed child's command line kept here */
557 go32_files_info (struct target_ops *target)
559 printf_unfiltered ("You are running a DJGPP V2 program.\n");
567 inferior_ptid = null_ptid;
568 prog_has_started = 0;
572 go32_kill_inferior (void)
574 redir_cmdline_delete (&child_cmd);
577 unpush_target (&go32_ops);
581 go32_create_inferior (char *exec_file, char *args, char **env, int from_tty)
583 extern char **environ;
586 char **env_save = environ;
589 /* If no exec file handed to us, get it from the exec-file command -- with
590 a good, common error message if none is specified. */
592 exec_file = get_exec_file (1);
594 if (prog_has_started)
597 go32_kill_inferior ();
602 /* Initialize child's cwd as empty to be initialized when starting
606 /* Init command line storage. */
607 if (redir_debug_init (&child_cmd) == -1)
608 internal_error (__FILE__, __LINE__,
609 _("Cannot allocate redirection storage: not enough memory.\n"));
611 /* Parse the command line and create redirections. */
612 if (strpbrk (args, "<>"))
614 if (redir_cmdline_parse (args, &child_cmd) == 0)
615 args = child_cmd.command;
617 error (_("Syntax error in command line."));
620 child_cmd.command = xstrdup (args);
622 cmdlen = strlen (args);
623 /* v2loadimage passes command lines via DOS memory, so it cannot
624 possibly handle commands longer than 1MB. */
625 if (cmdlen > 1024*1024)
626 error (_("Command line too long."));
628 cmdline = xmalloc (cmdlen + 4);
629 strcpy (cmdline + 1, args);
630 /* If the command-line length fits into DOS 126-char limits, use the
631 DOS command tail format; otherwise, tell v2loadimage to pass it
632 through a buffer in conventional memory. */
635 cmdline[0] = strlen (args);
636 cmdline[cmdlen + 1] = 13;
639 cmdline[0] = 0xff; /* signal v2loadimage it's a long command */
643 if (v2loadimage (exec_file, cmdline, start_state))
646 printf_unfiltered ("Load failed for image %s\n", exec_file);
652 edi_init (start_state);
653 #if __DJGPP_MINOR__ < 3
657 inferior_ptid = pid_to_ptid (SOME_PID);
658 push_target (&go32_ops);
659 clear_proceed_status ();
660 insert_breakpoints ();
661 prog_has_started = 1;
665 go32_mourn_inferior (void)
667 /* We need to make sure all the breakpoint enable bits in the DR7
668 register are reset when the inferior exits. Otherwise, if they
669 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
670 failure to set more watchpoints, and other calamities. It would
671 be nice if GDB itself would take care to remove all breakpoints
672 at all times, but it doesn't, probably under an assumption that
673 the OS cleans up when the debuggee exits. */
674 i386_cleanup_dregs ();
675 go32_kill_inferior ();
676 generic_mourn_inferior ();
685 /* Hardware watchpoint support. */
687 #define D_REGS edi.dr
688 #define CONTROL D_REGS[7]
689 #define STATUS D_REGS[6]
691 /* Pass the address ADDR to the inferior in the I'th debug register.
692 Here we just store the address in D_REGS, the watchpoint will be
693 actually set up when go32_wait runs the debuggee. */
695 go32_set_dr (int i, CORE_ADDR addr)
698 internal_error (__FILE__, __LINE__,
699 _("Invalid register %d in go32_set_dr.\n"), i);
703 /* Pass the value VAL to the inferior in the DR7 debug control
704 register. Here we just store the address in D_REGS, the watchpoint
705 will be actually set up when go32_wait runs the debuggee. */
707 go32_set_dr7 (unsigned val)
712 /* Get the value of the DR6 debug status register from the inferior.
713 Here we just return the value stored in D_REGS, as we've got it
714 from the last go32_wait call. */
721 /* Put the device open on handle FD into either raw or cooked
722 mode, return 1 if it was in raw mode, zero otherwise. */
725 device_mode (int fd, int raw_p)
727 int oldmode, newmode;
732 __dpmi_int (0x21, ®s);
733 if (regs.x.flags & 1)
735 newmode = oldmode = regs.x.dx;
742 if (oldmode & 0x80) /* Only for character dev */
746 regs.x.dx = newmode & 0xff; /* Force upper byte zero, else it fails */
747 __dpmi_int (0x21, ®s);
748 if (regs.x.flags & 1)
751 return (oldmode & 0x20) == 0x20;
755 static int inf_mode_valid = 0;
756 static int inf_terminal_mode;
758 /* This semaphore is needed because, amazingly enough, GDB calls
759 target.to_terminal_ours more than once after the inferior stops.
760 But we need the information from the first call only, since the
761 second call will always see GDB's own cooked terminal. */
762 static int terminal_is_ours = 1;
765 go32_terminal_init (void)
767 inf_mode_valid = 0; /* reinitialize, in case they are restarting child */
768 terminal_is_ours = 1;
772 go32_terminal_info (char *args, int from_tty)
774 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
776 ? "default" : inf_terminal_mode ? "raw" : "cooked");
778 #if __DJGPP_MINOR__ > 2
779 if (child_cmd.redirection)
783 for (i = 0; i < DBG_HANDLES; i++)
785 if (child_cmd.redirection[i]->file_name)
786 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
787 i, child_cmd.redirection[i]->file_name);
788 else if (_get_dev_info (child_cmd.redirection[i]->inf_handle) == -1)
790 ("\tFile handle %d appears to be closed by inferior.\n", i);
791 /* Mask off the raw/cooked bit when comparing device info words. */
792 else if ((_get_dev_info (child_cmd.redirection[i]->inf_handle) & 0xdf)
793 != (_get_dev_info (i) & 0xdf))
795 ("\tFile handle %d appears to be redirected by inferior.\n", i);
802 go32_terminal_inferior (void)
804 /* Redirect standard handles as child wants them. */
806 if (redir_to_child (&child_cmd) == -1)
808 redir_to_debugger (&child_cmd);
809 error (_("Cannot redirect standard handles for program: %s."),
810 safe_strerror (errno));
812 /* set the console device of the inferior to whatever mode
813 (raw or cooked) we found it last time */
814 if (terminal_is_ours)
817 device_mode (0, inf_terminal_mode);
818 terminal_is_ours = 0;
823 go32_terminal_ours (void)
825 /* Switch to cooked mode on the gdb terminal and save the inferior
826 terminal mode to be restored when it is resumed */
827 if (!terminal_is_ours)
829 inf_terminal_mode = device_mode (0, 0);
830 if (inf_terminal_mode != -1)
833 /* If device_mode returned -1, we don't know what happens with
834 handle 0 anymore, so make the info invalid. */
836 terminal_is_ours = 1;
838 /* Restore debugger's standard handles. */
840 if (redir_to_debugger (&child_cmd) == -1)
842 redir_to_child (&child_cmd);
843 error (_("Cannot redirect standard handles for debugger: %s."),
844 safe_strerror (errno));
852 go32_ops.to_shortname = "djgpp";
853 go32_ops.to_longname = "djgpp target process";
855 "Program loaded by djgpp, when gdb is used as an external debugger";
856 go32_ops.to_open = go32_open;
857 go32_ops.to_close = go32_close;
858 go32_ops.to_attach = go32_attach;
859 go32_ops.to_detach = go32_detach;
860 go32_ops.to_resume = go32_resume;
861 go32_ops.to_wait = go32_wait;
862 go32_ops.to_fetch_registers = go32_fetch_registers;
863 go32_ops.to_store_registers = go32_store_registers;
864 go32_ops.to_prepare_to_store = go32_prepare_to_store;
865 go32_ops.deprecated_xfer_memory = go32_xfer_memory;
866 go32_ops.to_files_info = go32_files_info;
867 go32_ops.to_insert_breakpoint = memory_insert_breakpoint;
868 go32_ops.to_remove_breakpoint = memory_remove_breakpoint;
869 go32_ops.to_terminal_init = go32_terminal_init;
870 go32_ops.to_terminal_inferior = go32_terminal_inferior;
871 go32_ops.to_terminal_ours_for_output = go32_terminal_ours;
872 go32_ops.to_terminal_ours = go32_terminal_ours;
873 go32_ops.to_terminal_info = go32_terminal_info;
874 go32_ops.to_kill = go32_kill_inferior;
875 go32_ops.to_create_inferior = go32_create_inferior;
876 go32_ops.to_mourn_inferior = go32_mourn_inferior;
877 go32_ops.to_can_run = go32_can_run;
878 go32_ops.to_stop = go32_stop;
879 go32_ops.to_stratum = process_stratum;
880 go32_ops.to_has_all_memory = 1;
881 go32_ops.to_has_memory = 1;
882 go32_ops.to_has_stack = 1;
883 go32_ops.to_has_registers = 1;
884 go32_ops.to_has_execution = 1;
885 go32_ops.to_magic = OPS_MAGIC;
887 /* Initialize child's cwd as empty to be initialized when starting
891 /* Initialize child's command line storage. */
892 if (redir_debug_init (&child_cmd) == -1)
893 internal_error (__FILE__, __LINE__,
894 _("Cannot allocate redirection storage: not enough memory.\n"));
896 /* We are always processing GCC-compiled programs. */
897 processing_gcc_compilation = 2;
899 /* Override the default name of the GDB init file. */
900 strcpy (gdbinit, "gdb.ini");
903 unsigned short windows_major, windows_minor;
905 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */
907 go32_get_windows_version(void)
912 __dpmi_int(0x2f, &r);
913 if (r.h.al > 2 && r.h.al != 0x80 && r.h.al != 0xff
914 && (r.h.al > 3 || r.h.ah > 0))
916 windows_major = r.h.al;
917 windows_minor = r.h.ah;
920 windows_major = 0xff; /* meaning no Windows */
923 /* A subroutine of go32_sysinfo to display memory info. */
925 print_mem (unsigned long datum, const char *header, int in_pages_p)
927 if (datum != 0xffffffffUL)
931 puts_filtered (header);
934 printf_filtered ("%lu KB", datum >> 10);
935 if (datum > 1024 * 1024)
936 printf_filtered (" (%lu MB)", datum >> 20);
939 printf_filtered ("%lu Bytes", datum);
940 puts_filtered ("\n");
944 /* Display assorted information about the underlying OS. */
946 go32_sysinfo (char *arg, int from_tty)
949 char cpuid_vendor[13];
950 unsigned cpuid_max = 0, cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx;
951 unsigned true_dos_version = _get_dos_version (1);
952 unsigned advertized_dos_version = ((unsigned int)_osmajor << 8) | _osminor;
954 char dpmi_vendor_info[129];
955 int dpmi_vendor_available =
956 __dpmi_get_capabilities (&dpmi_flags, dpmi_vendor_info);
957 __dpmi_version_ret dpmi_version_data;
959 __dpmi_free_mem_info mem_info;
962 cpuid_vendor[0] = '\0';
964 strcpy (u.machine, "Unknown x86");
965 else if (u.machine[0] == 'i' && u.machine[1] > 4)
967 /* CPUID with EAX = 0 returns the Vendor ID. */
968 __asm__ __volatile__ ("xorl %%ebx, %%ebx;"
977 : "=m" (cpuid_vendor[0]),
978 "=m" (cpuid_vendor[4]),
979 "=m" (cpuid_vendor[8]),
982 : "%eax", "%ebx", "%ecx", "%edx");
983 cpuid_vendor[12] = '\0';
986 printf_filtered ("CPU Type.......................%s", u.machine);
988 printf_filtered (" (%s)", cpuid_vendor);
989 puts_filtered ("\n");
991 /* CPUID with EAX = 1 returns processor signature and features. */
994 static char *brand_name[] = {
1002 char cpu_string[80];
1005 int intel_p = strcmp (cpuid_vendor, "GenuineIntel") == 0;
1006 int amd_p = strcmp (cpuid_vendor, "AuthenticAMD") == 0;
1007 unsigned cpu_family, cpu_model;
1009 __asm__ __volatile__ ("movl $1, %%eax;"
1016 brand_idx = cpuid_ebx & 0xff;
1017 cpu_family = (cpuid_eax >> 8) & 0xf;
1018 cpu_model = (cpuid_eax >> 4) & 0xf;
1019 cpu_brand[0] = '\0';
1023 && brand_idx < sizeof(brand_name)/sizeof(brand_name[0])
1024 && *brand_name[brand_idx])
1025 strcpy (cpu_brand, brand_name[brand_idx]);
1026 else if (cpu_family == 5)
1028 if (((cpuid_eax >> 12) & 3) == 0 && cpu_model == 4)
1029 strcpy (cpu_brand, " MMX");
1030 else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 1)
1031 strcpy (cpu_brand, " OverDrive");
1032 else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 2)
1033 strcpy (cpu_brand, " Dual");
1035 else if (cpu_family == 6 && cpu_model < 8)
1040 strcpy (cpu_brand, " Pro");
1043 strcpy (cpu_brand, " II");
1046 strcpy (cpu_brand, " II Xeon");
1049 strcpy (cpu_brand, " Celeron");
1052 strcpy (cpu_brand, " III");
1062 strcpy (cpu_brand, "486/5x86");
1071 strcpy (cpu_brand, "-K5");
1075 strcpy (cpu_brand, "-K6");
1078 strcpy (cpu_brand, "-K6-2");
1081 strcpy (cpu_brand, "-K6-III");
1091 strcpy (cpu_brand, " Athlon");
1094 strcpy (cpu_brand, " Duron");
1100 sprintf (cpu_string, "%s%s Model %d Stepping %d",
1101 intel_p ? "Pentium" : (amd_p ? "AMD" : "ix86"),
1102 cpu_brand, cpu_model, cpuid_eax & 0xf);
1103 printfi_filtered (31, "%s\n", cpu_string);
1104 if (((cpuid_edx & (6 | (0x0d << 23))) != 0)
1105 || ((cpuid_edx & 1) == 0)
1106 || (amd_p && (cpuid_edx & (3 << 30)) != 0))
1108 puts_filtered ("CPU Features...................");
1109 /* We only list features which might be useful in the DPMI
1111 if ((cpuid_edx & 1) == 0)
1112 puts_filtered ("No FPU "); /* it's unusual to not have an FPU */
1113 if ((cpuid_edx & (1 << 1)) != 0)
1114 puts_filtered ("VME ");
1115 if ((cpuid_edx & (1 << 2)) != 0)
1116 puts_filtered ("DE ");
1117 if ((cpuid_edx & (1 << 4)) != 0)
1118 puts_filtered ("TSC ");
1119 if ((cpuid_edx & (1 << 23)) != 0)
1120 puts_filtered ("MMX ");
1121 if ((cpuid_edx & (1 << 25)) != 0)
1122 puts_filtered ("SSE ");
1123 if ((cpuid_edx & (1 << 26)) != 0)
1124 puts_filtered ("SSE2 ");
1127 if ((cpuid_edx & (1 << 31)) != 0)
1128 puts_filtered ("3DNow! ");
1129 if ((cpuid_edx & (1 << 30)) != 0)
1130 puts_filtered ("3DNow!Ext");
1132 puts_filtered ("\n");
1135 puts_filtered ("\n");
1136 printf_filtered ("DOS Version....................%s %s.%s",
1137 _os_flavor, u.release, u.version);
1138 if (true_dos_version != advertized_dos_version)
1139 printf_filtered (" (disguised as v%d.%d)", _osmajor, _osminor);
1140 puts_filtered ("\n");
1142 go32_get_windows_version ();
1143 if (windows_major != 0xff)
1145 const char *windows_flavor;
1147 printf_filtered ("Windows Version................%d.%02d (Windows ",
1148 windows_major, windows_minor);
1149 switch (windows_major)
1152 windows_flavor = "3.X";
1155 switch (windows_minor)
1158 windows_flavor = "95, 95A, or 95B";
1161 windows_flavor = "95B OSR2.1 or 95C OSR2.5";
1164 windows_flavor = "98 or 98 SE";
1167 windows_flavor = "ME";
1170 windows_flavor = "9X";
1175 windows_flavor = "??";
1178 printf_filtered ("%s)\n", windows_flavor);
1180 else if (true_dos_version == 0x532 && advertized_dos_version == 0x500)
1181 printf_filtered ("Windows Version................Windows NT or Windows 2000\n");
1182 puts_filtered ("\n");
1183 if (dpmi_vendor_available == 0)
1185 /* The DPMI spec says the vendor string should be ASCIIZ, but
1186 I don't trust the vendors to follow that... */
1187 if (!memchr (&dpmi_vendor_info[2], 0, 126))
1188 dpmi_vendor_info[128] = '\0';
1189 printf_filtered ("DPMI Host......................%s v%d.%d (capabilities: %#x)\n",
1190 &dpmi_vendor_info[2],
1191 (unsigned)dpmi_vendor_info[0],
1192 (unsigned)dpmi_vendor_info[1],
1193 ((unsigned)dpmi_flags & 0x7f));
1195 __dpmi_get_version (&dpmi_version_data);
1196 printf_filtered ("DPMI Version...................%d.%02d\n",
1197 dpmi_version_data.major, dpmi_version_data.minor);
1198 printf_filtered ("DPMI Info......................%s-bit DPMI, with%s Virtual Memory support\n",
1199 (dpmi_version_data.flags & 1) ? "32" : "16",
1200 (dpmi_version_data.flags & 4) ? "" : "out");
1201 printfi_filtered (31, "Interrupts reflected to %s mode\n",
1202 (dpmi_version_data.flags & 2) ? "V86" : "Real");
1203 printfi_filtered (31, "Processor type: i%d86\n",
1204 dpmi_version_data.cpu);
1205 printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
1206 dpmi_version_data.master_pic, dpmi_version_data.slave_pic);
1208 /* a_tss is only initialized when the debuggee is first run. */
1209 if (prog_has_started)
1211 __asm__ __volatile__ ("pushfl ; popl %0" : "=g" (eflags));
1212 printf_filtered ("Protection.....................Ring %d (in %s), with%s I/O protection\n",
1213 a_tss.tss_cs & 3, (a_tss.tss_cs & 4) ? "LDT" : "GDT",
1214 (a_tss.tss_cs & 3) > ((eflags >> 12) & 3) ? "" : "out");
1216 puts_filtered ("\n");
1217 __dpmi_get_free_memory_information (&mem_info);
1218 print_mem (mem_info.total_number_of_physical_pages,
1219 "DPMI Total Physical Memory.....", 1);
1220 print_mem (mem_info.total_number_of_free_pages,
1221 "DPMI Free Physical Memory......", 1);
1222 print_mem (mem_info.size_of_paging_file_partition_in_pages,
1223 "DPMI Swap Space................", 1);
1224 print_mem (mem_info.linear_address_space_size_in_pages,
1225 "DPMI Total Linear Address Size.", 1);
1226 print_mem (mem_info.free_linear_address_space_in_pages,
1227 "DPMI Free Linear Address Size..", 1);
1228 print_mem (mem_info.largest_available_free_block_in_bytes,
1229 "DPMI Largest Free Memory Block.", 0);
1233 __dpmi_int (0x21, ®s);
1234 print_mem (regs.x.bx << 4, "Free DOS Memory................", 0);
1236 __dpmi_int (0x21, ®s);
1237 if ((regs.x.flags & 1) == 0)
1239 static const char *dos_hilo[] = {
1240 "Low", "", "", "", "High", "", "", "", "High, then Low"
1242 static const char *dos_fit[] = {
1243 "First", "Best", "Last"
1245 int hilo_idx = (regs.x.ax >> 4) & 0x0f;
1246 int fit_idx = regs.x.ax & 0x0f;
1252 printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1253 dos_hilo[hilo_idx], dos_fit[fit_idx]);
1255 __dpmi_int (0x21, ®s);
1256 if ((regs.x.flags & 1) != 0)
1258 printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1259 regs.h.al == 0 ? "not " : "");
1264 unsigned short limit0 __attribute__((packed));
1265 unsigned short base0 __attribute__((packed));
1266 unsigned char base1 __attribute__((packed));
1267 unsigned stype:5 __attribute__((packed));
1268 unsigned dpl:2 __attribute__((packed));
1269 unsigned present:1 __attribute__((packed));
1270 unsigned limit1:4 __attribute__((packed));
1271 unsigned available:1 __attribute__((packed));
1272 unsigned dummy:1 __attribute__((packed));
1273 unsigned bit32:1 __attribute__((packed));
1274 unsigned page_granular:1 __attribute__((packed));
1275 unsigned char base2 __attribute__((packed));
1279 unsigned short offset0 __attribute__((packed));
1280 unsigned short selector __attribute__((packed));
1281 unsigned param_count:5 __attribute__((packed));
1282 unsigned dummy:3 __attribute__((packed));
1283 unsigned stype:5 __attribute__((packed));
1284 unsigned dpl:2 __attribute__((packed));
1285 unsigned present:1 __attribute__((packed));
1286 unsigned short offset1 __attribute__((packed));
1289 /* Read LEN bytes starting at logical address ADDR, and put the result
1290 into DEST. Return 1 if success, zero if not. */
1292 read_memory_region (unsigned long addr, void *dest, size_t len)
1294 unsigned long dos_ds_limit = __dpmi_get_segment_limit (_dos_ds);
1297 /* For the low memory, we can simply use _dos_ds. */
1298 if (addr <= dos_ds_limit - len)
1299 dosmemget (addr, len, dest);
1302 /* For memory above 1MB we need to set up a special segment to
1303 be able to access that memory. */
1304 int sel = __dpmi_allocate_ldt_descriptors (1);
1310 int access_rights = __dpmi_get_descriptor_access_rights (sel);
1311 size_t segment_limit = len - 1;
1313 /* Make sure the crucial bits in the descriptor access
1314 rights are set correctly. Some DPMI providers might barf
1315 if we set the segment limit to something that is not an
1316 integral multiple of 4KB pages if the granularity bit is
1317 not set to byte-granular, even though the DPMI spec says
1318 it's the host's responsibility to set that bit correctly. */
1319 if (len > 1024 * 1024)
1321 access_rights |= 0x8000;
1322 /* Page-granular segments should have the low 12 bits of
1324 segment_limit |= 0xfff;
1327 access_rights &= ~0x8000;
1329 if (__dpmi_set_segment_base_address (sel, addr) != -1
1330 && __dpmi_set_descriptor_access_rights (sel, access_rights) != -1
1331 && __dpmi_set_segment_limit (sel, segment_limit) != -1
1332 /* W2K silently fails to set the segment limit, leaving
1333 it at zero; this test avoids the resulting crash. */
1334 && __dpmi_get_segment_limit (sel) >= segment_limit)
1335 movedata (sel, 0, _my_ds (), (unsigned)dest, len);
1339 __dpmi_free_ldt_descriptor (sel);
1345 /* Get a segment descriptor stored at index IDX in the descriptor
1346 table whose base address is TABLE_BASE. Return the descriptor
1347 type, or -1 if failure. */
1349 get_descriptor (unsigned long table_base, int idx, void *descr)
1351 unsigned long addr = table_base + idx * 8; /* 8 bytes per entry */
1353 if (read_memory_region (addr, descr, 8))
1354 return (int)((struct seg_descr *)descr)->stype;
1359 unsigned short limit __attribute__((packed));
1360 unsigned long base __attribute__((packed));
1363 /* Display a segment descriptor stored at index IDX in a descriptor
1364 table whose type is TYPE and whose base address is BASE_ADDR. If
1365 FORCE is non-zero, display even invalid descriptors. */
1367 display_descriptor (unsigned type, unsigned long base_addr, int idx, int force)
1369 struct seg_descr descr;
1370 struct gate_descr gate;
1372 /* Get the descriptor from the table. */
1373 if (idx == 0 && type == 0)
1374 puts_filtered ("0x000: null descriptor\n");
1375 else if (get_descriptor (base_addr, idx, &descr) != -1)
1377 /* For each type of descriptor table, this has a bit set if the
1378 corresponding type of selectors is valid in that table. */
1379 static unsigned allowed_descriptors[] = {
1380 0xffffdafeL, /* GDT */
1381 0x0000c0e0L, /* IDT */
1382 0xffffdafaL /* LDT */
1385 /* If the program hasn't started yet, assume the debuggee will
1386 have the same CPL as the debugger. */
1387 int cpl = prog_has_started ? (a_tss.tss_cs & 3) : _my_cs () & 3;
1388 unsigned long limit = (descr.limit1 << 16) | descr.limit0;
1391 && (allowed_descriptors[type] & (1 << descr.stype)) != 0)
1393 printf_filtered ("0x%03x: ",
1395 ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1396 if (descr.page_granular)
1397 limit = (limit << 12) | 0xfff; /* big segment: low 12 bit set */
1398 if (descr.stype == 1 || descr.stype == 2 || descr.stype == 3
1399 || descr.stype == 9 || descr.stype == 11
1400 || (descr.stype >= 16 && descr.stype < 32))
1401 printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1402 descr.base2, descr.base1, descr.base0, limit);
1404 switch (descr.stype)
1408 printf_filtered (" 16-bit TSS (task %sactive)",
1409 descr.stype == 3 ? "" : "in");
1412 puts_filtered (" LDT");
1415 memcpy (&gate, &descr, sizeof gate);
1416 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1417 gate.selector, gate.offset1, gate.offset0);
1418 printf_filtered (" 16-bit Call Gate (params=%d)",
1422 printf_filtered ("TSS selector=0x%04x", descr.base0);
1423 printfi_filtered (16, "Task Gate");
1427 memcpy (&gate, &descr, sizeof gate);
1428 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1429 gate.selector, gate.offset1, gate.offset0);
1430 printf_filtered (" 16-bit %s Gate",
1431 descr.stype == 6 ? "Interrupt" : "Trap");
1435 printf_filtered (" 32-bit TSS (task %sactive)",
1436 descr.stype == 3 ? "" : "in");
1439 memcpy (&gate, &descr, sizeof gate);
1440 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1441 gate.selector, gate.offset1, gate.offset0);
1442 printf_filtered (" 32-bit Call Gate (params=%d)",
1447 memcpy (&gate, &descr, sizeof gate);
1448 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1449 gate.selector, gate.offset1, gate.offset0);
1450 printf_filtered (" 32-bit %s Gate",
1451 descr.stype == 14 ? "Interrupt" : "Trap");
1453 case 16: /* data segments */
1461 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1462 descr.bit32 ? "32" : "16",
1463 descr.stype & 2 ? "Read/Write," : "Read-Only, ",
1464 descr.stype & 4 ? "down" : "up",
1465 descr.stype & 1 ? "" : ", N.Acc");
1467 case 24: /* code segments */
1475 printf_filtered (" %s-bit Code (%s, %sConf%s)",
1476 descr.bit32 ? "32" : "16",
1477 descr.stype & 2 ? "Exec/Read" : "Exec-Only",
1478 descr.stype & 4 ? "" : "N.",
1479 descr.stype & 1 ? "" : ", N.Acc");
1482 printf_filtered ("Unknown type 0x%02x", descr.stype);
1485 puts_filtered ("\n");
1489 printf_filtered ("0x%03x: ",
1491 ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1493 puts_filtered ("Segment not present\n");
1495 printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1500 printf_filtered ("0x%03x: Cannot read this descriptor\n", idx);
1504 go32_sldt (char *arg, int from_tty)
1506 struct dtr_reg gdtr;
1507 unsigned short ldtr = 0;
1509 struct seg_descr ldt_descr;
1510 long ldt_entry = -1L;
1511 int cpl = (prog_has_started ? a_tss.tss_cs : _my_cs ()) & 3;
1515 while (*arg && isspace(*arg))
1520 ldt_entry = parse_and_eval_long (arg);
1522 || (ldt_entry & 4) == 0
1523 || (ldt_entry & 3) != (cpl & 3))
1524 error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry);
1528 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1529 __asm__ __volatile__ ("sldt %0" : "=m" (ldtr) : /* no inputs */ );
1532 puts_filtered ("There is no LDT.\n");
1533 /* LDT's entry in the GDT must have the type LDT, which is 2. */
1534 else if (get_descriptor (gdtr.base, ldt_idx, &ldt_descr) != 2)
1535 printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1537 | (ldt_descr.base1 << 16)
1538 | (ldt_descr.base2 << 24));
1543 | (ldt_descr.base1 << 16)
1544 | (ldt_descr.base2 << 24);
1545 unsigned limit = ldt_descr.limit0 | (ldt_descr.limit1 << 16);
1548 if (ldt_descr.page_granular)
1549 /* Page-granular segments must have the low 12 bits of their
1551 limit = (limit << 12) | 0xfff;
1552 /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1557 max_entry = (limit + 1) / 8;
1561 if (ldt_entry > limit)
1562 error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1563 (unsigned long)ldt_entry, limit);
1565 display_descriptor (ldt_descr.stype, base, ldt_entry / 8, 1);
1571 for (i = 0; i < max_entry; i++)
1572 display_descriptor (ldt_descr.stype, base, i, 0);
1578 go32_sgdt (char *arg, int from_tty)
1580 struct dtr_reg gdtr;
1581 long gdt_entry = -1L;
1586 while (*arg && isspace(*arg))
1591 gdt_entry = parse_and_eval_long (arg);
1592 if (gdt_entry < 0 || (gdt_entry & 7) != 0)
1593 error (_("Invalid GDT entry 0x%03lx: not an integral multiple of 8."),
1594 (unsigned long)gdt_entry);
1598 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1599 max_entry = (gdtr.limit + 1) / 8;
1603 if (gdt_entry > gdtr.limit)
1604 error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1605 (unsigned long)gdt_entry, gdtr.limit);
1607 display_descriptor (0, gdtr.base, gdt_entry / 8, 1);
1613 for (i = 0; i < max_entry; i++)
1614 display_descriptor (0, gdtr.base, i, 0);
1619 go32_sidt (char *arg, int from_tty)
1621 struct dtr_reg idtr;
1622 long idt_entry = -1L;
1627 while (*arg && isspace(*arg))
1632 idt_entry = parse_and_eval_long (arg);
1634 error (_("Invalid (negative) IDT entry %ld."), idt_entry);
1638 __asm__ __volatile__ ("sidt %0" : "=m" (idtr) : /* no inputs */ );
1639 max_entry = (idtr.limit + 1) / 8;
1640 if (max_entry > 0x100) /* no more than 256 entries */
1645 if (idt_entry > idtr.limit)
1646 error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1647 (unsigned long)idt_entry, idtr.limit);
1649 display_descriptor (1, idtr.base, idt_entry, 1);
1655 for (i = 0; i < max_entry; i++)
1656 display_descriptor (1, idtr.base, i, 0);
1660 /* Cached linear address of the base of the page directory. For
1661 now, available only under CWSDPMI. Code based on ideas and
1662 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
1663 static unsigned long pdbr;
1665 static unsigned long
1670 unsigned long taskbase, cr3;
1671 struct dtr_reg gdtr;
1673 if (pdbr > 0 && pdbr <= 0xfffff)
1676 /* Get the linear address of GDT and the Task Register. */
1677 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1678 __asm__ __volatile__ ("str %0" : "=m" (taskreg) : /* no inputs */ );
1680 /* Task Register is a segment selector for the TSS of the current
1681 task. Therefore, it can be used as an index into the GDT to get
1682 at the segment descriptor for the TSS. To get the index, reset
1683 the low 3 bits of the selector (which give the CPL). Add 2 to the
1684 offset to point to the 3 low bytes of the base address. */
1685 offset = gdtr.base + (taskreg & 0xfff8) + 2;
1688 /* CWSDPMI's task base is always under the 1MB mark. */
1689 if (offset > 0xfffff)
1692 _farsetsel (_dos_ds);
1693 taskbase = _farnspeekl (offset) & 0xffffffU;
1694 taskbase += _farnspeekl (offset + 2) & 0xff000000U;
1695 if (taskbase > 0xfffff)
1698 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1699 offset 1Ch in the TSS. */
1700 cr3 = _farnspeekl (taskbase + 0x1c) & ~0xfff;
1703 #if 0 /* not fullly supported yet */
1704 /* The Page Directory is in UMBs. In that case, CWSDPMI puts
1705 the first Page Table right below the Page Directory. Thus,
1706 the first Page Table's entry for its own address and the Page
1707 Directory entry for that Page Table will hold the same
1708 physical address. The loop below searches the entire UMB
1709 range of addresses for such an occurence. */
1710 unsigned long addr, pte_idx;
1712 for (addr = 0xb0000, pte_idx = 0xb0;
1714 addr += 0x1000, pte_idx++)
1716 if (((_farnspeekl (addr + 4 * pte_idx) & 0xfffff027) ==
1717 (_farnspeekl (addr + 0x1000) & 0xfffff027))
1718 && ((_farnspeekl (addr + 4 * pte_idx + 4) & 0xfffff000) == cr3))
1720 cr3 = addr + 0x1000;
1733 /* Return the N'th Page Directory entry. */
1734 static unsigned long
1737 unsigned long pde = 0;
1739 if (pdbr && n >= 0 && n < 1024)
1741 pde = _farpeekl (_dos_ds, pdbr + 4*n);
1746 /* Return the N'th entry of the Page Table whose Page Directory entry
1748 static unsigned long
1749 get_pte (unsigned long pde, int n)
1751 unsigned long pte = 0;
1753 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
1754 page tables, for now. */
1755 if ((pde & 1) && !(pde & 0x80) && n >= 0 && n < 1024)
1757 pde &= ~0xfff; /* clear non-address bits */
1758 pte = _farpeekl (_dos_ds, pde + 4*n);
1763 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
1764 says this is a Page Directory entry. If FORCE is non-zero, display
1765 the entry even if its Present flag is off. OFF is the offset of the
1766 address from the page's base address. */
1768 display_ptable_entry (unsigned long entry, int is_dir, int force, unsigned off)
1770 if ((entry & 1) != 0)
1772 printf_filtered ("Base=0x%05lx000", entry >> 12);
1773 if ((entry & 0x100) && !is_dir)
1774 puts_filtered (" Global");
1775 if ((entry & 0x40) && !is_dir)
1776 puts_filtered (" Dirty");
1777 printf_filtered (" %sAcc.", (entry & 0x20) ? "" : "Not-");
1778 printf_filtered (" %sCached", (entry & 0x10) ? "" : "Not-");
1779 printf_filtered (" Write-%s", (entry & 8) ? "Thru" : "Back");
1780 printf_filtered (" %s", (entry & 4) ? "Usr" : "Sup");
1781 printf_filtered (" Read-%s", (entry & 2) ? "Write" : "Only");
1783 printf_filtered (" +0x%x", off);
1784 puts_filtered ("\n");
1787 printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1788 is_dir ? " Table" : "", entry >> 1);
1792 go32_pde (char *arg, int from_tty)
1794 long pde_idx = -1, i;
1798 while (*arg && isspace(*arg))
1803 pde_idx = parse_and_eval_long (arg);
1804 if (pde_idx < 0 || pde_idx >= 1024)
1805 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
1811 puts_filtered ("Access to Page Directories is not supported on this system.\n");
1812 else if (pde_idx >= 0)
1813 display_ptable_entry (get_pde (pde_idx), 1, 1, 0);
1815 for (i = 0; i < 1024; i++)
1816 display_ptable_entry (get_pde (i), 1, 0, 0);
1819 /* A helper function to display entries in a Page Table pointed to by
1820 the N'th entry in the Page Directory. If FORCE is non-zero, say
1821 something even if the Page Table is not accessible. */
1823 display_page_table (long n, int force)
1825 unsigned long pde = get_pde (n);
1831 printf_filtered ("Page Table pointed to by Page Directory entry 0x%lx:\n", n);
1832 for (i = 0; i < 1024; i++)
1833 display_ptable_entry (get_pte (pde, i), 0, 0, 0);
1834 puts_filtered ("\n");
1837 printf_filtered ("Page Table not present; value=0x%lx.\n", pde >> 1);
1841 go32_pte (char *arg, int from_tty)
1843 long pde_idx = -1L, i;
1847 while (*arg && isspace(*arg))
1852 pde_idx = parse_and_eval_long (arg);
1853 if (pde_idx < 0 || pde_idx >= 1024)
1854 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
1860 puts_filtered ("Access to Page Tables is not supported on this system.\n");
1861 else if (pde_idx >= 0)
1862 display_page_table (pde_idx, 1);
1864 for (i = 0; i < 1024; i++)
1865 display_page_table (i, 0);
1869 go32_pte_for_address (char *arg, int from_tty)
1871 CORE_ADDR addr = 0, i;
1875 while (*arg && isspace(*arg))
1879 addr = parse_and_eval_address (arg);
1882 error_no_arg (_("linear address"));
1886 puts_filtered ("Access to Page Tables is not supported on this system.\n");
1889 int pde_idx = (addr >> 22) & 0x3ff;
1890 int pte_idx = (addr >> 12) & 0x3ff;
1891 unsigned offs = addr & 0xfff;
1893 printf_filtered ("Page Table entry for address 0x%llx:\n",
1894 (unsigned long long)addr);
1895 display_ptable_entry (get_pte (get_pde (pde_idx), pte_idx), 0, 1, offs);
1899 static struct cmd_list_element *info_dos_cmdlist = NULL;
1902 go32_info_dos_command (char *args, int from_tty)
1904 help_list (info_dos_cmdlist, "info dos ", class_info, gdb_stdout);
1908 _initialize_go32_nat (void)
1911 add_target (&go32_ops);
1913 add_prefix_cmd ("dos", class_info, go32_info_dos_command, _("\
1914 Print information specific to DJGPP (aka MS-DOS) debugging."),
1915 &info_dos_cmdlist, "info dos ", 0, &infolist);
1917 add_cmd ("sysinfo", class_info, go32_sysinfo, _("\
1918 Display information about the target system, including CPU, OS, DPMI, etc."),
1920 add_cmd ("ldt", class_info, go32_sldt, _("\
1921 Display entries in the LDT (Local Descriptor Table).\n\
1922 Entry number (an expression) as an argument means display only that entry."),
1924 add_cmd ("gdt", class_info, go32_sgdt, _("\
1925 Display entries in the GDT (Global Descriptor Table).\n\
1926 Entry number (an expression) as an argument means display only that entry."),
1928 add_cmd ("idt", class_info, go32_sidt, _("\
1929 Display entries in the IDT (Interrupt Descriptor Table).\n\
1930 Entry number (an expression) as an argument means display only that entry."),
1932 add_cmd ("pde", class_info, go32_pde, _("\
1933 Display entries in the Page Directory.\n\
1934 Entry number (an expression) as an argument means display only that entry."),
1936 add_cmd ("pte", class_info, go32_pte, _("\
1937 Display entries in Page Tables.\n\
1938 Entry number (an expression) as an argument means display only entries\n\
1939 from the Page Table pointed to by the specified Page Directory entry."),
1941 add_cmd ("address-pte", class_info, go32_pte_for_address, _("\
1942 Display a Page Table entry for a linear address.\n\
1943 The address argument must be a linear address, after adding to\n\
1944 it the base address of the appropriate segment.\n\
1945 The base address of variables and functions in the debuggee's data\n\
1946 or code segment is stored in the variable __djgpp_base_address,\n\
1947 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
1948 For other segments, look up their base address in the output of\n\
1949 the `info dos ldt' command."),
1963 tcsetpgrp (int fd, pid_t pgid)
1965 if (isatty (fd) && pgid == SOME_PID)
1967 errno = pgid == SOME_PID ? ENOTTY : ENOSYS;