gdb: add target_ops::supports_displaced_step

[deliverable/binutils-gdb.git] / gdb / h8300-tdep.c

diff --git a/gdb/h8300-tdep.c b/gdb/h8300-tdep.c
index c87dfab61f7aad387cf6fc3d2765a15698a10e16..b569a23f2631cfb1f69d16e639734070b2b24cca 100644 (file)
--- a/gdb/h8300-tdep.c
+++ b/gdb/h8300-tdep.c
@@ -1,13 +1,12 @@
 /* Target-machine dependent code for Renesas H8/300, for GDB.
 
 /* Target-machine dependent code for Renesas H8/300, for GDB.
 

-   Copyright 1988, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
-   1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+   Copyright (C) 1988-2020 Free Software Foundation, Inc.

 
    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
 
    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
+   the Free Software Foundation; either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -16,9 +15,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    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.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 /*
    Contributed by Steve Chamberlain
 
 /*
    Contributed by Steve Chamberlain


@@ -27,41 +24,19 @@
 
 #include "defs.h"
 #include "value.h"
 
 #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 "arch-utils.h"
 #include "regcache.h"
 #include "gdbcore.h"
 #include "objfiles.h"

-#include "gdbcmd.h"
-#include "gdb_assert.h"

 #include "dis-asm.h"
 #include "dis-asm.h"

-
-/* Extra info which is saved in each frame_info. */
-struct frame_extra_info
-{
-  CORE_ADDR from_pc;
-};
-
-enum
-{
-  h8300_reg_size = 2,
-  h8300h_reg_size = 4,
-  h8300_max_reg_size = 4,
-};
-
-static int is_h8300hmode (struct gdbarch *gdbarch);
-static int is_h8300smode (struct gdbarch *gdbarch);
-static int is_h8300sxmode (struct gdbarch *gdbarch);
-static int is_h8300_normal_mode (struct gdbarch *gdbarch);
-
-#define BINWORD (is_h8300hmode (current_gdbarch) && \
-                 !is_h8300_normal_mode (current_gdbarch) ? h8300h_reg_size : h8300_reg_size)
+#include "dwarf2/frame.h"
+#include "frame-base.h"
+#include "frame-unwind.h"

 
 enum gdb_regnum
 {
   E_R0_REGNUM, E_ER0_REGNUM = E_R0_REGNUM, E_ARG0_REGNUM = E_R0_REGNUM,
 
 enum gdb_regnum
 {
   E_R0_REGNUM, E_ER0_REGNUM = E_R0_REGNUM, E_ARG0_REGNUM = E_R0_REGNUM,

-                                          E_RET0_REGNUM = E_R0_REGNUM,
+  E_RET0_REGNUM = E_R0_REGNUM,

   E_R1_REGNUM, E_ER1_REGNUM = E_R1_REGNUM, E_RET1_REGNUM = E_R1_REGNUM,
   E_R2_REGNUM, E_ER2_REGNUM = E_R2_REGNUM, E_ARGLAST_REGNUM = E_R2_REGNUM,
   E_R3_REGNUM, E_ER3_REGNUM = E_R3_REGNUM,
   E_R1_REGNUM, E_ER1_REGNUM = E_R1_REGNUM, E_RET1_REGNUM = E_R1_REGNUM,
   E_R2_REGNUM, E_ER2_REGNUM = E_R2_REGNUM, E_ARGLAST_REGNUM = E_R2_REGNUM,
   E_R3_REGNUM, E_ER3_REGNUM = E_R3_REGNUM,


@@ -81,20 +56,93 @@ enum gdb_regnum
   E_VBR_REGNUM
 };
 
   E_VBR_REGNUM
 };
 

-#define E_PSEUDO_CCR_REGNUM (NUM_REGS)
-#define E_PSEUDO_EXR_REGNUM (NUM_REGS+1)
+#define H8300_MAX_NUM_REGS 18
+
+#define E_PSEUDO_CCR_REGNUM(gdbarch) (gdbarch_num_regs (gdbarch))
+#define E_PSEUDO_EXR_REGNUM(gdbarch) (gdbarch_num_regs (gdbarch)+1)
+
+struct h8300_frame_cache
+{
+  /* Base address.  */
+  CORE_ADDR base;
+  CORE_ADDR sp_offset;
+  CORE_ADDR pc;
+
+  /* Flag showing that a frame has been created in the prologue code.  */
+  int uses_fp;
+
+  /* Saved registers.  */
+  CORE_ADDR saved_regs[H8300_MAX_NUM_REGS];
+  CORE_ADDR saved_sp;
+};
+
+enum
+{
+  h8300_reg_size = 2,
+  h8300h_reg_size = 4,
+  h8300_max_reg_size = 4,
+};
+
+static int is_h8300hmode (struct gdbarch *gdbarch);
+static int is_h8300smode (struct gdbarch *gdbarch);
+static int is_h8300sxmode (struct gdbarch *gdbarch);
+static int is_h8300_normal_mode (struct gdbarch *gdbarch);
+
+#define BINWORD(gdbarch) ((is_h8300hmode (gdbarch) \
+                 && !is_h8300_normal_mode (gdbarch)) \
+                ? h8300h_reg_size : h8300_reg_size)

 
 

-#define UNSIGNED_SHORT(X) ((X) & 0xffff)
+/* Normal frames.  */

 
 

-#define IS_PUSH(x) ((x & 0xfff0)==0x6df0)
-#define IS_PUSH_FP(x) (x == 0x6df6)
-#define IS_MOVE_FP(x) (x == 0x0d76 || x == 0x0ff6)
-#define IS_MOV_SP_FP(x) (x == 0x0d76 || x == 0x0ff6)
-#define IS_SUB2_SP(x) (x==0x1b87)
-#define IS_SUB4_SP(x) (x==0x1b97)
-#define IS_SUBL_SP(x) (x==0x7a37)
-#define IS_MOVK_R5(x) (x==0x7905)
-#define IS_SUB_R5SP(x) (x==0x1957)
+/* Allocate and initialize a frame cache.  */
+
+static void
+h8300_init_frame_cache (struct gdbarch *gdbarch,
+                       struct h8300_frame_cache *cache)
+{
+  int i;
+
+  /* Base address.  */
+  cache->base = 0;
+  cache->sp_offset = 0;
+  cache->pc = 0;
+
+  /* Frameless until proven otherwise.  */
+  cache->uses_fp = 0;
+
+  /* Saved registers.  We initialize these to -1 since zero is a valid
+     offset (that's where %fp is supposed to be stored).  */
+  for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
+    cache->saved_regs[i] = -1;
+}
+
+#define IS_MOVB_RnRm(x)                (((x) & 0xff88) == 0x0c88)
+#define IS_MOVW_RnRm(x)                (((x) & 0xff88) == 0x0d00)
+#define IS_MOVL_RnRm(x)                (((x) & 0xff88) == 0x0f80)
+#define IS_MOVB_Rn16_SP(x)     (((x) & 0xfff0) == 0x6ee0)
+#define IS_MOVB_EXT(x)         ((x) == 0x7860)
+#define IS_MOVB_Rn24_SP(x)     (((x) & 0xfff0) == 0x6aa0)
+#define IS_MOVW_Rn16_SP(x)     (((x) & 0xfff0) == 0x6fe0)
+#define IS_MOVW_EXT(x)         ((x) == 0x78e0)
+#define IS_MOVW_Rn24_SP(x)     (((x) & 0xfff0) == 0x6ba0)
+/* Same instructions as mov.w, just prefixed with 0x0100.  */
+#define IS_MOVL_PRE(x)         ((x) == 0x0100)
+#define IS_MOVL_Rn16_SP(x)     (((x) & 0xfff0) == 0x6fe0)
+#define IS_MOVL_EXT(x)         ((x) == 0x78e0)
+#define IS_MOVL_Rn24_SP(x)     (((x) & 0xfff0) == 0x6ba0)
+
+#define IS_PUSHFP_MOVESPFP(x)  ((x) == 0x6df60d76)
+#define IS_PUSH_FP(x)          ((x) == 0x01006df6)
+#define IS_MOV_SP_FP(x)                ((x) == 0x0ff6)
+#define IS_SUB2_SP(x)          ((x) == 0x1b87)
+#define IS_SUB4_SP(x)          ((x) == 0x1b97)
+#define IS_ADD_IMM_SP(x)       ((x) == 0x7a1f)
+#define IS_SUB_IMM_SP(x)       ((x) == 0x7a3f)
+#define IS_SUBL4_SP(x)         ((x) == 0x1acf)
+#define IS_MOV_IMM_Rn(x)       (((x) & 0xfff0) == 0x7905)
+#define IS_SUB_RnSP(x)         (((x) & 0xff0f) == 0x1907)
+#define IS_ADD_RnSP(x)         (((x) & 0xff0f) == 0x0907)
+#define IS_PUSH(x)             (((x) & 0xfff0) == 0x6df0)

 
 /* If the instruction at PC is an argument register spill, return its
    length.  Otherwise, return zero.
 
 /* If the instruction at PC is an argument register spill, return its
    length.  Otherwise, return zero.


@@ -108,463 +156,396 @@ enum gdb_regnum
    is used, it could be a byte, word or long move to registers r3-r5.  */
 
 static int
    is used, it could be a byte, word or long move to registers r3-r5.  */
 
 static int

