gdb/ft32-tdep.c

   1 /* Target-dependent code for FT32.
   2
   3    Copyright (C) 2009-2019 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "frame.h"
  22 #include "frame-unwind.h"
  23 #include "frame-base.h"
  24 #include "symtab.h"
  25 #include "gdbtypes.h"
  26 #include "gdbcmd.h"
  27 #include "gdbcore.h"
  28 #include "value.h"
  29 #include "inferior.h"
  30 #include "symfile.h"
  31 #include "objfiles.h"
  32 #include "osabi.h"
  33 #include "language.h"
  34 #include "arch-utils.h"
  35 #include "regcache.h"
  36 #include "trad-frame.h"
  37 #include "dis-asm.h"
  38 #include "record.h"
  39
  40 #include "opcode/ft32.h"
  41
  42 #include "ft32-tdep.h"
  43 #include "gdb/sim-ft32.h"
  44 #include <algorithm>
  45
  46 #define RAM_BIAS  0x800000  /* Bias added to RAM addresses.  */
  47
  48 /* Use an invalid address -1 as 'not available' marker.  */
  49 enum { REG_UNAVAIL = (CORE_ADDR) (-1) };
  50
  51 struct ft32_frame_cache
  52 {
  53   /* Base address of the frame */
  54   CORE_ADDR base;
  55   /* Function this frame belongs to */
  56   CORE_ADDR pc;
  57   /* Total size of this frame */
  58   LONGEST framesize;
  59   /* Saved registers in this frame */
  60   CORE_ADDR saved_regs[FT32_NUM_REGS];
  61   /* Saved SP in this frame */
  62   CORE_ADDR saved_sp;
  63   /* Has the new frame been LINKed.  */
  64   bfd_boolean established;
  65 };
  66
  67 /* Implement the "frame_align" gdbarch method.  */
  68
  69 static CORE_ADDR
  70 ft32_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
  71 {
  72   /* Align to the size of an instruction (so that they can safely be
  73      pushed onto the stack.  */
  74   return sp & ~1;
  75 }
  76
  77
  78 constexpr gdb_byte ft32_break_insn[] = { 0x02, 0x00, 0x34, 0x00 };
  79
  80 typedef BP_MANIPULATION (ft32_break_insn) ft32_breakpoint;
  81
  82 /* FT32 register names.  */
  83
  84 static const char *const ft32_register_names[] =
  85 {
  86     "fp", "sp",
  87     "r0", "r1", "r2", "r3",  "r4", "r5", "r6", "r7",
  88     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
  89     "r16", "r17", "r18", "r19",  "r20", "r21", "r22", "r23",
  90     "r24", "r25", "r26", "r27", "r28", "cc",
  91     "pc"
  92 };
  93
  94 /* Implement the "register_name" gdbarch method.  */
  95
  96 static const char *
  97 ft32_register_name (struct gdbarch *gdbarch, int reg_nr)
  98 {
  99   if (reg_nr < 0)
 100     return NULL;
 101   if (reg_nr >= FT32_NUM_REGS)
 102     return NULL;
 103   return ft32_register_names[reg_nr];
 104 }
 105
 106 /* Implement the "register_type" gdbarch method.  */
 107
 108 static struct type *
 109 ft32_register_type (struct gdbarch *gdbarch, int reg_nr)
 110 {
 111   if (reg_nr == FT32_PC_REGNUM)
 112     return gdbarch_tdep (gdbarch)->pc_type;
 113   else if (reg_nr == FT32_SP_REGNUM || reg_nr == FT32_FP_REGNUM)
 114     return builtin_type (gdbarch)->builtin_data_ptr;
 115   else
 116     return builtin_type (gdbarch)->builtin_int32;
 117 }
 118
 119 /* Write into appropriate registers a function return value
 120    of type TYPE, given in virtual format.  */
 121
 122 static void
 123 ft32_store_return_value (struct type *type, struct regcache *regcache,
 124                          const gdb_byte *valbuf)
 125 {
 126   struct gdbarch *gdbarch = regcache->arch ();
 127   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 128   CORE_ADDR regval;
 129   int len = TYPE_LENGTH (type);
 130
 131   /* Things always get returned in RET1_REGNUM, RET2_REGNUM.  */
 132   regval = extract_unsigned_integer (valbuf, len > 4 ? 4 : len, byte_order);
 133   regcache_cooked_write_unsigned (regcache, FT32_R0_REGNUM, regval);
 134   if (len > 4)
 135     {
 136       regval = extract_unsigned_integer (valbuf + 4,
 137                                          len - 4, byte_order);
 138       regcache_cooked_write_unsigned (regcache, FT32_R1_REGNUM, regval);
 139     }
 140 }
 141
 142 /* Fetch a single 32-bit instruction from address a. If memory contains
 143    a compressed instruction pair, return the expanded instruction.  */
 144
 145 static ULONGEST
 146 ft32_fetch_instruction (CORE_ADDR a, int *isize,
 147                         enum bfd_endian byte_order)
 148 {
 149   unsigned int sc[2];
 150   ULONGEST inst;
 151
 152   CORE_ADDR a4 = a & ~3;
 153   inst = read_code_unsigned_integer (a4, 4, byte_order);
 154   *isize = ft32_decode_shortcode (a4, inst, sc) ? 2 : 4;
 155   if (*isize == 2)
 156     return sc[1 & (a >> 1)];
 157   else
 158     return inst;
 159 }
 160
 161 /* Decode the instructions within the given address range.  Decide
 162    when we must have reached the end of the function prologue.  If a
 163    frame_info pointer is provided, fill in its saved_regs etc.
 164
 165    Returns the address of the first instruction after the prologue.  */
 166
 167 static CORE_ADDR
 168 ft32_analyze_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
 169                        struct ft32_frame_cache *cache,
 170                        struct gdbarch *gdbarch)
 171 {
 172   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 173   CORE_ADDR next_addr;
 174   ULONGEST inst;
 175   int isize = 0;
 176   int regnum, pushreg;
 177   struct bound_minimal_symbol msymbol;
 178   const int first_saved_reg = 13;       /* The first saved register.  */
 179   /* PROLOGS are addresses of the subroutine prologs, PROLOGS[n]
 180      is the address of __prolog_$rN.
 181      __prolog_$rN pushes registers from 13 through n inclusive.
 182      So for example CALL __prolog_$r15 is equivalent to:
 183        PUSH $r13
 184        PUSH $r14
 185        PUSH $r15
 186      Note that PROLOGS[0] through PROLOGS[12] are unused.  */
 187   CORE_ADDR prologs[32];
 188
 189   cache->saved_regs[FT32_PC_REGNUM] = 0;
 190   cache->framesize = 0;
 191
 192   for (regnum = first_saved_reg; regnum < 32; regnum++)
 193     {
 194       char prolog_symbol[32];
 195
 196       snprintf (prolog_symbol, sizeof (prolog_symbol), "__prolog_$r%02d",
 197                 regnum);
 198       msymbol = lookup_minimal_symbol (prolog_symbol, NULL, NULL);
 199       if (msymbol.minsym)
 200         prologs[regnum] = BMSYMBOL_VALUE_ADDRESS (msymbol);
 201       else
 202         prologs[regnum] = 0;
 203     }
 204
 205   if (start_addr >= end_addr)
 206     return end_addr;
 207
 208   cache->established = 0;
 209   for (next_addr = start_addr; next_addr < end_addr; next_addr += isize)
 210     {
 211       inst = ft32_fetch_instruction (next_addr, &isize, byte_order);
 212
 213       if (FT32_IS_PUSH (inst))
 214         {
 215           pushreg = FT32_PUSH_REG (inst);
 216           cache->framesize += 4;
 217           cache->saved_regs[FT32_R0_REGNUM + pushreg] = cache->framesize;
 218         }
 219       else if (FT32_IS_CALL (inst))
 220         {
 221           for (regnum = first_saved_reg; regnum < 32; regnum++)
 222             {
 223               if ((4 * (inst & 0x3ffff)) == prologs[regnum])
 224                 {
 225                   for (pushreg = first_saved_reg; pushreg <= regnum;
 226                        pushreg++)
 227                     {
 228                       cache->framesize += 4;
 229                       cache->saved_regs[FT32_R0_REGNUM + pushreg] =
 230                         cache->framesize;
 231                     }
 232                 }
 233             }
 234           break;
 235         }
 236       else
 237         break;
 238     }
 239   for (regnum = FT32_R0_REGNUM; regnum < FT32_PC_REGNUM; regnum++)
 240     {
 241       if (cache->saved_regs[regnum] != REG_UNAVAIL)
 242         cache->saved_regs[regnum] =
 243           cache->framesize - cache->saved_regs[regnum];
 244     }
 245   cache->saved_regs[FT32_PC_REGNUM] = cache->framesize;
 246
 247   /* It is a LINK?  */
 248   if (next_addr < end_addr)
 249     {
 250       inst = ft32_fetch_instruction (next_addr, &isize, byte_order);
 251       if (FT32_IS_LINK (inst))
 252         {
 253           cache->established = 1;
 254           for (regnum = FT32_R0_REGNUM; regnum < FT32_PC_REGNUM; regnum++)
 255             {
 256               if (cache->saved_regs[regnum] != REG_UNAVAIL)
 257                 cache->saved_regs[regnum] += 4;
 258             }
 259           cache->saved_regs[FT32_PC_REGNUM] = cache->framesize + 4;
 260           cache->saved_regs[FT32_FP_REGNUM] = 0;
 261           cache->framesize += FT32_LINK_SIZE (inst);
 262           next_addr += isize;
 263         }
 264     }
 265
 266   return next_addr;
 267 }
 268
 269 /* Find the end of function prologue.  */
 270
 271 static CORE_ADDR
 272 ft32_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 273 {
 274   CORE_ADDR func_addr = 0, func_end = 0;
 275   const char *func_name;
 276
 277   /* See if we can determine the end of the prologue via the symbol table.
 278      If so, then return either PC, or the PC after the prologue, whichever
 279      is greater.  */
 280   if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
 281     {
 282       CORE_ADDR post_prologue_pc
 283         = skip_prologue_using_sal (gdbarch, func_addr);
 284       if (post_prologue_pc != 0)
 285         return std::max (pc, post_prologue_pc);
 286       else
 287         {
 288           /* Can't determine prologue from the symbol table, need to examine
 289              instructions.  */
 290           struct symtab_and_line sal;
 291           struct symbol *sym;
 292           struct ft32_frame_cache cache;
 293           CORE_ADDR plg_end;
 294
 295           memset (&cache, 0, sizeof cache);
 296
 297           plg_end = ft32_analyze_prologue (func_addr,
 298                                            func_end, &cache, gdbarch);
 299           /* Found a function.  */
 300           sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol;
 301           /* Don't use line number debug info for assembly source files.  */
 302           if ((sym != NULL) && SYMBOL_LANGUAGE (sym) != language_asm)
 303             {
 304               sal = find_pc_line (func_addr, 0);
 305               if (sal.end && sal.end < func_end)
 306                 {
 307                   /* Found a line number, use it as end of prologue.  */
 308                   return sal.end;
 309                 }
 310             }
 311           /* No useable line symbol.  Use result of prologue parsing method.  */
 312           return plg_end;
 313         }
 314     }
 315
 316   /* No function symbol -- just return the PC.  */
 317   return pc;
 318 }
 319
 320 /* Implementation of `pointer_to_address' gdbarch method.
 321
 322    On FT32 address space zero is RAM, address space 1 is flash.
 323    RAM appears at address RAM_BIAS, flash at address 0.  */
 324
 325 static CORE_ADDR
 326 ft32_pointer_to_address (struct gdbarch *gdbarch,
 327                          struct type *type, const gdb_byte *buf)
 328 {
 329   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 330   CORE_ADDR addr
 331     = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
 332
 333   if (TYPE_ADDRESS_CLASS_1 (type))
 334     return addr;
 335   else
 336     return addr | RAM_BIAS;
 337 }
 338
 339 /* Implementation of `address_class_type_flags' gdbarch method.
 340
 341    This method maps DW_AT_address_class attributes to a
 342    type_instance_flag_value.  */
 343
 344 static int
 345 ft32_address_class_type_flags (int byte_size, int dwarf2_addr_class)
 346 {
 347   /* The value 1 of the DW_AT_address_class attribute corresponds to the
 348      __flash__ qualifier, meaning pointer to data in FT32 program memory.
 349    */
 350   if (dwarf2_addr_class == 1)
 351     return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
 352   return 0;
 353 }
 354
 355 /* Implementation of `address_class_type_flags_to_name' gdbarch method.
 356
 357    Convert a type_instance_flag_value to an address space qualifier.  */
 358
 359 static const char*
 360 ft32_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
 361 {
 362   if (type_flags & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
 363     return "flash";
 364   else
 365     return NULL;
 366 }
 367
 368 /* Implementation of `address_class_name_to_type_flags' gdbarch method.
 369
 370    Convert an address space qualifier to a type_instance_flag_value.  */
 371
 372 static int
 373 ft32_address_class_name_to_type_flags (struct gdbarch *gdbarch,
 374                                        const char* name,
 375                                        int *type_flags_ptr)
 376 {
 377   if (strcmp (name, "flash") == 0)
 378     {
 379       *type_flags_ptr = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
 380       return 1;
 381     }
 382   else
 383     return 0;
 384 }
 385
 386 /* Implement the "unwind_sp" gdbarch method.  */
 387
 388 static CORE_ADDR
 389 ft32_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 390 {
 391   return frame_unwind_register_unsigned (next_frame, FT32_SP_REGNUM);
 392 }
 393
 394 /* Given a return value in `regbuf' with a type `valtype',
 395    extract and copy its value into `valbuf'.  */
 396
 397 static void
 398 ft32_extract_return_value (struct type *type, struct regcache *regcache,
 399                            gdb_byte *dst)
 400 {
 401   struct gdbarch *gdbarch = regcache->arch ();
 402   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 403   bfd_byte *valbuf = dst;
 404   int len = TYPE_LENGTH (type);
 405   ULONGEST tmp;
 406
 407   /* By using store_unsigned_integer we avoid having to do
 408      anything special for small big-endian values.  */
 409   regcache_cooked_read_unsigned (regcache, FT32_R0_REGNUM, &tmp);
 410   store_unsigned_integer (valbuf, (len > 4 ? len - 4 : len), byte_order, tmp);
 411
 412   /* Ignore return values more than 8 bytes in size because the ft32
 413      returns anything more than 8 bytes in the stack.  */
 414   if (len > 4)
 415     {
 416       regcache_cooked_read_unsigned (regcache, FT32_R1_REGNUM, &tmp);
 417       store_unsigned_integer (valbuf + len - 4, 4, byte_order, tmp);
 418     }
 419 }
 420
 421 /* Implement the "return_value" gdbarch method.  */
 422
 423 static enum return_value_convention
 424 ft32_return_value (struct gdbarch *gdbarch, struct value *function,
 425                    struct type *valtype, struct regcache *regcache,
 426                    gdb_byte *readbuf, const gdb_byte *writebuf)
 427 {
 428   if (TYPE_LENGTH (valtype) > 8)
 429     return RETURN_VALUE_STRUCT_CONVENTION;
 430   else
 431     {
 432       if (readbuf != NULL)
 433         ft32_extract_return_value (valtype, regcache, readbuf);
 434       if (writebuf != NULL)
 435         ft32_store_return_value (valtype, regcache, writebuf);
 436       return RETURN_VALUE_REGISTER_CONVENTION;
 437     }
 438 }
 439
 440 /* Allocate and initialize a ft32_frame_cache object.  */
 441
 442 static struct ft32_frame_cache *
 443 ft32_alloc_frame_cache (void)
 444 {
 445   struct ft32_frame_cache *cache;
 446   int i;
 447
 448   cache = FRAME_OBSTACK_ZALLOC (struct ft32_frame_cache);
 449
 450   for (i = 0; i < FT32_NUM_REGS; ++i)
 451     cache->saved_regs[i] = REG_UNAVAIL;
 452
 453   return cache;
 454 }
 455
 456 /* Populate a ft32_frame_cache object for this_frame.  */
 457
 458 static struct ft32_frame_cache *
 459 ft32_frame_cache (struct frame_info *this_frame, void **this_cache)
 460 {
 461   struct ft32_frame_cache *cache;
 462   CORE_ADDR current_pc;
 463   int i;
 464
 465   if (*this_cache)
 466     return (struct ft32_frame_cache *) *this_cache;
 467
 468   cache = ft32_alloc_frame_cache ();
 469   *this_cache = cache;
 470
 471   cache->base = get_frame_register_unsigned (this_frame, FT32_FP_REGNUM);
 472   if (cache->base == 0)
 473     return cache;
 474
 475   cache->pc = get_frame_func (this_frame);
 476   current_pc = get_frame_pc (this_frame);
 477   if (cache->pc)
 478     {
 479       struct gdbarch *gdbarch = get_frame_arch (this_frame);
 480
 481       ft32_analyze_prologue (cache->pc, current_pc, cache, gdbarch);
 482       if (!cache->established)
 483         cache->base = get_frame_register_unsigned (this_frame, FT32_SP_REGNUM);
 484     }
 485
 486   cache->saved_sp = cache->base - 4;
 487
 488   for (i = 0; i < FT32_NUM_REGS; ++i)
 489     if (cache->saved_regs[i] != REG_UNAVAIL)
 490       cache->saved_regs[i] = cache->base + cache->saved_regs[i];
 491
 492   return cache;
 493 }
 494
 495 /* Implement the "unwind_pc" gdbarch method.  */
 496
 497 static CORE_ADDR
 498 ft32_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 499 {
 500   return frame_unwind_register_unsigned (next_frame, FT32_PC_REGNUM);
 501 }
 502
 503 /* Given a GDB frame, determine the address of the calling function's
 504    frame.  This will be used to create a new GDB frame struct.  */
 505
 506 static void
 507 ft32_frame_this_id (struct frame_info *this_frame,
 508                     void **this_prologue_cache, struct frame_id *this_id)
 509 {
 510   struct ft32_frame_cache *cache = ft32_frame_cache (this_frame,
 511                                                      this_prologue_cache);
 512
 513   /* This marks the outermost frame.  */
 514   if (cache->base == 0)
 515     return;
 516
 517   *this_id = frame_id_build (cache->saved_sp, cache->pc);
 518 }
 519
 520 /* Get the value of register regnum in the previous stack frame.  */
 521
 522 static struct value *
 523 ft32_frame_prev_register (struct frame_info *this_frame,
 524                           void **this_prologue_cache, int regnum)
 525 {
 526   struct ft32_frame_cache *cache = ft32_frame_cache (this_frame,
 527                                                      this_prologue_cache);
 528
 529   gdb_assert (regnum >= 0);
 530
 531   if (regnum == FT32_SP_REGNUM && cache->saved_sp)
 532     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
 533
 534   if (regnum < FT32_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
 535       return frame_unwind_got_memory (this_frame, regnum,
 536                                       RAM_BIAS | cache->saved_regs[regnum]);
 537
 538   return frame_unwind_got_register (this_frame, regnum, regnum);
 539 }
 540
 541 static const struct frame_unwind ft32_frame_unwind =
 542 {
 543   NORMAL_FRAME,
 544   default_frame_unwind_stop_reason,
 545   ft32_frame_this_id,
 546   ft32_frame_prev_register,
 547   NULL,
 548   default_frame_sniffer
 549 };
 550
 551 /* Return the base address of this_frame.  */
 552
 553 static CORE_ADDR
 554 ft32_frame_base_address (struct frame_info *this_frame, void **this_cache)
 555 {
 556   struct ft32_frame_cache *cache = ft32_frame_cache (this_frame,
 557                                                      this_cache);
 558
 559   return cache->base;
 560 }
 561
 562 static const struct frame_base ft32_frame_base =
 563 {
 564   &ft32_frame_unwind,
 565   ft32_frame_base_address,
 566   ft32_frame_base_address,
 567   ft32_frame_base_address
 568 };
 569
 570 static struct frame_id
 571 ft32_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 572 {
 573   CORE_ADDR sp = get_frame_register_unsigned (this_frame, FT32_SP_REGNUM);
 574
 575   return frame_id_build (sp, get_frame_pc (this_frame));
 576 }
 577
 578 /* Allocate and initialize the ft32 gdbarch object.  */
 579
 580 static struct gdbarch *
 581 ft32_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 582 {
 583   struct gdbarch *gdbarch;
 584   struct gdbarch_tdep *tdep;
 585   struct type *void_type;
 586   struct type *func_void_type;
 587
 588   /* If there is already a candidate, use it.  */
 589   arches = gdbarch_list_lookup_by_info (arches, &info);
 590   if (arches != NULL)
 591     return arches->gdbarch;
 592
 593   /* Allocate space for the new architecture.  */
 594   tdep = XCNEW (struct gdbarch_tdep);
 595   gdbarch = gdbarch_alloc (&info, tdep);
 596
 597   /* Create a type for PC.  We can't use builtin types here, as they may not
 598      be defined.  */
 599   void_type = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
 600   func_void_type = make_function_type (void_type, NULL);
 601   tdep->pc_type = arch_pointer_type (gdbarch, 4 * TARGET_CHAR_BIT, NULL,
 602                                      func_void_type);
 603   TYPE_INSTANCE_FLAGS (tdep->pc_type) |= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
 604
 605   set_gdbarch_unwind_sp (gdbarch, ft32_unwind_sp);
 606
 607   set_gdbarch_num_regs (gdbarch, FT32_NUM_REGS);
 608   set_gdbarch_sp_regnum (gdbarch, FT32_SP_REGNUM);
 609   set_gdbarch_pc_regnum (gdbarch, FT32_PC_REGNUM);
 610   set_gdbarch_register_name (gdbarch, ft32_register_name);
 611   set_gdbarch_register_type (gdbarch, ft32_register_type);
 612
 613   set_gdbarch_return_value (gdbarch, ft32_return_value);
 614
 615   set_gdbarch_pointer_to_address (gdbarch, ft32_pointer_to_address);
 616
 617   set_gdbarch_skip_prologue (gdbarch, ft32_skip_prologue);
 618   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 619   set_gdbarch_breakpoint_kind_from_pc (gdbarch, ft32_breakpoint::kind_from_pc);
 620   set_gdbarch_sw_breakpoint_from_kind (gdbarch, ft32_breakpoint::bp_from_kind);
 621   set_gdbarch_frame_align (gdbarch, ft32_frame_align);
 622
 623   frame_base_set_default (gdbarch, &ft32_frame_base);
 624
 625   /* Methods for saving / extracting a dummy frame's ID.  The ID's
 626      stack address must match the SP value returned by
 627      PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos.  */
 628   set_gdbarch_dummy_id (gdbarch, ft32_dummy_id);
 629
 630   set_gdbarch_unwind_pc (gdbarch, ft32_unwind_pc);
 631
 632   /* Hook in ABI-specific overrides, if they have been registered.  */
 633   gdbarch_init_osabi (info, gdbarch);
 634
 635   /* Hook in the default unwinders.  */
 636   frame_unwind_append_unwinder (gdbarch, &ft32_frame_unwind);
 637
 638   /* Support simple overlay manager.  */
 639   set_gdbarch_overlay_update (gdbarch, simple_overlay_update);
 640
 641   set_gdbarch_address_class_type_flags (gdbarch, ft32_address_class_type_flags);
 642   set_gdbarch_address_class_name_to_type_flags
 643     (gdbarch, ft32_address_class_name_to_type_flags);
 644   set_gdbarch_address_class_type_flags_to_name
 645     (gdbarch, ft32_address_class_type_flags_to_name);
 646
 647   return gdbarch;
 648 }
 649
 650 /* Register this machine's init routine.  */
 651
 652 void
 653 _initialize_ft32_tdep (void)
 654 {
 655   register_gdbarch_init (bfd_arch_ft32, ft32_gdbarch_init);
 656 }