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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [gdbserver/] [low-hppabsd.c] - Diff between revs 107 and 1765

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 107 Rev 1765
/* Low level interface to ptrace, for the remote server for GDB.
/* Low level interface to ptrace, for the remote server for GDB.
   Copyright (C) 1995 Free Software Foundation, Inc.
   Copyright (C) 1995 Free Software Foundation, Inc.
 
 
   This file is part of GDB.
   This file is part of GDB.
 
 
   This program is free software; you can redistribute it and/or modify
   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
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   (at your option) any later version.
 
 
   This program is distributed in the hope that it will be useful,
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   GNU General Public License for more details.
 
 
   You should have received a copy of the GNU General Public License
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */
   Boston, MA 02111-1307, USA.  */
 
 
#include "defs.h"
#include "defs.h"
#include <sys/wait.h>
#include <sys/wait.h>
#include "frame.h"
#include "frame.h"
#include "inferior.h"
#include "inferior.h"
 
 
#include <stdio.h>
#include <stdio.h>
#include <sys/param.h>
#include <sys/param.h>
#include <sys/dir.h>
#include <sys/dir.h>
#include <sys/user.h>
#include <sys/user.h>
#include <signal.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <sys/ioctl.h>
#include <sgtty.h>
#include <sgtty.h>
#include <fcntl.h>
#include <fcntl.h>
 
 
/***************Begin MY defs*********************/
/***************Begin MY defs*********************/
int quit_flag = 0;
int quit_flag = 0;
static char my_registers[REGISTER_BYTES];
static char my_registers[REGISTER_BYTES];
char *registers = my_registers;
char *registers = my_registers;
 
 
/* Index within `registers' of the first byte of the space for
/* Index within `registers' of the first byte of the space for
   register N.  */
   register N.  */
 
 
 
 
char buf2[MAX_REGISTER_RAW_SIZE];
char buf2[MAX_REGISTER_RAW_SIZE];
/***************End MY defs*********************/
/***************End MY defs*********************/
 
 
#include <sys/ptrace.h>
#include <sys/ptrace.h>
#include <machine/reg.h>
#include <machine/reg.h>
 
 
extern char **environ;
extern char **environ;
extern int errno;
extern int errno;
extern int inferior_pid;
extern int inferior_pid;
void quit (), perror_with_name ();
void quit (), perror_with_name ();
int query ();
int query ();
 
 
/* Start an inferior process and returns its pid.
/* Start an inferior process and returns its pid.
   ALLARGS is a vector of program-name and args.
   ALLARGS is a vector of program-name and args.
   ENV is the environment vector to pass.  */
   ENV is the environment vector to pass.  */
 
 
int
int
create_inferior (program, allargs)
create_inferior (program, allargs)
     char *program;
     char *program;
     char **allargs;
     char **allargs;
{
{
  int pid;
  int pid;
 
 
  pid = fork ();
  pid = fork ();
  if (pid < 0)
  if (pid < 0)
    perror_with_name ("fork");
    perror_with_name ("fork");
 
 
  if (pid == 0)
  if (pid == 0)
    {
    {
      ptrace (PT_TRACE_ME, 0, 0, 0, 0);
      ptrace (PT_TRACE_ME, 0, 0, 0, 0);
 
 
      execv (program, allargs);
      execv (program, allargs);
 
 
      fprintf (stderr, "Cannot exec %s: %s.\n", program,
      fprintf (stderr, "Cannot exec %s: %s.\n", program,
               errno < sys_nerr ? sys_errlist[errno] : "unknown error");
               errno < sys_nerr ? sys_errlist[errno] : "unknown error");
      fflush (stderr);
      fflush (stderr);
      _exit (0177);
      _exit (0177);
    }
    }
 
 
  return pid;
  return pid;
}
}
 
 
/* Kill the inferior process.  Make us have no inferior.  */
/* Kill the inferior process.  Make us have no inferior.  */
 
 
void
void
kill_inferior ()
kill_inferior ()
{
{
  if (inferior_pid == 0)
  if (inferior_pid == 0)
    return;
    return;
  ptrace (8, inferior_pid, 0, 0, 0);
  ptrace (8, inferior_pid, 0, 0, 0);
  wait (0);
  wait (0);
/*************inferior_died ();****VK**************/
/*************inferior_died ();****VK**************/
}
}
 
 
/* Return nonzero if the given thread is still alive.  */
/* Return nonzero if the given thread is still alive.  */
int
int
mythread_alive (pid)
mythread_alive (pid)
     int pid;
     int pid;
{
{
  return 1;
  return 1;
}
}
 
 
/* Wait for process, returns status */
/* Wait for process, returns status */
 
 
unsigned char
unsigned char
mywait (status)
mywait (status)
     char *status;
     char *status;
{
{
  int pid;
  int pid;
  union wait w;
  union wait w;
 
 
  pid = wait (&w);
  pid = wait (&w);
  if (pid != inferior_pid)
  if (pid != inferior_pid)
    perror_with_name ("wait");
    perror_with_name ("wait");
 
 
  if (WIFEXITED (w))
  if (WIFEXITED (w))
    {
    {
      fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
      fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
      *status = 'W';
      *status = 'W';
      return ((unsigned char) WEXITSTATUS (w));
      return ((unsigned char) WEXITSTATUS (w));
    }
    }
  else if (!WIFSTOPPED (w))
  else if (!WIFSTOPPED (w))
    {
    {
      fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
      fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
      *status = 'X';
      *status = 'X';
      return ((unsigned char) WTERMSIG (w));
      return ((unsigned char) WTERMSIG (w));
    }
    }
 
 
  fetch_inferior_registers (0);
  fetch_inferior_registers (0);
 
 
  *status = 'T';
  *status = 'T';
  return ((unsigned char) WSTOPSIG (w));
  return ((unsigned char) WSTOPSIG (w));
}
}
 
 
/* Resume execution of the inferior process.
/* Resume execution of the inferior process.
   If STEP is nonzero, single-step it.
   If STEP is nonzero, single-step it.
   If SIGNAL is nonzero, give it that signal.  */
   If SIGNAL is nonzero, give it that signal.  */
 
 
