URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [gdbserver/] [low-linux.c] - Blame information for rev 1774

Go to most recent revision | Details | Compare with Previous | View Log


/* Low level interface to ptrace, for the remote server for GDB.
   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
 
   This file is part of GDB.
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */
 
#include "defs.h"
#include <sys/wait.h>
#include "frame.h"
#include "inferior.h"
 
#include <stdio.h>
#include <sys/param.h>
#include <sys/dir.h>
#include <sys/ptrace.h>
#include <sys/user.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <fcntl.h>
 
/***************Begin MY defs*********************/
int quit_flag = 0;
static char my_registers[REGISTER_BYTES];
char *registers = my_registers;
 
/* Index within `registers' of the first byte of the space for
   register N.  */
 
 
char buf2[MAX_REGISTER_RAW_SIZE];
/***************End MY defs*********************/
 
#ifdef HAVE_SYS_REG_H
#include <sys/reg.h>
#endif
 
/* Default the type of the ptrace transfer to int.  */
#ifndef PTRACE_XFER_TYPE
#define PTRACE_XFER_TYPE int
#endif
 
extern char **environ;
extern int errno;
extern int inferior_pid;
void quit (), perror_with_name ();
int query ();
 
static void initialize_arch (void);
 
/* Start an inferior process and returns its pid.
   ALLARGS is a vector of program-name and args.
   ENV is the environment vector to pass.  */
 
int
create_inferior (program, allargs)
     char *program;
     char **allargs;
{
  int pid;
 
  pid = fork ();
  if (pid < 0)
    perror_with_name ("fork");
 
  if (pid == 0)
    {
      ptrace (PTRACE_TRACEME, 0, 0, 0);
 
      execv (program, allargs);
 
      fprintf (stderr, "Cannot exec %s: %s.\n", program,
               errno < sys_nerr ? sys_errlist[errno] : "unknown error");
      fflush (stderr);
      _exit (0177);
    }
 
  return pid;
}
 
/* Kill the inferior process.  Make us have no inferior.  */
 
void
kill_inferior ()
{
  if (inferior_pid == 0)
    return;
  ptrace (PTRACE_KILL, inferior_pid, 0, 0);
  wait (0);
/*************inferior_died ();****VK**************/
}
 
/* Return nonzero if the given thread is still alive.  */
int
mythread_alive (pid)
     int pid;
{
  return 1;
}
 
/* Wait for process, returns status */
 
unsigned char
mywait (status)
     char *status;
{
  int pid;
  union wait w;
 
  pid = wait (&w);
  if (pid != inferior_pid)
    perror_with_name ("wait");
 
  if (WIFEXITED (w))
    {
      fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
      *status = 'W';
      return ((unsigned char) WEXITSTATUS (w));
    }
  else if (!WIFSTOPPED (w))
    {
      fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
      *status = 'X';
      return ((unsigned char) WTERMSIG (w));
    }
 
  fetch_inferior_registers (0);
 
  *status = 'T';
  return ((unsigned char) WSTOPSIG (w));
}
 
/* Resume execution of the inferior process.
   If STEP is nonzero, single-step it.
   If SIGNAL is nonzero, give it that signal.  */
 
void
myresume (step, signal)
     int step;
     int signal;
{
  errno = 0;
  ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, inferior_pid, 1, signal);
  if (errno)
    perror_with_name ("ptrace");
}
 
 
#if !defined (offsetof)
#define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
#endif
 