-h8300_is_argument_spill (CORE_ADDR pc)
+h8300_is_argument_spill (struct gdbarch *gdbarch, CORE_ADDR pc)

 {
 {

-  int w = read_memory_unsigned_integer (pc, 2);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+  int w = read_memory_unsigned_integer (pc, 2, byte_order);

 
 

-  if (((w & 0xff88) == 0x0c88                 /* mov.b Rsl, Rdl */
-       || (w & 0xff88) == 0x0d00              /* mov.w Rs, Rd */
-       || (w & 0xff88) == 0x0f80)             /* mov.l Rs, Rd */
-      && (w & 0x70) <= 0x20                   /* Rs is R0, R1 or R2 */
-      && (w & 0x7) >= 0x3 && (w & 0x7) <= 0x5)/* Rd is R3, R4 or R5 */
+  if ((IS_MOVB_RnRm (w) || IS_MOVW_RnRm (w) || IS_MOVL_RnRm (w))
+      && (w & 0x70) <= 0x20    /* Rs is R0, R1 or R2 */
+      && (w & 0x7) >= 0x3 && (w & 0x7) <= 0x5) /* Rd is R3, R4 or R5 */

     return 2;
 
     return 2;
 

-  if ((w & 0xfff0) == 0x6ee0                  /* mov.b Rs,@(d:16,er6) */
-      && 8 <= (w & 0xf) && (w & 0xf) <= 10)   /* Rs is R0L, R1L, or R2L  */
+  if (IS_MOVB_Rn16_SP (w)
+      && 8 <= (w & 0xf) && (w & 0xf) <= 10)    /* Rs is R0L, R1L, or R2L  */

     {
     {

-      int w2 = read_memory_integer (pc + 2, 2);
-

       /* ... and d:16 is negative.  */
       /* ... and d:16 is negative.  */

-      if (w2 < 0)
-        return 4;
+      if (read_memory_integer (pc + 2, 2, byte_order) < 0)
+       return 4;

     }
     }

-  else if (w == 0x7860)
+  else if (IS_MOVB_EXT (w))

     {
     {

-      int w2 = read_memory_integer (pc + 2, 2);
-
-      if ((w2 & 0xfff0) == 0x6aa0)              /* mov.b Rs, @(d:24,er6) */
-        {
-          LONGEST disp = read_memory_integer (pc + 4, 4);
+      if (IS_MOVB_Rn24_SP (read_memory_unsigned_integer (pc + 2,
+                                                        2, byte_order)))
+       {
+         ULONGEST disp = read_memory_unsigned_integer (pc + 4, 4, byte_order);

 
 

-          /* ... and d:24 is negative.  */
-          if (disp < 0 && disp > 0xffffff)
-            return 8;
-        }
+         /* ... and d:24 is negative.  */
+         if ((disp & 0x00800000) != 0)
+           return 8;
+       }

     }
     }

-  else if ((w & 0xfff0) == 0x6fe0             /* mov.w Rs,@(d:16,er6) */
-           && (w & 0xf) <= 2)                 /* Rs is R0, R1, or R2 */
+  else if (IS_MOVW_Rn16_SP (w)
+          && (w & 0xf) <= 2)   /* Rs is R0, R1, or R2 */

     {
     {

-      int w2 = read_memory_integer (pc + 2, 2);
-

       /* ... and d:16 is negative.  */
       /* ... and d:16 is negative.  */

-      if (w2 < 0)
-        return 4;
+      if (read_memory_integer (pc + 2, 2, byte_order) < 0)
+       return 4;

     }
     }

-  else if (w == 0x78e0)
+  else if (IS_MOVW_EXT (w))

     {
     {

-      int w2 = read_memory_integer (pc + 2, 2);
-
-      if ((w2 & 0xfff0) == 0x6ba0)              /* mov.b Rs, @(d:24,er6) */
-        {
-          LONGEST disp = read_memory_integer (pc + 4, 4);
+      if (IS_MOVW_Rn24_SP (read_memory_unsigned_integer (pc + 2,
+                                                        2, byte_order)))
+       {
+         ULONGEST disp = read_memory_unsigned_integer (pc + 4, 4, byte_order);

 
 

-          /* ... and d:24 is negative.  */
-          if (disp < 0 && disp > 0xffffff)
-            return 8;
-        }
+         /* ... and d:24 is negative.  */
+         if ((disp & 0x00800000) != 0)
+           return 8;
+       }

     }
     }

-  else if (w == 0x0100)
+  else if (IS_MOVL_PRE (w))

     {
     {

-      int w2 = read_memory_integer (pc + 2, 2);
-
-      if ((w2 & 0xfff0) == 0x6fe0             /* mov.l Rs,@(d:16,er6) */
-          && (w2 & 0xf) <= 2)                /* Rs is ER0, ER1, or ER2 */
-        {
-          int w3 = read_memory_integer (pc + 4, 2);
-
-          /* ... and d:16 is negative.  */
-          if (w3 < 0)
-            return 6;
-        }
-      else if (w2 == 0x78e0)
-        {
-          int w3 = read_memory_integer (pc + 4, 2);
-
-          if ((w3 & 0xfff0) == 0x6ba0)          /* mov.l Rs, @(d:24,er6) */
-            {
-              LONGEST disp = read_memory_integer (pc + 6, 4);
+      int w2 = read_memory_integer (pc + 2, 2, byte_order);

 
 

-              /* ... and d:24 is negative.  */
-              if (disp < 0 && disp > 0xffffff)
-                return 10;
-            }
-        }
-    }
-
-  return 0;
-}
-
-static CORE_ADDR
-h8300_skip_prologue (CORE_ADDR start_pc)
-{
-  short int w;
-  int adjust = 0;
-
-  /* Skip past all push and stm insns.  */
-  while (1)
-    {
-      w = read_memory_unsigned_integer (start_pc, 2);
-      /* First look for push insns.  */
-      if (w == 0x0100 || w == 0x0110 || w == 0x0120 || w == 0x0130)
+      if (IS_MOVL_Rn16_SP (w2)
+         && (w2 & 0xf) <= 2)   /* Rs is ER0, ER1, or ER2 */

        {
        {

-         w = read_memory_unsigned_integer (start_pc + 2, 2);
-         adjust = 2;
+         /* ... and d:16 is negative.  */
+         if (read_memory_integer (pc + 4, 2, byte_order) < 0)
+           return 6;

        }
        }

-
-      if (IS_PUSH (w))
+      else if (IS_MOVL_EXT (w2))

        {
        {

-         start_pc += 2 + adjust;
-         w = read_memory_unsigned_integer (start_pc, 2);
-         continue;
-       }
-      adjust = 0;
-      break;
-    }
-
-  /* Skip past a move to FP, either word or long sized */
-  w = read_memory_unsigned_integer (start_pc, 2);
-  if (w == 0x0100)
-    {
-      w = read_memory_unsigned_integer (start_pc + 2, 2);
-      adjust += 2;
-    }
+         if (IS_MOVL_Rn24_SP (read_memory_integer (pc + 4, 2, byte_order)))
+           {
+             ULONGEST disp = read_memory_unsigned_integer (pc + 6, 4,
+                                                           byte_order);

 
 

-  if (IS_MOVE_FP (w))
-    {
-      start_pc += 2 + adjust;
-      w = read_memory_unsigned_integer (start_pc, 2);
+             /* ... and d:24 is negative.  */
+             if ((disp & 0x00800000) != 0)
+               return 10;
+           }
+       }

     }
 
     }
 

-  /* Check for loading either a word constant into r5;
-     long versions are handled by the SUBL_SP below.  */
-  if (IS_MOVK_R5 (w))
-    {
-      start_pc += 2;
-      w = read_memory_unsigned_integer (start_pc, 2);
-    }
+  return 0;
+}

 
 

-  /* Now check for subtracting r5 from sp, word sized only.  */
-  if (IS_SUB_R5SP (w))
-    {
-      start_pc += 2 + adjust;
-      w = read_memory_unsigned_integer (start_pc, 2);
-    }
+/* Do a full analysis of the prologue at PC and update CACHE
+   accordingly.  Bail out early if CURRENT_PC is reached.  Return the
+   address where the analysis stopped.

 
 

-  /* Check for subs #2 and subs #4. */
-  while (IS_SUB2_SP (w) || IS_SUB4_SP (w))
-    {
-      start_pc += 2 + adjust;
-      w = read_memory_unsigned_integer (start_pc, 2);
-    }
+   We handle all cases that can be generated by gcc.

 
 

-  /* Check for a 32bit subtract.  */
-  if (IS_SUBL_SP (w))
-    start_pc += 6 + adjust;
+   For allocating a stack frame:

 
 

-  /* Skip past another possible stm insn for registers R3 to R5 (possibly used
-     for register qualified arguments.  */
-  w = read_memory_unsigned_integer (start_pc, 2);
-  /* First look for push insns.  */
-  if (w == 0x0110 || w == 0x0120 || w == 0x0130)
-    {
-      w = read_memory_unsigned_integer (start_pc + 2, 2);
-      if (IS_PUSH (w) && (w & 0xf) >= 0x3 && (w & 0xf) <= 0x5)
-       start_pc += 4;
-    }
+   mov.w r6,@-sp
+   mov.w sp,r6
+   mov.w #-n,rN
+   add.w rN,sp

 
 

-  /* Check for spilling an argument register to the stack frame.
-     This could also be an initializing store from non-prologue code,
-     but I don't think there's any harm in skipping that.  */
-  for (;;)
-    {
-      int spill_size = h8300_is_argument_spill (start_pc);
-      if (spill_size == 0)
-        break;
-      start_pc += spill_size;
-    }
+   mov.w r6,@-sp
+   mov.w sp,r6
+   subs  #2,sp
+   (repeat)

 
 

-  return start_pc;
-}
+   mov.l er6,@-sp
+   mov.l sp,er6
+   add.l #-n,sp

 
 

-/* 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. */
+   mov.w r6,@-sp
+   mov.w sp,r6
+   subs  #4,sp
+   (repeat)

 
 

-static CORE_ADDR
-h8300_next_prologue_insn (CORE_ADDR addr, 
-                         CORE_ADDR lim, 
-                         unsigned short* pword1)
-{
-  char buf[2];
-  if (addr < lim + 8)
-    {
-      read_memory (addr, buf, 2);
-      *pword1 = extract_signed_integer (buf, 2);
+   For saving registers:

 
 

-      return addr + 2;
-    }
-  return 0;
-}
+   mov.w rN,@-sp
+   mov.l erN,@-sp
+   stm.l reglist,@-sp

 
 

-/* Examine the prologue of a function.  `ip' points to the first instruction.
-   `limit' is the limit of the prologue (e.g. the addr of the first
-   linenumber, or perhaps the program counter if we're stepping through).
-   `frame_sp' is the stack pointer value in use in this frame.
-   `fsr' is a pointer to a frame_saved_regs structure into which we put
-   info about the registers saved by this frame.
-   `fi' is a struct frame_info pointer; we fill in various fields in it
-   to reflect the offsets of the arg pointer and the locals pointer.  */
-
-/* Any function with a frame looks like this
-   SECOND ARG
-   FIRST ARG
-   RET PC
-   SAVED R2
-   SAVED R3
-   SAVED FP   <-FP POINTS HERE
-   LOCALS0
-   LOCALS1    <-SP POINTS HERE
- */
+   */

 
 static CORE_ADDR
 
 static CORE_ADDR

