gdb/mt-tdep.c

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