gdb: add target_ops::supports_displaced_step

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

diff --git a/gdb/mep-tdep.c b/gdb/mep-tdep.c
index b6038cc48327291d77770708cf176182242c4017..7e8247cd6427fba650cc1b4040f093f47e4fc42d 100644 (file)
--- a/gdb/mep-tdep.c
+++ b/gdb/mep-tdep.c
@@ -1,7 +1,6 @@
 /* Target-dependent code for the Toshiba MeP for GDB, the GNU debugger.
 
 /* Target-dependent code for the Toshiba MeP for GDB, the GNU debugger.
 

-   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
-   Free Software Foundation, Inc.
+   Copyright (C) 2001-2020 Free Software Foundation, Inc.

 
    Contributed by Red Hat, Inc.
 
 
    Contributed by Red Hat, Inc.
 


@@ -28,7 +27,6 @@
 #include "gdbtypes.h"
 #include "gdbcmd.h"
 #include "gdbcore.h"
 #include "gdbtypes.h"
 #include "gdbcmd.h"
 #include "gdbcore.h"

-#include "gdb_string.h"

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


@@ -38,7 +36,6 @@
 #include "arch-utils.h"
 #include "regcache.h"
 #include "remote.h"
 #include "arch-utils.h"
 #include "regcache.h"
 #include "remote.h"

-#include "floatformat.h"

 #include "sim-regno.h"
 #include "disasm.h"
 #include "trad-frame.h"
 #include "sim-regno.h"
 #include "disasm.h"
 #include "trad-frame.h"


@@ -46,11 +43,9 @@
 #include "elf-bfd.h"
 #include "elf/mep.h"
 #include "prologue-value.h"
 #include "elf-bfd.h"
 #include "elf/mep.h"
 #include "prologue-value.h"

-#include "opcode/cgen-bitset.h"
+#include "cgen/bitset.h"

 #include "infcall.h"
 
 #include "infcall.h"
 

-#include "gdb_assert.h"
-

 /* Get the user's customized MeP coprocessor register names from
    libopcodes.  */
 #include "opcodes/mep-desc.h"
 /* Get the user's customized MeP coprocessor register names from
    libopcodes.  */
 #include "opcodes/mep-desc.h"


@@ -264,7 +259,7 @@ me_module_register_set (CONFIG_ATTR me_module,
        mask contains any of the me_module's coprocessor ISAs,
        specifically excluding the generic coprocessor register sets.  */
 
        mask contains any of the me_module's coprocessor ISAs,
        specifically excluding the generic coprocessor register sets.  */
 

-  CGEN_CPU_DESC desc = gdbarch_tdep (current_gdbarch)->cpu_desc;
+  CGEN_CPU_DESC desc = gdbarch_tdep (target_gdbarch ())->cpu_desc;

   const CGEN_HW_ENTRY *hw;
 
   if (me_module == CONFIG_NONE)
   const CGEN_HW_ENTRY *hw;
 
   if (me_module == CONFIG_NONE)


@@ -289,7 +284,7 @@ me_module_register_set (CONFIG_ATTR me_module,
 
 /* Given a hardware table entry HW representing a register set, return
    a pointer to the keyword table with all the register names.  If HW
 
 /* Given a hardware table entry HW representing a register set, return
    a pointer to the keyword table with all the register names.  If HW

-   is NULL, return NULL, to propage the "no such register set" info
+   is NULL, return NULL, to propagate the "no such register set" info

    along.  */
 static CGEN_KEYWORD *
 register_set_keyword_table (const CGEN_HW_ENTRY *hw)
    along.  */
 static CGEN_KEYWORD *
 register_set_keyword_table (const CGEN_HW_ENTRY *hw)


@@ -309,7 +304,7 @@ register_set_keyword_table (const CGEN_HW_ENTRY *hw)
 /* Given a keyword table KEYWORD and a register number REGNUM, return
    the name of the register, or "" if KEYWORD contains no register
    whose number is REGNUM.  */
 /* Given a keyword table KEYWORD and a register number REGNUM, return
    the name of the register, or "" if KEYWORD contains no register
    whose number is REGNUM.  */

-static char *
+static const char *

 register_name_from_keyword (CGEN_KEYWORD *keyword_table, int regnum)
 {
   const CGEN_KEYWORD_ENTRY *entry
 register_name_from_keyword (CGEN_KEYWORD *keyword_table, int regnum)
 {
   const CGEN_KEYWORD_ENTRY *entry


@@ -785,10 +780,12 @@ mep_init_pseudoregister_maps (void)
 
 
 static int
 
 
 static int

-mep_debug_reg_to_regnum (int debug_reg)
+mep_debug_reg_to_regnum (struct gdbarch *gdbarch, int debug_reg)

 {
   /* The debug info uses the raw register numbers.  */
 {
   /* The debug info uses the raw register numbers.  */

-  return mep_raw_to_pseudo[debug_reg];
+  if (debug_reg >= 0 && debug_reg < ARRAY_SIZE (mep_raw_to_pseudo))
+    return mep_raw_to_pseudo[debug_reg];
+  return -1;

 }
 
 
 }
 
 


@@ -804,7 +801,7 @@ mep_pseudo_cr_size (int pseudo)
            || IS_FP_CR64_REGNUM (pseudo))
     return 64;
   else
            || IS_FP_CR64_REGNUM (pseudo))
     return 64;
   else

-    gdb_assert (0);
+    gdb_assert_not_reached ("unexpected coprocessor pseudo register");

 }
 
 
 }
 
 


@@ -833,7 +830,7 @@ mep_pseudo_cr_index (int pseudo)
   else if (IS_FP_CR64_REGNUM (pseudo))
       return pseudo - MEP_FIRST_FP_CR64_REGNUM;
   else
   else if (IS_FP_CR64_REGNUM (pseudo))
       return pseudo - MEP_FIRST_FP_CR64_REGNUM;
   else

-    gdb_assert (0);
+    gdb_assert_not_reached ("unexpected coprocessor pseudo register");

 }
 
 
 }
 
 


@@ -845,17 +842,17 @@ mep_pseudo_cr_index (int pseudo)
    from the ELF header's e_flags field of the current executable
    file.  */
 static CONFIG_ATTR
    from the ELF header's e_flags field of the current executable
    file.  */
 static CONFIG_ATTR

-current_me_module ()
+current_me_module (void)

 {
   if (target_has_registers)
     {
       ULONGEST regval;
       regcache_cooked_read_unsigned (get_current_regcache (),
                                     MEP_MODULE_REGNUM, &regval);
 {
   if (target_has_registers)
     {
       ULONGEST regval;
       regcache_cooked_read_unsigned (get_current_regcache (),
                                     MEP_MODULE_REGNUM, &regval);

-      return regval;
+      return (CONFIG_ATTR) regval;

     }
   else
     }
   else

-    return gdbarch_tdep (current_gdbarch)->me_module;
+    return gdbarch_tdep (target_gdbarch ())->me_module;

 }
 
 
 }
 
 


@@ -868,7 +865,7 @@ current_me_module ()
    then use the 'module_opt' field we computed when we build the
    gdbarch object for this module.  */
 static unsigned int
    then use the 'module_opt' field we computed when we build the
    gdbarch object for this module.  */
 static unsigned int

