xcoff slurp_armap bounds checking

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

diff --git a/gdb/tilegx-tdep.c b/gdb/tilegx-tdep.c
index 8be4046afe6a211f7606fadb0b66c62a2d13fe83..aa2681e2127a27dc221984965ee79f128996ccb4 100644 (file)
--- a/gdb/tilegx-tdep.c
+++ b/gdb/tilegx-tdep.c
@@ -1,6 +1,6 @@
 /* Target-dependent code for the Tilera TILE-Gx processor.
 
 /* Target-dependent code for the Tilera TILE-Gx processor.
 

-   Copyright (C) 2012-2013 Free Software Foundation, Inc.
+   Copyright (C) 2012-2019 Free Software Foundation, Inc.

 
    This file is part of GDB.
 
 
    This file is part of GDB.
 


@@ -30,20 +30,17 @@
 #include "value.h"
 #include "dis-asm.h"
 #include "inferior.h"
 #include "value.h"
 #include "dis-asm.h"
 #include "inferior.h"

-#include "gdb_string.h"
-#include "gdb_assert.h"

 #include "arch-utils.h"
 #include "arch-utils.h"

-#include "floatformat.h"

 #include "regcache.h"
 #include "regset.h"
 #include "regcache.h"
 #include "regset.h"

-#include "doublest.h"

 #include "osabi.h"
 #include "linux-tdep.h"
 #include "objfiles.h"
 #include "solib-svr4.h"
 #include "osabi.h"
 #include "linux-tdep.h"
 #include "objfiles.h"
 #include "solib-svr4.h"

-#include "symtab.h"

 #include "tilegx-tdep.h"
 #include "opcode/tilegx.h"
 #include "tilegx-tdep.h"
 #include "opcode/tilegx.h"

+#include <algorithm>
+#include "gdbsupport/byte-vector.h"

 
 struct tilegx_frame_cache
 {
 
 struct tilegx_frame_cache
 {


@@ -155,7 +152,7 @@ tilegx_register_name (struct gdbarch *gdbarch, int regnum)
       "r40",  "r41",  "r42",  "r43",  "r44",  "r45",  "r46",  "r47",
       "r48",  "r49",  "r50",  "r51",  "r52",  "tp",   "sp",   "lr",
       "sn",   "idn0", "idn1", "udn0", "udn1", "udn2", "udn3", "zero",
       "r40",  "r41",  "r42",  "r43",  "r44",  "r45",  "r46",  "r47",
       "r48",  "r49",  "r50",  "r51",  "r52",  "tp",   "sp",   "lr",
       "sn",   "idn0", "idn1", "udn0", "udn1", "udn2", "udn3", "zero",

-      "pc"
+      "pc",   "faultnum",

     };
 
   if (regnum < 0 || regnum >= TILEGX_NUM_REGS)
     };
 
   if (regnum < 0 || regnum >= TILEGX_NUM_REGS)


@@ -222,7 +219,7 @@ tilegx_extract_return_value (struct type *type, struct regcache *regcache,
   int i, regnum = TILEGX_R0_REGNUM;
 
   for (i = 0; i < len; i += tilegx_reg_size)
   int i, regnum = TILEGX_R0_REGNUM;
 
   for (i = 0; i < len; i += tilegx_reg_size)

-    regcache_raw_read (regcache, regnum++, valbuf + i);
+    regcache->raw_read (regnum++, valbuf + i);

 }
 
 /* Copy the function return value from VALBUF into the proper
 }
 
 /* Copy the function return value from VALBUF into the proper


@@ -239,7 +236,7 @@ tilegx_store_return_value (struct type *type, struct regcache *regcache,
       gdb_byte buf[tilegx_reg_size] = { 0 };
 
       memcpy (buf, valbuf, TYPE_LENGTH (type));
       gdb_byte buf[tilegx_reg_size] = { 0 };
 
       memcpy (buf, valbuf, TYPE_LENGTH (type));

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

     }
   else
     {
     }
   else
     {


@@ -247,7 +244,7 @@ tilegx_store_return_value (struct type *type, struct regcache *regcache,
       int i, regnum = TILEGX_R0_REGNUM;
 
       for (i = 0; i < len; i += tilegx_reg_size)
       int i, regnum = TILEGX_R0_REGNUM;
 
       for (i = 0; i < len; i += tilegx_reg_size)

-       regcache_raw_write (regcache, regnum++, (gdb_byte *) valbuf + i);
+       regcache->raw_write (regnum++, (gdb_byte *) valbuf + i);

     }
 }
 
     }
 }
 


@@ -284,19 +281,19 @@ tilegx_push_dummy_call (struct gdbarch *gdbarch,
                        struct regcache *regcache,
                        CORE_ADDR bp_addr, int nargs,
                        struct value **args,
                        struct regcache *regcache,
                        CORE_ADDR bp_addr, int nargs,
                        struct value **args,

-                       CORE_ADDR sp, int struct_return,
+                       CORE_ADDR sp, function_call_return_method return_method,

                        CORE_ADDR struct_addr)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   CORE_ADDR stack_dest = sp;
   int argreg = TILEGX_R0_REGNUM;
   int i, j;
                        CORE_ADDR struct_addr)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   CORE_ADDR stack_dest = sp;
   int argreg = TILEGX_R0_REGNUM;
   int i, j;

-  int typelen, slacklen, alignlen;
+  int typelen, slacklen;

   static const gdb_byte four_zero_words[16] = { 0 };
 
   /* If struct_return is 1, then the struct return address will
      consume one argument-passing register.  */
   static const gdb_byte four_zero_words[16] = { 0 };
 
   /* If struct_return is 1, then the struct return address will
      consume one argument-passing register.  */

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

     regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
 
   /* Arguments are passed in R0 - R9, and as soon as an argument
     regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
 
   /* Arguments are passed in R0 - R9, and as soon as an argument


@@ -330,21 +327,17 @@ tilegx_push_dummy_call (struct gdbarch *gdbarch,
      the stack, word aligned.  */
   for (j = nargs - 1; j >= i; j--)
     {
      the stack, word aligned.  */
   for (j = nargs - 1; j >= i; j--)
     {

-      gdb_byte *val;
-      struct cleanup *back_to;

       const gdb_byte *contents = value_contents (args[j]);
 
       typelen = TYPE_LENGTH (value_enclosing_type (args[j]));
       slacklen = align_up (typelen, 8) - typelen;
       const gdb_byte *contents = value_contents (args[j]);
 
       typelen = TYPE_LENGTH (value_enclosing_type (args[j]));
       slacklen = align_up (typelen, 8) - typelen;

-      val = xmalloc (typelen + slacklen);
-      back_to = make_cleanup (xfree, val);
-      memcpy (val, contents, typelen);
-      memset (val + typelen, 0, slacklen);
+      gdb::byte_vector val (typelen + slacklen);
+      memcpy (val.data (), contents, typelen);
+      memset (val.data () + typelen, 0, slacklen);

 
       /* Now write data to the stack.  The stack grows downwards.  */
       stack_dest -= typelen + slacklen;
 
       /* Now write data to the stack.  The stack grows downwards.  */
       stack_dest -= typelen + slacklen;

-      write_memory (stack_dest, val, typelen + slacklen);
-      do_cleanups (back_to);
+      write_memory (stack_dest, val.data (), typelen + slacklen);

     }
 
   /* Add 16 bytes for linkage space to the stack.  */
     }
 
   /* Add 16 bytes for linkage space to the stack.  */


