/* Target-dependent code for Atmel AVR, for GDB.
- Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
+ Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
Free Software Foundation, Inc.
This file is part of GDB.
}
static CORE_ADDR
-avr_pointer_to_address (struct type *type, void *buf)
+avr_pointer_to_address (struct type *type, const void *buf)
{
CORE_ADDR addr = extract_address (buf, TYPE_LENGTH (type));
return addr * 2;
}
-/* avr_scan_prologue is also used as the frame_init_saved_regs().
+/* avr_scan_prologue is also used as the
+ deprecated_frame_init_saved_regs().
Put here the code to store, into fi->saved_regs, the addresses of
the saved registers of frame described by FRAME_INFO. This
unsigned char prologue[AVR_MAX_PROLOGUE_SIZE];
int vpc = 0;
- fi->extra_info->framereg = AVR_SP_REGNUM;
+ get_frame_extra_info (fi)->framereg = AVR_SP_REGNUM;
if (find_pc_partial_function
(get_frame_pc (fi), &name, &prologue_start, &prologue_end))
/* Search the prologue looking for instructions that set up the
frame pointer, adjust the stack pointer, and save registers. */
- fi->extra_info->framesize = 0;
+ get_frame_extra_info (fi)->framesize = 0;
prologue_len = prologue_end - prologue_start;
read_memory (prologue_start, prologue, prologue_len);
0xcd, 0xbf /* out __SP_L__,r28 */
};
- fi->extra_info->framereg = AVR_FP_REGNUM;
+ get_frame_extra_info (fi)->framereg = AVR_FP_REGNUM;
insn = EXTRACT_INSN (&prologue[vpc]);
/* ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>) */
if ((insn & 0xf0f0) == 0xe0c0)
locals |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
if (memcmp (prologue + vpc + 4, img, sizeof (img)) == 0)
{
- fi->frame = locals;
+ deprecated_update_frame_base_hack (fi, locals);
- fi->extra_info->is_main = 1;
+ get_frame_extra_info (fi)->is_main = 1;
return;
}
}
if (num_pushes)
{
int from;
- fi->saved_regs[AVR_FP_REGNUM + 1] = num_pushes;
+ get_frame_saved_regs (fi)[AVR_FP_REGNUM + 1] = num_pushes;
if (num_pushes >= 2)
- fi->saved_regs[AVR_FP_REGNUM] = num_pushes - 1;
+ get_frame_saved_regs (fi)[AVR_FP_REGNUM] = num_pushes - 1;
i = 0;
for (from = AVR_LAST_PUSHED_REGNUM + 1 - (num_pushes - 2);
from <= AVR_LAST_PUSHED_REGNUM; ++from)
- fi->saved_regs[from] = ++i;
+ get_frame_saved_regs (fi)[from] = ++i;
}
- fi->extra_info->locals_size = loc_size;
- fi->extra_info->framesize = loc_size + num_pushes;
- fi->extra_info->framereg = AVR_FP_REGNUM;
+ get_frame_extra_info (fi)->locals_size = loc_size;
+ get_frame_extra_info (fi)->framesize = loc_size + num_pushes;
+ get_frame_extra_info (fi)->framereg = AVR_FP_REGNUM;
return;
}
if (memcmp (prologue, img, sizeof (img)) == 0)
{
vpc += sizeof (img);
- fi->saved_regs[0] = 2;
- fi->saved_regs[1] = 1;
- fi->extra_info->framesize += 3;
+ get_frame_saved_regs (fi)[0] = 2;
+ get_frame_saved_regs (fi)[1] = 1;
+ get_frame_extra_info (fi)->framesize += 3;
}
else if (memcmp (img + 1, prologue, sizeof (img) - 1) == 0)
{
vpc += sizeof (img) - 1;
- fi->saved_regs[0] = 2;
- fi->saved_regs[1] = 1;
- fi->extra_info->framesize += 3;
+ get_frame_saved_regs (fi)[0] = 2;
+ get_frame_saved_regs (fi)[1] = 1;
+ get_frame_extra_info (fi)->framesize += 3;
}
}
{
/* Bits 4-9 contain a mask for registers R0-R32. */
regno = (insn & 0x1f0) >> 4;
- ++fi->extra_info->framesize;
- fi->saved_regs[regno] = fi->extra_info->framesize;
+ ++get_frame_extra_info (fi)->framesize;
+ get_frame_saved_regs (fi)[regno] = get_frame_extra_info (fi)->framesize;
scan_stage = 1;
}
else
if (memcmp (prologue + vpc, img, sizeof (img)) == 0)
{
vpc += 4;
- fi->extra_info->framereg = AVR_FP_REGNUM;
+ get_frame_extra_info (fi)->framereg = AVR_FP_REGNUM;
scan_stage = 2;
}
}
}
else
return;
- fi->extra_info->locals_size = locals_size;
- fi->extra_info->framesize += locals_size;
+ get_frame_extra_info (fi)->locals_size = locals_size;
+ get_frame_extra_info (fi)->framesize += locals_size;
}
}
{
int reg;
- if (fi->next)
- deprecated_update_frame_pc_hack (fi, FRAME_SAVED_PC (fi->next));
+ if (get_next_frame (fi))
+ deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi)));
- fi->extra_info = (struct frame_extra_info *)
- frame_obstack_alloc (sizeof (struct frame_extra_info));
+ frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
frame_saved_regs_zalloc (fi);
- fi->extra_info->return_pc = 0;
- fi->extra_info->args_pointer = 0;
- fi->extra_info->locals_size = 0;
- fi->extra_info->framereg = 0;
- fi->extra_info->framesize = 0;
- fi->extra_info->is_main = 0;
+ get_frame_extra_info (fi)->return_pc = 0;
+ get_frame_extra_info (fi)->args_pointer = 0;
+ get_frame_extra_info (fi)->locals_size = 0;
+ get_frame_extra_info (fi)->framereg = 0;
+ get_frame_extra_info (fi)->framesize = 0;
+ get_frame_extra_info (fi)->is_main = 0;
avr_scan_prologue (fi);
- if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), fi->frame, fi->frame))
+ if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
+ get_frame_base (fi)))
{
/* We need to setup fi->frame here because run_stack_dummy gets it wrong
by assuming it's always FP. */
- fi->frame = deprecated_read_register_dummy (get_frame_pc (fi), fi->frame,
- AVR_PC_REGNUM);
+ deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi),
+ AVR_PC_REGNUM));
}
- else if (!fi->next) /* this is the innermost frame? */
- fi->frame = read_register (fi->extra_info->framereg);
- else if (fi->extra_info->is_main != 1) /* not the innermost frame, not `main' */
+ else if (!get_next_frame (fi))
+ /* this is the innermost frame? */
+ deprecated_update_frame_base_hack (fi, read_register (get_frame_extra_info (fi)->framereg));
+ else if (get_frame_extra_info (fi)->is_main != 1)
+ /* not the innermost frame, not `main' */
/* If we have an next frame, the callee saved it. */
{
- struct frame_info *next_fi = fi->next;
- if (fi->extra_info->framereg == AVR_SP_REGNUM)
- fi->frame =
- next_fi->frame + 2 /* ret addr */ + next_fi->extra_info->framesize;
+ struct frame_info *next_fi = get_next_frame (fi);
+ if (get_frame_extra_info (fi)->framereg == AVR_SP_REGNUM)
+ deprecated_update_frame_base_hack (fi, (get_frame_base (next_fi)
+ + 2 /* ret addr */
+ + get_frame_extra_info (next_fi)->framesize));
/* FIXME: I don't analyse va_args functions */
else
{
unsigned int fp_low, fp_high;
/* Scan all frames */
- for (; next_fi; next_fi = next_fi->next)
+ for (; next_fi; next_fi = get_next_frame (next_fi))
{
/* look for saved AVR_FP_REGNUM */
- if (next_fi->saved_regs[AVR_FP_REGNUM] && !fp)
- fp = next_fi->saved_regs[AVR_FP_REGNUM];
+ if (get_frame_saved_regs (next_fi)[AVR_FP_REGNUM] && !fp)
+ fp = get_frame_saved_regs (next_fi)[AVR_FP_REGNUM];
/* look for saved AVR_FP_REGNUM + 1 */
- if (next_fi->saved_regs[AVR_FP_REGNUM + 1] && !fp1)
- fp1 = next_fi->saved_regs[AVR_FP_REGNUM + 1];
+ if (get_frame_saved_regs (next_fi)[AVR_FP_REGNUM + 1] && !fp1)
+ fp1 = get_frame_saved_regs (next_fi)[AVR_FP_REGNUM + 1];
}
fp_low = (fp ? read_memory_unsigned_integer (avr_make_saddr (fp), 1)
: read_register (AVR_FP_REGNUM)) & 0xff;
fp_high =
(fp1 ? read_memory_unsigned_integer (avr_make_saddr (fp1), 1) :
read_register (AVR_FP_REGNUM + 1)) & 0xff;
- fi->frame = fp_low | (fp_high << 8);
+ deprecated_update_frame_base_hack (fi, fp_low | (fp_high << 8));
}
}
/* TRoth: Do we want to do this if we are in main? I don't think we should
since return_pc makes no sense when we are in main. */
- if ((get_frame_pc (fi)) && (fi->extra_info->is_main == 0)) /* We are not in CALL_DUMMY */
+ if ((get_frame_pc (fi)) && (get_frame_extra_info (fi)->is_main == 0))
+ /* We are not in CALL_DUMMY */
{
CORE_ADDR addr;
int i;
- addr = fi->frame + fi->extra_info->framesize + 1;
+ addr = get_frame_base (fi) + get_frame_extra_info (fi)->framesize + 1;
/* Return address in stack in different endianness */
- fi->extra_info->return_pc =
+ get_frame_extra_info (fi)->return_pc =
read_memory_unsigned_integer (avr_make_saddr (addr), 1) << 8;
- fi->extra_info->return_pc |=
+ get_frame_extra_info (fi)->return_pc |=
read_memory_unsigned_integer (avr_make_saddr (addr + 1), 1);
/* This return address in words,
must be converted to the bytes address */
- fi->extra_info->return_pc *= 2;
+ get_frame_extra_info (fi)->return_pc *= 2;
/* Resolve a pushed registers addresses */
for (i = 0; i < NUM_REGS; i++)
{
- if (fi->saved_regs[i])
- fi->saved_regs[i] = addr - fi->saved_regs[i];
+ if (get_frame_saved_regs (fi)[i])
+ get_frame_saved_regs (fi)[i] = addr - get_frame_saved_regs (fi)[i];
}
}
}
CORE_ADDR saddr;
struct frame_info *frame = get_current_frame ();
- if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame), frame->frame, frame->frame))
+ if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
+ get_frame_base (frame),
+ get_frame_base (frame)))
{
generic_pop_dummy_frame ();
}
{
/* Don't forget AVR_SP_REGNUM in a frame_saved_regs struct is the
actual value we want, not the address of the value we want. */
- if (frame->saved_regs[regnum] && regnum != AVR_SP_REGNUM)
+ if (get_frame_saved_regs (frame)[regnum] && regnum != AVR_SP_REGNUM)
{
- saddr = avr_make_saddr (frame->saved_regs[regnum]);
+ saddr = avr_make_saddr (get_frame_saved_regs (frame)[regnum]);
write_register (regnum,
read_memory_unsigned_integer (saddr, 1));
}
- else if (frame->saved_regs[regnum] && regnum == AVR_SP_REGNUM)
- write_register (regnum, frame->frame + 2);
+ else if (get_frame_saved_regs (frame)[regnum] && regnum == AVR_SP_REGNUM)
+ write_register (regnum, get_frame_base (frame) + 2);
}
/* Don't forget the update the PC too! */
- write_pc (frame->extra_info->return_pc);
+ write_pc (get_frame_extra_info (frame)->return_pc);
}
flush_cached_frames ();
}
static CORE_ADDR
avr_frame_saved_pc (struct frame_info *frame)
{
- if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame), frame->frame, frame->frame))
- return deprecated_read_register_dummy (get_frame_pc (frame), frame->frame,
+ if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
+ get_frame_base (frame),
+ get_frame_base (frame)))
+ return deprecated_read_register_dummy (get_frame_pc (frame),
+ get_frame_base (frame),
AVR_PC_REGNUM);
else
- return frame->extra_info->return_pc;
+ return get_frame_extra_info (frame)->return_pc;
}
static CORE_ADDR
return (m2 | (m1 << 8)) * 2;
}
-/* Figure out where in REGBUF the called function has left its return value.
- Copy that into VALBUF. */
-
-static void
-avr_extract_return_value (struct type *type, char *regbuf, char *valbuf)
-{
- int wordsize, len;
-
- wordsize = 2;
-
- len = TYPE_LENGTH (type);
-
- switch (len)
- {
- case 1: /* (char) */
- case 2: /* (short), (int) */
- memcpy (valbuf, regbuf + REGISTER_BYTE (24), 2);
- break;
- case 4: /* (long), (float) */
- memcpy (valbuf, regbuf + REGISTER_BYTE (22), 4);
- break;
- case 8: /* (double) (doesn't seem to happen, which is good,
- because this almost certainly isn't right. */
- error ("I don't know how a double is returned.");
- break;
- }
-}
-
/* Returns the return address for a dummy. */
static CORE_ADDR
return entry_point_address ();
}
-/* Place the appropriate value in the appropriate registers.
- Primarily used by the RETURN command. */
-
-static void
-avr_store_return_value (struct type *type, char *valbuf)
-{
- int wordsize, len, regval;
-
- wordsize = 2;
-
- len = TYPE_LENGTH (type);
- switch (len)
- {
- case 1: /* char */
- case 2: /* short, int */
- regval = extract_address (valbuf, len);
- write_register (0, regval);
- break;
- case 4: /* long, float */
- regval = extract_address (valbuf, len);
- write_register (0, regval >> 16);
- write_register (1, regval & 0xffff);
- break;
- case 8: /* presumeably double, but doesn't seem to happen */
- error ("I don't know how to return a double.");
- break;
- }
-}
-
/* Setup the return address for a dummy frame, as called by
call_function_by_hand. Only necessary when you are using an empty
CALL_DUMMY. */
static CORE_ADDR
avr_frame_address (struct frame_info *fi)
{
- return avr_make_saddr (fi->frame);
+ return avr_make_saddr (get_frame_base (fi));
}
/* Given a GDB frame, determine the address of the calling function's
frame. This will be used to create a new GDB frame struct, and
- then INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC will be
- called for the new frame.
+ then DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC
+ will be called for the new frame.
For us, the frame address is its stack pointer value, so we look up
the function prologue to determine the caller's sp value, and return it. */
static CORE_ADDR
avr_frame_chain (struct frame_info *frame)
{
- if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame), frame->frame, frame->frame))
+ if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
+ get_frame_base (frame),
+ get_frame_base (frame)))
{
/* initialize the return_pc now */
- frame->extra_info->return_pc
- = deprecated_read_register_dummy (get_frame_pc (frame), frame->frame,
+ get_frame_extra_info (frame)->return_pc
+ = deprecated_read_register_dummy (get_frame_pc (frame),
+ get_frame_base (frame),
AVR_PC_REGNUM);
- return frame->frame;
+ return get_frame_base (frame);
}
- return (frame->extra_info->is_main ? 0
- : frame->frame + frame->extra_info->framesize + 2 /* ret addr */ );
+ return (get_frame_extra_info (frame)->is_main ? 0
+ : get_frame_base (frame) + get_frame_extra_info (frame)->framesize + 2 /* ret addr */ );
}
/* Store the address of the place in which to copy the structure the
write_register (0, addr);
}
-/* Extract from an array REGBUF containing the (raw) register state
- the address in which a function should return its structure value,
- as a CORE_ADDR (or an expression that can be used as one). */
-
-static CORE_ADDR
-avr_extract_struct_value_address (char *regbuf)
-{
- return (extract_address ((regbuf) + REGISTER_BYTE (0),
- REGISTER_RAW_SIZE (0)) | AVR_SMEM_START);
-}
-
/* Setup the function arguments for calling a function in the inferior.
On the AVR architecture, there are 18 registers (R25 to R8) which are
set_gdbarch_write_pc (gdbarch, avr_write_pc);
set_gdbarch_read_fp (gdbarch, avr_read_fp);
set_gdbarch_read_sp (gdbarch, avr_read_sp);
- set_gdbarch_write_sp (gdbarch, avr_write_sp);
+ set_gdbarch_deprecated_dummy_write_sp (gdbarch, avr_write_sp);
set_gdbarch_num_regs (gdbarch, AVR_NUM_REGS);
set_gdbarch_register_bytes (gdbarch, AVR_NUM_REG_BYTES);
set_gdbarch_register_byte (gdbarch, avr_register_byte);
set_gdbarch_register_raw_size (gdbarch, avr_register_raw_size);
- set_gdbarch_max_register_raw_size (gdbarch, 4);
+ set_gdbarch_deprecated_max_register_raw_size (gdbarch, 4);
set_gdbarch_register_virtual_size (gdbarch, avr_register_virtual_size);
- set_gdbarch_max_register_virtual_size (gdbarch, 4);
+ set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 4);
set_gdbarch_register_virtual_type (gdbarch, avr_register_virtual_type);
set_gdbarch_print_insn (gdbarch, print_insn_avr);
set_gdbarch_call_dummy_address (gdbarch, avr_call_dummy_address);
- set_gdbarch_call_dummy_start_offset (gdbarch, 0);
- set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
- set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
- set_gdbarch_call_dummy_length (gdbarch, 0);
- set_gdbarch_call_dummy_p (gdbarch, 1);
set_gdbarch_call_dummy_words (gdbarch, avr_call_dummy_words);
- set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
- set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
/* set_gdbarch_believe_pcc_promotion (gdbarch, 1); // TRoth: should this be set? */
set_gdbarch_address_to_pointer (gdbarch, avr_address_to_pointer);
set_gdbarch_pointer_to_address (gdbarch, avr_pointer_to_address);
- set_gdbarch_deprecated_extract_return_value (gdbarch, avr_extract_return_value);
- set_gdbarch_push_arguments (gdbarch, avr_push_arguments);
- set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
- set_gdbarch_push_return_address (gdbarch, avr_push_return_address);
- set_gdbarch_pop_frame (gdbarch, avr_pop_frame);
-
- set_gdbarch_deprecated_store_return_value (gdbarch, avr_store_return_value);
+ set_gdbarch_deprecated_push_arguments (gdbarch, avr_push_arguments);
+ set_gdbarch_deprecated_push_return_address (gdbarch, avr_push_return_address);
+ set_gdbarch_deprecated_pop_frame (gdbarch, avr_pop_frame);
set_gdbarch_use_struct_convention (gdbarch, generic_use_struct_convention);
- set_gdbarch_store_struct_return (gdbarch, avr_store_struct_return);
- set_gdbarch_deprecated_extract_struct_value_address
- (gdbarch, avr_extract_struct_value_address);
+ set_gdbarch_deprecated_store_struct_return (gdbarch, avr_store_struct_return);
- set_gdbarch_frame_init_saved_regs (gdbarch, avr_scan_prologue);
- set_gdbarch_init_extra_frame_info (gdbarch, avr_init_extra_frame_info);
+ set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, avr_scan_prologue);
+ set_gdbarch_deprecated_init_extra_frame_info (gdbarch, avr_init_extra_frame_info);
set_gdbarch_skip_prologue (gdbarch, avr_skip_prologue);
-/* set_gdbarch_prologue_frameless_p (gdbarch, avr_prologue_frameless_p); */
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
set_gdbarch_decr_pc_after_break (gdbarch, 0);
avr_remote_translate_xfer_address);
set_gdbarch_frame_args_skip (gdbarch, 0);
set_gdbarch_frameless_function_invocation (gdbarch, frameless_look_for_prologue); /* ??? */
- set_gdbarch_frame_chain (gdbarch, avr_frame_chain);
- set_gdbarch_frame_chain_valid (gdbarch, generic_func_frame_chain_valid);
- set_gdbarch_frame_saved_pc (gdbarch, avr_frame_saved_pc);
+ set_gdbarch_deprecated_frame_chain (gdbarch, avr_frame_chain);
+ set_gdbarch_deprecated_frame_saved_pc (gdbarch, avr_frame_saved_pc);
set_gdbarch_frame_args_address (gdbarch, avr_frame_address);
set_gdbarch_frame_locals_address (gdbarch, avr_frame_address);
set_gdbarch_saved_pc_after_call (gdbarch, avr_saved_pc_after_call);
for (i = 0; i < nreg; i += step)
{
- j = step - (nreg % step); /* how many registers this round? */
+ /* how many registers this round? */
+ j = step;
+ if ((i+j) >= nreg)
+ j = nreg - i; /* last block is less than 8 registers */
snprintf (query, sizeof (query) - 1, "avr.io_reg:%x,%x", i, j);
target_query ((int) 'R', query, buf, &bufsiz);
projects / deliverable / binutils-gdb.git / blobdiff