1 /* Native debugging support for Intel x86 running DJGPP.
2 Copyright (C) 1997-2014 Free Software Foundation, Inc.
3 Written by Robert Hoehne.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 /* To whomever it may concern, here's a general description of how
21 debugging in DJGPP works, and the special quirks GDB does to
24 When the DJGPP port of GDB is debugging a DJGPP program natively,
25 there aren't 2 separate processes, the debuggee and GDB itself, as
26 on other systems. (This is DOS, where there can only be one active
27 process at any given time, remember?) Instead, GDB and the
28 debuggee live in the same process. So when GDB calls
29 go32_create_inferior below, and that function calls edi_init from
30 the DJGPP debug support library libdbg.a, we load the debuggee's
31 executable file into GDB's address space, set it up for execution
32 as the stub loader (a short real-mode program prepended to each
33 DJGPP executable) normally would, and do a lot of preparations for
34 swapping between GDB's and debuggee's internal state, primarily wrt
35 the exception handlers. This swapping happens every time we resume
36 the debuggee or switch back to GDB's code, and it includes:
38 . swapping all the segment registers
39 . swapping the PSP (the Program Segment Prefix)
40 . swapping the signal handlers
41 . swapping the exception handlers
42 . swapping the FPU status
43 . swapping the 3 standard file handles (more about this below)
45 Then running the debuggee simply means longjmp into it where its PC
46 is and let it run until it stops for some reason. When it stops,
47 GDB catches the exception that stopped it and longjmp's back into
48 its own code. All the possible exit points of the debuggee are
49 watched; for example, the normal exit point is recognized because a
50 DOS program issues a special system call to exit. If one of those
51 exit points is hit, we mourn the inferior and clean up after it.
52 Cleaning up is very important, even if the process exits normally,
53 because otherwise we might leave behind traces of previous
54 execution, and in several cases GDB itself might be left hosed,
55 because all the exception handlers were not restored.
57 Swapping of the standard handles (in redir_to_child and
58 redir_to_debugger) is needed because, since both GDB and the
59 debuggee live in the same process, as far as the OS is concerned,
60 the share the same file table. This means that the standard
61 handles 0, 1, and 2 point to the same file table entries, and thus
62 are connected to the same devices. Therefore, if the debugger
63 redirects its standard output, the standard output of the debuggee
64 is also automagically redirected to the same file/device!
65 Similarly, if the debuggee redirects its stdout to a file, you
66 won't be able to see debugger's output (it will go to the same file
67 where the debuggee has its output); and if the debuggee closes its
68 standard input, you will lose the ability to talk to debugger!
70 For this reason, every time the debuggee is about to be resumed, we
71 call redir_to_child, which redirects the standard handles to where
72 the debuggee expects them to be. When the debuggee stops and GDB
73 regains control, we call redir_to_debugger, which redirects those 3
74 handles back to where GDB expects.
76 Note that only the first 3 handles are swapped, so if the debuggee
77 redirects or closes any other handles, GDB will not notice. In
78 particular, the exit code of a DJGPP program forcibly closes all
79 file handles beyond the first 3 ones, so when the debuggee exits,
80 GDB currently loses its stdaux and stdprn streams. Fortunately,
81 GDB does not use those as of this writing, and will never need
90 #include "gdbthread.h"
95 #include "floatformat.h"
97 #include "i387-tdep.h"
98 #include "i386-tdep.h"
99 #include "i386-cpuid.h"
101 #include "regcache.h"
104 #include "cli/cli-utils.h"
105 #include "inf-child.h"
107 #include <stdio.h> /* might be required for __DJGPP_MINOR__ */
112 #include <sys/utsname.h>
117 #include <sys/farptr.h>
118 #include <debug/v2load.h>
119 #include <debug/dbgcom.h>
120 #if __DJGPP_MINOR__ > 2
121 #include <debug/redir.h>
124 #include <langinfo.h>
126 #if __DJGPP_MINOR__ < 3
127 /* This code will be provided from DJGPP 2.03 on. Until then I code it
135 unsigned short exponent
:15;
136 unsigned short sign
:1;
142 unsigned int control
;
147 unsigned int dataptr
;
148 unsigned int datasel
;
155 static void save_npx (void); /* Save the FPU of the debugged program. */
156 static void load_npx (void); /* Restore the FPU of the debugged program. */
158 /* ------------------------------------------------------------------------- */
159 /* Store the contents of the NPX in the global variable `npx'. */
165 asm ("inb $0xa0, %%al \n\
166 testb $0x20, %%al \n\
184 /* ------------------------------------------------------------------------- */
185 /* Reload the contents of the NPX from the global variable `npx'. */
190 asm ("frstor %0":"=m" (npx
));
192 /* ------------------------------------------------------------------------- */
193 /* Stubs for the missing redirection functions. */
200 redir_cmdline_delete (cmdline_t
*ptr
)
206 redir_cmdline_parse (const char *args
, cmdline_t
*ptr
)
212 redir_to_child (cmdline_t
*ptr
)
218 redir_to_debugger (cmdline_t
*ptr
)
224 redir_debug_init (cmdline_t
*ptr
)
228 #endif /* __DJGPP_MINOR < 3 */
230 typedef enum { wp_insert
, wp_remove
, wp_count
} wp_op
;
232 /* This holds the current reference counts for each debug register. */
233 static int dr_ref_count
[4];
237 static int prog_has_started
= 0;
238 static void go32_mourn_inferior (struct target_ops
*ops
);
240 #define r_ofs(x) (offsetof(TSS,x))
249 {r_ofs (tss_eax
), 4}, /* normal registers, from a_tss */
250 {r_ofs (tss_ecx
), 4},
251 {r_ofs (tss_edx
), 4},
252 {r_ofs (tss_ebx
), 4},
253 {r_ofs (tss_esp
), 4},
254 {r_ofs (tss_ebp
), 4},
255 {r_ofs (tss_esi
), 4},
256 {r_ofs (tss_edi
), 4},
257 {r_ofs (tss_eip
), 4},
258 {r_ofs (tss_eflags
), 4},
265 {0, 10}, /* 8 FP registers, from npx.reg[] */
273 /* The order of the next 7 registers must be consistent
274 with their numbering in config/i386/tm-i386.h, which see. */
275 {0, 2}, /* control word, from npx */
276 {4, 2}, /* status word, from npx */
277 {8, 2}, /* tag word, from npx */
278 {16, 2}, /* last FP exception CS from npx */
279 {12, 4}, /* last FP exception EIP from npx */
280 {24, 2}, /* last FP exception operand selector from npx */
281 {20, 4}, /* last FP exception operand offset from npx */
282 {18, 2} /* last FP opcode from npx */
288 enum gdb_signal gdb_sig
;
293 {1, GDB_SIGNAL_TRAP
},
294 /* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
295 but I think SIGBUS is better, since the NMI is usually activated
296 as a result of a memory parity check failure. */
298 {3, GDB_SIGNAL_TRAP
},
300 {5, GDB_SIGNAL_SEGV
},
302 {7, GDB_SIGNAL_EMT
}, /* no-coprocessor exception */
303 {8, GDB_SIGNAL_SEGV
},
304 {9, GDB_SIGNAL_SEGV
},
305 {10, GDB_SIGNAL_BUS
},
306 {11, GDB_SIGNAL_SEGV
},
307 {12, GDB_SIGNAL_SEGV
},
308 {13, GDB_SIGNAL_SEGV
},
309 {14, GDB_SIGNAL_SEGV
},
310 {16, GDB_SIGNAL_FPE
},
311 {17, GDB_SIGNAL_BUS
},
312 {31, GDB_SIGNAL_ILL
},
313 {0x1b, GDB_SIGNAL_INT
},
314 {0x75, GDB_SIGNAL_FPE
},
315 {0x78, GDB_SIGNAL_ALRM
},
316 {0x79, GDB_SIGNAL_INT
},
317 {0x7a, GDB_SIGNAL_QUIT
},
318 {-1, GDB_SIGNAL_LAST
}
322 enum gdb_signal gdb_sig
;
326 {GDB_SIGNAL_ILL
, 6}, /* Invalid Opcode */
327 {GDB_SIGNAL_EMT
, 7}, /* triggers SIGNOFP */
328 {GDB_SIGNAL_SEGV
, 13}, /* GPF */
329 {GDB_SIGNAL_BUS
, 17}, /* Alignment Check */
330 /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
332 {GDB_SIGNAL_TERM
, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
333 {GDB_SIGNAL_FPE
, 0x75},
334 {GDB_SIGNAL_INT
, 0x79},
335 {GDB_SIGNAL_QUIT
, 0x7a},
336 {GDB_SIGNAL_ALRM
, 0x78}, /* triggers SIGTIMR */
337 {GDB_SIGNAL_PROF
, 0x78},
338 {GDB_SIGNAL_LAST
, -1}
342 go32_attach (struct target_ops
*ops
, char *args
, int from_tty
)
345 You cannot attach to a running program on this platform.\n\
346 Use the `run' command to run DJGPP programs."));
349 static int resume_is_step
;
350 static int resume_signal
= -1;
353 go32_resume (struct target_ops
*ops
,
354 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
358 resume_is_step
= step
;
360 if (siggnal
!= GDB_SIGNAL_0
&& siggnal
!= GDB_SIGNAL_TRAP
)
362 for (i
= 0, resume_signal
= -1;
363 excepn_map
[i
].gdb_sig
!= GDB_SIGNAL_LAST
; i
++)
364 if (excepn_map
[i
].gdb_sig
== siggnal
)
366 resume_signal
= excepn_map
[i
].djgpp_excepno
;
369 if (resume_signal
== -1)
370 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
371 gdb_signal_to_name (siggnal
));
375 static char child_cwd
[FILENAME_MAX
];
378 go32_wait (struct target_ops
*ops
,
379 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
382 unsigned char saved_opcode
;
383 unsigned long INT3_addr
= 0;
384 int stepping_over_INT
= 0;
386 a_tss
.tss_eflags
&= 0xfeff; /* Reset the single-step flag (TF). */
389 /* If the next instruction is INT xx or INTO, we need to handle
390 them specially. Intel manuals say that these instructions
391 reset the single-step flag (a.k.a. TF). However, it seems
392 that, at least in the DPMI environment, and at least when
393 stepping over the DPMI interrupt 31h, the problem is having
394 TF set at all when INT 31h is executed: the debuggee either
395 crashes (and takes the system with it) or is killed by a
398 So we need to emulate single-step mode: we put an INT3 opcode
399 right after the INT xx instruction, let the debuggee run
400 until it hits INT3 and stops, then restore the original
401 instruction which we overwrote with the INT3 opcode, and back
402 up the debuggee's EIP to that instruction. */
403 read_child (a_tss
.tss_eip
, &saved_opcode
, 1);
404 if (saved_opcode
== 0xCD || saved_opcode
== 0xCE)
406 unsigned char INT3_opcode
= 0xCC;
409 = saved_opcode
== 0xCD ? a_tss
.tss_eip
+ 2 : a_tss
.tss_eip
+ 1;
410 stepping_over_INT
= 1;
411 read_child (INT3_addr
, &saved_opcode
, 1);
412 write_child (INT3_addr
, &INT3_opcode
, 1);
415 a_tss
.tss_eflags
|= 0x0100; /* normal instruction: set TF */
418 /* The special value FFFFh in tss_trap indicates to run_child that
419 tss_irqn holds a signal to be delivered to the debuggee. */
420 if (resume_signal
<= -1)
423 a_tss
.tss_irqn
= 0xff;
427 a_tss
.tss_trap
= 0xffff; /* run_child looks for this. */
428 a_tss
.tss_irqn
= resume_signal
;
431 /* The child might change working directory behind our back. The
432 GDB users won't like the side effects of that when they work with
433 relative file names, and GDB might be confused by its current
434 directory not being in sync with the truth. So we always make a
435 point of changing back to where GDB thinks is its cwd, when we
436 return control to the debugger, but restore child's cwd before we
438 /* Initialize child_cwd, before the first call to run_child and not
439 in the initialization, so the child get also the changed directory
440 set with the gdb-command "cd ..." */
442 /* Initialize child's cwd with the current one. */
443 getcwd (child_cwd
, sizeof (child_cwd
));
447 #if __DJGPP_MINOR__ < 3
451 #if __DJGPP_MINOR__ < 3
455 /* Did we step over an INT xx instruction? */
456 if (stepping_over_INT
&& a_tss
.tss_eip
== INT3_addr
+ 1)
458 /* Restore the original opcode. */
459 a_tss
.tss_eip
--; /* EIP points *after* the INT3 instruction. */
460 write_child (a_tss
.tss_eip
, &saved_opcode
, 1);
461 /* Simulate a TRAP exception. */
463 a_tss
.tss_eflags
|= 0x0100;
466 getcwd (child_cwd
, sizeof (child_cwd
)); /* in case it has changed */
467 chdir (current_directory
);
469 if (a_tss
.tss_irqn
== 0x21)
471 status
->kind
= TARGET_WAITKIND_EXITED
;
472 status
->value
.integer
= a_tss
.tss_eax
& 0xff;
476 status
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
477 status
->kind
= TARGET_WAITKIND_STOPPED
;
478 for (i
= 0; sig_map
[i
].go32_sig
!= -1; i
++)
480 if (a_tss
.tss_irqn
== sig_map
[i
].go32_sig
)
482 #if __DJGPP_MINOR__ < 3
483 if ((status
->value
.sig
= sig_map
[i
].gdb_sig
) !=
485 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
487 status
->value
.sig
= sig_map
[i
].gdb_sig
;
493 return pid_to_ptid (SOME_PID
);
497 fetch_register (struct regcache
*regcache
, int regno
)
499 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
500 if (regno
< gdbarch_fp0_regnum (gdbarch
))
501 regcache_raw_supply (regcache
, regno
,
502 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
503 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
,
505 i387_supply_fsave (regcache
, regno
, &npx
);
507 internal_error (__FILE__
, __LINE__
,
508 _("Invalid register no. %d in fetch_register."), regno
);
512 go32_fetch_registers (struct target_ops
*ops
,
513 struct regcache
*regcache
, int regno
)
516 fetch_register (regcache
, regno
);
520 regno
< gdbarch_fp0_regnum (get_regcache_arch (regcache
));
522 fetch_register (regcache
, regno
);
523 i387_supply_fsave (regcache
, -1, &npx
);
528 store_register (const struct regcache
*regcache
, int regno
)
530 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
531 if (regno
< gdbarch_fp0_regnum (gdbarch
))
532 regcache_raw_collect (regcache
, regno
,
533 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
534 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
,
536 i387_collect_fsave (regcache
, regno
, &npx
);
538 internal_error (__FILE__
, __LINE__
,
539 _("Invalid register no. %d in store_register."), regno
);
543 go32_store_registers (struct target_ops
*ops
,
544 struct regcache
*regcache
, int regno
)
549 store_register (regcache
, regno
);
552 for (r
= 0; r
< gdbarch_fp0_regnum (get_regcache_arch (regcache
)); r
++)
553 store_register (regcache
, r
);
554 i387_collect_fsave (regcache
, -1, &npx
);
558 /* Const-correct version of DJGPP's write_child, which unfortunately
559 takes a non-const buffer pointer. */
562 my_write_child (unsigned child_addr
, const void *buf
, unsigned len
)
564 static void *buffer
= NULL
;
565 static unsigned buffer_len
= 0;
568 if (buffer_len
< len
)
570 buffer
= xrealloc (buffer
, len
);
574 memcpy (buffer
, buf
, len
);
575 res
= write_child (child_addr
, buffer
, len
);
579 /* Helper for go32_xfer_partial that handles memory transfers.
580 Arguments are like target_xfer_partial. */
582 static enum target_xfer_status
583 go32_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
584 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
588 if (writebuf
!= NULL
)
589 res
= my_write_child (memaddr
, writebuf
, len
);
591 res
= read_child (memaddr
, readbuf
, len
);
594 return TARGET_XFER_E_IO
;
597 return TARGET_XFER_OK
;
600 /* Target to_xfer_partial implementation. */
602 static enum target_xfer_status
603 go32_xfer_partial (struct target_ops
*ops
, enum target_object object
,
604 const char *annex
, gdb_byte
*readbuf
,
605 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
606 ULONGEST
*xfered_len
)
610 case TARGET_OBJECT_MEMORY
:
611 return go32_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
614 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
615 readbuf
, writebuf
, offset
, len
,
620 static cmdline_t child_cmd
; /* Parsed child's command line kept here. */
623 go32_files_info (struct target_ops
*target
)
625 printf_unfiltered ("You are running a DJGPP V2 program.\n");
629 go32_kill_inferior (struct target_ops
*ops
)
631 go32_mourn_inferior (ops
);
635 go32_create_inferior (struct target_ops
*ops
, char *exec_file
,
636 char *args
, char **env
, int from_tty
)
638 extern char **environ
;
641 char **env_save
= environ
;
643 struct inferior
*inf
;
645 /* If no exec file handed to us, get it from the exec-file command -- with
646 a good, common error message if none is specified. */
648 exec_file
= get_exec_file (1);
653 /* Initialize child's cwd as empty to be initialized when starting
657 /* Init command line storage. */
658 if (redir_debug_init (&child_cmd
) == -1)
659 internal_error (__FILE__
, __LINE__
,
660 _("Cannot allocate redirection storage: "
661 "not enough memory.\n"));
663 /* Parse the command line and create redirections. */
664 if (strpbrk (args
, "<>"))
666 if (redir_cmdline_parse (args
, &child_cmd
) == 0)
667 args
= child_cmd
.command
;
669 error (_("Syntax error in command line."));
672 child_cmd
.command
= xstrdup (args
);
674 cmdlen
= strlen (args
);
675 /* v2loadimage passes command lines via DOS memory, so it cannot
676 possibly handle commands longer than 1MB. */
677 if (cmdlen
> 1024*1024)
678 error (_("Command line too long."));
680 cmdline
= xmalloc (cmdlen
+ 4);
681 strcpy (cmdline
+ 1, args
);
682 /* If the command-line length fits into DOS 126-char limits, use the
683 DOS command tail format; otherwise, tell v2loadimage to pass it
684 through a buffer in conventional memory. */
687 cmdline
[0] = strlen (args
);
688 cmdline
[cmdlen
+ 1] = 13;
691 cmdline
[0] = 0xff; /* Signal v2loadimage it's a long command. */
695 if (v2loadimage (exec_file
, cmdline
, start_state
))
698 printf_unfiltered ("Load failed for image %s\n", exec_file
);
704 edi_init (start_state
);
705 #if __DJGPP_MINOR__ < 3
709 inferior_ptid
= pid_to_ptid (SOME_PID
);
710 inf
= current_inferior ();
711 inferior_appeared (inf
, SOME_PID
);
713 if (!target_is_pushed (ops
))
716 add_thread_silent (inferior_ptid
);
718 clear_proceed_status ();
719 insert_breakpoints ();
720 prog_has_started
= 1;
724 go32_mourn_inferior (struct target_ops
*ops
)
728 redir_cmdline_delete (&child_cmd
);
734 /* We need to make sure all the breakpoint enable bits in the DR7
735 register are reset when the inferior exits. Otherwise, if they
736 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
737 failure to set more watchpoints, and other calamities. It would
738 be nice if GDB itself would take care to remove all breakpoints
739 at all times, but it doesn't, probably under an assumption that
740 the OS cleans up when the debuggee exits. */
741 i386_cleanup_dregs ();
743 ptid
= inferior_ptid
;
744 inferior_ptid
= null_ptid
;
745 delete_thread_silent (ptid
);
746 prog_has_started
= 0;
748 generic_mourn_inferior ();
749 inf_child_maybe_unpush_target (ops
);
752 /* Hardware watchpoint support. */
754 #define D_REGS edi.dr
755 #define CONTROL D_REGS[7]
756 #define STATUS D_REGS[6]
758 /* Pass the address ADDR to the inferior in the I'th debug register.
759 Here we just store the address in D_REGS, the watchpoint will be
760 actually set up when go32_wait runs the debuggee. */
762 go32_set_dr (int i
, CORE_ADDR addr
)
765 internal_error (__FILE__
, __LINE__
,
766 _("Invalid register %d in go32_set_dr.\n"), i
);
770 /* Pass the value VAL to the inferior in the DR7 debug control
771 register. Here we just store the address in D_REGS, the watchpoint
772 will be actually set up when go32_wait runs the debuggee. */
774 go32_set_dr7 (unsigned long val
)
779 /* Get the value of the DR6 debug status register from the inferior.
780 Here we just return the value stored in D_REGS, as we've got it
781 from the last go32_wait call. */
788 /* Get the value of the DR7 debug status register from the inferior.
789 Here we just return the value stored in D_REGS, as we've got it
790 from the last go32_wait call. */
798 /* Get the value of the DR debug register I from the inferior. Here
799 we just return the value stored in D_REGS, as we've got it from the
800 last go32_wait call. */
806 internal_error (__FILE__
, __LINE__
,
807 _("Invalid register %d in go32_get_dr.\n"), i
);
811 /* Put the device open on handle FD into either raw or cooked
812 mode, return 1 if it was in raw mode, zero otherwise. */
815 device_mode (int fd
, int raw_p
)
817 int oldmode
, newmode
;
822 __dpmi_int (0x21, ®s
);
823 if (regs
.x
.flags
& 1)
825 newmode
= oldmode
= regs
.x
.dx
;
832 if (oldmode
& 0x80) /* Only for character dev. */
836 regs
.x
.dx
= newmode
& 0xff; /* Force upper byte zero, else it fails. */
837 __dpmi_int (0x21, ®s
);
838 if (regs
.x
.flags
& 1)
841 return (oldmode
& 0x20) == 0x20;
845 static int inf_mode_valid
= 0;
846 static int inf_terminal_mode
;
848 /* This semaphore is needed because, amazingly enough, GDB calls
849 target.to_terminal_ours more than once after the inferior stops.
850 But we need the information from the first call only, since the
851 second call will always see GDB's own cooked terminal. */
852 static int terminal_is_ours
= 1;
855 go32_terminal_init (struct target_ops
*self
)
857 inf_mode_valid
= 0; /* Reinitialize, in case they are restarting child. */
858 terminal_is_ours
= 1;
862 go32_terminal_info (struct target_ops
*self
, const char *args
, int from_tty
)
864 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
866 ? "default" : inf_terminal_mode
? "raw" : "cooked");
868 #if __DJGPP_MINOR__ > 2
869 if (child_cmd
.redirection
)
873 for (i
= 0; i
< DBG_HANDLES
; i
++)
875 if (child_cmd
.redirection
[i
]->file_name
)
876 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
877 i
, child_cmd
.redirection
[i
]->file_name
);
878 else if (_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) == -1)
880 ("\tFile handle %d appears to be closed by inferior.\n", i
);
881 /* Mask off the raw/cooked bit when comparing device info words. */
882 else if ((_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) & 0xdf)
883 != (_get_dev_info (i
) & 0xdf))
885 ("\tFile handle %d appears to be redirected by inferior.\n", i
);
892 go32_terminal_inferior (struct target_ops
*self
)
894 /* Redirect standard handles as child wants them. */
896 if (redir_to_child (&child_cmd
) == -1)
898 redir_to_debugger (&child_cmd
);
899 error (_("Cannot redirect standard handles for program: %s."),
900 safe_strerror (errno
));
902 /* Set the console device of the inferior to whatever mode
903 (raw or cooked) we found it last time. */
904 if (terminal_is_ours
)
907 device_mode (0, inf_terminal_mode
);
908 terminal_is_ours
= 0;
913 go32_terminal_ours (struct target_ops
*self
)
915 /* Switch to cooked mode on the gdb terminal and save the inferior
916 terminal mode to be restored when it is resumed. */
917 if (!terminal_is_ours
)
919 inf_terminal_mode
= device_mode (0, 0);
920 if (inf_terminal_mode
!= -1)
923 /* If device_mode returned -1, we don't know what happens with
924 handle 0 anymore, so make the info invalid. */
926 terminal_is_ours
= 1;
928 /* Restore debugger's standard handles. */
930 if (redir_to_debugger (&child_cmd
) == -1)
932 redir_to_child (&child_cmd
);
933 error (_("Cannot redirect standard handles for debugger: %s."),
934 safe_strerror (errno
));
940 go32_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
942 return !ptid_equal (inferior_ptid
, null_ptid
);
946 go32_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
948 return normal_pid_to_str (ptid
);
951 /* Create a go32 target. */
953 static struct target_ops
*
956 struct target_ops
*t
= inf_child_target ();
958 t
->to_attach
= go32_attach
;
959 t
->to_resume
= go32_resume
;
960 t
->to_wait
= go32_wait
;
961 t
->to_fetch_registers
= go32_fetch_registers
;
962 t
->to_store_registers
= go32_store_registers
;
963 t
->to_xfer_partial
= go32_xfer_partial
;
964 t
->to_files_info
= go32_files_info
;
965 t
->to_terminal_init
= go32_terminal_init
;
966 t
->to_terminal_inferior
= go32_terminal_inferior
;
967 t
->to_terminal_ours_for_output
= go32_terminal_ours
;
968 t
->to_terminal_ours
= go32_terminal_ours
;
969 t
->to_terminal_info
= go32_terminal_info
;
970 t
->to_kill
= go32_kill_inferior
;
971 t
->to_create_inferior
= go32_create_inferior
;
972 t
->to_mourn_inferior
= go32_mourn_inferior
;
973 t
->to_thread_alive
= go32_thread_alive
;
974 t
->to_pid_to_str
= go32_pid_to_str
;
979 /* Return the current DOS codepage number. */
986 __dpmi_int (0x21, ®s
);
987 if (!(regs
.x
.flags
& 1))
988 return regs
.x
.bx
& 0xffff;
990 return 437; /* default */
993 /* Limited emulation of `nl_langinfo', for charset.c. */
995 nl_langinfo (nl_item item
)
1003 /* 8 is enough for SHORT_MAX + "CP" + null. */
1005 int blen
= sizeof (buf
);
1006 int needed
= snprintf (buf
, blen
, "CP%d", dos_codepage ());
1008 if (needed
> blen
) /* Should never happen. */
1010 retval
= xstrdup (buf
);
1014 retval
= xstrdup ("");
1020 unsigned short windows_major
, windows_minor
;
1022 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */
1024 go32_get_windows_version(void)
1029 __dpmi_int(0x2f, &r
);
1030 if (r
.h
.al
> 2 && r
.h
.al
!= 0x80 && r
.h
.al
!= 0xff
1031 && (r
.h
.al
> 3 || r
.h
.ah
> 0))
1033 windows_major
= r
.h
.al
;
1034 windows_minor
= r
.h
.ah
;
1037 windows_major
= 0xff; /* meaning no Windows */
1040 /* A subroutine of go32_sysinfo to display memory info. */
1042 print_mem (unsigned long datum
, const char *header
, int in_pages_p
)
1044 if (datum
!= 0xffffffffUL
)
1048 puts_filtered (header
);
1051 printf_filtered ("%lu KB", datum
>> 10);
1052 if (datum
> 1024 * 1024)
1053 printf_filtered (" (%lu MB)", datum
>> 20);
1056 printf_filtered ("%lu Bytes", datum
);
1057 puts_filtered ("\n");
1061 /* Display assorted information about the underlying OS. */
1063 go32_sysinfo (char *arg
, int from_tty
)
1065 static const char test_pattern
[] =
1066 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1067 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1068 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeafdeadbeaf";
1070 char cpuid_vendor
[13];
1071 unsigned cpuid_max
= 0, cpuid_eax
, cpuid_ebx
, cpuid_ecx
, cpuid_edx
;
1072 unsigned true_dos_version
= _get_dos_version (1);
1073 unsigned advertized_dos_version
= ((unsigned int)_osmajor
<< 8) | _osminor
;
1075 char dpmi_vendor_info
[129];
1076 int dpmi_vendor_available
;
1077 __dpmi_version_ret dpmi_version_data
;
1079 __dpmi_free_mem_info mem_info
;
1082 cpuid_vendor
[0] = '\0';
1084 strcpy (u
.machine
, "Unknown x86");
1085 else if (u
.machine
[0] == 'i' && u
.machine
[1] > 4)
1087 /* CPUID with EAX = 0 returns the Vendor ID. */
1089 /* Ideally we would use i386_cpuid(), but it needs someone to run
1090 native tests first to make sure things actually work. They should.
1091 http://sourceware.org/ml/gdb-patches/2013-05/msg00164.html */
1092 unsigned int eax
, ebx
, ecx
, edx
;
1094 if (i386_cpuid (0, &eax
, &ebx
, &ecx
, &edx
))
1097 memcpy (&vendor
[0], &ebx
, 4);
1098 memcpy (&vendor
[4], &ecx
, 4);
1099 memcpy (&vendor
[8], &edx
, 4);
1100 cpuid_vendor
[12] = '\0';
1103 __asm__
__volatile__ ("xorl %%ebx, %%ebx;"
1104 "xorl %%ecx, %%ecx;"
1105 "xorl %%edx, %%edx;"
1112 : "=m" (cpuid_vendor
[0]),
1113 "=m" (cpuid_vendor
[4]),
1114 "=m" (cpuid_vendor
[8]),
1117 : "%eax", "%ebx", "%ecx", "%edx");
1118 cpuid_vendor
[12] = '\0';
1122 printf_filtered ("CPU Type.......................%s", u
.machine
);
1123 if (cpuid_vendor
[0])
1124 printf_filtered (" (%s)", cpuid_vendor
);
1125 puts_filtered ("\n");
1127 /* CPUID with EAX = 1 returns processor signature and features. */
1130 static char *brand_name
[] = {
1138 char cpu_string
[80];
1141 int intel_p
= strcmp (cpuid_vendor
, "GenuineIntel") == 0;
1142 int amd_p
= strcmp (cpuid_vendor
, "AuthenticAMD") == 0;
1143 unsigned cpu_family
, cpu_model
;
1146 /* See comment above about cpuid usage. */
1147 i386_cpuid (1, &cpuid_eax
, &cpuid_ebx
, NULL
, &cpuid_edx
);
1149 __asm__
__volatile__ ("movl $1, %%eax;"
1157 brand_idx
= cpuid_ebx
& 0xff;
1158 cpu_family
= (cpuid_eax
>> 8) & 0xf;
1159 cpu_model
= (cpuid_eax
>> 4) & 0xf;
1160 cpu_brand
[0] = '\0';
1164 && brand_idx
< sizeof(brand_name
)/sizeof(brand_name
[0])
1165 && *brand_name
[brand_idx
])
1166 strcpy (cpu_brand
, brand_name
[brand_idx
]);
1167 else if (cpu_family
== 5)
1169 if (((cpuid_eax
>> 12) & 3) == 0 && cpu_model
== 4)
1170 strcpy (cpu_brand
, " MMX");
1171 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 1)
1172 strcpy (cpu_brand
, " OverDrive");
1173 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 2)
1174 strcpy (cpu_brand
, " Dual");
1176 else if (cpu_family
== 6 && cpu_model
< 8)
1181 strcpy (cpu_brand
, " Pro");
1184 strcpy (cpu_brand
, " II");
1187 strcpy (cpu_brand
, " II Xeon");
1190 strcpy (cpu_brand
, " Celeron");
1193 strcpy (cpu_brand
, " III");
1203 strcpy (cpu_brand
, "486/5x86");
1212 strcpy (cpu_brand
, "-K5");
1216 strcpy (cpu_brand
, "-K6");
1219 strcpy (cpu_brand
, "-K6-2");
1222 strcpy (cpu_brand
, "-K6-III");
1232 strcpy (cpu_brand
, " Athlon");
1235 strcpy (cpu_brand
, " Duron");
1241 xsnprintf (cpu_string
, sizeof (cpu_string
), "%s%s Model %d Stepping %d",
1242 intel_p
? "Pentium" : (amd_p
? "AMD" : "ix86"),
1243 cpu_brand
, cpu_model
, cpuid_eax
& 0xf);
1244 printfi_filtered (31, "%s\n", cpu_string
);
1245 if (((cpuid_edx
& (6 | (0x0d << 23))) != 0)
1246 || ((cpuid_edx
& 1) == 0)
1247 || (amd_p
&& (cpuid_edx
& (3 << 30)) != 0))
1249 puts_filtered ("CPU Features...................");
1250 /* We only list features which might be useful in the DPMI
1252 if ((cpuid_edx
& 1) == 0)
1253 puts_filtered ("No FPU "); /* It's unusual to not have an FPU. */
1254 if ((cpuid_edx
& (1 << 1)) != 0)
1255 puts_filtered ("VME ");
1256 if ((cpuid_edx
& (1 << 2)) != 0)
1257 puts_filtered ("DE ");
1258 if ((cpuid_edx
& (1 << 4)) != 0)
1259 puts_filtered ("TSC ");
1260 if ((cpuid_edx
& (1 << 23)) != 0)
1261 puts_filtered ("MMX ");
1262 if ((cpuid_edx
& (1 << 25)) != 0)
1263 puts_filtered ("SSE ");
1264 if ((cpuid_edx
& (1 << 26)) != 0)
1265 puts_filtered ("SSE2 ");
1268 if ((cpuid_edx
& (1 << 31)) != 0)
1269 puts_filtered ("3DNow! ");
1270 if ((cpuid_edx
& (1 << 30)) != 0)
1271 puts_filtered ("3DNow!Ext");
1273 puts_filtered ("\n");
1276 puts_filtered ("\n");
1277 printf_filtered ("DOS Version....................%s %s.%s",
1278 _os_flavor
, u
.release
, u
.version
);
1279 if (true_dos_version
!= advertized_dos_version
)
1280 printf_filtered (" (disguised as v%d.%d)", _osmajor
, _osminor
);
1281 puts_filtered ("\n");
1283 go32_get_windows_version ();
1284 if (windows_major
!= 0xff)
1286 const char *windows_flavor
;
1288 printf_filtered ("Windows Version................%d.%02d (Windows ",
1289 windows_major
, windows_minor
);
1290 switch (windows_major
)
1293 windows_flavor
= "3.X";
1296 switch (windows_minor
)
1299 windows_flavor
= "95, 95A, or 95B";
1302 windows_flavor
= "95B OSR2.1 or 95C OSR2.5";
1305 windows_flavor
= "98 or 98 SE";
1308 windows_flavor
= "ME";
1311 windows_flavor
= "9X";
1316 windows_flavor
= "??";
1319 printf_filtered ("%s)\n", windows_flavor
);
1321 else if (true_dos_version
== 0x532 && advertized_dos_version
== 0x500)
1322 printf_filtered ("Windows Version................"
1323 "Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
1324 puts_filtered ("\n");
1325 /* On some versions of Windows, __dpmi_get_capabilities returns
1326 zero, but the buffer is not filled with info, so we fill the
1327 buffer with a known pattern and test for it afterwards. */
1328 memcpy (dpmi_vendor_info
, test_pattern
, sizeof(dpmi_vendor_info
));
1329 dpmi_vendor_available
=
1330 __dpmi_get_capabilities (&dpmi_flags
, dpmi_vendor_info
);
1331 if (dpmi_vendor_available
== 0
1332 && memcmp (dpmi_vendor_info
, test_pattern
,
1333 sizeof(dpmi_vendor_info
)) != 0)
1335 /* The DPMI spec says the vendor string should be ASCIIZ, but
1336 I don't trust the vendors to follow that... */
1337 if (!memchr (&dpmi_vendor_info
[2], 0, 126))
1338 dpmi_vendor_info
[128] = '\0';
1339 printf_filtered ("DPMI Host......................"
1340 "%s v%d.%d (capabilities: %#x)\n",
1341 &dpmi_vendor_info
[2],
1342 (unsigned)dpmi_vendor_info
[0],
1343 (unsigned)dpmi_vendor_info
[1],
1344 ((unsigned)dpmi_flags
& 0x7f));
1347 printf_filtered ("DPMI Host......................(Info not available)\n");
1348 __dpmi_get_version (&dpmi_version_data
);
1349 printf_filtered ("DPMI Version...................%d.%02d\n",
1350 dpmi_version_data
.major
, dpmi_version_data
.minor
);
1351 printf_filtered ("DPMI Info......................"
1352 "%s-bit DPMI, with%s Virtual Memory support\n",
1353 (dpmi_version_data
.flags
& 1) ? "32" : "16",
1354 (dpmi_version_data
.flags
& 4) ? "" : "out");
1355 printfi_filtered (31, "Interrupts reflected to %s mode\n",
1356 (dpmi_version_data
.flags
& 2) ? "V86" : "Real");
1357 printfi_filtered (31, "Processor type: i%d86\n",
1358 dpmi_version_data
.cpu
);
1359 printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
1360 dpmi_version_data
.master_pic
, dpmi_version_data
.slave_pic
);
1362 /* a_tss is only initialized when the debuggee is first run. */
1363 if (prog_has_started
)
1365 __asm__
__volatile__ ("pushfl ; popl %0" : "=g" (eflags
));
1366 printf_filtered ("Protection....................."
1367 "Ring %d (in %s), with%s I/O protection\n",
1368 a_tss
.tss_cs
& 3, (a_tss
.tss_cs
& 4) ? "LDT" : "GDT",
1369 (a_tss
.tss_cs
& 3) > ((eflags
>> 12) & 3) ? "" : "out");
1371 puts_filtered ("\n");
1372 __dpmi_get_free_memory_information (&mem_info
);
1373 print_mem (mem_info
.total_number_of_physical_pages
,
1374 "DPMI Total Physical Memory.....", 1);
1375 print_mem (mem_info
.total_number_of_free_pages
,
1376 "DPMI Free Physical Memory......", 1);
1377 print_mem (mem_info
.size_of_paging_file_partition_in_pages
,
1378 "DPMI Swap Space................", 1);
1379 print_mem (mem_info
.linear_address_space_size_in_pages
,
1380 "DPMI Total Linear Address Size.", 1);
1381 print_mem (mem_info
.free_linear_address_space_in_pages
,
1382 "DPMI Free Linear Address Size..", 1);
1383 print_mem (mem_info
.largest_available_free_block_in_bytes
,
1384 "DPMI Largest Free Memory Block.", 0);
1388 __dpmi_int (0x21, ®s
);
1389 print_mem (regs
.x
.bx
<< 4, "Free DOS Memory................", 0);
1391 __dpmi_int (0x21, ®s
);
1392 if ((regs
.x
.flags
& 1) == 0)
1394 static const char *dos_hilo
[] = {
1395 "Low", "", "", "", "High", "", "", "", "High, then Low"
1397 static const char *dos_fit
[] = {
1398 "First", "Best", "Last"
1400 int hilo_idx
= (regs
.x
.ax
>> 4) & 0x0f;
1401 int fit_idx
= regs
.x
.ax
& 0x0f;
1407 printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1408 dos_hilo
[hilo_idx
], dos_fit
[fit_idx
]);
1410 __dpmi_int (0x21, ®s
);
1411 if ((regs
.x
.flags
& 1) != 0)
1413 printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1414 regs
.h
.al
== 0 ? "not " : "");
1419 unsigned short limit0
;
1420 unsigned short base0
;
1421 unsigned char base1
;
1426 unsigned available
:1;
1429 unsigned page_granular
:1;
1430 unsigned char base2
;
1431 } __attribute__ ((packed
));
1434 unsigned short offset0
;
1435 unsigned short selector
;
1436 unsigned param_count
:5;
1441 unsigned short offset1
;
1442 } __attribute__ ((packed
));
1444 /* Read LEN bytes starting at logical address ADDR, and put the result
1445 into DEST. Return 1 if success, zero if not. */
1447 read_memory_region (unsigned long addr
, void *dest
, size_t len
)
1449 unsigned long dos_ds_limit
= __dpmi_get_segment_limit (_dos_ds
);
1452 /* For the low memory, we can simply use _dos_ds. */
1453 if (addr
<= dos_ds_limit
- len
)
1454 dosmemget (addr
, len
, dest
);
1457 /* For memory above 1MB we need to set up a special segment to
1458 be able to access that memory. */
1459 int sel
= __dpmi_allocate_ldt_descriptors (1);
1465 int access_rights
= __dpmi_get_descriptor_access_rights (sel
);
1466 size_t segment_limit
= len
- 1;
1468 /* Make sure the crucial bits in the descriptor access
1469 rights are set correctly. Some DPMI providers might barf
1470 if we set the segment limit to something that is not an
1471 integral multiple of 4KB pages if the granularity bit is
1472 not set to byte-granular, even though the DPMI spec says
1473 it's the host's responsibility to set that bit correctly. */
1474 if (len
> 1024 * 1024)
1476 access_rights
|= 0x8000;
1477 /* Page-granular segments should have the low 12 bits of
1479 segment_limit
|= 0xfff;
1482 access_rights
&= ~0x8000;
1484 if (__dpmi_set_segment_base_address (sel
, addr
) != -1
1485 && __dpmi_set_descriptor_access_rights (sel
, access_rights
) != -1
1486 && __dpmi_set_segment_limit (sel
, segment_limit
) != -1
1487 /* W2K silently fails to set the segment limit, leaving
1488 it at zero; this test avoids the resulting crash. */
1489 && __dpmi_get_segment_limit (sel
) >= segment_limit
)
1490 movedata (sel
, 0, _my_ds (), (unsigned)dest
, len
);
1494 __dpmi_free_ldt_descriptor (sel
);
1500 /* Get a segment descriptor stored at index IDX in the descriptor
1501 table whose base address is TABLE_BASE. Return the descriptor
1502 type, or -1 if failure. */
1504 get_descriptor (unsigned long table_base
, int idx
, void *descr
)
1506 unsigned long addr
= table_base
+ idx
* 8; /* 8 bytes per entry */
1508 if (read_memory_region (addr
, descr
, 8))
1509 return (int)((struct seg_descr
*)descr
)->stype
;
1514 unsigned short limit
__attribute__((packed
));
1515 unsigned long base
__attribute__((packed
));
1518 /* Display a segment descriptor stored at index IDX in a descriptor
1519 table whose type is TYPE and whose base address is BASE_ADDR. If
1520 FORCE is non-zero, display even invalid descriptors. */
1522 display_descriptor (unsigned type
, unsigned long base_addr
, int idx
, int force
)
1524 struct seg_descr descr
;
1525 struct gate_descr gate
;
1527 /* Get the descriptor from the table. */
1528 if (idx
== 0 && type
== 0)
1529 puts_filtered ("0x000: null descriptor\n");
1530 else if (get_descriptor (base_addr
, idx
, &descr
) != -1)
1532 /* For each type of descriptor table, this has a bit set if the
1533 corresponding type of selectors is valid in that table. */
1534 static unsigned allowed_descriptors
[] = {
1535 0xffffdafeL
, /* GDT */
1536 0x0000c0e0L
, /* IDT */
1537 0xffffdafaL
/* LDT */
1540 /* If the program hasn't started yet, assume the debuggee will
1541 have the same CPL as the debugger. */
1542 int cpl
= prog_has_started
? (a_tss
.tss_cs
& 3) : _my_cs () & 3;
1543 unsigned long limit
= (descr
.limit1
<< 16) | descr
.limit0
;
1546 && (allowed_descriptors
[type
] & (1 << descr
.stype
)) != 0)
1548 printf_filtered ("0x%03x: ",
1550 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1551 if (descr
.page_granular
)
1552 limit
= (limit
<< 12) | 0xfff; /* big segment: low 12 bit set */
1553 if (descr
.stype
== 1 || descr
.stype
== 2 || descr
.stype
== 3
1554 || descr
.stype
== 9 || descr
.stype
== 11
1555 || (descr
.stype
>= 16 && descr
.stype
< 32))
1556 printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1557 descr
.base2
, descr
.base1
, descr
.base0
, limit
);
1559 switch (descr
.stype
)
1563 printf_filtered (" 16-bit TSS (task %sactive)",
1564 descr
.stype
== 3 ? "" : "in");
1567 puts_filtered (" LDT");
1570 memcpy (&gate
, &descr
, sizeof gate
);
1571 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1572 gate
.selector
, gate
.offset1
, gate
.offset0
);
1573 printf_filtered (" 16-bit Call Gate (params=%d)",
1577 printf_filtered ("TSS selector=0x%04x", descr
.base0
);
1578 printfi_filtered (16, "Task Gate");
1582 memcpy (&gate
, &descr
, sizeof gate
);
1583 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1584 gate
.selector
, gate
.offset1
, gate
.offset0
);
1585 printf_filtered (" 16-bit %s Gate",
1586 descr
.stype
== 6 ? "Interrupt" : "Trap");
1590 printf_filtered (" 32-bit TSS (task %sactive)",
1591 descr
.stype
== 3 ? "" : "in");
1594 memcpy (&gate
, &descr
, sizeof gate
);
1595 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1596 gate
.selector
, gate
.offset1
, gate
.offset0
);
1597 printf_filtered (" 32-bit Call Gate (params=%d)",
1602 memcpy (&gate
, &descr
, sizeof gate
);
1603 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1604 gate
.selector
, gate
.offset1
, gate
.offset0
);
1605 printf_filtered (" 32-bit %s Gate",
1606 descr
.stype
== 14 ? "Interrupt" : "Trap");
1608 case 16: /* data segments */
1616 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1617 descr
.bit32
? "32" : "16",
1619 ? "Read/Write," : "Read-Only, ",
1620 descr
.stype
& 4 ? "down" : "up",
1621 descr
.stype
& 1 ? "" : ", N.Acc");
1623 case 24: /* code segments */
1631 printf_filtered (" %s-bit Code (%s, %sConf%s)",
1632 descr
.bit32
? "32" : "16",
1633 descr
.stype
& 2 ? "Exec/Read" : "Exec-Only",
1634 descr
.stype
& 4 ? "" : "N.",
1635 descr
.stype
& 1 ? "" : ", N.Acc");
1638 printf_filtered ("Unknown type 0x%02x", descr
.stype
);
1641 puts_filtered ("\n");
1645 printf_filtered ("0x%03x: ",
1647 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1649 puts_filtered ("Segment not present\n");
1651 printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1656 printf_filtered ("0x%03x: Cannot read this descriptor\n", idx
);
1660 go32_sldt (char *arg
, int from_tty
)
1662 struct dtr_reg gdtr
;
1663 unsigned short ldtr
= 0;
1665 struct seg_descr ldt_descr
;
1666 long ldt_entry
= -1L;
1667 int cpl
= (prog_has_started
? a_tss
.tss_cs
: _my_cs ()) & 3;
1671 arg
= skip_spaces (arg
);
1675 ldt_entry
= parse_and_eval_long (arg
);
1677 || (ldt_entry
& 4) == 0
1678 || (ldt_entry
& 3) != (cpl
& 3))
1679 error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry
);
1683 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1684 __asm__
__volatile__ ("sldt %0" : "=m" (ldtr
) : /* no inputs */ );
1687 puts_filtered ("There is no LDT.\n");
1688 /* LDT's entry in the GDT must have the type LDT, which is 2. */
1689 else if (get_descriptor (gdtr
.base
, ldt_idx
, &ldt_descr
) != 2)
1690 printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1692 | (ldt_descr
.base1
<< 16)
1693 | (ldt_descr
.base2
<< 24));
1698 | (ldt_descr
.base1
<< 16)
1699 | (ldt_descr
.base2
<< 24);
1700 unsigned limit
= ldt_descr
.limit0
| (ldt_descr
.limit1
<< 16);
1703 if (ldt_descr
.page_granular
)
1704 /* Page-granular segments must have the low 12 bits of their
1706 limit
= (limit
<< 12) | 0xfff;
1707 /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1712 max_entry
= (limit
+ 1) / 8;
1716 if (ldt_entry
> limit
)
1717 error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1718 (unsigned long)ldt_entry
, limit
);
1720 display_descriptor (ldt_descr
.stype
, base
, ldt_entry
/ 8, 1);
1726 for (i
= 0; i
< max_entry
; i
++)
1727 display_descriptor (ldt_descr
.stype
, base
, i
, 0);
1733 go32_sgdt (char *arg
, int from_tty
)
1735 struct dtr_reg gdtr
;
1736 long gdt_entry
= -1L;
1741 arg
= skip_spaces (arg
);
1745 gdt_entry
= parse_and_eval_long (arg
);
1746 if (gdt_entry
< 0 || (gdt_entry
& 7) != 0)
1747 error (_("Invalid GDT entry 0x%03lx: "
1748 "not an integral multiple of 8."),
1749 (unsigned long)gdt_entry
);
1753 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1754 max_entry
= (gdtr
.limit
+ 1) / 8;
1758 if (gdt_entry
> gdtr
.limit
)
1759 error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1760 (unsigned long)gdt_entry
, gdtr
.limit
);
1762 display_descriptor (0, gdtr
.base
, gdt_entry
/ 8, 1);
1768 for (i
= 0; i
< max_entry
; i
++)
1769 display_descriptor (0, gdtr
.base
, i
, 0);
1774 go32_sidt (char *arg
, int from_tty
)
1776 struct dtr_reg idtr
;
1777 long idt_entry
= -1L;
1782 arg
= skip_spaces (arg
);
1786 idt_entry
= parse_and_eval_long (arg
);
1788 error (_("Invalid (negative) IDT entry %ld."), idt_entry
);
1792 __asm__
__volatile__ ("sidt %0" : "=m" (idtr
) : /* no inputs */ );
1793 max_entry
= (idtr
.limit
+ 1) / 8;
1794 if (max_entry
> 0x100) /* No more than 256 entries. */
1799 if (idt_entry
> idtr
.limit
)
1800 error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1801 (unsigned long)idt_entry
, idtr
.limit
);
1803 display_descriptor (1, idtr
.base
, idt_entry
, 1);
1809 for (i
= 0; i
< max_entry
; i
++)
1810 display_descriptor (1, idtr
.base
, i
, 0);
1814 /* Cached linear address of the base of the page directory. For
1815 now, available only under CWSDPMI. Code based on ideas and
1816 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
1817 static unsigned long pdbr
;
1819 static unsigned long
1824 unsigned long taskbase
, cr3
;
1825 struct dtr_reg gdtr
;
1827 if (pdbr
> 0 && pdbr
<= 0xfffff)
1830 /* Get the linear address of GDT and the Task Register. */
1831 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1832 __asm__
__volatile__ ("str %0" : "=m" (taskreg
) : /* no inputs */ );
1834 /* Task Register is a segment selector for the TSS of the current
1835 task. Therefore, it can be used as an index into the GDT to get
1836 at the segment descriptor for the TSS. To get the index, reset
1837 the low 3 bits of the selector (which give the CPL). Add 2 to the
1838 offset to point to the 3 low bytes of the base address. */
1839 offset
= gdtr
.base
+ (taskreg
& 0xfff8) + 2;
1842 /* CWSDPMI's task base is always under the 1MB mark. */
1843 if (offset
> 0xfffff)
1846 _farsetsel (_dos_ds
);
1847 taskbase
= _farnspeekl (offset
) & 0xffffffU
;
1848 taskbase
+= _farnspeekl (offset
+ 2) & 0xff000000U
;
1849 if (taskbase
> 0xfffff)
1852 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1853 offset 1Ch in the TSS. */
1854 cr3
= _farnspeekl (taskbase
+ 0x1c) & ~0xfff;
1857 #if 0 /* Not fullly supported yet. */
1858 /* The Page Directory is in UMBs. In that case, CWSDPMI puts
1859 the first Page Table right below the Page Directory. Thus,
1860 the first Page Table's entry for its own address and the Page
1861 Directory entry for that Page Table will hold the same
1862 physical address. The loop below searches the entire UMB
1863 range of addresses for such an occurence. */
1864 unsigned long addr
, pte_idx
;
1866 for (addr
= 0xb0000, pte_idx
= 0xb0;
1868 addr
+= 0x1000, pte_idx
++)
1870 if (((_farnspeekl (addr
+ 4 * pte_idx
) & 0xfffff027) ==
1871 (_farnspeekl (addr
+ 0x1000) & 0xfffff027))
1872 && ((_farnspeekl (addr
+ 4 * pte_idx
+ 4) & 0xfffff000) == cr3
))
1874 cr3
= addr
+ 0x1000;
1887 /* Return the N'th Page Directory entry. */
1888 static unsigned long
1891 unsigned long pde
= 0;
1893 if (pdbr
&& n
>= 0 && n
< 1024)
1895 pde
= _farpeekl (_dos_ds
, pdbr
+ 4*n
);
1900 /* Return the N'th entry of the Page Table whose Page Directory entry
1902 static unsigned long
1903 get_pte (unsigned long pde
, int n
)
1905 unsigned long pte
= 0;
1907 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
1908 page tables, for now. */
1909 if ((pde
& 1) && !(pde
& 0x80) && n
>= 0 && n
< 1024)
1911 pde
&= ~0xfff; /* Clear non-address bits. */
1912 pte
= _farpeekl (_dos_ds
, pde
+ 4*n
);
1917 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
1918 says this is a Page Directory entry. If FORCE is non-zero, display
1919 the entry even if its Present flag is off. OFF is the offset of the
1920 address from the page's base address. */
1922 display_ptable_entry (unsigned long entry
, int is_dir
, int force
, unsigned off
)
1924 if ((entry
& 1) != 0)
1926 printf_filtered ("Base=0x%05lx000", entry
>> 12);
1927 if ((entry
& 0x100) && !is_dir
)
1928 puts_filtered (" Global");
1929 if ((entry
& 0x40) && !is_dir
)
1930 puts_filtered (" Dirty");
1931 printf_filtered (" %sAcc.", (entry
& 0x20) ? "" : "Not-");
1932 printf_filtered (" %sCached", (entry
& 0x10) ? "" : "Not-");
1933 printf_filtered (" Write-%s", (entry
& 8) ? "Thru" : "Back");
1934 printf_filtered (" %s", (entry
& 4) ? "Usr" : "Sup");
1935 printf_filtered (" Read-%s", (entry
& 2) ? "Write" : "Only");
1937 printf_filtered (" +0x%x", off
);
1938 puts_filtered ("\n");
1941 printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1942 is_dir
? " Table" : "", entry
>> 1);
1946 go32_pde (char *arg
, int from_tty
)
1948 long pde_idx
= -1, i
;
1952 arg
= skip_spaces (arg
);
1956 pde_idx
= parse_and_eval_long (arg
);
1957 if (pde_idx
< 0 || pde_idx
>= 1024)
1958 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
1964 puts_filtered ("Access to Page Directories is "
1965 "not supported on this system.\n");
1966 else if (pde_idx
>= 0)
1967 display_ptable_entry (get_pde (pde_idx
), 1, 1, 0);
1969 for (i
= 0; i
< 1024; i
++)
1970 display_ptable_entry (get_pde (i
), 1, 0, 0);
1973 /* A helper function to display entries in a Page Table pointed to by
1974 the N'th entry in the Page Directory. If FORCE is non-zero, say
1975 something even if the Page Table is not accessible. */
1977 display_page_table (long n
, int force
)
1979 unsigned long pde
= get_pde (n
);
1985 printf_filtered ("Page Table pointed to by "
1986 "Page Directory entry 0x%lx:\n", n
);
1987 for (i
= 0; i
< 1024; i
++)
1988 display_ptable_entry (get_pte (pde
, i
), 0, 0, 0);
1989 puts_filtered ("\n");
1992 printf_filtered ("Page Table not present; value=0x%lx.\n", pde
>> 1);
1996 go32_pte (char *arg
, int from_tty
)
1998 long pde_idx
= -1L, i
;
2002 arg
= skip_spaces (arg
);
2006 pde_idx
= parse_and_eval_long (arg
);
2007 if (pde_idx
< 0 || pde_idx
>= 1024)
2008 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
2014 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2015 else if (pde_idx
>= 0)
2016 display_page_table (pde_idx
, 1);
2018 for (i
= 0; i
< 1024; i
++)
2019 display_page_table (i
, 0);
2023 go32_pte_for_address (char *arg
, int from_tty
)
2025 CORE_ADDR addr
= 0, i
;
2029 arg
= skip_spaces (arg
);
2032 addr
= parse_and_eval_address (arg
);
2035 error_no_arg (_("linear address"));
2039 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2042 int pde_idx
= (addr
>> 22) & 0x3ff;
2043 int pte_idx
= (addr
>> 12) & 0x3ff;
2044 unsigned offs
= addr
& 0xfff;
2046 printf_filtered ("Page Table entry for address %s:\n",
2048 display_ptable_entry (get_pte (get_pde (pde_idx
), pte_idx
), 0, 1, offs
);
2052 static struct cmd_list_element
*info_dos_cmdlist
= NULL
;
2055 go32_info_dos_command (char *args
, int from_tty
)
2057 help_list (info_dos_cmdlist
, "info dos ", class_info
, gdb_stdout
);
2060 /* -Wmissing-prototypes */
2061 extern initialize_file_ftype _initialize_go32_nat
;
2064 _initialize_go32_nat (void)
2066 struct target_ops
*t
= go32_target ();
2068 i386_dr_low
.set_control
= go32_set_dr7
;
2069 i386_dr_low
.set_addr
= go32_set_dr
;
2070 i386_dr_low
.get_status
= go32_get_dr6
;
2071 i386_dr_low
.get_control
= go32_get_dr7
;
2072 i386_dr_low
.get_addr
= go32_get_dr
;
2073 i386_set_debug_register_length (4);
2075 i386_use_watchpoints (t
);
2078 /* Initialize child's cwd as empty to be initialized when starting
2082 /* Initialize child's command line storage. */
2083 if (redir_debug_init (&child_cmd
) == -1)
2084 internal_error (__FILE__
, __LINE__
,
2085 _("Cannot allocate redirection storage: "
2086 "not enough memory.\n"));
2088 /* We are always processing GCC-compiled programs. */
2089 processing_gcc_compilation
= 2;
2091 add_prefix_cmd ("dos", class_info
, go32_info_dos_command
, _("\
2092 Print information specific to DJGPP (aka MS-DOS) debugging."),
2093 &info_dos_cmdlist
, "info dos ", 0, &infolist
);
2095 add_cmd ("sysinfo", class_info
, go32_sysinfo
, _("\
2096 Display information about the target system, including CPU, OS, DPMI, etc."),
2098 add_cmd ("ldt", class_info
, go32_sldt
, _("\
2099 Display entries in the LDT (Local Descriptor Table).\n\
2100 Entry number (an expression) as an argument means display only that entry."),
2102 add_cmd ("gdt", class_info
, go32_sgdt
, _("\
2103 Display entries in the GDT (Global Descriptor Table).\n\
2104 Entry number (an expression) as an argument means display only that entry."),
2106 add_cmd ("idt", class_info
, go32_sidt
, _("\
2107 Display entries in the IDT (Interrupt Descriptor Table).\n\
2108 Entry number (an expression) as an argument means display only that entry."),
2110 add_cmd ("pde", class_info
, go32_pde
, _("\
2111 Display entries in the Page Directory.\n\
2112 Entry number (an expression) as an argument means display only that entry."),
2114 add_cmd ("pte", class_info
, go32_pte
, _("\
2115 Display entries in Page Tables.\n\
2116 Entry number (an expression) as an argument means display only entries\n\
2117 from the Page Table pointed to by the specified Page Directory entry."),
2119 add_cmd ("address-pte", class_info
, go32_pte_for_address
, _("\
2120 Display a Page Table entry for a linear address.\n\
2121 The address argument must be a linear address, after adding to\n\
2122 it the base address of the appropriate segment.\n\
2123 The base address of variables and functions in the debuggee's data\n\
2124 or code segment is stored in the variable __djgpp_base_address,\n\
2125 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
2126 For other segments, look up their base address in the output of\n\
2127 the `info dos ldt' command."),
2141 tcsetpgrp (int fd
, pid_t pgid
)
2143 if (isatty (fd
) && pgid
== SOME_PID
)
2145 errno
= pgid
== SOME_PID
? ENOTTY
: ENOSYS
;