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, gdb_byte *readbuf,
 404                          const gdb_byte *writebuf,
 405                          ULONGEST offset, LONGEST len)
 406 {
 407   switch (object)
 408     {
 409     case TARGET_OBJECT_MEMORY:
 410 #ifdef PT_IO
 411       /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
 412          request that promises to be much more efficient in reading
 413          and writing data in the traced process's address space.  */
 414       {
 415         struct ptrace_io_desc piod;
 416
 417         /* NOTE: We assume that there are no distinct address spaces
 418            for instruction and data.  */
 419         piod.piod_op = writebuf ? PIOD_WRITE_D : PIOD_READ_D;
 420         piod.piod_addr = writebuf ? (void *) writebuf : readbuf;
 421         piod.piod_offs = (void *) (long) offset;
 422         piod.piod_len = len;
 423
 424         errno = 0;
 425         if (ptrace (PT_IO, PIDGET (inferior_ptid), (caddr_t) &piod, 0) == 0)
 426           /* Return the actual number of bytes read or written.  */
 427           return piod.piod_len;
 428         /* If the PT_IO request is somehow not supported, fallback on
 429            using PT_WRITE_D/PT_READ_D.  Otherwise we will return zero
 430            to indicate failure.  */
 431         if (errno != EINVAL)
 432           return 0;
 433       }
 434 #endif
 435       {
 436         union
 437         {
 438           PTRACE_TYPE_RET word;
 439           unsigned char byte[sizeof (PTRACE_TYPE_RET)];
 440         } buffer;
 441         ULONGEST rounded_offset;
 442         LONGEST partial_len;
 443
 444         /* Round the start offset down to the next long word
 445            boundary.  */
 446         rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
 447
 448         /* Since ptrace will transfer a single word starting at that
 449            rounded_offset the partial_len needs to be adjusted down to
 450            that (remember this function only does a single transfer).
 451            Should the required length be even less, adjust it down
 452            again.  */
 453         partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset;
 454         if (partial_len > len)
 455           partial_len = len;
 456
 457         if (writebuf)
 458           {
 459             /* If OFFSET:PARTIAL_LEN is smaller than
 460                ROUNDED_OFFSET:WORDSIZE then a read/modify write will
 461                be needed.  Read in the entire word.  */
 462             if (rounded_offset < offset
 463                 || (offset + partial_len
 464                     < rounded_offset + sizeof (PTRACE_TYPE_RET)))
 465               /* Need part of initial word -- fetch it.  */
 466               buffer.word = ptrace (PT_READ_I, PIDGET (inferior_ptid),
 467                                     (PTRACE_TYPE_ARG3) (long) rounded_offset,
 468                                     0);
 469
 470             /* Copy data to be written over corresponding part of
 471                buffer.  */
 472             memcpy (buffer.byte + (offset - rounded_offset),
 473                     writebuf, partial_len);
 474
 475             errno = 0;
 476             ptrace (PT_WRITE_D, PIDGET (inferior_ptid),
 477                     (PTRACE_TYPE_ARG3) (long) rounded_offset,
 478                     buffer.word);
 479             if (errno)
 480               {
 481                 /* Using the appropriate one (I or D) is necessary for
 482                    Gould NP1, at least.  */
 483                 errno = 0;
 484                 ptrace (PT_WRITE_I, PIDGET (inferior_ptid),
 485                         (PTRACE_TYPE_ARG3) (long) rounded_offset,
 486                         buffer.word);
 487                 if (errno)
 488                   return 0;
 489               }
 490           }
 491         if (readbuf)
 492           {
 493             errno = 0;
 494             buffer.word = ptrace (PT_READ_I, PIDGET (inferior_ptid),
 495                                   (PTRACE_TYPE_ARG3) (long) rounded_offset, 0);
 496             if (errno)
 497               return 0;
 498             /* Copy appropriate bytes out of the buffer.  */
 499             memcpy (readbuf, buffer.byte + (offset - rounded_offset),
 500                     partial_len);
 501           }
 502         return partial_len;
 503       }
 504
 505     case TARGET_OBJECT_UNWIND_TABLE:
 506       return -1;
 507
 508     case TARGET_OBJECT_AUXV:
 509       return -1;
 510
 511     case TARGET_OBJECT_WCOOKIE:
 512       return -1;
 513
 514     default:
 515       return -1;
 516     }
 517 }
 518
 519 static char *
 520 inf_ptrace_pid_to_str (ptid_t ptid)
 521 {
 522   return normal_pid_to_str (ptid);
 523 }
 524
 525 /* Create a prototype ptrace target.  The client can override it with
 526    local methods.  */
 527
 528 struct target_ops *
 529 inf_ptrace_target (void)
 530 {
 531   struct target_ops *t = inf_child_target ();
 532
 533   t->to_open = inf_ptrace_open;
 534   t->to_attach = inf_ptrace_attach;
 535   t->to_post_attach = inf_ptrace_post_attach;
 536   t->to_detach = inf_ptrace_detach;
 537   t->to_resume = inf_ptrace_resume;
 538   t->to_wait = inf_ptrace_wait;
 539   t->to_xfer_partial = inf_ptrace_xfer_partial;
 540   t->to_files_info = inf_ptrace_files_info;
 541   t->to_kill = inf_ptrace_kill_inferior;
 542   t->to_create_inferior = inf_ptrace_create_inferior;
 543   t->to_reported_exec_events_per_exec_call =
 544     inf_ptrace_reported_exec_events_per_exec_call;
 545   t->to_has_exited = inf_ptrace_has_exited;
 546   t->to_mourn_inferior = inf_ptrace_mourn_inferior;
 547   t->to_can_run = inf_ptrace_can_run;
 548   t->to_thread_alive = inf_ptrace_thread_alive;
 549   t->to_pid_to_str = inf_ptrace_pid_to_str;
 550   t->to_stop = inf_ptrace_stop;
 551   t->to_stratum = process_stratum;
 552   t->to_has_all_memory = 1;
 553   t->to_has_memory = 1;
 554   t->to_has_stack = 1;
 555   t->to_has_registers = 1;
 556   t->to_has_execution = 1;
 557   t->to_magic = OPS_MAGIC;
 558   ptrace_ops_hack = t;
 559
 560   return t;
 561 }
 562 \f
 563
 564 /* Pointer to a function that returns the oggset within the user area
 565    where a particular register is stored.  */
 566 static CORE_ADDR (*inf_ptrace_register_u_offset)(int);
 567
 568 /* Fetch register REGNUM from the inferior.  */
 569
 570 static void
 571 inf_ptrace_fetch_register (int regnum)
 572 {
 573   CORE_ADDR addr;
 574   size_t size;
 575   PTRACE_TYPE_RET *buf;
 576   int pid, i;
 577
 578   /* Cater for systems like GNU/Linux, that implement threads as
 579      seperate processes.  */
 580   pid = ptid_get_lwp (inferior_ptid);
 581   if (pid == 0)
 582     pid = ptid_get_pid (inferior_ptid);
 583
 584   /* This isn't really an address, but ptrace thinks of it as one.  */
 585   addr = inf_ptrace_register_u_offset (regnum);
 586   size = register_size (current_gdbarch, regnum);
 587
 588   gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
 589   buf = alloca (size);
 590
 591   /* Read the register contents from the inferior a chuck at the time.  */
 592   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
 593     {
 594       errno = 0;
 595       buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3) addr, 0);
 596       if (errno != 0)
 597         error (_("Couldn't read register %s (#%d): %s."), REGISTER_NAME (regnum),
 598                regnum, safe_strerror (errno));
 599
 600       addr += sizeof (PTRACE_TYPE_RET);
 601     }
 602   regcache_raw_supply (current_regcache, regnum, buf);
 603 }
 604
 605 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
 606    for all registers.  */
 607
 608 static void
 609 inf_ptrace_fetch_registers (int regnum)
 610 {
 611   if (regnum == -1)
 612     for (regnum = 0; regnum < NUM_REGS; regnum++)
 613       inf_ptrace_fetch_register (regnum);
 614   else
 615     inf_ptrace_fetch_register (regnum);
 616 }
 617
 618 /* Store register REGNUM into the inferior.  */
 619
 620 static void
 621 inf_ptrace_store_register (int regnum)
 622 {
 623   CORE_ADDR addr;
 624   size_t size;
 625   PTRACE_TYPE_RET *buf;
 626   int pid, i;
 627
 628   /* Cater for systems like GNU/Linux, that implement threads as
 629      seperate processes.  */
 630   pid = ptid_get_lwp (inferior_ptid);
 631   if (pid == 0)
 632     pid = ptid_get_pid (inferior_ptid);
 633
 634   /* This isn't really an address, but ptrace thinks of it as one.  */
 635   addr = inf_ptrace_register_u_offset (regnum);
 636   size = register_size (current_gdbarch, regnum);
 637
 638   gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
 639   buf = alloca (size);
 640
 641   /* Write the register contents into the inferior a chunk at the time.  */
 642   regcache_raw_collect (current_regcache, regnum, buf);
 643   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
 644     {
 645       errno = 0;
 646       ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3) addr, buf[i]);
 647       if (errno != 0)
 648         error (_("Couldn't write register %s (#%d): %s."), REGISTER_NAME (regnum),
 649                regnum, safe_strerror (errno));
 650
 651       addr += sizeof (PTRACE_TYPE_RET);
 652     }
 653 }
 654
 655 /* Store register REGNUM back into the inferior.  If REGNUM is -1, do
 656    this for all registers.  */
 657
 658 void
 659 inf_ptrace_store_registers (int regnum)
 660 {
 661   if (regnum == -1)
 662     for (regnum = 0; regnum < NUM_REGS; regnum++)
 663       inf_ptrace_store_register (regnum);
 664   else
 665     inf_ptrace_store_register (regnum);
 666 }
 667
 668 /* Create a "traditional" ptrace target.  REGISTER_U_OFFSET should be
 669    a function returning the offset within the user area where a
 670    particular register is stored.  */
 671
 672 struct target_ops *
 673 inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)(int))
 674 {
 675   struct target_ops *t = inf_ptrace_target();
 676
 677   gdb_assert (register_u_offset);
 678   inf_ptrace_register_u_offset = register_u_offset;
 679   t->to_fetch_registers = inf_ptrace_fetch_registers;
 680   t->to_store_registers = inf_ptrace_store_registers;
 681
 682   return t;
 683 }