gdb/mt-tdep.c

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