-h8300_examine_prologue (CORE_ADDR ip, CORE_ADDR limit,
-                       CORE_ADDR after_prolog_fp, CORE_ADDR *fsr,
-                       struct frame_info *fi)
+h8300_analyze_prologue (struct gdbarch *gdbarch,
+                       CORE_ADDR pc, CORE_ADDR current_pc,
+                       struct h8300_frame_cache *cache)

 {
 {

-  CORE_ADDR next_ip;
-  int r;
-  int have_fp = 0;
-  unsigned short insn_word;
-  /* Number of things pushed onto stack, starts at 2/4, 'cause the
-     PC is already there */
-  unsigned int reg_save_depth = BINWORD;
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+  unsigned int op;
+  int regno, i, spill_size;

 
 

-  unsigned int auto_depth = 0; /* Number of bytes of autos */
+  cache->sp_offset = 0;

 
 

-  char in_frame[11];           /* One for each reg */
+  if (pc >= current_pc)
+    return current_pc;

 
 

-  int adjust = 0;
+  op = read_memory_unsigned_integer (pc, 4, byte_order);

 
 

-  memset (in_frame, 1, 11);
-  for (r = 0; r < 8; r++)
+  if (IS_PUSHFP_MOVESPFP (op))

     {
     {

-      fsr[r] = 0;
+      cache->saved_regs[E_FP_REGNUM] = 0;
+      cache->uses_fp = 1;
+      pc += 4;

     }
     }

-  if (after_prolog_fp == 0)
-    {
-      after_prolog_fp = read_register (E_SP_REGNUM);
-    }
-
-  /* If the PC isn't valid, quit now.  */
-  if (ip == 0 || ip & (is_h8300hmode (current_gdbarch) &&
-                        !is_h8300_normal_mode (current_gdbarch) ? ~0xffffff : ~0xffff))
-    return 0;
-
-  next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
-
-  if (insn_word == 0x0100)     /* mov.l */
-    {
-      insn_word = read_memory_unsigned_integer (ip + 2, 2);
-      adjust = 2;
-    }
-
-  /* Skip over any fp push instructions */
-  fsr[E_FP_REGNUM] = after_prolog_fp;
-  while (next_ip && IS_PUSH_FP (insn_word))
-    {
-      ip = next_ip + adjust;
-
-      in_frame[insn_word & 0x7] = reg_save_depth;
-      next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
-      reg_save_depth += 2 + adjust;
-    }
-
-  /* Is this a move into the fp */
-  if (next_ip && IS_MOV_SP_FP (insn_word))
+  else if (IS_PUSH_FP (op))

     {
     {

-      ip = next_ip;
-      next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
-      have_fp = 1;
+      cache->saved_regs[E_FP_REGNUM] = 0;
+      pc += 4;
+      if (pc >= current_pc)
+        return current_pc;
+      op = read_memory_unsigned_integer (pc, 2, byte_order);
+      if (IS_MOV_SP_FP (op))
+       {
+         cache->uses_fp = 1;
+         pc += 2;
+       }

     }
 
     }
 

-  /* Skip over any stack adjustment, happens either with a number of
-     sub#2,sp or a mov #x,r5 sub r5,sp */
-
-  if (next_ip && (IS_SUB2_SP (insn_word) || IS_SUB4_SP (insn_word)))
+  while (pc < current_pc)

     {
     {

-      while (next_ip && (IS_SUB2_SP (insn_word) || IS_SUB4_SP (insn_word)))
+      op = read_memory_unsigned_integer (pc, 2, byte_order);
+      if (IS_SUB2_SP (op))

        {
        {

-         auto_depth += IS_SUB2_SP (insn_word) ? 2 : 4;
-         ip = next_ip;
-         next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
+         cache->sp_offset += 2;
+         pc += 2;

        }
        }

-    }
-  else
-    {
-      if (next_ip && IS_MOVK_R5 (insn_word))
+      else if (IS_SUB4_SP (op))

        {
        {

-         ip = next_ip;
-         next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
-         auto_depth += insn_word;
-
-         next_ip = h8300_next_prologue_insn (next_ip, limit, &insn_word);
-         auto_depth += insn_word;
+         cache->sp_offset += 4;
+         pc += 2;

        }
        }

-      if (next_ip && IS_SUBL_SP (insn_word))
+      else if (IS_ADD_IMM_SP (op))

        {
        {

-         ip = next_ip;
-         auto_depth += read_memory_unsigned_integer (ip, 4);
-         ip += 4;
-
-         next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
+         cache->sp_offset += -read_memory_integer (pc + 2, 2, byte_order);
+         pc += 4;

        }
        }

-    }
-
-  /* Now examine the push insns to determine where everything lives
-     on the stack.  */
-  while (1)
-    {
-      adjust = 0;
-      if (!next_ip)
-       break;
-
-      if (insn_word == 0x0100)
+      else if (IS_SUB_IMM_SP (op))

        {
        {

-         ip = next_ip;
-         next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
-         adjust = 2;
+         cache->sp_offset += read_memory_integer (pc + 2, 2, byte_order);
+         pc += 4;

        }
        }

-
-      if (IS_PUSH (insn_word))
+      else if (IS_SUBL4_SP (op))

        {
        {

-         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);
-         continue;
+         cache->sp_offset += 4;
+         pc += 2;

        }
        }

-
-      /* Now check for push multiple insns.  */
-      if (insn_word == 0x0110 || insn_word == 0x0120 || insn_word == 0x0130)
+      else if (IS_MOV_IMM_Rn (op))
+        {
+         int offset = read_memory_integer (pc + 2, 2, byte_order);
+         regno = op & 0x000f;
+         op = read_memory_unsigned_integer (pc + 4, 2, byte_order);
+         if (IS_ADD_RnSP (op) && (op & 0x00f0) == regno)
+           {
+             cache->sp_offset -= offset;
+             pc += 6;
+           }
+         else if (IS_SUB_RnSP (op) && (op & 0x00f0) == regno)
+           {
+             cache->sp_offset += offset;
+             pc += 6;
+           }
+         else
+           break;
+       }
+      else if (IS_PUSH (op))

        {
        {

-         int count = ((insn_word >> 4) & 0xf) + 1;
-         int start, i;
-
-         ip = next_ip;
-         next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
-         start = insn_word & 0x7;
-
-         for (i = start; i < start + count; i++)
+         regno = op & 0x000f;
+         cache->sp_offset += 2;
+         cache->saved_regs[regno] = cache->sp_offset;
+         pc += 2;
+       }
+      else if (op == 0x0100)
+       {
+         op = read_memory_unsigned_integer (pc + 2, 2, byte_order);
+         if (IS_PUSH (op))

            {
            {

-             auto_depth += 4;
-             fsr[i] = after_prolog_fp - auto_depth;
+             regno = op & 0x000f;
+             cache->sp_offset += 4;
+             cache->saved_regs[regno] = cache->sp_offset;
+             pc += 4;

            }
            }

+         else
+           break;

        }
        }

-      break;
+      else if ((op & 0xffcf) == 0x0100)
+       {
+         int op1;
+         op1 = read_memory_unsigned_integer (pc + 2, 2, byte_order);
+         if (IS_PUSH (op1))
+           {
+             /* Since the prefix is 0x01x0, this is not a simple pushm but a
+                stm.l reglist,@-sp */
+             i = ((op & 0x0030) >> 4) + 1;
+             regno = op1 & 0x000f;
+             for (; i > 0; regno++, --i)
+               {
+                 cache->sp_offset += 4;
+                 cache->saved_regs[regno] = cache->sp_offset;
+               }
+             pc += 4;
+           }
+         else
+           break;
+       }
+      else
+       break;

     }
 
     }
 

-  /* The PC is at a known place */
-  get_frame_extra_info (fi)->from_pc =
-    read_memory_unsigned_integer (after_prolog_fp + BINWORD, BINWORD);
+  /* Check for spilling an argument register to the stack frame.
+     This could also be an initializing store from non-prologue code,
+     but I don't think there's any harm in skipping that.  */
+  while ((spill_size = h8300_is_argument_spill (gdbarch, pc)) > 0
+         && pc + spill_size <= current_pc)
+    pc += spill_size;

 
 

-  /* Rememeber any others too */
-  in_frame[E_PC_REGNUM] = 0;
+  return pc;
+}
+
+static struct h8300_frame_cache *
+h8300_frame_cache (struct frame_info *this_frame, void **this_cache)
+{
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
+  struct h8300_frame_cache *cache;
+  int i;
+  CORE_ADDR current_pc;
+
+  if (*this_cache)
+    return (struct h8300_frame_cache *) *this_cache;
+
+  cache = FRAME_OBSTACK_ZALLOC (struct h8300_frame_cache);
+  h8300_init_frame_cache (gdbarch, cache);
+  *this_cache = cache;
+
+  /* In principle, for normal frames, %fp holds the frame pointer,
+     which holds the base address for the current stack frame.
+     However, for functions that don't need it, the frame pointer is
+     optional.  For these "frameless" functions the frame pointer is
+     actually the frame pointer of the calling frame.  */

 
 

-  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);
+  cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
+  if (cache->base == 0)
+    return cache;
+
+  cache->saved_regs[E_PC_REGNUM] = -BINWORD (gdbarch);
+
+  cache->pc = get_frame_func (this_frame);
+  current_pc = get_frame_pc (this_frame);
+  if (cache->pc != 0)
+    h8300_analyze_prologue (gdbarch, cache->pc, current_pc, cache);
+
+  if (!cache->uses_fp)
+    {
+      /* We didn't find a valid frame, which means that CACHE->base
+         currently holds the frame pointer for our calling frame.  If
+         we're at the start of a function, or somewhere half-way its
+         prologue, the function's frame probably hasn't been fully
+         setup yet.  Try to reconstruct the base address for the stack
+         frame by looking at the stack pointer.  For truly "frameless"
+         functions this might work too.  */
+
+      cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM)
+                   + cache->sp_offset;
+      cache->saved_sp = cache->base + BINWORD (gdbarch);
+      cache->saved_regs[E_PC_REGNUM] = 0;
+    }

   else
   else

-    fsr[E_SP_REGNUM] = after_prolog_fp + auto_depth;
+    {
+      cache->saved_sp = cache->base + 2 * BINWORD (gdbarch);
+      cache->saved_regs[E_PC_REGNUM] = -BINWORD (gdbarch);
+    }
+
+  /* Adjust all the saved registers such that they contain addresses
+     instead of offsets.  */
+  for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
+    if (cache->saved_regs[i] != -1)
+      cache->saved_regs[i] = cache->base - cache->saved_regs[i];

 
 

-  return (ip);
+  return cache;

 }
 
 static void
 }
 
 static void

