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