-current_options ()
+current_options (void)

 {
   if (target_has_registers)
     {
 {
   if (target_has_registers)
     {


@@ -885,7 +882,7 @@ current_options ()
 /* Return the width of the current me_module's coprocessor data bus,
    in bits.  This is either 32 or 64.  */
 static int
 /* Return the width of the current me_module's coprocessor data bus,
    in bits.  This is either 32 or 64.  */
 static int

-current_cop_data_bus_width ()
+current_cop_data_bus_width (void)

 {
   return me_module_cop_data_bus_width (current_me_module ());
 }
 {
   return me_module_cop_data_bus_width (current_me_module ());
 }


@@ -894,7 +891,7 @@ current_cop_data_bus_width ()
 /* Return the keyword table of coprocessor general-purpose register
    names appropriate for the me_module we're dealing with.  */
 static CGEN_KEYWORD *
 /* Return the keyword table of coprocessor general-purpose register
    names appropriate for the me_module we're dealing with.  */
 static CGEN_KEYWORD *

-current_cr_names ()
+current_cr_names (void)

 {
   const CGEN_HW_ENTRY *hw
     = me_module_register_set (current_me_module (), "h-cr-", HW_H_CR);
 {
   const CGEN_HW_ENTRY *hw
     = me_module_register_set (current_me_module (), "h-cr-", HW_H_CR);


@@ -906,7 +903,7 @@ current_cr_names ()
 /* Return non-zero if the coprocessor general-purpose registers are
    floating-point values, zero otherwise.  */
 static int
 /* Return non-zero if the coprocessor general-purpose registers are
    floating-point values, zero otherwise.  */
 static int

-current_cr_is_float ()
+current_cr_is_float (void)

 {
   const CGEN_HW_ENTRY *hw
     = me_module_register_set (current_me_module (), "h-cr-", HW_H_CR);
 {
   const CGEN_HW_ENTRY *hw
     = me_module_register_set (current_me_module (), "h-cr-", HW_H_CR);


@@ -918,7 +915,7 @@ current_cr_is_float ()
 /* Return the keyword table of coprocessor control register names
    appropriate for the me_module we're dealing with.  */
 static CGEN_KEYWORD *
 /* Return the keyword table of coprocessor control register names
    appropriate for the me_module we're dealing with.  */
 static CGEN_KEYWORD *

-current_ccr_names ()
+current_ccr_names (void)

 {
   const CGEN_HW_ENTRY *hw
     = me_module_register_set (current_me_module (), "h-ccr-", HW_H_CCR);
 {
   const CGEN_HW_ENTRY *hw
     = me_module_register_set (current_me_module (), "h-ccr-", HW_H_CCR);


@@ -930,8 +927,6 @@ current_ccr_names ()
 static const char *
 mep_register_name (struct gdbarch *gdbarch, int regnr)
 {
 static const char *
 mep_register_name (struct gdbarch *gdbarch, int regnr)
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);  
-

   /* General-purpose registers.  */
   static const char *gpr_names[] = {
     "r0",   "r1",   "r2",   "r3",   /* 0 */
   /* General-purpose registers.  */
   static const char *gpr_names[] = {
     "r0",   "r1",   "r2",   "r3",   /* 0 */


@@ -1084,7 +1079,7 @@ mep_register_type (struct gdbarch *gdbarch, int reg_nr)
      keep the 'g' packet format fixed), and the pseudoregisters vary
      in length.  */
   if (IS_RAW_CR_REGNUM (reg_nr))
      keep the 'g' packet format fixed), and the pseudoregisters vary
      in length.  */
   if (IS_RAW_CR_REGNUM (reg_nr))

-    return builtin_type_uint64;
+    return builtin_type (gdbarch)->builtin_uint64;

 
   /* Since GDB doesn't allow registers to change type, we have two
      banks of pseudoregisters for the coprocessor general-purpose
 
   /* Since GDB doesn't allow registers to change type, we have two
      banks of pseudoregisters for the coprocessor general-purpose


@@ -1097,88 +1092,79 @@ mep_register_type (struct gdbarch *gdbarch, int reg_nr)
       if (size == 32)
         {
           if (mep_pseudo_cr_is_float (reg_nr))
       if (size == 32)
         {
           if (mep_pseudo_cr_is_float (reg_nr))

-            return builtin_type_float;
+            return builtin_type (gdbarch)->builtin_float;

           else
           else

-            return builtin_type_uint32;
+            return builtin_type (gdbarch)->builtin_uint32;

         }
       else if (size == 64)
         {
           if (mep_pseudo_cr_is_float (reg_nr))
         }
       else if (size == 64)
         {
           if (mep_pseudo_cr_is_float (reg_nr))

-            return builtin_type_double;
+            return builtin_type (gdbarch)->builtin_double;

           else
           else

-            return builtin_type_uint64;
+            return builtin_type (gdbarch)->builtin_uint64;

         }
       else
         }
       else

-        gdb_assert (0);
+        gdb_assert_not_reached ("unexpected cr size");

     }
 
   /* All other registers are 32 bits long.  */
   else
     }
 
   /* All other registers are 32 bits long.  */
   else

-    return builtin_type_uint32;
-}
-
-
-static CORE_ADDR
-mep_read_pc (struct regcache *regcache)
-{
-  ULONGEST pc;
-  regcache_cooked_read_unsigned (regcache, MEP_PC_REGNUM, &pc);
-  return pc;
-}
-
-static void
-mep_write_pc (struct regcache *regcache, CORE_ADDR pc)
-{
-  regcache_cooked_write_unsigned (regcache, MEP_PC_REGNUM, pc);
+    return builtin_type (gdbarch)->builtin_uint32;

 }
 
 }
 

-
-static void
+static enum register_status

 mep_pseudo_cr32_read (struct gdbarch *gdbarch,
 mep_pseudo_cr32_read (struct gdbarch *gdbarch,

-                      struct regcache *regcache,
+                     readable_regcache *regcache,

                       int cookednum,
                       int cookednum,

-                      void *buf)
+                      gdb_byte *buf)

 {
 {

+  enum register_status status;
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   /* Read the raw register into a 64-bit buffer, and then return the
      appropriate end of that buffer.  */
   int rawnum = mep_pseudo_to_raw[cookednum];
   /* Read the raw register into a 64-bit buffer, and then return the
      appropriate end of that buffer.  */
   int rawnum = mep_pseudo_to_raw[cookednum];

-  char buf64[8];
+  gdb_byte buf64[8];

 
   gdb_assert (TYPE_LENGTH (register_type (gdbarch, rawnum)) == sizeof (buf64));
   gdb_assert (TYPE_LENGTH (register_type (gdbarch, cookednum)) == 4);
 
   gdb_assert (TYPE_LENGTH (register_type (gdbarch, rawnum)) == sizeof (buf64));
   gdb_assert (TYPE_LENGTH (register_type (gdbarch, cookednum)) == 4);

-  regcache_raw_read (regcache, rawnum, buf64);
-  /* Slow, but legible.  */
-  store_unsigned_integer (buf, 4, extract_unsigned_integer (buf64, 8));
+  status = regcache->raw_read (rawnum, buf64);
+  if (status == REG_VALID)
+    {
+      /* Slow, but legible.  */
+      store_unsigned_integer (buf, 4, byte_order,
+                             extract_unsigned_integer (buf64, 8, byte_order));
+    }
+  return status;

 }
 
 
 }
 
 

-static void
+static enum register_status

 mep_pseudo_cr64_read (struct gdbarch *gdbarch,
 mep_pseudo_cr64_read (struct gdbarch *gdbarch,

-                      struct regcache *regcache,
+                      readable_regcache *regcache,

                       int cookednum,
                       int cookednum,

-                      void *buf)
+                      gdb_byte *buf)

 {
 {

-  regcache_raw_read (regcache, mep_pseudo_to_raw[cookednum], buf);
+  return regcache->raw_read (mep_pseudo_to_raw[cookednum], buf);

 }
 
 
 }
 
 

-static void
+static enum register_status

 mep_pseudo_register_read (struct gdbarch *gdbarch,
 mep_pseudo_register_read (struct gdbarch *gdbarch,

-                          struct regcache *regcache,
+                         readable_regcache *regcache,

                           int cookednum,
                           gdb_byte *buf)
 {
   if (IS_CSR_REGNUM (cookednum)
       || IS_CCR_REGNUM (cookednum))
                           int cookednum,
                           gdb_byte *buf)
 {
   if (IS_CSR_REGNUM (cookednum)
       || IS_CCR_REGNUM (cookednum))

-    regcache_raw_read (regcache, mep_pseudo_to_raw[cookednum], buf);
+    return regcache->raw_read (mep_pseudo_to_raw[cookednum], buf);

   else if (IS_CR32_REGNUM (cookednum)
            || IS_FP_CR32_REGNUM (cookednum))
   else if (IS_CR32_REGNUM (cookednum)
            || IS_FP_CR32_REGNUM (cookednum))

-    mep_pseudo_cr32_read (gdbarch, regcache, cookednum, buf);
+    return mep_pseudo_cr32_read (gdbarch, regcache, cookednum, buf);

   else if (IS_CR64_REGNUM (cookednum)
            || IS_FP_CR64_REGNUM (cookednum))
   else if (IS_CR64_REGNUM (cookednum)
            || IS_FP_CR64_REGNUM (cookednum))

-    mep_pseudo_cr64_read (gdbarch, regcache, cookednum, buf);
+    return mep_pseudo_cr64_read (gdbarch, regcache, cookednum, buf);

   else
   else

-    gdb_assert (0);
+    gdb_assert_not_reached ("unexpected pseudo register");

 }
 
 
 }
 
 


@@ -1186,8 +1172,9 @@ static void
 mep_pseudo_csr_write (struct gdbarch *gdbarch,
                       struct regcache *regcache,
                       int cookednum,
 mep_pseudo_csr_write (struct gdbarch *gdbarch,
                       struct regcache *regcache,
                       int cookednum,

-                      const void *buf)
+                      const gdb_byte *buf)

 {
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   int size = register_size (gdbarch, cookednum);
   struct mep_csr_register *r
     = &mep_csr_registers[cookednum - MEP_FIRST_CSR_REGNUM];
   int size = register_size (gdbarch, cookednum);
   struct mep_csr_register *r
     = &mep_csr_registers[cookednum - MEP_FIRST_CSR_REGNUM];


@@ -1204,7 +1191,7 @@ mep_pseudo_csr_write (struct gdbarch *gdbarch,
       ULONGEST mixed_bits;
           
       regcache_raw_read_unsigned (regcache, r->raw, &old_bits);
       ULONGEST mixed_bits;
           
       regcache_raw_read_unsigned (regcache, r->raw, &old_bits);

-      new_bits = extract_unsigned_integer (buf, size);
+      new_bits = extract_unsigned_integer (buf, size, byte_order);

       mixed_bits = ((r->writeable_bits & new_bits)
                     | (~r->writeable_bits & old_bits));
       regcache_raw_write_unsigned (regcache, r->raw, mixed_bits);
       mixed_bits = ((r->writeable_bits & new_bits)
                     | (~r->writeable_bits & old_bits));
       regcache_raw_write_unsigned (regcache, r->raw, mixed_bits);


@@ -1216,18 +1203,20 @@ static void
 mep_pseudo_cr32_write (struct gdbarch *gdbarch,
                        struct regcache *regcache,
                        int cookednum,
 mep_pseudo_cr32_write (struct gdbarch *gdbarch,
                        struct regcache *regcache,
                        int cookednum,

-                       const void *buf)
+                       const gdb_byte *buf)

 {
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   /* Expand the 32-bit value into a 64-bit value, and write that to
      the pseudoregister.  */
   int rawnum = mep_pseudo_to_raw[cookednum];
   /* Expand the 32-bit value into a 64-bit value, and write that to
      the pseudoregister.  */
   int rawnum = mep_pseudo_to_raw[cookednum];

-  char buf64[8];
+  gdb_byte buf64[8];

   
   gdb_assert (TYPE_LENGTH (register_type (gdbarch, rawnum)) == sizeof (buf64));
   gdb_assert (TYPE_LENGTH (register_type (gdbarch, cookednum)) == 4);
   /* Slow, but legible.  */
   
   gdb_assert (TYPE_LENGTH (register_type (gdbarch, rawnum)) == sizeof (buf64));
   gdb_assert (TYPE_LENGTH (register_type (gdbarch, cookednum)) == 4);
   /* Slow, but legible.  */

-  store_unsigned_integer (buf64, 8, extract_unsigned_integer (buf, 4));
-  regcache_raw_write (regcache, rawnum, buf64);
+  store_unsigned_integer (buf64, 8, byte_order,
+                         extract_unsigned_integer (buf, 4, byte_order));
+  regcache->raw_write (rawnum, buf64);

 }
 
 
 }
 
 


@@ -1235,9 +1224,9 @@ static void
 mep_pseudo_cr64_write (struct gdbarch *gdbarch,
                      struct regcache *regcache,
                      int cookednum,
 mep_pseudo_cr64_write (struct gdbarch *gdbarch,
                      struct regcache *regcache,
                      int cookednum,

-                     const void *buf)
+                     const gdb_byte *buf)

 {
 {

-  regcache_raw_write (regcache, mep_pseudo_to_raw[cookednum], buf);
+  regcache->raw_write (mep_pseudo_to_raw[cookednum], buf);

 }
 
 
 }
 
 


@@ -1256,22 +1245,21 @@ mep_pseudo_register_write (struct gdbarch *gdbarch,
            || IS_FP_CR64_REGNUM (cookednum))
     mep_pseudo_cr64_write (gdbarch, regcache, cookednum, buf);
   else if (IS_CCR_REGNUM (cookednum))
            || IS_FP_CR64_REGNUM (cookednum))
     mep_pseudo_cr64_write (gdbarch, regcache, cookednum, buf);
   else if (IS_CCR_REGNUM (cookednum))

-    regcache_raw_write (regcache, mep_pseudo_to_raw[cookednum], buf);
+    regcache->raw_write (mep_pseudo_to_raw[cookednum], buf);

   else
   else

-    gdb_assert (0);
+    gdb_assert_not_reached ("unexpected pseudo register");

 }
 
 
 \f
 /* Disassembly.  */
 
 }
 
 
 \f
 /* Disassembly.  */
 

-/* The mep disassembler needs to know about the section in order to
-   work correctly. */
-int 
+static int

 mep_gdb_print_insn (bfd_vma pc, disassemble_info * info)
 {
   struct obj_section * s = find_pc_section (pc);
 
 mep_gdb_print_insn (bfd_vma pc, disassemble_info * info)
 {
   struct obj_section * s = find_pc_section (pc);
 

+  info->arch = bfd_arch_mep;

   if (s)
     {
       /* The libopcodes disassembly code uses the section to find the
   if (s)
     {
       /* The libopcodes disassembly code uses the section to find the


@@ -1279,12 +1267,9 @@ mep_gdb_print_insn (bfd_vma pc, disassemble_info * info)
          the me_module index, and the me_module index to select the
          right instructions to print.  */
       info->section = s->the_bfd_section;
          the me_module index, and the me_module index to select the
          right instructions to print.  */
       info->section = s->the_bfd_section;

-      info->arch = bfd_arch_mep;
-       
-      return print_insn_mep (pc, info);

     }
     }

-  
-  return 0;
+
+  return print_insn_mep (pc, info);

 }
 
 \f
 }
 
 \f


@@ -1320,7 +1305,7 @@ mep_gdb_print_insn (bfd_vma pc, disassemble_info * info)
      Every bundle is four bytes long, and naturally aligned, and can hold
      one or two instructions:
      - 16-bit core instruction; 16-bit coprocessor instruction
      Every bundle is four bytes long, and naturally aligned, and can hold
      one or two instructions:
      - 16-bit core instruction; 16-bit coprocessor instruction

-       These execute in parallel.       
+       These execute in parallel.

      - 32-bit core instruction
      - 32-bit coprocessor instruction
 
      - 32-bit core instruction
      - 32-bit coprocessor instruction
 


@@ -1328,9 +1313,9 @@ mep_gdb_print_insn (bfd_vma pc, disassemble_info * info)
      Every bundle is eight bytes long, and naturally aligned, and can hold
      one or two instructions:
      - 16-bit core instruction; 48-bit (!) coprocessor instruction
      Every bundle is eight bytes long, and naturally aligned, and can hold
      one or two instructions:
      - 16-bit core instruction; 48-bit (!) coprocessor instruction

-       These execute in parallel.       
+       These execute in parallel.

      - 32-bit core instruction; 32-bit coprocessor instruction
      - 32-bit core instruction; 32-bit coprocessor instruction

-       These execute in parallel.       
+       These execute in parallel.

      - 64-bit coprocessor instruction
 
    Now, the MeP manual doesn't define any 48- or 64-bit coprocessor
      - 64-bit coprocessor instruction
 
    Now, the MeP manual doesn't define any 48- or 64-bit coprocessor


@@ -1415,12 +1400,13 @@ mep_pc_in_vliw_section (CORE_ADDR pc)
    anyway.  */
 
 static CORE_ADDR 
    anyway.  */
 
 static CORE_ADDR 

-mep_get_insn (CORE_ADDR pc, long *insn)
+mep_get_insn (struct gdbarch *gdbarch, CORE_ADDR pc, unsigned long *insn)

 {
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   int pc_in_vliw_section;
   int vliw_mode;
   int insn_len;
   int pc_in_vliw_section;
   int vliw_mode;
   int insn_len;

-  char buf[2];
+  gdb_byte buf[2];

 
   *insn = 0;
 
 
   *insn = 0;
 


@@ -1453,7 +1439,7 @@ mep_get_insn (CORE_ADDR pc, long *insn)
     vliw_mode = 0;
 
   read_memory (pc, buf, sizeof (buf));
     vliw_mode = 0;
 
   read_memory (pc, buf, sizeof (buf));

-  *insn = extract_unsigned_integer (buf, 2) << 16;
+  *insn = extract_unsigned_integer (buf, 2, byte_order) << 16;

 
   /* The major opcode --- the top four bits of the first 16-bit
      part --- indicates whether this instruction is 16 or 32 bits
 
   /* The major opcode --- the top four bits of the first 16-bit
      part --- indicates whether this instruction is 16 or 32 bits


@@ -1463,7 +1449,7 @@ mep_get_insn (CORE_ADDR pc, long *insn)
     {
       /* Fetch the second 16-bit part of the instruction.  */
       read_memory (pc + 2, buf, sizeof (buf));
     {
       /* Fetch the second 16-bit part of the instruction.  */
       read_memory (pc + 2, buf, sizeof (buf));

-      *insn = *insn | extract_unsigned_integer (buf, 2);
+      *insn = *insn | extract_unsigned_integer (buf, 2, byte_order);

     }
 
   /* If we're in VLIW code, then the VLIW width determines the address
     }
 
   /* If we're in VLIW code, then the VLIW width determines the address


@@ -1482,7 +1468,7 @@ mep_get_insn (CORE_ADDR pc, long *insn)
 
       /* We'd better be in either core, 32-bit VLIW, or 64-bit VLIW mode.  */
       else
 
       /* We'd better be in either core, 32-bit VLIW, or 64-bit VLIW mode.  */
       else

-        gdb_assert (0);
+        gdb_assert_not_reached ("unexpected vliw mode");

     }
   
   /* Otherwise, the top two bits of the major opcode are (again) what
     }
   
   /* Otherwise, the top two bits of the major opcode are (again) what


@@ -1584,6 +1570,9 @@ mep_get_insn (CORE_ADDR pc, long *insn)
 /* This structure holds the results of a prologue analysis.  */
 struct mep_prologue
 {
 /* This structure holds the results of a prologue analysis.  */
 struct mep_prologue
 {

+  /* The architecture for which we generated this prologue info.  */
+  struct gdbarch *gdbarch;
+

   /* The offset from the frame base to the stack pointer --- always
      zero or negative.
 
   /* The offset from the frame base to the stack pointer --- always
      zero or negative.
 


@@ -1635,16 +1624,17 @@ is_arg_reg (pv_t value)
    - ADDR is a stack slot's address (e.g., relative to the original
      value of the SP).  */
 static int
    - ADDR is a stack slot's address (e.g., relative to the original
      value of the SP).  */
 static int

-is_arg_spill (pv_t value, pv_t addr, struct pv_area *stack)
+is_arg_spill (struct gdbarch *gdbarch, pv_t value, pv_t addr,
+             struct pv_area *stack)

 {
   return (is_arg_reg (value)
           && pv_is_register (addr, MEP_SP_REGNUM)
 {
   return (is_arg_reg (value)
           && pv_is_register (addr, MEP_SP_REGNUM)

-          && ! pv_area_find_reg (stack, current_gdbarch, value.reg, 0));
+          && ! stack->find_reg (gdbarch, value.reg, 0));

 }
 
 
 /* Function for finding saved registers in a 'struct pv_area'; we pass
 }
 
 
 /* Function for finding saved registers in a 'struct pv_area'; we pass

-   this to pv_area_scan.
+   this to pv_area::scan.

 
    If VALUE is a saved register, ADDR says it was saved at a constant
    offset from the frame base, and SIZE indicates that the whole
 
    If VALUE is a saved register, ADDR says it was saved at a constant
    offset from the frame base, and SIZE indicates that the whole


@@ -1657,7 +1647,7 @@ check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size, pv_t value)
   if (value.kind == pvk_register
       && value.k == 0
       && pv_is_register (addr, MEP_SP_REGNUM)
   if (value.kind == pvk_register
       && value.k == 0
       && pv_is_register (addr, MEP_SP_REGNUM)

-      && size == register_size (current_gdbarch, value.reg))
+      && size == register_size (result->gdbarch, value.reg))

     result->reg_offset[value.reg] = addr.k;
 }
 
     result->reg_offset[value.reg] = addr.k;
 }
 


@@ -1665,28 +1655,25 @@ check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size, pv_t value)
 /* Analyze a prologue starting at START_PC, going no further than
    LIMIT_PC.  Fill in RESULT as appropriate.  */
 static void
 /* Analyze a prologue starting at START_PC, going no further than
    LIMIT_PC.  Fill in RESULT as appropriate.  */
 static void

-mep_analyze_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
+mep_analyze_prologue (struct gdbarch *gdbarch,
+                     CORE_ADDR start_pc, CORE_ADDR limit_pc,

                       struct mep_prologue *result)
 {
   CORE_ADDR pc;
   unsigned long insn;
                       struct mep_prologue *result)
 {
   CORE_ADDR pc;
   unsigned long insn;

-  int rn;
-  int found_lp = 0;

   pv_t reg[MEP_NUM_REGS];
   pv_t reg[MEP_NUM_REGS];

-  struct pv_area *stack;
-  struct cleanup *back_to;

   CORE_ADDR after_last_frame_setup_insn = start_pc;
 
   memset (result, 0, sizeof (*result));
   CORE_ADDR after_last_frame_setup_insn = start_pc;
 
   memset (result, 0, sizeof (*result));

+  result->gdbarch = gdbarch;

 
 

-  for (rn = 0; rn < MEP_NUM_REGS; rn++)
+  for (int rn = 0; rn < MEP_NUM_REGS; rn++)

     {
       reg[rn] = pv_register (rn, 0);
       result->reg_offset[rn] = 1;
     }
 
     {
       reg[rn] = pv_register (rn, 0);
       result->reg_offset[rn] = 1;
     }
 

-  stack = make_pv_area (MEP_SP_REGNUM);
-  back_to = make_cleanup_free_pv_area (stack);
+  pv_area stack (MEP_SP_REGNUM, gdbarch_addr_bit (gdbarch));

 
   pc = start_pc;
   while (pc < limit_pc)
 
   pc = start_pc;
   while (pc < limit_pc)


@@ -1694,7 +1681,7 @@ mep_analyze_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
       CORE_ADDR next_pc;
       pv_t pre_insn_fp, pre_insn_sp;
 
       CORE_ADDR next_pc;
       pv_t pre_insn_fp, pre_insn_sp;
 

-      next_pc = mep_get_insn (pc, &insn);
+      next_pc = mep_get_insn (gdbarch, pc, &insn);

 
       /* A zero return from mep_get_insn means that either we weren't
          able to read the instruction from memory, or that we don't
 
       /* A zero return from mep_get_insn means that either we weren't
          able to read the instruction from memory, or that we don't


@@ -1738,13 +1725,13 @@ mep_analyze_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
           /* If simulating this store would require us to forget
              everything we know about the stack frame in the name of
              accuracy, it would be better to just quit now.  */
           /* If simulating this store would require us to forget
              everything we know about the stack frame in the name of
              accuracy, it would be better to just quit now.  */

-          if (pv_area_store_would_trash (stack, reg[rm]))
+          if (stack.store_would_trash (reg[rm]))

             break;
           
             break;
           

-          if (is_arg_spill (reg[rn], reg[rm], stack))
+          if (is_arg_spill (gdbarch, reg[rn], reg[rm], &stack))

             after_last_frame_setup_insn = next_pc;
 
             after_last_frame_setup_insn = next_pc;
 

-          pv_area_store (stack, reg[rm], 4, reg[rn]);
+          stack.store (reg[rm], 4, reg[rn]);

         }
       else if (IS_SW_IMMD (insn))
         {
         }
       else if (IS_SW_IMMD (insn))
         {


@@ -1755,13 +1742,13 @@ mep_analyze_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
           /* If simulating this store would require us to forget
              everything we know about the stack frame in the name of
              accuracy, it would be better to just quit now.  */
           /* If simulating this store would require us to forget
              everything we know about the stack frame in the name of
              accuracy, it would be better to just quit now.  */

-          if (pv_area_store_would_trash (stack, addr))
+          if (stack.store_would_trash (addr))

             break;
 
             break;
 

-          if (is_arg_spill (reg[rn], addr, stack))
+          if (is_arg_spill (gdbarch, reg[rn], addr, &stack))

             after_last_frame_setup_insn = next_pc;
 
             after_last_frame_setup_insn = next_pc;
 

-          pv_area_store (stack, addr, 4, reg[rn]);
+          stack.store (addr, 4, reg[rn]);

         }
       else if (IS_MOV (insn))
        {
         }
       else if (IS_MOV (insn))
        {


@@ -1780,17 +1767,16 @@ mep_analyze_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
           int disp = SWBH_32_OFFSET (insn);
           int size = (IS_SB (insn) ? 1
                       : IS_SH (insn) ? 2
           int disp = SWBH_32_OFFSET (insn);
           int size = (IS_SB (insn) ? 1
                       : IS_SH (insn) ? 2

-                      : IS_SW (insn) ? 4
-                      : (gdb_assert (0), 1));
+                      : (gdb_assert (IS_SW (insn)), 4));

           pv_t addr = pv_add_constant (reg[rm], disp);
 
           pv_t addr = pv_add_constant (reg[rm], disp);
 

-          if (pv_area_store_would_trash (stack, addr))
+          if (stack.store_would_trash (addr))

             break;
 
             break;
 

-          if (is_arg_spill (reg[rn], addr, stack))
+          if (is_arg_spill (gdbarch, reg[rn], addr, &stack))

             after_last_frame_setup_insn = next_pc;
 
             after_last_frame_setup_insn = next_pc;
 

-          pv_area_store (stack, addr, size, reg[rn]);
+          stack.store (addr, size, reg[rn]);

        }
       else if (IS_LDC (insn))
        {
        }
       else if (IS_LDC (insn))
        {


@@ -1806,7 +1792,7 @@ mep_analyze_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
           int offset = LW_OFFSET (insn);
           pv_t addr = pv_add_constant (reg[rm], offset);
 
           int offset = LW_OFFSET (insn);
           pv_t addr = pv_add_constant (reg[rm], offset);
 

-          reg[rn] = pv_area_fetch (stack, addr, 4);
+          reg[rn] = stack.fetch (addr, 4);

         }
       else if (IS_BRA (insn) && BRA_DISP (insn) > 0)
        {
         }
       else if (IS_BRA (insn) && BRA_DISP (insn) > 0)
        {


@@ -1814,7 +1800,7 @@ mep_analyze_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
             body, gcc 4.x will use a BRA instruction to branch to the
             loop condition checking code.  This BRA instruction is
             marked as part of the prologue.  We therefore set next_pc
             body, gcc 4.x will use a BRA instruction to branch to the
             loop condition checking code.  This BRA instruction is
             marked as part of the prologue.  We therefore set next_pc

-            to this branch target and also stop the prologue scan. 
+            to this branch target and also stop the prologue scan.

             The instructions at and beyond the branch target should
             no longer be associated with the prologue.
             
             The instructions at and beyond the branch target should
             no longer be associated with the prologue.
             


@@ -1885,18 +1871,16 @@ mep_analyze_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
     }
 
   /* Record where all the registers were saved.  */
     }
 
   /* Record where all the registers were saved.  */

-  pv_area_scan (stack, check_for_saved, (void *) result);
+  stack.scan (check_for_saved, (void *) result);

 
   result->prologue_end = after_last_frame_setup_insn;
 
   result->prologue_end = after_last_frame_setup_insn;

-
-  do_cleanups (back_to);

 }
 
 
 static CORE_ADDR
 }
 
 
 static CORE_ADDR

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

 {
 {

-  char *name;
+  const char *name;

   CORE_ADDR func_addr, func_end;
   struct mep_prologue p;
 
   CORE_ADDR func_addr, func_end;
   struct mep_prologue p;
 


@@ -1904,29 +1888,23 @@ mep_skip_prologue (CORE_ADDR pc)
   if (! find_pc_partial_function (pc, &name, &func_addr, &func_end))
     return pc;
 
   if (! find_pc_partial_function (pc, &name, &func_addr, &func_end))
     return pc;
 

-  mep_analyze_prologue (pc, func_end, &p);
+  mep_analyze_prologue (gdbarch, pc, func_end, &p);

   return p.prologue_end;
 }
 
 
 \f
 /* Breakpoints.  */
   return p.prologue_end;
 }
 
 
 \f
 /* Breakpoints.  */

+constexpr gdb_byte mep_break_insn[] = { 0x70, 0x32 };

 
 

-static const unsigned char *
-mep_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR * pcptr, int *lenptr)
-{
-  static unsigned char breakpoint[] = { 0x70, 0x32 };
-  *lenptr = sizeof (breakpoint);
-  return breakpoint;
-}
-
+typedef BP_MANIPULATION (mep_break_insn) mep_breakpoint;

 
 \f
 /* Frames and frame unwinding.  */
 
 
 static struct mep_prologue *
 
 \f
 /* Frames and frame unwinding.  */
 
 
 static struct mep_prologue *

-mep_analyze_frame_prologue (struct frame_info *next_frame,
+mep_analyze_frame_prologue (struct frame_info *this_frame,

                             void **this_prologue_cache)
 {
   if (! *this_prologue_cache)
                             void **this_prologue_cache)
 {
   if (! *this_prologue_cache)


@@ -1936,29 +1914,31 @@ mep_analyze_frame_prologue (struct frame_info *next_frame,
       *this_prologue_cache 
         = FRAME_OBSTACK_ZALLOC (struct mep_prologue);
 
       *this_prologue_cache 
         = FRAME_OBSTACK_ZALLOC (struct mep_prologue);
 

-      func_start = frame_func_unwind (next_frame, NORMAL_FRAME);
-      stop_addr = frame_pc_unwind (next_frame);
+      func_start = get_frame_func (this_frame);
+      stop_addr = get_frame_pc (this_frame);

 
       /* If we couldn't find any function containing the PC, then
          just initialize the prologue cache, but don't do anything.  */
       if (! func_start)
         stop_addr = func_start;
 
 
       /* If we couldn't find any function containing the PC, then
          just initialize the prologue cache, but don't do anything.  */
       if (! func_start)
         stop_addr = func_start;
 

-      mep_analyze_prologue (func_start, stop_addr, *this_prologue_cache);
+      mep_analyze_prologue (get_frame_arch (this_frame),
+                           func_start, stop_addr,
+                           (struct mep_prologue *) *this_prologue_cache);

     }
 
     }
 

-  return *this_prologue_cache;
+  return (struct mep_prologue *) *this_prologue_cache;

 }
 
 
 /* Given the next frame and a prologue cache, return this frame's
    base.  */
 static CORE_ADDR
 }
 
 
 /* Given the next frame and a prologue cache, return this frame's
    base.  */
 static CORE_ADDR

-mep_frame_base (struct frame_info *next_frame,
+mep_frame_base (struct frame_info *this_frame,

                 void **this_prologue_cache)
 {
   struct mep_prologue *p
                 void **this_prologue_cache)
 {
   struct mep_prologue *p

-    = mep_analyze_frame_prologue (next_frame, this_prologue_cache);
+    = mep_analyze_frame_prologue (this_frame, this_prologue_cache);

 
   /* In functions that use alloca, the distance between the stack
      pointer and the frame base varies dynamically, so we can't use
 
   /* In functions that use alloca, the distance between the stack
      pointer and the frame base varies dynamically, so we can't use


@@ -1969,37 +1949,34 @@ mep_frame_base (struct frame_info *next_frame,
   if (p->has_frame_ptr)
     {
       CORE_ADDR fp
   if (p->has_frame_ptr)
     {
       CORE_ADDR fp

-        = frame_unwind_register_unsigned (next_frame, MEP_FP_REGNUM);
+        = get_frame_register_unsigned (this_frame, MEP_FP_REGNUM);

       return fp - p->frame_ptr_offset;
     }
   else
     {
       CORE_ADDR sp
       return fp - p->frame_ptr_offset;
     }
   else
     {
       CORE_ADDR sp

-        = frame_unwind_register_unsigned (next_frame, MEP_SP_REGNUM);
+        = get_frame_register_unsigned (this_frame, MEP_SP_REGNUM);

       return sp - p->frame_size;
     }
 }
 
 
 static void
       return sp - p->frame_size;
     }
 }
 
 
 static void

-mep_frame_this_id (struct frame_info *next_frame,
+mep_frame_this_id (struct frame_info *this_frame,

                    void **this_prologue_cache,
                    struct frame_id *this_id)
 {
                    void **this_prologue_cache,
                    struct frame_id *this_id)
 {

-  *this_id = frame_id_build (mep_frame_base (next_frame, this_prologue_cache),
-                             frame_func_unwind (next_frame, NORMAL_FRAME));
+  *this_id = frame_id_build (mep_frame_base (this_frame, this_prologue_cache),
+                             get_frame_func (this_frame));

 }
 
 
 }
 
 

-static void
-mep_frame_prev_register (struct frame_info *next_frame,
-                         void **this_prologue_cache,
-                         int regnum, int *optimizedp,
-                         enum lval_type *lvalp, CORE_ADDR *addrp,
-                         int *realnump, gdb_byte *bufferp)
+static struct value *
+mep_frame_prev_register (struct frame_info *this_frame,
+                         void **this_prologue_cache, int regnum)

 {
   struct mep_prologue *p
 {
   struct mep_prologue *p

-    = mep_analyze_frame_prologue (next_frame, this_prologue_cache);
+    = mep_analyze_frame_prologue (this_frame, this_prologue_cache);

 
   /* There are a number of complications in unwinding registers on the
      MeP, having to do with core functions calling VLIW functions and
 
   /* There are a number of complications in unwinding registers on the
      MeP, having to do with core functions calling VLIW functions and


@@ -2021,102 +1998,69 @@ mep_frame_prev_register (struct frame_info *next_frame,
      do this.  */
   if (regnum == MEP_PC_REGNUM)
     {
      do this.  */
   if (regnum == MEP_PC_REGNUM)
     {

-      mep_frame_prev_register (next_frame, this_prologue_cache, MEP_LP_REGNUM,
-                               optimizedp, lvalp, addrp, realnump, bufferp);
-      store_unsigned_integer (bufferp, MEP_LP_SIZE, 
-                              (extract_unsigned_integer (bufferp, MEP_LP_SIZE)
-                               & ~1));
-      *lvalp = not_lval;
+      struct value *value;
+      CORE_ADDR lp;
+      value = mep_frame_prev_register (this_frame, this_prologue_cache,
+                                      MEP_LP_REGNUM);
+      lp = value_as_long (value);
+      release_value (value);
+
+      return frame_unwind_got_constant (this_frame, regnum, lp & ~1);

     }
   else
     {
     }
   else
     {

-      CORE_ADDR frame_base = mep_frame_base (next_frame, this_prologue_cache);
-      int reg_size = register_size (get_frame_arch (next_frame), regnum);
+      CORE_ADDR frame_base = mep_frame_base (this_frame, this_prologue_cache);
+      struct value *value;

 
       /* Our caller's SP is our frame base.  */
       if (regnum == MEP_SP_REGNUM)
 
       /* Our caller's SP is our frame base.  */
       if (regnum == MEP_SP_REGNUM)

-        {
-          *optimizedp = 0;
-          *lvalp = not_lval;
-          *addrp = 0;
-          *realnump = -1;
-          if (bufferp)
-            store_unsigned_integer (bufferp, reg_size, frame_base);
-        }
+       return frame_unwind_got_constant (this_frame, regnum, frame_base);

 
       /* If prologue analysis says we saved this register somewhere,
          return a description of the stack slot holding it.  */
 
       /* If prologue analysis says we saved this register somewhere,
          return a description of the stack slot holding it.  */

-      else if (p->reg_offset[regnum] != 1)
-        {
-          *optimizedp = 0;
-          *lvalp = lval_memory;
-          *addrp = frame_base + p->reg_offset[regnum];
-          *realnump = -1;
-          if (bufferp)
-            get_frame_memory (next_frame, *addrp, bufferp, reg_size);
-        }
+      if (p->reg_offset[regnum] != 1)
+       value = frame_unwind_got_memory (this_frame, regnum,
+                                        frame_base + p->reg_offset[regnum]);

 
       /* Otherwise, presume we haven't changed the value of this
          register, and get it from the next frame.  */
       else
 
       /* Otherwise, presume we haven't changed the value of this
          register, and get it from the next frame.  */
       else

-        frame_register_unwind (next_frame, regnum,
-                               optimizedp, lvalp, addrp, realnump, bufferp);
+       value = frame_unwind_got_register (this_frame, regnum, regnum);

 
       /* If we need to toggle the operating mode, do so.  */
       if (regnum == MEP_PSW_REGNUM)
         {
 
       /* If we need to toggle the operating mode, do so.  */
       if (regnum == MEP_PSW_REGNUM)
         {

-          int lp_optimized;
-          enum lval_type lp_lval;
-          CORE_ADDR lp_addr;
-          int lp_realnum;
-          char lp_buffer[MEP_LP_SIZE];
+         CORE_ADDR psw, lp;
+
+         psw = value_as_long (value);
+         release_value (value);

 
           /* Get the LP's value, too.  */
 
           /* Get the LP's value, too.  */

-          frame_register_unwind (next_frame, MEP_LP_REGNUM,
-                                 &lp_optimized, &lp_lval, &lp_addr,
-                                 &lp_realnum, lp_buffer);
+         value = get_frame_register_value (this_frame, MEP_LP_REGNUM);
+         lp = value_as_long (value);
+         release_value (value);

 
           /* If LP.LTOM is set, then toggle PSW.OM.  */
 
           /* If LP.LTOM is set, then toggle PSW.OM.  */

-          if (extract_unsigned_integer (lp_buffer, MEP_LP_SIZE) & 0x1)
-            store_unsigned_integer
-              (bufferp, MEP_PSW_SIZE,
-               (extract_unsigned_integer (bufferp, MEP_PSW_SIZE) ^ 0x1000));
-          *lvalp = not_lval;
+         if (lp & 0x1)
+           psw ^= 0x1000;
+
+         return frame_unwind_got_constant (this_frame, regnum, psw);

         }
         }

+
+      return value;

     }
 }
 
 
 static const struct frame_unwind mep_frame_unwind = {
   NORMAL_FRAME,
     }
 }
 
 
 static const struct frame_unwind mep_frame_unwind = {
   NORMAL_FRAME,

+  default_frame_unwind_stop_reason,

   mep_frame_this_id,
   mep_frame_this_id,

-  mep_frame_prev_register
+  mep_frame_prev_register,
+  NULL,
+  default_frame_sniffer

 };
 
 };
 

-
-static const struct frame_unwind *
-mep_frame_sniffer (struct frame_info *next_frame)
-{
-  return &mep_frame_unwind;
-}
-
-
-/* Our general unwinding function can handle unwinding the PC.  */
-static CORE_ADDR
-mep_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
-  return frame_unwind_register_unsigned (next_frame, MEP_PC_REGNUM);
-}
-
-
-/* Our general unwinding function can handle unwinding the SP.  */
-static CORE_ADDR
-mep_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
-  return frame_unwind_register_unsigned (next_frame, MEP_SP_REGNUM);
-}
-
-

 \f
 /* Return values.  */
 
 \f
 /* Return values.  */
 