@@ -378,9 +371,6 @@ tilegx_analyze_prologue (struct gdbarch* gdbarch,
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   CORE_ADDR next_addr;
   CORE_ADDR prolog_end = end_addr;
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   CORE_ADDR next_addr;
   CORE_ADDR prolog_end = end_addr;

-  ULONGEST inst, inst2;
-  LONGEST offset;
-  int regnum;

   gdb_byte instbuf[32 * TILEGX_BUNDLE_SIZE_IN_BYTES];
   CORE_ADDR instbuf_start;
   unsigned int instbuf_size;
   gdb_byte instbuf[32 * TILEGX_BUNDLE_SIZE_IN_BYTES];
   CORE_ADDR instbuf_start;
   unsigned int instbuf_size;


@@ -393,7 +383,7 @@ tilegx_analyze_prologue (struct gdbarch* gdbarch,
   struct tilegx_reverse_regs
     new_reverse_frame[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE];
   int dest_regs[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE];
   struct tilegx_reverse_regs
     new_reverse_frame[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE];
   int dest_regs[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE];

-  int reverse_frame_valid, prolog_done, branch_seen;
+  int reverse_frame_valid, prolog_done, branch_seen, lr_saved_on_stack_p;

   LONGEST prev_sp_value;
   int i, j;
 
   LONGEST prev_sp_value;
   int i, j;
 


@@ -409,6 +399,7 @@ tilegx_analyze_prologue (struct gdbarch* gdbarch,
   prolog_done = 0;
   branch_seen = 0;
   prev_sp_value = 0;
   prolog_done = 0;
   branch_seen = 0;
   prev_sp_value = 0;

+  lr_saved_on_stack_p = 0;

 
   /* To cut down on round-trip overhead, we fetch multiple bundles
      at once.  These variables describe the range of memory we have
 
   /* To cut down on round-trip overhead, we fetch multiple bundles
      at once.  These variables describe the range of memory we have


@@ -432,12 +423,15 @@ tilegx_analyze_prologue (struct gdbarch* gdbarch,
 
          if (instbuf_size > size_on_same_page)
            instbuf_size = size_on_same_page;
 
          if (instbuf_size > size_on_same_page)
            instbuf_size = size_on_same_page;

+
+         instbuf_size = std::min ((CORE_ADDR) instbuf_size,
+                                  (end_addr - next_addr));

          instbuf_start = next_addr;
 
          status = safe_frame_unwind_memory (next_frame, instbuf_start,
                                             instbuf, instbuf_size);
          if (status == 0)
          instbuf_start = next_addr;
 
          status = safe_frame_unwind_memory (next_frame, instbuf_start,
                                             instbuf, instbuf_size);
          if (status == 0)

-           memory_error (status, next_addr);
+           memory_error (TARGET_XFER_E_IO, next_addr);

        }
 
       reverse_frame_valid = 0;
        }
 
       reverse_frame_valid = 0;


@@ -450,7 +444,7 @@ tilegx_analyze_prologue (struct gdbarch* gdbarch,
       for (i = 0; i < num_insns; i++)
        {
          struct tilegx_decoded_instruction *this_insn = &decoded[i];
       for (i = 0; i < num_insns; i++)
        {
          struct tilegx_decoded_instruction *this_insn = &decoded[i];

-         int64_t *operands = (int64_t *) this_insn->operand_values;
+         long long *operands = this_insn->operand_values;

          const struct tilegx_opcode *opcode = this_insn->opcode;
 
          switch (opcode->mnemonic)
          const struct tilegx_opcode *opcode = this_insn->opcode;
 
          switch (opcode->mnemonic)


@@ -472,7 +466,11 @@ tilegx_analyze_prologue (struct gdbarch* gdbarch,
                     See trad-frame.h.  */
                  cache->saved_regs[saved_register].realreg = saved_register;
                  cache->saved_regs[saved_register].addr = saved_address;
                     See trad-frame.h.  */
                  cache->saved_regs[saved_register].realreg = saved_register;
                  cache->saved_regs[saved_register].addr = saved_address;

-               }
+               } 
+             else if (cache
+                      && (operands[0] == TILEGX_SP_REGNUM) 
+                      && (operands[1] == TILEGX_LR_REGNUM))
+               lr_saved_on_stack_p = 1;

              break;
            case TILEGX_OPC_ADDI:
            case TILEGX_OPC_ADDLI:
              break;
            case TILEGX_OPC_ADDI:
            case TILEGX_OPC_ADDLI:


@@ -725,43 +723,57 @@ tilegx_analyze_prologue (struct gdbarch* gdbarch,
        }
     }
 
        }
     }
 

