gdb/mt-tdep.c

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