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