-/* Target-dependent code for HPUX running on PA-RISC, for GDB.
+/* Target-dependent code for HP-UX on PA-RISC.
- Copyright 2002, 2003 Free Software Foundation, Inc.
+ Copyright 2002, 2003, 2004 Free Software Foundation, Inc.
-This file is part of GDB.
+ This file is part of GDB.
-This program is free software; you can redistribute it and/or modify
-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 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.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
#include "defs.h"
#include "arch-utils.h"
#include "gdbcore.h"
#include "osabi.h"
-#include "gdb_string.h"
#include "frame.h"
+#include "frame-unwind.h"
+#include "trad-frame.h"
#include "symtab.h"
#include "objfiles.h"
#include "inferior.h"
#include "infcall.h"
+#include "observer.h"
#include "hppa-tdep.h"
+#include "solib-som.h"
+#include "solib-pa64.h"
+#include "regset.h"
+#include "exceptions.h"
+
+#include "gdb_string.h"
#include <dl.h>
#include <machine/save_state.h>
+#ifndef offsetof
+#define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
+#endif
+
+#define IS_32BIT_TARGET(_gdbarch) \
+ ((gdbarch_tdep (_gdbarch))->bytes_per_address == 4)
+
/* Forward declarations. */
extern void _initialize_hppa_hpux_tdep (void);
extern initialize_file_ftype _initialize_hppa_hpux_tdep;
}
args_for_find_stub;
-/* FIXME: brobecker 2002-12-25. The following functions will eventually
- become static, after the multiarching conversion is done. */
-int hppa_hpux_pc_in_sigtramp (CORE_ADDR pc, char *name);
-void hppa32_hpux_frame_saved_pc_in_sigtramp (struct frame_info *fi,
- CORE_ADDR *tmp);
-void hppa32_hpux_frame_base_before_sigtramp (struct frame_info *fi,
- CORE_ADDR *tmp);
-void hppa32_hpux_frame_find_saved_regs_in_sigtramp (struct frame_info *fi,
- CORE_ADDR *fsr);
-void hppa64_hpux_frame_saved_pc_in_sigtramp (struct frame_info *fi,
- CORE_ADDR *tmp);
-void hppa64_hpux_frame_base_before_sigtramp (struct frame_info *fi,
- CORE_ADDR *tmp);
-void hppa64_hpux_frame_find_saved_regs_in_sigtramp (struct frame_info *fi,
- CORE_ADDR *fsr);
-
-int
-hppa_hpux_pc_in_sigtramp (CORE_ADDR pc, char *name)
-{
- /* Actually, for a PA running HPUX the kernel calls the signal handler
- without an intermediate trampoline. Luckily the kernel always sets
- the return pointer for the signal handler to point to _sigreturn. */
- return (name && (strcmp ("_sigreturn", name) == 0));
-}
-
-/* For hppa32_hpux_frame_saved_pc_in_sigtramp,
- hppa32_hpux_frame_base_before_sigtramp and
- hppa32_hpux_frame_find_saved_regs_in_sigtramp:
-
- The signal context structure pointer is always saved at the base
- of the frame which "calls" the signal handler. We only want to find
- the hardware save state structure, which lives 10 32bit words into
- sigcontext structure.
-
- Within the hardware save state structure, registers are found in the
- same order as the register numbers in GDB.
-
- At one time we peeked at %r31 rather than the PC queues to determine
- what instruction took the fault. This was done on purpose, but I don't
- remember why. Looking at the PC queues is really the right way, and
- I don't remember why that didn't work when this code was originally
- written. */
-
-void
-hppa32_hpux_frame_saved_pc_in_sigtramp (struct frame_info *fi, CORE_ADDR *tmp)
-{
- *tmp = read_memory_integer (get_frame_base (fi) + (43 * 4), 4);
-}
-
-void
-hppa32_hpux_frame_base_before_sigtramp (struct frame_info *fi,
- CORE_ADDR *tmp)
-{
- *tmp = read_memory_integer (get_frame_base (fi) + (40 * 4), 4);
-}
-
-void
-hppa32_hpux_frame_find_saved_regs_in_sigtramp (struct frame_info *fi,
- CORE_ADDR *fsr)
-{
- int i;
- const CORE_ADDR tmp = get_frame_base (fi) + (10 * 4);
-
- for (i = 0; i < NUM_REGS; i++)
- {
- if (i == HPPA_SP_REGNUM)
- fsr[HPPA_SP_REGNUM] = read_memory_integer (tmp + HPPA_SP_REGNUM * 4, 4);
- else
- fsr[i] = tmp + i * 4;
- }
-}
-
-/* For hppa64_hpux_frame_saved_pc_in_sigtramp,
- hppa64_hpux_frame_base_before_sigtramp and
- hppa64_hpux_frame_find_saved_regs_in_sigtramp:
-
- These functions are the PA64 ABI equivalents of the 32bits counterparts
- above. See the comments there.
-
- For PA64, the save_state structure is at an offset of 24 32-bit words
- from the sigcontext structure. The 64 bit general registers are at an
- offset of 640 bytes from the beginning of the save_state structure,
- and the floating pointer register are at an offset of 256 bytes from
- the beginning of the save_state structure. */
-
-void
-hppa64_hpux_frame_saved_pc_in_sigtramp (struct frame_info *fi, CORE_ADDR *tmp)
-{
- *tmp = read_memory_integer
- (get_frame_base (fi) + (24 * 4) + 640 + (33 * 8), 8);
-}
-
-void
-hppa64_hpux_frame_base_before_sigtramp (struct frame_info *fi,
- CORE_ADDR *tmp)
+static int
+in_opd_section (CORE_ADDR pc)
{
- *tmp = read_memory_integer
- (get_frame_base (fi) + (24 * 4) + 640 + (30 * 8), 8);
-}
+ struct obj_section *s;
+ int retval = 0;
-void
-hppa64_hpux_frame_find_saved_regs_in_sigtramp (struct frame_info *fi,
- CORE_ADDR *fsr)
-{
- int i;
- const CORE_ADDR tmp1 = get_frame_base (fi) + (24 * 4) + 640;
- const CORE_ADDR tmp2 = get_frame_base (fi) + (24 * 4) + 256;
+ s = find_pc_section (pc);
- for (i = 0; i < NUM_REGS; i++)
- {
- if (i == HPPA_SP_REGNUM)
- fsr[HPPA_SP_REGNUM] = read_memory_integer (tmp1 + HPPA_SP_REGNUM * 8, 8);
- else if (i >= HPPA_FP0_REGNUM)
- fsr[i] = tmp2 + (i - HPPA_FP0_REGNUM) * 8;
- else
- fsr[i] = tmp1 + i * 8;
- }
+ retval = (s != NULL
+ && s->the_bfd_section->name != NULL
+ && strcmp (s->the_bfd_section->name, ".opd") == 0);
+ return (retval);
}
/* Return one if PC is in the call path of a trampoline, else return zero.
{
struct minimal_symbol *minsym;
struct unwind_table_entry *u;
- static CORE_ADDR dyncall = 0;
- static CORE_ADDR sr4export = 0;
-
- /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
- new exec file */
/* First see if PC is in one of the two C-library trampolines. */
- if (!dyncall)
- {
- minsym = lookup_minimal_symbol ("$$dyncall", NULL, NULL);
- if (minsym)
- dyncall = SYMBOL_VALUE_ADDRESS (minsym);
- else
- dyncall = -1;
- }
-
- if (!sr4export)
- {
- minsym = lookup_minimal_symbol ("_sr4export", NULL, NULL);
- if (minsym)
- sr4export = SYMBOL_VALUE_ADDRESS (minsym);
- else
- sr4export = -1;
- }
-
- if (pc == dyncall || pc == sr4export)
+ if (pc == hppa_symbol_address("$$dyncall")
+ || pc == hppa_symbol_address("_sr4export"))
return 1;
minsym = lookup_minimal_symbol_by_pc (pc);
}
/* Should never happen. */
- warning ("Unable to find branch in parameter relocation stub.\n");
+ warning (_("Unable to find branch in parameter relocation stub."));
return 0;
}
}
/* Should never happen. */
- warning ("Unable to find branch in parameter relocation stub.\n");
+ warning (_("Unable to find branch in parameter relocation stub."));
return 0;
}
{
long orig_pc = pc;
long prev_inst, curr_inst, loc;
- static CORE_ADDR dyncall = 0;
- static CORE_ADDR dyncall_external = 0;
- static CORE_ADDR sr4export = 0;
struct minimal_symbol *msym;
struct unwind_table_entry *u;
- /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
- new exec file */
-
- if (!dyncall)
- {
- msym = lookup_minimal_symbol ("$$dyncall", NULL, NULL);
- if (msym)
- dyncall = SYMBOL_VALUE_ADDRESS (msym);
- else
- dyncall = -1;
- }
-
- if (!dyncall_external)
- {
- msym = lookup_minimal_symbol ("$$dyncall_external", NULL, NULL);
- if (msym)
- dyncall_external = SYMBOL_VALUE_ADDRESS (msym);
- else
- dyncall_external = -1;
- }
-
- if (!sr4export)
- {
- msym = lookup_minimal_symbol ("_sr4export", NULL, NULL);
- if (msym)
- sr4export = SYMBOL_VALUE_ADDRESS (msym);
- else
- sr4export = -1;
- }
-
/* Addresses passed to dyncall may *NOT* be the actual address
of the function. So we may have to do something special. */
- if (pc == dyncall)
+ if (pc == hppa_symbol_address("$$dyncall"))
{
pc = (CORE_ADDR) read_register (22);
if (pc & 0x2)
pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8);
}
- if (pc == dyncall_external)
+ if (pc == hppa_symbol_address("$$dyncall_external"))
{
pc = (CORE_ADDR) read_register (22);
pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8);
}
- else if (pc == sr4export)
+ else if (pc == hppa_symbol_address("_sr4export"))
pc = (CORE_ADDR) (read_register (22));
/* Get the unwind descriptor corresponding to PC, return zero
/* Make sure we haven't walked outside the range of this stub. */
if (u != find_unwind_entry (loc))
{
- warning ("Unable to find branch in linker stub");
+ warning (_("Unable to find branch in linker stub"));
return orig_pc == pc ? 0 : pc & ~0x3;
}
return (hppa_extract_21 (prev_inst) + hppa_extract_17 (curr_inst)) & ~0x3;
else
{
- warning ("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1).");
+ warning (_("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1)."));
return orig_pc == pc ? 0 : pc & ~0x3;
}
}
stubsym = lookup_minimal_symbol_by_pc (loc);
if (stubsym == NULL)
{
- warning ("Unable to find symbol for 0x%lx", loc);
+ warning (_("Unable to find symbol for 0x%lx"), loc);
return orig_pc == pc ? 0 : pc & ~0x3;
}
libsym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (stubsym), NULL, NULL);
if (libsym == NULL)
{
- warning ("Unable to find library symbol for %s\n",
+ warning (_("Unable to find library symbol for %s."),
DEPRECATED_SYMBOL_NAME (stubsym));
return orig_pc == pc ? 0 : pc & ~0x3;
}
(read_register (HPPA_SP_REGNUM) - 8, 4)) & ~0x3;
else
{
- warning ("Unable to find restore of %%rp before bv (%%rp).");
+ warning (_("Unable to find restore of %%rp before bv (%%rp)."));
return orig_pc == pc ? 0 : pc & ~0x3;
}
}
}
}
+void
+hppa_skip_permanent_breakpoint (void)
+{
+ /* To step over a breakpoint instruction on the PA takes some
+ fiddling with the instruction address queue.
+
+ When we stop at a breakpoint, the IA queue front (the instruction
+ we're executing now) points at the breakpoint instruction, and
+ the IA queue back (the next instruction to execute) points to
+ whatever instruction we would execute after the breakpoint, if it
+ were an ordinary instruction. This is the case even if the
+ breakpoint is in the delay slot of a branch instruction.
+
+ Clearly, to step past the breakpoint, we need to set the queue
+ front to the back. But what do we put in the back? What
+ instruction comes after that one? Because of the branch delay
+ slot, the next insn is always at the back + 4. */
+ write_register (HPPA_PCOQ_HEAD_REGNUM, read_register (HPPA_PCOQ_TAIL_REGNUM));
+ write_register (HPPA_PCSQ_HEAD_REGNUM, read_register (HPPA_PCSQ_TAIL_REGNUM));
+
+ write_register (HPPA_PCOQ_TAIL_REGNUM, read_register (HPPA_PCOQ_TAIL_REGNUM) + 4);
+ /* We can leave the tail's space the same, since there's no jump. */
+}
/* Exception handling support for the HP-UX ANSI C++ compiler.
The compiler (aCC) provides a callback for exception events;
GDB can set a breakpoint on this callback and find out what
exception event has occurred. */
-/* The name of the hook to be set to point to the callback function */
+/* The name of the hook to be set to point to the callback function. */
static char HP_ACC_EH_notify_hook[] = "__eh_notify_hook";
-/* The name of the function to be used to set the hook value */
+/* The name of the function to be used to set the hook value. */
static char HP_ACC_EH_set_hook_value[] = "__eh_set_hook_value";
/* The name of the callback function in end.o */
static char HP_ACC_EH_notify_callback[] = "__d_eh_notify_callback";
-/* Name of function in end.o on which a break is set (called by above) */
+/* Name of function in end.o on which a break is set (called by above). */
static char HP_ACC_EH_break[] = "__d_eh_break";
-/* Name of flag (in end.o) that enables catching throws */
+/* Name of flag (in end.o) that enables catching throws. */
static char HP_ACC_EH_catch_throw[] = "__d_eh_catch_throw";
-/* Name of flag (in end.o) that enables catching catching */
+/* Name of flag (in end.o) that enables catching catching. */
static char HP_ACC_EH_catch_catch[] = "__d_eh_catch_catch";
-/* The enum used by aCC */
+/* The enum used by aCC. */
typedef enum
{
__EH_NOTIFY_THROW,
/* Is exception-handling support available with this executable? */
static int hp_cxx_exception_support = 0;
/* Has the initialize function been run? */
-int hp_cxx_exception_support_initialized = 0;
+static int hp_cxx_exception_support_initialized = 0;
/* Address of __eh_notify_hook */
static CORE_ADDR eh_notify_hook_addr = 0;
/* Address of __d_eh_notify_callback */
ourselves.
0 => success
1 => failure */
-int
+static int
setup_d_pid_in_inferior (void)
{
CORE_ADDR anaddr;
msymbol = lookup_minimal_symbol ("__d_pid", NULL, symfile_objfile);
if (msymbol == NULL)
{
- warning ("Unable to find __d_pid symbol in object file.");
- warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
+ warning (_("Unable to find __d_pid symbol in object file.\n"
+ "Suggest linking executable with -g (links in /opt/langtools/lib/end.o)."));
return 1;
}
store_unsigned_integer (buf, 4, PIDGET (inferior_ptid)); /* FIXME 32x64? */
if (target_write_memory (anaddr, buf, 4)) /* FIXME 32x64? */
{
- warning ("Unable to write __d_pid");
- warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
+ warning (_("Unable to write __d_pid.\n"
+ "Suggest linking executable with -g (links in /opt/langtools/lib/end.o)."));
return 1;
}
return 0;
end.c
man entry for shl_findsym */
-CORE_ADDR
+static CORE_ADDR
find_stub_with_shl_get (struct minimal_symbol *function, CORE_ADDR handle)
{
struct symbol *get_sym, *symbol2;
target_read_memory (value_return_addr, (char *) &stub_addr, sizeof (stub_addr));
if (stub_addr <= 0)
- error ("call to __d_shl_get failed, error code is %d", err_value);
+ error (_("call to __d_shl_get failed, error code is %d"), err_value);
return (stub_addr);
}
}
/* Initialize exception catchpoint support by looking for the
- necessary hooks/callbacks in end.o, etc., and set the hook value to
- point to the required debug function
+ necessary hooks/callbacks in end.o, etc., and set the hook value
+ to point to the required debug function.
Return 0 => failure
1 => success */
/* Detect and disallow recursion. On HP-UX with aCC, infinite
recursion is a possibility because finding the hook for exception
callbacks involves making a call in the inferior, which means
- re-inserting breakpoints which can re-invoke this code */
+ re-inserting breakpoints which can re-invoke this code. */
static int recurse = 0;
if (recurse > 0)
if (!deprecated_hp_som_som_object_present)
return 0;
- /* We have a SOM executable with SOM debug info; find the hooks */
+ /* We have a SOM executable with SOM debug info; find the hooks. */
/* First look for the notify hook provided by aCC runtime libs */
/* If we find this symbol, we conclude that the executable must
should *not* be tried as an alternative.
ASSUMPTION: Only HP aCC code will have __eh_notify_hook defined.
- ASSUMPTION: HP aCC and g++ modules cannot be linked together. */
+ ASSUMPTION: HP aCC and g++ modules cannot be linked together. */
/* libCsup has this hook; it'll usually be non-debuggable */
msym = lookup_minimal_symbol (HP_ACC_EH_notify_hook, NULL, NULL);
}
else
{
- warning ("Unable to find exception callback hook (%s).", HP_ACC_EH_notify_hook);
- warning ("Executable may not have been compiled debuggable with HP aCC.");
- warning ("GDB will be unable to intercept exception events.");
+ warning (_("\
+Unable to find exception callback hook (%s).\n\
+Executable may not have been compiled debuggable with HP aCC.\n\
+GDB will be unable to intercept exception events."),
+ HP_ACC_EH_notify_hook);
eh_notify_hook_addr = 0;
hp_cxx_exception_support = 0;
return 0;
}
/* Next look for the notify callback routine in end.o */
- /* This is always available in the SOM symbol dictionary if end.o is linked in */
+ /* This is always available in the SOM symbol dictionary if end.o is
+ linked in. */
msym = lookup_minimal_symbol (HP_ACC_EH_notify_callback, NULL, NULL);
if (msym)
{
}
else
{
- warning ("Unable to find exception callback routine (%s).", HP_ACC_EH_notify_callback);
- warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
- warning ("GDB will be unable to intercept exception events.");
+ warning (_("\
+Unable to find exception callback routine (%s).\n\
+Suggest linking executable with -g (links in /opt/langtools/lib/end.o).\n\
+GDB will be unable to intercept exception events."),
+ HP_ACC_EH_notify_callback);
eh_notify_callback_addr = 0;
return 0;
}
shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, "$SHLIB_INFO$");
if (shlib_info && (bfd_section_size (symfile_objfile->obfd, shlib_info) != 0))
{
- /* The minsym we have has the local code address, but that's not the
- plabel that can be used by an inter-load-module call. */
- /* Find solib handle for main image (which has end.o), and use that
- and the min sym as arguments to __d_shl_get() (which does the equivalent
- of shl_findsym()) to find the plabel. */
+ /* The minsym we have has the local code address, but that's not
+ the plabel that can be used by an inter-load-module call. */
+ /* Find solib handle for main image (which has end.o), and use
+ that and the min sym as arguments to __d_shl_get() (which
+ does the equivalent of shl_findsym()) to find the plabel. */
args_for_find_stub args;
static char message[] = "Error while finding exception callback hook:\n";
- args.solib_handle = som_solib_get_solib_by_pc (eh_notify_callback_addr);
+ args.solib_handle = gdbarch_tdep (current_gdbarch)->solib_get_solib_by_pc (eh_notify_callback_addr);
args.msym = msym;
args.return_val = 0;
{
/* We can get here either if there is no plabel in the export list
for the main image, or if something strange happened (?) */
- warning ("Couldn't find a plabel (indirect function label) for the exception callback.");
- warning ("GDB will not be able to intercept exception events.");
+ warning (_("\
+Couldn't find a plabel (indirect function label) for the exception callback.\n\
+GDB will not be able to intercept exception events."));
return 0;
}
}
}
else
{
- warning ("Unable to find exception callback routine to set breakpoint (%s).", HP_ACC_EH_break);
- warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
- warning ("GDB will be unable to intercept exception events.");
+ warning (_("\
+Unable to find exception callback routine to set breakpoint (%s).\n\
+Suggest linking executable with -g (link in /opt/langtools/lib/end.o).\n\
+GDB will be unable to intercept exception events."),
+ HP_ACC_EH_break);
eh_break_addr = 0;
return 0;
}
}
else
{
- warning ("Unable to enable interception of exception catches.");
- warning ("Executable may not have been compiled debuggable with HP aCC.");
- warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
+ warning (_("\
+Unable to enable interception of exception catches.\n\
+Executable may not have been compiled debuggable with HP aCC.\n\
+Suggest linking executable with -g (link in /opt/langtools/lib/end.o)."));
return 0;
}
}
}
else
{
- warning ("Unable to enable interception of exception throws.");
- warning ("Executable may not have been compiled debuggable with HP aCC.");
- warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
+ warning (_("\
+Unable to enable interception of exception throws.\n\
+Executable may not have been compiled debuggable with HP aCC.\n\
+Suggest linking executable with -g (link in /opt/langtools/lib/end.o)."));
return 0;
}
}
/* there may be other cases in the future */
}
- /* Set the EH hook to point to the callback routine */
+ /* Set the EH hook to point to the callback routine. */
store_unsigned_integer (buf, 4, enable ? eh_notify_callback_addr : 0); /* FIXME 32x64 problem */
/* pai: (temp) FIXME should there be a pack operation first? */
if (target_write_memory (eh_notify_hook_addr, buf, 4)) /* FIXME 32x64 problem */
{
- warning ("Could not write to target memory for exception event callback.");
- warning ("Interception of exception events may not work.");
+ warning (_("\
+Could not write to target memory for exception event callback.\n\
+Interception of exception events may not work."));
return (struct symtab_and_line *) -1;
}
if (enable)
}
else
{
- warning ("Internal error: Invalid inferior pid? Cannot intercept exception events.");
+ warning (_("Internal error: Invalid inferior pid? Cannot intercept exception events."));
return (struct symtab_and_line *) -1;
}
}
store_unsigned_integer (buf, 4, enable ? 1 : 0);
if (target_write_memory (eh_catch_throw_addr, buf, 4)) /* FIXME 32x64? */
{
- warning ("Couldn't enable exception throw interception.");
+ warning (_("Couldn't enable exception throw interception."));
return (struct symtab_and_line *) -1;
}
break;
store_unsigned_integer (buf, 4, enable ? 1 : 0);
if (target_write_memory (eh_catch_catch_addr, buf, 4)) /* FIXME 32x64? */
{
- warning ("Couldn't enable exception catch interception.");
+ warning (_("Couldn't enable exception catch interception."));
return (struct symtab_and_line *) -1;
}
break;
default:
- error ("Request to enable unknown or unsupported exception event.");
+ error (_("Request to enable unknown or unsupported exception event."));
}
- /* Copy break address into new sal struct, malloc'ing if needed. */
+ /* Copy break address into new sal struct, malloc'ing if needed. */
if (!break_callback_sal)
- {
- break_callback_sal = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
- }
+ break_callback_sal = XMALLOC (struct symtab_and_line);
init_sal (break_callback_sal);
break_callback_sal->symtab = NULL;
break_callback_sal->pc = eh_break_addr;
return ¤t_ex_event;
}
+/* Signal frames. */
+struct hppa_hpux_sigtramp_unwind_cache
+{
+ CORE_ADDR base;
+ struct trad_frame_saved_reg *saved_regs;
+};
+
+static int hppa_hpux_tramp_reg[] = {
+ HPPA_SAR_REGNUM,
+ HPPA_PCOQ_HEAD_REGNUM,
+ HPPA_PCSQ_HEAD_REGNUM,
+ HPPA_PCOQ_TAIL_REGNUM,
+ HPPA_PCSQ_TAIL_REGNUM,
+ HPPA_EIEM_REGNUM,
+ HPPA_IIR_REGNUM,
+ HPPA_ISR_REGNUM,
+ HPPA_IOR_REGNUM,
+ HPPA_IPSW_REGNUM,
+ -1,
+ HPPA_SR4_REGNUM,
+ HPPA_SR4_REGNUM + 1,
+ HPPA_SR4_REGNUM + 2,
+ HPPA_SR4_REGNUM + 3,
+ HPPA_SR4_REGNUM + 4,
+ HPPA_SR4_REGNUM + 5,
+ HPPA_SR4_REGNUM + 6,
+ HPPA_SR4_REGNUM + 7,
+ HPPA_RCR_REGNUM,
+ HPPA_PID0_REGNUM,
+ HPPA_PID1_REGNUM,
+ HPPA_CCR_REGNUM,
+ HPPA_PID2_REGNUM,
+ HPPA_PID3_REGNUM,
+ HPPA_TR0_REGNUM,
+ HPPA_TR0_REGNUM + 1,
+ HPPA_TR0_REGNUM + 2,
+ HPPA_CR27_REGNUM
+};
+
+static struct hppa_hpux_sigtramp_unwind_cache *
+hppa_hpux_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
+ void **this_cache)
+
+{
+ struct gdbarch *gdbarch = get_frame_arch (next_frame);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ struct hppa_hpux_sigtramp_unwind_cache *info;
+ unsigned int flag;
+ CORE_ADDR sp, scptr;
+ int i, incr, off, szoff;
+
+ if (*this_cache)
+ return *this_cache;
+
+ info = FRAME_OBSTACK_ZALLOC (struct hppa_hpux_sigtramp_unwind_cache);
+ *this_cache = info;
+ info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
+
+ sp = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
+
+ scptr = sp - 1352;
+ off = scptr;
+
+ /* See /usr/include/machine/save_state.h for the structure of the save_state_t
+ structure. */
+
+ flag = read_memory_unsigned_integer(scptr, 4);
+
+ if (!(flag & 0x40))
+ {
+ /* Narrow registers. */
+ off = scptr + offsetof (save_state_t, ss_narrow);
+ incr = 4;
+ szoff = 0;
+ }
+ else
+ {
+ /* Wide registers. */
+ off = scptr + offsetof (save_state_t, ss_wide) + 8;
+ incr = 8;
+ szoff = (tdep->bytes_per_address == 4 ? 4 : 0);
+ }
+
+ for (i = 1; i < 32; i++)
+ {
+ info->saved_regs[HPPA_R0_REGNUM + i].addr = off + szoff;
+ off += incr;
+ }
+
+ for (i = 0; i < ARRAY_SIZE (hppa_hpux_tramp_reg); i++)
+ {
+ if (hppa_hpux_tramp_reg[i] > 0)
+ info->saved_regs[hppa_hpux_tramp_reg[i]].addr = off + szoff;
+ off += incr;
+ }
+
+ /* TODO: fp regs */
+
+ info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
+
+ return info;
+}
+
+static void
+hppa_hpux_sigtramp_frame_this_id (struct frame_info *next_frame,
+ void **this_prologue_cache,
+ struct frame_id *this_id)
+{
+ struct hppa_hpux_sigtramp_unwind_cache *info
+ = hppa_hpux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
+ *this_id = frame_id_build (info->base, frame_pc_unwind (next_frame));
+}
+
+static void
+hppa_hpux_sigtramp_frame_prev_register (struct frame_info *next_frame,
+ void **this_prologue_cache,
+ int regnum, int *optimizedp,
+ enum lval_type *lvalp,
+ CORE_ADDR *addrp,
+ int *realnump, gdb_byte *valuep)
+{
+ struct hppa_hpux_sigtramp_unwind_cache *info
+ = hppa_hpux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
+ hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
+ optimizedp, lvalp, addrp, realnump, valuep);
+}
+
+static const struct frame_unwind hppa_hpux_sigtramp_frame_unwind = {
+ SIGTRAMP_FRAME,
+ hppa_hpux_sigtramp_frame_this_id,
+ hppa_hpux_sigtramp_frame_prev_register
+};
+
+static const struct frame_unwind *
+hppa_hpux_sigtramp_unwind_sniffer (struct frame_info *next_frame)
+{
+ CORE_ADDR pc = frame_pc_unwind (next_frame);
+ char *name;
+
+ find_pc_partial_function (pc, &name, NULL, NULL);
+
+ if (name && strcmp(name, "_sigreturn") == 0)
+ return &hppa_hpux_sigtramp_frame_unwind;
+
+ return NULL;
+}
+
+static CORE_ADDR
+hppa32_hpux_find_global_pointer (struct value *function)
+{
+ CORE_ADDR faddr;
+
+ faddr = value_as_address (function);
+
+ /* Is this a plabel? If so, dereference it to get the gp value. */
+ if (faddr & 2)
+ {
+ int status;
+ char buf[4];
+
+ faddr &= ~3;
+
+ status = target_read_memory (faddr + 4, buf, sizeof (buf));
+ if (status == 0)
+ return extract_unsigned_integer (buf, sizeof (buf));
+ }
+
+ return gdbarch_tdep (current_gdbarch)->solib_get_got_by_pc (faddr);
+}
+
+static CORE_ADDR
+hppa64_hpux_find_global_pointer (struct value *function)
+{
+ CORE_ADDR faddr;
+ char buf[32];
+
+ faddr = value_as_address (function);
+
+ if (in_opd_section (faddr))
+ {
+ target_read_memory (faddr, buf, sizeof (buf));
+ return extract_unsigned_integer (&buf[24], 8);
+ }
+ else
+ {
+ return gdbarch_tdep (current_gdbarch)->solib_get_got_by_pc (faddr);
+ }
+}
+
+static unsigned int ldsid_pattern[] = {
+ 0x000010a0, /* ldsid (rX),rY */
+ 0x00001820, /* mtsp rY,sr0 */
+ 0xe0000000 /* be,n (sr0,rX) */
+};
+
+static CORE_ADDR
+hppa_hpux_search_pattern (CORE_ADDR start, CORE_ADDR end,
+ unsigned int *patterns, int count)
+{
+ unsigned int *buf;
+ int offset, i;
+ int region, insns;
+
+ region = end - start + 4;
+ insns = region / 4;
+ buf = (unsigned int *) alloca (region);
+
+ read_memory (start, (char *) buf, region);
+
+ for (i = 0; i < insns; i++)
+ buf[i] = extract_unsigned_integer (&buf[i], 4);
+
+ for (offset = 0; offset <= insns - count; offset++)
+ {
+ for (i = 0; i < count; i++)
+ {
+ if ((buf[offset + i] & patterns[i]) != patterns[i])
+ break;
+ }
+ if (i == count)
+ break;
+ }
+
+ if (offset <= insns - count)
+ return start + offset * 4;
+ else
+ return 0;
+}
+
+static CORE_ADDR
+hppa32_hpux_search_dummy_call_sequence (struct gdbarch *gdbarch, CORE_ADDR pc,
+ int *argreg)
+{
+ struct objfile *obj;
+ struct obj_section *sec;
+ struct hppa_objfile_private *priv;
+ struct frame_info *frame;
+ struct unwind_table_entry *u;
+ CORE_ADDR addr, rp;
+ char buf[4];
+ unsigned int insn;
+
+ sec = find_pc_section (pc);
+ obj = sec->objfile;
+ priv = objfile_data (obj, hppa_objfile_priv_data);
+
+ if (!priv)
+ priv = hppa_init_objfile_priv_data (obj);
+ if (!priv)
+ error (_("Internal error creating objfile private data."));
+
+ /* Use the cached value if we have one. */
+ if (priv->dummy_call_sequence_addr != 0)
+ {
+ *argreg = priv->dummy_call_sequence_reg;
+ return priv->dummy_call_sequence_addr;
+ }
+
+ /* First try a heuristic; if we are in a shared library call, our return
+ pointer is likely to point at an export stub. */
+ frame = get_current_frame ();
+ rp = frame_unwind_register_unsigned (frame, 2);
+ u = find_unwind_entry (rp);
+ if (u && u->stub_unwind.stub_type == EXPORT)
+ {
+ addr = hppa_hpux_search_pattern (u->region_start, u->region_end,
+ ldsid_pattern,
+ ARRAY_SIZE (ldsid_pattern));
+ if (addr)
+ goto found_pattern;
+ }
+
+ /* Next thing to try is to look for an export stub. */
+ if (priv->unwind_info)
+ {
+ int i;
+
+ for (i = 0; i < priv->unwind_info->last; i++)
+ {
+ struct unwind_table_entry *u;
+ u = &priv->unwind_info->table[i];
+ if (u->stub_unwind.stub_type == EXPORT)
+ {
+ addr = hppa_hpux_search_pattern (u->region_start, u->region_end,
+ ldsid_pattern,
+ ARRAY_SIZE (ldsid_pattern));
+ if (addr)
+ {
+ goto found_pattern;
+ }
+ }
+ }
+ }
+
+ /* Finally, if this is the main executable, try to locate a sequence
+ from noshlibs */
+ addr = hppa_symbol_address ("noshlibs");
+ sec = find_pc_section (addr);
+
+ if (sec && sec->objfile == obj)
+ {
+ CORE_ADDR start, end;
+
+ find_pc_partial_function (addr, NULL, &start, &end);
+ if (start != 0 && end != 0)
+ {
+ addr = hppa_hpux_search_pattern (start, end, ldsid_pattern,
+ ARRAY_SIZE (ldsid_pattern));
+ if (addr)
+ goto found_pattern;
+ }
+ }
+
+ /* Can't find a suitable sequence. */
+ return 0;
+
+found_pattern:
+ target_read_memory (addr, buf, sizeof (buf));
+ insn = extract_unsigned_integer (buf, sizeof (buf));
+ priv->dummy_call_sequence_addr = addr;
+ priv->dummy_call_sequence_reg = (insn >> 21) & 0x1f;
+
+ *argreg = priv->dummy_call_sequence_reg;
+ return priv->dummy_call_sequence_addr;
+}
+
+static CORE_ADDR
+hppa64_hpux_search_dummy_call_sequence (struct gdbarch *gdbarch, CORE_ADDR pc,
+ int *argreg)
+{
+ struct objfile *obj;
+ struct obj_section *sec;
+ struct hppa_objfile_private *priv;
+ CORE_ADDR addr;
+ struct minimal_symbol *msym;
+ int i;
+
+ sec = find_pc_section (pc);
+ obj = sec->objfile;
+ priv = objfile_data (obj, hppa_objfile_priv_data);
+
+ if (!priv)
+ priv = hppa_init_objfile_priv_data (obj);
+ if (!priv)
+ error (_("Internal error creating objfile private data."));
+
+ /* Use the cached value if we have one. */
+ if (priv->dummy_call_sequence_addr != 0)
+ {
+ *argreg = priv->dummy_call_sequence_reg;
+ return priv->dummy_call_sequence_addr;
+ }
+
+ /* FIXME: Without stub unwind information, locating a suitable sequence is
+ fairly difficult. For now, we implement a very naive and inefficient
+ scheme; try to read in blocks of code, and look for a "bve,n (rp)"
+ instruction. These are likely to occur at the end of functions, so
+ we only look at the last two instructions of each function. */
+ for (i = 0, msym = obj->msymbols; i < obj->minimal_symbol_count; i++, msym++)
+ {
+ CORE_ADDR begin, end;
+ char *name;
+ unsigned int insns[2];
+ int offset;
+
+ find_pc_partial_function (SYMBOL_VALUE_ADDRESS (msym), &name,
+ &begin, &end);
+
+ if (name == NULL || begin == 0 || end == 0)
+ continue;
+
+ if (target_read_memory (end - sizeof (insns), (char *)insns, sizeof (insns)) == 0)
+ {
+ for (offset = 0; offset < ARRAY_SIZE (insns); offset++)
+ {
+ unsigned int insn;
+
+ insn = extract_unsigned_integer (&insns[offset], 4);
+ if (insn == 0xe840d002) /* bve,n (rp) */
+ {
+ addr = (end - sizeof (insns)) + (offset * 4);
+ goto found_pattern;
+ }
+ }
+ }
+ }
+
+ /* Can't find a suitable sequence. */
+ return 0;
+
+found_pattern:
+ priv->dummy_call_sequence_addr = addr;
+ /* Right now we only look for a "bve,l (rp)" sequence, so the register is
+ always HPPA_RP_REGNUM. */
+ priv->dummy_call_sequence_reg = HPPA_RP_REGNUM;
+
+ *argreg = priv->dummy_call_sequence_reg;
+ return priv->dummy_call_sequence_addr;
+}
+
+static CORE_ADDR
+hppa_hpux_find_import_stub_for_addr (CORE_ADDR funcaddr)
+{
+ struct objfile *objfile;
+ struct minimal_symbol *funsym, *stubsym;
+ CORE_ADDR stubaddr;
+
+ funsym = lookup_minimal_symbol_by_pc (funcaddr);
+ stubaddr = 0;
+
+ ALL_OBJFILES (objfile)
+ {
+ stubsym = lookup_minimal_symbol_solib_trampoline
+ (SYMBOL_LINKAGE_NAME (funsym), objfile);
+
+ if (stubsym)
+ {
+ struct unwind_table_entry *u;
+
+ u = find_unwind_entry (SYMBOL_VALUE (stubsym));
+ if (u == NULL
+ || (u->stub_unwind.stub_type != IMPORT
+ && u->stub_unwind.stub_type != IMPORT_SHLIB))
+ continue;
+
+ stubaddr = SYMBOL_VALUE (stubsym);
+
+ /* If we found an IMPORT stub, then we can stop searching;
+ if we found an IMPORT_SHLIB, we want to continue the search
+ in the hopes that we will find an IMPORT stub. */
+ if (u->stub_unwind.stub_type == IMPORT)
+ break;
+ }
+ }
+
+ return stubaddr;
+}
+
+static int
+hppa_hpux_sr_for_addr (CORE_ADDR addr)
+{
+ int sr;
+ /* The space register to use is encoded in the top 2 bits of the address. */
+ sr = addr >> (gdbarch_tdep (current_gdbarch)->bytes_per_address * 8 - 2);
+ return sr + 4;
+}
+
+static CORE_ADDR
+hppa_hpux_find_dummy_bpaddr (CORE_ADDR addr)
+{
+ /* In order for us to restore the space register to its starting state,
+ we need the dummy trampoline to return to the an instruction address in
+ the same space as where we started the call. We used to place the
+ breakpoint near the current pc, however, this breaks nested dummy calls
+ as the nested call will hit the breakpoint address and terminate
+ prematurely. Instead, we try to look for an address in the same space to
+ put the breakpoint.
+
+ This is similar in spirit to putting the breakpoint at the "entry point"
+ of an executable. */
+
+ struct obj_section *sec;
+ struct unwind_table_entry *u;
+ struct minimal_symbol *msym;
+ CORE_ADDR func;
+ int i;
+
+ sec = find_pc_section (addr);
+ if (sec)
+ {
+ /* First try the lowest address in the section; we can use it as long
+ as it is "regular" code (i.e. not a stub) */
+ u = find_unwind_entry (sec->addr);
+ if (!u || u->stub_unwind.stub_type == 0)
+ return sec->addr;
+
+ /* Otherwise, we need to find a symbol for a regular function. We
+ do this by walking the list of msymbols in the objfile. The symbol
+ we find should not be the same as the function that was passed in. */
+
+ /* FIXME: this is broken, because we can find a function that will be
+ called by the dummy call target function, which will still not
+ work. */
+
+ find_pc_partial_function (addr, NULL, &func, NULL);
+ for (i = 0, msym = sec->objfile->msymbols;
+ i < sec->objfile->minimal_symbol_count;
+ i++, msym++)
+ {
+ u = find_unwind_entry (SYMBOL_VALUE_ADDRESS (msym));
+ if (func != SYMBOL_VALUE_ADDRESS (msym)
+ && (!u || u->stub_unwind.stub_type == 0))
+ return SYMBOL_VALUE_ADDRESS (msym);
+ }
+ }
+
+ warning (_("Cannot find suitable address to place dummy breakpoint; nested "
+ "calls may fail."));
+ return addr - 4;
+}
+
+static CORE_ADDR
+hppa_hpux_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp,
+ CORE_ADDR funcaddr, int using_gcc,
+ struct value **args, int nargs,
+ struct type *value_type,
+ CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
+{
+ CORE_ADDR pc, stubaddr;
+ int argreg;
+
+ pc = read_pc ();
+
+ /* Note: we don't want to pass a function descriptor here; push_dummy_call
+ fills in the PIC register for us. */
+ funcaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funcaddr, NULL);
+
+ /* The simple case is where we call a function in the same space that we are
+ currently in; in that case we don't really need to do anything. */
+ if (hppa_hpux_sr_for_addr (pc) == hppa_hpux_sr_for_addr (funcaddr))
+ {
+ /* Intraspace call. */
+ *bp_addr = hppa_hpux_find_dummy_bpaddr (pc);
+ *real_pc = funcaddr;
+ regcache_cooked_write_unsigned (current_regcache, HPPA_RP_REGNUM, *bp_addr);
+
+ return sp;
+ }
+
+ /* In order to make an interspace call, we need to go through a stub.
+ gcc supplies an appropriate stub called "__gcc_plt_call", however, if
+ an application is compiled with HP compilers then this stub is not
+ available. We used to fallback to "__d_plt_call", however that stub
+ is not entirely useful for us because it doesn't do an interspace
+ return back to the caller. Also, on hppa64-hpux, there is no
+ __gcc_plt_call available. In order to keep the code uniform, we
+ instead don't use either of these stubs, but instead write our own
+ onto the stack.
+
+ A problem arises since the stack is located in a different space than
+ code, so in order to branch to a stack stub, we will need to do an
+ interspace branch. Previous versions of gdb did this by modifying code
+ at the current pc and doing single-stepping to set the pcsq. Since this
+ is highly undesirable, we use a different scheme:
+
+ All we really need to do the branch to the stub is a short instruction
+ sequence like this:
+
+ PA1.1:
+ ldsid (rX),r1
+ mtsp r1,sr0
+ be,n (sr0,rX)
+
+ PA2.0:
+ bve,n (sr0,rX)
+
+ Instead of writing these sequences ourselves, we can find it in
+ the instruction stream that belongs to the current space. While this
+ seems difficult at first, we are actually guaranteed to find the sequences
+ in several places:
+
+ For 32-bit code:
+ - in export stubs for shared libraries
+ - in the "noshlibs" routine in the main module
+
+ For 64-bit code:
+ - at the end of each "regular" function
+
+ We cache the address of these sequences in the objfile's private data
+ since these operations can potentially be quite expensive.
+
+ So, what we do is:
+ - write a stack trampoline
+ - look for a suitable instruction sequence in the current space
+ - point the sequence at the trampoline
+ - set the return address of the trampoline to the current space
+ (see hppa_hpux_find_dummy_call_bpaddr)
+ - set the continuing address of the "dummy code" as the sequence.
+
+*/
+
+ if (IS_32BIT_TARGET (gdbarch))
+ {
+ static unsigned int hppa32_tramp[] = {
+ 0x0fdf1291, /* stw r31,-8(,sp) */
+ 0x02c010a1, /* ldsid (,r22),r1 */
+ 0x00011820, /* mtsp r1,sr0 */
+ 0xe6c00000, /* be,l 0(sr0,r22),%sr0,%r31 */
+ 0x081f0242, /* copy r31,rp */
+ 0x0fd11082, /* ldw -8(,sp),rp */
+ 0x004010a1, /* ldsid (,rp),r1 */
+ 0x00011820, /* mtsp r1,sr0 */
+ 0xe0400000, /* be 0(sr0,rp) */
+ 0x08000240 /* nop */
+ };
+
+ /* for hppa32, we must call the function through a stub so that on
+ return it can return to the space of our trampoline. */
+ stubaddr = hppa_hpux_find_import_stub_for_addr (funcaddr);
+ if (stubaddr == 0)
+ error (_("Cannot call external function not referenced by application "
+ "(no import stub).\n"));
+ regcache_cooked_write_unsigned (current_regcache, 22, stubaddr);
+
+ write_memory (sp, (char *)&hppa32_tramp, sizeof (hppa32_tramp));
+
+ *bp_addr = hppa_hpux_find_dummy_bpaddr (pc);
+ regcache_cooked_write_unsigned (current_regcache, 31, *bp_addr);
+
+ *real_pc = hppa32_hpux_search_dummy_call_sequence (gdbarch, pc, &argreg);
+ if (*real_pc == 0)
+ error (_("Cannot make interspace call from here."));
+
+ regcache_cooked_write_unsigned (current_regcache, argreg, sp);
+
+ sp += sizeof (hppa32_tramp);
+ }
+ else
+ {
+ static unsigned int hppa64_tramp[] = {
+ 0xeac0f000, /* bve,l (r22),%r2 */
+ 0x0fdf12d1, /* std r31,-8(,sp) */
+ 0x0fd110c2, /* ldd -8(,sp),rp */
+ 0xe840d002, /* bve,n (rp) */
+ 0x08000240 /* nop */
+ };
+
+ /* for hppa64, we don't need to call through a stub; all functions
+ return via a bve. */
+ regcache_cooked_write_unsigned (current_regcache, 22, funcaddr);
+ write_memory (sp, (char *)&hppa64_tramp, sizeof (hppa64_tramp));
+
+ *bp_addr = pc - 4;
+ regcache_cooked_write_unsigned (current_regcache, 31, *bp_addr);
+
+ *real_pc = hppa64_hpux_search_dummy_call_sequence (gdbarch, pc, &argreg);
+ if (*real_pc == 0)
+ error (_("Cannot make interspace call from here."));
+
+ regcache_cooked_write_unsigned (current_regcache, argreg, sp);
+
+ sp += sizeof (hppa64_tramp);
+ }
+
+ sp = gdbarch_frame_align (gdbarch, sp);
+
+ return sp;
+}
+
+\f
+
+/* Bit in the `ss_flag' member of `struct save_state' that indicates
+ that the 64-bit register values are live. From
+ <machine/save_state.h>. */
+#define HPPA_HPUX_SS_WIDEREGS 0x40
+
+/* Offsets of various parts of `struct save_state'. From
+ <machine/save_state.h>. */
+#define HPPA_HPUX_SS_FLAGS_OFFSET 0
+#define HPPA_HPUX_SS_NARROW_OFFSET 4
+#define HPPA_HPUX_SS_FPBLOCK_OFFSET 256
+#define HPPA_HPUX_SS_WIDE_OFFSET 640
+
+/* The size of `struct save_state. */
+#define HPPA_HPUX_SAVE_STATE_SIZE 1152
+
+/* The size of `struct pa89_save_state', which corresponds to PA-RISC
+ 1.1, the lowest common denominator that we support. */
+#define HPPA_HPUX_PA89_SAVE_STATE_SIZE 512
+
+static void
+hppa_hpux_supply_ss_narrow (struct regcache *regcache,
+ int regnum, const char *save_state)
+{
+ const char *ss_narrow = save_state + HPPA_HPUX_SS_NARROW_OFFSET;
+ int i, offset = 0;
+
+ for (i = HPPA_R1_REGNUM; i < HPPA_FP0_REGNUM; i++)
+ {
+ if (regnum == i || regnum == -1)
+ regcache_raw_supply (regcache, i, ss_narrow + offset);
+
+ offset += 4;
+ }
+}
+
+static void
+hppa_hpux_supply_ss_fpblock (struct regcache *regcache,
+ int regnum, const char *save_state)
+{
+ const char *ss_fpblock = save_state + HPPA_HPUX_SS_FPBLOCK_OFFSET;
+ int i, offset = 0;
+
+ /* FIXME: We view the floating-point state as 64 single-precision
+ registers for 32-bit code, and 32 double-precision register for
+ 64-bit code. This distinction is artificial and should be
+ eliminated. If that ever happens, we should remove the if-clause
+ below. */
+
+ if (register_size (get_regcache_arch (regcache), HPPA_FP0_REGNUM) == 4)
+ {
+ for (i = HPPA_FP0_REGNUM; i < HPPA_FP0_REGNUM + 64; i++)
+ {
+ if (regnum == i || regnum == -1)
+ regcache_raw_supply (regcache, i, ss_fpblock + offset);
+
+ offset += 4;
+ }
+ }
+ else
+ {
+ for (i = HPPA_FP0_REGNUM; i < HPPA_FP0_REGNUM + 32; i++)
+ {
+ if (regnum == i || regnum == -1)
+ regcache_raw_supply (regcache, i, ss_fpblock + offset);
+
+ offset += 8;
+ }
+ }
+}
+
+static void
+hppa_hpux_supply_ss_wide (struct regcache *regcache,
+ int regnum, const char *save_state)
+{
+ const char *ss_wide = save_state + HPPA_HPUX_SS_WIDE_OFFSET;
+ int i, offset = 8;
+
+ if (register_size (get_regcache_arch (regcache), HPPA_R1_REGNUM) == 4)
+ offset += 4;
+
+ for (i = HPPA_R1_REGNUM; i < HPPA_FP0_REGNUM; i++)
+ {
+ if (regnum == i || regnum == -1)
+ regcache_raw_supply (regcache, i, ss_wide + offset);
+
+ offset += 8;
+ }
+}
+
+static void
+hppa_hpux_supply_save_state (const struct regset *regset,
+ struct regcache *regcache,
+ int regnum, const void *regs, size_t len)
+{
+ const char *proc_info = regs;
+ const char *save_state = proc_info + 8;
+ ULONGEST flags;
+
+ flags = extract_unsigned_integer (save_state + HPPA_HPUX_SS_FLAGS_OFFSET, 4);
+ if (regnum == -1 || regnum == HPPA_FLAGS_REGNUM)
+ {
+ struct gdbarch *arch = get_regcache_arch (regcache);
+ size_t size = register_size (arch, HPPA_FLAGS_REGNUM);
+ char buf[8];
+
+ store_unsigned_integer (buf, size, flags);
+ regcache_raw_supply (regcache, HPPA_FLAGS_REGNUM, buf);
+ }
+
+ /* If the SS_WIDEREGS flag is set, we really do need the full
+ `struct save_state'. */
+ if (flags & HPPA_HPUX_SS_WIDEREGS && len < HPPA_HPUX_SAVE_STATE_SIZE)
+ error (_("Register set contents too small"));
+
+ if (flags & HPPA_HPUX_SS_WIDEREGS)
+ hppa_hpux_supply_ss_wide (regcache, regnum, save_state);
+ else
+ hppa_hpux_supply_ss_narrow (regcache, regnum, save_state);
+
+ hppa_hpux_supply_ss_fpblock (regcache, regnum, save_state);
+}
+
+/* HP-UX register set. */
+
+static struct regset hppa_hpux_regset =
+{
+ NULL,
+ hppa_hpux_supply_save_state
+};
+
+static const struct regset *
+hppa_hpux_regset_from_core_section (struct gdbarch *gdbarch,
+ const char *sect_name, size_t sect_size)
+{
+ if (strcmp (sect_name, ".reg") == 0
+ && sect_size >= HPPA_HPUX_PA89_SAVE_STATE_SIZE + 8)
+ return &hppa_hpux_regset;
+
+ return NULL;
+}
+\f
+
+/* Bit in the `ss_flag' member of `struct save_state' that indicates
+ the state was saved from a system call. From
+ <machine/save_state.h>. */
+#define HPPA_HPUX_SS_INSYSCALL 0x02
+
+static CORE_ADDR
+hppa_hpux_read_pc (ptid_t ptid)
+{
+ ULONGEST flags;
+
+ /* If we're currently in a system call return the contents of %r31. */
+ flags = read_register_pid (HPPA_FLAGS_REGNUM, ptid);
+ if (flags & HPPA_HPUX_SS_INSYSCALL)
+ return read_register_pid (HPPA_R31_REGNUM, ptid) & ~0x3;
+
+ return hppa_read_pc (ptid);
+}
+
+static void
+hppa_hpux_write_pc (CORE_ADDR pc, ptid_t ptid)
+{
+ ULONGEST flags;
+
+ /* If we're currently in a system call also write PC into %r31. */
+ flags = read_register_pid (HPPA_FLAGS_REGNUM, ptid);
+ if (flags & HPPA_HPUX_SS_INSYSCALL)
+ write_register_pid (HPPA_R31_REGNUM, pc | 0x3, ptid);
+
+ return hppa_write_pc (pc, ptid);
+}
+
+static CORE_ADDR
+hppa_hpux_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
+{
+ ULONGEST flags;
+
+ /* If we're currently in a system call return the contents of %r31. */
+ flags = frame_unwind_register_unsigned (next_frame, HPPA_FLAGS_REGNUM);
+ if (flags & HPPA_HPUX_SS_INSYSCALL)
+ return frame_unwind_register_unsigned (next_frame, HPPA_R31_REGNUM) & ~0x3;
+
+ return hppa_unwind_pc (gdbarch, next_frame);
+}
+\f
+
+static void
+hppa_hpux_inferior_created (struct target_ops *objfile, int from_tty)
+{
+ /* Some HP-UX related globals to clear when a new "main"
+ symbol file is loaded. HP-specific. */
+ deprecated_hp_som_som_object_present = 0;
+ hp_cxx_exception_support_initialized = 0;
+}
+
+/* Given the current value of the pc, check to see if it is inside a stub, and
+ if so, change the value of the pc to point to the caller of the stub.
+ NEXT_FRAME is the next frame in the current list of frames.
+ BASE contains to stack frame base of the current frame.
+ SAVE_REGS is the register file stored in the frame cache. */
+static void
+hppa_hpux_unwind_adjust_stub (struct frame_info *next_frame, CORE_ADDR base,
+ struct trad_frame_saved_reg *saved_regs)
+{
+ int optimized, realreg;
+ enum lval_type lval;
+ CORE_ADDR addr;
+ char buffer[sizeof(ULONGEST)];
+ ULONGEST val;
+ CORE_ADDR stubpc;
+ struct unwind_table_entry *u;
+
+ trad_frame_get_prev_register (next_frame, saved_regs,
+ HPPA_PCOQ_HEAD_REGNUM,
+ &optimized, &lval, &addr, &realreg, buffer);
+ val = extract_unsigned_integer (buffer,
+ register_size (get_frame_arch (next_frame),
+ HPPA_PCOQ_HEAD_REGNUM));
+
+ u = find_unwind_entry (val);
+ if (u && u->stub_unwind.stub_type == EXPORT)
+ {
+ stubpc = read_memory_integer (base - 24, TARGET_PTR_BIT / 8);
+ trad_frame_set_value (saved_regs, HPPA_PCOQ_HEAD_REGNUM, stubpc);
+ }
+ else if (hppa_symbol_address ("__gcc_plt_call")
+ == get_pc_function_start (val))
+ {
+ stubpc = read_memory_integer (base - 8, TARGET_PTR_BIT / 8);
+ trad_frame_set_value (saved_regs, HPPA_PCOQ_HEAD_REGNUM, stubpc);
+ }
+}
+
static void
hppa_hpux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- if (tdep->bytes_per_address == 4)
- set_gdbarch_in_solib_call_trampoline (gdbarch,
- hppa32_hpux_in_solib_call_trampoline);
+ if (IS_32BIT_TARGET (gdbarch))
+ tdep->in_solib_call_trampoline = hppa32_hpux_in_solib_call_trampoline;
else
- set_gdbarch_in_solib_call_trampoline (gdbarch,
- hppa64_hpux_in_solib_call_trampoline);
+ tdep->in_solib_call_trampoline = hppa64_hpux_in_solib_call_trampoline;
- set_gdbarch_in_solib_return_trampoline (gdbarch,
- hppa_hpux_in_solib_return_trampoline);
+ tdep->unwind_adjust_stub = hppa_hpux_unwind_adjust_stub;
+
+ set_gdbarch_in_solib_return_trampoline
+ (gdbarch, hppa_hpux_in_solib_return_trampoline);
set_gdbarch_skip_trampoline_code (gdbarch, hppa_hpux_skip_trampoline_code);
+
+ set_gdbarch_push_dummy_code (gdbarch, hppa_hpux_push_dummy_code);
+ set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
+
+ set_gdbarch_read_pc (gdbarch, hppa_hpux_read_pc);
+ set_gdbarch_write_pc (gdbarch, hppa_hpux_write_pc);
+ set_gdbarch_unwind_pc (gdbarch, hppa_hpux_unwind_pc);
+
+ set_gdbarch_regset_from_core_section
+ (gdbarch, hppa_hpux_regset_from_core_section);
+
+ frame_unwind_append_sniffer (gdbarch, hppa_hpux_sigtramp_unwind_sniffer);
+
+ observer_attach_inferior_created (hppa_hpux_inferior_created);
}
static void
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
tdep->is_elf = 0;
+
+ tdep->find_global_pointer = hppa32_hpux_find_global_pointer;
+
hppa_hpux_init_abi (info, gdbarch);
+ som_solib_select (tdep);
}
static void
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
tdep->is_elf = 1;
+ tdep->find_global_pointer = hppa64_hpux_find_global_pointer;
+
hppa_hpux_init_abi (info, gdbarch);
+ pa64_solib_select (tdep);
+}
+
+static enum gdb_osabi
+hppa_hpux_core_osabi_sniffer (bfd *abfd)
+{
+ if (strcmp (bfd_get_target (abfd), "hpux-core") == 0)
+ return GDB_OSABI_HPUX_SOM;
+
+ return GDB_OSABI_UNKNOWN;
}
void
_initialize_hppa_hpux_tdep (void)
{
+ /* BFD doesn't set a flavour for HP-UX style core files. It doesn't
+ set the architecture either. */
+ gdbarch_register_osabi_sniffer (bfd_arch_unknown,
+ bfd_target_unknown_flavour,
+ hppa_hpux_core_osabi_sniffer);
+
gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_HPUX_SOM,
hppa_hpux_som_init_abi);
gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w, GDB_OSABI_HPUX_ELF,