#undef XMALLOC
#define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
-#undef EXTRACT_INSN
-#define EXTRACT_INSN(addr) extract_unsigned_integer(addr,2)
-
/* Constants: prefixed with AVR_ to avoid name space clashes */
enum
struct gdbarch_tdep
{
- /* FIXME: TRoth: is there anything to put here? */
- int foo;
+ /* Number of bytes stored to the stack by call instructions.
+ 2 bytes for avr1-5, 3 bytes for avr6. */
+ int call_length;
};
/* Lookup the name of a register given it's number. */
static const char *
avr_register_name (struct gdbarch *gdbarch, int regnum)
{
- static char *register_names[] = {
+ static const char * const register_names[] = {
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
avr_register_type (struct gdbarch *gdbarch, int reg_nr)
{
if (reg_nr == AVR_PC_REGNUM)
- return builtin_type_uint32;
+ return builtin_type (gdbarch)->builtin_uint32;
if (reg_nr == AVR_SP_REGNUM)
return builtin_type (gdbarch)->builtin_data_ptr;
else
- return builtin_type_uint8;
+ return builtin_type (gdbarch)->builtin_uint8;
}
/* Instruction address checks and convertions. */
/* Convert from address to pointer and vice-versa. */
static void
-avr_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr)
+avr_address_to_pointer (struct gdbarch *gdbarch,
+ struct type *type, gdb_byte *buf, CORE_ADDR addr)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
/* Is it a code address? */
if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
|| TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD)
{
- store_unsigned_integer (buf, TYPE_LENGTH (type),
+ store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order,
avr_convert_iaddr_to_raw (addr >> 1));
}
else
{
/* Strip off any upper segment bits. */
- store_unsigned_integer (buf, TYPE_LENGTH (type),
+ store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order,
avr_convert_saddr_to_raw (addr));
}
}
static CORE_ADDR
-avr_pointer_to_address (struct type *type, const gdb_byte *buf)
+avr_pointer_to_address (struct gdbarch *gdbarch,
+ struct type *type, const gdb_byte *buf)
{
- CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+ CORE_ADDR addr
+ = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
/* Is it a code address? */
if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
avr_convert_iaddr_to_raw (val));
}
-static int
-avr_scan_arg_moves (int vpc, unsigned char *prologue)
-{
- unsigned short insn;
-
- for (; vpc < AVR_MAX_PROLOGUE_SIZE; vpc += 2)
- {
- insn = EXTRACT_INSN (&prologue[vpc]);
- if ((insn & 0xff00) == 0x0100) /* movw rXX, rYY */
- continue;
- else if ((insn & 0xfc00) == 0x2c00) /* mov rXX, rYY */
- continue;
- else
- break;
- }
-
- return vpc;
-}
-
/* Function: avr_scan_prologue
This function decodes an AVR function prologue to determine:
types. */
static CORE_ADDR
-avr_scan_prologue (CORE_ADDR pc, struct avr_unwind_cache *info)
+avr_scan_prologue (struct gdbarch *gdbarch, CORE_ADDR pc_beg, CORE_ADDR pc_end,
+ struct avr_unwind_cache *info)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int i;
unsigned short insn;
int scan_stage = 0;
struct minimal_symbol *msymbol;
unsigned char prologue[AVR_MAX_PROLOGUE_SIZE];
int vpc = 0;
+ int len;
+
+ len = pc_end - pc_beg;
+ if (len > AVR_MAX_PROLOGUE_SIZE)
+ len = AVR_MAX_PROLOGUE_SIZE;
/* FIXME: TRoth/2003-06-11: This could be made more efficient by only
reading in the bytes of the prologue. The problem is that the figuring
out where the end of the prologue is is a bit difficult. The old code
tried to do that, but failed quite often. */
- read_memory (pc, prologue, AVR_MAX_PROLOGUE_SIZE);
+ read_memory (pc_beg, prologue, len);
/* Scanning main()'s prologue
ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
out __SP_H__,r29
out __SP_L__,r28 */
- if (1)
+ if (len >= 4)
{
CORE_ADDR locals;
- unsigned char img[] = {
+ static const unsigned char img[] = {
0xde, 0xbf, /* out __SP_H__,r29 */
0xcd, 0xbf /* out __SP_L__,r28 */
};
- insn = EXTRACT_INSN (&prologue[vpc]);
+ insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
/* ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>) */
if ((insn & 0xf0f0) == 0xe0c0)
{
locals = (insn & 0xf) | ((insn & 0x0f00) >> 4);
- insn = EXTRACT_INSN (&prologue[vpc + 2]);
+ insn = extract_unsigned_integer (&prologue[vpc + 2], 2, byte_order);
/* ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>) */
if ((insn & 0xf0f0) == 0xe0d0)
{
locals |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
- if (memcmp (prologue + vpc + 4, img, sizeof (img)) == 0)
+ if (vpc + 4 + sizeof (img) < len
+ && memcmp (prologue + vpc + 4, img, sizeof (img)) == 0)
{
info->prologue_type = AVR_PROLOGUE_MAIN;
info->base = locals;
- return pc + 4;
+ return pc_beg + 4;
}
}
}
unsigned num_pushes;
int pc_offset = 0;
- insn = EXTRACT_INSN (&prologue[vpc]);
+ /* At least the fifth instruction must have been executed to
+ modify frame shape. */
+ if (len < 10)
+ break;
+
+ insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
/* ldi r26,<LOCALS_SIZE> */
if ((insn & 0xf0f0) != 0xe0a0)
break;
loc_size = (insn & 0xf) | ((insn & 0x0f00) >> 4);
pc_offset += 2;
- insn = EXTRACT_INSN (&prologue[vpc + 2]);
+ insn = extract_unsigned_integer (&prologue[vpc + 2], 2, byte_order);
/* ldi r27,<LOCALS_SIZE> / 256 */
if ((insn & 0xf0f0) != 0xe0b0)
break;
loc_size |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
pc_offset += 2;
- insn = EXTRACT_INSN (&prologue[vpc + 4]);
+ insn = extract_unsigned_integer (&prologue[vpc + 4], 2, byte_order);
/* ldi r30,pm_lo8(.L_foo_body) */
if ((insn & 0xf0f0) != 0xe0e0)
break;
body_addr = (insn & 0xf) | ((insn & 0x0f00) >> 4);
pc_offset += 2;
- insn = EXTRACT_INSN (&prologue[vpc + 6]);
+ insn = extract_unsigned_integer (&prologue[vpc + 6], 2, byte_order);
/* ldi r31,pm_hi8(.L_foo_body) */
if ((insn & 0xf0f0) != 0xe0f0)
break;
if (!msymbol)
break;
- insn = EXTRACT_INSN (&prologue[vpc + 8]);
+ insn = extract_unsigned_integer (&prologue[vpc + 8], 2, byte_order);
/* rjmp __prologue_saves__+RRR */
if ((insn & 0xf000) == 0xc000)
{
/* Convert offset to byte addressable mode */
i *= 2;
/* Destination address */
- i += pc + 10;
+ i += pc_beg + 10;
- if (body_addr != (pc + 10)/2)
+ if (body_addr != (pc_beg + 10)/2)
break;
pc_offset += 2;
{
/* Extract absolute PC address from JMP */
i = (((insn & 0x1) | ((insn & 0x1f0) >> 3) << 16)
- | (EXTRACT_INSN (&prologue[vpc + 10]) & 0xffff));
+ | (extract_unsigned_integer (&prologue[vpc + 10], 2, byte_order)
+ & 0xffff));
/* Convert address to byte addressable mode */
i *= 2;
- if (body_addr != (pc + 12)/2)
+ if (body_addr != (pc_beg + 12)/2)
break;
pc_offset += 4;
info->size = loc_size + num_pushes;
info->prologue_type = AVR_PROLOGUE_CALL;
- return pc + pc_offset;
+ return pc_beg + pc_offset;
}
/* Scan for the beginning of the prologue for an interrupt or signal
if (1)
{
- unsigned char img[] = {
+ static const unsigned char img[] = {
0x78, 0x94, /* sei */
0x1f, 0x92, /* push r1 */
0x0f, 0x92, /* push r0 */
0x0f, 0x92, /* push r0 */
0x11, 0x24 /* clr r1 */
};
- if (memcmp (prologue, img, sizeof (img)) == 0)
+ if (len >= sizeof (img)
+ && memcmp (prologue, img, sizeof (img)) == 0)
{
info->prologue_type = AVR_PROLOGUE_INTR;
vpc += sizeof (img);
info->saved_regs[1].addr = 1;
info->size += 3;
}
- else if (memcmp (img + 2, prologue, sizeof (img) - 2) == 0)
+ else if (len >= sizeof (img) - 2
+ && memcmp (img + 2, prologue, sizeof (img) - 2) == 0)
{
info->prologue_type = AVR_PROLOGUE_SIG;
vpc += sizeof (img) - 2;
/* First stage of the prologue scanning.
Scan pushes (saved registers) */
- for (; vpc < AVR_MAX_PROLOGUE_SIZE; vpc += 2)
+ for (; vpc < len; vpc += 2)
{
- insn = EXTRACT_INSN (&prologue[vpc]);
+ insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
if ((insn & 0xfe0f) == 0x920f) /* push rXX */
{
/* Bits 4-9 contain a mask for registers R0-R32. */
in r28,__SP_L__
in r29,__SP_H__ */
- if (scan_stage == 1 && vpc < AVR_MAX_PROLOGUE_SIZE)
+ if (scan_stage == 1 && vpc < len)
{
- unsigned char img[] = {
+ static const unsigned char img[] = {
0xcd, 0xb7, /* in r28,__SP_L__ */
0xde, 0xb7 /* in r29,__SP_H__ */
};
unsigned short insn1;
- if (memcmp (prologue + vpc, img, sizeof (img)) == 0)
+ if (vpc + sizeof (img) < len
+ && memcmp (prologue + vpc, img, sizeof (img)) == 0)
{
vpc += 4;
scan_stage = 2;
out __SREG__,__tmp_reg__
out __SP_L__,r28 */
- if (scan_stage == 2 && vpc < AVR_MAX_PROLOGUE_SIZE)
+ if (scan_stage == 2 && vpc < len)
{
int locals_size = 0;
- unsigned char img[] = {
+ static const unsigned char img[] = {
0x0f, 0xb6, /* in r0,0x3f */
0xf8, 0x94, /* cli */
0xde, 0xbf, /* out 0x3e,r29 ; SPH */
0x0f, 0xbe, /* out 0x3f,r0 ; SREG */
0xcd, 0xbf /* out 0x3d,r28 ; SPL */
};
- unsigned char img_sig[] = {
+ static const unsigned char img_sig[] = {
0xde, 0xbf, /* out 0x3e,r29 ; SPH */
0xcd, 0xbf /* out 0x3d,r28 ; SPL */
};
- unsigned char img_int[] = {
+ static const unsigned char img_int[] = {
0xf8, 0x94, /* cli */
0xde, 0xbf, /* out 0x3e,r29 ; SPH */
0x78, 0x94, /* sei */
0xcd, 0xbf /* out 0x3d,r28 ; SPL */
};
- insn = EXTRACT_INSN (&prologue[vpc]);
+ insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
vpc += 2;
if ((insn & 0xff30) == 0x9720) /* sbiw r28,XXX */
locals_size = (insn & 0xf) | ((insn & 0xc0) >> 2);
else if ((insn & 0xf0f0) == 0x50c0) /* subi r28,lo8(XX) */
{
locals_size = (insn & 0xf) | ((insn & 0xf00) >> 4);
- insn = EXTRACT_INSN (&prologue[vpc]);
+ insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
vpc += 2;
locals_size += ((insn & 0xf) | ((insn & 0xf00) >> 4) << 8);
}
else
- return pc + vpc;
+ return pc_beg + vpc;
/* Scan the last part of the prologue. May not be present for interrupt
or signal handler functions, which is why we set the prologue type
when we saw the beginning of the prologue previously. */
- if (memcmp (prologue + vpc, img_sig, sizeof (img_sig)) == 0)
+ if (vpc + sizeof (img_sig) < len
+ && memcmp (prologue + vpc, img_sig, sizeof (img_sig)) == 0)
{
vpc += sizeof (img_sig);
}
- else if (memcmp (prologue + vpc, img_int, sizeof (img_int)) == 0)
+ else if (vpc + sizeof (img_int) < len
+ && memcmp (prologue + vpc, img_int, sizeof (img_int)) == 0)
{
vpc += sizeof (img_int);
}
- if (memcmp (prologue + vpc, img, sizeof (img)) == 0)
+ if (vpc + sizeof (img) < len
+ && memcmp (prologue + vpc, img, sizeof (img)) == 0)
{
info->prologue_type = AVR_PROLOGUE_NORMAL;
vpc += sizeof (img);
info->size += locals_size;
- return pc + avr_scan_arg_moves (vpc, prologue);
+ /* Fall through. */
}
/* If we got this far, we could not scan the prologue, so just return the pc
of the frame plus an adjustment for argument move insns. */
- return pc + avr_scan_arg_moves (vpc, prologue);;
+ for (; vpc < len; vpc += 2)
+ {
+ insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
+ if ((insn & 0xff00) == 0x0100) /* movw rXX, rYY */
+ continue;
+ else if ((insn & 0xfc00) == 0x2c00) /* mov rXX, rYY */
+ continue;
+ else
+ break;
+ }
+
+ return pc_beg + vpc;
}
static CORE_ADDR
prologue and possibly skip over moving arguments passed via registers
to other registers. */
- prologue_end = avr_scan_prologue (pc, &info);
+ prologue_end = avr_scan_prologue (gdbarch, func_addr, func_end, &info);
if (info.prologue_type == AVR_PROLOGUE_NONE)
return pc;
}
}
-/* Either we didn't find the start of this function (nothing we can do),
- or there's no line info, or the line after the prologue is after
- the end of the function (there probably isn't a prologue). */
+ /* Either we didn't find the start of this function (nothing we can do),
+ or there's no line info, or the line after the prologue is after
+ the end of the function (there probably isn't a prologue). */
return prologue_end;
}
static const unsigned char *
avr_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR * pcptr, int *lenptr)
{
- static unsigned char avr_break_insn [] = { 0x98, 0x95 };
+ static const unsigned char avr_break_insn [] = { 0x98, 0x95 };
*lenptr = sizeof (avr_break_insn);
return avr_break_insn;
}
-/* Given a return value in `regbuf' with a type `valtype',
+/* Given a return value in `regcache' with a type `type',
extract and copy its value into `valbuf'.
Return values are always passed via registers r25:r24:... */
avr_extract_return_value (struct type *type, struct regcache *regcache,
gdb_byte *valbuf)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
ULONGEST r24, r25;
ULONGEST c;
int len;
if (TYPE_LENGTH (type) == 1)
{
regcache_cooked_read_unsigned (regcache, 24, &c);
- store_unsigned_integer (valbuf, 1, c);
+ store_unsigned_integer (valbuf, 1, byte_order, c);
}
else
{
and copy it into READBUF. If WRITEBUF is non-zero, write the value
from WRITEBUF into REGCACHE. */
-enum return_value_convention
+static enum return_value_convention
avr_return_value (struct gdbarch *gdbarch, struct type *func_type,
struct type *valtype, struct regcache *regcache,
gdb_byte *readbuf, const gdb_byte *writebuf)
in the stack frame. sp is even more special: the address we return
for it IS the sp for the next frame. */
-struct avr_unwind_cache *
+static struct avr_unwind_cache *
avr_frame_unwind_cache (struct frame_info *this_frame,
void **this_prologue_cache)
{
- CORE_ADDR pc;
+ CORE_ADDR start_pc, current_pc;
ULONGEST prev_sp;
ULONGEST this_base;
struct avr_unwind_cache *info;
+ struct gdbarch *gdbarch;
+ struct gdbarch_tdep *tdep;
int i;
- if ((*this_prologue_cache))
- return (*this_prologue_cache);
+ if (*this_prologue_cache)
+ return *this_prologue_cache;
info = FRAME_OBSTACK_ZALLOC (struct avr_unwind_cache);
- (*this_prologue_cache) = info;
+ *this_prologue_cache = info;
info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
info->size = 0;
info->prologue_type = AVR_PROLOGUE_NONE;
- pc = get_frame_func (this_frame);
-
- if ((pc > 0) && (pc < get_frame_pc (this_frame)))
- avr_scan_prologue (pc, info);
+ start_pc = get_frame_func (this_frame);
+ current_pc = get_frame_pc (this_frame);
+ if ((start_pc > 0) && (start_pc <= current_pc))
+ avr_scan_prologue (get_frame_arch (this_frame),
+ start_pc, current_pc, info);
if ((info->prologue_type != AVR_PROLOGUE_NONE)
&& (info->prologue_type != AVR_PROLOGUE_MAIN))
was created. Get THIS frame's FP value by unwinding it from
the next frame. */
this_base = get_frame_register_unsigned (this_frame, AVR_FP_REGNUM);
- high_base = get_frame_register_unsigned (this_frame, AVR_FP_REGNUM+1);
+ high_base = get_frame_register_unsigned (this_frame, AVR_FP_REGNUM + 1);
this_base += (high_base << 8);
/* The FP points at the last saved register. Adjust the FP back
/* Add 1 here to adjust for the post-decrement nature of the push
instruction.*/
- info->prev_sp = avr_make_saddr (prev_sp+1);
-
+ info->prev_sp = avr_make_saddr (prev_sp + 1);
info->base = avr_make_saddr (this_base);
+ gdbarch = get_frame_arch (this_frame);
+
/* Adjust all the saved registers so that they contain addresses and not
offsets. */
- for (i = 0; i < gdbarch_num_regs (get_frame_arch (this_frame)) - 1; i++)
- if (info->saved_regs[i].addr)
- {
- info->saved_regs[i].addr = (info->prev_sp - info->saved_regs[i].addr);
- }
+ for (i = 0; i < gdbarch_num_regs (gdbarch) - 1; i++)
+ if (info->saved_regs[i].addr > 0)
+ info->saved_regs[i].addr = info->prev_sp - info->saved_regs[i].addr;
/* Except for the main and startup code, the return PC is always saved on
the stack and is at the base of the frame. */
if (info->prologue_type != AVR_PROLOGUE_MAIN)
- {
- info->saved_regs[AVR_PC_REGNUM].addr = info->prev_sp;
- }
+ info->saved_regs[AVR_PC_REGNUM].addr = info->prev_sp;
/* The previous frame's SP needed to be computed. Save the computed
value. */
- trad_frame_set_value (info->saved_regs, AVR_SP_REGNUM, info->prev_sp+1);
+ tdep = gdbarch_tdep (gdbarch);
+ trad_frame_set_value (info->saved_regs, AVR_SP_REGNUM,
+ info->prev_sp - 1 + tdep->call_length);
return info;
}
static struct value *
avr_frame_prev_register (struct frame_info *this_frame,
- void **this_prologue_cache, int regnum)
+ void **this_prologue_cache, int regnum)
{
+ struct gdbarch *gdbarch = get_frame_arch (this_frame);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
struct avr_unwind_cache *info
= avr_frame_unwind_cache (this_frame, this_prologue_cache);
And to confuse matters even more, the return address stored
on the stack is in big endian byte order, even though most
everything else about the avr is little endian. Ick! */
-
- /* FIXME: number of bytes read here will need updated for the
- mega256 when it is available. */
-
ULONGEST pc;
- unsigned char tmp;
- unsigned char buf[2];
+ int i;
+ unsigned char buf[3];
+ struct gdbarch *gdbarch = get_frame_arch (this_frame);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- read_memory (info->saved_regs[regnum].addr, buf, 2);
+ read_memory (info->saved_regs[regnum].addr, buf, tdep->call_length);
- /* Convert the PC read from memory as a big-endian to
- little-endian order. */
- tmp = buf[0];
- buf[0] = buf[1];
- buf[1] = tmp;
+ /* Extract the PC read from memory as a big-endian. */
+ pc = 0;
+ for (i = 0; i < tdep->call_length; i++)
+ pc = (pc << 8) | buf[i];
- pc = (extract_unsigned_integer (buf, 2) * 2);
-
- return frame_unwind_got_constant (this_frame, regnum, pc);
+ return frame_unwind_got_constant (this_frame, regnum, pc << 1);
}
return frame_unwind_got_optimized (this_frame, regnum);
int nargs, struct value **args, CORE_ADDR sp,
int struct_return, CORE_ADDR struct_addr)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int i;
- unsigned char buf[2];
+ unsigned char buf[3];
+ int call_length = gdbarch_tdep (gdbarch)->call_length;
CORE_ADDR return_pc = avr_convert_iaddr_to_raw (bp_addr);
int regnum = AVR_ARGN_REGNUM;
struct stack_item *si = NULL;
if (len & 1)
regnum--;
- val = extract_unsigned_integer (contents, len);
- for (j=0; j<len; j++)
- {
- regcache_cooked_write_unsigned (regcache, regnum--,
- val >> (8*(len-j-1)));
- }
+ val = extract_unsigned_integer (contents, len, byte_order);
+ for (j = 0; j < len; j++)
+ regcache_cooked_write_unsigned
+ (regcache, regnum--, val >> (8 * (len - j - 1)));
}
/* No registers available, push the args onto the stack. */
else
{
sp -= si->len;
/* Add 1 to sp here to account for post decr nature of pushes. */
- write_memory (sp+1, si->data, si->len);
+ write_memory (sp + 1, si->data, si->len);
si = pop_stack_item (si);
}
/* Set the return address. For the avr, the return address is the BP_ADDR.
Need to push the return address onto the stack noting that it needs to be
in big-endian order on the stack. */
- buf[0] = (return_pc >> 8) & 0xff;
- buf[1] = return_pc & 0xff;
+ for (i = 1; i <= call_length; i++)
+ {
+ buf[call_length - i] = return_pc & 0xff;
+ return_pc >>= 8;
+ }
- sp -= 2;
- write_memory (sp+1, buf, 2); /* Add one since pushes are post decr ops. */
+ sp -= call_length;
+ /* Use 'sp + 1' since pushes are post decr ops. */
+ write_memory (sp + 1, buf, call_length);
/* Finally, update the SP register. */
regcache_cooked_write_unsigned (regcache, AVR_SP_REGNUM,
avr_convert_saddr_to_raw (sp));
- return sp;
+ /* Return SP value for the dummy frame, where the return address hasn't been
+ pushed. */
+ return sp + call_length;
}
/* Initialize the gdbarch structure for the AVR's. */
{
struct gdbarch *gdbarch;
struct gdbarch_tdep *tdep;
+ struct gdbarch_list *best_arch;
+ int call_length;
- /* Find a candidate among the list of pre-declared architectures. */
- arches = gdbarch_list_lookup_by_info (arches, &info);
- if (arches != NULL)
- return arches->gdbarch;
-
- /* None found, create a new architecture from the information provided. */
- tdep = XMALLOC (struct gdbarch_tdep);
- gdbarch = gdbarch_alloc (&info, tdep);
-
- /* If we ever need to differentiate the device types, do it here. */
+ /* Avr-6 call instructions save 3 bytes. */
switch (info.bfd_arch_info->mach)
{
case bfd_mach_avr1:
case bfd_mach_avr3:
case bfd_mach_avr4:
case bfd_mach_avr5:
+ default:
+ call_length = 2;
+ break;
+ case bfd_mach_avr6:
+ call_length = 3;
break;
}
+ /* If there is already a candidate, use it. */
+ for (best_arch = gdbarch_list_lookup_by_info (arches, &info);
+ best_arch != NULL;
+ best_arch = gdbarch_list_lookup_by_info (best_arch->next, &info))
+ {
+ if (gdbarch_tdep (best_arch->gdbarch)->call_length == call_length)
+ return best_arch->gdbarch;
+ }
+
+ /* None found, create a new architecture from the information provided. */
+ tdep = XMALLOC (struct gdbarch_tdep);
+ gdbarch = gdbarch_alloc (&info, tdep);
+
+ tdep->call_length = call_length;
+
set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);