#include "defs.h"
#include "gdbcore.h"
#include "osabi.h"
#include "target.h"
#include "objfiles.h"
#include "solib-svr4.h"
#include "glibc-tdep.h"
#include "frame-unwind.h"
#include "trad-frame.h"
#include "dwarf2-frame.h"
#include "value.h"
#include "hppa-tdep.h"
#include "elf/common.h"
#if 0
static int
hppa_dwarf_reg_to_regnum (int reg)
{
if (reg < 32)
return reg;
if (reg >= 32 && reg <= 85)
return HPPA_FP4_REGNUM + (reg - 32);
warning (_("Unmapped DWARF Register #%d encountered."), reg);
return -1;
}
#endif
static void
hppa_linux_target_write_pc (CORE_ADDR v, ptid_t ptid)
{
write_register_pid (HPPA_PCOQ_HEAD_REGNUM, v | 0x3, ptid);
write_register_pid (HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3, ptid);
}
struct insn_pattern
{
unsigned int data;
unsigned int mask;
};
static struct insn_pattern hppa_long_branch_stub[] = {
{ 0x20200000, 0xffe00000 },
{ 0xe0202002, 0xffe02002 },
{ 0, 0 }
};
static struct insn_pattern hppa_long_branch_pic_stub[] = {
{ 0xe8200000, 0xffe00000 },
{ 0x28200000, 0xffe00000 },
{ 0xe0202002, 0xffe02002 },
{ 0, 0 }
};
static struct insn_pattern hppa_import_stub[] = {
{ 0x2b600000, 0xffe00000 },
{ 0x48350000, 0xffffb000 },
{ 0xeaa0c000, 0xffffffff },
{ 0x48330000, 0xffffb000 },
{ 0, 0 }
};
static struct insn_pattern hppa_import_pic_stub[] = {
{ 0x2a600000, 0xffe00000 },
{ 0x48350000, 0xffffb000 },
{ 0xeaa0c000, 0xffffffff },
{ 0x48330000, 0xffffb000 },
{ 0, 0 },
};
static struct insn_pattern hppa_plt_stub[] = {
{ 0xea9f1fdd, 0xffffffff },
{ 0xd6801c1e, 0xffffffff },
{ 0, 0 }
};
static struct insn_pattern hppa_sigtramp[] = {
{ 0x34190000, 0xfffffffd },
{ 0x3414015a, 0xffffffff },
{ 0xe4008200, 0xffffffff },
{ 0x08000240, 0xffffffff },
{ 0, 0 }
};
#define HPPA_MAX_INSN_PATTERN_LEN (4)
static int
insns_match_pattern (CORE_ADDR pc,
struct insn_pattern *pattern,
unsigned int *insn)
{
int i;
CORE_ADDR npc = pc;
for (i = 0; pattern[i].mask; i++)
{
char buf[4];
deprecated_read_memory_nobpt (npc, buf, 4);
insn[i] = extract_unsigned_integer (buf, 4);
if ((insn[i] & pattern[i].mask) == pattern[i].data)
npc += 4;
else
return 0;
}
return 1;
}
static int
insns_match_pattern_relaxed (CORE_ADDR pc,
struct insn_pattern *pattern,
unsigned int *insn)
{
int pat_len = 0;
int offset;
while (pattern[pat_len].mask)
pat_len++;
for (offset = 0; offset < pat_len; offset++)
{
if (insns_match_pattern (pc - offset * 4,
pattern, insn))
return 1;
}
return 0;
}
static int
hppa_linux_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;
}
static int
hppa_linux_in_solib_call_trampoline (CORE_ADDR pc, char *name)
{
unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
int r;
struct unwind_table_entry *u;
u = find_unwind_entry (pc);
r = in_plt_section (pc, name)
|| hppa_linux_in_dyncall (pc)
|| (u == NULL
&& (insns_match_pattern_relaxed (pc, hppa_import_stub, insn)
|| insns_match_pattern_relaxed (pc, hppa_import_pic_stub, insn)
|| insns_match_pattern_relaxed (pc, hppa_long_branch_stub, insn)
|| insns_match_pattern_relaxed (pc, hppa_long_branch_pic_stub, insn)));
return r;
}
static CORE_ADDR
hppa_linux_skip_trampoline_code (CORE_ADDR pc)
{
unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
int dp_rel, pic_rel;
if (hppa_linux_in_dyncall (pc))
{
pc = (CORE_ADDR) read_register (22);
if (pc & 0x2)
pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8);
return pc;
}
dp_rel = pic_rel = 0;
if ((dp_rel = insns_match_pattern (pc, hppa_import_stub, insn))
|| (pic_rel = insns_match_pattern (pc, hppa_import_pic_stub, insn)))
{
pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]);
if (dp_rel)
pc += (CORE_ADDR) read_register (27);
else
pc += (CORE_ADDR) read_register (19);
}
if (in_plt_section (pc, NULL))
{
pc = (CORE_ADDR) read_memory_integer (pc, TARGET_PTR_BIT / 8);
if (in_plt_section (pc, NULL))
{
if (insns_match_pattern (pc, hppa_plt_stub, insn))
{
pc = (CORE_ADDR) read_memory_integer (pc + 8, TARGET_PTR_BIT / 8);
}
else
{
error (_("Cannot resolve plt stub at 0x%s."),
paddr_nz (pc));
pc = 0;
}
}
}
return pc;
}
static CORE_ADDR
hppa_linux_sigtramp_find_sigcontext (CORE_ADDR pc)
{
unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN];
int offs = 0;
int try;
static int pcoffs[] = { 0, 4*4, 5*4 };
static int sfoffs[] = { 4*4, 10*4, 10*4 };
CORE_ADDR sp;
sp = align_down (pc, 64);
for (try = 0; try < ARRAY_SIZE (pcoffs); try++)
{
if (insns_match_pattern (sp + pcoffs[try], hppa_sigtramp, dummy))
{
offs = sfoffs[try];
break;
}
}
if (offs == 0)
{
if (insns_match_pattern (pc, hppa_sigtramp, dummy))
{
try = 2;
sp = pc - pcoffs[try];
}
else
{
return 0;
}
}
return sp + sfoffs[try] + 128 + 24;
}
struct hppa_linux_sigtramp_unwind_cache
{
CORE_ADDR base;
struct trad_frame_saved_reg *saved_regs;
};
static struct hppa_linux_sigtramp_unwind_cache *
hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (next_frame);
struct hppa_linux_sigtramp_unwind_cache *info;
CORE_ADDR pc, scptr;
int i;
if (*this_cache)
return *this_cache;
info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache);
*this_cache = info;
info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
pc = frame_pc_unwind (next_frame);
scptr = hppa_linux_sigtramp_find_sigcontext (pc);
scptr += 4;
scptr += 4;
for (i = 1; i < 32; i++)
{
info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr;
scptr += 4;
}
scptr += 4;
scptr += (8 * 4);
for (i = 4; i < 32; i++)
{
info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].addr = scptr;
scptr += 4;
info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].addr = scptr;
scptr += 4;
}
info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr;
scptr += 4;
info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr;
scptr += 4;
info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr;
scptr += 4;
info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr;
scptr += 4;
info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
return info;
}
static void
hppa_linux_sigtramp_frame_this_id (struct frame_info *next_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
struct hppa_linux_sigtramp_unwind_cache *info
= hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
*this_id = frame_id_build (info->base, frame_pc_unwind (next_frame));
}
static void
hppa_linux_sigtramp_frame_prev_register (struct frame_info *next_frame,
void **this_prologue_cache,
int regnum, enum opt_state *optimizedp,
enum lval_type *lvalp,
CORE_ADDR *addrp,
int *realnump, void *valuep)
{
struct hppa_linux_sigtramp_unwind_cache *info
= hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
optimizedp, lvalp, addrp, realnump, valuep);
}
static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = {
SIGTRAMP_FRAME,
hppa_linux_sigtramp_frame_this_id,
hppa_linux_sigtramp_frame_prev_register
};
static const struct frame_unwind *
hppa_linux_sigtramp_unwind_sniffer (struct frame_info *next_frame)
{
CORE_ADDR pc = frame_pc_unwind (next_frame);
if (hppa_linux_sigtramp_find_sigcontext (pc))
return &hppa_linux_sigtramp_frame_unwind;
return NULL;
}
static CORE_ADDR
hppa_linux_find_global_pointer (struct value *function)
{
struct obj_section *faddr_sect;
CORE_ADDR faddr;
faddr = value_as_address (function);
if (faddr & 2)
{
int status;
char buf[4];
faddr &= ~3;
status = target_read_memory (faddr + 4, buf, sizeof (buf));
if (status == 0)
return extract_unsigned_integer (buf, sizeof (buf));
}
if (in_plt_section (faddr, NULL))
return 0;
faddr_sect = find_pc_section (faddr);
if (faddr_sect != NULL)
{
struct obj_section *osect;
ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
{
if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
break;
}
if (osect < faddr_sect->objfile->sections_end)
{
CORE_ADDR addr;
addr = osect->addr;
while (addr < osect->endaddr)
{
int status;
LONGEST tag;
char buf[4];
status = target_read_memory (addr, buf, sizeof (buf));
if (status != 0)
break;
tag = extract_signed_integer (buf, sizeof (buf));
if (tag == DT_PLTGOT)
{
CORE_ADDR global_pointer;
status = target_read_memory (addr + 4, buf, sizeof (buf));
if (status != 0)
break;
global_pointer = extract_unsigned_integer (buf, sizeof (buf));
return global_pointer;
}
if (tag == DT_NULL)
break;
addr += 8;
}
}
}
return 0;
}
extern initialize_file_ftype _initialize_hppa_linux_tdep;
static void
hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
tdep->is_elf = 1;
tdep->find_global_pointer = hppa_linux_find_global_pointer;
set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc);
frame_unwind_append_sniffer (gdbarch, hppa_linux_sigtramp_unwind_sniffer);
set_solib_svr4_fetch_link_map_offsets
(gdbarch, svr4_ilp32_fetch_link_map_offsets);
tdep->in_solib_call_trampoline = hppa_linux_in_solib_call_trampoline;
set_gdbarch_skip_trampoline_code
(gdbarch, hppa_linux_skip_trampoline_code);
set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
set_gdbarch_long_double_bit (gdbarch, 64);
#if 0
set_gdbarch_dwarf_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
#endif
set_gdbarch_fetch_tls_load_module_address (gdbarch,
svr4_fetch_objfile_link_map);
}
void
_initialize_hppa_linux_tdep (void)
{
gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, hppa_linux_init_abi);
}