-h8300_frame_init_saved_regs (struct frame_info *fi)
+h8300_frame_this_id (struct frame_info *this_frame, void **this_cache,
+                    struct frame_id *this_id)

 {
 {

-  CORE_ADDR func_addr, func_end;
+  struct h8300_frame_cache *cache =
+    h8300_frame_cache (this_frame, this_cache);

 
 

-  if (!deprecated_get_frame_saved_regs (fi))
-    {
-      frame_saved_regs_zalloc (fi);
+  /* This marks the outermost frame.  */
+  if (cache->base == 0)
+    return;

 
 

-      /* Find the beginning of this function, so we can analyze its
-        prologue. */
-      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 < get_frame_pc (fi)) 
-           ? sal.end : get_frame_pc (fi);
-         /* This will fill in fields in fi. */
-         h8300_examine_prologue (func_addr, limit, get_frame_base (fi),
-                                 deprecated_get_frame_saved_regs (fi), fi);
-       }
-      /* Else we're out of luck (can't debug completely stripped code). 
-        FIXME. */
-    }
+  *this_id = frame_id_build (cache->saved_sp, cache->pc);

 }
 
 }
 

-/* 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.
+static struct value *
+h8300_frame_prev_register (struct frame_info *this_frame, void **this_cache,
+                          int regnum)
+{
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
+  struct h8300_frame_cache *cache =
+    h8300_frame_cache (this_frame, this_cache);

 
 

-   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.  */
+  gdb_assert (regnum >= 0);

 
 

-static CORE_ADDR
-h8300_frame_chain (struct frame_info *thisframe)
-{
-  if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (thisframe),
-                                  get_frame_base (thisframe),
-                                  get_frame_base (thisframe)))
-    {                          /* initialize the from_pc now */
-      get_frame_extra_info (thisframe)->from_pc =
-       deprecated_read_register_dummy (get_frame_pc (thisframe),
-                                       get_frame_base (thisframe),
-                                       E_PC_REGNUM);
-      return get_frame_base (thisframe);
-    }
-  return deprecated_get_frame_saved_regs (thisframe)[E_SP_REGNUM];
-}
+  if (regnum == E_SP_REGNUM && cache->saved_sp)
+    return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
+
+  if (regnum < gdbarch_num_regs (gdbarch)
+      && cache->saved_regs[regnum] != -1)
+    return frame_unwind_got_memory (this_frame, regnum,
+                                    cache->saved_regs[regnum]);

 
 

-/* Return the saved PC from this frame.
+  return frame_unwind_got_register (this_frame, regnum, regnum);
+}

 
 

-   If the frame has a memory copy of SRP_REGNUM, use that.  If not,
-   just use the register SRP_REGNUM itself.  */
+static const struct frame_unwind h8300_frame_unwind = {
+  NORMAL_FRAME,
+  default_frame_unwind_stop_reason,
+  h8300_frame_this_id,
+  h8300_frame_prev_register,
+  NULL,
+  default_frame_sniffer
+};

 
 static CORE_ADDR
 
 static CORE_ADDR

-h8300_frame_saved_pc (struct frame_info *frame)
+h8300_frame_base_address (struct frame_info *this_frame, void **this_cache)

 {
 {

-  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 get_frame_extra_info (frame)->from_pc;
+  struct h8300_frame_cache *cache = h8300_frame_cache (this_frame, this_cache);
+  return cache->base;

 }
 
 }
 

-static void
-h8300_init_extra_frame_info (int fromleaf, struct frame_info *fi)
+static const struct frame_base h8300_frame_base = {
+  &h8300_frame_unwind,
+  h8300_frame_base_address,
+  h8300_frame_base_address,
+  h8300_frame_base_address
+};
+
+static CORE_ADDR
+h8300_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)

 {
 {

-  if (!get_frame_extra_info (fi))
+  CORE_ADDR func_addr = 0 , func_end = 0;
+
+  if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))

     {
     {

-      frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
-      get_frame_extra_info (fi)->from_pc = 0;
-      
-      if (!get_frame_pc (fi))
-        {
-         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);
+      struct symtab_and_line sal;
+      struct h8300_frame_cache cache;
+
+      /* Found a function.  */
+      sal = find_pc_line (func_addr, 0);
+      if (sal.end && sal.end < func_end)
+        /* Found a line number, use it as end of prologue.  */
+        return sal.end;
+
+      /* No useable line symbol.  Use prologue parsing method.  */
+      h8300_init_frame_cache (gdbarch, &cache);
+      return h8300_analyze_prologue (gdbarch, func_addr, func_end, &cache);

     }
     }

+
+  /* No function symbol -- just return the PC.  */
+  return (CORE_ADDR) pc;

 }
 
 /* Function: push_dummy_call
 }
 
 /* Function: push_dummy_call


@@ -632,13 +613,15 @@ h8300_init_extra_frame_info (int fromleaf, struct frame_info *fi)
      to begin with.  */
 
 static CORE_ADDR
      to begin with.  */
 
 static CORE_ADDR

-h8300_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
-                      struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
-                      struct value **args, CORE_ADDR sp, int struct_return,
+h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
+                      struct regcache *regcache, CORE_ADDR bp_addr,
+                      int nargs, struct value **args, CORE_ADDR sp,
+                      function_call_return_method return_method,

                       CORE_ADDR struct_addr)
 {
                       CORE_ADDR struct_addr)
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   int stack_alloc = 0, stack_offset = 0;
   int stack_alloc = 0, stack_offset = 0;

-  int wordsize = BINWORD;
+  int wordsize = BINWORD (gdbarch);

   int reg = E_ARG0_REGNUM;
   int argument;
 
   int reg = E_ARG0_REGNUM;
   int argument;
 


@@ -648,8 +631,8 @@ h8300_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
   /* Now make sure there's space on the stack for the arguments.  We
      may over-allocate a little here, but that won't hurt anything.  */
   for (argument = 0; argument < nargs; argument++)
   /* Now make sure there's space on the stack for the arguments.  We
      may over-allocate a little here, but that won't hurt anything.  */
   for (argument = 0; argument < nargs; argument++)

-    stack_alloc += align_up (TYPE_LENGTH (VALUE_TYPE (args[argument])),
-                             wordsize);
+    stack_alloc += align_up (TYPE_LENGTH (value_type (args[argument])),
+                            wordsize);

   sp -= stack_alloc;
 
   /* Now load as many arguments as possible into registers, and push
   sp -= stack_alloc;
 
   /* Now load as many arguments as possible into registers, and push


@@ -657,112 +640,78 @@ h8300_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
      If we're returning a structure by value, then we must pass a
      pointer to the buffer for the return value as an invisible first
      argument.  */
      If we're returning a structure by value, then we must pass a
      pointer to the buffer for the return value as an invisible first
      argument.  */

-  if (struct_return)
+  if (return_method == return_method_struct)

     regcache_cooked_write_unsigned (regcache, reg++, struct_addr);
 
   for (argument = 0; argument < nargs; argument++)
     {
     regcache_cooked_write_unsigned (regcache, reg++, struct_addr);
 
   for (argument = 0; argument < nargs; argument++)
     {

-      struct type *type = VALUE_TYPE (args[argument]);
+      struct type *type = value_type (args[argument]);

       int len = TYPE_LENGTH (type);
       int len = TYPE_LENGTH (type);

-      char *contents = (char *) VALUE_CONTENTS (args[argument]);
+      char *contents = (char *) value_contents (args[argument]);

 
       /* Pad the argument appropriately.  */
       int padded_len = align_up (len, wordsize);
 
       /* Pad the argument appropriately.  */
       int padded_len = align_up (len, wordsize);

-      char *padded = alloca (padded_len);
+      /* Use std::vector here to get zero initialization.  */
+      std::vector<gdb_byte> padded (padded_len);

 
 

-      memset (padded, 0, padded_len);
-      memcpy (len < wordsize ? padded + padded_len - len : padded,
-              contents, len);
+      memcpy ((len < wordsize ? padded.data () + padded_len - len
+              : padded.data ()),
+             contents, len);

 
       /* Could the argument fit in the remaining registers?  */
       if (padded_len <= (E_ARGLAST_REGNUM - reg + 1) * wordsize)
 
       /* Could the argument fit in the remaining registers?  */
       if (padded_len <= (E_ARGLAST_REGNUM - reg + 1) * wordsize)

-        {
-          /* Are we going to pass it on the stack anyway, for no good
-             reason?  */
-          if (len > wordsize && len % wordsize)
-            {
-              /* I feel so unclean.  */
-              write_memory (sp + stack_offset, padded, padded_len);
-              stack_offset += padded_len;
-
-              /* That's right --- even though we passed the argument
-                 on the stack, we consume the registers anyway!  Love
-                 me, love my dog.  */
-              reg += padded_len / wordsize;
-            }
-          else
-            {
-              /* Heavens to Betsy --- it's really going in registers!
-                 It would be nice if we could use write_register_bytes
-                 here, but on the h8/300s, there are gaps between
-                 the registers in the register file.  */
-              int offset;
-
-              for (offset = 0; offset < padded_len; offset += wordsize)
-                {
-                  ULONGEST word = extract_unsigned_integer (padded + offset, 
-                                                           wordsize);
+       {
+         /* Are we going to pass it on the stack anyway, for no good
+            reason?  */
+         if (len > wordsize && len % wordsize)
+           {
+             /* I feel so unclean.  */
+             write_memory (sp + stack_offset, padded.data (), padded_len);
+             stack_offset += padded_len;
+
+             /* That's right --- even though we passed the argument
+                on the stack, we consume the registers anyway!  Love
+                me, love my dog.  */
+             reg += padded_len / wordsize;
+           }
+         else
+           {
+             /* Heavens to Betsy --- it's really going in registers!
+                Note that on the h8/300s, there are gaps between the
+                registers in the register file.  */
+             int offset;
+
+             for (offset = 0; offset < padded_len; offset += wordsize)
+               {
+                 ULONGEST word
+                   = extract_unsigned_integer (&padded[offset],
+                                               wordsize, byte_order);

                  regcache_cooked_write_unsigned (regcache, reg++, word);
                  regcache_cooked_write_unsigned (regcache, reg++, word);

-                }
-            }
-        }
+               }
+           }
+       }

       else
       else

-        {
-          /* It doesn't fit in registers!  Onto the stack it goes.  */
-          write_memory (sp + stack_offset, padded, padded_len);
-          stack_offset += padded_len;
-
-          /* Once one argument has spilled onto the stack, all
-             subsequent arguments go on the stack.  */
-          reg = E_ARGLAST_REGNUM + 1;
-        }
+       {
+         /* It doesn't fit in registers!  Onto the stack it goes.  */
+         write_memory (sp + stack_offset, padded.data (), padded_len);
+         stack_offset += padded_len;
+
+         /* Once one argument has spilled onto the stack, all
+            subsequent arguments go on the stack.  */
+         reg = E_ARGLAST_REGNUM + 1;
+       }

     }
 
   /* Store return address.  */
   sp -= wordsize;
     }
 
   /* Store return address.  */
   sp -= wordsize;

