1 /* Native debugging support for Intel x86 running DJGPP.
2 Copyright (C) 1997, 1999, 2000, 2001, 2005, 2006, 2007, 2008
3 Free Software Foundation, Inc.
4 Written by Robert Hoehne.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "gdbthread.h"
30 #include "floatformat.h"
32 #include "i387-tdep.h"
33 #include "i386-tdep.h"
36 #include "gdb_string.h"
39 #include <stdio.h> /* might be required for __DJGPP_MINOR__ */
44 #include <sys/utsname.h>
49 #include <sys/farptr.h>
50 #include <debug/v2load.h>
51 #include <debug/dbgcom.h>
52 #if __DJGPP_MINOR__ > 2
53 #include <debug/redir.h>
56 #if __DJGPP_MINOR__ < 3
57 /* This code will be provided from DJGPP 2.03 on. Until then I code it
65 unsigned short exponent
:15;
66 unsigned short sign
:1;
85 static void save_npx (void); /* Save the FPU of the debugged program */
86 static void load_npx (void); /* Restore the FPU of the debugged program */
88 /* ------------------------------------------------------------------------- */
89 /* Store the contents of the NPX in the global variable `npx'. */
95 asm ("inb $0xa0, %%al \n\
114 /* ------------------------------------------------------------------------- */
115 /* Reload the contents of the NPX from the global variable `npx'. */
120 asm ("frstor %0":"=m" (npx
));
122 /* ------------------------------------------------------------------------- */
123 /* Stubs for the missing redirection functions. */
130 redir_cmdline_delete (cmdline_t
*ptr
)
136 redir_cmdline_parse (const char *args
, cmdline_t
*ptr
)
142 redir_to_child (cmdline_t
*ptr
)
148 redir_to_debugger (cmdline_t
*ptr
)
154 redir_debug_init (cmdline_t
*ptr
)
158 #endif /* __DJGPP_MINOR < 3 */
160 typedef enum { wp_insert
, wp_remove
, wp_count
} wp_op
;
162 /* This holds the current reference counts for each debug register. */
163 static int dr_ref_count
[4];
167 static int prog_has_started
= 0;
168 static void go32_open (char *name
, int from_tty
);
169 static void go32_close (int quitting
);
170 static void go32_attach (char *args
, int from_tty
);
171 static void go32_detach (char *args
, int from_tty
);
172 static void go32_resume (ptid_t ptid
, int step
,
173 enum target_signal siggnal
);
174 static ptid_t
go32_wait (ptid_t ptid
,
175 struct target_waitstatus
*status
);
176 static void go32_fetch_registers (struct regcache
*, int regno
);
177 static void store_register (const struct regcache
*, int regno
);
178 static void go32_store_registers (struct regcache
*, int regno
);
179 static void go32_prepare_to_store (struct regcache
*);
180 static int go32_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
,
182 struct mem_attrib
*attrib
,
183 struct target_ops
*target
);
184 static void go32_files_info (struct target_ops
*target
);
185 static void go32_stop (ptid_t
);
186 static void go32_kill_inferior (void);
187 static void go32_create_inferior (char *exec_file
, char *args
, char **env
, int from_tty
);
188 static void go32_mourn_inferior (void);
189 static int go32_can_run (void);
191 static struct target_ops go32_ops
;
192 static void go32_terminal_init (void);
193 static void go32_terminal_inferior (void);
194 static void go32_terminal_ours (void);
196 #define r_ofs(x) (offsetof(TSS,x))
205 {r_ofs (tss_eax
), 4}, /* normal registers, from a_tss */
206 {r_ofs (tss_ecx
), 4},
207 {r_ofs (tss_edx
), 4},
208 {r_ofs (tss_ebx
), 4},
209 {r_ofs (tss_esp
), 4},
210 {r_ofs (tss_ebp
), 4},
211 {r_ofs (tss_esi
), 4},
212 {r_ofs (tss_edi
), 4},
213 {r_ofs (tss_eip
), 4},
214 {r_ofs (tss_eflags
), 4},
221 {0, 10}, /* 8 FP registers, from npx.reg[] */
229 /* The order of the next 7 registers must be consistent
230 with their numbering in config/i386/tm-i386.h, which see. */
231 {0, 2}, /* control word, from npx */
232 {4, 2}, /* status word, from npx */
233 {8, 2}, /* tag word, from npx */
234 {16, 2}, /* last FP exception CS from npx */
235 {12, 4}, /* last FP exception EIP from npx */
236 {24, 2}, /* last FP exception operand selector from npx */
237 {20, 4}, /* last FP exception operand offset from npx */
238 {18, 2} /* last FP opcode from npx */
244 enum target_signal gdb_sig
;
248 {0, TARGET_SIGNAL_FPE
},
249 {1, TARGET_SIGNAL_TRAP
},
250 /* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
251 but I think SIGBUS is better, since the NMI is usually activated
252 as a result of a memory parity check failure. */
253 {2, TARGET_SIGNAL_BUS
},
254 {3, TARGET_SIGNAL_TRAP
},
255 {4, TARGET_SIGNAL_FPE
},
256 {5, TARGET_SIGNAL_SEGV
},
257 {6, TARGET_SIGNAL_ILL
},
258 {7, TARGET_SIGNAL_EMT
}, /* no-coprocessor exception */
259 {8, TARGET_SIGNAL_SEGV
},
260 {9, TARGET_SIGNAL_SEGV
},
261 {10, TARGET_SIGNAL_BUS
},
262 {11, TARGET_SIGNAL_SEGV
},
263 {12, TARGET_SIGNAL_SEGV
},
264 {13, TARGET_SIGNAL_SEGV
},
265 {14, TARGET_SIGNAL_SEGV
},
266 {16, TARGET_SIGNAL_FPE
},
267 {17, TARGET_SIGNAL_BUS
},
268 {31, TARGET_SIGNAL_ILL
},
269 {0x1b, TARGET_SIGNAL_INT
},
270 {0x75, TARGET_SIGNAL_FPE
},
271 {0x78, TARGET_SIGNAL_ALRM
},
272 {0x79, TARGET_SIGNAL_INT
},
273 {0x7a, TARGET_SIGNAL_QUIT
},
274 {-1, TARGET_SIGNAL_LAST
}
278 enum target_signal gdb_sig
;
281 {TARGET_SIGNAL_0
, -1},
282 {TARGET_SIGNAL_ILL
, 6}, /* Invalid Opcode */
283 {TARGET_SIGNAL_EMT
, 7}, /* triggers SIGNOFP */
284 {TARGET_SIGNAL_SEGV
, 13}, /* GPF */
285 {TARGET_SIGNAL_BUS
, 17}, /* Alignment Check */
286 /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
288 {TARGET_SIGNAL_TERM
, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
289 {TARGET_SIGNAL_FPE
, 0x75},
290 {TARGET_SIGNAL_INT
, 0x79},
291 {TARGET_SIGNAL_QUIT
, 0x7a},
292 {TARGET_SIGNAL_ALRM
, 0x78}, /* triggers SIGTIMR */
293 {TARGET_SIGNAL_PROF
, 0x78},
294 {TARGET_SIGNAL_LAST
, -1}
298 go32_open (char *name
, int from_tty
)
300 printf_unfiltered ("Done. Use the \"run\" command to run the program.\n");
304 go32_close (int quitting
)
309 go32_attach (char *args
, int from_tty
)
312 You cannot attach to a running program on this platform.\n\
313 Use the `run' command to run DJGPP programs."));
317 go32_detach (char *args
, int from_tty
)
321 static int resume_is_step
;
322 static int resume_signal
= -1;
325 go32_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
329 resume_is_step
= step
;
331 if (siggnal
!= TARGET_SIGNAL_0
&& siggnal
!= TARGET_SIGNAL_TRAP
)
333 for (i
= 0, resume_signal
= -1;
334 excepn_map
[i
].gdb_sig
!= TARGET_SIGNAL_LAST
; i
++)
335 if (excepn_map
[i
].gdb_sig
== siggnal
)
337 resume_signal
= excepn_map
[i
].djgpp_excepno
;
340 if (resume_signal
== -1)
341 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
342 target_signal_to_name (siggnal
));
346 static char child_cwd
[FILENAME_MAX
];
349 go32_wait (ptid_t ptid
, struct target_waitstatus
*status
)
352 unsigned char saved_opcode
;
353 unsigned long INT3_addr
= 0;
354 int stepping_over_INT
= 0;
356 a_tss
.tss_eflags
&= 0xfeff; /* reset the single-step flag (TF) */
359 /* If the next instruction is INT xx or INTO, we need to handle
360 them specially. Intel manuals say that these instructions
361 reset the single-step flag (a.k.a. TF). However, it seems
362 that, at least in the DPMI environment, and at least when
363 stepping over the DPMI interrupt 31h, the problem is having
364 TF set at all when INT 31h is executed: the debuggee either
365 crashes (and takes the system with it) or is killed by a
368 So we need to emulate single-step mode: we put an INT3 opcode
369 right after the INT xx instruction, let the debuggee run
370 until it hits INT3 and stops, then restore the original
371 instruction which we overwrote with the INT3 opcode, and back
372 up the debuggee's EIP to that instruction. */
373 read_child (a_tss
.tss_eip
, &saved_opcode
, 1);
374 if (saved_opcode
== 0xCD || saved_opcode
== 0xCE)
376 unsigned char INT3_opcode
= 0xCC;
379 = saved_opcode
== 0xCD ? a_tss
.tss_eip
+ 2 : a_tss
.tss_eip
+ 1;
380 stepping_over_INT
= 1;
381 read_child (INT3_addr
, &saved_opcode
, 1);
382 write_child (INT3_addr
, &INT3_opcode
, 1);
385 a_tss
.tss_eflags
|= 0x0100; /* normal instruction: set TF */
388 /* The special value FFFFh in tss_trap indicates to run_child that
389 tss_irqn holds a signal to be delivered to the debuggee. */
390 if (resume_signal
<= -1)
393 a_tss
.tss_irqn
= 0xff;
397 a_tss
.tss_trap
= 0xffff; /* run_child looks for this */
398 a_tss
.tss_irqn
= resume_signal
;
401 /* The child might change working directory behind our back. The
402 GDB users won't like the side effects of that when they work with
403 relative file names, and GDB might be confused by its current
404 directory not being in sync with the truth. So we always make a
405 point of changing back to where GDB thinks is its cwd, when we
406 return control to the debugger, but restore child's cwd before we
408 /* Initialize child_cwd, before the first call to run_child and not
409 in the initialization, so the child get also the changed directory
410 set with the gdb-command "cd ..." */
412 /* Initialize child's cwd with the current one. */
413 getcwd (child_cwd
, sizeof (child_cwd
));
417 #if __DJGPP_MINOR__ < 3
421 #if __DJGPP_MINOR__ < 3
425 /* Did we step over an INT xx instruction? */
426 if (stepping_over_INT
&& a_tss
.tss_eip
== INT3_addr
+ 1)
428 /* Restore the original opcode. */
429 a_tss
.tss_eip
--; /* EIP points *after* the INT3 instruction */
430 write_child (a_tss
.tss_eip
, &saved_opcode
, 1);
431 /* Simulate a TRAP exception. */
433 a_tss
.tss_eflags
|= 0x0100;
436 getcwd (child_cwd
, sizeof (child_cwd
)); /* in case it has changed */
437 chdir (current_directory
);
439 if (a_tss
.tss_irqn
== 0x21)
441 status
->kind
= TARGET_WAITKIND_EXITED
;
442 status
->value
.integer
= a_tss
.tss_eax
& 0xff;
446 status
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
447 status
->kind
= TARGET_WAITKIND_STOPPED
;
448 for (i
= 0; sig_map
[i
].go32_sig
!= -1; i
++)
450 if (a_tss
.tss_irqn
== sig_map
[i
].go32_sig
)
452 #if __DJGPP_MINOR__ < 3
453 if ((status
->value
.sig
= sig_map
[i
].gdb_sig
) !=
455 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
457 status
->value
.sig
= sig_map
[i
].gdb_sig
;
463 return pid_to_ptid (SOME_PID
);
467 fetch_register (struct regcache
*regcache
, int regno
)
469 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
470 if (regno
< gdbarch_fp0_regnum (gdbarch
))
471 regcache_raw_supply (regcache
, regno
,
472 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
473 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
, 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
);
488 regno
< gdbarch_fp0_regnum (get_regcache_arch (regcache
));
490 fetch_register (regcache
, regno
);
491 i387_supply_fsave (regcache
, -1, &npx
);
496 store_register (const struct regcache
*regcache
, int regno
)
498 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
499 if (regno
< gdbarch_fp0_regnum (gdbarch
))
500 regcache_raw_collect (regcache
, regno
,
501 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
502 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
, regno
))
503 i387_collect_fsave (regcache
, regno
, &npx
);
505 internal_error (__FILE__
, __LINE__
,
506 _("Invalid register no. %d in store_register."), regno
);
510 go32_store_registers (struct regcache
*regcache
, int regno
)
515 store_register (regcache
, regno
);
518 for (r
= 0; r
< gdbarch_fp0_regnum (get_regcache_arch (regcache
)); r
++)
519 store_register (regcache
, r
);
520 i387_collect_fsave (regcache
, -1, &npx
);
525 go32_prepare_to_store (struct regcache
*regcache
)
530 go32_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*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");
566 go32_stop (ptid_t ptid
)
570 ptid
= inferior_ptid
;
571 inferior_ptid
= null_ptid
;
572 delete_thread_silent (ptid
);
573 prog_has_started
= 0;
577 go32_kill_inferior (void)
579 redir_cmdline_delete (&child_cmd
);
582 if (!ptid_equal (inferior_ptid
, null_ptid
))
583 delete_thread_silent (inferior_ptid
);
584 unpush_target (&go32_ops
);
588 go32_create_inferior (char *exec_file
, char *args
, char **env
, int from_tty
)
590 extern char **environ
;
593 char **env_save
= environ
;
596 /* If no exec file handed to us, get it from the exec-file command -- with
597 a good, common error message if none is specified. */
599 exec_file
= get_exec_file (1);
601 if (prog_has_started
)
603 go32_stop (inferior_ptid
);
604 go32_kill_inferior ();
609 /* Initialize child's cwd as empty to be initialized when starting
613 /* Init command line storage. */
614 if (redir_debug_init (&child_cmd
) == -1)
615 internal_error (__FILE__
, __LINE__
,
616 _("Cannot allocate redirection storage: not enough memory.\n"));
618 /* Parse the command line and create redirections. */
619 if (strpbrk (args
, "<>"))
621 if (redir_cmdline_parse (args
, &child_cmd
) == 0)
622 args
= child_cmd
.command
;
624 error (_("Syntax error in command line."));
627 child_cmd
.command
= xstrdup (args
);
629 cmdlen
= strlen (args
);
630 /* v2loadimage passes command lines via DOS memory, so it cannot
631 possibly handle commands longer than 1MB. */
632 if (cmdlen
> 1024*1024)
633 error (_("Command line too long."));
635 cmdline
= xmalloc (cmdlen
+ 4);
636 strcpy (cmdline
+ 1, args
);
637 /* If the command-line length fits into DOS 126-char limits, use the
638 DOS command tail format; otherwise, tell v2loadimage to pass it
639 through a buffer in conventional memory. */
642 cmdline
[0] = strlen (args
);
643 cmdline
[cmdlen
+ 1] = 13;
646 cmdline
[0] = 0xff; /* signal v2loadimage it's a long command */
650 if (v2loadimage (exec_file
, cmdline
, start_state
))
653 printf_unfiltered ("Load failed for image %s\n", exec_file
);
659 edi_init (start_state
);
660 #if __DJGPP_MINOR__ < 3
664 inferior_ptid
= pid_to_ptid (SOME_PID
);
665 add_inferior_silent (SOME_PID
);
667 push_target (&go32_ops
);
669 add_thread_silent (inferior_ptid
);
671 clear_proceed_status ();
672 insert_breakpoints ();
673 prog_has_started
= 1;
677 go32_mourn_inferior (void)
679 /* We need to make sure all the breakpoint enable bits in the DR7
680 register are reset when the inferior exits. Otherwise, if they
681 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
682 failure to set more watchpoints, and other calamities. It would
683 be nice if GDB itself would take care to remove all breakpoints
684 at all times, but it doesn't, probably under an assumption that
685 the OS cleans up when the debuggee exits. */
686 i386_cleanup_dregs ();
687 go32_kill_inferior ();
688 generic_mourn_inferior ();
697 /* Hardware watchpoint support. */
699 #define D_REGS edi.dr
700 #define CONTROL D_REGS[7]
701 #define STATUS D_REGS[6]
703 /* Pass the address ADDR to the inferior in the I'th debug register.
704 Here we just store the address in D_REGS, the watchpoint will be
705 actually set up when go32_wait runs the debuggee. */
707 go32_set_dr (int i
, CORE_ADDR addr
)
710 internal_error (__FILE__
, __LINE__
,
711 _("Invalid register %d in go32_set_dr.\n"), i
);
715 /* Pass the value VAL to the inferior in the DR7 debug control
716 register. Here we just store the address in D_REGS, the watchpoint
717 will be actually set up when go32_wait runs the debuggee. */
719 go32_set_dr7 (unsigned val
)
724 /* Get the value of the DR6 debug status register from the inferior.
725 Here we just return the value stored in D_REGS, as we've got it
726 from the last go32_wait call. */
733 /* Put the device open on handle FD into either raw or cooked
734 mode, return 1 if it was in raw mode, zero otherwise. */
737 device_mode (int fd
, int raw_p
)
739 int oldmode
, newmode
;
744 __dpmi_int (0x21, ®s
);
745 if (regs
.x
.flags
& 1)
747 newmode
= oldmode
= regs
.x
.dx
;
754 if (oldmode
& 0x80) /* Only for character dev */
758 regs
.x
.dx
= newmode
& 0xff; /* Force upper byte zero, else it fails */
759 __dpmi_int (0x21, ®s
);
760 if (regs
.x
.flags
& 1)
763 return (oldmode
& 0x20) == 0x20;
767 static int inf_mode_valid
= 0;
768 static int inf_terminal_mode
;
770 /* This semaphore is needed because, amazingly enough, GDB calls
771 target.to_terminal_ours more than once after the inferior stops.
772 But we need the information from the first call only, since the
773 second call will always see GDB's own cooked terminal. */
774 static int terminal_is_ours
= 1;
777 go32_terminal_init (void)
779 inf_mode_valid
= 0; /* reinitialize, in case they are restarting child */
780 terminal_is_ours
= 1;
784 go32_terminal_info (char *args
, int from_tty
)
786 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
788 ? "default" : inf_terminal_mode
? "raw" : "cooked");
790 #if __DJGPP_MINOR__ > 2
791 if (child_cmd
.redirection
)
795 for (i
= 0; i
< DBG_HANDLES
; i
++)
797 if (child_cmd
.redirection
[i
]->file_name
)
798 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
799 i
, child_cmd
.redirection
[i
]->file_name
);
800 else if (_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) == -1)
802 ("\tFile handle %d appears to be closed by inferior.\n", i
);
803 /* Mask off the raw/cooked bit when comparing device info words. */
804 else if ((_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) & 0xdf)
805 != (_get_dev_info (i
) & 0xdf))
807 ("\tFile handle %d appears to be redirected by inferior.\n", i
);
814 go32_terminal_inferior (void)
816 /* Redirect standard handles as child wants them. */
818 if (redir_to_child (&child_cmd
) == -1)
820 redir_to_debugger (&child_cmd
);
821 error (_("Cannot redirect standard handles for program: %s."),
822 safe_strerror (errno
));
824 /* set the console device of the inferior to whatever mode
825 (raw or cooked) we found it last time */
826 if (terminal_is_ours
)
829 device_mode (0, inf_terminal_mode
);
830 terminal_is_ours
= 0;
835 go32_terminal_ours (void)
837 /* Switch to cooked mode on the gdb terminal and save the inferior
838 terminal mode to be restored when it is resumed */
839 if (!terminal_is_ours
)
841 inf_terminal_mode
= device_mode (0, 0);
842 if (inf_terminal_mode
!= -1)
845 /* If device_mode returned -1, we don't know what happens with
846 handle 0 anymore, so make the info invalid. */
848 terminal_is_ours
= 1;
850 /* Restore debugger's standard handles. */
852 if (redir_to_debugger (&child_cmd
) == -1)
854 redir_to_child (&child_cmd
);
855 error (_("Cannot redirect standard handles for debugger: %s."),
856 safe_strerror (errno
));
862 go32_thread_alive (ptid_t ptid
)
868 go32_pid_to_str (ptid_t ptid
)
871 xsnprintf (buf
, sizeof buf
, "Thread <main>");
878 go32_ops
.to_shortname
= "djgpp";
879 go32_ops
.to_longname
= "djgpp target process";
881 "Program loaded by djgpp, when gdb is used as an external debugger";
882 go32_ops
.to_open
= go32_open
;
883 go32_ops
.to_close
= go32_close
;
884 go32_ops
.to_attach
= go32_attach
;
885 go32_ops
.to_detach
= go32_detach
;
886 go32_ops
.to_resume
= go32_resume
;
887 go32_ops
.to_wait
= go32_wait
;
888 go32_ops
.to_fetch_registers
= go32_fetch_registers
;
889 go32_ops
.to_store_registers
= go32_store_registers
;
890 go32_ops
.to_prepare_to_store
= go32_prepare_to_store
;
891 go32_ops
.deprecated_xfer_memory
= go32_xfer_memory
;
892 go32_ops
.to_files_info
= go32_files_info
;
893 go32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
894 go32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
895 go32_ops
.to_terminal_init
= go32_terminal_init
;
896 go32_ops
.to_terminal_inferior
= go32_terminal_inferior
;
897 go32_ops
.to_terminal_ours_for_output
= go32_terminal_ours
;
898 go32_ops
.to_terminal_ours
= go32_terminal_ours
;
899 go32_ops
.to_terminal_info
= go32_terminal_info
;
900 go32_ops
.to_kill
= go32_kill_inferior
;
901 go32_ops
.to_create_inferior
= go32_create_inferior
;
902 go32_ops
.to_mourn_inferior
= go32_mourn_inferior
;
903 go32_ops
.to_can_run
= go32_can_run
;
904 go32_ops
.to_stop
= go32_stop
;
905 go32_ops
.to_thread_alive
= go32_thread_alive
;
906 go32_ops
.to_pid_to_str
= go32_pid_to_str
;
907 go32_ops
.to_stratum
= process_stratum
;
908 go32_ops
.to_has_all_memory
= 1;
909 go32_ops
.to_has_memory
= 1;
910 go32_ops
.to_has_stack
= 1;
911 go32_ops
.to_has_registers
= 1;
912 go32_ops
.to_has_execution
= 1;
913 go32_ops
.to_magic
= OPS_MAGIC
;
915 /* Initialize child's cwd as empty to be initialized when starting
919 /* Initialize child's command line storage. */
920 if (redir_debug_init (&child_cmd
) == -1)
921 internal_error (__FILE__
, __LINE__
,
922 _("Cannot allocate redirection storage: not enough memory.\n"));
924 /* We are always processing GCC-compiled programs. */
925 processing_gcc_compilation
= 2;
927 /* Override the default name of the GDB init file. */
928 strcpy (gdbinit
, "gdb.ini");
931 unsigned short windows_major
, windows_minor
;
933 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */
935 go32_get_windows_version(void)
940 __dpmi_int(0x2f, &r
);
941 if (r
.h
.al
> 2 && r
.h
.al
!= 0x80 && r
.h
.al
!= 0xff
942 && (r
.h
.al
> 3 || r
.h
.ah
> 0))
944 windows_major
= r
.h
.al
;
945 windows_minor
= r
.h
.ah
;
948 windows_major
= 0xff; /* meaning no Windows */
951 /* A subroutine of go32_sysinfo to display memory info. */
953 print_mem (unsigned long datum
, const char *header
, int in_pages_p
)
955 if (datum
!= 0xffffffffUL
)
959 puts_filtered (header
);
962 printf_filtered ("%lu KB", datum
>> 10);
963 if (datum
> 1024 * 1024)
964 printf_filtered (" (%lu MB)", datum
>> 20);
967 printf_filtered ("%lu Bytes", datum
);
968 puts_filtered ("\n");
972 /* Display assorted information about the underlying OS. */
974 go32_sysinfo (char *arg
, int from_tty
)
977 char cpuid_vendor
[13];
978 unsigned cpuid_max
= 0, cpuid_eax
, cpuid_ebx
, cpuid_ecx
, cpuid_edx
;
979 unsigned true_dos_version
= _get_dos_version (1);
980 unsigned advertized_dos_version
= ((unsigned int)_osmajor
<< 8) | _osminor
;
982 char dpmi_vendor_info
[129];
983 int dpmi_vendor_available
=
984 __dpmi_get_capabilities (&dpmi_flags
, dpmi_vendor_info
);
985 __dpmi_version_ret dpmi_version_data
;
987 __dpmi_free_mem_info mem_info
;
990 cpuid_vendor
[0] = '\0';
992 strcpy (u
.machine
, "Unknown x86");
993 else if (u
.machine
[0] == 'i' && u
.machine
[1] > 4)
995 /* CPUID with EAX = 0 returns the Vendor ID. */
996 __asm__
__volatile__ ("xorl %%ebx, %%ebx;"
1005 : "=m" (cpuid_vendor
[0]),
1006 "=m" (cpuid_vendor
[4]),
1007 "=m" (cpuid_vendor
[8]),
1010 : "%eax", "%ebx", "%ecx", "%edx");
1011 cpuid_vendor
[12] = '\0';
1014 printf_filtered ("CPU Type.......................%s", u
.machine
);
1015 if (cpuid_vendor
[0])
1016 printf_filtered (" (%s)", cpuid_vendor
);
1017 puts_filtered ("\n");
1019 /* CPUID with EAX = 1 returns processor signature and features. */
1022 static char *brand_name
[] = {
1030 char cpu_string
[80];
1033 int intel_p
= strcmp (cpuid_vendor
, "GenuineIntel") == 0;
1034 int amd_p
= strcmp (cpuid_vendor
, "AuthenticAMD") == 0;
1035 unsigned cpu_family
, cpu_model
;
1037 __asm__
__volatile__ ("movl $1, %%eax;"
1044 brand_idx
= cpuid_ebx
& 0xff;
1045 cpu_family
= (cpuid_eax
>> 8) & 0xf;
1046 cpu_model
= (cpuid_eax
>> 4) & 0xf;
1047 cpu_brand
[0] = '\0';
1051 && brand_idx
< sizeof(brand_name
)/sizeof(brand_name
[0])
1052 && *brand_name
[brand_idx
])
1053 strcpy (cpu_brand
, brand_name
[brand_idx
]);
1054 else if (cpu_family
== 5)
1056 if (((cpuid_eax
>> 12) & 3) == 0 && cpu_model
== 4)
1057 strcpy (cpu_brand
, " MMX");
1058 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 1)
1059 strcpy (cpu_brand
, " OverDrive");
1060 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 2)
1061 strcpy (cpu_brand
, " Dual");
1063 else if (cpu_family
== 6 && cpu_model
< 8)
1068 strcpy (cpu_brand
, " Pro");
1071 strcpy (cpu_brand
, " II");
1074 strcpy (cpu_brand
, " II Xeon");
1077 strcpy (cpu_brand
, " Celeron");
1080 strcpy (cpu_brand
, " III");
1090 strcpy (cpu_brand
, "486/5x86");
1099 strcpy (cpu_brand
, "-K5");
1103 strcpy (cpu_brand
, "-K6");
1106 strcpy (cpu_brand
, "-K6-2");
1109 strcpy (cpu_brand
, "-K6-III");
1119 strcpy (cpu_brand
, " Athlon");
1122 strcpy (cpu_brand
, " Duron");
1128 sprintf (cpu_string
, "%s%s Model %d Stepping %d",
1129 intel_p
? "Pentium" : (amd_p
? "AMD" : "ix86"),
1130 cpu_brand
, cpu_model
, cpuid_eax
& 0xf);
1131 printfi_filtered (31, "%s\n", cpu_string
);
1132 if (((cpuid_edx
& (6 | (0x0d << 23))) != 0)
1133 || ((cpuid_edx
& 1) == 0)
1134 || (amd_p
&& (cpuid_edx
& (3 << 30)) != 0))
1136 puts_filtered ("CPU Features...................");
1137 /* We only list features which might be useful in the DPMI
1139 if ((cpuid_edx
& 1) == 0)
1140 puts_filtered ("No FPU "); /* it's unusual to not have an FPU */
1141 if ((cpuid_edx
& (1 << 1)) != 0)
1142 puts_filtered ("VME ");
1143 if ((cpuid_edx
& (1 << 2)) != 0)
1144 puts_filtered ("DE ");
1145 if ((cpuid_edx
& (1 << 4)) != 0)
1146 puts_filtered ("TSC ");
1147 if ((cpuid_edx
& (1 << 23)) != 0)
1148 puts_filtered ("MMX ");
1149 if ((cpuid_edx
& (1 << 25)) != 0)
1150 puts_filtered ("SSE ");
1151 if ((cpuid_edx
& (1 << 26)) != 0)
1152 puts_filtered ("SSE2 ");
1155 if ((cpuid_edx
& (1 << 31)) != 0)
1156 puts_filtered ("3DNow! ");
1157 if ((cpuid_edx
& (1 << 30)) != 0)
1158 puts_filtered ("3DNow!Ext");
1160 puts_filtered ("\n");
1163 puts_filtered ("\n");
1164 printf_filtered ("DOS Version....................%s %s.%s",
1165 _os_flavor
, u
.release
, u
.version
);
1166 if (true_dos_version
!= advertized_dos_version
)
1167 printf_filtered (" (disguised as v%d.%d)", _osmajor
, _osminor
);
1168 puts_filtered ("\n");
1170 go32_get_windows_version ();
1171 if (windows_major
!= 0xff)
1173 const char *windows_flavor
;
1175 printf_filtered ("Windows Version................%d.%02d (Windows ",
1176 windows_major
, windows_minor
);
1177 switch (windows_major
)
1180 windows_flavor
= "3.X";
1183 switch (windows_minor
)
1186 windows_flavor
= "95, 95A, or 95B";
1189 windows_flavor
= "95B OSR2.1 or 95C OSR2.5";
1192 windows_flavor
= "98 or 98 SE";
1195 windows_flavor
= "ME";
1198 windows_flavor
= "9X";
1203 windows_flavor
= "??";
1206 printf_filtered ("%s)\n", windows_flavor
);
1208 else if (true_dos_version
== 0x532 && advertized_dos_version
== 0x500)
1209 printf_filtered ("Windows Version................Windows NT or Windows 2000\n");
1210 puts_filtered ("\n");
1211 if (dpmi_vendor_available
== 0)
1213 /* The DPMI spec says the vendor string should be ASCIIZ, but
1214 I don't trust the vendors to follow that... */
1215 if (!memchr (&dpmi_vendor_info
[2], 0, 126))
1216 dpmi_vendor_info
[128] = '\0';
1217 printf_filtered ("DPMI Host......................%s v%d.%d (capabilities: %#x)\n",
1218 &dpmi_vendor_info
[2],
1219 (unsigned)dpmi_vendor_info
[0],
1220 (unsigned)dpmi_vendor_info
[1],
1221 ((unsigned)dpmi_flags
& 0x7f));
1223 __dpmi_get_version (&dpmi_version_data
);
1224 printf_filtered ("DPMI Version...................%d.%02d\n",
1225 dpmi_version_data
.major
, dpmi_version_data
.minor
);
1226 printf_filtered ("DPMI Info......................%s-bit DPMI, with%s Virtual Memory support\n",
1227 (dpmi_version_data
.flags
& 1) ? "32" : "16",
1228 (dpmi_version_data
.flags
& 4) ? "" : "out");
1229 printfi_filtered (31, "Interrupts reflected to %s mode\n",
1230 (dpmi_version_data
.flags
& 2) ? "V86" : "Real");
1231 printfi_filtered (31, "Processor type: i%d86\n",
1232 dpmi_version_data
.cpu
);
1233 printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
1234 dpmi_version_data
.master_pic
, dpmi_version_data
.slave_pic
);
1236 /* a_tss is only initialized when the debuggee is first run. */
1237 if (prog_has_started
)
1239 __asm__
__volatile__ ("pushfl ; popl %0" : "=g" (eflags
));
1240 printf_filtered ("Protection.....................Ring %d (in %s), with%s I/O protection\n",
1241 a_tss
.tss_cs
& 3, (a_tss
.tss_cs
& 4) ? "LDT" : "GDT",
1242 (a_tss
.tss_cs
& 3) > ((eflags
>> 12) & 3) ? "" : "out");
1244 puts_filtered ("\n");
1245 __dpmi_get_free_memory_information (&mem_info
);
1246 print_mem (mem_info
.total_number_of_physical_pages
,
1247 "DPMI Total Physical Memory.....", 1);
1248 print_mem (mem_info
.total_number_of_free_pages
,
1249 "DPMI Free Physical Memory......", 1);
1250 print_mem (mem_info
.size_of_paging_file_partition_in_pages
,
1251 "DPMI Swap Space................", 1);
1252 print_mem (mem_info
.linear_address_space_size_in_pages
,
1253 "DPMI Total Linear Address Size.", 1);
1254 print_mem (mem_info
.free_linear_address_space_in_pages
,
1255 "DPMI Free Linear Address Size..", 1);
1256 print_mem (mem_info
.largest_available_free_block_in_bytes
,
1257 "DPMI Largest Free Memory Block.", 0);
1261 __dpmi_int (0x21, ®s
);
1262 print_mem (regs
.x
.bx
<< 4, "Free DOS Memory................", 0);
1264 __dpmi_int (0x21, ®s
);
1265 if ((regs
.x
.flags
& 1) == 0)
1267 static const char *dos_hilo
[] = {
1268 "Low", "", "", "", "High", "", "", "", "High, then Low"
1270 static const char *dos_fit
[] = {
1271 "First", "Best", "Last"
1273 int hilo_idx
= (regs
.x
.ax
>> 4) & 0x0f;
1274 int fit_idx
= regs
.x
.ax
& 0x0f;
1280 printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1281 dos_hilo
[hilo_idx
], dos_fit
[fit_idx
]);
1283 __dpmi_int (0x21, ®s
);
1284 if ((regs
.x
.flags
& 1) != 0)
1286 printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1287 regs
.h
.al
== 0 ? "not " : "");
1292 unsigned short limit0
;
1293 unsigned short base0
;
1294 unsigned char base1
;
1299 unsigned available
:1;
1302 unsigned page_granular
:1;
1303 unsigned char base2
;
1304 } __attribute__ ((packed
));
1307 unsigned short offset0
;
1308 unsigned short selector
;
1309 unsigned param_count
:5;
1314 unsigned short offset1
;
1315 } __attribute__ ((packed
));
1317 /* Read LEN bytes starting at logical address ADDR, and put the result
1318 into DEST. Return 1 if success, zero if not. */
1320 read_memory_region (unsigned long addr
, void *dest
, size_t len
)
1322 unsigned long dos_ds_limit
= __dpmi_get_segment_limit (_dos_ds
);
1325 /* For the low memory, we can simply use _dos_ds. */
1326 if (addr
<= dos_ds_limit
- len
)
1327 dosmemget (addr
, len
, dest
);
1330 /* For memory above 1MB we need to set up a special segment to
1331 be able to access that memory. */
1332 int sel
= __dpmi_allocate_ldt_descriptors (1);
1338 int access_rights
= __dpmi_get_descriptor_access_rights (sel
);
1339 size_t segment_limit
= len
- 1;
1341 /* Make sure the crucial bits in the descriptor access
1342 rights are set correctly. Some DPMI providers might barf
1343 if we set the segment limit to something that is not an
1344 integral multiple of 4KB pages if the granularity bit is
1345 not set to byte-granular, even though the DPMI spec says
1346 it's the host's responsibility to set that bit correctly. */
1347 if (len
> 1024 * 1024)
1349 access_rights
|= 0x8000;
1350 /* Page-granular segments should have the low 12 bits of
1352 segment_limit
|= 0xfff;
1355 access_rights
&= ~0x8000;
1357 if (__dpmi_set_segment_base_address (sel
, addr
) != -1
1358 && __dpmi_set_descriptor_access_rights (sel
, access_rights
) != -1
1359 && __dpmi_set_segment_limit (sel
, segment_limit
) != -1
1360 /* W2K silently fails to set the segment limit, leaving
1361 it at zero; this test avoids the resulting crash. */
1362 && __dpmi_get_segment_limit (sel
) >= segment_limit
)
1363 movedata (sel
, 0, _my_ds (), (unsigned)dest
, len
);
1367 __dpmi_free_ldt_descriptor (sel
);
1373 /* Get a segment descriptor stored at index IDX in the descriptor
1374 table whose base address is TABLE_BASE. Return the descriptor
1375 type, or -1 if failure. */
1377 get_descriptor (unsigned long table_base
, int idx
, void *descr
)
1379 unsigned long addr
= table_base
+ idx
* 8; /* 8 bytes per entry */
1381 if (read_memory_region (addr
, descr
, 8))
1382 return (int)((struct seg_descr
*)descr
)->stype
;
1387 unsigned short limit
__attribute__((packed
));
1388 unsigned long base
__attribute__((packed
));
1391 /* Display a segment descriptor stored at index IDX in a descriptor
1392 table whose type is TYPE and whose base address is BASE_ADDR. If
1393 FORCE is non-zero, display even invalid descriptors. */
1395 display_descriptor (unsigned type
, unsigned long base_addr
, int idx
, int force
)
1397 struct seg_descr descr
;
1398 struct gate_descr gate
;
1400 /* Get the descriptor from the table. */
1401 if (idx
== 0 && type
== 0)
1402 puts_filtered ("0x000: null descriptor\n");
1403 else if (get_descriptor (base_addr
, idx
, &descr
) != -1)
1405 /* For each type of descriptor table, this has a bit set if the
1406 corresponding type of selectors is valid in that table. */
1407 static unsigned allowed_descriptors
[] = {
1408 0xffffdafeL
, /* GDT */
1409 0x0000c0e0L
, /* IDT */
1410 0xffffdafaL
/* LDT */
1413 /* If the program hasn't started yet, assume the debuggee will
1414 have the same CPL as the debugger. */
1415 int cpl
= prog_has_started
? (a_tss
.tss_cs
& 3) : _my_cs () & 3;
1416 unsigned long limit
= (descr
.limit1
<< 16) | descr
.limit0
;
1419 && (allowed_descriptors
[type
] & (1 << descr
.stype
)) != 0)
1421 printf_filtered ("0x%03x: ",
1423 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1424 if (descr
.page_granular
)
1425 limit
= (limit
<< 12) | 0xfff; /* big segment: low 12 bit set */
1426 if (descr
.stype
== 1 || descr
.stype
== 2 || descr
.stype
== 3
1427 || descr
.stype
== 9 || descr
.stype
== 11
1428 || (descr
.stype
>= 16 && descr
.stype
< 32))
1429 printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1430 descr
.base2
, descr
.base1
, descr
.base0
, limit
);
1432 switch (descr
.stype
)
1436 printf_filtered (" 16-bit TSS (task %sactive)",
1437 descr
.stype
== 3 ? "" : "in");
1440 puts_filtered (" LDT");
1443 memcpy (&gate
, &descr
, sizeof gate
);
1444 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1445 gate
.selector
, gate
.offset1
, gate
.offset0
);
1446 printf_filtered (" 16-bit Call Gate (params=%d)",
1450 printf_filtered ("TSS selector=0x%04x", descr
.base0
);
1451 printfi_filtered (16, "Task Gate");
1455 memcpy (&gate
, &descr
, sizeof gate
);
1456 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1457 gate
.selector
, gate
.offset1
, gate
.offset0
);
1458 printf_filtered (" 16-bit %s Gate",
1459 descr
.stype
== 6 ? "Interrupt" : "Trap");
1463 printf_filtered (" 32-bit TSS (task %sactive)",
1464 descr
.stype
== 3 ? "" : "in");
1467 memcpy (&gate
, &descr
, sizeof gate
);
1468 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1469 gate
.selector
, gate
.offset1
, gate
.offset0
);
1470 printf_filtered (" 32-bit Call Gate (params=%d)",
1475 memcpy (&gate
, &descr
, sizeof gate
);
1476 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1477 gate
.selector
, gate
.offset1
, gate
.offset0
);
1478 printf_filtered (" 32-bit %s Gate",
1479 descr
.stype
== 14 ? "Interrupt" : "Trap");
1481 case 16: /* data segments */
1489 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1490 descr
.bit32
? "32" : "16",
1491 descr
.stype
& 2 ? "Read/Write," : "Read-Only, ",
1492 descr
.stype
& 4 ? "down" : "up",
1493 descr
.stype
& 1 ? "" : ", N.Acc");
1495 case 24: /* code segments */
1503 printf_filtered (" %s-bit Code (%s, %sConf%s)",
1504 descr
.bit32
? "32" : "16",
1505 descr
.stype
& 2 ? "Exec/Read" : "Exec-Only",
1506 descr
.stype
& 4 ? "" : "N.",
1507 descr
.stype
& 1 ? "" : ", N.Acc");
1510 printf_filtered ("Unknown type 0x%02x", descr
.stype
);
1513 puts_filtered ("\n");
1517 printf_filtered ("0x%03x: ",
1519 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1521 puts_filtered ("Segment not present\n");
1523 printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1528 printf_filtered ("0x%03x: Cannot read this descriptor\n", idx
);
1532 go32_sldt (char *arg
, int from_tty
)
1534 struct dtr_reg gdtr
;
1535 unsigned short ldtr
= 0;
1537 struct seg_descr ldt_descr
;
1538 long ldt_entry
= -1L;
1539 int cpl
= (prog_has_started
? a_tss
.tss_cs
: _my_cs ()) & 3;
1543 while (*arg
&& isspace(*arg
))
1548 ldt_entry
= parse_and_eval_long (arg
);
1550 || (ldt_entry
& 4) == 0
1551 || (ldt_entry
& 3) != (cpl
& 3))
1552 error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry
);
1556 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1557 __asm__
__volatile__ ("sldt %0" : "=m" (ldtr
) : /* no inputs */ );
1560 puts_filtered ("There is no LDT.\n");
1561 /* LDT's entry in the GDT must have the type LDT, which is 2. */
1562 else if (get_descriptor (gdtr
.base
, ldt_idx
, &ldt_descr
) != 2)
1563 printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1565 | (ldt_descr
.base1
<< 16)
1566 | (ldt_descr
.base2
<< 24));
1571 | (ldt_descr
.base1
<< 16)
1572 | (ldt_descr
.base2
<< 24);
1573 unsigned limit
= ldt_descr
.limit0
| (ldt_descr
.limit1
<< 16);
1576 if (ldt_descr
.page_granular
)
1577 /* Page-granular segments must have the low 12 bits of their
1579 limit
= (limit
<< 12) | 0xfff;
1580 /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1585 max_entry
= (limit
+ 1) / 8;
1589 if (ldt_entry
> limit
)
1590 error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1591 (unsigned long)ldt_entry
, limit
);
1593 display_descriptor (ldt_descr
.stype
, base
, ldt_entry
/ 8, 1);
1599 for (i
= 0; i
< max_entry
; i
++)
1600 display_descriptor (ldt_descr
.stype
, base
, i
, 0);
1606 go32_sgdt (char *arg
, int from_tty
)
1608 struct dtr_reg gdtr
;
1609 long gdt_entry
= -1L;
1614 while (*arg
&& isspace(*arg
))
1619 gdt_entry
= parse_and_eval_long (arg
);
1620 if (gdt_entry
< 0 || (gdt_entry
& 7) != 0)
1621 error (_("Invalid GDT entry 0x%03lx: not an integral multiple of 8."),
1622 (unsigned long)gdt_entry
);
1626 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1627 max_entry
= (gdtr
.limit
+ 1) / 8;
1631 if (gdt_entry
> gdtr
.limit
)
1632 error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1633 (unsigned long)gdt_entry
, gdtr
.limit
);
1635 display_descriptor (0, gdtr
.base
, gdt_entry
/ 8, 1);
1641 for (i
= 0; i
< max_entry
; i
++)
1642 display_descriptor (0, gdtr
.base
, i
, 0);
1647 go32_sidt (char *arg
, int from_tty
)
1649 struct dtr_reg idtr
;
1650 long idt_entry
= -1L;
1655 while (*arg
&& isspace(*arg
))
1660 idt_entry
= parse_and_eval_long (arg
);
1662 error (_("Invalid (negative) IDT entry %ld."), idt_entry
);
1666 __asm__
__volatile__ ("sidt %0" : "=m" (idtr
) : /* no inputs */ );
1667 max_entry
= (idtr
.limit
+ 1) / 8;
1668 if (max_entry
> 0x100) /* no more than 256 entries */
1673 if (idt_entry
> idtr
.limit
)
1674 error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1675 (unsigned long)idt_entry
, idtr
.limit
);
1677 display_descriptor (1, idtr
.base
, idt_entry
, 1);
1683 for (i
= 0; i
< max_entry
; i
++)
1684 display_descriptor (1, idtr
.base
, i
, 0);
1688 /* Cached linear address of the base of the page directory. For
1689 now, available only under CWSDPMI. Code based on ideas and
1690 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
1691 static unsigned long pdbr
;
1693 static unsigned long
1698 unsigned long taskbase
, cr3
;
1699 struct dtr_reg gdtr
;
1701 if (pdbr
> 0 && pdbr
<= 0xfffff)
1704 /* Get the linear address of GDT and the Task Register. */
1705 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1706 __asm__
__volatile__ ("str %0" : "=m" (taskreg
) : /* no inputs */ );
1708 /* Task Register is a segment selector for the TSS of the current
1709 task. Therefore, it can be used as an index into the GDT to get
1710 at the segment descriptor for the TSS. To get the index, reset
1711 the low 3 bits of the selector (which give the CPL). Add 2 to the
1712 offset to point to the 3 low bytes of the base address. */
1713 offset
= gdtr
.base
+ (taskreg
& 0xfff8) + 2;
1716 /* CWSDPMI's task base is always under the 1MB mark. */
1717 if (offset
> 0xfffff)
1720 _farsetsel (_dos_ds
);
1721 taskbase
= _farnspeekl (offset
) & 0xffffffU
;
1722 taskbase
+= _farnspeekl (offset
+ 2) & 0xff000000U
;
1723 if (taskbase
> 0xfffff)
1726 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1727 offset 1Ch in the TSS. */
1728 cr3
= _farnspeekl (taskbase
+ 0x1c) & ~0xfff;
1731 #if 0 /* not fullly supported yet */
1732 /* The Page Directory is in UMBs. In that case, CWSDPMI puts
1733 the first Page Table right below the Page Directory. Thus,
1734 the first Page Table's entry for its own address and the Page
1735 Directory entry for that Page Table will hold the same
1736 physical address. The loop below searches the entire UMB
1737 range of addresses for such an occurence. */
1738 unsigned long addr
, pte_idx
;
1740 for (addr
= 0xb0000, pte_idx
= 0xb0;
1742 addr
+= 0x1000, pte_idx
++)
1744 if (((_farnspeekl (addr
+ 4 * pte_idx
) & 0xfffff027) ==
1745 (_farnspeekl (addr
+ 0x1000) & 0xfffff027))
1746 && ((_farnspeekl (addr
+ 4 * pte_idx
+ 4) & 0xfffff000) == cr3
))
1748 cr3
= addr
+ 0x1000;
1761 /* Return the N'th Page Directory entry. */
1762 static unsigned long
1765 unsigned long pde
= 0;
1767 if (pdbr
&& n
>= 0 && n
< 1024)
1769 pde
= _farpeekl (_dos_ds
, pdbr
+ 4*n
);
1774 /* Return the N'th entry of the Page Table whose Page Directory entry
1776 static unsigned long
1777 get_pte (unsigned long pde
, int n
)
1779 unsigned long pte
= 0;
1781 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
1782 page tables, for now. */
1783 if ((pde
& 1) && !(pde
& 0x80) && n
>= 0 && n
< 1024)
1785 pde
&= ~0xfff; /* clear non-address bits */
1786 pte
= _farpeekl (_dos_ds
, pde
+ 4*n
);
1791 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
1792 says this is a Page Directory entry. If FORCE is non-zero, display
1793 the entry even if its Present flag is off. OFF is the offset of the
1794 address from the page's base address. */
1796 display_ptable_entry (unsigned long entry
, int is_dir
, int force
, unsigned off
)
1798 if ((entry
& 1) != 0)
1800 printf_filtered ("Base=0x%05lx000", entry
>> 12);
1801 if ((entry
& 0x100) && !is_dir
)
1802 puts_filtered (" Global");
1803 if ((entry
& 0x40) && !is_dir
)
1804 puts_filtered (" Dirty");
1805 printf_filtered (" %sAcc.", (entry
& 0x20) ? "" : "Not-");
1806 printf_filtered (" %sCached", (entry
& 0x10) ? "" : "Not-");
1807 printf_filtered (" Write-%s", (entry
& 8) ? "Thru" : "Back");
1808 printf_filtered (" %s", (entry
& 4) ? "Usr" : "Sup");
1809 printf_filtered (" Read-%s", (entry
& 2) ? "Write" : "Only");
1811 printf_filtered (" +0x%x", off
);
1812 puts_filtered ("\n");
1815 printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1816 is_dir
? " Table" : "", entry
>> 1);
1820 go32_pde (char *arg
, int from_tty
)
1822 long pde_idx
= -1, i
;
1826 while (*arg
&& isspace(*arg
))
1831 pde_idx
= parse_and_eval_long (arg
);
1832 if (pde_idx
< 0 || pde_idx
>= 1024)
1833 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
1839 puts_filtered ("Access to Page Directories is not supported on this system.\n");
1840 else if (pde_idx
>= 0)
1841 display_ptable_entry (get_pde (pde_idx
), 1, 1, 0);
1843 for (i
= 0; i
< 1024; i
++)
1844 display_ptable_entry (get_pde (i
), 1, 0, 0);
1847 /* A helper function to display entries in a Page Table pointed to by
1848 the N'th entry in the Page Directory. If FORCE is non-zero, say
1849 something even if the Page Table is not accessible. */
1851 display_page_table (long n
, int force
)
1853 unsigned long pde
= get_pde (n
);
1859 printf_filtered ("Page Table pointed to by Page Directory entry 0x%lx:\n", n
);
1860 for (i
= 0; i
< 1024; i
++)
1861 display_ptable_entry (get_pte (pde
, i
), 0, 0, 0);
1862 puts_filtered ("\n");
1865 printf_filtered ("Page Table not present; value=0x%lx.\n", pde
>> 1);
1869 go32_pte (char *arg
, int from_tty
)
1871 long pde_idx
= -1L, i
;
1875 while (*arg
&& isspace(*arg
))
1880 pde_idx
= parse_and_eval_long (arg
);
1881 if (pde_idx
< 0 || pde_idx
>= 1024)
1882 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
1888 puts_filtered ("Access to Page Tables is not supported on this system.\n");
1889 else if (pde_idx
>= 0)
1890 display_page_table (pde_idx
, 1);
1892 for (i
= 0; i
< 1024; i
++)
1893 display_page_table (i
, 0);
1897 go32_pte_for_address (char *arg
, int from_tty
)
1899 CORE_ADDR addr
= 0, i
;
1903 while (*arg
&& isspace(*arg
))
1907 addr
= parse_and_eval_address (arg
);
1910 error_no_arg (_("linear address"));
1914 puts_filtered ("Access to Page Tables is not supported on this system.\n");
1917 int pde_idx
= (addr
>> 22) & 0x3ff;
1918 int pte_idx
= (addr
>> 12) & 0x3ff;
1919 unsigned offs
= addr
& 0xfff;
1921 printf_filtered ("Page Table entry for address 0x%llx:\n",
1922 (unsigned long long)addr
);
1923 display_ptable_entry (get_pte (get_pde (pde_idx
), pte_idx
), 0, 1, offs
);
1927 static struct cmd_list_element
*info_dos_cmdlist
= NULL
;
1930 go32_info_dos_command (char *args
, int from_tty
)
1932 help_list (info_dos_cmdlist
, "info dos ", class_info
, gdb_stdout
);
1936 _initialize_go32_nat (void)
1939 add_target (&go32_ops
);
1941 add_prefix_cmd ("dos", class_info
, go32_info_dos_command
, _("\
1942 Print information specific to DJGPP (aka MS-DOS) debugging."),
1943 &info_dos_cmdlist
, "info dos ", 0, &infolist
);
1945 add_cmd ("sysinfo", class_info
, go32_sysinfo
, _("\
1946 Display information about the target system, including CPU, OS, DPMI, etc."),
1948 add_cmd ("ldt", class_info
, go32_sldt
, _("\
1949 Display entries in the LDT (Local Descriptor Table).\n\
1950 Entry number (an expression) as an argument means display only that entry."),
1952 add_cmd ("gdt", class_info
, go32_sgdt
, _("\
1953 Display entries in the GDT (Global Descriptor Table).\n\
1954 Entry number (an expression) as an argument means display only that entry."),
1956 add_cmd ("idt", class_info
, go32_sidt
, _("\
1957 Display entries in the IDT (Interrupt Descriptor Table).\n\
1958 Entry number (an expression) as an argument means display only that entry."),
1960 add_cmd ("pde", class_info
, go32_pde
, _("\
1961 Display entries in the Page Directory.\n\
1962 Entry number (an expression) as an argument means display only that entry."),
1964 add_cmd ("pte", class_info
, go32_pte
, _("\
1965 Display entries in Page Tables.\n\
1966 Entry number (an expression) as an argument means display only entries\n\
1967 from the Page Table pointed to by the specified Page Directory entry."),
1969 add_cmd ("address-pte", class_info
, go32_pte_for_address
, _("\
1970 Display a Page Table entry for a linear address.\n\
1971 The address argument must be a linear address, after adding to\n\
1972 it the base address of the appropriate segment.\n\
1973 The base address of variables and functions in the debuggee's data\n\
1974 or code segment is stored in the variable __djgpp_base_address,\n\
1975 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
1976 For other segments, look up their base address in the output of\n\
1977 the `info dos ldt' command."),
1991 tcsetpgrp (int fd
, pid_t pgid
)
1993 if (isatty (fd
) && pgid
== SOME_PID
)
1995 errno
= pgid
== SOME_PID
? ENOTTY
: ENOSYS
;