gdb/ft32-tdep.c

   1 /* Target-dependent code for FT32.
   2
   3    Copyright (C) 2009-2024 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 "extract-store-integer.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 "cli/cli-cmds.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 "sim/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   static_assert (ARRAY_SIZE (ft32_register_names) == FT32_NUM_REGS);
 100   return ft32_register_names[reg_nr];
 101 }
 102
 103 /* Implement the "register_type" gdbarch method.  */
 104
 105 static struct type *
 106 ft32_register_type (struct gdbarch *gdbarch, int reg_nr)
 107 {
 108   if (reg_nr == FT32_PC_REGNUM)
 109     {
 110       ft32_gdbarch_tdep *tdep = gdbarch_tdep<ft32_gdbarch_tdep> (gdbarch);
 111       return tdep->pc_type;
 112     }
 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 ();
 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   const int first_saved_reg = 13;       /* The first saved register.  */
 178
 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       bound_minimal_symbol msymbol
 199         = lookup_minimal_symbol (current_program_space, prolog_symbol);
 200       if (msymbol.minsym)
 201         prologs[regnum] = msymbol.value_address ();
 202       else
 203         prologs[regnum] = 0;
 204     }
 205
 206   if (start_addr >= end_addr)
 207     return end_addr;
 208
 209   cache->established = 0;
 210   for (next_addr = start_addr; next_addr < end_addr; next_addr += isize)
 211     {
 212       inst = ft32_fetch_instruction (next_addr, &isize, byte_order);
 213
 214       if (FT32_IS_PUSH (inst))
 215         {
 216           pushreg = FT32_PUSH_REG (inst);
 217           cache->framesize += 4;
 218           cache->saved_regs[FT32_R0_REGNUM + pushreg] = cache->framesize;
 219         }
 220       else if (FT32_IS_CALL (inst))
 221         {
 222           for (regnum = first_saved_reg; regnum < 32; regnum++)
 223             {
 224               if ((4 * (inst & 0x3ffff)) == prologs[regnum])
 225                 {
 226                   for (pushreg = first_saved_reg; pushreg <= regnum;
 227                        pushreg++)
 228                     {
 229                       cache->framesize += 4;
 230                       cache->saved_regs[FT32_R0_REGNUM + pushreg] =
 231                         cache->framesize;
 232                     }
 233                 }
 234             }
 235           break;
 236         }
 237       else
 238         break;
 239     }
 240   for (regnum = FT32_R0_REGNUM; regnum < FT32_PC_REGNUM; regnum++)
 241     {
 242       if (cache->saved_regs[regnum] != REG_UNAVAIL)
 243         cache->saved_regs[regnum] =
 244           cache->framesize - cache->saved_regs[regnum];
 245     }
 246   cache->saved_regs[FT32_PC_REGNUM] = cache->framesize;
 247
 248   /* It is a LINK?  */
 249   if (next_addr < end_addr)
 250     {
 251       inst = ft32_fetch_instruction (next_addr, &isize, byte_order);
 252       if (FT32_IS_LINK (inst))
 253         {
 254           cache->established = 1;
 255           for (regnum = FT32_R0_REGNUM; regnum < FT32_PC_REGNUM; regnum++)
 256             {
 257               if (cache->saved_regs[regnum] != REG_UNAVAIL)
 258                 cache->saved_regs[regnum] += 4;
 259             }
 260           cache->saved_regs[FT32_PC_REGNUM] = cache->framesize + 4;
 261           cache->saved_regs[FT32_FP_REGNUM] = 0;
 262           cache->framesize += FT32_LINK_SIZE (inst);
 263           next_addr += isize;
 264         }
 265     }
 266
 267   return next_addr;
 268 }
 269
 270 /* Find the end of function prologue.  */
 271
 272 static CORE_ADDR
 273 ft32_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 274 {
 275   CORE_ADDR func_addr = 0, func_end = 0;
 276   const char *func_name;
 277
 278   /* See if we can determine the end of the prologue via the symbol table.
 279      If so, then return either PC, or the PC after the prologue, whichever
 280      is greater.  */
 281   if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
 282     {
 283       CORE_ADDR post_prologue_pc
 284         = skip_prologue_using_sal (gdbarch, func_addr);
 285       if (post_prologue_pc != 0)
 286         return std::max (pc, post_prologue_pc);
 287       else
 288         {
 289           /* Can't determine prologue from the symbol table, need to examine
 290              instructions.  */
 291           struct symtab_and_line sal;
 292           struct symbol *sym;
 293           struct ft32_frame_cache cache;
 294           CORE_ADDR plg_end;
 295
 296           memset (&cache, 0, sizeof cache);
 297
 298           plg_end = ft32_analyze_prologue (func_addr,
 299                                            func_end, &cache, gdbarch);
 300           /* Found a function.  */
 301           sym = lookup_symbol (func_name, nullptr, SEARCH_FUNCTION_DOMAIN,
 302                                nullptr).symbol;
 303           /* Don't use line number debug info for assembly source files.  */
 304           if ((sym != NULL) && sym->language () != language_asm)
 305             {
 306               sal = find_pc_line (func_addr, 0);
 307               if (sal.end && sal.end < func_end)
 308                 {
 309                   /* Found a line number, use it as end of prologue.  */
 310                   return sal.end;
 311                 }
 312             }
 313           /* No useable line symbol.  Use result of prologue parsing method.  */
 314           return plg_end;
 315         }
 316     }
 317
 318   /* No function symbol -- just return the PC.  */
 319   return pc;
 320 }
 321
 322 /* Implementation of `pointer_to_address' gdbarch method.
 323
 324    On FT32 address space zero is RAM, address space 1 is flash.
 325    RAM appears at address RAM_BIAS, flash at address 0.  */
 326
 327 static CORE_ADDR
 328 ft32_pointer_to_address (struct gdbarch *gdbarch,
 329                          struct type *type, const gdb_byte *buf)
 330 {
 331   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 332   CORE_ADDR addr
 333     = extract_unsigned_integer (buf, type->length (), byte_order);
 334
 335   if (TYPE_ADDRESS_CLASS_1 (type))
 336     return addr;
 337   else
 338     return addr | RAM_BIAS;
 339 }
 340
 341 /* Implementation of `address_class_type_flags' gdbarch method.
 342
 343    This method maps DW_AT_address_class attributes to a
 344    type_instance_flag_value.  */
 345
 346 static type_instance_flags
 347 ft32_address_class_type_flags (int byte_size, int dwarf2_addr_class)
 348 {
 349   /* The value 1 of the DW_AT_address_class attribute corresponds to the
 350      __flash__ qualifier, meaning pointer to data in FT32 program memory.
 351    */
 352   if (dwarf2_addr_class == 1)
 353     return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
 354   return 0;
 355 }
 356
 357 /* Implementation of `address_class_type_flags_to_name' gdbarch method.
 358
 359    Convert a type_instance_flag_value to an address space qualifier.  */
 360
 361 static const char*
 362 ft32_address_class_type_flags_to_name (struct gdbarch *gdbarch,
 363                                        type_instance_flags type_flags)
 364 {
 365   if (type_flags & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
 366     return "flash";
 367   else
 368     return NULL;
 369 }
 370
 371 /* Implementation of `address_class_name_to_type_flags' gdbarch method.
 372
 373    Convert an address space qualifier to a type_instance_flag_value.  */
 374
 375 static bool
 376 ft32_address_class_name_to_type_flags (struct gdbarch *gdbarch,
 377                                        const char* name,
 378                                        type_instance_flags *type_flags_ptr)
 379 {
 380   if (strcmp (name, "flash") == 0)
 381     {
 382       *type_flags_ptr = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
 383       return true;
 384     }
 385   else
 386     return false;
 387 }
 388
 389 /* Given a return value in `regbuf' with a type `valtype',
 390    extract and copy its value into `valbuf'.  */
 391
 392 static void
 393 ft32_extract_return_value (struct type *type, struct regcache *regcache,
 394                            gdb_byte *dst)
 395 {
 396   struct gdbarch *gdbarch = regcache->arch ();
 397   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 398   bfd_byte *valbuf = dst;
 399   int len = type->length ();
 400   ULONGEST tmp;
 401
 402   /* By using store_unsigned_integer we avoid having to do
 403      anything special for small big-endian values.  */
 404   regcache_cooked_read_unsigned (regcache, FT32_R0_REGNUM, &tmp);
 405   store_unsigned_integer (valbuf, (len > 4 ? len - 4 : len), byte_order, tmp);
 406
 407   /* Ignore return values more than 8 bytes in size because the ft32
 408      returns anything more than 8 bytes in the stack.  */
 409   if (len > 4)
 410     {
 411       regcache_cooked_read_unsigned (regcache, FT32_R1_REGNUM, &tmp);
 412       store_unsigned_integer (valbuf + len - 4, 4, byte_order, tmp);
 413     }
 414 }
 415
 416 /* Implement the "return_value" gdbarch method.  */
 417
 418 static enum return_value_convention
 419 ft32_return_value (struct gdbarch *gdbarch, struct value *function,
 420                    struct type *valtype, struct regcache *regcache,
 421                    gdb_byte *readbuf, const gdb_byte *writebuf)
 422 {
 423   if (valtype->length () > 8)
 424     return RETURN_VALUE_STRUCT_CONVENTION;
 425   else
 426     {
 427       if (readbuf != NULL)
 428         ft32_extract_return_value (valtype, regcache, readbuf);
 429       if (writebuf != NULL)
 430         ft32_store_return_value (valtype, regcache, writebuf);
 431       return RETURN_VALUE_REGISTER_CONVENTION;
 432     }
 433 }
 434
 435 /* Allocate and initialize a ft32_frame_cache object.  */
 436
 437 static struct ft32_frame_cache *
 438 ft32_alloc_frame_cache (void)
 439 {
 440   struct ft32_frame_cache *cache;
 441   int i;
 442
 443   cache = FRAME_OBSTACK_ZALLOC (struct ft32_frame_cache);
 444
 445   for (i = 0; i < FT32_NUM_REGS; ++i)
 446     cache->saved_regs[i] = REG_UNAVAIL;
 447
 448   return cache;
 449 }
 450
 451 /* Populate a ft32_frame_cache object for this_frame.  */
 452
 453 static struct ft32_frame_cache *
 454 ft32_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
 455 {
 456   struct ft32_frame_cache *cache;
 457   CORE_ADDR current_pc;
 458   int i;
 459
 460   if (*this_cache)
 461     return (struct ft32_frame_cache *) *this_cache;
 462
 463   cache = ft32_alloc_frame_cache ();
 464   *this_cache = cache;
 465
 466   cache->base = get_frame_register_unsigned (this_frame, FT32_FP_REGNUM);
 467   if (cache->base == 0)
 468     return cache;
 469
 470   cache->pc = get_frame_func (this_frame);
 471   current_pc = get_frame_pc (this_frame);
 472   if (cache->pc)
 473     {
 474       struct gdbarch *gdbarch = get_frame_arch (this_frame);
 475
 476       ft32_analyze_prologue (cache->pc, current_pc, cache, gdbarch);
 477       if (!cache->established)
 478         cache->base = get_frame_register_unsigned (this_frame, FT32_SP_REGNUM);
 479     }
 480
 481   cache->saved_sp = cache->base - 4;
 482
 483   for (i = 0; i < FT32_NUM_REGS; ++i)
 484     if (cache->saved_regs[i] != REG_UNAVAIL)
 485       cache->saved_regs[i] = cache->base + cache->saved_regs[i];
 486
 487   return cache;
 488 }
 489
 490 /* Given a GDB frame, determine the address of the calling function's
 491    frame.  This will be used to create a new GDB frame struct.  */
 492
 493 static void
 494 ft32_frame_this_id (const frame_info_ptr &this_frame,
 495                     void **this_prologue_cache, struct frame_id *this_id)
 496 {
 497   struct ft32_frame_cache *cache = ft32_frame_cache (this_frame,
 498                                                      this_prologue_cache);
 499
 500   /* This marks the outermost frame.  */
 501   if (cache->base == 0)
 502     return;
 503
 504   *this_id = frame_id_build (cache->saved_sp, cache->pc);
 505 }
 506
 507 /* Get the value of register regnum in the previous stack frame.  */
 508
 509 static struct value *
 510 ft32_frame_prev_register (const frame_info_ptr &this_frame,
 511                           void **this_prologue_cache, int regnum)
 512 {
 513   struct ft32_frame_cache *cache = ft32_frame_cache (this_frame,
 514                                                      this_prologue_cache);
 515
 516   gdb_assert (regnum >= 0);
 517
 518   if (regnum == FT32_SP_REGNUM && cache->saved_sp)
 519     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
 520
 521   if (regnum < FT32_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
 522       return frame_unwind_got_memory (this_frame, regnum,
 523                                       RAM_BIAS | cache->saved_regs[regnum]);
 524
 525   return frame_unwind_got_register (this_frame, regnum, regnum);
 526 }
 527
 528 static const struct frame_unwind_legacy ft32_frame_unwind (
 529   "ft32 prologue",
 530   NORMAL_FRAME,
 531   FRAME_UNWIND_ARCH,
 532   default_frame_unwind_stop_reason,
 533   ft32_frame_this_id,
 534   ft32_frame_prev_register,
 535   NULL,
 536   default_frame_sniffer
 537 );
 538
 539 /* Return the base address of this_frame.  */
 540
 541 static CORE_ADDR
 542 ft32_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
 543 {
 544   struct ft32_frame_cache *cache = ft32_frame_cache (this_frame,
 545                                                      this_cache);
 546
 547   return cache->base;
 548 }
 549
 550 static const struct frame_base ft32_frame_base =
 551 {
 552   &ft32_frame_unwind,
 553   ft32_frame_base_address,
 554   ft32_frame_base_address,
 555   ft32_frame_base_address
 556 };
 557
 558 /* Allocate and initialize the ft32 gdbarch object.  */
 559
 560 static struct gdbarch *
 561 ft32_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 562 {
 563   struct type *void_type;
 564   struct type *func_void_type;
 565
 566   /* If there is already a candidate, use it.  */
 567   arches = gdbarch_list_lookup_by_info (arches, &info);
 568   if (arches != NULL)
 569     return arches->gdbarch;
 570
 571   /* Allocate space for the new architecture.  */
 572   gdbarch *gdbarch
 573     = gdbarch_alloc (&info, gdbarch_tdep_up (new ft32_gdbarch_tdep));
 574   ft32_gdbarch_tdep *tdep = gdbarch_tdep<ft32_gdbarch_tdep> (gdbarch);
 575
 576   /* Create a type for PC.  We can't use builtin types here, as they may not
 577      be defined.  */
 578   type_allocator alloc (gdbarch);
 579   void_type = alloc.new_type (TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
 580   func_void_type = make_function_type (void_type, NULL);
 581   tdep->pc_type = init_pointer_type (alloc, 4 * TARGET_CHAR_BIT, NULL,
 582                                      func_void_type);
 583   tdep->pc_type->set_instance_flags (tdep->pc_type->instance_flags ()
 584                                      | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1);
 585
 586   set_gdbarch_num_regs (gdbarch, FT32_NUM_REGS);
 587   set_gdbarch_sp_regnum (gdbarch, FT32_SP_REGNUM);
 588   set_gdbarch_pc_regnum (gdbarch, FT32_PC_REGNUM);
 589   set_gdbarch_register_name (gdbarch, ft32_register_name);
 590   set_gdbarch_register_type (gdbarch, ft32_register_type);
 591
 592   set_gdbarch_return_value (gdbarch, ft32_return_value);
 593
 594   set_gdbarch_pointer_to_address (gdbarch, ft32_pointer_to_address);
 595
 596   set_gdbarch_skip_prologue (gdbarch, ft32_skip_prologue);
 597   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 598   set_gdbarch_breakpoint_kind_from_pc (gdbarch, ft32_breakpoint::kind_from_pc);
 599   set_gdbarch_sw_breakpoint_from_kind (gdbarch, ft32_breakpoint::bp_from_kind);
 600   set_gdbarch_frame_align (gdbarch, ft32_frame_align);
 601
 602   frame_base_set_default (gdbarch, &ft32_frame_base);
 603
 604   /* Hook in ABI-specific overrides, if they have been registered.  */
 605   gdbarch_init_osabi (info, gdbarch);
 606
 607   /* Hook in the default unwinders.  */
 608   frame_unwind_append_unwinder (gdbarch, &ft32_frame_unwind);
 609
 610   /* Support simple overlay manager.  */
 611   set_gdbarch_overlay_update (gdbarch, simple_overlay_update);
 612
 613   set_gdbarch_address_class_type_flags (gdbarch, ft32_address_class_type_flags);
 614   set_gdbarch_address_class_name_to_type_flags
 615     (gdbarch, ft32_address_class_name_to_type_flags);
 616   set_gdbarch_address_class_type_flags_to_name
 617     (gdbarch, ft32_address_class_type_flags_to_name);
 618
 619   return gdbarch;
 620 }
 621
 622 /* Register this machine's init routine.  */
 623
 624 void _initialize_ft32_tdep ();
 625 void
 626 _initialize_ft32_tdep ()
 627 {
 628   gdbarch_register (bfd_arch_ft32, ft32_gdbarch_init);
 629 }