-  write_memory_unsigned_integer (sp, wordsize, bp_addr);
+  write_memory_unsigned_integer (sp, wordsize, byte_order, bp_addr);

 
   /* Update stack pointer.  */
   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
 
 
   /* Update stack pointer.  */
   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
 

-  return sp;
-}
-
-/* Function: h8300_pop_frame
-   Restore the machine to the state it had before the current frame 
-   was created.  Usually used either by the "RETURN" command, or by
-   call_function_by_hand after the dummy_frame is finished. */
-
-static void
-h8300_pop_frame (void)
-{
-  unsigned regno;
-  struct frame_info *frame = get_current_frame ();
-
-  if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
-                                  get_frame_base (frame),
-                                  get_frame_base (frame)))
-    {
-      generic_pop_dummy_frame ();
-    }
-  else
-    {
-      for (regno = 0; regno < 8; regno++)
-       {
-         /* 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 (deprecated_get_frame_saved_regs (frame)[regno] && regno != E_SP_REGNUM)
-           write_register (regno,
-                           read_memory_integer 
-                           (deprecated_get_frame_saved_regs (frame)[regno], BINWORD));
-         else if (deprecated_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, get_frame_extra_info (frame)->from_pc);
-    }
-  flush_cached_frames ();
+  /* Return the new stack pointer minus the return address slot since
+     that's what DWARF2/GCC uses as the frame's CFA.  */
+  return sp + wordsize;

 }
 
 /* Function: extract_return_value
 }
 
 /* Function: extract_return_value


@@ -771,69 +720,101 @@ h8300_pop_frame (void)
 
 static void
 h8300_extract_return_value (struct type *type, struct regcache *regcache,
 
 static void
 h8300_extract_return_value (struct type *type, struct regcache *regcache,

-                           void *valbuf)
+                           gdb_byte *valbuf)

 {
 {

+  struct gdbarch *gdbarch = regcache->arch ();
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   int len = TYPE_LENGTH (type);
   ULONGEST c, addr;
 
   switch (len)
     {
   int len = TYPE_LENGTH (type);
   ULONGEST c, addr;
 
   switch (len)
     {

-      case 1:
-      case 2:
-       regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c);
-       store_unsigned_integer (valbuf, len, c);
-       break;
-      case 4:  /* Needs two registers on plain H8/300 */
-       regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c);
-       store_unsigned_integer (valbuf, 2, c);
-       regcache_cooked_read_unsigned (regcache, E_RET1_REGNUM, &c);
-       store_unsigned_integer ((void*)((char *)valbuf + 2), 2, c);
-       break;
-      case 8:  /* long long is now 8 bytes.  */
-       if (TYPE_CODE (type) == TYPE_CODE_INT)
-         {
-           regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &addr);
-           c = read_memory_unsigned_integer ((CORE_ADDR) addr, len);
-           store_unsigned_integer (valbuf, len, c);
-         }
-       else
-         {
-           error ("I don't know how this 8 byte value is returned.");
-         }
-       break;
+    case 1:
+    case 2:
+      regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c);
+      store_unsigned_integer (valbuf, len, byte_order, c);
+      break;
+    case 4:                    /* Needs two registers on plain H8/300 */
+      regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c);
+      store_unsigned_integer (valbuf, 2, byte_order, c);
+      regcache_cooked_read_unsigned (regcache, E_RET1_REGNUM, &c);
+      store_unsigned_integer (valbuf + 2, 2, byte_order, c);
+      break;
+    case 8:                    /* long long is now 8 bytes.  */
+      if (type->code () == TYPE_CODE_INT)
+       {
+         regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &addr);
+         c = read_memory_unsigned_integer ((CORE_ADDR) addr, len, byte_order);
+         store_unsigned_integer (valbuf, len, byte_order, c);
+       }
+      else
+       {
+         error (_("I don't know how this 8 byte value is returned."));
+       }
+      break;

     }
 }
 
 static void
 h8300h_extract_return_value (struct type *type, struct regcache *regcache,
     }
 }
 
 static void
 h8300h_extract_return_value (struct type *type, struct regcache *regcache,

-                           void *valbuf)
+                            gdb_byte *valbuf)

 {
 {

-  int len = TYPE_LENGTH (type);
-  ULONGEST c, addr;
+  struct gdbarch *gdbarch = regcache->arch ();
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+  ULONGEST c;

 
 

-  switch (len)
+  switch (TYPE_LENGTH (type))

     {
     {

-      case 1:
-      case 2:
-      case 4:
-       regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c);
-       store_unsigned_integer (valbuf, len, c);
-       break;
-      case 8:  /* long long is now 8 bytes.  */
-       if (TYPE_CODE (type) == TYPE_CODE_INT)
-         {
-           regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &addr);
-           c = read_memory_unsigned_integer ((CORE_ADDR) addr, len);
-           store_unsigned_integer (valbuf, len, c);
-         }
-       else
-         {
-           error ("I don't know how this 8 byte value is returned.");
-         }
-       break;
+    case 1:
+    case 2:
+    case 4:
+      regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c);
+      store_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order, c);
+      break;
+    case 8:                    /* long long is now 8 bytes.  */
+      if (type->code () == TYPE_CODE_INT)
+       {
+         regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c);
+         store_unsigned_integer (valbuf, 4, byte_order, c);
+         regcache_cooked_read_unsigned (regcache, E_RET1_REGNUM, &c);
+         store_unsigned_integer (valbuf + 4, 4, byte_order, c);
+       }
+      else
+       {
+         error (_("I don't know how this 8 byte value is returned."));
+       }
+      break;

     }
 }
 
     }
 }
 

+static int
+h8300_use_struct_convention (struct type *value_type)
+{
+  /* Types of 1, 2 or 4 bytes are returned in R0/R1, everything else on the
+     stack.  */
+
+  if (value_type->code () == TYPE_CODE_STRUCT
+      || value_type->code () == TYPE_CODE_UNION)
+    return 1;
+  return !(TYPE_LENGTH (value_type) == 1
+          || TYPE_LENGTH (value_type) == 2
+          || TYPE_LENGTH (value_type) == 4);
+}
+
+static int
+h8300h_use_struct_convention (struct type *value_type)
+{
+  /* Types of 1, 2 or 4 bytes are returned in R0, INT types of 8 bytes are
+     returned in R0/R1, everything else on the stack.  */
+  if (value_type->code () == TYPE_CODE_STRUCT
+      || value_type->code () == TYPE_CODE_UNION)
+    return 1;
+  return !(TYPE_LENGTH (value_type) == 1
+          || TYPE_LENGTH (value_type) == 2
+          || TYPE_LENGTH (value_type) == 4
+          || (TYPE_LENGTH (value_type) == 8
+              && value_type->code () == TYPE_CODE_INT));
+}

 
 /* Function: store_return_value
    Place the appropriate value in the appropriate registers.
 
 /* Function: store_return_value
    Place the appropriate value in the appropriate registers.


@@ -841,105 +822,176 @@ h8300h_extract_return_value (struct type *type, struct regcache *regcache,
 
 static void
 h8300_store_return_value (struct type *type, struct regcache *regcache,
 
 static void
 h8300_store_return_value (struct type *type, struct regcache *regcache,

-                         const void *valbuf)
+                         const gdb_byte *valbuf)

 {
 {

-  int len = TYPE_LENGTH (type);
+  struct gdbarch *gdbarch = regcache->arch ();
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   ULONGEST val;
 
   ULONGEST val;
 

-  switch (len)
+  switch (TYPE_LENGTH (type))

     {
     {

-      case 1:
-    case 2:    /* short... */
-       val = extract_unsigned_integer (valbuf, len);
-       regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM, val);
-       break;
-      case 4:  /* long, float */
-       val = extract_unsigned_integer (valbuf, len);
-       regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM,
-                                       (val >> 16) &0xffff);
-       regcache_cooked_write_unsigned (regcache, E_RET1_REGNUM, val & 0xffff);
-       break;
-      case 8:  /* long long, double and long double are all defined
-                  as 4 byte types so far so this shouldn't happen.  */
-       error ("I don't know how to return an 8 byte value.");
-       break;
+    case 1:
+    case 2:                    /* short...  */
+      val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order);
+      regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM, val);
+      break;
+    case 4:                    /* long, float */
+      val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order);
+      regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM,
+                                     (val >> 16) & 0xffff);
+      regcache_cooked_write_unsigned (regcache, E_RET1_REGNUM, val & 0xffff);
+      break;
+    case 8:                    /* long long, double and long double
+                                  are all defined as 4 byte types so
+                                  far so this shouldn't happen.  */
+      error (_("I don't know how to return an 8 byte value."));
+      break;

     }
 }
 
 static void
 h8300h_store_return_value (struct type *type, struct regcache *regcache,
     }
 }
 
 static void
 h8300h_store_return_value (struct type *type, struct regcache *regcache,

-                          const void *valbuf)
+                          const gdb_byte *valbuf)

 {
 {

-  int len = TYPE_LENGTH (type);
+  struct gdbarch *gdbarch = regcache->arch ();
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   ULONGEST val;
 
   ULONGEST val;
 

-  switch (len)
+  switch (TYPE_LENGTH (type))

     {
     {

-      case 1:
-      case 2:
-      case 4:  /* long, float */
-       val = extract_unsigned_integer (valbuf, len);
-       regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM, val);
-       break;
-      case 8:  /* long long, double and long double are all defined
-                  as 4 byte types so far so this shouldn't happen.  */
-       error ("I don't know how to return an 8 byte value.");
-       break;
+    case 1:
+    case 2:
+    case 4:                    /* long, float */
+      val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order);
+      regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM, val);
+      break;
+    case 8:
+      val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order);
+      regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM,
+                                     (val >> 32) & 0xffffffff);
+      regcache_cooked_write_unsigned (regcache, E_RET1_REGNUM,
+                                     val & 0xffffffff);
+      break;
+    }
+}
+
+static enum return_value_convention
+h8300_return_value (struct gdbarch *gdbarch, struct value *function,
+                   struct type *type, struct regcache *regcache,
+                   gdb_byte *readbuf, const gdb_byte *writebuf)
+{
+  if (h8300_use_struct_convention (type))
+    return RETURN_VALUE_STRUCT_CONVENTION;
+  if (writebuf)
+    h8300_store_return_value (type, regcache, writebuf);
+  else if (readbuf)
+    h8300_extract_return_value (type, regcache, readbuf);
+  return RETURN_VALUE_REGISTER_CONVENTION;
+}
+
+static enum return_value_convention
+h8300h_return_value (struct gdbarch *gdbarch, struct value *function,
+                    struct type *type, struct regcache *regcache,
+                    gdb_byte *readbuf, const gdb_byte *writebuf)
+{
+  if (h8300h_use_struct_convention (type))
+    {
+      if (readbuf)
+       {
+         ULONGEST addr;
+
+         regcache_raw_read_unsigned (regcache, E_R0_REGNUM, &addr);
+         read_memory (addr, readbuf, TYPE_LENGTH (type));
+       }
+
+      return RETURN_VALUE_ABI_RETURNS_ADDRESS;

     }
     }

