gdb/mn10300-tdep.c

   1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
   2
   3    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   4    2007 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., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, 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 static const char *
 249 am33_2_register_name (int reg)
 250 {
 251   static char *regs[] =
 252   {
 253     "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
 254     "sp", "pc", "mdr", "psw", "lir", "lar", "mdrq", "r0",
 255     "r1", "r2", "r3", "r4", "r5", "r6", "r7", "ssp",
 256     "msp", "usp", "mcrh", "mcrl", "mcvf", "fpcr", "", "",
 257     "fs0", "fs1", "fs2", "fs3", "fs4", "fs5", "fs6", "fs7",
 258     "fs8", "fs9", "fs10", "fs11", "fs12", "fs13", "fs14", "fs15",
 259     "fs16", "fs17", "fs18", "fs19", "fs20", "fs21", "fs22", "fs23",
 260     "fs24", "fs25", "fs26", "fs27", "fs28", "fs29", "fs30", "fs31"
 261   };
 262   return register_name (reg, regs, sizeof regs);
 263 }
 264
 265 static struct type *
 266 mn10300_register_type (struct gdbarch *gdbarch, int reg)
 267 {
 268   return builtin_type_int;
 269 }
 270
 271 static CORE_ADDR
 272 mn10300_read_pc (struct regcache *regcache)
 273 {
 274   ULONGEST val;
 275   regcache_cooked_read_unsigned (regcache, E_PC_REGNUM, &val);
 276   return val;
 277 }
 278
 279 static void
 280 mn10300_write_pc (struct regcache *regcache, CORE_ADDR val)
 281 {
 282   regcache_cooked_write_unsigned (regcache, E_PC_REGNUM, val);
 283 }
 284
 285 /* The breakpoint instruction must be the same size as the smallest
 286    instruction in the instruction set.
 287
 288    The Matsushita mn10x00 processors have single byte instructions
 289    so we need a single byte breakpoint.  Matsushita hasn't defined
 290    one, so we defined it ourselves.  */
 291
 292 const static unsigned char *
 293 mn10300_breakpoint_from_pc (CORE_ADDR *bp_addr, int *bp_size)
 294 {
 295   static char breakpoint[] = {0xff};
 296   *bp_size = 1;
 297   return breakpoint;
 298 }
 299
 300 /* Set offsets of saved registers.
 301    This is a helper function for mn10300_analyze_prologue.  */
 302
 303 static void
 304 set_reg_offsets (struct frame_info *fi,
 305                   void **this_cache,
 306                   int movm_args,
 307                   int fpregmask,
 308                   int stack_extra_size,
 309                   int frame_in_fp)
 310 {
 311   struct trad_frame_cache *cache;
 312   int offset = 0;
 313   CORE_ADDR base;
 314
 315   if (fi == NULL || this_cache == NULL)
 316     return;
 317
 318   cache = mn10300_frame_unwind_cache (fi, this_cache);
 319   if (cache == NULL)
 320     return;
 321
 322   if (frame_in_fp)
 323     {
 324       base = frame_unwind_register_unsigned (fi, E_A3_REGNUM);
 325     }
 326   else
 327     {
 328       base = frame_unwind_register_unsigned (fi, E_SP_REGNUM) + stack_extra_size;
 329     }
 330
 331   trad_frame_set_this_base (cache, base);
 332
 333   if (AM33_MODE == 2)
 334     {
 335       /* If bit N is set in fpregmask, fsN is saved on the stack.
 336          The floating point registers are saved in ascending order.
 337          For example:  fs16 <- Frame Pointer
 338                        fs17    Frame Pointer + 4 */
 339       if (fpregmask != 0)
 340         {
 341           int i;
 342           for (i = 0; i < 32; i++)
 343             {
 344               if (fpregmask & (1 << i))
 345                 {
 346                   trad_frame_set_reg_addr (cache, E_FS0_REGNUM + i, base + offset);
 347                   offset += 4;
 348                 }
 349             }
 350         }
 351     }
 352
 353
 354   if (movm_args & movm_other_bit)
 355     {
 356       /* The `other' bit leaves a blank area of four bytes at the
 357          beginning of its block of saved registers, making it 32 bytes
 358          long in total.  */
 359       trad_frame_set_reg_addr (cache, E_LAR_REGNUM,    base + offset + 4);
 360       trad_frame_set_reg_addr (cache, E_LIR_REGNUM,    base + offset + 8);
 361       trad_frame_set_reg_addr (cache, E_MDR_REGNUM,    base + offset + 12);
 362       trad_frame_set_reg_addr (cache, E_A0_REGNUM + 1, base + offset + 16);
 363       trad_frame_set_reg_addr (cache, E_A0_REGNUM,     base + offset + 20);
 364       trad_frame_set_reg_addr (cache, E_D0_REGNUM + 1, base + offset + 24);
 365       trad_frame_set_reg_addr (cache, E_D0_REGNUM,     base + offset + 28);
 366       offset += 32;
 367     }
 368
 369   if (movm_args & movm_a3_bit)
 370     {
 371       trad_frame_set_reg_addr (cache, E_A3_REGNUM, base + offset);
 372       offset += 4;
 373     }
 374   if (movm_args & movm_a2_bit)
 375     {
 376       trad_frame_set_reg_addr (cache, E_A2_REGNUM, base + offset);
 377       offset += 4;
 378     }
 379   if (movm_args & movm_d3_bit)
 380     {
 381       trad_frame_set_reg_addr (cache, E_D3_REGNUM, base + offset);
 382       offset += 4;
 383     }
 384   if (movm_args & movm_d2_bit)
 385     {
 386       trad_frame_set_reg_addr (cache, E_D2_REGNUM, base + offset);
 387       offset += 4;
 388     }
 389   if (AM33_MODE)
 390     {
 391       if (movm_args & movm_exother_bit)
 392         {
 393           trad_frame_set_reg_addr (cache, E_MCVF_REGNUM, base + offset);
 394           trad_frame_set_reg_addr (cache, E_MCRL_REGNUM, base + offset + 4);
 395           trad_frame_set_reg_addr (cache, E_MCRH_REGNUM, base + offset + 8);
 396           trad_frame_set_reg_addr (cache, E_MDRQ_REGNUM, base + offset + 12);
 397           trad_frame_set_reg_addr (cache, E_E1_REGNUM,   base + offset + 16);
 398           trad_frame_set_reg_addr (cache, E_E0_REGNUM,   base + offset + 20);
 399           offset += 24;
 400         }
 401       if (movm_args & movm_exreg1_bit)
 402         {
 403           trad_frame_set_reg_addr (cache, E_E7_REGNUM, base + offset);
 404           trad_frame_set_reg_addr (cache, E_E6_REGNUM, base + offset + 4);
 405           trad_frame_set_reg_addr (cache, E_E5_REGNUM, base + offset + 8);
 406           trad_frame_set_reg_addr (cache, E_E4_REGNUM, base + offset + 12);
 407           offset += 16;
 408         }
 409       if (movm_args & movm_exreg0_bit)
 410         {
 411           trad_frame_set_reg_addr (cache, E_E3_REGNUM, base + offset);
 412           trad_frame_set_reg_addr (cache, E_E2_REGNUM, base + offset + 4);
 413           offset += 8;
 414         }
 415     }
 416   /* The last (or first) thing on the stack will be the PC.  */
 417   trad_frame_set_reg_addr (cache, E_PC_REGNUM, base + offset);
 418   /* Save the SP in the 'traditional' way.
 419      This will be the same location where the PC is saved.  */
 420   trad_frame_set_reg_value (cache, E_SP_REGNUM, base + offset);
 421 }
 422
 423 /* The main purpose of this file is dealing with prologues to extract
 424    information about stack frames and saved registers.
 425
 426    In gcc/config/mn13000/mn10300.c, the expand_prologue prologue
 427    function is pretty readable, and has a nice explanation of how the
 428    prologue is generated.  The prologues generated by that code will
 429    have the following form (NOTE: the current code doesn't handle all
 430    this!):
 431
 432    + If this is an old-style varargs function, then its arguments
 433      need to be flushed back to the stack:
 434
 435         mov d0,(4,sp)
 436         mov d1,(4,sp)
 437
 438    + If we use any of the callee-saved registers, save them now.
 439
 440         movm [some callee-saved registers],(sp)
 441
 442    + If we have any floating-point registers to save:
 443
 444      - Decrement the stack pointer to reserve space for the registers.
 445        If the function doesn't need a frame pointer, we may combine
 446        this with the adjustment that reserves space for the frame.
 447
 448         add -SIZE, sp
 449
 450      - Save the floating-point registers.  We have two possible
 451        strategies:
 452
 453        . Save them at fixed offset from the SP:
 454
 455         fmov fsN,(OFFSETN,sp)
 456         fmov fsM,(OFFSETM,sp)
 457         ...
 458
 459        Note that, if OFFSETN happens to be zero, you'll get the
 460        different opcode: fmov fsN,(sp)
 461
 462        . Or, set a0 to the start of the save area, and then use
 463        post-increment addressing to save the FP registers.
 464
 465         mov sp, a0
 466         add SIZE, a0
 467         fmov fsN,(a0+)
 468         fmov fsM,(a0+)
 469         ...
 470
 471    + If the function needs a frame pointer, we set it here.
 472
 473         mov sp, a3
 474
 475    + Now we reserve space for the stack frame proper.  This could be
 476      merged into the `add -SIZE, sp' instruction for FP saves up
 477      above, unless we needed to set the frame pointer in the previous
 478      step, or the frame is so large that allocating the whole thing at
 479      once would put the FP register save slots out of reach of the
 480      addressing mode (128 bytes).
 481
 482         add -SIZE, sp
 483
 484    One day we might keep the stack pointer constant, that won't
 485    change the code for prologues, but it will make the frame
 486    pointerless case much more common.  */
 487
 488 /* Analyze the prologue to determine where registers are saved,
 489    the end of the prologue, etc etc.  Return the end of the prologue
 490    scanned.
 491
 492    We store into FI (if non-null) several tidbits of information:
 493
 494    * stack_size -- size of this stack frame.  Note that if we stop in
 495    certain parts of the prologue/epilogue we may claim the size of the
 496    current frame is zero.  This happens when the current frame has
 497    not been allocated yet or has already been deallocated.
 498
 499    * fsr -- Addresses of registers saved in the stack by this frame.
 500
 501    * status -- A (relatively) generic status indicator.  It's a bitmask
 502    with the following bits:
 503
 504    MY_FRAME_IN_SP: The base of the current frame is actually in
 505    the stack pointer.  This can happen for frame pointerless
 506    functions, or cases where we're stopped in the prologue/epilogue
 507    itself.  For these cases mn10300_analyze_prologue will need up
 508    update fi->frame before returning or analyzing the register
 509    save instructions.
 510
 511    MY_FRAME_IN_FP: The base of the current frame is in the
 512    frame pointer register ($a3).
 513
 514    NO_MORE_FRAMES: Set this if the current frame is "start" or
 515    if the first instruction looks like mov <imm>,sp.  This tells
 516    frame chain to not bother trying to unwind past this frame.  */
 517
 518 static CORE_ADDR
 519 mn10300_analyze_prologue (struct frame_info *fi,
 520                           void **this_cache,
 521                           CORE_ADDR pc)
 522 {
 523   CORE_ADDR func_addr, func_end, addr, stop;
 524   long stack_extra_size = 0;
 525   int imm_size;
 526   unsigned char buf[4];
 527   int status;
 528   int movm_args = 0;
 529   int fpregmask = 0;
 530   char *name;
 531   int frame_in_fp = 0;
 532
 533   /* Use the PC in the frame if it's provided to look up the
 534      start of this function.
 535
 536      Note: kevinb/2003-07-16: We used to do the following here:
 537         pc = (fi ? get_frame_pc (fi) : pc);
 538      But this is (now) badly broken when called from analyze_dummy_frame().
 539   */
 540   if (fi)
 541     {
 542       pc = (pc ? pc : get_frame_pc (fi));
 543     }
 544
 545   /* Find the start of this function.  */
 546   status = find_pc_partial_function (pc, &name, &func_addr, &func_end);
 547
 548   /* Do nothing if we couldn't find the start of this function
 549
 550      MVS: comment went on to say "or if we're stopped at the first
 551      instruction in the prologue" -- but code doesn't reflect that,
 552      and I don't want to do that anyway.  */
 553   if (status == 0)
 554     {
 555       addr = pc;
 556       goto finish_prologue;
 557     }
 558
 559   /* If we're in start, then give up.  */
 560   if (strcmp (name, "start") == 0)
 561     {
 562       addr = pc;
 563       goto finish_prologue;
 564     }
 565
 566   /* Figure out where to stop scanning.  */
 567   stop = fi ? pc : func_end;
 568
 569   /* Don't walk off the end of the function.  */
 570   stop = stop > func_end ? func_end : stop;
 571
 572   /* Start scanning on the first instruction of this function.  */
 573   addr = func_addr;
 574
 575   /* Suck in two bytes.  */
 576   if (addr + 2 > stop || !safe_frame_unwind_memory (fi, addr, buf, 2))
 577     goto finish_prologue;
 578
 579   /* First see if this insn sets the stack pointer from a register; if
 580      so, it's probably the initialization of the stack pointer in _start,
 581      so mark this as the bottom-most frame.  */
 582   if (buf[0] == 0xf2 && (buf[1] & 0xf3) == 0xf0)
 583     {
 584       goto finish_prologue;
 585     }
 586
 587   /* Now look for movm [regs],sp, which saves the callee saved registers.
 588
 589      At this time we don't know if fi->frame is valid, so we only note
 590      that we encountered a movm instruction.  Later, we'll set the entries
 591      in fsr.regs as needed.  */
 592   if (buf[0] == 0xcf)
 593     {
 594       /* Extract the register list for the movm instruction.  */
 595       movm_args = buf[1];
 596
 597       addr += 2;
 598
 599       /* Quit now if we're beyond the stop point.  */
 600       if (addr >= stop)
 601         goto finish_prologue;
 602
 603       /* Get the next two bytes so the prologue scan can continue.  */
 604       if (!safe_frame_unwind_memory (fi, addr, buf, 2))
 605         goto finish_prologue;
 606     }
 607
 608   if (AM33_MODE == 2)
 609     {
 610       /* Determine if any floating point registers are to be saved.
 611          Look for one of the following three prologue formats:
 612
 613         [movm [regs],(sp)] [movm [regs],(sp)] [movm [regs],(sp)]
 614
 615          add -SIZE,sp       add -SIZE,sp       add -SIZE,sp
 616          fmov fs#,(sp)      mov sp,a0/a1       mov sp,a0/a1
 617          fmov fs#,(#,sp)    fmov fs#,(a0/a1+)  add SIZE2,a0/a1
 618          ...                ...                fmov fs#,(a0/a1+)
 619          ...                ...                ...
 620          fmov fs#,(#,sp)    fmov fs#,(a0/a1+)  fmov fs#,(a0/a1+)
 621
 622         [mov sp,a3]        [mov sp,a3]
 623         [add -SIZE2,sp]    [add -SIZE2,sp]                                 */
 624
 625       /* Remember the address at which we started in the event that we
 626          don't ultimately find an fmov instruction.  Once we're certain
 627          that we matched one of the above patterns, we'll set
 628          ``restore_addr'' to the appropriate value.  Note: At one time
 629          in the past, this code attempted to not adjust ``addr'' until
 630          there was a fair degree of certainty that the pattern would be
 631          matched.  However, that code did not wait until an fmov instruction
 632          was actually encountered.  As a consequence, ``addr'' would
 633          sometimes be advanced even when no fmov instructions were found.  */
 634       CORE_ADDR restore_addr = addr;
 635
 636       /* First, look for add -SIZE,sp (i.e. add imm8,sp  (0xf8feXX)
 637                                          or add imm16,sp (0xfafeXXXX)
 638                                          or add imm32,sp (0xfcfeXXXXXXXX)) */
 639       imm_size = 0;
 640       if (buf[0] == 0xf8 && buf[1] == 0xfe)
 641         imm_size = 1;
 642       else if (buf[0] == 0xfa && buf[1] == 0xfe)
 643         imm_size = 2;
 644       else if (buf[0] == 0xfc && buf[1] == 0xfe)
 645         imm_size = 4;
 646       if (imm_size != 0)
 647         {
 648           /* An "add -#,sp" instruction has been found. "addr + 2 + imm_size"
 649              is the address of the next instruction. Don't modify "addr" until
 650              the next "floating point prologue" instruction is found. If this
 651              is not a prologue that saves floating point registers we need to
 652              be able to back out of this bit of code and continue with the
 653              prologue analysis. */
 654           if (addr + 2 + imm_size < stop)
 655             {
 656               if (!safe_frame_unwind_memory (fi, addr + 2 + imm_size, buf, 3))
 657                 goto finish_prologue;
 658               if ((buf[0] & 0xfc) == 0x3c)
 659                 {
 660                   /* Occasionally, especially with C++ code, the "fmov"
 661                      instructions will be preceded by "mov sp,aN"
 662                      (aN => a0, a1, a2, or a3).
 663
 664                      This is a one byte instruction:  mov sp,aN = 0011 11XX
 665                      where XX is the register number.
 666
 667                      Skip this instruction by incrementing addr.  The "fmov"
 668                      instructions will have the form "fmov fs#,(aN+)" in this
 669                      case, but that will not necessitate a change in the
 670                      "fmov" parsing logic below. */
 671
 672                   addr++;
 673
 674                   if ((buf[1] & 0xfc) == 0x20)
 675                     {
 676                       /* Occasionally, especially with C++ code compiled with
 677                          the -fomit-frame-pointer or -O3 options, the
 678                          "mov sp,aN" instruction will be followed by an
 679                          "add #,aN" instruction. This indicates the
 680                          "stack_size", the size of the portion of the stack
 681                          containing the arguments. This instruction format is:
 682                          add #,aN = 0010 00XX YYYY YYYY
 683                          where XX        is the register number
 684                                YYYY YYYY is the constant.
 685                          Note the size of the stack (as a negative number) in
 686                          the frame info structure. */
 687                       if (fi)
 688                         stack_extra_size += -buf[2];
 689
 690                       addr += 2;
 691                     }
 692                 }
 693
 694               if ((buf[0] & 0xfc) == 0x3c ||
 695                   buf[0] == 0xf9 || buf[0] == 0xfb)
 696                 {
 697                   /* An "fmov" instruction has been found indicating that this
 698                      prologue saves floating point registers (or, as described
 699                      above, a "mov sp,aN" and possible "add #,aN" have been
 700                      found and we will assume an "fmov" follows). Process the
 701                      consecutive "fmov" instructions. */
 702                   for (addr += 2 + imm_size;;addr += imm_size)
 703                     {
 704                       int regnum;
 705
 706                       /* Read the "fmov" instruction. */
 707                       if (addr >= stop ||
 708                           !safe_frame_unwind_memory (fi, addr, buf, 4))
 709                         goto finish_prologue;
 710
 711                       if (buf[0] != 0xf9 && buf[0] != 0xfb)
 712                         break;
 713
 714                       /* An fmov instruction has just been seen.  We can
 715                          now really commit to the pattern match.  Set the
 716                          address to restore at the end of this speculative
 717                          bit of code to the actually address that we've
 718                          been incrementing (or not) throughout the
 719                          speculation.  */
 720                       restore_addr = addr;
 721
 722                       /* Get the floating point register number from the
 723                          2nd and 3rd bytes of the "fmov" instruction:
 724                          Machine Code: 0000 00X0 YYYY 0000 =>
 725                          Regnum: 000X YYYY */
 726                       regnum = (buf[1] & 0x02) << 3;
 727                       regnum |= ((buf[2] & 0xf0) >> 4) & 0x0f;
 728
 729                       /* Add this register number to the bit mask of floating
 730                          point registers that have been saved. */
 731                       fpregmask |= 1 << regnum;
 732
 733                       /* Determine the length of this "fmov" instruction.
 734                          fmov fs#,(sp)   => 3 byte instruction
 735                          fmov fs#,(#,sp) => 4 byte instruction */
 736                       imm_size = (buf[0] == 0xf9) ? 3 : 4;
 737                     }
 738                 }
 739               else
 740                 {
 741                   /* No "fmov" was found. Reread the two bytes at the original
 742                      "addr" to reset the state. */
 743                   addr = restore_addr;
 744                   if (!safe_frame_unwind_memory (fi, addr, buf, 2))
 745                     goto finish_prologue;
 746                 }
 747             }
 748           /* else the prologue consists entirely of an "add -SIZE,sp"
 749              instruction. Handle this below. */
 750         }
 751       /* else no "add -SIZE,sp" was found indicating no floating point
 752          registers are saved in this prologue.  */
 753
 754       /* In the pattern match code contained within this block, `restore_addr'
 755          is set to the starting address at the very beginning and then
 756          iteratively to the next address to start scanning at once the
 757          pattern match has succeeded.  Thus `restore_addr' will contain
 758          the address to rewind to if the pattern match failed.  If the
 759          match succeeded, `restore_addr' and `addr' will already have the
 760          same value.  */
 761       addr = restore_addr;
 762     }
 763
 764   /* Now see if we set up a frame pointer via "mov sp,a3" */
 765   if (buf[0] == 0x3f)
 766     {
 767       addr += 1;
 768
 769       /* The frame pointer is now valid.  */
 770       if (fi)
 771         {
 772           frame_in_fp = 1;
 773         }
 774
 775       /* Quit now if we're beyond the stop point.  */
 776       if (addr >= stop)
 777         goto finish_prologue;
 778
 779       /* Get two more bytes so scanning can continue.  */
 780       if (!safe_frame_unwind_memory (fi, addr, buf, 2))
 781         goto finish_prologue;
 782     }
 783
 784   /* Next we should allocate the local frame.  No more prologue insns
 785      are found after allocating the local frame.
 786
 787      Search for add imm8,sp (0xf8feXX)
 788      or add imm16,sp (0xfafeXXXX)
 789      or add imm32,sp (0xfcfeXXXXXXXX).
 790
 791      If none of the above was found, then this prologue has no
 792      additional stack.  */
 793
 794   imm_size = 0;
 795   if (buf[0] == 0xf8 && buf[1] == 0xfe)
 796     imm_size = 1;
 797   else if (buf[0] == 0xfa && buf[1] == 0xfe)
 798     imm_size = 2;
 799   else if (buf[0] == 0xfc && buf[1] == 0xfe)
 800     imm_size = 4;
 801
 802   if (imm_size != 0)
 803     {
 804       /* Suck in imm_size more bytes, they'll hold the size of the
 805          current frame.  */
 806       if (!safe_frame_unwind_memory (fi, addr + 2, buf, imm_size))
 807         goto finish_prologue;
 808
 809       /* Note the size of the stack.  */
 810       stack_extra_size -= extract_signed_integer (buf, imm_size);
 811
 812       /* We just consumed 2 + imm_size bytes.  */
 813       addr += 2 + imm_size;
 814
 815       /* No more prologue insns follow, so begin preparation to return.  */
 816       goto finish_prologue;
 817     }
 818   /* Do the essentials and get out of here.  */
 819  finish_prologue:
 820   /* Note if/where callee saved registers were saved.  */
 821   if (fi)
 822     set_reg_offsets (fi, this_cache, movm_args, fpregmask, stack_extra_size, frame_in_fp);
 823   return addr;
 824 }
 825
 826 /* Function: skip_prologue
 827    Return the address of the first inst past the prologue of the function.  */
 828
 829 static CORE_ADDR
 830 mn10300_skip_prologue (CORE_ADDR pc)
 831 {
 832   return mn10300_analyze_prologue (NULL, NULL, pc);
 833 }
 834
 835 /* Simple frame_unwind_cache.
 836    This finds the "extra info" for the frame.  */
 837 struct trad_frame_cache *
 838 mn10300_frame_unwind_cache (struct frame_info *next_frame,
 839                             void **this_prologue_cache)
 840 {
 841   struct trad_frame_cache *cache;
 842   CORE_ADDR pc, start, end;
 843
 844   if (*this_prologue_cache)
 845     return (*this_prologue_cache);
 846
 847   cache = trad_frame_cache_zalloc (next_frame);
 848   pc = gdbarch_unwind_pc (current_gdbarch, next_frame);
 849   mn10300_analyze_prologue (next_frame, (void **) &cache, pc);
 850   if (find_pc_partial_function (pc, NULL, &start, &end))
 851     trad_frame_set_id (cache,
 852                        frame_id_build (trad_frame_get_this_base (cache),
 853                                        start));
 854   else
 855     {
 856       start = frame_func_unwind (next_frame, NORMAL_FRAME);
 857       trad_frame_set_id (cache,
 858                          frame_id_build (trad_frame_get_this_base (cache),
 859                                          start));
 860     }
 861
 862   (*this_prologue_cache) = cache;
 863   return cache;
 864 }
 865
 866 /* Here is a dummy implementation.  */
 867 static struct frame_id
 868 mn10300_unwind_dummy_id (struct gdbarch *gdbarch,
 869                          struct frame_info *next_frame)
 870 {
 871   return frame_id_build (frame_sp_unwind (next_frame),
 872                          frame_pc_unwind (next_frame));
 873 }
 874
 875 /* Trad frame implementation.  */
 876 static void
 877 mn10300_frame_this_id (struct frame_info *next_frame,
 878                        void **this_prologue_cache,
 879                        struct frame_id *this_id)
 880 {
 881   struct trad_frame_cache *cache =
 882     mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
 883
 884   trad_frame_get_id (cache, this_id);
 885 }
 886
 887 static void
 888 mn10300_frame_prev_register (struct frame_info *next_frame,
 889                              void **this_prologue_cache,
 890                              int regnum, int *optimizedp,
 891                              enum lval_type *lvalp, CORE_ADDR *addrp,
 892                              int *realnump, gdb_byte *bufferp)
 893 {
 894   struct trad_frame_cache *cache =
 895     mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
 896
 897   trad_frame_get_register (cache, next_frame, regnum, optimizedp,
 898                            lvalp, addrp, realnump, bufferp);
 899   /* Or...
 900   trad_frame_get_prev_register (next_frame, cache->prev_regs, regnum,
 901                            optimizedp, lvalp, addrp, realnump, bufferp);
 902   */
 903 }
 904
 905 static const struct frame_unwind mn10300_frame_unwind = {
 906   NORMAL_FRAME,
 907   mn10300_frame_this_id,
 908   mn10300_frame_prev_register
 909 };
 910
 911 static CORE_ADDR
 912 mn10300_frame_base_address (struct frame_info *next_frame,
 913                             void **this_prologue_cache)
 914 {
 915   struct trad_frame_cache *cache =
 916     mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
 917
 918   return trad_frame_get_this_base (cache);
 919 }
 920
 921 static const struct frame_unwind *
 922 mn10300_frame_sniffer (struct frame_info *next_frame)
 923 {
 924   return &mn10300_frame_unwind;
 925 }
 926
 927 static const struct frame_base mn10300_frame_base = {
 928   &mn10300_frame_unwind,
 929   mn10300_frame_base_address,
 930   mn10300_frame_base_address,
 931   mn10300_frame_base_address
 932 };
 933
 934 static CORE_ADDR
 935 mn10300_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 936 {
 937   ULONGEST pc;
 938
 939   frame_unwind_unsigned_register (next_frame, E_PC_REGNUM, &pc);
 940   return pc;
 941 }
 942
 943 static CORE_ADDR
 944 mn10300_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 945 {
 946   ULONGEST sp;
 947
 948   frame_unwind_unsigned_register (next_frame, E_SP_REGNUM, &sp);
 949   return sp;
 950 }
 951
 952 static void
 953 mn10300_frame_unwind_init (struct gdbarch *gdbarch)
 954 {
 955   frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
 956   frame_unwind_append_sniffer (gdbarch, mn10300_frame_sniffer);
 957   frame_base_set_default (gdbarch, &mn10300_frame_base);
 958   set_gdbarch_unwind_dummy_id (gdbarch, mn10300_unwind_dummy_id);
 959   set_gdbarch_unwind_pc (gdbarch, mn10300_unwind_pc);
 960   set_gdbarch_unwind_sp (gdbarch, mn10300_unwind_sp);
 961 }
 962
 963 /* Function: push_dummy_call
 964  *
 965  * Set up machine state for a target call, including
 966  * function arguments, stack, return address, etc.
 967  *
 968  */
 969
 970 static CORE_ADDR
 971 mn10300_push_dummy_call (struct gdbarch *gdbarch,
 972                          struct value *target_func,
 973                          struct regcache *regcache,
 974                          CORE_ADDR bp_addr,
 975                          int nargs, struct value **args,
 976                          CORE_ADDR sp,
 977                          int struct_return,
 978                          CORE_ADDR struct_addr)
 979 {
 980   const int push_size = register_size (gdbarch, E_PC_REGNUM);
 981   int regs_used;
 982   int len, arg_len;
 983   int stack_offset = 0;
 984   int argnum;
 985   char *val, valbuf[MAX_REGISTER_SIZE];
 986
 987   /* This should be a nop, but align the stack just in case something
 988      went wrong.  Stacks are four byte aligned on the mn10300.  */
 989   sp &= ~3;
 990
 991   /* Now make space on the stack for the args.
 992
 993      XXX This doesn't appear to handle pass-by-invisible reference
 994      arguments.  */
 995   regs_used = struct_return ? 1 : 0;
 996   for (len = 0, argnum = 0; argnum < nargs; argnum++)
 997     {
 998       arg_len = (TYPE_LENGTH (value_type (args[argnum])) + 3) & ~3;
 999       while (regs_used < 2 && arg_len > 0)
1000         {
1001           regs_used++;
1002           arg_len -= push_size;
1003         }
1004       len += arg_len;
1005     }
1006
1007   /* Allocate stack space.  */
1008   sp -= len;
1009
1010   if (struct_return)
1011     {
1012       regs_used = 1;
1013       regcache_cooked_write_unsigned (regcache, E_D0_REGNUM, struct_addr);
1014     }
1015   else
1016     regs_used = 0;
1017
1018   /* Push all arguments onto the stack. */
1019   for (argnum = 0; argnum < nargs; argnum++)
1020     {
1021       /* FIXME what about structs?  Unions?  */
1022       if (TYPE_CODE (value_type (*args)) == TYPE_CODE_STRUCT
1023           && TYPE_LENGTH (value_type (*args)) > 8)
1024         {
1025           /* Change to pointer-to-type.  */
1026           arg_len = push_size;
1027           store_unsigned_integer (valbuf, push_size,
1028                                   VALUE_ADDRESS (*args));
1029           val = &valbuf[0];
1030         }
1031       else
1032         {
1033           arg_len = TYPE_LENGTH (value_type (*args));
1034           val = (char *) value_contents (*args);
1035         }
1036
1037       while (regs_used < 2 && arg_len > 0)
1038         {
1039           regcache_cooked_write_unsigned (regcache, regs_used,
1040                                   extract_unsigned_integer (val, push_size));
1041           val += push_size;
1042           arg_len -= push_size;
1043           regs_used++;
1044         }
1045
1046       while (arg_len > 0)
1047         {
1048           write_memory (sp + stack_offset, val, push_size);
1049           arg_len -= push_size;
1050           val += push_size;
1051           stack_offset += push_size;
1052         }
1053
1054       args++;
1055     }
1056
1057   /* Make space for the flushback area.  */
1058   sp -= 8;
1059
1060   /* Push the return address that contains the magic breakpoint.  */
1061   sp -= 4;
1062   write_memory_unsigned_integer (sp, push_size, bp_addr);
1063
1064   /* The CPU also writes the return address always into the
1065      MDR register on "call".  */
1066   regcache_cooked_write_unsigned (regcache, E_MDR_REGNUM, bp_addr);
1067
1068   /* Update $sp.  */
1069   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
1070   return sp;
1071 }
1072
1073 /* If DWARF2 is a register number appearing in Dwarf2 debug info, then
1074    mn10300_dwarf2_reg_to_regnum (DWARF2) is the corresponding GDB
1075    register number.  Why don't Dwarf2 and GDB use the same numbering?
1076    Who knows?  But since people have object files lying around with
1077    the existing Dwarf2 numbering, and other people have written stubs
1078    to work with the existing GDB, neither of them can change.  So we
1079    just have to cope.  */
1080 static int
1081 mn10300_dwarf2_reg_to_regnum (int dwarf2)
1082 {
1083   /* This table is supposed to be shaped like the gdbarch_register_name
1084      initializer in gcc/config/mn10300/mn10300.h.  Registers which
1085      appear in GCC's numbering, but have no counterpart in GDB's
1086      world, are marked with a -1.  */
1087   static int dwarf2_to_gdb[] = {
1088     0,  1,  2,  3,  4,  5,  6,  7, -1, 8,
1089     15, 16, 17, 18, 19, 20, 21, 22,
1090     32, 33, 34, 35, 36, 37, 38, 39,
1091     40, 41, 42, 43, 44, 45, 46, 47,
1092     48, 49, 50, 51, 52, 53, 54, 55,
1093     56, 57, 58, 59, 60, 61, 62, 63
1094   };
1095
1096   if (dwarf2 < 0
1097       || dwarf2 >= ARRAY_SIZE (dwarf2_to_gdb)
1098       || dwarf2_to_gdb[dwarf2] == -1)
1099     {
1100       warning (_("Bogus register number in debug info: %d"), dwarf2);
1101       return 0;
1102     }
1103
1104   return dwarf2_to_gdb[dwarf2];
1105 }
1106
1107 static struct gdbarch *
1108 mn10300_gdbarch_init (struct gdbarch_info info,
1109                       struct gdbarch_list *arches)
1110 {
1111   struct gdbarch *gdbarch;
1112   struct gdbarch_tdep *tdep;
1113   int num_regs;
1114
1115   arches = gdbarch_list_lookup_by_info (arches, &info);
1116   if (arches != NULL)
1117     return arches->gdbarch;
1118
1119   tdep = xmalloc (sizeof (struct gdbarch_tdep));
1120   gdbarch = gdbarch_alloc (&info, tdep);
1121
1122   switch (info.bfd_arch_info->mach)
1123     {
1124     case 0:
1125     case bfd_mach_mn10300:
1126       set_gdbarch_register_name (gdbarch, mn10300_generic_register_name);
1127       tdep->am33_mode = 0;
1128       num_regs = 32;
1129       break;
1130     case bfd_mach_am33:
1131       set_gdbarch_register_name (gdbarch, am33_register_name);
1132       tdep->am33_mode = 1;
1133       num_regs = 32;
1134       break;
1135     case bfd_mach_am33_2:
1136       set_gdbarch_register_name (gdbarch, am33_2_register_name);
1137       tdep->am33_mode = 2;
1138       num_regs = 64;
1139       set_gdbarch_fp0_regnum (gdbarch, 32);
1140       break;
1141     default:
1142       internal_error (__FILE__, __LINE__,
1143                       _("mn10300_gdbarch_init: Unknown mn10300 variant"));
1144       break;
1145     }
1146
1147   /* Registers.  */
1148   set_gdbarch_num_regs (gdbarch, num_regs);
1149   set_gdbarch_register_type (gdbarch, mn10300_register_type);
1150   set_gdbarch_skip_prologue (gdbarch, mn10300_skip_prologue);
1151   set_gdbarch_read_pc (gdbarch, mn10300_read_pc);
1152   set_gdbarch_write_pc (gdbarch, mn10300_write_pc);
1153   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
1154   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
1155   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, mn10300_dwarf2_reg_to_regnum);
1156
1157   /* Stack unwinding.  */
1158   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1159   /* Breakpoints.  */
1160   set_gdbarch_breakpoint_from_pc (gdbarch, mn10300_breakpoint_from_pc);
1161   /* decr_pc_after_break? */
1162   /* Disassembly.  */
1163   set_gdbarch_print_insn (gdbarch, print_insn_mn10300);
1164
1165   /* Stage 2 */
1166   set_gdbarch_return_value (gdbarch, mn10300_return_value);
1167
1168   /* Stage 3 -- get target calls working.  */
1169   set_gdbarch_push_dummy_call (gdbarch, mn10300_push_dummy_call);
1170   /* set_gdbarch_return_value (store, extract) */
1171
1172
1173   mn10300_frame_unwind_init (gdbarch);
1174
1175   /* Hook in ABI-specific overrides, if they have been registered.  */
1176   gdbarch_init_osabi (info, gdbarch);
1177
1178   return gdbarch;
1179 }
1180
1181 /* Dump out the mn10300 specific architecture information. */
1182
1183 static void
1184 mn10300_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
1185 {
1186   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1187   fprintf_unfiltered (file, "mn10300_dump_tdep: am33_mode = %d\n",
1188                       tdep->am33_mode);
1189 }
1190
1191 void
1192 _initialize_mn10300_tdep (void)
1193 {
1194   gdbarch_register (bfd_arch_mn10300, mn10300_gdbarch_init, mn10300_dump_tdep);
1195 }
1196