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 "frame.h"
/* On Windowed ABI, we use a6 through a11 for passing arguments
to a function called by GDB because CALL4 is used. */
-#define ARGS_FIRST_REG A6_REGNUM
+#define ARGS_FIRST_REG gdbarch_tdep (current_gdbarch)->a0_base + 6
#define ARGS_NUM_REGS 6
#define REGISTER_SIZE 4
/* Convert a live Ax register number to the corresponding Areg number. */
#define AREG_NUMBER(r, wb) \
- ((((r) - A0_REGNUM + (((wb) & WB_MASK) << WB_SHIFT)) & AREGS_MASK) + AR_BASE)
+ ((((r) - (gdbarch_tdep (current_gdbarch)->a0_base + 0) + (((wb) \
+ & ((gdbarch_tdep (current_gdbarch)->num_aregs - 1) >> 2)) << WB_SHIFT)) & \
+ (gdbarch_tdep (current_gdbarch)->num_aregs - 1)) \
+ + gdbarch_tdep (current_gdbarch)->ar_base)
/* ABI-independent macros. */
-#define ARG_NOF (CALL_ABI == CallAbiCall0Only ? C0_NARGS : (ARGS_NUM_REGS))
-#define ARG_1ST (CALL_ABI == CallAbiCall0Only \
- ? (A0_REGNUM) + C0_ARGS : (ARGS_FIRST_REG))
+#define ARG_NOF (gdbarch_tdep (current_gdbarch)->call_abi \
+ == CallAbiCall0Only ? C0_NARGS : (ARGS_NUM_REGS))
+#define ARG_1ST (gdbarch_tdep (current_gdbarch)->call_abi \
+ == CallAbiCall0Only \
+ ? (gdbarch_tdep (current_gdbarch)->a0_base + 0) + C0_ARGS \
+ : (ARGS_FIRST_REG))
extern struct gdbarch_tdep *xtensa_config_tdep (struct gdbarch_info *);
extern int xtensa_config_byte_order (struct gdbarch_info *);
/* Returns the name of a register. */
static const char *
-xtensa_register_name (int regnum)
+xtensa_register_name (struct gdbarch *gdbarch, int regnum)
{
/* Return the name stored in the register map. */
- if (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch))
- return REGMAP[regnum].name;
+ if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch))
+ return gdbarch_tdep (gdbarch)->regmap[regnum].name;
internal_error (__FILE__, __LINE__, _("invalid register %d"), regnum);
return 0;
xtensa_register_type (struct gdbarch *gdbarch, int regnum)
{
/* Return signed integer for ARx and Ax registers. */
- if ((regnum >= AR_BASE && regnum < AR_BASE + NUM_AREGS)
- || (regnum >= A0_BASE && regnum < A0_BASE + 16))
+ if ((regnum >= gdbarch_tdep (gdbarch)->ar_base
+ && regnum < gdbarch_tdep (gdbarch)->ar_base
+ + gdbarch_tdep (gdbarch)->num_aregs)
+ || (regnum >= gdbarch_tdep (gdbarch)->a0_base
+ && regnum < gdbarch_tdep (gdbarch)->a0_base + 16))
return builtin_type_int;
- if (regnum == gdbarch_pc_regnum (current_gdbarch) || regnum == A1_REGNUM)
+ if (regnum == gdbarch_pc_regnum (gdbarch)
+ || regnum == gdbarch_tdep (gdbarch)->a0_base + 1)
return lookup_pointer_type (builtin_type_void);
/* Return the stored type for all other registers. */
- else if (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch))
+ else if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch))
{
- xtensa_register_t* reg = ®MAP[regnum];
+ xtensa_register_t* reg = &gdbarch_tdep (gdbarch)->regmap[regnum];
/* Set ctype for this register (only the first time). */
int i;
if (regnum >= 0 && regnum < 16)
- return A0_BASE + regnum;
+ return gdbarch_tdep (current_gdbarch)->a0_base + regnum;
for (i = 0;
i < gdbarch_num_regs (current_gdbarch)
+ gdbarch_num_pseudo_regs (current_gdbarch);
i++)
- if (regnum == REGMAP[i].target_number)
+ if (regnum == gdbarch_tdep (current_gdbarch)->regmap[i].target_number)
return i;
internal_error (__FILE__, __LINE__,
DEBUGTRACE ("xtensa_register_write_masked ()\n");
/* Copy the masked register to host byte-order. */
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (get_regcache_arch (regcache)) == BFD_ENDIAN_BIG)
for (i = 0; i < bytesize; i++)
{
mem >>= 8;
ptr = value;
mem = *ptr;
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (get_regcache_arch (regcache)) == BFD_ENDIAN_BIG)
for (i = 0; i < bytesize; i++)
{
if ((i & 3) == 0)
gdb_byte *buffer)
{
DEBUGTRACE ("xtensa_pseudo_register_read (... regnum = %d (%s) ...)\n",
- regnum, xtensa_register_name (regnum));
+ regnum, xtensa_register_name (gdbarch, regnum));
- if (regnum == FP_ALIAS)
- regnum = A1_REGNUM;
+ if (regnum == gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch))
+ regnum = gdbarch_tdep (gdbarch)->a0_base + 1;
/* Read aliases a0..a15, if this is a Windowed ABI. */
- if (ISA_USE_WINDOWED_REGISTERS
- && (regnum >= A0_REGNUM) && (regnum <= A15_REGNUM))
+ if (gdbarch_tdep (gdbarch)->isa_use_windowed_registers
+ && (regnum >= gdbarch_tdep (gdbarch)->a0_base + 0)
+ && (regnum <= gdbarch_tdep (gdbarch)->a0_base + 15))
{
gdb_byte *buf = (gdb_byte *) alloca (MAX_REGISTER_SIZE);
- regcache_raw_read (regcache, WB_REGNUM, buf);
+ regcache_raw_read (regcache, gdbarch_tdep (gdbarch)->wb_regnum, buf);
regnum = AREG_NUMBER (regnum, extract_unsigned_integer (buf, 4));
}
/* We can always read non-pseudo registers. */
- if (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch))
+ if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch))
regcache_raw_read (regcache, regnum, buffer);
/* Pseudo registers. */
else if (regnum >= 0
- && regnum < gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch))
+ && regnum < gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch))
{
- xtensa_register_t *reg = ®MAP[regnum];
+ xtensa_register_t *reg = &gdbarch_tdep (gdbarch)->regmap[regnum];
xtensa_register_type_t type = reg->type;
- int flags = XTENSA_TARGET_FLAGS;
+ int flags = gdbarch_tdep (gdbarch)->target_flags;
/* We cannot read Unknown or Unmapped registers. */
if (type == xtRegisterTypeUnmapped || type == xtRegisterTypeUnknown)
if ((flags & xtTargetFlagsNonVisibleRegs) == 0)
{
warning (_("cannot read register %s"),
- xtensa_register_name (regnum));
+ xtensa_register_name (gdbarch, regnum));
return;
}
}
const gdb_byte *buffer)
{
DEBUGTRACE ("xtensa_pseudo_register_write (... regnum = %d (%s) ...)\n",
- regnum, xtensa_register_name (regnum));
+ regnum, xtensa_register_name (gdbarch, regnum));
- if (regnum == FP_ALIAS)
- regnum = A1_REGNUM;
+ if (regnum == gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch))
+ regnum = gdbarch_tdep (gdbarch)->a0_base + 1;
/* Renumber register, if aliase a0..a15 on Windowed ABI. */
- if (ISA_USE_WINDOWED_REGISTERS
- && (regnum >= A0_REGNUM) && (regnum <= A15_REGNUM))
+ if (gdbarch_tdep (gdbarch)->isa_use_windowed_registers
+ && (regnum >= gdbarch_tdep (gdbarch)->a0_base + 0)
+ && (regnum <= gdbarch_tdep (gdbarch)->a0_base + 15))
{
gdb_byte *buf = (gdb_byte *) alloca (MAX_REGISTER_SIZE);
unsigned int wb;
- regcache_raw_read (regcache, WB_REGNUM, buf);
+ regcache_raw_read (regcache,
+ gdbarch_tdep (gdbarch)->wb_regnum, buf);
regnum = AREG_NUMBER (regnum, extract_unsigned_integer (buf, 4));
}
/* We can always write 'core' registers.
Note: We might have converted Ax->ARy. */
- if (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch))
+ if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch))
regcache_raw_write (regcache, regnum, buffer);
/* Pseudo registers. */
else if (regnum >= 0
- && regnum < gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch))
+ && regnum < gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch))
{
- xtensa_register_t *reg = ®MAP[regnum];
+ xtensa_register_t *reg = &gdbarch_tdep (gdbarch)->regmap[regnum];
xtensa_register_type_t type = reg->type;
- int flags = XTENSA_TARGET_FLAGS;
+ int flags = gdbarch_tdep (gdbarch)->target_flags;
/* On most targets, we cannot write registers
of type "Unknown" or "Unmapped". */
if ((flags & xtTargetFlagsNonVisibleRegs) == 0)
{
warning (_("cannot write register %s"),
- xtensa_register_name (regnum));
+ xtensa_register_name (gdbarch, regnum));
return;
}
}
int regnum,
struct reggroup *group)
{
- xtensa_register_t* reg = ®MAP[regnum];
+ xtensa_register_t* reg = &gdbarch_tdep (gdbarch)->regmap[regnum];
xtensa_register_type_t type = reg->type;
xtensa_register_group_t rg = reg->group;
int cp_number;
if (group == vector_reggroup || group == xtensa_vectra_reggroup)
return rg & xtRegisterGroupVectra;
if (group == save_reggroup || group == restore_reggroup)
- return (regnum < gdbarch_num_regs (current_gdbarch)
+ return (regnum < gdbarch_num_regs (gdbarch)
&& (reg->flags & SAVE_REST_FLAGS) == SAVE_REST_VALID);
if ((cp_number = xtensa_coprocessor_register_group (group)) >= 0)
return rg & (xtRegisterGroupCP0 << cp_number);
size_t len)
{
const xtensa_elf_gregset_t *regs = gregs;
+ struct gdbarch *gdbarch = get_regcache_arch (rc);
int i;
DEBUGTRACE ("xtensa_supply_gregset (..., regnum==%d, ...) \n", regnum);
- if (regnum == gdbarch_pc_regnum (current_gdbarch) || regnum == -1)
- regcache_raw_supply (rc,
- gdbarch_pc_regnum (current_gdbarch),
- (char *) ®s->pc);
- if (regnum == gdbarch_ps_regnum (current_gdbarch) || regnum == -1)
- regcache_raw_supply (rc, gdbarch_ps_regnum (current_gdbarch),
- (char *) ®s->ps);
- if (regnum == WB_REGNUM || regnum == -1)
- regcache_raw_supply (rc, WB_REGNUM, (char *) ®s->windowbase);
- if (regnum == WS_REGNUM || regnum == -1)
- regcache_raw_supply (rc, WS_REGNUM, (char *) ®s->windowstart);
- if (regnum == LBEG_REGNUM || regnum == -1)
- regcache_raw_supply (rc, LBEG_REGNUM, (char *) ®s->lbeg);
- if (regnum == LEND_REGNUM || regnum == -1)
- regcache_raw_supply (rc, LEND_REGNUM, (char *) ®s->lend);
- if (regnum == LCOUNT_REGNUM || regnum == -1)
- regcache_raw_supply (rc, LCOUNT_REGNUM, (char *) ®s->lcount);
- if (regnum == SAR_REGNUM || regnum == -1)
- regcache_raw_supply (rc, SAR_REGNUM, (char *) ®s->sar);
- if (regnum == EXCCAUSE_REGNUM || regnum == -1)
- regcache_raw_supply (rc, EXCCAUSE_REGNUM, (char *) ®s->exccause);
- if (regnum == EXCVADDR_REGNUM || regnum == -1)
- regcache_raw_supply (rc, EXCVADDR_REGNUM, (char *) ®s->excvaddr);
- if (regnum >= AR_BASE && regnum < AR_BASE + NUM_AREGS)
- regcache_raw_supply (rc, regnum, (char *) ®s->ar[regnum - AR_BASE]);
+ if (regnum == gdbarch_pc_regnum (gdbarch) || regnum == -1)
+ regcache_raw_supply (rc, gdbarch_pc_regnum (gdbarch), (char *) ®s->pc);
+ if (regnum == gdbarch_ps_regnum (gdbarch) || regnum == -1)
+ regcache_raw_supply (rc, gdbarch_ps_regnum (gdbarch), (char *) ®s->ps);
+ if (regnum == gdbarch_tdep (gdbarch)->wb_regnum || regnum == -1)
+ regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->wb_regnum,
+ (char *) ®s->windowbase);
+ if (regnum == gdbarch_tdep (gdbarch)->ws_regnum || regnum == -1)
+ regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->ws_regnum,
+ (char *) ®s->windowstart);
+ if (regnum == gdbarch_tdep (gdbarch)->lbeg_regnum || regnum == -1)
+ regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->lbeg_regnum,
+ (char *) ®s->lbeg);
+ if (regnum == gdbarch_tdep (gdbarch)->lend_regnum || regnum == -1)
+ regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->lend_regnum,
+ (char *) ®s->lend);
+ if (regnum == gdbarch_tdep (gdbarch)->lcount_regnum || regnum == -1)
+ regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->lcount_regnum,
+ (char *) ®s->lcount);
+ if (regnum == gdbarch_tdep (gdbarch)->sar_regnum || regnum == -1)
+ regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->sar_regnum,
+ (char *) ®s->sar);
+ if (regnum == gdbarch_tdep (gdbarch)->exccause_regnum || regnum == -1)
+ regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->exccause_regnum,
+ (char *) ®s->exccause);
+ if (regnum == gdbarch_tdep (gdbarch)->excvaddr_regnum || regnum == -1)
+ regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->excvaddr_regnum,
+ (char *) ®s->excvaddr);
+ if (regnum >=gdbarch_tdep (gdbarch)->ar_base
+ && regnum < gdbarch_tdep (gdbarch)->ar_base
+ + gdbarch_tdep (gdbarch)->num_aregs)
+ regcache_raw_supply (rc, regnum,
+ (char *) ®s->ar[regnum - gdbarch_tdep
+ (gdbarch)->ar_base]);
else if (regnum == -1)
{
- for (i = 0; i < NUM_AREGS; ++i)
- regcache_raw_supply (rc, AR_BASE + i, (char *) ®s->ar[i]);
+ for (i = 0; i < gdbarch_tdep (gdbarch)->num_aregs; ++i)
+ regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->ar_base + i,
+ (char *) ®s->ar[i]);
}
}
DEBUGTRACE ("xtensa_unwind_pc (next_frame = %p)\n", next_frame);
- frame_unwind_register (next_frame, gdbarch_pc_regnum (current_gdbarch), buf);
+ frame_unwind_register (next_frame, gdbarch_pc_regnum (gdbarch), buf);
DEBUGINFO ("[xtensa_unwind_pc] pc = 0x%08x\n", (unsigned int)
extract_typed_address (buf, builtin_type_void_func_ptr));
DEBUGTRACE ("xtensa_unwind_dummy_id ()\n");
pc = frame_pc_unwind (next_frame);
- fp = frame_unwind_register_unsigned (next_frame, A1_REGNUM);
+ fp = frame_unwind_register_unsigned
+ (next_frame, gdbarch_tdep (gdbarch)->a0_base + 1);
/* Make dummy frame ID unique by adding a constant. */
return frame_id_build (fp + SP_ALIGNMENT, pc);
{
xtensa_frame_cache_t *cache;
CORE_ADDR ra, wb, ws, pc, sp, ps;
- unsigned int ps_regnum = gdbarch_ps_regnum (current_gdbarch);
+ struct gdbarch *gdbarch = get_frame_arch (next_frame);
+ unsigned int ps_regnum = gdbarch_ps_regnum (gdbarch);
char op1;
int windowed;
*this_cache = cache;
pc = frame_unwind_register_unsigned (next_frame,
- gdbarch_pc_regnum (current_gdbarch));
+ gdbarch_pc_regnum (gdbarch));
if (windowed)
{
/* Get WINDOWBASE, WINDOWSTART, and PS registers. */
- wb = frame_unwind_register_unsigned (next_frame, WB_REGNUM);
- ws = frame_unwind_register_unsigned (next_frame, WS_REGNUM);
+ wb = frame_unwind_register_unsigned
+ (next_frame, gdbarch_tdep (gdbarch)->wb_regnum);
+ ws = frame_unwind_register_unsigned
+ (next_frame, gdbarch_tdep (gdbarch)->ws_regnum);
ps = frame_unwind_register_unsigned (next_frame, ps_regnum);
op1 = read_memory_integer (pc, 1);
if (XTENSA_IS_ENTRY (op1))
{
int callinc = CALLINC (ps);
- ra = frame_unwind_register_unsigned (next_frame,
- A0_REGNUM + callinc * 4);
+ ra = frame_unwind_register_unsigned
+ (next_frame, gdbarch_tdep (gdbarch)->a0_base + 0 + callinc * 4);
DEBUGINFO("[xtensa_frame_cache] 'entry' at 0x%08x\n (callinc = %d)",
(int)pc, callinc);
cache->wd.callsize = 0;
cache->wd.wb = wb;
cache->wd.ws = ws;
- cache->prev_sp = frame_unwind_register_unsigned (next_frame,
- A1_REGNUM);
+ cache->prev_sp = frame_unwind_register_unsigned
+ (next_frame, gdbarch_tdep (gdbarch)->a0_base + 1);
}
else
{
- ra = frame_unwind_register_unsigned (next_frame, A0_REGNUM);
+ ra = frame_unwind_register_unsigned
+ (next_frame, gdbarch_tdep (gdbarch)->a0_base + 0);
cache->wd.callsize = WINSIZE (ra);
- cache->wd.wb = (wb - cache->wd.callsize / 4) & (NUM_AREGS / 4 - 1);
+ cache->wd.wb = (wb - cache->wd.callsize / 4)
+ & (gdbarch_tdep (gdbarch)->num_aregs / 4 - 1);
cache->wd.ws = ws & ~(1 << wb);
}
int i;
/* Set A0...A3. */
- sp = frame_unwind_register_unsigned (next_frame, A1_REGNUM) - 16;
+ sp = frame_unwind_register_unsigned
+ (next_frame, gdbarch_tdep (gdbarch)->a0_base + 1) - 16;
for (i = 0; i < 4; i++, sp += 4)
{
We can read caller's SP from the proper spill loction. */
cache->prev_sp =
read_memory_integer (cache->wd.aregs[1],
- register_size (current_gdbarch,
- A1_REGNUM));
+ register_size (gdbarch,
+ gdbarch_tdep (gdbarch)->a0_base + 1));
}
else
{
/* Read caller's frame SP directly from the previous window. */
- int regnum = AREG_NUMBER (A1_REGNUM, cache->wd.wb);
+ int regnum = AREG_NUMBER
+ (gdbarch_tdep (gdbarch)->a0_base + 1,
+ cache->wd.wb);
cache->prev_sp = xtensa_read_register (regnum);
}
call0_frame_cache (next_frame, cache, pc);
}
- cache->base = frame_unwind_register_unsigned (next_frame,A1_REGNUM);
+ cache->base = frame_unwind_register_unsigned
+ (next_frame, gdbarch_tdep (gdbarch)->a0_base + 1);
return cache;
}
{
CORE_ADDR fp, spe;
int stkofs;
- int reg = (regnum >= AR_BASE && regnum <= (AR_BASE + C0_NREGS))
- ? regnum - AR_BASE : regnum;
+ struct gdbarch *gdbarch = get_frame_arch (next_frame);
+ int reg = (regnum >= gdbarch_tdep (gdbarch)->ar_base
+ && regnum <= (gdbarch_tdep (gdbarch)->ar_base + C0_NREGS))
+ ? regnum - gdbarch_tdep (gdbarch)->ar_base : regnum;
/* Determine stack pointer on entry to this function, based on FP. */
spe = cache->c0.c0_fp - cache->c0.c0_rt[cache->c0.fp_regnum].fr_ofs;
*addrp = spe + stkofs;
if (valuep)
- read_memory (*addrp, valuep, register_size (current_gdbarch, regnum));
+ read_memory (*addrp, valuep, register_size (gdbarch, regnum));
return 1;
}
int *realnump,
gdb_byte *valuep)
{
+ struct gdbarch *gdbarch = get_frame_arch (next_frame);
struct xtensa_frame_cache *cache =
xtensa_frame_cache (next_frame, this_cache);
CORE_ADDR saved_reg = 0;
"*this 0x%08x, regnum %d (%s), ...)\n",
(unsigned int) next_frame,
*this_cache ? (unsigned int) *this_cache : 0, regnum,
- xtensa_register_name (regnum));
+ xtensa_register_name (gdbarch, regnum));
- if (regnum ==gdbarch_pc_regnum (current_gdbarch))
+ if (regnum ==gdbarch_pc_regnum (gdbarch))
saved_reg = cache->ra;
- else if (regnum == A1_REGNUM)
+ else if (regnum == gdbarch_tdep (gdbarch)->a0_base + 1)
saved_reg = cache->prev_sp;
else if (!cache->call0)
{
- if (regnum == WS_REGNUM)
+ if (regnum == gdbarch_tdep (gdbarch)->ws_regnum)
{
if (cache->wd.ws != 0)
saved_reg = cache->wd.ws;
else
saved_reg = 1 << cache->wd.wb;
}
- else if (regnum == WB_REGNUM)
+ else if (regnum == gdbarch_tdep (gdbarch)->wb_regnum)
saved_reg = cache->wd.wb;
- else if (regnum == gdbarch_ps_regnum (current_gdbarch))
+ else if (regnum == gdbarch_ps_regnum (gdbarch))
saved_reg = cache->ps;
else
done = 0;
if (!cache->call0) /* Windowed ABI. */
{
/* Convert A-register numbers to AR-register numbers. */
- if (regnum >= A0_REGNUM && regnum <= A15_REGNUM)
+ if (regnum >= gdbarch_tdep (gdbarch)->a0_base + 0
+ && regnum <= gdbarch_tdep (gdbarch)->a0_base + 15)
regnum = AREG_NUMBER (regnum, cache->wd.wb);
/* Check if AR-register has been saved to stack. */
- if (regnum >= AR_BASE && regnum <= (AR_BASE + NUM_AREGS))
+ if (regnum >= gdbarch_tdep (gdbarch)->ar_base
+ && regnum <= (gdbarch_tdep (gdbarch)->ar_base
+ + gdbarch_tdep (gdbarch)->num_aregs))
{
- int areg = regnum - AR_BASE - (cache->wd.wb * 4);
+ int areg = regnum - gdbarch_tdep (gdbarch)->ar_base
+ - (cache->wd.wb * 4);
if (areg >= 0
&& areg < XTENSA_NUM_SAVED_AREGS
if (valuep)
read_memory (*addrp, valuep,
- register_size (current_gdbarch, regnum));
+ register_size (gdbarch, regnum));
DEBUGINFO ("[xtensa_frame_prev_register] register on stack\n");
return;
}
else /* Call0 ABI. */
{
- int reg = (regnum >= AR_BASE && regnum <= (AR_BASE + C0_NREGS))
- ? regnum - AR_BASE : regnum;
+ int reg = (regnum >= gdbarch_tdep (gdbarch)->ar_base
+ && regnum <= (gdbarch_tdep (gdbarch)->ar_base
+ + C0_NREGS))
+ ? regnum - gdbarch_tdep (gdbarch)->ar_base : regnum;
if (reg < C0_NREGS)
{
if (valuep)
read_memory (*addrp, valuep,
- register_size (current_gdbarch, regnum));
+ register_size (gdbarch, regnum));
DEBUGINFO ("[xtensa_frame_prev_register] register on stack\n");
return;
struct regcache *regcache,
void *dst)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
bfd_byte *valbuf = dst;
int len = TYPE_LENGTH (type);
ULONGEST pc, wb;
gdb_assert(len > 0);
- if (CALL_ABI != CallAbiCall0Only)
+ if (gdbarch_tdep (gdbarch)->call_abi != CallAbiCall0Only)
{
/* First, we have to find the caller window in the register file. */
- regcache_raw_read_unsigned (regcache,
- gdbarch_pc_regnum (current_gdbarch), &pc);
+ regcache_raw_read_unsigned (regcache, gdbarch_pc_regnum (gdbarch), &pc);
callsize = extract_call_winsize (pc);
/* On Xtensa, we can return up to 4 words (or 2 for call12). */
/* Get the register offset of the return
register (A2) in the caller window. */
- regcache_raw_read_unsigned (regcache, WB_REGNUM, &wb);
- areg = AREG_NUMBER(A2_REGNUM + callsize, wb);
+ regcache_raw_read_unsigned
+ (regcache, gdbarch_tdep (gdbarch)->wb_regnum, &wb);
+ areg = AREG_NUMBER(gdbarch_tdep (gdbarch)->a0_base + 2 + callsize, wb);
}
else
{
/* No windowing hardware - Call0 ABI. */
- areg = A0_REGNUM + C0_ARGS;
+ areg = gdbarch_tdep (gdbarch)->a0_base + 0 + C0_ARGS;
}
DEBUGINFO ("[xtensa_extract_return_value] areg %d len %d\n", areg, len);
- if (len < 4 && gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (len < 4 && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
offset = 4 - len;
for (; len > 0; len -= 4, areg++, valbuf += 4)
struct regcache *regcache,
const void *dst)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
const bfd_byte *valbuf = dst;
unsigned int areg;
ULONGEST pc, wb;
DEBUGTRACE ("xtensa_store_return_value (...)\n");
- if (CALL_ABI != CallAbiCall0Only)
+ if (gdbarch_tdep (gdbarch)->call_abi != CallAbiCall0Only)
{
- regcache_raw_read_unsigned (regcache, WB_REGNUM, &wb);
- regcache_raw_read_unsigned (regcache,
- gdbarch_pc_regnum (current_gdbarch), &pc);
+ regcache_raw_read_unsigned
+ (regcache, gdbarch_tdep (gdbarch)->wb_regnum, &wb);
+ regcache_raw_read_unsigned (regcache, gdbarch_pc_regnum (gdbarch), &pc);
callsize = extract_call_winsize (pc);
if (len > (callsize > 8 ? 8 : 16))
internal_error (__FILE__, __LINE__,
_("unimplemented for this length: %d"),
TYPE_LENGTH (type));
- areg = AREG_NUMBER (A2_REGNUM + callsize, wb);
+ areg = AREG_NUMBER (gdbarch_tdep (gdbarch)->a0_base + 2 + callsize, wb);
DEBUGTRACE ("[xtensa_store_return_value] callsize %d wb %d\n",
callsize, (int) wb);
}
else
{
- areg = A0_REGNUM + C0_ARGS;
+ areg = gdbarch_tdep (gdbarch)->a0_base + 0 + C0_ARGS;
}
- if (len < 4 && gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (len < 4 && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
offset = 4 - len;
for (; len > 0; len -= 4, areg++, valbuf += 4)
sp = align_down (sp - onstack_size, SP_ALIGNMENT);
/* Simulate MOVSP, if Windowed ABI. */
- if ((CALL_ABI != CallAbiCall0Only) && (sp != osp))
+ if ((gdbarch_tdep (gdbarch)->call_abi != CallAbiCall0Only)
+ && (sp != osp))
{
read_memory (osp - 16, buf, 16);
write_memory (sp - 16, buf, 16);
applies for structures smaller than one word. */
if (n < REGISTER_SIZE
- && gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
offset += (REGISTER_SIZE - n);
write_memory (offset, info->contents, info->length);
will be left-aligned in the register on both endiannesses. */
if (n < REGISTER_SIZE
- && gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
{
ULONGEST v = extract_unsigned_integer (cp, REGISTER_SIZE);
v = v >> ((REGISTER_SIZE - n) * TARGET_CHAR_BIT);
The return address for the current function (in A0) is
saved in the dummy frame, so we can savely overwrite A0 here. */
- if (CALL_ABI != CallAbiCall0Only)
+ if (gdbarch_tdep (gdbarch)->call_abi != CallAbiCall0Only)
{
ra = (bp_addr & 0x3fffffff) | 0x40000000;
- regcache_raw_read (regcache, gdbarch_ps_regnum (current_gdbarch), buf);
+ regcache_raw_read (regcache, gdbarch_ps_regnum (gdbarch), buf);
ps = extract_unsigned_integer (buf, 4) & ~0x00030000;
- regcache_cooked_write_unsigned (regcache, A4_REGNUM, ra);
+ regcache_cooked_write_unsigned
+ (regcache, gdbarch_tdep (gdbarch)->a0_base + 4, ra);
regcache_cooked_write_unsigned (regcache,
- gdbarch_ps_regnum (current_gdbarch),
+ gdbarch_ps_regnum (gdbarch),
ps | 0x00010000);
}
else
{
/* Simulate CALL0: write RA into A0 register. */
- regcache_cooked_write_unsigned (regcache, A0_REGNUM, bp_addr);
+ regcache_cooked_write_unsigned
+ (regcache, gdbarch_tdep (gdbarch)->a0_base + 0, bp_addr);
}
/* Set new stack pointer and return it. */
- regcache_cooked_write_unsigned (regcache, A1_REGNUM, sp);
+ regcache_cooked_write_unsigned (regcache,
+ gdbarch_tdep (gdbarch)->a0_base + 1, sp);
/* Make dummy frame ID unique by adding a constant. */
return sp + SP_ALIGNMENT;
}
DEBUGTRACE ("xtensa_breakpoint_from_pc (pc = 0x%08x)\n", (int) *pcptr);
- if (ISA_USE_DENSITY_INSTRUCTIONS)
+ if (gdbarch_tdep (current_gdbarch)->isa_use_density_instructions)
{
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
{
/* 2 operands: dst, literal offset. */
gdb_assert (nods == 2);
/* litbase = xtensa_get_litbase (pc); can be also used. */
- litbase = (LITBASE_REGNUM == -1)
- ? 0 : xtensa_read_register (LITBASE_REGNUM);
+ litbase = (gdbarch_tdep (current_gdbarch)->litbase_regnum == -1)
+ ? 0 : xtensa_read_register
+ (gdbarch_tdep (current_gdbarch)->litbase_regnum);
litaddr = litbase & 1
? (litbase & ~1) + (signed)odv[1]
: (pc + 3 + (signed)odv[1]) & ~3;
call0_frame_cache (struct frame_info *next_frame,
xtensa_frame_cache_t *cache, CORE_ADDR pc)
{
+ struct gdbarch *gdbarch = get_frame_arch (next_frame);
CORE_ADDR start_pc; /* The beginning of the function. */
CORE_ADDR body_pc=UINT_MAX; /* PC, where prologue analysis stopped. */
CORE_ADDR sp, fp, ra;
&cache->call0);
}
- sp = frame_unwind_register_unsigned (next_frame, A1_REGNUM);
+ sp = frame_unwind_register_unsigned
+ (next_frame, gdbarch_tdep (gdbarch)->a0_base + 1);
fp = sp; /* Assume FP == SP until proven otherwise. */
/* Get the frame information and FP (if used) at the current PC.
was derived from SP. Otherwise, it would be C0_FP. */
fp_regnum = c0_hasfp ? C0_FP : C0_SP;
c0_frmsz = - cache->c0.c0_rt[fp_regnum].fr_ofs;
- fp_regnum += A0_BASE;
+ fp_regnum += gdbarch_tdep (gdbarch)->a0_base;
}
else /* No data from the prologue analysis. */
{
c0_hasfp = 0;
- fp_regnum = A0_BASE + C0_SP;
+ fp_regnum = gdbarch_tdep (gdbarch)->a0_base + C0_SP;
c0_frmsz = 0;
start_pc = pc;
}
i = C0_RA;
if (i < C0_NREGS) /* Read from the next_frame. */
{
- ra = frame_unwind_register_unsigned (next_frame,
- A0_REGNUM + cache->c0.c0_rt[i].fr_reg);
+ ra = frame_unwind_register_unsigned
+ (next_frame,
+ gdbarch_tdep (gdbarch)->a0_base + 0
+ + cache->c0.c0_rt[i].fr_reg);
}
else ra = 0;
}
}
static void
-xtensa_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
+xtensa_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
{
error (_("xtensa_dump_tdep(): not implemented"));
}