mirrors/binutils-gdb
1
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-11-25 19:14:52 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
5f8363d924
binutils-gdb/gdbserver/linux-ppc-low.cc
Joel Brobecker 4a94e36819 Automatic Copyright Year update after running gdb/copyright.py 
This commit brings all the changes made by running gdb/copyright.py
as per GDB's Start of New Year Procedure.

For the avoidance of doubt, all changes in this commits were
performed by the script.
2022-01-01 19:13:23 +04:00

3483 lines
88 KiB
C++
Raw Blame History

/* GNU/Linux/PowerPC specific low level interface, for the remote server for
GDB.
Copyright (C) 1995-2022 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 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "server.h"
#include "linux-low.h"
#include "elf/common.h"
#include <sys/uio.h>
#include <elf.h>
#include <asm/ptrace.h>
#include "arch/ppc-linux-common.h"
#include "arch/ppc-linux-tdesc.h"
#include "nat/ppc-linux.h"
#include "nat/linux-ptrace.h"
#include "linux-ppc-tdesc-init.h"
#include "ax.h"
#include "tracepoint.h"
#define PPC_FIELD(value, from, len) \
(((value) >> (32 - (from) - (len))) & ((1 << (len)) - 1))
#define PPC_SEXT(v, bs) \
((((CORE_ADDR) (v) & (((CORE_ADDR) 1 << (bs)) - 1)) \
^ ((CORE_ADDR) 1 << ((bs) - 1))) \
- ((CORE_ADDR) 1 << ((bs) - 1)))
#define PPC_OP6(insn) PPC_FIELD (insn, 0, 6)
#define PPC_BO(insn) PPC_FIELD (insn, 6, 5)
#define PPC_LI(insn) (PPC_SEXT (PPC_FIELD (insn, 6, 24), 24) << 2)
#define PPC_BD(insn) (PPC_SEXT (PPC_FIELD (insn, 16, 14), 14) << 2)
/* Linux target op definitions for the PowerPC architecture. */
class ppc_target : public linux_process_target
{
public:
const regs_info *get_regs_info () override;
const gdb_byte *sw_breakpoint_from_kind (int kind, int *size) override;
bool supports_z_point_type (char z_type) override;
void low_collect_ptrace_register (regcache *regcache, int regno,
char *buf) override;
void low_supply_ptrace_register (regcache *regcache, int regno,
const char *buf) override;
bool supports_tracepoints () override;
bool supports_fast_tracepoints () override;
int install_fast_tracepoint_jump_pad
(CORE_ADDR tpoint, CORE_ADDR tpaddr, CORE_ADDR collector,
CORE_ADDR lockaddr, ULONGEST orig_size, CORE_ADDR *jump_entry,
CORE_ADDR *trampoline, ULONGEST *trampoline_size,
unsigned char *jjump_pad_insn, ULONGEST *jjump_pad_insn_size,
CORE_ADDR *adjusted_insn_addr, CORE_ADDR *adjusted_insn_addr_end,
char *err) override;
int get_min_fast_tracepoint_insn_len () override;
struct emit_ops *emit_ops () override;
int get_ipa_tdesc_idx () override;
protected:
void low_arch_setup () override;
bool low_cannot_fetch_register (int regno) override;
bool low_cannot_store_register (int regno) override;
bool low_supports_breakpoints () override;
CORE_ADDR low_get_pc (regcache *regcache) override;
void low_set_pc (regcache *regcache, CORE_ADDR newpc) override;
bool low_breakpoint_at (CORE_ADDR pc) override;
int low_insert_point (raw_bkpt_type type, CORE_ADDR addr,
int size, raw_breakpoint *bp) override;
int low_remove_point (raw_bkpt_type type, CORE_ADDR addr,
int size, raw_breakpoint *bp) override;
int low_get_thread_area (int lwpid, CORE_ADDR *addrp) override;
};
/* The singleton target ops object. */
static ppc_target the_ppc_target;
/* Holds the AT_HWCAP auxv entry. */
static unsigned long ppc_hwcap;
/* Holds the AT_HWCAP2 auxv entry. */
static unsigned long ppc_hwcap2;
#define ppc_num_regs 73
#ifdef __powerpc64__
/* We use a constant for FPSCR instead of PT_FPSCR, because
many shipped PPC64 kernels had the wrong value in ptrace.h. */
static int ppc_regmap[] =
{PT_R0 * 8, PT_R1 * 8, PT_R2 * 8, PT_R3 * 8,
PT_R4 * 8, PT_R5 * 8, PT_R6 * 8, PT_R7 * 8,
PT_R8 * 8, PT_R9 * 8, PT_R10 * 8, PT_R11 * 8,
PT_R12 * 8, PT_R13 * 8, PT_R14 * 8, PT_R15 * 8,
PT_R16 * 8, PT_R17 * 8, PT_R18 * 8, PT_R19 * 8,
PT_R20 * 8, PT_R21 * 8, PT_R22 * 8, PT_R23 * 8,
PT_R24 * 8, PT_R25 * 8, PT_R26 * 8, PT_R27 * 8,
PT_R28 * 8, PT_R29 * 8, PT_R30 * 8, PT_R31 * 8,
PT_FPR0*8, PT_FPR0*8 + 8, PT_FPR0*8+16, PT_FPR0*8+24,
PT_FPR0*8+32, PT_FPR0*8+40, PT_FPR0*8+48, PT_FPR0*8+56,
PT_FPR0*8+64, PT_FPR0*8+72, PT_FPR0*8+80, PT_FPR0*8+88,
PT_FPR0*8+96, PT_FPR0*8+104, PT_FPR0*8+112, PT_FPR0*8+120,
PT_FPR0*8+128, PT_FPR0*8+136, PT_FPR0*8+144, PT_FPR0*8+152,
PT_FPR0*8+160, PT_FPR0*8+168, PT_FPR0*8+176, PT_FPR0*8+184,
PT_FPR0*8+192, PT_FPR0*8+200, PT_FPR0*8+208, PT_FPR0*8+216,
PT_FPR0*8+224, PT_FPR0*8+232, PT_FPR0*8+240, PT_FPR0*8+248,
PT_NIP * 8, PT_MSR * 8, PT_CCR * 8, PT_LNK * 8,
PT_CTR * 8, PT_XER * 8, PT_FPR0*8 + 256,
PT_ORIG_R3 * 8, PT_TRAP * 8 };
#else
/* Currently, don't check/send MQ. */
static int ppc_regmap[] =
{PT_R0 * 4, PT_R1 * 4, PT_R2 * 4, PT_R3 * 4,
PT_R4 * 4, PT_R5 * 4, PT_R6 * 4, PT_R7 * 4,
PT_R8 * 4, PT_R9 * 4, PT_R10 * 4, PT_R11 * 4,
PT_R12 * 4, PT_R13 * 4, PT_R14 * 4, PT_R15 * 4,
PT_R16 * 4, PT_R17 * 4, PT_R18 * 4, PT_R19 * 4,
PT_R20 * 4, PT_R21 * 4, PT_R22 * 4, PT_R23 * 4,
PT_R24 * 4, PT_R25 * 4, PT_R26 * 4, PT_R27 * 4,
PT_R28 * 4, PT_R29 * 4, PT_R30 * 4, PT_R31 * 4,
PT_FPR0*4, PT_FPR0*4 + 8, PT_FPR0*4+16, PT_FPR0*4+24,
PT_FPR0*4+32, PT_FPR0*4+40, PT_FPR0*4+48, PT_FPR0*4+56,
PT_FPR0*4+64, PT_FPR0*4+72, PT_FPR0*4+80, PT_FPR0*4+88,
PT_FPR0*4+96, PT_FPR0*4+104, PT_FPR0*4+112, PT_FPR0*4+120,
PT_FPR0*4+128, PT_FPR0*4+136, PT_FPR0*4+144, PT_FPR0*4+152,
PT_FPR0*4+160, PT_FPR0*4+168, PT_FPR0*4+176, PT_FPR0*4+184,
PT_FPR0*4+192, PT_FPR0*4+200, PT_FPR0*4+208, PT_FPR0*4+216,
PT_FPR0*4+224, PT_FPR0*4+232, PT_FPR0*4+240, PT_FPR0*4+248,
PT_NIP * 4, PT_MSR * 4, PT_CCR * 4, PT_LNK * 4,
PT_CTR * 4, PT_XER * 4, PT_FPSCR * 4,
PT_ORIG_R3 * 4, PT_TRAP * 4
};
static int ppc_regmap_e500[] =
{PT_R0 * 4, PT_R1 * 4, PT_R2 * 4, PT_R3 * 4,
PT_R4 * 4, PT_R5 * 4, PT_R6 * 4, PT_R7 * 4,
PT_R8 * 4, PT_R9 * 4, PT_R10 * 4, PT_R11 * 4,
PT_R12 * 4, PT_R13 * 4, PT_R14 * 4, PT_R15 * 4,
PT_R16 * 4, PT_R17 * 4, PT_R18 * 4, PT_R19 * 4,
PT_R20 * 4, PT_R21 * 4, PT_R22 * 4, PT_R23 * 4,
PT_R24 * 4, PT_R25 * 4, PT_R26 * 4, PT_R27 * 4,
PT_R28 * 4, PT_R29 * 4, PT_R30 * 4, PT_R31 * 4,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
PT_NIP * 4, PT_MSR * 4, PT_CCR * 4, PT_LNK * 4,
PT_CTR * 4, PT_XER * 4, -1,
PT_ORIG_R3 * 4, PT_TRAP * 4
};
#endif
/* Check whether the kernel provides a register set with number
REGSET_ID of size REGSETSIZE for process/thread TID. */
static int
ppc_check_regset (int tid, int regset_id, int regsetsize)
{
void *buf = alloca (regsetsize);
struct iovec iov;
iov.iov_base = buf;
iov.iov_len = regsetsize;
if (ptrace (PTRACE_GETREGSET, tid, regset_id, &iov) >= 0
|| errno == ENODATA)
return 1;
return 0;
}
bool
ppc_target::low_cannot_store_register (int regno)
{
const struct target_desc *tdesc = current_process ()->tdesc;
#ifndef __powerpc64__
/* Some kernels do not allow us to store fpscr. */
if (!(ppc_hwcap & PPC_FEATURE_HAS_SPE)
&& regno == find_regno (tdesc, "fpscr"))
return true;
#endif
/* Some kernels do not allow us to store orig_r3 or trap. */
if (regno == find_regno (tdesc, "orig_r3")
|| regno == find_regno (tdesc, "trap"))
return true;
return false;
}
bool
ppc_target::low_cannot_fetch_register (int regno)
{
return false;
}
void
ppc_target::low_collect_ptrace_register (regcache *regcache, int regno,
char *buf)
{
memset (buf, 0, sizeof (long));
if (__BYTE_ORDER == __LITTLE_ENDIAN)
{
/* Little-endian values always sit at the left end of the buffer. */
collect_register (regcache, regno, buf);
}
else if (__BYTE_ORDER == __BIG_ENDIAN)
{
/* Big-endian values sit at the right end of the buffer. In case of
registers whose sizes are smaller than sizeof (long), we must use a
padding to access them correctly. */
int size = register_size (regcache->tdesc, regno);
if (size < sizeof (long))
collect_register (regcache, regno, buf + sizeof (long) - size);
else
collect_register (regcache, regno, buf);
}
else
perror_with_name ("Unexpected byte order");
}
void
ppc_target::low_supply_ptrace_register (regcache *regcache, int regno,
const char *buf)
{
if (__BYTE_ORDER == __LITTLE_ENDIAN)
{
/* Little-endian values always sit at the left end of the buffer. */
supply_register (regcache, regno, buf);
}
else if (__BYTE_ORDER == __BIG_ENDIAN)
{
/* Big-endian values sit at the right end of the buffer. In case of
registers whose sizes are smaller than sizeof (long), we must use a
padding to access them correctly. */
int size = register_size (regcache->tdesc, regno);
if (size < sizeof (long))
supply_register (regcache, regno, buf + sizeof (long) - size);
else
supply_register (regcache, regno, buf);
}
else
perror_with_name ("Unexpected byte order");
}
bool
ppc_target::low_supports_breakpoints ()
{
return true;
}
CORE_ADDR
ppc_target::low_get_pc (regcache *regcache)
{
if (register_size (regcache->tdesc, 0) == 4)
{
unsigned int pc;
collect_register_by_name (regcache, "pc", &pc);
return (CORE_ADDR) pc;
}
else
{
unsigned long pc;
collect_register_by_name (regcache, "pc", &pc);
return (CORE_ADDR) pc;
}
}
void
ppc_target::low_set_pc (regcache *regcache, CORE_ADDR pc)
{
if (register_size (regcache->tdesc, 0) == 4)
{
unsigned int newpc = pc;
supply_register_by_name (regcache, "pc", &newpc);
}
else
{
unsigned long newpc = pc;
supply_register_by_name (regcache, "pc", &newpc);
}
}
#ifndef __powerpc64__
static int ppc_regmap_adjusted;
#endif
/* Correct in either endianness.
This instruction is "twge r2, r2", which GDB uses as a software
breakpoint. */
static const unsigned int ppc_breakpoint = 0x7d821008;
#define ppc_breakpoint_len 4
/* Implementation of target ops method "sw_breakpoint_from_kind". */
const gdb_byte *
ppc_target::sw_breakpoint_from_kind (int kind, int *size)
{
*size = ppc_breakpoint_len;
return (const gdb_byte *) &ppc_breakpoint;
}
bool
ppc_target::low_breakpoint_at (CORE_ADDR where)
{
unsigned int insn;
read_memory (where, (unsigned char *) &insn, 4);
if (insn == ppc_breakpoint)
return true;
/* If necessary, recognize more trap instructions here. GDB only uses
the one. */
return false;
}
/* Implement supports_z_point_type target-ops.
Returns true if type Z_TYPE breakpoint is supported.
Handling software breakpoint at server side, so tracepoints
and breakpoints can be inserted at the same location. */
bool
ppc_target::supports_z_point_type (char z_type)
{
switch (z_type)
{
case Z_PACKET_SW_BP:
return true;
case Z_PACKET_HW_BP:
case Z_PACKET_WRITE_WP:
case Z_PACKET_ACCESS_WP:
default:
return false;
}
}
/* Implement the low_insert_point linux target op.
Returns 0 on success, -1 on failure and 1 on unsupported. */
int
ppc_target::low_insert_point (raw_bkpt_type type, CORE_ADDR addr,
int size, raw_breakpoint *bp)
{
switch (type)
{
case raw_bkpt_type_sw:
return insert_memory_breakpoint (bp);
case raw_bkpt_type_hw:
case raw_bkpt_type_write_wp:
case raw_bkpt_type_access_wp:
default:
/* Unsupported. */
return 1;
}
}
/* Implement the low_remove_point linux target op.
Returns 0 on success, -1 on failure and 1 on unsupported. */
int
ppc_target::low_remove_point (raw_bkpt_type type, CORE_ADDR addr,
int size, raw_breakpoint *bp)
{
switch (type)
{
case raw_bkpt_type_sw:
return remove_memory_breakpoint (bp);
case raw_bkpt_type_hw:
case raw_bkpt_type_write_wp:
case raw_bkpt_type_access_wp:
default:
/* Unsupported. */
return 1;
}
}
/* Provide only a fill function for the general register set. ps_lgetregs
will use this for NPTL support. */
static void ppc_fill_gregset (struct regcache *regcache, void *buf)
{
int i;
ppc_target *my_ppc_target = (ppc_target *) the_linux_target;
for (i = 0; i < 32; i++)
my_ppc_target->low_collect_ptrace_register (regcache, i,
(char *) buf + ppc_regmap[i]);
for (i = 64; i < 70; i++)
my_ppc_target->low_collect_ptrace_register (regcache, i,
(char *) buf + ppc_regmap[i]);
for (i = 71; i < 73; i++)
my_ppc_target->low_collect_ptrace_register (regcache, i,
(char *) buf + ppc_regmap[i]);
}
/* Program Priority Register regset fill function. */
static void
ppc_fill_pprregset (struct regcache *regcache, void *buf)
{
char *ppr = (char *) buf;
collect_register_by_name (regcache, "ppr", ppr);
}
/* Program Priority Register regset store function. */
static void
ppc_store_pprregset (struct regcache *regcache, const void *buf)
{
const char *ppr = (const char *) buf;
supply_register_by_name (regcache, "ppr", ppr);
}
/* Data Stream Control Register regset fill function. */
static void
ppc_fill_dscrregset (struct regcache *regcache, void *buf)
{
char *dscr = (char *) buf;
collect_register_by_name (regcache, "dscr", dscr);
}
/* Data Stream Control Register regset store function. */
static void
ppc_store_dscrregset (struct regcache *regcache, const void *buf)
{
const char *dscr = (const char *) buf;
supply_register_by_name (regcache, "dscr", dscr);
}
/* Target Address Register regset fill function. */
static void
ppc_fill_tarregset (struct regcache *regcache, void *buf)
{
char *tar = (char *) buf;
collect_register_by_name (regcache, "tar", tar);
}
/* Target Address Register regset store function. */
static void
ppc_store_tarregset (struct regcache *regcache, const void *buf)
{
const char *tar = (const char *) buf;
supply_register_by_name (regcache, "tar", tar);
}
/* Event-Based Branching regset store function. Unless the inferior
has a perf event open, ptrace can return in error when reading and
writing to the regset, with ENODATA. For reading, the registers
will correctly show as unavailable. For writing, gdbserver
currently only caches any register writes from P and G packets and
the stub always tries to write all the regsets when resuming the
inferior, which would result in frequent warnings. For this
reason, we don't define a fill function. This also means that the
client-side regcache will be dirty if the user tries to write to
the EBB registers. G packets that the client sends to write to
unrelated registers will also include data for EBB registers, even
if they are unavailable. */
static void
ppc_store_ebbregset (struct regcache *regcache, const void *buf)
{
const char *regset = (const char *) buf;
/* The order in the kernel regset is: EBBRR, EBBHR, BESCR. In the
.dat file is BESCR, EBBHR, EBBRR. */
supply_register_by_name (regcache, "ebbrr", &regset[0]);
supply_register_by_name (regcache, "ebbhr", &regset[8]);
supply_register_by_name (regcache, "bescr", &regset[16]);
}
/* Performance Monitoring Unit regset fill function. */
static void
ppc_fill_pmuregset (struct regcache *regcache, void *buf)
{
char *regset = (char *) buf;
/* The order in the kernel regset is SIAR, SDAR, SIER, MMCR2, MMCR0.
In the .dat file is MMCR0, MMCR2, SIAR, SDAR, SIER. */
collect_register_by_name (regcache, "siar", &regset[0]);
collect_register_by_name (regcache, "sdar", &regset[8]);
collect_register_by_name (regcache, "sier", &regset[16]);
collect_register_by_name (regcache, "mmcr2", &regset[24]);
collect_register_by_name (regcache, "mmcr0", &regset[32]);
}
/* Performance Monitoring Unit regset store function. */
static void
ppc_store_pmuregset (struct regcache *regcache, const void *buf)
{
const char *regset = (const char *) buf;
supply_register_by_name (regcache, "siar", &regset[0]);
supply_register_by_name (regcache, "sdar", &regset[8]);
supply_register_by_name (regcache, "sier", &regset[16]);
supply_register_by_name (regcache, "mmcr2", &regset[24]);
supply_register_by_name (regcache, "mmcr0", &regset[32]);
}
/* Hardware Transactional Memory special-purpose register regset fill
function. */
static void
ppc_fill_tm_sprregset (struct regcache *regcache, void *buf)
{
int i, base;
char *regset = (char *) buf;
base = find_regno (regcache->tdesc, "tfhar");
for (i = 0; i < 3; i++)
collect_register (regcache, base + i, &regset[i * 8]);
}
/* Hardware Transactional Memory special-purpose register regset store
function. */
static void
ppc_store_tm_sprregset (struct regcache *regcache, const void *buf)
{
int i, base;
const char *regset = (const char *) buf;
base = find_regno (regcache->tdesc, "tfhar");
for (i = 0; i < 3; i++)
supply_register (regcache, base + i, &regset[i * 8]);
}
/* For the same reasons as the EBB regset, none of the HTM
checkpointed regsets have a fill function. These registers are
only available if the inferior is in a transaction. */
/* Hardware Transactional Memory checkpointed general-purpose regset
store function. */
static void
ppc_store_tm_cgprregset (struct regcache *regcache, const void *buf)
{
int i, base, size, endian_offset;
const char *regset = (const char *) buf;
base = find_regno (regcache->tdesc, "cr0");
size = register_size (regcache->tdesc, base);
gdb_assert (size == 4 || size == 8);
for (i = 0; i < 32; i++)
supply_register (regcache, base + i, &regset[i * size]);
endian_offset = 0;
if ((size == 8) && (__BYTE_ORDER == __BIG_ENDIAN))
endian_offset = 4;
supply_register_by_name (regcache, "ccr",
&regset[PT_CCR * size + endian_offset]);
supply_register_by_name (regcache, "cxer",
&regset[PT_XER * size + endian_offset]);
supply_register_by_name (regcache, "clr", &regset[PT_LNK * size]);
supply_register_by_name (regcache, "cctr", &regset[PT_CTR * size]);
}
/* Hardware Transactional Memory checkpointed floating-point regset
store function. */
static void
ppc_store_tm_cfprregset (struct regcache *regcache, const void *buf)
{
int i, base;
const char *regset = (const char *) buf;
base = find_regno (regcache->tdesc, "cf0");
for (i = 0; i < 32; i++)
supply_register (regcache, base + i, &regset[i * 8]);
supply_register_by_name (regcache, "cfpscr", &regset[32 * 8]);
}
/* Hardware Transactional Memory checkpointed vector regset store
function. */
static void
ppc_store_tm_cvrregset (struct regcache *regcache, const void *buf)
{
int i, base;
const char *regset = (const char *) buf;
int vscr_offset = 0;
base = find_regno (regcache->tdesc, "cvr0");
for (i = 0; i < 32; i++)
supply_register (regcache, base + i, &regset[i * 16]);
if (__BYTE_ORDER == __BIG_ENDIAN)
vscr_offset = 12;
supply_register_by_name (regcache, "cvscr",
&regset[32 * 16 + vscr_offset]);
supply_register_by_name (regcache, "cvrsave", &regset[33 * 16]);
}
/* Hardware Transactional Memory checkpointed vector-scalar regset
store function. */
static void
ppc_store_tm_cvsxregset (struct regcache *regcache, const void *buf)
{
int i, base;
const char *regset = (const char *) buf;
base = find_regno (regcache->tdesc, "cvs0h");
for (i = 0; i < 32; i++)
supply_register (regcache, base + i, &regset[i * 8]);
}
/* Hardware Transactional Memory checkpointed Program Priority
Register regset store function. */
static void
ppc_store_tm_cpprregset (struct regcache *regcache, const void *buf)
{
const char *cppr = (const char *) buf;
supply_register_by_name (regcache, "cppr", cppr);
}
/* Hardware Transactional Memory checkpointed Data Stream Control
Register regset store function. */
static void
ppc_store_tm_cdscrregset (struct regcache *regcache, const void *buf)
{
const char *cdscr = (const char *) buf;
supply_register_by_name (regcache, "cdscr", cdscr);
}
/* Hardware Transactional Memory checkpointed Target Address Register
regset store function. */
static void
ppc_store_tm_ctarregset (struct regcache *regcache, const void *buf)
{
const char *ctar = (const char *) buf;
supply_register_by_name (regcache, "ctar", ctar);
}
static void
ppc_fill_vsxregset (struct regcache *regcache, void *buf)
{
int i, base;
char *regset = (char *) buf;
base = find_regno (regcache->tdesc, "vs0h");
for (i = 0; i < 32; i++)
collect_register (regcache, base + i, &regset[i * 8]);
}
static void
ppc_store_vsxregset (struct regcache *regcache, const void *buf)
{
int i, base;
const char *regset = (const char *) buf;
base = find_regno (regcache->tdesc, "vs0h");
for (i = 0; i < 32; i++)
supply_register (regcache, base + i, &regset[i * 8]);
}
static void
ppc_fill_vrregset (struct regcache *regcache, void *buf)
{
int i, base;
char *regset = (char *) buf;
int vscr_offset = 0;
base = find_regno (regcache->tdesc, "vr0");
for (i = 0; i < 32; i++)
collect_register (regcache, base + i, &regset[i * 16]);
if (__BYTE_ORDER == __BIG_ENDIAN)
vscr_offset = 12;
collect_register_by_name (regcache, "vscr",
&regset[32 * 16 + vscr_offset]);
collect_register_by_name (regcache, "vrsave", &regset[33 * 16]);
}
static void
ppc_store_vrregset (struct regcache *regcache, const void *buf)
{
int i, base;
const char *regset = (const char *) buf;
int vscr_offset = 0;
base = find_regno (regcache->tdesc, "vr0");
for (i = 0; i < 32; i++)
supply_register (regcache, base + i, &regset[i * 16]);
if (__BYTE_ORDER == __BIG_ENDIAN)
vscr_offset = 12;
supply_register_by_name (regcache, "vscr",
&regset[32 * 16 + vscr_offset]);
supply_register_by_name (regcache, "vrsave", &regset[33 * 16]);
}
struct gdb_evrregset_t
{
unsigned long evr[32];
unsigned long long acc;
unsigned long spefscr;
};
static void
ppc_fill_evrregset (struct regcache *regcache, void *buf)
{
int i, ev0;
struct gdb_evrregset_t *regset = (struct gdb_evrregset_t *) buf;
ev0 = find_regno (regcache->tdesc, "ev0h");
for (i = 0; i < 32; i++)
collect_register (regcache, ev0 + i, &regset->evr[i]);
collect_register_by_name (regcache, "acc", &regset->acc);
collect_register_by_name (regcache, "spefscr", &regset->spefscr);
}
static void
ppc_store_evrregset (struct regcache *regcache, const void *buf)
{
int i, ev0;
const struct gdb_evrregset_t *regset = (const struct gdb_evrregset_t *) buf;
ev0 = find_regno (regcache->tdesc, "ev0h");
for (i = 0; i < 32; i++)
supply_register (regcache, ev0 + i, &regset->evr[i]);
supply_register_by_name (regcache, "acc", &regset->acc);
supply_register_by_name (regcache, "spefscr", &regset->spefscr);
}
static struct regset_info ppc_regsets[] = {
/* List the extra register sets before GENERAL_REGS. That way we will
fetch them every time, but still fall back to PTRACE_PEEKUSER for the
general registers. Some kernels support these, but not the newer
PPC_PTRACE_GETREGS. */
{ PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PPC_TM_CTAR, 0, EXTENDED_REGS,
NULL, ppc_store_tm_ctarregset },
{ PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PPC_TM_CDSCR, 0, EXTENDED_REGS,
NULL, ppc_store_tm_cdscrregset },
{ PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PPC_TM_CPPR, 0, EXTENDED_REGS,
NULL, ppc_store_tm_cpprregset },
{ PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PPC_TM_CVSX, 0, EXTENDED_REGS,
NULL, ppc_store_tm_cvsxregset },
{ PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PPC_TM_CVMX, 0, EXTENDED_REGS,
NULL, ppc_store_tm_cvrregset },
{ PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PPC_TM_CFPR, 0, EXTENDED_REGS,
NULL, ppc_store_tm_cfprregset },
{ PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PPC_TM_CGPR, 0, EXTENDED_REGS,
NULL, ppc_store_tm_cgprregset },
{ PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PPC_TM_SPR, 0, EXTENDED_REGS,
ppc_fill_tm_sprregset, ppc_store_tm_sprregset },
{ PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PPC_EBB, 0, EXTENDED_REGS,
NULL, ppc_store_ebbregset },
{ PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PPC_PMU, 0, EXTENDED_REGS,
ppc_fill_pmuregset, ppc_store_pmuregset },
{ PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PPC_TAR, 0, EXTENDED_REGS,
ppc_fill_tarregset, ppc_store_tarregset },
{ PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PPC_PPR, 0, EXTENDED_REGS,
ppc_fill_pprregset, ppc_store_pprregset },
{ PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PPC_DSCR, 0, EXTENDED_REGS,
ppc_fill_dscrregset, ppc_store_dscrregset },
{ PTRACE_GETVSXREGS, PTRACE_SETVSXREGS, 0, 0, EXTENDED_REGS,
ppc_fill_vsxregset, ppc_store_vsxregset },
{ PTRACE_GETVRREGS, PTRACE_SETVRREGS, 0, 0, EXTENDED_REGS,
ppc_fill_vrregset, ppc_store_vrregset },
{ PTRACE_GETEVRREGS, PTRACE_SETEVRREGS, 0, 0, EXTENDED_REGS,
ppc_fill_evrregset, ppc_store_evrregset },
{ 0, 0, 0, 0, GENERAL_REGS, ppc_fill_gregset, NULL },
NULL_REGSET
};
static struct usrregs_info ppc_usrregs_info =
{
ppc_num_regs,
ppc_regmap,
};
static struct regsets_info ppc_regsets_info =
{
ppc_regsets, /* regsets */
0, /* num_regsets */
NULL, /* disabled_regsets */
};
static struct regs_info myregs_info =
{
NULL, /* regset_bitmap */
&ppc_usrregs_info,
&ppc_regsets_info
};
const regs_info *
ppc_target::get_regs_info ()
{
return &myregs_info;
}
void
ppc_target::low_arch_setup ()
{
const struct target_desc *tdesc;
struct regset_info *regset;
struct ppc_linux_features features = ppc_linux_no_features;
int tid = lwpid_of (current_thread);
features.wordsize = ppc_linux_target_wordsize (tid);
if (features.wordsize == 4)
tdesc = tdesc_powerpc_32l;
else
tdesc = tdesc_powerpc_64l;
current_process ()->tdesc = tdesc;
/* The value of current_process ()->tdesc needs to be set for this
call. */
ppc_hwcap = linux_get_hwcap (features.wordsize);
ppc_hwcap2 = linux_get_hwcap2 (features.wordsize);
features.isa205 = ppc_linux_has_isa205 (ppc_hwcap);
if (ppc_hwcap & PPC_FEATURE_HAS_VSX)
features.vsx = true;
if (ppc_hwcap & PPC_FEATURE_HAS_ALTIVEC)
features.altivec = true;
if ((ppc_hwcap2 & PPC_FEATURE2_DSCR)
&& ppc_check_regset (tid, NT_PPC_DSCR, PPC_LINUX_SIZEOF_DSCRREGSET)
&& ppc_check_regset (tid, NT_PPC_PPR, PPC_LINUX_SIZEOF_PPRREGSET))
{
features.ppr_dscr = true;
if ((ppc_hwcap2 & PPC_FEATURE2_ARCH_2_07)
&& (ppc_hwcap2 & PPC_FEATURE2_TAR)
&& (ppc_hwcap2 & PPC_FEATURE2_EBB)
&& ppc_check_regset (tid, NT_PPC_TAR,
PPC_LINUX_SIZEOF_TARREGSET)
&& ppc_check_regset (tid, NT_PPC_EBB,
PPC_LINUX_SIZEOF_EBBREGSET)
&& ppc_check_regset (tid, NT_PPC_PMU,
PPC_LINUX_SIZEOF_PMUREGSET))
{
features.isa207 = true;
if ((ppc_hwcap2 & PPC_FEATURE2_HTM)
&& ppc_check_regset (tid, NT_PPC_TM_SPR,
PPC_LINUX_SIZEOF_TM_SPRREGSET))
features.htm = true;
}
}
tdesc = ppc_linux_match_description (features);
/* On 32-bit machines, check for SPE registers.
Set the low target's regmap field as appropriately. */
#ifndef __powerpc64__
if (ppc_hwcap & PPC_FEATURE_HAS_SPE)
tdesc = tdesc_powerpc_e500l;
if (!ppc_regmap_adjusted)
{
if (ppc_hwcap & PPC_FEATURE_HAS_SPE)
ppc_usrregs_info.regmap = ppc_regmap_e500;
/* If the FPSCR is 64-bit wide, we need to fetch the whole
64-bit slot and not just its second word. The PT_FPSCR
supplied in a 32-bit GDB compilation doesn't reflect
this. */
if (register_size (tdesc, 70) == 8)
ppc_regmap[70] = (48 + 2*32) * sizeof (long);
ppc_regmap_adjusted = 1;
}
#endif
current_process ()->tdesc = tdesc;
for (regset = ppc_regsets; regset->size >= 0; regset++)
switch (regset->get_request)
{
case PTRACE_GETVRREGS:
regset->size = features.altivec ? PPC_LINUX_SIZEOF_VRREGSET : 0;
break;
case PTRACE_GETVSXREGS:
regset->size = features.vsx ? PPC_LINUX_SIZEOF_VSXREGSET : 0;
break;
case PTRACE_GETEVRREGS:
if (ppc_hwcap & PPC_FEATURE_HAS_SPE)
regset->size = 32 * 4 + 8 + 4;
else
regset->size = 0;
break;
case PTRACE_GETREGSET:
switch (regset->nt_type)
{
case NT_PPC_PPR:
regset->size = (features.ppr_dscr ?
PPC_LINUX_SIZEOF_PPRREGSET : 0);
break;
case NT_PPC_DSCR:
regset->size = (features.ppr_dscr ?
PPC_LINUX_SIZEOF_DSCRREGSET : 0);
break;
case NT_PPC_TAR:
regset->size = (features.isa207 ?
PPC_LINUX_SIZEOF_TARREGSET : 0);
break;
case NT_PPC_EBB:
regset->size = (features.isa207 ?
PPC_LINUX_SIZEOF_EBBREGSET : 0);
break;
case NT_PPC_PMU:
regset->size = (features.isa207 ?
PPC_LINUX_SIZEOF_PMUREGSET : 0);
break;
case NT_PPC_TM_SPR:
regset->size = (features.htm ?
PPC_LINUX_SIZEOF_TM_SPRREGSET : 0);
break;
case NT_PPC_TM_CGPR:
if (features.wordsize == 4)
regset->size = (features.htm ?
PPC32_LINUX_SIZEOF_CGPRREGSET : 0);
else
regset->size = (features.htm ?
PPC64_LINUX_SIZEOF_CGPRREGSET : 0);
break;
case NT_PPC_TM_CFPR:
regset->size = (features.htm ?
PPC_LINUX_SIZEOF_CFPRREGSET : 0);
break;
case NT_PPC_TM_CVMX:
regset->size = (features.htm ?
PPC_LINUX_SIZEOF_CVMXREGSET : 0);
break;
case NT_PPC_TM_CVSX:
regset->size = (features.htm ?
PPC_LINUX_SIZEOF_CVSXREGSET : 0);
break;
case NT_PPC_TM_CPPR:
regset->size = (features.htm ?
PPC_LINUX_SIZEOF_CPPRREGSET : 0);
break;
case NT_PPC_TM_CDSCR:
regset->size = (features.htm ?
PPC_LINUX_SIZEOF_CDSCRREGSET : 0);
break;
case NT_PPC_TM_CTAR:
regset->size = (features.htm ?
PPC_LINUX_SIZEOF_CTARREGSET : 0);
break;
default:
break;
}
break;
default:
break;
}
}
/* Implementation of target ops method "supports_tracepoints". */
bool
ppc_target::supports_tracepoints ()
{
return true;
}
/* Get the thread area address. This is used to recognize which
thread is which when tracing with the in-process agent library. We
don't read anything from the address, and treat it as opaque; it's
the address itself that we assume is unique per-thread. */
int
ppc_target::low_get_thread_area (int lwpid, CORE_ADDR *addr)
{
struct lwp_info *lwp = find_lwp_pid (ptid_t (lwpid));
struct thread_info *thr = get_lwp_thread (lwp);
struct regcache *regcache = get_thread_regcache (thr, 1);
ULONGEST tp = 0;
#ifdef __powerpc64__
if (register_size (regcache->tdesc, 0) == 8)
collect_register_by_name (regcache, "r13", &tp);
else
#endif
collect_register_by_name (regcache, "r2", &tp);
*addr = tp;
return 0;
}
#ifdef __powerpc64__
/* Older glibc doesn't provide this. */
#ifndef EF_PPC64_ABI
#define EF_PPC64_ABI 3
#endif
/* Returns 1 if inferior is using ELFv2 ABI. Undefined for 32-bit
inferiors. */
static int
is_elfv2_inferior (void)
{
/* To be used as fallback if we're unable to determine the right result -
assume inferior uses the same ABI as gdbserver. */
#if _CALL_ELF == 2
const int def_res = 1;
#else
const int def_res = 0;
#endif
CORE_ADDR phdr;
Elf64_Ehdr ehdr;
const struct target_desc *tdesc = current_process ()->tdesc;
int wordsize = register_size (tdesc, 0);
if (!linux_get_auxv (wordsize, AT_PHDR, &phdr))
return def_res;
/* Assume ELF header is at the beginning of the page where program headers
are located. If it doesn't look like one, bail. */
read_inferior_memory (phdr & ~0xfff, (unsigned char *) &ehdr, sizeof ehdr);
if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG))
return def_res;
return (ehdr.e_flags & EF_PPC64_ABI) == 2;
}
#endif
/* Generate a ds-form instruction in BUF and return the number of bytes written
0 6 11 16 30 32
| OPCD | RST | RA | DS |XO| */
__attribute__((unused)) /* Maybe unused due to conditional compilation. */
static int
gen_ds_form (uint32_t *buf, int opcd, int rst, int ra, int ds, int xo)
{
uint32_t insn;
gdb_assert ((opcd & ~0x3f) == 0);
gdb_assert ((rst & ~0x1f) == 0);
gdb_assert ((ra & ~0x1f) == 0);
gdb_assert ((xo & ~0x3) == 0);
insn = (rst << 21) | (ra << 16) | (ds & 0xfffc) | (xo & 0x3);
*buf = (opcd << 26) | insn;
return 1;
}
/* Followings are frequently used ds-form instructions. */
#define GEN_STD(buf, rs, ra, offset) gen_ds_form (buf, 62, rs, ra, offset, 0)
#define GEN_STDU(buf, rs, ra, offset) gen_ds_form (buf, 62, rs, ra, offset, 1)
#define GEN_LD(buf, rt, ra, offset) gen_ds_form (buf, 58, rt, ra, offset, 0)
#define GEN_LDU(buf, rt, ra, offset) gen_ds_form (buf, 58, rt, ra, offset, 1)
/* Generate a d-form instruction in BUF.
0 6 11 16 32
| OPCD | RST | RA | D | */
static int
gen_d_form (uint32_t *buf, int opcd, int rst, int ra, int si)
{
uint32_t insn;
gdb_assert ((opcd & ~0x3f) == 0);
gdb_assert ((rst & ~0x1f) == 0);
gdb_assert ((ra & ~0x1f) == 0);
insn = (rst << 21) | (ra << 16) | (si & 0xffff);
*buf = (opcd << 26) | insn;
return 1;
}
/* Followings are frequently used d-form instructions. */
#define GEN_ADDI(buf, rt, ra, si) gen_d_form (buf, 14, rt, ra, si)
#define GEN_ADDIS(buf, rt, ra, si) gen_d_form (buf, 15, rt, ra, si)
#define GEN_LI(buf, rt, si) GEN_ADDI (buf, rt, 0, si)
#define GEN_LIS(buf, rt, si) GEN_ADDIS (buf, rt, 0, si)
#define GEN_ORI(buf, rt, ra, si) gen_d_form (buf, 24, rt, ra, si)
#define GEN_ORIS(buf, rt, ra, si) gen_d_form (buf, 25, rt, ra, si)
#define GEN_LWZ(buf, rt, ra, si) gen_d_form (buf, 32, rt, ra, si)
#define GEN_STW(buf, rt, ra, si) gen_d_form (buf, 36, rt, ra, si)
#define GEN_STWU(buf, rt, ra, si) gen_d_form (buf, 37, rt, ra, si)
/* Generate a xfx-form instruction in BUF and return the number of bytes
written.
0 6 11 21 31 32
| OPCD | RST | RI | XO |/| */
static int
gen_xfx_form (uint32_t *buf, int opcd, int rst, int ri, int xo)
{
uint32_t insn;
unsigned int n = ((ri & 0x1f) << 5) | ((ri >> 5) & 0x1f);
gdb_assert ((opcd & ~0x3f) == 0);
gdb_assert ((rst & ~0x1f) == 0);
gdb_assert ((xo & ~0x3ff) == 0);
insn = (rst << 21) | (n << 11) | (xo << 1);
*buf = (opcd << 26) | insn;
return 1;
}
/* Followings are frequently used xfx-form instructions. */
#define GEN_MFSPR(buf, rt, spr) gen_xfx_form (buf, 31, rt, spr, 339)
#define GEN_MTSPR(buf, rt, spr) gen_xfx_form (buf, 31, rt, spr, 467)
#define GEN_MFCR(buf, rt) gen_xfx_form (buf, 31, rt, 0, 19)
#define GEN_MTCR(buf, rt) gen_xfx_form (buf, 31, rt, 0x3cf, 144)
#define GEN_SYNC(buf, L, E) gen_xfx_form (buf, 31, L & 0x3, \
E & 0xf, 598)
#define GEN_LWSYNC(buf) GEN_SYNC (buf, 1, 0)
/* Generate a x-form instruction in BUF and return the number of bytes written.
0 6 11 16 21 31 32
| OPCD | RST | RA | RB | XO |RC| */
static int
gen_x_form (uint32_t *buf, int opcd, int rst, int ra, int rb, int xo, int rc)
{
uint32_t insn;
gdb_assert ((opcd & ~0x3f) == 0);
gdb_assert ((rst & ~0x1f) == 0);
gdb_assert ((ra & ~0x1f) == 0);
gdb_assert ((rb & ~0x1f) == 0);
gdb_assert ((xo & ~0x3ff) == 0);
gdb_assert ((rc & ~1) == 0);
insn = (rst << 21) | (ra << 16) | (rb << 11) | (xo << 1) | rc;
*buf = (opcd << 26) | insn;
return 1;
}
/* Followings are frequently used x-form instructions. */
#define GEN_OR(buf, ra, rs, rb) gen_x_form (buf, 31, rs, ra, rb, 444, 0)
#define GEN_MR(buf, ra, rs) GEN_OR (buf, ra, rs, rs)
#define GEN_LWARX(buf, rt, ra, rb) gen_x_form (buf, 31, rt, ra, rb, 20, 0)
#define GEN_STWCX(buf, rs, ra, rb) gen_x_form (buf, 31, rs, ra, rb, 150, 1)
/* Assume bf = cr7. */
#define GEN_CMPW(buf, ra, rb) gen_x_form (buf, 31, 28, ra, rb, 0, 0)
/* Generate a md-form instruction in BUF and return the number of bytes written.
0 6 11 16 21 27 30 31 32
| OPCD | RS | RA | sh | mb | XO |sh|Rc| */
static int
gen_md_form (uint32_t *buf, int opcd, int rs, int ra, int sh, int mb,
int xo, int rc)
{
uint32_t insn;
unsigned int n = ((mb & 0x1f) << 1) | ((mb >> 5) & 0x1);
unsigned int sh0_4 = sh & 0x1f;
unsigned int sh5 = (sh >> 5) & 1;
gdb_assert ((opcd & ~0x3f) == 0);
gdb_assert ((rs & ~0x1f) == 0);
gdb_assert ((ra & ~0x1f) == 0);
gdb_assert ((sh & ~0x3f) == 0);
gdb_assert ((mb & ~0x3f) == 0);
gdb_assert ((xo & ~0x7) == 0);
gdb_assert ((rc & ~0x1) == 0);
insn = (rs << 21) | (ra << 16) | (sh0_4 << 11) | (n << 5)
| (sh5 << 1) | (xo << 2) | (rc & 1);
*buf = (opcd << 26) | insn;
return 1;
}
/* The following are frequently used md-form instructions. */
#define GEN_RLDICL(buf, ra, rs ,sh, mb) \
gen_md_form (buf, 30, rs, ra, sh, mb, 0, 0)
#define GEN_RLDICR(buf, ra, rs ,sh, mb) \
gen_md_form (buf, 30, rs, ra, sh, mb, 1, 0)
/* Generate a i-form instruction in BUF and return the number of bytes written.
0 6 30 31 32
| OPCD | LI |AA|LK| */
static int
gen_i_form (uint32_t *buf, int opcd, int li, int aa, int lk)
{
uint32_t insn;
gdb_assert ((opcd & ~0x3f) == 0);
insn = (li & 0x3fffffc) | (aa & 1) | (lk & 1);
*buf = (opcd << 26) | insn;
return 1;
}
/* The following are frequently used i-form instructions. */
#define GEN_B(buf, li) gen_i_form (buf, 18, li, 0, 0)
#define GEN_BL(buf, li) gen_i_form (buf, 18, li, 0, 1)
/* Generate a b-form instruction in BUF and return the number of bytes written.
0 6 11 16 30 31 32
| OPCD | BO | BI | BD |AA|LK| */
static int
gen_b_form (uint32_t *buf, int opcd, int bo, int bi, int bd,
int aa, int lk)
{
uint32_t insn;
gdb_assert ((opcd & ~0x3f) == 0);
gdb_assert ((bo & ~0x1f) == 0);
gdb_assert ((bi & ~0x1f) == 0);
insn = (bo << 21) | (bi << 16) | (bd & 0xfffc) | (aa & 1) | (lk & 1);
*buf = (opcd << 26) | insn;
return 1;
}
/* The following are frequently used b-form instructions. */
/* Assume bi = cr7. */
#define GEN_BNE(buf, bd) gen_b_form (buf, 16, 0x4, (7 << 2) | 2, bd, 0 ,0)
/* GEN_LOAD and GEN_STORE generate 64- or 32-bit load/store for ppc64 or ppc32
respectively. They are primary used for save/restore GPRs in jump-pad,
not used for bytecode compiling. */
#ifdef __powerpc64__
#define GEN_LOAD(buf, rt, ra, si, is_64) (is_64 ? \
GEN_LD (buf, rt, ra, si) : \
GEN_LWZ (buf, rt, ra, si))
#define GEN_STORE(buf, rt, ra, si, is_64) (is_64 ? \
GEN_STD (buf, rt, ra, si) : \
GEN_STW (buf, rt, ra, si))
#else
#define GEN_LOAD(buf, rt, ra, si, is_64) GEN_LWZ (buf, rt, ra, si)
#define GEN_STORE(buf, rt, ra, si, is_64) GEN_STW (buf, rt, ra, si)
#endif
/* Generate a sequence of instructions to load IMM in the register REG.
Write the instructions in BUF and return the number of bytes written. */
static int
gen_limm (uint32_t *buf, int reg, uint64_t imm, int is_64)
{
uint32_t *p = buf;
if ((imm + 32768) < 65536)
{
/* li reg, imm[15:0] */
p += GEN_LI (p, reg, imm);
}
else if ((imm >> 32) == 0)
{
/* lis reg, imm[31:16]
ori reg, reg, imm[15:0]
rldicl reg, reg, 0, 32 */
p += GEN_LIS (p, reg, (imm >> 16) & 0xffff);
if ((imm & 0xffff) != 0)
p += GEN_ORI (p, reg, reg, imm & 0xffff);
/* Clear upper 32-bit if sign-bit is set. */
if (imm & (1u << 31) && is_64)
p += GEN_RLDICL (p, reg, reg, 0, 32);
}
else
{
gdb_assert (is_64);
/* lis reg, <imm[63:48]>
ori reg, reg, <imm[48:32]>
rldicr reg, reg, 32, 31
oris reg, reg, <imm[31:16]>
ori reg, reg, <imm[15:0]> */
p += GEN_LIS (p, reg, ((imm >> 48) & 0xffff));
if (((imm >> 32) & 0xffff) != 0)
p += GEN_ORI (p, reg, reg, ((imm >> 32) & 0xffff));
p += GEN_RLDICR (p, reg, reg, 32, 31);
if (((imm >> 16) & 0xffff) != 0)
p += GEN_ORIS (p, reg, reg, ((imm >> 16) & 0xffff));
if ((imm & 0xffff) != 0)
p += GEN_ORI (p, reg, reg, (imm & 0xffff));
}
return p - buf;
}
/* Generate a sequence for atomically exchange at location LOCK.
This code sequence clobbers r6, r7, r8. LOCK is the location for
the atomic-xchg, OLD_VALUE is expected old value stored in the
location, and R_NEW is a register for the new value. */
static int
gen_atomic_xchg (uint32_t *buf, CORE_ADDR lock, int old_value, int r_new,
int is_64)
{
const int r_lock = 6;
const int r_old = 7;
const int r_tmp = 8;
uint32_t *p = buf;
/*
1: lwarx TMP, 0, LOCK
cmpwi TMP, OLD
bne 1b
stwcx. NEW, 0, LOCK
bne 1b */
p += gen_limm (p, r_lock, lock, is_64);
p += gen_limm (p, r_old, old_value, is_64);
p += GEN_LWARX (p, r_tmp, 0, r_lock);
p += GEN_CMPW (p, r_tmp, r_old);
p += GEN_BNE (p, -8);
p += GEN_STWCX (p, r_new, 0, r_lock);
p += GEN_BNE (p, -16);
return p - buf;
}
/* Generate a sequence of instructions for calling a function
at address of FN. Return the number of bytes are written in BUF. */
static int
gen_call (uint32_t *buf, CORE_ADDR fn, int is_64, int is_opd)
{
uint32_t *p = buf;
/* Must be called by r12 for caller to calculate TOC address. */
p += gen_limm (p, 12, fn, is_64);
if (is_opd)
{
p += GEN_LOAD (p, 11, 12, 16, is_64);
p += GEN_LOAD (p, 2, 12, 8, is_64);
p += GEN_LOAD (p, 12, 12, 0, is_64);
}
p += GEN_MTSPR (p, 12, 9); /* mtctr r12 */
*p++ = 0x4e800421; /* bctrl */
return p - buf;
}
/* Copy the instruction from OLDLOC to *TO, and update *TO to *TO + size
of instruction. This function is used to adjust pc-relative instructions
when copying. */
static void
ppc_relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc)
{
uint32_t insn, op6;
long rel, newrel;
read_inferior_memory (oldloc, (unsigned char *) &insn, 4);
op6 = PPC_OP6 (insn);
if (op6 == 18 && (insn & 2) == 0)
{
/* branch && AA = 0 */
rel = PPC_LI (insn);
newrel = (oldloc - *to) + rel;
/* Out of range. Cannot relocate instruction. */
if (newrel >= (1 << 25) || newrel < -(1 << 25))
return;
insn = (insn & ~0x3fffffc) | (newrel & 0x3fffffc);
}
else if (op6 == 16 && (insn & 2) == 0)
{
/* conditional branch && AA = 0 */
/* If the new relocation is too big for even a 26-bit unconditional
branch, there is nothing we can do. Just abort.
Otherwise, if it can be fit in 16-bit conditional branch, just
copy the instruction and relocate the address.
If the it's big for conditional-branch (16-bit), try to invert the
condition and jump with 26-bit branch. For example,
beq .Lgoto
INSN1
=>
bne 1f (+8)
b .Lgoto
1:INSN1
After this transform, we are actually jump from *TO+4 instead of *TO,
so check the relocation again because it will be 1-insn farther then
before if *TO is after OLDLOC.
For BDNZT (or so) is transformed from
bdnzt eq, .Lgoto
INSN1
=>
bdz 1f (+12)
bf eq, 1f (+8)
b .Lgoto
1:INSN1
See also "BO field encodings". */
rel = PPC_BD (insn);
newrel = (oldloc - *to) + rel;
if (newrel < (1 << 15) && newrel >= -(1 << 15))
insn = (insn & ~0xfffc) | (newrel & 0xfffc);
else if ((PPC_BO (insn) & 0x14) == 0x4 || (PPC_BO (insn) & 0x14) == 0x10)
{
newrel -= 4;
/* Out of range. Cannot relocate instruction. */
if (newrel >= (1 << 25) || newrel < -(1 << 25))
return;
if ((PPC_BO (insn) & 0x14) == 0x4)
insn ^= (1 << 24);
else if ((PPC_BO (insn) & 0x14) == 0x10)
insn ^= (1 << 22);
/* Jump over the unconditional branch. */
insn = (insn & ~0xfffc) | 0x8;
target_write_memory (*to, (unsigned char *) &insn, 4);
*to += 4;
/* Build a unconditional branch and copy LK bit. */
insn = (18 << 26) | (0x3fffffc & newrel) | (insn & 0x3);
target_write_memory (*to, (unsigned char *) &insn, 4);
*to += 4;
return;
}
else if ((PPC_BO (insn) & 0x14) == 0)
{
uint32_t bdnz_insn = (16 << 26) | (0x10 << 21) | 12;
uint32_t bf_insn = (16 << 26) | (0x4 << 21) | 8;
newrel -= 8;
/* Out of range. Cannot relocate instruction. */
if (newrel >= (1 << 25) || newrel < -(1 << 25))
return;
/* Copy BI field. */
bf_insn |= (insn & 0x1f0000);
/* Invert condition. */
bdnz_insn |= (insn ^ (1 << 22)) & (1 << 22);
bf_insn |= (insn ^ (1 << 24)) & (1 << 24);
target_write_memory (*to, (unsigned char *) &bdnz_insn, 4);
*to += 4;
target_write_memory (*to, (unsigned char *) &bf_insn, 4);
*to += 4;
/* Build a unconditional branch and copy LK bit. */
insn = (18 << 26) | (0x3fffffc & newrel) | (insn & 0x3);
target_write_memory (*to, (unsigned char *) &insn, 4);
*to += 4;
return;
}
else /* (BO & 0x14) == 0x14, branch always. */
{
/* Out of range. Cannot relocate instruction. */
if (newrel >= (1 << 25) || newrel < -(1 << 25))
return;
/* Build a unconditional branch and copy LK bit. */
insn = (18 << 26) | (0x3fffffc & newrel) | (insn & 0x3);
target_write_memory (*to, (unsigned char *) &insn, 4);
*to += 4;
return;
}
}
target_write_memory (*to, (unsigned char *) &insn, 4);
*to += 4;
}
bool
ppc_target::supports_fast_tracepoints ()
{
return true;
}
/* Implement install_fast_tracepoint_jump_pad of target_ops.
See target.h for details. */
int
ppc_target::install_fast_tracepoint_jump_pad (CORE_ADDR tpoint,
CORE_ADDR tpaddr,
CORE_ADDR collector,
CORE_ADDR lockaddr,
ULONGEST orig_size,
CORE_ADDR *jump_entry,
CORE_ADDR *trampoline,
ULONGEST *trampoline_size,
unsigned char *jjump_pad_insn,
ULONGEST *jjump_pad_insn_size,
CORE_ADDR *adjusted_insn_addr,
CORE_ADDR *adjusted_insn_addr_end,
char *err)
{
uint32_t buf[256];
uint32_t *p = buf;
int j, offset;
CORE_ADDR buildaddr = *jump_entry;
const CORE_ADDR entryaddr = *jump_entry;
int rsz, min_frame, frame_size, tp_reg;
#ifdef __powerpc64__
struct regcache *regcache = get_thread_regcache (current_thread, 0);
int is_64 = register_size (regcache->tdesc, 0) == 8;
int is_opd = is_64 && !is_elfv2_inferior ();
#else
int is_64 = 0, is_opd = 0;
#endif
#ifdef __powerpc64__
if (is_64)
{
/* Minimum frame size is 32 bytes for ELFv2, and 112 bytes for ELFv1. */
rsz = 8;
min_frame = 112;
frame_size = (40 * rsz) + min_frame;
tp_reg = 13;
}
else
{
#endif
rsz = 4;
min_frame = 16;
frame_size = (40 * rsz) + min_frame;
tp_reg = 2;
#ifdef __powerpc64__
}
#endif
/* Stack frame layout for this jump pad,
High thread_area (r13/r2) |
tpoint - collecting_t obj
PC/<tpaddr> | +36
CTR | +35
LR | +34
XER | +33
CR | +32
R31 |
R29 |
... |
R1 | +1
R0 - collected registers
... |
... |
Low Back-chain -
The code flow of this jump pad,
1. Adjust SP
2. Save GPR and SPR
3. Prepare argument
4. Call gdb_collector
5. Restore GPR and SPR
6. Restore SP
7. Build a jump for back to the program
8. Copy/relocate original instruction
9. Build a jump for replacing original instruction. */
/* Adjust stack pointer. */
if (is_64)
p += GEN_STDU (p, 1, 1, -frame_size); /* stdu r1,-frame_size(r1) */
else
p += GEN_STWU (p, 1, 1, -frame_size); /* stwu r1,-frame_size(r1) */
/* Store GPRs. Save R1 later, because it had just been modified, but
we want the original value. */
for (j = 2; j < 32; j++)
p += GEN_STORE (p, j, 1, min_frame + j * rsz, is_64);
p += GEN_STORE (p, 0, 1, min_frame + 0 * rsz, is_64);
/* Set r0 to the original value of r1 before adjusting stack frame,
and then save it. */
p += GEN_ADDI (p, 0, 1, frame_size);
p += GEN_STORE (p, 0, 1, min_frame + 1 * rsz, is_64);
/* Save CR, XER, LR, and CTR. */
p += GEN_MFCR (p, 3); /* mfcr r3 */
p += GEN_MFSPR (p, 4, 1); /* mfxer r4 */
p += GEN_MFSPR (p, 5, 8); /* mflr r5 */
p += GEN_MFSPR (p, 6, 9); /* mfctr r6 */
p += GEN_STORE (p, 3, 1, min_frame + 32 * rsz, is_64);/* std r3, 32(r1) */
p += GEN_STORE (p, 4, 1, min_frame + 33 * rsz, is_64);/* std r4, 33(r1) */
p += GEN_STORE (p, 5, 1, min_frame + 34 * rsz, is_64);/* std r5, 34(r1) */
p += GEN_STORE (p, 6, 1, min_frame + 35 * rsz, is_64);/* std r6, 35(r1) */
/* Save PC<tpaddr> */
p += gen_limm (p, 3, tpaddr, is_64);
p += GEN_STORE (p, 3, 1, min_frame + 36 * rsz, is_64);
/* Setup arguments to collector. */
/* Set r4 to collected registers. */
p += GEN_ADDI (p, 4, 1, min_frame);
/* Set r3 to TPOINT. */
p += gen_limm (p, 3, tpoint, is_64);
/* Prepare collecting_t object for lock. */
p += GEN_STORE (p, 3, 1, min_frame + 37 * rsz, is_64);
p += GEN_STORE (p, tp_reg, 1, min_frame + 38 * rsz, is_64);
/* Set R5 to collecting object. */
p += GEN_ADDI (p, 5, 1, 37 * rsz);
p += GEN_LWSYNC (p);
p += gen_atomic_xchg (p, lockaddr, 0, 5, is_64);
p += GEN_LWSYNC (p);
/* Call to collector. */
p += gen_call (p, collector, is_64, is_opd);
/* Simply write 0 to release the lock. */
p += gen_limm (p, 3, lockaddr, is_64);
p += gen_limm (p, 4, 0, is_64);
p += GEN_LWSYNC (p);
p += GEN_STORE (p, 4, 3, 0, is_64);
/* Restore stack and registers. */
p += GEN_LOAD (p, 3, 1, min_frame + 32 * rsz, is_64); /* ld r3, 32(r1) */
p += GEN_LOAD (p, 4, 1, min_frame + 33 * rsz, is_64); /* ld r4, 33(r1) */
p += GEN_LOAD (p, 5, 1, min_frame + 34 * rsz, is_64); /* ld r5, 34(r1) */
p += GEN_LOAD (p, 6, 1, min_frame + 35 * rsz, is_64); /* ld r6, 35(r1) */
p += GEN_MTCR (p, 3); /* mtcr r3 */
p += GEN_MTSPR (p, 4, 1); /* mtxer r4 */
p += GEN_MTSPR (p, 5, 8); /* mtlr r5 */
p += GEN_MTSPR (p, 6, 9); /* mtctr r6 */
/* Restore GPRs. */
for (j = 2; j < 32; j++)
p += GEN_LOAD (p, j, 1, min_frame + j * rsz, is_64);
p += GEN_LOAD (p, 0, 1, min_frame + 0 * rsz, is_64);
/* Restore SP. */
p += GEN_ADDI (p, 1, 1, frame_size);
/* Flush instructions to inferior memory. */
target_write_memory (buildaddr, (unsigned char *) buf, (p - buf) * 4);
/* Now, insert the original instruction to execute in the jump pad. */
*adjusted_insn_addr = buildaddr + (p - buf) * 4;
*adjusted_insn_addr_end = *adjusted_insn_addr;
ppc_relocate_instruction (adjusted_insn_addr_end, tpaddr);
/* Verify the relocation size. If should be 4 for normal copy,
8 or 12 for some conditional branch. */
if ((*adjusted_insn_addr_end - *adjusted_insn_addr == 0)
|| (*adjusted_insn_addr_end - *adjusted_insn_addr > 12))
{
sprintf (err, "E.Unexpected instruction length = %d"
"when relocate instruction.",
(int) (*adjusted_insn_addr_end - *adjusted_insn_addr));
return 1;
}
buildaddr = *adjusted_insn_addr_end;
p = buf;
/* Finally, write a jump back to the program. */
offset = (tpaddr + 4) - buildaddr;
if (offset >= (1 << 25) || offset < -(1 << 25))
{
sprintf (err, "E.Jump back from jump pad too far from tracepoint "
"(offset 0x%x > 26-bit).", offset);
return 1;
}
/* b <tpaddr+4> */
p += GEN_B (p, offset);
target_write_memory (buildaddr, (unsigned char *) buf, (p - buf) * 4);
*jump_entry = buildaddr + (p - buf) * 4;
/* The jump pad is now built. Wire in a jump to our jump pad. This
is always done last (by our caller actually), so that we can
install fast tracepoints with threads running. This relies on
the agent's atomic write support. */
offset = entryaddr - tpaddr;
if (offset >= (1 << 25) || offset < -(1 << 25))
{
sprintf (err, "E.Jump back from jump pad too far from tracepoint "
"(offset 0x%x > 26-bit).", offset);
return 1;
}
/* b <jentry> */
GEN_B ((uint32_t *) jjump_pad_insn, offset);
*jjump_pad_insn_size = 4;
return 0;
}
/* Returns the minimum instruction length for installing a tracepoint. */
int
ppc_target::get_min_fast_tracepoint_insn_len ()
{
return 4;
}
/* Emits a given buffer into the target at current_insn_ptr. Length
is in units of 32-bit words. */
static void
emit_insns (uint32_t *buf, int n)
{
n = n * sizeof (uint32_t);
target_write_memory (current_insn_ptr, (unsigned char *) buf, n);
current_insn_ptr += n;
}
#define __EMIT_ASM(NAME, INSNS) \
do \
{ \
extern uint32_t start_bcax_ ## NAME []; \
extern uint32_t end_bcax_ ## NAME []; \
emit_insns (start_bcax_ ## NAME, \
end_bcax_ ## NAME - start_bcax_ ## NAME); \
__asm__ (".section .text.__ppcbcax\n\t" \
"start_bcax_" #NAME ":\n\t" \
INSNS "\n\t" \
"end_bcax_" #NAME ":\n\t" \
".previous\n\t"); \
} while (0)
#define _EMIT_ASM(NAME, INSNS) __EMIT_ASM (NAME, INSNS)
#define EMIT_ASM(INSNS) _EMIT_ASM (__LINE__, INSNS)
/*
Bytecode execution stack frame - 32-bit
| LR save area (SP + 4)
SP' -> +- Back chain (SP + 0)
| Save r31 for access saved arguments
| Save r30 for bytecode stack pointer
| Save r4 for incoming argument *value
| Save r3 for incoming argument regs
r30 -> +- Bytecode execution stack
|
| 64-byte (8 doublewords) at initial.
| Expand stack as needed.
|
+-
| Some padding for minimum stack frame and 16-byte alignment.
| 16 bytes.
SP +- Back-chain (SP')
initial frame size
= 16 + (4 * 4) + 64
= 96
r30 is the stack-pointer for bytecode machine.
It should point to next-empty, so we can use LDU for pop.
r3 is used for cache of the high part of TOP value.
It was the first argument, pointer to regs.
r4 is used for cache of the low part of TOP value.
It was the second argument, pointer to the result.
We should set *result = TOP after leaving this function.
Note:
* To restore stack at epilogue
=> sp = r31
* To check stack is big enough for bytecode execution.
=> r30 - 8 > SP + 8
* To return execution result.
=> 0(r4) = TOP
*/
/* Regardless of endian, register 3 is always high part, 4 is low part.
These defines are used when the register pair is stored/loaded.
Likewise, to simplify code, have a similiar define for 5:6. */
#if __BYTE_ORDER == __LITTLE_ENDIAN
#define TOP_FIRST "4"
#define TOP_SECOND "3"
#define TMP_FIRST "6"
#define TMP_SECOND "5"
#else
#define TOP_FIRST "3"
#define TOP_SECOND "4"
#define TMP_FIRST "5"
#define TMP_SECOND "6"
#endif
/* Emit prologue in inferior memory. See above comments. */
static void
ppc_emit_prologue (void)
{
EMIT_ASM (/* Save return address. */
"mflr 0 \n"
"stw 0, 4(1) \n"
/* Adjust SP. 96 is the initial frame size. */
"stwu 1, -96(1) \n"
/* Save r30 and incoming arguments. */
"stw 31, 96-4(1) \n"
"stw 30, 96-8(1) \n"
"stw 4, 96-12(1) \n"
"stw 3, 96-16(1) \n"
/* Point r31 to original r1 for access arguments. */
"addi 31, 1, 96 \n"
/* Set r30 to pointing stack-top. */
"addi 30, 1, 64 \n"
/* Initial r3/TOP to 0. */
"li 3, 0 \n"
"li 4, 0 \n");
}
/* Emit epilogue in inferior memory. See above comments. */
static void
ppc_emit_epilogue (void)
{
EMIT_ASM (/* *result = TOP */
"lwz 5, -12(31) \n"
"stw " TOP_FIRST ", 0(5) \n"
"stw " TOP_SECOND ", 4(5) \n"
/* Restore registers. */
"lwz 31, -4(31) \n"
"lwz 30, -8(31) \n"
/* Restore SP. */
"lwz 1, 0(1) \n"
/* Restore LR. */
"lwz 0, 4(1) \n"
/* Return 0 for no-error. */
"li 3, 0 \n"
"mtlr 0 \n"
"blr \n");
}
/* TOP = stack[--sp] + TOP */
static void
ppc_emit_add (void)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30)\n"
"addc 4, 6, 4 \n"
"adde 3, 5, 3 \n");
}
/* TOP = stack[--sp] - TOP */
static void
ppc_emit_sub (void)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30) \n"
"subfc 4, 4, 6 \n"
"subfe 3, 3, 5 \n");
}
/* TOP = stack[--sp] * TOP */
static void
ppc_emit_mul (void)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30) \n"
"mulhwu 7, 6, 4 \n"
"mullw 3, 6, 3 \n"
"mullw 5, 4, 5 \n"
"mullw 4, 6, 4 \n"
"add 3, 5, 3 \n"
"add 3, 7, 3 \n");
}
/* TOP = stack[--sp] << TOP */
static void
ppc_emit_lsh (void)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30) \n"
"subfic 3, 4, 32\n" /* r3 = 32 - TOP */
"addi 7, 4, -32\n" /* r7 = TOP - 32 */
"slw 5, 5, 4\n" /* Shift high part left */
"slw 4, 6, 4\n" /* Shift low part left */
"srw 3, 6, 3\n" /* Shift low to high if shift < 32 */
"slw 7, 6, 7\n" /* Shift low to high if shift >= 32 */
"or 3, 5, 3\n"
"or 3, 7, 3\n"); /* Assemble high part */
}
/* Top = stack[--sp] >> TOP
(Arithmetic shift right) */
static void
ppc_emit_rsh_signed (void)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30) \n"
"addi 7, 4, -32\n" /* r7 = TOP - 32 */
"sraw 3, 5, 4\n" /* Shift high part right */
"cmpwi 7, 1\n"
"blt 0, 1f\n" /* If shift <= 32, goto 1: */
"sraw 4, 5, 7\n" /* Shift high to low */
"b 2f\n"
"1:\n"
"subfic 7, 4, 32\n" /* r7 = 32 - TOP */
"srw 4, 6, 4\n" /* Shift low part right */
"slw 5, 5, 7\n" /* Shift high to low */
"or 4, 4, 5\n" /* Assemble low part */
"2:\n");
}
/* Top = stack[--sp] >> TOP
(Logical shift right) */
static void
ppc_emit_rsh_unsigned (void)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30) \n"
"subfic 3, 4, 32\n" /* r3 = 32 - TOP */
"addi 7, 4, -32\n" /* r7 = TOP - 32 */
"srw 6, 6, 4\n" /* Shift low part right */
"slw 3, 5, 3\n" /* Shift high to low if shift < 32 */
"srw 7, 5, 7\n" /* Shift high to low if shift >= 32 */
"or 6, 6, 3\n"
"srw 3, 5, 4\n" /* Shift high part right */
"or 4, 6, 7\n"); /* Assemble low part */
}
/* Emit code for signed-extension specified by ARG. */
static void
ppc_emit_ext (int arg)
{
switch (arg)
{
case 8:
EMIT_ASM ("extsb 4, 4\n"
"srawi 3, 4, 31");
break;
case 16:
EMIT_ASM ("extsh 4, 4\n"
"srawi 3, 4, 31");
break;
case 32:
EMIT_ASM ("srawi 3, 4, 31");
break;
default:
emit_error = 1;
}
}
/* Emit code for zero-extension specified by ARG. */
static void
ppc_emit_zero_ext (int arg)
{
switch (arg)
{
case 8:
EMIT_ASM ("clrlwi 4,4,24\n"
"li 3, 0\n");
break;
case 16:
EMIT_ASM ("clrlwi 4,4,16\n"
"li 3, 0\n");
break;
case 32:
EMIT_ASM ("li 3, 0");
break;
default:
emit_error = 1;
}
}
/* TOP = !TOP
i.e., TOP = (TOP == 0) ? 1 : 0; */
static void
ppc_emit_log_not (void)
{
EMIT_ASM ("or 4, 3, 4 \n"
"cntlzw 4, 4 \n"
"srwi 4, 4, 5 \n"
"li 3, 0 \n");
}
/* TOP = stack[--sp] & TOP */
static void
ppc_emit_bit_and (void)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30) \n"
"and 4, 6, 4 \n"
"and 3, 5, 3 \n");
}
/* TOP = stack[--sp] | TOP */
static void
ppc_emit_bit_or (void)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30) \n"
"or 4, 6, 4 \n"
"or 3, 5, 3 \n");
}
/* TOP = stack[--sp] ^ TOP */
static void
ppc_emit_bit_xor (void)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30) \n"
"xor 4, 6, 4 \n"
"xor 3, 5, 3 \n");
}
/* TOP = ~TOP
i.e., TOP = ~(TOP | TOP) */
static void
ppc_emit_bit_not (void)
{
EMIT_ASM ("nor 3, 3, 3 \n"
"nor 4, 4, 4 \n");
}
/* TOP = stack[--sp] == TOP */
static void
ppc_emit_equal (void)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30) \n"
"xor 4, 6, 4 \n"
"xor 3, 5, 3 \n"
"or 4, 3, 4 \n"
"cntlzw 4, 4 \n"
"srwi 4, 4, 5 \n"
"li 3, 0 \n");
}
/* TOP = stack[--sp] < TOP
(Signed comparison) */
static void
ppc_emit_less_signed (void)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30) \n"
"cmplw 6, 6, 4 \n"
"cmpw 7, 5, 3 \n"
/* CR6 bit 0 = low less and high equal */
"crand 6*4+0, 6*4+0, 7*4+2\n"
/* CR7 bit 0 = (low less and high equal) or high less */
"cror 7*4+0, 7*4+0, 6*4+0\n"
"mfcr 4 \n"
"rlwinm 4, 4, 29, 31, 31 \n"
"li 3, 0 \n");
}
/* TOP = stack[--sp] < TOP
(Unsigned comparison) */
static void
ppc_emit_less_unsigned (void)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30) \n"
"cmplw 6, 6, 4 \n"
"cmplw 7, 5, 3 \n"
/* CR6 bit 0 = low less and high equal */
"crand 6*4+0, 6*4+0, 7*4+2\n"
/* CR7 bit 0 = (low less and high equal) or high less */
"cror 7*4+0, 7*4+0, 6*4+0\n"
"mfcr 4 \n"
"rlwinm 4, 4, 29, 31, 31 \n"
"li 3, 0 \n");
}
/* Access the memory address in TOP in size of SIZE.
Zero-extend the read value. */
static void
ppc_emit_ref (int size)
{
switch (size)
{
case 1:
EMIT_ASM ("lbz 4, 0(4)\n"
"li 3, 0");
break;
case 2:
EMIT_ASM ("lhz 4, 0(4)\n"
"li 3, 0");
break;
case 4:
EMIT_ASM ("lwz 4, 0(4)\n"
"li 3, 0");
break;
case 8:
if (__BYTE_ORDER == __LITTLE_ENDIAN)
EMIT_ASM ("lwz 3, 4(4)\n"
"lwz 4, 0(4)");
else
EMIT_ASM ("lwz 3, 0(4)\n"
"lwz 4, 4(4)");
break;
}
}
/* TOP = NUM */
static void
ppc_emit_const (LONGEST num)
{
uint32_t buf[10];
uint32_t *p = buf;
p += gen_limm (p, 3, num >> 32 & 0xffffffff, 0);
p += gen_limm (p, 4, num & 0xffffffff, 0);
emit_insns (buf, p - buf);
gdb_assert ((p - buf) <= (sizeof (buf) / sizeof (*buf)));
}
/* Set TOP to the value of register REG by calling get_raw_reg function
with two argument, collected buffer and register number. */
static void
ppc_emit_reg (int reg)
{
uint32_t buf[13];
uint32_t *p = buf;
/* fctx->regs is passed in r3 and then saved in -16(31). */
p += GEN_LWZ (p, 3, 31, -16);
p += GEN_LI (p, 4, reg); /* li r4, reg */
p += gen_call (p, get_raw_reg_func_addr (), 0, 0);
emit_insns (buf, p - buf);
gdb_assert ((p - buf) <= (sizeof (buf) / sizeof (*buf)));
if (__BYTE_ORDER == __LITTLE_ENDIAN)
{
EMIT_ASM ("mr 5, 4\n"
"mr 4, 3\n"
"mr 3, 5\n");
}
}
/* TOP = stack[--sp] */
static void
ppc_emit_pop (void)
{
EMIT_ASM ("lwzu " TOP_FIRST ", 8(30) \n"
"lwz " TOP_SECOND ", 4(30) \n");
}
/* stack[sp++] = TOP
Because we may use up bytecode stack, expand 8 doublewords more
if needed. */
static void
ppc_emit_stack_flush (void)
{
/* Make sure bytecode stack is big enough before push.
Otherwise, expand 64-byte more. */
EMIT_ASM (" stw " TOP_FIRST ", 0(30) \n"
" stw " TOP_SECOND ", 4(30)\n"
" addi 5, 30, -(8 + 8) \n"
" cmpw 7, 5, 1 \n"
" bgt 7, 1f \n"
" stwu 31, -64(1) \n"
"1:addi 30, 30, -8 \n");
}
/* Swap TOP and stack[sp-1] */
static void
ppc_emit_swap (void)
{
EMIT_ASM ("lwz " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 12(30) \n"
"stw " TOP_FIRST ", 8(30) \n"
"stw " TOP_SECOND ", 12(30) \n"
"mr 3, 5 \n"
"mr 4, 6 \n");
}
/* Discard N elements in the stack. Also used for ppc64. */
static void
ppc_emit_stack_adjust (int n)
{
uint32_t buf[6];
uint32_t *p = buf;
n = n << 3;
if ((n >> 15) != 0)
{
emit_error = 1;
return;
}
p += GEN_ADDI (p, 30, 30, n);
emit_insns (buf, p - buf);
gdb_assert ((p - buf) <= (sizeof (buf) / sizeof (*buf)));
}
/* Call function FN. */
static void
ppc_emit_call (CORE_ADDR fn)
{
uint32_t buf[11];
uint32_t *p = buf;
p += gen_call (p, fn, 0, 0);
emit_insns (buf, p - buf);
gdb_assert ((p - buf) <= (sizeof (buf) / sizeof (*buf)));
}
/* FN's prototype is `LONGEST(*fn)(int)'.
TOP = fn (arg1)
*/
static void
ppc_emit_int_call_1 (CORE_ADDR fn, int arg1)
{
uint32_t buf[15];
uint32_t *p = buf;
/* Setup argument. arg1 is a 16-bit value. */
p += gen_limm (p, 3, (uint32_t) arg1, 0);
p += gen_call (p, fn, 0, 0);
emit_insns (buf, p - buf);
gdb_assert ((p - buf) <= (sizeof (buf) / sizeof (*buf)));
if (__BYTE_ORDER == __LITTLE_ENDIAN)
{
EMIT_ASM ("mr 5, 4\n"
"mr 4, 3\n"
"mr 3, 5\n");
}
}
/* FN's prototype is `void(*fn)(int,LONGEST)'.
fn (arg1, TOP)
TOP should be preserved/restored before/after the call. */
static void
ppc_emit_void_call_2 (CORE_ADDR fn, int arg1)
{
uint32_t buf[21];
uint32_t *p = buf;
/* Save TOP. 0(30) is next-empty. */
p += GEN_STW (p, 3, 30, 0);
p += GEN_STW (p, 4, 30, 4);
/* Setup argument. arg1 is a 16-bit value. */
if (__BYTE_ORDER == __LITTLE_ENDIAN)
{
p += GEN_MR (p, 5, 4);
p += GEN_MR (p, 6, 3);
}
else
{
p += GEN_MR (p, 5, 3);
p += GEN_MR (p, 6, 4);
}
p += gen_limm (p, 3, (uint32_t) arg1, 0);
p += gen_call (p, fn, 0, 0);
/* Restore TOP */
p += GEN_LWZ (p, 3, 30, 0);
p += GEN_LWZ (p, 4, 30, 4);
emit_insns (buf, p - buf);
gdb_assert ((p - buf) <= (sizeof (buf) / sizeof (*buf)));
}
/* Note in the following goto ops:
When emitting goto, the target address is later relocated by
write_goto_address. OFFSET_P is the offset of the branch instruction
in the code sequence, and SIZE_P is how to relocate the instruction,
recognized by ppc_write_goto_address. In current implementation,
SIZE can be either 24 or 14 for branch of conditional-branch instruction.
*/
/* If TOP is true, goto somewhere. Otherwise, just fall-through. */
static void
ppc_emit_if_goto (int *offset_p, int *size_p)
{
EMIT_ASM ("or. 3, 3, 4 \n"
"lwzu " TOP_FIRST ", 8(30) \n"
"lwz " TOP_SECOND ", 4(30) \n"
"1:bne 0, 1b \n");
if (offset_p)
*offset_p = 12;
if (size_p)
*size_p = 14;
}
/* Unconditional goto. Also used for ppc64. */
static void
ppc_emit_goto (int *offset_p, int *size_p)
{
EMIT_ASM ("1:b 1b");
if (offset_p)
*offset_p = 0;
if (size_p)
*size_p = 24;
}
/* Goto if stack[--sp] == TOP */
static void
ppc_emit_eq_goto (int *offset_p, int *size_p)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30) \n"
"xor 4, 6, 4 \n"
"xor 3, 5, 3 \n"
"or. 3, 3, 4 \n"
"lwzu " TOP_FIRST ", 8(30) \n"
"lwz " TOP_SECOND ", 4(30) \n"
"1:beq 0, 1b \n");
if (offset_p)
*offset_p = 28;
if (size_p)
*size_p = 14;
}
/* Goto if stack[--sp] != TOP */
static void
ppc_emit_ne_goto (int *offset_p, int *size_p)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30) \n"
"xor 4, 6, 4 \n"
"xor 3, 5, 3 \n"
"or. 3, 3, 4 \n"
"lwzu " TOP_FIRST ", 8(30) \n"
"lwz " TOP_SECOND ", 4(30) \n"
"1:bne 0, 1b \n");
if (offset_p)
*offset_p = 28;
if (size_p)
*size_p = 14;
}
/* Goto if stack[--sp] < TOP */
static void
ppc_emit_lt_goto (int *offset_p, int *size_p)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30) \n"
"cmplw 6, 6, 4 \n"
"cmpw 7, 5, 3 \n"
/* CR6 bit 0 = low less and high equal */
"crand 6*4+0, 6*4+0, 7*4+2\n"
/* CR7 bit 0 = (low less and high equal) or high less */
"cror 7*4+0, 7*4+0, 6*4+0\n"
"lwzu " TOP_FIRST ", 8(30) \n"
"lwz " TOP_SECOND ", 4(30)\n"
"1:blt 7, 1b \n");
if (offset_p)
*offset_p = 32;
if (size_p)
*size_p = 14;
}
/* Goto if stack[--sp] <= TOP */
static void
ppc_emit_le_goto (int *offset_p, int *size_p)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30) \n"
"cmplw 6, 6, 4 \n"
"cmpw 7, 5, 3 \n"
/* CR6 bit 0 = low less/equal and high equal */
"crandc 6*4+0, 7*4+2, 6*4+1\n"
/* CR7 bit 0 = (low less/eq and high equal) or high less */
"cror 7*4+0, 7*4+0, 6*4+0\n"
"lwzu " TOP_FIRST ", 8(30) \n"
"lwz " TOP_SECOND ", 4(30)\n"
"1:blt 7, 1b \n");
if (offset_p)
*offset_p = 32;
if (size_p)
*size_p = 14;
}
/* Goto if stack[--sp] > TOP */
static void
ppc_emit_gt_goto (int *offset_p, int *size_p)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30) \n"
"cmplw 6, 6, 4 \n"
"cmpw 7, 5, 3 \n"
/* CR6 bit 0 = low greater and high equal */
"crand 6*4+0, 6*4+1, 7*4+2\n"
/* CR7 bit 0 = (low greater and high equal) or high greater */
"cror 7*4+0, 7*4+1, 6*4+0\n"
"lwzu " TOP_FIRST ", 8(30) \n"
"lwz " TOP_SECOND ", 4(30)\n"
"1:blt 7, 1b \n");
if (offset_p)
*offset_p = 32;
if (size_p)
*size_p = 14;
}
/* Goto if stack[--sp] >= TOP */
static void
ppc_emit_ge_goto (int *offset_p, int *size_p)
{
EMIT_ASM ("lwzu " TMP_FIRST ", 8(30) \n"
"lwz " TMP_SECOND ", 4(30) \n"
"cmplw 6, 6, 4 \n"
"cmpw 7, 5, 3 \n"
/* CR6 bit 0 = low ge and high equal */
"crandc 6*4+0, 7*4+2, 6*4+0\n"
/* CR7 bit 0 = (low ge and high equal) or high greater */
"cror 7*4+0, 7*4+1, 6*4+0\n"
"lwzu " TOP_FIRST ", 8(30)\n"
"lwz " TOP_SECOND ", 4(30)\n"
"1:blt 7, 1b \n");
if (offset_p)
*offset_p = 32;
if (size_p)
*size_p = 14;
}
/* Relocate previous emitted branch instruction. FROM is the address
of the branch instruction, TO is the goto target address, and SIZE
if the value we set by *SIZE_P before. Currently, it is either
24 or 14 of branch and conditional-branch instruction.
Also used for ppc64. */
static void
ppc_write_goto_address (CORE_ADDR from, CORE_ADDR to, int size)
{
long rel = to - from;
uint32_t insn;
int opcd;
read_inferior_memory (from, (unsigned char *) &insn, 4);
opcd = (insn >> 26) & 0x3f;
switch (size)
{
case 14:
if (opcd != 16
|| (rel >= (1 << 15) || rel < -(1 << 15)))
emit_error = 1;
insn = (insn & ~0xfffc) | (rel & 0xfffc);
break;
case 24:
if (opcd != 18
|| (rel >= (1 << 25) || rel < -(1 << 25)))
emit_error = 1;
insn = (insn & ~0x3fffffc) | (rel & 0x3fffffc);
break;
default:
emit_error = 1;
}
if (!emit_error)
target_write_memory (from, (unsigned char *) &insn, 4);
}
/* Table of emit ops for 32-bit. */
static struct emit_ops ppc_emit_ops_impl =
{
ppc_emit_prologue,
ppc_emit_epilogue,
ppc_emit_add,
ppc_emit_sub,
ppc_emit_mul,
ppc_emit_lsh,
ppc_emit_rsh_signed,
ppc_emit_rsh_unsigned,
ppc_emit_ext,
ppc_emit_log_not,
ppc_emit_bit_and,
ppc_emit_bit_or,
ppc_emit_bit_xor,
ppc_emit_bit_not,
ppc_emit_equal,
ppc_emit_less_signed,
ppc_emit_less_unsigned,
ppc_emit_ref,
ppc_emit_if_goto,
ppc_emit_goto,
ppc_write_goto_address,
ppc_emit_const,
ppc_emit_call,
ppc_emit_reg,
ppc_emit_pop,
ppc_emit_stack_flush,
ppc_emit_zero_ext,
ppc_emit_swap,
ppc_emit_stack_adjust,
ppc_emit_int_call_1,
ppc_emit_void_call_2,
ppc_emit_eq_goto,
ppc_emit_ne_goto,
ppc_emit_lt_goto,
ppc_emit_le_goto,
ppc_emit_gt_goto,
ppc_emit_ge_goto
};
#ifdef __powerpc64__
/*
Bytecode execution stack frame - 64-bit
| LR save area (SP + 16)
| CR save area (SP + 8)
SP' -> +- Back chain (SP + 0)
| Save r31 for access saved arguments
| Save r30 for bytecode stack pointer
| Save r4 for incoming argument *value
| Save r3 for incoming argument regs
r30 -> +- Bytecode execution stack
|
| 64-byte (8 doublewords) at initial.
| Expand stack as needed.
|
+-
| Some padding for minimum stack frame.
| 112 for ELFv1.
SP +- Back-chain (SP')
initial frame size
= 112 + (4 * 8) + 64
= 208
r30 is the stack-pointer for bytecode machine.
It should point to next-empty, so we can use LDU for pop.
r3 is used for cache of TOP value.
It was the first argument, pointer to regs.
r4 is the second argument, pointer to the result.
We should set *result = TOP after leaving this function.
Note:
* To restore stack at epilogue
=> sp = r31
* To check stack is big enough for bytecode execution.
=> r30 - 8 > SP + 112
* To return execution result.
=> 0(r4) = TOP
*/
/* Emit prologue in inferior memory. See above comments. */
static void
ppc64v1_emit_prologue (void)
{
/* On ELFv1, function pointers really point to function descriptor,
so emit one here. We don't care about contents of words 1 and 2,
so let them just overlap out code. */
uint64_t opd = current_insn_ptr + 8;
uint32_t buf[2];
/* Mind the strict aliasing rules. */
memcpy (buf, &opd, sizeof buf);
emit_insns(buf, 2);
EMIT_ASM (/* Save return address. */
"mflr 0 \n"
"std 0, 16(1) \n"
/* Save r30 and incoming arguments. */
"std 31, -8(1) \n"
"std 30, -16(1) \n"
"std 4, -24(1) \n"
"std 3, -32(1) \n"
/* Point r31 to current r1 for access arguments. */
"mr 31, 1 \n"
/* Adjust SP. 208 is the initial frame size. */
"stdu 1, -208(1) \n"
/* Set r30 to pointing stack-top. */
"addi 30, 1, 168 \n"
/* Initial r3/TOP to 0. */
"li 3, 0 \n");
}
/* Emit prologue in inferior memory. See above comments. */
static void
ppc64v2_emit_prologue (void)
{
EMIT_ASM (/* Save return address. */
"mflr 0 \n"
"std 0, 16(1) \n"
/* Save r30 and incoming arguments. */
"std 31, -8(1) \n"
"std 30, -16(1) \n"
"std 4, -24(1) \n"
"std 3, -32(1) \n"
/* Point r31 to current r1 for access arguments. */
"mr 31, 1 \n"
/* Adjust SP. 208 is the initial frame size. */
"stdu 1, -208(1) \n"
/* Set r30 to pointing stack-top. */
"addi 30, 1, 168 \n"
/* Initial r3/TOP to 0. */
"li 3, 0 \n");
}
/* Emit epilogue in inferior memory. See above comments. */
static void
ppc64_emit_epilogue (void)
{
EMIT_ASM (/* Restore SP. */
"ld 1, 0(1) \n"
/* *result = TOP */
"ld 4, -24(1) \n"
"std 3, 0(4) \n"
/* Restore registers. */
"ld 31, -8(1) \n"
"ld 30, -16(1) \n"
/* Restore LR. */
"ld 0, 16(1) \n"
/* Return 0 for no-error. */
"li 3, 0 \n"
"mtlr 0 \n"
"blr \n");
}
/* TOP = stack[--sp] + TOP */
static void
ppc64_emit_add (void)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"add 3, 4, 3 \n");
}
/* TOP = stack[--sp] - TOP */
static void
ppc64_emit_sub (void)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"sub 3, 4, 3 \n");
}
/* TOP = stack[--sp] * TOP */
static void
ppc64_emit_mul (void)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"mulld 3, 4, 3 \n");
}
/* TOP = stack[--sp] << TOP */
static void
ppc64_emit_lsh (void)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"sld 3, 4, 3 \n");
}
/* Top = stack[--sp] >> TOP
(Arithmetic shift right) */
static void
ppc64_emit_rsh_signed (void)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"srad 3, 4, 3 \n");
}
/* Top = stack[--sp] >> TOP
(Logical shift right) */
static void
ppc64_emit_rsh_unsigned (void)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"srd 3, 4, 3 \n");
}
/* Emit code for signed-extension specified by ARG. */
static void
ppc64_emit_ext (int arg)
{
switch (arg)
{
case 8:
EMIT_ASM ("extsb 3, 3");
break;
case 16:
EMIT_ASM ("extsh 3, 3");
break;
case 32:
EMIT_ASM ("extsw 3, 3");
break;
default:
emit_error = 1;
}
}
/* Emit code for zero-extension specified by ARG. */
static void
ppc64_emit_zero_ext (int arg)
{
switch (arg)
{
case 8:
EMIT_ASM ("rldicl 3,3,0,56");
break;
case 16:
EMIT_ASM ("rldicl 3,3,0,48");
break;
case 32:
EMIT_ASM ("rldicl 3,3,0,32");
break;
default:
emit_error = 1;
}
}
/* TOP = !TOP
i.e., TOP = (TOP == 0) ? 1 : 0; */
static void
ppc64_emit_log_not (void)
{
EMIT_ASM ("cntlzd 3, 3 \n"
"srdi 3, 3, 6 \n");
}
/* TOP = stack[--sp] & TOP */
static void
ppc64_emit_bit_and (void)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"and 3, 4, 3 \n");
}
/* TOP = stack[--sp] | TOP */
static void
ppc64_emit_bit_or (void)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"or 3, 4, 3 \n");
}
/* TOP = stack[--sp] ^ TOP */
static void
ppc64_emit_bit_xor (void)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"xor 3, 4, 3 \n");
}
/* TOP = ~TOP
i.e., TOP = ~(TOP | TOP) */
static void
ppc64_emit_bit_not (void)
{
EMIT_ASM ("nor 3, 3, 3 \n");
}
/* TOP = stack[--sp] == TOP */
static void
ppc64_emit_equal (void)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"xor 3, 3, 4 \n"
"cntlzd 3, 3 \n"
"srdi 3, 3, 6 \n");
}
/* TOP = stack[--sp] < TOP
(Signed comparison) */
static void
ppc64_emit_less_signed (void)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"cmpd 7, 4, 3 \n"
"mfcr 3 \n"
"rlwinm 3, 3, 29, 31, 31 \n");
}
/* TOP = stack[--sp] < TOP
(Unsigned comparison) */
static void
ppc64_emit_less_unsigned (void)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"cmpld 7, 4, 3 \n"
"mfcr 3 \n"
"rlwinm 3, 3, 29, 31, 31 \n");
}
/* Access the memory address in TOP in size of SIZE.
Zero-extend the read value. */
static void
ppc64_emit_ref (int size)
{
switch (size)
{
case 1:
EMIT_ASM ("lbz 3, 0(3)");
break;
case 2:
EMIT_ASM ("lhz 3, 0(3)");
break;
case 4:
EMIT_ASM ("lwz 3, 0(3)");
break;
case 8:
EMIT_ASM ("ld 3, 0(3)");
break;
}
}
/* TOP = NUM */
static void
ppc64_emit_const (LONGEST num)
{
uint32_t buf[5];
uint32_t *p = buf;
p += gen_limm (p, 3, num, 1);
emit_insns (buf, p - buf);
gdb_assert ((p - buf) <= (sizeof (buf) / sizeof (*buf)));
}
/* Set TOP to the value of register REG by calling get_raw_reg function
with two argument, collected buffer and register number. */
static void
ppc64v1_emit_reg (int reg)
{
uint32_t buf[15];
uint32_t *p = buf;
/* fctx->regs is passed in r3 and then saved in 176(1). */
p += GEN_LD (p, 3, 31, -32);
p += GEN_LI (p, 4, reg);
p += GEN_STD (p, 2, 1, 40); /* Save TOC. */
p += gen_call (p, get_raw_reg_func_addr (), 1, 1);
p += GEN_LD (p, 2, 1, 40); /* Restore TOC. */
emit_insns (buf, p - buf);
gdb_assert ((p - buf) <= (sizeof (buf) / sizeof (*buf)));
}
/* Likewise, for ELFv2. */
static void
ppc64v2_emit_reg (int reg)
{
uint32_t buf[12];
uint32_t *p = buf;
/* fctx->regs is passed in r3 and then saved in 176(1). */
p += GEN_LD (p, 3, 31, -32);
p += GEN_LI (p, 4, reg);
p += GEN_STD (p, 2, 1, 24); /* Save TOC. */
p += gen_call (p, get_raw_reg_func_addr (), 1, 0);
p += GEN_LD (p, 2, 1, 24); /* Restore TOC. */
emit_insns (buf, p - buf);
gdb_assert ((p - buf) <= (sizeof (buf) / sizeof (*buf)));
}
/* TOP = stack[--sp] */
static void
ppc64_emit_pop (void)
{
EMIT_ASM ("ldu 3, 8(30)");
}
/* stack[sp++] = TOP
Because we may use up bytecode stack, expand 8 doublewords more
if needed. */
static void
ppc64_emit_stack_flush (void)
{
/* Make sure bytecode stack is big enough before push.
Otherwise, expand 64-byte more. */
EMIT_ASM (" std 3, 0(30) \n"
" addi 4, 30, -(112 + 8) \n"
" cmpd 7, 4, 1 \n"
" bgt 7, 1f \n"
" stdu 31, -64(1) \n"
"1:addi 30, 30, -8 \n");
}
/* Swap TOP and stack[sp-1] */
static void
ppc64_emit_swap (void)
{
EMIT_ASM ("ld 4, 8(30) \n"
"std 3, 8(30) \n"
"mr 3, 4 \n");
}
/* Call function FN - ELFv1. */
static void
ppc64v1_emit_call (CORE_ADDR fn)
{
uint32_t buf[13];
uint32_t *p = buf;
p += GEN_STD (p, 2, 1, 40); /* Save TOC. */
p += gen_call (p, fn, 1, 1);
p += GEN_LD (p, 2, 1, 40); /* Restore TOC. */
emit_insns (buf, p - buf);
gdb_assert ((p - buf) <= (sizeof (buf) / sizeof (*buf)));
}
/* Call function FN - ELFv2. */
static void
ppc64v2_emit_call (CORE_ADDR fn)
{
uint32_t buf[10];
uint32_t *p = buf;
p += GEN_STD (p, 2, 1, 24); /* Save TOC. */
p += gen_call (p, fn, 1, 0);
p += GEN_LD (p, 2, 1, 24); /* Restore TOC. */
emit_insns (buf, p - buf);
gdb_assert ((p - buf) <= (sizeof (buf) / sizeof (*buf)));
}
/* FN's prototype is `LONGEST(*fn)(int)'.
TOP = fn (arg1)
*/
static void
ppc64v1_emit_int_call_1 (CORE_ADDR fn, int arg1)
{
uint32_t buf[13];
uint32_t *p = buf;
/* Setup argument. arg1 is a 16-bit value. */
p += gen_limm (p, 3, arg1, 1);
p += GEN_STD (p, 2, 1, 40); /* Save TOC. */
p += gen_call (p, fn, 1, 1);
p += GEN_LD (p, 2, 1, 40); /* Restore TOC. */
emit_insns (buf, p - buf);
gdb_assert ((p - buf) <= (sizeof (buf) / sizeof (*buf)));
}
/* Likewise for ELFv2. */
static void
ppc64v2_emit_int_call_1 (CORE_ADDR fn, int arg1)
{
uint32_t buf[10];
uint32_t *p = buf;
/* Setup argument. arg1 is a 16-bit value. */
p += gen_limm (p, 3, arg1, 1);
p += GEN_STD (p, 2, 1, 24); /* Save TOC. */
p += gen_call (p, fn, 1, 0);
p += GEN_LD (p, 2, 1, 24); /* Restore TOC. */
emit_insns (buf, p - buf);
gdb_assert ((p - buf) <= (sizeof (buf) / sizeof (*buf)));
}
/* FN's prototype is `void(*fn)(int,LONGEST)'.
fn (arg1, TOP)
TOP should be preserved/restored before/after the call. */
static void
ppc64v1_emit_void_call_2 (CORE_ADDR fn, int arg1)
{
uint32_t buf[17];
uint32_t *p = buf;
/* Save TOP. 0(30) is next-empty. */
p += GEN_STD (p, 3, 30, 0);
/* Setup argument. arg1 is a 16-bit value. */
p += GEN_MR (p, 4, 3); /* mr r4, r3 */
p += gen_limm (p, 3, arg1, 1);
p += GEN_STD (p, 2, 1, 40); /* Save TOC. */
p += gen_call (p, fn, 1, 1);
p += GEN_LD (p, 2, 1, 40); /* Restore TOC. */
/* Restore TOP */
p += GEN_LD (p, 3, 30, 0);
emit_insns (buf, p - buf);
gdb_assert ((p - buf) <= (sizeof (buf) / sizeof (*buf)));
}
/* Likewise for ELFv2. */
static void
ppc64v2_emit_void_call_2 (CORE_ADDR fn, int arg1)
{
uint32_t buf[14];
uint32_t *p = buf;
/* Save TOP. 0(30) is next-empty. */
p += GEN_STD (p, 3, 30, 0);
/* Setup argument. arg1 is a 16-bit value. */
p += GEN_MR (p, 4, 3); /* mr r4, r3 */
p += gen_limm (p, 3, arg1, 1);
p += GEN_STD (p, 2, 1, 24); /* Save TOC. */
p += gen_call (p, fn, 1, 0);
p += GEN_LD (p, 2, 1, 24); /* Restore TOC. */
/* Restore TOP */
p += GEN_LD (p, 3, 30, 0);
emit_insns (buf, p - buf);
gdb_assert ((p - buf) <= (sizeof (buf) / sizeof (*buf)));
}
/* If TOP is true, goto somewhere. Otherwise, just fall-through. */
static void
ppc64_emit_if_goto (int *offset_p, int *size_p)
{
EMIT_ASM ("cmpdi 7, 3, 0 \n"
"ldu 3, 8(30) \n"
"1:bne 7, 1b \n");
if (offset_p)
*offset_p = 8;
if (size_p)
*size_p = 14;
}
/* Goto if stack[--sp] == TOP */
static void
ppc64_emit_eq_goto (int *offset_p, int *size_p)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"cmpd 7, 4, 3 \n"
"ldu 3, 8(30) \n"
"1:beq 7, 1b \n");
if (offset_p)
*offset_p = 12;
if (size_p)
*size_p = 14;
}
/* Goto if stack[--sp] != TOP */
static void
ppc64_emit_ne_goto (int *offset_p, int *size_p)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"cmpd 7, 4, 3 \n"
"ldu 3, 8(30) \n"
"1:bne 7, 1b \n");
if (offset_p)
*offset_p = 12;
if (size_p)
*size_p = 14;
}
/* Goto if stack[--sp] < TOP */
static void
ppc64_emit_lt_goto (int *offset_p, int *size_p)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"cmpd 7, 4, 3 \n"
"ldu 3, 8(30) \n"
"1:blt 7, 1b \n");
if (offset_p)
*offset_p = 12;
if (size_p)
*size_p = 14;
}
/* Goto if stack[--sp] <= TOP */
static void
ppc64_emit_le_goto (int *offset_p, int *size_p)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"cmpd 7, 4, 3 \n"
"ldu 3, 8(30) \n"
"1:ble 7, 1b \n");
if (offset_p)
*offset_p = 12;
if (size_p)
*size_p = 14;
}
/* Goto if stack[--sp] > TOP */
static void
ppc64_emit_gt_goto (int *offset_p, int *size_p)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"cmpd 7, 4, 3 \n"
"ldu 3, 8(30) \n"
"1:bgt 7, 1b \n");
if (offset_p)
*offset_p = 12;
if (size_p)
*size_p = 14;
}
/* Goto if stack[--sp] >= TOP */
static void
ppc64_emit_ge_goto (int *offset_p, int *size_p)
{
EMIT_ASM ("ldu 4, 8(30) \n"
"cmpd 7, 4, 3 \n"
"ldu 3, 8(30) \n"
"1:bge 7, 1b \n");
if (offset_p)
*offset_p = 12;
if (size_p)
*size_p = 14;
}
/* Table of emit ops for 64-bit ELFv1. */
static struct emit_ops ppc64v1_emit_ops_impl =
{
ppc64v1_emit_prologue,
ppc64_emit_epilogue,
ppc64_emit_add,
ppc64_emit_sub,
ppc64_emit_mul,
ppc64_emit_lsh,
ppc64_emit_rsh_signed,
ppc64_emit_rsh_unsigned,
ppc64_emit_ext,
ppc64_emit_log_not,
ppc64_emit_bit_and,
ppc64_emit_bit_or,
ppc64_emit_bit_xor,
ppc64_emit_bit_not,
ppc64_emit_equal,
ppc64_emit_less_signed,
ppc64_emit_less_unsigned,
ppc64_emit_ref,
ppc64_emit_if_goto,
ppc_emit_goto,
ppc_write_goto_address,
ppc64_emit_const,
ppc64v1_emit_call,
ppc64v1_emit_reg,
ppc64_emit_pop,
ppc64_emit_stack_flush,
ppc64_emit_zero_ext,
ppc64_emit_swap,
ppc_emit_stack_adjust,
ppc64v1_emit_int_call_1,
ppc64v1_emit_void_call_2,
ppc64_emit_eq_goto,
ppc64_emit_ne_goto,
ppc64_emit_lt_goto,
ppc64_emit_le_goto,
ppc64_emit_gt_goto,
ppc64_emit_ge_goto
};
/* Table of emit ops for 64-bit ELFv2. */
static struct emit_ops ppc64v2_emit_ops_impl =
{
ppc64v2_emit_prologue,
ppc64_emit_epilogue,
ppc64_emit_add,
ppc64_emit_sub,
ppc64_emit_mul,
ppc64_emit_lsh,
ppc64_emit_rsh_signed,
ppc64_emit_rsh_unsigned,
ppc64_emit_ext,
ppc64_emit_log_not,
ppc64_emit_bit_and,
ppc64_emit_bit_or,
ppc64_emit_bit_xor,
ppc64_emit_bit_not,
ppc64_emit_equal,
ppc64_emit_less_signed,
ppc64_emit_less_unsigned,
ppc64_emit_ref,
ppc64_emit_if_goto,
ppc_emit_goto,
ppc_write_goto_address,
ppc64_emit_const,
ppc64v2_emit_call,
ppc64v2_emit_reg,
ppc64_emit_pop,
ppc64_emit_stack_flush,
ppc64_emit_zero_ext,
ppc64_emit_swap,
ppc_emit_stack_adjust,
ppc64v2_emit_int_call_1,
ppc64v2_emit_void_call_2,
ppc64_emit_eq_goto,
ppc64_emit_ne_goto,
ppc64_emit_lt_goto,
ppc64_emit_le_goto,
ppc64_emit_gt_goto,
ppc64_emit_ge_goto
};
#endif
/* Implementation of target ops method "emit_ops". */
emit_ops *
ppc_target::emit_ops ()
{
#ifdef __powerpc64__
struct regcache *regcache = get_thread_regcache (current_thread, 0);
if (register_size (regcache->tdesc, 0) == 8)
{
if (is_elfv2_inferior ())
return &ppc64v2_emit_ops_impl;
else
return &ppc64v1_emit_ops_impl;
}
#endif
return &ppc_emit_ops_impl;
}
/* Implementation of target ops method "get_ipa_tdesc_idx". */
int
ppc_target::get_ipa_tdesc_idx ()
{
struct regcache *regcache = get_thread_regcache (current_thread, 0);
const struct target_desc *tdesc = regcache->tdesc;
#ifdef __powerpc64__
if (tdesc == tdesc_powerpc_64l)
return PPC_TDESC_BASE;
if (tdesc == tdesc_powerpc_altivec64l)
return PPC_TDESC_ALTIVEC;
if (tdesc == tdesc_powerpc_vsx64l)
return PPC_TDESC_VSX;
if (tdesc == tdesc_powerpc_isa205_64l)
return PPC_TDESC_ISA205;
if (tdesc == tdesc_powerpc_isa205_altivec64l)
return PPC_TDESC_ISA205_ALTIVEC;
if (tdesc == tdesc_powerpc_isa205_vsx64l)
return PPC_TDESC_ISA205_VSX;
if (tdesc == tdesc_powerpc_isa205_ppr_dscr_vsx64l)
return PPC_TDESC_ISA205_PPR_DSCR_VSX;
if (tdesc == tdesc_powerpc_isa207_vsx64l)
return PPC_TDESC_ISA207_VSX;
if (tdesc == tdesc_powerpc_isa207_htm_vsx64l)
return PPC_TDESC_ISA207_HTM_VSX;
#endif
if (tdesc == tdesc_powerpc_32l)
return PPC_TDESC_BASE;
if (tdesc == tdesc_powerpc_altivec32l)
return PPC_TDESC_ALTIVEC;
if (tdesc == tdesc_powerpc_vsx32l)
return PPC_TDESC_VSX;
if (tdesc == tdesc_powerpc_isa205_32l)
return PPC_TDESC_ISA205;
if (tdesc == tdesc_powerpc_isa205_altivec32l)
return PPC_TDESC_ISA205_ALTIVEC;
if (tdesc == tdesc_powerpc_isa205_vsx32l)
return PPC_TDESC_ISA205_VSX;
if (tdesc == tdesc_powerpc_isa205_ppr_dscr_vsx32l)
return PPC_TDESC_ISA205_PPR_DSCR_VSX;
if (tdesc == tdesc_powerpc_isa207_vsx32l)
return PPC_TDESC_ISA207_VSX;
if (tdesc == tdesc_powerpc_isa207_htm_vsx32l)
return PPC_TDESC_ISA207_HTM_VSX;
if (tdesc == tdesc_powerpc_e500l)
return PPC_TDESC_E500;
return 0;
}
/* The linux target ops object. */
linux_process_target *the_linux_target = &the_ppc_target;
void
initialize_low_arch (void)
{
/* Initialize the Linux target descriptions. */
init_registers_powerpc_32l ();
init_registers_powerpc_altivec32l ();
init_registers_powerpc_vsx32l ();
init_registers_powerpc_isa205_32l ();
init_registers_powerpc_isa205_altivec32l ();
init_registers_powerpc_isa205_vsx32l ();
init_registers_powerpc_isa205_ppr_dscr_vsx32l ();
init_registers_powerpc_isa207_vsx32l ();
init_registers_powerpc_isa207_htm_vsx32l ();
init_registers_powerpc_e500l ();
#if __powerpc64__
init_registers_powerpc_64l ();
init_registers_powerpc_altivec64l ();
init_registers_powerpc_vsx64l ();
init_registers_powerpc_isa205_64l ();
init_registers_powerpc_isa205_altivec64l ();
init_registers_powerpc_isa205_vsx64l ();
init_registers_powerpc_isa205_ppr_dscr_vsx64l ();
init_registers_powerpc_isa207_vsx64l ();
init_registers_powerpc_isa207_htm_vsx64l ();
#endif
initialize_regsets_info (&ppc_regsets_info);
}
Reference in New Issue View Git Blame Copy Permalink