/* Target-machine dependent code for Hitachi H8/300, for GDB.
Copyright 1988, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
- 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbcore.h"
#include "objfiles.h"
#include "gdbcmd.h"
+#include "gdb_assert.h"
/* Extra info which is saved in each frame_info. */
struct frame_extra_info
of the instruction. */
static CORE_ADDR
-h8300_next_prologue_insn (CORE_ADDR addr, CORE_ADDR lim, unsigned short* pword1)
+h8300_next_prologue_insn (CORE_ADDR addr,
+ CORE_ADDR lim,
+ unsigned short* pword1)
{
char buf[2];
if (addr < lim + 8)
if (IS_PUSH (insn_word))
{
+ auto_depth += 2 + adjust;
+ fsr[insn_word & 0x7] = after_prolog_fp - auto_depth;
ip = next_ip;
next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
- fsr[r] = after_prolog_fp + auto_depth;
- auto_depth += 2 + adjust;
continue;
}
next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
start = insn_word & 0x7;
- for (i = start; i <= start + count; i++)
+ for (i = start; i < start + count; i++)
{
- fsr[i] = after_prolog_fp + auto_depth;
auto_depth += 4;
+ fsr[i] = after_prolog_fp - auto_depth;
}
}
break;
}
/* The args are always reffed based from the stack pointer */
- fi->extra_info->args_pointer = after_prolog_fp;
+ get_frame_extra_info (fi)->args_pointer = after_prolog_fp;
/* Locals are always reffed based from the fp */
- fi->extra_info->locals_pointer = after_prolog_fp;
+ get_frame_extra_info (fi)->locals_pointer = after_prolog_fp;
/* The PC is at a known place */
- fi->extra_info->from_pc =
+ get_frame_extra_info (fi)->from_pc =
read_memory_unsigned_integer (after_prolog_fp + BINWORD, BINWORD);
/* Rememeber any others too */
if (have_fp)
/* We keep the old FP in the SP spot */
- fsr[E_SP_REGNUM] = read_memory_unsigned_integer (fsr[E_FP_REGNUM], BINWORD);
+ fsr[E_SP_REGNUM] = read_memory_unsigned_integer (fsr[E_FP_REGNUM],
+ BINWORD);
else
fsr[E_SP_REGNUM] = after_prolog_fp + auto_depth;
{
CORE_ADDR func_addr, func_end;
- if (!fi->saved_regs)
+ if (!get_frame_saved_regs (fi))
{
frame_saved_regs_zalloc (fi);
/* Find the beginning of this function, so we can analyze its
prologue. */
- if (find_pc_partial_function (fi->pc, NULL, &func_addr, &func_end))
+ if (find_pc_partial_function (get_frame_pc (fi), NULL,
+ &func_addr, &func_end))
{
struct symtab_and_line sal = find_pc_line (func_addr, 0);
- CORE_ADDR limit = (sal.end && sal.end < fi->pc) ? sal.end : fi->pc;
+ CORE_ADDR limit = (sal.end && sal.end < get_frame_pc (fi))
+ ? sal.end : get_frame_pc (fi);
/* This will fill in fields in fi. */
- h8300_examine_prologue (func_addr, limit, fi->frame, fi->saved_regs, fi);
+ h8300_examine_prologue (func_addr, limit, get_frame_base (fi),
+ get_frame_saved_regs (fi), fi);
}
/* Else we're out of luck (can't debug completely stripped code).
FIXME. */
}
}
-/* 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 INIT_FRAME_PC will be called for the new frame.
+/* 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 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. */
+ the function prologue to determine the caller's sp value, and
+ return it. */
static CORE_ADDR
h8300_frame_chain (struct frame_info *thisframe)
{
- if (PC_IN_CALL_DUMMY (thisframe->pc, thisframe->frame, thisframe->frame))
+ if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (thisframe),
+ get_frame_base (thisframe),
+ get_frame_base (thisframe)))
{ /* initialize the from_pc now */
- thisframe->extra_info->from_pc =
- deprecated_read_register_dummy (thisframe->pc, thisframe->frame,
+ get_frame_extra_info (thisframe)->from_pc =
+ deprecated_read_register_dummy (get_frame_pc (thisframe),
+ get_frame_base (thisframe),
E_PC_REGNUM);
- return thisframe->frame;
+ return get_frame_base (thisframe);
}
- return thisframe->saved_regs[E_SP_REGNUM];
+ return get_frame_saved_regs (thisframe)[E_SP_REGNUM];
}
/* Return the saved PC from this frame.
static CORE_ADDR
h8300_frame_saved_pc (struct frame_info *frame)
{
- if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
- return deprecated_read_register_dummy (frame->pc, 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),
E_PC_REGNUM);
else
- return frame->extra_info->from_pc;
+ return get_frame_extra_info (frame)->from_pc;
}
static void
h8300_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->from_pc = 0;
- fi->extra_info->args_pointer = 0; /* Unknown */
- fi->extra_info->locals_pointer = 0; /* Unknown */
+ frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
+ get_frame_extra_info (fi)->from_pc = 0;
+ get_frame_extra_info (fi)->args_pointer = 0; /* Unknown */
+ get_frame_extra_info (fi)->locals_pointer = 0; /* Unknown */
- if (!fi->pc)
+ if (!get_frame_pc (fi))
{
- if (fi->next)
- fi->pc = h8300_frame_saved_pc (fi->next);
+ if (get_next_frame (fi))
+ deprecated_update_frame_pc_hack (fi, h8300_frame_saved_pc (get_next_frame (fi)));
}
h8300_frame_init_saved_regs (fi);
}
static CORE_ADDR
h8300_frame_locals_address (struct frame_info *fi)
{
- if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
+ if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
+ get_frame_base (fi)))
return (CORE_ADDR) 0; /* Not sure what else to do... */
- return fi->extra_info->locals_pointer;
+ return get_frame_extra_info (fi)->locals_pointer;
}
/* Return the address of the argument block for the frame
static CORE_ADDR
h8300_frame_args_address (struct frame_info *fi)
{
- if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
+ if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
+ get_frame_base (fi)))
return (CORE_ADDR) 0; /* Not sure what else to do... */
- return fi->extra_info->args_pointer;
+ return get_frame_extra_info (fi)->args_pointer;
}
/* Round N up or down to the nearest multiple of UNIT.
for (offset = 0; offset < padded_len; offset += wordsize)
{
- ULONGEST word = extract_address (padded + offset, wordsize);
+ ULONGEST word = extract_unsigned_integer (padded + offset,
+ wordsize);
write_register (reg++, word);
}
}
unsigned regno;
struct frame_info *frame = get_current_frame ();
- if (PC_IN_CALL_DUMMY (frame->pc, 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 E_SP_REGNUM is a frame_saved_regs struct is the
actual value we want, not the address of the value we want. */
- if (frame->saved_regs[regno] && regno != E_SP_REGNUM)
+ if (get_frame_saved_regs (frame)[regno] && regno != E_SP_REGNUM)
write_register (regno,
- read_memory_integer (frame->saved_regs[regno],
- BINWORD));
- else if (frame->saved_regs[regno] && regno == E_SP_REGNUM)
- write_register (regno, frame->frame + 2 * BINWORD);
+ read_memory_integer
+ (get_frame_saved_regs (frame)[regno], BINWORD));
+ else if (get_frame_saved_regs (frame)[regno] && regno == E_SP_REGNUM)
+ write_register (regno, get_frame_base (frame) + 2 * BINWORD);
}
/* Don't forget to update the PC too! */
- write_register (E_PC_REGNUM, frame->extra_info->from_pc);
+ write_register (E_PC_REGNUM, get_frame_extra_info (frame)->from_pc);
}
flush_cached_frames ();
}
memcpy (valbuf + 2, regbuf + REGISTER_BYTE (1), 2);
}
break;
- case 8: /* (double) (doesn't seem to happen, which is good,
- because this almost certainly isn't right. */
+ case 8: /* (double) (doesn't seem to happen, which is good,
+ because this almost certainly isn't right.
+ FIXME: it will happen for h8sx... */
error ("I don't know how a double is returned.");
break;
}
{
case 1: /* char */
case 2: /* short, int */
- regval = extract_address (valbuf, len);
+ regval = extract_unsigned_integer (valbuf, len);
write_register (0, regval);
break;
case 4: /* long, float */
- regval = extract_address (valbuf, len);
+ regval = extract_unsigned_integer (valbuf, len);
if (wordsize == 4)
{
write_register (0, regval);
write_register (1, regval & 0xffff);
}
break;
- case 8: /* presumeably double, but doesn't seem to happen */
+ case 8: /* presumeably double, but doesn't seem to happen */
error ("I don't know how to return a double.");
break;
}
}
static void
-h8300_print_register (int regno)
+h8300_print_register (struct gdbarch *gdbarch, struct ui_file *file,
+ struct frame_info *frame, int regno)
{
- long val = read_register (regno);
+ ULONGEST rval;
+ long val;
const char *name = h8300_register_name (regno);
if (!name || !*name)
return;
- printf_filtered ("%-14s ", name);
+ /* FIXME: cagney/2002-10-22: The code below assumes that VAL is at
+ least 4 bytes (32 bits) in size and hence is large enough to hold
+ the largest h8300 register. Should instead be using ULONGEST and
+ the phex() functions. */
+ gdb_assert (sizeof (val) >= 4);
+ frame_read_unsigned_register (frame, regno, &rval);
+ val = rval;
+
+ fprintf_filtered (file, "%-14s ", name);
if (h8300hmode)
{
if (val)
- printf_filtered ("0x%08lx %-8ld", val, val);
+ fprintf_filtered (file, "0x%08lx %-8ld", val, val);
else
- printf_filtered ("0x%-8lx %-8ld", val, val);
+ fprintf_filtered (file, "0x%-8lx %-8ld", val, val);
}
else
{
if (val)
- printf_filtered ("0x%04lx %-4ld", val, val);
+ fprintf_filtered (file, "0x%04lx %-4ld", val, val);
else
- printf_filtered ("0x%-4lx %-4ld", val, val);
+ fprintf_filtered (file, "0x%-4lx %-4ld", val, val);
}
if (regno == E_CCR_REGNUM)
{
int C, Z, N, V;
unsigned char b[h8300h_reg_size];
unsigned char l;
- frame_register_read (selected_frame, regno, b);
+ frame_register_read (deprecated_selected_frame, regno, b);
l = b[REGISTER_VIRTUAL_SIZE (E_CCR_REGNUM) - 1];
- printf_unfiltered ("\t");
- printf_unfiltered ("I-%d ", (l & 0x80) != 0);
- printf_unfiltered ("UI-%d ", (l & 0x40) != 0);
- printf_unfiltered ("H-%d ", (l & 0x20) != 0);
- printf_unfiltered ("U-%d ", (l & 0x10) != 0);
+ fprintf_filtered (file, "\t");
+ fprintf_filtered (file, "I-%d ", (l & 0x80) != 0);
+ fprintf_filtered (file, "UI-%d ", (l & 0x40) != 0);
+ fprintf_filtered (file, "H-%d ", (l & 0x20) != 0);
+ fprintf_filtered (file, "U-%d ", (l & 0x10) != 0);
N = (l & 0x8) != 0;
Z = (l & 0x4) != 0;
V = (l & 0x2) != 0;
C = (l & 0x1) != 0;
- printf_unfiltered ("N-%d ", N);
- printf_unfiltered ("Z-%d ", Z);
- printf_unfiltered ("V-%d ", V);
- printf_unfiltered ("C-%d ", C);
+ fprintf_filtered (file, "N-%d ", N);
+ fprintf_filtered (file, "Z-%d ", Z);
+ fprintf_filtered (file, "V-%d ", V);
+ fprintf_filtered (file, "C-%d ", C);
if ((C | Z) == 0)
- printf_unfiltered ("u> ");
+ fprintf_filtered (file, "u> ");
if ((C | Z) == 1)
- printf_unfiltered ("u<= ");
+ fprintf_filtered (file, "u<= ");
if ((C == 0))
- printf_unfiltered ("u>= ");
+ fprintf_filtered (file, "u>= ");
if (C == 1)
- printf_unfiltered ("u< ");
+ fprintf_filtered (file, "u< ");
if (Z == 0)
- printf_unfiltered ("!= ");
+ fprintf_filtered (file, "!= ");
if (Z == 1)
- printf_unfiltered ("== ");
+ fprintf_filtered (file, "== ");
if ((N ^ V) == 0)
- printf_unfiltered (">= ");
+ fprintf_filtered (file, ">= ");
if ((N ^ V) == 1)
- printf_unfiltered ("< ");
+ fprintf_filtered (file, "< ");
if ((Z | (N ^ V)) == 0)
- printf_unfiltered ("> ");
+ fprintf_filtered (file, "> ");
if ((Z | (N ^ V)) == 1)
- printf_unfiltered ("<= ");
+ fprintf_filtered (file, "<= ");
}
else if (regno == E_EXR_REGNUM && h8300smode)
{
/* EXR register */
unsigned char b[h8300h_reg_size];
unsigned char l;
- frame_register_read (selected_frame, regno, b);
+ frame_register_read (deprecated_selected_frame, regno, b);
l = b[REGISTER_VIRTUAL_SIZE (E_EXR_REGNUM) - 1];
- printf_unfiltered ("\t");
- printf_unfiltered ("T-%d - - - ", (l & 0x80) != 0);
- printf_unfiltered ("I2-%d ", (l & 4) != 0);
- printf_unfiltered ("I1-%d ", (l & 2) != 0);
- printf_unfiltered ("I0-%d", (l & 1) != 0);
+ fprintf_filtered (file, "\t");
+ fprintf_filtered (file, "T-%d - - - ", (l & 0x80) != 0);
+ fprintf_filtered (file, "I2-%d ", (l & 4) != 0);
+ fprintf_filtered (file, "I1-%d ", (l & 2) != 0);
+ fprintf_filtered (file, "I0-%d", (l & 1) != 0);
}
- printf_filtered ("\n");
+ fprintf_filtered (file, "\n");
}
static void
-h8300_do_registers_info (int regno, int cpregs)
+h8300_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
+ struct frame_info *frame, int regno, int cpregs)
{
if (regno < 0)
for (regno = 0; regno < E_NUM_REGS; ++regno)
- h8300_print_register (regno);
+ h8300_print_register (gdbarch, file, frame, regno);
else
- h8300_print_register (regno);
+ h8300_print_register (gdbarch, file, frame, regno);
}
static CORE_ADDR
static CORE_ADDR
h8300_extract_struct_value_address (char *regbuf)
{
- return extract_address (regbuf + h8300_register_byte (E_ARG0_REGNUM),
- h8300_register_raw_size (E_ARG0_REGNUM));
+ return
+ extract_unsigned_integer (regbuf + h8300_register_byte (E_ARG0_REGNUM),
+ h8300_register_raw_size (E_ARG0_REGNUM));
}
const static unsigned char *
switch (info.bfd_arch_info->mach)
{
- case bfd_mach_h8300:
- h8300smode = 0;
- h8300hmode = 0;
- break;
- case bfd_mach_h8300h:
- h8300smode = 0;
- h8300hmode = 1;
- break;
- case bfd_mach_h8300s:
- h8300smode = 1;
- h8300hmode = 1;
- break;
+ case bfd_mach_h8300:
+ h8300sxmode = 0;
+ h8300smode = 0;
+ h8300hmode = 0;
+ break;
+ case bfd_mach_h8300h:
+ case bfd_mach_h8300hn:
+ h8300sxmode = 0;
+ h8300smode = 0;
+ h8300hmode = 1;
+ break;
+ case bfd_mach_h8300s:
+ case bfd_mach_h8300sn:
+ h8300sxmode = 0;
+ h8300smode = 1;
+ h8300hmode = 1;
+ break;
+ case bfd_mach_h8300sx:
+ h8300sxmode = 1;
+ h8300smode = 1;
+ h8300hmode = 1;
+ break;
}
gdbarch = gdbarch_alloc (&info, 0);
+ /* 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);
+
/*
* Basic register fields and methods.
*/
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, h8300_register_name);
- set_gdbarch_register_size (gdbarch, BINWORD);
- set_gdbarch_register_bytes (gdbarch, E_NUM_REGS * BINWORD);
+ set_gdbarch_deprecated_register_size (gdbarch, BINWORD);
+ set_gdbarch_deprecated_register_bytes (gdbarch, E_NUM_REGS * BINWORD);
set_gdbarch_register_byte (gdbarch, h8300_register_byte);
set_gdbarch_register_raw_size (gdbarch, h8300_register_raw_size);
- set_gdbarch_max_register_raw_size (gdbarch, h8300h_reg_size);
+ set_gdbarch_deprecated_max_register_raw_size (gdbarch, h8300h_reg_size);
set_gdbarch_register_virtual_size (gdbarch, h8300_register_raw_size);
- set_gdbarch_max_register_virtual_size (gdbarch, h8300h_reg_size);
+ set_gdbarch_deprecated_max_register_virtual_size (gdbarch, h8300h_reg_size);
set_gdbarch_register_virtual_type (gdbarch, h8300_register_virtual_type);
- set_gdbarch_do_registers_info (gdbarch, h8300_do_registers_info);
+ set_gdbarch_print_registers_info (gdbarch, h8300_print_registers_info);
set_gdbarch_print_float_info (gdbarch, h8300_print_float_info);
/*
* Frame Info
*/
- set_gdbarch_init_extra_frame_info (gdbarch, h8300_init_extra_frame_info);
- set_gdbarch_frame_init_saved_regs (gdbarch, h8300_frame_init_saved_regs);
- set_gdbarch_frame_chain (gdbarch, h8300_frame_chain);
- set_gdbarch_get_saved_register (gdbarch, generic_unwind_get_saved_register);
- set_gdbarch_saved_pc_after_call (gdbarch, h8300_saved_pc_after_call);
- set_gdbarch_frame_saved_pc (gdbarch, h8300_frame_saved_pc);
+ set_gdbarch_deprecated_frame_init_saved_regs (gdbarch,
+ h8300_frame_init_saved_regs);
+ set_gdbarch_deprecated_init_extra_frame_info (gdbarch,
+ h8300_init_extra_frame_info);
+ set_gdbarch_deprecated_frame_chain (gdbarch, h8300_frame_chain);
+ set_gdbarch_deprecated_saved_pc_after_call (gdbarch,
+ h8300_saved_pc_after_call);
+ set_gdbarch_deprecated_frame_saved_pc (gdbarch, h8300_frame_saved_pc);
set_gdbarch_skip_prologue (gdbarch, h8300_skip_prologue);
- set_gdbarch_frame_chain_valid (gdbarch, func_frame_chain_valid);
set_gdbarch_frame_args_address (gdbarch, h8300_frame_args_address);
set_gdbarch_frame_locals_address (gdbarch, h8300_frame_locals_address);
set_gdbarch_frameless_function_invocation (gdbarch,
frameless_look_for_prologue);
- /* W/o prototype, coerce float args to double. */
- /* set_gdbarch_coerce_float_to_double (gdbarch, standard_coerce_float_to_double); */
-
/*
* Call Dummies
*
* These values and methods are used when gdb calls a target function. */
- set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
- set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
- set_gdbarch_push_return_address (gdbarch, h8300_push_return_address);
- set_gdbarch_deprecated_extract_return_value (gdbarch, h8300_extract_return_value);
- set_gdbarch_push_arguments (gdbarch, h8300_push_arguments);
- set_gdbarch_pop_frame (gdbarch, h8300_pop_frame);
- set_gdbarch_store_struct_return (gdbarch, h8300_store_struct_return);
- set_gdbarch_deprecated_store_return_value (gdbarch, h8300_store_return_value);
- set_gdbarch_deprecated_extract_struct_value_address (gdbarch, h8300_extract_struct_value_address);
+ set_gdbarch_deprecated_push_return_address (gdbarch,
+ h8300_push_return_address);
+ set_gdbarch_deprecated_extract_return_value (gdbarch,
+ h8300_extract_return_value);
+ set_gdbarch_deprecated_push_arguments (gdbarch, h8300_push_arguments);
+ set_gdbarch_deprecated_pop_frame (gdbarch, h8300_pop_frame);
+ set_gdbarch_deprecated_store_struct_return (gdbarch,
+ h8300_store_struct_return);
+ set_gdbarch_deprecated_store_return_value (gdbarch,
+ h8300_store_return_value);
+ set_gdbarch_deprecated_extract_struct_value_address
+ (gdbarch, h8300_extract_struct_value_address);
set_gdbarch_use_struct_convention (gdbarch, h8300_use_struct_convention);
- set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
- 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_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy);
- 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, h8300_breakpoint_from_pc);
set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
set_gdbarch_addr_bit (gdbarch, BINWORD * TARGET_CHAR_BIT);
/* set_gdbarch_stack_align (gdbarch, SOME_stack_align); */
- set_gdbarch_extra_stack_alignment_needed (gdbarch, 0);
set_gdbarch_believe_pcc_promotion (gdbarch, 1);
+ /* Should be using push_dummy_call. */
+ set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
+
return gdbarch;
}
void
_initialize_h8300_tdep (void)
{
- tm_print_insn = gdb_print_insn_h8300;
+ deprecated_tm_print_insn = gdb_print_insn_h8300;
register_gdbarch_init (bfd_arch_h8300, h8300_gdbarch_init);
}
projects / deliverable / binutils-gdb.git / blobdiff