/* Target-dependent code for the IQ2000 architecture, for GDB, the GNU
|
/* Target-dependent code for the IQ2000 architecture, for GDB, the GNU
|
Debugger.
|
Debugger.
|
|
|
Copyright (C) 2000, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
|
Copyright (C) 2000, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
|
|
|
Contributed by Red Hat.
|
Contributed by Red Hat.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
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
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "frame.h"
|
#include "frame.h"
|
#include "frame-base.h"
|
#include "frame-base.h"
|
#include "frame-unwind.h"
|
#include "frame-unwind.h"
|
#include "dwarf2-frame.h"
|
#include "dwarf2-frame.h"
|
#include "gdbtypes.h"
|
#include "gdbtypes.h"
|
#include "value.h"
|
#include "value.h"
|
#include "dis-asm.h"
|
#include "dis-asm.h"
|
#include "gdb_string.h"
|
#include "gdb_string.h"
|
#include "arch-utils.h"
|
#include "arch-utils.h"
|
#include "regcache.h"
|
#include "regcache.h"
|
#include "osabi.h"
|
#include "osabi.h"
|
#include "gdbcore.h"
|
#include "gdbcore.h"
|
|
|
enum gdb_regnum
|
enum gdb_regnum
|
{
|
{
|
E_R0_REGNUM, E_R1_REGNUM, E_R2_REGNUM, E_R3_REGNUM,
|
E_R0_REGNUM, E_R1_REGNUM, E_R2_REGNUM, E_R3_REGNUM,
|
E_R4_REGNUM, E_R5_REGNUM, E_R6_REGNUM, E_R7_REGNUM,
|
E_R4_REGNUM, E_R5_REGNUM, E_R6_REGNUM, E_R7_REGNUM,
|
E_R8_REGNUM, E_R9_REGNUM, E_R10_REGNUM, E_R11_REGNUM,
|
E_R8_REGNUM, E_R9_REGNUM, E_R10_REGNUM, E_R11_REGNUM,
|
E_R12_REGNUM, E_R13_REGNUM, E_R14_REGNUM, E_R15_REGNUM,
|
E_R12_REGNUM, E_R13_REGNUM, E_R14_REGNUM, E_R15_REGNUM,
|
E_R16_REGNUM, E_R17_REGNUM, E_R18_REGNUM, E_R19_REGNUM,
|
E_R16_REGNUM, E_R17_REGNUM, E_R18_REGNUM, E_R19_REGNUM,
|
E_R20_REGNUM, E_R21_REGNUM, E_R22_REGNUM, E_R23_REGNUM,
|
E_R20_REGNUM, E_R21_REGNUM, E_R22_REGNUM, E_R23_REGNUM,
|
E_R24_REGNUM, E_R25_REGNUM, E_R26_REGNUM, E_R27_REGNUM,
|
E_R24_REGNUM, E_R25_REGNUM, E_R26_REGNUM, E_R27_REGNUM,
|
E_R28_REGNUM, E_R29_REGNUM, E_R30_REGNUM, E_R31_REGNUM,
|
E_R28_REGNUM, E_R29_REGNUM, E_R30_REGNUM, E_R31_REGNUM,
|
E_PC_REGNUM,
|
E_PC_REGNUM,
|
E_LR_REGNUM = E_R31_REGNUM, /* Link register. */
|
E_LR_REGNUM = E_R31_REGNUM, /* Link register. */
|
E_SP_REGNUM = E_R29_REGNUM, /* Stack pointer. */
|
E_SP_REGNUM = E_R29_REGNUM, /* Stack pointer. */
|
E_FP_REGNUM = E_R27_REGNUM, /* Frame pointer. */
|
E_FP_REGNUM = E_R27_REGNUM, /* Frame pointer. */
|
E_FN_RETURN_REGNUM = E_R2_REGNUM, /* Function return value register. */
|
E_FN_RETURN_REGNUM = E_R2_REGNUM, /* Function return value register. */
|
E_1ST_ARGREG = E_R4_REGNUM, /* 1st function arg register. */
|
E_1ST_ARGREG = E_R4_REGNUM, /* 1st function arg register. */
|
E_LAST_ARGREG = E_R11_REGNUM, /* Last function arg register. */
|
E_LAST_ARGREG = E_R11_REGNUM, /* Last function arg register. */
|
E_NUM_REGS = E_PC_REGNUM + 1
|
E_NUM_REGS = E_PC_REGNUM + 1
|
};
|
};
|
|
|
/* Use an invalid address value as 'not available' marker. */
|
/* Use an invalid address value as 'not available' marker. */
|
enum { REG_UNAVAIL = (CORE_ADDR) -1 };
|
enum { REG_UNAVAIL = (CORE_ADDR) -1 };
|
|
|
struct iq2000_frame_cache
|
struct iq2000_frame_cache
|
{
|
{
|
/* Base address. */
|
/* Base address. */
|
CORE_ADDR base;
|
CORE_ADDR base;
|
CORE_ADDR pc;
|
CORE_ADDR pc;
|
LONGEST framesize;
|
LONGEST framesize;
|
int using_fp;
|
int using_fp;
|
CORE_ADDR saved_sp;
|
CORE_ADDR saved_sp;
|
CORE_ADDR saved_regs [E_NUM_REGS];
|
CORE_ADDR saved_regs [E_NUM_REGS];
|
};
|
};
|
|
|
/* Harvard methods: */
|
/* Harvard methods: */
|
|
|
static CORE_ADDR
|
static CORE_ADDR
|
insn_ptr_from_addr (CORE_ADDR addr) /* CORE_ADDR to target pointer. */
|
insn_ptr_from_addr (CORE_ADDR addr) /* CORE_ADDR to target pointer. */
|
{
|
{
|
return addr & 0x7fffffffL;
|
return addr & 0x7fffffffL;
|
}
|
}
|
|
|
static CORE_ADDR
|
static CORE_ADDR
|
insn_addr_from_ptr (CORE_ADDR ptr) /* target_pointer to CORE_ADDR. */
|
insn_addr_from_ptr (CORE_ADDR ptr) /* target_pointer to CORE_ADDR. */
|
{
|
{
|
return (ptr & 0x7fffffffL) | 0x80000000L;
|
return (ptr & 0x7fffffffL) | 0x80000000L;
|
}
|
}
|
|
|
/* Function: pointer_to_address
|
/* Function: pointer_to_address
|
Convert a target pointer to an address in host (CORE_ADDR) format. */
|
Convert a target pointer to an address in host (CORE_ADDR) format. */
|
|
|
static CORE_ADDR
|
static CORE_ADDR
|
iq2000_pointer_to_address (struct type * type, const gdb_byte * buf)
|
iq2000_pointer_to_address (struct type * type, const gdb_byte * buf)
|
{
|
{
|
enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
|
enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
|
CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
|
CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
|
|
|
if (target == TYPE_CODE_FUNC
|
if (target == TYPE_CODE_FUNC
|
|| target == TYPE_CODE_METHOD
|
|| target == TYPE_CODE_METHOD
|
|| (TYPE_FLAGS (TYPE_TARGET_TYPE (type)) & TYPE_FLAG_CODE_SPACE) != 0)
|
|| (TYPE_FLAGS (TYPE_TARGET_TYPE (type)) & TYPE_FLAG_CODE_SPACE) != 0)
|
addr = insn_addr_from_ptr (addr);
|
addr = insn_addr_from_ptr (addr);
|
|
|
return addr;
|
return addr;
|
}
|
}
|
|
|
/* Function: address_to_pointer
|
/* Function: address_to_pointer
|
Convert a host-format address (CORE_ADDR) into a target pointer. */
|
Convert a host-format address (CORE_ADDR) into a target pointer. */
|
|
|
static void
|
static void
|
iq2000_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr)
|
iq2000_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr)
|
{
|
{
|
enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
|
enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
|
|
|
if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
|
if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
|
addr = insn_ptr_from_addr (addr);
|
addr = insn_ptr_from_addr (addr);
|
store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
|
store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
|
}
|
}
|
|
|
/* Real register methods: */
|
/* Real register methods: */
|
|
|
/* Function: register_name
|
/* Function: register_name
|
Returns the name of the iq2000 register number N. */
|
Returns the name of the iq2000 register number N. */
|
|
|
static const char *
|
static const char *
|
iq2000_register_name (struct gdbarch *gdbarch, int regnum)
|
iq2000_register_name (struct gdbarch *gdbarch, int regnum)
|
{
|
{
|
static const char * names[E_NUM_REGS] =
|
static const char * names[E_NUM_REGS] =
|
{
|
{
|
"r0", "r1", "r2", "r3", "r4",
|
"r0", "r1", "r2", "r3", "r4",
|
"r5", "r6", "r7", "r8", "r9",
|
"r5", "r6", "r7", "r8", "r9",
|
"r10", "r11", "r12", "r13", "r14",
|
"r10", "r11", "r12", "r13", "r14",
|
"r15", "r16", "r17", "r18", "r19",
|
"r15", "r16", "r17", "r18", "r19",
|
"r20", "r21", "r22", "r23", "r24",
|
"r20", "r21", "r22", "r23", "r24",
|
"r25", "r26", "r27", "r28", "r29",
|
"r25", "r26", "r27", "r28", "r29",
|
"r30", "r31",
|
"r30", "r31",
|
"pc"
|
"pc"
|
};
|
};
|
if (regnum < 0 || regnum >= E_NUM_REGS)
|
if (regnum < 0 || regnum >= E_NUM_REGS)
|
return NULL;
|
return NULL;
|
return names[regnum];
|
return names[regnum];
|
}
|
}
|
|
|
/* Prologue analysis methods: */
|
/* Prologue analysis methods: */
|
|
|
/* ADDIU insn (001001 rs(5) rt(5) imm(16)). */
|
/* ADDIU insn (001001 rs(5) rt(5) imm(16)). */
|
#define INSN_IS_ADDIU(X) (((X) & 0xfc000000) == 0x24000000)
|
#define INSN_IS_ADDIU(X) (((X) & 0xfc000000) == 0x24000000)
|
#define ADDIU_REG_SRC(X) (((X) & 0x03e00000) >> 21)
|
#define ADDIU_REG_SRC(X) (((X) & 0x03e00000) >> 21)
|
#define ADDIU_REG_TGT(X) (((X) & 0x001f0000) >> 16)
|
#define ADDIU_REG_TGT(X) (((X) & 0x001f0000) >> 16)
|
#define ADDIU_IMMEDIATE(X) ((signed short) ((X) & 0x0000ffff))
|
#define ADDIU_IMMEDIATE(X) ((signed short) ((X) & 0x0000ffff))
|
|
|
/* "MOVE" (OR) insn (000000 rs(5) rt(5) rd(5) 00000 100101). */
|
/* "MOVE" (OR) insn (000000 rs(5) rt(5) rd(5) 00000 100101). */
|
#define INSN_IS_MOVE(X) (((X) & 0xffe007ff) == 0x00000025)
|
#define INSN_IS_MOVE(X) (((X) & 0xffe007ff) == 0x00000025)
|
#define MOVE_REG_SRC(X) (((X) & 0x001f0000) >> 16)
|
#define MOVE_REG_SRC(X) (((X) & 0x001f0000) >> 16)
|
#define MOVE_REG_TGT(X) (((X) & 0x0000f800) >> 11)
|
#define MOVE_REG_TGT(X) (((X) & 0x0000f800) >> 11)
|
|
|
/* STORE WORD insn (101011 rs(5) rt(5) offset(16)). */
|
/* STORE WORD insn (101011 rs(5) rt(5) offset(16)). */
|
#define INSN_IS_STORE_WORD(X) (((X) & 0xfc000000) == 0xac000000)
|
#define INSN_IS_STORE_WORD(X) (((X) & 0xfc000000) == 0xac000000)
|
#define SW_REG_INDEX(X) (((X) & 0x03e00000) >> 21)
|
#define SW_REG_INDEX(X) (((X) & 0x03e00000) >> 21)
|
#define SW_REG_SRC(X) (((X) & 0x001f0000) >> 16)
|
#define SW_REG_SRC(X) (((X) & 0x001f0000) >> 16)
|
#define SW_OFFSET(X) ((signed short) ((X) & 0x0000ffff))
|
#define SW_OFFSET(X) ((signed short) ((X) & 0x0000ffff))
|
|
|
/* Function: find_last_line_symbol
|
/* Function: find_last_line_symbol
|
|
|
Given an address range, first find a line symbol corresponding to
|
Given an address range, first find a line symbol corresponding to
|
the starting address. Then find the last line symbol within the
|
the starting address. Then find the last line symbol within the
|
range that has a line number less than or equal to the first line.
|
range that has a line number less than or equal to the first line.
|
|
|
For optimized code with code motion, this finds the last address
|
For optimized code with code motion, this finds the last address
|
for the lowest-numbered line within the address range. */
|
for the lowest-numbered line within the address range. */
|
|
|
static struct symtab_and_line
|
static struct symtab_and_line
|
find_last_line_symbol (CORE_ADDR start, CORE_ADDR end, int notcurrent)
|
find_last_line_symbol (CORE_ADDR start, CORE_ADDR end, int notcurrent)
|
{
|
{
|
struct symtab_and_line sal = find_pc_line (start, notcurrent);
|
struct symtab_and_line sal = find_pc_line (start, notcurrent);
|
struct symtab_and_line best_sal = sal;
|
struct symtab_and_line best_sal = sal;
|
|
|
if (sal.pc == 0 || sal.line == 0 || sal.end == 0)
|
if (sal.pc == 0 || sal.line == 0 || sal.end == 0)
|
return sal;
|
return sal;
|
|
|
do
|
do
|
{
|
{
|
if (sal.line && sal.line <= best_sal.line)
|
if (sal.line && sal.line <= best_sal.line)
|
best_sal = sal;
|
best_sal = sal;
|
sal = find_pc_line (sal.end, notcurrent);
|
sal = find_pc_line (sal.end, notcurrent);
|
}
|
}
|
while (sal.pc && sal.pc < end);
|
while (sal.pc && sal.pc < end);
|
|
|
return best_sal;
|
return best_sal;
|
}
|
}
|
|
|
/* Function: scan_prologue
|
/* Function: scan_prologue
|
Decode the instructions within the given address range.
|
Decode the instructions within the given address range.
|
Decide when we must have reached the end of the function prologue.
|
Decide when we must have reached the end of the function prologue.
|
If a frame_info pointer is provided, fill in its prologue information.
|
If a frame_info pointer is provided, fill in its prologue information.
|
|
|
Returns the address of the first instruction after the prologue. */
|
Returns the address of the first instruction after the prologue. */
|
|
|
static CORE_ADDR
|
static CORE_ADDR
|
iq2000_scan_prologue (CORE_ADDR scan_start,
|
iq2000_scan_prologue (CORE_ADDR scan_start,
|
CORE_ADDR scan_end,
|
CORE_ADDR scan_end,
|
struct frame_info *fi,
|
struct frame_info *fi,
|
struct iq2000_frame_cache *cache)
|
struct iq2000_frame_cache *cache)
|
{
|
{
|
struct symtab_and_line sal;
|
struct symtab_and_line sal;
|
CORE_ADDR pc;
|
CORE_ADDR pc;
|
CORE_ADDR loop_end;
|
CORE_ADDR loop_end;
|
int found_store_lr = 0;
|
int found_store_lr = 0;
|
int found_decr_sp = 0;
|
int found_decr_sp = 0;
|
int srcreg;
|
int srcreg;
|
int tgtreg;
|
int tgtreg;
|
signed short offset;
|
signed short offset;
|
|
|
if (scan_end == (CORE_ADDR) 0)
|
if (scan_end == (CORE_ADDR) 0)
|
{
|
{
|
loop_end = scan_start + 100;
|
loop_end = scan_start + 100;
|
sal.end = sal.pc = 0;
|
sal.end = sal.pc = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
loop_end = scan_end;
|
loop_end = scan_end;
|
if (fi)
|
if (fi)
|
sal = find_last_line_symbol (scan_start, scan_end, 0);
|
sal = find_last_line_symbol (scan_start, scan_end, 0);
|
}
|
}
|
|
|
/* Saved registers:
|
/* Saved registers:
|
We first have to save the saved register's offset, and
|
We first have to save the saved register's offset, and
|
only later do we compute its actual address. Since the
|
only later do we compute its actual address. Since the
|
offset can be zero, we must first initialize all the
|
offset can be zero, we must first initialize all the
|
saved regs to minus one (so we can later distinguish
|
saved regs to minus one (so we can later distinguish
|
between one that's not saved, and one that's saved at zero). */
|
between one that's not saved, and one that's saved at zero). */
|
for (srcreg = 0; srcreg < E_NUM_REGS; srcreg ++)
|
for (srcreg = 0; srcreg < E_NUM_REGS; srcreg ++)
|
cache->saved_regs[srcreg] = -1;
|
cache->saved_regs[srcreg] = -1;
|
cache->using_fp = 0;
|
cache->using_fp = 0;
|
cache->framesize = 0;
|
cache->framesize = 0;
|
|
|
for (pc = scan_start; pc < loop_end; pc += 4)
|
for (pc = scan_start; pc < loop_end; pc += 4)
|
{
|
{
|
LONGEST insn = read_memory_unsigned_integer (pc, 4);
|
LONGEST insn = read_memory_unsigned_integer (pc, 4);
|
/* Skip any instructions writing to (sp) or decrementing the
|
/* Skip any instructions writing to (sp) or decrementing the
|
SP. */
|
SP. */
|
if ((insn & 0xffe00000) == 0xac200000)
|
if ((insn & 0xffe00000) == 0xac200000)
|
{
|
{
|
/* sw using SP/%1 as base. */
|
/* sw using SP/%1 as base. */
|
/* LEGACY -- from assembly-only port. */
|
/* LEGACY -- from assembly-only port. */
|
tgtreg = ((insn >> 16) & 0x1f);
|
tgtreg = ((insn >> 16) & 0x1f);
|
if (tgtreg >= 0 && tgtreg < E_NUM_REGS)
|
if (tgtreg >= 0 && tgtreg < E_NUM_REGS)
|
cache->saved_regs[tgtreg] = -((signed short) (insn & 0xffff));
|
cache->saved_regs[tgtreg] = -((signed short) (insn & 0xffff));
|
|
|
if (tgtreg == E_LR_REGNUM)
|
if (tgtreg == E_LR_REGNUM)
|
found_store_lr = 1;
|
found_store_lr = 1;
|
continue;
|
continue;
|
}
|
}
|
|
|
if ((insn & 0xffff8000) == 0x20218000)
|
if ((insn & 0xffff8000) == 0x20218000)
|
{
|
{
|
/* addi %1, %1, -N == addi %sp, %sp, -N */
|
/* addi %1, %1, -N == addi %sp, %sp, -N */
|
/* LEGACY -- from assembly-only port */
|
/* LEGACY -- from assembly-only port */
|
found_decr_sp = 1;
|
found_decr_sp = 1;
|
cache->framesize = -((signed short) (insn & 0xffff));
|
cache->framesize = -((signed short) (insn & 0xffff));
|
continue;
|
continue;
|
}
|
}
|
|
|
if (INSN_IS_ADDIU (insn))
|
if (INSN_IS_ADDIU (insn))
|
{
|
{
|
srcreg = ADDIU_REG_SRC (insn);
|
srcreg = ADDIU_REG_SRC (insn);
|
tgtreg = ADDIU_REG_TGT (insn);
|
tgtreg = ADDIU_REG_TGT (insn);
|
offset = ADDIU_IMMEDIATE (insn);
|
offset = ADDIU_IMMEDIATE (insn);
|
if (srcreg == E_SP_REGNUM && tgtreg == E_SP_REGNUM)
|
if (srcreg == E_SP_REGNUM && tgtreg == E_SP_REGNUM)
|
cache->framesize = -offset;
|
cache->framesize = -offset;
|
continue;
|
continue;
|
}
|
}
|
|
|
if (INSN_IS_STORE_WORD (insn))
|
if (INSN_IS_STORE_WORD (insn))
|
{
|
{
|
srcreg = SW_REG_SRC (insn);
|
srcreg = SW_REG_SRC (insn);
|
tgtreg = SW_REG_INDEX (insn);
|
tgtreg = SW_REG_INDEX (insn);
|
offset = SW_OFFSET (insn);
|
offset = SW_OFFSET (insn);
|
|
|
if (tgtreg == E_SP_REGNUM || tgtreg == E_FP_REGNUM)
|
if (tgtreg == E_SP_REGNUM || tgtreg == E_FP_REGNUM)
|
{
|
{
|
/* "push" to stack (via SP or FP reg) */
|
/* "push" to stack (via SP or FP reg) */
|
if (cache->saved_regs[srcreg] == -1) /* Don't save twice. */
|
if (cache->saved_regs[srcreg] == -1) /* Don't save twice. */
|
cache->saved_regs[srcreg] = offset;
|
cache->saved_regs[srcreg] = offset;
|
continue;
|
continue;
|
}
|
}
|
}
|
}
|
|
|
if (INSN_IS_MOVE (insn))
|
if (INSN_IS_MOVE (insn))
|
{
|
{
|
srcreg = MOVE_REG_SRC (insn);
|
srcreg = MOVE_REG_SRC (insn);
|
tgtreg = MOVE_REG_TGT (insn);
|
tgtreg = MOVE_REG_TGT (insn);
|
|
|
if (srcreg == E_SP_REGNUM && tgtreg == E_FP_REGNUM)
|
if (srcreg == E_SP_REGNUM && tgtreg == E_FP_REGNUM)
|
{
|
{
|
/* Copy sp to fp. */
|
/* Copy sp to fp. */
|
cache->using_fp = 1;
|
cache->using_fp = 1;
|
continue;
|
continue;
|
}
|
}
|
}
|
}
|
|
|
/* Unknown instruction encountered in frame. Bail out?
|
/* Unknown instruction encountered in frame. Bail out?
|
1) If we have a subsequent line symbol, we can keep going.
|
1) If we have a subsequent line symbol, we can keep going.
|
2) If not, we need to bail out and quit scanning instructions. */
|
2) If not, we need to bail out and quit scanning instructions. */
|
|
|
if (fi && sal.end && (pc < sal.end)) /* Keep scanning. */
|
if (fi && sal.end && (pc < sal.end)) /* Keep scanning. */
|
continue;
|
continue;
|
else /* bail */
|
else /* bail */
|
break;
|
break;
|
}
|
}
|
|
|
return pc;
|
return pc;
|
}
|
}
|
|
|
static void
|
static void
|
iq2000_init_frame_cache (struct iq2000_frame_cache *cache)
|
iq2000_init_frame_cache (struct iq2000_frame_cache *cache)
|
{
|
{
|
int i;
|
int i;
|
|
|
cache->base = 0;
|
cache->base = 0;
|
cache->framesize = 0;
|
cache->framesize = 0;
|
cache->using_fp = 0;
|
cache->using_fp = 0;
|
cache->saved_sp = 0;
|
cache->saved_sp = 0;
|
for (i = 0; i < E_NUM_REGS; i++)
|
for (i = 0; i < E_NUM_REGS; i++)
|
cache->saved_regs[i] = -1;
|
cache->saved_regs[i] = -1;
|
}
|
}
|
|
|
/* Function: iq2000_skip_prologue
|
/* Function: iq2000_skip_prologue
|
If the input address is in a function prologue,
|
If the input address is in a function prologue,
|
returns the address of the end of the prologue;
|
returns the address of the end of the prologue;
|
else returns the input address.
|
else returns the input address.
|
|
|
Note: the input address is likely to be the function start,
|
Note: the input address is likely to be the function start,
|
since this function is mainly used for advancing a breakpoint
|
since this function is mainly used for advancing a breakpoint
|
to the first line, or stepping to the first line when we have
|
to the first line, or stepping to the first line when we have
|
stepped into a function call. */
|
stepped into a function call. */
|
|
|
static CORE_ADDR
|
static CORE_ADDR
|
iq2000_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
|
iq2000_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
|
{
|
{
|
CORE_ADDR func_addr = 0 , func_end = 0;
|
CORE_ADDR func_addr = 0 , func_end = 0;
|
|
|
if (find_pc_partial_function (pc, NULL, & func_addr, & func_end))
|
if (find_pc_partial_function (pc, NULL, & func_addr, & func_end))
|
{
|
{
|
struct symtab_and_line sal;
|
struct symtab_and_line sal;
|
struct iq2000_frame_cache cache;
|
struct iq2000_frame_cache cache;
|
|
|
/* Found a function. */
|
/* Found a function. */
|
sal = find_pc_line (func_addr, 0);
|
sal = find_pc_line (func_addr, 0);
|
if (sal.end && sal.end < func_end)
|
if (sal.end && sal.end < func_end)
|
/* Found a line number, use it as end of prologue. */
|
/* Found a line number, use it as end of prologue. */
|
return sal.end;
|
return sal.end;
|
|
|
/* No useable line symbol. Use prologue parsing method. */
|
/* No useable line symbol. Use prologue parsing method. */
|
iq2000_init_frame_cache (&cache);
|
iq2000_init_frame_cache (&cache);
|
return iq2000_scan_prologue (func_addr, func_end, NULL, &cache);
|
return iq2000_scan_prologue (func_addr, func_end, NULL, &cache);
|
}
|
}
|
|
|
/* No function symbol -- just return the PC. */
|
/* No function symbol -- just return the PC. */
|
return (CORE_ADDR) pc;
|
return (CORE_ADDR) pc;
|
}
|
}
|
|
|
static struct iq2000_frame_cache *
|
static struct iq2000_frame_cache *
|
iq2000_frame_cache (struct frame_info *next_frame, void **this_cache)
|
iq2000_frame_cache (struct frame_info *next_frame, void **this_cache)
|
{
|
{
|
struct iq2000_frame_cache *cache;
|
struct iq2000_frame_cache *cache;
|
CORE_ADDR current_pc;
|
CORE_ADDR current_pc;
|
int i;
|
int i;
|
|
|
if (*this_cache)
|
if (*this_cache)
|
return *this_cache;
|
return *this_cache;
|
|
|
cache = FRAME_OBSTACK_ZALLOC (struct iq2000_frame_cache);
|
cache = FRAME_OBSTACK_ZALLOC (struct iq2000_frame_cache);
|
iq2000_init_frame_cache (cache);
|
iq2000_init_frame_cache (cache);
|
*this_cache = cache;
|
*this_cache = cache;
|
|
|
cache->base = frame_unwind_register_unsigned (next_frame, E_FP_REGNUM);
|
cache->base = frame_unwind_register_unsigned (next_frame, E_FP_REGNUM);
|
//if (cache->base == 0)
|
//if (cache->base == 0)
|
//return cache;
|
//return cache;
|
|
|
current_pc = frame_pc_unwind (next_frame);
|
current_pc = frame_pc_unwind (next_frame);
|
find_pc_partial_function (current_pc, NULL, &cache->pc, NULL);
|
find_pc_partial_function (current_pc, NULL, &cache->pc, NULL);
|
if (cache->pc != 0)
|
if (cache->pc != 0)
|
iq2000_scan_prologue (cache->pc, current_pc, next_frame, cache);
|
iq2000_scan_prologue (cache->pc, current_pc, next_frame, cache);
|
if (!cache->using_fp)
|
if (!cache->using_fp)
|
cache->base = frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
|
cache->base = frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
|
|
|
cache->saved_sp = cache->base + cache->framesize;
|
cache->saved_sp = cache->base + cache->framesize;
|
|
|
for (i = 0; i < E_NUM_REGS; i++)
|
for (i = 0; i < E_NUM_REGS; i++)
|
if (cache->saved_regs[i] != -1)
|
if (cache->saved_regs[i] != -1)
|
cache->saved_regs[i] += cache->base;
|
cache->saved_regs[i] += cache->base;
|
|
|
return cache;
|
return cache;
|
}
|
}
|
|
|
static void
|
static void
|
iq2000_frame_prev_register (struct frame_info *next_frame, void **this_cache,
|
iq2000_frame_prev_register (struct frame_info *next_frame, void **this_cache,
|
int regnum, int *optimizedp,
|
int regnum, int *optimizedp,
|
enum lval_type *lvalp, CORE_ADDR *addrp,
|
enum lval_type *lvalp, CORE_ADDR *addrp,
|
int *realnump, gdb_byte *valuep)
|
int *realnump, gdb_byte *valuep)
|
{
|
{
|
struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
|
struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
|
if (regnum == E_SP_REGNUM && cache->saved_sp)
|
if (regnum == E_SP_REGNUM && cache->saved_sp)
|
{
|
{
|
*optimizedp = 0;
|
*optimizedp = 0;
|
*lvalp = not_lval;
|
*lvalp = not_lval;
|
*addrp = 0;
|
*addrp = 0;
|
*realnump = -1;
|
*realnump = -1;
|
if (valuep)
|
if (valuep)
|
store_unsigned_integer (valuep, 4, cache->saved_sp);
|
store_unsigned_integer (valuep, 4, cache->saved_sp);
|
return;
|
return;
|
}
|
}
|
|
|
if (regnum == E_PC_REGNUM)
|
if (regnum == E_PC_REGNUM)
|
regnum = E_LR_REGNUM;
|
regnum = E_LR_REGNUM;
|
|
|
if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != -1)
|
if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != -1)
|
{
|
{
|
*optimizedp = 0;
|
*optimizedp = 0;
|
*lvalp = lval_memory;
|
*lvalp = lval_memory;
|
*addrp = cache->saved_regs[regnum];
|
*addrp = cache->saved_regs[regnum];
|
*realnump = -1;
|
*realnump = -1;
|
if (valuep)
|
if (valuep)
|
read_memory (*addrp, valuep,
|
read_memory (*addrp, valuep,
|
register_size (get_frame_arch (next_frame), regnum));
|
register_size (get_frame_arch (next_frame), regnum));
|
return;
|
return;
|
}
|
}
|
|
|
*optimizedp = 0;
|
*optimizedp = 0;
|
*lvalp = lval_register;
|
*lvalp = lval_register;
|
*addrp = 0;
|
*addrp = 0;
|
*realnump = regnum;
|
*realnump = regnum;
|
if (valuep)
|
if (valuep)
|
frame_unwind_register (next_frame, (*realnump), valuep);
|
frame_unwind_register (next_frame, (*realnump), valuep);
|
}
|
}
|
|
|
static void
|
static void
|
iq2000_frame_this_id (struct frame_info *next_frame, void **this_cache,
|
iq2000_frame_this_id (struct frame_info *next_frame, void **this_cache,
|
struct frame_id *this_id)
|
struct frame_id *this_id)
|
{
|
{
|
struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
|
struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
|
|
|
/* This marks the outermost frame. */
|
/* This marks the outermost frame. */
|
if (cache->base == 0)
|
if (cache->base == 0)
|
return;
|
return;
|
|
|
*this_id = frame_id_build (cache->saved_sp, cache->pc);
|
*this_id = frame_id_build (cache->saved_sp, cache->pc);
|
}
|
}
|
|
|
static const struct frame_unwind iq2000_frame_unwind = {
|
static const struct frame_unwind iq2000_frame_unwind = {
|
NORMAL_FRAME,
|
NORMAL_FRAME,
|
iq2000_frame_this_id,
|
iq2000_frame_this_id,
|
iq2000_frame_prev_register
|
iq2000_frame_prev_register
|
};
|
};
|
|
|
static const struct frame_unwind *
|
static const struct frame_unwind *
|
iq2000_frame_sniffer (struct frame_info *next_frame)
|
iq2000_frame_sniffer (struct frame_info *next_frame)
|
{
|
{
|
return &iq2000_frame_unwind;
|
return &iq2000_frame_unwind;
|
}
|
}
|
|
|
static CORE_ADDR
|
static CORE_ADDR
|
iq2000_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
|
iq2000_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
|
{
|
{
|
return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
|
return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
|
}
|
}
|
|
|
static CORE_ADDR
|
static CORE_ADDR
|
iq2000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
|
iq2000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
|
{
|
{
|
return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
|
return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
|
}
|
}
|
|
|
static struct frame_id
|
static struct frame_id
|
iq2000_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
|
iq2000_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
|
{
|
{
|
return frame_id_build (iq2000_unwind_sp (gdbarch, next_frame),
|
return frame_id_build (iq2000_unwind_sp (gdbarch, next_frame),
|
frame_pc_unwind (next_frame));
|
frame_pc_unwind (next_frame));
|
}
|
}
|
|
|
static CORE_ADDR
|
static CORE_ADDR
|
iq2000_frame_base_address (struct frame_info *next_frame, void **this_cache)
|
iq2000_frame_base_address (struct frame_info *next_frame, void **this_cache)
|
{
|
{
|
struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
|
struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
|
|
|
return cache->base;
|
return cache->base;
|
}
|
}
|
|
|
static const struct frame_base iq2000_frame_base = {
|
static const struct frame_base iq2000_frame_base = {
|
&iq2000_frame_unwind,
|
&iq2000_frame_unwind,
|
iq2000_frame_base_address,
|
iq2000_frame_base_address,
|
iq2000_frame_base_address,
|
iq2000_frame_base_address,
|
iq2000_frame_base_address
|
iq2000_frame_base_address
|
};
|
};
|
|
|
static const unsigned char *
|
static const unsigned char *
|
iq2000_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
|
iq2000_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
|
int *lenptr)
|
int *lenptr)
|
{
|
{
|
static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d };
|
static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d };
|
static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 };
|
static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 };
|
|
|
if ((*pcptr & 3) != 0)
|
if ((*pcptr & 3) != 0)
|
error ("breakpoint_from_pc: invalid breakpoint address 0x%lx",
|
error ("breakpoint_from_pc: invalid breakpoint address 0x%lx",
|
(long) *pcptr);
|
(long) *pcptr);
|
|
|
*lenptr = 4;
|
*lenptr = 4;
|
return (gdbarch_byte_order (gdbarch)
|
return (gdbarch_byte_order (gdbarch)
|
== BFD_ENDIAN_BIG) ? big_breakpoint : little_breakpoint;
|
== BFD_ENDIAN_BIG) ? big_breakpoint : little_breakpoint;
|
}
|
}
|
|
|
/* Target function return value methods: */
|
/* Target function return value methods: */
|
|
|
/* Function: store_return_value
|
/* Function: store_return_value
|
Copy the function return value from VALBUF into the
|
Copy the function return value from VALBUF into the
|
proper location for a function return. */
|
proper location for a function return. */
|
|
|
static void
|
static void
|
iq2000_store_return_value (struct type *type, struct regcache *regcache,
|
iq2000_store_return_value (struct type *type, struct regcache *regcache,
|
const void *valbuf)
|
const void *valbuf)
|
{
|
{
|
int len = TYPE_LENGTH (type);
|
int len = TYPE_LENGTH (type);
|
int regno = E_FN_RETURN_REGNUM;
|
int regno = E_FN_RETURN_REGNUM;
|
|
|
while (len > 0)
|
while (len > 0)
|
{
|
{
|
char buf[4];
|
char buf[4];
|
int size = len % 4 ?: 4;
|
int size = len % 4 ?: 4;
|
|
|
memset (buf, 0, 4);
|
memset (buf, 0, 4);
|
memcpy (buf + 4 - size, valbuf, size);
|
memcpy (buf + 4 - size, valbuf, size);
|
regcache_raw_write (regcache, regno++, buf);
|
regcache_raw_write (regcache, regno++, buf);
|
len -= size;
|
len -= size;
|
valbuf = ((char *) valbuf) + size;
|
valbuf = ((char *) valbuf) + size;
|
}
|
}
|
}
|
}
|
|
|
/* Function: use_struct_convention
|
/* Function: use_struct_convention
|
Returns non-zero if the given struct type will be returned using
|
Returns non-zero if the given struct type will be returned using
|
a special convention, rather than the normal function return method. */
|
a special convention, rather than the normal function return method. */
|
|
|
static int
|
static int
|
iq2000_use_struct_convention (struct type *type)
|
iq2000_use_struct_convention (struct type *type)
|
{
|
{
|
return ((TYPE_CODE (type) == TYPE_CODE_STRUCT)
|
return ((TYPE_CODE (type) == TYPE_CODE_STRUCT)
|
|| (TYPE_CODE (type) == TYPE_CODE_UNION))
|
|| (TYPE_CODE (type) == TYPE_CODE_UNION))
|
&& TYPE_LENGTH (type) > 8;
|
&& TYPE_LENGTH (type) > 8;
|
}
|
}
|
|
|
/* Function: extract_return_value
|
/* Function: extract_return_value
|
Copy the function's return value into VALBUF.
|
Copy the function's return value into VALBUF.
|
This function is called only in the context of "target function calls",
|
This function is called only in the context of "target function calls",
|
ie. when the debugger forces a function to be called in the child, and
|
ie. when the debugger forces a function to be called in the child, and
|
when the debugger forces a function to return prematurely via the
|
when the debugger forces a function to return prematurely via the
|
"return" command. */
|
"return" command. */
|
|
|
static void
|
static void
|
iq2000_extract_return_value (struct type *type, struct regcache *regcache,
|
iq2000_extract_return_value (struct type *type, struct regcache *regcache,
|
void *valbuf)
|
void *valbuf)
|
{
|
{
|
/* If the function's return value is 8 bytes or less, it is
|
/* If the function's return value is 8 bytes or less, it is
|
returned in a register, and if larger than 8 bytes, it is
|
returned in a register, and if larger than 8 bytes, it is
|
returned in a stack location which is pointed to by the same
|
returned in a stack location which is pointed to by the same
|
register. */
|
register. */
|
int len = TYPE_LENGTH (type);
|
int len = TYPE_LENGTH (type);
|
|
|
if (len <= (2 * 4))
|
if (len <= (2 * 4))
|
{
|
{
|
int regno = E_FN_RETURN_REGNUM;
|
int regno = E_FN_RETURN_REGNUM;
|
|
|
/* Return values of <= 8 bytes are returned in
|
/* Return values of <= 8 bytes are returned in
|
FN_RETURN_REGNUM. */
|
FN_RETURN_REGNUM. */
|
while (len > 0)
|
while (len > 0)
|
{
|
{
|
ULONGEST tmp;
|
ULONGEST tmp;
|
int size = len % 4 ?: 4;
|
int size = len % 4 ?: 4;
|
|
|
/* By using store_unsigned_integer we avoid having to
|
/* By using store_unsigned_integer we avoid having to
|
do anything special for small big-endian values. */
|
do anything special for small big-endian values. */
|
regcache_cooked_read_unsigned (regcache, regno++, &tmp);
|
regcache_cooked_read_unsigned (regcache, regno++, &tmp);
|
store_unsigned_integer (valbuf, size, tmp);
|
store_unsigned_integer (valbuf, size, tmp);
|
len -= size;
|
len -= size;
|
valbuf = ((char *) valbuf) + size;
|
valbuf = ((char *) valbuf) + size;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Return values > 8 bytes are returned in memory,
|
/* Return values > 8 bytes are returned in memory,
|
pointed to by FN_RETURN_REGNUM. */
|
pointed to by FN_RETURN_REGNUM. */
|
ULONGEST return_buffer;
|
ULONGEST return_buffer;
|
regcache_cooked_read_unsigned (regcache, E_FN_RETURN_REGNUM,
|
regcache_cooked_read_unsigned (regcache, E_FN_RETURN_REGNUM,
|
&return_buffer);
|
&return_buffer);
|
read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
|
read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
|
}
|
}
|
}
|
}
|
|
|
static enum return_value_convention
|
static enum return_value_convention
|
iq2000_return_value (struct gdbarch *gdbarch, struct type *type,
|
iq2000_return_value (struct gdbarch *gdbarch, struct type *type,
|
struct regcache *regcache,
|
struct regcache *regcache,
|
gdb_byte *readbuf, const gdb_byte *writebuf)
|
gdb_byte *readbuf, const gdb_byte *writebuf)
|
{
|
{
|
if (iq2000_use_struct_convention (type))
|
if (iq2000_use_struct_convention (type))
|
return RETURN_VALUE_STRUCT_CONVENTION;
|
return RETURN_VALUE_STRUCT_CONVENTION;
|
if (writebuf)
|
if (writebuf)
|
iq2000_store_return_value (type, regcache, writebuf);
|
iq2000_store_return_value (type, regcache, writebuf);
|
else if (readbuf)
|
else if (readbuf)
|
iq2000_extract_return_value (type, regcache, readbuf);
|
iq2000_extract_return_value (type, regcache, readbuf);
|
return RETURN_VALUE_REGISTER_CONVENTION;
|
return RETURN_VALUE_REGISTER_CONVENTION;
|
}
|
}
|
|
|
/* Function: register_virtual_type
|
/* Function: register_virtual_type
|
Returns the default type for register N. */
|
Returns the default type for register N. */
|
|
|
static struct type *
|
static struct type *
|
iq2000_register_type (struct gdbarch *gdbarch, int regnum)
|
iq2000_register_type (struct gdbarch *gdbarch, int regnum)
|
{
|
{
|
return builtin_type_int32;
|
return builtin_type_int32;
|
}
|
}
|
|
|
static CORE_ADDR
|
static CORE_ADDR
|
iq2000_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
|
iq2000_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
|
{
|
{
|
/* This is the same frame alignment used by gcc. */
|
/* This is the same frame alignment used by gcc. */
|
return ((sp + 7) & ~7);
|
return ((sp + 7) & ~7);
|
}
|
}
|
|
|
/* Convenience function to check 8-byte types for being a scalar type
|
/* Convenience function to check 8-byte types for being a scalar type
|
or a struct with only one long long or double member. */
|
or a struct with only one long long or double member. */
|
static int
|
static int
|
iq2000_pass_8bytetype_by_address (struct type *type)
|
iq2000_pass_8bytetype_by_address (struct type *type)
|
{
|
{
|
struct type *ftype;
|
struct type *ftype;
|
|
|
/* Skip typedefs. */
|
/* Skip typedefs. */
|
while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
|
while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
|
type = TYPE_TARGET_TYPE (type);
|
type = TYPE_TARGET_TYPE (type);
|
/* Non-struct and non-union types are always passed by value. */
|
/* Non-struct and non-union types are always passed by value. */
|
if (TYPE_CODE (type) != TYPE_CODE_STRUCT
|
if (TYPE_CODE (type) != TYPE_CODE_STRUCT
|
&& TYPE_CODE (type) != TYPE_CODE_UNION)
|
&& TYPE_CODE (type) != TYPE_CODE_UNION)
|
return 0;
|
return 0;
|
/* Structs with more than 1 field are always passed by address. */
|
/* Structs with more than 1 field are always passed by address. */
|
if (TYPE_NFIELDS (type) != 1)
|
if (TYPE_NFIELDS (type) != 1)
|
return 1;
|
return 1;
|
/* Get field type. */
|
/* Get field type. */
|
ftype = (TYPE_FIELDS (type))[0].type;
|
ftype = (TYPE_FIELDS (type))[0].type;
|
/* The field type must have size 8, otherwise pass by address. */
|
/* The field type must have size 8, otherwise pass by address. */
|
if (TYPE_LENGTH (ftype) != 8)
|
if (TYPE_LENGTH (ftype) != 8)
|
return 1;
|
return 1;
|
/* Skip typedefs of field type. */
|
/* Skip typedefs of field type. */
|
while (TYPE_CODE (ftype) == TYPE_CODE_TYPEDEF)
|
while (TYPE_CODE (ftype) == TYPE_CODE_TYPEDEF)
|
ftype = TYPE_TARGET_TYPE (ftype);
|
ftype = TYPE_TARGET_TYPE (ftype);
|
/* If field is int or float, pass by value. */
|
/* If field is int or float, pass by value. */
|
if (TYPE_CODE (ftype) == TYPE_CODE_FLT
|
if (TYPE_CODE (ftype) == TYPE_CODE_FLT
|
|| TYPE_CODE (ftype) == TYPE_CODE_INT)
|
|| TYPE_CODE (ftype) == TYPE_CODE_INT)
|
return 0;
|
return 0;
|
/* Everything else, pass by address. */
|
/* Everything else, pass by address. */
|
return 1;
|
return 1;
|
}
|
}
|
|
|
static CORE_ADDR
|
static CORE_ADDR
|
iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|
iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|
struct regcache *regcache, CORE_ADDR bp_addr,
|
struct regcache *regcache, CORE_ADDR bp_addr,
|
int nargs, struct value **args, CORE_ADDR sp,
|
int nargs, struct value **args, CORE_ADDR sp,
|
int struct_return, CORE_ADDR struct_addr)
|
int struct_return, CORE_ADDR struct_addr)
|
{
|
{
|
const bfd_byte *val;
|
const bfd_byte *val;
|
bfd_byte buf[4];
|
bfd_byte buf[4];
|
struct type *type;
|
struct type *type;
|
int i, argreg, typelen, slacklen;
|
int i, argreg, typelen, slacklen;
|
int stackspace = 0;
|
int stackspace = 0;
|
/* Used to copy struct arguments into the stack. */
|
/* Used to copy struct arguments into the stack. */
|
CORE_ADDR struct_ptr;
|
CORE_ADDR struct_ptr;
|
|
|
/* First determine how much stack space we will need. */
|
/* First determine how much stack space we will need. */
|
for (i = 0, argreg = E_1ST_ARGREG + (struct_return != 0); i < nargs; i++)
|
for (i = 0, argreg = E_1ST_ARGREG + (struct_return != 0); i < nargs; i++)
|
{
|
{
|
type = value_type (args[i]);
|
type = value_type (args[i]);
|
typelen = TYPE_LENGTH (type);
|
typelen = TYPE_LENGTH (type);
|
if (typelen <= 4)
|
if (typelen <= 4)
|
{
|
{
|
/* Scalars of up to 4 bytes,
|
/* Scalars of up to 4 bytes,
|
structs of up to 4 bytes, and
|
structs of up to 4 bytes, and
|
pointers. */
|
pointers. */
|
if (argreg <= E_LAST_ARGREG)
|
if (argreg <= E_LAST_ARGREG)
|
argreg++;
|
argreg++;
|
else
|
else
|
stackspace += 4;
|
stackspace += 4;
|
}
|
}
|
else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
|
else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
|
{
|
{
|
/* long long,
|
/* long long,
|
double, and possibly
|
double, and possibly
|
structs with a single field of long long or double. */
|
structs with a single field of long long or double. */
|
if (argreg <= E_LAST_ARGREG - 1)
|
if (argreg <= E_LAST_ARGREG - 1)
|
{
|
{
|
/* 8-byte arg goes into a register pair
|
/* 8-byte arg goes into a register pair
|
(must start with an even-numbered reg) */
|
(must start with an even-numbered reg) */
|
if (((argreg - E_1ST_ARGREG) % 2) != 0)
|
if (((argreg - E_1ST_ARGREG) % 2) != 0)
|
argreg ++;
|
argreg ++;
|
argreg += 2;
|
argreg += 2;
|
}
|
}
|
else
|
else
|
{
|
{
|
argreg = E_LAST_ARGREG + 1; /* no more argregs. */
|
argreg = E_LAST_ARGREG + 1; /* no more argregs. */
|
/* 8-byte arg goes on stack, must be 8-byte aligned. */
|
/* 8-byte arg goes on stack, must be 8-byte aligned. */
|
stackspace = ((stackspace + 7) & ~7);
|
stackspace = ((stackspace + 7) & ~7);
|
stackspace += 8;
|
stackspace += 8;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Structs are passed as pointer to a copy of the struct.
|
/* Structs are passed as pointer to a copy of the struct.
|
So we need room on the stack for a copy of the struct
|
So we need room on the stack for a copy of the struct
|
plus for the argument pointer. */
|
plus for the argument pointer. */
|
if (argreg <= E_LAST_ARGREG)
|
if (argreg <= E_LAST_ARGREG)
|
argreg++;
|
argreg++;
|
else
|
else
|
stackspace += 4;
|
stackspace += 4;
|
/* Care for 8-byte alignment of structs saved on stack. */
|
/* Care for 8-byte alignment of structs saved on stack. */
|
stackspace += ((typelen + 7) & ~7);
|
stackspace += ((typelen + 7) & ~7);
|
}
|
}
|
}
|
}
|
|
|
/* Now copy params, in ascending order, into their assigned location
|
/* Now copy params, in ascending order, into their assigned location
|
(either in a register or on the stack). */
|
(either in a register or on the stack). */
|
|
|
sp -= (sp % 8); /* align */
|
sp -= (sp % 8); /* align */
|
struct_ptr = sp;
|
struct_ptr = sp;
|
sp -= stackspace;
|
sp -= stackspace;
|
sp -= (sp % 8); /* align again */
|
sp -= (sp % 8); /* align again */
|
stackspace = 0;
|
stackspace = 0;
|
|
|
argreg = E_1ST_ARGREG;
|
argreg = E_1ST_ARGREG;
|
if (struct_return)
|
if (struct_return)
|
{
|
{
|
/* A function that returns a struct will consume one argreg to do so.
|
/* A function that returns a struct will consume one argreg to do so.
|
*/
|
*/
|
regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
|
regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
|
}
|
}
|
|
|
for (i = 0; i < nargs; i++)
|
for (i = 0; i < nargs; i++)
|
{
|
{
|
type = value_type (args[i]);
|
type = value_type (args[i]);
|
typelen = TYPE_LENGTH (type);
|
typelen = TYPE_LENGTH (type);
|
val = value_contents (args[i]);
|
val = value_contents (args[i]);
|
if (typelen <= 4)
|
if (typelen <= 4)
|
{
|
{
|
/* Char, short, int, float, pointer, and structs <= four bytes. */
|
/* Char, short, int, float, pointer, and structs <= four bytes. */
|
slacklen = (4 - (typelen % 4)) % 4;
|
slacklen = (4 - (typelen % 4)) % 4;
|
memset (buf, 0, sizeof (buf));
|
memset (buf, 0, sizeof (buf));
|
memcpy (buf + slacklen, val, typelen);
|
memcpy (buf + slacklen, val, typelen);
|
if (argreg <= E_LAST_ARGREG)
|
if (argreg <= E_LAST_ARGREG)
|
{
|
{
|
/* Passed in a register. */
|
/* Passed in a register. */
|
regcache_raw_write (regcache, argreg++, buf);
|
regcache_raw_write (regcache, argreg++, buf);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Passed on the stack. */
|
/* Passed on the stack. */
|
write_memory (sp + stackspace, buf, 4);
|
write_memory (sp + stackspace, buf, 4);
|
stackspace += 4;
|
stackspace += 4;
|
}
|
}
|
}
|
}
|
else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
|
else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
|
{
|
{
|
/* (long long), (double), or struct consisting of
|
/* (long long), (double), or struct consisting of
|
a single (long long) or (double). */
|
a single (long long) or (double). */
|
if (argreg <= E_LAST_ARGREG - 1)
|
if (argreg <= E_LAST_ARGREG - 1)
|
{
|
{
|
/* 8-byte arg goes into a register pair
|
/* 8-byte arg goes into a register pair
|
(must start with an even-numbered reg) */
|
(must start with an even-numbered reg) */
|
if (((argreg - E_1ST_ARGREG) % 2) != 0)
|
if (((argreg - E_1ST_ARGREG) % 2) != 0)
|
argreg++;
|
argreg++;
|
regcache_raw_write (regcache, argreg++, val);
|
regcache_raw_write (regcache, argreg++, val);
|
regcache_raw_write (regcache, argreg++, val + 4);
|
regcache_raw_write (regcache, argreg++, val + 4);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* 8-byte arg goes on stack, must be 8-byte aligned. */
|
/* 8-byte arg goes on stack, must be 8-byte aligned. */
|
argreg = E_LAST_ARGREG + 1; /* no more argregs. */
|
argreg = E_LAST_ARGREG + 1; /* no more argregs. */
|
stackspace = ((stackspace + 7) & ~7);
|
stackspace = ((stackspace + 7) & ~7);
|
write_memory (sp + stackspace, val, typelen);
|
write_memory (sp + stackspace, val, typelen);
|
stackspace += 8;
|
stackspace += 8;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Store struct beginning at the upper end of the previously
|
/* Store struct beginning at the upper end of the previously
|
computed stack space. Then store the address of the struct
|
computed stack space. Then store the address of the struct
|
using the usual rules for a 4 byte value. */
|
using the usual rules for a 4 byte value. */
|
struct_ptr -= ((typelen + 7) & ~7);
|
struct_ptr -= ((typelen + 7) & ~7);
|
write_memory (struct_ptr, val, typelen);
|
write_memory (struct_ptr, val, typelen);
|
if (argreg <= E_LAST_ARGREG)
|
if (argreg <= E_LAST_ARGREG)
|
regcache_cooked_write_unsigned (regcache, argreg++, struct_ptr);
|
regcache_cooked_write_unsigned (regcache, argreg++, struct_ptr);
|
else
|
else
|
{
|
{
|
store_unsigned_integer (buf, 4, struct_ptr);
|
store_unsigned_integer (buf, 4, struct_ptr);
|
write_memory (sp + stackspace, buf, 4);
|
write_memory (sp + stackspace, buf, 4);
|
stackspace += 4;
|
stackspace += 4;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Store return address. */
|
/* Store return address. */
|
regcache_cooked_write_unsigned (regcache, E_LR_REGNUM, bp_addr);
|
regcache_cooked_write_unsigned (regcache, E_LR_REGNUM, bp_addr);
|
|
|
/* Update stack pointer. */
|
/* Update stack pointer. */
|
regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
|
regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
|
|
|
/* And that should do it. Return the new stack pointer. */
|
/* And that should do it. Return the new stack pointer. */
|
return sp;
|
return sp;
|
}
|
}
|
|
|
/* Function: gdbarch_init
|
/* Function: gdbarch_init
|
Initializer function for the iq2000 gdbarch vector.
|
Initializer function for the iq2000 gdbarch vector.
|
Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
|
Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
|
|
|
static struct gdbarch *
|
static struct gdbarch *
|
iq2000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
iq2000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
{
|
{
|
struct gdbarch *gdbarch;
|
struct gdbarch *gdbarch;
|
|
|
/* Look up list for candidates - only one. */
|
/* Look up list for candidates - only one. */
|
arches = gdbarch_list_lookup_by_info (arches, &info);
|
arches = gdbarch_list_lookup_by_info (arches, &info);
|
if (arches != NULL)
|
if (arches != NULL)
|
return arches->gdbarch;
|
return arches->gdbarch;
|
|
|
gdbarch = gdbarch_alloc (&info, NULL);
|
gdbarch = gdbarch_alloc (&info, NULL);
|
|
|
set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
|
set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
|
set_gdbarch_num_pseudo_regs (gdbarch, 0);
|
set_gdbarch_num_pseudo_regs (gdbarch, 0);
|
set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
|
set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
|
set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
|
set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
|
set_gdbarch_register_name (gdbarch, iq2000_register_name);
|
set_gdbarch_register_name (gdbarch, iq2000_register_name);
|
set_gdbarch_address_to_pointer (gdbarch, iq2000_address_to_pointer);
|
set_gdbarch_address_to_pointer (gdbarch, iq2000_address_to_pointer);
|
set_gdbarch_pointer_to_address (gdbarch, iq2000_pointer_to_address);
|
set_gdbarch_pointer_to_address (gdbarch, iq2000_pointer_to_address);
|
set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
|
set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
|
set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
|
set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
|
set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
|
set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
|
set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
|
set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
|
set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
|
set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
|
set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
|
set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
|
set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
|
set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
|
set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
|
set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
|
set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
|
set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
|
set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
|
set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
|
set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
|
set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
|
set_gdbarch_return_value (gdbarch, iq2000_return_value);
|
set_gdbarch_return_value (gdbarch, iq2000_return_value);
|
set_gdbarch_breakpoint_from_pc (gdbarch, iq2000_breakpoint_from_pc);
|
set_gdbarch_breakpoint_from_pc (gdbarch, iq2000_breakpoint_from_pc);
|
set_gdbarch_frame_args_skip (gdbarch, 0);
|
set_gdbarch_frame_args_skip (gdbarch, 0);
|
set_gdbarch_skip_prologue (gdbarch, iq2000_skip_prologue);
|
set_gdbarch_skip_prologue (gdbarch, iq2000_skip_prologue);
|
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
|
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
|
set_gdbarch_print_insn (gdbarch, print_insn_iq2000);
|
set_gdbarch_print_insn (gdbarch, print_insn_iq2000);
|
set_gdbarch_register_type (gdbarch, iq2000_register_type);
|
set_gdbarch_register_type (gdbarch, iq2000_register_type);
|
set_gdbarch_frame_align (gdbarch, iq2000_frame_align);
|
set_gdbarch_frame_align (gdbarch, iq2000_frame_align);
|
set_gdbarch_unwind_sp (gdbarch, iq2000_unwind_sp);
|
set_gdbarch_unwind_sp (gdbarch, iq2000_unwind_sp);
|
set_gdbarch_unwind_pc (gdbarch, iq2000_unwind_pc);
|
set_gdbarch_unwind_pc (gdbarch, iq2000_unwind_pc);
|
set_gdbarch_unwind_dummy_id (gdbarch, iq2000_unwind_dummy_id);
|
set_gdbarch_unwind_dummy_id (gdbarch, iq2000_unwind_dummy_id);
|
frame_base_set_default (gdbarch, &iq2000_frame_base);
|
frame_base_set_default (gdbarch, &iq2000_frame_base);
|
set_gdbarch_push_dummy_call (gdbarch, iq2000_push_dummy_call);
|
set_gdbarch_push_dummy_call (gdbarch, iq2000_push_dummy_call);
|
|
|
gdbarch_init_osabi (info, gdbarch);
|
gdbarch_init_osabi (info, gdbarch);
|
|
|
frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
|
frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
|
frame_unwind_append_sniffer (gdbarch, iq2000_frame_sniffer);
|
frame_unwind_append_sniffer (gdbarch, iq2000_frame_sniffer);
|
|
|
return gdbarch;
|
return gdbarch;
|
}
|
}
|
|
|
/* Function: _initialize_iq2000_tdep
|
/* Function: _initialize_iq2000_tdep
|
Initializer function for the iq2000 module.
|
Initializer function for the iq2000 module.
|
Called by gdb at start-up. */
|
Called by gdb at start-up. */
|
|
|
void
|
void
|
_initialize_iq2000_tdep (void)
|
_initialize_iq2000_tdep (void)
|
{
|
{
|
register_gdbarch_init (bfd_arch_iq2000, iq2000_gdbarch_init);
|
register_gdbarch_init (bfd_arch_iq2000, iq2000_gdbarch_init);
|
}
|
}
|
|
|
