1 /* Native debugging support for Intel x86 running DJGPP.
2 Copyright (C) 1997, 1999, 2000, 2001, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
4 Written by Robert Hoehne.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
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>
58 #if __DJGPP_MINOR__ < 3
59 /* This code will be provided from DJGPP 2.03 on. Until then I code it
67 unsigned short exponent
:15;
68 unsigned short sign
:1;
87 static void save_npx (void); /* Save the FPU of the debugged program */
88 static void load_npx (void); /* Restore the FPU of the debugged program */
90 /* ------------------------------------------------------------------------- */
91 /* Store the contents of the NPX in the global variable `npx'. */
97 asm ("inb $0xa0, %%al \n\
116 /* ------------------------------------------------------------------------- */
117 /* Reload the contents of the NPX from the global variable `npx'. */
122 asm ("frstor %0":"=m" (npx
));
124 /* ------------------------------------------------------------------------- */
125 /* Stubs for the missing redirection functions. */
132 redir_cmdline_delete (cmdline_t
*ptr
)
138 redir_cmdline_parse (const char *args
, cmdline_t
*ptr
)
144 redir_to_child (cmdline_t
*ptr
)
150 redir_to_debugger (cmdline_t
*ptr
)
156 redir_debug_init (cmdline_t
*ptr
)
160 #endif /* __DJGPP_MINOR < 3 */
162 typedef enum { wp_insert
, wp_remove
, wp_count
} wp_op
;
164 /* This holds the current reference counts for each debug register. */
165 static int dr_ref_count
[4];
169 static int prog_has_started
= 0;
170 static void go32_open (char *name
, int from_tty
);
171 static void go32_close (int quitting
);
172 static void go32_attach (struct target_ops
*ops
, char *args
, int from_tty
);
173 static void go32_detach (struct target_ops
*ops
, char *args
, int from_tty
);
174 static void go32_resume (struct target_ops
*ops
,
175 ptid_t ptid
, int step
,
176 enum target_signal siggnal
);
177 static void go32_fetch_registers (struct target_ops
*ops
,
178 struct regcache
*, int regno
);
179 static void store_register (const struct regcache
*, int regno
);
180 static void go32_store_registers (struct target_ops
*ops
,
181 struct regcache
*, int regno
);
182 static void go32_prepare_to_store (struct regcache
*);
183 static int go32_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
,
185 struct mem_attrib
*attrib
,
186 struct target_ops
*target
);
187 static void go32_files_info (struct target_ops
*target
);
188 static void go32_stop (ptid_t
);
189 static void go32_kill_inferior (struct target_ops
*ops
);
190 static void go32_create_inferior (struct target_ops
*ops
, char *exec_file
,
191 char *args
, char **env
, int from_tty
);
192 static void go32_mourn_inferior (struct target_ops
*ops
);
193 static int go32_can_run (void);
195 static struct target_ops go32_ops
;
196 static void go32_terminal_init (void);
197 static void go32_terminal_inferior (void);
198 static void go32_terminal_ours (void);
200 #define r_ofs(x) (offsetof(TSS,x))
209 {r_ofs (tss_eax
), 4}, /* normal registers, from a_tss */
210 {r_ofs (tss_ecx
), 4},
211 {r_ofs (tss_edx
), 4},
212 {r_ofs (tss_ebx
), 4},
213 {r_ofs (tss_esp
), 4},
214 {r_ofs (tss_ebp
), 4},
215 {r_ofs (tss_esi
), 4},
216 {r_ofs (tss_edi
), 4},
217 {r_ofs (tss_eip
), 4},
218 {r_ofs (tss_eflags
), 4},
225 {0, 10}, /* 8 FP registers, from npx.reg[] */
233 /* The order of the next 7 registers must be consistent
234 with their numbering in config/i386/tm-i386.h, which see. */
235 {0, 2}, /* control word, from npx */
236 {4, 2}, /* status word, from npx */
237 {8, 2}, /* tag word, from npx */
238 {16, 2}, /* last FP exception CS from npx */
239 {12, 4}, /* last FP exception EIP from npx */
240 {24, 2}, /* last FP exception operand selector from npx */
241 {20, 4}, /* last FP exception operand offset from npx */
242 {18, 2} /* last FP opcode from npx */
248 enum target_signal gdb_sig
;
252 {0, TARGET_SIGNAL_FPE
},
253 {1, TARGET_SIGNAL_TRAP
},
254 /* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
255 but I think SIGBUS is better, since the NMI is usually activated
256 as a result of a memory parity check failure. */
257 {2, TARGET_SIGNAL_BUS
},
258 {3, TARGET_SIGNAL_TRAP
},
259 {4, TARGET_SIGNAL_FPE
},
260 {5, TARGET_SIGNAL_SEGV
},
261 {6, TARGET_SIGNAL_ILL
},
262 {7, TARGET_SIGNAL_EMT
}, /* no-coprocessor exception */
263 {8, TARGET_SIGNAL_SEGV
},
264 {9, TARGET_SIGNAL_SEGV
},
265 {10, TARGET_SIGNAL_BUS
},
266 {11, TARGET_SIGNAL_SEGV
},
267 {12, TARGET_SIGNAL_SEGV
},
268 {13, TARGET_SIGNAL_SEGV
},
269 {14, TARGET_SIGNAL_SEGV
},
270 {16, TARGET_SIGNAL_FPE
},
271 {17, TARGET_SIGNAL_BUS
},
272 {31, TARGET_SIGNAL_ILL
},
273 {0x1b, TARGET_SIGNAL_INT
},
274 {0x75, TARGET_SIGNAL_FPE
},
275 {0x78, TARGET_SIGNAL_ALRM
},
276 {0x79, TARGET_SIGNAL_INT
},
277 {0x7a, TARGET_SIGNAL_QUIT
},
278 {-1, TARGET_SIGNAL_LAST
}
282 enum target_signal gdb_sig
;
285 {TARGET_SIGNAL_0
, -1},
286 {TARGET_SIGNAL_ILL
, 6}, /* Invalid Opcode */
287 {TARGET_SIGNAL_EMT
, 7}, /* triggers SIGNOFP */
288 {TARGET_SIGNAL_SEGV
, 13}, /* GPF */
289 {TARGET_SIGNAL_BUS
, 17}, /* Alignment Check */
290 /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
292 {TARGET_SIGNAL_TERM
, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
293 {TARGET_SIGNAL_FPE
, 0x75},
294 {TARGET_SIGNAL_INT
, 0x79},
295 {TARGET_SIGNAL_QUIT
, 0x7a},
296 {TARGET_SIGNAL_ALRM
, 0x78}, /* triggers SIGTIMR */
297 {TARGET_SIGNAL_PROF
, 0x78},
298 {TARGET_SIGNAL_LAST
, -1}
302 go32_open (char *name
, int from_tty
)
304 printf_unfiltered ("Done. Use the \"run\" command to run the program.\n");
308 go32_close (int quitting
)
313 go32_attach (struct target_ops
*ops
, char *args
, int from_tty
)
316 You cannot attach to a running program on this platform.\n\
317 Use the `run' command to run DJGPP programs."));
321 go32_detach (struct target_ops
*ops
, char *args
, int from_tty
)
325 static int resume_is_step
;
326 static int resume_signal
= -1;
329 go32_resume (struct target_ops
*ops
,
330 ptid_t ptid
, int step
, enum target_signal siggnal
)
334 resume_is_step
= step
;
336 if (siggnal
!= TARGET_SIGNAL_0
&& siggnal
!= TARGET_SIGNAL_TRAP
)
338 for (i
= 0, resume_signal
= -1;
339 excepn_map
[i
].gdb_sig
!= TARGET_SIGNAL_LAST
; i
++)
340 if (excepn_map
[i
].gdb_sig
== siggnal
)
342 resume_signal
= excepn_map
[i
].djgpp_excepno
;
345 if (resume_signal
== -1)
346 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
347 target_signal_to_name (siggnal
));
351 static char child_cwd
[FILENAME_MAX
];
354 go32_wait (struct target_ops
*ops
,
355 ptid_t ptid
, struct target_waitstatus
*status
)
358 unsigned char saved_opcode
;
359 unsigned long INT3_addr
= 0;
360 int stepping_over_INT
= 0;
362 a_tss
.tss_eflags
&= 0xfeff; /* reset the single-step flag (TF) */
365 /* If the next instruction is INT xx or INTO, we need to handle
366 them specially. Intel manuals say that these instructions
367 reset the single-step flag (a.k.a. TF). However, it seems
368 that, at least in the DPMI environment, and at least when
369 stepping over the DPMI interrupt 31h, the problem is having
370 TF set at all when INT 31h is executed: the debuggee either
371 crashes (and takes the system with it) or is killed by a
374 So we need to emulate single-step mode: we put an INT3 opcode
375 right after the INT xx instruction, let the debuggee run
376 until it hits INT3 and stops, then restore the original
377 instruction which we overwrote with the INT3 opcode, and back
378 up the debuggee's EIP to that instruction. */
379 read_child (a_tss
.tss_eip
, &saved_opcode
, 1);
380 if (saved_opcode
== 0xCD || saved_opcode
== 0xCE)
382 unsigned char INT3_opcode
= 0xCC;
385 = saved_opcode
== 0xCD ? a_tss
.tss_eip
+ 2 : a_tss
.tss_eip
+ 1;
386 stepping_over_INT
= 1;
387 read_child (INT3_addr
, &saved_opcode
, 1);
388 write_child (INT3_addr
, &INT3_opcode
, 1);
391 a_tss
.tss_eflags
|= 0x0100; /* normal instruction: set TF */
394 /* The special value FFFFh in tss_trap indicates to run_child that
395 tss_irqn holds a signal to be delivered to the debuggee. */
396 if (resume_signal
<= -1)
399 a_tss
.tss_irqn
= 0xff;
403 a_tss
.tss_trap
= 0xffff; /* run_child looks for this */
404 a_tss
.tss_irqn
= resume_signal
;
407 /* The child might change working directory behind our back. The
408 GDB users won't like the side effects of that when they work with
409 relative file names, and GDB might be confused by its current
410 directory not being in sync with the truth. So we always make a
411 point of changing back to where GDB thinks is its cwd, when we
412 return control to the debugger, but restore child's cwd before we
414 /* Initialize child_cwd, before the first call to run_child and not
415 in the initialization, so the child get also the changed directory
416 set with the gdb-command "cd ..." */
418 /* Initialize child's cwd with the current one. */
419 getcwd (child_cwd
, sizeof (child_cwd
));
423 #if __DJGPP_MINOR__ < 3
427 #if __DJGPP_MINOR__ < 3
431 /* Did we step over an INT xx instruction? */
432 if (stepping_over_INT
&& a_tss
.tss_eip
== INT3_addr
+ 1)
434 /* Restore the original opcode. */
435 a_tss
.tss_eip
--; /* EIP points *after* the INT3 instruction */
436 write_child (a_tss
.tss_eip
, &saved_opcode
, 1);
437 /* Simulate a TRAP exception. */
439 a_tss
.tss_eflags
|= 0x0100;
442 getcwd (child_cwd
, sizeof (child_cwd
)); /* in case it has changed */
443 chdir (current_directory
);
445 if (a_tss
.tss_irqn
== 0x21)
447 status
->kind
= TARGET_WAITKIND_EXITED
;
448 status
->value
.integer
= a_tss
.tss_eax
& 0xff;
452 status
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
453 status
->kind
= TARGET_WAITKIND_STOPPED
;
454 for (i
= 0; sig_map
[i
].go32_sig
!= -1; i
++)
456 if (a_tss
.tss_irqn
== sig_map
[i
].go32_sig
)
458 #if __DJGPP_MINOR__ < 3
459 if ((status
->value
.sig
= sig_map
[i
].gdb_sig
) !=
461 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
463 status
->value
.sig
= sig_map
[i
].gdb_sig
;
469 return pid_to_ptid (SOME_PID
);
473 fetch_register (struct regcache
*regcache
, int regno
)
475 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
476 if (regno
< gdbarch_fp0_regnum (gdbarch
))
477 regcache_raw_supply (regcache
, regno
,
478 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
479 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
, regno
))
480 i387_supply_fsave (regcache
, regno
, &npx
);
482 internal_error (__FILE__
, __LINE__
,
483 _("Invalid register no. %d in fetch_register."), regno
);
487 go32_fetch_registers (struct target_ops
*ops
,
488 struct regcache
*regcache
, int regno
)
491 fetch_register (regcache
, regno
);
495 regno
< gdbarch_fp0_regnum (get_regcache_arch (regcache
));
497 fetch_register (regcache
, regno
);
498 i387_supply_fsave (regcache
, -1, &npx
);
503 store_register (const struct regcache
*regcache
, int regno
)
505 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
506 if (regno
< gdbarch_fp0_regnum (gdbarch
))
507 regcache_raw_collect (regcache
, regno
,
508 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
509 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
, regno
))
510 i387_collect_fsave (regcache
, regno
, &npx
);
512 internal_error (__FILE__
, __LINE__
,
513 _("Invalid register no. %d in store_register."), regno
);
517 go32_store_registers (struct target_ops
*ops
,
518 struct regcache
*regcache
, int regno
)
523 store_register (regcache
, regno
);
526 for (r
= 0; r
< gdbarch_fp0_regnum (get_regcache_arch (regcache
)); r
++)
527 store_register (regcache
, r
);
528 i387_collect_fsave (regcache
, -1, &npx
);
533 go32_prepare_to_store (struct regcache
*regcache
)
538 go32_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
,
539 struct mem_attrib
*attrib
, struct target_ops
*target
)
543 if (write_child (memaddr
, myaddr
, len
))
554 if (read_child (memaddr
, myaddr
, len
))
565 static cmdline_t child_cmd
; /* parsed child's command line kept here */
568 go32_files_info (struct target_ops
*target
)
570 printf_unfiltered ("You are running a DJGPP V2 program.\n");
574 go32_stop (ptid_t ptid
)
578 ptid
= inferior_ptid
;
579 inferior_ptid
= null_ptid
;
580 delete_thread_silent (ptid
);
581 prog_has_started
= 0;
585 go32_kill_inferior (struct target_ops
*ops
)
587 redir_cmdline_delete (&child_cmd
);
590 if (!ptid_equal (inferior_ptid
, null_ptid
))
591 delete_thread_silent (inferior_ptid
);
592 unpush_target (&go32_ops
);
596 go32_create_inferior (struct target_ops
*ops
, char *exec_file
,
597 char *args
, char **env
, int from_tty
)
599 extern char **environ
;
602 char **env_save
= environ
;
605 /* If no exec file handed to us, get it from the exec-file command -- with
606 a good, common error message if none is specified. */
608 exec_file
= get_exec_file (1);
610 if (prog_has_started
)
612 go32_stop (inferior_ptid
);
613 go32_kill_inferior (ops
);
618 /* Initialize child's cwd as empty to be initialized when starting
622 /* Init command line storage. */
623 if (redir_debug_init (&child_cmd
) == -1)
624 internal_error (__FILE__
, __LINE__
,
625 _("Cannot allocate redirection storage: not enough memory.\n"));
627 /* Parse the command line and create redirections. */
628 if (strpbrk (args
, "<>"))
630 if (redir_cmdline_parse (args
, &child_cmd
) == 0)
631 args
= child_cmd
.command
;
633 error (_("Syntax error in command line."));
636 child_cmd
.command
= xstrdup (args
);
638 cmdlen
= strlen (args
);
639 /* v2loadimage passes command lines via DOS memory, so it cannot
640 possibly handle commands longer than 1MB. */
641 if (cmdlen
> 1024*1024)
642 error (_("Command line too long."));
644 cmdline
= xmalloc (cmdlen
+ 4);
645 strcpy (cmdline
+ 1, args
);
646 /* If the command-line length fits into DOS 126-char limits, use the
647 DOS command tail format; otherwise, tell v2loadimage to pass it
648 through a buffer in conventional memory. */
651 cmdline
[0] = strlen (args
);
652 cmdline
[cmdlen
+ 1] = 13;
655 cmdline
[0] = 0xff; /* signal v2loadimage it's a long command */
659 if (v2loadimage (exec_file
, cmdline
, start_state
))
662 printf_unfiltered ("Load failed for image %s\n", exec_file
);
668 edi_init (start_state
);
669 #if __DJGPP_MINOR__ < 3
673 inferior_ptid
= pid_to_ptid (SOME_PID
);
674 add_inferior_silent (SOME_PID
);
676 push_target (&go32_ops
);
678 add_thread_silent (inferior_ptid
);
680 clear_proceed_status ();
681 insert_breakpoints ();
682 prog_has_started
= 1;
686 go32_mourn_inferior (struct target_ops
*ops
)
688 /* We need to make sure all the breakpoint enable bits in the DR7
689 register are reset when the inferior exits. Otherwise, if they
690 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
691 failure to set more watchpoints, and other calamities. It would
692 be nice if GDB itself would take care to remove all breakpoints
693 at all times, but it doesn't, probably under an assumption that
694 the OS cleans up when the debuggee exits. */
695 i386_cleanup_dregs ();
696 go32_kill_inferior (ops
);
697 generic_mourn_inferior ();
706 /* Hardware watchpoint support. */
708 #define D_REGS edi.dr
709 #define CONTROL D_REGS[7]
710 #define STATUS D_REGS[6]
712 /* Pass the address ADDR to the inferior in the I'th debug register.
713 Here we just store the address in D_REGS, the watchpoint will be
714 actually set up when go32_wait runs the debuggee. */
716 go32_set_dr (int i
, CORE_ADDR addr
)
719 internal_error (__FILE__
, __LINE__
,
720 _("Invalid register %d in go32_set_dr.\n"), i
);
724 /* Pass the value VAL to the inferior in the DR7 debug control
725 register. Here we just store the address in D_REGS, the watchpoint
726 will be actually set up when go32_wait runs the debuggee. */
728 go32_set_dr7 (unsigned val
)
733 /* Get the value of the DR6 debug status register from the inferior.
734 Here we just return the value stored in D_REGS, as we've got it
735 from the last go32_wait call. */
742 /* Put the device open on handle FD into either raw or cooked
743 mode, return 1 if it was in raw mode, zero otherwise. */
746 device_mode (int fd
, int raw_p
)
748 int oldmode
, newmode
;
753 __dpmi_int (0x21, ®s
);
754 if (regs
.x
.flags
& 1)
756 newmode
= oldmode
= regs
.x
.dx
;
763 if (oldmode
& 0x80) /* Only for character dev */
767 regs
.x
.dx
= newmode
& 0xff; /* Force upper byte zero, else it fails */
768 __dpmi_int (0x21, ®s
);
769 if (regs
.x
.flags
& 1)
772 return (oldmode
& 0x20) == 0x20;
776 static int inf_mode_valid
= 0;
777 static int inf_terminal_mode
;
779 /* This semaphore is needed because, amazingly enough, GDB calls
780 target.to_terminal_ours more than once after the inferior stops.
781 But we need the information from the first call only, since the
782 second call will always see GDB's own cooked terminal. */
783 static int terminal_is_ours
= 1;
786 go32_terminal_init (void)
788 inf_mode_valid
= 0; /* reinitialize, in case they are restarting child */
789 terminal_is_ours
= 1;
793 go32_terminal_info (char *args
, int from_tty
)
795 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
797 ? "default" : inf_terminal_mode
? "raw" : "cooked");
799 #if __DJGPP_MINOR__ > 2
800 if (child_cmd
.redirection
)
804 for (i
= 0; i
< DBG_HANDLES
; i
++)
806 if (child_cmd
.redirection
[i
]->file_name
)
807 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
808 i
, child_cmd
.redirection
[i
]->file_name
);
809 else if (_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) == -1)
811 ("\tFile handle %d appears to be closed by inferior.\n", i
);
812 /* Mask off the raw/cooked bit when comparing device info words. */
813 else if ((_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) & 0xdf)
814 != (_get_dev_info (i
) & 0xdf))
816 ("\tFile handle %d appears to be redirected by inferior.\n", i
);
823 go32_terminal_inferior (void)
825 /* Redirect standard handles as child wants them. */
827 if (redir_to_child (&child_cmd
) == -1)
829 redir_to_debugger (&child_cmd
);
830 error (_("Cannot redirect standard handles for program: %s."),
831 safe_strerror (errno
));
833 /* set the console device of the inferior to whatever mode
834 (raw or cooked) we found it last time */
835 if (terminal_is_ours
)
838 device_mode (0, inf_terminal_mode
);
839 terminal_is_ours
= 0;
844 go32_terminal_ours (void)
846 /* Switch to cooked mode on the gdb terminal and save the inferior
847 terminal mode to be restored when it is resumed */
848 if (!terminal_is_ours
)
850 inf_terminal_mode
= device_mode (0, 0);
851 if (inf_terminal_mode
!= -1)
854 /* If device_mode returned -1, we don't know what happens with
855 handle 0 anymore, so make the info invalid. */
857 terminal_is_ours
= 1;
859 /* Restore debugger's standard handles. */
861 if (redir_to_debugger (&child_cmd
) == -1)
863 redir_to_child (&child_cmd
);
864 error (_("Cannot redirect standard handles for debugger: %s."),
865 safe_strerror (errno
));
871 go32_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
873 return !ptid_equal (inferior_ptid
, null_ptid
);
877 go32_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
879 return normal_pid_to_str (ptid
);
885 go32_ops
.to_shortname
= "djgpp";
886 go32_ops
.to_longname
= "djgpp target process";
888 "Program loaded by djgpp, when gdb is used as an external debugger";
889 go32_ops
.to_open
= go32_open
;
890 go32_ops
.to_close
= go32_close
;
891 go32_ops
.to_attach
= go32_attach
;
892 go32_ops
.to_detach
= go32_detach
;
893 go32_ops
.to_resume
= go32_resume
;
894 go32_ops
.to_wait
= go32_wait
;
895 go32_ops
.to_fetch_registers
= go32_fetch_registers
;
896 go32_ops
.to_store_registers
= go32_store_registers
;
897 go32_ops
.to_prepare_to_store
= go32_prepare_to_store
;
898 go32_ops
.deprecated_xfer_memory
= go32_xfer_memory
;
899 go32_ops
.to_files_info
= go32_files_info
;
900 go32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
901 go32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
902 go32_ops
.to_terminal_init
= go32_terminal_init
;
903 go32_ops
.to_terminal_inferior
= go32_terminal_inferior
;
904 go32_ops
.to_terminal_ours_for_output
= go32_terminal_ours
;
905 go32_ops
.to_terminal_ours
= go32_terminal_ours
;
906 go32_ops
.to_terminal_info
= go32_terminal_info
;
907 go32_ops
.to_kill
= go32_kill_inferior
;
908 go32_ops
.to_create_inferior
= go32_create_inferior
;
909 go32_ops
.to_mourn_inferior
= go32_mourn_inferior
;
910 go32_ops
.to_can_run
= go32_can_run
;
911 go32_ops
.to_stop
= go32_stop
;
912 go32_ops
.to_thread_alive
= go32_thread_alive
;
913 go32_ops
.to_pid_to_str
= go32_pid_to_str
;
914 go32_ops
.to_stratum
= process_stratum
;
915 go32_ops
.to_has_all_memory
= 1;
916 go32_ops
.to_has_memory
= 1;
917 go32_ops
.to_has_stack
= 1;
918 go32_ops
.to_has_registers
= 1;
919 go32_ops
.to_has_execution
= 1;
921 i386_use_watchpoints (&go32_ops
);
923 go32_ops
.to_magic
= OPS_MAGIC
;
925 /* Initialize child's cwd as empty to be initialized when starting
929 /* Initialize child's command line storage. */
930 if (redir_debug_init (&child_cmd
) == -1)
931 internal_error (__FILE__
, __LINE__
,
932 _("Cannot allocate redirection storage: not enough memory.\n"));
934 /* We are always processing GCC-compiled programs. */
935 processing_gcc_compilation
= 2;
937 /* Override the default name of the GDB init file. */
938 strcpy (gdbinit
, "gdb.ini");
941 /* Return the current DOS codepage number. */
948 __dpmi_int (0x21, ®s
);
949 if (!(regs
.x
.flags
& 1))
950 return regs
.x
.bx
& 0xffff;
952 return 437; /* default */
955 /* Limited emulation of `nl_langinfo', for charset.c. */
957 nl_langinfo (nl_item item
)
965 /* 8 is enough for SHORT_MAX + "CP" + null. */
967 int blen
= sizeof (buf
);
968 int needed
= snprintf (buf
, blen
, "CP%d", dos_codepage ());
970 if (needed
> blen
) /* should never happen */
972 retval
= xstrdup (buf
);
976 retval
= xstrdup ("");
982 unsigned short windows_major
, windows_minor
;
984 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */
986 go32_get_windows_version(void)
991 __dpmi_int(0x2f, &r
);
992 if (r
.h
.al
> 2 && r
.h
.al
!= 0x80 && r
.h
.al
!= 0xff
993 && (r
.h
.al
> 3 || r
.h
.ah
> 0))
995 windows_major
= r
.h
.al
;
996 windows_minor
= r
.h
.ah
;
999 windows_major
= 0xff; /* meaning no Windows */
1002 /* A subroutine of go32_sysinfo to display memory info. */
1004 print_mem (unsigned long datum
, const char *header
, int in_pages_p
)
1006 if (datum
!= 0xffffffffUL
)
1010 puts_filtered (header
);
1013 printf_filtered ("%lu KB", datum
>> 10);
1014 if (datum
> 1024 * 1024)
1015 printf_filtered (" (%lu MB)", datum
>> 20);
1018 printf_filtered ("%lu Bytes", datum
);
1019 puts_filtered ("\n");
1023 /* Display assorted information about the underlying OS. */
1025 go32_sysinfo (char *arg
, int from_tty
)
1027 static const char test_pattern
[] =
1028 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1029 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1030 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeafdeadbeaf";
1032 char cpuid_vendor
[13];
1033 unsigned cpuid_max
= 0, cpuid_eax
, cpuid_ebx
, cpuid_ecx
, cpuid_edx
;
1034 unsigned true_dos_version
= _get_dos_version (1);
1035 unsigned advertized_dos_version
= ((unsigned int)_osmajor
<< 8) | _osminor
;
1037 char dpmi_vendor_info
[129];
1038 int dpmi_vendor_available
;
1039 __dpmi_version_ret dpmi_version_data
;
1041 __dpmi_free_mem_info mem_info
;
1044 cpuid_vendor
[0] = '\0';
1046 strcpy (u
.machine
, "Unknown x86");
1047 else if (u
.machine
[0] == 'i' && u
.machine
[1] > 4)
1049 /* CPUID with EAX = 0 returns the Vendor ID. */
1050 __asm__
__volatile__ ("xorl %%ebx, %%ebx;"
1051 "xorl %%ecx, %%ecx;"
1052 "xorl %%edx, %%edx;"
1059 : "=m" (cpuid_vendor
[0]),
1060 "=m" (cpuid_vendor
[4]),
1061 "=m" (cpuid_vendor
[8]),
1064 : "%eax", "%ebx", "%ecx", "%edx");
1065 cpuid_vendor
[12] = '\0';
1068 printf_filtered ("CPU Type.......................%s", u
.machine
);
1069 if (cpuid_vendor
[0])
1070 printf_filtered (" (%s)", cpuid_vendor
);
1071 puts_filtered ("\n");
1073 /* CPUID with EAX = 1 returns processor signature and features. */
1076 static char *brand_name
[] = {
1084 char cpu_string
[80];
1087 int intel_p
= strcmp (cpuid_vendor
, "GenuineIntel") == 0;
1088 int amd_p
= strcmp (cpuid_vendor
, "AuthenticAMD") == 0;
1089 unsigned cpu_family
, cpu_model
;
1091 __asm__
__volatile__ ("movl $1, %%eax;"
1098 brand_idx
= cpuid_ebx
& 0xff;
1099 cpu_family
= (cpuid_eax
>> 8) & 0xf;
1100 cpu_model
= (cpuid_eax
>> 4) & 0xf;
1101 cpu_brand
[0] = '\0';
1105 && brand_idx
< sizeof(brand_name
)/sizeof(brand_name
[0])
1106 && *brand_name
[brand_idx
])
1107 strcpy (cpu_brand
, brand_name
[brand_idx
]);
1108 else if (cpu_family
== 5)
1110 if (((cpuid_eax
>> 12) & 3) == 0 && cpu_model
== 4)
1111 strcpy (cpu_brand
, " MMX");
1112 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 1)
1113 strcpy (cpu_brand
, " OverDrive");
1114 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 2)
1115 strcpy (cpu_brand
, " Dual");
1117 else if (cpu_family
== 6 && cpu_model
< 8)
1122 strcpy (cpu_brand
, " Pro");
1125 strcpy (cpu_brand
, " II");
1128 strcpy (cpu_brand
, " II Xeon");
1131 strcpy (cpu_brand
, " Celeron");
1134 strcpy (cpu_brand
, " III");
1144 strcpy (cpu_brand
, "486/5x86");
1153 strcpy (cpu_brand
, "-K5");
1157 strcpy (cpu_brand
, "-K6");
1160 strcpy (cpu_brand
, "-K6-2");
1163 strcpy (cpu_brand
, "-K6-III");
1173 strcpy (cpu_brand
, " Athlon");
1176 strcpy (cpu_brand
, " Duron");
1182 sprintf (cpu_string
, "%s%s Model %d Stepping %d",
1183 intel_p
? "Pentium" : (amd_p
? "AMD" : "ix86"),
1184 cpu_brand
, cpu_model
, cpuid_eax
& 0xf);
1185 printfi_filtered (31, "%s\n", cpu_string
);
1186 if (((cpuid_edx
& (6 | (0x0d << 23))) != 0)
1187 || ((cpuid_edx
& 1) == 0)
1188 || (amd_p
&& (cpuid_edx
& (3 << 30)) != 0))
1190 puts_filtered ("CPU Features...................");
1191 /* We only list features which might be useful in the DPMI
1193 if ((cpuid_edx
& 1) == 0)
1194 puts_filtered ("No FPU "); /* it's unusual to not have an FPU */
1195 if ((cpuid_edx
& (1 << 1)) != 0)
1196 puts_filtered ("VME ");
1197 if ((cpuid_edx
& (1 << 2)) != 0)
1198 puts_filtered ("DE ");
1199 if ((cpuid_edx
& (1 << 4)) != 0)
1200 puts_filtered ("TSC ");
1201 if ((cpuid_edx
& (1 << 23)) != 0)
1202 puts_filtered ("MMX ");
1203 if ((cpuid_edx
& (1 << 25)) != 0)
1204 puts_filtered ("SSE ");
1205 if ((cpuid_edx
& (1 << 26)) != 0)
1206 puts_filtered ("SSE2 ");
1209 if ((cpuid_edx
& (1 << 31)) != 0)
1210 puts_filtered ("3DNow! ");
1211 if ((cpuid_edx
& (1 << 30)) != 0)
1212 puts_filtered ("3DNow!Ext");
1214 puts_filtered ("\n");
1217 puts_filtered ("\n");
1218 printf_filtered ("DOS Version....................%s %s.%s",
1219 _os_flavor
, u
.release
, u
.version
);
1220 if (true_dos_version
!= advertized_dos_version
)
1221 printf_filtered (" (disguised as v%d.%d)", _osmajor
, _osminor
);
1222 puts_filtered ("\n");
1224 go32_get_windows_version ();
1225 if (windows_major
!= 0xff)
1227 const char *windows_flavor
;
1229 printf_filtered ("Windows Version................%d.%02d (Windows ",
1230 windows_major
, windows_minor
);
1231 switch (windows_major
)
1234 windows_flavor
= "3.X";
1237 switch (windows_minor
)
1240 windows_flavor
= "95, 95A, or 95B";
1243 windows_flavor
= "95B OSR2.1 or 95C OSR2.5";
1246 windows_flavor
= "98 or 98 SE";
1249 windows_flavor
= "ME";
1252 windows_flavor
= "9X";
1257 windows_flavor
= "??";
1260 printf_filtered ("%s)\n", windows_flavor
);
1262 else if (true_dos_version
== 0x532 && advertized_dos_version
== 0x500)
1263 printf_filtered ("Windows Version................Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
1264 puts_filtered ("\n");
1265 /* On some versions of Windows, __dpmi_get_capabilities returns
1266 zero, but the buffer is not filled with info, so we fill the
1267 buffer with a known pattern and test for it afterwards. */
1268 memcpy (dpmi_vendor_info
, test_pattern
, sizeof(dpmi_vendor_info
));
1269 dpmi_vendor_available
=
1270 __dpmi_get_capabilities (&dpmi_flags
, dpmi_vendor_info
);
1271 if (dpmi_vendor_available
== 0
1272 && memcmp (dpmi_vendor_info
, test_pattern
,
1273 sizeof(dpmi_vendor_info
)) != 0)
1275 /* The DPMI spec says the vendor string should be ASCIIZ, but
1276 I don't trust the vendors to follow that... */
1277 if (!memchr (&dpmi_vendor_info
[2], 0, 126))
1278 dpmi_vendor_info
[128] = '\0';
1279 printf_filtered ("DPMI Host......................%s v%d.%d (capabilities: %#x)\n",
1280 &dpmi_vendor_info
[2],
1281 (unsigned)dpmi_vendor_info
[0],
1282 (unsigned)dpmi_vendor_info
[1],
1283 ((unsigned)dpmi_flags
& 0x7f));
1286 printf_filtered ("DPMI Host......................(Info not available)\n");
1287 __dpmi_get_version (&dpmi_version_data
);
1288 printf_filtered ("DPMI Version...................%d.%02d\n",
1289 dpmi_version_data
.major
, dpmi_version_data
.minor
);
1290 printf_filtered ("DPMI Info......................%s-bit DPMI, with%s Virtual Memory support\n",
1291 (dpmi_version_data
.flags
& 1) ? "32" : "16",
1292 (dpmi_version_data
.flags
& 4) ? "" : "out");
1293 printfi_filtered (31, "Interrupts reflected to %s mode\n",
1294 (dpmi_version_data
.flags
& 2) ? "V86" : "Real");
1295 printfi_filtered (31, "Processor type: i%d86\n",
1296 dpmi_version_data
.cpu
);
1297 printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
1298 dpmi_version_data
.master_pic
, dpmi_version_data
.slave_pic
);
1300 /* a_tss is only initialized when the debuggee is first run. */
1301 if (prog_has_started
)
1303 __asm__
__volatile__ ("pushfl ; popl %0" : "=g" (eflags
));
1304 printf_filtered ("Protection.....................Ring %d (in %s), with%s I/O protection\n",
1305 a_tss
.tss_cs
& 3, (a_tss
.tss_cs
& 4) ? "LDT" : "GDT",
1306 (a_tss
.tss_cs
& 3) > ((eflags
>> 12) & 3) ? "" : "out");
1308 puts_filtered ("\n");
1309 __dpmi_get_free_memory_information (&mem_info
);
1310 print_mem (mem_info
.total_number_of_physical_pages
,
1311 "DPMI Total Physical Memory.....", 1);
1312 print_mem (mem_info
.total_number_of_free_pages
,
1313 "DPMI Free Physical Memory......", 1);
1314 print_mem (mem_info
.size_of_paging_file_partition_in_pages
,
1315 "DPMI Swap Space................", 1);
1316 print_mem (mem_info
.linear_address_space_size_in_pages
,
1317 "DPMI Total Linear Address Size.", 1);
1318 print_mem (mem_info
.free_linear_address_space_in_pages
,
1319 "DPMI Free Linear Address Size..", 1);
1320 print_mem (mem_info
.largest_available_free_block_in_bytes
,
1321 "DPMI Largest Free Memory Block.", 0);
1325 __dpmi_int (0x21, ®s
);
1326 print_mem (regs
.x
.bx
<< 4, "Free DOS Memory................", 0);
1328 __dpmi_int (0x21, ®s
);
1329 if ((regs
.x
.flags
& 1) == 0)
1331 static const char *dos_hilo
[] = {
1332 "Low", "", "", "", "High", "", "", "", "High, then Low"
1334 static const char *dos_fit
[] = {
1335 "First", "Best", "Last"
1337 int hilo_idx
= (regs
.x
.ax
>> 4) & 0x0f;
1338 int fit_idx
= regs
.x
.ax
& 0x0f;
1344 printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1345 dos_hilo
[hilo_idx
], dos_fit
[fit_idx
]);
1347 __dpmi_int (0x21, ®s
);
1348 if ((regs
.x
.flags
& 1) != 0)
1350 printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1351 regs
.h
.al
== 0 ? "not " : "");
1356 unsigned short limit0
;
1357 unsigned short base0
;
1358 unsigned char base1
;
1363 unsigned available
:1;
1366 unsigned page_granular
:1;
1367 unsigned char base2
;
1368 } __attribute__ ((packed
));
1371 unsigned short offset0
;
1372 unsigned short selector
;
1373 unsigned param_count
:5;
1378 unsigned short offset1
;
1379 } __attribute__ ((packed
));
1381 /* Read LEN bytes starting at logical address ADDR, and put the result
1382 into DEST. Return 1 if success, zero if not. */
1384 read_memory_region (unsigned long addr
, void *dest
, size_t len
)
1386 unsigned long dos_ds_limit
= __dpmi_get_segment_limit (_dos_ds
);
1389 /* For the low memory, we can simply use _dos_ds. */
1390 if (addr
<= dos_ds_limit
- len
)
1391 dosmemget (addr
, len
, dest
);
1394 /* For memory above 1MB we need to set up a special segment to
1395 be able to access that memory. */
1396 int sel
= __dpmi_allocate_ldt_descriptors (1);
1402 int access_rights
= __dpmi_get_descriptor_access_rights (sel
);
1403 size_t segment_limit
= len
- 1;
1405 /* Make sure the crucial bits in the descriptor access
1406 rights are set correctly. Some DPMI providers might barf
1407 if we set the segment limit to something that is not an
1408 integral multiple of 4KB pages if the granularity bit is
1409 not set to byte-granular, even though the DPMI spec says
1410 it's the host's responsibility to set that bit correctly. */
1411 if (len
> 1024 * 1024)
1413 access_rights
|= 0x8000;
1414 /* Page-granular segments should have the low 12 bits of
1416 segment_limit
|= 0xfff;
1419 access_rights
&= ~0x8000;
1421 if (__dpmi_set_segment_base_address (sel
, addr
) != -1
1422 && __dpmi_set_descriptor_access_rights (sel
, access_rights
) != -1
1423 && __dpmi_set_segment_limit (sel
, segment_limit
) != -1
1424 /* W2K silently fails to set the segment limit, leaving
1425 it at zero; this test avoids the resulting crash. */
1426 && __dpmi_get_segment_limit (sel
) >= segment_limit
)
1427 movedata (sel
, 0, _my_ds (), (unsigned)dest
, len
);
1431 __dpmi_free_ldt_descriptor (sel
);
1437 /* Get a segment descriptor stored at index IDX in the descriptor
1438 table whose base address is TABLE_BASE. Return the descriptor
1439 type, or -1 if failure. */
1441 get_descriptor (unsigned long table_base
, int idx
, void *descr
)
1443 unsigned long addr
= table_base
+ idx
* 8; /* 8 bytes per entry */
1445 if (read_memory_region (addr
, descr
, 8))
1446 return (int)((struct seg_descr
*)descr
)->stype
;
1451 unsigned short limit
__attribute__((packed
));
1452 unsigned long base
__attribute__((packed
));
1455 /* Display a segment descriptor stored at index IDX in a descriptor
1456 table whose type is TYPE and whose base address is BASE_ADDR. If
1457 FORCE is non-zero, display even invalid descriptors. */
1459 display_descriptor (unsigned type
, unsigned long base_addr
, int idx
, int force
)
1461 struct seg_descr descr
;
1462 struct gate_descr gate
;
1464 /* Get the descriptor from the table. */
1465 if (idx
== 0 && type
== 0)
1466 puts_filtered ("0x000: null descriptor\n");
1467 else if (get_descriptor (base_addr
, idx
, &descr
) != -1)
1469 /* For each type of descriptor table, this has a bit set if the
1470 corresponding type of selectors is valid in that table. */
1471 static unsigned allowed_descriptors
[] = {
1472 0xffffdafeL
, /* GDT */
1473 0x0000c0e0L
, /* IDT */
1474 0xffffdafaL
/* LDT */
1477 /* If the program hasn't started yet, assume the debuggee will
1478 have the same CPL as the debugger. */
1479 int cpl
= prog_has_started
? (a_tss
.tss_cs
& 3) : _my_cs () & 3;
1480 unsigned long limit
= (descr
.limit1
<< 16) | descr
.limit0
;
1483 && (allowed_descriptors
[type
] & (1 << descr
.stype
)) != 0)
1485 printf_filtered ("0x%03x: ",
1487 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1488 if (descr
.page_granular
)
1489 limit
= (limit
<< 12) | 0xfff; /* big segment: low 12 bit set */
1490 if (descr
.stype
== 1 || descr
.stype
== 2 || descr
.stype
== 3
1491 || descr
.stype
== 9 || descr
.stype
== 11
1492 || (descr
.stype
>= 16 && descr
.stype
< 32))
1493 printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1494 descr
.base2
, descr
.base1
, descr
.base0
, limit
);
1496 switch (descr
.stype
)
1500 printf_filtered (" 16-bit TSS (task %sactive)",
1501 descr
.stype
== 3 ? "" : "in");
1504 puts_filtered (" LDT");
1507 memcpy (&gate
, &descr
, sizeof gate
);
1508 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1509 gate
.selector
, gate
.offset1
, gate
.offset0
);
1510 printf_filtered (" 16-bit Call Gate (params=%d)",
1514 printf_filtered ("TSS selector=0x%04x", descr
.base0
);
1515 printfi_filtered (16, "Task Gate");
1519 memcpy (&gate
, &descr
, sizeof gate
);
1520 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1521 gate
.selector
, gate
.offset1
, gate
.offset0
);
1522 printf_filtered (" 16-bit %s Gate",
1523 descr
.stype
== 6 ? "Interrupt" : "Trap");
1527 printf_filtered (" 32-bit TSS (task %sactive)",
1528 descr
.stype
== 3 ? "" : "in");
1531 memcpy (&gate
, &descr
, sizeof gate
);
1532 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1533 gate
.selector
, gate
.offset1
, gate
.offset0
);
1534 printf_filtered (" 32-bit Call Gate (params=%d)",
1539 memcpy (&gate
, &descr
, sizeof gate
);
1540 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1541 gate
.selector
, gate
.offset1
, gate
.offset0
);
1542 printf_filtered (" 32-bit %s Gate",
1543 descr
.stype
== 14 ? "Interrupt" : "Trap");
1545 case 16: /* data segments */
1553 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1554 descr
.bit32
? "32" : "16",
1555 descr
.stype
& 2 ? "Read/Write," : "Read-Only, ",
1556 descr
.stype
& 4 ? "down" : "up",
1557 descr
.stype
& 1 ? "" : ", N.Acc");
1559 case 24: /* code segments */
1567 printf_filtered (" %s-bit Code (%s, %sConf%s)",
1568 descr
.bit32
? "32" : "16",
1569 descr
.stype
& 2 ? "Exec/Read" : "Exec-Only",
1570 descr
.stype
& 4 ? "" : "N.",
1571 descr
.stype
& 1 ? "" : ", N.Acc");
1574 printf_filtered ("Unknown type 0x%02x", descr
.stype
);
1577 puts_filtered ("\n");
1581 printf_filtered ("0x%03x: ",
1583 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1585 puts_filtered ("Segment not present\n");
1587 printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1592 printf_filtered ("0x%03x: Cannot read this descriptor\n", idx
);
1596 go32_sldt (char *arg
, int from_tty
)
1598 struct dtr_reg gdtr
;
1599 unsigned short ldtr
= 0;
1601 struct seg_descr ldt_descr
;
1602 long ldt_entry
= -1L;
1603 int cpl
= (prog_has_started
? a_tss
.tss_cs
: _my_cs ()) & 3;
1607 while (*arg
&& isspace(*arg
))
1612 ldt_entry
= parse_and_eval_long (arg
);
1614 || (ldt_entry
& 4) == 0
1615 || (ldt_entry
& 3) != (cpl
& 3))
1616 error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry
);
1620 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1621 __asm__
__volatile__ ("sldt %0" : "=m" (ldtr
) : /* no inputs */ );
1624 puts_filtered ("There is no LDT.\n");
1625 /* LDT's entry in the GDT must have the type LDT, which is 2. */
1626 else if (get_descriptor (gdtr
.base
, ldt_idx
, &ldt_descr
) != 2)
1627 printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1629 | (ldt_descr
.base1
<< 16)
1630 | (ldt_descr
.base2
<< 24));
1635 | (ldt_descr
.base1
<< 16)
1636 | (ldt_descr
.base2
<< 24);
1637 unsigned limit
= ldt_descr
.limit0
| (ldt_descr
.limit1
<< 16);
1640 if (ldt_descr
.page_granular
)
1641 /* Page-granular segments must have the low 12 bits of their
1643 limit
= (limit
<< 12) | 0xfff;
1644 /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1649 max_entry
= (limit
+ 1) / 8;
1653 if (ldt_entry
> limit
)
1654 error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1655 (unsigned long)ldt_entry
, limit
);
1657 display_descriptor (ldt_descr
.stype
, base
, ldt_entry
/ 8, 1);
1663 for (i
= 0; i
< max_entry
; i
++)
1664 display_descriptor (ldt_descr
.stype
, base
, i
, 0);
1670 go32_sgdt (char *arg
, int from_tty
)
1672 struct dtr_reg gdtr
;
1673 long gdt_entry
= -1L;
1678 while (*arg
&& isspace(*arg
))
1683 gdt_entry
= parse_and_eval_long (arg
);
1684 if (gdt_entry
< 0 || (gdt_entry
& 7) != 0)
1685 error (_("Invalid GDT entry 0x%03lx: not an integral multiple of 8."),
1686 (unsigned long)gdt_entry
);
1690 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1691 max_entry
= (gdtr
.limit
+ 1) / 8;
1695 if (gdt_entry
> gdtr
.limit
)
1696 error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1697 (unsigned long)gdt_entry
, gdtr
.limit
);
1699 display_descriptor (0, gdtr
.base
, gdt_entry
/ 8, 1);
1705 for (i
= 0; i
< max_entry
; i
++)
1706 display_descriptor (0, gdtr
.base
, i
, 0);
1711 go32_sidt (char *arg
, int from_tty
)
1713 struct dtr_reg idtr
;
1714 long idt_entry
= -1L;
1719 while (*arg
&& isspace(*arg
))
1724 idt_entry
= parse_and_eval_long (arg
);
1726 error (_("Invalid (negative) IDT entry %ld."), idt_entry
);
1730 __asm__
__volatile__ ("sidt %0" : "=m" (idtr
) : /* no inputs */ );
1731 max_entry
= (idtr
.limit
+ 1) / 8;
1732 if (max_entry
> 0x100) /* no more than 256 entries */
1737 if (idt_entry
> idtr
.limit
)
1738 error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1739 (unsigned long)idt_entry
, idtr
.limit
);
1741 display_descriptor (1, idtr
.base
, idt_entry
, 1);
1747 for (i
= 0; i
< max_entry
; i
++)
1748 display_descriptor (1, idtr
.base
, i
, 0);
1752 /* Cached linear address of the base of the page directory. For
1753 now, available only under CWSDPMI. Code based on ideas and
1754 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
1755 static unsigned long pdbr
;
1757 static unsigned long
1762 unsigned long taskbase
, cr3
;
1763 struct dtr_reg gdtr
;
1765 if (pdbr
> 0 && pdbr
<= 0xfffff)
1768 /* Get the linear address of GDT and the Task Register. */
1769 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1770 __asm__
__volatile__ ("str %0" : "=m" (taskreg
) : /* no inputs */ );
1772 /* Task Register is a segment selector for the TSS of the current
1773 task. Therefore, it can be used as an index into the GDT to get
1774 at the segment descriptor for the TSS. To get the index, reset
1775 the low 3 bits of the selector (which give the CPL). Add 2 to the
1776 offset to point to the 3 low bytes of the base address. */
1777 offset
= gdtr
.base
+ (taskreg
& 0xfff8) + 2;
1780 /* CWSDPMI's task base is always under the 1MB mark. */
1781 if (offset
> 0xfffff)
1784 _farsetsel (_dos_ds
);
1785 taskbase
= _farnspeekl (offset
) & 0xffffffU
;
1786 taskbase
+= _farnspeekl (offset
+ 2) & 0xff000000U
;
1787 if (taskbase
> 0xfffff)
1790 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1791 offset 1Ch in the TSS. */
1792 cr3
= _farnspeekl (taskbase
+ 0x1c) & ~0xfff;
1795 #if 0 /* not fullly supported yet */
1796 /* The Page Directory is in UMBs. In that case, CWSDPMI puts
1797 the first Page Table right below the Page Directory. Thus,
1798 the first Page Table's entry for its own address and the Page
1799 Directory entry for that Page Table will hold the same
1800 physical address. The loop below searches the entire UMB
1801 range of addresses for such an occurence. */
1802 unsigned long addr
, pte_idx
;
1804 for (addr
= 0xb0000, pte_idx
= 0xb0;
1806 addr
+= 0x1000, pte_idx
++)
1808 if (((_farnspeekl (addr
+ 4 * pte_idx
) & 0xfffff027) ==
1809 (_farnspeekl (addr
+ 0x1000) & 0xfffff027))
1810 && ((_farnspeekl (addr
+ 4 * pte_idx
+ 4) & 0xfffff000) == cr3
))
1812 cr3
= addr
+ 0x1000;
1825 /* Return the N'th Page Directory entry. */
1826 static unsigned long
1829 unsigned long pde
= 0;
1831 if (pdbr
&& n
>= 0 && n
< 1024)
1833 pde
= _farpeekl (_dos_ds
, pdbr
+ 4*n
);
1838 /* Return the N'th entry of the Page Table whose Page Directory entry
1840 static unsigned long
1841 get_pte (unsigned long pde
, int n
)
1843 unsigned long pte
= 0;
1845 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
1846 page tables, for now. */
1847 if ((pde
& 1) && !(pde
& 0x80) && n
>= 0 && n
< 1024)
1849 pde
&= ~0xfff; /* clear non-address bits */
1850 pte
= _farpeekl (_dos_ds
, pde
+ 4*n
);
1855 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
1856 says this is a Page Directory entry. If FORCE is non-zero, display
1857 the entry even if its Present flag is off. OFF is the offset of the
1858 address from the page's base address. */
1860 display_ptable_entry (unsigned long entry
, int is_dir
, int force
, unsigned off
)
1862 if ((entry
& 1) != 0)
1864 printf_filtered ("Base=0x%05lx000", entry
>> 12);
1865 if ((entry
& 0x100) && !is_dir
)
1866 puts_filtered (" Global");
1867 if ((entry
& 0x40) && !is_dir
)
1868 puts_filtered (" Dirty");
1869 printf_filtered (" %sAcc.", (entry
& 0x20) ? "" : "Not-");
1870 printf_filtered (" %sCached", (entry
& 0x10) ? "" : "Not-");
1871 printf_filtered (" Write-%s", (entry
& 8) ? "Thru" : "Back");
1872 printf_filtered (" %s", (entry
& 4) ? "Usr" : "Sup");
1873 printf_filtered (" Read-%s", (entry
& 2) ? "Write" : "Only");
1875 printf_filtered (" +0x%x", off
);
1876 puts_filtered ("\n");
1879 printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1880 is_dir
? " Table" : "", entry
>> 1);
1884 go32_pde (char *arg
, int from_tty
)
1886 long pde_idx
= -1, i
;
1890 while (*arg
&& isspace(*arg
))
1895 pde_idx
= parse_and_eval_long (arg
);
1896 if (pde_idx
< 0 || pde_idx
>= 1024)
1897 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
1903 puts_filtered ("Access to Page Directories is not supported on this system.\n");
1904 else if (pde_idx
>= 0)
1905 display_ptable_entry (get_pde (pde_idx
), 1, 1, 0);
1907 for (i
= 0; i
< 1024; i
++)
1908 display_ptable_entry (get_pde (i
), 1, 0, 0);
1911 /* A helper function to display entries in a Page Table pointed to by
1912 the N'th entry in the Page Directory. If FORCE is non-zero, say
1913 something even if the Page Table is not accessible. */
1915 display_page_table (long n
, int force
)
1917 unsigned long pde
= get_pde (n
);
1923 printf_filtered ("Page Table pointed to by Page Directory entry 0x%lx:\n", n
);
1924 for (i
= 0; i
< 1024; i
++)
1925 display_ptable_entry (get_pte (pde
, i
), 0, 0, 0);
1926 puts_filtered ("\n");
1929 printf_filtered ("Page Table not present; value=0x%lx.\n", pde
>> 1);
1933 go32_pte (char *arg
, int from_tty
)
1935 long pde_idx
= -1L, i
;
1939 while (*arg
&& isspace(*arg
))
1944 pde_idx
= parse_and_eval_long (arg
);
1945 if (pde_idx
< 0 || pde_idx
>= 1024)
1946 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
1952 puts_filtered ("Access to Page Tables is not supported on this system.\n");
1953 else if (pde_idx
>= 0)
1954 display_page_table (pde_idx
, 1);
1956 for (i
= 0; i
< 1024; i
++)
1957 display_page_table (i
, 0);
1961 go32_pte_for_address (char *arg
, int from_tty
)
1963 CORE_ADDR addr
= 0, i
;
1967 while (*arg
&& isspace(*arg
))
1971 addr
= parse_and_eval_address (arg
);
1974 error_no_arg (_("linear address"));
1978 puts_filtered ("Access to Page Tables is not supported on this system.\n");
1981 int pde_idx
= (addr
>> 22) & 0x3ff;
1982 int pte_idx
= (addr
>> 12) & 0x3ff;
1983 unsigned offs
= addr
& 0xfff;
1985 printf_filtered ("Page Table entry for address 0x%llx:\n",
1986 (unsigned long long)addr
);
1987 display_ptable_entry (get_pte (get_pde (pde_idx
), pte_idx
), 0, 1, offs
);
1991 static struct cmd_list_element
*info_dos_cmdlist
= NULL
;
1994 go32_info_dos_command (char *args
, int from_tty
)
1996 help_list (info_dos_cmdlist
, "info dos ", class_info
, gdb_stdout
);
2000 _initialize_go32_nat (void)
2003 add_target (&go32_ops
);
2005 add_prefix_cmd ("dos", class_info
, go32_info_dos_command
, _("\
2006 Print information specific to DJGPP (aka MS-DOS) debugging."),
2007 &info_dos_cmdlist
, "info dos ", 0, &infolist
);
2009 add_cmd ("sysinfo", class_info
, go32_sysinfo
, _("\
2010 Display information about the target system, including CPU, OS, DPMI, etc."),
2012 add_cmd ("ldt", class_info
, go32_sldt
, _("\
2013 Display entries in the LDT (Local Descriptor Table).\n\
2014 Entry number (an expression) as an argument means display only that entry."),
2016 add_cmd ("gdt", class_info
, go32_sgdt
, _("\
2017 Display entries in the GDT (Global Descriptor Table).\n\
2018 Entry number (an expression) as an argument means display only that entry."),
2020 add_cmd ("idt", class_info
, go32_sidt
, _("\
2021 Display entries in the IDT (Interrupt Descriptor Table).\n\
2022 Entry number (an expression) as an argument means display only that entry."),
2024 add_cmd ("pde", class_info
, go32_pde
, _("\
2025 Display entries in the Page Directory.\n\
2026 Entry number (an expression) as an argument means display only that entry."),
2028 add_cmd ("pte", class_info
, go32_pte
, _("\
2029 Display entries in Page Tables.\n\
2030 Entry number (an expression) as an argument means display only entries\n\
2031 from the Page Table pointed to by the specified Page Directory entry."),
2033 add_cmd ("address-pte", class_info
, go32_pte_for_address
, _("\
2034 Display a Page Table entry for a linear address.\n\
2035 The address argument must be a linear address, after adding to\n\
2036 it the base address of the appropriate segment.\n\
2037 The base address of variables and functions in the debuggee's data\n\
2038 or code segment is stored in the variable __djgpp_base_address,\n\
2039 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
2040 For other segments, look up their base address in the output of\n\
2041 the `info dos ldt' command."),
2055 tcsetpgrp (int fd
, pid_t pgid
)
2057 if (isatty (fd
) && pgid
== SOME_PID
)
2059 errno
= pgid
== SOME_PID
? ENOTTY
: ENOSYS
;