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   call_ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3) 0, 0);
  59   ptrace_wait (null_ptid, &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 = ptrace_wait (inferior_ptid, &status);
 259
 260       save_errno = errno;
 261
 262       clear_sigio_trap ();
 263
 264       clear_sigint_trap ();
 265
 266       if (pid == -1)
 267         {
 268           if (save_errno == EINTR)
 269             continue;
 270
 271           fprintf_unfiltered (gdb_stderr,
 272                               "Child process unexpectedly missing: %s.\n",
 273                               safe_strerror (save_errno));
 274
 275           /* Claim it exited with unknown signal.  */
 276           ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 277           ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
 278           return pid_to_ptid (-1);
 279         }
 280
 281       /* Did it exit?
 282        */
 283       if (target_has_exited (pid, status, &exit_status))
 284         {
 285           /* ??rehrauer: For now, ignore this. */
 286           continue;
 287         }
 288
 289       if (!target_thread_alive (pid_to_ptid (pid)))
 290         {
 291           ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 292           return pid_to_ptid (pid);
 293         }
 294     }
 295   while (pid != PIDGET (inferior_ptid));        /* Some other child died or stopped */
 296
 297   store_waitstatus (ourstatus, status);
 298   return pid_to_ptid (pid);
 299 }
 300
 301 void
 302 inf_ptrace_post_wait (ptid_t ptid, int wait_status)
 303 {
 304   /* This version of Unix doesn't require a meaningful "post wait"
 305      operation.
 306    */
 307 }
 308
 309 /* Check to see if the given thread is alive.
 310
 311    FIXME: Is kill() ever the right way to do this?  I doubt it, but
 312    for now we're going to try and be compatable with the old thread
 313    code.  */
 314
 315 static int
 316 inf_ptrace_thread_alive (ptid_t ptid)
 317 {
 318   pid_t pid = PIDGET (ptid);
 319
 320   return (kill (pid, 0) != -1);
 321 }
 322
 323 /* Attach to process PID, then initialize for debugging it.  */
 324
 325 static void
 326 inf_ptrace_attach (char *args, int from_tty)
 327 {
 328   char *exec_file;
 329   int pid;
 330   char *dummy;
 331
 332   if (!args)
 333     error_no_arg ("process-id to attach");
 334
 335   dummy = args;
 336   pid = strtol (args, &dummy, 0);
 337   /* Some targets don't set errno on errors, grrr! */
 338   if ((pid == 0) && (args == dummy))
 339     error ("Illegal process-id: %s\n", args);
 340
 341   if (pid == getpid ())         /* Trying to masturbate? */
 342     error ("I refuse to debug myself!");
 343
 344   if (from_tty)
 345     {
 346       exec_file = (char *) get_exec_file (0);
 347
 348       if (exec_file)
 349         printf_unfiltered ("Attaching to program: %s, %s\n", exec_file,
 350                            target_pid_to_str (pid_to_ptid (pid)));
 351       else
 352         printf_unfiltered ("Attaching to %s\n",
 353                            target_pid_to_str (pid_to_ptid (pid)));
 354
 355       gdb_flush (gdb_stdout);
 356     }
 357
 358   attach (pid);
 359
 360   inferior_ptid = pid_to_ptid (pid);
 361   push_target (ptrace_ops_hack);
 362 }
 363
 364 static void
 365 inf_ptrace_post_attach (int pid)
 366 {
 367   /* This version of Unix doesn't require a meaningful "post attach"
 368      operation by a debugger.  */
 369 }
 370
 371 /* Take a program previously attached to and detaches it.  The program
 372    resumes execution and will no longer stop on signals, etc.  We'd
 373    better not have left any breakpoints in the program or it'll die
 374    when it hits one.  For this to work, it may be necessary for the
 375    process to have been previously attached.  It *might* work if the
 376    program was started via the normal ptrace (PTRACE_TRACEME).  */
 377
 378 static void
 379 inf_ptrace_detach (char *args, int from_tty)
 380 {
 381   int siggnal = 0;
 382   int pid = PIDGET (inferior_ptid);
 383
 384   if (from_tty)
 385     {
 386       char *exec_file = get_exec_file (0);
 387       if (exec_file == 0)
 388         exec_file = "";
 389       printf_unfiltered ("Detaching from program: %s, %s\n", exec_file,
 390                          target_pid_to_str (pid_to_ptid (pid)));
 391       gdb_flush (gdb_stdout);
 392     }
 393   if (args)
 394     siggnal = atoi (args);
 395
 396   detach (siggnal);
 397
 398   inferior_ptid = null_ptid;
 399   unpush_target (ptrace_ops_hack);
 400 }
 401
 402 /* Get ready to modify the registers array.  On machines which store
 403    individual registers, this doesn't need to do anything.  On
 404    machines which store all the registers in one fell swoop, this
 405    makes sure that registers contains all the registers from the
 406    program being debugged.  */
 407
 408 static void
 409 inf_ptrace_prepare_to_store (void)
 410 {
 411 }
 412
 413 /* Print status information about what we're accessing.  */
 414
 415 static void
 416 inf_ptrace_files_info (struct target_ops *ignore)
 417 {
 418   printf_unfiltered ("\tUsing the running image of %s %s.\n",
 419                      attach_flag ? "attached" : "child",
 420                      target_pid_to_str (inferior_ptid));
 421 }
 422
 423 static void
 424 inf_ptrace_open (char *arg, int from_tty)
 425 {
 426   error ("Use the \"run\" command to start a Unix child process.");
 427 }
 428
 429 /* Stub function which causes the inferior that runs it, to be ptrace-able
 430    by its parent process.  */
 431
 432 static void
 433 inf_ptrace_me (void)
 434 {
 435   /* "Trace me, Dr. Memory!" */
 436   call_ptrace (0, 0, (PTRACE_TYPE_ARG3) 0, 0);
 437 }
 438
 439 /* Stub function which causes the GDB that runs it, to start ptrace-ing
 440    the child process.  */
 441
 442 static void
 443 inf_ptrace_him (int pid)
 444 {
 445   push_target (ptrace_ops_hack);
 446
 447   /* On some targets, there must be some explicit synchronization
 448      between the parent and child processes after the debugger
 449      forks, and before the child execs the debuggee program.  This
 450      call basically gives permission for the child to exec.
 451    */
 452
 453   target_acknowledge_created_inferior (pid);
 454
 455   /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h,
 456    * and will be 1 or 2 depending on whether we're starting
 457    * without or with a shell.
 458    */
 459   startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
 460
 461   /* On some targets, there must be some explicit actions taken after
 462      the inferior has been started up.
 463    */
 464   target_post_startup_inferior (pid_to_ptid (pid));
 465 }
 466
 467 /* Start an inferior Unix child process and sets inferior_ptid to its
 468    pid.  EXEC_FILE is the file to run.  ALLARGS is a string containing
 469    the arguments to the program.  ENV is the environment vector to
 470    pass.  Errors reported with error().  */
 471
 472 static void
 473 inf_ptrace_create_inferior (char *exec_file, char *allargs, char **env,
 474                             int from_tty)
 475 {
 476   fork_inferior (exec_file, allargs, env, inf_ptrace_me, inf_ptrace_him,
 477                  NULL, NULL);
 478   /* We are at the first instruction we care about.  */
 479   observer_notify_inferior_created (&current_target, from_tty);
 480   /* Pedal to the metal... */
 481   proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
 482 }
 483
 484 static void
 485 inf_ptrace_post_startup_inferior (ptid_t ptid)
 486 {
 487   /* This version of Unix doesn't require a meaningful "post startup inferior"
 488      operation by a debugger.
 489    */
 490 }
 491
 492 static void
 493 inf_ptrace_acknowledge_created_inferior (int pid)
 494 {
 495   /* This version of Unix doesn't require a meaningful "acknowledge created inferior"
 496      operation by a debugger.
 497    */
 498 }
 499
 500 static int
 501 inf_ptrace_insert_fork_catchpoint (int pid)
 502 {
 503   /* This version of Unix doesn't support notification of fork events.  */
 504   return 0;
 505 }
 506
 507 static int
 508 inf_ptrace_remove_fork_catchpoint (int pid)
 509 {
 510   /* This version of Unix doesn't support notification of fork events.  */
 511   return 0;
 512 }
 513
 514 static int
 515 inf_ptrace_insert_vfork_catchpoint (int pid)
 516 {
 517   /* This version of Unix doesn't support notification of vfork events.  */
 518   return 0;
 519 }
 520
 521 static int
 522 inf_ptrace_remove_vfork_catchpoint (int pid)
 523 {
 524   /* This version of Unix doesn't support notification of vfork events.  */
 525   return 0;
 526 }
 527
 528 static int
 529 inf_ptrace_follow_fork (int follow_child)
 530 {
 531   /* This version of Unix doesn't support following fork or vfork events.  */
 532   return 0;
 533 }
 534
 535 static int
 536 inf_ptrace_insert_exec_catchpoint (int pid)
 537 {
 538   /* This version of Unix doesn't support notification of exec events.  */
 539   return 0;
 540 }
 541
 542 static int
 543 inf_ptrace_remove_exec_catchpoint (int pid)
 544 {
 545   /* This version of Unix doesn't support notification of exec events.  */
 546   return 0;
 547 }
 548
 549 static int
 550 inf_ptrace_reported_exec_events_per_exec_call (void)
 551 {
 552   /* This version of Unix doesn't support notification of exec events.
 553    */
 554   return 1;
 555 }
 556
 557 static int
 558 inf_ptrace_has_exited (int pid, int wait_status, int *exit_status)
 559 {
 560   if (WIFEXITED (wait_status))
 561     {
 562       *exit_status = WEXITSTATUS (wait_status);
 563       return 1;
 564     }
 565
 566   if (WIFSIGNALED (wait_status))
 567     {
 568       *exit_status = 0;         /* ?? Don't know what else to say here. */
 569       return 1;
 570     }
 571
 572   /* ?? Do we really need to consult the event state, too?  Assume the
 573      wait_state alone suffices.
 574    */
 575   return 0;
 576 }
 577
 578 static void
 579 inf_ptrace_mourn_inferior (void)
 580 {
 581   unpush_target (ptrace_ops_hack);
 582   generic_mourn_inferior ();
 583 }
 584
 585 static int
 586 inf_ptrace_can_run (void)
 587 {
 588   return 1;
 589 }
 590
 591 /* Send a SIGINT to the process group.  This acts just like the user
 592    typed a ^C on the controlling terminal.
 593
 594    XXX - This may not be correct for all systems.  Some may want to
 595    use killpg() instead of kill (-pgrp). */
 596
 597 static void
 598 inf_ptrace_stop (void)
 599 {
 600   kill (-inferior_process_group, SIGINT);
 601 }
 602
 603 /* Perform a partial transfer to/from the specified object.  For
 604    memory transfers, fall back to the old memory xfer functions.  */
 605
 606 static LONGEST
 607 inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
 608                          const char *annex, void *readbuf,
 609                          const void *writebuf, ULONGEST offset, LONGEST len)
 610 {
 611   switch (object)
 612     {
 613     case TARGET_OBJECT_MEMORY:
 614       if (readbuf)
 615         return inf_ptrace_xfer_memory (offset, readbuf, len, 0 /*write */ ,
 616                                        NULL, ops);
 617       if (writebuf)
 618         return inf_ptrace_xfer_memory (offset, readbuf, len, 1 /*write */ ,
 619                                        NULL, ops);
 620       return -1;
 621
 622     case TARGET_OBJECT_UNWIND_TABLE:
 623       return -1;
 624
 625     case TARGET_OBJECT_AUXV:
 626       return -1;
 627
 628     case TARGET_OBJECT_WCOOKIE:
 629       return -1;
 630
 631     default:
 632       return -1;
 633     }
 634 }
 635
 636 static char *
 637 inf_ptrace_pid_to_str (ptid_t ptid)
 638 {
 639   return normal_pid_to_str (ptid);
 640 }
 641
 642 struct target_ops *
 643 inf_ptrace_target (void)
 644 {
 645   struct target_ops *t = inf_child_target ();
 646   t->to_open = inf_ptrace_open;
 647   t->to_attach = inf_ptrace_attach;
 648   t->to_post_attach = inf_ptrace_post_attach;
 649   t->to_detach = inf_ptrace_detach;
 650   t->to_resume = inf_ptrace_resume;
 651   t->to_wait = inf_ptrace_wait;
 652   t->to_post_wait = inf_ptrace_post_wait;
 653   t->to_prepare_to_store = inf_ptrace_prepare_to_store;
 654   t->to_xfer_memory = inf_ptrace_xfer_memory;
 655   t->to_xfer_partial = inf_ptrace_xfer_partial;
 656   t->to_files_info = inf_ptrace_files_info;
 657   t->to_kill = inf_ptrace_kill_inferior;
 658   t->to_create_inferior = inf_ptrace_create_inferior;
 659   t->to_post_startup_inferior = inf_ptrace_post_startup_inferior;
 660   t->to_acknowledge_created_inferior =
 661     inf_ptrace_acknowledge_created_inferior;
 662   t->to_insert_fork_catchpoint = inf_ptrace_insert_fork_catchpoint;
 663   t->to_remove_fork_catchpoint = inf_ptrace_remove_fork_catchpoint;
 664   t->to_insert_vfork_catchpoint = inf_ptrace_insert_vfork_catchpoint;
 665   t->to_remove_vfork_catchpoint = inf_ptrace_remove_vfork_catchpoint;
 666   t->to_follow_fork = inf_ptrace_follow_fork;
 667   t->to_insert_exec_catchpoint = inf_ptrace_insert_exec_catchpoint;
 668   t->to_remove_exec_catchpoint = inf_ptrace_remove_exec_catchpoint;
 669   t->to_reported_exec_events_per_exec_call =
 670     inf_ptrace_reported_exec_events_per_exec_call;
 671   t->to_has_exited = inf_ptrace_has_exited;
 672   t->to_mourn_inferior = inf_ptrace_mourn_inferior;
 673   t->to_can_run = inf_ptrace_can_run;
 674   t->to_thread_alive = inf_ptrace_thread_alive;
 675   t->to_pid_to_str = inf_ptrace_pid_to_str;
 676   t->to_stop = inf_ptrace_stop;
 677   t->to_stratum = process_stratum;
 678   t->to_has_all_memory = 1;
 679   t->to_has_memory = 1;
 680   t->to_has_stack = 1;
 681   t->to_has_registers = 1;
 682   t->to_has_execution = 1;
 683   t->to_magic = OPS_MAGIC;
 684   ptrace_ops_hack = t;
 685   return t;
 686 }