+  if (lr_saved_on_stack_p)
+    {
+      cache->saved_regs[TILEGX_LR_REGNUM].realreg = TILEGX_LR_REGNUM;
+      cache->saved_regs[TILEGX_LR_REGNUM].addr =
+       cache->saved_regs[TILEGX_SP_REGNUM].addr;
+    }
+

   return prolog_end;
 }
 
 /* This is the implementation of gdbarch method skip_prologue.  */
 
 static CORE_ADDR
   return prolog_end;
 }
 
 /* This is the implementation of gdbarch method skip_prologue.  */
 
 static CORE_ADDR

-tilegx_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
+tilegx_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)

 {
 {

-  struct symtab_and_line sal;
-  CORE_ADDR func_start, func_end;
+  CORE_ADDR func_start, end_pc;
+  struct obj_section *s;

 
   /* This is the preferred method, find the end of the prologue by
      using the debugging information.  */
 
   /* This is the preferred method, find the end of the prologue by
      using the debugging information.  */

-  if (find_pc_partial_function (pc, NULL, &func_start, &func_end))
+  if (find_pc_partial_function (start_pc, NULL, &func_start, NULL))

     {
     {

-       sal = find_pc_line (func_start, 0);
+      CORE_ADDR post_prologue_pc
+        = skip_prologue_using_sal (gdbarch, func_start);

 
 

-       if (sal.end < func_end && pc <= sal.end)
-         return sal.end;
+      if (post_prologue_pc != 0)
+        return std::max (start_pc, post_prologue_pc);

     }
 
     }
 

+  /* Don't straddle a section boundary.  */
+  s = find_pc_section (start_pc);
+  end_pc = start_pc + 8 * TILEGX_BUNDLE_SIZE_IN_BYTES;
+  if (s != NULL)
+    end_pc = std::min (end_pc, obj_section_endaddr (s));
+

   /* Otherwise, try to skip prologue the hard way.  */
   return tilegx_analyze_prologue (gdbarch,
   /* Otherwise, try to skip prologue the hard way.  */
   return tilegx_analyze_prologue (gdbarch,

-                                 pc, pc + 8 * TILEGX_BUNDLE_SIZE_IN_BYTES,
+                                 start_pc,
+                                 end_pc,

                                  NULL, NULL);
 }
 
                                  NULL, NULL);
 }
 

