gdb/mn10300-tdep.c

   1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
   2
   3    Copyright (C) 1996-2019 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 #include "defs.h"
  21 #include "arch-utils.h"
  22 #include "dis-asm.h"
  23 #include "gdbtypes.h"
  24 #include "regcache.h"
  25 #include "gdbcore.h"    /* For write_memory_unsigned_integer.  */
  26 #include "value.h"
  27 #include "frame.h"
  28 #include "frame-unwind.h"
  29 #include "frame-base.h"
  30 #include "symtab.h"
  31 #include "dwarf2-frame.h"
  32 #include "osabi.h"
  33 #include "infcall.h"
  34 #include "prologue-value.h"
  35 #include "target.h"
  36
  37 #include "mn10300-tdep.h"
  38
  39
  40 /* The am33-2 has 64 registers.  */
  41 #define MN10300_MAX_NUM_REGS 64
  42
  43 /* Big enough to hold the size of the largest register in bytes.  */
  44 #define MN10300_MAX_REGISTER_SIZE      64
  45
  46 /* This structure holds the results of a prologue analysis.  */
  47 struct mn10300_prologue
  48 {
  49   /* The architecture for which we generated this prologue info.  */
  50   struct gdbarch *gdbarch;
  51
  52   /* The offset from the frame base to the stack pointer --- always
  53      zero or negative.
  54
  55      Calling this a "size" is a bit misleading, but given that the
  56      stack grows downwards, using offsets for everything keeps one
  57      from going completely sign-crazy: you never change anything's
  58      sign for an ADD instruction; always change the second operand's
  59      sign for a SUB instruction; and everything takes care of
  60      itself.  */
  61   int frame_size;
  62
  63   /* Non-zero if this function has initialized the frame pointer from
  64      the stack pointer, zero otherwise.  */
  65   int has_frame_ptr;
  66
  67   /* If has_frame_ptr is non-zero, this is the offset from the frame
  68      base to where the frame pointer points.  This is always zero or
  69      negative.  */
  70   int frame_ptr_offset;
  71
  72   /* The address of the first instruction at which the frame has been
  73      set up and the arguments are where the debug info says they are
  74      --- as best as we can tell.  */
  75   CORE_ADDR prologue_end;
  76
  77   /* reg_offset[R] is the offset from the CFA at which register R is
  78      saved, or 1 if register R has not been saved.  (Real values are
  79      always zero or negative.)  */
  80   int reg_offset[MN10300_MAX_NUM_REGS];
  81 };
  82
  83
  84 /* Compute the alignment required by a type.  */
  85
  86 static int
  87 mn10300_type_align (struct type *type)
  88 {
  89   int i, align = 1;
  90
  91   switch (TYPE_CODE (type))
  92     {
  93     case TYPE_CODE_INT:
  94     case TYPE_CODE_ENUM:
  95     case TYPE_CODE_SET:
  96     case TYPE_CODE_RANGE:
  97     case TYPE_CODE_CHAR:
  98     case TYPE_CODE_BOOL:
  99     case TYPE_CODE_FLT:
 100     case TYPE_CODE_PTR:
 101     case TYPE_CODE_REF:
 102     case TYPE_CODE_RVALUE_REF:
 103       return TYPE_LENGTH (type);
 104
 105     case TYPE_CODE_COMPLEX:
 106       return TYPE_LENGTH (type) / 2;
 107
 108     case TYPE_CODE_STRUCT:
 109     case TYPE_CODE_UNION:
 110       for (i = 0; i < TYPE_NFIELDS (type); i++)
 111         {
 112           int falign = mn10300_type_align (TYPE_FIELD_TYPE (type, i));
 113           while (align < falign)
 114             align <<= 1;
 115         }
 116       return align;
 117
 118     case TYPE_CODE_ARRAY:
 119       /* HACK!  Structures containing arrays, even small ones, are not
 120          elligible for returning in registers.  */
 121       return 256;
 122
 123     case TYPE_CODE_TYPEDEF:
 124       return mn10300_type_align (check_typedef (type));
 125
 126     default:
 127       internal_error (__FILE__, __LINE__, _("bad switch"));
 128     }
 129 }
 130
 131 /* Should call_function allocate stack space for a struct return?  */
 132 static int
 133 mn10300_use_struct_convention (struct type *type)
 134 {
 135   /* Structures bigger than a pair of words can't be returned in
 136      registers.  */
 137   if (TYPE_LENGTH (type) > 8)
 138     return 1;
 139
 140   switch (TYPE_CODE (type))
 141     {
 142     case TYPE_CODE_STRUCT:
 143     case TYPE_CODE_UNION:
 144       /* Structures with a single field are handled as the field
 145          itself.  */
 146       if (TYPE_NFIELDS (type) == 1)
 147         return mn10300_use_struct_convention (TYPE_FIELD_TYPE (type, 0));
 148
 149       /* Structures with word or double-word size are passed in memory, as
 150          long as they require at least word alignment.  */
 151       if (mn10300_type_align (type) >= 4)
 152         return 0;
 153
 154       return 1;
 155
 156       /* Arrays are addressable, so they're never returned in
 157          registers.  This condition can only hold when the array is
 158          the only field of a struct or union.  */
 159     case TYPE_CODE_ARRAY:
 160       return 1;
 161
 162     case TYPE_CODE_TYPEDEF:
 163       return mn10300_use_struct_convention (check_typedef (type));
 164
 165     default:
 166       return 0;
 167     }
 168 }
 169
 170 static void
 171 mn10300_store_return_value (struct gdbarch *gdbarch, struct type *type,
 172                             struct regcache *regcache, const gdb_byte *valbuf)
 173 {
 174   int len = TYPE_LENGTH (type);
 175   int reg, regsz;
 176
 177   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 178     reg = 4;
 179   else
 180     reg = 0;
 181
 182   regsz = register_size (gdbarch, reg);
 183
 184   if (len <= regsz)
 185     regcache->raw_write_part (reg, 0, len, valbuf);
 186   else if (len <= 2 * regsz)
 187     {
 188       regcache->raw_write (reg, valbuf);
 189       gdb_assert (regsz == register_size (gdbarch, reg + 1));
 190       regcache->raw_write_part (reg + 1, 0, len - regsz, valbuf + regsz);
 191     }
 192   else
 193     internal_error (__FILE__, __LINE__,
 194                     _("Cannot store return value %d bytes long."), len);
 195 }
 196
 197 static void
 198 mn10300_extract_return_value (struct gdbarch *gdbarch, struct type *type,
 199                               struct regcache *regcache, void *valbuf)
 200 {
 201   gdb_byte buf[MN10300_MAX_REGISTER_SIZE];
 202   int len = TYPE_LENGTH (type);
 203   int reg, regsz;
 204
 205   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 206     reg = 4;
 207   else
 208     reg = 0;
 209
 210   regsz = register_size (gdbarch, reg);
 211   gdb_assert (regsz <= MN10300_MAX_REGISTER_SIZE);
 212   if (len <= regsz)
 213     {
 214       regcache->raw_read (reg, buf);
 215       memcpy (valbuf, buf, len);
 216     }
 217   else if (len <= 2 * regsz)
 218     {
 219       regcache->raw_read (reg, buf);
 220       memcpy (valbuf, buf, regsz);
 221       gdb_assert (regsz == register_size (gdbarch, reg + 1));
 222       regcache->raw_read (reg + 1, buf);
 223       memcpy ((char *) valbuf + regsz, buf, len - regsz);
 224     }
 225   else
 226     internal_error (__FILE__, __LINE__,
 227                     _("Cannot extract return value %d bytes long."), len);
 228 }
 229
 230 /* Determine, for architecture GDBARCH, how a return value of TYPE
 231    should be returned.  If it is supposed to be returned in registers,
 232    and READBUF is non-zero, read the appropriate value from REGCACHE,
 233    and copy it into READBUF.  If WRITEBUF is non-zero, write the value
 234    from WRITEBUF into REGCACHE.  */
 235
 236 static enum return_value_convention
 237 mn10300_return_value (struct gdbarch *gdbarch, struct value *function,
 238                       struct type *type, struct regcache *regcache,
 239                       gdb_byte *readbuf, const gdb_byte *writebuf)
 240 {
 241   if (mn10300_use_struct_convention (type))
 242     return RETURN_VALUE_STRUCT_CONVENTION;
 243
 244   if (readbuf)
 245     mn10300_extract_return_value (gdbarch, type, regcache, readbuf);
 246   if (writebuf)
 247     mn10300_store_return_value (gdbarch, type, regcache, writebuf);
 248
 249   return RETURN_VALUE_REGISTER_CONVENTION;
 250 }
 251
 252 static const char *
 253 register_name (int reg, const char **regs, long sizeof_regs)
 254 {
 255   if (reg < 0 || reg >= sizeof_regs / sizeof (regs[0]))
 256     return NULL;
 257   else
 258     return regs[reg];
 259 }
 260
 261 static const char *
 262 mn10300_generic_register_name (struct gdbarch *gdbarch, int reg)
 263 {
 264   static const char *regs[] =
 265   { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
 266     "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
 267     "", "", "", "", "", "", "", "",
 268     "", "", "", "", "", "", "", "fp"
 269   };
 270   return register_name (reg, regs, sizeof regs);
 271 }
 272
 273
 274 static const char *
 275 am33_register_name (struct gdbarch *gdbarch, int reg)
 276 {
 277   static const char *regs[] =
 278   { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
 279     "sp", "pc", "mdr", "psw", "lir", "lar", "",
 280     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 281     "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
 282   };
 283   return register_name (reg, regs, sizeof regs);
 284 }
 285
 286 static const char *
 287 am33_2_register_name (struct gdbarch *gdbarch, int reg)
 288 {
 289   static const char *regs[] =
 290   {
 291     "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
 292     "sp", "pc", "mdr", "psw", "lir", "lar", "mdrq", "r0",
 293     "r1", "r2", "r3", "r4", "r5", "r6", "r7", "ssp",
 294     "msp", "usp", "mcrh", "mcrl", "mcvf", "fpcr", "", "",
 295     "fs0", "fs1", "fs2", "fs3", "fs4", "fs5", "fs6", "fs7",
 296     "fs8", "fs9", "fs10", "fs11", "fs12", "fs13", "fs14", "fs15",
 297     "fs16", "fs17", "fs18", "fs19", "fs20", "fs21", "fs22", "fs23",
 298     "fs24", "fs25", "fs26", "fs27", "fs28", "fs29", "fs30", "fs31"
 299   };
 300   return register_name (reg, regs, sizeof regs);
 301 }
 302
 303 static struct type *
 304 mn10300_register_type (struct gdbarch *gdbarch, int reg)
 305 {
 306   return builtin_type (gdbarch)->builtin_int;
 307 }
 308
 309 /* The breakpoint instruction must be the same size as the smallest
 310    instruction in the instruction set.
 311
 312    The Matsushita mn10x00 processors have single byte instructions
 313    so we need a single byte breakpoint.  Matsushita hasn't defined
 314    one, so we defined it ourselves.  */
 315 constexpr gdb_byte mn10300_break_insn[] = {0xff};
 316
 317 typedef BP_MANIPULATION (mn10300_break_insn) mn10300_breakpoint;
 318
 319 /* Model the semantics of pushing a register onto the stack.  This
 320    is a helper function for mn10300_analyze_prologue, below.  */
 321 static void
 322 push_reg (pv_t *regs, struct pv_area *stack, int regnum)
 323 {
 324   regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], -4);
 325   stack->store (regs[E_SP_REGNUM], 4, regs[regnum]);
 326 }
 327
 328 /* Translate an "r" register number extracted from an instruction encoding
 329    into a GDB register number.  Adapted from a simulator function
 330    of the same name; see am33.igen.  */
 331 static int
 332 translate_rreg (int rreg)
 333 {
 334  /* The higher register numbers actually correspond to the
 335      basic machine's address and data registers.  */
 336   if (rreg > 7 && rreg < 12)
 337     return E_A0_REGNUM + rreg - 8;
 338   else if (rreg > 11 && rreg < 16)
 339     return E_D0_REGNUM + rreg - 12;
 340   else
 341     return E_E0_REGNUM + rreg;
 342 }
 343
 344 /* Find saved registers in a 'struct pv_area'; we pass this to pv_area::scan.
 345
 346    If VALUE is a saved register, ADDR says it was saved at a constant
 347    offset from the frame base, and SIZE indicates that the whole
 348    register was saved, record its offset in RESULT_UNTYPED.  */
 349 static void
 350 check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size, pv_t value)
 351 {
 352   struct mn10300_prologue *result = (struct mn10300_prologue *) result_untyped;
 353
 354   if (value.kind == pvk_register
 355       && value.k == 0
 356       && pv_is_register (addr, E_SP_REGNUM)
 357       && size == register_size (result->gdbarch, value.reg))
 358     result->reg_offset[value.reg] = addr.k;
 359 }
 360
 361 /* Analyze the prologue to determine where registers are saved,
 362    the end of the prologue, etc.  The result of this analysis is
 363    returned in RESULT.  See struct mn10300_prologue above for more
 364    information.  */
 365 static void
 366 mn10300_analyze_prologue (struct gdbarch *gdbarch,
 367                           CORE_ADDR start_pc, CORE_ADDR limit_pc,
 368                           struct mn10300_prologue *result)
 369 {
 370   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 371   CORE_ADDR pc;
 372   int rn;
 373   pv_t regs[MN10300_MAX_NUM_REGS];
 374   CORE_ADDR after_last_frame_setup_insn = start_pc;
 375   int am33_mode = AM33_MODE (gdbarch);
 376
 377   memset (result, 0, sizeof (*result));
 378   result->gdbarch = gdbarch;
 379
 380   for (rn = 0; rn < MN10300_MAX_NUM_REGS; rn++)
 381     {
 382       regs[rn] = pv_register (rn, 0);
 383       result->reg_offset[rn] = 1;
 384     }
 385   pv_area stack (E_SP_REGNUM, gdbarch_addr_bit (gdbarch));
 386
 387   /* The typical call instruction will have saved the return address on the
 388      stack.  Space for the return address has already been preallocated in
 389      the caller's frame.  It's possible, such as when using -mrelax with gcc
 390      that other registers were saved as well.  If this happens, we really
 391      have no chance of deciphering the frame.  DWARF info can save the day
 392      when this happens.  */
 393   stack.store (regs[E_SP_REGNUM], 4, regs[E_PC_REGNUM]);
 394
 395   pc = start_pc;
 396   while (pc < limit_pc)
 397     {
 398       int status;
 399       gdb_byte instr[2];
 400
 401       /* Instructions can be as small as one byte; however, we usually
 402          need at least two bytes to do the decoding, so fetch that many
 403          to begin with.  */
 404       status = target_read_memory (pc, instr, 2);
 405       if (status != 0)
 406         break;
 407
 408       /* movm [regs], sp  */
 409       if (instr[0] == 0xcf)
 410         {
 411           gdb_byte save_mask;
 412
 413           save_mask = instr[1];
 414
 415           if ((save_mask & movm_exreg0_bit) && am33_mode)
 416             {
 417               push_reg (regs, &stack, E_E2_REGNUM);
 418               push_reg (regs, &stack, E_E3_REGNUM);
 419             }
 420           if ((save_mask & movm_exreg1_bit) && am33_mode)
 421             {
 422               push_reg (regs, &stack, E_E4_REGNUM);
 423               push_reg (regs, &stack, E_E5_REGNUM);
 424               push_reg (regs, &stack, E_E6_REGNUM);
 425               push_reg (regs, &stack, E_E7_REGNUM);
 426             }
 427           if ((save_mask & movm_exother_bit) && am33_mode)
 428             {
 429               push_reg (regs, &stack, E_E0_REGNUM);
 430               push_reg (regs, &stack, E_E1_REGNUM);
 431               push_reg (regs, &stack, E_MDRQ_REGNUM);
 432               push_reg (regs, &stack, E_MCRH_REGNUM);
 433               push_reg (regs, &stack, E_MCRL_REGNUM);
 434               push_reg (regs, &stack, E_MCVF_REGNUM);
 435             }
 436           if (save_mask & movm_d2_bit)
 437             push_reg (regs, &stack, E_D2_REGNUM);
 438           if (save_mask & movm_d3_bit)
 439             push_reg (regs, &stack, E_D3_REGNUM);
 440           if (save_mask & movm_a2_bit)
 441             push_reg (regs, &stack, E_A2_REGNUM);
 442           if (save_mask & movm_a3_bit)
 443             push_reg (regs, &stack, E_A3_REGNUM);
 444           if (save_mask & movm_other_bit)
 445             {
 446               push_reg (regs, &stack, E_D0_REGNUM);
 447               push_reg (regs, &stack, E_D1_REGNUM);
 448               push_reg (regs, &stack, E_A0_REGNUM);
 449               push_reg (regs, &stack, E_A1_REGNUM);
 450               push_reg (regs, &stack, E_MDR_REGNUM);
 451               push_reg (regs, &stack, E_LIR_REGNUM);
 452               push_reg (regs, &stack, E_LAR_REGNUM);
 453               /* The `other' bit leaves a blank area of four bytes at
 454                  the beginning of its block of saved registers, making
 455                  it 32 bytes long in total.  */
 456               regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], -4);
 457             }
 458
 459           pc += 2;
 460           after_last_frame_setup_insn = pc;
 461         }
 462       /* mov sp, aN */
 463       else if ((instr[0] & 0xfc) == 0x3c)
 464         {
 465           int aN = instr[0] & 0x03;
 466
 467           regs[E_A0_REGNUM + aN] = regs[E_SP_REGNUM];
 468
 469           pc += 1;
 470           if (aN == 3)
 471             after_last_frame_setup_insn = pc;
 472         }
 473       /* mov aM, aN */
 474       else if ((instr[0] & 0xf0) == 0x90
 475                && (instr[0] & 0x03) != ((instr[0] & 0x0c) >> 2))
 476         {
 477           int aN = instr[0] & 0x03;
 478           int aM = (instr[0] & 0x0c) >> 2;
 479
 480           regs[E_A0_REGNUM + aN] = regs[E_A0_REGNUM + aM];
 481
 482           pc += 1;
 483         }
 484       /* mov dM, dN */
 485       else if ((instr[0] & 0xf0) == 0x80
 486                && (instr[0] & 0x03) != ((instr[0] & 0x0c) >> 2))
 487         {
 488           int dN = instr[0] & 0x03;
 489           int dM = (instr[0] & 0x0c) >> 2;
 490
 491           regs[E_D0_REGNUM + dN] = regs[E_D0_REGNUM + dM];
 492
 493           pc += 1;
 494         }
 495       /* mov aM, dN */
 496       else if (instr[0] == 0xf1 && (instr[1] & 0xf0) == 0xd0)
 497         {
 498           int dN = instr[1] & 0x03;
 499           int aM = (instr[1] & 0x0c) >> 2;
 500
 501           regs[E_D0_REGNUM + dN] = regs[E_A0_REGNUM + aM];
 502
 503           pc += 2;
 504         }
 505       /* mov dM, aN */
 506       else if (instr[0] == 0xf1 && (instr[1] & 0xf0) == 0xe0)
 507         {
 508           int aN = instr[1] & 0x03;
 509           int dM = (instr[1] & 0x0c) >> 2;
 510
 511           regs[E_A0_REGNUM + aN] = regs[E_D0_REGNUM + dM];
 512
 513           pc += 2;
 514         }
 515       /* add imm8, SP */
 516       else if (instr[0] == 0xf8 && instr[1] == 0xfe)
 517         {
 518           gdb_byte buf[1];
 519           LONGEST imm8;
 520
 521
 522           status = target_read_memory (pc + 2, buf, 1);
 523           if (status != 0)
 524             break;
 525
 526           imm8 = extract_signed_integer (buf, 1, byte_order);
 527           regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], imm8);
 528
 529           pc += 3;
 530           /* Stack pointer adjustments are frame related.  */
 531           after_last_frame_setup_insn = pc;
 532         }
 533       /* add imm16, SP */
 534       else if (instr[0] == 0xfa && instr[1] == 0xfe)
 535         {
 536           gdb_byte buf[2];
 537           LONGEST imm16;
 538
 539           status = target_read_memory (pc + 2, buf, 2);
 540           if (status != 0)
 541             break;
 542
 543           imm16 = extract_signed_integer (buf, 2, byte_order);
 544           regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], imm16);
 545
 546           pc += 4;
 547           /* Stack pointer adjustments are frame related.  */
 548           after_last_frame_setup_insn = pc;
 549         }
 550       /* add imm32, SP */
 551       else if (instr[0] == 0xfc && instr[1] == 0xfe)
 552         {
 553           gdb_byte buf[4];
 554           LONGEST imm32;
 555
 556           status = target_read_memory (pc + 2, buf, 4);
 557           if (status != 0)
 558             break;
 559
 560
 561           imm32 = extract_signed_integer (buf, 4, byte_order);
 562           regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], imm32);
 563
 564           pc += 6;
 565           /* Stack pointer adjustments are frame related.  */
 566           after_last_frame_setup_insn = pc;
 567         }
 568       /* add imm8, aN  */
 569       else if ((instr[0] & 0xfc) == 0x20)
 570         {
 571           int aN;
 572           LONGEST imm8;
 573
 574           aN = instr[0] & 0x03;
 575           imm8 = extract_signed_integer (&instr[1], 1, byte_order);
 576
 577           regs[E_A0_REGNUM + aN] = pv_add_constant (regs[E_A0_REGNUM + aN],
 578                                                     imm8);
 579
 580           pc += 2;
 581         }
 582       /* add imm16, aN  */
 583       else if (instr[0] == 0xfa && (instr[1] & 0xfc) == 0xd0)
 584         {
 585           int aN;
 586           LONGEST imm16;
 587           gdb_byte buf[2];
 588
 589           aN = instr[1] & 0x03;
 590
 591           status = target_read_memory (pc + 2, buf, 2);
 592           if (status != 0)
 593             break;
 594
 595
 596           imm16 = extract_signed_integer (buf, 2, byte_order);
 597
 598           regs[E_A0_REGNUM + aN] = pv_add_constant (regs[E_A0_REGNUM + aN],
 599                                                     imm16);
 600
 601           pc += 4;
 602         }
 603       /* add imm32, aN  */
 604       else if (instr[0] == 0xfc && (instr[1] & 0xfc) == 0xd0)
 605         {
 606           int aN;
 607           LONGEST imm32;
 608           gdb_byte buf[4];
 609
 610           aN = instr[1] & 0x03;
 611
 612           status = target_read_memory (pc + 2, buf, 4);
 613           if (status != 0)
 614             break;
 615
 616           imm32 = extract_signed_integer (buf, 2, byte_order);
 617
 618           regs[E_A0_REGNUM + aN] = pv_add_constant (regs[E_A0_REGNUM + aN],
 619                                                     imm32);
 620           pc += 6;
 621         }
 622       /* fmov fsM, (rN) */
 623       else if (instr[0] == 0xf9 && (instr[1] & 0xfd) == 0x30)
 624         {
 625           int fsM, sM, Y, rN;
 626           gdb_byte buf[1];
 627
 628           Y = (instr[1] & 0x02) >> 1;
 629
 630           status = target_read_memory (pc + 2, buf, 1);
 631           if (status != 0)
 632             break;
 633
 634           sM = (buf[0] & 0xf0) >> 4;
 635           rN = buf[0] & 0x0f;
 636           fsM = (Y << 4) | sM;
 637
 638           stack.store (regs[translate_rreg (rN)], 4,
 639                        regs[E_FS0_REGNUM + fsM]);
 640
 641           pc += 3;
 642         }
 643       /* fmov fsM, (sp) */
 644       else if (instr[0] == 0xf9 && (instr[1] & 0xfd) == 0x34)
 645         {
 646           int fsM, sM, Y;
 647           gdb_byte buf[1];
 648
 649           Y = (instr[1] & 0x02) >> 1;
 650
 651           status = target_read_memory (pc + 2, buf, 1);
 652           if (status != 0)
 653             break;
 654
 655           sM = (buf[0] & 0xf0) >> 4;
 656           fsM = (Y << 4) | sM;
 657
 658           stack.store (regs[E_SP_REGNUM], 4,
 659                        regs[E_FS0_REGNUM + fsM]);
 660
 661           pc += 3;
 662         }
 663       /* fmov fsM, (rN, rI) */
 664       else if (instr[0] == 0xfb && instr[1] == 0x37)
 665         {
 666           int fsM, sM, Z, rN, rI;
 667           gdb_byte buf[2];
 668
 669
 670           status = target_read_memory (pc + 2, buf, 2);
 671           if (status != 0)
 672             break;
 673
 674           rI = (buf[0] & 0xf0) >> 4;
 675           rN = buf[0] & 0x0f;
 676           sM = (buf[1] & 0xf0) >> 4;
 677           Z = (buf[1] & 0x02) >> 1;
 678           fsM = (Z << 4) | sM;
 679
 680           stack.store (pv_add (regs[translate_rreg (rN)],
 681                                regs[translate_rreg (rI)]),
 682                        4, regs[E_FS0_REGNUM + fsM]);
 683
 684           pc += 4;
 685         }
 686       /* fmov fsM, (d8, rN) */
 687       else if (instr[0] == 0xfb && (instr[1] & 0xfd) == 0x30)
 688         {
 689           int fsM, sM, Y, rN;
 690           LONGEST d8;
 691           gdb_byte buf[2];
 692
 693           Y = (instr[1] & 0x02) >> 1;
 694
 695           status = target_read_memory (pc + 2, buf, 2);
 696           if (status != 0)
 697             break;
 698
 699           sM = (buf[0] & 0xf0) >> 4;
 700           rN = buf[0] & 0x0f;
 701           fsM = (Y << 4) | sM;
 702           d8 = extract_signed_integer (&buf[1], 1, byte_order);
 703
 704           stack.store (pv_add_constant (regs[translate_rreg (rN)], d8),
 705                        4, regs[E_FS0_REGNUM + fsM]);
 706
 707           pc += 4;
 708         }
 709       /* fmov fsM, (d24, rN) */
 710       else if (instr[0] == 0xfd && (instr[1] & 0xfd) == 0x30)
 711         {
 712           int fsM, sM, Y, rN;
 713           LONGEST d24;
 714           gdb_byte buf[4];
 715
 716           Y = (instr[1] & 0x02) >> 1;
 717
 718           status = target_read_memory (pc + 2, buf, 4);
 719           if (status != 0)
 720             break;
 721
 722           sM = (buf[0] & 0xf0) >> 4;
 723           rN = buf[0] & 0x0f;
 724           fsM = (Y << 4) | sM;
 725           d24 = extract_signed_integer (&buf[1], 3, byte_order);
 726
 727           stack.store (pv_add_constant (regs[translate_rreg (rN)], d24),
 728                        4, regs[E_FS0_REGNUM + fsM]);
 729
 730           pc += 6;
 731         }
 732       /* fmov fsM, (d32, rN) */
 733       else if (instr[0] == 0xfe && (instr[1] & 0xfd) == 0x30)
 734         {
 735           int fsM, sM, Y, rN;
 736           LONGEST d32;
 737           gdb_byte buf[5];
 738
 739           Y = (instr[1] & 0x02) >> 1;
 740
 741           status = target_read_memory (pc + 2, buf, 5);
 742           if (status != 0)
 743             break;
 744
 745           sM = (buf[0] & 0xf0) >> 4;
 746           rN = buf[0] & 0x0f;
 747           fsM = (Y << 4) | sM;
 748           d32 = extract_signed_integer (&buf[1], 4, byte_order);
 749
 750           stack.store (pv_add_constant (regs[translate_rreg (rN)], d32),
 751                        4, regs[E_FS0_REGNUM + fsM]);
 752
 753           pc += 7;
 754         }
 755       /* fmov fsM, (d8, SP) */
 756       else if (instr[0] == 0xfb && (instr[1] & 0xfd) == 0x34)
 757         {
 758           int fsM, sM, Y;
 759           LONGEST d8;
 760           gdb_byte buf[2];
 761
 762           Y = (instr[1] & 0x02) >> 1;
 763
 764           status = target_read_memory (pc + 2, buf, 2);
 765           if (status != 0)
 766             break;
 767
 768           sM = (buf[0] & 0xf0) >> 4;
 769           fsM = (Y << 4) | sM;
 770           d8 = extract_signed_integer (&buf[1], 1, byte_order);
 771
 772           stack.store (pv_add_constant (regs[E_SP_REGNUM], d8),
 773                        4, regs[E_FS0_REGNUM + fsM]);
 774
 775           pc += 4;
 776         }
 777       /* fmov fsM, (d24, SP) */
 778       else if (instr[0] == 0xfd && (instr[1] & 0xfd) == 0x34)
 779         {
 780           int fsM, sM, Y;
 781           LONGEST d24;
 782           gdb_byte buf[4];
 783
 784           Y = (instr[1] & 0x02) >> 1;
 785
 786           status = target_read_memory (pc + 2, buf, 4);
 787           if (status != 0)
 788             break;
 789
 790           sM = (buf[0] & 0xf0) >> 4;
 791           fsM = (Y << 4) | sM;
 792           d24 = extract_signed_integer (&buf[1], 3, byte_order);
 793
 794           stack.store (pv_add_constant (regs[E_SP_REGNUM], d24),
 795                        4, regs[E_FS0_REGNUM + fsM]);
 796
 797           pc += 6;
 798         }
 799       /* fmov fsM, (d32, SP) */
 800       else if (instr[0] == 0xfe && (instr[1] & 0xfd) == 0x34)
 801         {
 802           int fsM, sM, Y;
 803           LONGEST d32;
 804           gdb_byte buf[5];
 805
 806           Y = (instr[1] & 0x02) >> 1;
 807
 808           status = target_read_memory (pc + 2, buf, 5);
 809           if (status != 0)
 810             break;
 811
 812           sM = (buf[0] & 0xf0) >> 4;
 813           fsM = (Y << 4) | sM;
 814           d32 = extract_signed_integer (&buf[1], 4, byte_order);
 815
 816           stack.store (pv_add_constant (regs[E_SP_REGNUM], d32),
 817                        4, regs[E_FS0_REGNUM + fsM]);
 818
 819           pc += 7;
 820         }
 821       /* fmov fsM, (rN+) */
 822       else if (instr[0] == 0xf9 && (instr[1] & 0xfd) == 0x31)
 823         {
 824           int fsM, sM, Y, rN, rN_regnum;
 825           gdb_byte buf[1];
 826
 827           Y = (instr[1] & 0x02) >> 1;
 828
 829           status = target_read_memory (pc + 2, buf, 1);
 830           if (status != 0)
 831             break;
 832
 833           sM = (buf[0] & 0xf0) >> 4;
 834           rN = buf[0] & 0x0f;
 835           fsM = (Y << 4) | sM;
 836
 837           rN_regnum = translate_rreg (rN);
 838
 839           stack.store (regs[rN_regnum], 4,
 840                        regs[E_FS0_REGNUM + fsM]);
 841           regs[rN_regnum] = pv_add_constant (regs[rN_regnum], 4);
 842
 843           pc += 3;
 844         }
 845       /* fmov fsM, (rN+, imm8) */
 846       else if (instr[0] == 0xfb && (instr[1] & 0xfd) == 0x31)
 847         {
 848           int fsM, sM, Y, rN, rN_regnum;
 849           LONGEST imm8;
 850           gdb_byte buf[2];
 851
 852           Y = (instr[1] & 0x02) >> 1;
 853
 854           status = target_read_memory (pc + 2, buf, 2);
 855           if (status != 0)
 856             break;
 857
 858           sM = (buf[0] & 0xf0) >> 4;
 859           rN = buf[0] & 0x0f;
 860           fsM = (Y << 4) | sM;
 861           imm8 = extract_signed_integer (&buf[1], 1, byte_order);
 862
 863           rN_regnum = translate_rreg (rN);
 864
 865           stack.store (regs[rN_regnum], 4, regs[E_FS0_REGNUM + fsM]);
 866           regs[rN_regnum] = pv_add_constant (regs[rN_regnum], imm8);
 867
 868           pc += 4;
 869         }
 870       /* fmov fsM, (rN+, imm24) */
 871       else if (instr[0] == 0xfd && (instr[1] & 0xfd) == 0x31)
 872         {
 873           int fsM, sM, Y, rN, rN_regnum;
 874           LONGEST imm24;
 875           gdb_byte buf[4];
 876
 877           Y = (instr[1] & 0x02) >> 1;
 878
 879           status = target_read_memory (pc + 2, buf, 4);
 880           if (status != 0)
 881             break;
 882
 883           sM = (buf[0] & 0xf0) >> 4;
 884           rN = buf[0] & 0x0f;
 885           fsM = (Y << 4) | sM;
 886           imm24 = extract_signed_integer (&buf[1], 3, byte_order);
 887
 888           rN_regnum = translate_rreg (rN);
 889
 890           stack.store (regs[rN_regnum], 4, regs[E_FS0_REGNUM + fsM]);
 891           regs[rN_regnum] = pv_add_constant (regs[rN_regnum], imm24);
 892
 893           pc += 6;
 894         }
 895       /* fmov fsM, (rN+, imm32) */
 896       else if (instr[0] == 0xfe && (instr[1] & 0xfd) == 0x31)
 897         {
 898           int fsM, sM, Y, rN, rN_regnum;
 899           LONGEST imm32;
 900           gdb_byte buf[5];
 901
 902           Y = (instr[1] & 0x02) >> 1;
 903
 904           status = target_read_memory (pc + 2, buf, 5);
 905           if (status != 0)
 906             break;
 907
 908           sM = (buf[0] & 0xf0) >> 4;
 909           rN = buf[0] & 0x0f;
 910           fsM = (Y << 4) | sM;
 911           imm32 = extract_signed_integer (&buf[1], 4, byte_order);
 912
 913           rN_regnum = translate_rreg (rN);
 914
 915           stack.store (regs[rN_regnum], 4, regs[E_FS0_REGNUM + fsM]);
 916           regs[rN_regnum] = pv_add_constant (regs[rN_regnum], imm32);
 917
 918           pc += 7;
 919         }
 920       /* mov imm8, aN */
 921       else if ((instr[0] & 0xf0) == 0x90)
 922         {
 923           int aN = instr[0] & 0x03;
 924           LONGEST imm8;
 925
 926           imm8 = extract_signed_integer (&instr[1], 1, byte_order);
 927
 928           regs[E_A0_REGNUM + aN] = pv_constant (imm8);
 929           pc += 2;
 930         }
 931       /* mov imm16, aN */
 932       else if ((instr[0] & 0xfc) == 0x24)
 933         {
 934           int aN = instr[0] & 0x03;
 935           gdb_byte buf[2];
 936           LONGEST imm16;
 937
 938           status = target_read_memory (pc + 1, buf, 2);
 939           if (status != 0)
 940             break;
 941
 942           imm16 = extract_signed_integer (buf, 2, byte_order);
 943           regs[E_A0_REGNUM + aN] = pv_constant (imm16);
 944           pc += 3;
 945         }
 946       /* mov imm32, aN */
 947       else if (instr[0] == 0xfc && ((instr[1] & 0xfc) == 0xdc))
 948         {
 949           int aN = instr[1] & 0x03;
 950           gdb_byte buf[4];
 951           LONGEST imm32;
 952
 953           status = target_read_memory (pc + 2, buf, 4);
 954           if (status != 0)
 955             break;
 956
 957           imm32 = extract_signed_integer (buf, 4, byte_order);
 958           regs[E_A0_REGNUM + aN] = pv_constant (imm32);
 959           pc += 6;
 960         }
 961       /* mov imm8, dN */
 962       else if ((instr[0] & 0xf0) == 0x80)
 963         {
 964           int dN = instr[0] & 0x03;
 965           LONGEST imm8;
 966
 967           imm8 = extract_signed_integer (&instr[1], 1, byte_order);
 968
 969           regs[E_D0_REGNUM + dN] = pv_constant (imm8);
 970           pc += 2;
 971         }
 972       /* mov imm16, dN */
 973       else if ((instr[0] & 0xfc) == 0x2c)
 974         {
 975           int dN = instr[0] & 0x03;
 976           gdb_byte buf[2];
 977           LONGEST imm16;
 978
 979           status = target_read_memory (pc + 1, buf, 2);
 980           if (status != 0)
 981             break;
 982
 983           imm16 = extract_signed_integer (buf, 2, byte_order);
 984           regs[E_D0_REGNUM + dN] = pv_constant (imm16);
 985           pc += 3;
 986         }
 987       /* mov imm32, dN */
 988       else if (instr[0] == 0xfc && ((instr[1] & 0xfc) == 0xcc))
 989         {
 990           int dN = instr[1] & 0x03;
 991           gdb_byte buf[4];
 992           LONGEST imm32;
 993
 994           status = target_read_memory (pc + 2, buf, 4);
 995           if (status != 0)
 996             break;
 997
 998           imm32 = extract_signed_integer (buf, 4, byte_order);
 999           regs[E_D0_REGNUM + dN] = pv_constant (imm32);
1000           pc += 6;
1001         }
1002       else
1003         {
1004           /* We've hit some instruction that we don't recognize.  Hopefully,
1005              we have enough to do prologue analysis.  */
1006           break;
1007         }
1008     }
1009
1010   /* Is the frame size (offset, really) a known constant?  */
1011   if (pv_is_register (regs[E_SP_REGNUM], E_SP_REGNUM))
1012     result->frame_size = regs[E_SP_REGNUM].k;
1013
1014   /* Was the frame pointer initialized?  */
1015   if (pv_is_register (regs[E_A3_REGNUM], E_SP_REGNUM))
1016     {
1017       result->has_frame_ptr = 1;
1018       result->frame_ptr_offset = regs[E_A3_REGNUM].k;
1019     }
1020
1021   /* Record where all the registers were saved.  */
1022   stack.scan (check_for_saved, (void *) result);
1023
1024   result->prologue_end = after_last_frame_setup_insn;
1025 }
1026
1027 /* Function: skip_prologue
1028    Return the address of the first inst past the prologue of the function.  */
1029
1030 static CORE_ADDR
1031 mn10300_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1032 {
1033   const char *name;
1034   CORE_ADDR func_addr, func_end;
1035   struct mn10300_prologue p;
1036
1037   /* Try to find the extent of the function that contains PC.  */
1038   if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
1039     return pc;
1040
1041   mn10300_analyze_prologue (gdbarch, pc, func_end, &p);
1042   return p.prologue_end;
1043 }
1044
1045 /* Wrapper for mn10300_analyze_prologue: find the function start;
1046    use the current frame PC as the limit, then
1047    invoke mn10300_analyze_prologue and return its result.  */
1048 static struct mn10300_prologue *
1049 mn10300_analyze_frame_prologue (struct frame_info *this_frame,
1050                            void **this_prologue_cache)
1051 {
1052   if (!*this_prologue_cache)
1053     {
1054       CORE_ADDR func_start, stop_addr;
1055
1056       *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct mn10300_prologue);
1057
1058       func_start = get_frame_func (this_frame);
1059       stop_addr = get_frame_pc (this_frame);
1060
1061       /* If we couldn't find any function containing the PC, then
1062          just initialize the prologue cache, but don't do anything.  */
1063       if (!func_start)
1064         stop_addr = func_start;
1065
1066       mn10300_analyze_prologue (get_frame_arch (this_frame),
1067                                 func_start, stop_addr,
1068                                 ((struct mn10300_prologue *)
1069                                  *this_prologue_cache));
1070     }
1071
1072   return (struct mn10300_prologue *) *this_prologue_cache;
1073 }
1074
1075 /* Given the next frame and a prologue cache, return this frame's
1076    base.  */
1077 static CORE_ADDR
1078 mn10300_frame_base (struct frame_info *this_frame, void **this_prologue_cache)
1079 {
1080   struct mn10300_prologue *p
1081     = mn10300_analyze_frame_prologue (this_frame, this_prologue_cache);
1082
1083   /* In functions that use alloca, the distance between the stack
1084      pointer and the frame base varies dynamically, so we can't use
1085      the SP plus static information like prologue analysis to find the
1086      frame base.  However, such functions must have a frame pointer,
1087      to be able to restore the SP on exit.  So whenever we do have a
1088      frame pointer, use that to find the base.  */
1089   if (p->has_frame_ptr)
1090     {
1091       CORE_ADDR fp = get_frame_register_unsigned (this_frame, E_A3_REGNUM);
1092       return fp - p->frame_ptr_offset;
1093     }
1094   else
1095     {
1096       CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
1097       return sp - p->frame_size;
1098     }
1099 }
1100
1101 /* Here is a dummy implementation.  */
1102 static struct frame_id
1103 mn10300_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1104 {
1105   CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
1106   CORE_ADDR pc = get_frame_register_unsigned (this_frame, E_PC_REGNUM);
1107   return frame_id_build (sp, pc);
1108 }
1109
1110 static void
1111 mn10300_frame_this_id (struct frame_info *this_frame,
1112                        void **this_prologue_cache,
1113                        struct frame_id *this_id)
1114 {
1115   *this_id = frame_id_build (mn10300_frame_base (this_frame,
1116                                                  this_prologue_cache),
1117                              get_frame_func (this_frame));
1118
1119 }
1120
1121 static struct value *
1122 mn10300_frame_prev_register (struct frame_info *this_frame,
1123                              void **this_prologue_cache, int regnum)
1124 {
1125   struct mn10300_prologue *p
1126     = mn10300_analyze_frame_prologue (this_frame, this_prologue_cache);
1127   CORE_ADDR frame_base = mn10300_frame_base (this_frame, this_prologue_cache);
1128
1129   if (regnum == E_SP_REGNUM)
1130     return frame_unwind_got_constant (this_frame, regnum, frame_base);
1131
1132   /* If prologue analysis says we saved this register somewhere,
1133      return a description of the stack slot holding it.  */
1134   if (p->reg_offset[regnum] != 1)
1135     return frame_unwind_got_memory (this_frame, regnum,
1136                                     frame_base + p->reg_offset[regnum]);
1137
1138   /* Otherwise, presume we haven't changed the value of this
1139      register, and get it from the next frame.  */
1140   return frame_unwind_got_register (this_frame, regnum, regnum);
1141 }
1142
1143 static const struct frame_unwind mn10300_frame_unwind = {
1144   NORMAL_FRAME,
1145   default_frame_unwind_stop_reason,
1146   mn10300_frame_this_id,
1147   mn10300_frame_prev_register,
1148   NULL,
1149   default_frame_sniffer
1150 };
1151
1152 static CORE_ADDR
1153 mn10300_unwind_pc (struct gdbarch *gdbarch, struct frame_info *this_frame)
1154 {
1155   ULONGEST pc;
1156
1157   pc = frame_unwind_register_unsigned (this_frame, E_PC_REGNUM);
1158   return pc;
1159 }
1160
1161 static CORE_ADDR
1162 mn10300_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame)
1163 {
1164   ULONGEST sp;
1165
1166   sp = frame_unwind_register_unsigned (this_frame, E_SP_REGNUM);
1167   return sp;
1168 }
1169
1170 static void
1171 mn10300_frame_unwind_init (struct gdbarch *gdbarch)
1172 {
1173   dwarf2_append_unwinders (gdbarch);
1174   frame_unwind_append_unwinder (gdbarch, &mn10300_frame_unwind);
1175   set_gdbarch_dummy_id (gdbarch, mn10300_dummy_id);
1176   set_gdbarch_unwind_pc (gdbarch, mn10300_unwind_pc);
1177   set_gdbarch_unwind_sp (gdbarch, mn10300_unwind_sp);
1178 }
1179
1180 /* Function: push_dummy_call
1181  *
1182  * Set up machine state for a target call, including
1183  * function arguments, stack, return address, etc.
1184  *
1185  */
1186
1187 static CORE_ADDR
1188 mn10300_push_dummy_call (struct gdbarch *gdbarch,
1189                          struct value *target_func,
1190                          struct regcache *regcache,
1191                          CORE_ADDR bp_addr,
1192                          int nargs, struct value **args,
1193                          CORE_ADDR sp,
1194                          function_call_return_method return_method,
1195                          CORE_ADDR struct_addr)
1196 {
1197   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1198   const int push_size = register_size (gdbarch, E_PC_REGNUM);
1199   int regs_used;
1200   int len, arg_len;
1201   int stack_offset = 0;
1202   int argnum;
1203   const gdb_byte *val;
1204   gdb_byte valbuf[MN10300_MAX_REGISTER_SIZE];
1205
1206   /* This should be a nop, but align the stack just in case something
1207      went wrong.  Stacks are four byte aligned on the mn10300.  */
1208   sp &= ~3;
1209
1210   /* Now make space on the stack for the args.
1211
1212      XXX This doesn't appear to handle pass-by-invisible reference
1213      arguments.  */
1214   regs_used = (return_method == return_method_struct) ? 1 : 0;
1215   for (len = 0, argnum = 0; argnum < nargs; argnum++)
1216     {
1217       arg_len = (TYPE_LENGTH (value_type (args[argnum])) + 3) & ~3;
1218       while (regs_used < 2 && arg_len > 0)
1219         {
1220           regs_used++;
1221           arg_len -= push_size;
1222         }
1223       len += arg_len;
1224     }
1225
1226   /* Allocate stack space.  */
1227   sp -= len;
1228
1229   if (return_method == return_method_struct)
1230     {
1231       regs_used = 1;
1232       regcache_cooked_write_unsigned (regcache, E_D0_REGNUM, struct_addr);
1233     }
1234   else
1235     regs_used = 0;
1236
1237   /* Push all arguments onto the stack.  */
1238   for (argnum = 0; argnum < nargs; argnum++)
1239     {
1240       /* FIXME what about structs?  Unions?  */
1241       if (TYPE_CODE (value_type (*args)) == TYPE_CODE_STRUCT
1242           && TYPE_LENGTH (value_type (*args)) > 8)
1243         {
1244           /* Change to pointer-to-type.  */
1245           arg_len = push_size;
1246           gdb_assert (push_size <= MN10300_MAX_REGISTER_SIZE);
1247           store_unsigned_integer (valbuf, push_size, byte_order,
1248                                   value_address (*args));
1249           val = &valbuf[0];
1250         }
1251       else
1252         {
1253           arg_len = TYPE_LENGTH (value_type (*args));
1254           val = value_contents (*args);
1255         }
1256
1257       while (regs_used < 2 && arg_len > 0)
1258         {
1259           regcache_cooked_write_unsigned (regcache, regs_used,
1260                   extract_unsigned_integer (val, push_size, byte_order));
1261           val += push_size;
1262           arg_len -= push_size;
1263           regs_used++;
1264         }
1265
1266       while (arg_len > 0)
1267         {
1268           write_memory (sp + stack_offset, val, push_size);
1269           arg_len -= push_size;
1270           val += push_size;
1271           stack_offset += push_size;
1272         }
1273
1274       args++;
1275     }
1276
1277   /* Make space for the flushback area.  */
1278   sp -= 8;
1279
1280   /* Push the return address that contains the magic breakpoint.  */
1281   sp -= 4;
1282   write_memory_unsigned_integer (sp, push_size, byte_order, bp_addr);
1283
1284   /* The CPU also writes the return address always into the
1285      MDR register on "call".  */
1286   regcache_cooked_write_unsigned (regcache, E_MDR_REGNUM, bp_addr);
1287
1288   /* Update $sp.  */
1289   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
1290
1291   /* On the mn10300, it's possible to move some of the stack adjustment
1292      and saving of the caller-save registers out of the prologue and
1293      into the call sites.  (When using gcc, this optimization can
1294      occur when using the -mrelax switch.) If this occurs, the dwarf2
1295      info will reflect this fact.  We can test to see if this is the
1296      case by creating a new frame using the current stack pointer and
1297      the address of the function that we're about to call.  We then
1298      unwind SP and see if it's different than the SP of our newly
1299      created frame.  If the SP values are the same, the caller is not
1300      expected to allocate any additional stack.  On the other hand, if
1301      the SP values are different, the difference determines the
1302      additional stack that must be allocated.
1303
1304      Note that we don't update the return value though because that's
1305      the value of the stack just after pushing the arguments, but prior
1306      to performing the call.  This value is needed in order to
1307      construct the frame ID of the dummy call.  */
1308   {
1309     CORE_ADDR func_addr = find_function_addr (target_func, NULL);
1310     CORE_ADDR unwound_sp
1311       = mn10300_unwind_sp (gdbarch, create_new_frame (sp, func_addr));
1312     if (sp != unwound_sp)
1313       regcache_cooked_write_unsigned (regcache, E_SP_REGNUM,
1314                                       sp - (unwound_sp - sp));
1315   }
1316
1317   return sp;
1318 }
1319
1320 /* If DWARF2 is a register number appearing in Dwarf2 debug info, then
1321    mn10300_dwarf2_reg_to_regnum (DWARF2) is the corresponding GDB
1322    register number.  Why don't Dwarf2 and GDB use the same numbering?
1323    Who knows?  But since people have object files lying around with
1324    the existing Dwarf2 numbering, and other people have written stubs
1325    to work with the existing GDB, neither of them can change.  So we
1326    just have to cope.  */
1327 static int
1328 mn10300_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2)
1329 {
1330   /* This table is supposed to be shaped like the gdbarch_register_name
1331      initializer in gcc/config/mn10300/mn10300.h.  Registers which
1332      appear in GCC's numbering, but have no counterpart in GDB's
1333      world, are marked with a -1.  */
1334   static int dwarf2_to_gdb[] = {
1335     E_D0_REGNUM, E_D1_REGNUM, E_D2_REGNUM, E_D3_REGNUM,
1336     E_A0_REGNUM, E_A1_REGNUM, E_A2_REGNUM, E_A3_REGNUM,
1337     -1, E_SP_REGNUM,
1338
1339     E_E0_REGNUM, E_E1_REGNUM, E_E2_REGNUM, E_E3_REGNUM,
1340     E_E4_REGNUM, E_E5_REGNUM, E_E6_REGNUM, E_E7_REGNUM,
1341
1342     E_FS0_REGNUM + 0, E_FS0_REGNUM + 1, E_FS0_REGNUM + 2, E_FS0_REGNUM + 3,
1343     E_FS0_REGNUM + 4, E_FS0_REGNUM + 5, E_FS0_REGNUM + 6, E_FS0_REGNUM + 7,
1344
1345     E_FS0_REGNUM + 8, E_FS0_REGNUM + 9, E_FS0_REGNUM + 10, E_FS0_REGNUM + 11,
1346     E_FS0_REGNUM + 12, E_FS0_REGNUM + 13, E_FS0_REGNUM + 14, E_FS0_REGNUM + 15,
1347
1348     E_FS0_REGNUM + 16, E_FS0_REGNUM + 17, E_FS0_REGNUM + 18, E_FS0_REGNUM + 19,
1349     E_FS0_REGNUM + 20, E_FS0_REGNUM + 21, E_FS0_REGNUM + 22, E_FS0_REGNUM + 23,
1350
1351     E_FS0_REGNUM + 24, E_FS0_REGNUM + 25, E_FS0_REGNUM + 26, E_FS0_REGNUM + 27,
1352     E_FS0_REGNUM + 28, E_FS0_REGNUM + 29, E_FS0_REGNUM + 30, E_FS0_REGNUM + 31,
1353
1354     E_MDR_REGNUM, E_PSW_REGNUM, E_PC_REGNUM
1355   };
1356
1357   if (dwarf2 < 0
1358       || dwarf2 >= ARRAY_SIZE (dwarf2_to_gdb))
1359     return -1;
1360
1361   return dwarf2_to_gdb[dwarf2];
1362 }
1363
1364 static struct gdbarch *
1365 mn10300_gdbarch_init (struct gdbarch_info info,
1366                       struct gdbarch_list *arches)
1367 {
1368   struct gdbarch *gdbarch;
1369   struct gdbarch_tdep *tdep;
1370   int num_regs;
1371
1372   arches = gdbarch_list_lookup_by_info (arches, &info);
1373   if (arches != NULL)
1374     return arches->gdbarch;
1375
1376   tdep = XCNEW (struct gdbarch_tdep);
1377   gdbarch = gdbarch_alloc (&info, tdep);
1378
1379   switch (info.bfd_arch_info->mach)
1380     {
1381     case 0:
1382     case bfd_mach_mn10300:
1383       set_gdbarch_register_name (gdbarch, mn10300_generic_register_name);
1384       tdep->am33_mode = 0;
1385       num_regs = 32;
1386       break;
1387     case bfd_mach_am33:
1388       set_gdbarch_register_name (gdbarch, am33_register_name);
1389       tdep->am33_mode = 1;
1390       num_regs = 32;
1391       break;
1392     case bfd_mach_am33_2:
1393       set_gdbarch_register_name (gdbarch, am33_2_register_name);
1394       tdep->am33_mode = 2;
1395       num_regs = 64;
1396       set_gdbarch_fp0_regnum (gdbarch, 32);
1397       break;
1398     default:
1399       internal_error (__FILE__, __LINE__,
1400                       _("mn10300_gdbarch_init: Unknown mn10300 variant"));
1401       break;
1402     }
1403
1404   /* By default, chars are unsigned.  */
1405   set_gdbarch_char_signed (gdbarch, 0);
1406
1407   /* Registers.  */
1408   set_gdbarch_num_regs (gdbarch, num_regs);
1409   set_gdbarch_register_type (gdbarch, mn10300_register_type);
1410   set_gdbarch_skip_prologue (gdbarch, mn10300_skip_prologue);
1411   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
1412   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
1413   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, mn10300_dwarf2_reg_to_regnum);
1414
1415   /* Stack unwinding.  */
1416   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1417   /* Breakpoints.  */
1418   set_gdbarch_breakpoint_kind_from_pc (gdbarch,
1419                                        mn10300_breakpoint::kind_from_pc);
1420   set_gdbarch_sw_breakpoint_from_kind (gdbarch,
1421                                        mn10300_breakpoint::bp_from_kind);
1422   /* decr_pc_after_break?  */
1423
1424   /* Stage 2 */
1425   set_gdbarch_return_value (gdbarch, mn10300_return_value);
1426
1427   /* Stage 3 -- get target calls working.  */
1428   set_gdbarch_push_dummy_call (gdbarch, mn10300_push_dummy_call);
1429   /* set_gdbarch_return_value (store, extract) */
1430
1431
1432   mn10300_frame_unwind_init (gdbarch);
1433
1434   /* Hook in ABI-specific overrides, if they have been registered.  */
1435   gdbarch_init_osabi (info, gdbarch);
1436
1437   return gdbarch;
1438 }
1439
1440 /* Dump out the mn10300 specific architecture information.  */
1441
1442 static void
1443 mn10300_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
1444 {
1445   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1446   fprintf_unfiltered (file, "mn10300_dump_tdep: am33_mode = %d\n",
1447                       tdep->am33_mode);
1448 }
1449
1450 void
1451 _initialize_mn10300_tdep (void)
1452 {
1453   gdbarch_register (bfd_arch_mn10300, mn10300_gdbarch_init, mn10300_dump_tdep);
1454 }
1455