1 /* Native debugging support for Intel x86 running DJGPP.
2 Copyright 1997, 1999, 2000, 2001 Free Software Foundation, Inc.
3 Written by Robert Hoehne.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
30 #include "floatformat.h"
35 #include "gdb_string.h"
37 #include <stdio.h> /* might be required for __DJGPP_MINOR__ */
42 #include <sys/utsname.h>
47 #include <sys/farptr.h>
48 #include <debug/v2load.h>
49 #include <debug/dbgcom.h>
50 #if __DJGPP_MINOR__ > 2
51 #include <debug/redir.h>
54 #if __DJGPP_MINOR__ < 3
55 /* This code will be provided from DJGPP 2.03 on. Until then I code it
63 unsigned short exponent:15;
64 unsigned short sign:1;
83 static void save_npx (void); /* Save the FPU of the debugged program */
84 static void load_npx (void); /* Restore the FPU of the debugged program */
86 /* ------------------------------------------------------------------------- */
87 /* Store the contents of the NPX in the global variable `npx'. */
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 (int regno);
178 static void store_register (int regno);
179 static void go32_store_registers (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);
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 (int regno)
470 if (regno < FP0_REGNUM)
471 supply_register (regno, (char *) &a_tss + regno_mapping[regno].tss_ofs);
472 else if (regno <= LAST_FPU_CTRL_REGNUM)
473 i387_supply_register (regno, (char *) &npx);
475 internal_error (__FILE__, __LINE__,
476 "Invalid register no. %d in fetch_register.", regno);
480 go32_fetch_registers (int regno)
483 fetch_register (regno);
486 for (regno = 0; regno < FP0_REGNUM; regno++)
487 fetch_register (regno);
488 i387_supply_fsave ((char *) &npx);
493 store_register (int regno)
496 void *v = alloca (MAX_REGISTER_RAW_SIZE);
497 regcache_collect (regno, v);
499 if (regno < FP0_REGNUM)
500 memcpy ((char *) &a_tss + regno_mapping[regno].tss_ofs,
501 v, regno_mapping[regno].size);
502 else if (regno <= LAST_FPU_CTRL_REGNUM)
503 i387_fill_fsave ((char *)&npx, regno);
505 internal_error (__FILE__, __LINE__,
506 "Invalid register no. %d in store_register.", regno);
510 go32_store_registers (int regno)
515 store_register (regno);
518 for (r = 0; r < FP0_REGNUM; r++)
520 i387_fill_fsave ((char *) &npx, -1);
525 go32_prepare_to_store (void)
530 go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
531 struct mem_attrib *attrib, struct target_ops *target)
535 if (write_child (memaddr, myaddr, len))
546 if (read_child (memaddr, myaddr, len))
557 static cmdline_t child_cmd; /* parsed child's command line kept here */
560 go32_files_info (struct target_ops *target)
562 printf_unfiltered ("You are running a DJGPP V2 program.\n");
570 inferior_ptid = null_ptid;
571 prog_has_started = 0;
575 go32_kill_inferior (void)
577 redir_cmdline_delete (&child_cmd);
580 unpush_target (&go32_ops);
584 go32_create_inferior (char *exec_file, char *args, char **env)
586 extern char **environ;
589 char **env_save = environ;
592 /* If no exec file handed to us, get it from the exec-file command -- with
593 a good, common error message if none is specified. */
595 exec_file = get_exec_file (1);
597 if (prog_has_started)
600 go32_kill_inferior ();
605 /* Initialize child's cwd as empty to be initialized when starting
609 /* Init command line storage. */
610 if (redir_debug_init (&child_cmd) == -1)
611 internal_error (__FILE__, __LINE__,
612 "Cannot allocate redirection storage: not enough memory.\n");
614 /* Parse the command line and create redirections. */
615 if (strpbrk (args, "<>"))
617 if (redir_cmdline_parse (args, &child_cmd) == 0)
618 args = child_cmd.command;
620 error ("Syntax error in command line.");
623 child_cmd.command = xstrdup (args);
625 cmdlen = strlen (args);
626 /* v2loadimage passes command lines via DOS memory, so it cannot
627 possibly handle commands longer than 1MB. */
628 if (cmdlen > 1024*1024)
629 error ("Command line too long.");
631 cmdline = xmalloc (cmdlen + 4);
632 strcpy (cmdline + 1, args);
633 /* If the command-line length fits into DOS 126-char limits, use the
634 DOS command tail format; otherwise, tell v2loadimage to pass it
635 through a buffer in conventional memory. */
638 cmdline[0] = strlen (args);
639 cmdline[cmdlen + 1] = 13;
642 cmdline[0] = 0xff; /* signal v2loadimage it's a long command */
646 if (v2loadimage (exec_file, cmdline, start_state))
649 printf_unfiltered ("Load failed for image %s\n", exec_file);
655 edi_init (start_state);
656 #if __DJGPP_MINOR__ < 3
660 inferior_ptid = pid_to_ptid (SOME_PID);
661 push_target (&go32_ops);
662 clear_proceed_status ();
663 insert_breakpoints ();
664 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
665 prog_has_started = 1;
669 go32_mourn_inferior (void)
671 /* We need to make sure all the breakpoint enable bits in the DR7
672 register are reset when the inferior exits. Otherwise, if they
673 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
674 failure to set more watchpoints, and other calamities. It would
675 be nice if GDB itself would take care to remove all breakpoints
676 at all times, but it doesn't, probably under an assumption that
677 the OS cleans up when the debuggee exits. */
678 i386_cleanup_dregs ();
679 go32_kill_inferior ();
680 generic_mourn_inferior ();
689 /* Hardware watchpoint support. */
691 #define D_REGS edi.dr
692 #define CONTROL D_REGS[7]
693 #define STATUS D_REGS[6]
695 /* Pass the address ADDR to the inferior in the I'th debug register.
696 Here we just store the address in D_REGS, the watchpoint will be
697 actually set up when go32_wait runs the debuggee. */
699 go32_set_dr (int i, CORE_ADDR addr)
702 internal_error (__FILE__, __LINE__,
703 "Invalid register %d in go32_set_dr.\n", i);
707 /* Pass the value VAL to the inferior in the DR7 debug control
708 register. Here we just store the address in D_REGS, the watchpoint
709 will be actually set up when go32_wait runs the debuggee. */
711 go32_set_dr7 (unsigned val)
716 /* Get the value of the DR6 debug status register from the inferior.
717 Here we just return the value stored in D_REGS, as we've got it
718 from the last go32_wait call. */
725 /* Put the device open on handle FD into either raw or cooked
726 mode, return 1 if it was in raw mode, zero otherwise. */
729 device_mode (int fd, int raw_p)
731 int oldmode, newmode;
736 __dpmi_int (0x21, ®s);
737 if (regs.x.flags & 1)
739 newmode = oldmode = regs.x.dx;
746 if (oldmode & 0x80) /* Only for character dev */
750 regs.x.dx = newmode & 0xff; /* Force upper byte zero, else it fails */
751 __dpmi_int (0x21, ®s);
752 if (regs.x.flags & 1)
755 return (oldmode & 0x20) == 0x20;
759 static int inf_mode_valid = 0;
760 static int inf_terminal_mode;
762 /* This semaphore is needed because, amazingly enough, GDB calls
763 target.to_terminal_ours more than once after the inferior stops.
764 But we need the information from the first call only, since the
765 second call will always see GDB's own cooked terminal. */
766 static int terminal_is_ours = 1;
769 go32_terminal_init (void)
771 inf_mode_valid = 0; /* reinitialize, in case they are restarting child */
772 terminal_is_ours = 1;
776 go32_terminal_info (char *args, int from_tty)
778 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
780 ? "default" : inf_terminal_mode ? "raw" : "cooked");
782 #if __DJGPP_MINOR__ > 2
783 if (child_cmd.redirection)
787 for (i = 0; i < DBG_HANDLES; i++)
789 if (child_cmd.redirection[i]->file_name)
790 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
791 i, child_cmd.redirection[i]->file_name);
792 else if (_get_dev_info (child_cmd.redirection[i]->inf_handle) == -1)
794 ("\tFile handle %d appears to be closed by inferior.\n", i);
795 /* Mask off the raw/cooked bit when comparing device info words. */
796 else if ((_get_dev_info (child_cmd.redirection[i]->inf_handle) & 0xdf)
797 != (_get_dev_info (i) & 0xdf))
799 ("\tFile handle %d appears to be redirected by inferior.\n", i);
806 go32_terminal_inferior (void)
808 /* Redirect standard handles as child wants them. */
810 if (redir_to_child (&child_cmd) == -1)
812 redir_to_debugger (&child_cmd);
813 error ("Cannot redirect standard handles for program: %s.",
816 /* set the console device of the inferior to whatever mode
817 (raw or cooked) we found it last time */
818 if (terminal_is_ours)
821 device_mode (0, inf_terminal_mode);
822 terminal_is_ours = 0;
827 go32_terminal_ours (void)
829 /* Switch to cooked mode on the gdb terminal and save the inferior
830 terminal mode to be restored when it is resumed */
831 if (!terminal_is_ours)
833 inf_terminal_mode = device_mode (0, 0);
834 if (inf_terminal_mode != -1)
837 /* If device_mode returned -1, we don't know what happens with
838 handle 0 anymore, so make the info invalid. */
840 terminal_is_ours = 1;
842 /* Restore debugger's standard handles. */
844 if (redir_to_debugger (&child_cmd) == -1)
846 redir_to_child (&child_cmd);
847 error ("Cannot redirect standard handles for debugger: %s.",
856 go32_ops.to_shortname = "djgpp";
857 go32_ops.to_longname = "djgpp target process";
859 "Program loaded by djgpp, when gdb is used as an external debugger";
860 go32_ops.to_open = go32_open;
861 go32_ops.to_close = go32_close;
862 go32_ops.to_attach = go32_attach;
863 go32_ops.to_detach = go32_detach;
864 go32_ops.to_resume = go32_resume;
865 go32_ops.to_wait = go32_wait;
866 go32_ops.to_fetch_registers = go32_fetch_registers;
867 go32_ops.to_store_registers = go32_store_registers;
868 go32_ops.to_prepare_to_store = go32_prepare_to_store;
869 go32_ops.to_xfer_memory = go32_xfer_memory;
870 go32_ops.to_files_info = go32_files_info;
871 go32_ops.to_insert_breakpoint = memory_insert_breakpoint;
872 go32_ops.to_remove_breakpoint = memory_remove_breakpoint;
873 go32_ops.to_terminal_init = go32_terminal_init;
874 go32_ops.to_terminal_inferior = go32_terminal_inferior;
875 go32_ops.to_terminal_ours_for_output = go32_terminal_ours;
876 go32_ops.to_terminal_ours = go32_terminal_ours;
877 go32_ops.to_terminal_info = go32_terminal_info;
878 go32_ops.to_kill = go32_kill_inferior;
879 go32_ops.to_create_inferior = go32_create_inferior;
880 go32_ops.to_mourn_inferior = go32_mourn_inferior;
881 go32_ops.to_can_run = go32_can_run;
882 go32_ops.to_stop = go32_stop;
883 go32_ops.to_stratum = process_stratum;
884 go32_ops.to_has_all_memory = 1;
885 go32_ops.to_has_memory = 1;
886 go32_ops.to_has_stack = 1;
887 go32_ops.to_has_registers = 1;
888 go32_ops.to_has_execution = 1;
889 go32_ops.to_magic = OPS_MAGIC;
891 /* Initialize child's cwd as empty to be initialized when starting
895 /* Initialize child's command line storage. */
896 if (redir_debug_init (&child_cmd) == -1)
897 internal_error (__FILE__, __LINE__,
898 "Cannot allocate redirection storage: not enough memory.\n");
900 /* We are always processing GCC-compiled programs. */
901 processing_gcc_compilation = 2;
904 unsigned short windows_major, windows_minor;
906 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */
908 go32_get_windows_version(void)
913 __dpmi_int(0x2f, &r);
914 if (r.h.al > 2 && r.h.al != 0x80 && r.h.al != 0xff
915 && (r.h.al > 3 || r.h.ah > 0))
917 windows_major = r.h.al;
918 windows_minor = r.h.ah;
921 windows_major = 0xff; /* meaning no Windows */
924 /* A subroutine of go32_sysinfo to display memory info. */
926 print_mem (unsigned long datum, const char *header, int in_pages_p)
928 if (datum != 0xffffffffUL)
932 puts_filtered (header);
935 printf_filtered ("%lu KB", datum >> 10);
936 if (datum > 1024 * 1024)
937 printf_filtered (" (%lu MB)", datum >> 20);
940 printf_filtered ("%lu Bytes", datum);
941 puts_filtered ("\n");
945 /* Display assorted information about the underlying OS. */
947 go32_sysinfo (char *arg, int from_tty)
950 char cpuid_vendor[13];
951 unsigned cpuid_max = 0, cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx;
952 unsigned true_dos_version = _get_dos_version (1);
953 unsigned advertized_dos_version = ((unsigned int)_osmajor << 8) | _osminor;
955 char dpmi_vendor_info[129];
956 int dpmi_vendor_available =
957 __dpmi_get_capabilities (&dpmi_flags, dpmi_vendor_info);
958 __dpmi_version_ret dpmi_version_data;
960 __dpmi_free_mem_info mem_info;
963 cpuid_vendor[0] = '\0';
965 strcpy (u.machine, "Unknown x86");
966 else if (u.machine[0] == 'i' && u.machine[1] > 4)
968 /* CPUID with EAX = 0 returns the Vendor ID. */
969 __asm__ __volatile__ ("xorl %%ebx, %%ebx;"
978 : "=m" (cpuid_vendor[0]),
979 "=m" (cpuid_vendor[4]),
980 "=m" (cpuid_vendor[8]),
983 : "%eax", "%ebx", "%ecx", "%edx");
984 cpuid_vendor[12] = '\0';
987 printf_filtered ("CPU Type.......................%s", u.machine);
989 printf_filtered (" (%s)", cpuid_vendor);
990 puts_filtered ("\n");
992 /* CPUID with EAX = 1 returns processor signature and features. */
995 static char *brand_name[] = {
1003 char cpu_string[80];
1006 int intel_p = strcmp (cpuid_vendor, "GenuineIntel") == 0;
1007 int amd_p = strcmp (cpuid_vendor, "AuthenticAMD") == 0;
1008 unsigned cpu_family, cpu_model;
1010 __asm__ __volatile__ ("movl $1, %%eax;"
1017 brand_idx = cpuid_ebx & 0xff;
1018 cpu_family = (cpuid_eax >> 8) & 0xf;
1019 cpu_model = (cpuid_eax >> 4) & 0xf;
1020 cpu_brand[0] = '\0';
1024 && brand_idx < sizeof(brand_name)/sizeof(brand_name[0])
1025 && *brand_name[brand_idx])
1026 strcpy (cpu_brand, brand_name[brand_idx]);
1027 else if (cpu_family == 5)
1029 if (((cpuid_eax >> 12) & 3) == 0 && cpu_model == 4)
1030 strcpy (cpu_brand, " MMX");
1031 else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 1)
1032 strcpy (cpu_brand, " OverDrive");
1033 else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 2)
1034 strcpy (cpu_brand, " Dual");
1036 else if (cpu_family == 6 && cpu_model < 8)
1041 strcpy (cpu_brand, " Pro");
1044 strcpy (cpu_brand, " II");
1047 strcpy (cpu_brand, " II Xeon");
1050 strcpy (cpu_brand, " Celeron");
1053 strcpy (cpu_brand, " III");
1063 strcpy (cpu_brand, "486/5x86");
1072 strcpy (cpu_brand, "-K5");
1076 strcpy (cpu_brand, "-K6");
1079 strcpy (cpu_brand, "-K6-2");
1082 strcpy (cpu_brand, "-K6-III");
1092 strcpy (cpu_brand, " Athlon");
1095 strcpy (cpu_brand, " Duron");
1101 sprintf (cpu_string, "%s%s Model %d Stepping %d",
1102 intel_p ? "Pentium" : (amd_p ? "AMD" : "ix86"),
1103 cpu_brand, cpu_model, cpuid_eax & 0xf);
1104 printfi_filtered (31, "%s\n", cpu_string);
1105 if (((cpuid_edx & (6 | (0x0d << 23))) != 0)
1106 || ((cpuid_edx & 1) == 0)
1107 || (amd_p && (cpuid_edx & (3 << 30)) != 0))
1109 puts_filtered ("CPU Features...................");
1110 /* We only list features which might be useful in the DPMI
1112 if ((cpuid_edx & 1) == 0)
1113 puts_filtered ("No FPU "); /* it's unusual to not have an FPU */
1114 if ((cpuid_edx & (1 << 1)) != 0)
1115 puts_filtered ("VME ");
1116 if ((cpuid_edx & (1 << 2)) != 0)
1117 puts_filtered ("DE ");
1118 if ((cpuid_edx & (1 << 4)) != 0)
1119 puts_filtered ("TSC ");
1120 if ((cpuid_edx & (1 << 23)) != 0)
1121 puts_filtered ("MMX ");
1122 if ((cpuid_edx & (1 << 25)) != 0)
1123 puts_filtered ("SSE ");
1124 if ((cpuid_edx & (1 << 26)) != 0)
1125 puts_filtered ("SSE2 ");
1128 if ((cpuid_edx & (1 << 31)) != 0)
1129 puts_filtered ("3DNow! ");
1130 if ((cpuid_edx & (1 << 30)) != 0)
1131 puts_filtered ("3DNow!Ext");
1133 puts_filtered ("\n");
1136 puts_filtered ("\n");
1137 printf_filtered ("DOS Version....................%s %s.%s",
1138 _os_flavor, u.release, u.version);
1139 if (true_dos_version != advertized_dos_version)
1140 printf_filtered (" (disguised as v%d.%d)", _osmajor, _osminor);
1141 puts_filtered ("\n");
1143 go32_get_windows_version ();
1144 if (windows_major != 0xff)
1146 const char *windows_flavor;
1148 printf_filtered ("Windows Version................%d.%02d (Windows ",
1149 windows_major, windows_minor);
1150 switch (windows_major)
1153 windows_flavor = "3.X";
1156 switch (windows_minor)
1159 windows_flavor = "95, 95A, or 95B";
1162 windows_flavor = "95B OSR2.1 or 95C OSR2.5";
1165 windows_flavor = "98 or 98 SE";
1168 windows_flavor = "ME";
1171 windows_flavor = "9X";
1176 windows_flavor = "??";
1179 printf_filtered ("%s)\n", windows_flavor);
1181 else if (true_dos_version == 0x532 && advertized_dos_version == 0x500)
1182 printf_filtered ("Windows Version................Windows NT or Windows 2000\n");
1183 puts_filtered ("\n");
1184 if (dpmi_vendor_available == 0)
1186 /* The DPMI spec says the vendor string should be ASCIIZ, but
1187 I don't trust the vendors to follow that... */
1188 if (!memchr (&dpmi_vendor_info[2], 0, 126))
1189 dpmi_vendor_info[128] = '\0';
1190 printf_filtered ("DPMI Host......................%s v%d.%d (capabilities: %#x)\n",
1191 &dpmi_vendor_info[2],
1192 (unsigned)dpmi_vendor_info[0],
1193 (unsigned)dpmi_vendor_info[1],
1194 ((unsigned)dpmi_flags & 0x7f));
1196 __dpmi_get_version (&dpmi_version_data);
1197 printf_filtered ("DPMI Version...................%d.%02d\n",
1198 dpmi_version_data.major, dpmi_version_data.minor);
1199 printf_filtered ("DPMI Info......................%s-bit DPMI, with%s Virtual Memory support\n",
1200 (dpmi_version_data.flags & 1) ? "32" : "16",
1201 (dpmi_version_data.flags & 4) ? "" : "out");
1202 printfi_filtered (31, "Interrupts reflected to %s mode\n",
1203 (dpmi_version_data.flags & 2) ? "V86" : "Real");
1204 printfi_filtered (31, "Processor type: i%d86\n",
1205 dpmi_version_data.cpu);
1206 printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
1207 dpmi_version_data.master_pic, dpmi_version_data.slave_pic);
1209 /* a_tss is only initialized when the debuggee is first run. */
1210 if (prog_has_started)
1212 __asm__ __volatile__ ("pushfl ; popl %0" : "=g" (eflags));
1213 printf_filtered ("Protection.....................Ring %d (in %s), with%s I/O protection\n",
1214 a_tss.tss_cs & 3, (a_tss.tss_cs & 4) ? "LDT" : "GDT",
1215 (a_tss.tss_cs & 3) > ((eflags >> 12) & 3) ? "" : "out");
1217 puts_filtered ("\n");
1218 __dpmi_get_free_memory_information (&mem_info);
1219 print_mem (mem_info.total_number_of_physical_pages,
1220 "DPMI Total Physical Memory.....", 1);
1221 print_mem (mem_info.total_number_of_free_pages,
1222 "DPMI Free Physical Memory......", 1);
1223 print_mem (mem_info.size_of_paging_file_partition_in_pages,
1224 "DPMI Swap Space................", 1);
1225 print_mem (mem_info.linear_address_space_size_in_pages,
1226 "DPMI Total Linear Address Size.", 1);
1227 print_mem (mem_info.free_linear_address_space_in_pages,
1228 "DPMI Free Linear Address Size..", 1);
1229 print_mem (mem_info.largest_available_free_block_in_bytes,
1230 "DPMI Largest Free Memory Block.", 0);
1234 __dpmi_int (0x21, ®s);
1235 print_mem (regs.x.bx << 4, "Free DOS Memory................", 0);
1237 __dpmi_int (0x21, ®s);
1238 if ((regs.x.flags & 1) == 0)
1240 static const char *dos_hilo[] = {
1241 "Low", "", "", "", "High", "", "", "", "High, then Low"
1243 static const char *dos_fit[] = {
1244 "First", "Best", "Last"
1246 int hilo_idx = (regs.x.ax >> 4) & 0x0f;
1247 int fit_idx = regs.x.ax & 0x0f;
1253 printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1254 dos_hilo[hilo_idx], dos_fit[fit_idx]);
1256 __dpmi_int (0x21, ®s);
1257 if ((regs.x.flags & 1) != 0)
1259 printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1260 regs.h.al == 0 ? "not " : "");
1265 unsigned short limit0 __attribute__((packed));
1266 unsigned short base0 __attribute__((packed));
1267 unsigned char base1 __attribute__((packed));
1268 unsigned stype:5 __attribute__((packed));
1269 unsigned dpl:2 __attribute__((packed));
1270 unsigned present:1 __attribute__((packed));
1271 unsigned limit1:4 __attribute__((packed));
1272 unsigned available:1 __attribute__((packed));
1273 unsigned dummy:1 __attribute__((packed));
1274 unsigned bit32:1 __attribute__((packed));
1275 unsigned page_granular:1 __attribute__((packed));
1276 unsigned char base2 __attribute__((packed));
1280 unsigned short offset0 __attribute__((packed));
1281 unsigned short selector __attribute__((packed));
1282 unsigned param_count:5 __attribute__((packed));
1283 unsigned dummy:3 __attribute__((packed));
1284 unsigned stype:5 __attribute__((packed));
1285 unsigned dpl:2 __attribute__((packed));
1286 unsigned present:1 __attribute__((packed));
1287 unsigned short offset1 __attribute__((packed));
1290 /* Read LEN bytes starting at logical address ADDR, and put the result
1291 into DEST. Return 1 if success, zero if not. */
1293 read_memory_region (unsigned long addr, void *dest, size_t len)
1295 unsigned long dos_ds_limit = __dpmi_get_segment_limit (_dos_ds);
1298 /* For the low memory, we can simply use _dos_ds. */
1299 if (addr <= dos_ds_limit - len)
1300 dosmemget (addr, len, dest);
1303 /* For memory above 1MB we need to set up a special segment to
1304 be able to access that memory. */
1305 int sel = __dpmi_allocate_ldt_descriptors (1);
1311 int access_rights = __dpmi_get_descriptor_access_rights (sel);
1312 size_t segment_limit = len - 1;
1314 /* Make sure the crucial bits in the descriptor access
1315 rights are set correctly. Some DPMI providers might barf
1316 if we set the segment limit to something that is not an
1317 integral multiple of 4KB pages if the granularity bit is
1318 not set to byte-granular, even though the DPMI spec says
1319 it's the host's responsibility to set that bit correctly. */
1320 if (len > 1024 * 1024)
1322 access_rights |= 0x8000;
1323 /* Page-granular segments should have the low 12 bits of
1325 segment_limit |= 0xfff;
1328 access_rights &= ~0x8000;
1330 if (__dpmi_set_segment_base_address (sel, addr) != -1
1331 && __dpmi_set_descriptor_access_rights (sel, access_rights) != -1
1332 && __dpmi_set_segment_limit (sel, segment_limit) != -1
1333 /* W2K silently fails to set the segment limit, leaving
1334 it at zero; this test avoids the resulting crash. */
1335 && __dpmi_get_segment_limit (sel) >= segment_limit)
1336 movedata (sel, 0, _my_ds (), (unsigned)dest, len);
1340 __dpmi_free_ldt_descriptor (sel);
1346 /* Get a segment descriptor stored at index IDX in the descriptor
1347 table whose base address is TABLE_BASE. Return the descriptor
1348 type, or -1 if failure. */
1350 get_descriptor (unsigned long table_base, int idx, void *descr)
1352 unsigned long addr = table_base + idx * 8; /* 8 bytes per entry */
1354 if (read_memory_region (addr, descr, 8))
1355 return (int)((struct seg_descr *)descr)->stype;
1360 unsigned short limit __attribute__((packed));
1361 unsigned long base __attribute__((packed));
1364 /* Display a segment descriptor stored at index IDX in a descriptor
1365 table whose type is TYPE and whose base address is BASE_ADDR. If
1366 FORCE is non-zero, display even invalid descriptors. */
1368 display_descriptor (unsigned type, unsigned long base_addr, int idx, int force)
1370 struct seg_descr descr;
1371 struct gate_descr gate;
1373 /* Get the descriptor from the table. */
1374 if (idx == 0 && type == 0)
1375 puts_filtered ("0x000: null descriptor\n");
1376 else if (get_descriptor (base_addr, idx, &descr) != -1)
1378 /* For each type of descriptor table, this has a bit set if the
1379 corresponding type of selectors is valid in that table. */
1380 static unsigned allowed_descriptors[] = {
1381 0xffffdafeL, /* GDT */
1382 0x0000c0e0L, /* IDT */
1383 0xffffdafaL /* LDT */
1386 /* If the program hasn't started yet, assume the debuggee will
1387 have the same CPL as the debugger. */
1388 int cpl = prog_has_started ? (a_tss.tss_cs & 3) : _my_cs () & 3;
1389 unsigned long limit = (descr.limit1 << 16) | descr.limit0;
1392 && (allowed_descriptors[type] & (1 << descr.stype)) != 0)
1394 printf_filtered ("0x%03x: ",
1396 ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1397 if (descr.page_granular)
1398 limit = (limit << 12) | 0xfff; /* big segment: low 12 bit set */
1399 if (descr.stype == 1 || descr.stype == 2 || descr.stype == 3
1400 || descr.stype == 9 || descr.stype == 11
1401 || (descr.stype >= 16 && descr.stype < 32))
1402 printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1403 descr.base2, descr.base1, descr.base0, limit);
1405 switch (descr.stype)
1409 printf_filtered (" 16-bit TSS (task %sactive)",
1410 descr.stype == 3 ? "" : "in");
1413 puts_filtered (" LDT");
1416 memcpy (&gate, &descr, sizeof gate);
1417 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1418 gate.selector, gate.offset1, gate.offset0);
1419 printf_filtered (" 16-bit Call Gate (params=%d)",
1423 printf_filtered ("TSS selector=0x%04x", descr.base0);
1424 printfi_filtered (16, "Task Gate");
1428 memcpy (&gate, &descr, sizeof gate);
1429 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1430 gate.selector, gate.offset1, gate.offset0);
1431 printf_filtered (" 16-bit %s Gate",
1432 descr.stype == 6 ? "Interrupt" : "Trap");
1436 printf_filtered (" 32-bit TSS (task %sactive)",
1437 descr.stype == 3 ? "" : "in");
1440 memcpy (&gate, &descr, sizeof gate);
1441 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1442 gate.selector, gate.offset1, gate.offset0);
1443 printf_filtered (" 32-bit Call Gate (params=%d)",
1448 memcpy (&gate, &descr, sizeof gate);
1449 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1450 gate.selector, gate.offset1, gate.offset0);
1451 printf_filtered (" 32-bit %s Gate",
1452 descr.stype == 14 ? "Interrupt" : "Trap");
1454 case 16: /* data segments */
1462 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1463 descr.bit32 ? "32" : "16",
1464 descr.stype & 2 ? "Read/Write," : "Read-Only, ",
1465 descr.stype & 4 ? "down" : "up",
1466 descr.stype & 1 ? "" : ", N.Acc");
1468 case 24: /* code segments */
1476 printf_filtered (" %s-bit Code (%s, %sConf%s)",
1477 descr.bit32 ? "32" : "16",
1478 descr.stype & 2 ? "Exec/Read" : "Exec-Only",
1479 descr.stype & 4 ? "" : "N.",
1480 descr.stype & 1 ? "" : ", N.Acc");
1483 printf_filtered ("Unknown type 0x%02x", descr.stype);
1486 puts_filtered ("\n");
1490 printf_filtered ("0x%03x: ",
1492 ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1494 puts_filtered ("Segment not present\n");
1496 printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1501 printf_filtered ("0x%03x: Cannot read this descriptor\n", idx);
1505 go32_sldt (char *arg, int from_tty)
1507 struct dtr_reg gdtr;
1508 unsigned short ldtr = 0;
1510 struct seg_descr ldt_descr;
1511 long ldt_entry = -1L;
1512 int cpl = (prog_has_started ? a_tss.tss_cs : _my_cs ()) & 3;
1516 while (*arg && isspace(*arg))
1521 ldt_entry = parse_and_eval_long (arg);
1523 || (ldt_entry & 4) == 0
1524 || (ldt_entry & 3) != (cpl & 3))
1525 error ("Invalid LDT entry 0x%03x.", ldt_entry);
1529 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1530 __asm__ __volatile__ ("sldt %0" : "=m" (ldtr) : /* no inputs */ );
1533 puts_filtered ("There is no LDT.\n");
1534 /* LDT's entry in the GDT must have the type LDT, which is 2. */
1535 else if (get_descriptor (gdtr.base, ldt_idx, &ldt_descr) != 2)
1536 printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1538 | (ldt_descr.base1 << 16)
1539 | (ldt_descr.base2 << 24));
1544 | (ldt_descr.base1 << 16)
1545 | (ldt_descr.base2 << 24);
1546 unsigned limit = ldt_descr.limit0 | (ldt_descr.limit1 << 16);
1549 if (ldt_descr.page_granular)
1550 /* Page-granular segments must have the low 12 bits of their
1552 limit = (limit << 12) | 0xfff;
1553 /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1558 max_entry = (limit + 1) / 8;
1562 if (ldt_entry > limit)
1563 error ("Invalid LDT entry %#x: outside valid limits [0..%#x]",
1566 display_descriptor (ldt_descr.stype, base, ldt_entry / 8, 1);
1572 for (i = 0; i < max_entry; i++)
1573 display_descriptor (ldt_descr.stype, base, i, 0);
1579 go32_sgdt (char *arg, int from_tty)
1581 struct dtr_reg gdtr;
1582 long gdt_entry = -1L;
1587 while (*arg && isspace(*arg))
1592 gdt_entry = parse_and_eval_long (arg);
1593 if (gdt_entry < 0 || (gdt_entry & 7) != 0)
1594 error ("Invalid GDT entry 0x%03x: not an integral multiple of 8.",
1599 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1600 max_entry = (gdtr.limit + 1) / 8;
1604 if (gdt_entry > gdtr.limit)
1605 error ("Invalid GDT entry %#x: outside valid limits [0..%#x]",
1606 gdt_entry, gdtr.limit);
1608 display_descriptor (0, gdtr.base, gdt_entry / 8, 1);
1614 for (i = 0; i < max_entry; i++)
1615 display_descriptor (0, gdtr.base, i, 0);
1620 go32_sidt (char *arg, int from_tty)
1622 struct dtr_reg idtr;
1623 long idt_entry = -1L;
1628 while (*arg && isspace(*arg))
1633 idt_entry = parse_and_eval_long (arg);
1635 error ("Invalid (negative) IDT entry %d.", idt_entry);
1639 __asm__ __volatile__ ("sidt %0" : "=m" (idtr) : /* no inputs */ );
1640 max_entry = (idtr.limit + 1) / 8;
1641 if (max_entry > 0x100) /* no more than 256 entries */
1646 if (idt_entry > idtr.limit)
1647 error ("Invalid IDT entry %#x: outside valid limits [0..%#x]",
1648 idt_entry, idtr.limit);
1650 display_descriptor (1, idtr.base, idt_entry, 1);
1656 for (i = 0; i < max_entry; i++)
1657 display_descriptor (1, idtr.base, i, 0);
1661 /* Cached linear address of the base of the page directory. For
1662 now, available only under CWSDPMI. Code based on ideas and
1663 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
1664 static unsigned long pdbr;
1666 static unsigned long
1671 unsigned long taskbase, cr3;
1672 struct dtr_reg gdtr;
1674 if (pdbr > 0 && pdbr <= 0xfffff)
1677 /* Get the linear address of GDT and the Task Register. */
1678 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1679 __asm__ __volatile__ ("str %0" : "=m" (taskreg) : /* no inputs */ );
1681 /* Task Register is a segment selector for the TSS of the current
1682 task. Therefore, it can be used as an index into the GDT to get
1683 at the segment descriptor for the TSS. To get the index, reset
1684 the low 3 bits of the selector (which give the CPL). Add 2 to the
1685 offset to point to the 3 low bytes of the base address. */
1686 offset = gdtr.base + (taskreg & 0xfff8) + 2;
1689 /* CWSDPMI's task base is always under the 1MB mark. */
1690 if (offset > 0xfffff)
1693 _farsetsel (_dos_ds);
1694 taskbase = _farnspeekl (offset) & 0xffffffU;
1695 taskbase += _farnspeekl (offset + 2) & 0xff000000U;
1696 if (taskbase > 0xfffff)
1699 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1700 offset 1Ch in the TSS. */
1701 cr3 = _farnspeekl (taskbase + 0x1c) & ~0xfff;
1704 #if 0 /* not fully supported yet */
1705 /* The Page Directory is in UMBs. In that case, CWSDPMI puts
1706 the first Page Table right below the Page Directory. Thus,
1707 the first Page Table's entry for its own address and the Page
1708 Directory entry for that Page Table will hold the same
1709 physical address. The loop below searches the entire UMB
1710 range of addresses for such an occurence. */
1711 unsigned long addr, pte_idx;
1713 for (addr = 0xb0000, pte_idx = 0xb0;
1715 addr += 0x1000, pte_idx++)
1717 if (((_farnspeekl (addr + 4 * pte_idx) & 0xfffff027) ==
1718 (_farnspeekl (addr + 0x1000) & 0xfffff027))
1719 && ((_farnspeekl (addr + 4 * pte_idx + 4) & 0xfffff000) == cr3))
1721 cr3 = addr + 0x1000;
1734 /* Return the N'th Page Directory entry. */
1735 static unsigned long
1738 unsigned long pde = 0;
1740 if (pdbr && n >= 0 && n < 1024)
1742 pde = _farpeekl (_dos_ds, pdbr + 4*n);
1747 /* Return the N'th entry of the Page Table whose Page Directory entry
1749 static unsigned long
1750 get_pte (unsigned long pde, int n)
1752 unsigned long pte = 0;
1754 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
1755 page tables, for now. */
1756 if ((pde & 1) && !(pde & 0x80) && n >= 0 && n < 1024)
1758 pde &= ~0xfff; /* clear non-address bits */
1759 pte = _farpeekl (_dos_ds, pde + 4*n);
1764 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
1765 says this is a Page Directory entry. If FORCE is non-zero, display
1766 the entry even if its Present flag is off. OFF is the offset of the
1767 address from the page's base address. */
1769 display_ptable_entry (unsigned long entry, int is_dir, int force, unsigned off)
1771 if ((entry & 1) != 0)
1773 printf_filtered ("Base=0x%05lx000", entry >> 12);
1774 if ((entry & 0x100) && !is_dir)
1775 puts_filtered (" Global");
1776 if ((entry & 0x40) && !is_dir)
1777 puts_filtered (" Dirty");
1778 printf_filtered (" %sAcc.", (entry & 0x20) ? "" : "Not-");
1779 printf_filtered (" %sCached", (entry & 0x10) ? "" : "Not-");
1780 printf_filtered (" Write-%s", (entry & 8) ? "Thru" : "Back");
1781 printf_filtered (" %s", (entry & 4) ? "Usr" : "Sup");
1782 printf_filtered (" Read-%s", (entry & 2) ? "Write" : "Only");
1784 printf_filtered (" +0x%x", off);
1785 puts_filtered ("\n");
1788 printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1789 is_dir ? " Table" : "", entry >> 1);
1793 go32_pde (char *arg, int from_tty)
1795 long pde_idx = -1, i;
1799 while (*arg && isspace(*arg))
1804 pde_idx = parse_and_eval_long (arg);
1805 if (pde_idx < 0 || pde_idx >= 1024)
1806 error ("Entry %ld is outside valid limits [0..1023].", pde_idx);
1812 puts_filtered ("Access to Page Directories is not supported on this system.\n");
1813 else if (pde_idx >= 0)
1814 display_ptable_entry (get_pde (pde_idx), 1, 1, 0);
1816 for (i = 0; i < 1024; i++)
1817 display_ptable_entry (get_pde (i), 1, 0, 0);
1820 /* A helper function to display entries in a Page Table pointed to by
1821 the N'th entry in the Page Directory. If FORCE is non-zero, say
1822 something even if the Page Table is not accessible. */
1824 display_page_table (long n, int force)
1826 unsigned long pde = get_pde (n);
1832 printf_filtered ("Page Table pointed to by Page Directory entry 0x%lx:\n", n);
1833 for (i = 0; i < 1024; i++)
1834 display_ptable_entry (get_pte (pde, i), 0, 0, 0);
1835 puts_filtered ("\n");
1838 printf_filtered ("Page Table not present; value=0x%lx.\n", pde >> 1);
1842 go32_pte (char *arg, int from_tty)
1844 long pde_idx = -1, i;
1848 while (*arg && isspace(*arg))
1853 pde_idx = parse_and_eval_long (arg);
1854 if (pde_idx < 0 || pde_idx >= 1024)
1855 error ("Entry %d is outside valid limits [0..1023].", pde_idx);
1861 puts_filtered ("Access to Page Tables is not supported on this system.\n");
1862 else if (pde_idx >= 0)
1863 display_page_table (pde_idx, 1);
1865 for (i = 0; i < 1024; i++)
1866 display_page_table (i, 0);
1870 go32_pte_for_address (char *arg, int from_tty)
1872 CORE_ADDR addr = 0, i;
1876 while (*arg && isspace(*arg))
1880 addr = parse_and_eval_address (arg);
1883 error_no_arg ("linear address");
1887 puts_filtered ("Access to Page Tables is not supported on this system.\n");
1890 int pde_idx = (addr >> 22) & 0x3ff;
1891 int pte_idx = (addr >> 12) & 0x3ff;
1892 unsigned offs = addr & 0xfff;
1894 printf_filtered ("Page Table entry for address 0x%llx:\n",
1895 (unsigned long long)addr);
1896 display_ptable_entry (get_pte (get_pde (pde_idx), pte_idx), 0, 1, offs);
1900 static struct cmd_list_element *info_dos_cmdlist = NULL;
1903 go32_info_dos_command (char *args, int from_tty)
1905 help_list (info_dos_cmdlist, "info dos ", class_info, gdb_stdout);
1909 _initialize_go32_nat (void)
1912 add_target (&go32_ops);
1914 add_prefix_cmd ("dos", class_info, go32_info_dos_command,
1915 "Print information specific to DJGPP (a.k.a. MS-DOS) debugging.",
1916 &info_dos_cmdlist, "info dos ", 0, &infolist);
1918 add_cmd ("sysinfo", class_info, go32_sysinfo,
1919 "Display information about the target system, including CPU, OS, DPMI, etc.",
1921 add_cmd ("ldt", class_info, go32_sldt,
1922 "Display entries in the LDT (Local Descriptor Table).\n"
1923 "Entry number (an expression) as an argument means display only that entry.",
1925 add_cmd ("gdt", class_info, go32_sgdt,
1926 "Display entries in the GDT (Global Descriptor Table).\n"
1927 "Entry number (an expression) as an argument means display only that entry.",
1929 add_cmd ("idt", class_info, go32_sidt,
1930 "Display entries in the IDT (Interrupt Descriptor Table).\n"
1931 "Entry number (an expression) as an argument means display only that entry.",
1933 add_cmd ("pde", class_info, go32_pde,
1934 "Display entries in the Page Directory.\n"
1935 "Entry number (an expression) as an argument means display only that entry.",
1937 add_cmd ("pte", class_info, go32_pte,
1938 "Display entries in Page Tables.\n"
1939 "Entry number (an expression) as an argument means display only entries\n"
1940 "from the Page Table pointed to by the specified Page Directory entry.",
1942 add_cmd ("address-pte", class_info, go32_pte_for_address,
1943 "Display a Page Table entry for a linear address.\n"
1944 "The address argument must be a linear address, after adding to\n"
1945 "it the base address of the appropriate segment.\n"
1946 "The base address of variables and functions in the debuggee's data\n"
1947 "or code segment is stored in the variable __djgpp_base_address,\n"
1948 "so use `__djgpp_base_address + (char *)&var' as the argument.\n"
1949 "For other segments, look up their base address in the output of\n"
1950 "the `info dos ldt' command.",
1964 tcsetpgrp (int fd, pid_t pgid)
1966 if (isatty (fd) && pgid == SOME_PID)
1968 errno = pgid == SOME_PID ? ENOTTY : ENOSYS;