-/* This is the implementation of gdbarch method in_function_epilogue_p.  */
+/* This is the implementation of gdbarch method stack_frame_destroyed_p.  */

 
 static int
 
 static int

-tilegx_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
+tilegx_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)

 {
   CORE_ADDR func_addr = 0, func_end = 0;
 
   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
     {
 {
   CORE_ADDR func_addr = 0, func_end = 0;
 
   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
     {

-      ULONGEST inst, inst2;

       CORE_ADDR addr = func_end - TILEGX_BUNDLE_SIZE_IN_BYTES;
 
       /* FIXME: Find the actual epilogue.  */
       CORE_ADDR addr = func_end - TILEGX_BUNDLE_SIZE_IN_BYTES;
 
       /* FIXME: Find the actual epilogue.  */


@@ -772,20 +784,65 @@ tilegx_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
   return 0;
 }
 
   return 0;
 }
 

-/* This is the implementation of gdbarch method breakpoint_from_pc.  */
+/* This is the implementation of gdbarch method get_longjmp_target.  */

 
 

-static const unsigned char *
-tilegx_breakpoint_from_pc (struct gdbarch *gdbarch,
-                          CORE_ADDR *pcptr, int *lenptr)
+static int
+tilegx_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)

 {
 {

-  /* 64-bit pattern for a { bpt ; nop } bundle.  */
-  static const unsigned char breakpoint[] =
-    { 0x00, 0x50, 0x48, 0x51, 0xae, 0x44, 0x6a, 0x28 };
+  struct gdbarch *gdbarch = get_frame_arch (frame);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+  CORE_ADDR jb_addr;
+  gdb_byte buf[8];
+
+  jb_addr = get_frame_register_unsigned (frame, TILEGX_R0_REGNUM);

 
 

-  *lenptr = sizeof (breakpoint);
-  return breakpoint;
+  /* TileGX jmp_buf contains 32 elements of type __uint_reg_t which
+     has a size of 8 bytes.  The return address is stored in the 25th
+     slot.  */
+  if (target_read_memory (jb_addr + 25 * 8, buf, 8))
+    return 0;
+
+  *pc = extract_unsigned_integer (buf, 8, byte_order);
+
+  return 1;
+}
+
+/* by assigning the 'faultnum' reg in kernel pt_regs with this value,
+   kernel do_signal will not check r0. see tilegx kernel/signal.c
+   for details.  */
+#define INT_SWINT_1_SIGRETURN (~0)
+
+/* Implement the "write_pc" gdbarch method.  */
+
+static void
+tilegx_write_pc (struct regcache *regcache, CORE_ADDR pc)
+{
+  regcache_cooked_write_unsigned (regcache, TILEGX_PC_REGNUM, pc);
+
+  /* We must be careful with modifying the program counter.  If we
+     just interrupted a system call, the kernel might try to restart
+     it when we resume the inferior.  On restarting the system call,
+     the kernel will try backing up the program counter even though it
+     no longer points at the system call.  This typically results in a
+     SIGSEGV or SIGILL.  We can prevent this by writing INT_SWINT_1_SIGRETURN
+     in the "faultnum" pseudo-register.
+
+     Note that "faultnum" is saved when setting up a dummy call frame.
+     This means that it is properly restored when that frame is
+     popped, and that the interrupted system call will be restarted
+     when we resume the inferior on return from a function call from
+     within GDB.  In all other cases the system call will not be
+     restarted.  */
+  regcache_cooked_write_unsigned (regcache, TILEGX_FAULTNUM_REGNUM,
+                                  INT_SWINT_1_SIGRETURN);

 }
 
 }
 

+/* 64-bit pattern for a { bpt ; nop } bundle.  */
+constexpr gdb_byte tilegx_break_insn[] =
+  { 0x00, 0x50, 0x48, 0x51, 0xae, 0x44, 0x6a, 0x28 };
+
+typedef BP_MANIPULATION (tilegx_break_insn) tilegx_breakpoint;
+

 /* Normal frames.  */
 
 static struct tilegx_frame_cache *
 /* Normal frames.  */
 
 static struct tilegx_frame_cache *


@@ -794,10 +851,9 @@ tilegx_frame_cache (struct frame_info *this_frame, void **this_cache)
   struct gdbarch *gdbarch = get_frame_arch (this_frame);
   struct tilegx_frame_cache *cache;
   CORE_ADDR current_pc;
   struct gdbarch *gdbarch = get_frame_arch (this_frame);
   struct tilegx_frame_cache *cache;
   CORE_ADDR current_pc;

-  int i;

 
   if (*this_cache)
 
   if (*this_cache)

-    return *this_cache;
+    return (struct tilegx_frame_cache *) *this_cache;

 
   cache = FRAME_OBSTACK_ZALLOC (struct tilegx_frame_cache);
   *this_cache = cache;
 
   cache = FRAME_OBSTACK_ZALLOC (struct tilegx_frame_cache);
   *this_cache = cache;


@@ -809,11 +865,12 @@ tilegx_frame_cache (struct frame_info *this_frame, void **this_cache)
   cache->base = get_frame_register_unsigned (this_frame, TILEGX_SP_REGNUM);
   trad_frame_set_value (cache->saved_regs, TILEGX_SP_REGNUM, cache->base);
 
   cache->base = get_frame_register_unsigned (this_frame, TILEGX_SP_REGNUM);
   trad_frame_set_value (cache->saved_regs, TILEGX_SP_REGNUM, cache->base);
 

-  cache->saved_regs[TILEGX_PC_REGNUM] = cache->saved_regs[TILEGX_LR_REGNUM];

   if (cache->start_pc)
     tilegx_analyze_prologue (gdbarch, cache->start_pc, current_pc,
                             cache, this_frame);
 
   if (cache->start_pc)
     tilegx_analyze_prologue (gdbarch, cache->start_pc, current_pc,
                             cache, this_frame);
 

+  cache->saved_regs[TILEGX_PC_REGNUM] = cache->saved_regs[TILEGX_LR_REGNUM];
+

   return cache;
 }
 
   return cache;
 }
 


