gdb/inf-ptrace.c

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