gdb/mt-tdep.c

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