darlinghq/darling-gdb
1
0
Fork 0
mirror of https://github.com/darlinghq/darling-gdb.git synced 2025-02-03 15:42:52 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

From Wilfried Moser <wilfried.moser@aut.alcatel.at>:

Browse Source 
* gdbserver/low-linux.c: New file.
	* remote.c (remote_read_bytes): Fix aborts on larger packets.

	* config/i386/linux.mh (GDBSERVER_DEPFILES, GDBSERVER_LIBS):
	Define.
	* stabsread.c (define_symbol): If register value is too large,
	tell what it is and what max is.
This commit is contained in:
Fred Fish 1996-01-10 18:40:24 +00:00
parent 367c2d2aef
commit 0d14c7df68
5 changed files with 493 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
gdb/ChangeLog
View File

@ -1,3 +1,14 @@
Wed Jan 10 11:25:37 1996 Fred Fish <fnf@fishpond.amigalib.com>
From Wilfried Moser <wilfried.moser@aut.alcatel.at>:
* gdbserver/low-linux.c: New file.
* remote.c (remote_read_bytes): Fix aborts on larger packets.
* config/i386/linux.mh (GDBSERVER_DEPFILES, GDBSERVER_LIBS):
Define.
* stabsread.c (define_symbol): If register value is too large,
tell what it is and what max is.
Tue Jan 9 09:33:53 1996 Jeffrey A Law (law@cygnus.com)
* hpread.c (hpread_build_psymtabs): Finish Jan 4th

24
gdb/config/i386/linux.mh
View File

@ -1,14 +1,14 @@
# Host: Intel 386 running System V
XDEPFILES=
# Host: Intel 386 running Linux
XM_FILE= xm-linux.h
XDEPFILES= ser-tcp.o
# Needed for frexp() in libiberty.
XM_CLIBS= -lm
NAT_FILE= nm-linux.h
# corelow.o commented out because core dumps are broken as of GDB 4.9.
# According to eichin@cygnus.com, the GDB which ships with linux (not sure
# which linux distribution) can read a linux core dump. It's numbered 4.8,
# but I don't know whether it's vanilla 4.8 or modified.
NATDEPFILES= exec.o infptrace.o inftarg.o fork-child.o coredep.o i386v-nat.o
XM_CLIBS=
TERMLIB=
SYSV_DEFINE=-DSYSV
REGEX=regex.o
REGEX1=regex.o
NATDEPFILES= infptrace.o inftarg.o fork-child.o coredep.o i386v-nat.o corelow.o
GDBSERVER_DEPFILES= low-linux.o
# Requires libbsd.a for bsd_ioctl, which is how ioctl is implemented.
GDBSERVER_LIBS= -lbsd

421
gdb/gdbserver/low-linux.c Normal file
View File

@ -0,0 +1,421 @@
/* 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/user.h>
#include <signal.h>
#include <sys/ioctl.h>
#if 0
#include <sgtty.h>
#endif
#include <fcntl.h>
/***************Begin MY defs*********************/
int quit_flag = 0;
char registers[REGISTER_BYTES];
/* Index within `registers' of the first byte of the space for
register N. */
char buf2[MAX_REGISTER_RAW_SIZE];
/***************End MY defs*********************/
#include <sys/ptrace.h>
#if 0
#include <machine/reg.h>
#endif
extern char **environ;
extern int errno;
extern int inferior_pid;
void quit (), perror_with_name ();
int query ();
/* 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
/* 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]);
}
unsigned int
register_addr (regno, blockend)
int regno;
int blockend;
{
int 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;
{
register unsigned int regaddr;
char buf[MAX_REGISTER_RAW_SIZE];
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 (int))
{
errno = 0;
*(int *) &registers[ regno * 4 + i] = ptrace (PTRACE_PEEKUSR, inferior_pid,
(PTRACE_ARG3_TYPE) regaddr, 0);
regaddr += sizeof (int);
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;
{
register unsigned int regaddr;
char buf[80];
extern char registers[];
register int i;
unsigned int offset = U_REGS_OFFSET;
int scratch;
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_POKEUSR, 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. */
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 (int);
/* Round ending address up; get number of longwords that makes. */
register int count
= (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
/* Allocate buffer of that many longwords. */
register int *buffer = (int *) alloca (count * sizeof (int));
/* Read all the longwords */
for (i = 0; i < count; i++, addr += sizeof (int))
{
buffer[i] = ptrace (PTRACE_PEEKTEXT, inferior_pid, addr, 0);
}
/* Copy appropriate bytes out of the buffer. */
memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 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 (int);
/* Round ending address up; get number of longwords that makes. */
register int count
= (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
/* Allocate buffer of that many longwords. */
register int *buffer = (int *) alloca (count * sizeof (int));
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 (int), 0);
}
/* Copy data to be written over corresponding part of buffer */
memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
/* Write the entire buffer. */
for (i = 0; i < count; i++, addr += sizeof (int))
{
errno = 0;
ptrace (PTRACE_POKETEXT, inferior_pid, addr, buffer[i]);
if (errno)
return errno;
}
return 0;
}
void
initialize ()
{
inferior_pid = 0;
}
int
have_inferior_p ()
{
return inferior_pid != 0;
}

74
gdb/remote.c
View File

