X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fxstormy16-tdep.c;h=33c8b4ef0c33047807254dda0f2527a420e71330;hb=649e03f6e4b94665f1a74e2238a862f28097946a;hp=aaf5ae2d016127c17d0db336df3992e18a00a61a;hpb=66140c26166febde29e6e7f2001674a930967545;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/xstormy16-tdep.c b/gdb/xstormy16-tdep.c index aaf5ae2d01..33c8b4ef0c 100644 --- a/gdb/xstormy16-tdep.c +++ b/gdb/xstormy16-tdep.c @@ -1,6 +1,6 @@ /* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor. - Copyright 2001, 2002, 2003 Free Software Foundation, Inc. + Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc. This file is part of GDB. @@ -22,11 +22,11 @@ #include "defs.h" #include "value.h" #include "inferior.h" -#include "symfile.h" #include "arch-utils.h" #include "regcache.h" #include "gdbcore.h" #include "objfiles.h" +#include "dis-asm.h" struct gdbarch_tdep { @@ -150,16 +150,6 @@ xstormy16_register_raw_size (int regnum) return xstormy16_reg_size; } -/* Function: xstormy16_register_virtual_size - Returns the number of bytes occupied by the register as represented - internally by gdb. */ - -static int -xstormy16_register_virtual_size (int regnum) -{ - return xstormy16_register_raw_size (regnum); -} - /* Function: xstormy16_reg_virtual_type Returns the default type for register N. */ @@ -220,7 +210,7 @@ xstormy16_extract_return_value (struct type *type, char *regbuf, char *valbuf) /* Scalar return values of <= 12 bytes are returned in E_1ST_ARG_REGNUM to E_LST_ARG_REGNUM. */ memcpy (valbuf, - ®buf[REGISTER_BYTE (E_1ST_ARG_REGNUM)] + offset, + ®buf[DEPRECATED_REGISTER_BYTE (E_1ST_ARG_REGNUM)] + offset, TYPE_LENGTH (type)); } else @@ -228,8 +218,8 @@ xstormy16_extract_return_value (struct type *type, char *regbuf, char *valbuf) /* 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 + DEPRECATED_REGISTER_BYTE (E_PTR_RET_REGNUM), + DEPRECATED_REGISTER_RAW_SIZE (E_PTR_RET_REGNUM)); read_memory (return_buffer, valbuf, TYPE_LENGTH (type)); } @@ -307,12 +297,12 @@ xstormy16_push_arguments (int nargs, struct value **args, CORE_ADDR sp, (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; } @@ -333,7 +323,8 @@ xstormy16_pop_frame (void) 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 (); } @@ -341,19 +332,19 @@ xstormy16_pop_frame (void) { /* Restore the saved regs. */ for (i = 0; i < NUM_REGS; i++) - if (get_frame_saved_regs (fi)[i]) + if (deprecated_get_frame_saved_regs (fi)[i]) { if (i == SP_REGNUM) - write_register (i, get_frame_saved_regs (fi)[i]); + write_register (i, deprecated_get_frame_saved_regs (fi)[i]); else if (i == E_PC_REGNUM) - write_register (i, read_memory_integer (get_frame_saved_regs (fi)[i], + write_register (i, read_memory_integer (deprecated_get_frame_saved_regs (fi)[i], xstormy16_pc_size)); else - write_register (i, read_memory_integer (get_frame_saved_regs (fi)[i], + write_register (i, read_memory_integer (deprecated_get_frame_saved_regs (fi)[i], 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; @@ -391,7 +382,7 @@ xstormy16_store_return_value (struct type *type, char *valbuf) } else if (xstormy16_type_is_scalar (type) && TYPE_LENGTH (type) <= E_MAX_RETTYPE_SIZE_IN_REGS) - deprecated_write_register_bytes (REGISTER_BYTE (E_1ST_ARG_REGNUM), + deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (E_1ST_ARG_REGNUM), valbuf, TYPE_LENGTH (type)); else { @@ -407,11 +398,14 @@ xstormy16_store_return_value (struct type *type, char *valbuf) */ static CORE_ADDR -xstormy16_extract_struct_value_address (char *regbuf) +xstormy16_extract_struct_value_address (struct regcache *regcache) { - return extract_address (regbuf + - xstormy16_register_byte (E_PTR_RET_REGNUM), - xstormy16_reg_size); + /* FIXME: cagney/2004-01-17: Does the ABI guarantee that the return + address regster is preserved across function calls? Probably + not, making this function wrong. */ + ULONGEST val; + regcache_raw_read_unsigned (regcache, E_PTR_RET_REGNUM, &val); + return val; } /* Function: xstormy16_use_struct_convention @@ -466,7 +460,8 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr, 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. @@ -476,7 +471,7 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr, 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) @@ -490,8 +485,8 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr, if (fi) { regnum = inst & 0x000f; - get_frame_saved_regs (fi)[regnum] = fi->extra_info->framesize; - fi->extra_info->framesize += xstormy16_reg_size; + deprecated_get_frame_saved_regs (fi)[regnum] = get_frame_extra_info (fi)->framesize; + get_frame_extra_info (fi)->framesize += xstormy16_reg_size; } } @@ -499,28 +494,28 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr, 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; } @@ -546,7 +541,7 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr, if (offset & 0x0800) offset -= 0x1000; - get_frame_saved_regs (fi)[regnum] = fi->extra_info->framesize + offset; + deprecated_get_frame_saved_regs (fi)[regnum] = get_frame_extra_info (fi)->framesize + offset; } next_addr += xstormy16_inst_size; } @@ -591,15 +586,15 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr, 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; + deprecated_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; + deprecated_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 @@ -607,11 +602,11 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr, sp, fp and framesize. We know the beginning of the frame so we can translate the register offsets to real addresses. */ for (regnum = 0; regnum < E_SP_REGNUM; ++regnum) - if (get_frame_saved_regs (fi)[regnum]) - get_frame_saved_regs (fi)[regnum] += get_frame_saved_regs (fi)[E_SP_REGNUM]; + if (deprecated_get_frame_saved_regs (fi)[regnum]) + deprecated_get_frame_saved_regs (fi)[regnum] += deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM]; /* Save address of PC on stack. */ - get_frame_saved_regs (fi)[E_PC_REGNUM] = get_frame_saved_regs (fi)[E_SP_REGNUM]; + deprecated_get_frame_saved_regs (fi)[E_PC_REGNUM] = deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM]; } return next_addr; @@ -646,7 +641,7 @@ xstormy16_skip_prologue (CORE_ADDR pc) 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) { @@ -721,18 +716,17 @@ xstormy16_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc) 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) { CORE_ADDR func_addr, func_end; - if (!get_frame_saved_regs (fi)) + if (!deprecated_get_frame_saved_regs (fi)) { frame_saved_regs_zalloc (fi); @@ -747,23 +741,24 @@ 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 { - saved_pc = read_memory_unsigned_integer (get_frame_saved_regs (fi)[E_PC_REGNUM], + saved_pc = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (fi)[E_PC_REGNUM], xstormy16_pc_size); } @@ -779,12 +774,11 @@ xstormy16_frame_saved_pc (struct frame_info *fi) 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, @@ -800,8 +794,8 @@ xstormy16_init_extra_frame_info (int fromleaf, struct frame_info *fi) 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). */ @@ -817,32 +811,32 @@ xstormy16_init_extra_frame_info (int fromleaf, struct frame_info *fi) 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) @@ -961,7 +955,7 @@ static CORE_ADDR 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) { @@ -984,7 +978,7 @@ xstormy16_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr) if (addr2) addr = addr2; } - store_address (buf, TYPE_LENGTH (type), addr); + store_unsigned_integer (buf, TYPE_LENGTH (type), addr); } static CORE_ADDR @@ -995,7 +989,7 @@ xstormy16_stack_align (CORE_ADDR addr) return addr; } -void +static void xstormy16_save_dummy_frame_tos (CORE_ADDR sp) { generic_save_dummy_frame_tos (sp - xstormy16_pc_size); @@ -1025,7 +1019,7 @@ xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* NOTE: cagney/2002-12-06: This can be deleted when this arch is ready to unwind the PC first (see frame.c:get_prev_frame()). */ - set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default); + set_gdbarch_deprecated_init_frame_pc (gdbarch, deprecated_init_frame_pc_default); /* * Basic register fields and methods. @@ -1034,31 +1028,31 @@ xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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); @@ -1068,43 +1062,25 @@ xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) */ /* Stack grows up. */ set_gdbarch_inner_than (gdbarch, core_addr_greaterthan); - /* PC stops zero byte after a trap instruction - (which means: exactly on trap instruction). */ - set_gdbarch_decr_pc_after_break (gdbarch, 0); - /* This value is almost never non-zero... */ - 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); @@ -1113,16 +1089,20 @@ xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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; } @@ -1130,11 +1110,10 @@ xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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; }