/* U_REGS_OFFSET is the offset of the registers within the u area.  */
#if !defined (U_REGS_OFFSET)
#define U_REGS_OFFSET \
  ptrace (PT_READ_U, inferior_pid, \
          (PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \
    - KERNEL_U_ADDR
#endif
 
#ifdef I386_GNULINUX_TARGET
/* i386_register_raw_size[i] is the number of bytes of storage in the
   actual machine representation for register i.  */
int i386_register_raw_size[MAX_NUM_REGS] = {
   4,  4,  4,  4,
   4,  4,  4,  4,
   4,  4,  4,  4,
   4,  4,  4,  4,
  10, 10, 10, 10,
  10, 10, 10, 10,
   4,  4,  4,  4,
   4,  4,  4,  4,
  16, 16, 16, 16,
  16, 16, 16, 16,
   4
};
 
int i386_register_byte[MAX_NUM_REGS];
 
static void
initialize_arch ()
{
  /* Initialize the table saying where each register starts in the
     register file.  */
  {
    int i, offset;
 
    offset = 0;
    for (i = 0; i < MAX_NUM_REGS; i++)
      {
        i386_register_byte[i] = offset;
        offset += i386_register_raw_size[i];
      }
  }
}
 
/* this table must line up with REGISTER_NAMES in tm-i386v.h */
/* symbols like 'EAX' come from <sys/reg.h> */
static int regmap[] =
{
  EAX, ECX, EDX, EBX,
  UESP, EBP, ESI, EDI,
  EIP, EFL, CS, SS,
  DS, ES, FS, GS,
};
 
int
i386_register_u_addr (blockend, regnum)
     int blockend;
     int regnum;
{
#if 0
  /* this will be needed if fp registers are reinstated */
  /* for now, you can look at them with 'info float'
   * sys5 wont let you change them with ptrace anyway
   */
  if (regnum >= FP0_REGNUM && regnum <= FP7_REGNUM)
    {
      int ubase, fpstate;
      struct user u;
      ubase = blockend + 4 * (SS + 1) - KSTKSZ;
      fpstate = ubase + ((char *) &u.u_fpstate - (char *) &u);
      return (fpstate + 0x1c + 10 * (regnum - FP0_REGNUM));
    }
  else
#endif
    return (blockend + 4 * regmap[regnum]);
 
}
#elif defined(TARGET_M68K)
static void
initialize_arch ()
{
  return;
}
 
/* This table must line up with REGISTER_NAMES in tm-m68k.h */
static int regmap[] =
{
#ifdef PT_D0
  PT_D0, PT_D1, PT_D2, PT_D3, PT_D4, PT_D5, PT_D6, PT_D7,
  PT_A0, PT_A1, PT_A2, PT_A3, PT_A4, PT_A5, PT_A6, PT_USP,
  PT_SR, PT_PC,
#else
  14, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15,
  17, 18,
#endif
#ifdef PT_FP0
  PT_FP0, PT_FP1, PT_FP2, PT_FP3, PT_FP4, PT_FP5, PT_FP6, PT_FP7,
  PT_FPCR, PT_FPSR, PT_FPIAR
#else
  21, 24, 27, 30, 33, 36, 39, 42, 45, 46, 47
#endif
};
 
/* BLOCKEND is the value of u.u_ar0, and points to the place where GS
   is stored.  */
 
int
m68k_linux_register_u_addr (blockend, regnum)
     int blockend;
     int regnum;
{
  return (blockend + 4 * regmap[regnum]);
}
#elif defined(IA64_GNULINUX_TARGET)
#undef NUM_FREGS
#define NUM_FREGS 0
 
#include <asm/ptrace_offsets.h>
 
static int u_offsets[] =
  {
    /* general registers */
    -1,         /* gr0 not available; i.e, it's always zero */
    PT_R1,
    PT_R2,
    PT_R3,
    PT_R4,
    PT_R5,
    PT_R6,
    PT_R7,
    PT_R8,
    PT_R9,
    PT_R10,
    PT_R11,
    PT_R12,
    PT_R13,
    PT_R14,
    PT_R15,
    PT_R16,
    PT_R17,
    PT_R18,
    PT_R19,
    PT_R20,
    PT_R21,
    PT_R22,
    PT_R23,
    PT_R24,
    PT_R25,
    PT_R26,
    PT_R27,
    PT_R28,
    PT_R29,
    PT_R30,
    PT_R31,
    /* gr32 through gr127 not directly available via the ptrace interface */
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    /* Floating point registers */
    -1, -1,     /* f0 and f1 not available (f0 is +0.0 and f1 is +1.0) */
    PT_F2,
    PT_F3,
    PT_F4,
    PT_F5,
    PT_F6,
    PT_F7,
    PT_F8,
    PT_F9,
    PT_F10,
    PT_F11,
    PT_F12,
    PT_F13,
    PT_F14,
    PT_F15,
    PT_F16,
    PT_F17,
    PT_F18,
    PT_F19,
    PT_F20,
    PT_F21,
    PT_F22,
    PT_F23,
    PT_F24,
    PT_F25,
    PT_F26,
    PT_F27,
    PT_F28,
    PT_F29,
    PT_F30,
    PT_F31,
    PT_F32,
    PT_F33,
    PT_F34,
    PT_F35,
    PT_F36,
    PT_F37,
    PT_F38,
    PT_F39,
    PT_F40,
    PT_F41,
    PT_F42,
    PT_F43,
    PT_F44,
    PT_F45,
    PT_F46,
    PT_F47,
    PT_F48,
    PT_F49,
    PT_F50,
    PT_F51,
    PT_F52,
    PT_F53,
    PT_F54,
    PT_F55,
    PT_F56,
    PT_F57,
    PT_F58,
    PT_F59,
    PT_F60,
    PT_F61,
    PT_F62,
    PT_F63,
    PT_F64,
    PT_F65,
    PT_F66,
    PT_F67,
    PT_F68,
    PT_F69,
    PT_F70,
    PT_F71,
    PT_F72,
    PT_F73,
    PT_F74,
    PT_F75,
    PT_F76,
    PT_F77,
    PT_F78,
    PT_F79,
    PT_F80,
    PT_F81,
    PT_F82,
    PT_F83,
    PT_F84,
    PT_F85,
    PT_F86,
    PT_F87,
    PT_F88,
    PT_F89,
    PT_F90,
    PT_F91,
    PT_F92,
    PT_F93,
    PT_F94,
    PT_F95,
    PT_F96,
    PT_F97,
    PT_F98,
    PT_F99,
    PT_F100,
    PT_F101,
    PT_F102,
    PT_F103,
    PT_F104,
    PT_F105,
    PT_F106,
    PT_F107,
    PT_F108,
    PT_F109,
    PT_F110,
    PT_F111,
    PT_F112,
    PT_F113,
    PT_F114,
    PT_F115,
    PT_F116,
    PT_F117,
    PT_F118,
    PT_F119,
    PT_F120,
    PT_F121,
    PT_F122,
    PT_F123,
    PT_F124,
    PT_F125,
    PT_F126,
    PT_F127,
    /* predicate registers - we don't fetch these individually */
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    /* branch registers */
    PT_B0,
    PT_B1,
    PT_B2,
    PT_B3,
    PT_B4,
    PT_B5,
    PT_B6,
    PT_B7,
    /* virtual frame pointer and virtual return address pointer */
    -1, -1,
    /* other registers */
    PT_PR,
    PT_CR_IIP,  /* ip */
    PT_CR_IPSR, /* psr */
    PT_CR_IFS,  /* cfm */
    /* kernel registers not visible via ptrace interface (?) */
    -1, -1, -1, -1, -1, -1, -1, -1,
    /* hole */
    -1, -1, -1, -1, -1, -1, -1, -1,
    PT_AR_RSC,
    PT_AR_BSP,
    PT_AR_BSPSTORE,
    PT_AR_RNAT,
    -1,
    -1,         /* Not available: FCR, IA32 floating control register */
    -1, -1,
    -1,         /* Not available: EFLAG */
    -1,         /* Not available: CSD */
    -1,         /* Not available: SSD */
    -1,         /* Not available: CFLG */
    -1,         /* Not available: FSR */
    -1,         /* Not available: FIR */
    -1,         /* Not available: FDR */
    -1,
    PT_AR_CCV,
    -1, -1, -1,
    PT_AR_UNAT,
    -1, -1, -1,
    PT_AR_FPSR,
    -1, -1, -1,
    -1,         /* Not available: ITC */
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1,
    PT_AR_PFS,
    PT_AR_LC,
    -1,         /* Not available: EC, the Epilog Count register */
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1,
    /* nat bits - not fetched directly; instead we obtain these bits from
       either rnat or unat or from memory. */
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,
  };
 
int
ia64_register_u_addr (int blockend, int regnum)
{
  int addr;
 
  if (regnum < 0 || regnum >= NUM_REGS)
    error ("Invalid register number %d.", regnum);
 
  addr = u_offsets[regnum];
  if (addr == -1)
    addr = 0;
 
  return addr;
}
 
static void
initialize_arch ()
{
  return;
}
#endif
 
CORE_ADDR
register_addr (regno, blockend)
     int regno;
     CORE_ADDR blockend;
{
  CORE_ADDR addr;
 
  if (regno < 0 || regno >= ARCH_NUM_REGS)
    error ("Invalid register number %d.", regno);
 
  REGISTER_U_ADDR (addr, blockend, regno);
 
  return addr;
}
 
/* Fetch one register.  */
 
static void
fetch_register (regno)
     int regno;
{
  CORE_ADDR regaddr;
  register int i;
 
  /* Offset of registers within the u area.  */
  unsigned int offset;
 
  offset = U_REGS_OFFSET;
 
  regaddr = register_addr (regno, offset);
  for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
    {
      errno = 0;
      *(PTRACE_XFER_TYPE *) &registers[REGISTER_BYTE (regno) + i] =
        ptrace (PTRACE_PEEKUSER, inferior_pid, (PTRACE_ARG3_TYPE) regaddr, 0);
      regaddr += sizeof (PTRACE_XFER_TYPE);
      if (errno != 0)
        {
          /* Warning, not error, in case we are attached; sometimes the
             kernel doesn't let us at the registers.  */
          char *err = strerror (errno);
          char *msg = alloca (strlen (err) + 128);
          sprintf (msg, "reading register %d: %s", regno, err);
          error (msg);
          goto error_exit;
        }
    }
error_exit:;
}
 
/* Fetch all registers, or just one, from the child process.  */
 
void
fetch_inferior_registers (regno)
     int regno;
{
  if (regno == -1 || regno == 0)
    for (regno = 0; regno < NUM_REGS - NUM_FREGS; regno++)
      fetch_register (regno);
  else
    fetch_register (regno);
}
 
/* Store our register values back into the inferior.
   If REGNO is -1, do this for all registers.
   Otherwise, REGNO specifies which register (so we can save time).  */
 
void
store_inferior_registers (regno)
     int regno;
{
  CORE_ADDR regaddr;
  int i;
  unsigned int offset = U_REGS_OFFSET;
 
  if (regno >= 0)
    {
#if 0
      if (CANNOT_STORE_REGISTER (regno))
        return;
#endif
      regaddr = register_addr (regno, offset);
      errno = 0;
#if 0
      if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM)
        {
          scratch = *(int *) &registers[REGISTER_BYTE (regno)] | 0x3;
          ptrace (PT_WUREGS, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
                  scratch, 0);
          if (errno != 0)
            {
              /* Error, even if attached.  Failing to write these two
                 registers is pretty serious.  */
              sprintf (buf, "writing register number %d", regno);
              perror_with_name (buf);
            }
        }
      else
#endif
        for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
          {
            errno = 0;
            ptrace (PTRACE_POKEUSER, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
                    *(int *) &registers[REGISTER_BYTE (regno) + i]);
            if (errno != 0)
              {
                /* Warning, not error, in case we are attached; sometimes the
                   kernel doesn't let us at the registers.  */
                char *err = strerror (errno);
                char *msg = alloca (strlen (err) + 128);
                sprintf (msg, "writing register %d: %s",
                         regno, err);
                error (msg);
                return;
              }
            regaddr += sizeof (int);
          }
    }
  else
    for (regno = 0; regno < NUM_REGS - NUM_FREGS; regno++)
      store_inferior_registers (regno);
}
 
/* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
   in the NEW_SUN_PTRACE case.
   It ought to be straightforward.  But it appears that writing did
   not write the data that I specified.  I cannot understand where
   it got the data that it actually did write.  */
 
/* Copy LEN bytes from inferior's memory starting at MEMADDR
   to debugger memory starting at MYADDR.  */
 
void
read_inferior_memory (memaddr, myaddr, len)
     CORE_ADDR memaddr;
     char *myaddr;
     int len;
{
  register int i;
  /* Round starting address down to longword boundary.  */
  register CORE_ADDR addr = memaddr & -sizeof (PTRACE_XFER_TYPE);
  /* Round ending address up; get number of longwords that makes.  */
  register int count
    = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
      / sizeof (PTRACE_XFER_TYPE);
  /* Allocate buffer of that many longwords.  */
  register PTRACE_XFER_TYPE *buffer
    = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
 
  /* Read all the longwords */
  for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
    {
      buffer[i] = ptrace (PTRACE_PEEKTEXT, inferior_pid, addr, 0);
    }
 
  /* Copy appropriate bytes out of the buffer.  */
  memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), len);
}
 