@ -1,5 +1,5 @@
/* Remote target communications for serial-line targets in custom GDB protocol
Copyright 1988, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
Copyright 1988, 1991, 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
This file is part of GDB.
@ -182,7 +182,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include "symfile.h"
#include "target.h"
#include "wait.h"
#include "terminal.h"
/*#include "terminal.h"*/
#include "gdbcmd.h"
#include "objfiles.h"
#include "gdb-stabs.h"
@ -741,7 +741,6 @@ remote_wait (pid, status)
{
unsigned char *p1;
char *p_temp;
unsigned LONGEST val;
regno = strtol ((const char *) p, &p_temp, 16); /* Read the register number */
p1 = (unsigned char *)p_temp;
@ -773,16 +772,13 @@ Packet: '%s'\n",
Packet: '%s'\n",
regno, p, buf);
val = 0L;
for (i = 0; i < REGISTER_RAW_SIZE (regno); i++)
{
if (p[0] == 0 || p[1] == 0)
warning ("Remote reply is too short: %s", buf);
val = val * 256 + fromhex (p[0]) * 16 + fromhex (p[1]);
regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
p += 2;
}
store_unsigned_integer (regs, REGISTER_RAW_SIZE (regno), val);
supply_register (regno, regs);
}
@ -1112,40 +1108,54 @@ remote_read_bytes (memaddr, myaddr, len)
char buf[PBUFSIZ];
int i;
char *p;
int done;
/* Chop transfer down if neccessary */
#if 0
/* FIXME: This is wrong for larger packets */
if (len > PBUFSIZ / 2 - 1)
abort ();
/* FIXME-32x64: Need a version of print_address_numeric which puts the
result in a buffer like sprintf. */
sprintf (buf, "m%lx,%x", (unsigned long) memaddr, len);
putpkt (buf);
getpkt (buf, 0);
if (buf[0] == 'E')
#endif
done = 0;
while (done < len)
{
/* There is no correspondance between what the remote protocol uses
for errors and errno codes. We would like a cleaner way of
representing errors (big enough to include errno codes, bfd_error
codes, and others). But for now just return EIO. */
errno = EIO;
return 0;
}
int todo = len - done;
int cando = PBUFSIZ / 2 - 32; /* number of bytes that will fit. */
if (todo > cando)
todo = cando;
/* FIXME-32x64: Need a version of print_address_numeric which puts the
result in a buffer like sprintf. */
sprintf (buf, "m%lx,%x", (unsigned long) memaddr, todo);
putpkt (buf);
getpkt (buf, 0);
if (buf[0] == 'E')
{
/* There is no correspondance between what the remote protocol uses
for errors and errno codes. We would like a cleaner way of
representing errors (big enough to include errno codes, bfd_error
codes, and others). But for now just return EIO. */
errno = EIO;
return 0;
}
/* Reply describes memory byte by byte,
each byte encoded as two hex characters. */
p = buf;
for (i = 0; i < len; i++)
{
if (p[0] == 0 || p[1] == 0)
/* Reply is short. This means that we were able to read only part
of what we wanted to. */
break;
myaddr[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
p += 2;
p = buf;
for (i = 0; i < todo; i++)
{
if (p[0] == 0 || p[1] == 0)
/* Reply is short. This means that we were able to read only part
of what we wanted to. */
break;
myaddr[i + done] = fromhex (p[0]) * 16 + fromhex (p[1]);
p += 2;
}
done += todo;
}
return i;
return len;
}
/* Read or write LEN bytes from inferior memory at MEMADDR, transferring

11
gdb/stabsread.c
View File

@ -177,7 +177,7 @@ struct complaint range_type_base_complaint =
{"base type %d of range type is not defined", 0, 0};
struct complaint reg_value_complaint =
{"register number too large in symbol %s", 0, 0};
{"register number %d too large (max %d) in symbol %s", 0, 0};
struct complaint vtbl_notfound_complaint =
{"virtual function table pointer not found when defining class `%s'", 0, 0};
@ -955,7 +955,8 @@ define_symbol (valu, string, desc, type, objfile)
SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu);
if (SYMBOL_VALUE (sym) >= NUM_REGS)
{
complain (&reg_value_complaint, SYMBOL_SOURCE_NAME (sym));
complain (&reg_value_complaint, SYMBOL_VALUE (sym), NUM_REGS,
SYMBOL_SOURCE_NAME (sym));
SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */
}
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
@ -969,7 +970,8 @@ define_symbol (valu, string, desc, type, objfile)
SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu);
if (SYMBOL_VALUE (sym) >= NUM_REGS)
{
complain (&reg_value_complaint, SYMBOL_SOURCE_NAME (sym));
complain (&reg_value_complaint, SYMBOL_VALUE (sym), NUM_REGS,
SYMBOL_SOURCE_NAME (sym));
SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */
}
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
@ -1191,7 +1193,8 @@ define_symbol (valu, string, desc, type, objfile)
SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu);
if (SYMBOL_VALUE (sym) >= NUM_REGS)
{
complain (&reg_value_complaint, SYMBOL_SOURCE_NAME (sym));
complain (&reg_value_complaint, SYMBOL_VALUE (sym), NUM_REGS,
SYMBOL_SOURCE_NAME (sym));
SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */
}
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;