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