gdb/mt-tdep.c

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