a29k-pinsn.c
a29k-tdep.c
a68v-nat.c
+alpha-nat.c
+alpha-tdep.c
altos-xdep.c
arm-convert.s
arm-pinsn.c
ns32k-pinsn.c
objfiles.c
objfiles.h
+osfsolib.c
paread.c
parse.c
parser-defs.h
+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)
* configure.in: Recognize hppa*-*-hiux* (currently synonym for hpux).
# why they are separate from the lists of files above.
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 \
convex-tdep.c \
convex-xdep.c core-svr4.c coredep.c corelow.c dcache.c delta68-nat.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 \
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 \
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 \
mips-tdep.c news-xdep.c nindy-share/Onindy.c nindy-share/nindy.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-mm.c remote-mon.c remote-nindy.c remote-sim.c \
remote-st.c remote-utils.c dcache.c \
ALLPARAM = config/a29k/nm-ultra3.h config/a29k/tm-a29k.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/arm/xm-arm.h config/convex/tm-convex.h \
config/convex/xm-convex.h config/gould/tm-np1.h config/gould/tm-pn.h \
ALLCONFIG = config/a29k/a29k-kern.mt config/a29k/a29k-udi.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/convex/convex.mt config/gould/np1.mh config/gould/np1.mt \
config/gould/pn.mh config/gould/pn.mt config/h8300/h8300hms.mt \
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)
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)
arm-pinsn.o: arm-pinsn.c $(OP_INCLUDE)/arm.h $(defs_h) $(symtab_h)
i386-tdep.o: i386-tdep.c $(defs_h) $(gdbcore_h) $(inferior_h) target.h
i386b-nat.o: i386b-nat.c $(defs_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)
i386v-nat.o: i386v-nat.c $(ieee-float_h) $(defs_h) $(gdbcore_h) \
objfiles.o: objfiles.c $(bfd_h) $(defs_h) objfiles.h symfile.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) \
gdb-stabs.h objfiles.h symfile.h $(symtab_h)
--- /dev/null
+/* 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);
+}
--- /dev/null
+/* 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
+\f
+
+/* 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;
+
+\f
+#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);
+ }
+}
+\f
+/* 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);
+}
return 1;
if (symfile_objfile == 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 &&
addr < symfile_objfile -> ei.entry_file_highpc);
}
return 1;
if (symfile_objfile == 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 &&
symfile_objfile -> ei.entry_func_highpc > pc);
}
goto return_cached_value;
}
}
-
- /* Now that static symbols go in the minimal symbol table, perhaps
- we could just ignore the partial symbols. But at least for now
- we use the partial or minimal symbol, whichever is larger. */
- psb = find_pc_psymbol (pst, pc);
-
- if (psb
- && (msymbol == NULL ||
- (SYMBOL_VALUE_ADDRESS (psb) >= SYMBOL_VALUE_ADDRESS (msymbol))))
+ else
{
- /* This case isn't being cached currently. */
- if (address)
- *address = SYMBOL_VALUE_ADDRESS (psb);
- if (name)
- *name = SYMBOL_NAME (psb);
- /* endaddr non-NULL can't happen here. */
- return 1;
+ /* Now that static symbols go in the minimal symbol table, perhaps
+ we could just ignore the partial symbols. But at least for now
+ we use the partial or minimal symbol, whichever is larger. */
+ psb = find_pc_psymbol (pst, pc);
+
+ if (psb
+ && (msymbol == NULL ||
+ (SYMBOL_VALUE_ADDRESS (psb)
+ >= SYMBOL_VALUE_ADDRESS (msymbol))))
+ {
+ /* This case isn't being cached currently. */
+ if (address)
+ *address = SYMBOL_VALUE_ADDRESS (psb);
+ if (name)
+ *name = SYMBOL_NAME (psb);
+ /* endaddr non-NULL can't happen here. */
+ return 1;
+ }
}
}
b->inserted = 0;
#ifdef BREAKPOINT_DEBUG
printf ("Removed breakpoint at %s",
- local_hex_string(b->address));
+ local_hex_string((unsigned long) b->address));
printf (", shadow %s",
- local_hex_string(b->shadow_contents[0]));
+ local_hex_string((unsigned long) b->shadow_contents[0]));
printf (", %s.\n",
- local_hex_string(b->shadow_contents[1]));
+ local_hex_string((unsigned long) b->shadow_contents[1]));
#endif /* BREAKPOINT_DEBUG */
}
{
/* We use value_{,free_to_}mark because it could be a
*long* time before we return to the command level and
- call free_all_values. */
- /* But couldn't we just call free_all_values instead? */
+ call free_all_values. We can't call free_all_values because
+ we might be in the middle of evaluating a function call. */
value mark = value_mark ();
value new_val = evaluate_expression (bs->breakpoint_at->exp);
enum bpstat_what_main_action current_action = BPSTAT_WHAT_KEEP_CHECKING;
struct bpstat_what retval;
+ retval.call_dummy = 0;
+ retval.step_resume = 0;
for (; bs != NULL; bs = bs->next)
{
enum class bs_class = no_effect;
case bp_step_resume:
case bp_call_dummy:
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;
if (b->source_file)
if (b->frame)
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)
{
printf_filtered ("\tstop only if ");
(b->enable == disabled) ? " (disabled)" : "",
(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));
}
}
\f
break;
case bp_breakpoint:
printf_filtered ("Breakpoint %d at %s", b->number,
- local_hex_string(b->address));
+ local_hex_string((unsigned long) b->address));
if (b->source_file)
printf_filtered (": file %s, line %d.",
b->source_file, b->line_number);
bpstat bs;
{
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);
}
case "${target_cpu}" in
+alpha) gdb_target_cpu=alpha ;;
c[12]) gdb_target_cpu=convex ;;
hppa*) gdb_target_cpu=pa ;;
i[34]86) gdb_target_cpu=i386 ;;
a29k-*-sym1) gdb_target=ultra3 ;;
a29k-*-udi) gdb_target=a29k-udi ;;
+alpha-*-osf*) gdb_target=alpha-osf1 ;;
+
arm-*-*) gdb_target=arm ;;
c1-*-*) gdb_target=convex ;;
struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
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
if (step) {
single_step(sig); /* Do it the hard way, w/temp breakpoints */
/* 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
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)
&& (stop_signal != SIGCLD)
--- /dev/null
+/* 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.");
+}
/* ARGSUSED */
struct symbol *
define_symbol (valu, string, desc, type, objfile)
- unsigned int valu;
+ CORE_ADDR valu;
char *string;
int desc;
int type;
nbits = n3bits;
}
/* Range from <large number> to <large number>-1 is a large signed
- integral type. */
- else if (n2bits != 0 && n3bits != 0 && n2bits == n3bits + 1)
+ integral type. Take care of the case where <large number> doesn't
+ 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;
nbits = n2bits;
add_undefined_type PARAMS ((struct type *));
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
stabsread_init PARAMS ((void));
#if CALL_DUMMY_LOCATION == ON_STACK
write_memory (start_sp, (char *)dummy1, sizeof dummy);
+#endif /* On stack. */
-#else /* Not on stack. */
#if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
/* Convex Unix prohibits executing in the stack segment. */
/* Hope there is empty room at the top of the text segment. */
real_pc = text_end - 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;
int errcode;
error ("Cannot write text segment -- call_function failed");
}
#endif /* After text_end. */
-#endif /* Not on stack. */
+
+#if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
+ real_pc = funaddr;
+#endif /* At entry point. */
#ifdef lint
sp = old_sp; /* It really is used, for some ifdef's... */
char format[80];
sprintf (format, "at %s", local_hex_format ());
name = alloca (80);
- sprintf (name, format, funaddr);
+ sprintf (name, format, (unsigned long) funaddr);
}
/* Execute the stack dummy routine, calling FUNCTION.
/* 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,
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. */
static value
}
v = search_struct_method (name, arg1p, args, base_offset + offset,
static_memfuncp, TYPE_BASECLASS (type, i));
- if (v == -1)
+ if (v == (value) -1)
{
name_matched = 1;
}
return v;
}
}
- if (name_matched) return -1;
+ if (name_matched) return (value) -1;
else return NULL;
}
else
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);
}
projects / binutils-gdb.git / commitdiff