/* Target-dependent code for Hitachi H8/500, for GDB.
- Copyright 1993, 1994, 1995 Free Software Foundation, Inc.
+ Copyright 1993, 1994, 1995, 2001 Free Software Foundation, Inc.
-This file is part of GDB.
+ This file is part of GDB.
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
/*
- Contributed by Steve Chamberlain
- sac@cygnus.com
+ Contributed by Steve Chamberlain
+ sac@cygnus.com
*/
#include "defs.h"
#include "value.h"
#include "dis-asm.h"
#include "gdbcore.h"
+#include "regcache.h"
#define UNSIGNED_SHORT(X) ((X) & 0xffff)
arg-2
arg-1
return address <2 or 4 bytes>
- old fp <2 bytes>
+ old fp <2 bytes>
auto-n
..
auto-1
saved registers
-*/
+ */
/* an easy to debug H8 stack frame looks like:
-0x6df6 push r6
-0x0d76 mov.w r7,r6
-0x6dfn push reg
-0x7905 nnnn mov.w #n,r5 or 0x1b87 subs #2,sp
-0x1957 sub.w r5,sp
+ 0x6df6 push r6
+ 0x0d76 mov.w r7,r6
+ 0x6dfn push reg
+ 0x7905 nnnn mov.w #n,r5 or 0x1b87 subs #2,sp
+ 0x1957 sub.w r5,sp
*/
int minimum_mode = 1;
CORE_ADDR
-h8500_skip_prologue (start_pc)
- CORE_ADDR start_pc;
+h8500_skip_prologue (CORE_ADDR start_pc)
{
short int w;
return start_pc;
}
+CORE_ADDR
+h8500_addr_bits_remove (CORE_ADDR addr)
+{
+ return ((addr) & 0xffffff);
+}
+
/* 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.
the function prologue to determine the caller's sp value, and return it. */
CORE_ADDR
-h8500_frame_chain (thisframe)
- struct frame_info *thisframe;
+h8500_frame_chain (struct frame_info *thisframe)
{
if (!inside_entry_file (thisframe->pc))
return (read_memory_integer (FRAME_FP (thisframe), PTR_SIZE));
/* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
is not the address of a valid instruction, the address of the next
instruction beyond ADDR otherwise. *PWORD1 receives the first word
- of the instruction.*/
+ of the instruction. */
CORE_ADDR
-NEXT_PROLOGUE_INSN (addr, lim, pword1)
- CORE_ADDR addr;
- CORE_ADDR lim;
- char *pword1;
+NEXT_PROLOGUE_INSN (CORE_ADDR addr, CORE_ADDR lim, char *pword1)
{
if (addr < lim + 8)
{
/* Return the saved PC from this frame. */
CORE_ADDR
-frame_saved_pc (frame)
- struct frame_info *frame;
+frame_saved_pc (struct frame_info *frame)
{
return read_memory_integer (FRAME_FP (frame) + 2, PTR_SIZE);
}
-void
-h8500_pop_frame ()
+void
+h8500_pop_frame (void)
{
unsigned regnum;
struct frame_saved_regs fsr;
}
void
-print_register_hook (regno)
- int regno;
+print_register_hook (int regno)
{
if (regno == CCR_REGNUM)
{
}
int
-h8500_register_size (regno)
- int regno;
+h8500_register_size (int regno)
{
switch (regno)
{
case PC_REGNUM:
return 4;
default:
- abort ();
+ internal_error (__FILE__, __LINE__, "failed internal consistency check");
}
}
struct type *
-h8500_register_virtual_type (regno)
- int regno;
+h8500_register_virtual_type (int regno)
{
switch (regno)
{
case PC_REGNUM:
return builtin_type_unsigned_long;
default:
- abort ();
+ internal_error (__FILE__, __LINE__, "failed internal consistency check");
}
}
the address we return for it IS the sp for the next frame. */
void
-frame_find_saved_regs (frame_info, frame_saved_regs)
- struct frame_info *frame_info;
- struct frame_saved_regs *frame_saved_regs;
+frame_find_saved_regs (struct frame_info *frame_info,
+ struct frame_saved_regs *frame_saved_regs)
{
register int regnum;
register int regmask;
{
pc = get_pc_function_start ((frame_info)->pc);
/* Verify we have a link a6 instruction next;
- if not we lose. If we win, find the address above the saved
- regs using the amount of storage from the link instruction.
- */
+ if not we lose. If we win, find the address above the saved
+ regs using the amount of storage from the link instruction.
+ */
thebyte = read_memory_integer (pc, 1);
if (0x1f == thebyte)
}
CORE_ADDR
-saved_pc_after_call ()
+saved_pc_after_call (void)
{
int x;
int a = read_register (SP_REGNUM);
return x;
}
-#if 0 /* never called */
-/* Nonzero if instruction at PC is a return instruction. */
-
-int
-about_to_return (pc)
- CORE_ADDR pc;
-{
- int b1 = read_memory_integer (pc, 1);
-
- switch (b1)
- {
- case 0x14: /* rtd #8 */
- case 0x1c: /* rtd #16 */
- case 0x19: /* rts */
- case 0x1a: /* rte */
- return 1;
- case 0x11:
- {
- int b2 = read_memory_integer (pc + 1, 1);
- switch (b2)
- {
- case 0x18: /* prts */
- case 0x14: /* prtd #8 */
- case 0x16: /* prtd #16 */
- return 1;
- }
- }
- }
- return 0;
-}
-#endif
-
void
-h8500_set_pointer_size (newsize)
- int newsize;
+h8500_set_pointer_size (int newsize)
{
static int oldsize = 0;
}
static void
-big_command ()
+big_command (char *arg, int from_tty)
{
h8500_set_pointer_size (32);
code_size = 4;
}
static void
-medium_command ()
+medium_command (char *arg, int from_tty)
{
h8500_set_pointer_size (32);
code_size = 4;
}
static void
-compact_command ()
+compact_command (char *arg, int from_tty)
{
h8500_set_pointer_size (32);
code_size = 2;
}
static void
-small_command ()
+small_command (char *arg, int from_tty)
{
h8500_set_pointer_size (16);
code_size = 2;
static struct cmd_list_element *setmemorylist;
static void
-set_memory (args, from_tty)
- char *args;
- int from_tty;
+set_memory (char *args, int from_tty)
{
printf_unfiltered ("\"set memory\" must be followed by the name of a memory subcommand.\n");
help_list (setmemorylist, "set memory ", -1, gdb_stdout);
/* See if variable name is ppc or pr[0-7] */
int
-h8500_is_trapped_internalvar (name)
- char *name;
+h8500_is_trapped_internalvar (char *name)
{
if (name[0] != 'p')
return 0;
}
value_ptr
-h8500_value_of_trapped_internalvar (var)
- struct internalvar *var;
+h8500_value_of_trapped_internalvar (struct internalvar *var)
{
LONGEST regval;
unsigned char regbuf[4];
regval = regbuf[0] << 16;
get_saved_register (regbuf, NULL, NULL, selected_frame, regnum, NULL);
- regval |= regbuf[0] << 8 | regbuf[1]; /* XXX host/target byte order */
+ regval |= regbuf[0] << 8 | regbuf[1]; /* XXX host/target byte order */
- free (var->value); /* Free up old value */
+ xfree (var->value); /* Free up old value */
var->value = value_from_longest (builtin_type_unsigned_long, regval);
release_value (var->value); /* Unchain new value */
}
void
-h8500_set_trapped_internalvar (var, newval, bitpos, bitsize, offset)
- struct internalvar *var;
- int offset, bitpos, bitsize;
- value_ptr newval;
+h8500_set_trapped_internalvar (struct internalvar *var, value_ptr newval,
+ int bitpos, int bitsize, int offset)
{
char *page_regnum, *regnum;
char expression[100];
}
CORE_ADDR
-h8500_read_sp ()
+h8500_read_sp (void)
{
return read_register (PR7_REGNUM);
}
void
-h8500_write_sp (v)
- CORE_ADDR v;
+h8500_write_sp (CORE_ADDR v)
{
write_register (PR7_REGNUM, v);
}
CORE_ADDR
-h8500_read_pc (pid)
- int pid;
+h8500_read_pc (int pid)
{
return read_register (PC_REGNUM);
}
void
-h8500_write_pc (v, pid)
- CORE_ADDR v;
- int pid;
+h8500_write_pc (CORE_ADDR v, int pid)
{
write_register (PC_REGNUM, v);
}
CORE_ADDR
-h8500_read_fp ()
+h8500_read_fp (void)
{
return read_register (PR6_REGNUM);
}
void
-h8500_write_fp (v)
- CORE_ADDR v;
+h8500_write_fp (CORE_ADDR v)
{
write_register (PR6_REGNUM, v);
}
void
-_initialize_h8500_tdep ()
+_initialize_h8500_tdep (void)
{
tm_print_insn = print_insn_h8500;
&setlist);
add_cmd ("small", class_support, small_command,
- "Set small memory model. (16 bit code, 16 bit data)", &setmemorylist);
+ "Set small memory model. (16 bit code, 16 bit data)", &setmemorylist);
add_cmd ("big", class_support, big_command,
- "Set big memory model. (32 bit code, 32 bit data)", &setmemorylist);
+ "Set big memory model. (32 bit code, 32 bit data)", &setmemorylist);
add_cmd ("medium", class_support, medium_command,
- "Set medium memory model. (32 bit code, 16 bit data)", &setmemorylist);
+ "Set medium memory model. (32 bit code, 16 bit data)", &setmemorylist);
add_cmd ("compact", class_support, compact_command,
- "Set compact memory model. (16 bit code, 32 bit data)", &setmemorylist);
+ "Set compact memory model. (16 bit code, 32 bit data)", &setmemorylist);
}
projects / deliverable / binutils-gdb.git / blobdiff