+  if (writebuf)
+    h8300h_store_return_value (type, regcache, writebuf);
+  else if (readbuf)
+    h8300h_extract_return_value (type, regcache, readbuf);
+  return RETURN_VALUE_REGISTER_CONVENTION;

 }
 
 }
 

-static struct cmd_list_element *setmachinelist;
+/* Implementation of 'register_sim_regno' gdbarch method.  */
+
+static int
+h8300_register_sim_regno (struct gdbarch *gdbarch, int regnum)
+{
+  /* Only makes sense to supply raw registers.  */
+  gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
+
+  /* We hide the raw ccr from the user by making it nameless.  Because
+     the default register_sim_regno hook returns
+     LEGACY_SIM_REGNO_IGNORE for unnamed registers, we need to
+     override it.  The sim register numbering is compatible with
+     gdb's.  */
+  return regnum;
+}

 
 static const char *
 
 static const char *

-h8300_register_name (int regno)
+h8300_register_name_common (const char *regnames[], int numregs,
+                           struct gdbarch *gdbarch, int regno)

 {
 {

-  /* The register names change depending on which h8300 processor
-     type is selected. */
-  static char *register_names[] = {
-    "r0", "r1", "r2", "r3", "r4", "r5", "r6",
-    "sp", "","pc","cycles", "tick", "inst",
-    "ccr", /* pseudo register */
-  };

   if (regno < 0
   if (regno < 0

-      || regno >= (sizeof (register_names) / sizeof (*register_names)))
+      || regno >= numregs)

     internal_error (__FILE__, __LINE__,
     internal_error (__FILE__, __LINE__,

-                    "h8300_register_name: illegal register number %d", regno);
+                   _("h8300_register_name_common: illegal register number %d"),
+                   regno);

   else
   else

-    return register_names[regno];
+    return regnames[regno];
+}
+
+static const char *
+h8300_register_name (struct gdbarch *gdbarch, int regno)
+{
+  /* The register names change depending on which h8300 processor
+     type is selected.  */
+  static const char *register_names[] = {
+    "r0", "r1", "r2", "r3", "r4", "r5", "r6",
+    "sp", "", "pc", "cycles", "tick", "inst",
+    "ccr",                     /* pseudo register */
+  };
+  return h8300_register_name_common(register_names, ARRAY_SIZE(register_names),
+                                   gdbarch, regno);

 }
 
 static const char *
 }
 
 static const char *

-h8300s_register_name (int regno)
+h8300h_register_name (struct gdbarch *gdbarch, int regno)

 {
 {

-  static char *register_names[] = {
+  static const char *register_names[] = {
+    "er0", "er1", "er2", "er3", "er4", "er5", "er6",
+    "sp", "", "pc", "cycles", "tick", "inst",
+    "ccr",                     /* pseudo register */
+  };
+  return h8300_register_name_common(register_names, ARRAY_SIZE(register_names),
+                                   gdbarch, regno);
+}
+
+static const char *
+h8300s_register_name (struct gdbarch *gdbarch, int regno)
+{
+  static const char *register_names[] = {

     "er0", "er1", "er2", "er3", "er4", "er5", "er6",
     "sp", "", "pc", "cycles", "", "tick", "inst",
     "mach", "macl",
     "er0", "er1", "er2", "er3", "er4", "er5", "er6",
     "sp", "", "pc", "cycles", "", "tick", "inst",
     "mach", "macl",

-    "ccr", "exr" /* pseudo registers */
+    "ccr", "exr"               /* pseudo registers */

   };
   };

-  if (regno < 0
-      || regno >= (sizeof (register_names) / sizeof (*register_names)))
-    internal_error (__FILE__, __LINE__,
-                    "h8300s_register_name: illegal register number %d", regno);
-  else
-    return register_names[regno];
+  return h8300_register_name_common(register_names, ARRAY_SIZE(register_names),
+                                   gdbarch, regno);

 }
 
 static const char *
 }
 
 static const char *

-h8300sx_register_name (int regno)
+h8300sx_register_name (struct gdbarch *gdbarch, int regno)

 {
 {

-  static char *register_names[] = {
+  static const char *register_names[] = {

     "er0", "er1", "er2", "er3", "er4", "er5", "er6",
     "sp", "", "pc", "cycles", "", "tick", "inst",
     "mach", "macl", "sbr", "vbr",
     "er0", "er1", "er2", "er3", "er4", "er5", "er6",
     "sp", "", "pc", "cycles", "", "tick", "inst",
     "mach", "macl", "sbr", "vbr",

-    "ccr", "exr" /* pseudo registers */
+    "ccr", "exr"               /* pseudo registers */

   };
   };

-  if (regno < 0
-      || regno >= (sizeof (register_names) / sizeof (*register_names)))
-    internal_error (__FILE__, __LINE__,
-                   "h8300sx_register_name: illegal register number %d", regno);
-  else
-    return register_names[regno];
+  return h8300_register_name_common(register_names, ARRAY_SIZE(register_names),
+                                   gdbarch, regno);

 }
 
 static void
 }
 
 static void


