gdb/inf-ptrace.c

   1 /* Low level Unix child interface to ptrace, for GDB when running under Unix.
   2
   3    Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   4    1998, 1999, 2000, 2001, 2002, 2004 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "observer.h"
  25 #include "gdb_ptrace.h"
  26 #include "inflow.h"
  27 #include "inferior.h"
  28 #include "regcache.h"
  29 #include "command.h"
  30 #include "gdbcore.h"
  31 #include "inf-child.h"
  32 #include "gdbcmd.h"
  33 #include "gdb_string.h"
  34
  35 #include <sys/wait.h>
  36 #include <signal.h>
  37
  38 /* HACK: Save the ptrace ops returned by ptrace_target.  */
  39 static struct target_ops *ptrace_ops_hack;
  40
  41 static void
  42 inf_ptrace_kill_inferior (void)
  43 {
  44   int status;
  45   int pid = PIDGET (inferior_ptid);
  46
  47   if (pid == 0)
  48     return;
  49
  50   /* This once used to call "kill" to kill the inferior just in case
  51      the inferior was still running.  As others have noted in the past
  52      (kingdon) there shouldn't be any way to get here if the inferior
  53      is still running -- else there's a major problem elsewere in gdb
  54      and it needs to be fixed.
  55
  56      The kill call causes problems under hpux10, so it's been removed;
  57      if this causes problems we'll deal with them as they arise.  */
  58   ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3) 0, 0);
  59   wait (&status);
  60   target_mourn_inferior ();
  61 }
  62
  63 /* Resume execution of the inferior process.  If STEP is nonzero,
  64    single-step it.  If SIGNAL is nonzero, give it that signal.  */
  65
  66 static void
  67 inf_ptrace_resume (ptid_t ptid, int step, enum target_signal signal)
  68 {
  69   int request = PT_CONTINUE;
  70   int pid = PIDGET (ptid);
  71
  72   if (pid == -1)
  73     /* Resume all threads.  */
  74     /* I think this only gets used in the non-threaded case, where
  75        "resume all threads" and "resume inferior_ptid" are the
  76        same.  */
  77     pid = PIDGET (inferior_ptid);
  78
  79   if (step)
  80     {
  81       /* If this system does not support PT_STEP, a higher level
  82          function will have called single_step() to transmute the step
  83          request into a continue request (by setting breakpoints on
  84          all possible successor instructions), so we don't have to
  85          worry about that here.  */
  86       request = PT_STEP;
  87     }
  88
  89   /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
  90      where it was.  If GDB wanted it to start some other way, we have
  91      already written a new PC value to the child.  */
  92   errno = 0;
  93   ptrace (request, pid, (PTRACE_TYPE_ARG3) 1, target_signal_to_host (signal));
  94   if (errno != 0)
  95     perror_with_name ("ptrace");
  96 }
  97
  98 /* Set an upper limit on alloca.  */
  99 #define GDB_MAX_ALLOCA 0x1000
 100
 101 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
 102    in the NEW_SUN_PTRACE case.  It ought to be straightforward.  But
 103    it appears that writing did not write the data that I specified.  I
 104    cannot understand where it got the data that it actually did
 105    write.  */
 106
 107 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR to
 108    debugger memory starting at MYADDR.  Copy to inferior if WRITE is
 109    nonzero.  TARGET is ignored.
 110
 111    Returns the length copied, which is either the LEN argument or
 112    zero.  This xfer function does not do partial moves, since
 113    ptrace_ops_hack doesn't allow memory operations to cross below us in the
 114    target stack anyway.  */
 115
 116 int
 117 inf_ptrace_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 118                         struct mem_attrib *attrib, struct target_ops *target)
 119 {
 120   int i;
 121   /* Round starting address down to longword boundary.  */
 122   CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
 123   /* Round ending address up; get number of longwords that makes.  */
 124   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
 125                / sizeof (PTRACE_TYPE_RET));
 126   int alloc = count * sizeof (PTRACE_TYPE_RET);
 127   PTRACE_TYPE_RET *buffer;
 128   struct cleanup *old_chain = NULL;
 129
 130 #ifdef PT_IO
 131   /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO request
 132      that promises to be much more efficient in reading and writing
 133      data in the traced process's address space.  */
 134
 135   {
 136     struct ptrace_io_desc piod;
 137
 138     /* NOTE: We assume that there are no distinct address spaces for
 139        instruction and data.  */
 140     piod.piod_op = write ? PIOD_WRITE_D : PIOD_READ_D;
 141     piod.piod_offs = (void *) memaddr;
 142     piod.piod_addr = myaddr;
 143     piod.piod_len = len;
 144
 145     if (ptrace (PT_IO, PIDGET (inferior_ptid), (caddr_t) & piod, 0) == -1)
 146       {
 147         /* If the PT_IO request is somehow not supported, fallback on
 148            using PT_WRITE_D/PT_READ_D.  Otherwise we will return zero
 149            to indicate failure.  */
 150         if (errno != EINVAL)
 151           return 0;
 152       }
 153     else
 154       {
 155         /* Return the actual number of bytes read or written.  */
 156         return piod.piod_len;
 157       }
 158   }
 159 #endif
 160
 161   /* Allocate buffer of that many longwords.  */
 162   if (len < GDB_MAX_ALLOCA)
 163     {
 164       buffer = (PTRACE_TYPE_RET *) alloca (alloc);
 165     }
 166   else
 167     {
 168       buffer = (PTRACE_TYPE_RET *) xmalloc (alloc);
 169       old_chain = make_cleanup (xfree, buffer);
 170     }
 171
 172   if (write)
 173     {
 174       /* Fill start and end extra bytes of buffer with existing memory
 175          data.  */
 176       if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
 177         {
 178           /* Need part of initial word -- fetch it.  */
 179           buffer[0] = ptrace (PT_READ_I, PIDGET (inferior_ptid),
 180                               (PTRACE_TYPE_ARG3) addr, 0);
 181         }
 182
 183       if (count > 1)            /* FIXME, avoid if even boundary.  */
 184         {
 185           buffer[count - 1] =
 186             ptrace (PT_READ_I, PIDGET (inferior_ptid),
 187                     ((PTRACE_TYPE_ARG3)
 188                      (addr + (count - 1) * sizeof (PTRACE_TYPE_RET))), 0);
 189         }
 190
 191       /* Copy data to be written over corresponding part of buffer.  */
 192       memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 193               myaddr, len);
 194
 195       /* Write the entire buffer.  */
 196       for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 197         {
 198           errno = 0;
 199           ptrace (PT_WRITE_D, PIDGET (inferior_ptid),
 200                   (PTRACE_TYPE_ARG3) addr, buffer[i]);
 201           if (errno)
 202             {
 203               /* Using the appropriate one (I or D) is necessary for
 204                  Gould NP1, at least.  */
 205               errno = 0;
 206               ptrace (PT_WRITE_I, PIDGET (inferior_ptid),
 207                       (PTRACE_TYPE_ARG3) addr, buffer[i]);
 208             }
 209           if (errno)
 210             return 0;
 211         }
 212     }
 213   else
 214     {
 215       /* Read all the longwords.  */
 216       for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 217         {
 218           errno = 0;
 219           buffer[i] = ptrace (PT_READ_I, PIDGET (inferior_ptid),
 220                               (PTRACE_TYPE_ARG3) addr, 0);
 221           if (errno)
 222             return 0;
 223           QUIT;
 224         }
 225
 226       /* Copy appropriate bytes out of the buffer.  */
 227       memcpy (myaddr,
 228               (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 229               len);
 230     }
 231
 232   if (old_chain != NULL)
 233     do_cleanups (old_chain);
 234   return len;
 235 }
 236
 237 /* Wait for child to do something.  Return pid of child, or -1 in case
 238    of error; store status through argument pointer OURSTATUS.  */
 239
 240 static ptid_t
 241 inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 242 {
 243   int save_errno;
 244   int status;
 245   char *execd_pathname = NULL;
 246   int exit_status;
 247   int related_pid;
 248   int syscall_id;
 249   enum target_waitkind kind;
 250   int pid;
 251
 252   do
 253     {
 254       set_sigint_trap ();       /* Causes SIGINT to be passed on to the
 255                                    attached process. */
 256       set_sigio_trap ();
 257
 258       pid = wait (&status);
 259       target_post_wait (pid_to_ptid (pid), status);
 260
 261       save_errno = errno;
 262
 263       clear_sigio_trap ();
 264
 265       clear_sigint_trap ();
 266
 267       if (pid == -1)
 268         {
 269           if (save_errno == EINTR)
 270             continue;
 271
 272           fprintf_unfiltered (gdb_stderr,
 273                               "Child process unexpectedly missing: %s.\n",
 274                               safe_strerror (save_errno));
 275
 276           /* Claim it exited with unknown signal.  */
 277           ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 278           ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
 279           return pid_to_ptid (-1);
 280         }
 281
 282       /* Did it exit?
 283        */
 284       if (target_has_exited (pid, status, &exit_status))
 285         {
 286           /* ??rehrauer: For now, ignore this. */
 287           continue;
 288         }
 289
 290       if (!target_thread_alive (pid_to_ptid (pid)))
 291         {
 292           ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 293           return pid_to_ptid (pid);
 294         }
 295     }
 296   while (pid != PIDGET (inferior_ptid));        /* Some other child died or stopped */
 297
 298   store_waitstatus (ourstatus, status);
 299   return pid_to_ptid (pid);
 300 }
 301
 302 void
 303 inf_ptrace_post_wait (ptid_t ptid, int wait_status)
 304 {
 305   /* This version of Unix doesn't require a meaningful "post wait"
 306      operation.
 307    */
 308 }
 309
 310 /* Check to see if the given thread is alive.
 311
 312    FIXME: Is kill() ever the right way to do this?  I doubt it, but
 313    for now we're going to try and be compatable with the old thread
 314    code.  */
 315
 316 static int
 317 inf_ptrace_thread_alive (ptid_t ptid)
 318 {
 319   pid_t pid = PIDGET (ptid);
 320
 321   return (kill (pid, 0) != -1);
 322 }
 323
 324 /* Attach to process PID, then initialize for debugging it.  */
 325
 326 static void
 327 inf_ptrace_attach (char *args, int from_tty)
 328 {
 329   char *exec_file;
 330   int pid;
 331   char *dummy;
 332
 333   if (!args)
 334     error_no_arg ("process-id to attach");
 335
 336   dummy = args;
 337   pid = strtol (args, &dummy, 0);
 338   /* Some targets don't set errno on errors, grrr! */
 339   if ((pid == 0) && (args == dummy))
 340     error ("Illegal process-id: %s\n", args);
 341
 342   if (pid == getpid ())         /* Trying to masturbate? */
 343     error ("I refuse to debug myself!");
 344
 345   if (from_tty)
 346     {
 347       exec_file = (char *) get_exec_file (0);
 348
 349       if (exec_file)
 350         printf_unfiltered ("Attaching to program: %s, %s\n", exec_file,
 351                            target_pid_to_str (pid_to_ptid (pid)));
 352       else
 353         printf_unfiltered ("Attaching to %s\n",
 354                            target_pid_to_str (pid_to_ptid (pid)));
 355
 356       gdb_flush (gdb_stdout);
 357     }
 358
 359   attach (pid);
 360
 361   inferior_ptid = pid_to_ptid (pid);
 362   push_target (ptrace_ops_hack);
 363 }
 364
 365 static void
 366 inf_ptrace_post_attach (int pid)
 367 {
 368   /* This version of Unix doesn't require a meaningful "post attach"
 369      operation by a debugger.  */
 370 }
 371
 372 /* Take a program previously attached to and detaches it.  The program
 373    resumes execution and will no longer stop on signals, etc.  We'd
 374    better not have left any breakpoints in the program or it'll die
 375    when it hits one.  For this to work, it may be necessary for the
 376    process to have been previously attached.  It *might* work if the
 377    program was started via the normal ptrace (PTRACE_TRACEME).  */
 378
 379 static void
 380 inf_ptrace_detach (char *args, int from_tty)
 381 {
 382   int siggnal = 0;
 383   int pid = PIDGET (inferior_ptid);
 384
 385   if (from_tty)
 386     {
 387       char *exec_file = get_exec_file (0);
 388       if (exec_file == 0)
 389         exec_file = "";
 390       printf_unfiltered ("Detaching from program: %s, %s\n", exec_file,
 391                          target_pid_to_str (pid_to_ptid (pid)));
 392       gdb_flush (gdb_stdout);
 393     }
 394   if (args)
 395     siggnal = atoi (args);
 396
 397   detach (siggnal);
 398
 399   inferior_ptid = null_ptid;
 400   unpush_target (ptrace_ops_hack);
 401 }
 402
 403 /* Get ready to modify the registers array.  On machines which store
 404    individual registers, this doesn't need to do anything.  On
 405    machines which store all the registers in one fell swoop, this
 406    makes sure that registers contains all the registers from the
 407    program being debugged.  */
 408
 409 static void
 410 inf_ptrace_prepare_to_store (void)
 411 {
 412 }
 413
 414 /* Print status information about what we're accessing.  */
 415
 416 static void
 417 inf_ptrace_files_info (struct target_ops *ignore)
 418 {
 419   printf_unfiltered ("\tUsing the running image of %s %s.\n",
 420                      attach_flag ? "attached" : "child",
 421                      target_pid_to_str (inferior_ptid));
 422 }
 423
 424 static void
 425 inf_ptrace_open (char *arg, int from_tty)
 426 {
 427   error ("Use the \"run\" command to start a Unix child process.");
 428 }
 429
 430 /* Stub function which causes the inferior that runs it, to be ptrace-able
 431    by its parent process.  */
 432
 433 static void
 434 inf_ptrace_me (void)
 435 {
 436   /* "Trace me, Dr. Memory!" */
 437   ptrace (0, 0, (PTRACE_TYPE_ARG3) 0, 0);
 438 }
 439
 440 /* Stub function which causes the GDB that runs it, to start ptrace-ing
 441    the child process.  */
 442
 443 static void
 444 inf_ptrace_him (int pid)
 445 {
 446   push_target (ptrace_ops_hack);
 447
 448   /* On some targets, there must be some explicit synchronization
 449      between the parent and child processes after the debugger
 450      forks, and before the child execs the debuggee program.  This
 451      call basically gives permission for the child to exec.
 452    */
 453
 454   target_acknowledge_created_inferior (pid);
 455
 456   /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h,
 457    * and will be 1 or 2 depending on whether we're starting
 458    * without or with a shell.
 459    */
 460   startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
 461
 462   /* On some targets, there must be some explicit actions taken after
 463      the inferior has been started up.
 464    */
 465   target_post_startup_inferior (pid_to_ptid (pid));
 466 }
 467
 468 /* Start an inferior Unix child process and sets inferior_ptid to its
 469    pid.  EXEC_FILE is the file to run.  ALLARGS is a string containing
 470    the arguments to the program.  ENV is the environment vector to
 471    pass.  Errors reported with error().  */
 472
 473 static void
 474 inf_ptrace_create_inferior (char *exec_file, char *allargs, char **env,
 475                             int from_tty)
 476 {
 477   fork_inferior (exec_file, allargs, env, inf_ptrace_me, inf_ptrace_him,
 478                  NULL, NULL);
 479   /* We are at the first instruction we care about.  */
 480   observer_notify_inferior_created (&current_target, from_tty);
 481   /* Pedal to the metal... */
 482   proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
 483 }
 484
 485 static void
 486 inf_ptrace_post_startup_inferior (ptid_t ptid)
 487 {
 488   /* This version of Unix doesn't require a meaningful "post startup inferior"
 489      operation by a debugger.
 490    */
 491 }
 492
 493 static void
 494 inf_ptrace_acknowledge_created_inferior (int pid)
 495 {
 496   /* This version of Unix doesn't require a meaningful "acknowledge created inferior"
 497      operation by a debugger.
 498    */
 499 }
 500
 501 static int
 502 inf_ptrace_insert_fork_catchpoint (int pid)
 503 {
 504   /* This version of Unix doesn't support notification of fork events.  */
 505   return 0;
 506 }
 507
 508 static int
 509 inf_ptrace_remove_fork_catchpoint (int pid)
 510 {
 511   /* This version of Unix doesn't support notification of fork events.  */
 512   return 0;
 513 }
 514
 515 static int
 516 inf_ptrace_insert_vfork_catchpoint (int pid)
 517 {
 518   /* This version of Unix doesn't support notification of vfork events.  */
 519   return 0;
 520 }
 521
 522 static int
 523 inf_ptrace_remove_vfork_catchpoint (int pid)
 524 {
 525   /* This version of Unix doesn't support notification of vfork events.  */
 526   return 0;
 527 }
 528
 529 static int
 530 inf_ptrace_follow_fork (int follow_child)
 531 {
 532   /* This version of Unix doesn't support following fork or vfork events.  */
 533   return 0;
 534 }
 535
 536 static int
 537 inf_ptrace_insert_exec_catchpoint (int pid)
 538 {
 539   /* This version of Unix doesn't support notification of exec events.  */
 540   return 0;
 541 }
 542
 543 static int
 544 inf_ptrace_remove_exec_catchpoint (int pid)
 545 {
 546   /* This version of Unix doesn't support notification of exec events.  */
 547   return 0;
 548 }
 549
 550 static int
 551 inf_ptrace_reported_exec_events_per_exec_call (void)
 552 {
 553   /* This version of Unix doesn't support notification of exec events.
 554    */
 555   return 1;
 556 }
 557
 558 static int
 559 inf_ptrace_has_exited (int pid, int wait_status, int *exit_status)
 560 {
 561   if (WIFEXITED (wait_status))
 562     {
 563       *exit_status = WEXITSTATUS (wait_status);
 564       return 1;
 565     }
 566
 567   if (WIFSIGNALED (wait_status))
 568     {
 569       *exit_status = 0;         /* ?? Don't know what else to say here. */
 570       return 1;
 571     }
 572
 573   /* ?? Do we really need to consult the event state, too?  Assume the
 574      wait_state alone suffices.
 575    */
 576   return 0;
 577 }
 578
 579 static void
 580 inf_ptrace_mourn_inferior (void)
 581 {
 582   unpush_target (ptrace_ops_hack);
 583   generic_mourn_inferior ();
 584 }
 585
 586 static int
 587 inf_ptrace_can_run (void)
 588 {
 589   return 1;
 590 }
 591
 592 /* Send a SIGINT to the process group.  This acts just like the user
 593    typed a ^C on the controlling terminal.
 594
 595    XXX - This may not be correct for all systems.  Some may want to
 596    use killpg() instead of kill (-pgrp). */
 597
 598 static void
 599 inf_ptrace_stop (void)
 600 {
 601   kill (-inferior_process_group, SIGINT);
 602 }
 603
 604 /* Perform a partial transfer to/from the specified object.  For
 605    memory transfers, fall back to the old memory xfer functions.  */
 606
 607 static LONGEST
 608 inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
 609                          const char *annex, void *readbuf,
 610                          const void *writebuf, ULONGEST offset, LONGEST len)
 611 {
 612   switch (object)
 613     {
 614     case TARGET_OBJECT_MEMORY:
 615       if (readbuf)
 616         return inf_ptrace_xfer_memory (offset, readbuf, len, 0 /*write */ ,
 617                                        NULL, ops);
 618       if (writebuf)
 619         return inf_ptrace_xfer_memory (offset, readbuf, len, 1 /*write */ ,
 620                                        NULL, ops);
 621       return -1;
 622
 623     case TARGET_OBJECT_UNWIND_TABLE:
 624       return -1;
 625
 626     case TARGET_OBJECT_AUXV:
 627       return -1;
 628
 629     case TARGET_OBJECT_WCOOKIE:
 630       return -1;
 631
 632     default:
 633       return -1;
 634     }
 635 }
 636
 637 static char *
 638 inf_ptrace_pid_to_str (ptid_t ptid)
 639 {
 640   return normal_pid_to_str (ptid);
 641 }
 642
 643 struct target_ops *
 644 inf_ptrace_target (void)
 645 {
 646   struct target_ops *t = inf_child_target ();
 647   t->to_open = inf_ptrace_open;
 648   t->to_attach = inf_ptrace_attach;
 649   t->to_post_attach = inf_ptrace_post_attach;
 650   t->to_detach = inf_ptrace_detach;
 651   t->to_resume = inf_ptrace_resume;
 652   t->to_wait = inf_ptrace_wait;
 653   t->to_post_wait = inf_ptrace_post_wait;
 654   t->to_prepare_to_store = inf_ptrace_prepare_to_store;
 655   t->to_xfer_memory = inf_ptrace_xfer_memory;
 656   t->to_xfer_partial = inf_ptrace_xfer_partial;
 657   t->to_files_info = inf_ptrace_files_info;
 658   t->to_kill = inf_ptrace_kill_inferior;
 659   t->to_create_inferior = inf_ptrace_create_inferior;
 660   t->to_post_startup_inferior = inf_ptrace_post_startup_inferior;
 661   t->to_acknowledge_created_inferior =
 662     inf_ptrace_acknowledge_created_inferior;
 663   t->to_insert_fork_catchpoint = inf_ptrace_insert_fork_catchpoint;
 664   t->to_remove_fork_catchpoint = inf_ptrace_remove_fork_catchpoint;
 665   t->to_insert_vfork_catchpoint = inf_ptrace_insert_vfork_catchpoint;
 666   t->to_remove_vfork_catchpoint = inf_ptrace_remove_vfork_catchpoint;
 667   t->to_follow_fork = inf_ptrace_follow_fork;
 668   t->to_insert_exec_catchpoint = inf_ptrace_insert_exec_catchpoint;
 669   t->to_remove_exec_catchpoint = inf_ptrace_remove_exec_catchpoint;
 670   t->to_reported_exec_events_per_exec_call =
 671     inf_ptrace_reported_exec_events_per_exec_call;
 672   t->to_has_exited = inf_ptrace_has_exited;
 673   t->to_mourn_inferior = inf_ptrace_mourn_inferior;
 674   t->to_can_run = inf_ptrace_can_run;
 675   t->to_thread_alive = inf_ptrace_thread_alive;
 676   t->to_pid_to_str = inf_ptrace_pid_to_str;
 677   t->to_stop = inf_ptrace_stop;
 678   t->to_stratum = process_stratum;
 679   t->to_has_all_memory = 1;
 680   t->to_has_memory = 1;
 681   t->to_has_stack = 1;
 682   t->to_has_registers = 1;
 683   t->to_has_execution = 1;
 684   t->to_magic = OPS_MAGIC;
 685   ptrace_ops_hack = t;
 686   return t;
 687 }