void
void
myresume (step, signal)
myresume (step, signal)
     int step;
     int step;
     int signal;
     int signal;
{
{
  errno = 0;
  errno = 0;
  ptrace (step ? PT_STEP : PT_CONTINUE, inferior_pid, 1, signal, 0);
  ptrace (step ? PT_STEP : PT_CONTINUE, inferior_pid, 1, signal, 0);
  if (errno)
  if (errno)
    perror_with_name ("ptrace");
    perror_with_name ("ptrace");
}
}
 
 
 
 
#if !defined (offsetof)
#if !defined (offsetof)
#define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
#define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
#endif
#endif
 
 
/* U_REGS_OFFSET is the offset of the registers within the u area.  */
/* U_REGS_OFFSET is the offset of the registers within the u area.  */
#if !defined (U_REGS_OFFSET)
#if !defined (U_REGS_OFFSET)
#define U_REGS_OFFSET \
#define U_REGS_OFFSET \
  ptrace (PT_READ_U, inferior_pid, \
  ptrace (PT_READ_U, inferior_pid, \
          (PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \
          (PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \
    - KERNEL_U_ADDR
    - KERNEL_U_ADDR
#endif
#endif
 
 
CORE_ADDR
CORE_ADDR
register_addr (regno, blockend)
register_addr (regno, blockend)
     int regno;
     int regno;
     CORE_ADDR blockend;
     CORE_ADDR blockend;
{
{
  CORE_ADDR addr;
  CORE_ADDR addr;
 
 
  if (regno < 0 || regno >= ARCH_NUM_REGS)
  if (regno < 0 || regno >= ARCH_NUM_REGS)
    error ("Invalid register number %d.", regno);
    error ("Invalid register number %d.", regno);
 
 
  REGISTER_U_ADDR (addr, blockend, regno);
  REGISTER_U_ADDR (addr, blockend, regno);
 
 
  return addr;
  return addr;
}
}
 
 
/* Fetch one register.  */
/* Fetch one register.  */
 
 
static void
static void
fetch_register (regno)
fetch_register (regno)
     int regno;
     int regno;
{
{
  register unsigned int regaddr;
  register unsigned int regaddr;
  char buf[MAX_REGISTER_RAW_SIZE];
  char buf[MAX_REGISTER_RAW_SIZE];
  register int i;
  register int i;
 
 
  /* Offset of registers within the u area.  */
  /* Offset of registers within the u area.  */
  unsigned int offset;
  unsigned int offset;
 
 
  offset = U_REGS_OFFSET;
  offset = U_REGS_OFFSET;
 
 
  regaddr = register_addr (regno, offset);
  regaddr = register_addr (regno, offset);
  for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
  for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
    {
    {
      errno = 0;
      errno = 0;
      *(int *) &registers[regno * 4 + i] = ptrace (PT_RUREGS, inferior_pid,
      *(int *) &registers[regno * 4 + i] = ptrace (PT_RUREGS, inferior_pid,
                                          (PTRACE_ARG3_TYPE) regaddr, 0, 0);
                                          (PTRACE_ARG3_TYPE) regaddr, 0, 0);
      regaddr += sizeof (int);
      regaddr += sizeof (int);
      if (errno != 0)
      if (errno != 0)
        {
        {
          /* Warning, not error, in case we are attached; sometimes the
          /* Warning, not error, in case we are attached; sometimes the
             kernel doesn't let us at the registers.  */
             kernel doesn't let us at the registers.  */
          char *err = strerror (errno);
          char *err = strerror (errno);
          char *msg = alloca (strlen (err) + 128);
          char *msg = alloca (strlen (err) + 128);
          sprintf (msg, "reading register %d: %s", regno, err);
          sprintf (msg, "reading register %d: %s", regno, err);
          error (msg);
          error (msg);
          goto error_exit;
          goto error_exit;
        }
        }
    }
    }
error_exit:;
error_exit:;
}
}
 
 
/* Fetch all registers, or just one, from the child process.  */
/* Fetch all registers, or just one, from the child process.  */
 
 
void
void
fetch_inferior_registers (regno)
fetch_inferior_registers (regno)
     int regno;
     int regno;
{
{
  if (regno == -1 || regno == 0)
  if (regno == -1 || regno == 0)
    for (regno = 0; regno < NUM_REGS; regno++)
    for (regno = 0; regno < NUM_REGS; regno++)
      fetch_register (regno);
      fetch_register (regno);
  else
  else
    fetch_register (regno);
    fetch_register (regno);
}
}
 
 
/* Store our register values back into the inferior.
/* Store our register values back into the inferior.
   If REGNO is -1, do this for all registers.
   If REGNO is -1, do this for all registers.
   Otherwise, REGNO specifies which register (so we can save time).  */
   Otherwise, REGNO specifies which register (so we can save time).  */
 
 
void
void
store_inferior_registers (regno)
store_inferior_registers (regno)
     int regno;
     int regno;
{
{
  register unsigned int regaddr;
  register unsigned int regaddr;
  char buf[80];
  char buf[80];
  extern char registers[];
  extern char registers[];
  register int i;
  register int i;
  unsigned int offset = U_REGS_OFFSET;
  unsigned int offset = U_REGS_OFFSET;
  int scratch;
  int scratch;
 
 
  if (regno >= 0)
  if (regno >= 0)
    {
    {
      if (CANNOT_STORE_REGISTER (regno))
      if (CANNOT_STORE_REGISTER (regno))
        return;
        return;
      regaddr = register_addr (regno, offset);
      regaddr = register_addr (regno, offset);
      errno = 0;
      errno = 0;
      if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM)
      if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM)
        {
        {
          scratch = *(int *) &registers[REGISTER_BYTE (regno)] | 0x3;
          scratch = *(int *) &registers[REGISTER_BYTE (regno)] | 0x3;
          ptrace (PT_WUREGS, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
          ptrace (PT_WUREGS, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
                  scratch, 0);
                  scratch, 0);
          if (errno != 0)
          if (errno != 0)
            {
            {
              /* Error, even if attached.  Failing to write these two
              /* Error, even if attached.  Failing to write these two
                 registers is pretty serious.  */
                 registers is pretty serious.  */
              sprintf (buf, "writing register number %d", regno);
              sprintf (buf, "writing register number %d", regno);
              perror_with_name (buf);
              perror_with_name (buf);
            }
            }
        }
        }
      else
      else
        for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
        for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
          {
          {
            errno = 0;
            errno = 0;
            ptrace (PT_WUREGS, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
            ptrace (PT_WUREGS, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
                    *(int *) &registers[REGISTER_BYTE (regno) + i], 0);
                    *(int *) &registers[REGISTER_BYTE (regno) + i], 0);
            if (errno != 0)
            if (errno != 0)
              {
              {
                /* Warning, not error, in case we are attached; sometimes the
                /* Warning, not error, in case we are attached; sometimes the
                   kernel doesn't let us at the registers.  */
                   kernel doesn't let us at the registers.  */
                char *err = strerror (errno);
                char *err = strerror (errno);
                char *msg = alloca (strlen (err) + 128);
                char *msg = alloca (strlen (err) + 128);
                sprintf (msg, "writing register %d: %s",
                sprintf (msg, "writing register %d: %s",
                         regno, err);
                         regno, err);
                error (msg);
                error (msg);
                return;
                return;
              }
              }
            regaddr += sizeof (int);
            regaddr += sizeof (int);
          }
          }
    }
    }
  else
  else
    for (regno = 0; regno < NUM_REGS; regno++)
    for (regno = 0; regno < NUM_REGS; regno++)
      store_inferior_registers (regno);
      store_inferior_registers (regno);
}
}
 
 
/* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
/* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
   in the NEW_SUN_PTRACE case.
   in the NEW_SUN_PTRACE case.
   It ought to be straightforward.  But it appears that writing did
   It ought to be straightforward.  But it appears that writing did
   not write the data that I specified.  I cannot understand where
   not write the data that I specified.  I cannot understand where
   it got the data that it actually did write.  */
   it got the data that it actually did write.  */
 
 
/* Copy LEN bytes from inferior's memory starting at MEMADDR
/* Copy LEN bytes from inferior's memory starting at MEMADDR
   to debugger memory starting at MYADDR.  */
   to debugger memory starting at MYADDR.  */
 
 
read_inferior_memory (memaddr, myaddr, len)
read_inferior_memory (memaddr, myaddr, len)
     CORE_ADDR memaddr;
     CORE_ADDR memaddr;
     char *myaddr;
     char *myaddr;
     int len;
     int len;
{
{
  register int i;
  register int i;
  /* Round starting address down to longword boundary.  */
  /* Round starting address down to longword boundary.  */
  register CORE_ADDR addr = memaddr & -sizeof (int);
  register CORE_ADDR addr = memaddr & -sizeof (int);
  /* Round ending address up; get number of longwords that makes.  */
  /* Round ending address up; get number of longwords that makes.  */
  register int count
  register int count
  = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
  = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
  /* Allocate buffer of that many longwords.  */
  /* Allocate buffer of that many longwords.  */
  register int *buffer = (int *) alloca (count * sizeof (int));
  register int *buffer = (int *) alloca (count * sizeof (int));
 
 
  /* Read all the longwords */
  /* Read all the longwords */
  for (i = 0; i < count; i++, addr += sizeof (int))
  for (i = 0; i < count; i++, addr += sizeof (int))
    {
    {
      buffer[i] = ptrace (1, inferior_pid, addr, 0, 0);
      buffer[i] = ptrace (1, inferior_pid, addr, 0, 0);
    }
    }
 
 
  /* Copy appropriate bytes out of the buffer.  */
  /* Copy appropriate bytes out of the buffer.  */
  memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
  memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
}
}
 
 
/* Copy LEN bytes of data from debugger memory at MYADDR
/* Copy LEN bytes of data from debugger memory at MYADDR
   to inferior's memory at MEMADDR.
   to inferior's memory at MEMADDR.
   On failure (cannot write the inferior)
   On failure (cannot write the inferior)
   returns the value of errno.  */
   returns the value of errno.  */
 
 
int
int
write_inferior_memory (memaddr, myaddr, len)
write_inferior_memory (memaddr, myaddr, len)
     CORE_ADDR memaddr;
     CORE_ADDR memaddr;
     char *myaddr;
     char *myaddr;
     int len;
     int len;
{
{
  register int i;
  register int i;
  /* Round starting address down to longword boundary.  */
  /* Round starting address down to longword boundary.  */
  register CORE_ADDR addr = memaddr & -sizeof (int);
  register CORE_ADDR addr = memaddr & -sizeof (int);
  /* Round ending address up; get number of longwords that makes.  */
  /* Round ending address up; get number of longwords that makes.  */
  register int count
  register int count
  = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
  = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
  /* Allocate buffer of that many longwords.  */
  /* Allocate buffer of that many longwords.  */
  register int *buffer = (int *) alloca (count * sizeof (int));
  register int *buffer = (int *) alloca (count * sizeof (int));
  extern int errno;
  extern int errno;
 
 
  /* Fill start and end extra bytes of buffer with existing memory data.  */
  /* Fill start and end extra bytes of buffer with existing memory data.  */
 
 
  buffer[0] = ptrace (1, inferior_pid, addr, 0, 0);
  buffer[0] = ptrace (1, inferior_pid, addr, 0, 0);
 
 
  if (count > 1)
  if (count > 1)
    {
    {
      buffer[count - 1]
      buffer[count - 1]
        = ptrace (1, inferior_pid,
        = ptrace (1, inferior_pid,
                  addr + (count - 1) * sizeof (int), 0, 0);
                  addr + (count - 1) * sizeof (int), 0, 0);
    }
    }
 
 
  /* Copy data to be written over corresponding part of buffer */
  /* Copy data to be written over corresponding part of buffer */
 
 
  memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
  memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
 
 
  /* Write the entire buffer.  */
  /* Write the entire buffer.  */
 
 
  for (i = 0; i < count; i++, addr += sizeof (int))
  for (i = 0; i < count; i++, addr += sizeof (int))
    {
    {
      errno = 0;
      errno = 0;
      ptrace (4, inferior_pid, addr, buffer[i], 0);
      ptrace (4, inferior_pid, addr, buffer[i], 0);
      if (errno)
      if (errno)
        return errno;
        return errno;
    }
    }
 
 
  return 0;
  return 0;
}
}


void
void
initialize_low ()
initialize_low ()
{
{
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.