@@ -873,29 +930,6 @@ static const struct frame_base tilegx_frame_base = {
   tilegx_frame_base_address
 };
 
   tilegx_frame_base_address
 };
 

-static CORE_ADDR
-tilegx_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
-  return frame_unwind_register_unsigned (next_frame, TILEGX_SP_REGNUM);
-}
-
-static CORE_ADDR
-tilegx_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
-  return frame_unwind_register_unsigned (next_frame, TILEGX_PC_REGNUM);
-}
-
-static struct frame_id
-tilegx_unwind_dummy_id (struct gdbarch *gdbarch,
-                       struct frame_info *this_frame)
-{
-  CORE_ADDR sp;
-
-  sp = get_frame_register_unsigned (this_frame, TILEGX_SP_REGNUM);
-  return frame_id_build (sp, get_frame_pc (this_frame));
-}
-
-

 /* We cannot read/write the "special" registers.  */
 
 static int
 /* We cannot read/write the "special" registers.  */
 
 static int


@@ -903,7 +937,8 @@ tilegx_cannot_reference_register (struct gdbarch *gdbarch, int regno)
 {
   if (regno >= 0 && regno < TILEGX_NUM_EASY_REGS)
     return 0;
 {
   if (regno >= 0 && regno < TILEGX_NUM_EASY_REGS)
     return 0;

-  else if (regno == TILEGX_PC_REGNUM)
+  else if (regno == TILEGX_PC_REGNUM
+           || regno == TILEGX_FAULTNUM_REGNUM)

     return 0;
   else
     return 1;
     return 0;
   else
     return 1;


@@ -948,7 +983,6 @@ tilegx_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_register_name (gdbarch, tilegx_register_name);
   set_gdbarch_register_type (gdbarch, tilegx_register_type);
 
   set_gdbarch_register_name (gdbarch, tilegx_register_name);
   set_gdbarch_register_type (gdbarch, tilegx_register_type);
 

-  set_gdbarch_char_signed (gdbarch, 0);

   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
   set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
   set_gdbarch_long_bit (gdbarch, arch_size);
   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
   set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
   set_gdbarch_long_bit (gdbarch, arch_size);


@@ -970,27 +1004,26 @@ tilegx_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 
   /* Frame Info.  */
   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 
   /* Frame Info.  */

-  set_gdbarch_unwind_sp (gdbarch, tilegx_unwind_sp);
-  set_gdbarch_unwind_pc (gdbarch, tilegx_unwind_pc);
-  set_gdbarch_dummy_id (gdbarch, tilegx_unwind_dummy_id);

   set_gdbarch_frame_align (gdbarch, tilegx_frame_align);
   frame_base_set_default (gdbarch, &tilegx_frame_base);
 
   set_gdbarch_skip_prologue (gdbarch, tilegx_skip_prologue);
 
   set_gdbarch_frame_align (gdbarch, tilegx_frame_align);
   frame_base_set_default (gdbarch, &tilegx_frame_base);
 
   set_gdbarch_skip_prologue (gdbarch, tilegx_skip_prologue);
 

-  set_gdbarch_in_function_epilogue_p (gdbarch,
-                                     tilegx_in_function_epilogue_p);
+  set_gdbarch_stack_frame_destroyed_p (gdbarch, tilegx_stack_frame_destroyed_p);

 
   /* Map debug registers into internal register numbers.  */
   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, tilegx_dwarf2_reg_to_regnum);
 
   /* These values and methods are used when gdb calls a target function.  */
   set_gdbarch_push_dummy_call (gdbarch, tilegx_push_dummy_call);
 
   /* Map debug registers into internal register numbers.  */
   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, tilegx_dwarf2_reg_to_regnum);
 
   /* These values and methods are used when gdb calls a target function.  */
   set_gdbarch_push_dummy_call (gdbarch, tilegx_push_dummy_call);

