* stack.c (print_frame_args): Fix typos in comments.
[deliverable/binutils-gdb.git] / gdb / go32-nat.c
1 /* Native debugging support for Intel x86 running DJGPP.
2 Copyright (C) 1997, 1999, 2000, 2001, 2005, 2006, 2007, 2008
3 Free Software Foundation, Inc.
4 Written by Robert Hoehne.
5
6 This file is part of GDB.
7
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.
12
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.
17
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/>. */
20
21 #include <fcntl.h>
22
23 #include "defs.h"
24 #include "inferior.h"
25 #include "gdbthread.h"
26 #include "gdb_wait.h"
27 #include "gdbcore.h"
28 #include "command.h"
29 #include "gdbcmd.h"
30 #include "floatformat.h"
31 #include "buildsym.h"
32 #include "i387-tdep.h"
33 #include "i386-tdep.h"
34 #include "value.h"
35 #include "regcache.h"
36 #include "gdb_string.h"
37 #include "top.h"
38
39 #include <stdio.h> /* might be required for __DJGPP_MINOR__ */
40 #include <stdlib.h>
41 #include <ctype.h>
42 #include <errno.h>
43 #include <unistd.h>
44 #include <sys/utsname.h>
45 #include <io.h>
46 #include <dos.h>
47 #include <dpmi.h>
48 #include <go32.h>
49 #include <sys/farptr.h>
50 #include <debug/v2load.h>
51 #include <debug/dbgcom.h>
52 #if __DJGPP_MINOR__ > 2
53 #include <debug/redir.h>
54 #endif
55
56 #if __DJGPP_MINOR__ < 3
57 /* This code will be provided from DJGPP 2.03 on. Until then I code it
58 here */
59 typedef struct
60 {
61 unsigned short sig0;
62 unsigned short sig1;
63 unsigned short sig2;
64 unsigned short sig3;
65 unsigned short exponent:15;
66 unsigned short sign:1;
67 }
68 NPXREG;
69
70 typedef struct
71 {
72 unsigned int control;
73 unsigned int status;
74 unsigned int tag;
75 unsigned int eip;
76 unsigned int cs;
77 unsigned int dataptr;
78 unsigned int datasel;
79 NPXREG reg[8];
80 }
81 NPX;
82
83 static NPX npx;
84
85 static void save_npx (void); /* Save the FPU of the debugged program */
86 static void load_npx (void); /* Restore the FPU of the debugged program */
87
88 /* ------------------------------------------------------------------------- */
89 /* Store the contents of the NPX in the global variable `npx'. */
90 /* *INDENT-OFF* */
91
92 static void
93 save_npx (void)
94 {
95 asm ("inb $0xa0, %%al \n\
96 testb $0x20, %%al \n\
97 jz 1f \n\
98 xorb %%al, %%al \n\
99 outb %%al, $0xf0 \n\
100 movb $0x20, %%al \n\
101 outb %%al, $0xa0 \n\
102 outb %%al, $0x20 \n\
103 1: \n\
104 fnsave %0 \n\
105 fwait "
106 : "=m" (npx)
107 : /* No input */
108 : "%eax");
109 }
110
111 /* *INDENT-ON* */
112
113
114 /* ------------------------------------------------------------------------- */
115 /* Reload the contents of the NPX from the global variable `npx'. */
116
117 static void
118 load_npx (void)
119 {
120 asm ("frstor %0":"=m" (npx));
121 }
122 /* ------------------------------------------------------------------------- */
123 /* Stubs for the missing redirection functions. */
124 typedef struct {
125 char *command;
126 int redirected;
127 } cmdline_t;
128
129 void
130 redir_cmdline_delete (cmdline_t *ptr)
131 {
132 ptr->redirected = 0;
133 }
134
135 int
136 redir_cmdline_parse (const char *args, cmdline_t *ptr)
137 {
138 return -1;
139 }
140
141 int
142 redir_to_child (cmdline_t *ptr)
143 {
144 return 1;
145 }
146
147 int
148 redir_to_debugger (cmdline_t *ptr)
149 {
150 return 1;
151 }
152
153 int
154 redir_debug_init (cmdline_t *ptr)
155 {
156 return 0;
157 }
158 #endif /* __DJGPP_MINOR < 3 */
159
160 typedef enum { wp_insert, wp_remove, wp_count } wp_op;
161
162 /* This holds the current reference counts for each debug register. */
163 static int dr_ref_count[4];
164
165 #define SOME_PID 42
166
167 static int prog_has_started = 0;
168 static void go32_open (char *name, int from_tty);
169 static void go32_close (int quitting);
170 static void go32_attach (char *args, int from_tty);
171 static void go32_detach (char *args, int from_tty);
172 static void go32_resume (ptid_t ptid, int step,
173 enum target_signal siggnal);
174 static ptid_t go32_wait (ptid_t ptid,
175 struct target_waitstatus *status);
176 static void go32_fetch_registers (struct regcache *, int regno);
177 static void store_register (const struct regcache *, int regno);
178 static void go32_store_registers (struct regcache *, int regno);
179 static void go32_prepare_to_store (struct regcache *);
180 static int go32_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
181 int write,
182 struct mem_attrib *attrib,
183 struct target_ops *target);
184 static void go32_files_info (struct target_ops *target);
185 static void go32_stop (ptid_t);
186 static void go32_kill_inferior (void);
187 static void go32_create_inferior (char *exec_file, char *args, char **env, int from_tty);
188 static void go32_mourn_inferior (void);
189 static int go32_can_run (void);
190
191 static struct target_ops go32_ops;
192 static void go32_terminal_init (void);
193 static void go32_terminal_inferior (void);
194 static void go32_terminal_ours (void);
195
196 #define r_ofs(x) (offsetof(TSS,x))
197
198 static struct
199 {
200 size_t tss_ofs;
201 size_t size;
202 }
203 regno_mapping[] =
204 {
205 {r_ofs (tss_eax), 4}, /* normal registers, from a_tss */
206 {r_ofs (tss_ecx), 4},
207 {r_ofs (tss_edx), 4},
208 {r_ofs (tss_ebx), 4},
209 {r_ofs (tss_esp), 4},
210 {r_ofs (tss_ebp), 4},
211 {r_ofs (tss_esi), 4},
212 {r_ofs (tss_edi), 4},
213 {r_ofs (tss_eip), 4},
214 {r_ofs (tss_eflags), 4},
215 {r_ofs (tss_cs), 2},
216 {r_ofs (tss_ss), 2},
217 {r_ofs (tss_ds), 2},
218 {r_ofs (tss_es), 2},
219 {r_ofs (tss_fs), 2},
220 {r_ofs (tss_gs), 2},
221 {0, 10}, /* 8 FP registers, from npx.reg[] */
222 {1, 10},
223 {2, 10},
224 {3, 10},
225 {4, 10},
226 {5, 10},
227 {6, 10},
228 {7, 10},
229 /* The order of the next 7 registers must be consistent
230 with their numbering in config/i386/tm-i386.h, which see. */
231 {0, 2}, /* control word, from npx */
232 {4, 2}, /* status word, from npx */
233 {8, 2}, /* tag word, from npx */
234 {16, 2}, /* last FP exception CS from npx */
235 {12, 4}, /* last FP exception EIP from npx */
236 {24, 2}, /* last FP exception operand selector from npx */
237 {20, 4}, /* last FP exception operand offset from npx */
238 {18, 2} /* last FP opcode from npx */
239 };
240
241 static struct
242 {
243 int go32_sig;
244 enum target_signal gdb_sig;
245 }
246 sig_map[] =
247 {
248 {0, TARGET_SIGNAL_FPE},
249 {1, TARGET_SIGNAL_TRAP},
250 /* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
251 but I think SIGBUS is better, since the NMI is usually activated
252 as a result of a memory parity check failure. */
253 {2, TARGET_SIGNAL_BUS},
254 {3, TARGET_SIGNAL_TRAP},
255 {4, TARGET_SIGNAL_FPE},
256 {5, TARGET_SIGNAL_SEGV},
257 {6, TARGET_SIGNAL_ILL},
258 {7, TARGET_SIGNAL_EMT}, /* no-coprocessor exception */
259 {8, TARGET_SIGNAL_SEGV},
260 {9, TARGET_SIGNAL_SEGV},
261 {10, TARGET_SIGNAL_BUS},
262 {11, TARGET_SIGNAL_SEGV},
263 {12, TARGET_SIGNAL_SEGV},
264 {13, TARGET_SIGNAL_SEGV},
265 {14, TARGET_SIGNAL_SEGV},
266 {16, TARGET_SIGNAL_FPE},
267 {17, TARGET_SIGNAL_BUS},
268 {31, TARGET_SIGNAL_ILL},
269 {0x1b, TARGET_SIGNAL_INT},
270 {0x75, TARGET_SIGNAL_FPE},
271 {0x78, TARGET_SIGNAL_ALRM},
272 {0x79, TARGET_SIGNAL_INT},
273 {0x7a, TARGET_SIGNAL_QUIT},
274 {-1, TARGET_SIGNAL_LAST}
275 };
276
277 static struct {
278 enum target_signal gdb_sig;
279 int djgpp_excepno;
280 } excepn_map[] = {
281 {TARGET_SIGNAL_0, -1},
282 {TARGET_SIGNAL_ILL, 6}, /* Invalid Opcode */
283 {TARGET_SIGNAL_EMT, 7}, /* triggers SIGNOFP */
284 {TARGET_SIGNAL_SEGV, 13}, /* GPF */
285 {TARGET_SIGNAL_BUS, 17}, /* Alignment Check */
286 /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
287 details. */
288 {TARGET_SIGNAL_TERM, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
289 {TARGET_SIGNAL_FPE, 0x75},
290 {TARGET_SIGNAL_INT, 0x79},
291 {TARGET_SIGNAL_QUIT, 0x7a},
292 {TARGET_SIGNAL_ALRM, 0x78}, /* triggers SIGTIMR */
293 {TARGET_SIGNAL_PROF, 0x78},
294 {TARGET_SIGNAL_LAST, -1}
295 };
296
297 static void
298 go32_open (char *name, int from_tty)
299 {
300 printf_unfiltered ("Done. Use the \"run\" command to run the program.\n");
301 }
302
303 static void
304 go32_close (int quitting)
305 {
306 }
307
308 static void
309 go32_attach (char *args, int from_tty)
310 {
311 error (_("\
312 You cannot attach to a running program on this platform.\n\
313 Use the `run' command to run DJGPP programs."));
314 }
315
316 static void
317 go32_detach (char *args, int from_tty)
318 {
319 }
320
321 static int resume_is_step;
322 static int resume_signal = -1;
323
324 static void
325 go32_resume (ptid_t ptid, int step, enum target_signal siggnal)
326 {
327 int i;
328
329 resume_is_step = step;
330
331 if (siggnal != TARGET_SIGNAL_0 && siggnal != TARGET_SIGNAL_TRAP)
332 {
333 for (i = 0, resume_signal = -1;
334 excepn_map[i].gdb_sig != TARGET_SIGNAL_LAST; i++)
335 if (excepn_map[i].gdb_sig == siggnal)
336 {
337 resume_signal = excepn_map[i].djgpp_excepno;
338 break;
339 }
340 if (resume_signal == -1)
341 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
342 target_signal_to_name (siggnal));
343 }
344 }
345
346 static char child_cwd[FILENAME_MAX];
347
348 static ptid_t
349 go32_wait (ptid_t ptid, struct target_waitstatus *status)
350 {
351 int i;
352 unsigned char saved_opcode;
353 unsigned long INT3_addr = 0;
354 int stepping_over_INT = 0;
355
356 a_tss.tss_eflags &= 0xfeff; /* reset the single-step flag (TF) */
357 if (resume_is_step)
358 {
359 /* If the next instruction is INT xx or INTO, we need to handle
360 them specially. Intel manuals say that these instructions
361 reset the single-step flag (a.k.a. TF). However, it seems
362 that, at least in the DPMI environment, and at least when
363 stepping over the DPMI interrupt 31h, the problem is having
364 TF set at all when INT 31h is executed: the debuggee either
365 crashes (and takes the system with it) or is killed by a
366 SIGTRAP.
367
368 So we need to emulate single-step mode: we put an INT3 opcode
369 right after the INT xx instruction, let the debuggee run
370 until it hits INT3 and stops, then restore the original
371 instruction which we overwrote with the INT3 opcode, and back
372 up the debuggee's EIP to that instruction. */
373 read_child (a_tss.tss_eip, &saved_opcode, 1);
374 if (saved_opcode == 0xCD || saved_opcode == 0xCE)
375 {
376 unsigned char INT3_opcode = 0xCC;
377
378 INT3_addr
379 = saved_opcode == 0xCD ? a_tss.tss_eip + 2 : a_tss.tss_eip + 1;
380 stepping_over_INT = 1;
381 read_child (INT3_addr, &saved_opcode, 1);
382 write_child (INT3_addr, &INT3_opcode, 1);
383 }
384 else
385 a_tss.tss_eflags |= 0x0100; /* normal instruction: set TF */
386 }
387
388 /* The special value FFFFh in tss_trap indicates to run_child that
389 tss_irqn holds a signal to be delivered to the debuggee. */
390 if (resume_signal <= -1)
391 {
392 a_tss.tss_trap = 0;
393 a_tss.tss_irqn = 0xff;
394 }
395 else
396 {
397 a_tss.tss_trap = 0xffff; /* run_child looks for this */
398 a_tss.tss_irqn = resume_signal;
399 }
400
401 /* The child might change working directory behind our back. The
402 GDB users won't like the side effects of that when they work with
403 relative file names, and GDB might be confused by its current
404 directory not being in sync with the truth. So we always make a
405 point of changing back to where GDB thinks is its cwd, when we
406 return control to the debugger, but restore child's cwd before we
407 run it. */
408 /* Initialize child_cwd, before the first call to run_child and not
409 in the initialization, so the child get also the changed directory
410 set with the gdb-command "cd ..." */
411 if (!*child_cwd)
412 /* Initialize child's cwd with the current one. */
413 getcwd (child_cwd, sizeof (child_cwd));
414
415 chdir (child_cwd);
416
417 #if __DJGPP_MINOR__ < 3
418 load_npx ();
419 #endif
420 run_child ();
421 #if __DJGPP_MINOR__ < 3
422 save_npx ();
423 #endif
424
425 /* Did we step over an INT xx instruction? */
426 if (stepping_over_INT && a_tss.tss_eip == INT3_addr + 1)
427 {
428 /* Restore the original opcode. */
429 a_tss.tss_eip--; /* EIP points *after* the INT3 instruction */
430 write_child (a_tss.tss_eip, &saved_opcode, 1);
431 /* Simulate a TRAP exception. */
432 a_tss.tss_irqn = 1;
433 a_tss.tss_eflags |= 0x0100;
434 }
435
436 getcwd (child_cwd, sizeof (child_cwd)); /* in case it has changed */
437 chdir (current_directory);
438
439 if (a_tss.tss_irqn == 0x21)
440 {
441 status->kind = TARGET_WAITKIND_EXITED;
442 status->value.integer = a_tss.tss_eax & 0xff;
443 }
444 else
445 {
446 status->value.sig = TARGET_SIGNAL_UNKNOWN;
447 status->kind = TARGET_WAITKIND_STOPPED;
448 for (i = 0; sig_map[i].go32_sig != -1; i++)
449 {
450 if (a_tss.tss_irqn == sig_map[i].go32_sig)
451 {
452 #if __DJGPP_MINOR__ < 3
453 if ((status->value.sig = sig_map[i].gdb_sig) !=
454 TARGET_SIGNAL_TRAP)
455 status->kind = TARGET_WAITKIND_SIGNALLED;
456 #else
457 status->value.sig = sig_map[i].gdb_sig;
458 #endif
459 break;
460 }
461 }
462 }
463 return pid_to_ptid (SOME_PID);
464 }
465
466 static void
467 fetch_register (struct regcache *regcache, int regno)
468 {
469 struct gdbarch *gdbarch = get_regcache_arch (regcache);
470 if (regno < gdbarch_fp0_regnum (gdbarch))
471 regcache_raw_supply (regcache, regno,
472 (char *) &a_tss + regno_mapping[regno].tss_ofs);
473 else if (i386_fp_regnum_p (gdbarch, regno) || i386_fpc_regnum_p (gdbarch, regno))
474 i387_supply_fsave (regcache, regno, &npx);
475 else
476 internal_error (__FILE__, __LINE__,
477 _("Invalid register no. %d in fetch_register."), regno);
478 }
479
480 static void
481 go32_fetch_registers (struct regcache *regcache, int regno)
482 {
483 if (regno >= 0)
484 fetch_register (regcache, regno);
485 else
486 {
487 for (regno = 0;
488 regno < gdbarch_fp0_regnum (get_regcache_arch (regcache));
489 regno++)
490 fetch_register (regcache, regno);
491 i387_supply_fsave (regcache, -1, &npx);
492 }
493 }
494
495 static void
496 store_register (const struct regcache *regcache, int regno)
497 {
498 struct gdbarch *gdbarch = get_regcache_arch (regcache);
499 if (regno < gdbarch_fp0_regnum (gdbarch))
500 regcache_raw_collect (regcache, regno,
501 (char *) &a_tss + regno_mapping[regno].tss_ofs);
502 else if (i386_fp_regnum_p (gdbarch, regno) || i386_fpc_regnum_p (gdbarch, regno))
503 i387_collect_fsave (regcache, regno, &npx);
504 else
505 internal_error (__FILE__, __LINE__,
506 _("Invalid register no. %d in store_register."), regno);
507 }
508
509 static void
510 go32_store_registers (struct regcache *regcache, int regno)
511 {
512 unsigned r;
513
514 if (regno >= 0)
515 store_register (regcache, regno);
516 else
517 {
518 for (r = 0; r < gdbarch_fp0_regnum (get_regcache_arch (regcache)); r++)
519 store_register (regcache, r);
520 i387_collect_fsave (regcache, -1, &npx);
521 }
522 }
523
524 static void
525 go32_prepare_to_store (struct regcache *regcache)
526 {
527 }
528
529 static int
530 go32_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
531 struct mem_attrib *attrib, struct target_ops *target)
532 {
533 if (write)
534 {
535 if (write_child (memaddr, myaddr, len))
536 {
537 return 0;
538 }
539 else
540 {
541 return len;
542 }
543 }
544 else
545 {
546 if (read_child (memaddr, myaddr, len))
547 {
548 return 0;
549 }
550 else
551 {
552 return len;
553 }
554 }
555 }
556
557 static cmdline_t child_cmd; /* parsed child's command line kept here */
558
559 static void
560 go32_files_info (struct target_ops *target)
561 {
562 printf_unfiltered ("You are running a DJGPP V2 program.\n");
563 }
564
565 static void
566 go32_stop (ptid_t ptid)
567 {
568 normal_stop ();
569 cleanup_client ();
570 ptid = inferior_ptid;
571 inferior_ptid = null_ptid;
572 delete_thread_silent (ptid);
573 prog_has_started = 0;
574 }
575
576 static void
577 go32_kill_inferior (void)
578 {
579 redir_cmdline_delete (&child_cmd);
580 resume_signal = -1;
581 resume_is_step = 0;
582 if (!ptid_equal (inferior_ptid, null_ptid))
583 delete_thread_silent (inferior_ptid);
584 unpush_target (&go32_ops);
585 }
586
587 static void
588 go32_create_inferior (char *exec_file, char *args, char **env, int from_tty)
589 {
590 extern char **environ;
591 jmp_buf start_state;
592 char *cmdline;
593 char **env_save = environ;
594 size_t cmdlen;
595
596 /* If no exec file handed to us, get it from the exec-file command -- with
597 a good, common error message if none is specified. */
598 if (exec_file == 0)
599 exec_file = get_exec_file (1);
600
601 if (prog_has_started)
602 {
603 go32_stop (inferior_ptid);
604 go32_kill_inferior ();
605 }
606 resume_signal = -1;
607 resume_is_step = 0;
608
609 /* Initialize child's cwd as empty to be initialized when starting
610 the child. */
611 *child_cwd = 0;
612
613 /* Init command line storage. */
614 if (redir_debug_init (&child_cmd) == -1)
615 internal_error (__FILE__, __LINE__,
616 _("Cannot allocate redirection storage: not enough memory.\n"));
617
618 /* Parse the command line and create redirections. */
619 if (strpbrk (args, "<>"))
620 {
621 if (redir_cmdline_parse (args, &child_cmd) == 0)
622 args = child_cmd.command;
623 else
624 error (_("Syntax error in command line."));
625 }
626 else
627 child_cmd.command = xstrdup (args);
628
629 cmdlen = strlen (args);
630 /* v2loadimage passes command lines via DOS memory, so it cannot
631 possibly handle commands longer than 1MB. */
632 if (cmdlen > 1024*1024)
633 error (_("Command line too long."));
634
635 cmdline = xmalloc (cmdlen + 4);
636 strcpy (cmdline + 1, args);
637 /* If the command-line length fits into DOS 126-char limits, use the
638 DOS command tail format; otherwise, tell v2loadimage to pass it
639 through a buffer in conventional memory. */
640 if (cmdlen < 127)
641 {
642 cmdline[0] = strlen (args);
643 cmdline[cmdlen + 1] = 13;
644 }
645 else
646 cmdline[0] = 0xff; /* signal v2loadimage it's a long command */
647
648 environ = env;
649
650 if (v2loadimage (exec_file, cmdline, start_state))
651 {
652 environ = env_save;
653 printf_unfiltered ("Load failed for image %s\n", exec_file);
654 exit (1);
655 }
656 environ = env_save;
657 xfree (cmdline);
658
659 edi_init (start_state);
660 #if __DJGPP_MINOR__ < 3
661 save_npx ();
662 #endif
663
664 inferior_ptid = pid_to_ptid (SOME_PID);
665 add_inferior_silent (SOME_PID);
666
667 push_target (&go32_ops);
668
669 add_thread_silent (inferior_ptid);
670
671 clear_proceed_status ();
672 insert_breakpoints ();
673 prog_has_started = 1;
674 }
675
676 static void
677 go32_mourn_inferior (void)
678 {
679 /* We need to make sure all the breakpoint enable bits in the DR7
680 register are reset when the inferior exits. Otherwise, if they
681 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
682 failure to set more watchpoints, and other calamities. It would
683 be nice if GDB itself would take care to remove all breakpoints
684 at all times, but it doesn't, probably under an assumption that
685 the OS cleans up when the debuggee exits. */
686 i386_cleanup_dregs ();
687 go32_kill_inferior ();
688 generic_mourn_inferior ();
689 }
690
691 static int
692 go32_can_run (void)
693 {
694 return 1;
695 }
696
697 /* Hardware watchpoint support. */
698
699 #define D_REGS edi.dr
700 #define CONTROL D_REGS[7]
701 #define STATUS D_REGS[6]
702
703 /* Pass the address ADDR to the inferior in the I'th debug register.
704 Here we just store the address in D_REGS, the watchpoint will be
705 actually set up when go32_wait runs the debuggee. */
706 void
707 go32_set_dr (int i, CORE_ADDR addr)
708 {
709 if (i < 0 || i > 3)
710 internal_error (__FILE__, __LINE__,
711 _("Invalid register %d in go32_set_dr.\n"), i);
712 D_REGS[i] = addr;
713 }
714
715 /* Pass the value VAL to the inferior in the DR7 debug control
716 register. Here we just store the address in D_REGS, the watchpoint
717 will be actually set up when go32_wait runs the debuggee. */
718 void
719 go32_set_dr7 (unsigned val)
720 {
721 CONTROL = val;
722 }
723
724 /* Get the value of the DR6 debug status register from the inferior.
725 Here we just return the value stored in D_REGS, as we've got it
726 from the last go32_wait call. */
727 unsigned
728 go32_get_dr6 (void)
729 {
730 return STATUS;
731 }
732
733 /* Put the device open on handle FD into either raw or cooked
734 mode, return 1 if it was in raw mode, zero otherwise. */
735
736 static int
737 device_mode (int fd, int raw_p)
738 {
739 int oldmode, newmode;
740 __dpmi_regs regs;
741
742 regs.x.ax = 0x4400;
743 regs.x.bx = fd;
744 __dpmi_int (0x21, &regs);
745 if (regs.x.flags & 1)
746 return -1;
747 newmode = oldmode = regs.x.dx;
748
749 if (raw_p)
750 newmode |= 0x20;
751 else
752 newmode &= ~0x20;
753
754 if (oldmode & 0x80) /* Only for character dev */
755 {
756 regs.x.ax = 0x4401;
757 regs.x.bx = fd;
758 regs.x.dx = newmode & 0xff; /* Force upper byte zero, else it fails */
759 __dpmi_int (0x21, &regs);
760 if (regs.x.flags & 1)
761 return -1;
762 }
763 return (oldmode & 0x20) == 0x20;
764 }
765
766
767 static int inf_mode_valid = 0;
768 static int inf_terminal_mode;
769
770 /* This semaphore is needed because, amazingly enough, GDB calls
771 target.to_terminal_ours more than once after the inferior stops.
772 But we need the information from the first call only, since the
773 second call will always see GDB's own cooked terminal. */
774 static int terminal_is_ours = 1;
775
776 static void
777 go32_terminal_init (void)
778 {
779 inf_mode_valid = 0; /* reinitialize, in case they are restarting child */
780 terminal_is_ours = 1;
781 }
782
783 static void
784 go32_terminal_info (char *args, int from_tty)
785 {
786 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
787 !inf_mode_valid
788 ? "default" : inf_terminal_mode ? "raw" : "cooked");
789
790 #if __DJGPP_MINOR__ > 2
791 if (child_cmd.redirection)
792 {
793 int i;
794
795 for (i = 0; i < DBG_HANDLES; i++)
796 {
797 if (child_cmd.redirection[i]->file_name)
798 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
799 i, child_cmd.redirection[i]->file_name);
800 else if (_get_dev_info (child_cmd.redirection[i]->inf_handle) == -1)
801 printf_unfiltered
802 ("\tFile handle %d appears to be closed by inferior.\n", i);
803 /* Mask off the raw/cooked bit when comparing device info words. */
804 else if ((_get_dev_info (child_cmd.redirection[i]->inf_handle) & 0xdf)
805 != (_get_dev_info (i) & 0xdf))
806 printf_unfiltered
807 ("\tFile handle %d appears to be redirected by inferior.\n", i);
808 }
809 }
810 #endif
811 }
812
813 static void
814 go32_terminal_inferior (void)
815 {
816 /* Redirect standard handles as child wants them. */
817 errno = 0;
818 if (redir_to_child (&child_cmd) == -1)
819 {
820 redir_to_debugger (&child_cmd);
821 error (_("Cannot redirect standard handles for program: %s."),
822 safe_strerror (errno));
823 }
824 /* set the console device of the inferior to whatever mode
825 (raw or cooked) we found it last time */
826 if (terminal_is_ours)
827 {
828 if (inf_mode_valid)
829 device_mode (0, inf_terminal_mode);
830 terminal_is_ours = 0;
831 }
832 }
833
834 static void
835 go32_terminal_ours (void)
836 {
837 /* Switch to cooked mode on the gdb terminal and save the inferior
838 terminal mode to be restored when it is resumed */
839 if (!terminal_is_ours)
840 {
841 inf_terminal_mode = device_mode (0, 0);
842 if (inf_terminal_mode != -1)
843 inf_mode_valid = 1;
844 else
845 /* If device_mode returned -1, we don't know what happens with
846 handle 0 anymore, so make the info invalid. */
847 inf_mode_valid = 0;
848 terminal_is_ours = 1;
849
850 /* Restore debugger's standard handles. */
851 errno = 0;
852 if (redir_to_debugger (&child_cmd) == -1)
853 {
854 redir_to_child (&child_cmd);
855 error (_("Cannot redirect standard handles for debugger: %s."),
856 safe_strerror (errno));
857 }
858 }
859 }
860
861 static int
862 go32_thread_alive (ptid_t ptid)
863 {
864 return 1;
865 }
866
867 static char *
868 go32_pid_to_str (ptid_t ptid)
869 {
870 static char buf[64];
871 xsnprintf (buf, sizeof buf, "Thread <main>");
872 return buf;
873 }
874
875 static void
876 init_go32_ops (void)
877 {
878 go32_ops.to_shortname = "djgpp";
879 go32_ops.to_longname = "djgpp target process";
880 go32_ops.to_doc =
881 "Program loaded by djgpp, when gdb is used as an external debugger";
882 go32_ops.to_open = go32_open;
883 go32_ops.to_close = go32_close;
884 go32_ops.to_attach = go32_attach;
885 go32_ops.to_detach = go32_detach;
886 go32_ops.to_resume = go32_resume;
887 go32_ops.to_wait = go32_wait;
888 go32_ops.to_fetch_registers = go32_fetch_registers;
889 go32_ops.to_store_registers = go32_store_registers;
890 go32_ops.to_prepare_to_store = go32_prepare_to_store;
891 go32_ops.deprecated_xfer_memory = go32_xfer_memory;
892 go32_ops.to_files_info = go32_files_info;
893 go32_ops.to_insert_breakpoint = memory_insert_breakpoint;
894 go32_ops.to_remove_breakpoint = memory_remove_breakpoint;
895 go32_ops.to_terminal_init = go32_terminal_init;
896 go32_ops.to_terminal_inferior = go32_terminal_inferior;
897 go32_ops.to_terminal_ours_for_output = go32_terminal_ours;
898 go32_ops.to_terminal_ours = go32_terminal_ours;
899 go32_ops.to_terminal_info = go32_terminal_info;
900 go32_ops.to_kill = go32_kill_inferior;
901 go32_ops.to_create_inferior = go32_create_inferior;
902 go32_ops.to_mourn_inferior = go32_mourn_inferior;
903 go32_ops.to_can_run = go32_can_run;
904 go32_ops.to_stop = go32_stop;
905 go32_ops.to_thread_alive = go32_thread_alive;
906 go32_ops.to_pid_to_str = go32_pid_to_str;
907 go32_ops.to_stratum = process_stratum;
908 go32_ops.to_has_all_memory = 1;
909 go32_ops.to_has_memory = 1;
910 go32_ops.to_has_stack = 1;
911 go32_ops.to_has_registers = 1;
912 go32_ops.to_has_execution = 1;
913 go32_ops.to_magic = OPS_MAGIC;
914
915 /* Initialize child's cwd as empty to be initialized when starting
916 the child. */
917 *child_cwd = 0;
918
919 /* Initialize child's command line storage. */
920 if (redir_debug_init (&child_cmd) == -1)
921 internal_error (__FILE__, __LINE__,
922 _("Cannot allocate redirection storage: not enough memory.\n"));
923
924 /* We are always processing GCC-compiled programs. */
925 processing_gcc_compilation = 2;
926
927 /* Override the default name of the GDB init file. */
928 strcpy (gdbinit, "gdb.ini");
929 }
930
931 unsigned short windows_major, windows_minor;
932
933 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */
934 static void
935 go32_get_windows_version(void)
936 {
937 __dpmi_regs r;
938
939 r.x.ax = 0x1600;
940 __dpmi_int(0x2f, &r);
941 if (r.h.al > 2 && r.h.al != 0x80 && r.h.al != 0xff
942 && (r.h.al > 3 || r.h.ah > 0))
943 {
944 windows_major = r.h.al;
945 windows_minor = r.h.ah;
946 }
947 else
948 windows_major = 0xff; /* meaning no Windows */
949 }
950
951 /* A subroutine of go32_sysinfo to display memory info. */
952 static void
953 print_mem (unsigned long datum, const char *header, int in_pages_p)
954 {
955 if (datum != 0xffffffffUL)
956 {
957 if (in_pages_p)
958 datum <<= 12;
959 puts_filtered (header);
960 if (datum > 1024)
961 {
962 printf_filtered ("%lu KB", datum >> 10);
963 if (datum > 1024 * 1024)
964 printf_filtered (" (%lu MB)", datum >> 20);
965 }
966 else
967 printf_filtered ("%lu Bytes", datum);
968 puts_filtered ("\n");
969 }
970 }
971
972 /* Display assorted information about the underlying OS. */
973 static void
974 go32_sysinfo (char *arg, int from_tty)
975 {
976 struct utsname u;
977 char cpuid_vendor[13];
978 unsigned cpuid_max = 0, cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx;
979 unsigned true_dos_version = _get_dos_version (1);
980 unsigned advertized_dos_version = ((unsigned int)_osmajor << 8) | _osminor;
981 int dpmi_flags;
982 char dpmi_vendor_info[129];
983 int dpmi_vendor_available =
984 __dpmi_get_capabilities (&dpmi_flags, dpmi_vendor_info);
985 __dpmi_version_ret dpmi_version_data;
986 long eflags;
987 __dpmi_free_mem_info mem_info;
988 __dpmi_regs regs;
989
990 cpuid_vendor[0] = '\0';
991 if (uname (&u))
992 strcpy (u.machine, "Unknown x86");
993 else if (u.machine[0] == 'i' && u.machine[1] > 4)
994 {
995 /* CPUID with EAX = 0 returns the Vendor ID. */
996 __asm__ __volatile__ ("xorl %%ebx, %%ebx;"
997 "xorl %%ecx, %%ecx;"
998 "xorl %%edx, %%edx;"
999 "movl $0, %%eax;"
1000 "cpuid;"
1001 "movl %%ebx, %0;"
1002 "movl %%edx, %1;"
1003 "movl %%ecx, %2;"
1004 "movl %%eax, %3;"
1005 : "=m" (cpuid_vendor[0]),
1006 "=m" (cpuid_vendor[4]),
1007 "=m" (cpuid_vendor[8]),
1008 "=m" (cpuid_max)
1009 :
1010 : "%eax", "%ebx", "%ecx", "%edx");
1011 cpuid_vendor[12] = '\0';
1012 }
1013
1014 printf_filtered ("CPU Type.......................%s", u.machine);
1015 if (cpuid_vendor[0])
1016 printf_filtered (" (%s)", cpuid_vendor);
1017 puts_filtered ("\n");
1018
1019 /* CPUID with EAX = 1 returns processor signature and features. */
1020 if (cpuid_max >= 1)
1021 {
1022 static char *brand_name[] = {
1023 "",
1024 " Celeron",
1025 " III",
1026 " III Xeon",
1027 "", "", "", "",
1028 " 4"
1029 };
1030 char cpu_string[80];
1031 char cpu_brand[20];
1032 unsigned brand_idx;
1033 int intel_p = strcmp (cpuid_vendor, "GenuineIntel") == 0;
1034 int amd_p = strcmp (cpuid_vendor, "AuthenticAMD") == 0;
1035 unsigned cpu_family, cpu_model;
1036
1037 __asm__ __volatile__ ("movl $1, %%eax;"
1038 "cpuid;"
1039 : "=a" (cpuid_eax),
1040 "=b" (cpuid_ebx),
1041 "=d" (cpuid_edx)
1042 :
1043 : "%ecx");
1044 brand_idx = cpuid_ebx & 0xff;
1045 cpu_family = (cpuid_eax >> 8) & 0xf;
1046 cpu_model = (cpuid_eax >> 4) & 0xf;
1047 cpu_brand[0] = '\0';
1048 if (intel_p)
1049 {
1050 if (brand_idx > 0
1051 && brand_idx < sizeof(brand_name)/sizeof(brand_name[0])
1052 && *brand_name[brand_idx])
1053 strcpy (cpu_brand, brand_name[brand_idx]);
1054 else if (cpu_family == 5)
1055 {
1056 if (((cpuid_eax >> 12) & 3) == 0 && cpu_model == 4)
1057 strcpy (cpu_brand, " MMX");
1058 else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 1)
1059 strcpy (cpu_brand, " OverDrive");
1060 else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 2)
1061 strcpy (cpu_brand, " Dual");
1062 }
1063 else if (cpu_family == 6 && cpu_model < 8)
1064 {
1065 switch (cpu_model)
1066 {
1067 case 1:
1068 strcpy (cpu_brand, " Pro");
1069 break;
1070 case 3:
1071 strcpy (cpu_brand, " II");
1072 break;
1073 case 5:
1074 strcpy (cpu_brand, " II Xeon");
1075 break;
1076 case 6:
1077 strcpy (cpu_brand, " Celeron");
1078 break;
1079 case 7:
1080 strcpy (cpu_brand, " III");
1081 break;
1082 }
1083 }
1084 }
1085 else if (amd_p)
1086 {
1087 switch (cpu_family)
1088 {
1089 case 4:
1090 strcpy (cpu_brand, "486/5x86");
1091 break;
1092 case 5:
1093 switch (cpu_model)
1094 {
1095 case 0:
1096 case 1:
1097 case 2:
1098 case 3:
1099 strcpy (cpu_brand, "-K5");
1100 break;
1101 case 6:
1102 case 7:
1103 strcpy (cpu_brand, "-K6");
1104 break;
1105 case 8:
1106 strcpy (cpu_brand, "-K6-2");
1107 break;
1108 case 9:
1109 strcpy (cpu_brand, "-K6-III");
1110 break;
1111 }
1112 break;
1113 case 6:
1114 switch (cpu_model)
1115 {
1116 case 1:
1117 case 2:
1118 case 4:
1119 strcpy (cpu_brand, " Athlon");
1120 break;
1121 case 3:
1122 strcpy (cpu_brand, " Duron");
1123 break;
1124 }
1125 break;
1126 }
1127 }
1128 sprintf (cpu_string, "%s%s Model %d Stepping %d",
1129 intel_p ? "Pentium" : (amd_p ? "AMD" : "ix86"),
1130 cpu_brand, cpu_model, cpuid_eax & 0xf);
1131 printfi_filtered (31, "%s\n", cpu_string);
1132 if (((cpuid_edx & (6 | (0x0d << 23))) != 0)
1133 || ((cpuid_edx & 1) == 0)
1134 || (amd_p && (cpuid_edx & (3 << 30)) != 0))
1135 {
1136 puts_filtered ("CPU Features...................");
1137 /* We only list features which might be useful in the DPMI
1138 environment. */
1139 if ((cpuid_edx & 1) == 0)
1140 puts_filtered ("No FPU "); /* it's unusual to not have an FPU */
1141 if ((cpuid_edx & (1 << 1)) != 0)
1142 puts_filtered ("VME ");
1143 if ((cpuid_edx & (1 << 2)) != 0)
1144 puts_filtered ("DE ");
1145 if ((cpuid_edx & (1 << 4)) != 0)
1146 puts_filtered ("TSC ");
1147 if ((cpuid_edx & (1 << 23)) != 0)
1148 puts_filtered ("MMX ");
1149 if ((cpuid_edx & (1 << 25)) != 0)
1150 puts_filtered ("SSE ");
1151 if ((cpuid_edx & (1 << 26)) != 0)
1152 puts_filtered ("SSE2 ");
1153 if (amd_p)
1154 {
1155 if ((cpuid_edx & (1 << 31)) != 0)
1156 puts_filtered ("3DNow! ");
1157 if ((cpuid_edx & (1 << 30)) != 0)
1158 puts_filtered ("3DNow!Ext");
1159 }
1160 puts_filtered ("\n");
1161 }
1162 }
1163 puts_filtered ("\n");
1164 printf_filtered ("DOS Version....................%s %s.%s",
1165 _os_flavor, u.release, u.version);
1166 if (true_dos_version != advertized_dos_version)
1167 printf_filtered (" (disguised as v%d.%d)", _osmajor, _osminor);
1168 puts_filtered ("\n");
1169 if (!windows_major)
1170 go32_get_windows_version ();
1171 if (windows_major != 0xff)
1172 {
1173 const char *windows_flavor;
1174
1175 printf_filtered ("Windows Version................%d.%02d (Windows ",
1176 windows_major, windows_minor);
1177 switch (windows_major)
1178 {
1179 case 3:
1180 windows_flavor = "3.X";
1181 break;
1182 case 4:
1183 switch (windows_minor)
1184 {
1185 case 0:
1186 windows_flavor = "95, 95A, or 95B";
1187 break;
1188 case 3:
1189 windows_flavor = "95B OSR2.1 or 95C OSR2.5";
1190 break;
1191 case 10:
1192 windows_flavor = "98 or 98 SE";
1193 break;
1194 case 90:
1195 windows_flavor = "ME";
1196 break;
1197 default:
1198 windows_flavor = "9X";
1199 break;
1200 }
1201 break;
1202 default:
1203 windows_flavor = "??";
1204 break;
1205 }
1206 printf_filtered ("%s)\n", windows_flavor);
1207 }
1208 else if (true_dos_version == 0x532 && advertized_dos_version == 0x500)
1209 printf_filtered ("Windows Version................Windows NT or Windows 2000\n");
1210 puts_filtered ("\n");
1211 if (dpmi_vendor_available == 0)
1212 {
1213 /* The DPMI spec says the vendor string should be ASCIIZ, but
1214 I don't trust the vendors to follow that... */
1215 if (!memchr (&dpmi_vendor_info[2], 0, 126))
1216 dpmi_vendor_info[128] = '\0';
1217 printf_filtered ("DPMI Host......................%s v%d.%d (capabilities: %#x)\n",
1218 &dpmi_vendor_info[2],
1219 (unsigned)dpmi_vendor_info[0],
1220 (unsigned)dpmi_vendor_info[1],
1221 ((unsigned)dpmi_flags & 0x7f));
1222 }
1223 __dpmi_get_version (&dpmi_version_data);
1224 printf_filtered ("DPMI Version...................%d.%02d\n",
1225 dpmi_version_data.major, dpmi_version_data.minor);
1226 printf_filtered ("DPMI Info......................%s-bit DPMI, with%s Virtual Memory support\n",
1227 (dpmi_version_data.flags & 1) ? "32" : "16",
1228 (dpmi_version_data.flags & 4) ? "" : "out");
1229 printfi_filtered (31, "Interrupts reflected to %s mode\n",
1230 (dpmi_version_data.flags & 2) ? "V86" : "Real");
1231 printfi_filtered (31, "Processor type: i%d86\n",
1232 dpmi_version_data.cpu);
1233 printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
1234 dpmi_version_data.master_pic, dpmi_version_data.slave_pic);
1235
1236 /* a_tss is only initialized when the debuggee is first run. */
1237 if (prog_has_started)
1238 {
1239 __asm__ __volatile__ ("pushfl ; popl %0" : "=g" (eflags));
1240 printf_filtered ("Protection.....................Ring %d (in %s), with%s I/O protection\n",
1241 a_tss.tss_cs & 3, (a_tss.tss_cs & 4) ? "LDT" : "GDT",
1242 (a_tss.tss_cs & 3) > ((eflags >> 12) & 3) ? "" : "out");
1243 }
1244 puts_filtered ("\n");
1245 __dpmi_get_free_memory_information (&mem_info);
1246 print_mem (mem_info.total_number_of_physical_pages,
1247 "DPMI Total Physical Memory.....", 1);
1248 print_mem (mem_info.total_number_of_free_pages,
1249 "DPMI Free Physical Memory......", 1);
1250 print_mem (mem_info.size_of_paging_file_partition_in_pages,
1251 "DPMI Swap Space................", 1);
1252 print_mem (mem_info.linear_address_space_size_in_pages,
1253 "DPMI Total Linear Address Size.", 1);
1254 print_mem (mem_info.free_linear_address_space_in_pages,
1255 "DPMI Free Linear Address Size..", 1);
1256 print_mem (mem_info.largest_available_free_block_in_bytes,
1257 "DPMI Largest Free Memory Block.", 0);
1258
1259 regs.h.ah = 0x48;
1260 regs.x.bx = 0xffff;
1261 __dpmi_int (0x21, &regs);
1262 print_mem (regs.x.bx << 4, "Free DOS Memory................", 0);
1263 regs.x.ax = 0x5800;
1264 __dpmi_int (0x21, &regs);
1265 if ((regs.x.flags & 1) == 0)
1266 {
1267 static const char *dos_hilo[] = {
1268 "Low", "", "", "", "High", "", "", "", "High, then Low"
1269 };
1270 static const char *dos_fit[] = {
1271 "First", "Best", "Last"
1272 };
1273 int hilo_idx = (regs.x.ax >> 4) & 0x0f;
1274 int fit_idx = regs.x.ax & 0x0f;
1275
1276 if (hilo_idx > 8)
1277 hilo_idx = 0;
1278 if (fit_idx > 2)
1279 fit_idx = 0;
1280 printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1281 dos_hilo[hilo_idx], dos_fit[fit_idx]);
1282 regs.x.ax = 0x5802;
1283 __dpmi_int (0x21, &regs);
1284 if ((regs.x.flags & 1) != 0)
1285 regs.h.al = 0;
1286 printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1287 regs.h.al == 0 ? "not " : "");
1288 }
1289 }
1290
1291 struct seg_descr {
1292 unsigned short limit0;
1293 unsigned short base0;
1294 unsigned char base1;
1295 unsigned stype:5;
1296 unsigned dpl:2;
1297 unsigned present:1;
1298 unsigned limit1:4;
1299 unsigned available:1;
1300 unsigned dummy:1;
1301 unsigned bit32:1;
1302 unsigned page_granular:1;
1303 unsigned char base2;
1304 } __attribute__ ((packed));
1305
1306 struct gate_descr {
1307 unsigned short offset0;
1308 unsigned short selector;
1309 unsigned param_count:5;
1310 unsigned dummy:3;
1311 unsigned stype:5;
1312 unsigned dpl:2;
1313 unsigned present:1;
1314 unsigned short offset1;
1315 } __attribute__ ((packed));
1316
1317 /* Read LEN bytes starting at logical address ADDR, and put the result
1318 into DEST. Return 1 if success, zero if not. */
1319 static int
1320 read_memory_region (unsigned long addr, void *dest, size_t len)
1321 {
1322 unsigned long dos_ds_limit = __dpmi_get_segment_limit (_dos_ds);
1323 int retval = 1;
1324
1325 /* For the low memory, we can simply use _dos_ds. */
1326 if (addr <= dos_ds_limit - len)
1327 dosmemget (addr, len, dest);
1328 else
1329 {
1330 /* For memory above 1MB we need to set up a special segment to
1331 be able to access that memory. */
1332 int sel = __dpmi_allocate_ldt_descriptors (1);
1333
1334 if (sel <= 0)
1335 retval = 0;
1336 else
1337 {
1338 int access_rights = __dpmi_get_descriptor_access_rights (sel);
1339 size_t segment_limit = len - 1;
1340
1341 /* Make sure the crucial bits in the descriptor access
1342 rights are set correctly. Some DPMI providers might barf
1343 if we set the segment limit to something that is not an
1344 integral multiple of 4KB pages if the granularity bit is
1345 not set to byte-granular, even though the DPMI spec says
1346 it's the host's responsibility to set that bit correctly. */
1347 if (len > 1024 * 1024)
1348 {
1349 access_rights |= 0x8000;
1350 /* Page-granular segments should have the low 12 bits of
1351 the limit set. */
1352 segment_limit |= 0xfff;
1353 }
1354 else
1355 access_rights &= ~0x8000;
1356
1357 if (__dpmi_set_segment_base_address (sel, addr) != -1
1358 && __dpmi_set_descriptor_access_rights (sel, access_rights) != -1
1359 && __dpmi_set_segment_limit (sel, segment_limit) != -1
1360 /* W2K silently fails to set the segment limit, leaving
1361 it at zero; this test avoids the resulting crash. */
1362 && __dpmi_get_segment_limit (sel) >= segment_limit)
1363 movedata (sel, 0, _my_ds (), (unsigned)dest, len);
1364 else
1365 retval = 0;
1366
1367 __dpmi_free_ldt_descriptor (sel);
1368 }
1369 }
1370 return retval;
1371 }
1372
1373 /* Get a segment descriptor stored at index IDX in the descriptor
1374 table whose base address is TABLE_BASE. Return the descriptor
1375 type, or -1 if failure. */
1376 static int
1377 get_descriptor (unsigned long table_base, int idx, void *descr)
1378 {
1379 unsigned long addr = table_base + idx * 8; /* 8 bytes per entry */
1380
1381 if (read_memory_region (addr, descr, 8))
1382 return (int)((struct seg_descr *)descr)->stype;
1383 return -1;
1384 }
1385
1386 struct dtr_reg {
1387 unsigned short limit __attribute__((packed));
1388 unsigned long base __attribute__((packed));
1389 };
1390
1391 /* Display a segment descriptor stored at index IDX in a descriptor
1392 table whose type is TYPE and whose base address is BASE_ADDR. If
1393 FORCE is non-zero, display even invalid descriptors. */
1394 static void
1395 display_descriptor (unsigned type, unsigned long base_addr, int idx, int force)
1396 {
1397 struct seg_descr descr;
1398 struct gate_descr gate;
1399
1400 /* Get the descriptor from the table. */
1401 if (idx == 0 && type == 0)
1402 puts_filtered ("0x000: null descriptor\n");
1403 else if (get_descriptor (base_addr, idx, &descr) != -1)
1404 {
1405 /* For each type of descriptor table, this has a bit set if the
1406 corresponding type of selectors is valid in that table. */
1407 static unsigned allowed_descriptors[] = {
1408 0xffffdafeL, /* GDT */
1409 0x0000c0e0L, /* IDT */
1410 0xffffdafaL /* LDT */
1411 };
1412
1413 /* If the program hasn't started yet, assume the debuggee will
1414 have the same CPL as the debugger. */
1415 int cpl = prog_has_started ? (a_tss.tss_cs & 3) : _my_cs () & 3;
1416 unsigned long limit = (descr.limit1 << 16) | descr.limit0;
1417
1418 if (descr.present
1419 && (allowed_descriptors[type] & (1 << descr.stype)) != 0)
1420 {
1421 printf_filtered ("0x%03x: ",
1422 type == 1
1423 ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1424 if (descr.page_granular)
1425 limit = (limit << 12) | 0xfff; /* big segment: low 12 bit set */
1426 if (descr.stype == 1 || descr.stype == 2 || descr.stype == 3
1427 || descr.stype == 9 || descr.stype == 11
1428 || (descr.stype >= 16 && descr.stype < 32))
1429 printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1430 descr.base2, descr.base1, descr.base0, limit);
1431
1432 switch (descr.stype)
1433 {
1434 case 1:
1435 case 3:
1436 printf_filtered (" 16-bit TSS (task %sactive)",
1437 descr.stype == 3 ? "" : "in");
1438 break;
1439 case 2:
1440 puts_filtered (" LDT");
1441 break;
1442 case 4:
1443 memcpy (&gate, &descr, sizeof gate);
1444 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1445 gate.selector, gate.offset1, gate.offset0);
1446 printf_filtered (" 16-bit Call Gate (params=%d)",
1447 gate.param_count);
1448 break;
1449 case 5:
1450 printf_filtered ("TSS selector=0x%04x", descr.base0);
1451 printfi_filtered (16, "Task Gate");
1452 break;
1453 case 6:
1454 case 7:
1455 memcpy (&gate, &descr, sizeof gate);
1456 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1457 gate.selector, gate.offset1, gate.offset0);
1458 printf_filtered (" 16-bit %s Gate",
1459 descr.stype == 6 ? "Interrupt" : "Trap");
1460 break;
1461 case 9:
1462 case 11:
1463 printf_filtered (" 32-bit TSS (task %sactive)",
1464 descr.stype == 3 ? "" : "in");
1465 break;
1466 case 12:
1467 memcpy (&gate, &descr, sizeof gate);
1468 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1469 gate.selector, gate.offset1, gate.offset0);
1470 printf_filtered (" 32-bit Call Gate (params=%d)",
1471 gate.param_count);
1472 break;
1473 case 14:
1474 case 15:
1475 memcpy (&gate, &descr, sizeof gate);
1476 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1477 gate.selector, gate.offset1, gate.offset0);
1478 printf_filtered (" 32-bit %s Gate",
1479 descr.stype == 14 ? "Interrupt" : "Trap");
1480 break;
1481 case 16: /* data segments */
1482 case 17:
1483 case 18:
1484 case 19:
1485 case 20:
1486 case 21:
1487 case 22:
1488 case 23:
1489 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1490 descr.bit32 ? "32" : "16",
1491 descr.stype & 2 ? "Read/Write," : "Read-Only, ",
1492 descr.stype & 4 ? "down" : "up",
1493 descr.stype & 1 ? "" : ", N.Acc");
1494 break;
1495 case 24: /* code segments */
1496 case 25:
1497 case 26:
1498 case 27:
1499 case 28:
1500 case 29:
1501 case 30:
1502 case 31:
1503 printf_filtered (" %s-bit Code (%s, %sConf%s)",
1504 descr.bit32 ? "32" : "16",
1505 descr.stype & 2 ? "Exec/Read" : "Exec-Only",
1506 descr.stype & 4 ? "" : "N.",
1507 descr.stype & 1 ? "" : ", N.Acc");
1508 break;
1509 default:
1510 printf_filtered ("Unknown type 0x%02x", descr.stype);
1511 break;
1512 }
1513 puts_filtered ("\n");
1514 }
1515 else if (force)
1516 {
1517 printf_filtered ("0x%03x: ",
1518 type == 1
1519 ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1520 if (!descr.present)
1521 puts_filtered ("Segment not present\n");
1522 else
1523 printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1524 descr.stype);
1525 }
1526 }
1527 else if (force)
1528 printf_filtered ("0x%03x: Cannot read this descriptor\n", idx);
1529 }
1530
1531 static void
1532 go32_sldt (char *arg, int from_tty)
1533 {
1534 struct dtr_reg gdtr;
1535 unsigned short ldtr = 0;
1536 int ldt_idx;
1537 struct seg_descr ldt_descr;
1538 long ldt_entry = -1L;
1539 int cpl = (prog_has_started ? a_tss.tss_cs : _my_cs ()) & 3;
1540
1541 if (arg && *arg)
1542 {
1543 while (*arg && isspace(*arg))
1544 arg++;
1545
1546 if (*arg)
1547 {
1548 ldt_entry = parse_and_eval_long (arg);
1549 if (ldt_entry < 0
1550 || (ldt_entry & 4) == 0
1551 || (ldt_entry & 3) != (cpl & 3))
1552 error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry);
1553 }
1554 }
1555
1556 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1557 __asm__ __volatile__ ("sldt %0" : "=m" (ldtr) : /* no inputs */ );
1558 ldt_idx = ldtr / 8;
1559 if (ldt_idx == 0)
1560 puts_filtered ("There is no LDT.\n");
1561 /* LDT's entry in the GDT must have the type LDT, which is 2. */
1562 else if (get_descriptor (gdtr.base, ldt_idx, &ldt_descr) != 2)
1563 printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1564 ldt_descr.base0
1565 | (ldt_descr.base1 << 16)
1566 | (ldt_descr.base2 << 24));
1567 else
1568 {
1569 unsigned base =
1570 ldt_descr.base0
1571 | (ldt_descr.base1 << 16)
1572 | (ldt_descr.base2 << 24);
1573 unsigned limit = ldt_descr.limit0 | (ldt_descr.limit1 << 16);
1574 int max_entry;
1575
1576 if (ldt_descr.page_granular)
1577 /* Page-granular segments must have the low 12 bits of their
1578 limit set. */
1579 limit = (limit << 12) | 0xfff;
1580 /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1581 64KB. */
1582 if (limit > 0xffff)
1583 limit = 0xffff;
1584
1585 max_entry = (limit + 1) / 8;
1586
1587 if (ldt_entry >= 0)
1588 {
1589 if (ldt_entry > limit)
1590 error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1591 (unsigned long)ldt_entry, limit);
1592
1593 display_descriptor (ldt_descr.stype, base, ldt_entry / 8, 1);
1594 }
1595 else
1596 {
1597 int i;
1598
1599 for (i = 0; i < max_entry; i++)
1600 display_descriptor (ldt_descr.stype, base, i, 0);
1601 }
1602 }
1603 }
1604
1605 static void
1606 go32_sgdt (char *arg, int from_tty)
1607 {
1608 struct dtr_reg gdtr;
1609 long gdt_entry = -1L;
1610 int max_entry;
1611
1612 if (arg && *arg)
1613 {
1614 while (*arg && isspace(*arg))
1615 arg++;
1616
1617 if (*arg)
1618 {
1619 gdt_entry = parse_and_eval_long (arg);
1620 if (gdt_entry < 0 || (gdt_entry & 7) != 0)
1621 error (_("Invalid GDT entry 0x%03lx: not an integral multiple of 8."),
1622 (unsigned long)gdt_entry);
1623 }
1624 }
1625
1626 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1627 max_entry = (gdtr.limit + 1) / 8;
1628
1629 if (gdt_entry >= 0)
1630 {
1631 if (gdt_entry > gdtr.limit)
1632 error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1633 (unsigned long)gdt_entry, gdtr.limit);
1634
1635 display_descriptor (0, gdtr.base, gdt_entry / 8, 1);
1636 }
1637 else
1638 {
1639 int i;
1640
1641 for (i = 0; i < max_entry; i++)
1642 display_descriptor (0, gdtr.base, i, 0);
1643 }
1644 }
1645
1646 static void
1647 go32_sidt (char *arg, int from_tty)
1648 {
1649 struct dtr_reg idtr;
1650 long idt_entry = -1L;
1651 int max_entry;
1652
1653 if (arg && *arg)
1654 {
1655 while (*arg && isspace(*arg))
1656 arg++;
1657
1658 if (*arg)
1659 {
1660 idt_entry = parse_and_eval_long (arg);
1661 if (idt_entry < 0)
1662 error (_("Invalid (negative) IDT entry %ld."), idt_entry);
1663 }
1664 }
1665
1666 __asm__ __volatile__ ("sidt %0" : "=m" (idtr) : /* no inputs */ );
1667 max_entry = (idtr.limit + 1) / 8;
1668 if (max_entry > 0x100) /* no more than 256 entries */
1669 max_entry = 0x100;
1670
1671 if (idt_entry >= 0)
1672 {
1673 if (idt_entry > idtr.limit)
1674 error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1675 (unsigned long)idt_entry, idtr.limit);
1676
1677 display_descriptor (1, idtr.base, idt_entry, 1);
1678 }
1679 else
1680 {
1681 int i;
1682
1683 for (i = 0; i < max_entry; i++)
1684 display_descriptor (1, idtr.base, i, 0);
1685 }
1686 }
1687
1688 /* Cached linear address of the base of the page directory. For
1689 now, available only under CWSDPMI. Code based on ideas and
1690 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
1691 static unsigned long pdbr;
1692
1693 static unsigned long
1694 get_cr3 (void)
1695 {
1696 unsigned offset;
1697 unsigned taskreg;
1698 unsigned long taskbase, cr3;
1699 struct dtr_reg gdtr;
1700
1701 if (pdbr > 0 && pdbr <= 0xfffff)
1702 return pdbr;
1703
1704 /* Get the linear address of GDT and the Task Register. */
1705 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1706 __asm__ __volatile__ ("str %0" : "=m" (taskreg) : /* no inputs */ );
1707
1708 /* Task Register is a segment selector for the TSS of the current
1709 task. Therefore, it can be used as an index into the GDT to get
1710 at the segment descriptor for the TSS. To get the index, reset
1711 the low 3 bits of the selector (which give the CPL). Add 2 to the
1712 offset to point to the 3 low bytes of the base address. */
1713 offset = gdtr.base + (taskreg & 0xfff8) + 2;
1714
1715
1716 /* CWSDPMI's task base is always under the 1MB mark. */
1717 if (offset > 0xfffff)
1718 return 0;
1719
1720 _farsetsel (_dos_ds);
1721 taskbase = _farnspeekl (offset) & 0xffffffU;
1722 taskbase += _farnspeekl (offset + 2) & 0xff000000U;
1723 if (taskbase > 0xfffff)
1724 return 0;
1725
1726 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1727 offset 1Ch in the TSS. */
1728 cr3 = _farnspeekl (taskbase + 0x1c) & ~0xfff;
1729 if (cr3 > 0xfffff)
1730 {
1731 #if 0 /* not fullly supported yet */
1732 /* The Page Directory is in UMBs. In that case, CWSDPMI puts
1733 the first Page Table right below the Page Directory. Thus,
1734 the first Page Table's entry for its own address and the Page
1735 Directory entry for that Page Table will hold the same
1736 physical address. The loop below searches the entire UMB
1737 range of addresses for such an occurence. */
1738 unsigned long addr, pte_idx;
1739
1740 for (addr = 0xb0000, pte_idx = 0xb0;
1741 pte_idx < 0xff;
1742 addr += 0x1000, pte_idx++)
1743 {
1744 if (((_farnspeekl (addr + 4 * pte_idx) & 0xfffff027) ==
1745 (_farnspeekl (addr + 0x1000) & 0xfffff027))
1746 && ((_farnspeekl (addr + 4 * pte_idx + 4) & 0xfffff000) == cr3))
1747 {
1748 cr3 = addr + 0x1000;
1749 break;
1750 }
1751 }
1752 #endif
1753
1754 if (cr3 > 0xfffff)
1755 cr3 = 0;
1756 }
1757
1758 return cr3;
1759 }
1760
1761 /* Return the N'th Page Directory entry. */
1762 static unsigned long
1763 get_pde (int n)
1764 {
1765 unsigned long pde = 0;
1766
1767 if (pdbr && n >= 0 && n < 1024)
1768 {
1769 pde = _farpeekl (_dos_ds, pdbr + 4*n);
1770 }
1771 return pde;
1772 }
1773
1774 /* Return the N'th entry of the Page Table whose Page Directory entry
1775 is PDE. */
1776 static unsigned long
1777 get_pte (unsigned long pde, int n)
1778 {
1779 unsigned long pte = 0;
1780
1781 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
1782 page tables, for now. */
1783 if ((pde & 1) && !(pde & 0x80) && n >= 0 && n < 1024)
1784 {
1785 pde &= ~0xfff; /* clear non-address bits */
1786 pte = _farpeekl (_dos_ds, pde + 4*n);
1787 }
1788 return pte;
1789 }
1790
1791 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
1792 says this is a Page Directory entry. If FORCE is non-zero, display
1793 the entry even if its Present flag is off. OFF is the offset of the
1794 address from the page's base address. */
1795 static void
1796 display_ptable_entry (unsigned long entry, int is_dir, int force, unsigned off)
1797 {
1798 if ((entry & 1) != 0)
1799 {
1800 printf_filtered ("Base=0x%05lx000", entry >> 12);
1801 if ((entry & 0x100) && !is_dir)
1802 puts_filtered (" Global");
1803 if ((entry & 0x40) && !is_dir)
1804 puts_filtered (" Dirty");
1805 printf_filtered (" %sAcc.", (entry & 0x20) ? "" : "Not-");
1806 printf_filtered (" %sCached", (entry & 0x10) ? "" : "Not-");
1807 printf_filtered (" Write-%s", (entry & 8) ? "Thru" : "Back");
1808 printf_filtered (" %s", (entry & 4) ? "Usr" : "Sup");
1809 printf_filtered (" Read-%s", (entry & 2) ? "Write" : "Only");
1810 if (off)
1811 printf_filtered (" +0x%x", off);
1812 puts_filtered ("\n");
1813 }
1814 else if (force)
1815 printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1816 is_dir ? " Table" : "", entry >> 1);
1817 }
1818
1819 static void
1820 go32_pde (char *arg, int from_tty)
1821 {
1822 long pde_idx = -1, i;
1823
1824 if (arg && *arg)
1825 {
1826 while (*arg && isspace(*arg))
1827 arg++;
1828
1829 if (*arg)
1830 {
1831 pde_idx = parse_and_eval_long (arg);
1832 if (pde_idx < 0 || pde_idx >= 1024)
1833 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
1834 }
1835 }
1836
1837 pdbr = get_cr3 ();
1838 if (!pdbr)
1839 puts_filtered ("Access to Page Directories is not supported on this system.\n");
1840 else if (pde_idx >= 0)
1841 display_ptable_entry (get_pde (pde_idx), 1, 1, 0);
1842 else
1843 for (i = 0; i < 1024; i++)
1844 display_ptable_entry (get_pde (i), 1, 0, 0);
1845 }
1846
1847 /* A helper function to display entries in a Page Table pointed to by
1848 the N'th entry in the Page Directory. If FORCE is non-zero, say
1849 something even if the Page Table is not accessible. */
1850 static void
1851 display_page_table (long n, int force)
1852 {
1853 unsigned long pde = get_pde (n);
1854
1855 if ((pde & 1) != 0)
1856 {
1857 int i;
1858
1859 printf_filtered ("Page Table pointed to by Page Directory entry 0x%lx:\n", n);
1860 for (i = 0; i < 1024; i++)
1861 display_ptable_entry (get_pte (pde, i), 0, 0, 0);
1862 puts_filtered ("\n");
1863 }
1864 else if (force)
1865 printf_filtered ("Page Table not present; value=0x%lx.\n", pde >> 1);
1866 }
1867
1868 static void
1869 go32_pte (char *arg, int from_tty)
1870 {
1871 long pde_idx = -1L, i;
1872
1873 if (arg && *arg)
1874 {
1875 while (*arg && isspace(*arg))
1876 arg++;
1877
1878 if (*arg)
1879 {
1880 pde_idx = parse_and_eval_long (arg);
1881 if (pde_idx < 0 || pde_idx >= 1024)
1882 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
1883 }
1884 }
1885
1886 pdbr = get_cr3 ();
1887 if (!pdbr)
1888 puts_filtered ("Access to Page Tables is not supported on this system.\n");
1889 else if (pde_idx >= 0)
1890 display_page_table (pde_idx, 1);
1891 else
1892 for (i = 0; i < 1024; i++)
1893 display_page_table (i, 0);
1894 }
1895
1896 static void
1897 go32_pte_for_address (char *arg, int from_tty)
1898 {
1899 CORE_ADDR addr = 0, i;
1900
1901 if (arg && *arg)
1902 {
1903 while (*arg && isspace(*arg))
1904 arg++;
1905
1906 if (*arg)
1907 addr = parse_and_eval_address (arg);
1908 }
1909 if (!addr)
1910 error_no_arg (_("linear address"));
1911
1912 pdbr = get_cr3 ();
1913 if (!pdbr)
1914 puts_filtered ("Access to Page Tables is not supported on this system.\n");
1915 else
1916 {
1917 int pde_idx = (addr >> 22) & 0x3ff;
1918 int pte_idx = (addr >> 12) & 0x3ff;
1919 unsigned offs = addr & 0xfff;
1920
1921 printf_filtered ("Page Table entry for address 0x%llx:\n",
1922 (unsigned long long)addr);
1923 display_ptable_entry (get_pte (get_pde (pde_idx), pte_idx), 0, 1, offs);
1924 }
1925 }
1926
1927 static struct cmd_list_element *info_dos_cmdlist = NULL;
1928
1929 static void
1930 go32_info_dos_command (char *args, int from_tty)
1931 {
1932 help_list (info_dos_cmdlist, "info dos ", class_info, gdb_stdout);
1933 }
1934
1935 void
1936 _initialize_go32_nat (void)
1937 {
1938 init_go32_ops ();
1939 add_target (&go32_ops);
1940
1941 add_prefix_cmd ("dos", class_info, go32_info_dos_command, _("\
1942 Print information specific to DJGPP (aka MS-DOS) debugging."),
1943 &info_dos_cmdlist, "info dos ", 0, &infolist);
1944
1945 add_cmd ("sysinfo", class_info, go32_sysinfo, _("\
1946 Display information about the target system, including CPU, OS, DPMI, etc."),
1947 &info_dos_cmdlist);
1948 add_cmd ("ldt", class_info, go32_sldt, _("\
1949 Display entries in the LDT (Local Descriptor Table).\n\
1950 Entry number (an expression) as an argument means display only that entry."),
1951 &info_dos_cmdlist);
1952 add_cmd ("gdt", class_info, go32_sgdt, _("\
1953 Display entries in the GDT (Global Descriptor Table).\n\
1954 Entry number (an expression) as an argument means display only that entry."),
1955 &info_dos_cmdlist);
1956 add_cmd ("idt", class_info, go32_sidt, _("\
1957 Display entries in the IDT (Interrupt Descriptor Table).\n\
1958 Entry number (an expression) as an argument means display only that entry."),
1959 &info_dos_cmdlist);
1960 add_cmd ("pde", class_info, go32_pde, _("\
1961 Display entries in the Page Directory.\n\
1962 Entry number (an expression) as an argument means display only that entry."),
1963 &info_dos_cmdlist);
1964 add_cmd ("pte", class_info, go32_pte, _("\
1965 Display entries in Page Tables.\n\
1966 Entry number (an expression) as an argument means display only entries\n\
1967 from the Page Table pointed to by the specified Page Directory entry."),
1968 &info_dos_cmdlist);
1969 add_cmd ("address-pte", class_info, go32_pte_for_address, _("\
1970 Display a Page Table entry for a linear address.\n\
1971 The address argument must be a linear address, after adding to\n\
1972 it the base address of the appropriate segment.\n\
1973 The base address of variables and functions in the debuggee's data\n\
1974 or code segment is stored in the variable __djgpp_base_address,\n\
1975 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
1976 For other segments, look up their base address in the output of\n\
1977 the `info dos ldt' command."),
1978 &info_dos_cmdlist);
1979 }
1980
1981 pid_t
1982 tcgetpgrp (int fd)
1983 {
1984 if (isatty (fd))
1985 return SOME_PID;
1986 errno = ENOTTY;
1987 return -1;
1988 }
1989
1990 int
1991 tcsetpgrp (int fd, pid_t pgid)
1992 {
1993 if (isatty (fd) && pgid == SOME_PID)
1994 return 0;
1995 errno = pgid == SOME_PID ? ENOTTY : ENOSYS;
1996 return -1;
1997 }
This page took 0.071883 seconds and 4 git commands to generate.