gdb/mt-tdep.c

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