@@ -2150,10 +2094,9 @@ mep_extract_return_value (struct gdbarch *arch,
   else
     offset = 0;
 
   else
     offset = 0;
 

-  /* Return values that do fit in a single register are returned in R0. */
-  regcache_cooked_read_part (regcache, MEP_R0_REGNUM,
-                             offset, TYPE_LENGTH (type),
-                             valbuf);
+  /* Return values that do fit in a single register are returned in R0.  */
+  regcache->cooked_read_part (MEP_R0_REGNUM, offset, TYPE_LENGTH (type),
+                             valbuf);

 }
 
 
 }
 
 


@@ -2178,26 +2121,24 @@ mep_store_return_value (struct gdbarch *arch,
       else
         offset = 0;
 
       else
         offset = 0;
 

-      regcache_cooked_write_part (regcache, MEP_R0_REGNUM,
-                                  offset, TYPE_LENGTH (type),
-                                  valbuf);
+      regcache->cooked_write_part (MEP_R0_REGNUM, offset, TYPE_LENGTH (type),
+                                  valbuf);

     }
 
   /* Return values larger than a single register are returned in
      memory, pointed to by R0.  Unfortunately, we can't count on R0
     }
 
   /* Return values larger than a single register are returned in
      memory, pointed to by R0.  Unfortunately, we can't count on R0

-     pointing to the return buffer, so we raise an error here. */
+     pointing to the return buffer, so we raise an error here.  */

   else
   else

