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