Changes to support alpha OSF/1 in native mode.
* alpha-nat.c, alpha-tdep.c, config/alpha/alpha-osf1.mt, config/alpha/nm-alpha.h, config/alpha/tm-alpha.h, osfsolib.c: New files. * Makefile.in: Add new files and dependencies. * configure.in: Add alpha target. * config/alpha/alpha-osf1.mh (NATDEPFILES): Add osfsolib.o * config/alpha/alpha-osf1.mh (MH_CFLAGS): Remove, we can handle shared libraries now. * config/alpha/xm-alpha.h: Cleanup, get MAKEVA_* defines right. * defs.h (CORE_ADDR): Make its type overridable via CORE_ADDR_TYPE, provide `unsigned int' default. * breakpoint.c (breakpoint_auto_delete): Delete only if we really stopped for the breakpoint. * stabsread.c, stabsread.h (define_symbol): Change valu parameter to a CORE_ADDR. * stabsread.c (read_range_type): Handle the case where the lower bound overflows and the upper doesn't and the range is legal. * infrun.c (resume): Do not step a breakpoint instruction if CANNOT_STEP_BREAKPOINT is defined. * inferior.h (CALL_DUMMY_LOCATION): New variant AT_ENTRY_POINT. Now that we have the bp_call_dummy breakpoint the call dummy code is no longer needed. PUSH_DUMMY_FRAME, PUSH_ARGUMENTS and FIX_CALL_DUMMY can be used to set up everything for the dummy. The breakpoint for the dummy is set at the entry point and thats it. * blockframe.c (inside_entry_file, inside_entry_func): Do not stop backtraces if pc is in the call dummy at the entry point. * infcmd.c (run_stack_dummy): Handle AT_ENTRY_POINT case. Use the expected breakpoint pc when setting up the frame for set_momentary_breakpoint. * symfile.c (entry_point_address): New function for AT_ENTRY_POINT support. * valops.c (call_function_by_hand): Handle AT_ENTRY_POINT case.
This commit is contained in:
Peter Schauer
parent
a72e983365
commit
cef4c2e7a5
|
|
@ -42,6 +42,8 @@ TODO
|
||||||
a29k-pinsn.c
|
a29k-pinsn.c
|
||||||
a29k-tdep.c
|
a29k-tdep.c
|
||||||
a68v-nat.c
|
a68v-nat.c
|
||||||
|
alpha-nat.c
|
||||||
|
alpha-tdep.c
|
||||||
altos-xdep.c
|
altos-xdep.c
|
||||||
arm-convert.s
|
arm-convert.s
|
||||||
arm-pinsn.c
|
arm-pinsn.c
|
||||||
|
|
@ -174,6 +176,7 @@ ns32k-opcode.h
|
||||||
ns32k-pinsn.c
|
ns32k-pinsn.c
|
||||||
objfiles.c
|
objfiles.c
|
||||||
objfiles.h
|
objfiles.h
|
||||||
|
osfsolib.c
|
||||||
paread.c
|
paread.c
|
||||||
parse.c
|
parse.c
|
||||||
parser-defs.h
|
parser-defs.h
|
||||||
|
|
|
||||||
|
|
@ -1,3 +1,43 @@
|
||||||
|
Tue Oct 5 12:17:40 1993 Peter Schauer (pes@regent.e-technik.tu-muenchen.de)
|
||||||
|
Jim Kingdon (kingdon@cygnus.com)
|
||||||
|
Stu Grossman (grossman@cygnus.com)
|
||||||
|
|
||||||
|
Changes to support alpha OSF/1 in native mode.
|
||||||
|
* alpha-nat.c, alpha-tdep.c, config/alpha/alpha-osf1.mt,
|
||||||
|
config/alpha/nm-alpha.h, config/alpha/tm-alpha.h, osfsolib.c:
|
||||||
|
New files.
|
||||||
|
* Makefile.in: Add new files and dependencies.
|
||||||
|
* configure.in: Add alpha target.
|
||||||
|
* config/alpha/alpha-osf1.mh (NATDEPFILES): Add osfsolib.o
|
||||||
|
* config/alpha/alpha-osf1.mh (MH_CFLAGS): Remove, we can handle
|
||||||
|
shared libraries now.
|
||||||
|
* config/alpha/xm-alpha.h: Cleanup, get MAKEVA_* defines right.
|
||||||
|
|
||||||
|
* defs.h (CORE_ADDR): Make its type overridable via CORE_ADDR_TYPE,
|
||||||
|
provide `unsigned int' default.
|
||||||
|
* breakpoint.c (breakpoint_auto_delete): Delete only if we really
|
||||||
|
stopped for the breakpoint.
|
||||||
|
* stabsread.c, stabsread.h (define_symbol): Change valu parameter
|
||||||
|
to a CORE_ADDR.
|
||||||
|
* stabsread.c (read_range_type): Handle the case where the lower
|
||||||
|
bound overflows and the upper doesn't and the range is legal.
|
||||||
|
* infrun.c (resume): Do not step a breakpoint instruction if
|
||||||
|
CANNOT_STEP_BREAKPOINT is defined.
|
||||||
|
|
||||||
|
* inferior.h (CALL_DUMMY_LOCATION): New variant AT_ENTRY_POINT.
|
||||||
|
Now that we have the bp_call_dummy breakpoint the call dummy code
|
||||||
|
is no longer needed. PUSH_DUMMY_FRAME, PUSH_ARGUMENTS and
|
||||||
|
FIX_CALL_DUMMY can be used to set up everything for the dummy.
|
||||||
|
The breakpoint for the dummy is set at the entry point and thats it.
|
||||||
|
* blockframe.c (inside_entry_file, inside_entry_func): Do not stop
|
||||||
|
backtraces if pc is in the call dummy at the entry point.
|
||||||
|
* infcmd.c (run_stack_dummy): Handle AT_ENTRY_POINT case. Use
|
||||||
|
the expected breakpoint pc when setting up the frame for
|
||||||
|
set_momentary_breakpoint.
|
||||||
|
* symfile.c (entry_point_address): New function for AT_ENTRY_POINT
|
||||||
|
support.
|
||||||
|
* valops.c (call_function_by_hand): Handle AT_ENTRY_POINT case.
|
||||||
|
|
||||||
Tue Oct 5 11:37:02 1993 Jim Kingdon (kingdon@lioth.cygnus.com)
|
Tue Oct 5 11:37:02 1993 Jim Kingdon (kingdon@lioth.cygnus.com)
|
||||||
|
|
||||||
* configure.in: Recognize hppa*-*-hiux* (currently synonym for hpux).
|
* configure.in: Recognize hppa*-*-hiux* (currently synonym for hpux).
|
||||||
|
|
|
||||||
|
|
@ -802,7 +802,8 @@ unexport CHILLFLAGS CHILL_LIB CHILL_FOR_TARGET :
|
||||||
# why they are separate from the lists of files above.
|
# why they are separate from the lists of files above.
|
||||||
|
|
||||||
ALLDEPFILES = 29k-share/udi/udip2soc.c 29k-share/udi/udr.c \
|
ALLDEPFILES = 29k-share/udi/udip2soc.c 29k-share/udi/udr.c \
|
||||||
a29k-pinsn.c a29k-tdep.c a68v-nat.c altos-xdep.c arm-convert.s \
|
a29k-pinsn.c a29k-tdep.c a68v-nat.c alpha-nat.c alpha-tdep.c \
|
||||||
|
altos-xdep.c arm-convert.s \
|
||||||
arm-pinsn.c arm-tdep.c arm-xdep.c coff-solib.c convex-pinsn.c \
|
arm-pinsn.c arm-tdep.c arm-xdep.c coff-solib.c convex-pinsn.c \
|
||||||
convex-tdep.c \
|
convex-tdep.c \
|
||||||
convex-xdep.c core-svr4.c coredep.c corelow.c dcache.c delta68-nat.c \
|
convex-xdep.c core-svr4.c coredep.c corelow.c dcache.c delta68-nat.c \
|
||||||
|
|
@ -810,13 +811,14 @@ ALLDEPFILES = 29k-share/udi/udip2soc.c 29k-share/udi/udr.c \
|
||||||
go32-xdep.c gould-pinsn.c gould-xdep.c h8300-tdep.c h8500-tdep.c \
|
go32-xdep.c gould-pinsn.c gould-xdep.c h8300-tdep.c h8500-tdep.c \
|
||||||
hp300ux-nat.c hppa-pinsn.c hppa-tdep.c hppab-nat.c hppah-nat.c \
|
hp300ux-nat.c hppa-pinsn.c hppa-tdep.c hppab-nat.c hppah-nat.c \
|
||||||
i386-pinsn.c i386-tdep.c i386b-nat.c i386mach-nat.c i386v-nat.c \
|
i386-pinsn.c i386-tdep.c i386b-nat.c i386mach-nat.c i386v-nat.c \
|
||||||
i386aix-nat.c i386v4-nat.c i386lynx-nat.c i386lynx-tdep.c i387-tdep.c \
|
i386aix-nat.c i386v4-nat.c i386lynx-nat.c i386ly-tdep.c i387-tdep.c \
|
||||||
i960-pinsn.c i960-tdep.c \
|
i960-pinsn.c i960-tdep.c \
|
||||||
infptrace.c inftarg.c irix4-nat.c isi-xdep.c m68k-pinsn.c m68k-tdep.c \
|
infptrace.c inftarg.c irix4-nat.c isi-xdep.c m68k-pinsn.c m68k-tdep.c \
|
||||||
m88k-nat.c m88k-pinsn.c m88k-tdep.c mips-nat.c mips-pinsn.c \
|
m88k-nat.c m88k-pinsn.c m88k-tdep.c mips-nat.c mips-pinsn.c \
|
||||||
mips-tdep.c news-xdep.c nindy-share/Onindy.c nindy-share/nindy.c \
|
mips-tdep.c news-xdep.c nindy-share/Onindy.c nindy-share/nindy.c \
|
||||||
nindy-share/ttyflush.c nindy-tdep.c \
|
nindy-share/ttyflush.c nindy-tdep.c \
|
||||||
ns32k-pinsn.c paread.c procfs.c pyr-pinsn.c pyr-tdep.c pyr-xdep.c \
|
ns32k-pinsn.c osfsolib.c \
|
||||||
|
paread.c procfs.c pyr-pinsn.c pyr-tdep.c pyr-xdep.c \
|
||||||
remote-adapt.c remote-bug.c remote-eb.c remote-es.c remote-hms.c remote-mips.c \
|
remote-adapt.c remote-bug.c remote-eb.c remote-es.c remote-hms.c remote-mips.c \
|
||||||
remote-mm.c remote-mon.c remote-nindy.c remote-sim.c \
|
remote-mm.c remote-mon.c remote-nindy.c remote-sim.c \
|
||||||
remote-st.c remote-utils.c dcache.c \
|
remote-st.c remote-utils.c dcache.c \
|
||||||
|
|
@ -829,6 +831,7 @@ ALLDEPFILES = 29k-share/udi/udip2soc.c 29k-share/udi/udr.c \
|
||||||
|
|
||||||
ALLPARAM = config/a29k/nm-ultra3.h config/a29k/tm-a29k.h \
|
ALLPARAM = config/a29k/nm-ultra3.h config/a29k/tm-a29k.h \
|
||||||
config/a29k/tm-ultra3.h config/a29k/xm-ultra3.h \
|
config/a29k/tm-ultra3.h config/a29k/xm-ultra3.h \
|
||||||
|
config/alpha/nm-alpha.h config/alpha/tm-alpha.h \
|
||||||
config/alpha/xm-alpha.h config/arm/tm-arm.h \
|
config/alpha/xm-alpha.h config/arm/tm-arm.h \
|
||||||
config/arm/xm-arm.h config/convex/tm-convex.h \
|
config/arm/xm-arm.h config/convex/tm-convex.h \
|
||||||
config/convex/xm-convex.h config/gould/tm-np1.h config/gould/tm-pn.h \
|
config/convex/xm-convex.h config/gould/tm-np1.h config/gould/tm-pn.h \
|
||||||
|
|
@ -897,7 +900,7 @@ ALLPARAM = config/a29k/nm-ultra3.h config/a29k/tm-a29k.h \
|
||||||
|
|
||||||
ALLCONFIG = config/a29k/a29k-kern.mt config/a29k/a29k-udi.mt \
|
ALLCONFIG = config/a29k/a29k-kern.mt config/a29k/a29k-udi.mt \
|
||||||
config/a29k/a29k.mt config/a29k/ultra3.mh config/a29k/ultra3.mt \
|
config/a29k/a29k.mt config/a29k/ultra3.mh config/a29k/ultra3.mt \
|
||||||
config/alpha/alpha-osf1.mh \
|
config/alpha/alpha-osf1.mh config/alpha/alpha-osf1.mt \
|
||||||
config/arm/arm.mh config/arm/arm.mt config/convex/convex.mh \
|
config/arm/arm.mh config/arm/arm.mt config/convex/convex.mh \
|
||||||
config/convex/convex.mt config/gould/np1.mh config/gould/np1.mt \
|
config/convex/convex.mt config/gould/np1.mh config/gould/np1.mt \
|
||||||
config/gould/pn.mh config/gould/pn.mt config/h8300/h8300hms.mt \
|
config/gould/pn.mh config/gould/pn.mt config/h8300/h8300hms.mt \
|
||||||
|
|
@ -956,6 +959,12 @@ udr.o: 29k-share/udi/udr.c $(udiheaders)
|
||||||
a29k-pinsn.o: a29k-pinsn.c $(bfd_h) $(dis-asm_h)
|
a29k-pinsn.o: a29k-pinsn.c $(bfd_h) $(dis-asm_h)
|
||||||
a29k-tdep.o: a29k-tdep.c $(gdbcmd_h) $(gdbcore_h) $(inferior_h) $(defs_h)
|
a29k-tdep.o: a29k-tdep.c $(gdbcmd_h) $(gdbcore_h) $(inferior_h) $(defs_h)
|
||||||
a68v-nat.o: a68v-nat.c $(defs_h) $(gdbcore_h) $(inferior_h)
|
a68v-nat.o: a68v-nat.c $(defs_h) $(gdbcore_h) $(inferior_h)
|
||||||
|
|
||||||
|
alpha-nat.o: alpha-nat.c $(defs_h) $(gdbcore_h) $(inferior_h) target.h
|
||||||
|
|
||||||
|
alpha-tdep.o: alpha-tdep.c $(defs_h) $(gdbcmd_h) $(gdbcore_h) \
|
||||||
|
$(inferior_h) $(symtab_h) $(dis-asm.h)
|
||||||
|
|
||||||
altos-xdep.o: altos-xdep.c $(defs_h) $(gdbcore_h) $(inferior_h)
|
altos-xdep.o: altos-xdep.c $(defs_h) $(gdbcore_h) $(inferior_h)
|
||||||
arm-pinsn.o: arm-pinsn.c $(OP_INCLUDE)/arm.h $(defs_h) $(symtab_h)
|
arm-pinsn.o: arm-pinsn.c $(OP_INCLUDE)/arm.h $(defs_h) $(symtab_h)
|
||||||
|
|
||||||
|
|
@ -1086,7 +1095,7 @@ i386-pinsn.o: i386-pinsn.c $(bfd_h) $(dis-asm_h) $(defs_h)
|
||||||
i386-tdep.o: i386-tdep.c $(defs_h) $(gdbcore_h) $(inferior_h) target.h
|
i386-tdep.o: i386-tdep.c $(defs_h) $(gdbcore_h) $(inferior_h) target.h
|
||||||
i386b-nat.o: i386b-nat.c $(defs_h)
|
i386b-nat.o: i386b-nat.c $(defs_h)
|
||||||
i386lynx-nat.o: i386lynx-nat.c $(defs_h) $(frame_h) $(inferior_h) target.h
|
i386lynx-nat.o: i386lynx-nat.c $(defs_h) $(frame_h) $(inferior_h) target.h
|
||||||
i386lynx-tdep.o: i386lynx-tdep.c $(defs_h) $(inferior_h) target.h
|
i386ly-tdep.o: i386ly-tdep.c $(defs_h) $(inferior_h) target.h
|
||||||
i386mach-nat.o: i386mach-nat.c $(defs_h) $(gdbcore_h) $(inferior_h)
|
i386mach-nat.o: i386mach-nat.c $(defs_h) $(gdbcore_h) $(inferior_h)
|
||||||
|
|
||||||
i386v-nat.o: i386v-nat.c $(ieee-float_h) $(defs_h) $(gdbcore_h) \
|
i386v-nat.o: i386v-nat.c $(ieee-float_h) $(defs_h) $(gdbcore_h) \
|
||||||
|
|
@ -1184,6 +1193,9 @@ ns32k-pinsn.o: ns32k-pinsn.c $(defs_h) $(gdbcore_h) ns32k-opcode.h \
|
||||||
objfiles.o: objfiles.c $(bfd_h) $(defs_h) objfiles.h symfile.h \
|
objfiles.o: objfiles.c $(bfd_h) $(defs_h) objfiles.h symfile.h \
|
||||||
$(symtab_h)
|
$(symtab_h)
|
||||||
|
|
||||||
|
osfsolib.o: osfsolib.c $(command_h) $(defs_h) $(gdbcore_h) $(inferior_h) \
|
||||||
|
objfiles.h regex.h symfile.h target.h language.h
|
||||||
|
|
||||||
paread.o: paread.c $(bfd_h) buildsym.h complaints.h $(defs_h) \
|
paread.o: paread.c $(bfd_h) buildsym.h complaints.h $(defs_h) \
|
||||||
gdb-stabs.h objfiles.h symfile.h $(symtab_h)
|
gdb-stabs.h objfiles.h symfile.h $(symtab_h)
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,144 @@
|
||||||
|
/* Low level Alpha interface, for GDB when running native.
|
||||||
|
Copyright 1993 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||||
|
|
||||||
|
#include "defs.h"
|
||||||
|
#include "inferior.h"
|
||||||
|
#include "gdbcore.h"
|
||||||
|
#include "target.h"
|
||||||
|
#include <sys/ptrace.h>
|
||||||
|
#include <machine/reg.h>
|
||||||
|
|
||||||
|
/* Size of elements in jmpbuf */
|
||||||
|
|
||||||
|
#define JB_ELEMENT_SIZE 8
|
||||||
|
|
||||||
|
/* The definition for JB_PC in machine/reg.h is wrong.
|
||||||
|
And we can't get at the correct definition in setjmp.h as it is
|
||||||
|
not always available (eg. if _POSIX_SOURCE is defined which is the
|
||||||
|
default). As the defintion is unlikely to change (see comment
|
||||||
|
in <setjmp.h>, define the correct value here. */
|
||||||
|
|
||||||
|
#undef JB_PC
|
||||||
|
#define JB_PC 2
|
||||||
|
|
||||||
|
/* Figure out where the longjmp will land.
|
||||||
|
We expect the first arg to be a pointer to the jmp_buf structure from which
|
||||||
|
we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
|
||||||
|
This routine returns true on success. */
|
||||||
|
|
||||||
|
int
|
||||||
|
get_longjmp_target (pc)
|
||||||
|
CORE_ADDR *pc;
|
||||||
|
{
|
||||||
|
CORE_ADDR jb_addr;
|
||||||
|
char raw_buffer[MAX_REGISTER_RAW_SIZE];
|
||||||
|
|
||||||
|
jb_addr = read_register(A0_REGNUM);
|
||||||
|
|
||||||
|
if (target_read_memory(jb_addr + JB_PC * JB_ELEMENT_SIZE, raw_buffer,
|
||||||
|
sizeof(CORE_ADDR)))
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
*pc = extract_address (raw_buffer, sizeof(CORE_ADDR));
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Extract the register values out of the core file and store
|
||||||
|
them where `read_register' will find them.
|
||||||
|
|
||||||
|
CORE_REG_SECT points to the register values themselves, read into memory.
|
||||||
|
CORE_REG_SIZE is the size of that area.
|
||||||
|
WHICH says which set of registers we are handling (0 = int, 2 = float
|
||||||
|
on machines where they are discontiguous).
|
||||||
|
REG_ADDR is the offset from u.u_ar0 to the register values relative to
|
||||||
|
core_reg_sect. This is used with old-fashioned core files to
|
||||||
|
locate the registers in a large upage-plus-stack ".reg" section.
|
||||||
|
Original upage address X is at location core_reg_sect+x+reg_addr.
|
||||||
|
*/
|
||||||
|
|
||||||
|
void
|
||||||
|
fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
|
||||||
|
char *core_reg_sect;
|
||||||
|
unsigned core_reg_size;
|
||||||
|
int which;
|
||||||
|
unsigned reg_addr;
|
||||||
|
{
|
||||||
|
register int regno;
|
||||||
|
register int addr;
|
||||||
|
int bad_reg = -1;
|
||||||
|
|
||||||
|
/* Table to map a gdb regnum to an index in the core register section.
|
||||||
|
The floating point register values are garbage in OSF/1.2 core files. */
|
||||||
|
static int core_reg_mapping[NUM_REGS] =
|
||||||
|
{
|
||||||
|
#define EFL (EF_SIZE / 8)
|
||||||
|
EF_V0, EF_T0, EF_T1, EF_T2, EF_T3, EF_T4, EF_T5, EF_T6,
|
||||||
|
EF_T7, EF_S0, EF_S1, EF_S2, EF_S3, EF_S4, EF_S5, EF_S6,
|
||||||
|
EF_A0, EF_A1, EF_A2, EF_A3, EF_A4, EF_A5, EF_T8, EF_T9,
|
||||||
|
EF_T10, EF_T11, EF_RA, EF_T12, EF_AT, EF_GP, EF_SP, -1,
|
||||||
|
EFL+0, EFL+1, EFL+2, EFL+3, EFL+4, EFL+5, EFL+6, EFL+7,
|
||||||
|
EFL+8, EFL+9, EFL+10, EFL+11, EFL+12, EFL+13, EFL+14, EFL+15,
|
||||||
|
EFL+16, EFL+17, EFL+18, EFL+19, EFL+20, EFL+21, EFL+22, EFL+23,
|
||||||
|
EFL+24, EFL+25, EFL+26, EFL+27, EFL+28, EFL+29, EFL+30, EFL+31,
|
||||||
|
EF_PC, -1
|
||||||
|
};
|
||||||
|
static char zerobuf[MAX_REGISTER_RAW_SIZE] = {0};
|
||||||
|
|
||||||
|
for (regno = 0; regno < NUM_REGS; regno++)
|
||||||
|
{
|
||||||
|
if (CANNOT_FETCH_REGISTER (regno))
|
||||||
|
{
|
||||||
|
supply_register (regno, zerobuf);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
addr = 8 * core_reg_mapping[regno];
|
||||||
|
if (addr < 0 || addr >= core_reg_size)
|
||||||
|
{
|
||||||
|
if (bad_reg < 0)
|
||||||
|
bad_reg = regno;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
supply_register (regno, core_reg_sect + addr);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (bad_reg >= 0)
|
||||||
|
{
|
||||||
|
error ("Register %s not found in core file.", reg_names[bad_reg]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Map gdb internal register number to a ptrace ``address''.
|
||||||
|
These ``addresses'' are defined in <sys/ptrace.h> */
|
||||||
|
|
||||||
|
#define REGISTER_PTRACE_ADDR(regno) \
|
||||||
|
(regno < FP0_REGNUM ? GPR_BASE + (regno) \
|
||||||
|
: regno == PC_REGNUM ? PC \
|
||||||
|
: regno >= FP0_REGNUM ? FPR_BASE + ((regno) - FP0_REGNUM) \
|
||||||
|
: 0)
|
||||||
|
|
||||||
|
/* Return the ptrace ``address'' of register REGNO. */
|
||||||
|
|
||||||
|
unsigned int
|
||||||
|
register_addr (regno, blockend)
|
||||||
|
int regno;
|
||||||
|
int blockend;
|
||||||
|
{
|
||||||
|
return REGISTER_PTRACE_ADDR (regno);
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,987 @@
|
||||||
|
/* Target-dependent code for the ALPHA architecture, for GDB, the GNU Debugger.
|
||||||
|
Copyright 1993 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||||
|
|
||||||
|
#include "defs.h"
|
||||||
|
#include "frame.h"
|
||||||
|
#include "inferior.h"
|
||||||
|
#include "symtab.h"
|
||||||
|
#include "value.h"
|
||||||
|
#include "gdbcmd.h"
|
||||||
|
#include "gdbcore.h"
|
||||||
|
#include "dis-asm.h"
|
||||||
|
|
||||||
|
/* FIXME: Some of this code should perhaps be merged with mips-tdep.c. */
|
||||||
|
|
||||||
|
#define VM_MIN_ADDRESS (CORE_ADDR)0x120000000
|
||||||
|
|
||||||
|
|
||||||
|
/* Forward declarations. */
|
||||||
|
|
||||||
|
static CORE_ADDR
|
||||||
|
read_next_frame_reg PARAMS ((FRAME, int));
|
||||||
|
|
||||||
|
static CORE_ADDR
|
||||||
|
heuristic_proc_start PARAMS ((CORE_ADDR));
|
||||||
|
|
||||||
|
static alpha_extra_func_info_t
|
||||||
|
heuristic_proc_desc PARAMS ((CORE_ADDR, CORE_ADDR, FRAME));
|
||||||
|
|
||||||
|
static alpha_extra_func_info_t
|
||||||
|
find_proc_desc PARAMS ((CORE_ADDR, FRAME));
|
||||||
|
|
||||||
|
static int
|
||||||
|
alpha_in_lenient_prologue PARAMS ((CORE_ADDR, CORE_ADDR));
|
||||||
|
|
||||||
|
static void
|
||||||
|
reinit_frame_cache_sfunc PARAMS ((char *, int, struct cmd_list_element *));
|
||||||
|
|
||||||
|
void
|
||||||
|
_initialize_alpha_tdep PARAMS ((void));
|
||||||
|
|
||||||
|
/* Heuristic_proc_start may hunt through the text section for a long
|
||||||
|
time across a 2400 baud serial line. Allows the user to limit this
|
||||||
|
search. */
|
||||||
|
static unsigned int heuristic_fence_post = 0;
|
||||||
|
|
||||||
|
/* Layout of a stack frame on the alpha:
|
||||||
|
|
||||||
|
| |
|
||||||
|
pdr members: | 7th ... nth arg, |
|
||||||
|
| `pushed' by caller. |
|
||||||
|
| |
|
||||||
|
----------------|-------------------------------|<-- old_sp == vfp
|
||||||
|
^ ^ ^ ^ | |
|
||||||
|
| | | | | |
|
||||||
|
| |localoff | Copies of 1st .. 6th |
|
||||||
|
| | | | | argument if necessary. |
|
||||||
|
| | | v | |
|
||||||
|
| | | --- |-------------------------------|<-- FRAME_ARGS_ADDRESS,
|
||||||
|
| | | | | FRAME_LOCALS_ADDRESS
|
||||||
|
| | | | Locals and temporaries. |
|
||||||
|
| | | | |
|
||||||
|
| | | |-------------------------------|
|
||||||
|
| | | | |
|
||||||
|
|-fregoffset | Saved float registers. |
|
||||||
|
| | | | F9 |
|
||||||
|
| | | | . |
|
||||||
|
| | | | . |
|
||||||
|
| | | | F2 |
|
||||||
|
| | v | |
|
||||||
|
| | -------|-------------------------------|
|
||||||
|
| | | |
|
||||||
|
| | | Saved registers. |
|
||||||
|
| | | S6 |
|
||||||
|
|-regoffset | . |
|
||||||
|
| | | . |
|
||||||
|
| | | S0 |
|
||||||
|
| | | pdr.pcreg |
|
||||||
|
| v | |
|
||||||
|
| ----------|-------------------------------|
|
||||||
|
| | |
|
||||||
|
frameoffset | Argument build area, gets |
|
||||||
|
| | 7th ... nth arg for any |
|
||||||
|
| | called procedure. |
|
||||||
|
v | |
|
||||||
|
-------------|-------------------------------|<-- sp
|
||||||
|
| |
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define PROC_LOW_ADDR(proc) ((proc)->pdr.adr) /* least address */
|
||||||
|
#define PROC_HIGH_ADDR(proc) ((proc)->pdr.iline) /* upper address bound */
|
||||||
|
#define PROC_DUMMY_FRAME(proc) ((proc)->pdr.iopt) /* frame for CALL_DUMMY */
|
||||||
|
#define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
|
||||||
|
#define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
|
||||||
|
#define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
|
||||||
|
#define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
|
||||||
|
#define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
|
||||||
|
#define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
|
||||||
|
#define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
|
||||||
|
#define PROC_LOCALOFF(proc) ((proc)->pdr.localoff)
|
||||||
|
#define PROC_SYMBOL(proc) (*(struct symbol**)&(proc)->pdr.isym)
|
||||||
|
#define _PROC_MAGIC_ 0x0F0F0F0F
|
||||||
|
#define PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym == _PROC_MAGIC_)
|
||||||
|
#define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym = _PROC_MAGIC_)
|
||||||
|
|
||||||
|
struct linked_proc_info
|
||||||
|
{
|
||||||
|
struct alpha_extra_func_info info;
|
||||||
|
struct linked_proc_info *next;
|
||||||
|
} *linked_proc_desc_table = NULL;
|
||||||
|
|
||||||
|
|
||||||
|
#define READ_FRAME_REG(fi, regno) read_next_frame_reg((fi)->next, regno)
|
||||||
|
|
||||||
|
static CORE_ADDR
|
||||||
|
read_next_frame_reg(fi, regno)
|
||||||
|
FRAME fi;
|
||||||
|
int regno;
|
||||||
|
{
|
||||||
|
/* If it is the frame for sigtramp we have a pointer to the sigcontext
|
||||||
|
on the stack.
|
||||||
|
If the stack layout for __sigtramp changes or if sigcontext offsets
|
||||||
|
change we might have to update this code. */
|
||||||
|
#ifndef SIGFRAME_PC_OFF
|
||||||
|
#define SIGFRAME_PC_OFF (2 * 8)
|
||||||
|
#define SIGFRAME_REGSAVE_OFF (4 * 8)
|
||||||
|
#endif
|
||||||
|
for (; fi; fi = fi->next)
|
||||||
|
{
|
||||||
|
if (fi->signal_handler_caller)
|
||||||
|
{
|
||||||
|
int offset;
|
||||||
|
CORE_ADDR sigcontext_addr = read_memory_integer(fi->frame, 8);
|
||||||
|
|
||||||
|
if (regno == PC_REGNUM)
|
||||||
|
offset = SIGFRAME_PC_OFF;
|
||||||
|
else if (regno < 32)
|
||||||
|
offset = SIGFRAME_REGSAVE_OFF + regno * 8;
|
||||||
|
else
|
||||||
|
return 0;
|
||||||
|
return read_memory_integer(sigcontext_addr + offset, 8);
|
||||||
|
}
|
||||||
|
else if (regno == SP_REGNUM)
|
||||||
|
return fi->frame;
|
||||||
|
else if (fi->saved_regs->regs[regno])
|
||||||
|
return read_memory_integer(fi->saved_regs->regs[regno], 8);
|
||||||
|
}
|
||||||
|
return read_register(regno);
|
||||||
|
}
|
||||||
|
|
||||||
|
CORE_ADDR
|
||||||
|
alpha_frame_saved_pc(frame)
|
||||||
|
FRAME frame;
|
||||||
|
{
|
||||||
|
alpha_extra_func_info_t proc_desc = frame->proc_desc;
|
||||||
|
int pcreg = proc_desc ? PROC_PC_REG(proc_desc) : RA_REGNUM;
|
||||||
|
|
||||||
|
if (proc_desc && PROC_DESC_IS_DUMMY(proc_desc))
|
||||||
|
return read_memory_integer(frame->frame - 8, 8);
|
||||||
|
|
||||||
|
return read_next_frame_reg(frame, pcreg);
|
||||||
|
}
|
||||||
|
|
||||||
|
CORE_ADDR
|
||||||
|
alpha_saved_pc_after_call (frame)
|
||||||
|
FRAME frame;
|
||||||
|
{
|
||||||
|
alpha_extra_func_info_t proc_desc = find_proc_desc (frame->pc, frame->next);
|
||||||
|
int pcreg = proc_desc ? PROC_PC_REG (proc_desc) : RA_REGNUM;
|
||||||
|
|
||||||
|
return read_register (pcreg);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static struct alpha_extra_func_info temp_proc_desc;
|
||||||
|
static struct frame_saved_regs temp_saved_regs;
|
||||||
|
|
||||||
|
/* This fencepost looks highly suspicious to me. Removing it also
|
||||||
|
seems suspicious as it could affect remote debugging across serial
|
||||||
|
lines. */
|
||||||
|
|
||||||
|
static CORE_ADDR
|
||||||
|
heuristic_proc_start(pc)
|
||||||
|
CORE_ADDR pc;
|
||||||
|
{
|
||||||
|
CORE_ADDR start_pc = pc;
|
||||||
|
CORE_ADDR fence = start_pc - heuristic_fence_post;
|
||||||
|
|
||||||
|
if (start_pc == 0) return 0;
|
||||||
|
|
||||||
|
if (heuristic_fence_post == UINT_MAX
|
||||||
|
|| fence < VM_MIN_ADDRESS)
|
||||||
|
fence = VM_MIN_ADDRESS;
|
||||||
|
|
||||||
|
/* search back for previous return */
|
||||||
|
for (start_pc -= 4; ; start_pc -= 4)
|
||||||
|
if (start_pc < fence)
|
||||||
|
{
|
||||||
|
/* It's not clear to me why we reach this point when
|
||||||
|
stop_soon_quietly, but with this test, at least we
|
||||||
|
don't print out warnings for every child forked (eg, on
|
||||||
|
decstation). 22apr93 rich@cygnus.com. */
|
||||||
|
if (!stop_soon_quietly)
|
||||||
|
{
|
||||||
|
static int blurb_printed = 0;
|
||||||
|
|
||||||
|
if (fence == VM_MIN_ADDRESS)
|
||||||
|
warning("Hit beginning of text section without finding");
|
||||||
|
else
|
||||||
|
warning("Hit heuristic-fence-post without finding");
|
||||||
|
|
||||||
|
warning("enclosing function for address 0x%lx", pc);
|
||||||
|
if (!blurb_printed)
|
||||||
|
{
|
||||||
|
printf_filtered ("\
|
||||||
|
This warning occurs if you are debugging a function without any symbols\n\
|
||||||
|
(for example, in a stripped executable). In that case, you may wish to\n\
|
||||||
|
increase the size of the search with the `set heuristic-fence-post' command.\n\
|
||||||
|
\n\
|
||||||
|
Otherwise, you told GDB there was a function where there isn't one, or\n\
|
||||||
|
(more likely) you have encountered a bug in GDB.\n");
|
||||||
|
blurb_printed = 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
else if (ABOUT_TO_RETURN(start_pc))
|
||||||
|
break;
|
||||||
|
|
||||||
|
start_pc += 4; /* skip return */
|
||||||
|
return start_pc;
|
||||||
|
}
|
||||||
|
|
||||||
|
static alpha_extra_func_info_t
|
||||||
|
heuristic_proc_desc(start_pc, limit_pc, next_frame)
|
||||||
|
CORE_ADDR start_pc, limit_pc;
|
||||||
|
FRAME next_frame;
|
||||||
|
{
|
||||||
|
CORE_ADDR sp = next_frame ? next_frame->frame : read_register (SP_REGNUM);
|
||||||
|
CORE_ADDR cur_pc;
|
||||||
|
int frame_size;
|
||||||
|
int has_frame_reg = 0;
|
||||||
|
unsigned long reg_mask = 0;
|
||||||
|
|
||||||
|
if (start_pc == 0)
|
||||||
|
return NULL;
|
||||||
|
memset(&temp_proc_desc, '\0', sizeof(temp_proc_desc));
|
||||||
|
memset(&temp_saved_regs, '\0', sizeof(struct frame_saved_regs));
|
||||||
|
PROC_LOW_ADDR(&temp_proc_desc) = start_pc;
|
||||||
|
|
||||||
|
if (start_pc + 200 < limit_pc)
|
||||||
|
limit_pc = start_pc + 200;
|
||||||
|
frame_size = 0;
|
||||||
|
for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += 4)
|
||||||
|
{
|
||||||
|
char buf[4];
|
||||||
|
unsigned long word;
|
||||||
|
int status;
|
||||||
|
|
||||||
|
status = read_memory_nobpt (cur_pc, buf, 4);
|
||||||
|
if (status)
|
||||||
|
memory_error (status, cur_pc);
|
||||||
|
word = extract_unsigned_integer (buf, 4);
|
||||||
|
|
||||||
|
if ((word & 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
|
||||||
|
frame_size += (-word) & 0xffff;
|
||||||
|
else if ((word & 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
|
||||||
|
&& (word & 0xffff0000) != 0xb7fe0000) /* reg != $zero */
|
||||||
|
{
|
||||||
|
int reg = (word & 0x03e00000) >> 21;
|
||||||
|
reg_mask |= 1 << reg;
|
||||||
|
temp_saved_regs.regs[reg] = sp + (short)word;
|
||||||
|
}
|
||||||
|
else if (word == 0x47de040f) /* bis sp,sp fp */
|
||||||
|
has_frame_reg = 1;
|
||||||
|
}
|
||||||
|
if (has_frame_reg)
|
||||||
|
PROC_FRAME_REG(&temp_proc_desc) = GCC_FP_REGNUM;
|
||||||
|
else
|
||||||
|
PROC_FRAME_REG(&temp_proc_desc) = SP_REGNUM;
|
||||||
|
PROC_FRAME_OFFSET(&temp_proc_desc) = frame_size;
|
||||||
|
PROC_REG_MASK(&temp_proc_desc) = reg_mask;
|
||||||
|
PROC_PC_REG(&temp_proc_desc) = RA_REGNUM;
|
||||||
|
return &temp_proc_desc;
|
||||||
|
}
|
||||||
|
|
||||||
|
static alpha_extra_func_info_t
|
||||||
|
find_proc_desc(pc, next_frame)
|
||||||
|
CORE_ADDR pc;
|
||||||
|
FRAME next_frame;
|
||||||
|
{
|
||||||
|
alpha_extra_func_info_t proc_desc;
|
||||||
|
struct block *b;
|
||||||
|
struct symbol *sym;
|
||||||
|
CORE_ADDR startaddr;
|
||||||
|
|
||||||
|
/* Try to get the proc_desc from the linked call dummy proc_descs
|
||||||
|
if the pc is in the call dummy.
|
||||||
|
This is hairy. In the case of nested dummy calls we have to find the
|
||||||
|
right proc_desc, but we might not yet know the frame for the dummy
|
||||||
|
as it will be contained in the proc_desc we are searching for.
|
||||||
|
So we have to find the proc_desc whose frame is closest to the current
|
||||||
|
stack pointer. */
|
||||||
|
if (PC_IN_CALL_DUMMY (pc, 0, 0))
|
||||||
|
{
|
||||||
|
struct linked_proc_info *link;
|
||||||
|
CORE_ADDR sp = next_frame ? next_frame->frame : read_register (SP_REGNUM);
|
||||||
|
alpha_extra_func_info_t found_proc_desc = NULL;
|
||||||
|
long min_distance = LONG_MAX;
|
||||||
|
|
||||||
|
for (link = linked_proc_desc_table; link; link = link->next)
|
||||||
|
{
|
||||||
|
long distance = (CORE_ADDR) PROC_DUMMY_FRAME (&link->info) - sp;
|
||||||
|
if (distance > 0 && distance < min_distance)
|
||||||
|
{
|
||||||
|
min_distance = distance;
|
||||||
|
found_proc_desc = &link->info;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (found_proc_desc != NULL)
|
||||||
|
return found_proc_desc;
|
||||||
|
}
|
||||||
|
|
||||||
|
b = block_for_pc(pc);
|
||||||
|
find_pc_partial_function (pc, NULL, &startaddr, NULL);
|
||||||
|
if (b == NULL)
|
||||||
|
sym = NULL;
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if (startaddr > BLOCK_START (b))
|
||||||
|
/* This is the "pathological" case referred to in a comment in
|
||||||
|
print_frame_info. It might be better to move this check into
|
||||||
|
symbol reading. */
|
||||||
|
sym = NULL;
|
||||||
|
else
|
||||||
|
sym = lookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_NAMESPACE,
|
||||||
|
0, NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (sym)
|
||||||
|
{
|
||||||
|
/* IF (this is the topmost frame OR a frame interrupted by a signal)
|
||||||
|
* AND (this proc does not have debugging information OR
|
||||||
|
* the PC is in the procedure prologue)
|
||||||
|
* THEN create a "heuristic" proc_desc (by analyzing
|
||||||
|
* the actual code) to replace the "official" proc_desc.
|
||||||
|
*/
|
||||||
|
proc_desc = (alpha_extra_func_info_t)SYMBOL_VALUE(sym);
|
||||||
|
if (next_frame == NULL || next_frame->signal_handler_caller) {
|
||||||
|
struct symtab_and_line val;
|
||||||
|
struct symbol *proc_symbol =
|
||||||
|
PROC_DESC_IS_DUMMY(proc_desc) ? 0 : PROC_SYMBOL(proc_desc);
|
||||||
|
|
||||||
|
if (proc_symbol) {
|
||||||
|
val = find_pc_line (BLOCK_START
|
||||||
|
(SYMBOL_BLOCK_VALUE(proc_symbol)),
|
||||||
|
0);
|
||||||
|
val.pc = val.end ? val.end : pc;
|
||||||
|
}
|
||||||
|
if (!proc_symbol || pc < val.pc) {
|
||||||
|
alpha_extra_func_info_t found_heuristic =
|
||||||
|
heuristic_proc_desc(PROC_LOW_ADDR(proc_desc),
|
||||||
|
pc, next_frame);
|
||||||
|
if (found_heuristic)
|
||||||
|
{
|
||||||
|
/* The call to heuristic_proc_desc determines
|
||||||
|
which registers have been saved so far and if the
|
||||||
|
frame is already set up.
|
||||||
|
The heuristic algorithm doesn't work well for other
|
||||||
|
information in the procedure descriptor, so copy
|
||||||
|
it from the found procedure descriptor. */
|
||||||
|
PROC_LOCALOFF(found_heuristic) = PROC_LOCALOFF(proc_desc);
|
||||||
|
PROC_PC_REG(found_heuristic) = PROC_PC_REG(proc_desc);
|
||||||
|
proc_desc = found_heuristic;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if (startaddr == 0)
|
||||||
|
startaddr = heuristic_proc_start (pc);
|
||||||
|
|
||||||
|
proc_desc =
|
||||||
|
heuristic_proc_desc (startaddr, pc, next_frame);
|
||||||
|
}
|
||||||
|
return proc_desc;
|
||||||
|
}
|
||||||
|
|
||||||
|
alpha_extra_func_info_t cached_proc_desc;
|
||||||
|
|
||||||
|
FRAME_ADDR
|
||||||
|
alpha_frame_chain(frame)
|
||||||
|
FRAME frame;
|
||||||
|
{
|
||||||
|
alpha_extra_func_info_t proc_desc;
|
||||||
|
CORE_ADDR saved_pc = FRAME_SAVED_PC(frame);
|
||||||
|
|
||||||
|
if (saved_pc == 0 || inside_entry_file (saved_pc))
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
proc_desc = find_proc_desc(saved_pc, frame);
|
||||||
|
if (!proc_desc)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
cached_proc_desc = proc_desc;
|
||||||
|
|
||||||
|
/* Fetch the frame pointer for a dummy frame from the procedure
|
||||||
|
descriptor. */
|
||||||
|
if (PROC_DESC_IS_DUMMY(proc_desc))
|
||||||
|
return (FRAME_ADDR) PROC_DUMMY_FRAME(proc_desc);
|
||||||
|
|
||||||
|
/* If no frame pointer and frame size is zero, we must be at end
|
||||||
|
of stack (or otherwise hosed). If we don't check frame size,
|
||||||
|
we loop forever if we see a zero size frame. */
|
||||||
|
if (PROC_FRAME_REG (proc_desc) == SP_REGNUM
|
||||||
|
&& PROC_FRAME_OFFSET (proc_desc) == 0
|
||||||
|
/* The alpha __sigtramp routine is frameless and has a frame size
|
||||||
|
of zero. Luckily it is the only procedure which has PC_REGNUM
|
||||||
|
as PROC_PC_REG. */
|
||||||
|
&& PROC_PC_REG (proc_desc) != PC_REGNUM
|
||||||
|
/* The previous frame from a sigtramp frame might be frameless
|
||||||
|
and have frame size zero. */
|
||||||
|
&& !frame->signal_handler_caller)
|
||||||
|
return 0;
|
||||||
|
else
|
||||||
|
return read_next_frame_reg(frame, PROC_FRAME_REG(proc_desc))
|
||||||
|
+ PROC_FRAME_OFFSET(proc_desc);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
init_extra_frame_info(fci)
|
||||||
|
struct frame_info *fci;
|
||||||
|
{
|
||||||
|
extern struct obstack frame_cache_obstack;
|
||||||
|
/* Use proc_desc calculated in frame_chain */
|
||||||
|
alpha_extra_func_info_t proc_desc =
|
||||||
|
fci->next ? cached_proc_desc : find_proc_desc(fci->pc, fci->next);
|
||||||
|
|
||||||
|
fci->saved_regs = (struct frame_saved_regs*)
|
||||||
|
obstack_alloc (&frame_cache_obstack, sizeof(struct frame_saved_regs));
|
||||||
|
memset (fci->saved_regs, 0, sizeof (struct frame_saved_regs));
|
||||||
|
fci->proc_desc =
|
||||||
|
proc_desc == &temp_proc_desc ? 0 : proc_desc;
|
||||||
|
if (proc_desc)
|
||||||
|
{
|
||||||
|
int ireg;
|
||||||
|
CORE_ADDR reg_position;
|
||||||
|
unsigned long mask;
|
||||||
|
int returnreg;
|
||||||
|
|
||||||
|
/* Get the locals offset from the procedure descriptor, it is valid
|
||||||
|
even if we are in the middle of the prologue. */
|
||||||
|
fci->localoff = PROC_LOCALOFF(proc_desc);
|
||||||
|
|
||||||
|
/* FIXME: This is a kludge for gcc-2.4.5.
|
||||||
|
gcc-2.4.5 builds frames for the alpha in a peculiar way.
|
||||||
|
It uses $fp as a frame register (which seems to be identical to $sp
|
||||||
|
in all procedures that do not use alloca).
|
||||||
|
It has the arguments and the locals above the frame register, if
|
||||||
|
there are few arguments then the locals are above the arguments,
|
||||||
|
otherwise the arguments are above the local.
|
||||||
|
Frame offsets for arguments and locals are relative to $fp and always
|
||||||
|
positive.
|
||||||
|
If we want to stay compatible with the native cc compiler we have
|
||||||
|
to set localoff to frameoffset so that FRAME_ARGS_ADDRESS and
|
||||||
|
FRAME_LOCALS_ADDRESS point to the right place in the frame.
|
||||||
|
Please note that the setting of localoff in the compiler won't work
|
||||||
|
as localoff is only 8 bits wide (which is enough for cc as it needs
|
||||||
|
at most number_of_arg_regs * 8 == 48). */
|
||||||
|
if (PROC_FRAME_REG(proc_desc) == GCC_FP_REGNUM)
|
||||||
|
fci->localoff = PROC_FRAME_OFFSET(proc_desc);
|
||||||
|
|
||||||
|
/* Fixup frame-pointer - only needed for top frame */
|
||||||
|
/* Fetch the frame pointer for a dummy frame from the procedure
|
||||||
|
descriptor. */
|
||||||
|
if (PROC_DESC_IS_DUMMY(proc_desc))
|
||||||
|
fci->frame = (FRAME_ADDR) PROC_DUMMY_FRAME(proc_desc);
|
||||||
|
/* This may not be quite right, if proc has a real frame register.
|
||||||
|
Get the value of the frame relative sp, procedure might have been
|
||||||
|
interrupted by a signal at it's very start. */
|
||||||
|
else if (fci->pc == PROC_LOW_ADDR(proc_desc))
|
||||||
|
fci->frame = READ_FRAME_REG(fci, SP_REGNUM);
|
||||||
|
else
|
||||||
|
fci->frame = READ_FRAME_REG(fci, PROC_FRAME_REG(proc_desc))
|
||||||
|
+ PROC_FRAME_OFFSET(proc_desc);
|
||||||
|
|
||||||
|
/* If this is the innermost frame, and we are still in the
|
||||||
|
prologue (loosely defined), then the registers may not have
|
||||||
|
been saved yet. */
|
||||||
|
if (fci->next == NULL
|
||||||
|
&& !PROC_DESC_IS_DUMMY(proc_desc)
|
||||||
|
&& alpha_in_lenient_prologue (PROC_LOW_ADDR (proc_desc), fci->pc))
|
||||||
|
{
|
||||||
|
/* Can't just say that the registers are not saved, because they
|
||||||
|
might get clobbered halfway through the prologue.
|
||||||
|
heuristic_proc_desc already has the right code to figure out
|
||||||
|
exactly what has been saved, so use it. As far as I know we
|
||||||
|
could be doing this (as we do on the 68k, for example)
|
||||||
|
regardless of whether we are in the prologue; I'm leaving in
|
||||||
|
the check for being in the prologue only out of conservatism
|
||||||
|
(I'm not sure whether heuristic_proc_desc handles all cases,
|
||||||
|
for example).
|
||||||
|
|
||||||
|
This stuff is ugly (and getting uglier by the minute). Probably
|
||||||
|
the best way to clean it up is to ignore the proc_desc's from
|
||||||
|
the symbols altogher, and get all the information we need by
|
||||||
|
examining the prologue (provided we can make the prologue
|
||||||
|
examining code good enough to get all the cases...). */
|
||||||
|
proc_desc =
|
||||||
|
heuristic_proc_desc (PROC_LOW_ADDR (proc_desc),
|
||||||
|
fci->pc,
|
||||||
|
fci->next);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (proc_desc == &temp_proc_desc)
|
||||||
|
*fci->saved_regs = temp_saved_regs;
|
||||||
|
else
|
||||||
|
{
|
||||||
|
/* Find which general-purpose registers were saved.
|
||||||
|
The return address register is the first saved register,
|
||||||
|
the other registers follow in ascending order. */
|
||||||
|
reg_position = fci->frame + PROC_REG_OFFSET(proc_desc);
|
||||||
|
mask = PROC_REG_MASK(proc_desc) & 0xffffffffL;
|
||||||
|
returnreg = PROC_PC_REG(proc_desc);
|
||||||
|
if (mask & (1 << returnreg))
|
||||||
|
{
|
||||||
|
fci->saved_regs->regs[returnreg] = reg_position;
|
||||||
|
reg_position += 8;
|
||||||
|
}
|
||||||
|
for (ireg = 0; mask; ireg++, mask >>= 1)
|
||||||
|
if (mask & 1)
|
||||||
|
{
|
||||||
|
if (ireg == returnreg)
|
||||||
|
continue;
|
||||||
|
fci->saved_regs->regs[ireg] = reg_position;
|
||||||
|
reg_position += 8;
|
||||||
|
}
|
||||||
|
/* find which floating-point registers were saved */
|
||||||
|
reg_position = fci->frame + PROC_FREG_OFFSET(proc_desc);
|
||||||
|
mask = PROC_FREG_MASK(proc_desc) & 0xffffffffL;
|
||||||
|
for (ireg = 0; mask; ireg++, mask >>= 1)
|
||||||
|
if (mask & 1)
|
||||||
|
{
|
||||||
|
fci->saved_regs->regs[FP0_REGNUM+ireg] = reg_position;
|
||||||
|
reg_position += 8;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fci->saved_regs->regs[PC_REGNUM] = fci->saved_regs->regs[PROC_PC_REG(proc_desc)];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* ALPHA stack frames are almost impenetrable. When execution stops,
|
||||||
|
we basically have to look at symbol information for the function
|
||||||
|
that we stopped in, which tells us *which* register (if any) is
|
||||||
|
the base of the frame pointer, and what offset from that register
|
||||||
|
the frame itself is at.
|
||||||
|
|
||||||
|
This presents a problem when trying to examine a stack in memory
|
||||||
|
(that isn't executing at the moment), using the "frame" command. We
|
||||||
|
don't have a PC, nor do we have any registers except SP.
|
||||||
|
|
||||||
|
This routine takes two arguments, SP and PC, and tries to make the
|
||||||
|
cached frames look as if these two arguments defined a frame on the
|
||||||
|
cache. This allows the rest of info frame to extract the important
|
||||||
|
arguments without difficulty. */
|
||||||
|
|
||||||
|
FRAME
|
||||||
|
setup_arbitrary_frame (argc, argv)
|
||||||
|
int argc;
|
||||||
|
FRAME_ADDR *argv;
|
||||||
|
{
|
||||||
|
if (argc != 2)
|
||||||
|
error ("ALPHA frame specifications require two arguments: sp and pc");
|
||||||
|
|
||||||
|
return create_new_frame (argv[0], argv[1]);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* The alpha passes the first six arguments in the registers, the rest on
|
||||||
|
the stack. The register arguments are eventually transferred to the
|
||||||
|
argument transfer area immediately below the stack by the called function
|
||||||
|
anyway. So we `push' at least six arguments on the stack, `reload' the
|
||||||
|
argument registers and then adjust the stack pointer to point past the
|
||||||
|
sixth argument. This algorithm simplifies the passing of a large struct
|
||||||
|
which extends from the registers to the stack.
|
||||||
|
If the called function is returning a structure, the address of the
|
||||||
|
structure to be returned is passed as a hidden first argument. */
|
||||||
|
|
||||||
|
#define NUM_ARG_REGS 6
|
||||||
|
|
||||||
|
CORE_ADDR
|
||||||
|
alpha_push_arguments (nargs, args, sp, struct_return, struct_addr)
|
||||||
|
int nargs;
|
||||||
|
value *args;
|
||||||
|
CORE_ADDR sp;
|
||||||
|
int struct_return;
|
||||||
|
CORE_ADDR struct_addr;
|
||||||
|
{
|
||||||
|
register i;
|
||||||
|
int accumulate_size = struct_return ? 8 : 0;
|
||||||
|
int arg_regs_size = NUM_ARG_REGS * 8;
|
||||||
|
struct alpha_arg { char *contents; int len; int offset; };
|
||||||
|
struct alpha_arg *alpha_args =
|
||||||
|
(struct alpha_arg*)alloca (nargs * sizeof (struct alpha_arg));
|
||||||
|
register struct alpha_arg *m_arg;
|
||||||
|
char raw_buffer[sizeof (CORE_ADDR)];
|
||||||
|
int required_arg_regs;
|
||||||
|
|
||||||
|
for (i = 0, m_arg = alpha_args; i < nargs; i++, m_arg++)
|
||||||
|
{
|
||||||
|
value arg = value_arg_coerce (args[i]);
|
||||||
|
/* Cast argument to long if necessary as the compiler does it too. */
|
||||||
|
if (TYPE_LENGTH (VALUE_TYPE (arg)) < TYPE_LENGTH (builtin_type_long))
|
||||||
|
arg = value_cast (builtin_type_long, arg);
|
||||||
|
m_arg->len = TYPE_LENGTH (VALUE_TYPE (arg));
|
||||||
|
m_arg->offset = accumulate_size;
|
||||||
|
accumulate_size = (accumulate_size + m_arg->len + 7) & ~7;
|
||||||
|
m_arg->contents = VALUE_CONTENTS(arg);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Determine required argument register loads, loading an argument register
|
||||||
|
is expensive as it uses three ptrace calls. */
|
||||||
|
required_arg_regs = accumulate_size / 8;
|
||||||
|
if (required_arg_regs > NUM_ARG_REGS)
|
||||||
|
required_arg_regs = NUM_ARG_REGS;
|
||||||
|
|
||||||
|
/* Make room for the arguments on the stack. */
|
||||||
|
if (accumulate_size < arg_regs_size)
|
||||||
|
accumulate_size = arg_regs_size;
|
||||||
|
sp -= accumulate_size;
|
||||||
|
|
||||||
|
/* Keep sp aligned to a multiple of 16 as the compiler does it too. */
|
||||||
|
sp &= ~15;
|
||||||
|
|
||||||
|
/* `Push' arguments on the stack. */
|
||||||
|
for (i = nargs; m_arg--, --i >= 0; )
|
||||||
|
write_memory(sp + m_arg->offset, m_arg->contents, m_arg->len);
|
||||||
|
if (struct_return)
|
||||||
|
{
|
||||||
|
store_address (raw_buffer, sizeof (CORE_ADDR), struct_addr);
|
||||||
|
write_memory (sp, raw_buffer, sizeof (CORE_ADDR));
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Load the argument registers. */
|
||||||
|
for (i = 0; i < required_arg_regs; i++)
|
||||||
|
{
|
||||||
|
LONGEST val;
|
||||||
|
|
||||||
|
val = read_memory_integer (sp + i * 8, 8);
|
||||||
|
write_register (A0_REGNUM + i, val);
|
||||||
|
write_register (FPA0_REGNUM + i, val);
|
||||||
|
}
|
||||||
|
|
||||||
|
return sp + arg_regs_size;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
alpha_push_dummy_frame()
|
||||||
|
{
|
||||||
|
int ireg;
|
||||||
|
struct linked_proc_info *link = (struct linked_proc_info*)
|
||||||
|
xmalloc(sizeof (struct linked_proc_info));
|
||||||
|
alpha_extra_func_info_t proc_desc = &link->info;
|
||||||
|
CORE_ADDR sp = read_register (SP_REGNUM);
|
||||||
|
CORE_ADDR save_address;
|
||||||
|
char raw_buffer[MAX_REGISTER_RAW_SIZE];
|
||||||
|
unsigned long mask;
|
||||||
|
|
||||||
|
link->next = linked_proc_desc_table;
|
||||||
|
linked_proc_desc_table = link;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* The registers we must save are all those not preserved across
|
||||||
|
* procedure calls.
|
||||||
|
* In addition, we must save the PC and RA.
|
||||||
|
*
|
||||||
|
* Dummy frame layout:
|
||||||
|
* (high memory)
|
||||||
|
* Saved PC
|
||||||
|
* Saved F30
|
||||||
|
* ...
|
||||||
|
* Saved F0
|
||||||
|
* Saved R29
|
||||||
|
* ...
|
||||||
|
* Saved R0
|
||||||
|
* Saved R26 (RA)
|
||||||
|
* Parameter build area
|
||||||
|
* (low memory)
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<31. */
|
||||||
|
#define MASK(i,j) (((1L << ((j)+1)) - 1) ^ ((1L << (i)) - 1))
|
||||||
|
#define GEN_REG_SAVE_MASK (MASK(0,8) | MASK(16,29))
|
||||||
|
#define GEN_REG_SAVE_COUNT 24
|
||||||
|
#define FLOAT_REG_SAVE_MASK (MASK(0,1) | MASK(10,30))
|
||||||
|
#define FLOAT_REG_SAVE_COUNT 23
|
||||||
|
/* The special register is the PC as we have no bit for it in the save masks.
|
||||||
|
alpha_frame_saved_pc knows where the pc is saved in a dummy frame. */
|
||||||
|
#define SPECIAL_REG_SAVE_COUNT 1
|
||||||
|
|
||||||
|
PROC_REG_MASK(proc_desc) = GEN_REG_SAVE_MASK;
|
||||||
|
PROC_FREG_MASK(proc_desc) = FLOAT_REG_SAVE_MASK;
|
||||||
|
/* PROC_REG_OFFSET is the offset from the dummy frame to the saved RA,
|
||||||
|
but keep SP aligned to a multiple of 16. */
|
||||||
|
PROC_REG_OFFSET(proc_desc) =
|
||||||
|
- ((8 * (SPECIAL_REG_SAVE_COUNT
|
||||||
|
+ GEN_REG_SAVE_COUNT
|
||||||
|
+ FLOAT_REG_SAVE_COUNT)
|
||||||
|
+ 15) & ~15);
|
||||||
|
PROC_FREG_OFFSET(proc_desc) =
|
||||||
|
PROC_REG_OFFSET(proc_desc) + 8 * GEN_REG_SAVE_COUNT;
|
||||||
|
|
||||||
|
/* Save general registers.
|
||||||
|
The return address register is the first saved register, all other
|
||||||
|
registers follow in ascending order.
|
||||||
|
The PC is saved immediately below the SP. */
|
||||||
|
save_address = sp + PROC_REG_OFFSET(proc_desc);
|
||||||
|
store_address (raw_buffer, 8, read_register (RA_REGNUM));
|
||||||
|
write_memory (save_address, raw_buffer, 8);
|
||||||
|
save_address += 8;
|
||||||
|
mask = PROC_REG_MASK(proc_desc) & 0xffffffffL;
|
||||||
|
for (ireg = 0; mask; ireg++, mask >>= 1)
|
||||||
|
if (mask & 1)
|
||||||
|
{
|
||||||
|
if (ireg == RA_REGNUM)
|
||||||
|
continue;
|
||||||
|
store_address (raw_buffer, 8, read_register (ireg));
|
||||||
|
write_memory (save_address, raw_buffer, 8);
|
||||||
|
save_address += 8;
|
||||||
|
}
|
||||||
|
|
||||||
|
store_address (raw_buffer, 8, read_register (PC_REGNUM));
|
||||||
|
write_memory (sp - 8, raw_buffer, 8);
|
||||||
|
|
||||||
|
/* Save floating point registers. */
|
||||||
|
save_address = sp + PROC_FREG_OFFSET(proc_desc);
|
||||||
|
mask = PROC_FREG_MASK(proc_desc) & 0xffffffffL;
|
||||||
|
for (ireg = 0; mask; ireg++, mask >>= 1)
|
||||||
|
if (mask & 1)
|
||||||
|
{
|
||||||
|
store_address (raw_buffer, 8, read_register (ireg + FP0_REGNUM));
|
||||||
|
write_memory (save_address, raw_buffer, 8);
|
||||||
|
save_address += 8;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Set and save the frame address for the dummy.
|
||||||
|
This is tricky. The only registers that are suitable for a frame save
|
||||||
|
are those that are preserved across procedure calls (s0-s6). But if
|
||||||
|
a read system call is interrupted and then a dummy call is made
|
||||||
|
(see testsuite/gdb.t17/interrupt.exp) the dummy call hangs till the read
|
||||||
|
is satisfied. Then it returns with the s0-s6 registers set to the values
|
||||||
|
on entry to the read system call and our dummy frame pointer would be
|
||||||
|
destroyed. So we save the dummy frame in the proc_desc and handle the
|
||||||
|
retrieval of the frame pointer of a dummy specifically. The frame register
|
||||||
|
is set to the virtual frame (pseudo) register, it's value will always
|
||||||
|
be read as zero and will help us to catch any errors in the dummy frame
|
||||||
|
retrieval code. */
|
||||||
|
PROC_DUMMY_FRAME(proc_desc) = sp;
|
||||||
|
PROC_FRAME_REG(proc_desc) = FP_REGNUM;
|
||||||
|
PROC_FRAME_OFFSET(proc_desc) = 0;
|
||||||
|
sp += PROC_REG_OFFSET(proc_desc);
|
||||||
|
write_register (SP_REGNUM, sp);
|
||||||
|
|
||||||
|
PROC_LOW_ADDR(proc_desc) = entry_point_address ();
|
||||||
|
PROC_HIGH_ADDR(proc_desc) = PROC_LOW_ADDR(proc_desc) + 4;
|
||||||
|
|
||||||
|
SET_PROC_DESC_IS_DUMMY(proc_desc);
|
||||||
|
PROC_PC_REG(proc_desc) = RA_REGNUM;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
alpha_pop_frame()
|
||||||
|
{
|
||||||
|
register int regnum;
|
||||||
|
FRAME frame = get_current_frame ();
|
||||||
|
CORE_ADDR new_sp = frame->frame;
|
||||||
|
|
||||||
|
alpha_extra_func_info_t proc_desc = frame->proc_desc;
|
||||||
|
|
||||||
|
write_register (PC_REGNUM, FRAME_SAVED_PC(frame));
|
||||||
|
if (proc_desc)
|
||||||
|
{
|
||||||
|
for (regnum = 32; --regnum >= 0; )
|
||||||
|
if (PROC_REG_MASK(proc_desc) & (1 << regnum))
|
||||||
|
write_register (regnum,
|
||||||
|
read_memory_integer (frame->saved_regs->regs[regnum],
|
||||||
|
8));
|
||||||
|
for (regnum = 32; --regnum >= 0; )
|
||||||
|
if (PROC_FREG_MASK(proc_desc) & (1 << regnum))
|
||||||
|
write_register (regnum + FP0_REGNUM,
|
||||||
|
read_memory_integer (frame->saved_regs->regs[regnum + FP0_REGNUM], 8));
|
||||||
|
}
|
||||||
|
write_register (SP_REGNUM, new_sp);
|
||||||
|
flush_cached_frames ();
|
||||||
|
/* We let init_extra_frame_info figure out the frame pointer */
|
||||||
|
set_current_frame (create_new_frame (0, read_pc ()));
|
||||||
|
|
||||||
|
if (proc_desc && PROC_DESC_IS_DUMMY(proc_desc))
|
||||||
|
{
|
||||||
|
struct linked_proc_info *pi_ptr, *prev_ptr;
|
||||||
|
|
||||||
|
for (pi_ptr = linked_proc_desc_table, prev_ptr = NULL;
|
||||||
|
pi_ptr != NULL;
|
||||||
|
prev_ptr = pi_ptr, pi_ptr = pi_ptr->next)
|
||||||
|
{
|
||||||
|
if (&pi_ptr->info == proc_desc)
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (pi_ptr == NULL)
|
||||||
|
error ("Can't locate dummy extra frame info\n");
|
||||||
|
|
||||||
|
if (prev_ptr != NULL)
|
||||||
|
prev_ptr->next = pi_ptr->next;
|
||||||
|
else
|
||||||
|
linked_proc_desc_table = pi_ptr->next;
|
||||||
|
|
||||||
|
free (pi_ptr);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* To skip prologues, I use this predicate. Returns either PC itself
|
||||||
|
if the code at PC does not look like a function prologue; otherwise
|
||||||
|
returns an address that (if we're lucky) follows the prologue. If
|
||||||
|
LENIENT, then we must skip everything which is involved in setting
|
||||||
|
up the frame (it's OK to skip more, just so long as we don't skip
|
||||||
|
anything which might clobber the registers which are being saved.
|
||||||
|
Currently we must not skip more on the alpha, but we might the lenient
|
||||||
|
stuff some day. */
|
||||||
|
|
||||||
|
CORE_ADDR
|
||||||
|
alpha_skip_prologue (pc, lenient)
|
||||||
|
CORE_ADDR pc;
|
||||||
|
int lenient;
|
||||||
|
{
|
||||||
|
unsigned long inst;
|
||||||
|
int offset;
|
||||||
|
|
||||||
|
/* Skip the typical prologue instructions. These are the stack adjustment
|
||||||
|
instruction and the instructions that save registers on the stack
|
||||||
|
or in the gcc frame. */
|
||||||
|
for (offset = 0; offset < 100; offset += 4)
|
||||||
|
{
|
||||||
|
char buf[4];
|
||||||
|
int status;
|
||||||
|
|
||||||
|
status = read_memory_nobpt (pc + offset, buf, 4);
|
||||||
|
if (status)
|
||||||
|
memory_error (status, pc + offset);
|
||||||
|
inst = extract_unsigned_integer (buf, 4);
|
||||||
|
|
||||||
|
/* The alpha has no delay slots. But let's keep the lenient stuff,
|
||||||
|
we might need it for something else in the future. */
|
||||||
|
if (lenient && 0)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
if ((inst & 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
|
||||||
|
continue;
|
||||||
|
if ((inst & 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
|
||||||
|
continue;
|
||||||
|
if ((inst & 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
|
||||||
|
continue;
|
||||||
|
else if ((inst & 0xfc1f0000) == 0xb41e0000
|
||||||
|
&& (inst & 0xffff0000) != 0xb7fe0000)
|
||||||
|
continue; /* stq reg,n($sp) */
|
||||||
|
/* reg != $zero */
|
||||||
|
else if ((inst & 0xfc1f0000) == 0x9c1e0000
|
||||||
|
&& (inst & 0xffff0000) != 0x9ffe0000)
|
||||||
|
continue; /* stt reg,n($sp) */
|
||||||
|
/* reg != $zero */
|
||||||
|
else if (inst == 0x47de040f) /* bis sp,sp,fp */
|
||||||
|
continue;
|
||||||
|
else
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
return pc + offset;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Is address PC in the prologue (loosely defined) for function at
|
||||||
|
STARTADDR? */
|
||||||
|
|
||||||
|
static int
|
||||||
|
alpha_in_lenient_prologue (startaddr, pc)
|
||||||
|
CORE_ADDR startaddr;
|
||||||
|
CORE_ADDR pc;
|
||||||
|
{
|
||||||
|
CORE_ADDR end_prologue = alpha_skip_prologue (startaddr, 1);
|
||||||
|
return pc >= startaddr && pc < end_prologue;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Given a return value in `regbuf' with a type `valtype',
|
||||||
|
extract and copy its value into `valbuf'. */
|
||||||
|
void
|
||||||
|
alpha_extract_return_value (valtype, regbuf, valbuf)
|
||||||
|
struct type *valtype;
|
||||||
|
char regbuf[REGISTER_BYTES];
|
||||||
|
char *valbuf;
|
||||||
|
{
|
||||||
|
int regnum;
|
||||||
|
|
||||||
|
regnum = TYPE_CODE (valtype) == TYPE_CODE_FLT ? FP0_REGNUM : V0_REGNUM;
|
||||||
|
|
||||||
|
memcpy (valbuf, regbuf + REGISTER_BYTE (regnum), TYPE_LENGTH (valtype));
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Given a return value in `regbuf' with a type `valtype',
|
||||||
|
write it's value into the appropriate register. */
|
||||||
|
void
|
||||||
|
alpha_store_return_value (valtype, valbuf)
|
||||||
|
struct type *valtype;
|
||||||
|
char *valbuf;
|
||||||
|
{
|
||||||
|
int regnum;
|
||||||
|
char raw_buffer[MAX_REGISTER_RAW_SIZE];
|
||||||
|
|
||||||
|
regnum = TYPE_CODE (valtype) == TYPE_CODE_FLT ? FP0_REGNUM : V0_REGNUM;
|
||||||
|
memcpy(raw_buffer, valbuf, TYPE_LENGTH (valtype));
|
||||||
|
|
||||||
|
write_register_bytes(REGISTER_BYTE (regnum), raw_buffer, TYPE_LENGTH (valtype));
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Print the instruction at address MEMADDR in debugged memory,
|
||||||
|
on STREAM. Returns length of the instruction, in bytes. */
|
||||||
|
|
||||||
|
int
|
||||||
|
print_insn (memaddr, stream)
|
||||||
|
CORE_ADDR memaddr;
|
||||||
|
FILE *stream;
|
||||||
|
{
|
||||||
|
disassemble_info info;
|
||||||
|
|
||||||
|
GDB_INIT_DISASSEMBLE_INFO(info, stream);
|
||||||
|
|
||||||
|
return print_insn_alpha (memaddr, &info);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Just like reinit_frame_cache, but with the right arguments to be
|
||||||
|
callable as an sfunc. */
|
||||||
|
static void
|
||||||
|
reinit_frame_cache_sfunc (args, from_tty, c)
|
||||||
|
char *args;
|
||||||
|
int from_tty;
|
||||||
|
struct cmd_list_element *c;
|
||||||
|
{
|
||||||
|
reinit_frame_cache ();
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
_initialize_alpha_tdep ()
|
||||||
|
{
|
||||||
|
struct cmd_list_element *c;
|
||||||
|
|
||||||
|
/* Let the user set the fence post for heuristic_proc_start. */
|
||||||
|
|
||||||
|
/* We really would like to have both "0" and "unlimited" work, but
|
||||||
|
command.c doesn't deal with that. So make it a var_zinteger
|
||||||
|
because the user can always use "999999" or some such for unlimited. */
|
||||||
|
c = add_set_cmd ("heuristic-fence-post", class_support, var_zinteger,
|
||||||
|
(char *) &heuristic_fence_post,
|
||||||
|
"\
|
||||||
|
Set the distance searched for the start of a function.\n\
|
||||||
|
If you are debugging a stripped executable, GDB needs to search through the\n\
|
||||||
|
program for the start of a function. This command sets the distance of the\n\
|
||||||
|
search. The only need to set it is when debugging a stripped executable.",
|
||||||
|
&setlist);
|
||||||
|
/* We need to throw away the frame cache when we set this, since it
|
||||||
|
might change our ability to get backtraces. */
|
||||||
|
c->function.sfunc = reinit_frame_cache_sfunc;
|
||||||
|
add_show_from_set (c, &showlist);
|
||||||
|
}
|
||||||
|
|
@ -45,6 +45,12 @@ inside_entry_file (addr)
|
||||||
return 1;
|
return 1;
|
||||||
if (symfile_objfile == 0)
|
if (symfile_objfile == 0)
|
||||||
return 0;
|
return 0;
|
||||||
|
#if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
|
||||||
|
/* Do not stop backtracing if the pc is in the call dummy
|
||||||
|
at the entry point. */
|
||||||
|
if (PC_IN_CALL_DUMMY (addr, 0, 0))
|
||||||
|
return 0;
|
||||||
|
#endif
|
||||||
return (addr >= symfile_objfile -> ei.entry_file_lowpc &&
|
return (addr >= symfile_objfile -> ei.entry_file_lowpc &&
|
||||||
addr < symfile_objfile -> ei.entry_file_highpc);
|
addr < symfile_objfile -> ei.entry_file_highpc);
|
||||||
}
|
}
|
||||||
|
|
@ -85,6 +91,12 @@ CORE_ADDR pc;
|
||||||
return 1;
|
return 1;
|
||||||
if (symfile_objfile == 0)
|
if (symfile_objfile == 0)
|
||||||
return 0;
|
return 0;
|
||||||
|
#if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
|
||||||
|
/* Do not stop backtracing if the pc is in the call dummy
|
||||||
|
at the entry point. */
|
||||||
|
if (PC_IN_CALL_DUMMY (pc, 0, 0))
|
||||||
|
return 0;
|
||||||
|
#endif
|
||||||
return (symfile_objfile -> ei.entry_func_lowpc <= pc &&
|
return (symfile_objfile -> ei.entry_func_lowpc <= pc &&
|
||||||
symfile_objfile -> ei.entry_func_highpc > pc);
|
symfile_objfile -> ei.entry_func_highpc > pc);
|
||||||
}
|
}
|
||||||
|
|
@ -653,7 +665,8 @@ find_pc_partial_function (pc, name, address, endaddr)
|
||||||
goto return_cached_value;
|
goto return_cached_value;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
/* Now that static symbols go in the minimal symbol table, perhaps
|
/* Now that static symbols go in the minimal symbol table, perhaps
|
||||||
we could just ignore the partial symbols. But at least for now
|
we could just ignore the partial symbols. But at least for now
|
||||||
we use the partial or minimal symbol, whichever is larger. */
|
we use the partial or minimal symbol, whichever is larger. */
|
||||||
|
|
@ -661,7 +674,8 @@ find_pc_partial_function (pc, name, address, endaddr)
|
||||||
|
|
||||||
if (psb
|
if (psb
|
||||||
&& (msymbol == NULL ||
|
&& (msymbol == NULL ||
|
||||||
(SYMBOL_VALUE_ADDRESS (psb) >= SYMBOL_VALUE_ADDRESS (msymbol))))
|
(SYMBOL_VALUE_ADDRESS (psb)
|
||||||
|
>= SYMBOL_VALUE_ADDRESS (msymbol))))
|
||||||
{
|
{
|
||||||
/* This case isn't being cached currently. */
|
/* This case isn't being cached currently. */
|
||||||
if (address)
|
if (address)
|
||||||
|
|
@ -672,6 +686,7 @@ find_pc_partial_function (pc, name, address, endaddr)
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
/* Must be in the minimal symbol table. */
|
/* Must be in the minimal symbol table. */
|
||||||
if (msymbol == NULL)
|
if (msymbol == NULL)
|
||||||
|
|
|
||||||
|
|
@ -494,11 +494,11 @@ remove_breakpoints ()
|
||||||
b->inserted = 0;
|
b->inserted = 0;
|
||||||
#ifdef BREAKPOINT_DEBUG
|
#ifdef BREAKPOINT_DEBUG
|
||||||
printf ("Removed breakpoint at %s",
|
printf ("Removed breakpoint at %s",
|
||||||
local_hex_string(b->address));
|
local_hex_string((unsigned long) b->address));
|
||||||
printf (", shadow %s",
|
printf (", shadow %s",
|
||||||
local_hex_string(b->shadow_contents[0]));
|
local_hex_string((unsigned long) b->shadow_contents[0]));
|
||||||
printf (", %s.\n",
|
printf (", %s.\n",
|
||||||
local_hex_string(b->shadow_contents[1]));
|
local_hex_string((unsigned long) b->shadow_contents[1]));
|
||||||
#endif /* BREAKPOINT_DEBUG */
|
#endif /* BREAKPOINT_DEBUG */
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -945,8 +945,8 @@ watchpoint_check (p)
|
||||||
{
|
{
|
||||||
/* We use value_{,free_to_}mark because it could be a
|
/* We use value_{,free_to_}mark because it could be a
|
||||||
*long* time before we return to the command level and
|
*long* time before we return to the command level and
|
||||||
call free_all_values. */
|
call free_all_values. We can't call free_all_values because
|
||||||
/* But couldn't we just call free_all_values instead? */
|
we might be in the middle of evaluating a function call. */
|
||||||
|
|
||||||
value mark = value_mark ();
|
value mark = value_mark ();
|
||||||
value new_val = evaluate_expression (bs->breakpoint_at->exp);
|
value new_val = evaluate_expression (bs->breakpoint_at->exp);
|
||||||
|
|
@ -1252,6 +1252,8 @@ bpstat_what (bs)
|
||||||
enum bpstat_what_main_action current_action = BPSTAT_WHAT_KEEP_CHECKING;
|
enum bpstat_what_main_action current_action = BPSTAT_WHAT_KEEP_CHECKING;
|
||||||
struct bpstat_what retval;
|
struct bpstat_what retval;
|
||||||
|
|
||||||
|
retval.call_dummy = 0;
|
||||||
|
retval.step_resume = 0;
|
||||||
for (; bs != NULL; bs = bs->next)
|
for (; bs != NULL; bs = bs->next)
|
||||||
{
|
{
|
||||||
enum class bs_class = no_effect;
|
enum class bs_class = no_effect;
|
||||||
|
|
@ -1396,7 +1398,7 @@ breakpoint_1 (bnum, allflag)
|
||||||
case bp_step_resume:
|
case bp_step_resume:
|
||||||
case bp_call_dummy:
|
case bp_call_dummy:
|
||||||
if (addressprint)
|
if (addressprint)
|
||||||
printf_filtered ("%s ", local_hex_string_custom(b->address, "08"));
|
printf_filtered ("%s ", local_hex_string_custom ((unsigned long) b->address, "08l"));
|
||||||
|
|
||||||
last_addr = b->address;
|
last_addr = b->address;
|
||||||
if (b->source_file)
|
if (b->source_file)
|
||||||
|
|
@ -1421,7 +1423,7 @@ breakpoint_1 (bnum, allflag)
|
||||||
|
|
||||||
if (b->frame)
|
if (b->frame)
|
||||||
printf_filtered ("\tstop only in stack frame at %s\n",
|
printf_filtered ("\tstop only in stack frame at %s\n",
|
||||||
local_hex_string(b->frame));
|
local_hex_string((unsigned long) b->frame));
|
||||||
if (b->cond)
|
if (b->cond)
|
||||||
{
|
{
|
||||||
printf_filtered ("\tstop only if ");
|
printf_filtered ("\tstop only if ");
|
||||||
|
|
@ -1510,7 +1512,7 @@ describe_other_breakpoints (pc)
|
||||||
(b->enable == disabled) ? " (disabled)" : "",
|
(b->enable == disabled) ? " (disabled)" : "",
|
||||||
(others > 1) ? "," : ((others == 1) ? " and" : ""));
|
(others > 1) ? "," : ((others == 1) ? " and" : ""));
|
||||||
}
|
}
|
||||||
printf ("also set at pc %s.\n", local_hex_string(pc));
|
printf ("also set at pc %s.\n", local_hex_string((unsigned long) pc));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -1744,7 +1746,7 @@ mention (b)
|
||||||
break;
|
break;
|
||||||
case bp_breakpoint:
|
case bp_breakpoint:
|
||||||
printf_filtered ("Breakpoint %d at %s", b->number,
|
printf_filtered ("Breakpoint %d at %s", b->number,
|
||||||
local_hex_string(b->address));
|
local_hex_string((unsigned long) b->address));
|
||||||
if (b->source_file)
|
if (b->source_file)
|
||||||
printf_filtered (": file %s, line %d.",
|
printf_filtered (": file %s, line %d.",
|
||||||
b->source_file, b->line_number);
|
b->source_file, b->line_number);
|
||||||
|
|
@ -2503,7 +2505,8 @@ breakpoint_auto_delete (bs)
|
||||||
bpstat bs;
|
bpstat bs;
|
||||||
{
|
{
|
||||||
for (; bs; bs = bs->next)
|
for (; bs; bs = bs->next)
|
||||||
if (bs->breakpoint_at && bs->breakpoint_at->disposition == delete)
|
if (bs->breakpoint_at && bs->breakpoint_at->disposition == delete
|
||||||
|
&& bs->stop)
|
||||||
delete_breakpoint (bs->breakpoint_at);
|
delete_breakpoint (bs->breakpoint_at);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -130,6 +130,7 @@ hostfile=`awk '$1 == "XM_FILE=" { print $2 }' <${srcdir}/config/${gdb_host_cpu}/
|
||||||
|
|
||||||
case "${target_cpu}" in
|
case "${target_cpu}" in
|
||||||
|
|
||||||
|
alpha) gdb_target_cpu=alpha ;;
|
||||||
c[12]) gdb_target_cpu=convex ;;
|
c[12]) gdb_target_cpu=convex ;;
|
||||||
hppa*) gdb_target_cpu=pa ;;
|
hppa*) gdb_target_cpu=pa ;;
|
||||||
i[34]86) gdb_target_cpu=i386 ;;
|
i[34]86) gdb_target_cpu=i386 ;;
|
||||||
|
|
@ -159,6 +160,8 @@ a29k-*-none) gdb_target=a29k ;;
|
||||||
a29k-*-sym1) gdb_target=ultra3 ;;
|
a29k-*-sym1) gdb_target=ultra3 ;;
|
||||||
a29k-*-udi) gdb_target=a29k-udi ;;
|
a29k-*-udi) gdb_target=a29k-udi ;;
|
||||||
|
|
||||||
|
alpha-*-osf*) gdb_target=alpha-osf1 ;;
|
||||||
|
|
||||||
arm-*-*) gdb_target=arm ;;
|
arm-*-*) gdb_target=arm ;;
|
||||||
|
|
||||||
c1-*-*) gdb_target=convex ;;
|
c1-*-*) gdb_target=convex ;;
|
||||||
|
|
|
||||||
10
gdb/infrun.c
10
gdb/infrun.c
|
|
@ -283,6 +283,14 @@ resume (step, sig)
|
||||||
struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
|
struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
|
||||||
QUIT;
|
QUIT;
|
||||||
|
|
||||||
|
#ifdef CANNOT_STEP_BREAKPOINT
|
||||||
|
/* Most targets can step a breakpoint instruction, thus executing it
|
||||||
|
normally. But if this one cannot, just continue and we will hit
|
||||||
|
it anyway. */
|
||||||
|
if (step && breakpoints_inserted && breakpoint_here_p (read_pc ()))
|
||||||
|
step = 0;
|
||||||
|
#endif
|
||||||
|
|
||||||
#ifdef NO_SINGLE_STEP
|
#ifdef NO_SINGLE_STEP
|
||||||
if (step) {
|
if (step) {
|
||||||
single_step(sig); /* Do it the hard way, w/temp breakpoints */
|
single_step(sig); /* Do it the hard way, w/temp breakpoints */
|
||||||
|
|
@ -1255,6 +1263,8 @@ step_into_function:
|
||||||
/* I'm not sure when this following segment applies. I do know, now,
|
/* I'm not sure when this following segment applies. I do know, now,
|
||||||
that we shouldn't rewrite the regs when we were stopped by a
|
that we shouldn't rewrite the regs when we were stopped by a
|
||||||
random signal from the inferior process. */
|
random signal from the inferior process. */
|
||||||
|
/* FIXME: Shouldn't this be based on the valid bit of the SXIP?
|
||||||
|
(this is only used on the 88k). */
|
||||||
|
|
||||||
if (!bpstat_explains_signal (stop_bpstat)
|
if (!bpstat_explains_signal (stop_bpstat)
|
||||||
&& (stop_signal != SIGCLD)
|
&& (stop_signal != SIGCLD)
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,786 @@
|
||||||
|
/* Handle OSF/1 shared libraries for GDB, the GNU Debugger.
|
||||||
|
Copyright 1993 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||||
|
|
||||||
|
/* FIXME: Most of this code could be merged with solib.c by using
|
||||||
|
next_link_map_member and xfer_link_map_member in solib.c. */
|
||||||
|
|
||||||
|
#include "defs.h"
|
||||||
|
|
||||||
|
#include <sys/types.h>
|
||||||
|
#include <signal.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <fcntl.h>
|
||||||
|
|
||||||
|
#include "symtab.h"
|
||||||
|
#include "bfd.h"
|
||||||
|
#include "symfile.h"
|
||||||
|
#include "objfiles.h"
|
||||||
|
#include "gdbcore.h"
|
||||||
|
#include "command.h"
|
||||||
|
#include "target.h"
|
||||||
|
#include "frame.h"
|
||||||
|
#include "regex.h"
|
||||||
|
#include "inferior.h"
|
||||||
|
#include "language.h"
|
||||||
|
|
||||||
|
#define MAX_PATH_SIZE 256 /* FIXME: Should be dynamic */
|
||||||
|
|
||||||
|
/* FIXME: This is a terrible hack for shared library support under OSF/1.
|
||||||
|
The main problem is that the needed definitions are not contained in
|
||||||
|
the system header files.
|
||||||
|
The ldr_* routines described in loader(3) would be the way to go here.
|
||||||
|
But they do not work for arbitrary target processes (as documented). */
|
||||||
|
|
||||||
|
#ifndef USE_LDR_ROUTINES
|
||||||
|
#define RLD_CONTEXT_ADDRESS 0x3ffc0000000
|
||||||
|
|
||||||
|
typedef struct
|
||||||
|
{
|
||||||
|
CORE_ADDR next;
|
||||||
|
CORE_ADDR previous;
|
||||||
|
CORE_ADDR unknown;
|
||||||
|
char *module_name;
|
||||||
|
CORE_ADDR modinfo_addr;
|
||||||
|
} ldr_module_info_t;
|
||||||
|
|
||||||
|
typedef struct
|
||||||
|
{
|
||||||
|
CORE_ADDR unknown1;
|
||||||
|
CORE_ADDR unknown2;
|
||||||
|
CORE_ADDR head;
|
||||||
|
CORE_ADDR tail;
|
||||||
|
} ldr_context_t;
|
||||||
|
|
||||||
|
static ldr_context_t ldr_context;
|
||||||
|
#else
|
||||||
|
#include <loader.h>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* Define our own link_map structure.
|
||||||
|
This will help to share code with solib.c. */
|
||||||
|
|
||||||
|
struct link_map {
|
||||||
|
CORE_ADDR l_addr; /* address at which object mapped */
|
||||||
|
char *l_name; /* full name of loaded object */
|
||||||
|
ldr_module_info_t module_info; /* corresponding module info */
|
||||||
|
};
|
||||||
|
|
||||||
|
#define LM_ADDR(so) ((so) -> lm.l_addr)
|
||||||
|
#define LM_NAME(so) ((so) -> lm.l_name)
|
||||||
|
|
||||||
|
struct so_list {
|
||||||
|
struct so_list *next; /* next structure in linked list */
|
||||||
|
struct link_map lm; /* copy of link map from inferior */
|
||||||
|
struct link_map *lmaddr; /* addr in inferior lm was read from */
|
||||||
|
CORE_ADDR lmend; /* upper addr bound of mapped object */
|
||||||
|
char so_name[MAX_PATH_SIZE]; /* shared object lib name (FIXME) */
|
||||||
|
char symbols_loaded; /* flag: symbols read in yet? */
|
||||||
|
char from_tty; /* flag: print msgs? */
|
||||||
|
struct objfile *objfile; /* objfile for loaded lib */
|
||||||
|
struct section_table *sections;
|
||||||
|
struct section_table *sections_end;
|
||||||
|
struct section_table *textsection;
|
||||||
|
bfd *bfd;
|
||||||
|
};
|
||||||
|
|
||||||
|
static struct so_list *so_list_head; /* List of known shared objects */
|
||||||
|
|
||||||
|
extern int
|
||||||
|
fdmatch PARAMS ((int, int)); /* In libiberty */
|
||||||
|
|
||||||
|
/* Local function prototypes */
|
||||||
|
|
||||||
|
static void
|
||||||
|
sharedlibrary_command PARAMS ((char *, int));
|
||||||
|
|
||||||
|
static void
|
||||||
|
info_sharedlibrary_command PARAMS ((char *, int));
|
||||||
|
|
||||||
|
static int
|
||||||
|
symbol_add_stub PARAMS ((char *));
|
||||||
|
|
||||||
|
static struct so_list *
|
||||||
|
find_solib PARAMS ((struct so_list *));
|
||||||
|
|
||||||
|
static struct link_map *
|
||||||
|
first_link_map_member PARAMS ((void));
|
||||||
|
|
||||||
|
static struct link_map *
|
||||||
|
next_link_map_member PARAMS ((struct so_list *));
|
||||||
|
|
||||||
|
static void
|
||||||
|
xfer_link_map_member PARAMS ((struct so_list *, struct link_map *));
|
||||||
|
|
||||||
|
static void
|
||||||
|
solib_map_sections PARAMS ((struct so_list *));
|
||||||
|
|
||||||
|
void
|
||||||
|
_initialize_solib PARAMS ((void));
|
||||||
|
|
||||||
|
/*
|
||||||
|
|
||||||
|
LOCAL FUNCTION
|
||||||
|
|
||||||
|
solib_map_sections -- open bfd and build sections for shared lib
|
||||||
|
|
||||||
|
SYNOPSIS
|
||||||
|
|
||||||
|
static void solib_map_sections (struct so_list *so)
|
||||||
|
|
||||||
|
DESCRIPTION
|
||||||
|
|
||||||
|
Given a pointer to one of the shared objects in our list
|
||||||
|
of mapped objects, use the recorded name to open a bfd
|
||||||
|
descriptor for the object, build a section table, and then
|
||||||
|
relocate all the section addresses by the base address at
|
||||||
|
which the shared object was mapped.
|
||||||
|
|
||||||
|
FIXMES
|
||||||
|
|
||||||
|
In most (all?) cases the shared object file name recorded in the
|
||||||
|
dynamic linkage tables will be a fully qualified pathname. For
|
||||||
|
cases where it isn't, do we really mimic the systems search
|
||||||
|
mechanism correctly in the below code (particularly the tilde
|
||||||
|
expansion stuff?).
|
||||||
|
*/
|
||||||
|
|
||||||
|
static void
|
||||||
|
solib_map_sections (so)
|
||||||
|
struct so_list *so;
|
||||||
|
{
|
||||||
|
char *filename;
|
||||||
|
char *scratch_pathname;
|
||||||
|
int scratch_chan;
|
||||||
|
struct section_table *p;
|
||||||
|
struct cleanup *old_chain;
|
||||||
|
bfd *abfd;
|
||||||
|
|
||||||
|
filename = tilde_expand (so -> so_name);
|
||||||
|
old_chain = make_cleanup (free, filename);
|
||||||
|
|
||||||
|
scratch_chan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
|
||||||
|
&scratch_pathname);
|
||||||
|
if (scratch_chan < 0)
|
||||||
|
{
|
||||||
|
scratch_chan = openp (getenv ("LD_LIBRARY_PATH"), 1, filename,
|
||||||
|
O_RDONLY, 0, &scratch_pathname);
|
||||||
|
}
|
||||||
|
if (scratch_chan < 0)
|
||||||
|
{
|
||||||
|
perror_with_name (filename);
|
||||||
|
}
|
||||||
|
/* Leave scratch_pathname allocated. bfd->name will point to it. */
|
||||||
|
|
||||||
|
abfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan);
|
||||||
|
if (!abfd)
|
||||||
|
{
|
||||||
|
close (scratch_chan);
|
||||||
|
error ("Could not open `%s' as an executable file: %s",
|
||||||
|
scratch_pathname, bfd_errmsg (bfd_error));
|
||||||
|
}
|
||||||
|
/* Leave bfd open, core_xfer_memory and "info files" need it. */
|
||||||
|
so -> bfd = abfd;
|
||||||
|
abfd -> cacheable = true;
|
||||||
|
|
||||||
|
if (!bfd_check_format (abfd, bfd_object))
|
||||||
|
{
|
||||||
|
error ("\"%s\": not in executable format: %s.",
|
||||||
|
scratch_pathname, bfd_errmsg (bfd_error));
|
||||||
|
}
|
||||||
|
if (build_section_table (abfd, &so -> sections, &so -> sections_end))
|
||||||
|
{
|
||||||
|
error ("Can't find the file sections in `%s': %s",
|
||||||
|
bfd_get_filename (exec_bfd), bfd_errmsg (bfd_error));
|
||||||
|
}
|
||||||
|
|
||||||
|
for (p = so -> sections; p < so -> sections_end; p++)
|
||||||
|
{
|
||||||
|
/* Relocate the section binding addresses as recorded in the shared
|
||||||
|
object's file by the base address to which the object was actually
|
||||||
|
mapped. */
|
||||||
|
p -> addr += (CORE_ADDR) LM_ADDR (so);
|
||||||
|
p -> endaddr += (CORE_ADDR) LM_ADDR (so);
|
||||||
|
so -> lmend = (CORE_ADDR) max (p -> endaddr, so -> lmend);
|
||||||
|
if (STREQ (p -> sec_ptr -> name, ".text"))
|
||||||
|
{
|
||||||
|
so -> textsection = p;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Free the file names, close the file now. */
|
||||||
|
do_cleanups (old_chain);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
|
||||||
|
LOCAL FUNCTION
|
||||||
|
|
||||||
|
first_link_map_member -- locate first member in dynamic linker's map
|
||||||
|
|
||||||
|
SYNOPSIS
|
||||||
|
|
||||||
|
static struct link_map *first_link_map_member (void)
|
||||||
|
|
||||||
|
DESCRIPTION
|
||||||
|
|
||||||
|
Read in a copy of the first member in the inferior's dynamic
|
||||||
|
link map from the inferior's dynamic linker structures, and return
|
||||||
|
a pointer to the copy in our address space.
|
||||||
|
*/
|
||||||
|
|
||||||
|
static struct link_map *
|
||||||
|
first_link_map_member ()
|
||||||
|
{
|
||||||
|
struct link_map *lm = NULL;
|
||||||
|
static struct link_map first_lm;
|
||||||
|
|
||||||
|
#ifdef USE_LDR_ROUTINES
|
||||||
|
ldr_module_t mod_id = LDR_NULL_MODULE;
|
||||||
|
size_t retsize;
|
||||||
|
|
||||||
|
if (ldr_next_module(inferior_pid, &mod_id) != 0
|
||||||
|
|| mod_id == LDR_NULL_MODULE
|
||||||
|
|| ldr_inq_module(inferior_pid, mod_id,
|
||||||
|
&first_lm.module_info, sizeof(ldr_module_info_t),
|
||||||
|
&retsize) != 0)
|
||||||
|
return lm;
|
||||||
|
#else
|
||||||
|
CORE_ADDR ldr_context_addr;
|
||||||
|
|
||||||
|
if (target_read_memory ((CORE_ADDR) RLD_CONTEXT_ADDRESS,
|
||||||
|
(char *) &ldr_context_addr,
|
||||||
|
sizeof (CORE_ADDR)) != 0
|
||||||
|
|| target_read_memory (ldr_context_addr,
|
||||||
|
(char *) &ldr_context,
|
||||||
|
sizeof (ldr_context_t)) != 0
|
||||||
|
|| target_read_memory ((CORE_ADDR) ldr_context.head,
|
||||||
|
(char *) &first_lm.module_info,
|
||||||
|
sizeof (ldr_module_info_t)) != 0)
|
||||||
|
return lm;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
lm = &first_lm;
|
||||||
|
|
||||||
|
/* The first entry is for the main program and should be skipped. */
|
||||||
|
lm->l_name = NULL;
|
||||||
|
|
||||||
|
return lm;
|
||||||
|
}
|
||||||
|
|
||||||
|
static struct link_map *
|
||||||
|
next_link_map_member (so_list_ptr)
|
||||||
|
struct so_list *so_list_ptr;
|
||||||
|
{
|
||||||
|
struct link_map *lm = NULL;
|
||||||
|
static struct link_map next_lm;
|
||||||
|
#ifdef USE_LDR_ROUTINES
|
||||||
|
ldr_module_t mod_id = lm->module_info.lmi_modid;
|
||||||
|
size_t retsize;
|
||||||
|
|
||||||
|
if (ldr_next_module(inferior_pid, &mod_id) != 0
|
||||||
|
|| mod_id == LDR_NULL_MODULE
|
||||||
|
|| ldr_inq_module(inferior_pid, mod_id,
|
||||||
|
&next_lm.module_info, sizeof(ldr_module_info_t),
|
||||||
|
&retsize) != 0)
|
||||||
|
return lm;
|
||||||
|
|
||||||
|
lm = &next_lm;
|
||||||
|
lm->l_name = lm->module_info.lmi_name;
|
||||||
|
#else
|
||||||
|
CORE_ADDR ldr_context_addr;
|
||||||
|
|
||||||
|
/* Reread context in case ldr_context.tail was updated. */
|
||||||
|
|
||||||
|
if (target_read_memory ((CORE_ADDR) RLD_CONTEXT_ADDRESS,
|
||||||
|
(char *) &ldr_context_addr,
|
||||||
|
sizeof (CORE_ADDR)) != 0
|
||||||
|
|| target_read_memory (ldr_context_addr,
|
||||||
|
(char *) &ldr_context,
|
||||||
|
sizeof (ldr_context_t)) != 0
|
||||||
|
|| so_list_ptr->lm.module_info.modinfo_addr == ldr_context.tail
|
||||||
|
|| target_read_memory (so_list_ptr->lm.module_info.next,
|
||||||
|
(char *) &next_lm.module_info,
|
||||||
|
sizeof (ldr_module_info_t)) != 0)
|
||||||
|
return lm;
|
||||||
|
|
||||||
|
lm = &next_lm;
|
||||||
|
lm->l_name = lm->module_info.module_name;
|
||||||
|
#endif
|
||||||
|
return lm;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
xfer_link_map_member (so_list_ptr, lm)
|
||||||
|
struct so_list *so_list_ptr;
|
||||||
|
struct link_map *lm;
|
||||||
|
{
|
||||||
|
so_list_ptr->lm = *lm;
|
||||||
|
|
||||||
|
/* OSF/1 has absolute addresses in shared libraries. */
|
||||||
|
LM_ADDR (so_list_ptr) = 0;
|
||||||
|
|
||||||
|
/* There is one entry that has no name (for the inferior executable)
|
||||||
|
since it is not a shared object. */
|
||||||
|
if (LM_NAME (so_list_ptr) != 0)
|
||||||
|
{
|
||||||
|
|
||||||
|
#ifdef USE_LDR_ROUTINES
|
||||||
|
int len = strlen (LM_NAME (so_list_ptr) + 1);
|
||||||
|
|
||||||
|
if (len > MAX_PATH_SIZE)
|
||||||
|
len = MAX_PATH_SIZE;
|
||||||
|
strncpy (so_list_ptr->so_name, LM_NAME (so_list_ptr), MAX_PATH_SIZE);
|
||||||
|
#else
|
||||||
|
if (!target_read_string((CORE_ADDR) LM_NAME (so_list_ptr),
|
||||||
|
so_list_ptr->so_name, MAX_PATH_SIZE - 1))
|
||||||
|
error ("xfer_link_map_member: Can't read pathname for load map\n");
|
||||||
|
#endif
|
||||||
|
so_list_ptr->so_name[MAX_PATH_SIZE - 1] = 0;
|
||||||
|
|
||||||
|
solib_map_sections (so_list_ptr);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
|
||||||
|
LOCAL FUNCTION
|
||||||
|
|
||||||
|
find_solib -- step through list of shared objects
|
||||||
|
|
||||||
|
SYNOPSIS
|
||||||
|
|
||||||
|
struct so_list *find_solib (struct so_list *so_list_ptr)
|
||||||
|
|
||||||
|
DESCRIPTION
|
||||||
|
|
||||||
|
This module contains the routine which finds the names of any
|
||||||
|
loaded "images" in the current process. The argument in must be
|
||||||
|
NULL on the first call, and then the returned value must be passed
|
||||||
|
in on subsequent calls. This provides the capability to "step" down
|
||||||
|
the list of loaded objects. On the last object, a NULL value is
|
||||||
|
returned.
|
||||||
|
|
||||||
|
The arg and return value are "struct link_map" pointers, as defined
|
||||||
|
in <link.h>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
static struct so_list *
|
||||||
|
find_solib (so_list_ptr)
|
||||||
|
struct so_list *so_list_ptr; /* Last lm or NULL for first one */
|
||||||
|
{
|
||||||
|
struct so_list *so_list_next = NULL;
|
||||||
|
struct link_map *lm = NULL;
|
||||||
|
struct so_list *new;
|
||||||
|
|
||||||
|
if (so_list_ptr == NULL)
|
||||||
|
{
|
||||||
|
/* We are setting up for a new scan through the loaded images. */
|
||||||
|
if ((so_list_next = so_list_head) == NULL)
|
||||||
|
{
|
||||||
|
/* Find the first link map list member. */
|
||||||
|
lm = first_link_map_member ();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
/* We have been called before, and are in the process of walking
|
||||||
|
the shared library list. Advance to the next shared object. */
|
||||||
|
lm = next_link_map_member (so_list_ptr);
|
||||||
|
so_list_next = so_list_ptr -> next;
|
||||||
|
}
|
||||||
|
if ((so_list_next == NULL) && (lm != NULL))
|
||||||
|
{
|
||||||
|
/* Get next link map structure from inferior image and build a local
|
||||||
|
abbreviated load_map structure */
|
||||||
|
new = (struct so_list *) xmalloc (sizeof (struct so_list));
|
||||||
|
memset ((char *) new, 0, sizeof (struct so_list));
|
||||||
|
new -> lmaddr = lm;
|
||||||
|
/* Add the new node as the next node in the list, or as the root
|
||||||
|
node if this is the first one. */
|
||||||
|
if (so_list_ptr != NULL)
|
||||||
|
{
|
||||||
|
so_list_ptr -> next = new;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
so_list_head = new;
|
||||||
|
}
|
||||||
|
so_list_next = new;
|
||||||
|
xfer_link_map_member (new, lm);
|
||||||
|
}
|
||||||
|
return (so_list_next);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* A small stub to get us past the arg-passing pinhole of catch_errors. */
|
||||||
|
|
||||||
|
static int
|
||||||
|
symbol_add_stub (arg)
|
||||||
|
char *arg;
|
||||||
|
{
|
||||||
|
register struct so_list *so = (struct so_list *) arg; /* catch_errs bogon */
|
||||||
|
|
||||||
|
so -> objfile = symbol_file_add (so -> so_name, so -> from_tty,
|
||||||
|
so -> textsection -> addr,
|
||||||
|
0, 0, 0);
|
||||||
|
return (1);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
|
||||||
|
GLOBAL FUNCTION
|
||||||
|
|
||||||
|
solib_add -- add a shared library file to the symtab and section list
|
||||||
|
|
||||||
|
SYNOPSIS
|
||||||
|
|
||||||
|
void solib_add (char *arg_string, int from_tty,
|
||||||
|
struct target_ops *target)
|
||||||
|
|
||||||
|
DESCRIPTION
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
void
|
||||||
|
solib_add (arg_string, from_tty, target)
|
||||||
|
char *arg_string;
|
||||||
|
int from_tty;
|
||||||
|
struct target_ops *target;
|
||||||
|
{
|
||||||
|
register struct so_list *so = NULL; /* link map state variable */
|
||||||
|
|
||||||
|
/* Last shared library that we read. */
|
||||||
|
struct so_list *so_last = NULL;
|
||||||
|
|
||||||
|
char *re_err;
|
||||||
|
int count;
|
||||||
|
int old;
|
||||||
|
|
||||||
|
if ((re_err = re_comp (arg_string ? arg_string : ".")) != NULL)
|
||||||
|
{
|
||||||
|
error ("Invalid regexp: %s", re_err);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* Add the shared library sections to the section table of the
|
||||||
|
specified target, if any. We have to do this before reading the
|
||||||
|
symbol files as symbol_file_add calls reinit_frame_cache and
|
||||||
|
creating a new frame might access memory in the shared library. */
|
||||||
|
if (target)
|
||||||
|
{
|
||||||
|
/* Count how many new section_table entries there are. */
|
||||||
|
so = NULL;
|
||||||
|
count = 0;
|
||||||
|
while ((so = find_solib (so)) != NULL)
|
||||||
|
{
|
||||||
|
if (so -> so_name[0])
|
||||||
|
{
|
||||||
|
count += so -> sections_end - so -> sections;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (count)
|
||||||
|
{
|
||||||
|
/* Reallocate the target's section table including the new size. */
|
||||||
|
if (target -> to_sections)
|
||||||
|
{
|
||||||
|
old = target -> to_sections_end - target -> to_sections;
|
||||||
|
target -> to_sections = (struct section_table *)
|
||||||
|
xrealloc ((char *)target -> to_sections,
|
||||||
|
(sizeof (struct section_table)) * (count + old));
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
old = 0;
|
||||||
|
target -> to_sections = (struct section_table *)
|
||||||
|
xmalloc ((sizeof (struct section_table)) * count);
|
||||||
|
}
|
||||||
|
target -> to_sections_end = target -> to_sections + (count + old);
|
||||||
|
|
||||||
|
/* Add these section table entries to the target's table. */
|
||||||
|
while ((so = find_solib (so)) != NULL)
|
||||||
|
{
|
||||||
|
if (so -> so_name[0])
|
||||||
|
{
|
||||||
|
count = so -> sections_end - so -> sections;
|
||||||
|
memcpy ((char *) (target -> to_sections + old),
|
||||||
|
so -> sections,
|
||||||
|
(sizeof (struct section_table)) * count);
|
||||||
|
old += count;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Now add the symbol files. */
|
||||||
|
so = NULL;
|
||||||
|
while ((so = find_solib (so)) != NULL)
|
||||||
|
{
|
||||||
|
if (so -> so_name[0] && re_exec (so -> so_name))
|
||||||
|
{
|
||||||
|
so -> from_tty = from_tty;
|
||||||
|
if (so -> symbols_loaded)
|
||||||
|
{
|
||||||
|
if (from_tty)
|
||||||
|
{
|
||||||
|
printf ("Symbols already loaded for %s\n", so -> so_name);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if (catch_errors
|
||||||
|
(symbol_add_stub, (char *) so,
|
||||||
|
"Error while reading shared library symbols:\n",
|
||||||
|
RETURN_MASK_ALL))
|
||||||
|
{
|
||||||
|
so_last = so;
|
||||||
|
so -> symbols_loaded = 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
|
||||||
|
LOCAL FUNCTION
|
||||||
|
|
||||||
|
info_sharedlibrary_command -- code for "info sharedlibrary"
|
||||||
|
|
||||||
|
SYNOPSIS
|
||||||
|
|
||||||
|
static void info_sharedlibrary_command ()
|
||||||
|
|
||||||
|
DESCRIPTION
|
||||||
|
|
||||||
|
Walk through the shared library list and print information
|
||||||
|
about each attached library.
|
||||||
|
*/
|
||||||
|
|
||||||
|
static void
|
||||||
|
info_sharedlibrary_command (ignore, from_tty)
|
||||||
|
char *ignore;
|
||||||
|
int from_tty;
|
||||||
|
{
|
||||||
|
register struct so_list *so = NULL; /* link map state variable */
|
||||||
|
int header_done = 0;
|
||||||
|
|
||||||
|
if (exec_bfd == NULL)
|
||||||
|
{
|
||||||
|
printf ("No exec file.\n");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
while ((so = find_solib (so)) != NULL)
|
||||||
|
{
|
||||||
|
if (so -> so_name[0])
|
||||||
|
{
|
||||||
|
unsigned long txt_start = 0;
|
||||||
|
unsigned long txt_end = 0;
|
||||||
|
|
||||||
|
if (!header_done)
|
||||||
|
{
|
||||||
|
printf("%-20s%-20s%-12s%s\n", "From", "To", "Syms Read",
|
||||||
|
"Shared Object Library");
|
||||||
|
header_done++;
|
||||||
|
}
|
||||||
|
if (so -> textsection)
|
||||||
|
{
|
||||||
|
txt_start = (unsigned long) so -> textsection -> addr;
|
||||||
|
txt_end = (unsigned long) so -> textsection -> endaddr;
|
||||||
|
}
|
||||||
|
printf ("%-20s", local_hex_string_custom (txt_start, "08l"));
|
||||||
|
printf ("%-20s", local_hex_string_custom (txt_end, "08l"));
|
||||||
|
printf ("%-12s", so -> symbols_loaded ? "Yes" : "No");
|
||||||
|
printf ("%s\n", so -> so_name);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (so_list_head == NULL)
|
||||||
|
{
|
||||||
|
printf ("No shared libraries loaded at this time.\n");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
|
||||||
|
GLOBAL FUNCTION
|
||||||
|
|
||||||
|
solib_address -- check to see if an address is in a shared lib
|
||||||
|
|
||||||
|
SYNOPSIS
|
||||||
|
|
||||||
|
int solib_address (CORE_ADDR address)
|
||||||
|
|
||||||
|
DESCRIPTION
|
||||||
|
|
||||||
|
Provides a hook for other gdb routines to discover whether or
|
||||||
|
not a particular address is within the mapped address space of
|
||||||
|
a shared library. Any address between the base mapping address
|
||||||
|
and the first address beyond the end of the last mapping, is
|
||||||
|
considered to be within the shared library address space, for
|
||||||
|
our purposes.
|
||||||
|
|
||||||
|
For example, this routine is called at one point to disable
|
||||||
|
breakpoints which are in shared libraries that are not currently
|
||||||
|
mapped in.
|
||||||
|
*/
|
||||||
|
|
||||||
|
int
|
||||||
|
solib_address (address)
|
||||||
|
CORE_ADDR address;
|
||||||
|
{
|
||||||
|
register struct so_list *so = 0; /* link map state variable */
|
||||||
|
|
||||||
|
while ((so = find_solib (so)) != NULL)
|
||||||
|
{
|
||||||
|
if (so -> so_name[0] && so -> textsection)
|
||||||
|
{
|
||||||
|
if ((address >= (CORE_ADDR) so -> textsection -> addr) &&
|
||||||
|
(address < (CORE_ADDR) so -> textsection -> endaddr))
|
||||||
|
{
|
||||||
|
return (1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return (0);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Called by free_all_symtabs */
|
||||||
|
|
||||||
|
void
|
||||||
|
clear_solib()
|
||||||
|
{
|
||||||
|
struct so_list *next;
|
||||||
|
char *bfd_filename;
|
||||||
|
|
||||||
|
while (so_list_head)
|
||||||
|
{
|
||||||
|
if (so_list_head -> sections)
|
||||||
|
{
|
||||||
|
free ((PTR)so_list_head -> sections);
|
||||||
|
}
|
||||||
|
if (so_list_head -> bfd)
|
||||||
|
{
|
||||||
|
bfd_filename = bfd_get_filename (so_list_head -> bfd);
|
||||||
|
bfd_close (so_list_head -> bfd);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
/* This happens for the executable on SVR4. */
|
||||||
|
bfd_filename = NULL;
|
||||||
|
|
||||||
|
next = so_list_head -> next;
|
||||||
|
if (bfd_filename)
|
||||||
|
free ((PTR)bfd_filename);
|
||||||
|
free ((PTR)so_list_head);
|
||||||
|
so_list_head = next;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
|
||||||
|
GLOBAL FUNCTION
|
||||||
|
|
||||||
|
solib_create_inferior_hook -- shared library startup support
|
||||||
|
|
||||||
|
SYNOPSIS
|
||||||
|
|
||||||
|
void solib_create_inferior_hook()
|
||||||
|
|
||||||
|
DESCRIPTION
|
||||||
|
|
||||||
|
When gdb starts up the inferior, it nurses it along (through the
|
||||||
|
shell) until it is ready to execute it's first instruction. At this
|
||||||
|
point, this function gets called via expansion of the macro
|
||||||
|
SOLIB_CREATE_INFERIOR_HOOK.
|
||||||
|
For a statically bound executable, this first instruction is the
|
||||||
|
one at "_start", or a similar text label. No further processing is
|
||||||
|
needed in that case.
|
||||||
|
For a dynamically bound executable, this first instruction is somewhere
|
||||||
|
in the rld, and the actual user executable is not yet mapped in.
|
||||||
|
We continue the inferior again, rld then maps in the actual user
|
||||||
|
executable and any needed shared libraries and then sends
|
||||||
|
itself a SIGTRAP.
|
||||||
|
At that point we discover the names of all shared libraries and
|
||||||
|
read their symbols in.
|
||||||
|
|
||||||
|
FIXME
|
||||||
|
|
||||||
|
This code does not properly handle hitting breakpoints which the
|
||||||
|
user might have set in the rld itself. Proper handling would have
|
||||||
|
to check if the SIGTRAP happened due to a kill call.
|
||||||
|
|
||||||
|
Also, what if child has exit()ed? Must exit loop somehow.
|
||||||
|
*/
|
||||||
|
|
||||||
|
void
|
||||||
|
solib_create_inferior_hook()
|
||||||
|
{
|
||||||
|
|
||||||
|
/* Nothing to do for statically bound executables. */
|
||||||
|
|
||||||
|
if (symfile_objfile == 0 || symfile_objfile->ei.entry_file_lowpc == stop_pc)
|
||||||
|
return;
|
||||||
|
|
||||||
|
/* Now run the target. It will eventually get a SIGTRAP, at
|
||||||
|
which point all of the libraries will have been mapped in and we
|
||||||
|
can go groveling around in the rld structures to find
|
||||||
|
out what we need to know about them. */
|
||||||
|
|
||||||
|
clear_proceed_status ();
|
||||||
|
stop_soon_quietly = 1;
|
||||||
|
stop_signal = 0;
|
||||||
|
do
|
||||||
|
{
|
||||||
|
target_resume (inferior_pid, 0, stop_signal);
|
||||||
|
wait_for_inferior ();
|
||||||
|
}
|
||||||
|
while (stop_signal != SIGTRAP);
|
||||||
|
stop_soon_quietly = 0;
|
||||||
|
|
||||||
|
solib_add ((char *) 0, 0, (struct target_ops *) 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
|
||||||
|
LOCAL FUNCTION
|
||||||
|
|
||||||
|
sharedlibrary_command -- handle command to explicitly add library
|
||||||
|
|
||||||
|
SYNOPSIS
|
||||||
|
|
||||||
|
static void sharedlibrary_command (char *args, int from_tty)
|
||||||
|
|
||||||
|
DESCRIPTION
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
static void
|
||||||
|
sharedlibrary_command (args, from_tty)
|
||||||
|
char *args;
|
||||||
|
int from_tty;
|
||||||
|
{
|
||||||
|
dont_repeat ();
|
||||||
|
solib_add (args, from_tty, (struct target_ops *) 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
_initialize_solib()
|
||||||
|
{
|
||||||
|
|
||||||
|
add_com ("sharedlibrary", class_files, sharedlibrary_command,
|
||||||
|
"Load shared object library symbols for files matching REGEXP.");
|
||||||
|
add_info ("sharedlibrary", info_sharedlibrary_command,
|
||||||
|
"Status of loaded shared object libraries.");
|
||||||
|
}
|
||||||
|
|
@ -467,7 +467,7 @@ static char *type_synonym_name;
|
||||||
/* ARGSUSED */
|
/* ARGSUSED */
|
||||||
struct symbol *
|
struct symbol *
|
||||||
define_symbol (valu, string, desc, type, objfile)
|
define_symbol (valu, string, desc, type, objfile)
|
||||||
unsigned int valu;
|
CORE_ADDR valu;
|
||||||
char *string;
|
char *string;
|
||||||
int desc;
|
int desc;
|
||||||
int type;
|
int type;
|
||||||
|
|
@ -3228,8 +3228,12 @@ read_range_type (pp, typenums, objfile)
|
||||||
nbits = n3bits;
|
nbits = n3bits;
|
||||||
}
|
}
|
||||||
/* Range from <large number> to <large number>-1 is a large signed
|
/* Range from <large number> to <large number>-1 is a large signed
|
||||||
integral type. */
|
integral type. Take care of the case where <large number> doesn't
|
||||||
else if (n2bits != 0 && n3bits != 0 && n2bits == n3bits + 1)
|
fit in a long but <large number>-1 does. */
|
||||||
|
else if ((n2bits != 0 && n3bits != 0 && n2bits == n3bits + 1)
|
||||||
|
|| (n2bits != 0 && n3bits == 0
|
||||||
|
&& (n2bits == sizeof (long) * HOST_CHAR_BIT)
|
||||||
|
&& n3 == LONG_MAX))
|
||||||
{
|
{
|
||||||
got_signed = 1;
|
got_signed = 1;
|
||||||
nbits = n2bits;
|
nbits = n2bits;
|
||||||
|
|
|
||||||
|
|
@ -152,7 +152,7 @@ extern void
|
||||||
add_undefined_type PARAMS ((struct type *));
|
add_undefined_type PARAMS ((struct type *));
|
||||||
|
|
||||||
extern struct symbol *
|
extern struct symbol *
|
||||||
define_symbol PARAMS ((unsigned int, char *, int, int, struct objfile *));
|
define_symbol PARAMS ((CORE_ADDR, char *, int, int, struct objfile *));
|
||||||
|
|
||||||
extern void
|
extern void
|
||||||
stabsread_init PARAMS ((void));
|
stabsread_init PARAMS ((void));
|
||||||
|
|
|
||||||
21
gdb/valops.c
21
gdb/valops.c
|
|
@ -896,8 +896,8 @@ call_function_by_hand (function, nargs, args)
|
||||||
|
|
||||||
#if CALL_DUMMY_LOCATION == ON_STACK
|
#if CALL_DUMMY_LOCATION == ON_STACK
|
||||||
write_memory (start_sp, (char *)dummy1, sizeof dummy);
|
write_memory (start_sp, (char *)dummy1, sizeof dummy);
|
||||||
|
#endif /* On stack. */
|
||||||
|
|
||||||
#else /* Not on stack. */
|
|
||||||
#if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
|
#if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
|
||||||
/* Convex Unix prohibits executing in the stack segment. */
|
/* Convex Unix prohibits executing in the stack segment. */
|
||||||
/* Hope there is empty room at the top of the text segment. */
|
/* Hope there is empty room at the top of the text segment. */
|
||||||
|
|
@ -913,7 +913,9 @@ call_function_by_hand (function, nargs, args)
|
||||||
real_pc = text_end - sizeof dummy;
|
real_pc = text_end - sizeof dummy;
|
||||||
write_memory (real_pc, (char *)dummy1, sizeof dummy);
|
write_memory (real_pc, (char *)dummy1, sizeof dummy);
|
||||||
}
|
}
|
||||||
#else /* After text_end. */
|
#endif /* Before text_end. */
|
||||||
|
|
||||||
|
#if CALL_DUMMY_LOCATION == AFTER_TEXT_END
|
||||||
{
|
{
|
||||||
extern CORE_ADDR text_end;
|
extern CORE_ADDR text_end;
|
||||||
int errcode;
|
int errcode;
|
||||||
|
|
@ -924,7 +926,10 @@ call_function_by_hand (function, nargs, args)
|
||||||
error ("Cannot write text segment -- call_function failed");
|
error ("Cannot write text segment -- call_function failed");
|
||||||
}
|
}
|
||||||
#endif /* After text_end. */
|
#endif /* After text_end. */
|
||||||
#endif /* Not on stack. */
|
|
||||||
|
#if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
|
||||||
|
real_pc = funaddr;
|
||||||
|
#endif /* At entry point. */
|
||||||
|
|
||||||
#ifdef lint
|
#ifdef lint
|
||||||
sp = old_sp; /* It really is used, for some ifdef's... */
|
sp = old_sp; /* It really is used, for some ifdef's... */
|
||||||
|
|
@ -1056,7 +1061,7 @@ call_function_by_hand (function, nargs, args)
|
||||||
char format[80];
|
char format[80];
|
||||||
sprintf (format, "at %s", local_hex_format ());
|
sprintf (format, "at %s", local_hex_format ());
|
||||||
name = alloca (80);
|
name = alloca (80);
|
||||||
sprintf (name, format, funaddr);
|
sprintf (name, format, (unsigned long) funaddr);
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Execute the stack dummy routine, calling FUNCTION.
|
/* Execute the stack dummy routine, calling FUNCTION.
|
||||||
|
|
@ -1349,7 +1354,7 @@ search_struct_field (name, arg1, offset, type, looking_for_baseclass)
|
||||||
/* Helper function used by value_struct_elt to recurse through baseclasses.
|
/* Helper function used by value_struct_elt to recurse through baseclasses.
|
||||||
Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
|
Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
|
||||||
and search in it assuming it has (class) type TYPE.
|
and search in it assuming it has (class) type TYPE.
|
||||||
If found, return value, else if name matched and args not return -1,
|
If found, return value, else if name matched and args not return (value)-1,
|
||||||
else return NULL. */
|
else return NULL. */
|
||||||
|
|
||||||
static value
|
static value
|
||||||
|
|
@ -1409,7 +1414,7 @@ search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
|
||||||
}
|
}
|
||||||
v = search_struct_method (name, arg1p, args, base_offset + offset,
|
v = search_struct_method (name, arg1p, args, base_offset + offset,
|
||||||
static_memfuncp, TYPE_BASECLASS (type, i));
|
static_memfuncp, TYPE_BASECLASS (type, i));
|
||||||
if (v == -1)
|
if (v == (value) -1)
|
||||||
{
|
{
|
||||||
name_matched = 1;
|
name_matched = 1;
|
||||||
}
|
}
|
||||||
|
|
@ -1420,7 +1425,7 @@ search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
|
||||||
return v;
|
return v;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
if (name_matched) return -1;
|
if (name_matched) return (value) -1;
|
||||||
else return NULL;
|
else return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -1519,7 +1524,7 @@ value_struct_elt (argp, args, name, static_memfuncp, err)
|
||||||
else
|
else
|
||||||
v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
|
v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
|
||||||
|
|
||||||
if (v == -1)
|
if (v == (value) -1)
|
||||||
{
|
{
|
||||||
error("Argument list of %s mismatch with component in the structure.", name);
|
error("Argument list of %s mismatch with component in the structure.", name);
|
||||||
}
|
}
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue