gdb/mn10300-tdep.c

   1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
   2
   3    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "arch-utils.h"
  25 #include "dis-asm.h"
  26 #include "gdbtypes.h"
  27 #include "regcache.h"
  28 #include "gdb_string.h"
  29 #include "gdb_assert.h"
  30 #include "gdbcore.h"    /* for write_memory_unsigned_integer */
  31 #include "value.h"
  32 #include "gdbtypes.h"
  33 #include "frame.h"
  34 #include "frame-unwind.h"
  35 #include "frame-base.h"
  36 #include "trad-frame.h"
  37 #include "symtab.h"
  38 #include "dwarf2-frame.h"
  39 #include "osabi.h"
  40
  41 #include "mn10300-tdep.h"
  42
  43 /* Forward decl.  */
  44 extern struct trad_frame_cache *mn10300_frame_unwind_cache (struct frame_info*,
  45                                                             void **);
  46
  47 /* Compute the alignment required by a type.  */
  48
  49 static int
  50 mn10300_type_align (struct type *type)
  51 {
  52   int i, align = 1;
  53
  54   switch (TYPE_CODE (type))
  55     {
  56     case TYPE_CODE_INT:
  57     case TYPE_CODE_ENUM:
  58     case TYPE_CODE_SET:
  59     case TYPE_CODE_RANGE:
  60     case TYPE_CODE_CHAR:
  61     case TYPE_CODE_BOOL:
  62     case TYPE_CODE_FLT:
  63     case TYPE_CODE_PTR:
  64     case TYPE_CODE_REF:
  65       return TYPE_LENGTH (type);
  66
  67     case TYPE_CODE_COMPLEX:
  68       return TYPE_LENGTH (type) / 2;
  69
  70     case TYPE_CODE_STRUCT:
  71     case TYPE_CODE_UNION:
  72       for (i = 0; i < TYPE_NFIELDS (type); i++)
  73         {
  74           int falign = mn10300_type_align (TYPE_FIELD_TYPE (type, i));
  75           while (align < falign)
  76             align <<= 1;
  77         }
  78       return align;
  79
  80     case TYPE_CODE_ARRAY:
  81       /* HACK!  Structures containing arrays, even small ones, are not
  82          elligible for returning in registers.  */
  83       return 256;
  84
  85     case TYPE_CODE_TYPEDEF:
  86       return mn10300_type_align (check_typedef (type));
  87
  88     default:
  89       internal_error (__FILE__, __LINE__, _("bad switch"));
  90     }
  91 }
  92
  93 /* Should call_function allocate stack space for a struct return?  */
  94 static int
  95 mn10300_use_struct_convention (struct type *type)
  96 {
  97   /* Structures bigger than a pair of words can't be returned in
  98      registers.  */
  99   if (TYPE_LENGTH (type) > 8)
 100     return 1;
 101
 102   switch (TYPE_CODE (type))
 103     {
 104     case TYPE_CODE_STRUCT:
 105     case TYPE_CODE_UNION:
 106       /* Structures with a single field are handled as the field
 107          itself.  */
 108       if (TYPE_NFIELDS (type) == 1)
 109         return mn10300_use_struct_convention (TYPE_FIELD_TYPE (type, 0));
 110
 111       /* Structures with word or double-word size are passed in memory, as
 112          long as they require at least word alignment.  */
 113       if (mn10300_type_align (type) >= 4)
 114         return 0;
 115
 116       return 1;
 117
 118       /* Arrays are addressable, so they're never returned in
 119          registers.  This condition can only hold when the array is
 120          the only field of a struct or union.  */
 121     case TYPE_CODE_ARRAY:
 122       return 1;
 123
 124     case TYPE_CODE_TYPEDEF:
 125       return mn10300_use_struct_convention (check_typedef (type));
 126
 127     default:
 128       return 0;
 129     }
 130 }
 131
 132 static void
 133 mn10300_store_return_value (struct gdbarch *gdbarch, struct type *type,
 134                             struct regcache *regcache, const void *valbuf)
 135 {
 136   int len = TYPE_LENGTH (type);
 137   int reg, regsz;
 138
 139   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 140     reg = 4;
 141   else
 142     reg = 0;
 143
 144   regsz = register_size (gdbarch, reg);
 145
 146   if (len <= regsz)
 147     regcache_raw_write_part (regcache, reg, 0, len, valbuf);
 148   else if (len <= 2 * regsz)
 149     {
 150       regcache_raw_write (regcache, reg, valbuf);
 151       gdb_assert (regsz == register_size (gdbarch, reg + 1));
 152       regcache_raw_write_part (regcache, reg+1, 0,
 153                                len - regsz, (char *) valbuf + regsz);
 154     }
 155   else
 156     internal_error (__FILE__, __LINE__,
 157                     _("Cannot store return value %d bytes long."), len);
 158 }
 159
 160 static void
 161 mn10300_extract_return_value (struct gdbarch *gdbarch, struct type *type,
 162                               struct regcache *regcache, void *valbuf)
 163 {
 164   char buf[MAX_REGISTER_SIZE];
 165   int len = TYPE_LENGTH (type);
 166   int reg, regsz;
 167
 168   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 169     reg = 4;
 170   else
 171     reg = 0;
 172
 173   regsz = register_size (gdbarch, reg);
 174   if (len <= regsz)
 175     {
 176       regcache_raw_read (regcache, reg, buf);
 177       memcpy (valbuf, buf, len);
 178     }
 179   else if (len <= 2 * regsz)
 180     {
 181       regcache_raw_read (regcache, reg, buf);
 182       memcpy (valbuf, buf, regsz);
 183       gdb_assert (regsz == register_size (gdbarch, reg + 1));
 184       regcache_raw_read (regcache, reg + 1, buf);
 185       memcpy ((char *) valbuf + regsz, buf, len - regsz);
 186     }
 187   else
 188     internal_error (__FILE__, __LINE__,
 189                     _("Cannot extract return value %d bytes long."), len);
 190 }
 191
 192 /* Determine, for architecture GDBARCH, how a return value of TYPE
 193    should be returned.  If it is supposed to be returned in registers,
 194    and READBUF is non-zero, read the appropriate value from REGCACHE,
 195    and copy it into READBUF.  If WRITEBUF is non-zero, write the value
 196    from WRITEBUF into REGCACHE.  */
 197
 198 static enum return_value_convention
 199 mn10300_return_value (struct gdbarch *gdbarch, struct type *type,
 200                       struct regcache *regcache, gdb_byte *readbuf,
 201                       const gdb_byte *writebuf)
 202 {
 203   if (mn10300_use_struct_convention (type))
 204     return RETURN_VALUE_STRUCT_CONVENTION;
 205
 206   if (readbuf)
 207     mn10300_extract_return_value (gdbarch, type, regcache, readbuf);
 208   if (writebuf)
 209     mn10300_store_return_value (gdbarch, type, regcache, writebuf);
 210
 211   return RETURN_VALUE_REGISTER_CONVENTION;
 212 }
 213
 214 static char *
 215 register_name (int reg, char **regs, long sizeof_regs)
 216 {
 217   if (reg < 0 || reg >= sizeof_regs / sizeof (regs[0]))
 218     return NULL;
 219   else
 220     return regs[reg];
 221 }
 222
 223 static const char *
 224 mn10300_generic_register_name (int reg)
 225 {
 226   static char *regs[] =
 227   { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
 228     "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
 229     "", "", "", "", "", "", "", "",
 230     "", "", "", "", "", "", "", "fp"
 231   };
 232   return register_name (reg, regs, sizeof regs);
 233 }
 234
 235
 236 static const char *
 237 am33_register_name (int reg)
 238 {
 239   static char *regs[] =
 240   { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
 241     "sp", "pc", "mdr", "psw", "lir", "lar", "",
 242     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 243     "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
 244   };
 245   return register_name (reg, regs, sizeof regs);
 246 }
 247
 248
 249 static struct type *
 250 mn10300_register_type (struct gdbarch *gdbarch, int reg)
 251 {
 252   return builtin_type_int;
 253 }
 254
 255 static CORE_ADDR
 256 mn10300_read_pc (ptid_t ptid)
 257 {
 258   return read_register_pid (E_PC_REGNUM, ptid);
 259 }
 260
 261 static void
 262 mn10300_write_pc (CORE_ADDR val, ptid_t ptid)
 263 {
 264   return write_register_pid (E_PC_REGNUM, val, ptid);
 265 }
 266
 267 /* The breakpoint instruction must be the same size as the smallest
 268    instruction in the instruction set.
 269
 270    The Matsushita mn10x00 processors have single byte instructions
 271    so we need a single byte breakpoint.  Matsushita hasn't defined
 272    one, so we defined it ourselves.  */
 273
 274 const static unsigned char *
 275 mn10300_breakpoint_from_pc (CORE_ADDR *bp_addr, int *bp_size)
 276 {
 277   static char breakpoint[] = {0xff};
 278   *bp_size = 1;
 279   return breakpoint;
 280 }
 281
 282 /*
 283  * Frame Extra Info:
 284  *
 285  *   status -- actually frame type (SP, FP, or last frame)
 286  *   stack size -- offset to the next frame
 287  *
 288  * The former might ultimately be stored in the frame_base.
 289  * Seems like there'd be a way to store the later too.
 290  *
 291  * Temporarily supply empty stub functions as place holders.
 292  */
 293
 294 static void
 295 my_frame_is_in_sp (struct frame_info *fi, void **this_cache)
 296 {
 297   struct trad_frame_cache *cache = mn10300_frame_unwind_cache (fi, this_cache);
 298   trad_frame_set_this_base (cache,
 299                             frame_unwind_register_unsigned (fi,
 300                                                             E_SP_REGNUM));
 301 }
 302
 303 static void
 304 my_frame_is_in_fp (struct frame_info *fi, void **this_cache)
 305 {
 306   struct trad_frame_cache *cache = mn10300_frame_unwind_cache (fi, this_cache);
 307   trad_frame_set_this_base (cache,
 308                             frame_unwind_register_unsigned (fi,
 309                                                             E_A3_REGNUM));
 310 }
 311
 312 static void
 313 my_frame_is_last (struct frame_info *fi)
 314 {
 315 }
 316
 317 static void
 318 set_my_stack_size (struct frame_info *fi, CORE_ADDR size)
 319 {
 320 }
 321
 322
 323 /* Set offsets of registers saved by movm instruction.
 324    This is a helper function for mn10300_analyze_prologue.  */
 325
 326 static void
 327 set_movm_offsets (struct frame_info *fi,
 328                   void **this_cache,
 329                   int movm_args)
 330 {
 331   struct trad_frame_cache *cache;
 332   int offset = 0;
 333   CORE_ADDR base;
 334
 335   if (fi == NULL || this_cache == NULL)
 336     return;
 337
 338   cache = mn10300_frame_unwind_cache (fi, this_cache);
 339   if (cache == NULL)
 340     return;
 341
 342   base = trad_frame_get_this_base (cache);
 343   if (movm_args & movm_other_bit)
 344     {
 345       /* The `other' bit leaves a blank area of four bytes at the
 346          beginning of its block of saved registers, making it 32 bytes
 347          long in total.  */
 348       trad_frame_set_reg_addr (cache, E_LAR_REGNUM,    base + offset + 4);
 349       trad_frame_set_reg_addr (cache, E_LIR_REGNUM,    base + offset + 8);
 350       trad_frame_set_reg_addr (cache, E_MDR_REGNUM,    base + offset + 12);
 351       trad_frame_set_reg_addr (cache, E_A0_REGNUM + 1, base + offset + 16);
 352       trad_frame_set_reg_addr (cache, E_A0_REGNUM,     base + offset + 20);
 353       trad_frame_set_reg_addr (cache, E_D0_REGNUM + 1, base + offset + 24);
 354       trad_frame_set_reg_addr (cache, E_D0_REGNUM,     base + offset + 28);
 355       offset += 32;
 356     }
 357
 358   if (movm_args & movm_a3_bit)
 359     {
 360       trad_frame_set_reg_addr (cache, E_A3_REGNUM, base + offset);
 361       offset += 4;
 362     }
 363   if (movm_args & movm_a2_bit)
 364     {
 365       trad_frame_set_reg_addr (cache, E_A2_REGNUM, base + offset);
 366       offset += 4;
 367     }
 368   if (movm_args & movm_d3_bit)
 369     {
 370       trad_frame_set_reg_addr (cache, E_D3_REGNUM, base + offset);
 371       offset += 4;
 372     }
 373   if (movm_args & movm_d2_bit)
 374     {
 375       trad_frame_set_reg_addr (cache, E_D2_REGNUM, base + offset);
 376       offset += 4;
 377     }
 378   if (AM33_MODE)
 379     {
 380       if (movm_args & movm_exother_bit)
 381         {
 382           trad_frame_set_reg_addr (cache, E_MCVF_REGNUM, base + offset);
 383           trad_frame_set_reg_addr (cache, E_MCRL_REGNUM, base + offset + 4);
 384           trad_frame_set_reg_addr (cache, E_MCRH_REGNUM, base + offset + 8);
 385           trad_frame_set_reg_addr (cache, E_MDRQ_REGNUM, base + offset + 12);
 386           trad_frame_set_reg_addr (cache, E_E1_REGNUM,   base + offset + 16);
 387           trad_frame_set_reg_addr (cache, E_E0_REGNUM,   base + offset + 20);
 388           offset += 24;
 389         }
 390       if (movm_args & movm_exreg1_bit)
 391         {
 392           trad_frame_set_reg_addr (cache, E_E7_REGNUM, base + offset);
 393           trad_frame_set_reg_addr (cache, E_E6_REGNUM, base + offset + 4);
 394           trad_frame_set_reg_addr (cache, E_E5_REGNUM, base + offset + 8);
 395           trad_frame_set_reg_addr (cache, E_E4_REGNUM, base + offset + 12);
 396           offset += 16;
 397         }
 398       if (movm_args & movm_exreg0_bit)
 399         {
 400           trad_frame_set_reg_addr (cache, E_E3_REGNUM, base + offset);
 401           trad_frame_set_reg_addr (cache, E_E2_REGNUM, base + offset + 4);
 402           offset += 8;
 403         }
 404     }
 405   /* The last (or first) thing on the stack will be the PC.  */
 406   trad_frame_set_reg_addr (cache, E_PC_REGNUM, base + offset);
 407   /* Save the SP in the 'traditional' way.
 408      This will be the same location where the PC is saved.  */
 409   trad_frame_set_reg_value (cache, E_SP_REGNUM, base + offset);
 410 }
 411
 412 /* The main purpose of this file is dealing with prologues to extract
 413    information about stack frames and saved registers.
 414
 415    In gcc/config/mn13000/mn10300.c, the expand_prologue prologue
 416    function is pretty readable, and has a nice explanation of how the
 417    prologue is generated.  The prologues generated by that code will
 418    have the following form (NOTE: the current code doesn't handle all
 419    this!):
 420
 421    + If this is an old-style varargs function, then its arguments
 422      need to be flushed back to the stack:
 423
 424         mov d0,(4,sp)
 425         mov d1,(4,sp)
 426
 427    + If we use any of the callee-saved registers, save them now.
 428
 429         movm [some callee-saved registers],(sp)
 430
 431    + If we have any floating-point registers to save:
 432
 433      - Decrement the stack pointer to reserve space for the registers.
 434        If the function doesn't need a frame pointer, we may combine
 435        this with the adjustment that reserves space for the frame.
 436
 437         add -SIZE, sp
 438
 439      - Save the floating-point registers.  We have two possible
 440        strategies:
 441
 442        . Save them at fixed offset from the SP:
 443
 444         fmov fsN,(OFFSETN,sp)
 445         fmov fsM,(OFFSETM,sp)
 446         ...
 447
 448        Note that, if OFFSETN happens to be zero, you'll get the
 449        different opcode: fmov fsN,(sp)
 450
 451        . Or, set a0 to the start of the save area, and then use
 452        post-increment addressing to save the FP registers.
 453
 454         mov sp, a0
 455         add SIZE, a0
 456         fmov fsN,(a0+)
 457         fmov fsM,(a0+)
 458         ...
 459
 460    + If the function needs a frame pointer, we set it here.
 461
 462         mov sp, a3
 463
 464    + Now we reserve space for the stack frame proper.  This could be
 465      merged into the `add -SIZE, sp' instruction for FP saves up
 466      above, unless we needed to set the frame pointer in the previous
 467      step, or the frame is so large that allocating the whole thing at
 468      once would put the FP register save slots out of reach of the
 469      addressing mode (128 bytes).
 470
 471         add -SIZE, sp
 472
 473    One day we might keep the stack pointer constant, that won't
 474    change the code for prologues, but it will make the frame
 475    pointerless case much more common.  */
 476
 477 /* Analyze the prologue to determine where registers are saved,
 478    the end of the prologue, etc etc.  Return the end of the prologue
 479    scanned.
 480
 481    We store into FI (if non-null) several tidbits of information:
 482
 483    * stack_size -- size of this stack frame.  Note that if we stop in
 484    certain parts of the prologue/epilogue we may claim the size of the
 485    current frame is zero.  This happens when the current frame has
 486    not been allocated yet or has already been deallocated.
 487
 488    * fsr -- Addresses of registers saved in the stack by this frame.
 489
 490    * status -- A (relatively) generic status indicator.  It's a bitmask
 491    with the following bits:
 492
 493    MY_FRAME_IN_SP: The base of the current frame is actually in
 494    the stack pointer.  This can happen for frame pointerless
 495    functions, or cases where we're stopped in the prologue/epilogue
 496    itself.  For these cases mn10300_analyze_prologue will need up
 497    update fi->frame before returning or analyzing the register
 498    save instructions.
 499
 500    MY_FRAME_IN_FP: The base of the current frame is in the
 501    frame pointer register ($a3).
 502
 503    NO_MORE_FRAMES: Set this if the current frame is "start" or
 504    if the first instruction looks like mov <imm>,sp.  This tells
 505    frame chain to not bother trying to unwind past this frame.  */
 506
 507 static CORE_ADDR
 508 mn10300_analyze_prologue (struct frame_info *fi,
 509                           void **this_cache,
 510                           CORE_ADDR pc)
 511 {
 512   CORE_ADDR func_addr, func_end, addr, stop;
 513   long      stack_size;
 514   int imm_size;
 515   unsigned char buf[4];
 516   int status, movm_args = 0;
 517   char *name;
 518
 519   /* Use the PC in the frame if it's provided to look up the
 520      start of this function.
 521
 522      Note: kevinb/2003-07-16: We used to do the following here:
 523         pc = (fi ? get_frame_pc (fi) : pc);
 524      But this is (now) badly broken when called from analyze_dummy_frame().
 525   */
 526   if (fi)
 527     {
 528       pc = (pc ? pc : get_frame_pc (fi));
 529       /* At the start of a function our frame is in the stack pointer.  */
 530       my_frame_is_in_sp (fi, this_cache);
 531     }
 532
 533   /* Find the start of this function.  */
 534   status = find_pc_partial_function (pc, &name, &func_addr, &func_end);
 535
 536   /* Do nothing if we couldn't find the start of this function
 537
 538      MVS: comment went on to say "or if we're stopped at the first
 539      instruction in the prologue" -- but code doesn't reflect that,
 540      and I don't want to do that anyway.  */
 541   if (status == 0)
 542     {
 543       return pc;
 544     }
 545
 546   /* If we're in start, then give up.  */
 547   if (strcmp (name, "start") == 0)
 548     {
 549       if (fi != NULL)
 550         my_frame_is_last (fi);
 551       return pc;
 552     }
 553
 554 #if 0
 555   /* Get the next two bytes into buf, we need two because rets is a two
 556      byte insn and the first isn't enough to uniquely identify it.  */
 557   status = deprecated_read_memory_nobpt (pc, buf, 2);
 558   if (status != 0)
 559     return pc;
 560
 561   /* Note: kevinb/2003-07-16: We shouldn't be making these sorts of
 562      changes to the frame in prologue examination code.  */
 563   /* If we're physically on an "rets" instruction, then our frame has
 564      already been deallocated.  Note this can also be true for retf
 565      and ret if they specify a size of zero.
 566
 567      In this case fi->frame is bogus, we need to fix it.  */
 568   if (fi && buf[0] == 0xf0 && buf[1] == 0xfc)
 569     {
 570       if (get_next_frame (fi) == NULL)
 571         deprecated_update_frame_base_hack (fi, read_sp ());
 572       return get_frame_pc (fi);
 573     }
 574
 575   /* Similarly if we're stopped on the first insn of a prologue as our
 576      frame hasn't been allocated yet.  */
 577   if (fi && get_frame_pc (fi) == func_addr)
 578     {
 579       if (get_next_frame (fi) == NULL)
 580         deprecated_update_frame_base_hack (fi, read_sp ());
 581       return get_frame_pc (fi);
 582     }
 583 #endif
 584
 585   /* NOTE: from here on, we don't want to return without jumping to
 586      finish_prologue.  */
 587
 588
 589   /* Figure out where to stop scanning.  */
 590   stop = fi ? pc : func_end;
 591
 592   /* Don't walk off the end of the function.  */
 593   stop = stop > func_end ? func_end : stop;
 594
 595   /* Start scanning on the first instruction of this function.  */
 596   addr = func_addr;
 597
 598   /* Suck in two bytes.  */
 599   if (addr + 2 >= stop
 600       || (status = deprecated_read_memory_nobpt (addr, buf, 2)) != 0)
 601     goto finish_prologue;
 602
 603   /* First see if this insn sets the stack pointer from a register; if
 604      so, it's probably the initialization of the stack pointer in _start,
 605      so mark this as the bottom-most frame.  */
 606   if (buf[0] == 0xf2 && (buf[1] & 0xf3) == 0xf0)
 607     {
 608       if (fi)
 609         my_frame_is_last (fi);
 610       goto finish_prologue;
 611     }
 612
 613   /* Now look for movm [regs],sp, which saves the callee saved registers.
 614
 615      At this time we don't know if fi->frame is valid, so we only note
 616      that we encountered a movm instruction.  Later, we'll set the entries
 617      in fsr.regs as needed.  */
 618   if (buf[0] == 0xcf)
 619     {
 620       /* Extract the register list for the movm instruction.  */
 621       movm_args = buf[1];
 622
 623       addr += 2;
 624
 625       /* Quit now if we're beyond the stop point.  */
 626       if (addr >= stop)
 627         goto finish_prologue;
 628
 629       /* Get the next two bytes so the prologue scan can continue.  */
 630       status = deprecated_read_memory_nobpt (addr, buf, 2);
 631       if (status != 0)
 632         goto finish_prologue;
 633     }
 634
 635   /* Now see if we set up a frame pointer via "mov sp,a3" */
 636   if (buf[0] == 0x3f)
 637     {
 638       addr += 1;
 639
 640       /* The frame pointer is now valid.  */
 641       if (fi)
 642         {
 643           my_frame_is_in_fp (fi, this_cache);
 644         }
 645
 646       /* Quit now if we're beyond the stop point.  */
 647       if (addr >= stop)
 648         goto finish_prologue;
 649
 650       /* Get two more bytes so scanning can continue.  */
 651       status = deprecated_read_memory_nobpt (addr, buf, 2);
 652       if (status != 0)
 653         goto finish_prologue;
 654     }
 655
 656   /* Next we should allocate the local frame.  No more prologue insns
 657      are found after allocating the local frame.
 658
 659      Search for add imm8,sp (0xf8feXX)
 660      or add imm16,sp (0xfafeXXXX)
 661      or add imm32,sp (0xfcfeXXXXXXXX).
 662
 663      If none of the above was found, then this prologue has no
 664      additional stack.  */
 665
 666   imm_size = 0;
 667   if (buf[0] == 0xf8 && buf[1] == 0xfe)
 668     imm_size = 1;
 669   else if (buf[0] == 0xfa && buf[1] == 0xfe)
 670     imm_size = 2;
 671   else if (buf[0] == 0xfc && buf[1] == 0xfe)
 672     imm_size = 4;
 673
 674   if (imm_size != 0)
 675     {
 676       /* Suck in imm_size more bytes, they'll hold the size of the
 677          current frame.  */
 678       status = deprecated_read_memory_nobpt (addr + 2, buf, imm_size);
 679       if (status != 0)
 680         goto finish_prologue;
 681
 682       /* Note the size of the stack in the frame info structure.  */
 683       stack_size = extract_signed_integer (buf, imm_size);
 684       if (fi)
 685         set_my_stack_size (fi, stack_size);
 686
 687       /* We just consumed 2 + imm_size bytes.  */
 688       addr += 2 + imm_size;
 689
 690       /* No more prologue insns follow, so begin preparation to return.  */
 691       goto finish_prologue;
 692     }
 693   /* Do the essentials and get out of here.  */
 694  finish_prologue:
 695   /* Note if/where callee saved registers were saved.  */
 696   if (fi)
 697     set_movm_offsets (fi, this_cache, movm_args);
 698   return addr;
 699 }
 700
 701 /* Function: skip_prologue
 702    Return the address of the first inst past the prologue of the function.  */
 703
 704 static CORE_ADDR
 705 mn10300_skip_prologue (CORE_ADDR pc)
 706 {
 707   return mn10300_analyze_prologue (NULL, NULL, pc);
 708 }
 709
 710 /* Simple frame_unwind_cache.
 711    This finds the "extra info" for the frame.  */
 712 struct trad_frame_cache *
 713 mn10300_frame_unwind_cache (struct frame_info *next_frame,
 714                             void **this_prologue_cache)
 715 {
 716   struct trad_frame_cache *cache;
 717   CORE_ADDR pc, start, end;
 718
 719   if (*this_prologue_cache)
 720     return (*this_prologue_cache);
 721
 722   cache = trad_frame_cache_zalloc (next_frame);
 723   pc = gdbarch_unwind_pc (current_gdbarch, next_frame);
 724   mn10300_analyze_prologue (next_frame, (void **) &cache, pc);
 725   if (find_pc_partial_function (pc, NULL, &start, &end))
 726     trad_frame_set_id (cache,
 727                        frame_id_build (trad_frame_get_this_base (cache),
 728                                        start));
 729   else
 730     trad_frame_set_id (cache,
 731                        frame_id_build (trad_frame_get_this_base (cache),
 732                                        frame_func_unwind (next_frame)));
 733
 734   (*this_prologue_cache) = cache;
 735   return cache;
 736 }
 737
 738 /* Here is a dummy implementation.  */
 739 static struct frame_id
 740 mn10300_unwind_dummy_id (struct gdbarch *gdbarch,
 741                          struct frame_info *next_frame)
 742 {
 743   return frame_id_build (frame_sp_unwind (next_frame),
 744                          frame_pc_unwind (next_frame));
 745 }
 746
 747 /* Trad frame implementation.  */
 748 static void
 749 mn10300_frame_this_id (struct frame_info *next_frame,
 750                        void **this_prologue_cache,
 751                        struct frame_id *this_id)
 752 {
 753   struct trad_frame_cache *cache =
 754     mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
 755
 756   trad_frame_get_id (cache, this_id);
 757 }
 758
 759 static void
 760 mn10300_frame_prev_register (struct frame_info *next_frame,
 761                              void **this_prologue_cache,
 762                              int regnum, int *optimizedp,
 763                              enum lval_type *lvalp, CORE_ADDR *addrp,
 764                              int *realnump, gdb_byte *bufferp)
 765 {
 766   struct trad_frame_cache *cache =
 767     mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
 768
 769   trad_frame_get_register (cache, next_frame, regnum, optimizedp,
 770                            lvalp, addrp, realnump, bufferp);
 771   /* Or...
 772   trad_frame_get_prev_register (next_frame, cache->prev_regs, regnum,
 773                            optimizedp, lvalp, addrp, realnump, bufferp);
 774   */
 775 }
 776
 777 static const struct frame_unwind mn10300_frame_unwind = {
 778   NORMAL_FRAME,
 779   mn10300_frame_this_id,
 780   mn10300_frame_prev_register
 781 };
 782
 783 static CORE_ADDR
 784 mn10300_frame_base_address (struct frame_info *next_frame,
 785                             void **this_prologue_cache)
 786 {
 787   struct trad_frame_cache *cache =
 788     mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
 789
 790   return trad_frame_get_this_base (cache);
 791 }
 792
 793 static const struct frame_unwind *
 794 mn10300_frame_sniffer (struct frame_info *next_frame)
 795 {
 796   return &mn10300_frame_unwind;
 797 }
 798
 799 static const struct frame_base mn10300_frame_base = {
 800   &mn10300_frame_unwind,
 801   mn10300_frame_base_address,
 802   mn10300_frame_base_address,
 803   mn10300_frame_base_address
 804 };
 805
 806 static CORE_ADDR
 807 mn10300_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 808 {
 809   ULONGEST pc;
 810
 811   frame_unwind_unsigned_register (next_frame, E_PC_REGNUM, &pc);
 812   return pc;
 813 }
 814
 815 static CORE_ADDR
 816 mn10300_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 817 {
 818   ULONGEST sp;
 819
 820   frame_unwind_unsigned_register (next_frame, E_SP_REGNUM, &sp);
 821   return sp;
 822 }
 823
 824 static void
 825 mn10300_frame_unwind_init (struct gdbarch *gdbarch)
 826 {
 827   frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
 828   frame_unwind_append_sniffer (gdbarch, mn10300_frame_sniffer);
 829   frame_base_set_default (gdbarch, &mn10300_frame_base);
 830   set_gdbarch_unwind_dummy_id (gdbarch, mn10300_unwind_dummy_id);
 831   set_gdbarch_unwind_pc (gdbarch, mn10300_unwind_pc);
 832   set_gdbarch_unwind_sp (gdbarch, mn10300_unwind_sp);
 833 }
 834
 835 /* Function: push_dummy_call
 836  *
 837  * Set up machine state for a target call, including
 838  * function arguments, stack, return address, etc.
 839  *
 840  */
 841
 842 static CORE_ADDR
 843 mn10300_push_dummy_call (struct gdbarch *gdbarch,
 844                          struct value *target_func,
 845                          struct regcache *regcache,
 846                          CORE_ADDR bp_addr,
 847                          int nargs, struct value **args,
 848                          CORE_ADDR sp,
 849                          int struct_return,
 850                          CORE_ADDR struct_addr)
 851 {
 852   const int push_size = register_size (gdbarch, E_PC_REGNUM);
 853   int regs_used;
 854   int len, arg_len;
 855   int stack_offset = 0;
 856   int argnum;
 857   char *val, valbuf[MAX_REGISTER_SIZE];
 858
 859   /* This should be a nop, but align the stack just in case something
 860      went wrong.  Stacks are four byte aligned on the mn10300.  */
 861   sp &= ~3;
 862
 863   /* Now make space on the stack for the args.
 864
 865      XXX This doesn't appear to handle pass-by-invisible reference
 866      arguments.  */
 867   regs_used = struct_return ? 1 : 0;
 868   for (len = 0, argnum = 0; argnum < nargs; argnum++)
 869     {
 870       arg_len = (TYPE_LENGTH (value_type (args[argnum])) + 3) & ~3;
 871       while (regs_used < 2 && arg_len > 0)
 872         {
 873           regs_used++;
 874           arg_len -= push_size;
 875         }
 876       len += arg_len;
 877     }
 878
 879   /* Allocate stack space.  */
 880   sp -= len;
 881
 882   if (struct_return)
 883     {
 884       regs_used = 1;
 885       write_register (E_D0_REGNUM, struct_addr);
 886     }
 887   else
 888     regs_used = 0;
 889
 890   /* Push all arguments onto the stack. */
 891   for (argnum = 0; argnum < nargs; argnum++)
 892     {
 893       /* FIXME what about structs?  Unions?  */
 894       if (TYPE_CODE (value_type (*args)) == TYPE_CODE_STRUCT
 895           && TYPE_LENGTH (value_type (*args)) > 8)
 896         {
 897           /* Change to pointer-to-type.  */
 898           arg_len = push_size;
 899           store_unsigned_integer (valbuf, push_size,
 900                                   VALUE_ADDRESS (*args));
 901           val = &valbuf[0];
 902         }
 903       else
 904         {
 905           arg_len = TYPE_LENGTH (value_type (*args));
 906           val = (char *) value_contents (*args);
 907         }
 908
 909       while (regs_used < 2 && arg_len > 0)
 910         {
 911           write_register (regs_used,
 912                           extract_unsigned_integer (val, push_size));
 913           val += push_size;
 914           arg_len -= push_size;
 915           regs_used++;
 916         }
 917
 918       while (arg_len > 0)
 919         {
 920           write_memory (sp + stack_offset, val, push_size);
 921           arg_len -= push_size;
 922           val += push_size;
 923           stack_offset += push_size;
 924         }
 925
 926       args++;
 927     }
 928
 929   /* Make space for the flushback area.  */
 930   sp -= 8;
 931
 932   /* Push the return address that contains the magic breakpoint.  */
 933   sp -= 4;
 934   write_memory_unsigned_integer (sp, push_size, bp_addr);
 935   /* Update $sp.  */
 936   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
 937   return sp;
 938 }
 939
 940 /* If DWARF2 is a register number appearing in Dwarf2 debug info, then
 941    mn10300_dwarf2_reg_to_regnum (DWARF2) is the corresponding GDB
 942    register number.  Why don't Dwarf2 and GDB use the same numbering?
 943    Who knows?  But since people have object files lying around with
 944    the existing Dwarf2 numbering, and other people have written stubs
 945    to work with the existing GDB, neither of them can change.  So we
 946    just have to cope.  */
 947 static int
 948 mn10300_dwarf2_reg_to_regnum (int dwarf2)
 949 {
 950   /* This table is supposed to be shaped like the REGISTER_NAMES
 951      initializer in gcc/config/mn10300/mn10300.h.  Registers which
 952      appear in GCC's numbering, but have no counterpart in GDB's
 953      world, are marked with a -1.  */
 954   static int dwarf2_to_gdb[] = {
 955     0,  1,  2,  3,  4,  5,  6,  7, -1, 8,
 956     15, 16, 17, 18, 19, 20, 21, 22,
 957     32, 33, 34, 35, 36, 37, 38, 39,
 958     40, 41, 42, 43, 44, 45, 46, 47,
 959     48, 49, 50, 51, 52, 53, 54, 55,
 960     56, 57, 58, 59, 60, 61, 62, 63
 961   };
 962
 963   if (dwarf2 < 0
 964       || dwarf2 >= (sizeof (dwarf2_to_gdb) / sizeof (dwarf2_to_gdb[0]))
 965       || dwarf2_to_gdb[dwarf2] == -1)
 966     internal_error (__FILE__, __LINE__,
 967                     "bogus register number in debug info: %d", dwarf2);
 968
 969   return dwarf2_to_gdb[dwarf2];
 970 }
 971
 972 static struct gdbarch *
 973 mn10300_gdbarch_init (struct gdbarch_info info,
 974                       struct gdbarch_list *arches)
 975 {
 976   struct gdbarch *gdbarch;
 977   struct gdbarch_tdep *tdep;
 978
 979   arches = gdbarch_list_lookup_by_info (arches, &info);
 980   if (arches != NULL)
 981     return arches->gdbarch;
 982
 983   tdep = xmalloc (sizeof (struct gdbarch_tdep));
 984   gdbarch = gdbarch_alloc (&info, tdep);
 985
 986   switch (info.bfd_arch_info->mach)
 987     {
 988     case 0:
 989     case bfd_mach_mn10300:
 990       set_gdbarch_register_name (gdbarch, mn10300_generic_register_name);
 991       tdep->am33_mode = 0;
 992       break;
 993     case bfd_mach_am33:
 994       set_gdbarch_register_name (gdbarch, am33_register_name);
 995       tdep->am33_mode = 1;
 996       break;
 997     default:
 998       internal_error (__FILE__, __LINE__,
 999                       _("mn10300_gdbarch_init: Unknown mn10300 variant"));
1000       break;
1001     }
1002
1003   /* Registers.  */
1004   set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
1005   set_gdbarch_register_type (gdbarch, mn10300_register_type);
1006   set_gdbarch_skip_prologue (gdbarch, mn10300_skip_prologue);
1007   set_gdbarch_read_pc (gdbarch, mn10300_read_pc);
1008   set_gdbarch_write_pc (gdbarch, mn10300_write_pc);
1009   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
1010   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
1011   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, mn10300_dwarf2_reg_to_regnum);
1012
1013   /* Stack unwinding.  */
1014   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1015   /* Breakpoints.  */
1016   set_gdbarch_breakpoint_from_pc (gdbarch, mn10300_breakpoint_from_pc);
1017   /* decr_pc_after_break? */
1018   /* Disassembly.  */
1019   set_gdbarch_print_insn (gdbarch, print_insn_mn10300);
1020
1021   /* Stage 2 */
1022   set_gdbarch_return_value (gdbarch, mn10300_return_value);
1023
1024   /* Stage 3 -- get target calls working.  */
1025   set_gdbarch_push_dummy_call (gdbarch, mn10300_push_dummy_call);
1026   /* set_gdbarch_return_value (store, extract) */
1027
1028
1029   mn10300_frame_unwind_init (gdbarch);
1030
1031   /* Hook in ABI-specific overrides, if they have been registered.  */
1032   gdbarch_init_osabi (info, gdbarch);
1033
1034   return gdbarch;
1035 }
1036
1037 /* Dump out the mn10300 specific architecture information. */
1038
1039 static void
1040 mn10300_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
1041 {
1042   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1043   fprintf_unfiltered (file, "mn10300_dump_tdep: am33_mode = %d\n",
1044                       tdep->am33_mode);
1045 }
1046
1047 void
1048 _initialize_mn10300_tdep (void)
1049 {
1050   gdbarch_register (bfd_arch_mn10300, mn10300_gdbarch_init, mn10300_dump_tdep);
1051 }
1052