![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to inflow.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb|
Return to inflow.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb |
1.1 ! root 1: /* Low level interface to ptrace, for GDB when running under Unix. ! 2: Copyright (C) 1986, 1987 Free Software Foundation, Inc. ! 3: ! 4: GDB is distributed in the hope that it will be useful, but WITHOUT ANY ! 5: WARRANTY. No author or distributor accepts responsibility to anyone ! 6: for the consequences of using it or for whether it serves any ! 7: particular purpose or works at all, unless he says so in writing. ! 8: Refer to the GDB General Public License for full details. ! 9: ! 10: Everyone is granted permission to copy, modify and redistribute GDB, ! 11: but only under the conditions described in the GDB General Public ! 12: License. A copy of this license is supposed to have been given to you ! 13: along with GDB so you can know your rights and responsibilities. It ! 14: should be in a file named COPYING. Among other things, the copyright ! 15: notice and this notice must be preserved on all copies. ! 16: ! 17: In other words, go ahead and share GDB, but don't try to stop ! 18: anyone else from sharing it farther. Help stamp out software hoarding! ! 19: */ ! 20: ! 21: #include "defs.h" ! 22: #include "initialize.h" ! 23: #include "param.h" ! 24: #include "frame.h" ! 25: #include "inferior.h" ! 26: ! 27: #include <stdio.h> ! 28: #include <sys/param.h> ! 29: #include <sys/dir.h> ! 30: #ifndef UMAX_PTRACE ! 31: #include <sys/user.h> ! 32: #endif ! 33: #include <signal.h> ! 34: #include <sys/ioctl.h> ! 35: #include <fcntl.h> ! 36: ! 37: #ifdef UMAX_PTRACE ! 38: #include <a.out.h> ! 39: #include <sys/ptrace.h> ! 40: #define PTRACE_ATTACH PT_ATTACH ! 41: #define PTRACE_DETACH PT_FREEPROC ! 42: #endif ! 43: ! 44: #ifdef NEW_SUN_PTRACE ! 45: #include <sys/ptrace.h> ! 46: #include <machine/reg.h> ! 47: #endif ! 48: ! 49: #ifdef HP9K320 ! 50: #include <sys/ptrace.h> ! 51: #include <sys/reg.h> ! 52: #include <sys/trap.h> ! 53: #endif ! 54: ! 55: #ifdef HAVE_TERMIO ! 56: #include <termio.h> ! 57: #undef TIOCGETP ! 58: #define TIOCGETP TCGETA ! 59: #undef TIOCSETN ! 60: #define TIOCSETN TCSETA ! 61: #undef TIOCSETP ! 62: #define TIOCSETP TCSETAF ! 63: #define TERMINAL struct termio ! 64: #else ! 65: #include <sgtty.h> ! 66: #define TERMINAL struct sgttyb ! 67: #endif ! 68: ! 69: extern int errno; ! 70: ! 71: /* Nonzero if we are debugging an attached outside process ! 72: rather than an inferior. */ ! 73: ! 74: static int attach_flag; ! 75: ! 76: START_FILE ! 77: ! 78: /* Record terminal status separately for debugger and inferior. */ ! 79: ! 80: static TERMINAL sg_inferior; ! 81: static TERMINAL sg_ours; ! 82: static int tflags_inferior; ! 83: static int tflags_ours; ! 84: ! 85: #ifdef TIOCGLTC ! 86: static struct tchars tc_inferior; ! 87: static struct tchars tc_ours; ! 88: static struct ltchars ltc_inferior; ! 89: static struct ltchars ltc_ours; ! 90: static int lmode_inferior; ! 91: static int lmode_ours; ! 92: #endif /* TIOCGLTC */ ! 93: ! 94: #ifdef TIOCGPGRP ! 95: static int pgrp_inferior; ! 96: static int pgrp_ours; ! 97: #else ! 98: static int (*sigint_ours) (); ! 99: static int (*sigquit_ours) (); ! 100: #endif /* TIOCGPGRP */ ! 101: ! 102: /* Copy of inferior_io_terminal when inferior was last started. */ ! 103: static char *inferior_thisrun_terminal; ! 104: ! 105: static void terminal_ours_1 (); ! 106: ! 107: /* Nonzero if our terminal settings are in effect. ! 108: Zero if the inferior's settings are in effect. */ ! 109: static int terminal_is_ours; ! 110: ! 111: /* Initialize the terminal settings we record for the inferior, ! 112: before we actually run the inferior. */ ! 113: ! 114: void ! 115: terminal_init_inferior () ! 116: { ! 117: if (remote_debugging) ! 118: return; ! 119: ! 120: sg_inferior = sg_ours; ! 121: tflags_inferior = tflags_ours; ! 122: ! 123: #ifdef TIOCGLTC ! 124: tc_inferior = tc_ours; ! 125: ltc_inferior = ltc_ours; ! 126: lmode_inferior = lmode_ours; ! 127: #endif /* TIOCGLTC */ ! 128: ! 129: #ifdef TIOCGPGRP ! 130: pgrp_inferior = inferior_pid; ! 131: #endif /* TIOCGPGRP */ ! 132: ! 133: terminal_is_ours = 1; ! 134: } ! 135: ! 136: /* Put the inferior's terminal settings into effect. ! 137: This is preparation for starting or resuming the inferior. */ ! 138: ! 139: void ! 140: terminal_inferior () ! 141: { ! 142: if (remote_debugging) ! 143: return; ! 144: ! 145: if (terminal_is_ours) /* && inferior_thisrun_terminal == 0) */ ! 146: { ! 147: fcntl (0, F_SETFL, tflags_inferior); ! 148: fcntl (0, F_SETFL, tflags_inferior); ! 149: ioctl (0, TIOCSETN, &sg_inferior); ! 150: ! 151: #ifdef TIOCGLTC ! 152: ioctl (0, TIOCSETC, &tc_inferior); ! 153: ioctl (0, TIOCSLTC, <c_inferior); ! 154: ioctl (0, TIOCLSET, &lmode_inferior); ! 155: #endif /* TIOCGLTC */ ! 156: ! 157: #ifdef TIOCGPGRP ! 158: ioctl (0, TIOCSPGRP, &pgrp_inferior); ! 159: #else ! 160: sigint_ours = (signal (SIGINT, SIG_IGN)); ! 161: sigquit_ours = (signal (SIGQUIT, SIG_IGN)); ! 162: #endif /* TIOCGPGRP */ ! 163: } ! 164: terminal_is_ours = 0; ! 165: } ! 166: ! 167: /* Put some of our terminal settings into effect, ! 168: enough to get proper results from our output, ! 169: but do not change into or out of RAW mode ! 170: so that no input is discarded. ! 171: ! 172: After doing this, either terminal_ours or terminal_inferior ! 173: should be called to get back to a normal state of affairs. */ ! 174: ! 175: void ! 176: terminal_ours_for_output () ! 177: { ! 178: if (remote_debugging) ! 179: return; ! 180: ! 181: terminal_ours_1 (1); ! 182: } ! 183: ! 184: /* Put our terminal settings into effect. ! 185: First record the inferior's terminal settings ! 186: so they can be restored properly later. */ ! 187: ! 188: void ! 189: terminal_ours () ! 190: { ! 191: if (remote_debugging) ! 192: return; ! 193: ! 194: terminal_ours_1 (0); ! 195: } ! 196: ! 197: static void ! 198: terminal_ours_1 (output_only) ! 199: int output_only; ! 200: { ! 201: #ifdef TIOCGPGRP ! 202: /* Ignore this signal since it will happen when we try to set the pgrp. */ ! 203: int (*osigttou) (); ! 204: #endif /* TIOCGPGRP */ ! 205: ! 206: if (!terminal_is_ours) /* && inferior_thisrun_terminal == 0) */ ! 207: { ! 208: terminal_is_ours = 1; ! 209: ! 210: #ifdef TIOCGPGRP ! 211: osigttou = signal (SIGTTOU, SIG_IGN); ! 212: ! 213: ioctl (0, TIOCGPGRP, &pgrp_inferior); ! 214: ioctl (0, TIOCSPGRP, &pgrp_ours); ! 215: ! 216: signal (SIGTTOU, osigttou); ! 217: #else ! 218: signal (SIGINT, sigint_ours); ! 219: signal (SIGQUIT, sigquit_ours); ! 220: #endif /* TIOCGPGRP */ ! 221: ! 222: tflags_inferior = fcntl (0, F_GETFL, 0); ! 223: ioctl (0, TIOCGETP, &sg_inferior); ! 224: ! 225: #ifdef TIOCGLTC ! 226: ioctl (0, TIOCGETC, &tc_inferior); ! 227: ioctl (0, TIOCGLTC, <c_inferior); ! 228: ioctl (0, TIOCLGET, &lmode_inferior); ! 229: #endif /* TIOCGLTC */ ! 230: } ! 231: ! 232: #ifdef HAVE_TERMIO ! 233: sg_ours.c_lflag |= ICANON; ! 234: if (output_only && !(sg_inferior.c_lflag & ICANON)) ! 235: sg_ours.c_lflag &= ~ICANON; ! 236: #else /* not HAVE_TERMIO */ ! 237: sg_ours.sg_flags &= ~RAW & ~CBREAK; ! 238: if (output_only) ! 239: sg_ours.sg_flags |= (RAW | CBREAK) & sg_inferior.sg_flags; ! 240: #endif /* not HAVE_TERMIO */ ! 241: ! 242: fcntl (0, F_SETFL, tflags_ours); ! 243: fcntl (0, F_SETFL, tflags_ours); ! 244: ioctl (0, TIOCSETN, &sg_ours); ! 245: ! 246: #ifdef TIOCGLTC ! 247: ioctl (0, TIOCSETC, &tc_ours); ! 248: ioctl (0, TIOCSLTC, <c_ours); ! 249: ioctl (0, TIOCLSET, &lmode_ours); ! 250: #endif /* TIOCGLTC */ ! 251: ! 252: ! 253: #ifdef HAVE_TERMIO ! 254: sg_ours.c_lflag |= ICANON; ! 255: #else /* not HAVE_TERMIO */ ! 256: sg_ours.sg_flags &= ~RAW & ~CBREAK; ! 257: #endif /* not HAVE_TERMIO */ ! 258: } ! 259: ! 260: static void ! 261: term_status_command () ! 262: { ! 263: register int i; ! 264: ! 265: if (remote_debugging) ! 266: { ! 267: printf ("No terminal status when remote debugging.\n"); ! 268: return; ! 269: } ! 270: ! 271: printf ("Inferior's terminal status (currently saved by GDB):\n"); ! 272: ! 273: #ifdef HAVE_TERMIO ! 274: ! 275: printf ("fcntl flags = 0x%x, c_iflag = 0x%x, c_oflag = 0x%x,\n", ! 276: tflags_inferior, sg_inferior.c_iflag, sg_inferior.c_oflag); ! 277: printf ("c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n", ! 278: sg_inferior.c_cflag, sg_inferior.c_lflag, sg_inferior.c_line); ! 279: printf ("c_cc: "); ! 280: for (i = 0; (i < NCC); i += 1) ! 281: printf ("0x%x ", sg_inferior.c_cc[i]); ! 282: printf ("\n"); ! 283: ! 284: #else /* not HAVE_TERMIO */ ! 285: ! 286: printf ("fcntl flags = 0x%x, lmode = 0x%x,\nsgttyb.sg_flags = 0x%x, owner pid = %d.\n", ! 287: tflags_inferior, lmode_inferior, ! 288: sg_inferior.sg_flags, pgrp_inferior); ! 289: printf ("tchars: "); ! 290: for (i = 0; i < sizeof (struct tchars); i++) ! 291: printf ("0x%x ", ((char *)&tc_inferior)[i]); ! 292: printf ("\n"); ! 293: printf ("ltchars: "); ! 294: for (i = 0; i < sizeof (struct ltchars); i++) ! 295: printf ("0x%x ", ((char *)<c_inferior)[i]); ! 296: ! 297: #endif /* not HAVE_TERMIO */ ! 298: } ! 299: ! 300: static void ! 301: new_tty (ttyname) ! 302: char *ttyname; ! 303: { ! 304: register int tty; ! 305: register int fd; ! 306: ! 307: #if 0 ! 308: /* I think it is better not to do this. Then C-z on the GDB terminal ! 309: will still stop the program, while C-z on the data terminal ! 310: will be input. */ ! 311: ! 312: /* Disconnect the child process from our controlling terminal. */ ! 313: tty = open("/dev/tty", O_RDWR); ! 314: if (tty > 0) ! 315: { ! 316: ioctl(tty, TIOCNOTTY, 0); ! 317: close(tty); ! 318: } ! 319: #endif ! 320: /* Now open the specified new terminal. */ ! 321: ! 322: tty = open(ttyname, O_RDWR); ! 323: if (tty == -1) ! 324: _exit(1); ! 325: ! 326: dup2(tty, 0); ! 327: dup2(tty, 1); ! 328: dup2(tty, 2); ! 329: close(tty); ! 330: } ! 331: ! 332: /* Start an inferior process and returns its pid. ! 333: ALLARGS is a string containing shell command to run the program. ! 334: ENV is the environment vector to pass. */ ! 335: ! 336: #ifndef SHELL_FILE ! 337: #define SHELL_FILE "/bin/sh" ! 338: #endif ! 339: ! 340: int ! 341: create_inferior (allargs, env) ! 342: char *allargs; ! 343: char **env; ! 344: { ! 345: int pid; ! 346: char *shell_command; ! 347: extern int sys_nerr; ! 348: extern char *sys_errlist[]; ! 349: extern int errno; ! 350: ! 351: /* If desired, concat something onto the front of ALLARGS. ! 352: SHELL_COMMAND is the result. */ ! 353: #ifdef SHELL_COMMAND_CONCAT ! 354: shell_command = (char *) alloca (strlen (SHELL_COMMAND_CONCAT) + strlen (allargs) + 1); ! 355: strcpy (shell_command, SHELL_COMMAND_CONCAT); ! 356: strcat (shell_command, allargs); ! 357: #else ! 358: shell_command = allargs; ! 359: #endif ! 360: ! 361: /* exec is said to fail if the executable is open. */ ! 362: close_exec_file (); ! 363: ! 364: pid = vfork (); ! 365: if (pid < 0) ! 366: perror_with_name ("vfork"); ! 367: ! 368: if (pid == 0) ! 369: { ! 370: char *args[4]; ! 371: ! 372: #ifdef TIOCGPGRP ! 373: /* Run inferior in a separate process group. */ ! 374: setpgrp (getpid (), getpid ()); ! 375: #endif /* TIOCGPGRP */ ! 376: ! 377: inferior_thisrun_terminal = inferior_io_terminal; ! 378: if (inferior_io_terminal != 0) ! 379: new_tty (inferior_io_terminal); ! 380: ! 381: /* Not needed on Sun, at least, and loses there ! 382: because it clobbers the superior. */ ! 383: /*??? signal (SIGQUIT, SIG_DFL); ! 384: signal (SIGINT, SIG_DFL); */ ! 385: ! 386: ptrace (0); ! 387: ! 388: args[0] = "sh"; ! 389: args[1] = "-c"; ! 390: args[2] = shell_command; ! 391: args[3] = 0; ! 392: ! 393: execve (SHELL_FILE, args, env); ! 394: ! 395: fprintf (stderr, "Cannot exec %s: %s.\n", SHELL_FILE, ! 396: errno < sys_nerr ? sys_errlist[errno] : "unknown error"); ! 397: fflush (stderr); ! 398: _exit (0177); ! 399: } ! 400: return pid; ! 401: } ! 402: ! 403: /* Kill the inferior process. Make us have no inferior. */ ! 404: ! 405: static void ! 406: kill_command () ! 407: { ! 408: if (remote_debugging) ! 409: return; ! 410: if (inferior_pid == 0) ! 411: error ("The program is not being run."); ! 412: if (!query ("Kill the inferior process? ")) ! 413: error ("Not confirmed."); ! 414: kill_inferior (); ! 415: } ! 416: ! 417: kill_inferior () ! 418: { ! 419: if (remote_debugging) ! 420: return; ! 421: if (inferior_pid == 0) ! 422: return; ! 423: ptrace (8, inferior_pid, 0, 0); ! 424: wait (0); ! 425: inferior_died (); ! 426: } ! 427: ! 428: /* This is used when GDB is exiting. It gives less chance of error.*/ ! 429: ! 430: kill_inferior_fast () ! 431: { ! 432: if (remote_debugging) ! 433: return; ! 434: if (inferior_pid == 0) ! 435: return; ! 436: ptrace (8, inferior_pid, 0, 0); ! 437: wait (0); ! 438: } ! 439: ! 440: inferior_died () ! 441: { ! 442: inferior_pid = 0; ! 443: attach_flag = 0; ! 444: mark_breakpoints_out (); ! 445: reopen_exec_file (); ! 446: if (have_core_file_p ()) ! 447: set_current_frame (read_register (FP_REGNUM)); ! 448: } ! 449: ! 450: /* Resume execution of the inferior process. ! 451: If STEP is nonzero, single-step it. ! 452: If SIGNAL is nonzero, give it that signal. */ ! 453: ! 454: void ! 455: resume (step, signal) ! 456: int step; ! 457: int signal; ! 458: { ! 459: errno = 0; ! 460: if (remote_debugging) ! 461: remote_resume (step, signal); ! 462: else ! 463: { ! 464: ptrace (step ? 9 : 7, inferior_pid, 1, signal); ! 465: if (errno) ! 466: perror_with_name ("ptrace"); ! 467: } ! 468: } ! 469: ! 470: #ifdef ATTACH_DETACH ! 471: ! 472: /* Start debugging the process whose number is PID. */ ! 473: ! 474: attach (pid) ! 475: int pid; ! 476: { ! 477: errno = 0; ! 478: ptrace (PTRACE_ATTACH, pid, 0, 0); ! 479: if (errno) ! 480: perror_with_name ("ptrace"); ! 481: attach_flag = 1; ! 482: return pid; ! 483: } ! 484: ! 485: /* Stop debugging the process whose number is PID ! 486: and continue it with signal number SIGNAL. ! 487: SIGNAL = 0 means just continue it. */ ! 488: ! 489: void ! 490: detach (signal) ! 491: int signal; ! 492: { ! 493: errno = 0; ! 494: ptrace (PTRACE_DETACH, inferior_pid, 1, signal); ! 495: if (errno) ! 496: perror_with_name ("ptrace"); ! 497: attach_flag = 0; ! 498: } ! 499: #endif /* ATTACH_DETACH */ ! 500: ! 501: #ifdef NEW_SUN_PTRACE ! 502: ! 503: void ! 504: fetch_inferior_registers () ! 505: { ! 506: struct regs inferior_registers; ! 507: struct fp_status inferior_fp_registers; ! 508: extern char registers[]; ! 509: ! 510: if (remote_debugging) ! 511: remote_fetch_registers (registers); ! 512: else ! 513: { ! 514: ptrace (PTRACE_GETREGS, inferior_pid, &inferior_registers); ! 515: ptrace (PTRACE_GETFPREGS, inferior_pid, &inferior_fp_registers); ! 516: ! 517: bcopy (&inferior_registers, registers, 16 * 4); ! 518: bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)], ! 519: sizeof inferior_fp_registers.fps_regs); ! 520: *(int *)®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps; ! 521: *(int *)®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc; ! 522: bcopy (&inferior_fp_registers.fps_control, ! 523: ®isters[REGISTER_BYTE (FPC_REGNUM)], ! 524: sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs); ! 525: } ! 526: } ! 527: ! 528: /* Store our register values back into the inferior. ! 529: If REGNO is -1, do this for all registers. ! 530: Otherwise, REGNO specifies which register (so we can save time). */ ! 531: ! 532: store_inferior_registers (regno) ! 533: int regno; ! 534: { ! 535: struct regs inferior_registers; ! 536: struct fp_status inferior_fp_registers; ! 537: extern char registers[]; ! 538: ! 539: if (remote_debugging) ! 540: remote_store_registers (registers); ! 541: else ! 542: { ! 543: bcopy (registers, &inferior_registers, 16 * 4); ! 544: bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers, ! 545: sizeof inferior_fp_registers.fps_regs); ! 546: inferior_registers.r_ps = *(int *)®isters[REGISTER_BYTE (PS_REGNUM)]; ! 547: inferior_registers.r_pc = *(int *)®isters[REGISTER_BYTE (PC_REGNUM)]; ! 548: bcopy (®isters[REGISTER_BYTE (FPC_REGNUM)], ! 549: &inferior_fp_registers.fps_control, ! 550: sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs); ! 551: ! 552: ptrace (PTRACE_SETREGS, inferior_pid, &inferior_registers); ! 553: ptrace (PTRACE_SETFPREGS, inferior_pid, &inferior_fp_registers); ! 554: } ! 555: } ! 556: ! 557: #else ! 558: #ifdef HP9K320 ! 559: ! 560: #define FP_REGISTER_ADDR_DIFF(u, regno) \ ! 561: (((char *) (FP_REGISTER_ADDR (u, regno))) - ((char *) &(u))) ! 562: ! 563: #define INFERIOR_AR0(u) \ ! 564: ((ptrace \ ! 565: (PT_RUAREA, inferior_pid, ((char *) &u.u_ar0 - (char *) &u), 0)) \ ! 566: - KERNEL_U_ADDR) ! 567: ! 568: static void ! 569: fetch_inferior_register (regno, regaddr) ! 570: register int regno; ! 571: register unsigned int regaddr; ! 572: { ! 573: #ifndef HPUX_VERSION_5 ! 574: if (regno == PS_REGNUM) ! 575: { ! 576: union { int i; short s[2]; } ps_val; ! 577: int regval; ! 578: ! 579: ps_val.i = (ptrace (PT_RUAREA, inferior_pid, regaddr, 0)); ! 580: regval = ps_val.s[0]; ! 581: supply_register (regno, ®val); ! 582: } ! 583: else ! 584: #endif /* not HPUX_VERSION_5 */ ! 585: { ! 586: char buf[MAX_REGISTER_RAW_SIZE]; ! 587: register int i; ! 588: ! 589: for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int)) ! 590: { ! 591: *(int *) &buf[i] = ptrace (PT_RUAREA, inferior_pid, regaddr, 0); ! 592: regaddr += sizeof (int); ! 593: } ! 594: supply_register (regno, buf); ! 595: } ! 596: return; ! 597: } ! 598: ! 599: static void ! 600: store_inferior_register_1 (regno, regaddr, value) ! 601: int regno; ! 602: unsigned int regaddr; ! 603: int value; ! 604: { ! 605: errno = 0; ! 606: ptrace (PT_WUAREA, inferior_pid, regaddr, value); ! 607: #if 0 ! 608: /* HP-UX randomly sets errno to non-zero for regno == 25. ! 609: However, the value is correctly written, so ignore errno. */ ! 610: if (errno != 0) ! 611: { ! 612: char string_buf[64]; ! 613: ! 614: sprintf (string_buf, "writing register number %d", regno); ! 615: perror_with_name (string_buf); ! 616: } ! 617: #endif ! 618: return; ! 619: } ! 620: ! 621: static void ! 622: store_inferior_register (regno, regaddr) ! 623: register int regno; ! 624: register unsigned int regaddr; ! 625: { ! 626: #ifndef HPUX_VERSION_5 ! 627: if (regno == PS_REGNUM) ! 628: { ! 629: union { int i; short s[2]; } ps_val; ! 630: ! 631: ps_val.i = (ptrace (PT_RUAREA, inferior_pid, regaddr, 0)); ! 632: ps_val.s[0] = (read_register (regno)); ! 633: store_inferior_register_1 (regno, regaddr, ps_val.i); ! 634: } ! 635: else ! 636: #endif /* not HPUX_VERSION_5 */ ! 637: { ! 638: char buf[MAX_REGISTER_RAW_SIZE]; ! 639: register int i; ! 640: extern char registers[]; ! 641: ! 642: for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int)) ! 643: { ! 644: store_inferior_register_1 ! 645: (regno, regaddr, ! 646: (*(int *) ®isters[(REGISTER_BYTE (regno)) + i])); ! 647: regaddr += sizeof (int); ! 648: } ! 649: } ! 650: return; ! 651: } ! 652: ! 653: void ! 654: fetch_inferior_registers () ! 655: { ! 656: struct user u; ! 657: register int regno; ! 658: register unsigned int ar0_offset; ! 659: ! 660: ar0_offset = (INFERIOR_AR0 (u)); ! 661: for (regno = 0; (regno < FP0_REGNUM); regno++) ! 662: fetch_inferior_register (regno, (REGISTER_ADDR (ar0_offset, regno))); ! 663: for (; (regno < NUM_REGS); regno++) ! 664: fetch_inferior_register (regno, (FP_REGISTER_ADDR_DIFF (u, regno))); ! 665: } ! 666: ! 667: /* Store our register values back into the inferior. ! 668: If REGNO is -1, do this for all registers. ! 669: Otherwise, REGNO specifies which register (so we can save time). */ ! 670: ! 671: store_inferior_registers (regno) ! 672: register int regno; ! 673: { ! 674: struct user u; ! 675: register unsigned int ar0_offset; ! 676: ! 677: if (regno >= FP0_REGNUM) ! 678: { ! 679: store_inferior_register (regno, (FP_REGISTER_ADDR_DIFF (u, regno))); ! 680: return; ! 681: } ! 682: ! 683: ar0_offset = (INFERIOR_AR0 (u)); ! 684: if (regno >= 0) ! 685: { ! 686: store_inferior_register (regno, (REGISTER_ADDR (ar0_offset, regno))); ! 687: return; ! 688: } ! 689: ! 690: for (regno = 0; (regno < FP0_REGNUM); regno++) ! 691: store_inferior_register (regno, (REGISTER_ADDR (ar0_offset, regno))); ! 692: for (; (regno < NUM_REGS); regno++) ! 693: store_inferior_register (regno, (FP_REGISTER_ADDR_DIFF (u, regno))); ! 694: return; ! 695: } ! 696: ! 697: #else /* not HP9K320 */ ! 698: ! 699: void ! 700: fetch_inferior_registers () ! 701: { ! 702: register int regno; ! 703: register unsigned int regaddr; ! 704: char buf[MAX_REGISTER_RAW_SIZE]; ! 705: register int i; ! 706: ! 707: #ifdef UMAX_PTRACE ! 708: unsigned int offset = 0; ! 709: #else ! 710: struct user u; ! 711: unsigned int offset = (char *) &u.u_ar0 - (char *) &u; ! 712: offset = ptrace (3, inferior_pid, offset, 0) - KERNEL_U_ADDR; ! 713: #endif ! 714: ! 715: for (regno = 0; regno < NUM_REGS; regno++) ! 716: { ! 717: regaddr = register_addr (regno, offset); ! 718: for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int)) ! 719: { ! 720: *(int *) &buf[i] = ptrace (3, inferior_pid, regaddr, 0); ! 721: regaddr += sizeof (int); ! 722: } ! 723: supply_register (regno, buf); ! 724: } ! 725: } ! 726: ! 727: /* Store our register values back into the inferior. ! 728: If REGNO is -1, do this for all registers. ! 729: Otherwise, REGNO specifies which register (so we can save time). */ ! 730: ! 731: store_inferior_registers (regno) ! 732: int regno; ! 733: { ! 734: register unsigned int regaddr; ! 735: char buf[80]; ! 736: extern char registers[]; ! 737: int i; ! 738: ! 739: #ifdef UMAX_PTRACE ! 740: unsigned int offset = 0; ! 741: #else ! 742: struct user u; ! 743: unsigned int offset = (char *) &u.u_ar0 - (char *) &u; ! 744: offset = ptrace (3, inferior_pid, offset, 0) - KERNEL_U_ADDR; ! 745: #endif ! 746: ! 747: if (regno >= 0) ! 748: { ! 749: regaddr = register_addr (regno, offset); ! 750: for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(int)) ! 751: { ! 752: errno = 0; ! 753: ptrace (6, inferior_pid, regaddr, ! 754: *(int *) ®isters[REGISTER_BYTE (regno) + i]); ! 755: if (errno != 0) ! 756: { ! 757: sprintf (buf, "writing register number %d(%d)", regno, i); ! 758: perror_with_name (buf); ! 759: } ! 760: regaddr += sizeof(int); ! 761: } ! 762: } ! 763: else for (regno = 0; regno < NUM_REGS; regno++) ! 764: { ! 765: regaddr = register_addr (regno, offset); ! 766: for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(int)) ! 767: { ! 768: errno = 0; ! 769: ptrace (6, inferior_pid, regaddr, ! 770: *(int *) ®isters[REGISTER_BYTE (regno) + i]); ! 771: if (errno != 0) ! 772: { ! 773: sprintf (buf, "writing register number %d(%d)", regno, i); ! 774: perror_with_name (buf); ! 775: } ! 776: regaddr += sizeof(int); ! 777: } ! 778: } ! 779: } ! 780: ! 781: #endif /* not HP9K320 */ ! 782: #endif /* not NEW_SUN_PTRACE */ ! 783: ! 784: /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory ! 785: in the NEW_SUN_PTRACE case. ! 786: It ought to be straightforward. But it appears that writing did ! 787: not write the data that I specified. I cannot understand where ! 788: it got the data that it actually did write. */ ! 789: ! 790: /* Copy LEN bytes from inferior's memory starting at MEMADDR ! 791: to debugger memory starting at MYADDR. */ ! 792: ! 793: read_inferior_memory (memaddr, myaddr, len) ! 794: CORE_ADDR memaddr; ! 795: char *myaddr; ! 796: int len; ! 797: { ! 798: register int i; ! 799: /* Round starting address down to longword boundary. */ ! 800: register CORE_ADDR addr = memaddr & - sizeof (int); ! 801: /* Round ending address up; get number of longwords that makes. */ ! 802: register int count ! 803: = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int); ! 804: /* Allocate buffer of that many longwords. */ ! 805: register int *buffer = (int *) alloca (count * sizeof (int)); ! 806: ! 807: /* Read all the longwords */ ! 808: for (i = 0; i < count; i++, addr += sizeof (int)) ! 809: { ! 810: if (remote_debugging) ! 811: buffer[i] = remote_fetch_word (addr); ! 812: else ! 813: buffer[i] = ptrace (1, inferior_pid, addr, 0); ! 814: } ! 815: ! 816: /* Copy appropriate bytes out of the buffer. */ ! 817: bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len); ! 818: } ! 819: ! 820: /* Copy LEN bytes of data from debugger memory at MYADDR ! 821: to inferior's memory at MEMADDR. ! 822: On failure (cannot write the inferior) ! 823: returns the value of errno. */ ! 824: ! 825: int ! 826: write_inferior_memory (memaddr, myaddr, len) ! 827: CORE_ADDR memaddr; ! 828: char *myaddr; ! 829: int len; ! 830: { ! 831: register int i; ! 832: /* Round starting address down to longword boundary. */ ! 833: register CORE_ADDR addr = memaddr & - sizeof (int); ! 834: /* Round ending address up; get number of longwords that makes. */ ! 835: register int count ! 836: = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int); ! 837: /* Allocate buffer of that many longwords. */ ! 838: register int *buffer = (int *) alloca (count * sizeof (int)); ! 839: extern int errno; ! 840: ! 841: /* Fill start and end extra bytes of buffer with existing memory data. */ ! 842: ! 843: if (remote_debugging) ! 844: buffer[0] = remote_fetch_word (addr); ! 845: else ! 846: buffer[0] = ptrace (1, inferior_pid, addr, 0); ! 847: ! 848: if (count > 1) ! 849: { ! 850: if (remote_debugging) ! 851: buffer[count - 1] ! 852: = remote_fetch_word (addr + (count - 1) * sizeof (int)); ! 853: else ! 854: buffer[count - 1] ! 855: = ptrace (1, inferior_pid, ! 856: addr + (count - 1) * sizeof (int), 0); ! 857: } ! 858: ! 859: /* Copy data to be written over corresponding part of buffer */ ! 860: ! 861: bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len); ! 862: ! 863: /* Write the entire buffer. */ ! 864: ! 865: for (i = 0; i < count; i++, addr += sizeof (int)) ! 866: { ! 867: errno = 0; ! 868: if (remote_debugging) ! 869: remote_store_word (addr, buffer[i]); ! 870: else ! 871: ptrace (4, inferior_pid, addr, buffer[i]); ! 872: if (errno) ! 873: return errno; ! 874: } ! 875: ! 876: return 0; ! 877: } ! 878: ! 879: static void ! 880: try_writing_regs_command () ! 881: { ! 882: register int i; ! 883: register int value; ! 884: extern int errno; ! 885: ! 886: if (inferior_pid == 0) ! 887: error ("There is no inferior process now."); ! 888: ! 889: for (i = 0; ; i += 2) ! 890: { ! 891: QUIT; ! 892: errno = 0; ! 893: value = ptrace (3, inferior_pid, i, 0); ! 894: ptrace (6, inferior_pid, i, value); ! 895: if (errno == 0) ! 896: { ! 897: printf (" Succeeded with address 0x%x; value 0x%x (%d).\n", ! 898: i, value, value); ! 899: } ! 900: else if ((i & 0377) == 0) ! 901: printf (" Failed at 0x%x.\n", i); ! 902: } ! 903: } ! 904: ! 905: static ! 906: initialize () ! 907: { ! 908: add_com ("term-status", class_obscure, term_status_command, ! 909: "Print info on inferior's saved terminal status."); ! 910: ! 911: add_com ("try-writing-regs", class_obscure, try_writing_regs_command, ! 912: "Try writing all locations in inferior's system block.\n\ ! 913: Report which ones can be written."); ! 914: ! 915: add_com ("kill", class_run, kill_command, ! 916: "Kill execution of program being debugged."); ! 917: ! 918: inferior_pid = 0; ! 919: ! 920: ioctl (0, TIOCGETP, &sg_ours); ! 921: fcntl (0, F_GETFL, tflags_ours); ! 922: ! 923: #ifdef TIOCGLTC ! 924: ioctl (0, TIOCGETC, &tc_ours); ! 925: ioctl (0, TIOCGLTC, <c_ours); ! 926: ioctl (0, TIOCLGET, &lmode_ours); ! 927: #endif /* TIOCGLTC */ ! 928: ! 929: #ifdef TIOCGPGRP ! 930: ioctl (0, TIOCGPGRP, &pgrp_ours); ! 931: #endif /* TIOCGPGRP */ ! 932: ! 933: terminal_is_ours = 1; ! 934: } ! 935: ! 936: END_FILE
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.