-    error ("GDB cannot set return values larger than four bytes; "
-           "the Media Processor's\n"
-           "calling conventions do not provide enough information "
-           "to do this.\n"
-           "Try using the 'return' command with no argument.");
+    error (_("\
+GDB cannot set return values larger than four bytes; the Media Processor's\n\
+calling conventions do not provide enough information to do this.\n\
+Try using the 'return' command with no argument."));

 }
 
 }
 

-enum return_value_convention
-mep_return_value (struct gdbarch *gdbarch, struct type *type,
-                 struct regcache *regcache, gdb_byte *readbuf,
-                 const gdb_byte *writebuf)
+static enum return_value_convention
+mep_return_value (struct gdbarch *gdbarch, struct value *function,
+                 struct type *type, struct regcache *regcache,
+                 gdb_byte *readbuf, const gdb_byte *writebuf)

 {
   if (mep_use_struct_convention (type))
     {
 {
   if (mep_use_struct_convention (type))
     {


@@ -2214,12 +2155,11 @@ mep_return_value (struct gdbarch *gdbarch, struct type *type,
        {
          /* Return values larger than a single register are returned in
             memory, pointed to by R0.  Unfortunately, we can't count on R0
        {
          /* Return values larger than a single register are returned in
             memory, pointed to by R0.  Unfortunately, we can't count on R0

-            pointing to the return buffer, so we raise an error here. */
-         error ("GDB cannot set return values larger than four bytes; "
-                "the Media Processor's\n"
-                "calling conventions do not provide enough information "
-                "to do this.\n"
-                "Try using the 'return' command with no argument.");
+            pointing to the return buffer, so we raise an error here.  */
+         error (_("\
+GDB cannot set return values larger than four bytes; the Media Processor's\n\
+calling conventions do not provide enough information to do this.\n\
+Try using the 'return' command with no argument."));

        }
       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
     }
        }
       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
     }


@@ -2251,15 +2191,15 @@ mep_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
    4.2.1 Core register conventions
 
    - Parameters should be evaluated from left to right, and they
    4.2.1 Core register conventions
 
    - Parameters should be evaluated from left to right, and they

-     should be held in $1,$2,$3,$4 in order. The fifth parameter or
-     after should be held in the stack. If the size is larger than 4
+     should be held in $1,$2,$3,$4 in order.  The fifth parameter or
+     after should be held in the stack.  If the size is larger than 4

      bytes in the first four parameters, the pointer should be held in
      bytes in the first four parameters, the pointer should be held in

-     the registers instead. If the size is larger than 4 bytes in the
+     the registers instead.  If the size is larger than 4 bytes in the

      fifth parameter or after, the pointer should be held in the stack.
 
      fifth parameter or after, the pointer should be held in the stack.
 

-   - Return value of a function should be held in register $0. If the
+   - Return value of a function should be held in register $0.  If the

      size of return value is larger than 4 bytes, $1 should hold the
      size of return value is larger than 4 bytes, $1 should hold the

-     pointer pointing memory that would hold the return value. In this
+     pointer pointing memory that would hold the return value.  In this

      case, the first parameter should be held in $2, the second one in
      $3, and the third one in $4, and the forth parameter or after
      should be held in the stack.
      case, the first parameter should be held in $2, the second one in
      $3, and the third one in $4, and the forth parameter or after
      should be held in the stack.


@@ -2301,11 +2241,11 @@ static CORE_ADDR
 mep_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                      struct regcache *regcache, CORE_ADDR bp_addr,
                      int argc, struct value **argv, CORE_ADDR sp,
 mep_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                      struct regcache *regcache, CORE_ADDR bp_addr,
                      int argc, struct value **argv, CORE_ADDR sp,

-                     int struct_return,
+                    function_call_return_method return_method,

                      CORE_ADDR struct_addr)
 {
                      CORE_ADDR struct_addr)
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   CORE_ADDR *copy = (CORE_ADDR *) alloca (argc * sizeof (copy[0]));
   CORE_ADDR *copy = (CORE_ADDR *) alloca (argc * sizeof (copy[0]));

-  CORE_ADDR func_addr = find_function_addr (function, NULL);

   int i;
 
   /* The number of the next register available to hold an argument.  */
   int i;
 
   /* The number of the next register available to hold an argument.  */


@@ -2330,7 +2270,7 @@ mep_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   /* If we're returning a structure by value, push the pointer to the
      buffer as the first argument.  */
 
   /* If we're returning a structure by value, push the pointer to the
      buffer as the first argument.  */

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

     {
       regcache_cooked_write_unsigned (regcache, arg_reg, struct_addr);
       arg_reg++;
     {
       regcache_cooked_write_unsigned (regcache, arg_reg, struct_addr);
       arg_reg++;


@@ -2338,13 +2278,13 @@ mep_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   for (i = 0; i < argc; i++)
     {
 
   for (i = 0; i < argc; i++)
     {

-      unsigned arg_size = TYPE_LENGTH (value_type (argv[i]));

       ULONGEST value;
 
       /* Arguments that fit in a GPR get expanded to fill the GPR.  */
       ULONGEST value;
 
       /* Arguments that fit in a GPR get expanded to fill the GPR.  */

-      if (arg_size <= MEP_GPR_SIZE)
+      if (TYPE_LENGTH (value_type (argv[i])) <= MEP_GPR_SIZE)

         value = extract_unsigned_integer (value_contents (argv[i]),
         value = extract_unsigned_integer (value_contents (argv[i]),

-                                          TYPE_LENGTH (value_type (argv[i])));
+                                          TYPE_LENGTH (value_type (argv[i])),
+                                         byte_order);

 
       /* Arguments too large to fit in a GPR get copied to the stack,
          and we pass a pointer to the copy.  */
 
       /* Arguments too large to fit in a GPR get copied to the stack,
          and we pass a pointer to the copy.  */


@@ -2359,8 +2299,8 @@ mep_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
         }
       else
         {
         }
       else
         {

-          char buf[MEP_GPR_SIZE];
-          store_unsigned_integer (buf, MEP_GPR_SIZE, value);
+          gdb_byte buf[MEP_GPR_SIZE];
+          store_unsigned_integer (buf, MEP_GPR_SIZE, byte_order, value);

           write_memory (arg_stack, buf, MEP_GPR_SIZE);
           arg_stack += MEP_GPR_SIZE;
         }
           write_memory (arg_stack, buf, MEP_GPR_SIZE);
           arg_stack += MEP_GPR_SIZE;
         }


@@ -2377,15 +2317,6 @@ mep_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   return sp;
 }
 
   return sp;
 }
 

-
-static struct frame_id
-mep_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
-  return frame_id_build (mep_unwind_sp (gdbarch, next_frame),
-                         frame_pc_unwind (next_frame));
-}
-
-

 \f
 /* Initialization.  */
 
 \f
 /* Initialization.  */
 


