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 /* The breakpoint instruction must be the same size as the smallest
 453    instruction in the instruction set.
 454
 455    The BP for ms1 is defined as 0x68000000 (BREAK).
 456    The BP for ms2 is defined as 0x69000000 (illegal).  */
 457
 458 static const gdb_byte *
 459 mt_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *bp_addr,
 460                        int *bp_size)
 461 {
 462   static gdb_byte ms1_breakpoint[] = { 0x68, 0, 0, 0 };
 463   static gdb_byte ms2_breakpoint[] = { 0x69, 0, 0, 0 };
 464
 465   *bp_size = 4;
 466   if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_ms2)
 467     return ms2_breakpoint;
 468
 469   return ms1_breakpoint;
 470 }
 471
 472 /* Select the correct coprocessor register bank.  Return the pseudo
 473    regnum we really want to read.  */
 474
 475 static int
 476 mt_select_coprocessor (struct gdbarch *gdbarch,
 477                         struct regcache *regcache, int regno)
 478 {
 479   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 480   unsigned index, base;
 481   gdb_byte copro[4];
 482
 483   /* Get the copro pseudo regnum.  */
 484   regcache_raw_read (regcache, MT_COPRO_REGNUM, copro);
 485   base = ((extract_signed_integer (&copro[0], 2, byte_order)
 486            * MT_COPRO_PSEUDOREG_DIM_2)
 487           + extract_signed_integer (&copro[2], 2, byte_order));
 488
 489   regno -= MT_COPRO_PSEUDOREG_ARRAY;
 490   index = regno % MT_COPRO_PSEUDOREG_REGS;
 491   regno /= MT_COPRO_PSEUDOREG_REGS;
 492   if (base != regno)
 493     {
 494       /* Select the correct coprocessor register bank.  Invalidate the
 495          coprocessor register cache.  */
 496       unsigned ix;
 497
 498       store_signed_integer (&copro[0], 2, byte_order,
 499                             regno / MT_COPRO_PSEUDOREG_DIM_2);
 500       store_signed_integer (&copro[2], 2, byte_order,
 501                             regno % MT_COPRO_PSEUDOREG_DIM_2);
 502       regcache_raw_write (regcache, MT_COPRO_REGNUM, copro);
 503
 504       /* We must flush the cache, as it is now invalid.  */
 505       for (ix = MT_NUM_CPU_REGS; ix != MT_NUM_REGS; ix++)
 506         regcache_invalidate (regcache, ix);
 507     }
 508
 509   return index;
 510 }
 511
 512 /* Fetch the pseudo registers:
 513
 514    There are two regular pseudo-registers:
 515    1) The 'coprocessor' pseudo-register (which mirrors the
 516    "real" coprocessor register sent by the target), and
 517    2) The 'MAC' pseudo-register (which represents the union
 518    of the original 32 bit target MAC register and the new
 519    8-bit extended-MAC register).
 520
 521    Additionally there is an array of coprocessor registers which track
 522    the coprocessor registers for each coprocessor.  */
 523
 524 static enum register_status
 525 mt_pseudo_register_read (struct gdbarch *gdbarch,
 526                          struct regcache *regcache, int regno, gdb_byte *buf)
 527 {
 528   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 529
 530   switch (regno)
 531     {
 532     case MT_COPRO_REGNUM:
 533     case MT_COPRO_PSEUDOREG_REGNUM:
 534       return regcache_raw_read (regcache, MT_COPRO_REGNUM, buf);
 535     case MT_MAC_REGNUM:
 536     case MT_MAC_PSEUDOREG_REGNUM:
 537       if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_mrisc2
 538           || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_ms2)
 539         {
 540           enum register_status status;
 541           ULONGEST oldmac = 0, ext_mac = 0;
 542           ULONGEST newmac;
 543
 544           status = regcache_cooked_read_unsigned (regcache, MT_MAC_REGNUM, &oldmac);
 545           if (status != REG_VALID)
 546             return status;
 547
 548           regcache_cooked_read_unsigned (regcache, MT_EXMAC_REGNUM, &ext_mac);
 549           if (status != REG_VALID)
 550             return status;
 551
 552           newmac =
 553             (oldmac & 0xffffffff) | ((long long) (ext_mac & 0xff) << 32);
 554           store_signed_integer (buf, 8, byte_order, newmac);
 555
 556           return REG_VALID;
 557         }
 558       else
 559         return regcache_raw_read (regcache, MT_MAC_REGNUM, buf);
 560       break;
 561     default:
 562       {
 563         unsigned index = mt_select_coprocessor (gdbarch, regcache, regno);
 564
 565         if (index == MT_COPRO_PSEUDOREG_MAC_REGNUM)
 566           return mt_pseudo_register_read (gdbarch, regcache,
 567                                           MT_MAC_PSEUDOREG_REGNUM, buf);
 568         else if (index < MT_NUM_REGS - MT_CPR0_REGNUM)
 569           return regcache_raw_read (regcache, index + MT_CPR0_REGNUM, buf);
 570         else
 571           /* ??? */
 572           return REG_VALID;
 573       }
 574       break;
 575     }
 576 }
 577
 578 /* Write the pseudo registers:
 579
 580    Mt pseudo-registers are stored directly to the target.  The
 581    'coprocessor' register is special, because when it is modified, all
 582    the other coprocessor regs must be flushed from the reg cache.  */
 583
 584 static void
 585 mt_pseudo_register_write (struct gdbarch *gdbarch,
 586                            struct regcache *regcache,
 587                            int regno, const gdb_byte *buf)
 588 {
 589   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 590   int i;
 591
 592   switch (regno)
 593     {
 594     case MT_COPRO_REGNUM:
 595     case MT_COPRO_PSEUDOREG_REGNUM:
 596       regcache_raw_write (regcache, MT_COPRO_REGNUM, buf);
 597       for (i = MT_NUM_CPU_REGS; i < MT_NUM_REGS; i++)
 598         regcache_invalidate (regcache, i);
 599       break;
 600     case MT_MAC_REGNUM:
 601     case MT_MAC_PSEUDOREG_REGNUM:
 602       if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_mrisc2
 603           || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_ms2)
 604         {
 605           /* The 8-byte MAC pseudo-register must be broken down into two
 606              32-byte registers.  */
 607           unsigned int oldmac, ext_mac;
 608           ULONGEST newmac;
 609
 610           newmac = extract_unsigned_integer (buf, 8, byte_order);
 611           oldmac = newmac & 0xffffffff;
 612           ext_mac = (newmac >> 32) & 0xff;
 613           regcache_cooked_write_unsigned (regcache, MT_MAC_REGNUM, oldmac);
 614           regcache_cooked_write_unsigned (regcache, MT_EXMAC_REGNUM, ext_mac);
 615         }
 616       else
 617         regcache_raw_write (regcache, MT_MAC_REGNUM, buf);
 618       break;
 619     default:
 620       {
 621         unsigned index = mt_select_coprocessor (gdbarch, regcache, regno);
 622
 623         if (index == MT_COPRO_PSEUDOREG_MAC_REGNUM)
 624           mt_pseudo_register_write (gdbarch, regcache,
 625                                     MT_MAC_PSEUDOREG_REGNUM, buf);
 626         else if (index < MT_NUM_REGS - MT_CPR0_REGNUM)
 627           regcache_raw_write (regcache, index + MT_CPR0_REGNUM, buf);
 628       }
 629       break;
 630     }
 631 }
 632
 633 static CORE_ADDR
 634 mt_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
 635 {
 636   /* Register size is 4 bytes.  */
 637   return align_down (sp, 4);
 638 }
 639
 640 /* Implements the "info registers" command.   When ``all'' is non-zero,
 641    the coprocessor registers will be printed in addition to the rest
 642    of the registers.  */
 643
 644 static void
 645 mt_registers_info (struct gdbarch *gdbarch,
 646                    struct ui_file *file,
 647                    struct frame_info *frame, int regnum, int all)
 648 {
 649   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 650
 651   if (regnum == -1)
 652     {
 653       int lim;
 654
 655       lim = all ? MT_NUM_REGS : MT_NUM_CPU_REGS;
 656
 657       for (regnum = 0; regnum < lim; regnum++)
 658         {
 659           /* Don't display the Qchannel register since it will be displayed
 660              along with Ichannel.  (See below.)  */
 661           if (regnum == MT_QCHANNEL_REGNUM)
 662             continue;
 663
 664           mt_registers_info (gdbarch, file, frame, regnum, all);
 665
 666           /* Display the Qchannel register immediately after Ichannel.  */
 667           if (regnum == MT_ICHANNEL_REGNUM)
 668             mt_registers_info (gdbarch, file, frame, MT_QCHANNEL_REGNUM, all);
 669         }
 670     }
 671   else
 672     {
 673       if (regnum == MT_EXMAC_REGNUM)
 674         return;
 675       else if (regnum == MT_CONTEXT_REGNUM)
 676         {
 677           /* Special output handling for 38-bit context register.  */
 678           unsigned char *buff;
 679           unsigned int i, regsize;
 680
 681           regsize = register_size (gdbarch, regnum);
 682
 683           buff = (unsigned char *) alloca (regsize);
 684
 685           deprecated_frame_register_read (frame, regnum, buff);
 686
 687           fputs_filtered (gdbarch_register_name
 688                           (gdbarch, regnum), file);
 689           print_spaces_filtered (15 - strlen (gdbarch_register_name
 690                                                 (gdbarch, regnum)),
 691                                  file);
 692           fputs_filtered ("0x", file);
 693
 694           for (i = 0; i < regsize; i++)
 695             fprintf_filtered (file, "%02x", (unsigned int)
 696                               extract_unsigned_integer (buff + i, 1, byte_order));
 697           fputs_filtered ("\t", file);
 698           print_longest (file, 'd', 0,
 699                          extract_unsigned_integer (buff, regsize, byte_order));
 700           fputs_filtered ("\n", file);
 701         }
 702       else if (regnum == MT_COPRO_REGNUM
 703                || regnum == MT_COPRO_PSEUDOREG_REGNUM)
 704         {
 705           /* Special output handling for the 'coprocessor' register.  */
 706           gdb_byte *buf;
 707           struct value_print_options opts;
 708
 709           buf = (gdb_byte *) alloca (register_size (gdbarch, MT_COPRO_REGNUM));
 710           deprecated_frame_register_read (frame, MT_COPRO_REGNUM, buf);
 711           /* And print.  */
 712           regnum = MT_COPRO_PSEUDOREG_REGNUM;
 713           fputs_filtered (gdbarch_register_name (gdbarch, regnum),
 714                           file);
 715           print_spaces_filtered (15 - strlen (gdbarch_register_name
 716                                                 (gdbarch, regnum)),
 717                                  file);
 718           get_no_prettyformat_print_options (&opts);
 719           opts.deref_ref = 1;
 720           val_print (register_type (gdbarch, regnum), buf,
 721                      0, 0, file, 0, NULL,
 722                      &opts, current_language);
 723           fputs_filtered ("\n", file);
 724         }
 725       else if (regnum == MT_MAC_REGNUM || regnum == MT_MAC_PSEUDOREG_REGNUM)
 726         {
 727           ULONGEST oldmac, ext_mac, newmac;
 728           gdb_byte buf[3 * sizeof (LONGEST)];
 729
 730           /* Get the two "real" mac registers.  */
 731           deprecated_frame_register_read (frame, MT_MAC_REGNUM, buf);
 732           oldmac = extract_unsigned_integer
 733             (buf, register_size (gdbarch, MT_MAC_REGNUM), byte_order);
 734           if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_mrisc2
 735               || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_ms2)
 736             {
 737               deprecated_frame_register_read (frame, MT_EXMAC_REGNUM, buf);
 738               ext_mac = extract_unsigned_integer
 739                 (buf, register_size (gdbarch, MT_EXMAC_REGNUM), byte_order);
 740             }
 741           else
 742             ext_mac = 0;
 743
 744           /* Add them together.  */
 745           newmac = (oldmac & 0xffffffff) + ((ext_mac & 0xff) << 32);
 746
 747           /* And print.  */
 748           regnum = MT_MAC_PSEUDOREG_REGNUM;
 749           fputs_filtered (gdbarch_register_name (gdbarch, regnum),
 750                           file);
 751           print_spaces_filtered (15 - strlen (gdbarch_register_name
 752                                               (gdbarch, regnum)),
 753                                  file);
 754           fputs_filtered ("0x", file);
 755           print_longest (file, 'x', 0, newmac);
 756           fputs_filtered ("\t", file);
 757           print_longest (file, 'u', 0, newmac);
 758           fputs_filtered ("\n", file);
 759         }
 760       else
 761         default_print_registers_info (gdbarch, file, frame, regnum, all);
 762     }
 763 }
 764
 765 /* Set up the callee's arguments for an inferior function call.  The
 766    arguments are pushed on the stack or are placed in registers as
 767    appropriate.  It also sets up the return address (which points to
 768    the call dummy breakpoint).
 769
 770    Returns the updated (and aligned) stack pointer.  */
 771
 772 static CORE_ADDR
 773 mt_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 774                      struct regcache *regcache, CORE_ADDR bp_addr,
 775                      int nargs, struct value **args, CORE_ADDR sp,
 776                      int struct_return, CORE_ADDR struct_addr)
 777 {
 778 #define wordsize 4
 779   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 780   gdb_byte buf[MT_MAX_STRUCT_SIZE];
 781   int argreg = MT_1ST_ARGREG;
 782   int split_param_len = 0;
 783   int stack_dest = sp;
 784   int slacklen;
 785   int typelen;
 786   int i, j;
 787
 788   /* First handle however many args we can fit into MT_1ST_ARGREG thru
 789      MT_LAST_ARGREG.  */
 790   for (i = 0; i < nargs && argreg <= MT_LAST_ARGREG; i++)
 791     {
 792       const gdb_byte *val;
 793       typelen = TYPE_LENGTH (value_type (args[i]));
 794       switch (typelen)
 795         {
 796         case 1:
 797         case 2:
 798         case 3:
 799         case 4:
 800           regcache_cooked_write_unsigned (regcache, argreg++,
 801                                           extract_unsigned_integer
 802                                           (value_contents (args[i]),
 803                                            wordsize, byte_order));
 804           break;
 805         case 8:
 806         case 12:
 807         case 16:
 808           val = value_contents (args[i]);
 809           while (typelen > 0)
 810             {
 811               if (argreg <= MT_LAST_ARGREG)
 812                 {
 813                   /* This word of the argument is passed in a register.  */
 814                   regcache_cooked_write_unsigned (regcache, argreg++,
 815                                                   extract_unsigned_integer
 816                                                   (val, wordsize, byte_order));
 817                   typelen -= wordsize;
 818                   val += wordsize;
 819                 }
 820               else
 821                 {
 822                   /* Remainder of this arg must be passed on the stack
 823                      (deferred to do later).  */
 824                   split_param_len = typelen;
 825                   memcpy (buf, val, typelen);
 826                   break;        /* No more args can be handled in regs.  */
 827                 }
 828             }
 829           break;
 830         default:
 831           /* By reverse engineering of gcc output, args bigger than
 832              16 bytes go on the stack, and their address is passed
 833              in the argreg.  */
 834           stack_dest -= typelen;
 835           write_memory (stack_dest, value_contents (args[i]), typelen);
 836           regcache_cooked_write_unsigned (regcache, argreg++, stack_dest);
 837           break;
 838         }
 839     }
 840
 841   /* Next, the rest of the arguments go onto the stack, in reverse order.  */
 842   for (j = nargs - 1; j >= i; j--)
 843     {
 844       gdb_byte *val;
 845       struct cleanup *back_to;
 846       const gdb_byte *contents = value_contents (args[j]);
 847
 848       /* Right-justify the value in an aligned-length buffer.  */
 849       typelen = TYPE_LENGTH (value_type (args[j]));
 850       slacklen = (wordsize - (typelen % wordsize)) % wordsize;
 851       val = (gdb_byte *) xmalloc (typelen + slacklen);
 852       back_to = make_cleanup (xfree, val);
 853       memcpy (val, contents, typelen);
 854       memset (val + typelen, 0, slacklen);
 855       /* Now write this data to the stack.  */
 856       stack_dest -= typelen + slacklen;
 857       write_memory (stack_dest, val, typelen + slacklen);
 858       do_cleanups (back_to);
 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 (struct mt_unwind_cache *) (*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   default_frame_unwind_stop_reason,
1119   mt_frame_this_id,
1120   mt_frame_prev_register,
1121   NULL,
1122   default_frame_sniffer
1123 };
1124
1125 /* Another shared interface:  the 'frame_base' object specifies how to
1126    unwind a frame and secure the base addresses for frame objects
1127    (locals, args).  */
1128
1129 static struct frame_base mt_frame_base = {
1130   &mt_frame_unwind,
1131   mt_frame_base_address,
1132   mt_frame_base_address,
1133   mt_frame_base_address
1134 };
1135
1136 static struct gdbarch *
1137 mt_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1138 {
1139   struct gdbarch *gdbarch;
1140   struct gdbarch_tdep *tdep;
1141
1142   /* Find a candidate among the list of pre-declared architectures.  */
1143   arches = gdbarch_list_lookup_by_info (arches, &info);
1144   if (arches != NULL)
1145     return arches->gdbarch;
1146
1147   /* None found, create a new architecture from the information
1148      provided.  */
1149   tdep = XCNEW (struct gdbarch_tdep);
1150   gdbarch = gdbarch_alloc (&info, tdep);
1151
1152   set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
1153   set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
1154   set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
1155
1156   set_gdbarch_register_name (gdbarch, mt_register_name);
1157   set_gdbarch_num_regs (gdbarch, MT_NUM_REGS);
1158   set_gdbarch_num_pseudo_regs (gdbarch, MT_NUM_PSEUDO_REGS);
1159   set_gdbarch_pc_regnum (gdbarch, MT_PC_REGNUM);
1160   set_gdbarch_sp_regnum (gdbarch, MT_SP_REGNUM);
1161   set_gdbarch_pseudo_register_read (gdbarch, mt_pseudo_register_read);
1162   set_gdbarch_pseudo_register_write (gdbarch, mt_pseudo_register_write);
1163   set_gdbarch_skip_prologue (gdbarch, mt_skip_prologue);
1164   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1165   set_gdbarch_breakpoint_from_pc (gdbarch, mt_breakpoint_from_pc);
1166   set_gdbarch_decr_pc_after_break (gdbarch, 0);
1167   set_gdbarch_frame_args_skip (gdbarch, 0);
1168   set_gdbarch_print_insn (gdbarch, print_insn_mt);
1169   set_gdbarch_register_type (gdbarch, mt_register_type);
1170   set_gdbarch_register_reggroup_p (gdbarch, mt_register_reggroup_p);
1171
1172   set_gdbarch_return_value (gdbarch, mt_return_value);
1173   set_gdbarch_sp_regnum (gdbarch, MT_SP_REGNUM);
1174
1175   set_gdbarch_frame_align (gdbarch, mt_frame_align);
1176
1177   set_gdbarch_print_registers_info (gdbarch, mt_registers_info);
1178
1179   set_gdbarch_push_dummy_call (gdbarch, mt_push_dummy_call);
1180
1181   /* Target builtin data types.  */
1182   set_gdbarch_short_bit (gdbarch, 16);
1183   set_gdbarch_int_bit (gdbarch, 32);
1184   set_gdbarch_long_bit (gdbarch, 32);
1185   set_gdbarch_long_long_bit (gdbarch, 64);
1186   set_gdbarch_float_bit (gdbarch, 32);
1187   set_gdbarch_double_bit (gdbarch, 64);
1188   set_gdbarch_long_double_bit (gdbarch, 64);
1189   set_gdbarch_ptr_bit (gdbarch, 32);
1190
1191   /* Register the DWARF 2 sniffer first, and then the traditional prologue
1192      based sniffer.  */
1193   dwarf2_append_unwinders (gdbarch);
1194   frame_unwind_append_unwinder (gdbarch, &mt_frame_unwind);
1195   frame_base_set_default (gdbarch, &mt_frame_base);
1196
1197   /* Register the 'unwind_pc' method.  */
1198   set_gdbarch_unwind_pc (gdbarch, mt_unwind_pc);
1199   set_gdbarch_unwind_sp (gdbarch, mt_unwind_sp);
1200
1201   /* Methods for saving / extracting a dummy frame's ID.
1202      The ID's stack address must match the SP value returned by
1203      PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos.  */
1204   set_gdbarch_dummy_id (gdbarch, mt_dummy_id);
1205
1206   return gdbarch;
1207 }
1208
1209 /* Provide a prototype to silence -Wmissing-prototypes.  */
1210 extern initialize_file_ftype _initialize_mt_tdep;
1211
1212 void
1213 _initialize_mt_tdep (void)
1214 {
1215   register_gdbarch_init (bfd_arch_mt, mt_gdbarch_init);
1216 }