@@ -955,18 +1007,19 @@ h8300_print_register (struct gdbarch *gdbarch, struct ui_file *file,
   rval = get_frame_register_signed (frame, regno);
 
   fprintf_filtered (file, "%-14s ", name);
   rval = get_frame_register_signed (frame, regno);
 
   fprintf_filtered (file, "%-14s ", name);

-  if (regno == E_PSEUDO_CCR_REGNUM ||
-       (regno == E_PSEUDO_EXR_REGNUM && is_h8300smode (current_gdbarch)))
+  if ((regno == E_PSEUDO_CCR_REGNUM (gdbarch)) || \
+      (regno == E_PSEUDO_EXR_REGNUM (gdbarch) && is_h8300smode (gdbarch)))

     {
     {

-      fprintf_filtered (file, "0x%02x        ", (unsigned char)rval);
+      fprintf_filtered (file, "0x%02x        ", (unsigned char) rval);

       print_longest (file, 'u', 1, rval);
     }
   else
     {
       print_longest (file, 'u', 1, rval);
     }
   else
     {

-      fprintf_filtered (file, "0x%s  ", phex ((ULONGEST)rval, BINWORD));
+      fprintf_filtered (file, "0x%s  ", phex ((ULONGEST) rval,
+                       BINWORD (gdbarch)));

       print_longest (file, 'd', 1, rval);
     }
       print_longest (file, 'd', 1, rval);
     }

-  if (regno == E_PSEUDO_CCR_REGNUM)
+  if (regno == E_PSEUDO_CCR_REGNUM (gdbarch))

     {
       /* CCR register */
       int C, Z, N, V;
     {
       /* CCR register */
       int C, Z, N, V;


@@ -988,7 +1041,7 @@ h8300_print_register (struct gdbarch *gdbarch, struct ui_file *file,
        fprintf_filtered (file, "u> ");
       if ((C | Z) == 1)
        fprintf_filtered (file, "u<= ");
        fprintf_filtered (file, "u> ");
       if ((C | Z) == 1)
        fprintf_filtered (file, "u<= ");

-      if ((C == 0))
+      if (C == 0)

        fprintf_filtered (file, "u>= ");
       if (C == 1)
        fprintf_filtered (file, "u< ");
        fprintf_filtered (file, "u>= ");
       if (C == 1)
        fprintf_filtered (file, "u< ");


@@ -1005,7 +1058,7 @@ h8300_print_register (struct gdbarch *gdbarch, struct ui_file *file,
       if ((Z | (N ^ V)) == 1)
        fprintf_filtered (file, "<= ");
     }
       if ((Z | (N ^ V)) == 1)
        fprintf_filtered (file, "<= ");
     }

-  else if (regno == E_PSEUDO_EXR_REGNUM && is_h8300smode (current_gdbarch))
+  else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch) && is_h8300smode (gdbarch))

     {
       /* EXR register */
       unsigned char l = rval & 0xff;
     {
       /* EXR register */
       unsigned char l = rval & 0xff;


@@ -1026,12 +1079,14 @@ h8300_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
     {
       for (regno = E_R0_REGNUM; regno <= E_SP_REGNUM; ++regno)
        h8300_print_register (gdbarch, file, frame, regno);
     {
       for (regno = E_R0_REGNUM; regno <= E_SP_REGNUM; ++regno)
        h8300_print_register (gdbarch, file, frame, regno);

-      h8300_print_register (gdbarch, file, frame, E_PSEUDO_CCR_REGNUM);
+      h8300_print_register (gdbarch, file, frame,
+                           E_PSEUDO_CCR_REGNUM (gdbarch));

       h8300_print_register (gdbarch, file, frame, E_PC_REGNUM);
       h8300_print_register (gdbarch, file, frame, E_PC_REGNUM);

-      if (is_h8300smode (current_gdbarch))
-        {
-         h8300_print_register (gdbarch, file, frame, E_PSEUDO_EXR_REGNUM);
-         if (is_h8300sxmode (current_gdbarch))
+      if (is_h8300smode (gdbarch))
+       {
+         h8300_print_register (gdbarch, file, frame,
+                               E_PSEUDO_EXR_REGNUM (gdbarch));
+         if (is_h8300sxmode (gdbarch))

            {
              h8300_print_register (gdbarch, file, frame, E_SBR_REGNUM);
              h8300_print_register (gdbarch, file, frame, E_VBR_REGNUM);
            {
              h8300_print_register (gdbarch, file, frame, E_SBR_REGNUM);
              h8300_print_register (gdbarch, file, frame, E_VBR_REGNUM);


@@ -1043,7 +1098,7 @@ h8300_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
          h8300_print_register (gdbarch, file, frame, E_INSTS_REGNUM);
        }
       else
          h8300_print_register (gdbarch, file, frame, E_INSTS_REGNUM);
        }
       else

-        {
+       {

          h8300_print_register (gdbarch, file, frame, E_CYCLES_REGNUM);
          h8300_print_register (gdbarch, file, frame, E_TICK_REGNUM);
          h8300_print_register (gdbarch, file, frame, E_INST_REGNUM);
          h8300_print_register (gdbarch, file, frame, E_CYCLES_REGNUM);
          h8300_print_register (gdbarch, file, frame, E_TICK_REGNUM);
          h8300_print_register (gdbarch, file, frame, E_INST_REGNUM);


@@ -1052,307 +1107,280 @@ h8300_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
   else
     {
       if (regno == E_CCR_REGNUM)
   else
     {
       if (regno == E_CCR_REGNUM)

-        h8300_print_register (gdbarch, file, frame, E_PSEUDO_CCR_REGNUM);
-      else if (regno == E_PSEUDO_EXR_REGNUM && is_h8300smode (current_gdbarch))
-       h8300_print_register (gdbarch, file, frame, E_PSEUDO_EXR_REGNUM);
+       h8300_print_register (gdbarch, file, frame,
+                             E_PSEUDO_CCR_REGNUM (gdbarch));
+      else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch)
+              && is_h8300smode (gdbarch))
+       h8300_print_register (gdbarch, file, frame,
+                             E_PSEUDO_EXR_REGNUM (gdbarch));

       else
        h8300_print_register (gdbarch, file, frame, regno);
     }
 }
 
       else
        h8300_print_register (gdbarch, file, frame, regno);
     }
 }
 

-static CORE_ADDR
-h8300_saved_pc_after_call (struct frame_info *ignore)
-{
-  return read_memory_unsigned_integer (read_register (E_SP_REGNUM), BINWORD);
-}
-

 static struct type *
 h8300_register_type (struct gdbarch *gdbarch, int regno)
 {
 static struct type *
 h8300_register_type (struct gdbarch *gdbarch, int regno)
 {

-  if (regno < 0 || regno >= NUM_REGS + NUM_PSEUDO_REGS)
+  if (regno < 0 || regno >= gdbarch_num_cooked_regs (gdbarch))

     internal_error (__FILE__, __LINE__,
     internal_error (__FILE__, __LINE__,

-                   "h8300_register_type: illegal register number %d",
+                   _("h8300_register_type: illegal register number %d"),

                    regno);
   else
     {
       switch (regno)
                    regno);
   else
     {
       switch (regno)

-        {
-         case E_PC_REGNUM:
-           return builtin_type_void_func_ptr;
-         case E_SP_REGNUM:
-         case E_FP_REGNUM:
-           return builtin_type_void_data_ptr;
-         default:
-           if (regno == E_PSEUDO_CCR_REGNUM)
-             return builtin_type_uint8;
-           else if (regno == E_PSEUDO_EXR_REGNUM)
-             return builtin_type_uint8;
-           else if (is_h8300hmode (current_gdbarch))
-             return builtin_type_int32;
-           else
-             return builtin_type_int16;
-        }
+       {
+       case E_PC_REGNUM:
+         return builtin_type (gdbarch)->builtin_func_ptr;
+       case E_SP_REGNUM:
+       case E_FP_REGNUM:
+         return builtin_type (gdbarch)->builtin_data_ptr;
+       default:
+         if (regno == E_PSEUDO_CCR_REGNUM (gdbarch))
+           return builtin_type (gdbarch)->builtin_uint8;
+         else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch))
+           return builtin_type (gdbarch)->builtin_uint8;
+         else if (is_h8300hmode (gdbarch))
+           return builtin_type (gdbarch)->builtin_int32;
+         else
+           return builtin_type (gdbarch)->builtin_int16;
+       }

     }
 }
 
     }
 }
 

+/* Helpers for h8300_pseudo_register_read.  We expose ccr/exr as
+   pseudo-registers to users with smaller sizes than the corresponding
+   raw registers.  These helpers extend/narrow the values.  */
+
+static enum register_status
+pseudo_from_raw_register (struct gdbarch *gdbarch, readable_regcache *regcache,
+                         gdb_byte *buf, int pseudo_regno, int raw_regno)
+{
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+  enum register_status status;
+  ULONGEST val;
+
+  status = regcache->raw_read (raw_regno, &val);
+  if (status == REG_VALID)
+    store_unsigned_integer (buf,
+                           register_size (gdbarch, pseudo_regno),
+                           byte_order, val);
+  return status;
+}
+
+/* See pseudo_from_raw_register.  */
+

 static void
 static void

-h8300_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
-                           int regno, void *buf)
+raw_from_pseudo_register (struct gdbarch *gdbarch, struct regcache *regcache,
+                         const gdb_byte *buf, int raw_regno, int pseudo_regno)

 {
 {

-  if (regno == E_PSEUDO_CCR_REGNUM)
-    regcache_raw_read (regcache, E_CCR_REGNUM, buf);
-  else if (regno == E_PSEUDO_EXR_REGNUM)
-    regcache_raw_read (regcache, E_EXR_REGNUM, buf);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+  ULONGEST val;
+
+  val = extract_unsigned_integer (buf, register_size (gdbarch, pseudo_regno),
+                                 byte_order);
+  regcache_raw_write_unsigned (regcache, raw_regno, val);
+}
+
+static enum register_status
+h8300_pseudo_register_read (struct gdbarch *gdbarch,
+                           readable_regcache *regcache, int regno,
+                           gdb_byte *buf)
+{
+  if (regno == E_PSEUDO_CCR_REGNUM (gdbarch))
+    {
+      return pseudo_from_raw_register (gdbarch, regcache, buf,
+                                      regno, E_CCR_REGNUM);
+    }
+  else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch))
+    {
+      return pseudo_from_raw_register (gdbarch, regcache, buf,
+                                      regno, E_EXR_REGNUM);
+    }

   else
   else

-    regcache_raw_read (regcache, regno, buf);
+    return regcache->raw_read (regno, buf);

 }
 
 static void
 }
 
 static void

-h8300_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
-                            int regno, const void *buf)
+h8300_pseudo_register_write (struct gdbarch *gdbarch,
+                            struct regcache *regcache, int regno,
+                            const gdb_byte *buf)

 {
 {

-  if (regno == E_PSEUDO_CCR_REGNUM)
-    regcache_raw_write (regcache, E_CCR_REGNUM, buf);
-  else if (regno == E_PSEUDO_EXR_REGNUM)
-    regcache_raw_write (regcache, E_EXR_REGNUM, buf);
+  if (regno == E_PSEUDO_CCR_REGNUM (gdbarch))
+    raw_from_pseudo_register (gdbarch, regcache, buf, E_CCR_REGNUM, regno);
+  else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch))
+    raw_from_pseudo_register (gdbarch, regcache, buf, E_EXR_REGNUM, regno);

   else
   else

-    regcache_raw_write (regcache, regno, buf);
+    regcache->raw_write (regno, buf);

 }
 
 static int
 }
 
 static int

-h8300_dbg_reg_to_regnum (int regno)
+h8300_dbg_reg_to_regnum (struct gdbarch *gdbarch, int regno)

 {
   if (regno == E_CCR_REGNUM)
 {
   if (regno == E_CCR_REGNUM)

-    return E_PSEUDO_CCR_REGNUM;
+    return E_PSEUDO_CCR_REGNUM (gdbarch);

   return regno;
 }
 
 static int
   return regno;
 }
 
 static int

-h8300s_dbg_reg_to_regnum (int regno)
+h8300s_dbg_reg_to_regnum (struct gdbarch *gdbarch, int regno)

 {
   if (regno == E_CCR_REGNUM)
 {
   if (regno == E_CCR_REGNUM)

-    return E_PSEUDO_CCR_REGNUM;
+    return E_PSEUDO_CCR_REGNUM (gdbarch);

   if (regno == E_EXR_REGNUM)
   if (regno == E_EXR_REGNUM)

-    return E_PSEUDO_EXR_REGNUM;
+    return E_PSEUDO_EXR_REGNUM (gdbarch);

   return regno;
 }
 
   return regno;
 }
 

-static CORE_ADDR
-h8300_extract_struct_value_address (struct regcache *regcache)
-{
-  ULONGEST addr;
-  regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &addr);
-  return addr;
-}
-
-const static unsigned char *
-h8300_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
-{
-  /*static unsigned char breakpoint[] = { 0x7A, 0xFF };*/      /* ??? */
-  static unsigned char breakpoint[] = { 0x01, 0x80 };          /* Sleep */
-
-  *lenptr = sizeof (breakpoint);
-  return breakpoint;
-}
+/*static unsigned char breakpoint[] = { 0x7A, 0xFF }; *//* ??? */
+constexpr gdb_byte h8300_break_insn[] = { 0x01, 0x80 };        /* Sleep */

 
 

-static CORE_ADDR
-h8300_push_dummy_code (struct gdbarch *gdbarch,
-                      CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
-                      struct value **args, int nargs,
-                      struct type *value_type,
-                      CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
-{
-  /* Allocate space sufficient for a breakpoint.  */
-  sp = (sp - 2) & ~1;
-  /* Store the address of that breakpoint */
-  *bp_addr = sp;
-  /* h8300 always starts the call at the callee's entry point.  */
-  *real_pc = funaddr;
-  return sp;
-}
-
-static void
-h8300_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
-                       struct frame_info *frame, const char *args)
-{
-  fprintf_filtered (file, "\
-No floating-point info available for this processor.\n");
-}
+typedef BP_MANIPULATION (h8300_break_insn) h8300_breakpoint;

 
 static struct gdbarch *
 h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 {
 
 static struct gdbarch *
 h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 {

-  struct gdbarch_tdep *tdep = NULL;

   struct gdbarch *gdbarch;
 
   arches = gdbarch_list_lookup_by_info (arches, &info);
   if (arches != NULL)
     return arches->gdbarch;
 
   struct gdbarch *gdbarch;
 
   arches = gdbarch_list_lookup_by_info (arches, &info);
   if (arches != NULL)
     return arches->gdbarch;
 

-#if 0
-  tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
-#endif
-

   if (info.bfd_arch_info->arch != bfd_arch_h8300)
     return NULL;
 
   gdbarch = gdbarch_alloc (&info, 0);
 
   if (info.bfd_arch_info->arch != bfd_arch_h8300)
     return NULL;
 
   gdbarch = gdbarch_alloc (&info, 0);
 

+  set_gdbarch_register_sim_regno (gdbarch, h8300_register_sim_regno);
+

   switch (info.bfd_arch_info->mach)
     {
     case bfd_mach_h8300:
       set_gdbarch_num_regs (gdbarch, 13);
       set_gdbarch_num_pseudo_regs (gdbarch, 1);
   switch (info.bfd_arch_info->mach)
     {
     case bfd_mach_h8300:
       set_gdbarch_num_regs (gdbarch, 13);
       set_gdbarch_num_pseudo_regs (gdbarch, 1);

-      set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
-      set_gdbarch_dwarf_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);

       set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
       set_gdbarch_stab_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
       set_gdbarch_register_name (gdbarch, h8300_register_name);
       set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
       set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
       set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
       set_gdbarch_stab_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
       set_gdbarch_register_name (gdbarch, h8300_register_name);
       set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
       set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);

-      set_gdbarch_extract_return_value (gdbarch, h8300_extract_return_value);
-      set_gdbarch_store_return_value (gdbarch, h8300_store_return_value);
-      set_gdbarch_print_insn (gdbarch, print_insn_h8300);
+      set_gdbarch_return_value (gdbarch, h8300_return_value);

       break;
     case bfd_mach_h8300h:
     case bfd_mach_h8300hn:
       set_gdbarch_num_regs (gdbarch, 13);
       set_gdbarch_num_pseudo_regs (gdbarch, 1);
       break;
     case bfd_mach_h8300h:
     case bfd_mach_h8300hn:
       set_gdbarch_num_regs (gdbarch, 13);
       set_gdbarch_num_pseudo_regs (gdbarch, 1);

-      set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
-      set_gdbarch_dwarf_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);

       set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
       set_gdbarch_stab_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
       set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
       set_gdbarch_stab_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);