@@ -2406,7 +2337,10 @@ mep_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
       /* The way to get the me_module code depends on the object file
          format.  At the moment, we only know how to handle ELF.  */
       if (bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
       /* The way to get the me_module code depends on the object file
          format.  At the moment, we only know how to handle ELF.  */
       if (bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)

-        me_module = elf_elfheader (info.abfd)->e_flags & EF_MEP_INDEX_MASK;
+       {
+         int flag = elf_elfheader (info.abfd)->e_flags & EF_MEP_INDEX_MASK;
+         me_module = (CONFIG_ATTR) flag;
+       }

       else
         me_module = CONFIG_NONE;
     }
       else
         me_module = CONFIG_NONE;
     }


@@ -2430,14 +2364,14 @@ mep_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
           
           fputc_unfiltered ('\n', gdb_stderr);
           if (module_name)
           
           fputc_unfiltered ('\n', gdb_stderr);
           if (module_name)

-            warning ("the MeP module '%s' is %s-endian, but the executable\n"
-                     "%s is %s-endian.",
+            warning (_("the MeP module '%s' is %s-endian, but the executable\n"
+                      "%s is %s-endian."),

                      module_name, module_endianness,
                      file_name, file_endianness);
           else
                      module_name, module_endianness,
                      file_name, file_endianness);
           else

