gdb/mt-tdep.c

   1 /* Target-dependent code for Morpho mt processor, for GDB.
   2
   3    Copyright (C) 2005, 2007, 2008, 2009 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 /* Contributed by Michael Snyder, msnyder@redhat.com.  */
  21
  22 #include "defs.h"
  23 #include "frame.h"
  24 #include "frame-unwind.h"
  25 #include "frame-base.h"
  26 #include "symtab.h"
  27 #include "dis-asm.h"
  28 #include "arch-utils.h"
  29 #include "gdbtypes.h"
  30 #include "gdb_string.h"
  31 #include "regcache.h"
  32 #include "reggroups.h"
  33 #include "gdbcore.h"
  34 #include "trad-frame.h"
  35 #include "inferior.h"
  36 #include "dwarf2-frame.h"
  37 #include "infcall.h"
  38 #include "gdb_assert.h"
  39 #include "language.h"
  40 #include "valprint.h"
  41
  42 enum mt_arch_constants
  43 {
  44   MT_MAX_STRUCT_SIZE = 16
  45 };
  46
  47 enum mt_gdb_regnums
  48 {
  49   MT_R0_REGNUM,                 /* 32 bit regs.  */
  50   MT_R1_REGNUM,
  51   MT_1ST_ARGREG = MT_R1_REGNUM,
  52   MT_R2_REGNUM,
  53   MT_R3_REGNUM,
  54   MT_R4_REGNUM,
  55   MT_LAST_ARGREG = MT_R4_REGNUM,
  56   MT_R5_REGNUM,
  57   MT_R6_REGNUM,
  58   MT_R7_REGNUM,
  59   MT_R8_REGNUM,
  60   MT_R9_REGNUM,
  61   MT_R10_REGNUM,
  62   MT_R11_REGNUM,
  63   MT_R12_REGNUM,
  64   MT_FP_REGNUM = MT_R12_REGNUM,
  65   MT_R13_REGNUM,
  66   MT_SP_REGNUM = MT_R13_REGNUM,
  67   MT_R14_REGNUM,
  68   MT_RA_REGNUM = MT_R14_REGNUM,
  69   MT_R15_REGNUM,
  70   MT_IRA_REGNUM = MT_R15_REGNUM,
  71   MT_PC_REGNUM,
  72
  73   /* Interrupt Enable pseudo-register, exported by SID.  */
  74   MT_INT_ENABLE_REGNUM,
  75   /* End of CPU regs.  */
  76
  77   MT_NUM_CPU_REGS,
  78
  79   /* Co-processor registers.  */
  80   MT_COPRO_REGNUM = MT_NUM_CPU_REGS,    /* 16 bit regs.  */
  81   MT_CPR0_REGNUM,
  82   MT_CPR1_REGNUM,
  83   MT_CPR2_REGNUM,
  84   MT_CPR3_REGNUM,
  85   MT_CPR4_REGNUM,
  86   MT_CPR5_REGNUM,
  87   MT_CPR6_REGNUM,
  88   MT_CPR7_REGNUM,
  89   MT_CPR8_REGNUM,
  90   MT_CPR9_REGNUM,
  91   MT_CPR10_REGNUM,
  92   MT_CPR11_REGNUM,
  93   MT_CPR12_REGNUM,
  94   MT_CPR13_REGNUM,
  95   MT_CPR14_REGNUM,
  96   MT_CPR15_REGNUM,
  97   MT_BYPA_REGNUM,               /* 32 bit regs.  */
  98   MT_BYPB_REGNUM,
  99   MT_BYPC_REGNUM,
 100   MT_FLAG_REGNUM,
 101   MT_CONTEXT_REGNUM,            /* 38 bits (treat as array of
 102                                    six bytes).  */
 103   MT_MAC_REGNUM,                        /* 32 bits.  */
 104   MT_Z1_REGNUM,                 /* 16 bits.  */
 105   MT_Z2_REGNUM,                 /* 16 bits.  */
 106   MT_ICHANNEL_REGNUM,           /* 32 bits.  */
 107   MT_ISCRAMB_REGNUM,            /* 32 bits.  */
 108   MT_QSCRAMB_REGNUM,            /* 32 bits.  */
 109   MT_OUT_REGNUM,                        /* 16 bits.  */
 110   MT_EXMAC_REGNUM,              /* 32 bits (8 used).  */
 111   MT_QCHANNEL_REGNUM,           /* 32 bits.  */
 112   MT_ZI2_REGNUM,                /* 16 bits.  */
 113   MT_ZQ2_REGNUM,                /* 16 bits.  */
 114   MT_CHANNEL2_REGNUM,           /* 32 bits.  */
 115   MT_ISCRAMB2_REGNUM,           /* 32 bits.  */
 116   MT_QSCRAMB2_REGNUM,           /* 32 bits.  */
 117   MT_QCHANNEL2_REGNUM,          /* 32 bits.  */
 118
 119   /* Number of real registers.  */
 120   MT_NUM_REGS,
 121
 122   /* Pseudo-registers.  */
 123   MT_COPRO_PSEUDOREG_REGNUM = MT_NUM_REGS,
 124   MT_MAC_PSEUDOREG_REGNUM,
 125   MT_COPRO_PSEUDOREG_ARRAY,
 126
 127   MT_COPRO_PSEUDOREG_DIM_1 = 2,
 128   MT_COPRO_PSEUDOREG_DIM_2 = 8,
 129   /* The number of pseudo-registers for each coprocessor.  These
 130      include the real coprocessor registers, the pseudo-registe for
 131      the coprocessor number, and the pseudo-register for the MAC.  */
 132   MT_COPRO_PSEUDOREG_REGS = MT_NUM_REGS - MT_NUM_CPU_REGS + 2,
 133   /* The register number of the MAC, relative to a given coprocessor.  */
 134   MT_COPRO_PSEUDOREG_MAC_REGNUM = MT_COPRO_PSEUDOREG_REGS - 1,
 135
 136   /* Two pseudo-regs ('coprocessor' and 'mac').  */
 137   MT_NUM_PSEUDO_REGS = 2 + (MT_COPRO_PSEUDOREG_REGS
 138                             * MT_COPRO_PSEUDOREG_DIM_1
 139                             * MT_COPRO_PSEUDOREG_DIM_2)
 140 };
 141
 142 /* Return name of register number specified by REGNUM.  */
 143
 144 static const char *
 145 mt_register_name (struct gdbarch *gdbarch, int regnum)
 146 {
 147   static const char *const register_names[] = {
 148     /* CPU regs.  */
 149     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 150     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 151     "pc", "IE",
 152     /* Co-processor regs.  */
 153     "",                         /* copro register.  */
 154     "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
 155     "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
 156     "bypa", "bypb", "bypc", "flag", "context", "" /* mac.  */ , "z1", "z2",
 157     "Ichannel", "Iscramb", "Qscramb", "out", "" /* ex-mac.  */ , "Qchannel",
 158     "zi2", "zq2", "Ichannel2", "Iscramb2", "Qscramb2", "Qchannel2",
 159     /* Pseudo-registers.  */
 160     "coprocessor", "MAC"
 161   };
 162   static const char *array_names[MT_COPRO_PSEUDOREG_REGS
 163                                  * MT_COPRO_PSEUDOREG_DIM_1
 164                                  * MT_COPRO_PSEUDOREG_DIM_2];
 165
 166   if (regnum < 0)
 167     return "";
 168   if (regnum < ARRAY_SIZE (register_names))
 169     return register_names[regnum];
 170   if (array_names[regnum - MT_COPRO_PSEUDOREG_ARRAY])
 171     return array_names[regnum - MT_COPRO_PSEUDOREG_ARRAY];
 172
 173   {
 174     char *name;
 175     const char *stub;
 176     unsigned dim_1;
 177     unsigned dim_2;
 178     unsigned index;
 179
 180     regnum -= MT_COPRO_PSEUDOREG_ARRAY;
 181     index = regnum % MT_COPRO_PSEUDOREG_REGS;
 182     dim_2 = (regnum / MT_COPRO_PSEUDOREG_REGS) % MT_COPRO_PSEUDOREG_DIM_2;
 183     dim_1 = ((regnum / MT_COPRO_PSEUDOREG_REGS / MT_COPRO_PSEUDOREG_DIM_2)
 184              %  MT_COPRO_PSEUDOREG_DIM_1);
 185
 186     if (index == MT_COPRO_PSEUDOREG_MAC_REGNUM)
 187       stub = register_names[MT_MAC_PSEUDOREG_REGNUM];
 188     else if (index >= MT_NUM_REGS - MT_CPR0_REGNUM)
 189       stub = "";
 190     else
 191       stub = register_names[index + MT_CPR0_REGNUM];
 192     if (!*stub)
 193       {
 194         array_names[regnum] = stub;
 195         return stub;
 196       }
 197     name = xmalloc (30);
 198     sprintf (name, "copro_%d_%d_%s", dim_1, dim_2, stub);
 199     array_names[regnum] = name;
 200     return name;
 201   }
 202 }
 203
 204 /* Return the type of a coprocessor register.  */
 205
 206 static struct type *
 207 mt_copro_register_type (struct gdbarch *arch, int regnum)
 208 {
 209   switch (regnum)
 210     {
 211     case MT_INT_ENABLE_REGNUM:
 212     case MT_ICHANNEL_REGNUM:
 213     case MT_QCHANNEL_REGNUM:
 214     case MT_ISCRAMB_REGNUM:
 215     case MT_QSCRAMB_REGNUM:
 216       return builtin_type_int32;
 217     case MT_BYPA_REGNUM:
 218     case MT_BYPB_REGNUM:
 219     case MT_BYPC_REGNUM:
 220     case MT_Z1_REGNUM:
 221     case MT_Z2_REGNUM:
 222     case MT_OUT_REGNUM:
 223     case MT_ZI2_REGNUM:
 224     case MT_ZQ2_REGNUM:
 225       return builtin_type_int16;
 226     case MT_EXMAC_REGNUM:
 227     case MT_MAC_REGNUM:
 228       return builtin_type_uint32;
 229     case MT_CONTEXT_REGNUM:
 230       return builtin_type (arch)->builtin_long_long;
 231     case MT_FLAG_REGNUM:
 232       return builtin_type (arch)->builtin_unsigned_char;
 233     default:
 234       if (regnum >= MT_CPR0_REGNUM && regnum <= MT_CPR15_REGNUM)
 235         return builtin_type_int16;
 236       else if (regnum == MT_CPR0_REGNUM + MT_COPRO_PSEUDOREG_MAC_REGNUM)
 237         {
 238           if (gdbarch_bfd_arch_info (arch)->mach == bfd_mach_mrisc2
 239               || gdbarch_bfd_arch_info (arch)->mach == bfd_mach_ms2)
 240             return builtin_type_uint64;
 241           else
 242             return builtin_type_uint32;
 243         }
 244       else
 245         return builtin_type_uint32;
 246     }
 247 }
 248
 249 /* Given ARCH and a register number specified by REGNUM, return the
 250    type of that register.  */
 251
 252 static struct type *
 253 mt_register_type (struct gdbarch *arch, int regnum)
 254 {
 255   static struct type *copro_type = NULL;
 256
 257   if (regnum >= 0 && regnum < MT_NUM_REGS + MT_NUM_PSEUDO_REGS)
 258     {
 259       if (copro_type == NULL)
 260         copro_type = lookup_array_range_type (builtin_type_int16, 0, 1);
 261       switch (regnum)
 262         {
 263         case MT_PC_REGNUM:
 264         case MT_RA_REGNUM:
 265         case MT_IRA_REGNUM:
 266           return builtin_type (arch)->builtin_func_ptr;
 267         case MT_SP_REGNUM:
 268         case MT_FP_REGNUM:
 269           return builtin_type (arch)->builtin_data_ptr;
 270         case MT_COPRO_REGNUM:
 271         case MT_COPRO_PSEUDOREG_REGNUM:
 272           return copro_type;
 273         case MT_MAC_PSEUDOREG_REGNUM:
 274           return mt_copro_register_type (arch,
 275                                          MT_CPR0_REGNUM
 276                                          + MT_COPRO_PSEUDOREG_MAC_REGNUM);
 277         default:
 278           if (regnum >= MT_R0_REGNUM && regnum <= MT_R15_REGNUM)
 279             return builtin_type_int32;
 280           else if (regnum < MT_COPRO_PSEUDOREG_ARRAY)
 281             return mt_copro_register_type (arch, regnum);
 282           else
 283             {
 284               regnum -= MT_COPRO_PSEUDOREG_ARRAY;
 285               regnum %= MT_COPRO_PSEUDOREG_REGS;
 286               regnum += MT_CPR0_REGNUM;
 287               return mt_copro_register_type (arch, regnum);
 288             }
 289         }
 290     }
 291   internal_error (__FILE__, __LINE__,
 292                   _("mt_register_type: illegal register number %d"), regnum);
 293 }
 294
 295 /* Return true if register REGNUM is a member of the register group
 296    specified by GROUP.  */
 297
 298 static int
 299 mt_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
 300                          struct reggroup *group)
 301 {
 302   /* Groups of registers that can be displayed via "info reg".  */
 303   if (group == all_reggroup)
 304     return (regnum >= 0
 305             && regnum < MT_NUM_REGS + MT_NUM_PSEUDO_REGS
 306             && mt_register_name (gdbarch, regnum)[0] != '\0');
 307
 308   if (group == general_reggroup)
 309     return (regnum >= MT_R0_REGNUM && regnum <= MT_R15_REGNUM);
 310
 311   if (group == float_reggroup)
 312     return 0;                   /* No float regs.  */
 313
 314   if (group == vector_reggroup)
 315     return 0;                   /* No vector regs.  */
 316
 317   /* For any that are not handled above.  */
 318   return default_register_reggroup_p (gdbarch, regnum, group);
 319 }
 320
 321 /* Return the return value convention used for a given type TYPE.
 322    Optionally, fetch or set the return value via READBUF or
 323    WRITEBUF respectively using REGCACHE for the register
 324    values.  */
 325
 326 static enum return_value_convention
 327 mt_return_value (struct gdbarch *gdbarch, struct type *func_type,
 328                  struct type *type, struct regcache *regcache,
 329                  gdb_byte *readbuf, const gdb_byte *writebuf)
 330 {
 331   if (TYPE_LENGTH (type) > 4)
 332     {
 333       /* Return values > 4 bytes are returned in memory,
 334          pointed to by R11.  */
 335       if (readbuf)
 336         {
 337           ULONGEST addr;
 338
 339           regcache_cooked_read_unsigned (regcache, MT_R11_REGNUM, &addr);
 340           read_memory (addr, readbuf, TYPE_LENGTH (type));
 341         }
 342
 343       if (writebuf)
 344         {
 345           ULONGEST addr;
 346
 347           regcache_cooked_read_unsigned (regcache, MT_R11_REGNUM, &addr);
 348           write_memory (addr, writebuf, TYPE_LENGTH (type));
 349         }
 350
 351       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
 352     }
 353   else
 354     {
 355       if (readbuf)
 356         {
 357           ULONGEST temp;
 358
 359           /* Return values of <= 4 bytes are returned in R11.  */
 360           regcache_cooked_read_unsigned (regcache, MT_R11_REGNUM, &temp);
 361           store_unsigned_integer (readbuf, TYPE_LENGTH (type), temp);
 362         }
 363
 364       if (writebuf)
 365         {
 366           if (TYPE_LENGTH (type) < 4)
 367             {
 368               gdb_byte buf[4];
 369               /* Add leading zeros to the value.  */
 370               memset (buf, 0, sizeof (buf));
 371               memcpy (buf + sizeof (buf) - TYPE_LENGTH (type),
 372                       writebuf, TYPE_LENGTH (type));
 373               regcache_cooked_write (regcache, MT_R11_REGNUM, buf);
 374             }
 375           else                  /* (TYPE_LENGTH (type) == 4 */
 376             regcache_cooked_write (regcache, MT_R11_REGNUM, writebuf);
 377         }
 378
 379       return RETURN_VALUE_REGISTER_CONVENTION;
 380     }
 381 }
 382
 383 /* If the input address, PC, is in a function prologue, return the
 384    address of the end of the prologue, otherwise return the input
 385    address.
 386
 387    Note:  PC is likely to be the function start, since this function
 388    is mainly used for advancing a breakpoint to the first line, or
 389    stepping to the first line when we have stepped into a function
 390    call.  */
 391
 392 static CORE_ADDR
 393 mt_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 394 {
 395   CORE_ADDR func_addr = 0, func_end = 0;
 396   char *func_name;
 397   unsigned long instr;
 398
 399   if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
 400     {
 401       struct symtab_and_line sal;
 402       struct symbol *sym;
 403
 404       /* Found a function.  */
 405       sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL);
 406       if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
 407         {
 408           /* Don't use this trick for assembly source files.  */
 409           sal = find_pc_line (func_addr, 0);
 410
 411           if (sal.end && sal.end < func_end)
 412             {
 413               /* Found a line number, use it as end of prologue.  */
 414               return sal.end;
 415             }
 416         }
 417     }
 418
 419   /* No function symbol, or no line symbol.  Use prologue scanning method.  */
 420   for (;; pc += 4)
 421     {
 422       instr = read_memory_unsigned_integer (pc, 4);
 423       if (instr == 0x12000000)  /* nop */
 424         continue;
 425       if (instr == 0x12ddc000)  /* copy sp into fp */
 426         continue;
 427       instr >>= 16;
 428       if (instr == 0x05dd)      /* subi sp, sp, imm */
 429         continue;
 430       if (instr >= 0x43c0 && instr <= 0x43df)   /* push */
 431         continue;
 432       /* Not an obvious prologue instruction.  */
 433       break;
 434     }
 435
 436   return pc;
 437 }
 438
 439 /* The breakpoint instruction must be the same size as the smallest
 440    instruction in the instruction set.
 441
 442    The BP for ms1 is defined as 0x68000000 (BREAK).
 443    The BP for ms2 is defined as 0x69000000 (illegal)  */
 444
 445 static const gdb_byte *
 446 mt_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *bp_addr,
 447                        int *bp_size)
 448 {
 449   static gdb_byte ms1_breakpoint[] = { 0x68, 0, 0, 0 };
 450   static gdb_byte ms2_breakpoint[] = { 0x69, 0, 0, 0 };
 451
 452   *bp_size = 4;
 453   if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_ms2)
 454     return ms2_breakpoint;
 455
 456   return ms1_breakpoint;
 457 }
 458
 459 /* Select the correct coprocessor register bank.  Return the pseudo
 460    regnum we really want to read.  */
 461
 462 static int
 463 mt_select_coprocessor (struct gdbarch *gdbarch,
 464                         struct regcache *regcache, int regno)
 465 {
 466   unsigned index, base;
 467   gdb_byte copro[4];
 468
 469   /* Get the copro pseudo regnum. */
 470   regcache_raw_read (regcache, MT_COPRO_REGNUM, copro);
 471   base = (extract_signed_integer (&copro[0], 2) * MT_COPRO_PSEUDOREG_DIM_2
 472           + extract_signed_integer (&copro[2], 2));
 473
 474   regno -= MT_COPRO_PSEUDOREG_ARRAY;
 475   index = regno % MT_COPRO_PSEUDOREG_REGS;
 476   regno /= MT_COPRO_PSEUDOREG_REGS;
 477   if (base != regno)
 478     {
 479       /* Select the correct coprocessor register bank.  Invalidate the
 480          coprocessor register cache.  */
 481       unsigned ix;
 482
 483       store_signed_integer (&copro[0], 2, regno / MT_COPRO_PSEUDOREG_DIM_2);
 484       store_signed_integer (&copro[2], 2, regno % MT_COPRO_PSEUDOREG_DIM_2);
 485       regcache_raw_write (regcache, MT_COPRO_REGNUM, copro);
 486
 487       /* We must flush the cache, as it is now invalid.  */
 488       for (ix = MT_NUM_CPU_REGS; ix != MT_NUM_REGS; ix++)
 489         regcache_invalidate (regcache, ix);
 490     }
 491
 492   return index;
 493 }
 494
 495 /* Fetch the pseudo registers:
 496
 497    There are two regular pseudo-registers:
 498    1) The 'coprocessor' pseudo-register (which mirrors the
 499    "real" coprocessor register sent by the target), and
 500    2) The 'MAC' pseudo-register (which represents the union
 501    of the original 32 bit target MAC register and the new
 502    8-bit extended-MAC register).
 503
 504    Additionally there is an array of coprocessor registers which track
 505    the coprocessor registers for each coprocessor.  */
 506
 507 static void
 508 mt_pseudo_register_read (struct gdbarch *gdbarch,
 509                           struct regcache *regcache, int regno, gdb_byte *buf)
 510 {
 511   switch (regno)
 512     {
 513     case MT_COPRO_REGNUM:
 514     case MT_COPRO_PSEUDOREG_REGNUM:
 515       regcache_raw_read (regcache, MT_COPRO_REGNUM, buf);
 516       break;
 517     case MT_MAC_REGNUM:
 518     case MT_MAC_PSEUDOREG_REGNUM:
 519       if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_mrisc2
 520           || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_ms2)
 521         {
 522           ULONGEST oldmac = 0, ext_mac = 0;
 523           ULONGEST newmac;
 524
 525           regcache_cooked_read_unsigned (regcache, MT_MAC_REGNUM, &oldmac);
 526           regcache_cooked_read_unsigned (regcache, MT_EXMAC_REGNUM, &ext_mac);
 527           newmac =
 528             (oldmac & 0xffffffff) | ((long long) (ext_mac & 0xff) << 32);
 529           store_signed_integer (buf, 8, newmac);
 530         }
 531       else
 532         regcache_raw_read (regcache, MT_MAC_REGNUM, buf);
 533       break;
 534     default:
 535       {
 536         unsigned index = mt_select_coprocessor (gdbarch, regcache, regno);
 537
 538         if (index == MT_COPRO_PSEUDOREG_MAC_REGNUM)
 539           mt_pseudo_register_read (gdbarch, regcache,
 540                                    MT_MAC_PSEUDOREG_REGNUM, buf);
 541         else if (index < MT_NUM_REGS - MT_CPR0_REGNUM)
 542           regcache_raw_read (regcache, index + MT_CPR0_REGNUM, buf);
 543       }
 544       break;
 545     }
 546 }
 547
 548 /* Write the pseudo registers:
 549
 550    Mt pseudo-registers are stored directly to the target.  The
 551    'coprocessor' register is special, because when it is modified, all
 552    the other coprocessor regs must be flushed from the reg cache.  */
 553
 554 static void
 555 mt_pseudo_register_write (struct gdbarch *gdbarch,
 556                            struct regcache *regcache,
 557                            int regno, const gdb_byte *buf)
 558 {
 559   int i;
 560
 561   switch (regno)
 562     {
 563     case MT_COPRO_REGNUM:
 564     case MT_COPRO_PSEUDOREG_REGNUM:
 565       regcache_raw_write (regcache, MT_COPRO_REGNUM, buf);
 566       for (i = MT_NUM_CPU_REGS; i < MT_NUM_REGS; i++)
 567         regcache_invalidate (regcache, i);
 568       break;
 569     case MT_MAC_REGNUM:
 570     case MT_MAC_PSEUDOREG_REGNUM:
 571       if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_mrisc2
 572           || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_ms2)
 573         {
 574           /* The 8-byte MAC pseudo-register must be broken down into two
 575              32-byte registers.  */
 576           unsigned int oldmac, ext_mac;
 577           ULONGEST newmac;
 578
 579           newmac = extract_unsigned_integer (buf, 8);
 580           oldmac = newmac & 0xffffffff;
 581           ext_mac = (newmac >> 32) & 0xff;
 582           regcache_cooked_write_unsigned (regcache, MT_MAC_REGNUM, oldmac);
 583           regcache_cooked_write_unsigned (regcache, MT_EXMAC_REGNUM, ext_mac);
 584         }
 585       else
 586         regcache_raw_write (regcache, MT_MAC_REGNUM, buf);
 587       break;
 588     default:
 589       {
 590         unsigned index = mt_select_coprocessor (gdbarch, regcache, regno);
 591
 592         if (index == MT_COPRO_PSEUDOREG_MAC_REGNUM)
 593           mt_pseudo_register_write (gdbarch, regcache,
 594                                     MT_MAC_PSEUDOREG_REGNUM, buf);
 595         else if (index < MT_NUM_REGS - MT_CPR0_REGNUM)
 596           regcache_raw_write (regcache, index + MT_CPR0_REGNUM, buf);
 597       }
 598       break;
 599     }
 600 }
 601
 602 static CORE_ADDR
 603 mt_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
 604 {
 605   /* Register size is 4 bytes.  */
 606   return align_down (sp, 4);
 607 }
 608
 609 /* Implements the "info registers" command.   When ``all'' is non-zero,
 610    the coprocessor registers will be printed in addition to the rest
 611    of the registers.  */
 612
 613 static void
 614 mt_registers_info (struct gdbarch *gdbarch,
 615                    struct ui_file *file,
 616                    struct frame_info *frame, int regnum, int all)
 617 {
 618   if (regnum == -1)
 619     {
 620       int lim;
 621
 622       lim = all ? MT_NUM_REGS : MT_NUM_CPU_REGS;
 623
 624       for (regnum = 0; regnum < lim; regnum++)
 625         {
 626           /* Don't display the Qchannel register since it will be displayed
 627              along with Ichannel.  (See below.)  */
 628           if (regnum == MT_QCHANNEL_REGNUM)
 629             continue;
 630
 631           mt_registers_info (gdbarch, file, frame, regnum, all);
 632
 633           /* Display the Qchannel register immediately after Ichannel.  */
 634           if (regnum == MT_ICHANNEL_REGNUM)
 635             mt_registers_info (gdbarch, file, frame, MT_QCHANNEL_REGNUM, all);
 636         }
 637     }
 638   else
 639     {
 640       if (regnum == MT_EXMAC_REGNUM)
 641         return;
 642       else if (regnum == MT_CONTEXT_REGNUM)
 643         {
 644           /* Special output handling for 38-bit context register.  */
 645           unsigned char *buff;
 646           unsigned int *bytes, i, regsize;
 647
 648           regsize = register_size (gdbarch, regnum);
 649
 650           buff = alloca (regsize);
 651           bytes = alloca (regsize * sizeof (*bytes));
 652
 653           frame_register_read (frame, regnum, buff);
 654
 655           fputs_filtered (gdbarch_register_name
 656                           (gdbarch, regnum), file);
 657           print_spaces_filtered (15 - strlen (gdbarch_register_name
 658                                                 (gdbarch, regnum)),
 659                                  file);
 660           fputs_filtered ("0x", file);
 661
 662           for (i = 0; i < regsize; i++)
 663             fprintf_filtered (file, "%02x", (unsigned int)
 664                               extract_unsigned_integer (buff + i, 1));
 665           fputs_filtered ("\t", file);
 666           print_longest (file, 'd', 0,
 667                          extract_unsigned_integer (buff, regsize));
 668           fputs_filtered ("\n", file);
 669         }
 670       else if (regnum == MT_COPRO_REGNUM
 671                || regnum == MT_COPRO_PSEUDOREG_REGNUM)
 672         {
 673           /* Special output handling for the 'coprocessor' register.  */
 674           gdb_byte *buf;
 675           struct value_print_options opts;
 676
 677           buf = alloca (register_size (gdbarch, MT_COPRO_REGNUM));
 678           frame_register_read (frame, MT_COPRO_REGNUM, buf);
 679           /* And print.  */
 680           regnum = MT_COPRO_PSEUDOREG_REGNUM;
 681           fputs_filtered (gdbarch_register_name (gdbarch, regnum),
 682                           file);
 683           print_spaces_filtered (15 - strlen (gdbarch_register_name
 684                                                 (gdbarch, regnum)),
 685                                  file);
 686           get_raw_print_options (&opts);
 687           opts.deref_ref = 1;
 688           val_print (register_type (gdbarch, regnum), buf,
 689                      0, 0, file, 0, &opts,
 690                      current_language);
 691           fputs_filtered ("\n", file);
 692         }
 693       else if (regnum == MT_MAC_REGNUM || regnum == MT_MAC_PSEUDOREG_REGNUM)
 694         {
 695           ULONGEST oldmac, ext_mac, newmac;
 696           gdb_byte buf[3 * sizeof (LONGEST)];
 697
 698           /* Get the two "real" mac registers.  */
 699           frame_register_read (frame, MT_MAC_REGNUM, buf);
 700           oldmac = extract_unsigned_integer
 701             (buf, register_size (gdbarch, MT_MAC_REGNUM));
 702           if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_mrisc2
 703               || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_ms2)
 704             {
 705               frame_register_read (frame, MT_EXMAC_REGNUM, buf);
 706               ext_mac = extract_unsigned_integer
 707                 (buf, register_size (gdbarch, MT_EXMAC_REGNUM));
 708             }
 709           else
 710             ext_mac = 0;
 711
 712           /* Add them together.  */
 713           newmac = (oldmac & 0xffffffff) + ((ext_mac & 0xff) << 32);
 714
 715           /* And print.  */
 716           regnum = MT_MAC_PSEUDOREG_REGNUM;
 717           fputs_filtered (gdbarch_register_name (gdbarch, regnum),
 718                           file);
 719           print_spaces_filtered (15 - strlen (gdbarch_register_name
 720                                               (gdbarch, regnum)),
 721                                  file);
 722           fputs_filtered ("0x", file);
 723           print_longest (file, 'x', 0, newmac);
 724           fputs_filtered ("\t", file);
 725           print_longest (file, 'u', 0, newmac);
 726           fputs_filtered ("\n", file);
 727         }
 728       else
 729         default_print_registers_info (gdbarch, file, frame, regnum, all);
 730     }
 731 }
 732
 733 /* Set up the callee's arguments for an inferior function call.  The
 734    arguments are pushed on the stack or are placed in registers as
 735    appropriate.  It also sets up the return address (which points to
 736    the call dummy breakpoint).
 737
 738    Returns the updated (and aligned) stack pointer.  */
 739
 740 static CORE_ADDR
 741 mt_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 742                      struct regcache *regcache, CORE_ADDR bp_addr,
 743                      int nargs, struct value **args, CORE_ADDR sp,
 744                      int struct_return, CORE_ADDR struct_addr)
 745 {
 746 #define wordsize 4
 747   gdb_byte buf[MT_MAX_STRUCT_SIZE];
 748   int argreg = MT_1ST_ARGREG;
 749   int split_param_len = 0;
 750   int stack_dest = sp;
 751   int slacklen;
 752   int typelen;
 753   int i, j;
 754
 755   /* First handle however many args we can fit into MT_1ST_ARGREG thru
 756      MT_LAST_ARGREG.  */
 757   for (i = 0; i < nargs && argreg <= MT_LAST_ARGREG; i++)
 758     {
 759       const gdb_byte *val;
 760       typelen = TYPE_LENGTH (value_type (args[i]));
 761       switch (typelen)
 762         {
 763         case 1:
 764         case 2:
 765         case 3:
 766         case 4:
 767           regcache_cooked_write_unsigned (regcache, argreg++,
 768                                           extract_unsigned_integer
 769                                           (value_contents (args[i]),
 770                                            wordsize));
 771           break;
 772         case 8:
 773         case 12:
 774         case 16:
 775           val = value_contents (args[i]);
 776           while (typelen > 0)
 777             {
 778               if (argreg <= MT_LAST_ARGREG)
 779                 {
 780                   /* This word of the argument is passed in a register.  */
 781                   regcache_cooked_write_unsigned (regcache, argreg++,
 782                                                   extract_unsigned_integer
 783                                                   (val, wordsize));
 784                   typelen -= wordsize;
 785                   val += wordsize;
 786                 }
 787               else
 788                 {
 789                   /* Remainder of this arg must be passed on the stack
 790                      (deferred to do later).  */
 791                   split_param_len = typelen;
 792                   memcpy (buf, val, typelen);
 793                   break;        /* No more args can be handled in regs.  */
 794                 }
 795             }
 796           break;
 797         default:
 798           /* By reverse engineering of gcc output, args bigger than
 799              16 bytes go on the stack, and their address is passed
 800              in the argreg.  */
 801           stack_dest -= typelen;
 802           write_memory (stack_dest, value_contents (args[i]), typelen);
 803           regcache_cooked_write_unsigned (regcache, argreg++, stack_dest);
 804           break;
 805         }
 806     }
 807
 808   /* Next, the rest of the arguments go onto the stack, in reverse order.  */
 809   for (j = nargs - 1; j >= i; j--)
 810     {
 811       gdb_byte *val;
 812
 813       /* Right-justify the value in an aligned-length buffer.  */
 814       typelen = TYPE_LENGTH (value_type (args[j]));
 815       slacklen = (wordsize - (typelen % wordsize)) % wordsize;
 816       val = alloca (typelen + slacklen);
 817       memcpy (val, value_contents (args[j]), typelen);
 818       memset (val + typelen, 0, slacklen);
 819       /* Now write this data to the stack.  */
 820       stack_dest -= typelen + slacklen;
 821       write_memory (stack_dest, val, typelen + slacklen);
 822     }
 823
 824   /* Finally, if a param needs to be split between registers and stack,
 825      write the second half to the stack now.  */
 826   if (split_param_len != 0)
 827     {
 828       stack_dest -= split_param_len;
 829       write_memory (stack_dest, buf, split_param_len);
 830     }
 831
 832   /* Set up return address (provided to us as bp_addr).  */
 833   regcache_cooked_write_unsigned (regcache, MT_RA_REGNUM, bp_addr);
 834
 835   /* Store struct return address, if given.  */
 836   if (struct_return && struct_addr != 0)
 837     regcache_cooked_write_unsigned (regcache, MT_R11_REGNUM, struct_addr);
 838
 839   /* Set aside 16 bytes for the callee to save regs 1-4.  */
 840   stack_dest -= 16;
 841
 842   /* Update the stack pointer.  */
 843   regcache_cooked_write_unsigned (regcache, MT_SP_REGNUM, stack_dest);
 844
 845   /* And that should do it.  Return the new stack pointer.  */
 846   return stack_dest;
 847 }
 848
 849
 850 /* The 'unwind_cache' data structure.  */
 851
 852 struct mt_unwind_cache
 853 {
 854   /* The previous frame's inner most stack address.
 855      Used as this frame ID's stack_addr.  */
 856   CORE_ADDR prev_sp;
 857   CORE_ADDR frame_base;
 858   int framesize;
 859   int frameless_p;
 860
 861   /* Table indicating the location of each and every register.  */
 862   struct trad_frame_saved_reg *saved_regs;
 863 };
 864
 865 /* Initialize an unwind_cache.  Build up the saved_regs table etc. for
 866    the frame.  */
 867
 868 static struct mt_unwind_cache *
 869 mt_frame_unwind_cache (struct frame_info *this_frame,
 870                         void **this_prologue_cache)
 871 {
 872   struct gdbarch *gdbarch;
 873   struct mt_unwind_cache *info;
 874   CORE_ADDR next_addr, start_addr, end_addr, prologue_end_addr;
 875   unsigned long instr, upper_half, delayed_store = 0;
 876   int regnum, offset;
 877   ULONGEST sp, fp;
 878
 879   if ((*this_prologue_cache))
 880     return (*this_prologue_cache);
 881
 882   gdbarch = get_frame_arch (this_frame);
 883   info = FRAME_OBSTACK_ZALLOC (struct mt_unwind_cache);
 884   (*this_prologue_cache) = info;
 885
 886   info->prev_sp = 0;
 887   info->framesize = 0;
 888   info->frame_base = 0;
 889   info->frameless_p = 1;
 890   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 891
 892   /* Grab the frame-relative values of SP and FP, needed below.
 893      The frame_saved_register function will find them on the
 894      stack or in the registers as appropriate.  */
 895   sp = get_frame_register_unsigned (this_frame, MT_SP_REGNUM);
 896   fp = get_frame_register_unsigned (this_frame, MT_FP_REGNUM);
 897
 898   start_addr = get_frame_func (this_frame);
 899
 900   /* Return early if GDB couldn't find the function.  */
 901   if (start_addr == 0)
 902     return info;
 903
 904   end_addr = get_frame_pc (this_frame);
 905   prologue_end_addr = skip_prologue_using_sal (gdbarch, start_addr);
 906   if (end_addr == 0)
 907   for (next_addr = start_addr; next_addr < end_addr; next_addr += 4)
 908     {
 909       instr = get_frame_memory_unsigned (this_frame, next_addr, 4);
 910       if (delayed_store)        /* previous instr was a push */
 911         {
 912           upper_half = delayed_store >> 16;
 913           regnum = upper_half & 0xf;
 914           offset = delayed_store & 0xffff;
 915           switch (upper_half & 0xfff0)
 916             {
 917             case 0x43c0:        /* push using frame pointer */
 918               info->saved_regs[regnum].addr = offset;
 919               break;
 920             case 0x43d0:        /* push using stack pointer */
 921               info->saved_regs[regnum].addr = offset;
 922               break;
 923             default:            /* lint */
 924               break;
 925             }
 926           delayed_store = 0;
 927         }
 928
 929       switch (instr)
 930         {
 931         case 0x12000000:        /* NO-OP */
 932           continue;
 933         case 0x12ddc000:        /* copy sp into fp */
 934           info->frameless_p = 0;        /* Record that the frame pointer is in use.  */
 935           continue;
 936         default:
 937           upper_half = instr >> 16;
 938           if (upper_half == 0x05dd ||   /* subi  sp, sp, imm */
 939               upper_half == 0x07dd)     /* subui sp, sp, imm */
 940             {
 941               /* Record the frame size.  */
 942               info->framesize = instr & 0xffff;
 943               continue;
 944             }
 945           if ((upper_half & 0xfff0) == 0x43c0 ||        /* frame push */
 946               (upper_half & 0xfff0) == 0x43d0)  /* stack push */
 947             {
 948               /* Save this instruction, but don't record the
 949                  pushed register as 'saved' until we see the
 950                  next instruction.  That's because of deferred stores
 951                  on this target -- GDB won't be able to read the register
 952                  from the stack until one instruction later.  */
 953               delayed_store = instr;
 954               continue;
 955             }
 956           /* Not a prologue instruction.  Is this the end of the prologue?
 957              This is the most difficult decision; when to stop scanning.
 958
 959              If we have no line symbol, then the best thing we can do
 960              is to stop scanning when we encounter an instruction that
 961              is not likely to be a part of the prologue.
 962
 963              But if we do have a line symbol, then we should
 964              keep scanning until we reach it (or we reach end_addr).  */
 965
 966           if (prologue_end_addr && (prologue_end_addr > (next_addr + 4)))
 967             continue;           /* Keep scanning, recording saved_regs etc.  */
 968           else
 969             break;              /* Quit scanning: breakpoint can be set here.  */
 970         }
 971     }
 972
 973   /* Special handling for the "saved" address of the SP:
 974      The SP is of course never saved on the stack at all, so
 975      by convention what we put here is simply the previous
 976      _value_ of the SP (as opposed to an address where the
 977      previous value would have been pushed).  This will also
 978      give us the frame base address.  */
 979
 980   if (info->frameless_p)
 981     {
 982       info->frame_base = sp + info->framesize;
 983       info->prev_sp = sp + info->framesize;
 984     }
 985   else
 986     {
 987       info->frame_base = fp + info->framesize;
 988       info->prev_sp = fp + info->framesize;
 989     }
 990   /* Save prev_sp in saved_regs as a value, not as an address.  */
 991   trad_frame_set_value (info->saved_regs, MT_SP_REGNUM, info->prev_sp);
 992
 993   /* Now convert frame offsets to actual addresses (not offsets).  */
 994   for (regnum = 0; regnum < MT_NUM_REGS; regnum++)
 995     if (trad_frame_addr_p (info->saved_regs, regnum))
 996       info->saved_regs[regnum].addr += info->frame_base - info->framesize;
 997
 998   /* The call instruction moves the caller's PC in the callee's RA reg.
 999      Since this is an unwind, do the reverse.  Copy the location of RA
1000      into PC (the address / regnum) so that a request for PC will be
1001      converted into a request for the RA.  */
1002   info->saved_regs[MT_PC_REGNUM] = info->saved_regs[MT_RA_REGNUM];
1003
1004   return info;
1005 }
1006
1007 static CORE_ADDR
1008 mt_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1009 {
1010   ULONGEST pc;
1011
1012   pc = frame_unwind_register_unsigned (next_frame, MT_PC_REGNUM);
1013   return pc;
1014 }
1015
1016 static CORE_ADDR
1017 mt_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
1018 {
1019   ULONGEST sp;
1020
1021   sp = frame_unwind_register_unsigned (next_frame, MT_SP_REGNUM);
1022   return sp;
1023 }
1024
1025 /* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy
1026    frame.  The frame ID's base needs to match the TOS value saved by
1027    save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint.  */
1028
1029 static struct frame_id
1030 mt_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1031 {
1032   CORE_ADDR sp = get_frame_register_unsigned (this_frame, MT_SP_REGNUM);
1033   return frame_id_build (sp, get_frame_pc (this_frame));
1034 }
1035
1036 /* Given a GDB frame, determine the address of the calling function's
1037    frame.  This will be used to create a new GDB frame struct.  */
1038
1039 static void
1040 mt_frame_this_id (struct frame_info *this_frame,
1041                    void **this_prologue_cache, struct frame_id *this_id)
1042 {
1043   struct mt_unwind_cache *info =
1044     mt_frame_unwind_cache (this_frame, this_prologue_cache);
1045
1046   if (!(info == NULL || info->prev_sp == 0))
1047     (*this_id) = frame_id_build (info->prev_sp, get_frame_func (this_frame));
1048
1049   return;
1050 }
1051
1052 static struct value *
1053 mt_frame_prev_register (struct frame_info *this_frame,
1054                          void **this_prologue_cache, int regnum)
1055 {
1056   struct mt_unwind_cache *info =
1057     mt_frame_unwind_cache (this_frame, this_prologue_cache);
1058
1059   return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1060 }
1061
1062 static CORE_ADDR
1063 mt_frame_base_address (struct frame_info *this_frame,
1064                         void **this_prologue_cache)
1065 {
1066   struct mt_unwind_cache *info =
1067     mt_frame_unwind_cache (this_frame, this_prologue_cache);
1068
1069   return info->frame_base;
1070 }
1071
1072 /* This is a shared interface:  the 'frame_unwind' object is what's
1073    returned by the 'sniffer' function, and in turn specifies how to
1074    get a frame's ID and prev_regs.
1075
1076    This exports the 'prev_register' and 'this_id' methods.  */
1077
1078 static const struct frame_unwind mt_frame_unwind = {
1079   NORMAL_FRAME,
1080   mt_frame_this_id,
1081   mt_frame_prev_register,
1082   NULL,
1083   default_frame_sniffer
1084 };
1085
1086 /* Another shared interface:  the 'frame_base' object specifies how to
1087    unwind a frame and secure the base addresses for frame objects
1088    (locals, args).  */
1089
1090 static struct frame_base mt_frame_base = {
1091   &mt_frame_unwind,
1092   mt_frame_base_address,
1093   mt_frame_base_address,
1094   mt_frame_base_address
1095 };
1096
1097 static struct gdbarch *
1098 mt_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1099 {
1100   struct gdbarch *gdbarch;
1101
1102   /* Find a candidate among the list of pre-declared architectures.  */
1103   arches = gdbarch_list_lookup_by_info (arches, &info);
1104   if (arches != NULL)
1105     return arches->gdbarch;
1106
1107   /* None found, create a new architecture from the information
1108      provided.  */
1109   gdbarch = gdbarch_alloc (&info, NULL);
1110
1111   set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
1112   set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
1113   set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
1114
1115   set_gdbarch_register_name (gdbarch, mt_register_name);
1116   set_gdbarch_num_regs (gdbarch, MT_NUM_REGS);
1117   set_gdbarch_num_pseudo_regs (gdbarch, MT_NUM_PSEUDO_REGS);
1118   set_gdbarch_pc_regnum (gdbarch, MT_PC_REGNUM);
1119   set_gdbarch_sp_regnum (gdbarch, MT_SP_REGNUM);
1120   set_gdbarch_pseudo_register_read (gdbarch, mt_pseudo_register_read);
1121   set_gdbarch_pseudo_register_write (gdbarch, mt_pseudo_register_write);
1122   set_gdbarch_skip_prologue (gdbarch, mt_skip_prologue);
1123   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1124   set_gdbarch_breakpoint_from_pc (gdbarch, mt_breakpoint_from_pc);
1125   set_gdbarch_decr_pc_after_break (gdbarch, 0);
1126   set_gdbarch_frame_args_skip (gdbarch, 0);
1127   set_gdbarch_print_insn (gdbarch, print_insn_mt);
1128   set_gdbarch_register_type (gdbarch, mt_register_type);
1129   set_gdbarch_register_reggroup_p (gdbarch, mt_register_reggroup_p);
1130
1131   set_gdbarch_return_value (gdbarch, mt_return_value);
1132   set_gdbarch_sp_regnum (gdbarch, MT_SP_REGNUM);
1133
1134   set_gdbarch_frame_align (gdbarch, mt_frame_align);
1135
1136   set_gdbarch_print_registers_info (gdbarch, mt_registers_info);
1137
1138   set_gdbarch_push_dummy_call (gdbarch, mt_push_dummy_call);
1139
1140   /* Target builtin data types.  */
1141   set_gdbarch_short_bit (gdbarch, 16);
1142   set_gdbarch_int_bit (gdbarch, 32);
1143   set_gdbarch_long_bit (gdbarch, 32);
1144   set_gdbarch_long_long_bit (gdbarch, 64);
1145   set_gdbarch_float_bit (gdbarch, 32);
1146   set_gdbarch_double_bit (gdbarch, 64);
1147   set_gdbarch_long_double_bit (gdbarch, 64);
1148   set_gdbarch_ptr_bit (gdbarch, 32);
1149
1150   /* Register the DWARF 2 sniffer first, and then the traditional prologue
1151      based sniffer.  */
1152   dwarf2_append_unwinders (gdbarch);
1153   frame_unwind_append_unwinder (gdbarch, &mt_frame_unwind);
1154   frame_base_set_default (gdbarch, &mt_frame_base);
1155
1156   /* Register the 'unwind_pc' method.  */
1157   set_gdbarch_unwind_pc (gdbarch, mt_unwind_pc);
1158   set_gdbarch_unwind_sp (gdbarch, mt_unwind_sp);
1159
1160   /* Methods for saving / extracting a dummy frame's ID.
1161      The ID's stack address must match the SP value returned by
1162      PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos.  */
1163   set_gdbarch_dummy_id (gdbarch, mt_dummy_id);
1164
1165   return gdbarch;
1166 }
1167
1168 /* Provide a prototype to silence -Wmissing-prototypes.  */
1169 extern initialize_file_ftype _initialize_mt_tdep;
1170
1171 void
1172 _initialize_mt_tdep (void)
1173 {
1174   register_gdbarch_init (bfd_arch_mt, mt_gdbarch_init);
1175 }