-      set_gdbarch_register_name (gdbarch, h8300_register_name);
-      if(info.bfd_arch_info->mach != bfd_mach_h8300hn)
-        {
-          set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
-          set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
-        }
+      set_gdbarch_register_name (gdbarch, h8300h_register_name);
+      if (info.bfd_arch_info->mach != bfd_mach_h8300hn)
+       {
+         set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
+         set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
+       }

       else
       else

-        {
-          set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
-          set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
-        }
-      set_gdbarch_extract_return_value (gdbarch, h8300h_extract_return_value);
-      set_gdbarch_store_return_value (gdbarch, h8300h_store_return_value);
-      set_gdbarch_print_insn (gdbarch, print_insn_h8300h);
+       {
+         set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
+         set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
+       }
+      set_gdbarch_return_value (gdbarch, h8300h_return_value);

       break;
     case bfd_mach_h8300s:
     case bfd_mach_h8300sn:
       set_gdbarch_num_regs (gdbarch, 16);
       set_gdbarch_num_pseudo_regs (gdbarch, 2);
       break;
     case bfd_mach_h8300s:
     case bfd_mach_h8300sn:
       set_gdbarch_num_regs (gdbarch, 16);
       set_gdbarch_num_pseudo_regs (gdbarch, 2);

-      set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
-      set_gdbarch_dwarf_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);

       set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
       set_gdbarch_stab_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
       set_gdbarch_register_name (gdbarch, h8300s_register_name);
       set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
       set_gdbarch_stab_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
       set_gdbarch_register_name (gdbarch, h8300s_register_name);

-      if(info.bfd_arch_info->mach != bfd_mach_h8300sn)
-        {
-          set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
-          set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
-        }
+      if (info.bfd_arch_info->mach != bfd_mach_h8300sn)
+       {
+         set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
+         set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
+       }

       else
       else

-        {
-          set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
-          set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
-        }
-      set_gdbarch_extract_return_value (gdbarch, h8300h_extract_return_value);
-      set_gdbarch_store_return_value (gdbarch, h8300h_store_return_value);
-      set_gdbarch_print_insn (gdbarch, print_insn_h8300s);
+       {
+         set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
+         set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
+       }
+      set_gdbarch_return_value (gdbarch, h8300h_return_value);

       break;
     case bfd_mach_h8300sx:
     case bfd_mach_h8300sxn:
       set_gdbarch_num_regs (gdbarch, 18);
       set_gdbarch_num_pseudo_regs (gdbarch, 2);
       break;
     case bfd_mach_h8300sx:
     case bfd_mach_h8300sxn:
       set_gdbarch_num_regs (gdbarch, 18);
       set_gdbarch_num_pseudo_regs (gdbarch, 2);

-      set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
-      set_gdbarch_dwarf_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);

       set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
       set_gdbarch_stab_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
       set_gdbarch_register_name (gdbarch, h8300sx_register_name);
       set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
       set_gdbarch_stab_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
       set_gdbarch_register_name (gdbarch, h8300sx_register_name);

-      if(info.bfd_arch_info->mach != bfd_mach_h8300sxn)
-        {
-          set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
-          set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
-        }
+      if (info.bfd_arch_info->mach != bfd_mach_h8300sxn)
+       {
+         set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
+         set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
+       }

       else
       else

-        {
-          set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
-          set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
-        }
-      set_gdbarch_extract_return_value (gdbarch, h8300h_extract_return_value);
-      set_gdbarch_store_return_value (gdbarch, h8300h_store_return_value);
-      set_gdbarch_print_insn (gdbarch, print_insn_h8300s);
+       {
+         set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
+         set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
+       }
+      set_gdbarch_return_value (gdbarch, h8300h_return_value);

       break;
     }
 
   set_gdbarch_pseudo_register_read (gdbarch, h8300_pseudo_register_read);
   set_gdbarch_pseudo_register_write (gdbarch, h8300_pseudo_register_write);
 
       break;
     }
 
   set_gdbarch_pseudo_register_read (gdbarch, h8300_pseudo_register_read);
   set_gdbarch_pseudo_register_write (gdbarch, h8300_pseudo_register_write);
 

-  /* 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, deprecated_init_frame_pc_default);
-

   /*
    * Basic register fields and methods.
    */
 
   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
   /*
    * Basic register fields and methods.
    */
 
   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);

-  set_gdbarch_deprecated_fp_regnum (gdbarch, E_FP_REGNUM);

   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
   set_gdbarch_register_type (gdbarch, h8300_register_type);
   set_gdbarch_print_registers_info (gdbarch, h8300_print_registers_info);
   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
   set_gdbarch_register_type (gdbarch, h8300_register_type);
   set_gdbarch_print_registers_info (gdbarch, h8300_print_registers_info);

-  set_gdbarch_print_float_info (gdbarch, h8300_print_float_info);

 
   /*
    * Frame Info
    */
   set_gdbarch_skip_prologue (gdbarch, h8300_skip_prologue);
 
 
   /*
    * Frame Info
    */
   set_gdbarch_skip_prologue (gdbarch, h8300_skip_prologue);
 

-  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_deprecated_pop_frame (gdbarch, h8300_pop_frame);
+  /* Frame unwinder.  */
+  frame_base_set_default (gdbarch, &h8300_frame_base);

 
   /* 
 
   /* 

-   * Miscelany
+   * Miscellany

    */
    */

-  /* Stack grows up. */
+  /* Stack grows up.  */

   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);

-  /* This value is almost never non-zero... */
-  set_gdbarch_frame_args_skip (gdbarch, 0);
-  set_gdbarch_frameless_function_invocation (gdbarch,
-                                            frameless_look_for_prologue);
-
-  set_gdbarch_extract_struct_value_address (gdbarch,
-                                           h8300_extract_struct_value_address);
-  set_gdbarch_use_struct_convention (gdbarch, always_use_struct_convention);
-  set_gdbarch_breakpoint_from_pc (gdbarch, h8300_breakpoint_from_pc);
-  set_gdbarch_push_dummy_code (gdbarch, h8300_push_dummy_code);
+
+  set_gdbarch_breakpoint_kind_from_pc (gdbarch,
+                                      h8300_breakpoint::kind_from_pc);
+  set_gdbarch_sw_breakpoint_from_kind (gdbarch,
+                                      h8300_breakpoint::bp_from_kind);

   set_gdbarch_push_dummy_call (gdbarch, h8300_push_dummy_call);
 
   set_gdbarch_push_dummy_call (gdbarch, h8300_push_dummy_call);
 

+  set_gdbarch_char_signed (gdbarch, 0);

   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);

+
+  set_gdbarch_wchar_bit (gdbarch, 2 * TARGET_CHAR_BIT);
+  set_gdbarch_wchar_signed (gdbarch, 0);
+

   set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
   set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);

+  set_gdbarch_double_format (gdbarch, floatformats_ieee_single);

   set_gdbarch_long_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
   set_gdbarch_long_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);

+  set_gdbarch_long_double_format (gdbarch, floatformats_ieee_single);

 
   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
 
 
   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
 

-  /* Char is unsigned.  */
-  set_gdbarch_char_signed (gdbarch, 0);
+  /* Hook in the DWARF CFI frame unwinder.  */
+  dwarf2_append_unwinders (gdbarch);
+  frame_unwind_append_unwinder (gdbarch, &h8300_frame_unwind);

 
   return gdbarch;
 
   return gdbarch;

-}

 
 

-extern initialize_file_ftype _initialize_h8300_tdep; /* -Wmissing-prototypes */
+}

 
 

+void _initialize_h8300_tdep ();

 void
 void

-_initialize_h8300_tdep (void)
+_initialize_h8300_tdep ()

 {
   register_gdbarch_init (bfd_arch_h8300, h8300_gdbarch_init);
 }
 {
   register_gdbarch_init (bfd_arch_h8300, h8300_gdbarch_init);
 }


@@ -1361,34 +1389,33 @@ static int
 is_h8300hmode (struct gdbarch *gdbarch)
 {
   return gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sx
 is_h8300hmode (struct gdbarch *gdbarch)
 {
   return gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sx

-        || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sxn
-        || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300s
-        || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sn
-        || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300h
-        || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300hn;
+    || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sxn
+    || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300s
+    || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sn
+    || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300h
+    || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300hn;

 }
 
 static int
 is_h8300smode (struct gdbarch *gdbarch)
 {
   return gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sx
 }
 
 static int
 is_h8300smode (struct gdbarch *gdbarch)
 {
   return gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sx

-        || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sxn
-        || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300s
-        || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sn;
+    || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sxn
+    || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300s
+    || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sn;

 }
 
 static int
 is_h8300sxmode (struct gdbarch *gdbarch)
 {
   return gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sx
 }
 
 static int
 is_h8300sxmode (struct gdbarch *gdbarch)
 {
   return gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sx

-        || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sxn;
+    || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sxn;

 }
 
 static int
 is_h8300_normal_mode (struct gdbarch *gdbarch)
 {
   return gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sxn
 }
 
 static int
 is_h8300_normal_mode (struct gdbarch *gdbarch)
 {
   return gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sxn

-        || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sn
-        || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300hn;
+    || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sn
+    || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300hn;

 }
 }

-