-            warning ("the selected MeP module is %s-endian, but the "
-                     "executable\n"
-                     "%s is %s-endian.",
+            warning (_("the selected MeP module is %s-endian, but the "
+                      "executable\n"
+                      "%s is %s-endian."),

                      module_endianness, file_name, file_endianness);
         }
     }
                      module_endianness, file_name, file_endianness);
         }
     }


@@ -2452,7 +2386,7 @@ mep_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
     if (gdbarch_tdep (arches->gdbarch)->me_module == me_module)
       return arches->gdbarch;
 
     if (gdbarch_tdep (arches->gdbarch)->me_module == me_module)
       return arches->gdbarch;
 

-  tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
+  tdep = XCNEW (struct gdbarch_tdep);

   gdbarch = gdbarch_alloc (&info, tdep);
 
   /* Get a CGEN CPU descriptor for this architecture.  */
   gdbarch = gdbarch_alloc (&info, tdep);
 
   /* Get a CGEN CPU descriptor for this architecture.  */


@@ -2470,9 +2404,8 @@ mep_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   tdep->me_module = me_module;
 
   /* Register set.  */
   tdep->me_module = me_module;
 
   /* Register set.  */

-  set_gdbarch_read_pc (gdbarch, mep_read_pc);
-  set_gdbarch_write_pc (gdbarch, mep_write_pc);

   set_gdbarch_num_regs (gdbarch, MEP_NUM_RAW_REGS);
   set_gdbarch_num_regs (gdbarch, MEP_NUM_RAW_REGS);

+  set_gdbarch_pc_regnum (gdbarch, MEP_PC_REGNUM);

   set_gdbarch_sp_regnum (gdbarch, MEP_SP_REGNUM);
   set_gdbarch_register_name (gdbarch, mep_register_name);
   set_gdbarch_register_type (gdbarch, mep_register_type);
   set_gdbarch_sp_regnum (gdbarch, MEP_SP_REGNUM);
   set_gdbarch_register_name (gdbarch, mep_register_name);
   set_gdbarch_register_type (gdbarch, mep_register_type);


@@ -2495,14 +2428,13 @@ mep_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_print_insn (gdbarch, mep_gdb_print_insn); 
 
   /* Breakpoints.  */
   set_gdbarch_print_insn (gdbarch, mep_gdb_print_insn); 
 
   /* Breakpoints.  */

-  set_gdbarch_breakpoint_from_pc (gdbarch, mep_breakpoint_from_pc);
+  set_gdbarch_breakpoint_kind_from_pc (gdbarch, mep_breakpoint::kind_from_pc);
+  set_gdbarch_sw_breakpoint_from_kind (gdbarch, mep_breakpoint::bp_from_kind);

   set_gdbarch_decr_pc_after_break (gdbarch, 0);
   set_gdbarch_skip_prologue (gdbarch, mep_skip_prologue);
 
   /* Frames and frame unwinding.  */
   set_gdbarch_decr_pc_after_break (gdbarch, 0);
   set_gdbarch_skip_prologue (gdbarch, mep_skip_prologue);
 
   /* Frames and frame unwinding.  */

