gdb/mt-tdep.c

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