#include "regcache.h"
#include "gdbcore.h"
#include "objfiles.h"
+#include "dis-asm.h"
struct gdbarch_tdep
{
/* Aggregates and return values > 12 bytes are returned in memory,
pointed to by R2. */
return_buffer =
- extract_address (regbuf + REGISTER_BYTE (E_PTR_RET_REGNUM),
- REGISTER_RAW_SIZE (E_PTR_RET_REGNUM));
+ extract_unsigned_integer (regbuf + REGISTER_BYTE (E_PTR_RET_REGNUM),
+ REGISTER_RAW_SIZE (E_PTR_RET_REGNUM));
read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
}
(which may or may not be the same as before).
*/
-CORE_ADDR
+static CORE_ADDR
xstormy16_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
{
unsigned char buf[xstormy16_pc_size];
- store_unsigned_integer (buf, xstormy16_pc_size, CALL_DUMMY_ADDRESS ());
+ store_unsigned_integer (buf, xstormy16_pc_size, entry_point_address ());
write_memory (sp, buf, xstormy16_pc_size);
return sp + xstormy16_pc_size;
}
if (fi == NULL)
return; /* paranoia */
- 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)))
{
generic_pop_dummy_frame ();
}
xstormy16_reg_size));
}
/* Restore the PC */
- write_register (PC_REGNUM, FRAME_SAVED_PC (fi));
+ write_register (PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (fi));
flush_cached_frames ();
}
return;
static CORE_ADDR
xstormy16_extract_struct_value_address (char *regbuf)
{
- return extract_address (regbuf +
- xstormy16_register_byte (E_PTR_RET_REGNUM),
- xstormy16_reg_size);
+ return extract_unsigned_integer (regbuf + xstormy16_register_byte (E_PTR_RET_REGNUM),
+ xstormy16_reg_size);
}
/* Function: xstormy16_use_struct_convention
if (fi)
{
/* In a call dummy, don't touch the frame. */
- 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)))
return start_addr;
/* Grab the frame-relative values of SP and FP, needed below.
fp = xstormy16_frame_saved_register (fi, E_FP_REGNUM);
/* Initialize framesize with size of PC put on stack by CALLF inst. */
- fi->extra_info->framesize = xstormy16_pc_size;
+ get_frame_extra_info (fi)->framesize = xstormy16_pc_size;
}
for (next_addr = start_addr;
next_addr < end_addr; next_addr += xstormy16_inst_size)
if (fi)
{
regnum = inst & 0x000f;
- get_frame_saved_regs (fi)[regnum] = fi->extra_info->framesize;
- fi->extra_info->framesize += xstormy16_reg_size;
+ get_frame_saved_regs (fi)[regnum] = get_frame_extra_info (fi)->framesize;
+ get_frame_extra_info (fi)->framesize += xstormy16_reg_size;
}
}
else if (inst == 0x301f || inst == 0x303f) /* inc r15, #0x1/#0x3 */
{
if (fi) /* Record the frame size. */
- fi->extra_info->framesize += ((inst & 0x0030) >> 4) + 1;
+ get_frame_extra_info (fi)->framesize += ((inst & 0x0030) >> 4) + 1;
}
/* optional stack allocation for args and local vars > 4 && < 16 byte */
else if ((inst & 0xff0f) == 0x510f) /* 51Hf add r15, #0xH */
{
if (fi) /* Record the frame size. */
- fi->extra_info->framesize += (inst & 0x00f0) >> 4;
+ get_frame_extra_info (fi)->framesize += (inst & 0x00f0) >> 4;
}
/* optional stack allocation for args and local vars >= 16 byte */
else if (inst == 0x314f && inst2 >= 0x0010) /* 314f HHHH add r15, #0xH */
{
if (fi) /* Record the frame size. */
- fi->extra_info->framesize += inst2;
+ get_frame_extra_info (fi)->framesize += inst2;
next_addr += xstormy16_inst_size;
}
else if (inst == 0x46fd) /* mov r13, r15 */
{
if (fi) /* Record that the frame pointer is in use. */
- fi->extra_info->frameless_p = 0;
+ get_frame_extra_info (fi)->frameless_p = 0;
if (frameless)
*frameless = 0;
}
if (offset & 0x0800)
offset -= 0x1000;
- get_frame_saved_regs (fi)[regnum] = fi->extra_info->framesize + offset;
+ get_frame_saved_regs (fi)[regnum] = get_frame_extra_info (fi)->framesize + offset;
}
next_addr += xstormy16_inst_size;
}
by convention what we put here is simply the previous
_value_ of the SP (as opposed to an address where the
previous value would have been pushed). */
- if (fi->extra_info->frameless_p)
+ if (get_frame_extra_info (fi)->frameless_p)
{
- get_frame_saved_regs (fi)[E_SP_REGNUM] = sp - fi->extra_info->framesize;
- fi->frame = sp;
+ get_frame_saved_regs (fi)[E_SP_REGNUM] = sp - get_frame_extra_info (fi)->framesize;
+ deprecated_update_frame_base_hack (fi, sp);
}
else
{
- get_frame_saved_regs (fi)[E_SP_REGNUM] = fp - fi->extra_info->framesize;
- fi->frame = fp;
+ get_frame_saved_regs (fi)[E_SP_REGNUM] = fp - get_frame_extra_info (fi)->framesize;
+ deprecated_update_frame_base_hack (fi, fp);
}
/* So far only offsets to the beginning of the frame are
return plg_end;
/* Found a function. */
- sym = lookup_symbol (func_name, NULL, VAR_NAMESPACE, NULL, NULL);
+ sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL, NULL);
/* Don't use line number debug info for assembly source files. */
if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
{
actual value of the previous frame's stack register.
This function may be called in any context where the saved register
- values may be needed (backtrace, frame_info, get_saved_register).
- On many targets, it is called directly by init_extra_frame_info,
- in part because the information may be needed immediately by
- frame_chain.
-*/
+ values may be needed (backtrace, frame_info, frame_register). On
+ many targets, it is called directly by init_extra_frame_info, in
+ part because the information may be needed immediately by
+ frame_chain. */
static void
xstormy16_frame_init_saved_regs (struct frame_info *fi)
/* Function: xstormy16_frame_saved_pc
Returns the return address for the selected frame.
- Called by frame_info, frame_chain_valid, and sometimes by
- get_prev_frame.
-*/
+ Called by frame_info, legacy_frame_chain_valid, and sometimes by
+ get_prev_frame. */
static CORE_ADDR
xstormy16_frame_saved_pc (struct frame_info *fi)
{
CORE_ADDR saved_pc;
- 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)))
{
- saved_pc = deprecated_read_register_dummy (get_frame_pc (fi), fi->frame,
+ saved_pc = deprecated_read_register_dummy (get_frame_pc (fi),
+ get_frame_base (fi),
E_PC_REGNUM);
}
else
static void
xstormy16_init_extra_frame_info (int fromleaf, struct frame_info *fi)
{
- if (!fi->extra_info)
+ if (!get_frame_extra_info (fi))
{
- fi->extra_info = (struct frame_extra_info *)
- frame_obstack_alloc (sizeof (struct frame_extra_info));
- fi->extra_info->framesize = 0;
- fi->extra_info->frameless_p = 1; /* Default frameless, detect framed */
+ frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
+ get_frame_extra_info (fi)->framesize = 0;
+ get_frame_extra_info (fi)->frameless_p = 1; /* Default frameless, detect framed */
/* By default, the fi->frame is set to the value of the FP reg by gdb.
This may not always be right; we may be in a frameless function,
Fortunately this will never happen from the outermost
frame, so we should be able to get the saved pc from
the next frame. */
- if (fi->next)
- deprecated_update_frame_pc_hack (fi, xstormy16_frame_saved_pc (fi->next));
+ if (get_next_frame (fi))
+ deprecated_update_frame_pc_hack (fi, xstormy16_frame_saved_pc (get_next_frame (fi)));
}
/* Take care of the saved_regs right here (non-lazy). */
static CORE_ADDR
xstormy16_frame_chain (struct frame_info *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)))
{
/* Call dummy's frame is the same as caller's. */
- return fi->frame;
+ return get_frame_base (fi);
}
else
{
/* Return computed offset from this frame's fp. */
- return fi->frame - fi->extra_info->framesize;
+ return get_frame_base (fi) - get_frame_extra_info (fi)->framesize;
}
}
static int
xstormy16_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
{
- return chain < 0x8000 && FRAME_SAVED_PC (thisframe) >= 0x8000 &&
- (thisframe->extra_info->frameless_p ||
- thisframe->frame - thisframe->extra_info->framesize == chain);
+ return chain < 0x8000 && DEPRECATED_FRAME_SAVED_PC (thisframe) >= 0x8000 &&
+ (get_frame_extra_info (thisframe)->frameless_p ||
+ get_frame_base (thisframe) - get_frame_extra_info (thisframe)->framesize == chain);
}
-/* Function: xstormy16_saved_pc_after_call
- Returns the previous PC immediately after a function call.
- This function is meant to bypass the regular get_saved_register
- mechanism, ie. it is meant to work even if the frame isn't complete.
- Called by step_over_function, and sometimes by get_prev_frame.
-*/
+/* Function: xstormy16_saved_pc_after_call Returns the previous PC
+ immediately after a function call. This function is meant to
+ bypass the regular frame_register() mechanism, ie. it is meant to
+ work even if the frame isn't complete. Called by
+ step_over_function, and sometimes by get_prev_frame. */
static CORE_ADDR
xstormy16_saved_pc_after_call (struct frame_info *ignore)
xstormy16_pointer_to_address (struct type *type, const void *buf)
{
enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
- CORE_ADDR addr = extract_address (buf, TYPE_LENGTH (type));
+ CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
{
if (addr2)
addr = addr2;
}
- store_address (buf, TYPE_LENGTH (type), addr);
+ store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
}
static CORE_ADDR
return addr;
}
-void
+static void
xstormy16_save_dummy_frame_tos (CORE_ADDR sp)
{
generic_save_dummy_frame_tos (sp - xstormy16_pc_size);
set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
set_gdbarch_num_pseudo_regs (gdbarch, 0);
set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
- set_gdbarch_fp_regnum (gdbarch, E_FP_REGNUM);
+ set_gdbarch_deprecated_fp_regnum (gdbarch, E_FP_REGNUM);
set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
set_gdbarch_register_name (gdbarch, xstormy16_register_name);
- set_gdbarch_register_size (gdbarch, xstormy16_reg_size);
- set_gdbarch_register_bytes (gdbarch, E_ALL_REGS_SIZE);
- set_gdbarch_register_byte (gdbarch, xstormy16_register_byte);
- set_gdbarch_register_raw_size (gdbarch, xstormy16_register_raw_size);
- set_gdbarch_max_register_raw_size (gdbarch, xstormy16_pc_size);
- set_gdbarch_register_virtual_size (gdbarch, xstormy16_register_raw_size);
- set_gdbarch_max_register_virtual_size (gdbarch, 4);
- set_gdbarch_register_virtual_type (gdbarch, xstormy16_reg_virtual_type);
+ set_gdbarch_deprecated_register_size (gdbarch, xstormy16_reg_size);
+ set_gdbarch_deprecated_register_bytes (gdbarch, E_ALL_REGS_SIZE);
+ set_gdbarch_deprecated_register_byte (gdbarch, xstormy16_register_byte);
+ set_gdbarch_deprecated_register_raw_size (gdbarch, xstormy16_register_raw_size);
+ set_gdbarch_deprecated_max_register_raw_size (gdbarch, xstormy16_pc_size);
+ set_gdbarch_deprecated_register_virtual_size (gdbarch, xstormy16_register_raw_size);
+ set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 4);
+ set_gdbarch_deprecated_register_virtual_type (gdbarch, xstormy16_reg_virtual_type);
/*
* Frame Info
*/
- set_gdbarch_init_extra_frame_info (gdbarch,
+ set_gdbarch_deprecated_init_extra_frame_info (gdbarch,
xstormy16_init_extra_frame_info);
- set_gdbarch_frame_init_saved_regs (gdbarch,
+ set_gdbarch_deprecated_frame_init_saved_regs (gdbarch,
xstormy16_frame_init_saved_regs);
- set_gdbarch_frame_chain (gdbarch, xstormy16_frame_chain);
- set_gdbarch_get_saved_register (gdbarch, xstormy16_get_saved_register);
- set_gdbarch_saved_pc_after_call (gdbarch, xstormy16_saved_pc_after_call);
- set_gdbarch_frame_saved_pc (gdbarch, xstormy16_frame_saved_pc);
+ set_gdbarch_deprecated_frame_chain (gdbarch, xstormy16_frame_chain);
+ set_gdbarch_deprecated_get_saved_register (gdbarch, xstormy16_get_saved_register);
+ set_gdbarch_deprecated_saved_pc_after_call (gdbarch, xstormy16_saved_pc_after_call);
+ set_gdbarch_deprecated_frame_saved_pc (gdbarch, xstormy16_frame_saved_pc);
set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue);
- set_gdbarch_frame_chain_valid (gdbarch, xstormy16_frame_chain_valid);
+ set_gdbarch_deprecated_frame_chain_valid (gdbarch, xstormy16_frame_chain_valid);
set_gdbarch_in_function_epilogue_p (gdbarch,
xstormy16_in_function_epilogue_p);
set_gdbarch_function_start_offset (gdbarch, 0);
/* This value is almost never non-zero... */
set_gdbarch_frame_args_skip (gdbarch, 0);
- /* OK to default this value to 'unknown'. */
- set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
/*
* Call Dummies
*
* These values and methods are used when gdb calls a target function. */
- set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
- set_gdbarch_push_return_address (gdbarch, xstormy16_push_return_address);
+ set_gdbarch_deprecated_push_return_address (gdbarch, xstormy16_push_return_address);
set_gdbarch_deprecated_extract_return_value (gdbarch, xstormy16_extract_return_value);
- set_gdbarch_push_arguments (gdbarch, xstormy16_push_arguments);
- set_gdbarch_pop_frame (gdbarch, xstormy16_pop_frame);
- set_gdbarch_store_struct_return (gdbarch, xstormy16_store_struct_return);
+ set_gdbarch_deprecated_push_arguments (gdbarch, xstormy16_push_arguments);
+ set_gdbarch_deprecated_pop_frame (gdbarch, xstormy16_pop_frame);
+ set_gdbarch_deprecated_store_struct_return (gdbarch, xstormy16_store_struct_return);
set_gdbarch_deprecated_store_return_value (gdbarch, xstormy16_store_return_value);
set_gdbarch_deprecated_extract_struct_value_address (gdbarch, xstormy16_extract_struct_value_address);
set_gdbarch_use_struct_convention (gdbarch,
xstormy16_use_struct_convention);
- set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
- set_gdbarch_call_dummy_start_offset (gdbarch, 0);
- set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
- set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
- set_gdbarch_call_dummy_length (gdbarch, 0);
- set_gdbarch_call_dummy_p (gdbarch, 1);
- set_gdbarch_call_dummy_words (gdbarch, call_dummy_words);
- set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
- set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
- /* set_gdbarch_call_dummy_stack_adjust */
- set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
+ set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_words);
+ set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_breakpoint_from_pc (gdbarch, xstormy16_breakpoint_from_pc);
+ set_gdbarch_char_signed (gdbarch, 0);
set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);
- set_gdbarch_stack_align (gdbarch, xstormy16_stack_align);
- set_gdbarch_extra_stack_alignment_needed (gdbarch, 0);
+ set_gdbarch_deprecated_stack_align (gdbarch, xstormy16_stack_align);
- set_gdbarch_save_dummy_frame_tos (gdbarch, xstormy16_save_dummy_frame_tos);
+ set_gdbarch_deprecated_save_dummy_frame_tos (gdbarch, xstormy16_save_dummy_frame_tos);
set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code);
set_gdbarch_in_solib_call_trampoline (gdbarch,
xstormy16_in_solib_call_trampoline);
+ /* Should be using push_dummy_call. */
+ set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
+
+ set_gdbarch_print_insn (gdbarch, print_insn_xstormy16);
+
return gdbarch;
}
Initializer function for the Sanyo Xstormy16a module.
Called by gdb at start-up. */
+extern initialize_file_ftype _initialize_xstormy16_tdep; /* -Wmissing-prototypes */
+
void
_initialize_xstormy16_tdep (void)
{
- extern int print_insn_xstormy16 ();
-
register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);
- tm_print_insn = print_insn_xstormy16;
}
projects / deliverable / binutils-gdb.git / blobdiff