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 (struct target_ops
*ops
, char *exec_file
,
188 char *args
, char **env
, int from_tty
);
189 static void go32_mourn_inferior (struct target_ops
*ops
);
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 (struct target_ops
*ops
, 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 (struct target_ops
*ops
, char *args
, int from_tty
)
322 static int resume_is_step
;
323 static int resume_signal
= -1;
326 go32_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
330 resume_is_step
= step
;
332 if (siggnal
!= TARGET_SIGNAL_0
&& siggnal
!= TARGET_SIGNAL_TRAP
)
334 for (i
= 0, resume_signal
= -1;
335 excepn_map
[i
].gdb_sig
!= TARGET_SIGNAL_LAST
; i
++)
336 if (excepn_map
[i
].gdb_sig
== siggnal
)
338 resume_signal
= excepn_map
[i
].djgpp_excepno
;
341 if (resume_signal
== -1)
342 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
343 target_signal_to_name (siggnal
));
347 static char child_cwd
[FILENAME_MAX
];
350 go32_wait (ptid_t ptid
, struct target_waitstatus
*status
)
353 unsigned char saved_opcode
;
354 unsigned long INT3_addr
= 0;
355 int stepping_over_INT
= 0;
357 a_tss
.tss_eflags
&= 0xfeff; /* reset the single-step flag (TF) */
360 /* If the next instruction is INT xx or INTO, we need to handle
361 them specially. Intel manuals say that these instructions
362 reset the single-step flag (a.k.a. TF). However, it seems
363 that, at least in the DPMI environment, and at least when
364 stepping over the DPMI interrupt 31h, the problem is having
365 TF set at all when INT 31h is executed: the debuggee either
366 crashes (and takes the system with it) or is killed by a
369 So we need to emulate single-step mode: we put an INT3 opcode
370 right after the INT xx instruction, let the debuggee run
371 until it hits INT3 and stops, then restore the original
372 instruction which we overwrote with the INT3 opcode, and back
373 up the debuggee's EIP to that instruction. */
374 read_child (a_tss
.tss_eip
, &saved_opcode
, 1);
375 if (saved_opcode
== 0xCD || saved_opcode
== 0xCE)
377 unsigned char INT3_opcode
= 0xCC;
380 = saved_opcode
== 0xCD ? a_tss
.tss_eip
+ 2 : a_tss
.tss_eip
+ 1;
381 stepping_over_INT
= 1;
382 read_child (INT3_addr
, &saved_opcode
, 1);
383 write_child (INT3_addr
, &INT3_opcode
, 1);
386 a_tss
.tss_eflags
|= 0x0100; /* normal instruction: set TF */
389 /* The special value FFFFh in tss_trap indicates to run_child that
390 tss_irqn holds a signal to be delivered to the debuggee. */
391 if (resume_signal
<= -1)
394 a_tss
.tss_irqn
= 0xff;
398 a_tss
.tss_trap
= 0xffff; /* run_child looks for this */
399 a_tss
.tss_irqn
= resume_signal
;
402 /* The child might change working directory behind our back. The
403 GDB users won't like the side effects of that when they work with
404 relative file names, and GDB might be confused by its current
405 directory not being in sync with the truth. So we always make a
406 point of changing back to where GDB thinks is its cwd, when we
407 return control to the debugger, but restore child's cwd before we
409 /* Initialize child_cwd, before the first call to run_child and not
410 in the initialization, so the child get also the changed directory
411 set with the gdb-command "cd ..." */
413 /* Initialize child's cwd with the current one. */
414 getcwd (child_cwd
, sizeof (child_cwd
));
418 #if __DJGPP_MINOR__ < 3
422 #if __DJGPP_MINOR__ < 3
426 /* Did we step over an INT xx instruction? */
427 if (stepping_over_INT
&& a_tss
.tss_eip
== INT3_addr
+ 1)
429 /* Restore the original opcode. */
430 a_tss
.tss_eip
--; /* EIP points *after* the INT3 instruction */
431 write_child (a_tss
.tss_eip
, &saved_opcode
, 1);
432 /* Simulate a TRAP exception. */
434 a_tss
.tss_eflags
|= 0x0100;
437 getcwd (child_cwd
, sizeof (child_cwd
)); /* in case it has changed */
438 chdir (current_directory
);
440 if (a_tss
.tss_irqn
== 0x21)
442 status
->kind
= TARGET_WAITKIND_EXITED
;
443 status
->value
.integer
= a_tss
.tss_eax
& 0xff;
447 status
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
448 status
->kind
= TARGET_WAITKIND_STOPPED
;
449 for (i
= 0; sig_map
[i
].go32_sig
!= -1; i
++)
451 if (a_tss
.tss_irqn
== sig_map
[i
].go32_sig
)
453 #if __DJGPP_MINOR__ < 3
454 if ((status
->value
.sig
= sig_map
[i
].gdb_sig
) !=
456 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
458 status
->value
.sig
= sig_map
[i
].gdb_sig
;
464 return pid_to_ptid (SOME_PID
);
468 fetch_register (struct regcache
*regcache
, int regno
)
470 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
471 if (regno
< gdbarch_fp0_regnum (gdbarch
))
472 regcache_raw_supply (regcache
, regno
,
473 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
474 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
, regno
))
475 i387_supply_fsave (regcache
, regno
, &npx
);
477 internal_error (__FILE__
, __LINE__
,
478 _("Invalid register no. %d in fetch_register."), regno
);
482 go32_fetch_registers (struct regcache
*regcache
, int regno
)
485 fetch_register (regcache
, regno
);
489 regno
< gdbarch_fp0_regnum (get_regcache_arch (regcache
));
491 fetch_register (regcache
, regno
);
492 i387_supply_fsave (regcache
, -1, &npx
);
497 store_register (const struct regcache
*regcache
, int regno
)
499 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
500 if (regno
< gdbarch_fp0_regnum (gdbarch
))
501 regcache_raw_collect (regcache
, regno
,
502 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
503 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
, regno
))
504 i387_collect_fsave (regcache
, regno
, &npx
);
506 internal_error (__FILE__
, __LINE__
,
507 _("Invalid register no. %d in store_register."), regno
);
511 go32_store_registers (struct regcache
*regcache
, int regno
)
516 store_register (regcache
, regno
);
519 for (r
= 0; r
< gdbarch_fp0_regnum (get_regcache_arch (regcache
)); r
++)
520 store_register (regcache
, r
);
521 i387_collect_fsave (regcache
, -1, &npx
);
526 go32_prepare_to_store (struct regcache
*regcache
)
531 go32_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
,
532 struct mem_attrib
*attrib
, struct target_ops
*target
)
536 if (write_child (memaddr
, myaddr
, len
))
547 if (read_child (memaddr
, myaddr
, len
))
558 static cmdline_t child_cmd
; /* parsed child's command line kept here */
561 go32_files_info (struct target_ops
*target
)
563 printf_unfiltered ("You are running a DJGPP V2 program.\n");
567 go32_stop (ptid_t ptid
)
571 ptid
= inferior_ptid
;
572 inferior_ptid
= null_ptid
;
573 delete_thread_silent (ptid
);
574 prog_has_started
= 0;
578 go32_kill_inferior (void)
580 redir_cmdline_delete (&child_cmd
);
583 if (!ptid_equal (inferior_ptid
, null_ptid
))
584 delete_thread_silent (inferior_ptid
);
585 unpush_target (&go32_ops
);
589 go32_create_inferior (char *exec_file
, char *args
, char **env
, int from_tty
)
591 extern char **environ
;
594 char **env_save
= environ
;
597 /* If no exec file handed to us, get it from the exec-file command -- with
598 a good, common error message if none is specified. */
600 exec_file
= get_exec_file (1);
602 if (prog_has_started
)
604 go32_stop (inferior_ptid
);
605 go32_kill_inferior ();
610 /* Initialize child's cwd as empty to be initialized when starting
614 /* Init command line storage. */
615 if (redir_debug_init (&child_cmd
) == -1)
616 internal_error (__FILE__
, __LINE__
,
617 _("Cannot allocate redirection storage: not enough memory.\n"));
619 /* Parse the command line and create redirections. */
620 if (strpbrk (args
, "<>"))
622 if (redir_cmdline_parse (args
, &child_cmd
) == 0)
623 args
= child_cmd
.command
;
625 error (_("Syntax error in command line."));
628 child_cmd
.command
= xstrdup (args
);
630 cmdlen
= strlen (args
);
631 /* v2loadimage passes command lines via DOS memory, so it cannot
632 possibly handle commands longer than 1MB. */
633 if (cmdlen
> 1024*1024)
634 error (_("Command line too long."));
636 cmdline
= xmalloc (cmdlen
+ 4);
637 strcpy (cmdline
+ 1, args
);
638 /* If the command-line length fits into DOS 126-char limits, use the
639 DOS command tail format; otherwise, tell v2loadimage to pass it
640 through a buffer in conventional memory. */
643 cmdline
[0] = strlen (args
);
644 cmdline
[cmdlen
+ 1] = 13;
647 cmdline
[0] = 0xff; /* signal v2loadimage it's a long command */
651 if (v2loadimage (exec_file
, cmdline
, start_state
))
654 printf_unfiltered ("Load failed for image %s\n", exec_file
);
660 edi_init (start_state
);
661 #if __DJGPP_MINOR__ < 3
665 inferior_ptid
= pid_to_ptid (SOME_PID
);
666 add_inferior_silent (SOME_PID
);
668 push_target (&go32_ops
);
670 add_thread_silent (inferior_ptid
);
672 clear_proceed_status ();
673 insert_breakpoints ();
674 prog_has_started
= 1;
678 go32_mourn_inferior (struct target_ops
*ops
)
680 /* We need to make sure all the breakpoint enable bits in the DR7
681 register are reset when the inferior exits. Otherwise, if they
682 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
683 failure to set more watchpoints, and other calamities. It would
684 be nice if GDB itself would take care to remove all breakpoints
685 at all times, but it doesn't, probably under an assumption that
686 the OS cleans up when the debuggee exits. */
687 i386_cleanup_dregs ();
688 go32_kill_inferior ();
689 generic_mourn_inferior ();
698 /* Hardware watchpoint support. */
700 #define D_REGS edi.dr
701 #define CONTROL D_REGS[7]
702 #define STATUS D_REGS[6]
704 /* Pass the address ADDR to the inferior in the I'th debug register.
705 Here we just store the address in D_REGS, the watchpoint will be
706 actually set up when go32_wait runs the debuggee. */
708 go32_set_dr (int i
, CORE_ADDR addr
)
711 internal_error (__FILE__
, __LINE__
,
712 _("Invalid register %d in go32_set_dr.\n"), i
);
716 /* Pass the value VAL to the inferior in the DR7 debug control
717 register. Here we just store the address in D_REGS, the watchpoint
718 will be actually set up when go32_wait runs the debuggee. */
720 go32_set_dr7 (unsigned val
)
725 /* Get the value of the DR6 debug status register from the inferior.
726 Here we just return the value stored in D_REGS, as we've got it
727 from the last go32_wait call. */
734 /* Put the device open on handle FD into either raw or cooked
735 mode, return 1 if it was in raw mode, zero otherwise. */
738 device_mode (int fd
, int raw_p
)
740 int oldmode
, newmode
;
745 __dpmi_int (0x21, ®s
);
746 if (regs
.x
.flags
& 1)
748 newmode
= oldmode
= regs
.x
.dx
;
755 if (oldmode
& 0x80) /* Only for character dev */
759 regs
.x
.dx
= newmode
& 0xff; /* Force upper byte zero, else it fails */
760 __dpmi_int (0x21, ®s
);
761 if (regs
.x
.flags
& 1)
764 return (oldmode
& 0x20) == 0x20;
768 static int inf_mode_valid
= 0;
769 static int inf_terminal_mode
;
771 /* This semaphore is needed because, amazingly enough, GDB calls
772 target.to_terminal_ours more than once after the inferior stops.
773 But we need the information from the first call only, since the
774 second call will always see GDB's own cooked terminal. */
775 static int terminal_is_ours
= 1;
778 go32_terminal_init (void)
780 inf_mode_valid
= 0; /* reinitialize, in case they are restarting child */
781 terminal_is_ours
= 1;
785 go32_terminal_info (char *args
, int from_tty
)
787 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
789 ? "default" : inf_terminal_mode
? "raw" : "cooked");
791 #if __DJGPP_MINOR__ > 2
792 if (child_cmd
.redirection
)
796 for (i
= 0; i
< DBG_HANDLES
; i
++)
798 if (child_cmd
.redirection
[i
]->file_name
)
799 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
800 i
, child_cmd
.redirection
[i
]->file_name
);
801 else if (_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) == -1)
803 ("\tFile handle %d appears to be closed by inferior.\n", i
);
804 /* Mask off the raw/cooked bit when comparing device info words. */
805 else if ((_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) & 0xdf)
806 != (_get_dev_info (i
) & 0xdf))
808 ("\tFile handle %d appears to be redirected by inferior.\n", i
);
815 go32_terminal_inferior (void)
817 /* Redirect standard handles as child wants them. */
819 if (redir_to_child (&child_cmd
) == -1)
821 redir_to_debugger (&child_cmd
);
822 error (_("Cannot redirect standard handles for program: %s."),
823 safe_strerror (errno
));
825 /* set the console device of the inferior to whatever mode
826 (raw or cooked) we found it last time */
827 if (terminal_is_ours
)
830 device_mode (0, inf_terminal_mode
);
831 terminal_is_ours
= 0;
836 go32_terminal_ours (void)
838 /* Switch to cooked mode on the gdb terminal and save the inferior
839 terminal mode to be restored when it is resumed */
840 if (!terminal_is_ours
)
842 inf_terminal_mode
= device_mode (0, 0);
843 if (inf_terminal_mode
!= -1)
846 /* If device_mode returned -1, we don't know what happens with
847 handle 0 anymore, so make the info invalid. */
849 terminal_is_ours
= 1;
851 /* Restore debugger's standard handles. */
853 if (redir_to_debugger (&child_cmd
) == -1)
855 redir_to_child (&child_cmd
);
856 error (_("Cannot redirect standard handles for debugger: %s."),
857 safe_strerror (errno
));
863 go32_thread_alive (ptid_t ptid
)
869 go32_pid_to_str (ptid_t ptid
)
872 xsnprintf (buf
, sizeof buf
, "Thread <main>");
879 go32_ops
.to_shortname
= "djgpp";
880 go32_ops
.to_longname
= "djgpp target process";
882 "Program loaded by djgpp, when gdb is used as an external debugger";
883 go32_ops
.to_open
= go32_open
;
884 go32_ops
.to_close
= go32_close
;
885 go32_ops
.to_attach
= go32_attach
;
886 go32_ops
.to_detach
= go32_detach
;
887 go32_ops
.to_resume
= go32_resume
;
888 go32_ops
.to_wait
= go32_wait
;
889 go32_ops
.to_fetch_registers
= go32_fetch_registers
;
890 go32_ops
.to_store_registers
= go32_store_registers
;
891 go32_ops
.to_prepare_to_store
= go32_prepare_to_store
;
892 go32_ops
.deprecated_xfer_memory
= go32_xfer_memory
;
893 go32_ops
.to_files_info
= go32_files_info
;
894 go32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
895 go32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
896 go32_ops
.to_terminal_init
= go32_terminal_init
;
897 go32_ops
.to_terminal_inferior
= go32_terminal_inferior
;
898 go32_ops
.to_terminal_ours_for_output
= go32_terminal_ours
;
899 go32_ops
.to_terminal_ours
= go32_terminal_ours
;
900 go32_ops
.to_terminal_info
= go32_terminal_info
;
901 go32_ops
.to_kill
= go32_kill_inferior
;
902 go32_ops
.to_create_inferior
= go32_create_inferior
;
903 go32_ops
.to_mourn_inferior
= go32_mourn_inferior
;
904 go32_ops
.to_can_run
= go32_can_run
;
905 go32_ops
.to_stop
= go32_stop
;
906 go32_ops
.to_thread_alive
= go32_thread_alive
;
907 go32_ops
.to_pid_to_str
= go32_pid_to_str
;
908 go32_ops
.to_stratum
= process_stratum
;
909 go32_ops
.to_has_all_memory
= 1;
910 go32_ops
.to_has_memory
= 1;
911 go32_ops
.to_has_stack
= 1;
912 go32_ops
.to_has_registers
= 1;
913 go32_ops
.to_has_execution
= 1;
914 go32_ops
.to_magic
= OPS_MAGIC
;
916 /* Initialize child's cwd as empty to be initialized when starting
920 /* Initialize child's command line storage. */
921 if (redir_debug_init (&child_cmd
) == -1)
922 internal_error (__FILE__
, __LINE__
,
923 _("Cannot allocate redirection storage: not enough memory.\n"));
925 /* We are always processing GCC-compiled programs. */
926 processing_gcc_compilation
= 2;
928 /* Override the default name of the GDB init file. */
929 strcpy (gdbinit
, "gdb.ini");
932 unsigned short windows_major
, windows_minor
;
934 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */
936 go32_get_windows_version(void)
941 __dpmi_int(0x2f, &r
);
942 if (r
.h
.al
> 2 && r
.h
.al
!= 0x80 && r
.h
.al
!= 0xff
943 && (r
.h
.al
> 3 || r
.h
.ah
> 0))
945 windows_major
= r
.h
.al
;
946 windows_minor
= r
.h
.ah
;
949 windows_major
= 0xff; /* meaning no Windows */
952 /* A subroutine of go32_sysinfo to display memory info. */
954 print_mem (unsigned long datum
, const char *header
, int in_pages_p
)
956 if (datum
!= 0xffffffffUL
)
960 puts_filtered (header
);
963 printf_filtered ("%lu KB", datum
>> 10);
964 if (datum
> 1024 * 1024)
965 printf_filtered (" (%lu MB)", datum
>> 20);
968 printf_filtered ("%lu Bytes", datum
);
969 puts_filtered ("\n");
973 /* Display assorted information about the underlying OS. */
975 go32_sysinfo (char *arg
, int from_tty
)
978 char cpuid_vendor
[13];
979 unsigned cpuid_max
= 0, cpuid_eax
, cpuid_ebx
, cpuid_ecx
, cpuid_edx
;
980 unsigned true_dos_version
= _get_dos_version (1);
981 unsigned advertized_dos_version
= ((unsigned int)_osmajor
<< 8) | _osminor
;
983 char dpmi_vendor_info
[129];
984 int dpmi_vendor_available
=
985 __dpmi_get_capabilities (&dpmi_flags
, dpmi_vendor_info
);
986 __dpmi_version_ret dpmi_version_data
;
988 __dpmi_free_mem_info mem_info
;
991 cpuid_vendor
[0] = '\0';
993 strcpy (u
.machine
, "Unknown x86");
994 else if (u
.machine
[0] == 'i' && u
.machine
[1] > 4)
996 /* CPUID with EAX = 0 returns the Vendor ID. */
997 __asm__
__volatile__ ("xorl %%ebx, %%ebx;"
1006 : "=m" (cpuid_vendor
[0]),
1007 "=m" (cpuid_vendor
[4]),
1008 "=m" (cpuid_vendor
[8]),
1011 : "%eax", "%ebx", "%ecx", "%edx");
1012 cpuid_vendor
[12] = '\0';
1015 printf_filtered ("CPU Type.......................%s", u
.machine
);
1016 if (cpuid_vendor
[0])
1017 printf_filtered (" (%s)", cpuid_vendor
);
1018 puts_filtered ("\n");
1020 /* CPUID with EAX = 1 returns processor signature and features. */
1023 static char *brand_name
[] = {
1031 char cpu_string
[80];
1034 int intel_p
= strcmp (cpuid_vendor
, "GenuineIntel") == 0;
1035 int amd_p
= strcmp (cpuid_vendor
, "AuthenticAMD") == 0;
1036 unsigned cpu_family
, cpu_model
;
1038 __asm__
__volatile__ ("movl $1, %%eax;"
1045 brand_idx
= cpuid_ebx
& 0xff;
1046 cpu_family
= (cpuid_eax
>> 8) & 0xf;
1047 cpu_model
= (cpuid_eax
>> 4) & 0xf;
1048 cpu_brand
[0] = '\0';
1052 && brand_idx
< sizeof(brand_name
)/sizeof(brand_name
[0])
1053 && *brand_name
[brand_idx
])
1054 strcpy (cpu_brand
, brand_name
[brand_idx
]);
1055 else if (cpu_family
== 5)
1057 if (((cpuid_eax
>> 12) & 3) == 0 && cpu_model
== 4)
1058 strcpy (cpu_brand
, " MMX");
1059 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 1)
1060 strcpy (cpu_brand
, " OverDrive");
1061 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 2)
1062 strcpy (cpu_brand
, " Dual");
1064 else if (cpu_family
== 6 && cpu_model
< 8)
1069 strcpy (cpu_brand
, " Pro");
1072 strcpy (cpu_brand
, " II");
1075 strcpy (cpu_brand
, " II Xeon");
1078 strcpy (cpu_brand
, " Celeron");
1081 strcpy (cpu_brand
, " III");
1091 strcpy (cpu_brand
, "486/5x86");
1100 strcpy (cpu_brand
, "-K5");
1104 strcpy (cpu_brand
, "-K6");
1107 strcpy (cpu_brand
, "-K6-2");
1110 strcpy (cpu_brand
, "-K6-III");
1120 strcpy (cpu_brand
, " Athlon");
1123 strcpy (cpu_brand
, " Duron");
1129 sprintf (cpu_string
, "%s%s Model %d Stepping %d",
1130 intel_p
? "Pentium" : (amd_p
? "AMD" : "ix86"),
1131 cpu_brand
, cpu_model
, cpuid_eax
& 0xf);
1132 printfi_filtered (31, "%s\n", cpu_string
);
1133 if (((cpuid_edx
& (6 | (0x0d << 23))) != 0)
1134 || ((cpuid_edx
& 1) == 0)
1135 || (amd_p
&& (cpuid_edx
& (3 << 30)) != 0))
1137 puts_filtered ("CPU Features...................");
1138 /* We only list features which might be useful in the DPMI
1140 if ((cpuid_edx
& 1) == 0)
1141 puts_filtered ("No FPU "); /* it's unusual to not have an FPU */
1142 if ((cpuid_edx
& (1 << 1)) != 0)
1143 puts_filtered ("VME ");
1144 if ((cpuid_edx
& (1 << 2)) != 0)
1145 puts_filtered ("DE ");
1146 if ((cpuid_edx
& (1 << 4)) != 0)
1147 puts_filtered ("TSC ");
1148 if ((cpuid_edx
& (1 << 23)) != 0)
1149 puts_filtered ("MMX ");
1150 if ((cpuid_edx
& (1 << 25)) != 0)
1151 puts_filtered ("SSE ");
1152 if ((cpuid_edx
& (1 << 26)) != 0)
1153 puts_filtered ("SSE2 ");
1156 if ((cpuid_edx
& (1 << 31)) != 0)
1157 puts_filtered ("3DNow! ");
1158 if ((cpuid_edx
& (1 << 30)) != 0)
1159 puts_filtered ("3DNow!Ext");
1161 puts_filtered ("\n");
1164 puts_filtered ("\n");
1165 printf_filtered ("DOS Version....................%s %s.%s",
1166 _os_flavor
, u
.release
, u
.version
);
1167 if (true_dos_version
!= advertized_dos_version
)
1168 printf_filtered (" (disguised as v%d.%d)", _osmajor
, _osminor
);
1169 puts_filtered ("\n");
1171 go32_get_windows_version ();
1172 if (windows_major
!= 0xff)
1174 const char *windows_flavor
;
1176 printf_filtered ("Windows Version................%d.%02d (Windows ",
1177 windows_major
, windows_minor
);
1178 switch (windows_major
)
1181 windows_flavor
= "3.X";
1184 switch (windows_minor
)
1187 windows_flavor
= "95, 95A, or 95B";
1190 windows_flavor
= "95B OSR2.1 or 95C OSR2.5";
1193 windows_flavor
= "98 or 98 SE";
1196 windows_flavor
= "ME";
1199 windows_flavor
= "9X";
1204 windows_flavor
= "??";
1207 printf_filtered ("%s)\n", windows_flavor
);
1209 else if (true_dos_version
== 0x532 && advertized_dos_version
== 0x500)
1210 printf_filtered ("Windows Version................Windows NT or Windows 2000\n");
1211 puts_filtered ("\n");
1212 if (dpmi_vendor_available
== 0)
1214 /* The DPMI spec says the vendor string should be ASCIIZ, but
1215 I don't trust the vendors to follow that... */
1216 if (!memchr (&dpmi_vendor_info
[2], 0, 126))
1217 dpmi_vendor_info
[128] = '\0';
1218 printf_filtered ("DPMI Host......................%s v%d.%d (capabilities: %#x)\n",
1219 &dpmi_vendor_info
[2],
1220 (unsigned)dpmi_vendor_info
[0],
1221 (unsigned)dpmi_vendor_info
[1],
1222 ((unsigned)dpmi_flags
& 0x7f));
1224 __dpmi_get_version (&dpmi_version_data
);
1225 printf_filtered ("DPMI Version...................%d.%02d\n",
1226 dpmi_version_data
.major
, dpmi_version_data
.minor
);
1227 printf_filtered ("DPMI Info......................%s-bit DPMI, with%s Virtual Memory support\n",
1228 (dpmi_version_data
.flags
& 1) ? "32" : "16",
1229 (dpmi_version_data
.flags
& 4) ? "" : "out");
1230 printfi_filtered (31, "Interrupts reflected to %s mode\n",
1231 (dpmi_version_data
.flags
& 2) ? "V86" : "Real");
1232 printfi_filtered (31, "Processor type: i%d86\n",
1233 dpmi_version_data
.cpu
);
1234 printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
1235 dpmi_version_data
.master_pic
, dpmi_version_data
.slave_pic
);
1237 /* a_tss is only initialized when the debuggee is first run. */
1238 if (prog_has_started
)
1240 __asm__
__volatile__ ("pushfl ; popl %0" : "=g" (eflags
));
1241 printf_filtered ("Protection.....................Ring %d (in %s), with%s I/O protection\n",
1242 a_tss
.tss_cs
& 3, (a_tss
.tss_cs
& 4) ? "LDT" : "GDT",
1243 (a_tss
.tss_cs
& 3) > ((eflags
>> 12) & 3) ? "" : "out");
1245 puts_filtered ("\n");
1246 __dpmi_get_free_memory_information (&mem_info
);
1247 print_mem (mem_info
.total_number_of_physical_pages
,
1248 "DPMI Total Physical Memory.....", 1);
1249 print_mem (mem_info
.total_number_of_free_pages
,
1250 "DPMI Free Physical Memory......", 1);
1251 print_mem (mem_info
.size_of_paging_file_partition_in_pages
,
1252 "DPMI Swap Space................", 1);
1253 print_mem (mem_info
.linear_address_space_size_in_pages
,
1254 "DPMI Total Linear Address Size.", 1);
1255 print_mem (mem_info
.free_linear_address_space_in_pages
,
1256 "DPMI Free Linear Address Size..", 1);
1257 print_mem (mem_info
.largest_available_free_block_in_bytes
,
1258 "DPMI Largest Free Memory Block.", 0);
1262 __dpmi_int (0x21, ®s
);
1263 print_mem (regs
.x
.bx
<< 4, "Free DOS Memory................", 0);
1265 __dpmi_int (0x21, ®s
);
1266 if ((regs
.x
.flags
& 1) == 0)
1268 static const char *dos_hilo
[] = {
1269 "Low", "", "", "", "High", "", "", "", "High, then Low"
1271 static const char *dos_fit
[] = {
1272 "First", "Best", "Last"
1274 int hilo_idx
= (regs
.x
.ax
>> 4) & 0x0f;
1275 int fit_idx
= regs
.x
.ax
& 0x0f;
1281 printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1282 dos_hilo
[hilo_idx
], dos_fit
[fit_idx
]);
1284 __dpmi_int (0x21, ®s
);
1285 if ((regs
.x
.flags
& 1) != 0)
1287 printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1288 regs
.h
.al
== 0 ? "not " : "");
1293 unsigned short limit0
;
1294 unsigned short base0
;
1295 unsigned char base1
;
1300 unsigned available
:1;
1303 unsigned page_granular
:1;
1304 unsigned char base2
;
1305 } __attribute__ ((packed
));
1308 unsigned short offset0
;
1309 unsigned short selector
;
1310 unsigned param_count
:5;
1315 unsigned short offset1
;
1316 } __attribute__ ((packed
));
1318 /* Read LEN bytes starting at logical address ADDR, and put the result
1319 into DEST. Return 1 if success, zero if not. */
1321 read_memory_region (unsigned long addr
, void *dest
, size_t len
)
1323 unsigned long dos_ds_limit
= __dpmi_get_segment_limit (_dos_ds
);
1326 /* For the low memory, we can simply use _dos_ds. */
1327 if (addr
<= dos_ds_limit
- len
)
1328 dosmemget (addr
, len
, dest
);
1331 /* For memory above 1MB we need to set up a special segment to
1332 be able to access that memory. */
1333 int sel
= __dpmi_allocate_ldt_descriptors (1);
1339 int access_rights
= __dpmi_get_descriptor_access_rights (sel
);
1340 size_t segment_limit
= len
- 1;
1342 /* Make sure the crucial bits in the descriptor access
1343 rights are set correctly. Some DPMI providers might barf
1344 if we set the segment limit to something that is not an
1345 integral multiple of 4KB pages if the granularity bit is
1346 not set to byte-granular, even though the DPMI spec says
1347 it's the host's responsibility to set that bit correctly. */
1348 if (len
> 1024 * 1024)
1350 access_rights
|= 0x8000;
1351 /* Page-granular segments should have the low 12 bits of
1353 segment_limit
|= 0xfff;
1356 access_rights
&= ~0x8000;
1358 if (__dpmi_set_segment_base_address (sel
, addr
) != -1
1359 && __dpmi_set_descriptor_access_rights (sel
, access_rights
) != -1
1360 && __dpmi_set_segment_limit (sel
, segment_limit
) != -1
1361 /* W2K silently fails to set the segment limit, leaving
1362 it at zero; this test avoids the resulting crash. */
1363 && __dpmi_get_segment_limit (sel
) >= segment_limit
)
1364 movedata (sel
, 0, _my_ds (), (unsigned)dest
, len
);
1368 __dpmi_free_ldt_descriptor (sel
);
1374 /* Get a segment descriptor stored at index IDX in the descriptor
1375 table whose base address is TABLE_BASE. Return the descriptor
1376 type, or -1 if failure. */
1378 get_descriptor (unsigned long table_base
, int idx
, void *descr
)
1380 unsigned long addr
= table_base
+ idx
* 8; /* 8 bytes per entry */
1382 if (read_memory_region (addr
, descr
, 8))
1383 return (int)((struct seg_descr
*)descr
)->stype
;
1388 unsigned short limit
__attribute__((packed
));
1389 unsigned long base
__attribute__((packed
));
1392 /* Display a segment descriptor stored at index IDX in a descriptor
1393 table whose type is TYPE and whose base address is BASE_ADDR. If
1394 FORCE is non-zero, display even invalid descriptors. */
1396 display_descriptor (unsigned type
, unsigned long base_addr
, int idx
, int force
)
1398 struct seg_descr descr
;
1399 struct gate_descr gate
;
1401 /* Get the descriptor from the table. */
1402 if (idx
== 0 && type
== 0)
1403 puts_filtered ("0x000: null descriptor\n");
1404 else if (get_descriptor (base_addr
, idx
, &descr
) != -1)
1406 /* For each type of descriptor table, this has a bit set if the
1407 corresponding type of selectors is valid in that table. */
1408 static unsigned allowed_descriptors
[] = {
1409 0xffffdafeL
, /* GDT */
1410 0x0000c0e0L
, /* IDT */
1411 0xffffdafaL
/* LDT */
1414 /* If the program hasn't started yet, assume the debuggee will
1415 have the same CPL as the debugger. */
1416 int cpl
= prog_has_started
? (a_tss
.tss_cs
& 3) : _my_cs () & 3;
1417 unsigned long limit
= (descr
.limit1
<< 16) | descr
.limit0
;
1420 && (allowed_descriptors
[type
] & (1 << descr
.stype
)) != 0)
1422 printf_filtered ("0x%03x: ",
1424 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1425 if (descr
.page_granular
)
1426 limit
= (limit
<< 12) | 0xfff; /* big segment: low 12 bit set */
1427 if (descr
.stype
== 1 || descr
.stype
== 2 || descr
.stype
== 3
1428 || descr
.stype
== 9 || descr
.stype
== 11
1429 || (descr
.stype
>= 16 && descr
.stype
< 32))
1430 printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1431 descr
.base2
, descr
.base1
, descr
.base0
, limit
);
1433 switch (descr
.stype
)
1437 printf_filtered (" 16-bit TSS (task %sactive)",
1438 descr
.stype
== 3 ? "" : "in");
1441 puts_filtered (" LDT");
1444 memcpy (&gate
, &descr
, sizeof gate
);
1445 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1446 gate
.selector
, gate
.offset1
, gate
.offset0
);
1447 printf_filtered (" 16-bit Call Gate (params=%d)",
1451 printf_filtered ("TSS selector=0x%04x", descr
.base0
);
1452 printfi_filtered (16, "Task Gate");
1456 memcpy (&gate
, &descr
, sizeof gate
);
1457 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1458 gate
.selector
, gate
.offset1
, gate
.offset0
);
1459 printf_filtered (" 16-bit %s Gate",
1460 descr
.stype
== 6 ? "Interrupt" : "Trap");
1464 printf_filtered (" 32-bit TSS (task %sactive)",
1465 descr
.stype
== 3 ? "" : "in");
1468 memcpy (&gate
, &descr
, sizeof gate
);
1469 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1470 gate
.selector
, gate
.offset1
, gate
.offset0
);
1471 printf_filtered (" 32-bit Call Gate (params=%d)",
1476 memcpy (&gate
, &descr
, sizeof gate
);
1477 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1478 gate
.selector
, gate
.offset1
, gate
.offset0
);
1479 printf_filtered (" 32-bit %s Gate",
1480 descr
.stype
== 14 ? "Interrupt" : "Trap");
1482 case 16: /* data segments */
1490 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1491 descr
.bit32
? "32" : "16",
1492 descr
.stype
& 2 ? "Read/Write," : "Read-Only, ",
1493 descr
.stype
& 4 ? "down" : "up",
1494 descr
.stype
& 1 ? "" : ", N.Acc");
1496 case 24: /* code segments */
1504 printf_filtered (" %s-bit Code (%s, %sConf%s)",
1505 descr
.bit32
? "32" : "16",
1506 descr
.stype
& 2 ? "Exec/Read" : "Exec-Only",
1507 descr
.stype
& 4 ? "" : "N.",
1508 descr
.stype
& 1 ? "" : ", N.Acc");
1511 printf_filtered ("Unknown type 0x%02x", descr
.stype
);
1514 puts_filtered ("\n");
1518 printf_filtered ("0x%03x: ",
1520 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1522 puts_filtered ("Segment not present\n");
1524 printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1529 printf_filtered ("0x%03x: Cannot read this descriptor\n", idx
);
1533 go32_sldt (char *arg
, int from_tty
)
1535 struct dtr_reg gdtr
;
1536 unsigned short ldtr
= 0;
1538 struct seg_descr ldt_descr
;
1539 long ldt_entry
= -1L;
1540 int cpl
= (prog_has_started
? a_tss
.tss_cs
: _my_cs ()) & 3;
1544 while (*arg
&& isspace(*arg
))
1549 ldt_entry
= parse_and_eval_long (arg
);
1551 || (ldt_entry
& 4) == 0
1552 || (ldt_entry
& 3) != (cpl
& 3))
1553 error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry
);
1557 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1558 __asm__
__volatile__ ("sldt %0" : "=m" (ldtr
) : /* no inputs */ );
1561 puts_filtered ("There is no LDT.\n");
1562 /* LDT's entry in the GDT must have the type LDT, which is 2. */
1563 else if (get_descriptor (gdtr
.base
, ldt_idx
, &ldt_descr
) != 2)
1564 printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1566 | (ldt_descr
.base1
<< 16)
1567 | (ldt_descr
.base2
<< 24));
1572 | (ldt_descr
.base1
<< 16)
1573 | (ldt_descr
.base2
<< 24);
1574 unsigned limit
= ldt_descr
.limit0
| (ldt_descr
.limit1
<< 16);
1577 if (ldt_descr
.page_granular
)
1578 /* Page-granular segments must have the low 12 bits of their
1580 limit
= (limit
<< 12) | 0xfff;
1581 /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1586 max_entry
= (limit
+ 1) / 8;
1590 if (ldt_entry
> limit
)
1591 error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1592 (unsigned long)ldt_entry
, limit
);
1594 display_descriptor (ldt_descr
.stype
, base
, ldt_entry
/ 8, 1);
1600 for (i
= 0; i
< max_entry
; i
++)
1601 display_descriptor (ldt_descr
.stype
, base
, i
, 0);
1607 go32_sgdt (char *arg
, int from_tty
)
1609 struct dtr_reg gdtr
;
1610 long gdt_entry
= -1L;
1615 while (*arg
&& isspace(*arg
))
1620 gdt_entry
= parse_and_eval_long (arg
);
1621 if (gdt_entry
< 0 || (gdt_entry
& 7) != 0)
1622 error (_("Invalid GDT entry 0x%03lx: not an integral multiple of 8."),
1623 (unsigned long)gdt_entry
);
1627 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1628 max_entry
= (gdtr
.limit
+ 1) / 8;
1632 if (gdt_entry
> gdtr
.limit
)
1633 error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1634 (unsigned long)gdt_entry
, gdtr
.limit
);
1636 display_descriptor (0, gdtr
.base
, gdt_entry
/ 8, 1);
1642 for (i
= 0; i
< max_entry
; i
++)
1643 display_descriptor (0, gdtr
.base
, i
, 0);
1648 go32_sidt (char *arg
, int from_tty
)
1650 struct dtr_reg idtr
;
1651 long idt_entry
= -1L;
1656 while (*arg
&& isspace(*arg
))
1661 idt_entry
= parse_and_eval_long (arg
);
1663 error (_("Invalid (negative) IDT entry %ld."), idt_entry
);
1667 __asm__
__volatile__ ("sidt %0" : "=m" (idtr
) : /* no inputs */ );
1668 max_entry
= (idtr
.limit
+ 1) / 8;
1669 if (max_entry
> 0x100) /* no more than 256 entries */
1674 if (idt_entry
> idtr
.limit
)
1675 error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1676 (unsigned long)idt_entry
, idtr
.limit
);
1678 display_descriptor (1, idtr
.base
, idt_entry
, 1);
1684 for (i
= 0; i
< max_entry
; i
++)
1685 display_descriptor (1, idtr
.base
, i
, 0);
1689 /* Cached linear address of the base of the page directory. For
1690 now, available only under CWSDPMI. Code based on ideas and
1691 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
1692 static unsigned long pdbr
;
1694 static unsigned long
1699 unsigned long taskbase
, cr3
;
1700 struct dtr_reg gdtr
;
1702 if (pdbr
> 0 && pdbr
<= 0xfffff)
1705 /* Get the linear address of GDT and the Task Register. */
1706 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1707 __asm__
__volatile__ ("str %0" : "=m" (taskreg
) : /* no inputs */ );
1709 /* Task Register is a segment selector for the TSS of the current
1710 task. Therefore, it can be used as an index into the GDT to get
1711 at the segment descriptor for the TSS. To get the index, reset
1712 the low 3 bits of the selector (which give the CPL). Add 2 to the
1713 offset to point to the 3 low bytes of the base address. */
1714 offset
= gdtr
.base
+ (taskreg
& 0xfff8) + 2;
1717 /* CWSDPMI's task base is always under the 1MB mark. */
1718 if (offset
> 0xfffff)
1721 _farsetsel (_dos_ds
);
1722 taskbase
= _farnspeekl (offset
) & 0xffffffU
;
1723 taskbase
+= _farnspeekl (offset
+ 2) & 0xff000000U
;
1724 if (taskbase
> 0xfffff)
1727 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1728 offset 1Ch in the TSS. */
1729 cr3
= _farnspeekl (taskbase
+ 0x1c) & ~0xfff;
1732 #if 0 /* not fullly supported yet */
1733 /* The Page Directory is in UMBs. In that case, CWSDPMI puts
1734 the first Page Table right below the Page Directory. Thus,
1735 the first Page Table's entry for its own address and the Page
1736 Directory entry for that Page Table will hold the same
1737 physical address. The loop below searches the entire UMB
1738 range of addresses for such an occurence. */
1739 unsigned long addr
, pte_idx
;
1741 for (addr
= 0xb0000, pte_idx
= 0xb0;
1743 addr
+= 0x1000, pte_idx
++)
1745 if (((_farnspeekl (addr
+ 4 * pte_idx
) & 0xfffff027) ==
1746 (_farnspeekl (addr
+ 0x1000) & 0xfffff027))
1747 && ((_farnspeekl (addr
+ 4 * pte_idx
+ 4) & 0xfffff000) == cr3
))
1749 cr3
= addr
+ 0x1000;
1762 /* Return the N'th Page Directory entry. */
1763 static unsigned long
1766 unsigned long pde
= 0;
1768 if (pdbr
&& n
>= 0 && n
< 1024)
1770 pde
= _farpeekl (_dos_ds
, pdbr
+ 4*n
);
1775 /* Return the N'th entry of the Page Table whose Page Directory entry
1777 static unsigned long
1778 get_pte (unsigned long pde
, int n
)
1780 unsigned long pte
= 0;
1782 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
1783 page tables, for now. */
1784 if ((pde
& 1) && !(pde
& 0x80) && n
>= 0 && n
< 1024)
1786 pde
&= ~0xfff; /* clear non-address bits */
1787 pte
= _farpeekl (_dos_ds
, pde
+ 4*n
);
1792 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
1793 says this is a Page Directory entry. If FORCE is non-zero, display
1794 the entry even if its Present flag is off. OFF is the offset of the
1795 address from the page's base address. */
1797 display_ptable_entry (unsigned long entry
, int is_dir
, int force
, unsigned off
)
1799 if ((entry
& 1) != 0)
1801 printf_filtered ("Base=0x%05lx000", entry
>> 12);
1802 if ((entry
& 0x100) && !is_dir
)
1803 puts_filtered (" Global");
1804 if ((entry
& 0x40) && !is_dir
)
1805 puts_filtered (" Dirty");
1806 printf_filtered (" %sAcc.", (entry
& 0x20) ? "" : "Not-");
1807 printf_filtered (" %sCached", (entry
& 0x10) ? "" : "Not-");
1808 printf_filtered (" Write-%s", (entry
& 8) ? "Thru" : "Back");
1809 printf_filtered (" %s", (entry
& 4) ? "Usr" : "Sup");
1810 printf_filtered (" Read-%s", (entry
& 2) ? "Write" : "Only");
1812 printf_filtered (" +0x%x", off
);
1813 puts_filtered ("\n");
1816 printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1817 is_dir
? " Table" : "", entry
>> 1);
1821 go32_pde (char *arg
, int from_tty
)
1823 long pde_idx
= -1, i
;
1827 while (*arg
&& isspace(*arg
))
1832 pde_idx
= parse_and_eval_long (arg
);
1833 if (pde_idx
< 0 || pde_idx
>= 1024)
1834 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
1840 puts_filtered ("Access to Page Directories is not supported on this system.\n");
1841 else if (pde_idx
>= 0)
1842 display_ptable_entry (get_pde (pde_idx
), 1, 1, 0);
1844 for (i
= 0; i
< 1024; i
++)
1845 display_ptable_entry (get_pde (i
), 1, 0, 0);
1848 /* A helper function to display entries in a Page Table pointed to by
1849 the N'th entry in the Page Directory. If FORCE is non-zero, say
1850 something even if the Page Table is not accessible. */
1852 display_page_table (long n
, int force
)
1854 unsigned long pde
= get_pde (n
);
1860 printf_filtered ("Page Table pointed to by Page Directory entry 0x%lx:\n", n
);
1861 for (i
= 0; i
< 1024; i
++)
1862 display_ptable_entry (get_pte (pde
, i
), 0, 0, 0);
1863 puts_filtered ("\n");
1866 printf_filtered ("Page Table not present; value=0x%lx.\n", pde
>> 1);
1870 go32_pte (char *arg
, int from_tty
)
1872 long pde_idx
= -1L, i
;
1876 while (*arg
&& isspace(*arg
))
1881 pde_idx
= parse_and_eval_long (arg
);
1882 if (pde_idx
< 0 || pde_idx
>= 1024)
1883 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
1889 puts_filtered ("Access to Page Tables is not supported on this system.\n");
1890 else if (pde_idx
>= 0)
1891 display_page_table (pde_idx
, 1);
1893 for (i
= 0; i
< 1024; i
++)
1894 display_page_table (i
, 0);
1898 go32_pte_for_address (char *arg
, int from_tty
)
1900 CORE_ADDR addr
= 0, i
;
1904 while (*arg
&& isspace(*arg
))
1908 addr
= parse_and_eval_address (arg
);
1911 error_no_arg (_("linear address"));
1915 puts_filtered ("Access to Page Tables is not supported on this system.\n");
1918 int pde_idx
= (addr
>> 22) & 0x3ff;
1919 int pte_idx
= (addr
>> 12) & 0x3ff;
1920 unsigned offs
= addr
& 0xfff;
1922 printf_filtered ("Page Table entry for address 0x%llx:\n",
1923 (unsigned long long)addr
);
1924 display_ptable_entry (get_pte (get_pde (pde_idx
), pte_idx
), 0, 1, offs
);
1928 static struct cmd_list_element
*info_dos_cmdlist
= NULL
;
1931 go32_info_dos_command (char *args
, int from_tty
)
1933 help_list (info_dos_cmdlist
, "info dos ", class_info
, gdb_stdout
);
1937 _initialize_go32_nat (void)
1940 add_target (&go32_ops
);
1942 add_prefix_cmd ("dos", class_info
, go32_info_dos_command
, _("\
1943 Print information specific to DJGPP (aka MS-DOS) debugging."),
1944 &info_dos_cmdlist
, "info dos ", 0, &infolist
);
1946 add_cmd ("sysinfo", class_info
, go32_sysinfo
, _("\
1947 Display information about the target system, including CPU, OS, DPMI, etc."),
1949 add_cmd ("ldt", class_info
, go32_sldt
, _("\
1950 Display entries in the LDT (Local Descriptor Table).\n\
1951 Entry number (an expression) as an argument means display only that entry."),
1953 add_cmd ("gdt", class_info
, go32_sgdt
, _("\
1954 Display entries in the GDT (Global Descriptor Table).\n\
1955 Entry number (an expression) as an argument means display only that entry."),
1957 add_cmd ("idt", class_info
, go32_sidt
, _("\
1958 Display entries in the IDT (Interrupt Descriptor Table).\n\
1959 Entry number (an expression) as an argument means display only that entry."),
1961 add_cmd ("pde", class_info
, go32_pde
, _("\
1962 Display entries in the Page Directory.\n\
1963 Entry number (an expression) as an argument means display only that entry."),
1965 add_cmd ("pte", class_info
, go32_pte
, _("\
1966 Display entries in Page Tables.\n\
1967 Entry number (an expression) as an argument means display only entries\n\
1968 from the Page Table pointed to by the specified Page Directory entry."),
1970 add_cmd ("address-pte", class_info
, go32_pte_for_address
, _("\
1971 Display a Page Table entry for a linear address.\n\
1972 The address argument must be a linear address, after adding to\n\
1973 it the base address of the appropriate segment.\n\
1974 The base address of variables and functions in the debuggee's data\n\
1975 or code segment is stored in the variable __djgpp_base_address,\n\
1976 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
1977 For other segments, look up their base address in the output of\n\
1978 the `info dos ldt' command."),
1992 tcsetpgrp (int fd
, pid_t pgid
)
1994 if (isatty (fd
) && pgid
== SOME_PID
)
1996 errno
= pgid
== SOME_PID
? ENOTTY
: ENOSYS
;