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
)
877 go32_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
880 xsnprintf (buf
, sizeof buf
, "Thread <main>");
887 go32_ops
.to_shortname
= "djgpp";
888 go32_ops
.to_longname
= "djgpp target process";
890 "Program loaded by djgpp, when gdb is used as an external debugger";
891 go32_ops
.to_open
= go32_open
;
892 go32_ops
.to_close
= go32_close
;
893 go32_ops
.to_attach
= go32_attach
;
894 go32_ops
.to_detach
= go32_detach
;
895 go32_ops
.to_resume
= go32_resume
;
896 go32_ops
.to_wait
= go32_wait
;
897 go32_ops
.to_fetch_registers
= go32_fetch_registers
;
898 go32_ops
.to_store_registers
= go32_store_registers
;
899 go32_ops
.to_prepare_to_store
= go32_prepare_to_store
;
900 go32_ops
.deprecated_xfer_memory
= go32_xfer_memory
;
901 go32_ops
.to_files_info
= go32_files_info
;
902 go32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
903 go32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
904 go32_ops
.to_terminal_init
= go32_terminal_init
;
905 go32_ops
.to_terminal_inferior
= go32_terminal_inferior
;
906 go32_ops
.to_terminal_ours_for_output
= go32_terminal_ours
;
907 go32_ops
.to_terminal_ours
= go32_terminal_ours
;
908 go32_ops
.to_terminal_info
= go32_terminal_info
;
909 go32_ops
.to_kill
= go32_kill_inferior
;
910 go32_ops
.to_create_inferior
= go32_create_inferior
;
911 go32_ops
.to_mourn_inferior
= go32_mourn_inferior
;
912 go32_ops
.to_can_run
= go32_can_run
;
913 go32_ops
.to_stop
= go32_stop
;
914 go32_ops
.to_thread_alive
= go32_thread_alive
;
915 go32_ops
.to_pid_to_str
= go32_pid_to_str
;
916 go32_ops
.to_stratum
= process_stratum
;
917 go32_ops
.to_has_all_memory
= 1;
918 go32_ops
.to_has_memory
= 1;
919 go32_ops
.to_has_stack
= 1;
920 go32_ops
.to_has_registers
= 1;
921 go32_ops
.to_has_execution
= 1;
923 i386_use_watchpoints (&go32_ops
);
925 go32_ops
.to_magic
= OPS_MAGIC
;
927 /* Initialize child's cwd as empty to be initialized when starting
931 /* Initialize child's command line storage. */
932 if (redir_debug_init (&child_cmd
) == -1)
933 internal_error (__FILE__
, __LINE__
,
934 _("Cannot allocate redirection storage: not enough memory.\n"));
936 /* We are always processing GCC-compiled programs. */
937 processing_gcc_compilation
= 2;
939 /* Override the default name of the GDB init file. */
940 strcpy (gdbinit
, "gdb.ini");
943 /* Return the current DOS codepage number. */
950 __dpmi_int (0x21, ®s
);
951 if (!(regs
.x
.flags
& 1))
952 return regs
.x
.bx
& 0xffff;
954 return 437; /* default */
957 /* Limited emulation of `nl_langinfo', for charset.c. */
959 nl_langinfo (nl_item item
)
967 /* 8 is enough for SHORT_MAX + "CP" + null. */
969 int blen
= sizeof (buf
);
970 int needed
= snprintf (buf
, blen
, "CP%d", dos_codepage ());
972 if (needed
> blen
) /* should never happen */
974 retval
= xstrdup (buf
);
978 retval
= xstrdup ("");
984 unsigned short windows_major
, windows_minor
;
986 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */
988 go32_get_windows_version(void)
993 __dpmi_int(0x2f, &r
);
994 if (r
.h
.al
> 2 && r
.h
.al
!= 0x80 && r
.h
.al
!= 0xff
995 && (r
.h
.al
> 3 || r
.h
.ah
> 0))
997 windows_major
= r
.h
.al
;
998 windows_minor
= r
.h
.ah
;
1001 windows_major
= 0xff; /* meaning no Windows */
1004 /* A subroutine of go32_sysinfo to display memory info. */
1006 print_mem (unsigned long datum
, const char *header
, int in_pages_p
)
1008 if (datum
!= 0xffffffffUL
)
1012 puts_filtered (header
);
1015 printf_filtered ("%lu KB", datum
>> 10);
1016 if (datum
> 1024 * 1024)
1017 printf_filtered (" (%lu MB)", datum
>> 20);
1020 printf_filtered ("%lu Bytes", datum
);
1021 puts_filtered ("\n");
1025 /* Display assorted information about the underlying OS. */
1027 go32_sysinfo (char *arg
, int from_tty
)
1029 static const char test_pattern
[] =
1030 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1031 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1032 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeafdeadbeaf";
1034 char cpuid_vendor
[13];
1035 unsigned cpuid_max
= 0, cpuid_eax
, cpuid_ebx
, cpuid_ecx
, cpuid_edx
;
1036 unsigned true_dos_version
= _get_dos_version (1);
1037 unsigned advertized_dos_version
= ((unsigned int)_osmajor
<< 8) | _osminor
;
1039 char dpmi_vendor_info
[129];
1040 int dpmi_vendor_available
;
1041 __dpmi_version_ret dpmi_version_data
;
1043 __dpmi_free_mem_info mem_info
;
1046 cpuid_vendor
[0] = '\0';
1048 strcpy (u
.machine
, "Unknown x86");
1049 else if (u
.machine
[0] == 'i' && u
.machine
[1] > 4)
1051 /* CPUID with EAX = 0 returns the Vendor ID. */
1052 __asm__
__volatile__ ("xorl %%ebx, %%ebx;"
1053 "xorl %%ecx, %%ecx;"
1054 "xorl %%edx, %%edx;"
1061 : "=m" (cpuid_vendor
[0]),
1062 "=m" (cpuid_vendor
[4]),
1063 "=m" (cpuid_vendor
[8]),
1066 : "%eax", "%ebx", "%ecx", "%edx");
1067 cpuid_vendor
[12] = '\0';
1070 printf_filtered ("CPU Type.......................%s", u
.machine
);
1071 if (cpuid_vendor
[0])
1072 printf_filtered (" (%s)", cpuid_vendor
);
1073 puts_filtered ("\n");
1075 /* CPUID with EAX = 1 returns processor signature and features. */
1078 static char *brand_name
[] = {
1086 char cpu_string
[80];
1089 int intel_p
= strcmp (cpuid_vendor
, "GenuineIntel") == 0;
1090 int amd_p
= strcmp (cpuid_vendor
, "AuthenticAMD") == 0;
1091 unsigned cpu_family
, cpu_model
;
1093 __asm__
__volatile__ ("movl $1, %%eax;"
1100 brand_idx
= cpuid_ebx
& 0xff;
1101 cpu_family
= (cpuid_eax
>> 8) & 0xf;
1102 cpu_model
= (cpuid_eax
>> 4) & 0xf;
1103 cpu_brand
[0] = '\0';
1107 && brand_idx
< sizeof(brand_name
)/sizeof(brand_name
[0])
1108 && *brand_name
[brand_idx
])
1109 strcpy (cpu_brand
, brand_name
[brand_idx
]);
1110 else if (cpu_family
== 5)
1112 if (((cpuid_eax
>> 12) & 3) == 0 && cpu_model
== 4)
1113 strcpy (cpu_brand
, " MMX");
1114 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 1)
1115 strcpy (cpu_brand
, " OverDrive");
1116 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 2)
1117 strcpy (cpu_brand
, " Dual");
1119 else if (cpu_family
== 6 && cpu_model
< 8)
1124 strcpy (cpu_brand
, " Pro");
1127 strcpy (cpu_brand
, " II");
1130 strcpy (cpu_brand
, " II Xeon");
1133 strcpy (cpu_brand
, " Celeron");
1136 strcpy (cpu_brand
, " III");
1146 strcpy (cpu_brand
, "486/5x86");
1155 strcpy (cpu_brand
, "-K5");
1159 strcpy (cpu_brand
, "-K6");
1162 strcpy (cpu_brand
, "-K6-2");
1165 strcpy (cpu_brand
, "-K6-III");
1175 strcpy (cpu_brand
, " Athlon");
1178 strcpy (cpu_brand
, " Duron");
1184 sprintf (cpu_string
, "%s%s Model %d Stepping %d",
1185 intel_p
? "Pentium" : (amd_p
? "AMD" : "ix86"),
1186 cpu_brand
, cpu_model
, cpuid_eax
& 0xf);
1187 printfi_filtered (31, "%s\n", cpu_string
);
1188 if (((cpuid_edx
& (6 | (0x0d << 23))) != 0)
1189 || ((cpuid_edx
& 1) == 0)
1190 || (amd_p
&& (cpuid_edx
& (3 << 30)) != 0))
1192 puts_filtered ("CPU Features...................");
1193 /* We only list features which might be useful in the DPMI
1195 if ((cpuid_edx
& 1) == 0)
1196 puts_filtered ("No FPU "); /* it's unusual to not have an FPU */
1197 if ((cpuid_edx
& (1 << 1)) != 0)
1198 puts_filtered ("VME ");
1199 if ((cpuid_edx
& (1 << 2)) != 0)
1200 puts_filtered ("DE ");
1201 if ((cpuid_edx
& (1 << 4)) != 0)
1202 puts_filtered ("TSC ");
1203 if ((cpuid_edx
& (1 << 23)) != 0)
1204 puts_filtered ("MMX ");
1205 if ((cpuid_edx
& (1 << 25)) != 0)
1206 puts_filtered ("SSE ");
1207 if ((cpuid_edx
& (1 << 26)) != 0)
1208 puts_filtered ("SSE2 ");
1211 if ((cpuid_edx
& (1 << 31)) != 0)
1212 puts_filtered ("3DNow! ");
1213 if ((cpuid_edx
& (1 << 30)) != 0)
1214 puts_filtered ("3DNow!Ext");
1216 puts_filtered ("\n");
1219 puts_filtered ("\n");
1220 printf_filtered ("DOS Version....................%s %s.%s",
1221 _os_flavor
, u
.release
, u
.version
);
1222 if (true_dos_version
!= advertized_dos_version
)
1223 printf_filtered (" (disguised as v%d.%d)", _osmajor
, _osminor
);
1224 puts_filtered ("\n");
1226 go32_get_windows_version ();
1227 if (windows_major
!= 0xff)
1229 const char *windows_flavor
;
1231 printf_filtered ("Windows Version................%d.%02d (Windows ",
1232 windows_major
, windows_minor
);
1233 switch (windows_major
)
1236 windows_flavor
= "3.X";
1239 switch (windows_minor
)
1242 windows_flavor
= "95, 95A, or 95B";
1245 windows_flavor
= "95B OSR2.1 or 95C OSR2.5";
1248 windows_flavor
= "98 or 98 SE";
1251 windows_flavor
= "ME";
1254 windows_flavor
= "9X";
1259 windows_flavor
= "??";
1262 printf_filtered ("%s)\n", windows_flavor
);
1264 else if (true_dos_version
== 0x532 && advertized_dos_version
== 0x500)
1265 printf_filtered ("Windows Version................Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
1266 puts_filtered ("\n");
1267 /* On some versions of Windows, __dpmi_get_capabilities returns
1268 zero, but the buffer is not filled with info, so we fill the
1269 buffer with a known pattern and test for it afterwards. */
1270 memcpy (dpmi_vendor_info
, test_pattern
, sizeof(dpmi_vendor_info
));
1271 dpmi_vendor_available
=
1272 __dpmi_get_capabilities (&dpmi_flags
, dpmi_vendor_info
);
1273 if (dpmi_vendor_available
== 0
1274 && memcmp (dpmi_vendor_info
, test_pattern
,
1275 sizeof(dpmi_vendor_info
)) != 0)
1277 /* The DPMI spec says the vendor string should be ASCIIZ, but
1278 I don't trust the vendors to follow that... */
1279 if (!memchr (&dpmi_vendor_info
[2], 0, 126))
1280 dpmi_vendor_info
[128] = '\0';
1281 printf_filtered ("DPMI Host......................%s v%d.%d (capabilities: %#x)\n",
1282 &dpmi_vendor_info
[2],
1283 (unsigned)dpmi_vendor_info
[0],
1284 (unsigned)dpmi_vendor_info
[1],
1285 ((unsigned)dpmi_flags
& 0x7f));
1288 printf_filtered ("DPMI Host......................(Info not available)\n");
1289 __dpmi_get_version (&dpmi_version_data
);
1290 printf_filtered ("DPMI Version...................%d.%02d\n",
1291 dpmi_version_data
.major
, dpmi_version_data
.minor
);
1292 printf_filtered ("DPMI Info......................%s-bit DPMI, with%s Virtual Memory support\n",
1293 (dpmi_version_data
.flags
& 1) ? "32" : "16",
1294 (dpmi_version_data
.flags
& 4) ? "" : "out");
1295 printfi_filtered (31, "Interrupts reflected to %s mode\n",
1296 (dpmi_version_data
.flags
& 2) ? "V86" : "Real");
1297 printfi_filtered (31, "Processor type: i%d86\n",
1298 dpmi_version_data
.cpu
);
1299 printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
1300 dpmi_version_data
.master_pic
, dpmi_version_data
.slave_pic
);
1302 /* a_tss is only initialized when the debuggee is first run. */
1303 if (prog_has_started
)
1305 __asm__
__volatile__ ("pushfl ; popl %0" : "=g" (eflags
));
1306 printf_filtered ("Protection.....................Ring %d (in %s), with%s I/O protection\n",
1307 a_tss
.tss_cs
& 3, (a_tss
.tss_cs
& 4) ? "LDT" : "GDT",
1308 (a_tss
.tss_cs
& 3) > ((eflags
>> 12) & 3) ? "" : "out");
1310 puts_filtered ("\n");
1311 __dpmi_get_free_memory_information (&mem_info
);
1312 print_mem (mem_info
.total_number_of_physical_pages
,
1313 "DPMI Total Physical Memory.....", 1);
1314 print_mem (mem_info
.total_number_of_free_pages
,
1315 "DPMI Free Physical Memory......", 1);
1316 print_mem (mem_info
.size_of_paging_file_partition_in_pages
,
1317 "DPMI Swap Space................", 1);
1318 print_mem (mem_info
.linear_address_space_size_in_pages
,
1319 "DPMI Total Linear Address Size.", 1);
1320 print_mem (mem_info
.free_linear_address_space_in_pages
,
1321 "DPMI Free Linear Address Size..", 1);
1322 print_mem (mem_info
.largest_available_free_block_in_bytes
,
1323 "DPMI Largest Free Memory Block.", 0);
1327 __dpmi_int (0x21, ®s
);
1328 print_mem (regs
.x
.bx
<< 4, "Free DOS Memory................", 0);
1330 __dpmi_int (0x21, ®s
);
1331 if ((regs
.x
.flags
& 1) == 0)
1333 static const char *dos_hilo
[] = {
1334 "Low", "", "", "", "High", "", "", "", "High, then Low"
1336 static const char *dos_fit
[] = {
1337 "First", "Best", "Last"
1339 int hilo_idx
= (regs
.x
.ax
>> 4) & 0x0f;
1340 int fit_idx
= regs
.x
.ax
& 0x0f;
1346 printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1347 dos_hilo
[hilo_idx
], dos_fit
[fit_idx
]);
1349 __dpmi_int (0x21, ®s
);
1350 if ((regs
.x
.flags
& 1) != 0)
1352 printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1353 regs
.h
.al
== 0 ? "not " : "");
1358 unsigned short limit0
;
1359 unsigned short base0
;
1360 unsigned char base1
;
1365 unsigned available
:1;
1368 unsigned page_granular
:1;
1369 unsigned char base2
;
1370 } __attribute__ ((packed
));
1373 unsigned short offset0
;
1374 unsigned short selector
;
1375 unsigned param_count
:5;
1380 unsigned short offset1
;
1381 } __attribute__ ((packed
));
1383 /* Read LEN bytes starting at logical address ADDR, and put the result
1384 into DEST. Return 1 if success, zero if not. */
1386 read_memory_region (unsigned long addr
, void *dest
, size_t len
)
1388 unsigned long dos_ds_limit
= __dpmi_get_segment_limit (_dos_ds
);
1391 /* For the low memory, we can simply use _dos_ds. */
1392 if (addr
<= dos_ds_limit
- len
)
1393 dosmemget (addr
, len
, dest
);
1396 /* For memory above 1MB we need to set up a special segment to
1397 be able to access that memory. */
1398 int sel
= __dpmi_allocate_ldt_descriptors (1);
1404 int access_rights
= __dpmi_get_descriptor_access_rights (sel
);
1405 size_t segment_limit
= len
- 1;
1407 /* Make sure the crucial bits in the descriptor access
1408 rights are set correctly. Some DPMI providers might barf
1409 if we set the segment limit to something that is not an
1410 integral multiple of 4KB pages if the granularity bit is
1411 not set to byte-granular, even though the DPMI spec says
1412 it's the host's responsibility to set that bit correctly. */
1413 if (len
> 1024 * 1024)
1415 access_rights
|= 0x8000;
1416 /* Page-granular segments should have the low 12 bits of
1418 segment_limit
|= 0xfff;
1421 access_rights
&= ~0x8000;
1423 if (__dpmi_set_segment_base_address (sel
, addr
) != -1
1424 && __dpmi_set_descriptor_access_rights (sel
, access_rights
) != -1
1425 && __dpmi_set_segment_limit (sel
, segment_limit
) != -1
1426 /* W2K silently fails to set the segment limit, leaving
1427 it at zero; this test avoids the resulting crash. */
1428 && __dpmi_get_segment_limit (sel
) >= segment_limit
)
1429 movedata (sel
, 0, _my_ds (), (unsigned)dest
, len
);
1433 __dpmi_free_ldt_descriptor (sel
);
1439 /* Get a segment descriptor stored at index IDX in the descriptor
1440 table whose base address is TABLE_BASE. Return the descriptor
1441 type, or -1 if failure. */
1443 get_descriptor (unsigned long table_base
, int idx
, void *descr
)
1445 unsigned long addr
= table_base
+ idx
* 8; /* 8 bytes per entry */
1447 if (read_memory_region (addr
, descr
, 8))
1448 return (int)((struct seg_descr
*)descr
)->stype
;
1453 unsigned short limit
__attribute__((packed
));
1454 unsigned long base
__attribute__((packed
));
1457 /* Display a segment descriptor stored at index IDX in a descriptor
1458 table whose type is TYPE and whose base address is BASE_ADDR. If
1459 FORCE is non-zero, display even invalid descriptors. */
1461 display_descriptor (unsigned type
, unsigned long base_addr
, int idx
, int force
)
1463 struct seg_descr descr
;
1464 struct gate_descr gate
;
1466 /* Get the descriptor from the table. */
1467 if (idx
== 0 && type
== 0)
1468 puts_filtered ("0x000: null descriptor\n");
1469 else if (get_descriptor (base_addr
, idx
, &descr
) != -1)
1471 /* For each type of descriptor table, this has a bit set if the
1472 corresponding type of selectors is valid in that table. */
1473 static unsigned allowed_descriptors
[] = {
1474 0xffffdafeL
, /* GDT */
1475 0x0000c0e0L
, /* IDT */
1476 0xffffdafaL
/* LDT */
1479 /* If the program hasn't started yet, assume the debuggee will
1480 have the same CPL as the debugger. */
1481 int cpl
= prog_has_started
? (a_tss
.tss_cs
& 3) : _my_cs () & 3;
1482 unsigned long limit
= (descr
.limit1
<< 16) | descr
.limit0
;
1485 && (allowed_descriptors
[type
] & (1 << descr
.stype
)) != 0)
1487 printf_filtered ("0x%03x: ",
1489 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1490 if (descr
.page_granular
)
1491 limit
= (limit
<< 12) | 0xfff; /* big segment: low 12 bit set */
1492 if (descr
.stype
== 1 || descr
.stype
== 2 || descr
.stype
== 3
1493 || descr
.stype
== 9 || descr
.stype
== 11
1494 || (descr
.stype
>= 16 && descr
.stype
< 32))
1495 printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1496 descr
.base2
, descr
.base1
, descr
.base0
, limit
);
1498 switch (descr
.stype
)
1502 printf_filtered (" 16-bit TSS (task %sactive)",
1503 descr
.stype
== 3 ? "" : "in");
1506 puts_filtered (" LDT");
1509 memcpy (&gate
, &descr
, sizeof gate
);
1510 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1511 gate
.selector
, gate
.offset1
, gate
.offset0
);
1512 printf_filtered (" 16-bit Call Gate (params=%d)",
1516 printf_filtered ("TSS selector=0x%04x", descr
.base0
);
1517 printfi_filtered (16, "Task Gate");
1521 memcpy (&gate
, &descr
, sizeof gate
);
1522 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1523 gate
.selector
, gate
.offset1
, gate
.offset0
);
1524 printf_filtered (" 16-bit %s Gate",
1525 descr
.stype
== 6 ? "Interrupt" : "Trap");
1529 printf_filtered (" 32-bit TSS (task %sactive)",
1530 descr
.stype
== 3 ? "" : "in");
1533 memcpy (&gate
, &descr
, sizeof gate
);
1534 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1535 gate
.selector
, gate
.offset1
, gate
.offset0
);
1536 printf_filtered (" 32-bit Call Gate (params=%d)",
1541 memcpy (&gate
, &descr
, sizeof gate
);
1542 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1543 gate
.selector
, gate
.offset1
, gate
.offset0
);
1544 printf_filtered (" 32-bit %s Gate",
1545 descr
.stype
== 14 ? "Interrupt" : "Trap");
1547 case 16: /* data segments */
1555 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1556 descr
.bit32
? "32" : "16",
1557 descr
.stype
& 2 ? "Read/Write," : "Read-Only, ",
1558 descr
.stype
& 4 ? "down" : "up",
1559 descr
.stype
& 1 ? "" : ", N.Acc");
1561 case 24: /* code segments */
1569 printf_filtered (" %s-bit Code (%s, %sConf%s)",
1570 descr
.bit32
? "32" : "16",
1571 descr
.stype
& 2 ? "Exec/Read" : "Exec-Only",
1572 descr
.stype
& 4 ? "" : "N.",
1573 descr
.stype
& 1 ? "" : ", N.Acc");
1576 printf_filtered ("Unknown type 0x%02x", descr
.stype
);
1579 puts_filtered ("\n");
1583 printf_filtered ("0x%03x: ",
1585 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1587 puts_filtered ("Segment not present\n");
1589 printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1594 printf_filtered ("0x%03x: Cannot read this descriptor\n", idx
);
1598 go32_sldt (char *arg
, int from_tty
)
1600 struct dtr_reg gdtr
;
1601 unsigned short ldtr
= 0;
1603 struct seg_descr ldt_descr
;
1604 long ldt_entry
= -1L;
1605 int cpl
= (prog_has_started
? a_tss
.tss_cs
: _my_cs ()) & 3;
1609 while (*arg
&& isspace(*arg
))
1614 ldt_entry
= parse_and_eval_long (arg
);
1616 || (ldt_entry
& 4) == 0
1617 || (ldt_entry
& 3) != (cpl
& 3))
1618 error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry
);
1622 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1623 __asm__
__volatile__ ("sldt %0" : "=m" (ldtr
) : /* no inputs */ );
1626 puts_filtered ("There is no LDT.\n");
1627 /* LDT's entry in the GDT must have the type LDT, which is 2. */
1628 else if (get_descriptor (gdtr
.base
, ldt_idx
, &ldt_descr
) != 2)
1629 printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1631 | (ldt_descr
.base1
<< 16)
1632 | (ldt_descr
.base2
<< 24));
1637 | (ldt_descr
.base1
<< 16)
1638 | (ldt_descr
.base2
<< 24);
1639 unsigned limit
= ldt_descr
.limit0
| (ldt_descr
.limit1
<< 16);
1642 if (ldt_descr
.page_granular
)
1643 /* Page-granular segments must have the low 12 bits of their
1645 limit
= (limit
<< 12) | 0xfff;
1646 /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1651 max_entry
= (limit
+ 1) / 8;
1655 if (ldt_entry
> limit
)
1656 error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1657 (unsigned long)ldt_entry
, limit
);
1659 display_descriptor (ldt_descr
.stype
, base
, ldt_entry
/ 8, 1);
1665 for (i
= 0; i
< max_entry
; i
++)
1666 display_descriptor (ldt_descr
.stype
, base
, i
, 0);
1672 go32_sgdt (char *arg
, int from_tty
)
1674 struct dtr_reg gdtr
;
1675 long gdt_entry
= -1L;
1680 while (*arg
&& isspace(*arg
))
1685 gdt_entry
= parse_and_eval_long (arg
);
1686 if (gdt_entry
< 0 || (gdt_entry
& 7) != 0)
1687 error (_("Invalid GDT entry 0x%03lx: not an integral multiple of 8."),
1688 (unsigned long)gdt_entry
);
1692 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1693 max_entry
= (gdtr
.limit
+ 1) / 8;
1697 if (gdt_entry
> gdtr
.limit
)
1698 error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1699 (unsigned long)gdt_entry
, gdtr
.limit
);
1701 display_descriptor (0, gdtr
.base
, gdt_entry
/ 8, 1);
1707 for (i
= 0; i
< max_entry
; i
++)
1708 display_descriptor (0, gdtr
.base
, i
, 0);
1713 go32_sidt (char *arg
, int from_tty
)
1715 struct dtr_reg idtr
;
1716 long idt_entry
= -1L;
1721 while (*arg
&& isspace(*arg
))
1726 idt_entry
= parse_and_eval_long (arg
);
1728 error (_("Invalid (negative) IDT entry %ld."), idt_entry
);
1732 __asm__
__volatile__ ("sidt %0" : "=m" (idtr
) : /* no inputs */ );
1733 max_entry
= (idtr
.limit
+ 1) / 8;
1734 if (max_entry
> 0x100) /* no more than 256 entries */
1739 if (idt_entry
> idtr
.limit
)
1740 error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1741 (unsigned long)idt_entry
, idtr
.limit
);
1743 display_descriptor (1, idtr
.base
, idt_entry
, 1);
1749 for (i
= 0; i
< max_entry
; i
++)
1750 display_descriptor (1, idtr
.base
, i
, 0);
1754 /* Cached linear address of the base of the page directory. For
1755 now, available only under CWSDPMI. Code based on ideas and
1756 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
1757 static unsigned long pdbr
;
1759 static unsigned long
1764 unsigned long taskbase
, cr3
;
1765 struct dtr_reg gdtr
;
1767 if (pdbr
> 0 && pdbr
<= 0xfffff)
1770 /* Get the linear address of GDT and the Task Register. */
1771 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1772 __asm__
__volatile__ ("str %0" : "=m" (taskreg
) : /* no inputs */ );
1774 /* Task Register is a segment selector for the TSS of the current
1775 task. Therefore, it can be used as an index into the GDT to get
1776 at the segment descriptor for the TSS. To get the index, reset
1777 the low 3 bits of the selector (which give the CPL). Add 2 to the
1778 offset to point to the 3 low bytes of the base address. */
1779 offset
= gdtr
.base
+ (taskreg
& 0xfff8) + 2;
1782 /* CWSDPMI's task base is always under the 1MB mark. */
1783 if (offset
> 0xfffff)
1786 _farsetsel (_dos_ds
);
1787 taskbase
= _farnspeekl (offset
) & 0xffffffU
;
1788 taskbase
+= _farnspeekl (offset
+ 2) & 0xff000000U
;
1789 if (taskbase
> 0xfffff)
1792 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1793 offset 1Ch in the TSS. */
1794 cr3
= _farnspeekl (taskbase
+ 0x1c) & ~0xfff;
1797 #if 0 /* not fullly supported yet */
1798 /* The Page Directory is in UMBs. In that case, CWSDPMI puts
1799 the first Page Table right below the Page Directory. Thus,
1800 the first Page Table's entry for its own address and the Page
1801 Directory entry for that Page Table will hold the same
1802 physical address. The loop below searches the entire UMB
1803 range of addresses for such an occurence. */
1804 unsigned long addr
, pte_idx
;
1806 for (addr
= 0xb0000, pte_idx
= 0xb0;
1808 addr
+= 0x1000, pte_idx
++)
1810 if (((_farnspeekl (addr
+ 4 * pte_idx
) & 0xfffff027) ==
1811 (_farnspeekl (addr
+ 0x1000) & 0xfffff027))
1812 && ((_farnspeekl (addr
+ 4 * pte_idx
+ 4) & 0xfffff000) == cr3
))
1814 cr3
= addr
+ 0x1000;
1827 /* Return the N'th Page Directory entry. */
1828 static unsigned long
1831 unsigned long pde
= 0;
1833 if (pdbr
&& n
>= 0 && n
< 1024)
1835 pde
= _farpeekl (_dos_ds
, pdbr
+ 4*n
);
1840 /* Return the N'th entry of the Page Table whose Page Directory entry
1842 static unsigned long
1843 get_pte (unsigned long pde
, int n
)
1845 unsigned long pte
= 0;
1847 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
1848 page tables, for now. */
1849 if ((pde
& 1) && !(pde
& 0x80) && n
>= 0 && n
< 1024)
1851 pde
&= ~0xfff; /* clear non-address bits */
1852 pte
= _farpeekl (_dos_ds
, pde
+ 4*n
);
1857 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
1858 says this is a Page Directory entry. If FORCE is non-zero, display
1859 the entry even if its Present flag is off. OFF is the offset of the
1860 address from the page's base address. */
1862 display_ptable_entry (unsigned long entry
, int is_dir
, int force
, unsigned off
)
1864 if ((entry
& 1) != 0)
1866 printf_filtered ("Base=0x%05lx000", entry
>> 12);
1867 if ((entry
& 0x100) && !is_dir
)
1868 puts_filtered (" Global");
1869 if ((entry
& 0x40) && !is_dir
)
1870 puts_filtered (" Dirty");
1871 printf_filtered (" %sAcc.", (entry
& 0x20) ? "" : "Not-");
1872 printf_filtered (" %sCached", (entry
& 0x10) ? "" : "Not-");
1873 printf_filtered (" Write-%s", (entry
& 8) ? "Thru" : "Back");
1874 printf_filtered (" %s", (entry
& 4) ? "Usr" : "Sup");
1875 printf_filtered (" Read-%s", (entry
& 2) ? "Write" : "Only");
1877 printf_filtered (" +0x%x", off
);
1878 puts_filtered ("\n");
1881 printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1882 is_dir
? " Table" : "", entry
>> 1);
1886 go32_pde (char *arg
, int from_tty
)
1888 long pde_idx
= -1, i
;
1892 while (*arg
&& isspace(*arg
))
1897 pde_idx
= parse_and_eval_long (arg
);
1898 if (pde_idx
< 0 || pde_idx
>= 1024)
1899 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
1905 puts_filtered ("Access to Page Directories is not supported on this system.\n");
1906 else if (pde_idx
>= 0)
1907 display_ptable_entry (get_pde (pde_idx
), 1, 1, 0);
1909 for (i
= 0; i
< 1024; i
++)
1910 display_ptable_entry (get_pde (i
), 1, 0, 0);
1913 /* A helper function to display entries in a Page Table pointed to by
1914 the N'th entry in the Page Directory. If FORCE is non-zero, say
1915 something even if the Page Table is not accessible. */
1917 display_page_table (long n
, int force
)
1919 unsigned long pde
= get_pde (n
);
1925 printf_filtered ("Page Table pointed to by Page Directory entry 0x%lx:\n", n
);
1926 for (i
= 0; i
< 1024; i
++)
1927 display_ptable_entry (get_pte (pde
, i
), 0, 0, 0);
1928 puts_filtered ("\n");
1931 printf_filtered ("Page Table not present; value=0x%lx.\n", pde
>> 1);
1935 go32_pte (char *arg
, int from_tty
)
1937 long pde_idx
= -1L, i
;
1941 while (*arg
&& isspace(*arg
))
1946 pde_idx
= parse_and_eval_long (arg
);
1947 if (pde_idx
< 0 || pde_idx
>= 1024)
1948 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
1954 puts_filtered ("Access to Page Tables is not supported on this system.\n");
1955 else if (pde_idx
>= 0)
1956 display_page_table (pde_idx
, 1);
1958 for (i
= 0; i
< 1024; i
++)
1959 display_page_table (i
, 0);
1963 go32_pte_for_address (char *arg
, int from_tty
)
1965 CORE_ADDR addr
= 0, i
;
1969 while (*arg
&& isspace(*arg
))
1973 addr
= parse_and_eval_address (arg
);
1976 error_no_arg (_("linear address"));
1980 puts_filtered ("Access to Page Tables is not supported on this system.\n");
1983 int pde_idx
= (addr
>> 22) & 0x3ff;
1984 int pte_idx
= (addr
>> 12) & 0x3ff;
1985 unsigned offs
= addr
& 0xfff;
1987 printf_filtered ("Page Table entry for address 0x%llx:\n",
1988 (unsigned long long)addr
);
1989 display_ptable_entry (get_pte (get_pde (pde_idx
), pte_idx
), 0, 1, offs
);
1993 static struct cmd_list_element
*info_dos_cmdlist
= NULL
;
1996 go32_info_dos_command (char *args
, int from_tty
)
1998 help_list (info_dos_cmdlist
, "info dos ", class_info
, gdb_stdout
);
2002 _initialize_go32_nat (void)
2005 add_target (&go32_ops
);
2007 add_prefix_cmd ("dos", class_info
, go32_info_dos_command
, _("\
2008 Print information specific to DJGPP (aka MS-DOS) debugging."),
2009 &info_dos_cmdlist
, "info dos ", 0, &infolist
);
2011 add_cmd ("sysinfo", class_info
, go32_sysinfo
, _("\
2012 Display information about the target system, including CPU, OS, DPMI, etc."),
2014 add_cmd ("ldt", class_info
, go32_sldt
, _("\
2015 Display entries in the LDT (Local Descriptor Table).\n\
2016 Entry number (an expression) as an argument means display only that entry."),
2018 add_cmd ("gdt", class_info
, go32_sgdt
, _("\
2019 Display entries in the GDT (Global Descriptor Table).\n\
2020 Entry number (an expression) as an argument means display only that entry."),
2022 add_cmd ("idt", class_info
, go32_sidt
, _("\
2023 Display entries in the IDT (Interrupt Descriptor Table).\n\
2024 Entry number (an expression) as an argument means display only that entry."),
2026 add_cmd ("pde", class_info
, go32_pde
, _("\
2027 Display entries in the Page Directory.\n\
2028 Entry number (an expression) as an argument means display only that entry."),
2030 add_cmd ("pte", class_info
, go32_pte
, _("\
2031 Display entries in Page Tables.\n\
2032 Entry number (an expression) as an argument means display only entries\n\
2033 from the Page Table pointed to by the specified Page Directory entry."),
2035 add_cmd ("address-pte", class_info
, go32_pte_for_address
, _("\
2036 Display a Page Table entry for a linear address.\n\
2037 The address argument must be a linear address, after adding to\n\
2038 it the base address of the appropriate segment.\n\
2039 The base address of variables and functions in the debuggee's data\n\
2040 or code segment is stored in the variable __djgpp_base_address,\n\
2041 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
2042 For other segments, look up their base address in the output of\n\
2043 the `info dos ldt' command."),
2057 tcsetpgrp (int fd
, pid_t pgid
)
2059 if (isatty (fd
) && pgid
== SOME_PID
)
2061 errno
= pgid
== SOME_PID
? ENOTTY
: ENOSYS
;