-  set_gdbarch_breakpoint_from_pc (gdbarch, tilegx_breakpoint_from_pc);
+  set_gdbarch_get_longjmp_target (gdbarch, tilegx_get_longjmp_target);
+  set_gdbarch_write_pc (gdbarch, tilegx_write_pc);
+  set_gdbarch_breakpoint_kind_from_pc (gdbarch,
+                                      tilegx_breakpoint::kind_from_pc);
+  set_gdbarch_sw_breakpoint_from_kind (gdbarch,
+                                      tilegx_breakpoint::bp_from_kind);

   set_gdbarch_return_value (gdbarch, tilegx_return_value);
 
   set_gdbarch_return_value (gdbarch, tilegx_return_value);
 

-  set_gdbarch_print_insn (gdbarch, print_insn_tilegx);
-

   gdbarch_init_osabi (info, gdbarch);
 
   dwarf2_append_unwinders (gdbarch);
   gdbarch_init_osabi (info, gdbarch);
 
   dwarf2_append_unwinders (gdbarch);


@@ -999,9 +1032,6 @@ tilegx_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   return gdbarch;
 }
 
   return gdbarch;
 }
 

-/* Provide a prototype to silence -Wmissing-prototypes.  */
-extern initialize_file_ftype _initialize_tilegx_tdep;
-

 void
 _initialize_tilegx_tdep (void)
 {
 void
 _initialize_tilegx_tdep (void)
 {