/* Copy LEN bytes of data from debugger memory at MYADDR
   to inferior's memory at MEMADDR.
   On failure (cannot write the inferior)
   returns the value of errno.  */
 
int
write_inferior_memory (memaddr, myaddr, len)
     CORE_ADDR memaddr;
     char *myaddr;
     int len;
{
  register int i;
  /* Round starting address down to longword boundary.  */
  register CORE_ADDR addr = memaddr & -sizeof (PTRACE_XFER_TYPE);
  /* Round ending address up; get number of longwords that makes.  */
  register int count
  = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1) / sizeof (PTRACE_XFER_TYPE);
  /* Allocate buffer of that many longwords.  */
  register PTRACE_XFER_TYPE *buffer = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
  extern int errno;
 
  /* Fill start and end extra bytes of buffer with existing memory data.  */
 
  buffer[0] = ptrace (PTRACE_PEEKTEXT, inferior_pid, addr, 0);
 
  if (count > 1)
    {
      buffer[count - 1]
        = ptrace (PTRACE_PEEKTEXT, inferior_pid,
                  addr + (count - 1) * sizeof (PTRACE_XFER_TYPE), 0);
    }
 
  /* Copy data to be written over corresponding part of buffer */
 
  memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), myaddr, len);
 
  /* Write the entire buffer.  */
 
  for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
    {
      errno = 0;
      ptrace (PTRACE_POKETEXT, inferior_pid, addr, buffer[i]);
      if (errno)
        return errno;
    }
 
  return 0;
}
 
