/* Target-dependent code for HP-UX on PA-RISC.
- Copyright (C) 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009
+ Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "arch-utils.h"
return 1;
minsym = lookup_minimal_symbol_by_pc (pc);
- if (minsym && strcmp (DEPRECATED_SYMBOL_NAME (minsym), ".stub") == 0)
+ if (minsym && strcmp (SYMBOL_LINKAGE_NAME (minsym), ".stub") == 0)
return 1;
/* Get the unwind descriptor corresponding to PC, return zero
if (! minsym)
return 0;
- sec = SYMBOL_BFD_SECTION (minsym);
+ sec = SYMBOL_OBJ_SECTION (minsym)->the_bfd_section;
if (bfd_get_section_vma (sec->owner, sec) <= pc
&& pc < (bfd_get_section_vma (sec->owner, sec)
static CORE_ADDR
hppa_hpux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
{
+ struct gdbarch *gdbarch = get_frame_arch (frame);
long orig_pc = pc;
long prev_inst, curr_inst, loc;
struct minimal_symbol *msym;
itself. Bit 31 has meaning too, but only for MPE. */
if (pc & 0x2)
pc = (CORE_ADDR) read_memory_integer
- (pc & ~0x3, gdbarch_ptr_bit (current_gdbarch) / 8);
+ (pc & ~0x3, gdbarch_ptr_bit (gdbarch) / 8);
}
if (pc == hppa_symbol_address("$$dyncall_external"))
{
pc = (CORE_ADDR) get_frame_register_unsigned (frame, 22);
pc = (CORE_ADDR) read_memory_integer
- (pc & ~0x3, gdbarch_ptr_bit (current_gdbarch) / 8);
+ (pc & ~0x3, gdbarch_ptr_bit (gdbarch) / 8);
}
else if (pc == hppa_symbol_address("_sr4export"))
pc = (CORE_ADDR) get_frame_register_unsigned (frame, 22);
ALL_MSYMBOLS (objfile, msymbol)
{
if (MSYMBOL_TYPE (msymbol) == mst_text
- && DEPRECATED_STREQ (DEPRECATED_SYMBOL_NAME (msymbol), DEPRECATED_SYMBOL_NAME (msym)))
+ && strcmp (SYMBOL_LINKAGE_NAME (msymbol),
+ SYMBOL_LINKAGE_NAME (msym)) == 0)
{
function_found = 1;
break;
return orig_pc == pc ? 0 : pc & ~0x3;
}
- libsym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (stubsym), NULL, NULL);
+ libsym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (stubsym), NULL, NULL);
if (libsym == NULL)
{
warning (_("Unable to find library symbol for %s."),
- DEPRECATED_SYMBOL_NAME (stubsym));
+ SYMBOL_PRINT_NAME (stubsym));
return orig_pc == pc ? 0 : pc & ~0x3;
}
{
return (read_memory_integer
(get_frame_register_unsigned (frame, HPPA_SP_REGNUM) - 24,
- gdbarch_ptr_bit (current_gdbarch) / 8)) & ~0x3;
+ gdbarch_ptr_bit (gdbarch) / 8)) & ~0x3;
}
/* What about be,n 0(sr0,%rp)? It's just another way we return to
mtsp %r1,%sr0 if we want to do sanity checking. */
return (read_memory_integer
(get_frame_register_unsigned (frame, HPPA_SP_REGNUM) - 24,
- gdbarch_ptr_bit (current_gdbarch) / 8)) & ~0x3;
+ gdbarch_ptr_bit (gdbarch) / 8)) & ~0x3;
}
/* Haven't found the branch yet, but we're still in the stub.
};
static struct hppa_hpux_sigtramp_unwind_cache *
-hppa_hpux_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
+hppa_hpux_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
void **this_cache)
{
- struct gdbarch *gdbarch = get_frame_arch (next_frame);
+ struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
struct hppa_hpux_sigtramp_unwind_cache *info;
unsigned int flag;
info = FRAME_OBSTACK_ZALLOC (struct hppa_hpux_sigtramp_unwind_cache);
*this_cache = info;
- info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
+ info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
- sp = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
+ sp = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
if (IS_32BIT_TARGET (gdbarch))
scptr = sp - 1352;
/* TODO: fp regs */
- info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
+ info->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
return info;
}
static void
-hppa_hpux_sigtramp_frame_this_id (struct frame_info *next_frame,
+hppa_hpux_sigtramp_frame_this_id (struct frame_info *this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
struct hppa_hpux_sigtramp_unwind_cache *info
- = hppa_hpux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
- *this_id = frame_id_build (info->base, frame_pc_unwind (next_frame));
+ = hppa_hpux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
+
+ *this_id = frame_id_build (info->base, get_frame_pc (this_frame));
}
-static void
-hppa_hpux_sigtramp_frame_prev_register (struct frame_info *next_frame,
+static struct value *
+hppa_hpux_sigtramp_frame_prev_register (struct frame_info *this_frame,
void **this_prologue_cache,
- int regnum, int *optimizedp,
- enum lval_type *lvalp,
- CORE_ADDR *addrp,
- int *realnump, gdb_byte *valuep)
+ int regnum)
{
struct hppa_hpux_sigtramp_unwind_cache *info
- = hppa_hpux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
- hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
- optimizedp, lvalp, addrp, realnump, valuep);
-}
+ = hppa_hpux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
-static const struct frame_unwind hppa_hpux_sigtramp_frame_unwind = {
- SIGTRAMP_FRAME,
- hppa_hpux_sigtramp_frame_this_id,
- hppa_hpux_sigtramp_frame_prev_register
-};
+ return hppa_frame_prev_register_helper (this_frame, info->saved_regs, regnum);
+}
-static const struct frame_unwind *
-hppa_hpux_sigtramp_unwind_sniffer (struct frame_info *next_frame)
+static int
+hppa_hpux_sigtramp_unwind_sniffer (const struct frame_unwind *self,
+ struct frame_info *this_frame,
+ void **this_cache)
{
struct unwind_table_entry *u;
- CORE_ADDR pc = frame_pc_unwind (next_frame);
+ CORE_ADDR pc = get_frame_pc (this_frame);
u = find_unwind_entry (pc);
gdb_byte buf[HPPA_INSN_SIZE];
unsigned long insn;
- if (!safe_frame_unwind_memory (next_frame, u->region_start,
+ if (!safe_frame_unwind_memory (this_frame, u->region_start,
buf, sizeof buf))
- return NULL;
+ return 0;
insn = extract_unsigned_integer (buf, sizeof buf);
if ((insn & 0xffe0e000) == 0xe8400000)
}
if (u && u->HP_UX_interrupt_marker)
- return &hppa_hpux_sigtramp_frame_unwind;
+ return 1;
- return NULL;
+ return 0;
}
+static const struct frame_unwind hppa_hpux_sigtramp_frame_unwind = {
+ SIGTRAMP_FRAME,
+ hppa_hpux_sigtramp_frame_this_id,
+ hppa_hpux_sigtramp_frame_prev_register,
+ NULL,
+ hppa_hpux_sigtramp_unwind_sniffer
+};
+
static CORE_ADDR
-hppa32_hpux_find_global_pointer (struct value *function)
+hppa32_hpux_find_global_pointer (struct gdbarch *gdbarch,
+ struct value *function)
{
CORE_ADDR faddr;
return extract_unsigned_integer (buf, sizeof (buf));
}
- return gdbarch_tdep (current_gdbarch)->solib_get_got_by_pc (faddr);
+ return gdbarch_tdep (gdbarch)->solib_get_got_by_pc (faddr);
}
static CORE_ADDR
-hppa64_hpux_find_global_pointer (struct value *function)
+hppa64_hpux_find_global_pointer (struct gdbarch *gdbarch,
+ struct value *function)
{
CORE_ADDR faddr;
char buf[32];
}
else
{
- return gdbarch_tdep (current_gdbarch)->solib_get_got_by_pc (faddr);
+ return gdbarch_tdep (gdbarch)->solib_get_got_by_pc (faddr);
}
}
}
static int
-hppa_hpux_sr_for_addr (CORE_ADDR addr)
+hppa_hpux_sr_for_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
{
int sr;
/* The space register to use is encoded in the top 2 bits of the address. */
- sr = addr >> (gdbarch_tdep (current_gdbarch)->bytes_per_address * 8 - 2);
+ sr = addr >> (gdbarch_tdep (gdbarch)->bytes_per_address * 8 - 2);
return sr + 4;
}
{
/* First try the lowest address in the section; we can use it as long
as it is "regular" code (i.e. not a stub) */
- u = find_unwind_entry (sec->addr);
+ u = find_unwind_entry (obj_section_addr (sec));
if (!u || u->stub_unwind.stub_type == 0)
- return sec->addr;
+ return obj_section_addr (sec);
/* Otherwise, we need to find a symbol for a regular function. We
do this by walking the list of msymbols in the objfile. The symbol
static CORE_ADDR
hppa_hpux_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp,
- CORE_ADDR funcaddr, int using_gcc,
+ CORE_ADDR funcaddr,
struct value **args, int nargs,
struct type *value_type,
CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
/* The simple case is where we call a function in the same space that we are
currently in; in that case we don't really need to do anything. */
- if (hppa_hpux_sr_for_addr (pc) == hppa_hpux_sr_for_addr (funcaddr))
+ if (hppa_hpux_sr_for_addr (gdbarch, pc)
+ == hppa_hpux_sr_for_addr (gdbarch, funcaddr))
{
/* Intraspace call. */
*bp_addr = hppa_hpux_find_dummy_bpaddr (pc);
#define HPPA_HPUX_SS_INSYSCALL 0x02
static CORE_ADDR
-hppa_hpux_read_pc (ptid_t ptid)
+hppa_hpux_read_pc (struct regcache *regcache)
{
ULONGEST flags;
/* If we're currently in a system call return the contents of %r31. */
- flags = read_register_pid (HPPA_FLAGS_REGNUM, ptid);
+ regcache_cooked_read_unsigned (regcache, HPPA_FLAGS_REGNUM, &flags);
if (flags & HPPA_HPUX_SS_INSYSCALL)
- return read_register_pid (HPPA_R31_REGNUM, ptid) & ~0x3;
+ {
+ ULONGEST pc;
+ regcache_cooked_read_unsigned (regcache, HPPA_R31_REGNUM, &pc);
+ return pc & ~0x3;
+ }
- return hppa_read_pc (ptid);
+ return hppa_read_pc (regcache);
}
static void
-hppa_hpux_write_pc (CORE_ADDR pc, ptid_t ptid)
+hppa_hpux_write_pc (struct regcache *regcache, CORE_ADDR pc)
{
ULONGEST flags;
/* If we're currently in a system call also write PC into %r31. */
- flags = read_register_pid (HPPA_FLAGS_REGNUM, ptid);
+ regcache_cooked_read_unsigned (regcache, HPPA_FLAGS_REGNUM, &flags);
if (flags & HPPA_HPUX_SS_INSYSCALL)
- write_register_pid (HPPA_R31_REGNUM, pc | 0x3, ptid);
+ regcache_cooked_write_unsigned (regcache, HPPA_R31_REGNUM, pc | 0x3);
- return hppa_write_pc (pc, ptid);
+ hppa_write_pc (regcache, pc);
}
static CORE_ADDR
/* Given the current value of the pc, check to see if it is inside a stub, and
if so, change the value of the pc to point to the caller of the stub.
- NEXT_FRAME is the next frame in the current list of frames.
+ THIS_FRAME is the current frame in the current list of frames.
BASE contains to stack frame base of the current frame.
SAVE_REGS is the register file stored in the frame cache. */
static void
-hppa_hpux_unwind_adjust_stub (struct frame_info *next_frame, CORE_ADDR base,
+hppa_hpux_unwind_adjust_stub (struct frame_info *this_frame, CORE_ADDR base,
struct trad_frame_saved_reg *saved_regs)
{
- int optimized, realreg;
- enum lval_type lval;
- CORE_ADDR addr;
- char buffer[sizeof(ULONGEST)];
- ULONGEST val;
+ struct gdbarch *gdbarch = get_frame_arch (this_frame);
+ struct value *pcoq_head_val;
+ ULONGEST pcoq_head;
CORE_ADDR stubpc;
struct unwind_table_entry *u;
- trad_frame_get_prev_register (next_frame, saved_regs,
- HPPA_PCOQ_HEAD_REGNUM,
- &optimized, &lval, &addr, &realreg, buffer);
- val = extract_unsigned_integer (buffer,
- register_size (get_frame_arch (next_frame),
- HPPA_PCOQ_HEAD_REGNUM));
+ pcoq_head_val = trad_frame_get_prev_register (this_frame, saved_regs,
+ HPPA_PCOQ_HEAD_REGNUM);
+ pcoq_head =
+ extract_unsigned_integer (value_contents_all (pcoq_head_val),
+ register_size (gdbarch, HPPA_PCOQ_HEAD_REGNUM));
- u = find_unwind_entry (val);
+ u = find_unwind_entry (pcoq_head);
if (u && u->stub_unwind.stub_type == EXPORT)
{
- stubpc = read_memory_integer
- (base - 24, gdbarch_ptr_bit (current_gdbarch) / 8);
+ stubpc = read_memory_integer (base - 24, gdbarch_ptr_bit (gdbarch) / 8);
trad_frame_set_value (saved_regs, HPPA_PCOQ_HEAD_REGNUM, stubpc);
}
else if (hppa_symbol_address ("__gcc_plt_call")
- == get_pc_function_start (val))
+ == get_pc_function_start (pcoq_head))
{
stubpc = read_memory_integer
- (base - 8, gdbarch_ptr_bit (current_gdbarch) / 8);
+ (base - 8, gdbarch_ptr_bit (gdbarch) / 8);
trad_frame_set_value (saved_regs, HPPA_PCOQ_HEAD_REGNUM, stubpc);
}
}
set_gdbarch_regset_from_core_section
(gdbarch, hppa_hpux_regset_from_core_section);
- frame_unwind_append_sniffer (gdbarch, hppa_hpux_sigtramp_unwind_sniffer);
+ frame_unwind_append_unwinder (gdbarch, &hppa_hpux_sigtramp_frame_unwind);
}
static void
tdep->find_global_pointer = hppa32_hpux_find_global_pointer;
hppa_hpux_init_abi (info, gdbarch);
- som_solib_select (tdep);
+ som_solib_select (gdbarch);
}
static void
tdep->find_global_pointer = hppa64_hpux_find_global_pointer;
hppa_hpux_init_abi (info, gdbarch);
- pa64_solib_select (tdep);
+ pa64_solib_select (gdbarch);
}
static enum gdb_osabi