1 /* Native debugging support for Intel x86 running DJGPP.
2 Copyright (C) 1997, 1999-2001, 2005-2012 Free Software Foundation,
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/>. */
21 /* To whomever it may concern, here's a general description of how
22 debugging in DJGPP works, and the special quirks GDB does to
25 When the DJGPP port of GDB is debugging a DJGPP program natively,
26 there aren't 2 separate processes, the debuggee and GDB itself, as
27 on other systems. (This is DOS, where there can only be one active
28 process at any given time, remember?) Instead, GDB and the
29 debuggee live in the same process. So when GDB calls
30 go32_create_inferior below, and that function calls edi_init from
31 the DJGPP debug support library libdbg.a, we load the debuggee's
32 executable file into GDB's address space, set it up for execution
33 as the stub loader (a short real-mode program prepended to each
34 DJGPP executable) normally would, and do a lot of preparations for
35 swapping between GDB's and debuggee's internal state, primarily wrt
36 the exception handlers. This swapping happens every time we resume
37 the debuggee or switch back to GDB's code, and it includes:
39 . swapping all the segment registers
40 . swapping the PSP (the Program Segment Prefix)
41 . swapping the signal handlers
42 . swapping the exception handlers
43 . swapping the FPU status
44 . swapping the 3 standard file handles (more about this below)
46 Then running the debuggee simply means longjmp into it where its PC
47 is and let it run until it stops for some reason. When it stops,
48 GDB catches the exception that stopped it and longjmp's back into
49 its own code. All the possible exit points of the debuggee are
50 watched; for example, the normal exit point is recognized because a
51 DOS program issues a special system call to exit. If one of those
52 exit points is hit, we mourn the inferior and clean up after it.
53 Cleaning up is very important, even if the process exits normally,
54 because otherwise we might leave behind traces of previous
55 execution, and in several cases GDB itself might be left hosed,
56 because all the exception handlers were not restored.
58 Swapping of the standard handles (in redir_to_child and
59 redir_to_debugger) is needed because, since both GDB and the
60 debuggee live in the same process, as far as the OS is concerned,
61 the share the same file table. This means that the standard
62 handles 0, 1, and 2 point to the same file table entries, and thus
63 are connected to the same devices. Therefore, if the debugger
64 redirects its standard output, the standard output of the debuggee
65 is also automagically redirected to the same file/device!
66 Similarly, if the debuggee redirects its stdout to a file, you
67 won't be able to see debugger's output (it will go to the same file
68 where the debuggee has its output); and if the debuggee closes its
69 standard input, you will lose the ability to talk to debugger!
71 For this reason, every time the debuggee is about to be resumed, we
72 call redir_to_child, which redirects the standard handles to where
73 the debuggee expects them to be. When the debuggee stops and GDB
74 regains control, we call redir_to_debugger, which redirects those 3
75 handles back to where GDB expects.
77 Note that only the first 3 handles are swapped, so if the debuggee
78 redirects or closes any other handles, GDB will not notice. In
79 particular, the exit code of a DJGPP program forcibly closes all
80 file handles beyond the first 3 ones, so when the debuggee exits,
81 GDB currently loses its stdaux and stdprn streams. Fortunately,
82 GDB does not use those as of this writing, and will never need
91 #include "gdbthread.h"
96 #include "floatformat.h"
98 #include "i387-tdep.h"
99 #include "i386-tdep.h"
101 #include "regcache.h"
102 #include "gdb_string.h"
105 #include <stdio.h> /* might be required for __DJGPP_MINOR__ */
110 #include <sys/utsname.h>
115 #include <sys/farptr.h>
116 #include <debug/v2load.h>
117 #include <debug/dbgcom.h>
118 #if __DJGPP_MINOR__ > 2
119 #include <debug/redir.h>
122 #include <langinfo.h>
124 #if __DJGPP_MINOR__ < 3
125 /* This code will be provided from DJGPP 2.03 on. Until then I code it
133 unsigned short exponent
:15;
134 unsigned short sign
:1;
140 unsigned int control
;
145 unsigned int dataptr
;
146 unsigned int datasel
;
153 static void save_npx (void); /* Save the FPU of the debugged program. */
154 static void load_npx (void); /* Restore the FPU of the debugged program. */
156 /* ------------------------------------------------------------------------- */
157 /* Store the contents of the NPX in the global variable `npx'. */
163 asm ("inb $0xa0, %%al \n\
164 testb $0x20, %%al \n\
182 /* ------------------------------------------------------------------------- */
183 /* Reload the contents of the NPX from the global variable `npx'. */
188 asm ("frstor %0":"=m" (npx
));
190 /* ------------------------------------------------------------------------- */
191 /* Stubs for the missing redirection functions. */
198 redir_cmdline_delete (cmdline_t
*ptr
)
204 redir_cmdline_parse (const char *args
, cmdline_t
*ptr
)
210 redir_to_child (cmdline_t
*ptr
)
216 redir_to_debugger (cmdline_t
*ptr
)
222 redir_debug_init (cmdline_t
*ptr
)
226 #endif /* __DJGPP_MINOR < 3 */
228 typedef enum { wp_insert
, wp_remove
, wp_count
} wp_op
;
230 /* This holds the current reference counts for each debug register. */
231 static int dr_ref_count
[4];
235 static int prog_has_started
= 0;
236 static void go32_open (char *name
, int from_tty
);
237 static void go32_close (int quitting
);
238 static void go32_attach (struct target_ops
*ops
, char *args
, int from_tty
);
239 static void go32_detach (struct target_ops
*ops
, char *args
, int from_tty
);
240 static void go32_resume (struct target_ops
*ops
,
241 ptid_t ptid
, int step
,
242 enum gdb_signal siggnal
);
243 static void go32_fetch_registers (struct target_ops
*ops
,
244 struct regcache
*, int regno
);
245 static void store_register (const struct regcache
*, int regno
);
246 static void go32_store_registers (struct target_ops
*ops
,
247 struct regcache
*, int regno
);
248 static void go32_prepare_to_store (struct regcache
*);
249 static int go32_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
,
251 struct mem_attrib
*attrib
,
252 struct target_ops
*target
);
253 static void go32_files_info (struct target_ops
*target
);
254 static void go32_kill_inferior (struct target_ops
*ops
);
255 static void go32_create_inferior (struct target_ops
*ops
, char *exec_file
,
256 char *args
, char **env
, int from_tty
);
257 static void go32_mourn_inferior (struct target_ops
*ops
);
258 static int go32_can_run (void);
260 static struct target_ops go32_ops
;
261 static void go32_terminal_init (void);
262 static void go32_terminal_inferior (void);
263 static void go32_terminal_ours (void);
265 #define r_ofs(x) (offsetof(TSS,x))
274 {r_ofs (tss_eax
), 4}, /* normal registers, from a_tss */
275 {r_ofs (tss_ecx
), 4},
276 {r_ofs (tss_edx
), 4},
277 {r_ofs (tss_ebx
), 4},
278 {r_ofs (tss_esp
), 4},
279 {r_ofs (tss_ebp
), 4},
280 {r_ofs (tss_esi
), 4},
281 {r_ofs (tss_edi
), 4},
282 {r_ofs (tss_eip
), 4},
283 {r_ofs (tss_eflags
), 4},
290 {0, 10}, /* 8 FP registers, from npx.reg[] */
298 /* The order of the next 7 registers must be consistent
299 with their numbering in config/i386/tm-i386.h, which see. */
300 {0, 2}, /* control word, from npx */
301 {4, 2}, /* status word, from npx */
302 {8, 2}, /* tag word, from npx */
303 {16, 2}, /* last FP exception CS from npx */
304 {12, 4}, /* last FP exception EIP from npx */
305 {24, 2}, /* last FP exception operand selector from npx */
306 {20, 4}, /* last FP exception operand offset from npx */
307 {18, 2} /* last FP opcode from npx */
313 enum gdb_signal gdb_sig
;
318 {1, GDB_SIGNAL_TRAP
},
319 /* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
320 but I think SIGBUS is better, since the NMI is usually activated
321 as a result of a memory parity check failure. */
323 {3, GDB_SIGNAL_TRAP
},
325 {5, GDB_SIGNAL_SEGV
},
327 {7, GDB_SIGNAL_EMT
}, /* no-coprocessor exception */
328 {8, GDB_SIGNAL_SEGV
},
329 {9, GDB_SIGNAL_SEGV
},
330 {10, GDB_SIGNAL_BUS
},
331 {11, GDB_SIGNAL_SEGV
},
332 {12, GDB_SIGNAL_SEGV
},
333 {13, GDB_SIGNAL_SEGV
},
334 {14, GDB_SIGNAL_SEGV
},
335 {16, GDB_SIGNAL_FPE
},
336 {17, GDB_SIGNAL_BUS
},
337 {31, GDB_SIGNAL_ILL
},
338 {0x1b, GDB_SIGNAL_INT
},
339 {0x75, GDB_SIGNAL_FPE
},
340 {0x78, GDB_SIGNAL_ALRM
},
341 {0x79, GDB_SIGNAL_INT
},
342 {0x7a, GDB_SIGNAL_QUIT
},
343 {-1, GDB_SIGNAL_LAST
}
347 enum gdb_signal gdb_sig
;
351 {GDB_SIGNAL_ILL
, 6}, /* Invalid Opcode */
352 {GDB_SIGNAL_EMT
, 7}, /* triggers SIGNOFP */
353 {GDB_SIGNAL_SEGV
, 13}, /* GPF */
354 {GDB_SIGNAL_BUS
, 17}, /* Alignment Check */
355 /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
357 {GDB_SIGNAL_TERM
, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
358 {GDB_SIGNAL_FPE
, 0x75},
359 {GDB_SIGNAL_INT
, 0x79},
360 {GDB_SIGNAL_QUIT
, 0x7a},
361 {GDB_SIGNAL_ALRM
, 0x78}, /* triggers SIGTIMR */
362 {GDB_SIGNAL_PROF
, 0x78},
363 {GDB_SIGNAL_LAST
, -1}
367 go32_open (char *name
, int from_tty
)
369 printf_unfiltered ("Done. Use the \"run\" command to run the program.\n");
373 go32_close (int quitting
)
378 go32_attach (struct target_ops
*ops
, char *args
, int from_tty
)
381 You cannot attach to a running program on this platform.\n\
382 Use the `run' command to run DJGPP programs."));
386 go32_detach (struct target_ops
*ops
, char *args
, int from_tty
)
390 static int resume_is_step
;
391 static int resume_signal
= -1;
394 go32_resume (struct target_ops
*ops
,
395 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
399 resume_is_step
= step
;
401 if (siggnal
!= GDB_SIGNAL_0
&& siggnal
!= GDB_SIGNAL_TRAP
)
403 for (i
= 0, resume_signal
= -1;
404 excepn_map
[i
].gdb_sig
!= GDB_SIGNAL_LAST
; i
++)
405 if (excepn_map
[i
].gdb_sig
== siggnal
)
407 resume_signal
= excepn_map
[i
].djgpp_excepno
;
410 if (resume_signal
== -1)
411 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
412 gdb_signal_to_name (siggnal
));
416 static char child_cwd
[FILENAME_MAX
];
419 go32_wait (struct target_ops
*ops
,
420 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
423 unsigned char saved_opcode
;
424 unsigned long INT3_addr
= 0;
425 int stepping_over_INT
= 0;
427 a_tss
.tss_eflags
&= 0xfeff; /* Reset the single-step flag (TF). */
430 /* If the next instruction is INT xx or INTO, we need to handle
431 them specially. Intel manuals say that these instructions
432 reset the single-step flag (a.k.a. TF). However, it seems
433 that, at least in the DPMI environment, and at least when
434 stepping over the DPMI interrupt 31h, the problem is having
435 TF set at all when INT 31h is executed: the debuggee either
436 crashes (and takes the system with it) or is killed by a
439 So we need to emulate single-step mode: we put an INT3 opcode
440 right after the INT xx instruction, let the debuggee run
441 until it hits INT3 and stops, then restore the original
442 instruction which we overwrote with the INT3 opcode, and back
443 up the debuggee's EIP to that instruction. */
444 read_child (a_tss
.tss_eip
, &saved_opcode
, 1);
445 if (saved_opcode
== 0xCD || saved_opcode
== 0xCE)
447 unsigned char INT3_opcode
= 0xCC;
450 = saved_opcode
== 0xCD ? a_tss
.tss_eip
+ 2 : a_tss
.tss_eip
+ 1;
451 stepping_over_INT
= 1;
452 read_child (INT3_addr
, &saved_opcode
, 1);
453 write_child (INT3_addr
, &INT3_opcode
, 1);
456 a_tss
.tss_eflags
|= 0x0100; /* normal instruction: set TF */
459 /* The special value FFFFh in tss_trap indicates to run_child that
460 tss_irqn holds a signal to be delivered to the debuggee. */
461 if (resume_signal
<= -1)
464 a_tss
.tss_irqn
= 0xff;
468 a_tss
.tss_trap
= 0xffff; /* run_child looks for this. */
469 a_tss
.tss_irqn
= resume_signal
;
472 /* The child might change working directory behind our back. The
473 GDB users won't like the side effects of that when they work with
474 relative file names, and GDB might be confused by its current
475 directory not being in sync with the truth. So we always make a
476 point of changing back to where GDB thinks is its cwd, when we
477 return control to the debugger, but restore child's cwd before we
479 /* Initialize child_cwd, before the first call to run_child and not
480 in the initialization, so the child get also the changed directory
481 set with the gdb-command "cd ..." */
483 /* Initialize child's cwd with the current one. */
484 getcwd (child_cwd
, sizeof (child_cwd
));
488 #if __DJGPP_MINOR__ < 3
492 #if __DJGPP_MINOR__ < 3
496 /* Did we step over an INT xx instruction? */
497 if (stepping_over_INT
&& a_tss
.tss_eip
== INT3_addr
+ 1)
499 /* Restore the original opcode. */
500 a_tss
.tss_eip
--; /* EIP points *after* the INT3 instruction. */
501 write_child (a_tss
.tss_eip
, &saved_opcode
, 1);
502 /* Simulate a TRAP exception. */
504 a_tss
.tss_eflags
|= 0x0100;
507 getcwd (child_cwd
, sizeof (child_cwd
)); /* in case it has changed */
508 chdir (current_directory
);
510 if (a_tss
.tss_irqn
== 0x21)
512 status
->kind
= TARGET_WAITKIND_EXITED
;
513 status
->value
.integer
= a_tss
.tss_eax
& 0xff;
517 status
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
518 status
->kind
= TARGET_WAITKIND_STOPPED
;
519 for (i
= 0; sig_map
[i
].go32_sig
!= -1; i
++)
521 if (a_tss
.tss_irqn
== sig_map
[i
].go32_sig
)
523 #if __DJGPP_MINOR__ < 3
524 if ((status
->value
.sig
= sig_map
[i
].gdb_sig
) !=
526 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
528 status
->value
.sig
= sig_map
[i
].gdb_sig
;
534 return pid_to_ptid (SOME_PID
);
538 fetch_register (struct regcache
*regcache
, int regno
)
540 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
541 if (regno
< gdbarch_fp0_regnum (gdbarch
))
542 regcache_raw_supply (regcache
, regno
,
543 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
544 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
,
546 i387_supply_fsave (regcache
, regno
, &npx
);
548 internal_error (__FILE__
, __LINE__
,
549 _("Invalid register no. %d in fetch_register."), regno
);
553 go32_fetch_registers (struct target_ops
*ops
,
554 struct regcache
*regcache
, int regno
)
557 fetch_register (regcache
, regno
);
561 regno
< gdbarch_fp0_regnum (get_regcache_arch (regcache
));
563 fetch_register (regcache
, regno
);
564 i387_supply_fsave (regcache
, -1, &npx
);
569 store_register (const struct regcache
*regcache
, int regno
)
571 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
572 if (regno
< gdbarch_fp0_regnum (gdbarch
))
573 regcache_raw_collect (regcache
, regno
,
574 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
575 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
,
577 i387_collect_fsave (regcache
, regno
, &npx
);
579 internal_error (__FILE__
, __LINE__
,
580 _("Invalid register no. %d in store_register."), regno
);
584 go32_store_registers (struct target_ops
*ops
,
585 struct regcache
*regcache
, int regno
)
590 store_register (regcache
, regno
);
593 for (r
= 0; r
< gdbarch_fp0_regnum (get_regcache_arch (regcache
)); r
++)
594 store_register (regcache
, r
);
595 i387_collect_fsave (regcache
, -1, &npx
);
600 go32_prepare_to_store (struct regcache
*regcache
)
605 go32_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
,
606 struct mem_attrib
*attrib
, struct target_ops
*target
)
610 if (write_child (memaddr
, myaddr
, len
))
621 if (read_child (memaddr
, myaddr
, len
))
632 static cmdline_t child_cmd
; /* Parsed child's command line kept here. */
635 go32_files_info (struct target_ops
*target
)
637 printf_unfiltered ("You are running a DJGPP V2 program.\n");
641 go32_kill_inferior (struct target_ops
*ops
)
643 go32_mourn_inferior (ops
);
647 go32_create_inferior (struct target_ops
*ops
, char *exec_file
,
648 char *args
, char **env
, int from_tty
)
650 extern char **environ
;
653 char **env_save
= environ
;
655 struct inferior
*inf
;
657 /* If no exec file handed to us, get it from the exec-file command -- with
658 a good, common error message if none is specified. */
660 exec_file
= get_exec_file (1);
665 /* Initialize child's cwd as empty to be initialized when starting
669 /* Init command line storage. */
670 if (redir_debug_init (&child_cmd
) == -1)
671 internal_error (__FILE__
, __LINE__
,
672 _("Cannot allocate redirection storage: "
673 "not enough memory.\n"));
675 /* Parse the command line and create redirections. */
676 if (strpbrk (args
, "<>"))
678 if (redir_cmdline_parse (args
, &child_cmd
) == 0)
679 args
= child_cmd
.command
;
681 error (_("Syntax error in command line."));
684 child_cmd
.command
= xstrdup (args
);
686 cmdlen
= strlen (args
);
687 /* v2loadimage passes command lines via DOS memory, so it cannot
688 possibly handle commands longer than 1MB. */
689 if (cmdlen
> 1024*1024)
690 error (_("Command line too long."));
692 cmdline
= xmalloc (cmdlen
+ 4);
693 strcpy (cmdline
+ 1, args
);
694 /* If the command-line length fits into DOS 126-char limits, use the
695 DOS command tail format; otherwise, tell v2loadimage to pass it
696 through a buffer in conventional memory. */
699 cmdline
[0] = strlen (args
);
700 cmdline
[cmdlen
+ 1] = 13;
703 cmdline
[0] = 0xff; /* Signal v2loadimage it's a long command. */
707 if (v2loadimage (exec_file
, cmdline
, start_state
))
710 printf_unfiltered ("Load failed for image %s\n", exec_file
);
716 edi_init (start_state
);
717 #if __DJGPP_MINOR__ < 3
721 inferior_ptid
= pid_to_ptid (SOME_PID
);
722 inf
= current_inferior ();
723 inferior_appeared (inf
, SOME_PID
);
725 push_target (&go32_ops
);
727 add_thread_silent (inferior_ptid
);
729 clear_proceed_status ();
730 insert_breakpoints ();
731 prog_has_started
= 1;
735 go32_mourn_inferior (struct target_ops
*ops
)
739 redir_cmdline_delete (&child_cmd
);
745 /* We need to make sure all the breakpoint enable bits in the DR7
746 register are reset when the inferior exits. Otherwise, if they
747 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
748 failure to set more watchpoints, and other calamities. It would
749 be nice if GDB itself would take care to remove all breakpoints
750 at all times, but it doesn't, probably under an assumption that
751 the OS cleans up when the debuggee exits. */
752 i386_cleanup_dregs ();
754 ptid
= inferior_ptid
;
755 inferior_ptid
= null_ptid
;
756 delete_thread_silent (ptid
);
757 prog_has_started
= 0;
760 generic_mourn_inferior ();
769 /* Hardware watchpoint support. */
771 #define D_REGS edi.dr
772 #define CONTROL D_REGS[7]
773 #define STATUS D_REGS[6]
775 /* Pass the address ADDR to the inferior in the I'th debug register.
776 Here we just store the address in D_REGS, the watchpoint will be
777 actually set up when go32_wait runs the debuggee. */
779 go32_set_dr (int i
, CORE_ADDR addr
)
782 internal_error (__FILE__
, __LINE__
,
783 _("Invalid register %d in go32_set_dr.\n"), i
);
787 /* Pass the value VAL to the inferior in the DR7 debug control
788 register. Here we just store the address in D_REGS, the watchpoint
789 will be actually set up when go32_wait runs the debuggee. */
791 go32_set_dr7 (unsigned long val
)
796 /* Get the value of the DR6 debug status register from the inferior.
797 Here we just return the value stored in D_REGS, as we've got it
798 from the last go32_wait call. */
805 /* Get the value of the DR7 debug status register from the inferior.
806 Here we just return the value stored in D_REGS, as we've got it
807 from the last go32_wait call. */
815 /* Get the value of the DR debug register I from the inferior. Here
816 we just return the value stored in D_REGS, as we've got it from the
817 last go32_wait call. */
823 internal_error (__FILE__
, __LINE__
,
824 _("Invalid register %d in go32_get_dr.\n"), i
);
828 /* Put the device open on handle FD into either raw or cooked
829 mode, return 1 if it was in raw mode, zero otherwise. */
832 device_mode (int fd
, int raw_p
)
834 int oldmode
, newmode
;
839 __dpmi_int (0x21, ®s
);
840 if (regs
.x
.flags
& 1)
842 newmode
= oldmode
= regs
.x
.dx
;
849 if (oldmode
& 0x80) /* Only for character dev. */
853 regs
.x
.dx
= newmode
& 0xff; /* Force upper byte zero, else it fails. */
854 __dpmi_int (0x21, ®s
);
855 if (regs
.x
.flags
& 1)
858 return (oldmode
& 0x20) == 0x20;
862 static int inf_mode_valid
= 0;
863 static int inf_terminal_mode
;
865 /* This semaphore is needed because, amazingly enough, GDB calls
866 target.to_terminal_ours more than once after the inferior stops.
867 But we need the information from the first call only, since the
868 second call will always see GDB's own cooked terminal. */
869 static int terminal_is_ours
= 1;
872 go32_terminal_init (void)
874 inf_mode_valid
= 0; /* Reinitialize, in case they are restarting child. */
875 terminal_is_ours
= 1;
879 go32_terminal_info (char *args
, int from_tty
)
881 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
883 ? "default" : inf_terminal_mode
? "raw" : "cooked");
885 #if __DJGPP_MINOR__ > 2
886 if (child_cmd
.redirection
)
890 for (i
= 0; i
< DBG_HANDLES
; i
++)
892 if (child_cmd
.redirection
[i
]->file_name
)
893 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
894 i
, child_cmd
.redirection
[i
]->file_name
);
895 else if (_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) == -1)
897 ("\tFile handle %d appears to be closed by inferior.\n", i
);
898 /* Mask off the raw/cooked bit when comparing device info words. */
899 else if ((_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) & 0xdf)
900 != (_get_dev_info (i
) & 0xdf))
902 ("\tFile handle %d appears to be redirected by inferior.\n", i
);
909 go32_terminal_inferior (void)
911 /* Redirect standard handles as child wants them. */
913 if (redir_to_child (&child_cmd
) == -1)
915 redir_to_debugger (&child_cmd
);
916 error (_("Cannot redirect standard handles for program: %s."),
917 safe_strerror (errno
));
919 /* Set the console device of the inferior to whatever mode
920 (raw or cooked) we found it last time. */
921 if (terminal_is_ours
)
924 device_mode (0, inf_terminal_mode
);
925 terminal_is_ours
= 0;
930 go32_terminal_ours (void)
932 /* Switch to cooked mode on the gdb terminal and save the inferior
933 terminal mode to be restored when it is resumed. */
934 if (!terminal_is_ours
)
936 inf_terminal_mode
= device_mode (0, 0);
937 if (inf_terminal_mode
!= -1)
940 /* If device_mode returned -1, we don't know what happens with
941 handle 0 anymore, so make the info invalid. */
943 terminal_is_ours
= 1;
945 /* Restore debugger's standard handles. */
947 if (redir_to_debugger (&child_cmd
) == -1)
949 redir_to_child (&child_cmd
);
950 error (_("Cannot redirect standard handles for debugger: %s."),
951 safe_strerror (errno
));
957 go32_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
959 return !ptid_equal (inferior_ptid
, null_ptid
);
963 go32_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
965 return normal_pid_to_str (ptid
);
971 go32_ops
.to_shortname
= "djgpp";
972 go32_ops
.to_longname
= "djgpp target process";
974 "Program loaded by djgpp, when gdb is used as an external debugger";
975 go32_ops
.to_open
= go32_open
;
976 go32_ops
.to_close
= go32_close
;
977 go32_ops
.to_attach
= go32_attach
;
978 go32_ops
.to_detach
= go32_detach
;
979 go32_ops
.to_resume
= go32_resume
;
980 go32_ops
.to_wait
= go32_wait
;
981 go32_ops
.to_fetch_registers
= go32_fetch_registers
;
982 go32_ops
.to_store_registers
= go32_store_registers
;
983 go32_ops
.to_prepare_to_store
= go32_prepare_to_store
;
984 go32_ops
.deprecated_xfer_memory
= go32_xfer_memory
;
985 go32_ops
.to_files_info
= go32_files_info
;
986 go32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
987 go32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
988 go32_ops
.to_terminal_init
= go32_terminal_init
;
989 go32_ops
.to_terminal_inferior
= go32_terminal_inferior
;
990 go32_ops
.to_terminal_ours_for_output
= go32_terminal_ours
;
991 go32_ops
.to_terminal_ours
= go32_terminal_ours
;
992 go32_ops
.to_terminal_info
= go32_terminal_info
;
993 go32_ops
.to_kill
= go32_kill_inferior
;
994 go32_ops
.to_create_inferior
= go32_create_inferior
;
995 go32_ops
.to_mourn_inferior
= go32_mourn_inferior
;
996 go32_ops
.to_can_run
= go32_can_run
;
997 go32_ops
.to_thread_alive
= go32_thread_alive
;
998 go32_ops
.to_pid_to_str
= go32_pid_to_str
;
999 go32_ops
.to_stratum
= process_stratum
;
1000 go32_ops
.to_has_all_memory
= default_child_has_all_memory
;
1001 go32_ops
.to_has_memory
= default_child_has_memory
;
1002 go32_ops
.to_has_stack
= default_child_has_stack
;
1003 go32_ops
.to_has_registers
= default_child_has_registers
;
1004 go32_ops
.to_has_execution
= default_child_has_execution
;
1006 i386_use_watchpoints (&go32_ops
);
1009 i386_dr_low
.set_control
= go32_set_dr7
;
1010 i386_dr_low
.set_addr
= go32_set_dr
;
1011 i386_dr_low
.get_status
= go32_get_dr6
;
1012 i386_dr_low
.get_control
= go32_get_dr7
;
1013 i386_dr_low
.get_addr
= go32_get_dr
;
1014 i386_set_debug_register_length (4);
1016 go32_ops
.to_magic
= OPS_MAGIC
;
1018 /* Initialize child's cwd as empty to be initialized when starting
1022 /* Initialize child's command line storage. */
1023 if (redir_debug_init (&child_cmd
) == -1)
1024 internal_error (__FILE__
, __LINE__
,
1025 _("Cannot allocate redirection storage: "
1026 "not enough memory.\n"));
1028 /* We are always processing GCC-compiled programs. */
1029 processing_gcc_compilation
= 2;
1031 /* Override the default name of the GDB init file. */
1032 strcpy (gdbinit
, "gdb.ini");
1035 /* Return the current DOS codepage number. */
1042 __dpmi_int (0x21, ®s
);
1043 if (!(regs
.x
.flags
& 1))
1044 return regs
.x
.bx
& 0xffff;
1046 return 437; /* default */
1049 /* Limited emulation of `nl_langinfo', for charset.c. */
1051 nl_langinfo (nl_item item
)
1059 /* 8 is enough for SHORT_MAX + "CP" + null. */
1061 int blen
= sizeof (buf
);
1062 int needed
= snprintf (buf
, blen
, "CP%d", dos_codepage ());
1064 if (needed
> blen
) /* Should never happen. */
1066 retval
= xstrdup (buf
);
1070 retval
= xstrdup ("");
1076 unsigned short windows_major
, windows_minor
;
1078 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */
1080 go32_get_windows_version(void)
1085 __dpmi_int(0x2f, &r
);
1086 if (r
.h
.al
> 2 && r
.h
.al
!= 0x80 && r
.h
.al
!= 0xff
1087 && (r
.h
.al
> 3 || r
.h
.ah
> 0))
1089 windows_major
= r
.h
.al
;
1090 windows_minor
= r
.h
.ah
;
1093 windows_major
= 0xff; /* meaning no Windows */
1096 /* A subroutine of go32_sysinfo to display memory info. */
1098 print_mem (unsigned long datum
, const char *header
, int in_pages_p
)
1100 if (datum
!= 0xffffffffUL
)
1104 puts_filtered (header
);
1107 printf_filtered ("%lu KB", datum
>> 10);
1108 if (datum
> 1024 * 1024)
1109 printf_filtered (" (%lu MB)", datum
>> 20);
1112 printf_filtered ("%lu Bytes", datum
);
1113 puts_filtered ("\n");
1117 /* Display assorted information about the underlying OS. */
1119 go32_sysinfo (char *arg
, int from_tty
)
1121 static const char test_pattern
[] =
1122 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1123 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1124 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeafdeadbeaf";
1126 char cpuid_vendor
[13];
1127 unsigned cpuid_max
= 0, cpuid_eax
, cpuid_ebx
, cpuid_ecx
, cpuid_edx
;
1128 unsigned true_dos_version
= _get_dos_version (1);
1129 unsigned advertized_dos_version
= ((unsigned int)_osmajor
<< 8) | _osminor
;
1131 char dpmi_vendor_info
[129];
1132 int dpmi_vendor_available
;
1133 __dpmi_version_ret dpmi_version_data
;
1135 __dpmi_free_mem_info mem_info
;
1138 cpuid_vendor
[0] = '\0';
1140 strcpy (u
.machine
, "Unknown x86");
1141 else if (u
.machine
[0] == 'i' && u
.machine
[1] > 4)
1143 /* CPUID with EAX = 0 returns the Vendor ID. */
1144 __asm__
__volatile__ ("xorl %%ebx, %%ebx;"
1145 "xorl %%ecx, %%ecx;"
1146 "xorl %%edx, %%edx;"
1153 : "=m" (cpuid_vendor
[0]),
1154 "=m" (cpuid_vendor
[4]),
1155 "=m" (cpuid_vendor
[8]),
1158 : "%eax", "%ebx", "%ecx", "%edx");
1159 cpuid_vendor
[12] = '\0';
1162 printf_filtered ("CPU Type.......................%s", u
.machine
);
1163 if (cpuid_vendor
[0])
1164 printf_filtered (" (%s)", cpuid_vendor
);
1165 puts_filtered ("\n");
1167 /* CPUID with EAX = 1 returns processor signature and features. */
1170 static char *brand_name
[] = {
1178 char cpu_string
[80];
1181 int intel_p
= strcmp (cpuid_vendor
, "GenuineIntel") == 0;
1182 int amd_p
= strcmp (cpuid_vendor
, "AuthenticAMD") == 0;
1183 unsigned cpu_family
, cpu_model
;
1185 __asm__
__volatile__ ("movl $1, %%eax;"
1192 brand_idx
= cpuid_ebx
& 0xff;
1193 cpu_family
= (cpuid_eax
>> 8) & 0xf;
1194 cpu_model
= (cpuid_eax
>> 4) & 0xf;
1195 cpu_brand
[0] = '\0';
1199 && brand_idx
< sizeof(brand_name
)/sizeof(brand_name
[0])
1200 && *brand_name
[brand_idx
])
1201 strcpy (cpu_brand
, brand_name
[brand_idx
]);
1202 else if (cpu_family
== 5)
1204 if (((cpuid_eax
>> 12) & 3) == 0 && cpu_model
== 4)
1205 strcpy (cpu_brand
, " MMX");
1206 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 1)
1207 strcpy (cpu_brand
, " OverDrive");
1208 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 2)
1209 strcpy (cpu_brand
, " Dual");
1211 else if (cpu_family
== 6 && cpu_model
< 8)
1216 strcpy (cpu_brand
, " Pro");
1219 strcpy (cpu_brand
, " II");
1222 strcpy (cpu_brand
, " II Xeon");
1225 strcpy (cpu_brand
, " Celeron");
1228 strcpy (cpu_brand
, " III");
1238 strcpy (cpu_brand
, "486/5x86");
1247 strcpy (cpu_brand
, "-K5");
1251 strcpy (cpu_brand
, "-K6");
1254 strcpy (cpu_brand
, "-K6-2");
1257 strcpy (cpu_brand
, "-K6-III");
1267 strcpy (cpu_brand
, " Athlon");
1270 strcpy (cpu_brand
, " Duron");
1276 xsnprintf (cpu_string
, sizeof (cpu_string
), "%s%s Model %d Stepping %d",
1277 intel_p
? "Pentium" : (amd_p
? "AMD" : "ix86"),
1278 cpu_brand
, cpu_model
, cpuid_eax
& 0xf);
1279 printfi_filtered (31, "%s\n", cpu_string
);
1280 if (((cpuid_edx
& (6 | (0x0d << 23))) != 0)
1281 || ((cpuid_edx
& 1) == 0)
1282 || (amd_p
&& (cpuid_edx
& (3 << 30)) != 0))
1284 puts_filtered ("CPU Features...................");
1285 /* We only list features which might be useful in the DPMI
1287 if ((cpuid_edx
& 1) == 0)
1288 puts_filtered ("No FPU "); /* It's unusual to not have an FPU. */
1289 if ((cpuid_edx
& (1 << 1)) != 0)
1290 puts_filtered ("VME ");
1291 if ((cpuid_edx
& (1 << 2)) != 0)
1292 puts_filtered ("DE ");
1293 if ((cpuid_edx
& (1 << 4)) != 0)
1294 puts_filtered ("TSC ");
1295 if ((cpuid_edx
& (1 << 23)) != 0)
1296 puts_filtered ("MMX ");
1297 if ((cpuid_edx
& (1 << 25)) != 0)
1298 puts_filtered ("SSE ");
1299 if ((cpuid_edx
& (1 << 26)) != 0)
1300 puts_filtered ("SSE2 ");
1303 if ((cpuid_edx
& (1 << 31)) != 0)
1304 puts_filtered ("3DNow! ");
1305 if ((cpuid_edx
& (1 << 30)) != 0)
1306 puts_filtered ("3DNow!Ext");
1308 puts_filtered ("\n");
1311 puts_filtered ("\n");
1312 printf_filtered ("DOS Version....................%s %s.%s",
1313 _os_flavor
, u
.release
, u
.version
);
1314 if (true_dos_version
!= advertized_dos_version
)
1315 printf_filtered (" (disguised as v%d.%d)", _osmajor
, _osminor
);
1316 puts_filtered ("\n");
1318 go32_get_windows_version ();
1319 if (windows_major
!= 0xff)
1321 const char *windows_flavor
;
1323 printf_filtered ("Windows Version................%d.%02d (Windows ",
1324 windows_major
, windows_minor
);
1325 switch (windows_major
)
1328 windows_flavor
= "3.X";
1331 switch (windows_minor
)
1334 windows_flavor
= "95, 95A, or 95B";
1337 windows_flavor
= "95B OSR2.1 or 95C OSR2.5";
1340 windows_flavor
= "98 or 98 SE";
1343 windows_flavor
= "ME";
1346 windows_flavor
= "9X";
1351 windows_flavor
= "??";
1354 printf_filtered ("%s)\n", windows_flavor
);
1356 else if (true_dos_version
== 0x532 && advertized_dos_version
== 0x500)
1357 printf_filtered ("Windows Version................"
1358 "Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
1359 puts_filtered ("\n");
1360 /* On some versions of Windows, __dpmi_get_capabilities returns
1361 zero, but the buffer is not filled with info, so we fill the
1362 buffer with a known pattern and test for it afterwards. */
1363 memcpy (dpmi_vendor_info
, test_pattern
, sizeof(dpmi_vendor_info
));
1364 dpmi_vendor_available
=
1365 __dpmi_get_capabilities (&dpmi_flags
, dpmi_vendor_info
);
1366 if (dpmi_vendor_available
== 0
1367 && memcmp (dpmi_vendor_info
, test_pattern
,
1368 sizeof(dpmi_vendor_info
)) != 0)
1370 /* The DPMI spec says the vendor string should be ASCIIZ, but
1371 I don't trust the vendors to follow that... */
1372 if (!memchr (&dpmi_vendor_info
[2], 0, 126))
1373 dpmi_vendor_info
[128] = '\0';
1374 printf_filtered ("DPMI Host......................"
1375 "%s v%d.%d (capabilities: %#x)\n",
1376 &dpmi_vendor_info
[2],
1377 (unsigned)dpmi_vendor_info
[0],
1378 (unsigned)dpmi_vendor_info
[1],
1379 ((unsigned)dpmi_flags
& 0x7f));
1382 printf_filtered ("DPMI Host......................(Info not available)\n");
1383 __dpmi_get_version (&dpmi_version_data
);
1384 printf_filtered ("DPMI Version...................%d.%02d\n",
1385 dpmi_version_data
.major
, dpmi_version_data
.minor
);
1386 printf_filtered ("DPMI Info......................"
1387 "%s-bit DPMI, with%s Virtual Memory support\n",
1388 (dpmi_version_data
.flags
& 1) ? "32" : "16",
1389 (dpmi_version_data
.flags
& 4) ? "" : "out");
1390 printfi_filtered (31, "Interrupts reflected to %s mode\n",
1391 (dpmi_version_data
.flags
& 2) ? "V86" : "Real");
1392 printfi_filtered (31, "Processor type: i%d86\n",
1393 dpmi_version_data
.cpu
);
1394 printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
1395 dpmi_version_data
.master_pic
, dpmi_version_data
.slave_pic
);
1397 /* a_tss is only initialized when the debuggee is first run. */
1398 if (prog_has_started
)
1400 __asm__
__volatile__ ("pushfl ; popl %0" : "=g" (eflags
));
1401 printf_filtered ("Protection....................."
1402 "Ring %d (in %s), with%s I/O protection\n",
1403 a_tss
.tss_cs
& 3, (a_tss
.tss_cs
& 4) ? "LDT" : "GDT",
1404 (a_tss
.tss_cs
& 3) > ((eflags
>> 12) & 3) ? "" : "out");
1406 puts_filtered ("\n");
1407 __dpmi_get_free_memory_information (&mem_info
);
1408 print_mem (mem_info
.total_number_of_physical_pages
,
1409 "DPMI Total Physical Memory.....", 1);
1410 print_mem (mem_info
.total_number_of_free_pages
,
1411 "DPMI Free Physical Memory......", 1);
1412 print_mem (mem_info
.size_of_paging_file_partition_in_pages
,
1413 "DPMI Swap Space................", 1);
1414 print_mem (mem_info
.linear_address_space_size_in_pages
,
1415 "DPMI Total Linear Address Size.", 1);
1416 print_mem (mem_info
.free_linear_address_space_in_pages
,
1417 "DPMI Free Linear Address Size..", 1);
1418 print_mem (mem_info
.largest_available_free_block_in_bytes
,
1419 "DPMI Largest Free Memory Block.", 0);
1423 __dpmi_int (0x21, ®s
);
1424 print_mem (regs
.x
.bx
<< 4, "Free DOS Memory................", 0);
1426 __dpmi_int (0x21, ®s
);
1427 if ((regs
.x
.flags
& 1) == 0)
1429 static const char *dos_hilo
[] = {
1430 "Low", "", "", "", "High", "", "", "", "High, then Low"
1432 static const char *dos_fit
[] = {
1433 "First", "Best", "Last"
1435 int hilo_idx
= (regs
.x
.ax
>> 4) & 0x0f;
1436 int fit_idx
= regs
.x
.ax
& 0x0f;
1442 printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1443 dos_hilo
[hilo_idx
], dos_fit
[fit_idx
]);
1445 __dpmi_int (0x21, ®s
);
1446 if ((regs
.x
.flags
& 1) != 0)
1448 printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1449 regs
.h
.al
== 0 ? "not " : "");
1454 unsigned short limit0
;
1455 unsigned short base0
;
1456 unsigned char base1
;
1461 unsigned available
:1;
1464 unsigned page_granular
:1;
1465 unsigned char base2
;
1466 } __attribute__ ((packed
));
1469 unsigned short offset0
;
1470 unsigned short selector
;
1471 unsigned param_count
:5;
1476 unsigned short offset1
;
1477 } __attribute__ ((packed
));
1479 /* Read LEN bytes starting at logical address ADDR, and put the result
1480 into DEST. Return 1 if success, zero if not. */
1482 read_memory_region (unsigned long addr
, void *dest
, size_t len
)
1484 unsigned long dos_ds_limit
= __dpmi_get_segment_limit (_dos_ds
);
1487 /* For the low memory, we can simply use _dos_ds. */
1488 if (addr
<= dos_ds_limit
- len
)
1489 dosmemget (addr
, len
, dest
);
1492 /* For memory above 1MB we need to set up a special segment to
1493 be able to access that memory. */
1494 int sel
= __dpmi_allocate_ldt_descriptors (1);
1500 int access_rights
= __dpmi_get_descriptor_access_rights (sel
);
1501 size_t segment_limit
= len
- 1;
1503 /* Make sure the crucial bits in the descriptor access
1504 rights are set correctly. Some DPMI providers might barf
1505 if we set the segment limit to something that is not an
1506 integral multiple of 4KB pages if the granularity bit is
1507 not set to byte-granular, even though the DPMI spec says
1508 it's the host's responsibility to set that bit correctly. */
1509 if (len
> 1024 * 1024)
1511 access_rights
|= 0x8000;
1512 /* Page-granular segments should have the low 12 bits of
1514 segment_limit
|= 0xfff;
1517 access_rights
&= ~0x8000;
1519 if (__dpmi_set_segment_base_address (sel
, addr
) != -1
1520 && __dpmi_set_descriptor_access_rights (sel
, access_rights
) != -1
1521 && __dpmi_set_segment_limit (sel
, segment_limit
) != -1
1522 /* W2K silently fails to set the segment limit, leaving
1523 it at zero; this test avoids the resulting crash. */
1524 && __dpmi_get_segment_limit (sel
) >= segment_limit
)
1525 movedata (sel
, 0, _my_ds (), (unsigned)dest
, len
);
1529 __dpmi_free_ldt_descriptor (sel
);
1535 /* Get a segment descriptor stored at index IDX in the descriptor
1536 table whose base address is TABLE_BASE. Return the descriptor
1537 type, or -1 if failure. */
1539 get_descriptor (unsigned long table_base
, int idx
, void *descr
)
1541 unsigned long addr
= table_base
+ idx
* 8; /* 8 bytes per entry */
1543 if (read_memory_region (addr
, descr
, 8))
1544 return (int)((struct seg_descr
*)descr
)->stype
;
1549 unsigned short limit
__attribute__((packed
));
1550 unsigned long base
__attribute__((packed
));
1553 /* Display a segment descriptor stored at index IDX in a descriptor
1554 table whose type is TYPE and whose base address is BASE_ADDR. If
1555 FORCE is non-zero, display even invalid descriptors. */
1557 display_descriptor (unsigned type
, unsigned long base_addr
, int idx
, int force
)
1559 struct seg_descr descr
;
1560 struct gate_descr gate
;
1562 /* Get the descriptor from the table. */
1563 if (idx
== 0 && type
== 0)
1564 puts_filtered ("0x000: null descriptor\n");
1565 else if (get_descriptor (base_addr
, idx
, &descr
) != -1)
1567 /* For each type of descriptor table, this has a bit set if the
1568 corresponding type of selectors is valid in that table. */
1569 static unsigned allowed_descriptors
[] = {
1570 0xffffdafeL
, /* GDT */
1571 0x0000c0e0L
, /* IDT */
1572 0xffffdafaL
/* LDT */
1575 /* If the program hasn't started yet, assume the debuggee will
1576 have the same CPL as the debugger. */
1577 int cpl
= prog_has_started
? (a_tss
.tss_cs
& 3) : _my_cs () & 3;
1578 unsigned long limit
= (descr
.limit1
<< 16) | descr
.limit0
;
1581 && (allowed_descriptors
[type
] & (1 << descr
.stype
)) != 0)
1583 printf_filtered ("0x%03x: ",
1585 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1586 if (descr
.page_granular
)
1587 limit
= (limit
<< 12) | 0xfff; /* big segment: low 12 bit set */
1588 if (descr
.stype
== 1 || descr
.stype
== 2 || descr
.stype
== 3
1589 || descr
.stype
== 9 || descr
.stype
== 11
1590 || (descr
.stype
>= 16 && descr
.stype
< 32))
1591 printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1592 descr
.base2
, descr
.base1
, descr
.base0
, limit
);
1594 switch (descr
.stype
)
1598 printf_filtered (" 16-bit TSS (task %sactive)",
1599 descr
.stype
== 3 ? "" : "in");
1602 puts_filtered (" LDT");
1605 memcpy (&gate
, &descr
, sizeof gate
);
1606 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1607 gate
.selector
, gate
.offset1
, gate
.offset0
);
1608 printf_filtered (" 16-bit Call Gate (params=%d)",
1612 printf_filtered ("TSS selector=0x%04x", descr
.base0
);
1613 printfi_filtered (16, "Task Gate");
1617 memcpy (&gate
, &descr
, sizeof gate
);
1618 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1619 gate
.selector
, gate
.offset1
, gate
.offset0
);
1620 printf_filtered (" 16-bit %s Gate",
1621 descr
.stype
== 6 ? "Interrupt" : "Trap");
1625 printf_filtered (" 32-bit TSS (task %sactive)",
1626 descr
.stype
== 3 ? "" : "in");
1629 memcpy (&gate
, &descr
, sizeof gate
);
1630 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1631 gate
.selector
, gate
.offset1
, gate
.offset0
);
1632 printf_filtered (" 32-bit Call Gate (params=%d)",
1637 memcpy (&gate
, &descr
, sizeof gate
);
1638 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1639 gate
.selector
, gate
.offset1
, gate
.offset0
);
1640 printf_filtered (" 32-bit %s Gate",
1641 descr
.stype
== 14 ? "Interrupt" : "Trap");
1643 case 16: /* data segments */
1651 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1652 descr
.bit32
? "32" : "16",
1654 ? "Read/Write," : "Read-Only, ",
1655 descr
.stype
& 4 ? "down" : "up",
1656 descr
.stype
& 1 ? "" : ", N.Acc");
1658 case 24: /* code segments */
1666 printf_filtered (" %s-bit Code (%s, %sConf%s)",
1667 descr
.bit32
? "32" : "16",
1668 descr
.stype
& 2 ? "Exec/Read" : "Exec-Only",
1669 descr
.stype
& 4 ? "" : "N.",
1670 descr
.stype
& 1 ? "" : ", N.Acc");
1673 printf_filtered ("Unknown type 0x%02x", descr
.stype
);
1676 puts_filtered ("\n");
1680 printf_filtered ("0x%03x: ",
1682 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1684 puts_filtered ("Segment not present\n");
1686 printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1691 printf_filtered ("0x%03x: Cannot read this descriptor\n", idx
);
1695 go32_sldt (char *arg
, int from_tty
)
1697 struct dtr_reg gdtr
;
1698 unsigned short ldtr
= 0;
1700 struct seg_descr ldt_descr
;
1701 long ldt_entry
= -1L;
1702 int cpl
= (prog_has_started
? a_tss
.tss_cs
: _my_cs ()) & 3;
1706 while (*arg
&& isspace(*arg
))
1711 ldt_entry
= parse_and_eval_long (arg
);
1713 || (ldt_entry
& 4) == 0
1714 || (ldt_entry
& 3) != (cpl
& 3))
1715 error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry
);
1719 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1720 __asm__
__volatile__ ("sldt %0" : "=m" (ldtr
) : /* no inputs */ );
1723 puts_filtered ("There is no LDT.\n");
1724 /* LDT's entry in the GDT must have the type LDT, which is 2. */
1725 else if (get_descriptor (gdtr
.base
, ldt_idx
, &ldt_descr
) != 2)
1726 printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1728 | (ldt_descr
.base1
<< 16)
1729 | (ldt_descr
.base2
<< 24));
1734 | (ldt_descr
.base1
<< 16)
1735 | (ldt_descr
.base2
<< 24);
1736 unsigned limit
= ldt_descr
.limit0
| (ldt_descr
.limit1
<< 16);
1739 if (ldt_descr
.page_granular
)
1740 /* Page-granular segments must have the low 12 bits of their
1742 limit
= (limit
<< 12) | 0xfff;
1743 /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1748 max_entry
= (limit
+ 1) / 8;
1752 if (ldt_entry
> limit
)
1753 error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1754 (unsigned long)ldt_entry
, limit
);
1756 display_descriptor (ldt_descr
.stype
, base
, ldt_entry
/ 8, 1);
1762 for (i
= 0; i
< max_entry
; i
++)
1763 display_descriptor (ldt_descr
.stype
, base
, i
, 0);
1769 go32_sgdt (char *arg
, int from_tty
)
1771 struct dtr_reg gdtr
;
1772 long gdt_entry
= -1L;
1777 while (*arg
&& isspace(*arg
))
1782 gdt_entry
= parse_and_eval_long (arg
);
1783 if (gdt_entry
< 0 || (gdt_entry
& 7) != 0)
1784 error (_("Invalid GDT entry 0x%03lx: "
1785 "not an integral multiple of 8."),
1786 (unsigned long)gdt_entry
);
1790 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1791 max_entry
= (gdtr
.limit
+ 1) / 8;
1795 if (gdt_entry
> gdtr
.limit
)
1796 error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1797 (unsigned long)gdt_entry
, gdtr
.limit
);
1799 display_descriptor (0, gdtr
.base
, gdt_entry
/ 8, 1);
1805 for (i
= 0; i
< max_entry
; i
++)
1806 display_descriptor (0, gdtr
.base
, i
, 0);
1811 go32_sidt (char *arg
, int from_tty
)
1813 struct dtr_reg idtr
;
1814 long idt_entry
= -1L;
1819 while (*arg
&& isspace(*arg
))
1824 idt_entry
= parse_and_eval_long (arg
);
1826 error (_("Invalid (negative) IDT entry %ld."), idt_entry
);
1830 __asm__
__volatile__ ("sidt %0" : "=m" (idtr
) : /* no inputs */ );
1831 max_entry
= (idtr
.limit
+ 1) / 8;
1832 if (max_entry
> 0x100) /* No more than 256 entries. */
1837 if (idt_entry
> idtr
.limit
)
1838 error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1839 (unsigned long)idt_entry
, idtr
.limit
);
1841 display_descriptor (1, idtr
.base
, idt_entry
, 1);
1847 for (i
= 0; i
< max_entry
; i
++)
1848 display_descriptor (1, idtr
.base
, i
, 0);
1852 /* Cached linear address of the base of the page directory. For
1853 now, available only under CWSDPMI. Code based on ideas and
1854 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
1855 static unsigned long pdbr
;
1857 static unsigned long
1862 unsigned long taskbase
, cr3
;
1863 struct dtr_reg gdtr
;
1865 if (pdbr
> 0 && pdbr
<= 0xfffff)
1868 /* Get the linear address of GDT and the Task Register. */
1869 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1870 __asm__
__volatile__ ("str %0" : "=m" (taskreg
) : /* no inputs */ );
1872 /* Task Register is a segment selector for the TSS of the current
1873 task. Therefore, it can be used as an index into the GDT to get
1874 at the segment descriptor for the TSS. To get the index, reset
1875 the low 3 bits of the selector (which give the CPL). Add 2 to the
1876 offset to point to the 3 low bytes of the base address. */
1877 offset
= gdtr
.base
+ (taskreg
& 0xfff8) + 2;
1880 /* CWSDPMI's task base is always under the 1MB mark. */
1881 if (offset
> 0xfffff)
1884 _farsetsel (_dos_ds
);
1885 taskbase
= _farnspeekl (offset
) & 0xffffffU
;
1886 taskbase
+= _farnspeekl (offset
+ 2) & 0xff000000U
;
1887 if (taskbase
> 0xfffff)
1890 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1891 offset 1Ch in the TSS. */
1892 cr3
= _farnspeekl (taskbase
+ 0x1c) & ~0xfff;
1895 #if 0 /* Not fullly supported yet. */
1896 /* The Page Directory is in UMBs. In that case, CWSDPMI puts
1897 the first Page Table right below the Page Directory. Thus,
1898 the first Page Table's entry for its own address and the Page
1899 Directory entry for that Page Table will hold the same
1900 physical address. The loop below searches the entire UMB
1901 range of addresses for such an occurence. */
1902 unsigned long addr
, pte_idx
;
1904 for (addr
= 0xb0000, pte_idx
= 0xb0;
1906 addr
+= 0x1000, pte_idx
++)
1908 if (((_farnspeekl (addr
+ 4 * pte_idx
) & 0xfffff027) ==
1909 (_farnspeekl (addr
+ 0x1000) & 0xfffff027))
1910 && ((_farnspeekl (addr
+ 4 * pte_idx
+ 4) & 0xfffff000) == cr3
))
1912 cr3
= addr
+ 0x1000;
1925 /* Return the N'th Page Directory entry. */
1926 static unsigned long
1929 unsigned long pde
= 0;
1931 if (pdbr
&& n
>= 0 && n
< 1024)
1933 pde
= _farpeekl (_dos_ds
, pdbr
+ 4*n
);
1938 /* Return the N'th entry of the Page Table whose Page Directory entry
1940 static unsigned long
1941 get_pte (unsigned long pde
, int n
)
1943 unsigned long pte
= 0;
1945 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
1946 page tables, for now. */
1947 if ((pde
& 1) && !(pde
& 0x80) && n
>= 0 && n
< 1024)
1949 pde
&= ~0xfff; /* Clear non-address bits. */
1950 pte
= _farpeekl (_dos_ds
, pde
+ 4*n
);
1955 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
1956 says this is a Page Directory entry. If FORCE is non-zero, display
1957 the entry even if its Present flag is off. OFF is the offset of the
1958 address from the page's base address. */
1960 display_ptable_entry (unsigned long entry
, int is_dir
, int force
, unsigned off
)
1962 if ((entry
& 1) != 0)
1964 printf_filtered ("Base=0x%05lx000", entry
>> 12);
1965 if ((entry
& 0x100) && !is_dir
)
1966 puts_filtered (" Global");
1967 if ((entry
& 0x40) && !is_dir
)
1968 puts_filtered (" Dirty");
1969 printf_filtered (" %sAcc.", (entry
& 0x20) ? "" : "Not-");
1970 printf_filtered (" %sCached", (entry
& 0x10) ? "" : "Not-");
1971 printf_filtered (" Write-%s", (entry
& 8) ? "Thru" : "Back");
1972 printf_filtered (" %s", (entry
& 4) ? "Usr" : "Sup");
1973 printf_filtered (" Read-%s", (entry
& 2) ? "Write" : "Only");
1975 printf_filtered (" +0x%x", off
);
1976 puts_filtered ("\n");
1979 printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1980 is_dir
? " Table" : "", entry
>> 1);
1984 go32_pde (char *arg
, int from_tty
)
1986 long pde_idx
= -1, i
;
1990 while (*arg
&& isspace(*arg
))
1995 pde_idx
= parse_and_eval_long (arg
);
1996 if (pde_idx
< 0 || pde_idx
>= 1024)
1997 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
2003 puts_filtered ("Access to Page Directories is "
2004 "not supported on this system.\n");
2005 else if (pde_idx
>= 0)
2006 display_ptable_entry (get_pde (pde_idx
), 1, 1, 0);
2008 for (i
= 0; i
< 1024; i
++)
2009 display_ptable_entry (get_pde (i
), 1, 0, 0);
2012 /* A helper function to display entries in a Page Table pointed to by
2013 the N'th entry in the Page Directory. If FORCE is non-zero, say
2014 something even if the Page Table is not accessible. */
2016 display_page_table (long n
, int force
)
2018 unsigned long pde
= get_pde (n
);
2024 printf_filtered ("Page Table pointed to by "
2025 "Page Directory entry 0x%lx:\n", n
);
2026 for (i
= 0; i
< 1024; i
++)
2027 display_ptable_entry (get_pte (pde
, i
), 0, 0, 0);
2028 puts_filtered ("\n");
2031 printf_filtered ("Page Table not present; value=0x%lx.\n", pde
>> 1);
2035 go32_pte (char *arg
, int from_tty
)
2037 long pde_idx
= -1L, i
;
2041 while (*arg
&& isspace(*arg
))
2046 pde_idx
= parse_and_eval_long (arg
);
2047 if (pde_idx
< 0 || pde_idx
>= 1024)
2048 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
2054 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2055 else if (pde_idx
>= 0)
2056 display_page_table (pde_idx
, 1);
2058 for (i
= 0; i
< 1024; i
++)
2059 display_page_table (i
, 0);
2063 go32_pte_for_address (char *arg
, int from_tty
)
2065 CORE_ADDR addr
= 0, i
;
2069 while (*arg
&& isspace(*arg
))
2073 addr
= parse_and_eval_address (arg
);
2076 error_no_arg (_("linear address"));
2080 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2083 int pde_idx
= (addr
>> 22) & 0x3ff;
2084 int pte_idx
= (addr
>> 12) & 0x3ff;
2085 unsigned offs
= addr
& 0xfff;
2087 printf_filtered ("Page Table entry for address %s:\n",
2089 display_ptable_entry (get_pte (get_pde (pde_idx
), pte_idx
), 0, 1, offs
);
2093 static struct cmd_list_element
*info_dos_cmdlist
= NULL
;
2096 go32_info_dos_command (char *args
, int from_tty
)
2098 help_list (info_dos_cmdlist
, "info dos ", class_info
, gdb_stdout
);
2101 /* -Wmissing-prototypes */
2102 extern initialize_file_ftype _initialize_go32_nat
;
2105 _initialize_go32_nat (void)
2108 add_target (&go32_ops
);
2110 add_prefix_cmd ("dos", class_info
, go32_info_dos_command
, _("\
2111 Print information specific to DJGPP (aka MS-DOS) debugging."),
2112 &info_dos_cmdlist
, "info dos ", 0, &infolist
);
2114 add_cmd ("sysinfo", class_info
, go32_sysinfo
, _("\
2115 Display information about the target system, including CPU, OS, DPMI, etc."),
2117 add_cmd ("ldt", class_info
, go32_sldt
, _("\
2118 Display entries in the LDT (Local Descriptor Table).\n\
2119 Entry number (an expression) as an argument means display only that entry."),
2121 add_cmd ("gdt", class_info
, go32_sgdt
, _("\
2122 Display entries in the GDT (Global Descriptor Table).\n\
2123 Entry number (an expression) as an argument means display only that entry."),
2125 add_cmd ("idt", class_info
, go32_sidt
, _("\
2126 Display entries in the IDT (Interrupt Descriptor Table).\n\
2127 Entry number (an expression) as an argument means display only that entry."),
2129 add_cmd ("pde", class_info
, go32_pde
, _("\
2130 Display entries in the Page Directory.\n\
2131 Entry number (an expression) as an argument means display only that entry."),
2133 add_cmd ("pte", class_info
, go32_pte
, _("\
2134 Display entries in Page Tables.\n\
2135 Entry number (an expression) as an argument means display only entries\n\
2136 from the Page Table pointed to by the specified Page Directory entry."),
2138 add_cmd ("address-pte", class_info
, go32_pte_for_address
, _("\
2139 Display a Page Table entry for a linear address.\n\
2140 The address argument must be a linear address, after adding to\n\
2141 it the base address of the appropriate segment.\n\
2142 The base address of variables and functions in the debuggee's data\n\
2143 or code segment is stored in the variable __djgpp_base_address,\n\
2144 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
2145 For other segments, look up their base address in the output of\n\
2146 the `info dos ldt' command."),
2160 tcsetpgrp (int fd
, pid_t pgid
)
2162 if (isatty (fd
) && pgid
== SOME_PID
)
2164 errno
= pgid
== SOME_PID
? ENOTTY
: ENOSYS
;