void
initialize_low ()
{
  initialize_arch ();
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [gdbserver/] [low-linux.c] - Blame information for rev 1774

Line No.	Rev	Author	Line
1	106	markom	`/* Low level interface to ptrace, for the remote server for GDB.`
2			`Copyright (C) 1995, 1996 Free Software Foundation, Inc.`
3
4			`This file is part of GDB.`
5
6			`This program is free software; you can redistribute it and/or modify`
7			`it under the terms of the GNU General Public License as published by`
8			`the Free Software Foundation; either version 2 of the License, or`
9			`(at your option) any later version.`
10
11			`This program is distributed in the hope that it will be useful,`
12			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
13			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
14			`GNU General Public License for more details.`
15
16			`You should have received a copy of the GNU General Public License`
17			`along with this program; if not, write to the Free Software`
18			`Foundation, Inc., 59 Temple Place - Suite 330,`
19			`Boston, MA 02111-1307, USA. */`
20
21			`#include "defs.h"`
22			`#include <sys/wait.h>`
23			`#include "frame.h"`
24			`#include "inferior.h"`
25
26			`#include <stdio.h>`
27			`#include <sys/param.h>`
28			`#include <sys/dir.h>`
29			`#include <sys/ptrace.h>`
30			`#include <sys/user.h>`
31			`#include <signal.h>`
32			`#include <sys/ioctl.h>`
33			`#include <fcntl.h>`
34
35			`/*************Begin MY defs*******************/`
36			`int quit_flag = 0;`
37			`static char my_registers[REGISTER_BYTES];`
38			`char *registers = my_registers;`
39
40			/* Index within `registers' of the first byte of the space for
41			`register N. */`
42
43
44			`char buf2[MAX_REGISTER_RAW_SIZE];`
45			`/*************End MY defs*******************/`
46
47			`#ifdef HAVE_SYS_REG_H`
48			`#include <sys/reg.h>`
49			`#endif`
50
51			`/* Default the type of the ptrace transfer to int. */`
52			`#ifndef PTRACE_XFER_TYPE`
53			`#define PTRACE_XFER_TYPE int`
54			`#endif`
55
56			`extern char **environ;`
57			`extern int errno;`
58			`extern int inferior_pid;`
59			`void quit (), perror_with_name ();`
60			`int query ();`
61
62			`static void initialize_arch (void);`
63
64			`/* Start an inferior process and returns its pid.`
65			`ALLARGS is a vector of program-name and args.`
66			`ENV is the environment vector to pass. */`
67
68			`int`
69			`create_inferior (program, allargs)`
70			`char *program;`
71			`char **allargs;`
72			`{`
73			`int pid;`
74
75			`pid = fork ();`
76			`if (pid < 0)`
77			`perror_with_name ("fork");`
78
79			`if (pid == 0)`
80			`{`
81			`ptrace (PTRACE_TRACEME, 0, 0, 0);`
82
83			`execv (program, allargs);`
84
85			`fprintf (stderr, "Cannot exec %s: %s.\n", program,`
86			`errno < sys_nerr ? sys_errlist[errno] : "unknown error");`
87			`fflush (stderr);`
88			`_exit (0177);`
89			`}`
90
91			`return pid;`
92			`}`
93
94			`/* Kill the inferior process. Make us have no inferior. */`
95
96			`void`
97			`kill_inferior ()`
98			`{`
99			`if (inferior_pid == 0)`
100			`return;`
101			`ptrace (PTRACE_KILL, inferior_pid, 0, 0);`
102			`wait (0);`
103			`/***********inferior_died ();VK************/`
104			`}`
105
106			`/* Return nonzero if the given thread is still alive. */`
107			`int`
108			`mythread_alive (pid)`
109			`int pid;`
110			`{`
111			`return 1;`
112			`}`
113
114			`/* Wait for process, returns status */`
115
116			`unsigned char`
117			`mywait (status)`
118			`char *status;`
119			`{`
120			`int pid;`
121			`union wait w;`
122
123			`pid = wait (&w);`
124			`if (pid != inferior_pid)`
125			`perror_with_name ("wait");`
126
127			`if (WIFEXITED (w))`
128			`{`
129			`fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));`
130			`*status = 'W';`
131			`return ((unsigned char) WEXITSTATUS (w));`
132			`}`
133			`else if (!WIFSTOPPED (w))`
134			`{`
135			`fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));`
136			`*status = 'X';`
137			`return ((unsigned char) WTERMSIG (w));`
138			`}`
139
140			`fetch_inferior_registers (0);`
141
142			`*status = 'T';`
143			`return ((unsigned char) WSTOPSIG (w));`
144			`}`
145
146			`/* Resume execution of the inferior process.`
147			`If STEP is nonzero, single-step it.`
148			`If SIGNAL is nonzero, give it that signal. */`
149
150			`void`
151			`myresume (step, signal)`
152			`int step;`
153			`int signal;`
154			`{`
155			`errno = 0;`
156			`ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, inferior_pid, 1, signal);`
157			`if (errno)`
158			`perror_with_name ("ptrace");`
159			`}`
160
161
162			`#if !defined (offsetof)`
163			`#define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)`
164			`#endif`
165
166			`/* U_REGS_OFFSET is the offset of the registers within the u area. */`
167			`#if !defined (U_REGS_OFFSET)`
168			`#define U_REGS_OFFSET \`
169			`ptrace (PT_READ_U, inferior_pid, \`
170			`(PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \`
171			`- KERNEL_U_ADDR`
172			`#endif`
173
174			`#ifdef I386_GNULINUX_TARGET`
175			`/* i386_register_raw_size[i] is the number of bytes of storage in the`
176			`actual machine representation for register i. */`
177			`int i386_register_raw_size[MAX_NUM_REGS] = {`
178			`4, 4, 4, 4,`
179			`4, 4, 4, 4,`
180			`4, 4, 4, 4,`
181			`4, 4, 4, 4,`
182			`10, 10, 10, 10,`
183			`10, 10, 10, 10,`
184			`4, 4, 4, 4,`
185			`4, 4, 4, 4,`
186			`16, 16, 16, 16,`
187			`16, 16, 16, 16,`
188			`4`
189			`};`
190
191			`int i386_register_byte[MAX_NUM_REGS];`
192
193			`static void`
194			`initialize_arch ()`
195			`{`
196			`/* Initialize the table saying where each register starts in the`
197			`register file. */`
198			`{`
199			`int i, offset;`
200
201			`offset = 0;`
202			`for (i = 0; i < MAX_NUM_REGS; i++)`
203			`{`
204			`i386_register_byte[i] = offset;`
205			`offset += i386_register_raw_size[i];`
206			`}`
207			`}`
208			`}`
209
210			`/* this table must line up with REGISTER_NAMES in tm-i386v.h */`
211			`/* symbols like 'EAX' come from <sys/reg.h> */`
212			`static int regmap[] =`
213			`{`
214			`EAX, ECX, EDX, EBX,`
215			`UESP, EBP, ESI, EDI,`
216			`EIP, EFL, CS, SS,`
217			`DS, ES, FS, GS,`
218			`};`
219
220			`int`
221			`i386_register_u_addr (blockend, regnum)`
222			`int blockend;`
223			`int regnum;`
224			`{`
225			`#if 0`
226			`/* this will be needed if fp registers are reinstated */`
227			`/* for now, you can look at them with 'info float'`
228			`* sys5 wont let you change them with ptrace anyway`
229			`*/`
230			`if (regnum >= FP0_REGNUM && regnum <= FP7_REGNUM)`
231			`{`
232			`int ubase, fpstate;`
233			`struct user u;`
234			`ubase = blockend + 4 * (SS + 1) - KSTKSZ;`
235			`fpstate = ubase + ((char ) &u.u_fpstate - (char ) &u);`
236			`return (fpstate + 0x1c + 10 * (regnum - FP0_REGNUM));`
237			`}`
238			`else`
239			`#endif`
240			`return (blockend + 4 * regmap[regnum]);`
241
242			`}`
243			`#elif defined(TARGET_M68K)`
244			`static void`
245			`initialize_arch ()`
246			`{`
247			`return;`
248			`}`
249
250			`/* This table must line up with REGISTER_NAMES in tm-m68k.h */`
251			`static int regmap[] =`
252			`{`
253			`#ifdef PT_D0`
254			`PT_D0, PT_D1, PT_D2, PT_D3, PT_D4, PT_D5, PT_D6, PT_D7,`
255			`PT_A0, PT_A1, PT_A2, PT_A3, PT_A4, PT_A5, PT_A6, PT_USP,`
256			`PT_SR, PT_PC,`
257			`#else`
258			`14, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15,`
259			`17, 18,`
260			`#endif`
261			`#ifdef PT_FP0`
262			`PT_FP0, PT_FP1, PT_FP2, PT_FP3, PT_FP4, PT_FP5, PT_FP6, PT_FP7,`
263			`PT_FPCR, PT_FPSR, PT_FPIAR`
264			`#else`
265			`21, 24, 27, 30, 33, 36, 39, 42, 45, 46, 47`
266			`#endif`
267			`};`
268
269			`/* BLOCKEND is the value of u.u_ar0, and points to the place where GS`
270			`is stored. */`
271
272			`int`
273			`m68k_linux_register_u_addr (blockend, regnum)`
274			`int blockend;`
275			`int regnum;`
276			`{`
277			`return (blockend + 4 * regmap[regnum]);`
278			`}`
279			`#elif defined(IA64_GNULINUX_TARGET)`
280			`#undef NUM_FREGS`
281			`#define NUM_FREGS 0`
282
283			`#include <asm/ptrace_offsets.h>`
284
285			`static int u_offsets[] =`
286			`{`
287			`/* general registers */`
288			`-1, /* gr0 not available; i.e, it's always zero */`
289			`PT_R1,`
290			`PT_R2,`
291			`PT_R3,`
292			`PT_R4,`
293			`PT_R5,`
294			`PT_R6,`
295			`PT_R7,`
296			`PT_R8,`
297			`PT_R9,`
298			`PT_R10,`
299			`PT_R11,`
300			`PT_R12,`
301			`PT_R13,`
302			`PT_R14,`
303			`PT_R15,`
304			`PT_R16,`
305			`PT_R17,`
306			`PT_R18,`
307			`PT_R19,`
308			`PT_R20,`
309			`PT_R21,`
310			`PT_R22,`
311			`PT_R23,`
312			`PT_R24,`
313			`PT_R25,`
314			`PT_R26,`
315			`PT_R27,`
316			`PT_R28,`
317			`PT_R29,`
318			`PT_R30,`
319			`PT_R31,`
320			`/* gr32 through gr127 not directly available via the ptrace interface */`
321			`-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,`
322			`-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,`
323			`-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,`
324			`-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,`
325			`-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,`
326			`-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,`
327			`/* Floating point registers */`
328			`-1, -1, /* f0 and f1 not available (f0 is +0.0 and f1 is +1.0) */`
329			`PT_F2,`
330			`PT_F3,`
331			`PT_F4,`
332			`PT_F5,`
333			`PT_F6,`
334			`PT_F7,`
335			`PT_F8,`
336			`PT_F9,`
337			`PT_F10,`
338			`PT_F11,`
339			`PT_F12,`
340			`PT_F13,`
341			`PT_F14,`
342			`PT_F15,`
343			`PT_F16,`
344			`PT_F17,`
345			`PT_F18,`
346			`PT_F19,`
347			`PT_F20,`
348			`PT_F21,`
349			`PT_F22,`
350			`PT_F23,`
351			`PT_F24,`
352			`PT_F25,`
353			`PT_F26,`
354			`PT_F27,`
355			`PT_F28,`
356			`PT_F29,`
357			`PT_F30,`
358			`PT_F31,`
359			`PT_F32,`
360			`PT_F33,`
361			`PT_F34,`
362			`PT_F35,`
363			`PT_F36,`
364			`PT_F37,`
365			`PT_F38,`
366			`PT_F39,`
367			`PT_F40,`
368			`PT_F41,`
369			`PT_F42,`
370			`PT_F43,`
371			`PT_F44,`
372			`PT_F45,`
373			`PT_F46,`
374			`PT_F47,`
375			`PT_F48,`
376			`PT_F49,`
377			`PT_F50,`
378			`PT_F51,`
379			`PT_F52,`
380			`PT_F53,`
381			`PT_F54,`
382			`PT_F55,`
383			`PT_F56,`
384			`PT_F57,`
385			`PT_F58,`
386			`PT_F59,`
387			`PT_F60,`
388			`PT_F61,`
389			`PT_F62,`
390			`PT_F63,`
391			`PT_F64,`
392			`PT_F65,`
393			`PT_F66,`
394			`PT_F67,`
395			`PT_F68,`
396			`PT_F69,`
397			`PT_F70,`
398			`PT_F71,`
399			`PT_F72,`
400			`PT_F73,`
401			`PT_F74,`
402			`PT_F75,`
403			`PT_F76,`
404			`PT_F77,`
405			`PT_F78,`
406			`PT_F79,`
407			`PT_F80,`
408			`PT_F81,`
409			`PT_F82,`
410			`PT_F83,`
411			`PT_F84,`
412			`PT_F85,`
413			`PT_F86,`
414			`PT_F87,`
415			`PT_F88,`
416			`PT_F89,`
417			`PT_F90,`
418			`PT_F91,`
419			`PT_F92,`
420			`PT_F93,`
421			`PT_F94,`
422			`PT_F95,`
423			`PT_F96,`
424			`PT_F97,`
425			`PT_F98,`
426			`PT_F99,`
427			`PT_F100,`
428			`PT_F101,`
429			`PT_F102,`
430			`PT_F103,`
431			`PT_F104,`
432			`PT_F105,`
433			`PT_F106,`
434			`PT_F107,`
435			`PT_F108,`
436			`PT_F109,`
437			`PT_F110,`
438			`PT_F111,`
439			`PT_F112,`
440			`PT_F113,`
441			`PT_F114,`
442			`PT_F115,`
443			`PT_F116,`
444			`PT_F117,`
445			`PT_F118,`
446			`PT_F119,`
447			`PT_F120,`
448			`PT_F121,`
449			`PT_F122,`
450			`PT_F123,`
451			`PT_F124,`
452			`PT_F125,`
453			`PT_F126,`
454			`PT_F127,`
455			`/* predicate registers - we don't fetch these individually */`
456			`-1, -1, -1, -1, -1, -1, -1, -1,`
457			`-1, -1, -1, -1, -1, -1, -1, -1,`
458			`-1, -1, -1, -1, -1, -1, -1, -1,`
459			`-1, -1, -1, -1, -1, -1, -1, -1,`
460			`-1, -1, -1, -1, -1, -1, -1, -1,`
461			`-1, -1, -1, -1, -1, -1, -1, -1,`
462			`-1, -1, -1, -1, -1, -1, -1, -1,`
463			`-1, -1, -1, -1, -1, -1, -1, -1,`
464			`/* branch registers */`
465			`PT_B0,`
466			`PT_B1,`
467			`PT_B2,`
468			`PT_B3,`
469			`PT_B4,`
470			`PT_B5,`
471			`PT_B6,`
472			`PT_B7,`
473			`/* virtual frame pointer and virtual return address pointer */`
474			`-1, -1,`
475			`/* other registers */`
476			`PT_PR,`
477			`PT_CR_IIP, /* ip */`
478			`PT_CR_IPSR, /* psr */`
479			`PT_CR_IFS, /* cfm */`
480			`/* kernel registers not visible via ptrace interface (?) */`
481			`-1, -1, -1, -1, -1, -1, -1, -1,`
482			`/* hole */`
483			`-1, -1, -1, -1, -1, -1, -1, -1,`
484			`PT_AR_RSC,`
485			`PT_AR_BSP,`
486			`PT_AR_BSPSTORE,`
487			`PT_AR_RNAT,`
488			`-1,`
489			`-1, /* Not available: FCR, IA32 floating control register */`
490			`-1, -1,`
491			`-1, /* Not available: EFLAG */`
492			`-1, /* Not available: CSD */`
493			`-1, /* Not available: SSD */`
494			`-1, /* Not available: CFLG */`
495			`-1, /* Not available: FSR */`
496			`-1, /* Not available: FIR */`
497			`-1, /* Not available: FDR */`
498			`-1,`
499			`PT_AR_CCV,`
500			`-1, -1, -1,`
501			`PT_AR_UNAT,`
502			`-1, -1, -1,`
503			`PT_AR_FPSR,`
504			`-1, -1, -1,`
505			`-1, /* Not available: ITC */`
506			`-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,`
507			`-1, -1, -1, -1, -1, -1, -1, -1, -1,`
508			`PT_AR_PFS,`
509			`PT_AR_LC,`
510			`-1, /* Not available: EC, the Epilog Count register */`
511			`-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,`
512			`-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,`
513			`-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,`
514			`-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,`
515			`-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,`
516			`-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,`
517			`-1,`
518			`/* nat bits - not fetched directly; instead we obtain these bits from`
519			`either rnat or unat or from memory. */`
520			`-1, -1, -1, -1, -1, -1, -1, -1,`
521			`-1, -1, -1, -1, -1, -1, -1, -1,`
522			`-1, -1, -1, -1, -1, -1, -1, -1,`
523			`-1, -1, -1, -1, -1, -1, -1, -1,`
524			`-1, -1, -1, -1, -1, -1, -1, -1,`
525			`-1, -1, -1, -1, -1, -1, -1, -1,`
526			`-1, -1, -1, -1, -1, -1, -1, -1,`
527			`-1, -1, -1, -1, -1, -1, -1, -1,`
528			`-1, -1, -1, -1, -1, -1, -1, -1,`
529			`-1, -1, -1, -1, -1, -1, -1, -1,`
530			`-1, -1, -1, -1, -1, -1, -1, -1,`
531			`-1, -1, -1, -1, -1, -1, -1, -1,`
532			`-1, -1, -1, -1, -1, -1, -1, -1,`
533			`-1, -1, -1, -1, -1, -1, -1, -1,`
534			`-1, -1, -1, -1, -1, -1, -1, -1,`
535			`-1, -1, -1, -1, -1, -1, -1, -1,`
536			`};`
537
538			`int`
539			`ia64_register_u_addr (int blockend, int regnum)`
540			`{`
541			`int addr;`
542
543			`if (regnum < 0 \|\| regnum >= NUM_REGS)`
544			`error ("Invalid register number %d.", regnum);`
545
546			`addr = u_offsets[regnum];`
547			`if (addr == -1)`
548			`addr = 0;`
549
550			`return addr;`
551			`}`
552
553			`static void`
554			`initialize_arch ()`
555			`{`
556			`return;`
557			`}`
558			`#endif`
559
560			`CORE_ADDR`
561			`register_addr (regno, blockend)`
562			`int regno;`
563			`CORE_ADDR blockend;`
564			`{`
565			`CORE_ADDR addr;`
566
567			`if (regno < 0 \|\| regno >= ARCH_NUM_REGS)`
568			`error ("Invalid register number %d.", regno);`
569
570			`REGISTER_U_ADDR (addr, blockend, regno);`
571
572			`return addr;`
573			`}`
574
575			`/* Fetch one register. */`
576
577			`static void`
578			`fetch_register (regno)`
579			`int regno;`
580			`{`
581			`CORE_ADDR regaddr;`
582			`register int i;`
583
584			`/* Offset of registers within the u area. */`
585			`unsigned int offset;`
586
587			`offset = U_REGS_OFFSET;`
588
589			`regaddr = register_addr (regno, offset);`
590			`for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))`
591			`{`
592			`errno = 0;`
593			`(PTRACE_XFER_TYPE ) &registers[REGISTER_BYTE (regno) + i] =`
594			`ptrace (PTRACE_PEEKUSER, inferior_pid, (PTRACE_ARG3_TYPE) regaddr, 0);`
595			`regaddr += sizeof (PTRACE_XFER_TYPE);`
596			`if (errno != 0)`
597			`{`
598			`/* Warning, not error, in case we are attached; sometimes the`
599			`kernel doesn't let us at the registers. */`
600			`char *err = strerror (errno);`
601			`char *msg = alloca (strlen (err) + 128);`
602			`sprintf (msg, "reading register %d: %s", regno, err);`
603			`error (msg);`
604			`goto error_exit;`
605			`}`
606			`}`
607			`error_exit:;`
608			`}`
609
610			`/* Fetch all registers, or just one, from the child process. */`
611
612			`void`
613			`fetch_inferior_registers (regno)`
614			`int regno;`
615			`{`
616			`if (regno == -1 \|\| regno == 0)`
617			`for (regno = 0; regno < NUM_REGS - NUM_FREGS; regno++)`
618			`fetch_register (regno);`
619			`else`
620			`fetch_register (regno);`
621			`}`
622
623			`/* Store our register values back into the inferior.`
624			`If REGNO is -1, do this for all registers.`
625			`Otherwise, REGNO specifies which register (so we can save time). */`
626
627			`void`
628			`store_inferior_registers (regno)`
629			`int regno;`
630			`{`
631			`CORE_ADDR regaddr;`
632			`int i;`
633			`unsigned int offset = U_REGS_OFFSET;`
634
635			`if (regno >= 0)`
636			`{`
637			`#if 0`
638			`if (CANNOT_STORE_REGISTER (regno))`
639			`return;`
640			`#endif`
641			`regaddr = register_addr (regno, offset);`
642			`errno = 0;`
643			`#if 0`
644			`if (regno == PCOQ_HEAD_REGNUM \|\| regno == PCOQ_TAIL_REGNUM)`
645			`{`
646			`scratch = (int ) &registers[REGISTER_BYTE (regno)] \| 0x3;`
647			`ptrace (PT_WUREGS, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,`
648			`scratch, 0);`
649			`if (errno != 0)`
650			`{`
651			`/* Error, even if attached. Failing to write these two`
652			`registers is pretty serious. */`
653			`sprintf (buf, "writing register number %d", regno);`
654			`perror_with_name (buf);`
655			`}`
656			`}`
657			`else`
658			`#endif`
659			`for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))`
660			`{`
661			`errno = 0;`
662			`ptrace (PTRACE_POKEUSER, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,`
663			`(int ) &registers[REGISTER_BYTE (regno) + i]);`
664			`if (errno != 0)`
665			`{`
666			`/* Warning, not error, in case we are attached; sometimes the`
667			`kernel doesn't let us at the registers. */`
668			`char *err = strerror (errno);`
669			`char *msg = alloca (strlen (err) + 128);`
670			`sprintf (msg, "writing register %d: %s",`
671			`regno, err);`
672			`error (msg);`
673			`return;`
674			`}`
675			`regaddr += sizeof (int);`
676			`}`
677			`}`
678			`else`
679			`for (regno = 0; regno < NUM_REGS - NUM_FREGS; regno++)`
680			`store_inferior_registers (regno);`
681			`}`
682
683			`/* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory`
684			`in the NEW_SUN_PTRACE case.`
685			`It ought to be straightforward. But it appears that writing did`
686			`not write the data that I specified. I cannot understand where`
687			`it got the data that it actually did write. */`
688
689			`/* Copy LEN bytes from inferior's memory starting at MEMADDR`
690			`to debugger memory starting at MYADDR. */`
691
692			`void`
693			`read_inferior_memory (memaddr, myaddr, len)`
694			`CORE_ADDR memaddr;`
695			`char *myaddr;`
696			`int len;`
697			`{`
698			`register int i;`
699			`/* Round starting address down to longword boundary. */`
700			`register CORE_ADDR addr = memaddr & -sizeof (PTRACE_XFER_TYPE);`
701			`/* Round ending address up; get number of longwords that makes. */`
702			`register int count`
703			`= (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)`
704			`/ sizeof (PTRACE_XFER_TYPE);`
705			`/* Allocate buffer of that many longwords. */`
706			`register PTRACE_XFER_TYPE *buffer`
707			`= (PTRACE_XFER_TYPE ) alloca (count sizeof (PTRACE_XFER_TYPE));`
708
709			`/* Read all the longwords */`
710			`for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))`
711			`{`
712			`buffer[i] = ptrace (PTRACE_PEEKTEXT, inferior_pid, addr, 0);`
713			`}`
714
715			`/* Copy appropriate bytes out of the buffer. */`
716			`memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), len);`
717			`}`
718
719			`/* Copy LEN bytes of data from debugger memory at MYADDR`
720			`to inferior's memory at MEMADDR.`
721			`On failure (cannot write the inferior)`
722			`returns the value of errno. */`
723
724			`int`
725			`write_inferior_memory (memaddr, myaddr, len)`
726			`CORE_ADDR memaddr;`
727			`char *myaddr;`
728			`int len;`
729			`{`
730			`register int i;`
731			`/* Round starting address down to longword boundary. */`
732			`register CORE_ADDR addr = memaddr & -sizeof (PTRACE_XFER_TYPE);`
733			`/* Round ending address up; get number of longwords that makes. */`
734			`register int count`
735			`= (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1) / sizeof (PTRACE_XFER_TYPE);`
736			`/* Allocate buffer of that many longwords. */`
737			`register PTRACE_XFER_TYPE buffer = (PTRACE_XFER_TYPE ) alloca (count * sizeof (PTRACE_XFER_TYPE));`
738			`extern int errno;`
739
740			`/* Fill start and end extra bytes of buffer with existing memory data. */`
741
742			`buffer[0] = ptrace (PTRACE_PEEKTEXT, inferior_pid, addr, 0);`
743
744			`if (count > 1)`
745			`{`
746			`buffer[count - 1]`
747			`= ptrace (PTRACE_PEEKTEXT, inferior_pid,`
748			`addr + (count - 1) * sizeof (PTRACE_XFER_TYPE), 0);`
749			`}`
750
751			`/* Copy data to be written over corresponding part of buffer */`
752
753			`memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), myaddr, len);`
754
755			`/* Write the entire buffer. */`
756
757			`for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))`
758			`{`
759			`errno = 0;`
760			`ptrace (PTRACE_POKETEXT, inferior_pid, addr, buffer[i]);`
761			`if (errno)`
762			`return errno;`
763			`}`
764
765			`return 0;`
766			`}`
767
768			`void`
769			`initialize_low ()`
770			`{`
771			`initialize_arch ();`
772			`}`