-/* Target-dependent code for the HP PA architecture, for GDB.
+/* Target-dependent code for the HP PA-RISC architecture.
- Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
- Foundation, Inc.
+ Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
+ 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
+ Free Software Foundation, Inc.
Contributed by the Center for Software Science at the
University of Utah (pa-gdb-bugs@cs.utah.edu).
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. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
#include "defs.h"
-#include "frame.h"
#include "bfd.h"
#include "inferior.h"
-#include "value.h"
#include "regcache.h"
#include "completer.h"
-#include "language.h"
#include "osabi.h"
#include "gdb_assert.h"
-#include "infttrace.h"
#include "arch-utils.h"
/* For argument passing to the inferior */
#include "symtab.h"
-#include "infcall.h"
#include "dis-asm.h"
#include "trad-frame.h"
#include "frame-unwind.h"
#include "frame-base.h"
-#ifdef USG
-#include <sys/types.h>
-#endif
-
-#include <dl.h>
-#include <sys/param.h>
-#include <signal.h>
-
-#include <sys/ptrace.h>
-#include <machine/save_state.h>
-
-#ifdef COFF_ENCAPSULATE
-#include "a.out.encap.h"
-#else
-#endif
-
-/*#include <sys/user.h> After a.out.h */
-#include <sys/file.h>
-#include "gdb_stat.h"
-#include "gdb_wait.h"
-
#include "gdbcore.h"
#include "gdbcmd.h"
-#include "target.h"
-#include "symfile.h"
#include "objfiles.h"
#include "hppa-tdep.h"
+static int hppa_debug = 0;
+
/* Some local constants. */
static const int hppa32_num_regs = 128;
static const int hppa64_num_regs = 96;
+/* hppa-specific object data -- unwind and solib info.
+ TODO/maybe: think about splitting this into two parts; the unwind data is
+ common to all hppa targets, but is only used in this file; we can register
+ that separately and make this static. The solib data is probably hpux-
+ specific, so we can create a separate extern objfile_data that is registered
+ by hppa-hpux-tdep.c and shared with pa64solib.c and somsolib.c. */
+const struct objfile_data *hppa_objfile_priv_data = NULL;
+
/* Get at various relevent fields of an instruction word. */
#define MASK_5 0x1f
#define MASK_11 0x7ff
#define MASK_14 0x3fff
#define MASK_21 0x1fffff
-/* Define offsets into the call dummy for the _sr4export address.
- See comments related to CALL_DUMMY for more info. */
-#define SR4EXPORT_LDIL_OFFSET (INSTRUCTION_SIZE * 12)
-#define SR4EXPORT_LDO_OFFSET (INSTRUCTION_SIZE * 13)
-
-/* To support detection of the pseudo-initial frame
- that threads have. */
-#define THREAD_INITIAL_FRAME_SYMBOL "__pthread_exit"
-#define THREAD_INITIAL_FRAME_SYM_LEN sizeof(THREAD_INITIAL_FRAME_SYMBOL)
-
/* Sizes (in bytes) of the native unwind entries. */
#define UNWIND_ENTRY_SIZE 16
#define STUB_UNWIND_ENTRY_SIZE 8
-static int get_field (unsigned word, int from, int to);
-
-static int extract_5_load (unsigned int);
-
-static unsigned extract_5R_store (unsigned int);
-
-static unsigned extract_5r_store (unsigned int);
-
-struct unwind_table_entry *find_unwind_entry (CORE_ADDR);
-
-static int extract_17 (unsigned int);
-
-static int extract_21 (unsigned);
-
-static int extract_14 (unsigned);
-
-static void unwind_command (char *, int);
-
-static int low_sign_extend (unsigned int, unsigned int);
-
-static int sign_extend (unsigned int, unsigned int);
-
-static int hppa_alignof (struct type *);
-
-static int prologue_inst_adjust_sp (unsigned long);
-
-static int is_branch (unsigned long);
-
-static int inst_saves_gr (unsigned long);
-
-static int inst_saves_fr (unsigned long);
-
-static int compare_unwind_entries (const void *, const void *);
-
-static void read_unwind_info (struct objfile *);
-
-static void internalize_unwinds (struct objfile *,
- struct unwind_table_entry *,
- asection *, unsigned int,
- unsigned int, CORE_ADDR);
-static void pa_print_registers (char *, int, int);
-static void pa_strcat_registers (char *, int, int, struct ui_file *);
-static void pa_register_look_aside (char *, int, long *);
-static void pa_print_fp_reg (int);
-static void pa_strcat_fp_reg (int, struct ui_file *, enum precision_type);
-static void record_text_segment_lowaddr (bfd *, asection *, void *);
/* FIXME: brobecker 2002-11-07: We will likely be able to make the
following functions static, once we hppa is partially multiarched. */
-int hppa_reg_struct_has_addr (int gcc_p, struct type *type);
-CORE_ADDR hppa_skip_prologue (CORE_ADDR pc);
-CORE_ADDR hppa_skip_trampoline_code (CORE_ADDR pc);
-int hppa_in_solib_call_trampoline (CORE_ADDR pc, char *name);
-int hppa_in_solib_return_trampoline (CORE_ADDR pc, char *name);
-int hppa_inner_than (CORE_ADDR lhs, CORE_ADDR rhs);
int hppa_pc_requires_run_before_use (CORE_ADDR pc);
-int hppa_instruction_nullified (void);
-int hppa_register_raw_size (int reg_nr);
-int hppa_register_byte (int reg_nr);
-struct type * hppa32_register_virtual_type (int reg_nr);
-struct type * hppa64_register_virtual_type (int reg_nr);
-int hppa_cannot_store_register (int regnum);
-CORE_ADDR hppa_smash_text_address (CORE_ADDR addr);
-CORE_ADDR hppa_target_read_pc (ptid_t ptid);
-void hppa_target_write_pc (CORE_ADDR v, ptid_t ptid);
-CORE_ADDR hppa_target_read_fp (void);
-
-typedef struct
- {
- struct minimal_symbol *msym;
- CORE_ADDR solib_handle;
- CORE_ADDR return_val;
- }
-args_for_find_stub;
-
-static int cover_find_stub_with_shl_get (void *);
-
-static int is_pa_2 = 0; /* False */
-
-/* This is declared in symtab.c; set to 1 in hp-symtab-read.c */
-extern int hp_som_som_object_present;
-
-/* In breakpoint.c */
-extern int exception_catchpoints_are_fragile;
-
-/* Handle 32/64-bit struct return conventions. */
-
-static enum return_value_convention
-hppa32_return_value (struct gdbarch *gdbarch,
- struct type *type, struct regcache *regcache,
- void *readbuf, const void *writebuf)
-{
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
- {
- if (readbuf != NULL)
- regcache_cooked_read_part (regcache, FP4_REGNUM, 0,
- TYPE_LENGTH (type), readbuf);
- if (writebuf != NULL)
- regcache_cooked_write_part (regcache, FP4_REGNUM, 0,
- TYPE_LENGTH (type), writebuf);
- return RETURN_VALUE_REGISTER_CONVENTION;
- }
- if (TYPE_LENGTH (type) <= 2 * 4)
- {
- /* The value always lives in the right hand end of the register
- (or register pair)? */
- int b;
- int reg = 28;
- int part = TYPE_LENGTH (type) % 4;
- /* The left hand register contains only part of the value,
- transfer that first so that the rest can be xfered as entire
- 4-byte registers. */
- if (part > 0)
- {
- if (readbuf != NULL)
- regcache_cooked_read_part (regcache, reg, 4 - part,
- part, readbuf);
- if (writebuf != NULL)
- regcache_cooked_write_part (regcache, reg, 4 - part,
- part, writebuf);
- reg++;
- }
- /* Now transfer the remaining register values. */
- for (b = part; b < TYPE_LENGTH (type); b += 4)
- {
- if (readbuf != NULL)
- regcache_cooked_read (regcache, reg, (char *) readbuf + b);
- if (writebuf != NULL)
- regcache_cooked_write (regcache, reg, (const char *) writebuf + b);
- reg++;
- }
- return RETURN_VALUE_REGISTER_CONVENTION;
- }
- else
- return RETURN_VALUE_STRUCT_CONVENTION;
-}
-
-static enum return_value_convention
-hppa64_return_value (struct gdbarch *gdbarch,
- struct type *type, struct regcache *regcache,
- void *readbuf, const void *writebuf)
-{
- /* RM: Floats are returned in FR4R, doubles in FR4. Integral values
- are in r28, padded on the left. Aggregates less that 65 bits are
- in r28, right padded. Aggregates upto 128 bits are in r28 and
- r29, right padded. */
- if (TYPE_CODE (type) == TYPE_CODE_FLT
- && TYPE_LENGTH (type) <= 8)
- {
- /* Floats are right aligned? */
- int offset = register_size (gdbarch, FP4_REGNUM) - TYPE_LENGTH (type);
- if (readbuf != NULL)
- regcache_cooked_read_part (regcache, FP4_REGNUM, offset,
- TYPE_LENGTH (type), readbuf);
- if (writebuf != NULL)
- regcache_cooked_write_part (regcache, FP4_REGNUM, offset,
- TYPE_LENGTH (type), writebuf);
- return RETURN_VALUE_REGISTER_CONVENTION;
- }
- else if (TYPE_LENGTH (type) <= 8 && is_integral_type (type))
- {
- /* Integrals are right aligned. */
- int offset = register_size (gdbarch, FP4_REGNUM) - TYPE_LENGTH (type);
- if (readbuf != NULL)
- regcache_cooked_read_part (regcache, 28, offset,
- TYPE_LENGTH (type), readbuf);
- if (writebuf != NULL)
- regcache_cooked_write_part (regcache, 28, offset,
- TYPE_LENGTH (type), writebuf);
- return RETURN_VALUE_REGISTER_CONVENTION;
- }
- else if (TYPE_LENGTH (type) <= 2 * 8)
- {
- /* Composite values are left aligned. */
- int b;
- for (b = 0; b < TYPE_LENGTH (type); b += 8)
- {
- int part = min (8, TYPE_LENGTH (type) - b);
- if (readbuf != NULL)
- regcache_cooked_read_part (regcache, 28 + b / 8, 0, part,
- (char *) readbuf + b);
- if (writebuf != NULL)
- regcache_cooked_write_part (regcache, 28 + b / 8, 0, part,
- (const char *) writebuf + b);
- }
- return RETURN_VALUE_REGISTER_CONVENTION;
- }
- else
- return RETURN_VALUE_STRUCT_CONVENTION;
-}
/* Routines to extract various sized constants out of hppa
instructions. */
/* This assumes that no garbage lies outside of the lower bits of
value. */
-static int
-sign_extend (unsigned val, unsigned bits)
+int
+hppa_sign_extend (unsigned val, unsigned bits)
{
return (int) (val >> (bits - 1) ? (-1 << bits) | val : val);
}
/* For many immediate values the sign bit is the low bit! */
-static int
-low_sign_extend (unsigned val, unsigned bits)
+int
+hppa_low_hppa_sign_extend (unsigned val, unsigned bits)
{
return (int) ((val & 0x1 ? (-1 << (bits - 1)) : 0) | val >> 1);
}
/* Extract the bits at positions between FROM and TO, using HP's numbering
(MSB = 0). */
-static int
-get_field (unsigned word, int from, int to)
+int
+hppa_get_field (unsigned word, int from, int to)
{
return ((word) >> (31 - (to)) & ((1 << ((to) - (from) + 1)) - 1));
}
/* extract the immediate field from a ld{bhw}s instruction */
-static int
-extract_5_load (unsigned word)
+int
+hppa_extract_5_load (unsigned word)
{
- return low_sign_extend (word >> 16 & MASK_5, 5);
+ return hppa_low_hppa_sign_extend (word >> 16 & MASK_5, 5);
}
/* extract the immediate field from a break instruction */
-static unsigned
-extract_5r_store (unsigned word)
+unsigned
+hppa_extract_5r_store (unsigned word)
{
return (word & MASK_5);
}
/* extract the immediate field from a {sr}sm instruction */
-static unsigned
-extract_5R_store (unsigned word)
+unsigned
+hppa_extract_5R_store (unsigned word)
{
return (word >> 16 & MASK_5);
}
/* extract a 14 bit immediate field */
-static int
-extract_14 (unsigned word)
+int
+hppa_extract_14 (unsigned word)
{
- return low_sign_extend (word & MASK_14, 14);
+ return hppa_low_hppa_sign_extend (word & MASK_14, 14);
}
/* extract a 21 bit constant */
-static int
-extract_21 (unsigned word)
+int
+hppa_extract_21 (unsigned word)
{
int val;
word &= MASK_21;
word <<= 11;
- val = get_field (word, 20, 20);
+ val = hppa_get_field (word, 20, 20);
val <<= 11;
- val |= get_field (word, 9, 19);
+ val |= hppa_get_field (word, 9, 19);
val <<= 2;
- val |= get_field (word, 5, 6);
+ val |= hppa_get_field (word, 5, 6);
val <<= 5;
- val |= get_field (word, 0, 4);
+ val |= hppa_get_field (word, 0, 4);
val <<= 2;
- val |= get_field (word, 7, 8);
- return sign_extend (val, 21) << 11;
+ val |= hppa_get_field (word, 7, 8);
+ return hppa_sign_extend (val, 21) << 11;
}
/* extract a 17 bit constant from branch instructions, returning the
19 bit signed value. */
-static int
-extract_17 (unsigned word)
+int
+hppa_extract_17 (unsigned word)
{
- return sign_extend (get_field (word, 19, 28) |
- get_field (word, 29, 29) << 10 |
- get_field (word, 11, 15) << 11 |
+ return hppa_sign_extend (hppa_get_field (word, 19, 28) |
+ hppa_get_field (word, 29, 29) << 10 |
+ hppa_get_field (word, 11, 15) << 11 |
(word & 0x1) << 16, 17) << 2;
}
+
+CORE_ADDR
+hppa_symbol_address(const char *sym)
+{
+ struct minimal_symbol *minsym;
+
+ minsym = lookup_minimal_symbol (sym, NULL, NULL);
+ if (minsym)
+ return SYMBOL_VALUE_ADDRESS (minsym);
+ else
+ return (CORE_ADDR)-1;
+}
+
+struct hppa_objfile_private *
+hppa_init_objfile_priv_data (struct objfile *objfile)
+{
+ struct hppa_objfile_private *priv;
+
+ priv = (struct hppa_objfile_private *)
+ obstack_alloc (&objfile->objfile_obstack,
+ sizeof (struct hppa_objfile_private));
+ set_objfile_data (objfile, hppa_objfile_priv_data, priv);
+ memset (priv, 0, sizeof (*priv));
+
+ return priv;
+}
\f
/* Compare the start address for two unwind entries returning 1 if
return 0;
}
-static CORE_ADDR low_text_segment_address;
-
static void
-record_text_segment_lowaddr (bfd *abfd, asection *section, void *ignored)
+record_text_segment_lowaddr (bfd *abfd, asection *section, void *data)
{
- if (((section->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
+ if ((section->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
== (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
- && section->vma < low_text_segment_address)
- low_text_segment_address = section->vma;
+ {
+ bfd_vma value = section->vma - section->filepos;
+ CORE_ADDR *low_text_segment_address = (CORE_ADDR *)data;
+
+ if (value < *low_text_segment_address)
+ *low_text_segment_address = value;
+ }
}
static void
{
/* We will read the unwind entries into temporary memory, then
fill in the actual unwind table. */
+
if (size > 0)
{
unsigned long tmp;
unsigned i;
char *buf = alloca (size);
+ CORE_ADDR low_text_segment_address;
- low_text_segment_address = -1;
-
- /* If addresses are 64 bits wide, then unwinds are supposed to
+ /* For ELF targets, then unwinds are supposed to
be segment relative offsets instead of absolute addresses.
Note that when loading a shared library (text_offset != 0) the
unwinds are already relative to the text_offset that will be
passed in. */
- if (TARGET_PTR_BIT == 64 && text_offset == 0)
+ if (gdbarch_tdep (current_gdbarch)->is_elf && text_offset == 0)
{
+ low_text_segment_address = -1;
+
bfd_map_over_sections (objfile->obfd,
- record_text_segment_lowaddr, NULL);
+ record_text_segment_lowaddr,
+ &low_text_segment_address);
- /* ?!? Mask off some low bits. Should this instead subtract
- out the lowest section's filepos or something like that?
- This looks very hokey to me. */
- low_text_segment_address &= ~0xfff;
- text_offset += low_text_segment_address;
+ text_offset = low_text_segment_address;
+ }
+ else if (gdbarch_tdep (current_gdbarch)->solib_get_text_base)
+ {
+ text_offset = gdbarch_tdep (current_gdbarch)->solib_get_text_base (objfile);
}
bfd_get_section_contents (objfile->obfd, section, buf, 0, size);
table[i].Millicode = (tmp >> 30) & 0x1;
table[i].Millicode_save_sr0 = (tmp >> 29) & 0x1;
table[i].Region_description = (tmp >> 27) & 0x3;
- table[i].reserved1 = (tmp >> 26) & 0x1;
+ table[i].reserved = (tmp >> 26) & 0x1;
table[i].Entry_SR = (tmp >> 25) & 0x1;
table[i].Entry_FR = (tmp >> 21) & 0xf;
table[i].Entry_GR = (tmp >> 16) & 0x1f;
table[i].Frame_Extension_Millicode = (tmp >> 12) & 0x1;
table[i].Stack_Overflow_Check = (tmp >> 11) & 0x1;
table[i].Two_Instruction_SP_Increment = (tmp >> 10) & 0x1;
- table[i].Ada_Region = (tmp >> 9) & 0x1;
+ table[i].sr4export = (tmp >> 9) & 0x1;
table[i].cxx_info = (tmp >> 8) & 0x1;
table[i].cxx_try_catch = (tmp >> 7) & 0x1;
table[i].sched_entry_seq = (tmp >> 6) & 0x1;
- table[i].reserved2 = (tmp >> 5) & 0x1;
+ table[i].reserved1 = (tmp >> 5) & 0x1;
table[i].Save_SP = (tmp >> 4) & 0x1;
table[i].Save_RP = (tmp >> 3) & 0x1;
table[i].Save_MRP_in_frame = (tmp >> 2) & 0x1;
- table[i].extn_ptr_defined = (tmp >> 1) & 0x1;
+ table[i].save_r19 = (tmp >> 1) & 0x1;
table[i].Cleanup_defined = tmp & 0x1;
tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
buf += 4;
table[i].MPE_XL_interrupt_marker = (tmp >> 31) & 0x1;
table[i].HP_UX_interrupt_marker = (tmp >> 30) & 0x1;
table[i].Large_frame = (tmp >> 29) & 0x1;
- table[i].Pseudo_SP_Set = (tmp >> 28) & 0x1;
- table[i].reserved4 = (tmp >> 27) & 0x1;
+ table[i].alloca_frame = (tmp >> 28) & 0x1;
+ table[i].reserved2 = (tmp >> 27) & 0x1;
table[i].Total_frame_size = tmp & 0x7ffffff;
/* Stub unwinds are handled elsewhere. */
unsigned index, unwind_entries;
unsigned stub_entries, total_entries;
CORE_ADDR text_offset;
- struct obj_unwind_info *ui;
- obj_private_data_t *obj_private;
+ struct hppa_unwind_info *ui;
+ struct hppa_objfile_private *obj_private;
text_offset = ANOFFSET (objfile->section_offsets, 0);
- ui = (struct obj_unwind_info *) obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct obj_unwind_info));
+ ui = (struct hppa_unwind_info *) obstack_alloc (&objfile->objfile_obstack,
+ sizeof (struct hppa_unwind_info));
ui->table = NULL;
ui->cache = NULL;
}
/* Now compute the size of the stub unwinds. Note the ELF tools do not
- use stub unwinds at the curren time. */
+ use stub unwinds at the current time. */
stub_unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_END$");
if (stub_unwind_sec)
compare_unwind_entries);
/* Keep a pointer to the unwind information. */
- if (objfile->obj_private == NULL)
- {
- obj_private = (obj_private_data_t *)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (obj_private_data_t));
- obj_private->unwind_info = NULL;
- obj_private->so_info = NULL;
- obj_private->dp = 0;
-
- objfile->obj_private = obj_private;
- }
- obj_private = (obj_private_data_t *) objfile->obj_private;
+ obj_private = (struct hppa_objfile_private *)
+ objfile_data (objfile, hppa_objfile_priv_data);
+ if (obj_private == NULL)
+ obj_private = hppa_init_objfile_priv_data (objfile);
+
obj_private->unwind_info = ui;
}
{
int first, middle, last;
struct objfile *objfile;
+ struct hppa_objfile_private *priv;
+
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, "{ find_unwind_entry 0x%s -> ",
+ paddr_nz (pc));
/* A function at address 0? Not in HP-UX! */
if (pc == (CORE_ADDR) 0)
- return NULL;
+ {
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, "NULL }\n");
+ return NULL;
+ }
ALL_OBJFILES (objfile)
{
- struct obj_unwind_info *ui;
+ struct hppa_unwind_info *ui;
ui = NULL;
- if (objfile->obj_private)
- ui = ((obj_private_data_t *) (objfile->obj_private))->unwind_info;
+ priv = objfile_data (objfile, hppa_objfile_priv_data);
+ if (priv)
+ ui = ((struct hppa_objfile_private *) priv)->unwind_info;
if (!ui)
{
read_unwind_info (objfile);
- if (objfile->obj_private == NULL)
- error ("Internal error reading unwind information.");
- ui = ((obj_private_data_t *) (objfile->obj_private))->unwind_info;
+ priv = objfile_data (objfile, hppa_objfile_priv_data);
+ if (priv == NULL)
+ error (_("Internal error reading unwind information."));
+ ui = ((struct hppa_objfile_private *) priv)->unwind_info;
}
/* First, check the cache */
if (ui->cache
&& pc >= ui->cache->region_start
&& pc <= ui->cache->region_end)
- return ui->cache;
+ {
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, "0x%s (cached) }\n",
+ paddr_nz ((CORE_ADDR) ui->cache));
+ return ui->cache;
+ }
/* Not in the cache, do a binary search */
&& pc <= ui->table[middle].region_end)
{
ui->cache = &ui->table[middle];
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, "0x%s }\n",
+ paddr_nz ((CORE_ADDR) ui->cache));
return &ui->table[middle];
}
first = middle + 1;
}
} /* ALL_OBJFILES() */
+
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, "NULL (not found) }\n");
+
return NULL;
}
-const unsigned char *
+/* The epilogue is defined here as the area either on the `bv' instruction
+ itself or an instruction which destroys the function's stack frame.
+
+ We do not assume that the epilogue is at the end of a function as we can
+ also have return sequences in the middle of a function. */
+static int
+hppa_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
+{
+ unsigned long status;
+ unsigned int inst;
+ char buf[4];
+ int off;
+
+ status = read_memory_nobpt (pc, buf, 4);
+ if (status != 0)
+ return 0;
+
+ inst = extract_unsigned_integer (buf, 4);
+
+ /* The most common way to perform a stack adjustment ldo X(sp),sp
+ We are destroying a stack frame if the offset is negative. */
+ if ((inst & 0xffffc000) == 0x37de0000
+ && hppa_extract_14 (inst) < 0)
+ return 1;
+
+ /* ldw,mb D(sp),X or ldd,mb D(sp),X */
+ if (((inst & 0x0fc010e0) == 0x0fc010e0
+ || (inst & 0x0fc010e0) == 0x0fc010e0)
+ && hppa_extract_14 (inst) < 0)
+ return 1;
+
+ /* bv %r0(%rp) or bv,n %r0(%rp) */
+ if (inst == 0xe840c000 || inst == 0xe840c002)
+ return 1;
+
+ return 0;
+}
+
+static const unsigned char *
hppa_breakpoint_from_pc (CORE_ADDR *pc, int *len)
{
static const unsigned char breakpoint[] = {0x00, 0x01, 0x00, 0x04};
/* Return the name of a register. */
-const char *
+static const char *
hppa32_register_name (int i)
{
static char *names[] = {
return names[i];
}
-const char *
+static const char *
hppa64_register_name (int i)
{
static char *names[] = {
return names[i];
}
-
-
-/* Return the adjustment necessary to make for addresses on the stack
- as presented by hpread.c.
-
- This is necessary because of the stack direction on the PA and the
- bizarre way in which someone (?) decided they wanted to handle
- frame pointerless code in GDB. */
-int
-hpread_adjust_stack_address (CORE_ADDR func_addr)
+static int
+hppa64_dwarf_reg_to_regnum (int reg)
{
- struct unwind_table_entry *u;
+ /* r0-r31 and sar map one-to-one. */
+ if (reg <= 32)
+ return reg;
- u = find_unwind_entry (func_addr);
- if (!u)
- return 0;
- else
- return u->Total_frame_size << 3;
+ /* fr4-fr31 are mapped from 72 in steps of 2. */
+ if (reg >= 72 || reg < 72 + 28 * 2)
+ return HPPA64_FP4_REGNUM + (reg - 72) / 2;
+
+ error ("Invalid DWARF register num %d.", reg);
+ return -1;
}
/* This function pushes a stack frame with arguments as part of the
We simply allocate the appropriate amount of stack space and put
arguments into their proper slots. */
-CORE_ADDR
-hppa32_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
+static CORE_ADDR
+hppa32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
struct regcache *regcache, CORE_ADDR bp_addr,
int nargs, struct value **args, CORE_ADDR sp,
int struct_return, CORE_ADDR struct_addr)
{
- /* NOTE: cagney/2004-02-27: This is a guess - its implemented by
- reverse engineering testsuite failures. */
-
/* Stack base address at which any pass-by-reference parameters are
stored. */
CORE_ADDR struct_end = 0;
/* Two passes. First pass computes the location of everything,
second pass writes the bytes out. */
int write_pass;
+
+ /* Global pointer (r19) of the function we are trying to call. */
+ CORE_ADDR gp;
+
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+
for (write_pass = 0; write_pass < 2; write_pass++)
{
CORE_ADDR struct_ptr = 0;
- CORE_ADDR param_ptr = 0;
- int reg = 27; /* NOTE: Registers go down. */
+ /* The first parameter goes into sp-36, each stack slot is 4-bytes.
+ struct_ptr is adjusted for each argument below, so the first
+ argument will end up at sp-36. */
+ CORE_ADDR param_ptr = 32;
int i;
+ int small_struct = 0;
+
for (i = 0; i < nargs; i++)
{
struct value *arg = args[i];
- struct type *type = check_typedef (VALUE_TYPE (arg));
+ struct type *type = check_typedef (value_type (arg));
/* The corresponding parameter that is pushed onto the
stack, and [possibly] passed in a register. */
char param_val[8];
param_len = 4;
struct_ptr += align_up (TYPE_LENGTH (type), 8);
if (write_pass)
- write_memory (struct_end - struct_ptr, VALUE_CONTENTS (arg),
+ write_memory (struct_end - struct_ptr, value_contents (arg),
TYPE_LENGTH (type));
store_unsigned_integer (param_val, 4, struct_end - struct_ptr);
}
param_len = align_up (TYPE_LENGTH (type), 4);
store_unsigned_integer (param_val, param_len,
unpack_long (type,
- VALUE_CONTENTS (arg)));
+ value_contents (arg)));
}
+ else if (TYPE_CODE (type) == TYPE_CODE_FLT)
+ {
+ /* Floating point value store, right aligned. */
+ param_len = align_up (TYPE_LENGTH (type), 4);
+ memcpy (param_val, value_contents (arg), param_len);
+ }
else
{
- /* Small struct value, store right aligned? */
param_len = align_up (TYPE_LENGTH (type), 4);
+
+ /* Small struct value are stored right-aligned. */
memcpy (param_val + param_len - TYPE_LENGTH (type),
- VALUE_CONTENTS (arg), TYPE_LENGTH (type));
+ value_contents (arg), TYPE_LENGTH (type));
+
+ /* Structures of size 5, 6 and 7 bytes are special in that
+ the higher-ordered word is stored in the lower-ordered
+ argument, and even though it is a 8-byte quantity the
+ registers need not be 8-byte aligned. */
+ if (param_len > 4 && param_len < 8)
+ small_struct = 1;
}
+
param_ptr += param_len;
- reg -= param_len / 4;
+ if (param_len == 8 && !small_struct)
+ param_ptr = align_up (param_ptr, 8);
+
+ /* First 4 non-FP arguments are passed in gr26-gr23.
+ First 4 32-bit FP arguments are passed in fr4L-fr7L.
+ First 2 64-bit FP arguments are passed in fr5 and fr7.
+
+ The rest go on the stack, starting at sp-36, towards lower
+ addresses. 8-byte arguments must be aligned to a 8-byte
+ stack boundary. */
if (write_pass)
{
write_memory (param_end - param_ptr, param_val, param_len);
- if (reg >= 23)
+
+ /* There are some cases when we don't know the type
+ expected by the callee (e.g. for variadic functions), so
+ pass the parameters in both general and fp regs. */
+ if (param_ptr <= 48)
{
- regcache_cooked_write (regcache, reg, param_val);
+ int grreg = 26 - (param_ptr - 36) / 4;
+ int fpLreg = 72 + (param_ptr - 36) / 4 * 2;
+ int fpreg = 74 + (param_ptr - 32) / 8 * 4;
+
+ regcache_cooked_write (regcache, grreg, param_val);
+ regcache_cooked_write (regcache, fpLreg, param_val);
+
if (param_len > 4)
- regcache_cooked_write (regcache, reg + 1, param_val + 4);
+ {
+ regcache_cooked_write (regcache, grreg + 1,
+ param_val + 4);
+
+ regcache_cooked_write (regcache, fpreg, param_val);
+ regcache_cooked_write (regcache, fpreg + 1,
+ param_val + 4);
+ }
}
}
}
/* Update the various stack pointers. */
if (!write_pass)
{
- struct_end = sp + struct_ptr;
+ struct_end = sp + align_up (struct_ptr, 64);
/* PARAM_PTR already accounts for all the arguments passed
by the user. However, the ABI mandates minimum stack
space allocations for outgoing arguments. The ABI also
mandates minimum stack alignments which we must
preserve. */
- param_end = struct_end + max (align_up (param_ptr, 8),
- REG_PARM_STACK_SPACE);
+ param_end = struct_end + align_up (param_ptr, 64);
}
}
if (struct_return)
write_register (28, struct_addr);
+ gp = tdep->find_global_pointer (function);
+
+ if (gp != 0)
+ write_register (19, gp);
+
/* Set the return address. */
- regcache_cooked_write_unsigned (regcache, RP_REGNUM, bp_addr);
+ if (!gdbarch_push_dummy_code_p (gdbarch))
+ regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
+
+ /* Update the Stack Pointer. */
+ regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, param_end);
- /* The stack will have 32 bytes of additional space for a frame marker. */
- return param_end + 32;
+ return param_end;
}
-/* This function pushes a stack frame with arguments as part of the
- inferior function calling mechanism.
+/* The 64-bit PA-RISC calling conventions are documented in "64-Bit
+ Runtime Architecture for PA-RISC 2.0", which is distributed as part
+ as of the HP-UX Software Transition Kit (STK). This implementation
+ is based on version 3.3, dated October 6, 1997. */
- This is the version for the PA64, in which later arguments appear
- at higher addresses. (The stack always grows towards higher
- addresses.)
+/* Check whether TYPE is an "Integral or Pointer Scalar Type". */
- We simply allocate the appropriate amount of stack space and put
- arguments into their proper slots.
+static int
+hppa64_integral_or_pointer_p (const struct type *type)
+{
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_INT:
+ case TYPE_CODE_BOOL:
+ case TYPE_CODE_CHAR:
+ case TYPE_CODE_ENUM:
+ case TYPE_CODE_RANGE:
+ {
+ int len = TYPE_LENGTH (type);
+ return (len == 1 || len == 2 || len == 4 || len == 8);
+ }
+ case TYPE_CODE_PTR:
+ case TYPE_CODE_REF:
+ return (TYPE_LENGTH (type) == 8);
+ default:
+ break;
+ }
- This ABI also requires that the caller provide an argument pointer
- to the callee, so we do that too. */
-
-CORE_ADDR
-hppa64_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
+ return 0;
+}
+
+/* Check whether TYPE is a "Floating Scalar Type". */
+
+static int
+hppa64_floating_p (const struct type *type)
+{
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_FLT:
+ {
+ int len = TYPE_LENGTH (type);
+ return (len == 4 || len == 8 || len == 16);
+ }
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+/* If CODE points to a function entry address, try to look up the corresponding
+ function descriptor and return its address instead. If CODE is not a
+ function entry address, then just return it unchanged. */
+static CORE_ADDR
+hppa64_convert_code_addr_to_fptr (CORE_ADDR code)
+{
+ struct obj_section *sec, *opd;
+
+ sec = find_pc_section (code);
+
+ if (!sec)
+ return code;
+
+ /* If CODE is in a data section, assume it's already a fptr. */
+ if (!(sec->the_bfd_section->flags & SEC_CODE))
+ return code;
+
+ ALL_OBJFILE_OSECTIONS (sec->objfile, opd)
+ {
+ if (strcmp (opd->the_bfd_section->name, ".opd") == 0)
+ break;
+ }
+
+ if (opd < sec->objfile->sections_end)
+ {
+ CORE_ADDR addr;
+
+ for (addr = opd->addr; addr < opd->endaddr; addr += 2 * 8)
+ {
+ ULONGEST opdaddr;
+ char tmp[8];
+
+ if (target_read_memory (addr, tmp, sizeof (tmp)))
+ break;
+ opdaddr = extract_unsigned_integer (tmp, sizeof (tmp));
+
+ if (opdaddr == code)
+ return addr - 16;
+ }
+ }
+
+ return code;
+}
+
+static CORE_ADDR
+hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
struct regcache *regcache, CORE_ADDR bp_addr,
int nargs, struct value **args, CORE_ADDR sp,
int struct_return, CORE_ADDR struct_addr)
{
- /* NOTE: cagney/2004-02-27: This is a guess - its implemented by
- reverse engineering testsuite failures. */
-
- /* Stack base address at which any pass-by-reference parameters are
- stored. */
- CORE_ADDR struct_end = 0;
- /* Stack base address at which the first parameter is stored. */
- CORE_ADDR param_end = 0;
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ int i, offset = 0;
+ CORE_ADDR gp;
- /* The inner most end of the stack after all the parameters have
- been pushed. */
- CORE_ADDR new_sp = 0;
+ /* "The outgoing parameter area [...] must be aligned at a 16-byte
+ boundary." */
+ sp = align_up (sp, 16);
- /* Two passes. First pass computes the location of everything,
- second pass writes the bytes out. */
- int write_pass;
- for (write_pass = 0; write_pass < 2; write_pass++)
+ for (i = 0; i < nargs; i++)
{
- CORE_ADDR struct_ptr = 0;
- CORE_ADDR param_ptr = 0;
- int i;
- for (i = 0; i < nargs; i++)
+ struct value *arg = args[i];
+ struct type *type = value_type (arg);
+ int len = TYPE_LENGTH (type);
+ const bfd_byte *valbuf;
+ bfd_byte fptrbuf[8];
+ int regnum;
+
+ /* "Each parameter begins on a 64-bit (8-byte) boundary." */
+ offset = align_up (offset, 8);
+
+ if (hppa64_integral_or_pointer_p (type))
{
- struct value *arg = args[i];
- struct type *type = check_typedef (VALUE_TYPE (arg));
- if ((TYPE_CODE (type) == TYPE_CODE_INT
- || TYPE_CODE (type) == TYPE_CODE_ENUM)
- && TYPE_LENGTH (type) <= 8)
+ /* "Integral scalar parameters smaller than 64 bits are
+ padded on the left (i.e., the value is in the
+ least-significant bits of the 64-bit storage unit, and
+ the high-order bits are undefined)." Therefore we can
+ safely sign-extend them. */
+ if (len < 8)
{
- /* Integer value store, right aligned. "unpack_long"
- takes care of any sign-extension problems. */
- param_ptr += 8;
- if (write_pass)
- {
- ULONGEST val = unpack_long (type, VALUE_CONTENTS (arg));
- int reg = 27 - param_ptr / 8;
- write_memory_unsigned_integer (param_end - param_ptr,
- val, 8);
- if (reg >= 19)
- regcache_cooked_write_unsigned (regcache, reg, val);
- }
+ arg = value_cast (builtin_type_int64, arg);
+ len = 8;
+ }
+ }
+ else if (hppa64_floating_p (type))
+ {
+ if (len > 8)
+ {
+ /* "Quad-precision (128-bit) floating-point scalar
+ parameters are aligned on a 16-byte boundary." */
+ offset = align_up (offset, 16);
+
+ /* "Double-extended- and quad-precision floating-point
+ parameters within the first 64 bytes of the parameter
+ list are always passed in general registers." */
}
else
{
- /* Small struct value, store left aligned? */
- int reg;
- if (TYPE_LENGTH (type) > 8)
+ if (len == 4)
{
- param_ptr = align_up (param_ptr, 16);
- reg = 26 - param_ptr / 8;
- param_ptr += align_up (TYPE_LENGTH (type), 16);
+ /* "Single-precision (32-bit) floating-point scalar
+ parameters are padded on the left with 32 bits of
+ garbage (i.e., the floating-point value is in the
+ least-significant 32 bits of a 64-bit storage
+ unit)." */
+ offset += 4;
}
- else
+
+ /* "Single- and double-precision floating-point
+ parameters in this area are passed according to the
+ available formal parameter information in a function
+ prototype. [...] If no prototype is in scope,
+ floating-point parameters must be passed both in the
+ corresponding general registers and in the
+ corresponding floating-point registers." */
+ regnum = HPPA64_FP4_REGNUM + offset / 8;
+
+ if (regnum < HPPA64_FP4_REGNUM + 8)
{
- param_ptr = align_up (param_ptr, 8);
- reg = 26 - param_ptr / 8;
- param_ptr += align_up (TYPE_LENGTH (type), 8);
- }
- if (write_pass)
- {
- int byte;
- write_memory (param_end - param_ptr, VALUE_CONTENTS (arg),
- TYPE_LENGTH (type));
- for (byte = 0; byte < TYPE_LENGTH (type); byte += 8)
- {
- if (reg >= 19)
- {
- int len = min (8, TYPE_LENGTH (type) - byte);
- regcache_cooked_write_part (regcache, reg, 0, len,
- VALUE_CONTENTS (arg) + byte);
- }
- reg--;
- }
+ /* "Single-precision floating-point parameters, when
+ passed in floating-point registers, are passed in
+ the right halves of the floating point registers;
+ the left halves are unused." */
+ regcache_cooked_write_part (regcache, regnum, offset % 8,
+ len, value_contents (arg));
}
}
}
- /* Update the various stack pointers. */
- if (!write_pass)
- {
- struct_end = sp + struct_ptr;
- /* PARAM_PTR already accounts for all the arguments passed
- by the user. However, the ABI mandates minimum stack
- space allocations for outgoing arguments. The ABI also
- mandates minimum stack alignments which we must
- preserve. */
- param_end = struct_end + max (align_up (param_ptr, 16),
- REG_PARM_STACK_SPACE);
- }
- }
-
- /* If a structure has to be returned, set up register 28 to hold its
- address */
- if (struct_return)
- write_register (28, struct_addr);
-
- /* Set the return address. */
- regcache_cooked_write_unsigned (regcache, RP_REGNUM, bp_addr);
-
- /* The stack will have 32 bytes of additional space for a frame marker. */
- return param_end + 64;
-}
-
-static CORE_ADDR
-hppa32_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
-{
- /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
- and not _bit_)! */
- return align_up (addr, 64);
-}
-
-/* Force all frames to 16-byte alignment. Better safe than sorry. */
-
-static CORE_ADDR
-hppa64_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
-{
- /* Just always 16-byte align. */
- return align_up (addr, 16);
-}
-
-
-/* elz: Used to lookup a symbol in the shared libraries.
- This function calls shl_findsym, indirectly through a
- call to __d_shl_get. __d_shl_get is in end.c, which is always
- linked in by the hp compilers/linkers.
- The call to shl_findsym cannot be made directly because it needs
- to be active in target address space.
- inputs: - minimal symbol pointer for the function we want to look up
- - address in target space of the descriptor for the library
- where we want to look the symbol up.
- This address is retrieved using the
- som_solib_get_solib_by_pc function (somsolib.c).
- output: - real address in the library of the function.
- note: the handle can be null, in which case shl_findsym will look for
- the symbol in all the loaded shared libraries.
- files to look at if you need reference on this stuff:
- dld.c, dld_shl_findsym.c
- end.c
- man entry for shl_findsym */
-
-CORE_ADDR
-find_stub_with_shl_get (struct minimal_symbol *function, CORE_ADDR handle)
-{
- struct symbol *get_sym, *symbol2;
- struct minimal_symbol *buff_minsym, *msymbol;
- struct type *ftype;
- struct value **args;
- struct value *funcval;
- struct value *val;
-
- int x, namelen, err_value, tmp = -1;
- CORE_ADDR endo_buff_addr, value_return_addr, errno_return_addr;
- CORE_ADDR stub_addr;
-
-
- args = alloca (sizeof (struct value *) * 8); /* 6 for the arguments and one null one??? */
- funcval = find_function_in_inferior ("__d_shl_get");
- get_sym = lookup_symbol ("__d_shl_get", NULL, VAR_DOMAIN, NULL, NULL);
- buff_minsym = lookup_minimal_symbol ("__buffer", NULL, NULL);
- msymbol = lookup_minimal_symbol ("__shldp", NULL, NULL);
- symbol2 = lookup_symbol ("__shldp", NULL, VAR_DOMAIN, NULL, NULL);
- endo_buff_addr = SYMBOL_VALUE_ADDRESS (buff_minsym);
- namelen = strlen (DEPRECATED_SYMBOL_NAME (function));
- value_return_addr = endo_buff_addr + namelen;
- ftype = check_typedef (SYMBOL_TYPE (get_sym));
-
- /* do alignment */
- if ((x = value_return_addr % 64) != 0)
- value_return_addr = value_return_addr + 64 - x;
-
- errno_return_addr = value_return_addr + 64;
-
-
- /* set up stuff needed by __d_shl_get in buffer in end.o */
-
- target_write_memory (endo_buff_addr, DEPRECATED_SYMBOL_NAME (function), namelen);
-
- target_write_memory (value_return_addr, (char *) &tmp, 4);
-
- target_write_memory (errno_return_addr, (char *) &tmp, 4);
-
- target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol),
- (char *) &handle, 4);
-
- /* now prepare the arguments for the call */
-
- args[0] = value_from_longest (TYPE_FIELD_TYPE (ftype, 0), 12);
- args[1] = value_from_pointer (TYPE_FIELD_TYPE (ftype, 1), SYMBOL_VALUE_ADDRESS (msymbol));
- args[2] = value_from_pointer (TYPE_FIELD_TYPE (ftype, 2), endo_buff_addr);
- args[3] = value_from_longest (TYPE_FIELD_TYPE (ftype, 3), TYPE_PROCEDURE);
- args[4] = value_from_pointer (TYPE_FIELD_TYPE (ftype, 4), value_return_addr);
- args[5] = value_from_pointer (TYPE_FIELD_TYPE (ftype, 5), errno_return_addr);
-
- /* now call the function */
-
- val = call_function_by_hand (funcval, 6, args);
-
- /* now get the results */
-
- target_read_memory (errno_return_addr, (char *) &err_value, sizeof (err_value));
-
- 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);
-
- return (stub_addr);
-}
-
-/* Cover routine for find_stub_with_shl_get to pass to catch_errors */
-static int
-cover_find_stub_with_shl_get (void *args_untyped)
-{
- args_for_find_stub *args = args_untyped;
- args->return_val = find_stub_with_shl_get (args->msym, args->solib_handle);
- return 0;
-}
-
-/* If the pid is in a syscall, then the FP register is not readable.
- We'll return zero in that case, rather than attempting to read it
- and cause a warning. */
-
-CORE_ADDR
-hppa_read_fp (int pid)
-{
- int flags = read_register (FLAGS_REGNUM);
-
- if (flags & 2)
- {
- return (CORE_ADDR) 0;
- }
-
- /* This is the only site that may directly read_register () the FP
- register. All others must use deprecated_read_fp (). */
- return read_register (DEPRECATED_FP_REGNUM);
-}
-
-CORE_ADDR
-hppa_target_read_fp (void)
-{
- return hppa_read_fp (PIDGET (inferior_ptid));
-}
-
-/* Get the PC from %r31 if currently in a syscall. Also mask out privilege
- bits. */
-
-CORE_ADDR
-hppa_target_read_pc (ptid_t ptid)
-{
- int flags = read_register_pid (FLAGS_REGNUM, ptid);
-
- /* The following test does not belong here. It is OS-specific, and belongs
- in native code. */
- /* Test SS_INSYSCALL */
- if (flags & 2)
- return read_register_pid (31, ptid) & ~0x3;
-
- return read_register_pid (PCOQ_HEAD_REGNUM, ptid) & ~0x3;
-}
-
-/* Write out the PC. If currently in a syscall, then also write the new
- PC value into %r31. */
-
-void
-hppa_target_write_pc (CORE_ADDR v, ptid_t ptid)
-{
- int flags = read_register_pid (FLAGS_REGNUM, ptid);
-
- /* The following test does not belong here. It is OS-specific, and belongs
- in native code. */
- /* If in a syscall, then set %r31. Also make sure to get the
- privilege bits set correctly. */
- /* Test SS_INSYSCALL */
- if (flags & 2)
- write_register_pid (31, v | 0x3, ptid);
-
- write_register_pid (PCOQ_HEAD_REGNUM, v, ptid);
- write_register_pid (PCOQ_TAIL_REGNUM, v + 4, ptid);
-}
-
-/* return the alignment of a type in bytes. Structures have the maximum
- alignment required by their fields. */
-
-static int
-hppa_alignof (struct type *type)
-{
- int max_align, align, i;
- CHECK_TYPEDEF (type);
- switch (TYPE_CODE (type))
- {
- case TYPE_CODE_PTR:
- case TYPE_CODE_INT:
- case TYPE_CODE_FLT:
- return TYPE_LENGTH (type);
- case TYPE_CODE_ARRAY:
- return hppa_alignof (TYPE_FIELD_TYPE (type, 0));
- case TYPE_CODE_STRUCT:
- case TYPE_CODE_UNION:
- max_align = 1;
- for (i = 0; i < TYPE_NFIELDS (type); i++)
+ else
{
- /* Bit fields have no real alignment. */
- /* if (!TYPE_FIELD_BITPOS (type, i)) */
- if (!TYPE_FIELD_BITSIZE (type, i)) /* elz: this should be bitsize */
+ if (len > 8)
{
- align = hppa_alignof (TYPE_FIELD_TYPE (type, i));
- max_align = max (max_align, align);
+ /* "Aggregates larger than 8 bytes are aligned on a
+ 16-byte boundary, possibly leaving an unused argument
+ slot, which is filled with garbage. If necessary,
+ they are padded on the right (with garbage), to a
+ multiple of 8 bytes." */
+ offset = align_up (offset, 16);
}
}
- return max_align;
- default:
- return 4;
- }
-}
-
-/* Print the register regnum, or all registers if regnum is -1 */
-
-void
-pa_do_registers_info (int regnum, int fpregs)
-{
- char *raw_regs = alloca (DEPRECATED_REGISTER_BYTES);
- int i;
-
- /* Make a copy of gdb's save area (may cause actual
- reads from the target). */
- for (i = 0; i < NUM_REGS; i++)
- frame_register_read (deprecated_selected_frame, i,
- raw_regs + DEPRECATED_REGISTER_BYTE (i));
-
- if (regnum == -1)
- pa_print_registers (raw_regs, regnum, fpregs);
- else if (regnum < FP4_REGNUM)
- {
- long reg_val[2];
-
- /* Why is the value not passed through "extract_signed_integer"
- as in "pa_print_registers" below? */
- pa_register_look_aside (raw_regs, regnum, ®_val[0]);
- if (!is_pa_2)
- {
- printf_unfiltered ("%s %lx\n", REGISTER_NAME (regnum), reg_val[1]);
+ /* If we are passing a function pointer, make sure we pass a function
+ descriptor instead of the function entry address. */
+ if (TYPE_CODE (type) == TYPE_CODE_PTR
+ && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
+ {
+ ULONGEST codeptr, fptr;
+
+ codeptr = unpack_long (type, value_contents (arg));
+ fptr = hppa64_convert_code_addr_to_fptr (codeptr);
+ store_unsigned_integer (fptrbuf, TYPE_LENGTH (type), fptr);
+ valbuf = fptrbuf;
}
else
- {
- /* Fancy % formats to prevent leading zeros. */
- if (reg_val[0] == 0)
- printf_unfiltered ("%s %lx\n", REGISTER_NAME (regnum), reg_val[1]);
- else
- printf_unfiltered ("%s %lx%8.8lx\n", REGISTER_NAME (regnum),
- reg_val[0], reg_val[1]);
+ {
+ valbuf = value_contents (arg);
}
- }
- else
- /* Note that real floating point values only start at
- FP4_REGNUM. FP0 and up are just status and error
- registers, which have integral (bit) values. */
- pa_print_fp_reg (regnum);
-}
-
-/********** new function ********************/
-void
-pa_do_strcat_registers_info (int regnum, int fpregs, struct ui_file *stream,
- enum precision_type precision)
-{
- char *raw_regs = alloca (DEPRECATED_REGISTER_BYTES);
- int i;
-
- /* Make a copy of gdb's save area (may cause actual
- reads from the target). */
- for (i = 0; i < NUM_REGS; i++)
- frame_register_read (deprecated_selected_frame, i,
- raw_regs + DEPRECATED_REGISTER_BYTE (i));
-
- if (regnum == -1)
- pa_strcat_registers (raw_regs, regnum, fpregs, stream);
-
- else if (regnum < FP4_REGNUM)
- {
- long reg_val[2];
- /* Why is the value not passed through "extract_signed_integer"
- as in "pa_print_registers" below? */
- pa_register_look_aside (raw_regs, regnum, ®_val[0]);
+ /* Always store the argument in memory. */
+ write_memory (sp + offset, valbuf, len);
- if (!is_pa_2)
+ regnum = HPPA_ARG0_REGNUM - offset / 8;
+ while (regnum > HPPA_ARG0_REGNUM - 8 && len > 0)
{
- fprintf_unfiltered (stream, "%s %lx", REGISTER_NAME (regnum), reg_val[1]);
+ regcache_cooked_write_part (regcache, regnum,
+ offset % 8, min (len, 8), valbuf);
+ offset += min (len, 8);
+ valbuf += min (len, 8);
+ len -= min (len, 8);
+ regnum--;
}
- else
- {
- /* Fancy % formats to prevent leading zeros. */
- if (reg_val[0] == 0)
- fprintf_unfiltered (stream, "%s %lx", REGISTER_NAME (regnum),
- reg_val[1]);
- else
- fprintf_unfiltered (stream, "%s %lx%8.8lx", REGISTER_NAME (regnum),
- reg_val[0], reg_val[1]);
- }
- }
- else
- /* Note that real floating point values only start at
- FP4_REGNUM. FP0 and up are just status and error
- registers, which have integral (bit) values. */
- pa_strcat_fp_reg (regnum, stream, precision);
-}
-
-/* If this is a PA2.0 machine, fetch the real 64-bit register
- value. Otherwise use the info from gdb's saved register area.
-
- Note that reg_val is really expected to be an array of longs,
- with two elements. */
-static void
-pa_register_look_aside (char *raw_regs, int regnum, long *raw_val)
-{
- static int know_which = 0; /* False */
-
- int regaddr;
- unsigned int offset;
- int i;
- int start;
+ offset += len;
+ }
- char buf[MAX_REGISTER_SIZE];
- long long reg_val;
+ /* Set up GR29 (%ret1) to hold the argument pointer (ap). */
+ regcache_cooked_write_unsigned (regcache, HPPA_RET1_REGNUM, sp + 64);
- if (!know_which)
- {
- if (CPU_PA_RISC2_0 == sysconf (_SC_CPU_VERSION))
- {
- is_pa_2 = (1 == 1);
- }
+ /* Allocate the outgoing parameter area. Make sure the outgoing
+ parameter area is multiple of 16 bytes in length. */
+ sp += max (align_up (offset, 16), 64);
- know_which = 1; /* True */
- }
+ /* Allocate 32-bytes of scratch space. The documentation doesn't
+ mention this, but it seems to be needed. */
+ sp += 32;
- raw_val[0] = 0;
- raw_val[1] = 0;
+ /* Allocate the frame marker area. */
+ sp += 16;
- if (!is_pa_2)
- {
- raw_val[1] = *(long *) (raw_regs + DEPRECATED_REGISTER_BYTE (regnum));
- return;
- }
-
- /* Code below copied from hppah-nat.c, with fixes for wide
- registers, using different area of save_state, etc. */
- if (regnum == FLAGS_REGNUM || regnum >= FP0_REGNUM ||
- !HAVE_STRUCT_SAVE_STATE_T || !HAVE_STRUCT_MEMBER_SS_WIDE)
- {
- /* Use narrow regs area of save_state and default macro. */
- offset = U_REGS_OFFSET;
- regaddr = register_addr (regnum, offset);
- start = 1;
- }
- else
- {
- /* Use wide regs area, and calculate registers as 8 bytes wide.
-
- We'd like to do this, but current version of "C" doesn't
- permit "offsetof":
-
- offset = offsetof(save_state_t, ss_wide);
-
- Note that to avoid "C" doing typed pointer arithmetic, we
- have to cast away the type in our offset calculation:
- otherwise we get an offset of 1! */
-
- /* NB: save_state_t is not available before HPUX 9.
- The ss_wide field is not available previous to HPUX 10.20,
- so to avoid compile-time warnings, we only compile this for
- PA 2.0 processors. This control path should only be followed
- if we're debugging a PA 2.0 processor, so this should not cause
- problems. */
-
- /* #if the following code out so that this file can still be
- compiled on older HPUX boxes (< 10.20) which don't have
- this structure/structure member. */
-#if HAVE_STRUCT_SAVE_STATE_T == 1 && HAVE_STRUCT_MEMBER_SS_WIDE == 1
- save_state_t temp;
-
- offset = ((int) &temp.ss_wide) - ((int) &temp);
- regaddr = offset + regnum * 8;
- start = 0;
-#endif
- }
+ /* If a structure has to be returned, set up GR 28 (%ret0) to hold
+ its address. */
+ if (struct_return)
+ regcache_cooked_write_unsigned (regcache, HPPA_RET0_REGNUM, struct_addr);
- for (i = start; i < 2; i++)
- {
- errno = 0;
- raw_val[i] = call_ptrace (PT_RUREGS, PIDGET (inferior_ptid),
- (PTRACE_ARG3_TYPE) regaddr, 0);
- if (errno != 0)
- {
- /* Warning, not error, in case we are attached; sometimes the
- kernel doesn't let us at the registers. */
- char *err = safe_strerror (errno);
- char *msg = alloca (strlen (err) + 128);
- sprintf (msg, "reading register %s: %s", REGISTER_NAME (regnum), err);
- warning (msg);
- goto error_exit;
- }
+ /* Set up GR27 (%dp) to hold the global pointer (gp). */
+ gp = tdep->find_global_pointer (function);
+ if (gp != 0)
+ regcache_cooked_write_unsigned (regcache, HPPA_DP_REGNUM, gp);
- regaddr += sizeof (long);
- }
+ /* Set up GR2 (%rp) to hold the return pointer (rp). */
+ if (!gdbarch_push_dummy_code_p (gdbarch))
+ regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
- if (regnum == PCOQ_HEAD_REGNUM || regnum == PCOQ_TAIL_REGNUM)
- raw_val[1] &= ~0x3; /* I think we're masking out space bits */
+ /* Set up GR30 to hold the stack pointer (sp). */
+ regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, sp);
-error_exit:
- ;
+ return sp;
}
+\f
-/* "Info all-reg" command */
+/* Handle 32/64-bit struct return conventions. */
-static void
-pa_print_registers (char *raw_regs, int regnum, int fpregs)
+static enum return_value_convention
+hppa32_return_value (struct gdbarch *gdbarch,
+ struct type *type, struct regcache *regcache,
+ gdb_byte *readbuf, const gdb_byte *writebuf)
{
- int i, j;
- /* Alas, we are compiled so that "long long" is 32 bits */
- long raw_val[2];
- long long_val;
- int rows = 48, columns = 2;
-
- for (i = 0; i < rows; i++)
+ if (TYPE_LENGTH (type) <= 2 * 4)
{
- for (j = 0; j < columns; j++)
+ /* The value always lives in the right hand end of the register
+ (or register pair)? */
+ int b;
+ int reg = TYPE_CODE (type) == TYPE_CODE_FLT ? HPPA_FP4_REGNUM : 28;
+ int part = TYPE_LENGTH (type) % 4;
+ /* The left hand register contains only part of the value,
+ transfer that first so that the rest can be xfered as entire
+ 4-byte registers. */
+ if (part > 0)
{
- /* We display registers in column-major order. */
- int regnum = i + j * rows;
-
- /* Q: Why is the value passed through "extract_signed_integer",
- while above, in "pa_do_registers_info" it isn't?
- A: ? */
- pa_register_look_aside (raw_regs, regnum, &raw_val[0]);
-
- /* Even fancier % formats to prevent leading zeros
- and still maintain the output in columns. */
- if (!is_pa_2)
- {
- /* Being big-endian, on this machine the low bits
- (the ones we want to look at) are in the second longword. */
- long_val = extract_signed_integer (&raw_val[1], 4);
- printf_filtered ("%10.10s: %8lx ",
- REGISTER_NAME (regnum), long_val);
- }
- else
- {
- /* raw_val = extract_signed_integer(&raw_val, 8); */
- if (raw_val[0] == 0)
- printf_filtered ("%10.10s: %8lx ",
- REGISTER_NAME (regnum), raw_val[1]);
- else
- printf_filtered ("%10.10s: %8lx%8.8lx ",
- REGISTER_NAME (regnum),
- raw_val[0], raw_val[1]);
- }
+ if (readbuf != NULL)
+ regcache_cooked_read_part (regcache, reg, 4 - part,
+ part, readbuf);
+ if (writebuf != NULL)
+ regcache_cooked_write_part (regcache, reg, 4 - part,
+ part, writebuf);
+ reg++;
}
- printf_unfiltered ("\n");
- }
-
- if (fpregs)
- for (i = FP4_REGNUM; i < NUM_REGS; i++) /* FP4_REGNUM == 72 */
- pa_print_fp_reg (i);
-}
-
-/************* new function ******************/
-static void
-pa_strcat_registers (char *raw_regs, int regnum, int fpregs,
- struct ui_file *stream)
-{
- int i, j;
- long raw_val[2]; /* Alas, we are compiled so that "long long" is 32 bits */
- long long_val;
- enum precision_type precision;
-
- precision = unspecified_precision;
-
- for (i = 0; i < 18; i++)
- {
- for (j = 0; j < 4; j++)
+ /* Now transfer the remaining register values. */
+ for (b = part; b < TYPE_LENGTH (type); b += 4)
{
- /* Q: Why is the value passed through "extract_signed_integer",
- while above, in "pa_do_registers_info" it isn't?
- A: ? */
- pa_register_look_aside (raw_regs, i + (j * 18), &raw_val[0]);
-
- /* Even fancier % formats to prevent leading zeros
- and still maintain the output in columns. */
- if (!is_pa_2)
- {
- /* Being big-endian, on this machine the low bits
- (the ones we want to look at) are in the second longword. */
- long_val = extract_signed_integer (&raw_val[1], 4);
- fprintf_filtered (stream, "%8.8s: %8lx ",
- REGISTER_NAME (i + (j * 18)), long_val);
- }
- else
- {
- /* raw_val = extract_signed_integer(&raw_val, 8); */
- if (raw_val[0] == 0)
- fprintf_filtered (stream, "%8.8s: %8lx ",
- REGISTER_NAME (i + (j * 18)), raw_val[1]);
- else
- fprintf_filtered (stream, "%8.8s: %8lx%8.8lx ",
- REGISTER_NAME (i + (j * 18)), raw_val[0],
- raw_val[1]);
- }
+ if (readbuf != NULL)
+ regcache_cooked_read (regcache, reg, readbuf + b);
+ if (writebuf != NULL)
+ regcache_cooked_write (regcache, reg, writebuf + b);
+ reg++;
}
- fprintf_unfiltered (stream, "\n");
+ return RETURN_VALUE_REGISTER_CONVENTION;
}
-
- if (fpregs)
- for (i = FP4_REGNUM; i < NUM_REGS; i++) /* FP4_REGNUM == 72 */
- pa_strcat_fp_reg (i, stream, precision);
+ else
+ return RETURN_VALUE_STRUCT_CONVENTION;
}
-static void
-pa_print_fp_reg (int i)
+static enum return_value_convention
+hppa64_return_value (struct gdbarch *gdbarch,
+ struct type *type, struct regcache *regcache,
+ gdb_byte *readbuf, const gdb_byte *writebuf)
{
- char raw_buffer[MAX_REGISTER_SIZE];
- char virtual_buffer[MAX_REGISTER_SIZE];
-
- /* Get 32bits of data. */
- frame_register_read (deprecated_selected_frame, i, raw_buffer);
-
- /* Put it in the buffer. No conversions are ever necessary. */
- memcpy (virtual_buffer, raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (i));
+ int len = TYPE_LENGTH (type);
+ int regnum, offset;
- fputs_filtered (REGISTER_NAME (i), gdb_stdout);
- print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), gdb_stdout);
- fputs_filtered ("(single precision) ", gdb_stdout);
-
- val_print (DEPRECATED_REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0, gdb_stdout, 0,
- 1, 0, Val_pretty_default);
- printf_filtered ("\n");
-
- /* If "i" is even, then this register can also be a double-precision
- FP register. Dump it out as such. */
- if ((i % 2) == 0)
+ if (len > 16)
{
- /* Get the data in raw format for the 2nd half. */
- frame_register_read (deprecated_selected_frame, i + 1, raw_buffer);
-
- /* Copy it into the appropriate part of the virtual buffer. */
- memcpy (virtual_buffer + DEPRECATED_REGISTER_RAW_SIZE (i), raw_buffer,
- DEPRECATED_REGISTER_RAW_SIZE (i));
-
- /* Dump it as a double. */
- fputs_filtered (REGISTER_NAME (i), gdb_stdout);
- print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), gdb_stdout);
- fputs_filtered ("(double precision) ", gdb_stdout);
+ /* All return values larget than 128 bits must be aggregate
+ return values. */
+ gdb_assert (!hppa64_integral_or_pointer_p (type));
+ gdb_assert (!hppa64_floating_p (type));
- val_print (builtin_type_double, virtual_buffer, 0, 0, gdb_stdout, 0,
- 1, 0, Val_pretty_default);
- printf_filtered ("\n");
+ /* "Aggregate return values larger than 128 bits are returned in
+ a buffer allocated by the caller. The address of the buffer
+ must be passed in GR 28." */
+ return RETURN_VALUE_STRUCT_CONVENTION;
}
-}
-
-/*************** new function ***********************/
-static void
-pa_strcat_fp_reg (int i, struct ui_file *stream, enum precision_type precision)
-{
- char raw_buffer[MAX_REGISTER_SIZE];
- char virtual_buffer[MAX_REGISTER_SIZE];
-
- fputs_filtered (REGISTER_NAME (i), stream);
- print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), stream);
-
- /* Get 32bits of data. */
- frame_register_read (deprecated_selected_frame, i, raw_buffer);
-
- /* Put it in the buffer. No conversions are ever necessary. */
- memcpy (virtual_buffer, raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (i));
-
- if (precision == double_precision && (i % 2) == 0)
- {
- char raw_buf[MAX_REGISTER_SIZE];
-
- /* Get the data in raw format for the 2nd half. */
- frame_register_read (deprecated_selected_frame, i + 1, raw_buf);
-
- /* Copy it into the appropriate part of the virtual buffer. */
- memcpy (virtual_buffer + DEPRECATED_REGISTER_RAW_SIZE (i), raw_buf,
- DEPRECATED_REGISTER_RAW_SIZE (i));
-
- val_print (builtin_type_double, virtual_buffer, 0, 0, stream, 0,
- 1, 0, Val_pretty_default);
-
- }
- else
+ if (hppa64_integral_or_pointer_p (type))
{
- val_print (DEPRECATED_REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0, stream, 0,
- 1, 0, Val_pretty_default);
+ /* "Integral return values are returned in GR 28. Values
+ smaller than 64 bits are padded on the left (with garbage)." */
+ regnum = HPPA_RET0_REGNUM;
+ offset = 8 - len;
}
-
-}
-
-/* Return one if PC is in the call path of a trampoline, else return zero.
-
- Note we return one for *any* call trampoline (long-call, arg-reloc), not
- just shared library trampolines (import, export). */
-
-int
-hppa_in_solib_call_trampoline (CORE_ADDR pc, char *name)
-{
- struct minimal_symbol *minsym;
- struct unwind_table_entry *u;
- static CORE_ADDR dyncall = 0;
- static CORE_ADDR sr4export = 0;
-
-#ifdef GDB_TARGET_IS_HPPA_20W
- /* PA64 has a completely different stub/trampoline scheme. Is it
- better? Maybe. It's certainly harder to determine with any
- certainty that we are in a stub because we can not refer to the
- unwinders to help.
-
- The heuristic is simple. Try to lookup the current PC value in th
- minimal symbol table. If that fails, then assume we are not in a
- stub and return.
-
- Then see if the PC value falls within the section bounds for the
- section containing the minimal symbol we found in the first
- step. If it does, then assume we are not in a stub and return.
-
- Finally peek at the instructions to see if they look like a stub. */
- {
- struct minimal_symbol *minsym;
- asection *sec;
- CORE_ADDR addr;
- int insn, i;
-
- minsym = lookup_minimal_symbol_by_pc (pc);
- if (! minsym)
- return 0;
-
- sec = SYMBOL_BFD_SECTION (minsym);
-
- if (bfd_get_section_vma (sec->owner, sec) <= pc
- && pc < (bfd_get_section_vma (sec->owner, sec)
- + bfd_section_size (sec->owner, sec)))
- return 0;
-
- /* We might be in a stub. Peek at the instructions. Stubs are 3
- instructions long. */
- insn = read_memory_integer (pc, 4);
-
- /* Find out where we think we are within the stub. */
- if ((insn & 0xffffc00e) == 0x53610000)
- addr = pc;
- else if ((insn & 0xffffffff) == 0xe820d000)
- addr = pc - 4;
- else if ((insn & 0xffffc00e) == 0x537b0000)
- addr = pc - 8;
- else
- return 0;
-
- /* Now verify each insn in the range looks like a stub instruction. */
- insn = read_memory_integer (addr, 4);
- if ((insn & 0xffffc00e) != 0x53610000)
- return 0;
-
- /* Now verify each insn in the range looks like a stub instruction. */
- insn = read_memory_integer (addr + 4, 4);
- if ((insn & 0xffffffff) != 0xe820d000)
- return 0;
-
- /* Now verify each insn in the range looks like a stub instruction. */
- insn = read_memory_integer (addr + 8, 4);
- if ((insn & 0xffffc00e) != 0x537b0000)
- return 0;
-
- /* Looks like a stub. */
- return 1;
- }
-#endif
-
- /* 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)
+ else if (hppa64_floating_p (type))
{
- minsym = lookup_minimal_symbol ("$$dyncall", NULL, NULL);
- if (minsym)
- dyncall = SYMBOL_VALUE_ADDRESS (minsym);
+ if (len > 8)
+ {
+ /* "Double-extended- and quad-precision floating-point
+ values are returned in GRs 28 and 29. The sign,
+ exponent, and most-significant bits of the mantissa are
+ returned in GR 28; the least-significant bits of the
+ mantissa are passed in GR 29. For double-extended
+ precision values, GR 29 is padded on the right with 48
+ bits of garbage." */
+ regnum = HPPA_RET0_REGNUM;
+ offset = 0;
+ }
else
- dyncall = -1;
+ {
+ /* "Single-precision and double-precision floating-point
+ return values are returned in FR 4R (single precision) or
+ FR 4 (double-precision)." */
+ regnum = HPPA64_FP4_REGNUM;
+ offset = 8 - len;
+ }
}
-
- if (!sr4export)
+ else
{
- minsym = lookup_minimal_symbol ("_sr4export", NULL, NULL);
- if (minsym)
- sr4export = SYMBOL_VALUE_ADDRESS (minsym);
- else
- sr4export = -1;
- }
-
- if (pc == dyncall || pc == sr4export)
- return 1;
-
- minsym = lookup_minimal_symbol_by_pc (pc);
- if (minsym && strcmp (DEPRECATED_SYMBOL_NAME (minsym), ".stub") == 0)
- return 1;
-
- /* Get the unwind descriptor corresponding to PC, return zero
- if no unwind was found. */
- u = find_unwind_entry (pc);
- if (!u)
- return 0;
-
- /* If this isn't a linker stub, then return now. */
- if (u->stub_unwind.stub_type == 0)
- return 0;
-
- /* By definition a long-branch stub is a call stub. */
- if (u->stub_unwind.stub_type == LONG_BRANCH)
- return 1;
+ /* "Aggregate return values up to 64 bits in size are returned
+ in GR 28. Aggregates smaller than 64 bits are left aligned
+ in the register; the pad bits on the right are undefined."
- /* The call and return path execute the same instructions within
- an IMPORT stub! So an IMPORT stub is both a call and return
- trampoline. */
- if (u->stub_unwind.stub_type == IMPORT)
- return 1;
+ "Aggregate return values between 65 and 128 bits are returned
+ in GRs 28 and 29. The first 64 bits are placed in GR 28, and
+ the remaining bits are placed, left aligned, in GR 29. The
+ pad bits on the right of GR 29 (if any) are undefined." */
+ regnum = HPPA_RET0_REGNUM;
+ offset = 0;
+ }
- /* Parameter relocation stubs always have a call path and may have a
- return path. */
- if (u->stub_unwind.stub_type == PARAMETER_RELOCATION
- || u->stub_unwind.stub_type == EXPORT)
+ if (readbuf)
{
- CORE_ADDR addr;
-
- /* Search forward from the current PC until we hit a branch
- or the end of the stub. */
- for (addr = pc; addr <= u->region_end; addr += 4)
+ while (len > 0)
{
- unsigned long insn;
-
- insn = read_memory_integer (addr, 4);
-
- /* Does it look like a bl? If so then it's the call path, if
- we find a bv or be first, then we're on the return path. */
- if ((insn & 0xfc00e000) == 0xe8000000)
- return 1;
- else if ((insn & 0xfc00e001) == 0xe800c000
- || (insn & 0xfc000000) == 0xe0000000)
- return 0;
+ regcache_cooked_read_part (regcache, regnum, offset,
+ min (len, 8), readbuf);
+ readbuf += min (len, 8);
+ len -= min (len, 8);
+ regnum++;
}
-
- /* Should never happen. */
- warning ("Unable to find branch in parameter relocation stub.\n");
- return 0;
}
- /* Unknown stub type. For now, just return zero. */
- return 0;
-}
-
-/* Return one if PC is in the return path of a trampoline, else return zero.
-
- Note we return one for *any* call trampoline (long-call, arg-reloc), not
- just shared library trampolines (import, export). */
-
-int
-hppa_in_solib_return_trampoline (CORE_ADDR pc, char *name)
-{
- struct unwind_table_entry *u;
-
- /* Get the unwind descriptor corresponding to PC, return zero
- if no unwind was found. */
- u = find_unwind_entry (pc);
- if (!u)
- return 0;
-
- /* If this isn't a linker stub or it's just a long branch stub, then
- return zero. */
- if (u->stub_unwind.stub_type == 0 || u->stub_unwind.stub_type == LONG_BRANCH)
- return 0;
-
- /* The call and return path execute the same instructions within
- an IMPORT stub! So an IMPORT stub is both a call and return
- trampoline. */
- if (u->stub_unwind.stub_type == IMPORT)
- return 1;
-
- /* Parameter relocation stubs always have a call path and may have a
- return path. */
- if (u->stub_unwind.stub_type == PARAMETER_RELOCATION
- || u->stub_unwind.stub_type == EXPORT)
+ if (writebuf)
{
- CORE_ADDR addr;
-
- /* Search forward from the current PC until we hit a branch
- or the end of the stub. */
- for (addr = pc; addr <= u->region_end; addr += 4)
+ while (len > 0)
{
- unsigned long insn;
-
- insn = read_memory_integer (addr, 4);
-
- /* Does it look like a bl? If so then it's the call path, if
- we find a bv or be first, then we're on the return path. */
- if ((insn & 0xfc00e000) == 0xe8000000)
- return 0;
- else if ((insn & 0xfc00e001) == 0xe800c000
- || (insn & 0xfc000000) == 0xe0000000)
- return 1;
+ regcache_cooked_write_part (regcache, regnum, offset,
+ min (len, 8), writebuf);
+ writebuf += min (len, 8);
+ len -= min (len, 8);
+ regnum++;
}
-
- /* Should never happen. */
- warning ("Unable to find branch in parameter relocation stub.\n");
- return 0;
}
- /* Unknown stub type. For now, just return zero. */
- return 0;
-
+ return RETURN_VALUE_REGISTER_CONVENTION;
}
+\f
-/* Figure out if PC is in a trampoline, and if so find out where
- the trampoline will jump to. If not in a trampoline, return zero.
-
- Simple code examination probably is not a good idea since the code
- sequences in trampolines can also appear in user code.
-
- We use unwinds and information from the minimal symbol table to
- determine when we're in a trampoline. This won't work for ELF
- (yet) since it doesn't create stub unwind entries. Whether or
- not ELF will create stub unwinds or normal unwinds for linker
- stubs is still being debated.
-
- This should handle simple calls through dyncall or sr4export,
- long calls, argument relocation stubs, and dyncall/sr4export
- calling an argument relocation stub. It even handles some stubs
- used in dynamic executables. */
-
-CORE_ADDR
-hppa_skip_trampoline_code (CORE_ADDR pc)
+static CORE_ADDR
+hppa32_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
+ struct target_ops *targ)
{
- 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)
- {
- pc = (CORE_ADDR) read_register (22);
-
- /* If bit 30 (counting from the left) is on, then pc is the address of
- the PLT entry for this function, not the address of the function
- itself. Bit 31 has meaning too, but only for MPE. */
- if (pc & 0x2)
- pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8);
- }
- if (pc == dyncall_external)
+ if (addr & 2)
{
- pc = (CORE_ADDR) read_register (22);
- pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8);
+ CORE_ADDR plabel = addr & ~3;
+ return read_memory_typed_address (plabel, builtin_type_void_func_ptr);
}
- else if (pc == sr4export)
- pc = (CORE_ADDR) (read_register (22));
-
- /* Get the unwind descriptor corresponding to PC, return zero
- if no unwind was found. */
- u = find_unwind_entry (pc);
- if (!u)
- return 0;
-
- /* If this isn't a linker stub, then return now. */
- /* elz: attention here! (FIXME) because of a compiler/linker
- error, some stubs which should have a non zero stub_unwind.stub_type
- have unfortunately a value of zero. So this function would return here
- as if we were not in a trampoline. To fix this, we go look at the partial
- symbol information, which reports this guy as a stub.
- (FIXME): Unfortunately, we are not that lucky: it turns out that the
- partial symbol information is also wrong sometimes. This is because
- when it is entered (somread.c::som_symtab_read()) it can happen that
- if the type of the symbol (from the som) is Entry, and the symbol is
- in a shared library, then it can also be a trampoline. This would
- be OK, except that I believe the way they decide if we are ina shared library
- does not work. SOOOO..., even if we have a regular function w/o trampolines
- its minimal symbol can be assigned type mst_solib_trampoline.
- Also, if we find that the symbol is a real stub, then we fix the unwind
- descriptor, and define the stub type to be EXPORT.
- Hopefully this is correct most of the times. */
- if (u->stub_unwind.stub_type == 0)
- {
-
-/* elz: NOTE (FIXME!) once the problem with the unwind information is fixed
- we can delete all the code which appears between the lines */
-/*--------------------------------------------------------------------------*/
- msym = lookup_minimal_symbol_by_pc (pc);
-
- if (msym == NULL || MSYMBOL_TYPE (msym) != mst_solib_trampoline)
- return orig_pc == pc ? 0 : pc & ~0x3;
-
- else if (msym != NULL && MSYMBOL_TYPE (msym) == mst_solib_trampoline)
- {
- struct objfile *objfile;
- struct minimal_symbol *msymbol;
- int function_found = 0;
- /* go look if there is another minimal symbol with the same name as
- this one, but with type mst_text. This would happen if the msym
- is an actual trampoline, in which case there would be another
- symbol with the same name corresponding to the real function */
-
- ALL_MSYMBOLS (objfile, msymbol)
- {
- if (MSYMBOL_TYPE (msymbol) == mst_text
- && DEPRECATED_STREQ (DEPRECATED_SYMBOL_NAME (msymbol), DEPRECATED_SYMBOL_NAME (msym)))
- {
- function_found = 1;
- break;
- }
- }
-
- if (function_found)
- /* the type of msym is correct (mst_solib_trampoline), but
- the unwind info is wrong, so set it to the correct value */
- u->stub_unwind.stub_type = EXPORT;
- else
- /* the stub type info in the unwind is correct (this is not a
- trampoline), but the msym type information is wrong, it
- should be mst_text. So we need to fix the msym, and also
- get out of this function */
- {
- MSYMBOL_TYPE (msym) = mst_text;
- return orig_pc == pc ? 0 : pc & ~0x3;
- }
- }
+ return addr;
+}
-/*--------------------------------------------------------------------------*/
- }
+static CORE_ADDR
+hppa32_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
+{
+ /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
+ and not _bit_)! */
+ return align_up (addr, 64);
+}
- /* It's a stub. Search for a branch and figure out where it goes.
- Note we have to handle multi insn branch sequences like ldil;ble.
- Most (all?) other branches can be determined by examining the contents
- of certain registers and the stack. */
+/* Force all frames to 16-byte alignment. Better safe than sorry. */
- loc = pc;
- curr_inst = 0;
- prev_inst = 0;
- while (1)
- {
- /* 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");
- return orig_pc == pc ? 0 : pc & ~0x3;
- }
+static CORE_ADDR
+hppa64_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
+{
+ /* Just always 16-byte align. */
+ return align_up (addr, 16);
+}
- prev_inst = curr_inst;
- curr_inst = read_memory_integer (loc, 4);
+CORE_ADDR
+hppa_read_pc (ptid_t ptid)
+{
+ ULONGEST ipsw;
+ CORE_ADDR pc;
- /* Does it look like a branch external using %r1? Then it's the
- branch from the stub to the actual function. */
- if ((curr_inst & 0xffe0e000) == 0xe0202000)
- {
- /* Yup. See if the previous instruction loaded
- a value into %r1. If so compute and return the jump address. */
- if ((prev_inst & 0xffe00000) == 0x20200000)
- return (extract_21 (prev_inst) + extract_17 (curr_inst)) & ~0x3;
- else
- {
- warning ("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1).");
- return orig_pc == pc ? 0 : pc & ~0x3;
- }
- }
+ ipsw = read_register_pid (HPPA_IPSW_REGNUM, ptid);
+ pc = read_register_pid (HPPA_PCOQ_HEAD_REGNUM, ptid);
- /* Does it look like a be 0(sr0,%r21)? OR
- Does it look like a be, n 0(sr0,%r21)? OR
- Does it look like a bve (r21)? (this is on PA2.0)
- Does it look like a bve, n(r21)? (this is also on PA2.0)
- That's the branch from an
- import stub to an export stub.
-
- It is impossible to determine the target of the branch via
- simple examination of instructions and/or data (consider
- that the address in the plabel may be the address of the
- bind-on-reference routine in the dynamic loader).
-
- So we have try an alternative approach.
-
- Get the name of the symbol at our current location; it should
- be a stub symbol with the same name as the symbol in the
- shared library.
-
- Then lookup a minimal symbol with the same name; we should
- get the minimal symbol for the target routine in the shared
- library as those take precedence of import/export stubs. */
- if ((curr_inst == 0xe2a00000) ||
- (curr_inst == 0xe2a00002) ||
- (curr_inst == 0xeaa0d000) ||
- (curr_inst == 0xeaa0d002))
- {
- struct minimal_symbol *stubsym, *libsym;
+ /* If the current instruction is nullified, then we are effectively
+ still executing the previous instruction. Pretend we are still
+ there. This is needed when single stepping; if the nullified
+ instruction is on a different line, we don't want GDB to think
+ we've stepped onto that line. */
+ if (ipsw & 0x00200000)
+ pc -= 4;
- stubsym = lookup_minimal_symbol_by_pc (loc);
- if (stubsym == NULL)
- {
- warning ("Unable to find symbol for 0x%lx", loc);
- return orig_pc == pc ? 0 : pc & ~0x3;
- }
+ return pc & ~0x3;
+}
- libsym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (stubsym), NULL, NULL);
- if (libsym == NULL)
- {
- warning ("Unable to find library symbol for %s\n",
- DEPRECATED_SYMBOL_NAME (stubsym));
- return orig_pc == pc ? 0 : pc & ~0x3;
- }
+void
+hppa_write_pc (CORE_ADDR pc, ptid_t ptid)
+{
+ write_register_pid (HPPA_PCOQ_HEAD_REGNUM, pc, ptid);
+ write_register_pid (HPPA_PCOQ_TAIL_REGNUM, pc + 4, ptid);
+}
- return SYMBOL_VALUE (libsym);
- }
+/* return the alignment of a type in bytes. Structures have the maximum
+ alignment required by their fields. */
- /* Does it look like bl X,%rp or bl X,%r0? Another way to do a
- branch from the stub to the actual function. */
- /*elz */
- else if ((curr_inst & 0xffe0e000) == 0xe8400000
- || (curr_inst & 0xffe0e000) == 0xe8000000
- || (curr_inst & 0xffe0e000) == 0xe800A000)
- return (loc + extract_17 (curr_inst) + 8) & ~0x3;
-
- /* Does it look like bv (rp)? Note this depends on the
- current stack pointer being the same as the stack
- pointer in the stub itself! This is a branch on from the
- stub back to the original caller. */
- /*else if ((curr_inst & 0xffe0e000) == 0xe840c000) */
- else if ((curr_inst & 0xffe0f000) == 0xe840c000)
+static int
+hppa_alignof (struct type *type)
+{
+ int max_align, align, i;
+ CHECK_TYPEDEF (type);
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_PTR:
+ case TYPE_CODE_INT:
+ case TYPE_CODE_FLT:
+ return TYPE_LENGTH (type);
+ case TYPE_CODE_ARRAY:
+ return hppa_alignof (TYPE_FIELD_TYPE (type, 0));
+ case TYPE_CODE_STRUCT:
+ case TYPE_CODE_UNION:
+ max_align = 1;
+ for (i = 0; i < TYPE_NFIELDS (type); i++)
{
- /* Yup. See if the previous instruction loaded
- rp from sp - 8. */
- if (prev_inst == 0x4bc23ff1)
- return (read_memory_integer
- (read_register (SP_REGNUM) - 8, 4)) & ~0x3;
- else
+ /* Bit fields have no real alignment. */
+ /* if (!TYPE_FIELD_BITPOS (type, i)) */
+ if (!TYPE_FIELD_BITSIZE (type, i)) /* elz: this should be bitsize */
{
- warning ("Unable to find restore of %%rp before bv (%%rp).");
- return orig_pc == pc ? 0 : pc & ~0x3;
+ align = hppa_alignof (TYPE_FIELD_TYPE (type, i));
+ max_align = max (max_align, align);
}
}
-
- /* elz: added this case to capture the new instruction
- at the end of the return part of an export stub used by
- the PA2.0: BVE, n (rp) */
- else if ((curr_inst & 0xffe0f000) == 0xe840d000)
- {
- return (read_memory_integer
- (read_register (SP_REGNUM) - 24, TARGET_PTR_BIT / 8)) & ~0x3;
- }
-
- /* What about be,n 0(sr0,%rp)? It's just another way we return to
- the original caller from the stub. Used in dynamic executables. */
- else if (curr_inst == 0xe0400002)
- {
- /* The value we jump to is sitting in sp - 24. But that's
- loaded several instructions before the be instruction.
- I guess we could check for the previous instruction being
- mtsp %r1,%sr0 if we want to do sanity checking. */
- return (read_memory_integer
- (read_register (SP_REGNUM) - 24, TARGET_PTR_BIT / 8)) & ~0x3;
- }
-
- /* Haven't found the branch yet, but we're still in the stub.
- Keep looking. */
- loc += 4;
+ return max_align;
+ default:
+ return 4;
}
}
-
/* For the given instruction (INST), return any adjustment it makes
to the stack pointer or zero for no adjustment.
/* The most common way to perform a stack adjustment ldo X(sp),sp */
if ((inst & 0xffffc000) == 0x37de0000)
- return extract_14 (inst);
+ return hppa_extract_14 (inst);
/* stwm X,D(sp) */
if ((inst & 0xffe00000) == 0x6fc00000)
- return extract_14 (inst);
+ return hppa_extract_14 (inst);
/* std,ma X,D(sp) */
if ((inst & 0xffe00008) == 0x73c00008)
return (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
- /* addil high21,%r1; ldo low11,(%r1),%r30)
+ /* addil high21,%r30; ldo low11,(%r1),%r30)
save high bits in save_high21 for later use. */
- if ((inst & 0xffe00000) == 0x28200000)
+ if ((inst & 0xffe00000) == 0x2bc00000)
{
- save_high21 = extract_21 (inst);
+ save_high21 = hppa_extract_21 (inst);
return 0;
}
if ((inst & 0xffff0000) == 0x343e0000)
- return save_high21 + extract_14 (inst);
+ return save_high21 + hppa_extract_14 (inst);
/* fstws as used by the HP compilers. */
if ((inst & 0xffffffe0) == 0x2fd01220)
- return extract_5_load (inst);
+ return hppa_extract_5_load (inst);
/* No adjustment. */
return 0;
|| (inst >> 26) == 0x1f
|| ((inst >> 26) == 0x1f
&& ((inst >> 6) == 0xa)))
- return extract_5R_store (inst);
+ return hppa_extract_5R_store (inst);
/* Does it look like a std? */
if ((inst >> 26) == 0x1c
|| ((inst >> 26) == 0x03
&& ((inst >> 6) & 0xf) == 0xb))
- return extract_5R_store (inst);
+ return hppa_extract_5R_store (inst);
/* Does it look like a stwm? GCC & HPC may use this in prologues. */
if ((inst >> 26) == 0x1b)
- return extract_5R_store (inst);
+ return hppa_extract_5R_store (inst);
/* Does it look like sth or stb? HPC versions 9.0 and later use these
too. */
|| ((inst >> 26) == 0x3
&& (((inst >> 6) & 0xf) == 0x8
|| (inst >> 6) & 0xf) == 0x9))
- return extract_5R_store (inst);
+ return hppa_extract_5R_store (inst);
return 0;
}
{
/* is this an FSTD ? */
if ((inst & 0xfc00dfc0) == 0x2c001200)
- return extract_5r_store (inst);
+ return hppa_extract_5r_store (inst);
if ((inst & 0xfc000002) == 0x70000002)
- return extract_5R_store (inst);
+ return hppa_extract_5R_store (inst);
/* is this an FSTW ? */
if ((inst & 0xfc00df80) == 0x24001200)
- return extract_5r_store (inst);
+ return hppa_extract_5r_store (inst);
if ((inst & 0xfc000002) == 0x7c000000)
- return extract_5R_store (inst);
+ return hppa_extract_5R_store (inst);
return 0;
}
be in the prologue. */
-CORE_ADDR
-skip_prologue_hard_way (CORE_ADDR pc)
+static CORE_ADDR
+skip_prologue_hard_way (CORE_ADDR pc, int stop_before_branch)
{
char buf[4];
CORE_ADDR orig_pc = pc;
unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
unsigned long args_stored, status, i, restart_gr, restart_fr;
struct unwind_table_entry *u;
+ int final_iteration;
restart_gr = 0;
restart_fr = 0;
for (i = 3; i < u->Entry_GR + 3; i++)
{
/* Frame pointer gets saved into a special location. */
- if (u->Save_SP && i == DEPRECATED_FP_REGNUM)
+ if (u->Save_SP && i == HPPA_FP_REGNUM)
continue;
save_gr |= (1 << i);
save_fr |= (1 << i);
save_fr &= ~restart_fr;
+ final_iteration = 0;
+
/* Loop until we find everything of interest or hit a branch.
For unoptimized GCC code and for any HP CC code this will never ever
old_save_sp = save_sp;
old_stack_remaining = stack_remaining;
- status = target_read_memory (pc, buf, 4);
+ status = read_memory_nobpt (pc, buf, 4);
inst = extract_unsigned_integer (buf, 4);
/* Yow! */
/* There are limited ways to store the return pointer into the
stack. */
- if (inst == 0x6bc23fd9 || inst == 0x0fc212c1)
+ if (inst == 0x6bc23fd9 || inst == 0x0fc212c1 || inst == 0x73c23fe1)
save_rp = 0;
/* These are the only ways we save SP into the stack. At this time
while (reg_num >= (TARGET_PTR_BIT == 64 ? 19 : 23) && reg_num <= 26)
{
pc += 4;
- status = target_read_memory (pc, buf, 4);
+ status = read_memory_nobpt (pc, buf, 4);
inst = extract_unsigned_integer (buf, 4);
if (status != 0)
return pc;
reg_num = inst_saves_fr (inst);
save_fr &= ~(1 << reg_num);
- status = target_read_memory (pc + 4, buf, 4);
+ status = read_memory_nobpt (pc + 4, buf, 4);
next_inst = extract_unsigned_integer (buf, 4);
/* Yow! */
while (reg_num >= 4 && reg_num <= (TARGET_PTR_BIT == 64 ? 11 : 7))
{
pc += 8;
- status = target_read_memory (pc, buf, 4);
+ status = read_memory_nobpt (pc, buf, 4);
inst = extract_unsigned_integer (buf, 4);
if (status != 0)
return pc;
if ((inst & 0xfc000000) != 0x34000000)
break;
- status = target_read_memory (pc + 4, buf, 4);
+ status = read_memory_nobpt (pc + 4, buf, 4);
next_inst = extract_unsigned_integer (buf, 4);
if (status != 0)
return pc;
/* Quit if we hit any kind of branch. This can happen if a prologue
instruction is in the delay slot of the first call/branch. */
- if (is_branch (inst))
+ if (is_branch (inst) && stop_before_branch)
break;
/* What a crock. The HP compilers set args_stored even if no
/* Bump the PC. */
pc += 4;
+
+ /* !stop_before_branch, so also look at the insn in the delay slot
+ of the branch. */
+ if (final_iteration)
+ break;
+ if (is_branch (inst))
+ final_iteration = 1;
}
/* We've got a tenative location for the end of the prologue. However
/* 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. */
+ returns an address that (if we're lucky) follows the prologue.
+
+ hppa_skip_prologue is called by gdb to place a breakpoint in a function.
+ It doesn't necessarily skips all the insns in the prologue. In fact
+ we might not want to skip all the insns because a prologue insn may
+ appear in the delay slot of the first branch, and we don't want to
+ skip over the branch in that case. */
-CORE_ADDR
+static CORE_ADDR
hppa_skip_prologue (CORE_ADDR pc)
{
unsigned long inst;
if (post_prologue_pc != 0)
return max (pc, post_prologue_pc);
else
- return (skip_prologue_hard_way (pc));
+ return (skip_prologue_hard_way (pc, 1));
+}
+
+/* Return an unwind entry that falls within the frame's code block. */
+static struct unwind_table_entry *
+hppa_find_unwind_entry_in_block (struct frame_info *f)
+{
+ CORE_ADDR pc;
+
+ pc = frame_unwind_address_in_block (f);
+ pc = gdbarch_addr_bits_remove (get_frame_arch (f), pc);
+ return find_unwind_entry (pc);
}
struct hppa_frame_cache
CORE_ADDR this_sp;
long frame_size;
struct unwind_table_entry *u;
+ CORE_ADDR prologue_end;
+ int fp_in_r1 = 0;
int i;
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, "{ hppa_frame_cache (frame=%d) -> ",
+ frame_relative_level(next_frame));
+
if ((*this_cache) != NULL)
- return (*this_cache);
+ {
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, "base=0x%s (cached) }",
+ paddr_nz (((struct hppa_frame_cache *)*this_cache)->base));
+ return (*this_cache);
+ }
cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
(*this_cache) = cache;
cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
/* Yow! */
- u = find_unwind_entry (frame_func_unwind (next_frame));
+ u = hppa_find_unwind_entry_in_block (next_frame);
if (!u)
- return (*this_cache);
+ {
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, "base=NULL (no unwind entry) }");
+ return (*this_cache);
+ }
/* Turn the Entry_GR field into a bitmask. */
saved_gr_mask = 0;
for (i = 3; i < u->Entry_GR + 3; i++)
{
/* Frame pointer gets saved into a special location. */
- if (u->Save_SP && i == DEPRECATED_FP_REGNUM)
+ if (u->Save_SP && i == HPPA_FP_REGNUM)
continue;
saved_gr_mask |= (1 << i);
GCC code. */
{
int final_iteration = 0;
- CORE_ADDR pc;
- CORE_ADDR end_pc = skip_prologue_using_sal (pc);
+ CORE_ADDR pc, start_pc, end_pc;
int looking_for_sp = u->Save_SP;
int looking_for_rp = u->Save_RP;
int fp_loc = -1;
- if (end_pc == 0)
- end_pc = frame_pc_unwind (next_frame);
+
+ /* We have to use skip_prologue_hard_way instead of just
+ skip_prologue_using_sal, in case we stepped into a function without
+ symbol information. hppa_skip_prologue also bounds the returned
+ pc by the passed in pc, so it will not return a pc in the next
+ function.
+
+ We used to call hppa_skip_prologue to find the end of the prologue,
+ but if some non-prologue instructions get scheduled into the prologue,
+ and the program is compiled with debug information, the "easy" way
+ in hppa_skip_prologue will return a prologue end that is too early
+ for us to notice any potential frame adjustments. */
+
+ /* We used to use frame_func_unwind () to locate the beginning of the
+ function to pass to skip_prologue (). However, when objects are
+ compiled without debug symbols, frame_func_unwind can return the wrong
+ function (or 0). We can do better than that by using unwind records.
+ This only works if the Region_description of the unwind record
+ indicates that it includes the entry point of the function.
+ HP compilers sometimes generate unwind records for regions that
+ do not include the entry or exit point of a function. GNU tools
+ do not do this. */
+
+ if ((u->Region_description & 0x2) == 0)
+ start_pc = u->region_start;
+ else
+ start_pc = frame_func_unwind (next_frame);
+
+ prologue_end = skip_prologue_hard_way (start_pc, 0);
+ end_pc = frame_pc_unwind (next_frame);
+
+ if (prologue_end != 0 && end_pc > prologue_end)
+ end_pc = prologue_end;
+
frame_size = 0;
- for (pc = frame_func_unwind (next_frame);
+
+ for (pc = start_pc;
((saved_gr_mask || saved_fr_mask
|| looking_for_sp || looking_for_rp
|| frame_size < (u->Total_frame_size << 3))
- && pc <= end_pc);
+ && pc < end_pc);
pc += 4)
{
int reg;
char buf4[4];
- long status = target_read_memory (pc, buf4, sizeof buf4);
- long inst = extract_unsigned_integer (buf4, sizeof buf4);
-
+ long inst;
+
+ if (!safe_frame_unwind_memory (next_frame, pc, buf4,
+ sizeof buf4))
+ {
+ error (_("Cannot read instruction at 0x%s."), paddr_nz (pc));
+ return (*this_cache);
+ }
+
+ inst = extract_unsigned_integer (buf4, sizeof buf4);
+
/* Note the interesting effects of this instruction. */
frame_size += prologue_inst_adjust_sp (inst);
if (inst == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
{
looking_for_rp = 0;
- cache->saved_regs[RP_REGNUM].addr = -20;
+ cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
+ }
+ else if (inst == 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
+ {
+ looking_for_rp = 0;
+ cache->saved_regs[HPPA_RP_REGNUM].addr = -24;
}
- else if (inst == 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
+ else if (inst == 0x0fc212c1
+ || inst == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
{
looking_for_rp = 0;
- cache->saved_regs[RP_REGNUM].addr = -16;
+ cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
}
/* Check to see if we saved SP into the stack. This also
|| (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
{
looking_for_sp = 0;
- cache->saved_regs[DEPRECATED_FP_REGNUM].addr = 0;
+ cache->saved_regs[HPPA_FP_REGNUM].addr = 0;
+ }
+ else if (inst == 0x08030241) /* copy %r3, %r1 */
+ {
+ fp_in_r1 = 1;
}
/* Account for general and floating-point register saves. */
reg = inst_saves_gr (inst);
if (reg >= 3 && reg <= 18
- && (!u->Save_SP || reg != DEPRECATED_FP_REGNUM))
+ && (!u->Save_SP || reg != HPPA_FP_REGNUM))
{
saved_gr_mask &= ~(1 << reg);
- if ((inst >> 26) == 0x1b && extract_14 (inst) >= 0)
+ if ((inst >> 26) == 0x1b && hppa_extract_14 (inst) >= 0)
/* stwm with a positive displacement is a _post_
_modify_. */
cache->saved_regs[reg].addr = 0;
if ((inst >> 26) == 0x1c)
offset = (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
else if ((inst >> 26) == 0x03)
- offset = low_sign_extend (inst & 0x1f, 5);
+ offset = hppa_low_hppa_sign_extend (inst & 0x1f, 5);
else
- offset = extract_14 (inst);
+ offset = hppa_extract_14 (inst);
/* Handle code with and without frame pointers. */
if (u->Save_SP)
/* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
if ((inst & 0xffffc000) == 0x34610000
|| (inst & 0xffffc000) == 0x37c10000)
- fp_loc = extract_14 (inst);
+ fp_loc = hppa_extract_14 (inst);
reg = inst_saves_fr (inst);
if (reg >= 12 && reg <= 21)
/* 1st HP CC FP register store. After this
instruction we've set enough state that the GCC and
HPCC code are both handled in the same manner. */
- cache->saved_regs[reg + FP4_REGNUM + 4].addr = 0;
+ cache->saved_regs[reg + HPPA_FP4_REGNUM + 4].addr = 0;
fp_loc = 8;
}
else
{
- cache->saved_regs[reg + FP0_REGNUM + 4].addr = fp_loc;
+ cache->saved_regs[reg + HPPA_FP0_REGNUM + 4].addr = fp_loc;
fp_loc += 8;
}
}
/* The frame base always represents the value of %sp at entry to
the current function (and is thus equivalent to the "saved"
stack pointer. */
- CORE_ADDR this_sp = frame_unwind_register_unsigned (next_frame, SP_REGNUM);
- /* FIXME: cagney/2004-02-22: This assumes that the frame has been
- created. If it hasn't everything will be out-of-wack. */
- if (u->Save_SP && trad_frame_addr_p (cache->saved_regs, SP_REGNUM))
- /* Both we're expecting the SP to be saved and the SP has been
- saved. The entry SP value is saved at this frame's SP
- address. */
- cache->base = read_memory_integer (this_sp, TARGET_PTR_BIT / 8);
+ CORE_ADDR this_sp = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
+ CORE_ADDR fp;
+
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, " (this_sp=0x%s, pc=0x%s, "
+ "prologue_end=0x%s) ",
+ paddr_nz (this_sp),
+ paddr_nz (frame_pc_unwind (next_frame)),
+ paddr_nz (prologue_end));
+
+ /* Check to see if a frame pointer is available, and use it for
+ frame unwinding if it is.
+
+ There are some situations where we need to rely on the frame
+ pointer to do stack unwinding. For example, if a function calls
+ alloca (), the stack pointer can get adjusted inside the body of
+ the function. In this case, the ABI requires that the compiler
+ maintain a frame pointer for the function.
+
+ The unwind record has a flag (alloca_frame) that indicates that
+ a function has a variable frame; unfortunately, gcc/binutils
+ does not set this flag. Instead, whenever a frame pointer is used
+ and saved on the stack, the Save_SP flag is set. We use this to
+ decide whether to use the frame pointer for unwinding.
+
+ TODO: For the HP compiler, maybe we should use the alloca_frame flag
+ instead of Save_SP. */
+
+ fp = frame_unwind_register_unsigned (next_frame, HPPA_FP_REGNUM);
+
+ if (u->alloca_frame)
+ fp -= u->Total_frame_size << 3;
+
+ if (frame_pc_unwind (next_frame) >= prologue_end
+ && (u->Save_SP || u->alloca_frame) && fp != 0)
+ {
+ cache->base = fp;
+
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [frame pointer]",
+ paddr_nz (cache->base));
+ }
+ else if (u->Save_SP
+ && trad_frame_addr_p (cache->saved_regs, HPPA_SP_REGNUM))
+ {
+ /* Both we're expecting the SP to be saved and the SP has been
+ saved. The entry SP value is saved at this frame's SP
+ address. */
+ cache->base = read_memory_integer (this_sp, TARGET_PTR_BIT / 8);
+
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [saved]",
+ paddr_nz (cache->base));
+ }
else
- /* The prologue has been slowly allocating stack space. Adjust
- the SP back. */
- cache->base = this_sp - frame_size;
- trad_frame_set_value (cache->saved_regs, SP_REGNUM, cache->base);
+ {
+ /* The prologue has been slowly allocating stack space. Adjust
+ the SP back. */
+ cache->base = this_sp - frame_size;
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [unwind adjust]",
+ paddr_nz (cache->base));
+
+ }
+ trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
}
/* The PC is found in the "return register", "Millicode" uses "r31"
as the return register while normal code uses "rp". */
if (u->Millicode)
- cache->saved_regs[PCOQ_HEAD_REGNUM] = cache->saved_regs[31];
+ {
+ if (trad_frame_addr_p (cache->saved_regs, 31))
+ {
+ cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = cache->saved_regs[31];
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, " (pc=r31) [stack] } ");
+ }
+ else
+ {
+ ULONGEST r31 = frame_unwind_register_unsigned (next_frame, 31);
+ trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, r31);
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, " (pc=r31) [frame] } ");
+ }
+ }
else
- cache->saved_regs[PCOQ_HEAD_REGNUM] = cache->saved_regs[RP_REGNUM];
+ {
+ if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
+ {
+ cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
+ cache->saved_regs[HPPA_RP_REGNUM];
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, " (pc=rp) [stack] } ");
+ }
+ else
+ {
+ ULONGEST rp = frame_unwind_register_unsigned (next_frame, HPPA_RP_REGNUM);
+ trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, " (pc=rp) [frame] } ");
+ }
+ }
+
+ /* If Save_SP is set, then we expect the frame pointer to be saved in the
+ frame. However, there is a one-insn window where we haven't saved it
+ yet, but we've already clobbered it. Detect this case and fix it up.
+
+ The prologue sequence for frame-pointer functions is:
+ 0: stw %rp, -20(%sp)
+ 4: copy %r3, %r1
+ 8: copy %sp, %r3
+ c: stw,ma %r1, XX(%sp)
+
+ So if we are at offset c, the r3 value that we want is not yet saved
+ on the stack, but it's been overwritten. The prologue analyzer will
+ set fp_in_r1 when it sees the copy insn so we know to get the value
+ from r1 instead. */
+ if (u->Save_SP && !trad_frame_addr_p (cache->saved_regs, HPPA_FP_REGNUM)
+ && fp_in_r1)
+ {
+ ULONGEST r1 = frame_unwind_register_unsigned (next_frame, 1);
+ trad_frame_set_value (cache->saved_regs, HPPA_FP_REGNUM, r1);
+ }
{
/* Convert all the offsets into addresses. */
}
}
+ {
+ struct gdbarch *gdbarch;
+ struct gdbarch_tdep *tdep;
+
+ gdbarch = get_frame_arch (next_frame);
+ tdep = gdbarch_tdep (gdbarch);
+
+ if (tdep->unwind_adjust_stub)
+ {
+ tdep->unwind_adjust_stub (next_frame, cache->base, cache->saved_regs);
+ }
+ }
+
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, "base=0x%s }",
+ paddr_nz (((struct hppa_frame_cache *)*this_cache)->base));
return (*this_cache);
}
hppa_frame_this_id (struct frame_info *next_frame, void **this_cache,
struct frame_id *this_id)
{
- struct hppa_frame_cache *info = hppa_frame_cache (next_frame, this_cache);
- (*this_id) = frame_id_build (info->base, frame_func_unwind (next_frame));
+ struct hppa_frame_cache *info;
+ CORE_ADDR pc = frame_pc_unwind (next_frame);
+ struct unwind_table_entry *u;
+
+ info = hppa_frame_cache (next_frame, this_cache);
+ u = hppa_find_unwind_entry_in_block (next_frame);
+
+ (*this_id) = frame_id_build (info->base, u->region_start);
}
static void
hppa_frame_prev_register (struct frame_info *next_frame,
- void **this_cache,
- int regnum, int *optimizedp,
- enum lval_type *lvalp, CORE_ADDR *addrp,
- int *realnump, void *valuep)
+ void **this_cache,
+ int regnum, int *optimizedp,
+ enum lval_type *lvalp, CORE_ADDR *addrp,
+ int *realnump, gdb_byte *valuep)
{
struct hppa_frame_cache *info = hppa_frame_cache (next_frame, this_cache);
- struct gdbarch *gdbarch = get_frame_arch (next_frame);
- if (regnum == PCOQ_TAIL_REGNUM)
- {
- /* The PCOQ TAIL, or NPC, needs to be computed from the unwound
- PC register. */
- *optimizedp = 0;
- *lvalp = not_lval;
- *addrp = 0;
- *realnump = 0;
- if (valuep)
- {
- int regsize = register_size (gdbarch, PCOQ_HEAD_REGNUM);
- CORE_ADDR pc;
- int optimized;
- enum lval_type lval;
- CORE_ADDR addr;
- int realnum;
- bfd_byte value[MAX_REGISTER_SIZE];
- trad_frame_prev_register (next_frame, info->saved_regs,
- PCOQ_HEAD_REGNUM, &optimized, &lval, &addr,
- &realnum, &value);
- pc = extract_unsigned_integer (&value, regsize);
- store_unsigned_integer (valuep, regsize, pc + 4);
- }
- }
- else
- {
- trad_frame_prev_register (next_frame, info->saved_regs, regnum,
- optimizedp, lvalp, addrp, realnump, valuep);
- }
+ hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
+ optimizedp, lvalp, addrp, realnump, valuep);
}
static const struct frame_unwind hppa_frame_unwind =
static const struct frame_unwind *
hppa_frame_unwind_sniffer (struct frame_info *next_frame)
{
- return &hppa_frame_unwind;
-}
+ if (hppa_find_unwind_entry_in_block (next_frame))
+ return &hppa_frame_unwind;
-static CORE_ADDR
-hppa_frame_base_address (struct frame_info *next_frame,
- void **this_cache)
-{
- struct hppa_frame_cache *info = hppa_frame_cache (next_frame,
- this_cache);
- return info->base;
+ return NULL;
}
-static const struct frame_base hppa_frame_base = {
- &hppa_frame_unwind,
- hppa_frame_base_address,
- hppa_frame_base_address,
- hppa_frame_base_address
-};
-
-static const struct frame_base *
-hppa_frame_base_sniffer (struct frame_info *next_frame)
-{
- return &hppa_frame_base;
-}
+/* This is a generic fallback frame unwinder that kicks in if we fail all
+ the other ones. Normally we would expect the stub and regular unwinder
+ to work, but in some cases we might hit a function that just doesn't
+ have any unwind information available. In this case we try to do
+ unwinding solely based on code reading. This is obviously going to be
+ slow, so only use this as a last resort. Currently this will only
+ identify the stack and pc for the frame. */
-static struct frame_id
-hppa_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
+static struct hppa_frame_cache *
+hppa_fallback_frame_cache (struct frame_info *next_frame, void **this_cache)
{
- return frame_id_build (frame_unwind_register_unsigned (next_frame,
- SP_REGNUM),
- frame_pc_unwind (next_frame));
-}
+ struct hppa_frame_cache *cache;
+ unsigned int frame_size = 0;
+ int found_rp = 0;
+ CORE_ADDR start_pc;
-static CORE_ADDR
-hppa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
- return frame_unwind_register_signed (next_frame, PCOQ_HEAD_REGNUM) & ~3;
-}
-
-/* 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 */
-static char HP_ACC_EH_notify_hook[] = "__eh_notify_hook";
-/* 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) */
-static char HP_ACC_EH_break[] = "__d_eh_break";
-/* 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 */
-static char HP_ACC_EH_catch_catch[] = "__d_eh_catch_catch";
-/* The enum used by aCC */
-typedef enum
- {
- __EH_NOTIFY_THROW,
- __EH_NOTIFY_CATCH
- }
-__eh_notification;
-
-/* 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;
-/* Similar to above, but imported from breakpoint.c -- non-target-specific */
-extern int exception_support_initialized;
-/* Address of __eh_notify_hook */
-static CORE_ADDR eh_notify_hook_addr = 0;
-/* Address of __d_eh_notify_callback */
-static CORE_ADDR eh_notify_callback_addr = 0;
-/* Address of __d_eh_break */
-static CORE_ADDR eh_break_addr = 0;
-/* Address of __d_eh_catch_catch */
-static CORE_ADDR eh_catch_catch_addr = 0;
-/* Address of __d_eh_catch_throw */
-static CORE_ADDR eh_catch_throw_addr = 0;
-/* Sal for __d_eh_break */
-static struct symtab_and_line *break_callback_sal = 0;
-
-/* Code in end.c expects __d_pid to be set in the inferior,
- otherwise __d_eh_notify_callback doesn't bother to call
- __d_eh_break! So we poke the pid into this symbol
- ourselves.
- 0 => success
- 1 => failure */
-int
-setup_d_pid_in_inferior (void)
-{
- CORE_ADDR anaddr;
- struct minimal_symbol *msymbol;
- char buf[4]; /* FIXME 32x64? */
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog,
+ "{ hppa_fallback_frame_cache (frame=%d) -> ",
+ frame_relative_level (next_frame));
- /* Slam the pid of the process into __d_pid; failing is only a warning! */
- 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).");
- return 1;
- }
+ cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
+ (*this_cache) = cache;
+ cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
- anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
- store_unsigned_integer (buf, 4, PIDGET (inferior_ptid)); /* FIXME 32x64? */
- if (target_write_memory (anaddr, buf, 4)) /* FIXME 32x64? */
+ start_pc = frame_func_unwind (next_frame);
+ if (start_pc)
{
- warning ("Unable to write __d_pid");
- warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
- return 1;
- }
- return 0;
-}
-
-/* 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
+ CORE_ADDR cur_pc = frame_pc_unwind (next_frame);
+ CORE_ADDR pc;
- Return 0 => failure
- 1 => success */
-
-static int
-initialize_hp_cxx_exception_support (void)
-{
- struct symtabs_and_lines sals;
- struct cleanup *old_chain;
- struct cleanup *canonical_strings_chain = NULL;
- int i;
- char *addr_start;
- char *addr_end = NULL;
- char **canonical = (char **) NULL;
- int thread = -1;
- struct symbol *sym = NULL;
- struct minimal_symbol *msym = NULL;
- struct objfile *objfile;
- asection *shlib_info;
+ for (pc = start_pc; pc < cur_pc; pc += 4)
+ {
+ unsigned int insn;
- /* 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 */
+ insn = read_memory_unsigned_integer (pc, 4);
+ frame_size += prologue_inst_adjust_sp (insn);
- static int recurse = 0;
- if (recurse > 0)
- {
- hp_cxx_exception_support_initialized = 0;
- exception_support_initialized = 0;
- return 0;
+ /* There are limited ways to store the return pointer into the
+ stack. */
+ if (insn == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
+ {
+ cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
+ found_rp = 1;
+ }
+ else if (insn == 0x0fc212c1
+ || insn == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
+ {
+ cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
+ found_rp = 1;
+ }
+ }
}
- hp_cxx_exception_support = 0;
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, " frame_size=%d, found_rp=%d }\n",
+ frame_size, found_rp);
- /* First check if we have seen any HP compiled objects; if not,
- it is very unlikely that HP's idiosyncratic callback mechanism
- for exception handling debug support will be available!
- This will percolate back up to breakpoint.c, where our callers
- will decide to try the g++ exception-handling support instead. */
- if (!hp_som_som_object_present)
- return 0;
+ cache->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
+ cache->base -= frame_size;
+ trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
- /* 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
- have HP aCC exception support built in. If this symbol is not
- found, even though we're a HP SOM-SOM file, we may have been
- built with some other compiler (not aCC). This results percolates
- back up to our callers in breakpoint.c which can decide to
- try the g++ style of exception support instead.
- If this symbol is found but the other symbols we require are
- not found, there is something weird going on, and g++ support
- 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. */
-
- /* libCsup has this hook; it'll usually be non-debuggable */
- msym = lookup_minimal_symbol (HP_ACC_EH_notify_hook, NULL, NULL);
- if (msym)
+ if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
{
- eh_notify_hook_addr = SYMBOL_VALUE_ADDRESS (msym);
- hp_cxx_exception_support = 1;
+ cache->saved_regs[HPPA_RP_REGNUM].addr += cache->base;
+ cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
+ cache->saved_regs[HPPA_RP_REGNUM];
}
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.");
- eh_notify_hook_addr = 0;
- hp_cxx_exception_support = 0;
- return 0;
+ ULONGEST rp;
+ rp = frame_unwind_register_unsigned (next_frame, HPPA_RP_REGNUM);
+ trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
}
- /* 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 */
- msym = lookup_minimal_symbol (HP_ACC_EH_notify_callback, NULL, NULL);
- if (msym)
- {
- eh_notify_callback_addr = SYMBOL_VALUE_ADDRESS (msym);
- hp_cxx_exception_support = 1;
- }
- 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.");
- eh_notify_callback_addr = 0;
- return 0;
- }
+ return cache;
+}
-#ifndef GDB_TARGET_IS_HPPA_20W
- /* Check whether the executable is dynamically linked or archive bound */
- /* With an archive-bound executable we can use the raw addresses we find
- for the callback function, etc. without modification. For an executable
- with shared libraries, we have to do more work to find the plabel, which
- can be the target of a call through $$dyncall from the aCC runtime support
- library (libCsup) which is linked shared by default by aCC. */
- /* This test below was copied from somsolib.c/somread.c. It may not be a very
- reliable one to test that an executable is linked shared. pai/1997-07-18 */
- 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. */
+static void
+hppa_fallback_frame_this_id (struct frame_info *next_frame, void **this_cache,
+ struct frame_id *this_id)
+{
+ struct hppa_frame_cache *info =
+ hppa_fallback_frame_cache (next_frame, this_cache);
+ (*this_id) = frame_id_build (info->base, frame_func_unwind (next_frame));
+}
- args_for_find_stub args;
- static char message[] = "Error while finding exception callback hook:\n";
+static void
+hppa_fallback_frame_prev_register (struct frame_info *next_frame,
+ void **this_cache,
+ int regnum, int *optimizedp,
+ enum lval_type *lvalp, CORE_ADDR *addrp,
+ int *realnump, gdb_byte *valuep)
+{
+ struct hppa_frame_cache *info =
+ hppa_fallback_frame_cache (next_frame, this_cache);
+ hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
+ optimizedp, lvalp, addrp, realnump, valuep);
+}
- args.solib_handle = som_solib_get_solib_by_pc (eh_notify_callback_addr);
- args.msym = msym;
- args.return_val = 0;
+static const struct frame_unwind hppa_fallback_frame_unwind =
+{
+ NORMAL_FRAME,
+ hppa_fallback_frame_this_id,
+ hppa_fallback_frame_prev_register
+};
- recurse++;
- catch_errors (cover_find_stub_with_shl_get, &args, message,
- RETURN_MASK_ALL);
- eh_notify_callback_addr = args.return_val;
- recurse--;
+static const struct frame_unwind *
+hppa_fallback_unwind_sniffer (struct frame_info *next_frame)
+{
+ return &hppa_fallback_frame_unwind;
+}
- exception_catchpoints_are_fragile = 1;
+/* Stub frames, used for all kinds of call stubs. */
+struct hppa_stub_unwind_cache
+{
+ CORE_ADDR base;
+ struct trad_frame_saved_reg *saved_regs;
+};
- if (!eh_notify_callback_addr)
- {
- /* 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.");
- return 0;
- }
- }
- else
- exception_catchpoints_are_fragile = 0;
-#endif
+static struct hppa_stub_unwind_cache *
+hppa_stub_frame_unwind_cache (struct frame_info *next_frame,
+ void **this_cache)
+{
+ struct gdbarch *gdbarch = get_frame_arch (next_frame);
+ struct hppa_stub_unwind_cache *info;
+ struct unwind_table_entry *u;
- /* Now, look for the breakpointable routine in end.o */
- /* This should also be available in the SOM symbol dict. if end.o linked in */
- msym = lookup_minimal_symbol (HP_ACC_EH_break, NULL, NULL);
- if (msym)
- {
- eh_break_addr = SYMBOL_VALUE_ADDRESS (msym);
- hp_cxx_exception_support = 1;
- }
- 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.");
- eh_break_addr = 0;
- return 0;
- }
+ if (*this_cache)
+ return *this_cache;
- /* Next look for the catch enable flag provided in end.o */
- sym = lookup_symbol (HP_ACC_EH_catch_catch, (struct block *) NULL,
- VAR_DOMAIN, 0, (struct symtab **) NULL);
- if (sym) /* sometimes present in debug info */
- {
- eh_catch_catch_addr = SYMBOL_VALUE_ADDRESS (sym);
- hp_cxx_exception_support = 1;
- }
- else
- /* otherwise look in SOM symbol dict. */
- {
- msym = lookup_minimal_symbol (HP_ACC_EH_catch_catch, NULL, NULL);
- if (msym)
- {
- eh_catch_catch_addr = SYMBOL_VALUE_ADDRESS (msym);
- hp_cxx_exception_support = 1;
- }
- 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).");
- return 0;
- }
- }
+ info = FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache);
+ *this_cache = info;
+ info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
- /* Next look for the catch enable flag provided end.o */
- sym = lookup_symbol (HP_ACC_EH_catch_catch, (struct block *) NULL,
- VAR_DOMAIN, 0, (struct symtab **) NULL);
- if (sym) /* sometimes present in debug info */
- {
- eh_catch_throw_addr = SYMBOL_VALUE_ADDRESS (sym);
- hp_cxx_exception_support = 1;
- }
- else
- /* otherwise look in SOM symbol dict. */
+ info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
+
+ if (gdbarch_osabi (gdbarch) == GDB_OSABI_HPUX_SOM)
{
- msym = lookup_minimal_symbol (HP_ACC_EH_catch_throw, NULL, NULL);
- if (msym)
- {
- eh_catch_throw_addr = SYMBOL_VALUE_ADDRESS (msym);
- hp_cxx_exception_support = 1;
- }
- else
+ /* HPUX uses export stubs in function calls; the export stub clobbers
+ the return value of the caller, and, later restores it from the
+ stack. */
+ u = find_unwind_entry (frame_pc_unwind (next_frame));
+
+ if (u && u->stub_unwind.stub_type == EXPORT)
{
- 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).");
- return 0;
+ info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = info->base - 24;
+
+ return info;
}
}
- /* Set the flags */
- hp_cxx_exception_support = 2; /* everything worked so far */
- hp_cxx_exception_support_initialized = 1;
- exception_support_initialized = 1;
+ /* By default we assume that stubs do not change the rp. */
+ info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].realreg = HPPA_RP_REGNUM;
- return 1;
+ return info;
+}
+
+static void
+hppa_stub_frame_this_id (struct frame_info *next_frame,
+ void **this_prologue_cache,
+ struct frame_id *this_id)
+{
+ struct hppa_stub_unwind_cache *info
+ = hppa_stub_frame_unwind_cache (next_frame, this_prologue_cache);
+
+ if (info)
+ *this_id = frame_id_build (info->base, frame_func_unwind (next_frame));
+ else
+ *this_id = null_frame_id;
+}
+
+static void
+hppa_stub_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_stub_unwind_cache *info
+ = hppa_stub_frame_unwind_cache (next_frame, this_prologue_cache);
+
+ if (info)
+ hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
+ optimizedp, lvalp, addrp, realnump,
+ valuep);
+ else
+ error (_("Requesting registers from null frame."));
}
-/* Target operation for enabling or disabling interception of
- exception events.
- KIND is either EX_EVENT_THROW or EX_EVENT_CATCH
- ENABLE is either 0 (disable) or 1 (enable).
- Return value is NULL if no support found;
- -1 if something went wrong,
- or a pointer to a symtab/line struct if the breakpointable
- address was found. */
+static const struct frame_unwind hppa_stub_frame_unwind = {
+ NORMAL_FRAME,
+ hppa_stub_frame_this_id,
+ hppa_stub_frame_prev_register
+};
-struct symtab_and_line *
-child_enable_exception_callback (enum exception_event_kind kind, int enable)
+static const struct frame_unwind *
+hppa_stub_unwind_sniffer (struct frame_info *next_frame)
{
- char buf[4];
+ CORE_ADDR pc = frame_pc_unwind (next_frame);
+ struct gdbarch *gdbarch = get_frame_arch (next_frame);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- if (!exception_support_initialized || !hp_cxx_exception_support_initialized)
- if (!initialize_hp_cxx_exception_support ())
- return NULL;
+ if (pc == 0
+ || (tdep->in_solib_call_trampoline != NULL
+ && tdep->in_solib_call_trampoline (pc, NULL))
+ || IN_SOLIB_RETURN_TRAMPOLINE (pc, NULL))
+ return &hppa_stub_frame_unwind;
+ return NULL;
+}
- switch (hp_cxx_exception_support)
- {
- case 0:
- /* Assuming no HP support at all */
- return NULL;
- case 1:
- /* HP support should be present, but something went wrong */
- return (struct symtab_and_line *) -1; /* yuck! */
- /* there may be other cases in the future */
- }
+static struct frame_id
+hppa_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
+{
+ return frame_id_build (frame_unwind_register_unsigned (next_frame,
+ HPPA_SP_REGNUM),
+ frame_pc_unwind (next_frame));
+}
- /* 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.");
- return (struct symtab_and_line *) -1;
- }
- if (enable)
- {
- /* Ensure that __d_pid is set up correctly -- end.c code checks this. :-( */
- if (PIDGET (inferior_ptid) > 0)
- {
- if (setup_d_pid_in_inferior ())
- return (struct symtab_and_line *) -1;
- }
- else
- {
- warning ("Internal error: Invalid inferior pid? Cannot intercept exception events.");
- return (struct symtab_and_line *) -1;
- }
- }
+CORE_ADDR
+hppa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
+{
+ ULONGEST ipsw;
+ CORE_ADDR pc;
- switch (kind)
- {
- case EX_EVENT_THROW:
- 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.");
- return (struct symtab_and_line *) -1;
- }
- break;
- case EX_EVENT_CATCH:
- 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.");
- return (struct symtab_and_line *) -1;
- }
- break;
- default:
- error ("Request to enable unknown or unsupported exception event.");
- }
+ ipsw = frame_unwind_register_unsigned (next_frame, HPPA_IPSW_REGNUM);
+ pc = frame_unwind_register_unsigned (next_frame, HPPA_PCOQ_HEAD_REGNUM);
+
+ /* If the current instruction is nullified, then we are effectively
+ still executing the previous instruction. Pretend we are still
+ there. This is needed when single stepping; if the nullified
+ instruction is on a different line, we don't want GDB to think
+ we've stepped onto that line. */
+ if (ipsw & 0x00200000)
+ pc -= 4;
+
+ return pc & ~0x3;
+}
+
+/* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
+ Return NULL if no such symbol was found. */
+
+struct minimal_symbol *
+hppa_lookup_stub_minimal_symbol (const char *name,
+ enum unwind_stub_types stub_type)
+{
+ struct objfile *objfile;
+ struct minimal_symbol *msym;
- /* Copy break address into new sal struct, malloc'ing if needed. */
- if (!break_callback_sal)
+ ALL_MSYMBOLS (objfile, msym)
{
- break_callback_sal = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
+ if (strcmp (SYMBOL_LINKAGE_NAME (msym), name) == 0)
+ {
+ struct unwind_table_entry *u;
+
+ u = find_unwind_entry (SYMBOL_VALUE (msym));
+ if (u != NULL && u->stub_unwind.stub_type == stub_type)
+ return msym;
+ }
}
- init_sal (break_callback_sal);
- break_callback_sal->symtab = NULL;
- break_callback_sal->pc = eh_break_addr;
- break_callback_sal->line = 0;
- break_callback_sal->end = eh_break_addr;
-
- return break_callback_sal;
-}
-
-/* Record some information about the current exception event */
-static struct exception_event_record current_ex_event;
-/* Convenience struct */
-static struct symtab_and_line null_symtab_and_line =
-{NULL, 0, 0, 0};
-
-/* Report current exception event. Returns a pointer to a record
- that describes the kind of the event, where it was thrown from,
- and where it will be caught. More information may be reported
- in the future */
-struct exception_event_record *
-child_get_current_exception_event (void)
-{
- CORE_ADDR event_kind;
- CORE_ADDR throw_addr;
- CORE_ADDR catch_addr;
- struct frame_info *fi, *curr_frame;
- int level = 1;
-
- curr_frame = get_current_frame ();
- if (!curr_frame)
- return (struct exception_event_record *) NULL;
-
- /* Go up one frame to __d_eh_notify_callback, because at the
- point when this code is executed, there's garbage in the
- arguments of __d_eh_break. */
- fi = find_relative_frame (curr_frame, &level);
- if (level != 0)
- return (struct exception_event_record *) NULL;
-
- select_frame (fi);
-
- /* Read in the arguments */
- /* __d_eh_notify_callback() is called with 3 arguments:
- 1. event kind catch or throw
- 2. the target address if known
- 3. a flag -- not sure what this is. pai/1997-07-17 */
- event_kind = read_register (ARG0_REGNUM);
- catch_addr = read_register (ARG1_REGNUM);
-
- /* Now go down to a user frame */
- /* For a throw, __d_eh_break is called by
- __d_eh_notify_callback which is called by
- __notify_throw which is called
- from user code.
- For a catch, __d_eh_break is called by
- __d_eh_notify_callback which is called by
- <stackwalking stuff> which is called by
- __throw__<stuff> or __rethrow_<stuff> which is called
- from user code. */
- /* FIXME: Don't use such magic numbers; search for the frames */
- level = (event_kind == EX_EVENT_THROW) ? 3 : 4;
- fi = find_relative_frame (curr_frame, &level);
- if (level != 0)
- return (struct exception_event_record *) NULL;
-
- select_frame (fi);
- throw_addr = get_frame_pc (fi);
-
- /* Go back to original (top) frame */
- select_frame (curr_frame);
-
- current_ex_event.kind = (enum exception_event_kind) event_kind;
- current_ex_event.throw_sal = find_pc_line (throw_addr, 1);
- current_ex_event.catch_sal = find_pc_line (catch_addr, 1);
-
- return ¤t_ex_event;
-}
-
-/* Instead of this nasty cast, add a method pvoid() that prints out a
- host VOID data type (remember %p isn't portable). */
-static CORE_ADDR
-hppa_pointer_to_address_hack (void *ptr)
-{
- gdb_assert (sizeof (ptr) == TYPE_LENGTH (builtin_type_void_data_ptr));
- return POINTER_TO_ADDRESS (builtin_type_void_data_ptr, &ptr);
+ return NULL;
}
static void
return;
}
- printf_unfiltered ("unwind_table_entry (0x%s):\n",
- paddr_nz (hppa_pointer_to_address_hack (u)));
+ printf_unfiltered ("unwind_table_entry (0x%lx):\n", (unsigned long)u);
printf_unfiltered ("\tregion_start = ");
print_address (u->region_start, gdb_stdout);
+ gdb_flush (gdb_stdout);
printf_unfiltered ("\n\tregion_end = ");
print_address (u->region_end, gdb_stdout);
+ gdb_flush (gdb_stdout);
#define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
pif (Frame_Extension_Millicode);
pif (Stack_Overflow_Check);
pif (Two_Instruction_SP_Increment);
- pif (Ada_Region);
+ pif (sr4export);
+ pif (cxx_info);
+ pif (cxx_try_catch);
+ pif (sched_entry_seq);
pif (Save_SP);
pif (Save_RP);
pif (Save_MRP_in_frame);
- pif (extn_ptr_defined);
+ pif (save_r19);
pif (Cleanup_defined);
pif (MPE_XL_interrupt_marker);
pif (HP_UX_interrupt_marker);
pif (Large_frame);
+ pif (alloca_frame);
putchar_unfiltered ('\n');
pin (Entry_FR);
pin (Entry_GR);
pin (Total_frame_size);
-}
-
-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 (PCOQ_HEAD_REGNUM, read_register (PCOQ_TAIL_REGNUM));
- write_register (PCSQ_HEAD_REGNUM, read_register (PCSQ_TAIL_REGNUM));
-
- write_register (PCOQ_TAIL_REGNUM, read_register (PCOQ_TAIL_REGNUM) + 4);
- /* We can leave the tail's space the same, since there's no jump. */
-}
-
-int
-hppa_reg_struct_has_addr (int gcc_p, struct type *type)
-{
- /* On the PA, any pass-by-value structure > 8 bytes is actually passed
- via a pointer regardless of its type or the compiler used. */
- return (TYPE_LENGTH (type) > 8);
-}
-int
-hppa_inner_than (CORE_ADDR lhs, CORE_ADDR rhs)
-{
- /* Stack grows upward */
- return (lhs > rhs);
+ if (u->stub_unwind.stub_type)
+ {
+ printf_unfiltered ("\tstub type = ");
+ switch (u->stub_unwind.stub_type)
+ {
+ case LONG_BRANCH:
+ printf_unfiltered ("long branch\n");
+ break;
+ case PARAMETER_RELOCATION:
+ printf_unfiltered ("parameter relocation\n");
+ break;
+ case EXPORT:
+ printf_unfiltered ("export\n");
+ break;
+ case IMPORT:
+ printf_unfiltered ("import\n");
+ break;
+ case IMPORT_SHLIB:
+ printf_unfiltered ("import shlib\n");
+ break;
+ default:
+ printf_unfiltered ("unknown (%d)\n", u->stub_unwind.stub_type);
+ }
+ }
}
int
minimal symbols, I'm resorting to the gross hack of checking the
top byte of the address for all 1's. Sigh. */
- return (!target_has_stack && (pc & 0xFF000000));
-}
-
-int
-hppa_instruction_nullified (void)
-{
- /* brobecker 2002/11/07: Couldn't we use a ULONGEST here? It would
- avoid the type cast. I'm leaving it as is for now as I'm doing
- semi-mechanical multiarching-related changes. */
- const int ipsw = (int) read_register (IPSW_REGNUM);
- const int flags = (int) read_register (FLAGS_REGNUM);
-
- return ((ipsw & 0x00200000) && !(flags & 0x2));
-}
-
-int
-hppa_register_raw_size (int reg_nr)
-{
- /* All registers have the same size. */
- return DEPRECATED_REGISTER_SIZE;
+ return (!target_has_stack && (pc & 0xFF000000) == 0xFF000000);
}
-/* Index within the register vector of the first byte of the space i
- used for register REG_NR. */
+/* Return the GDB type object for the "standard" data type of data in
+ register REGNUM. */
-int
-hppa_register_byte (int reg_nr)
+static struct type *
+hppa32_register_type (struct gdbarch *gdbarch, int regnum)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
-
- return reg_nr * tdep->bytes_per_address;
+ if (regnum < HPPA_FP4_REGNUM)
+ return builtin_type_uint32;
+ else
+ return builtin_type_ieee_single;
}
-/* Return the GDB type object for the "standard" data type of data
- in register N. */
-
-struct type *
-hppa32_register_virtual_type (int reg_nr)
+static struct type *
+hppa64_register_type (struct gdbarch *gdbarch, int regnum)
{
- if (reg_nr < FP4_REGNUM)
- return builtin_type_int;
+ if (regnum < HPPA64_FP4_REGNUM)
+ return builtin_type_uint64;
else
- return builtin_type_float;
+ return builtin_type_ieee_double;
}
-/* Return the GDB type object for the "standard" data type of data
- in register N. hppa64 version. */
+/* Return non-zero if REGNUM is not a register available to the user
+ through ptrace/ttrace. */
-struct type *
-hppa64_register_virtual_type (int reg_nr)
+static int
+hppa32_cannot_store_register (int regnum)
{
- if (reg_nr < FP4_REGNUM)
- return builtin_type_unsigned_long_long;
- else
- return builtin_type_double;
+ return (regnum == 0
+ || regnum == HPPA_PCSQ_HEAD_REGNUM
+ || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
+ || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA_FP4_REGNUM));
}
-/* Return True if REGNUM is not a register available to the user
- through ptrace(). */
-
-int
-hppa_cannot_store_register (int regnum)
+static int
+hppa64_cannot_store_register (int regnum)
{
return (regnum == 0
- || regnum == PCSQ_HEAD_REGNUM
- || (regnum >= PCSQ_TAIL_REGNUM && regnum < IPSW_REGNUM)
- || (regnum > IPSW_REGNUM && regnum < FP4_REGNUM));
-
+ || regnum == HPPA_PCSQ_HEAD_REGNUM
+ || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
+ || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA64_FP4_REGNUM));
}
-CORE_ADDR
+static CORE_ADDR
hppa_smash_text_address (CORE_ADDR addr)
{
/* The low two bits of the PC on the PA contain the privilege level.
return (addr &= ~0x3);
}
-/* Get the ith function argument for the current function. */
-CORE_ADDR
+/* Get the ARGIth function argument for the current function. */
+
+static CORE_ADDR
hppa_fetch_pointer_argument (struct frame_info *frame, int argi,
struct type *type)
{
- CORE_ADDR addr;
- get_frame_register (frame, R0_REGNUM + 26 - argi, &addr);
- return addr;
+ return get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 26 - argi);
+}
+
+static void
+hppa_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
+ int regnum, gdb_byte *buf)
+{
+ ULONGEST tmp;
+
+ regcache_raw_read_unsigned (regcache, regnum, &tmp);
+ if (regnum == HPPA_PCOQ_HEAD_REGNUM || regnum == HPPA_PCOQ_TAIL_REGNUM)
+ tmp &= ~0x3;
+ store_unsigned_integer (buf, sizeof tmp, tmp);
+}
+
+static CORE_ADDR
+hppa_find_global_pointer (struct value *function)
+{
+ return 0;
+}
+
+void
+hppa_frame_prev_register_helper (struct frame_info *next_frame,
+ struct trad_frame_saved_reg saved_regs[],
+ int regnum, int *optimizedp,
+ enum lval_type *lvalp, CORE_ADDR *addrp,
+ int *realnump, gdb_byte *valuep)
+{
+ struct gdbarch *arch = get_frame_arch (next_frame);
+
+ if (regnum == HPPA_PCOQ_TAIL_REGNUM)
+ {
+ if (valuep)
+ {
+ int size = register_size (arch, HPPA_PCOQ_HEAD_REGNUM);
+ CORE_ADDR pc;
+
+ trad_frame_get_prev_register (next_frame, saved_regs,
+ HPPA_PCOQ_HEAD_REGNUM, optimizedp,
+ lvalp, addrp, realnump, valuep);
+
+ pc = extract_unsigned_integer (valuep, size);
+ store_unsigned_integer (valuep, size, pc + 4);
+ }
+
+ /* It's a computed value. */
+ *optimizedp = 0;
+ *lvalp = not_lval;
+ *addrp = 0;
+ *realnump = -1;
+ return;
+ }
+
+ /* Make sure the "flags" register is zero in all unwound frames.
+ The "flags" registers is a HP-UX specific wart, and only the code
+ in hppa-hpux-tdep.c depends on it. However, it is easier to deal
+ with it here. This shouldn't affect other systems since those
+ should provide zero for the "flags" register anyway. */
+ if (regnum == HPPA_FLAGS_REGNUM)
+ {
+ if (valuep)
+ store_unsigned_integer (valuep, register_size (arch, regnum), 0);
+
+ /* It's a computed value. */
+ *optimizedp = 0;
+ *lvalp = not_lval;
+ *addrp = 0;
+ *realnump = -1;
+ return;
+ }
+
+ trad_frame_get_prev_register (next_frame, saved_regs, regnum,
+ optimizedp, lvalp, addrp, realnump, valuep);
+}
+\f
+
+/* An instruction to match. */
+struct insn_pattern
+{
+ unsigned int data; /* See if it matches this.... */
+ unsigned int mask; /* ... with this mask. */
+};
+
+/* See bfd/elf32-hppa.c */
+static struct insn_pattern hppa_long_branch_stub[] = {
+ /* ldil LR'xxx,%r1 */
+ { 0x20200000, 0xffe00000 },
+ /* be,n RR'xxx(%sr4,%r1) */
+ { 0xe0202002, 0xffe02002 },
+ { 0, 0 }
+};
+
+static struct insn_pattern hppa_long_branch_pic_stub[] = {
+ /* b,l .+8, %r1 */
+ { 0xe8200000, 0xffe00000 },
+ /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
+ { 0x28200000, 0xffe00000 },
+ /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
+ { 0xe0202002, 0xffe02002 },
+ { 0, 0 }
+};
+
+static struct insn_pattern hppa_import_stub[] = {
+ /* addil LR'xxx, %dp */
+ { 0x2b600000, 0xffe00000 },
+ /* ldw RR'xxx(%r1), %r21 */
+ { 0x48350000, 0xffffb000 },
+ /* bv %r0(%r21) */
+ { 0xeaa0c000, 0xffffffff },
+ /* ldw RR'xxx+4(%r1), %r19 */
+ { 0x48330000, 0xffffb000 },
+ { 0, 0 }
+};
+
+static struct insn_pattern hppa_import_pic_stub[] = {
+ /* addil LR'xxx,%r19 */
+ { 0x2a600000, 0xffe00000 },
+ /* ldw RR'xxx(%r1),%r21 */
+ { 0x48350000, 0xffffb000 },
+ /* bv %r0(%r21) */
+ { 0xeaa0c000, 0xffffffff },
+ /* ldw RR'xxx+4(%r1),%r19 */
+ { 0x48330000, 0xffffb000 },
+ { 0, 0 },
+};
+
+static struct insn_pattern hppa_plt_stub[] = {
+ /* b,l 1b, %r20 - 1b is 3 insns before here */
+ { 0xea9f1fdd, 0xffffffff },
+ /* depi 0,31,2,%r20 */
+ { 0xd6801c1e, 0xffffffff },
+ { 0, 0 }
+};
+
+static struct insn_pattern hppa_sigtramp[] = {
+ /* ldi 0, %r25 or ldi 1, %r25 */
+ { 0x34190000, 0xfffffffd },
+ /* ldi __NR_rt_sigreturn, %r20 */
+ { 0x3414015a, 0xffffffff },
+ /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
+ { 0xe4008200, 0xffffffff },
+ /* nop */
+ { 0x08000240, 0xffffffff },
+ { 0, 0 }
+};
+
+/* Maximum number of instructions on the patterns above. */
+#define HPPA_MAX_INSN_PATTERN_LEN 4
+
+/* Return non-zero if the instructions at PC match the series
+ described in PATTERN, or zero otherwise. PATTERN is an array of
+ 'struct insn_pattern' objects, terminated by an entry whose mask is
+ zero.
+
+ When the match is successful, fill INSN[i] with what PATTERN[i]
+ matched. */
+
+static int
+hppa_match_insns (CORE_ADDR pc, struct insn_pattern *pattern,
+ unsigned int *insn)
+{
+ CORE_ADDR npc = pc;
+ int i;
+
+ for (i = 0; pattern[i].mask; i++)
+ {
+ gdb_byte buf[HPPA_INSN_SIZE];
+
+ read_memory_nobpt (npc, buf, HPPA_INSN_SIZE);
+ insn[i] = extract_unsigned_integer (buf, HPPA_INSN_SIZE);
+ if ((insn[i] & pattern[i].mask) == pattern[i].data)
+ npc += 4;
+ else
+ return 0;
+ }
+
+ return 1;
+}
+
+/* This relaxed version of the insstruction matcher allows us to match
+ from somewhere inside the pattern, by looking backwards in the
+ instruction scheme. */
+
+static int
+hppa_match_insns_relaxed (CORE_ADDR pc, struct insn_pattern *pattern,
+ unsigned int *insn)
+{
+ int offset, len = 0;
+
+ while (pattern[len].mask)
+ len++;
+
+ for (offset = 0; offset < len; offset++)
+ if (hppa_match_insns (pc - offset * HPPA_INSN_SIZE, pattern, insn))
+ return 1;
+
+ return 0;
+}
+
+static int
+hppa_in_dyncall (CORE_ADDR pc)
+{
+ struct unwind_table_entry *u;
+
+ u = find_unwind_entry (hppa_symbol_address ("$$dyncall"));
+ if (!u)
+ return 0;
+
+ return (pc >= u->region_start && pc <= u->region_end);
+}
+
+int
+hppa_in_solib_call_trampoline (CORE_ADDR pc, char *name)
+{
+ unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
+ struct unwind_table_entry *u;
+
+ if (in_plt_section (pc, name) || hppa_in_dyncall (pc))
+ return 1;
+
+ /* The GNU toolchain produces linker stubs without unwind
+ information. Since the pattern matching for linker stubs can be
+ quite slow, so bail out if we do have an unwind entry. */
+
+ u = find_unwind_entry (pc);
+ if (u != NULL)
+ return 0;
+
+ return (hppa_match_insns_relaxed (pc, hppa_import_stub, insn)
+ || hppa_match_insns_relaxed (pc, hppa_import_pic_stub, insn)
+ || hppa_match_insns_relaxed (pc, hppa_long_branch_stub, insn)
+ || hppa_match_insns_relaxed (pc, hppa_long_branch_pic_stub, insn));
+}
+
+/* This code skips several kind of "trampolines" used on PA-RISC
+ systems: $$dyncall, import stubs and PLT stubs. */
+
+CORE_ADDR
+hppa_skip_trampoline_code (CORE_ADDR pc)
+{
+ unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
+ int dp_rel;
+
+ /* $$dyncall handles both PLABELs and direct addresses. */
+ if (hppa_in_dyncall (pc))
+ {
+ pc = read_register (HPPA_R0_REGNUM + 22);
+
+ /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it. */
+ if (pc & 0x2)
+ pc = read_memory_typed_address (pc & ~0x3, builtin_type_void_func_ptr);
+
+ return pc;
+ }
+
+ dp_rel = hppa_match_insns (pc, hppa_import_stub, insn);
+ if (dp_rel || hppa_match_insns (pc, hppa_import_pic_stub, insn))
+ {
+ /* Extract the target address from the addil/ldw sequence. */
+ pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]);
+
+ if (dp_rel)
+ pc += read_register (HPPA_DP_REGNUM);
+ else
+ pc += read_register (HPPA_R0_REGNUM + 19);
+
+ /* fallthrough */
+ }
+
+ if (in_plt_section (pc, NULL))
+ {
+ pc = read_memory_typed_address (pc, builtin_type_void_func_ptr);
+
+ /* If the PLT slot has not yet been resolved, the target will be
+ the PLT stub. */
+ if (in_plt_section (pc, NULL))
+ {
+ /* Sanity check: are we pointing to the PLT stub? */
+ if (!hppa_match_insns (pc, hppa_plt_stub, insn))
+ {
+ warning (_("Cannot resolve PLT stub at 0x%s."), paddr_nz (pc));
+ return 0;
+ }
+
+ /* This should point to the fixup routine. */
+ pc = read_memory_typed_address (pc + 8, builtin_type_void_func_ptr);
+ }
+ }
+
+ return pc;
}
+\f
/* Here is a table of C type sizes on hppa with various compiles
and options. I measured this on PA 9000/800 with HP-UX 11.11
return (arches->gdbarch);
/* If none found, then allocate and initialize one. */
- tdep = XMALLOC (struct gdbarch_tdep);
+ tdep = XZALLOC (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
/* Determine from the bfd_arch_info structure if we are dealing with
else
tdep->bytes_per_address = 4;
+ tdep->find_global_pointer = hppa_find_global_pointer;
+
/* Some parts of the gdbarch vector depend on whether we are running
on a 32 bits or 64 bits target. */
switch (tdep->bytes_per_address)
case 4:
set_gdbarch_num_regs (gdbarch, hppa32_num_regs);
set_gdbarch_register_name (gdbarch, hppa32_register_name);
- set_gdbarch_deprecated_register_virtual_type
- (gdbarch, hppa32_register_virtual_type);
+ set_gdbarch_register_type (gdbarch, hppa32_register_type);
+ set_gdbarch_cannot_store_register (gdbarch,
+ hppa32_cannot_store_register);
+ set_gdbarch_cannot_fetch_register (gdbarch,
+ hppa32_cannot_store_register);
break;
case 8:
set_gdbarch_num_regs (gdbarch, hppa64_num_regs);
set_gdbarch_register_name (gdbarch, hppa64_register_name);
- set_gdbarch_deprecated_register_virtual_type
- (gdbarch, hppa64_register_virtual_type);
+ set_gdbarch_register_type (gdbarch, hppa64_register_type);
+ set_gdbarch_dwarf_reg_to_regnum (gdbarch, hppa64_dwarf_reg_to_regnum);
+ set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa64_dwarf_reg_to_regnum);
+ set_gdbarch_cannot_store_register (gdbarch,
+ hppa64_cannot_store_register);
+ set_gdbarch_cannot_fetch_register (gdbarch,
+ hppa64_cannot_store_register);
break;
default:
- internal_error (__FILE__, __LINE__, "Unsupported address size: %d",
+ internal_error (__FILE__, __LINE__, _("Unsupported address size: %d"),
tdep->bytes_per_address);
}
- /* The following gdbarch vector elements depend on other parts of this
- vector which have been set above, depending on the ABI. */
- set_gdbarch_deprecated_register_bytes
- (gdbarch, gdbarch_num_regs (gdbarch) * tdep->bytes_per_address);
set_gdbarch_long_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
set_gdbarch_ptr_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
and LP64, but might show differences some day. */
set_gdbarch_long_long_bit (gdbarch, 64);
set_gdbarch_long_double_bit (gdbarch, 128);
- set_gdbarch_long_double_format (gdbarch, &floatformat_ia64_quad_big);
+ set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
/* The following gdbarch vector elements do not depend on the address
size, or in any other gdbarch element previously set. */
set_gdbarch_skip_prologue (gdbarch, hppa_skip_prologue);
- set_gdbarch_skip_trampoline_code (gdbarch, hppa_skip_trampoline_code);
- set_gdbarch_in_solib_call_trampoline (gdbarch, hppa_in_solib_call_trampoline);
- set_gdbarch_in_solib_return_trampoline (gdbarch,
- hppa_in_solib_return_trampoline);
- set_gdbarch_inner_than (gdbarch, hppa_inner_than);
- set_gdbarch_deprecated_register_size (gdbarch, tdep->bytes_per_address);
- set_gdbarch_deprecated_fp_regnum (gdbarch, 3);
- set_gdbarch_sp_regnum (gdbarch, 30);
- set_gdbarch_fp0_regnum (gdbarch, 64);
- set_gdbarch_deprecated_register_raw_size (gdbarch, hppa_register_raw_size);
- set_gdbarch_deprecated_register_byte (gdbarch, hppa_register_byte);
- set_gdbarch_deprecated_register_virtual_size (gdbarch, hppa_register_raw_size);
- set_gdbarch_deprecated_max_register_raw_size (gdbarch, tdep->bytes_per_address);
- set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 8);
- set_gdbarch_cannot_store_register (gdbarch, hppa_cannot_store_register);
+ set_gdbarch_in_function_epilogue_p (gdbarch,
+ hppa_in_function_epilogue_p);
+ set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
+ set_gdbarch_sp_regnum (gdbarch, HPPA_SP_REGNUM);
+ set_gdbarch_fp0_regnum (gdbarch, HPPA_FP0_REGNUM);
set_gdbarch_addr_bits_remove (gdbarch, hppa_smash_text_address);
set_gdbarch_smash_text_address (gdbarch, hppa_smash_text_address);
set_gdbarch_believe_pcc_promotion (gdbarch, 1);
- set_gdbarch_read_pc (gdbarch, hppa_target_read_pc);
- set_gdbarch_write_pc (gdbarch, hppa_target_write_pc);
- set_gdbarch_deprecated_target_read_fp (gdbarch, hppa_target_read_fp);
+ set_gdbarch_read_pc (gdbarch, hppa_read_pc);
+ set_gdbarch_write_pc (gdbarch, hppa_write_pc);
/* Helper for function argument information. */
set_gdbarch_fetch_pointer_argument (gdbarch, hppa_fetch_pointer_argument);
case 4:
set_gdbarch_push_dummy_call (gdbarch, hppa32_push_dummy_call);
set_gdbarch_frame_align (gdbarch, hppa32_frame_align);
+ set_gdbarch_convert_from_func_ptr_addr
+ (gdbarch, hppa32_convert_from_func_ptr_addr);
break;
case 8:
set_gdbarch_push_dummy_call (gdbarch, hppa64_push_dummy_call);
set_gdbarch_frame_align (gdbarch, hppa64_frame_align);
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
/* Struct return methods. */
break;
case 8:
set_gdbarch_return_value (gdbarch, hppa64_return_value);
+ break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
+ set_gdbarch_breakpoint_from_pc (gdbarch, hppa_breakpoint_from_pc);
+ set_gdbarch_pseudo_register_read (gdbarch, hppa_pseudo_register_read);
+
/* Frame unwind methods. */
set_gdbarch_unwind_dummy_id (gdbarch, hppa_unwind_dummy_id);
set_gdbarch_unwind_pc (gdbarch, hppa_unwind_pc);
- frame_unwind_append_sniffer (gdbarch, hppa_frame_unwind_sniffer);
- frame_base_append_sniffer (gdbarch, hppa_frame_base_sniffer);
/* Hook in ABI-specific overrides, if they have been registered. */
gdbarch_init_osabi (info, gdbarch);
+ /* Hook in the default unwinders. */
+ frame_unwind_append_sniffer (gdbarch, hppa_stub_unwind_sniffer);
+ frame_unwind_append_sniffer (gdbarch, hppa_frame_unwind_sniffer);
+ frame_unwind_append_sniffer (gdbarch, hppa_fallback_unwind_sniffer);
+
return gdbarch;
}
static void
hppa_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
{
- /* Nothing to print for the moment. */
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+
+ fprintf_unfiltered (file, "bytes_per_address = %d\n",
+ tdep->bytes_per_address);
+ fprintf_unfiltered (file, "elf = %s\n", tdep->is_elf ? "yes" : "no");
}
void
_initialize_hppa_tdep (void)
{
struct cmd_list_element *c;
- void break_at_finish_command (char *arg, int from_tty);
- void tbreak_at_finish_command (char *arg, int from_tty);
- void break_at_finish_at_depth_command (char *arg, int from_tty);
gdbarch_register (bfd_arch_hppa, hppa_gdbarch_init, hppa_dump_tdep);
+ hppa_objfile_priv_data = register_objfile_data ();
+
add_cmd ("unwind", class_maintenance, unwind_command,
- "Print unwind table entry at given address.",
+ _("Print unwind table entry at given address."),
&maintenanceprintlist);
- deprecate_cmd (add_com ("xbreak", class_breakpoint,
- break_at_finish_command,
- concat ("Set breakpoint at procedure exit. \n\
-Argument may be function name, or \"*\" and an address.\n\
-If function is specified, break at end of code for that function.\n\
-If an address is specified, break at the end of the function that contains \n\
-that exact address.\n",
- "With no arg, uses current execution address of selected stack frame.\n\
-This is useful for breaking on return to a stack frame.\n\
-\n\
-Multiple breakpoints at one place are permitted, and useful if conditional.\n\
-\n\
-Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL)), NULL);
- deprecate_cmd (add_com_alias ("xb", "xbreak", class_breakpoint, 1), NULL);
- deprecate_cmd (add_com_alias ("xbr", "xbreak", class_breakpoint, 1), NULL);
- deprecate_cmd (add_com_alias ("xbre", "xbreak", class_breakpoint, 1), NULL);
- deprecate_cmd (add_com_alias ("xbrea", "xbreak", class_breakpoint, 1), NULL);
-
- deprecate_cmd (c = add_com ("txbreak", class_breakpoint,
- tbreak_at_finish_command,
-"Set temporary breakpoint at procedure exit. Either there should\n\
-be no argument or the argument must be a depth.\n"), NULL);
- set_cmd_completer (c, location_completer);
-
- if (xdb_commands)
- deprecate_cmd (add_com ("bx", class_breakpoint,
- break_at_finish_at_depth_command,
-"Set breakpoint at procedure exit. Either there should\n\
-be no argument or the argument must be a depth.\n"), NULL);
+ /* Debug this files internals. */
+ add_setshow_boolean_cmd ("hppa", class_maintenance, &hppa_debug, _("\
+Set whether hppa target specific debugging information should be displayed."),
+ _("\
+Show whether hppa target specific debugging information is displayed."), _("\
+This flag controls whether hppa target specific debugging information is\n\
+displayed. This information is particularly useful for debugging frame\n\
+unwinding problems."),
+ NULL,
+ NULL, /* FIXME: i18n: hppa debug flag is %s. */
+ &setdebuglist, &showdebuglist);
}
-
projects / deliverable / binutils-gdb.git / blobdiff