gdb/mt-tdep.c

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