-  frame_unwind_append_sniffer (gdbarch, mep_frame_sniffer);
-  set_gdbarch_unwind_pc (gdbarch, mep_unwind_pc);
-  set_gdbarch_unwind_sp (gdbarch, mep_unwind_sp);
+  frame_unwind_append_unwinder (gdbarch, &mep_frame_unwind);

   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
   set_gdbarch_frame_args_skip (gdbarch, 0);
 
   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
   set_gdbarch_frame_args_skip (gdbarch, 0);
 


@@ -2512,14 +2444,13 @@ mep_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   /* Inferior function calls.  */
   set_gdbarch_frame_align (gdbarch, mep_frame_align);
   set_gdbarch_push_dummy_call (gdbarch, mep_push_dummy_call);
   /* Inferior function calls.  */
   set_gdbarch_frame_align (gdbarch, mep_frame_align);
   set_gdbarch_push_dummy_call (gdbarch, mep_push_dummy_call);

-  set_gdbarch_unwind_dummy_id (gdbarch, mep_unwind_dummy_id);

 
   return gdbarch;
 }
 
 
   return gdbarch;
 }
 

-
+void _initialize_mep_tdep ();

 void
 void

-_initialize_mep_tdep (void)
+_initialize_mep_tdep ()

 {
   mep_csr_reggroup = reggroup_new ("csr", USER_REGGROUP);
   mep_cr_reggroup  = reggroup_new ("cr", USER_REGGROUP); 
 {
   mep_csr_reggroup = reggroup_new ("csr", USER_REGGROUP);
   mep_cr_reggroup  = reggroup_new ("cr", USER_REGGROUP);