gdb/mn10300-tdep.c

   1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
   2    Copyright 1996, 1997, 1998 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "frame.h"
  23 #include "inferior.h"
  24 #include "obstack.h"
  25 #include "target.h"
  26 #include "value.h"
  27 #include "bfd.h"
  28 #include "gdb_string.h"
  29 #include "gdbcore.h"
  30 #include "symfile.h"
  31
  32 extern void _initialize_mn10300_tdep (void);
  33 static CORE_ADDR mn10300_analyze_prologue PARAMS ((struct frame_info * fi,
  34                                                    CORE_ADDR pc));
  35
  36 /* Additional info used by the frame */
  37
  38 struct frame_extra_info
  39   {
  40     int status;
  41     int stack_size;
  42   };
  43
  44
  45 static char *mn10300_generic_register_names[] =
  46 {"d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
  47  "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
  48  "", "", "", "", "", "", "", "",
  49  "", "", "", "", "", "", "", "fp"};
  50
  51 static char **mn10300_register_names = mn10300_generic_register_names;
  52 static char *am33_register_names[] =
  53 {
  54   "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
  55   "sp", "pc", "mdr", "psw", "lir", "lar", "",
  56   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
  57   "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""};
  58 static int am33_mode;
  59
  60 char *
  61 mn10300_register_name (i)
  62      int i;
  63 {
  64   return mn10300_register_names[i];
  65 }
  66
  67 CORE_ADDR
  68 mn10300_saved_pc_after_call (fi)
  69      struct frame_info *fi;
  70 {
  71   return read_memory_integer (read_register (SP_REGNUM), 4);
  72 }
  73
  74 void
  75 mn10300_extract_return_value (type, regbuf, valbuf)
  76      struct type *type;
  77      char *regbuf;
  78      char *valbuf;
  79 {
  80   if (TYPE_CODE (type) == TYPE_CODE_PTR)
  81     memcpy (valbuf, regbuf + REGISTER_BYTE (4), TYPE_LENGTH (type));
  82   else
  83     memcpy (valbuf, regbuf + REGISTER_BYTE (0), TYPE_LENGTH (type));
  84 }
  85
  86 CORE_ADDR
  87 mn10300_extract_struct_value_address (regbuf)
  88      char *regbuf;
  89 {
  90   return extract_address (regbuf + REGISTER_BYTE (4),
  91                           REGISTER_RAW_SIZE (4));
  92 }
  93
  94 void
  95 mn10300_store_return_value (type, valbuf)
  96      struct type *type;
  97      char *valbuf;
  98 {
  99   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 100     write_register_bytes (REGISTER_BYTE (4), valbuf, TYPE_LENGTH (type));
 101   else
 102     write_register_bytes (REGISTER_BYTE (0), valbuf, TYPE_LENGTH (type));
 103 }
 104
 105 static struct frame_info *analyze_dummy_frame PARAMS ((CORE_ADDR, CORE_ADDR));
 106 static struct frame_info *
 107 analyze_dummy_frame (pc, frame)
 108      CORE_ADDR pc;
 109      CORE_ADDR frame;
 110 {
 111   static struct frame_info *dummy = NULL;
 112   if (dummy == NULL)
 113     {
 114       dummy = xmalloc (sizeof (struct frame_info));
 115       dummy->saved_regs = xmalloc (SIZEOF_FRAME_SAVED_REGS);
 116       dummy->extra_info = xmalloc (sizeof (struct frame_extra_info));
 117     }
 118   dummy->next = NULL;
 119   dummy->prev = NULL;
 120   dummy->pc = pc;
 121   dummy->frame = frame;
 122   dummy->extra_info->status = 0;
 123   dummy->extra_info->stack_size = 0;
 124   memset (dummy->saved_regs, '\000', SIZEOF_FRAME_SAVED_REGS);
 125   mn10300_analyze_prologue (dummy, 0);
 126   return dummy;
 127 }
 128
 129 /* Values for frame_info.status */
 130
 131 #define MY_FRAME_IN_SP 0x1
 132 #define MY_FRAME_IN_FP 0x2
 133 #define NO_MORE_FRAMES 0x4
 134
 135
 136 /* Should call_function allocate stack space for a struct return?  */
 137 int
 138 mn10300_use_struct_convention (gcc_p, type)
 139      int gcc_p;
 140      struct type *type;
 141 {
 142   return (TYPE_NFIELDS (type) > 1 || TYPE_LENGTH (type) > 8);
 143 }
 144
 145 /* The breakpoint instruction must be the same size as the smallest
 146    instruction in the instruction set.
 147
 148    The Matsushita mn10x00 processors have single byte instructions
 149    so we need a single byte breakpoint.  Matsushita hasn't defined
 150    one, so we defined it ourselves.  */
 151
 152 unsigned char *
 153 mn10300_breakpoint_from_pc (bp_addr, bp_size)
 154      CORE_ADDR *bp_addr;
 155      int *bp_size;
 156 {
 157   static char breakpoint[] =
 158   {0xff};
 159   *bp_size = 1;
 160   return breakpoint;
 161 }
 162
 163
 164 /* Fix fi->frame if it's bogus at this point.  This is a helper
 165    function for mn10300_analyze_prologue. */
 166
 167 static void
 168 fix_frame_pointer (fi, stack_size)
 169      struct frame_info *fi;
 170      int stack_size;
 171 {
 172   if (fi && fi->next == NULL)
 173     {
 174       if (fi->extra_info->status & MY_FRAME_IN_SP)
 175         fi->frame = read_sp () - stack_size;
 176       else if (fi->extra_info->status & MY_FRAME_IN_FP)
 177         fi->frame = read_register (A3_REGNUM);
 178     }
 179 }
 180
 181
 182 /* Set offsets of registers saved by movm instruction.
 183    This is a helper function for mn10300_analyze_prologue.  */
 184
 185 static void
 186 set_movm_offsets (fi, movm_args)
 187      struct frame_info *fi;
 188      int movm_args;
 189 {
 190   int offset = 0;
 191
 192   if (fi == NULL || movm_args == 0)
 193     return;
 194
 195   if (movm_args & 0x10)
 196     {
 197       fi->saved_regs[A3_REGNUM] = fi->frame + offset;
 198       offset += 4;
 199     }
 200   if (movm_args & 0x20)
 201     {
 202       fi->saved_regs[A2_REGNUM] = fi->frame + offset;
 203       offset += 4;
 204     }
 205   if (movm_args & 0x40)
 206     {
 207       fi->saved_regs[D3_REGNUM] = fi->frame + offset;
 208       offset += 4;
 209     }
 210   if (movm_args & 0x80)
 211     {
 212       fi->saved_regs[D2_REGNUM] = fi->frame + offset;
 213       offset += 4;
 214     }
 215   if (am33_mode && movm_args & 0x02)
 216     {
 217       fi->saved_regs[E0_REGNUM + 5] = fi->frame + offset;
 218       fi->saved_regs[E0_REGNUM + 4] = fi->frame + offset + 4;
 219       fi->saved_regs[E0_REGNUM + 3] = fi->frame + offset + 8;
 220       fi->saved_regs[E0_REGNUM + 2] = fi->frame + offset + 12;
 221     }
 222 }
 223
 224
 225 /* The main purpose of this file is dealing with prologues to extract
 226    information about stack frames and saved registers.
 227
 228    For reference here's how prologues look on the mn10300:
 229
 230    With frame pointer:
 231    movm [d2,d3,a2,a3],sp
 232    mov sp,a3
 233    add <size>,sp
 234
 235    Without frame pointer:
 236    movm [d2,d3,a2,a3],sp (if needed)
 237    add <size>,sp
 238
 239    One day we might keep the stack pointer constant, that won't
 240    change the code for prologues, but it will make the frame
 241    pointerless case much more common.  */
 242
 243 /* Analyze the prologue to determine where registers are saved,
 244    the end of the prologue, etc etc.  Return the end of the prologue
 245    scanned.
 246
 247    We store into FI (if non-null) several tidbits of information:
 248
 249    * stack_size -- size of this stack frame.  Note that if we stop in
 250    certain parts of the prologue/epilogue we may claim the size of the
 251    current frame is zero.  This happens when the current frame has
 252    not been allocated yet or has already been deallocated.
 253
 254    * fsr -- Addresses of registers saved in the stack by this frame.
 255
 256    * status -- A (relatively) generic status indicator.  It's a bitmask
 257    with the following bits:
 258
 259    MY_FRAME_IN_SP: The base of the current frame is actually in
 260    the stack pointer.  This can happen for frame pointerless
 261    functions, or cases where we're stopped in the prologue/epilogue
 262    itself.  For these cases mn10300_analyze_prologue will need up
 263    update fi->frame before returning or analyzing the register
 264    save instructions.
 265
 266    MY_FRAME_IN_FP: The base of the current frame is in the
 267    frame pointer register ($a2).
 268
 269    NO_MORE_FRAMES: Set this if the current frame is "start" or
 270    if the first instruction looks like mov <imm>,sp.  This tells
 271    frame chain to not bother trying to unwind past this frame.  */
 272
 273 static CORE_ADDR
 274 mn10300_analyze_prologue (fi, pc)
 275      struct frame_info *fi;
 276      CORE_ADDR pc;
 277 {
 278   CORE_ADDR func_addr, func_end, addr, stop;
 279   CORE_ADDR stack_size;
 280   int imm_size;
 281   unsigned char buf[4];
 282   int status, movm_args = 0;
 283   char *name;
 284
 285   /* Use the PC in the frame if it's provided to look up the
 286      start of this function.  */
 287   pc = (fi ? fi->pc : pc);
 288
 289   /* Find the start of this function.  */
 290   status = find_pc_partial_function (pc, &name, &func_addr, &func_end);
 291
 292   /* Do nothing if we couldn't find the start of this function or if we're
 293      stopped at the first instruction in the prologue.  */
 294   if (status == 0)
 295     {
 296       return pc;
 297     }
 298
 299   /* If we're in start, then give up.  */
 300   if (strcmp (name, "start") == 0)
 301     {
 302       if (fi != NULL)
 303         fi->extra_info->status = NO_MORE_FRAMES;
 304       return pc;
 305     }
 306
 307   /* At the start of a function our frame is in the stack pointer.  */
 308   if (fi)
 309     fi->extra_info->status = MY_FRAME_IN_SP;
 310
 311   /* Get the next two bytes into buf, we need two because rets is a two
 312      byte insn and the first isn't enough to uniquely identify it.  */
 313   status = read_memory_nobpt (pc, buf, 2);
 314   if (status != 0)
 315     return pc;
 316
 317   /* If we're physically on an "rets" instruction, then our frame has
 318      already been deallocated.  Note this can also be true for retf
 319      and ret if they specify a size of zero.
 320
 321      In this case fi->frame is bogus, we need to fix it.  */
 322   if (fi && buf[0] == 0xf0 && buf[1] == 0xfc)
 323     {
 324       if (fi->next == NULL)
 325         fi->frame = read_sp ();
 326       return fi->pc;
 327     }
 328
 329   /* Similarly if we're stopped on the first insn of a prologue as our
 330      frame hasn't been allocated yet.  */
 331   if (fi && fi->pc == func_addr)
 332     {
 333       if (fi->next == NULL)
 334         fi->frame = read_sp ();
 335       return fi->pc;
 336     }
 337
 338   /* Figure out where to stop scanning.  */
 339   stop = fi ? fi->pc : func_end;
 340
 341   /* Don't walk off the end of the function.  */
 342   stop = stop > func_end ? func_end : stop;
 343
 344   /* Start scanning on the first instruction of this function.  */
 345   addr = func_addr;
 346
 347   /* Suck in two bytes.  */
 348   status = read_memory_nobpt (addr, buf, 2);
 349   if (status != 0)
 350     {
 351       fix_frame_pointer (fi, 0);
 352       return addr;
 353     }
 354
 355   /* First see if this insn sets the stack pointer; if so, it's something
 356      we won't understand, so quit now.   */
 357   if (buf[0] == 0xf2 && (buf[1] & 0xf3) == 0xf0)
 358     {
 359       if (fi)
 360         fi->extra_info->status = NO_MORE_FRAMES;
 361       return addr;
 362     }
 363
 364   /* Now look for movm [regs],sp, which saves the callee saved registers.
 365
 366      At this time we don't know if fi->frame is valid, so we only note
 367      that we encountered a movm instruction.  Later, we'll set the entries
 368      in fsr.regs as needed.  */
 369   if (buf[0] == 0xcf)
 370     {
 371       /* Extract the register list for the movm instruction.  */
 372       status = read_memory_nobpt (addr + 1, buf, 1);
 373       movm_args = *buf;
 374
 375       addr += 2;
 376
 377       /* Quit now if we're beyond the stop point.  */
 378       if (addr >= stop)
 379         {
 380           /* Fix fi->frame since it's bogus at this point.  */
 381           if (fi && fi->next == NULL)
 382             fi->frame = read_sp ();
 383
 384           /* Note if/where callee saved registers were saved.  */
 385           set_movm_offsets (fi, movm_args);
 386           return addr;
 387         }
 388
 389       /* Get the next two bytes so the prologue scan can continue.  */
 390       status = read_memory_nobpt (addr, buf, 2);
 391       if (status != 0)
 392         {
 393           /* Fix fi->frame since it's bogus at this point.  */
 394           if (fi && fi->next == NULL)
 395             fi->frame = read_sp ();
 396
 397           /* Note if/where callee saved registers were saved.  */
 398           set_movm_offsets (fi, movm_args);
 399           return addr;
 400         }
 401     }
 402
 403   /* Now see if we set up a frame pointer via "mov sp,a3" */
 404   if (buf[0] == 0x3f)
 405     {
 406       addr += 1;
 407
 408       /* The frame pointer is now valid.  */
 409       if (fi)
 410         {
 411           fi->extra_info->status |= MY_FRAME_IN_FP;
 412           fi->extra_info->status &= ~MY_FRAME_IN_SP;
 413         }
 414
 415       /* Quit now if we're beyond the stop point.  */
 416       if (addr >= stop)
 417         {
 418           /* Fix fi->frame if it's bogus at this point.  */
 419           fix_frame_pointer (fi, 0);
 420
 421           /* Note if/where callee saved registers were saved.  */
 422           set_movm_offsets (fi, movm_args);
 423           return addr;
 424         }
 425
 426       /* Get two more bytes so scanning can continue.  */
 427       status = read_memory_nobpt (addr, buf, 2);
 428       if (status != 0)
 429         {
 430           /* Fix fi->frame if it's bogus at this point.  */
 431           fix_frame_pointer (fi, 0);
 432
 433           /* Note if/where callee saved registers were saved.  */
 434           set_movm_offsets (fi, movm_args);
 435           return addr;
 436         }
 437     }
 438
 439   /* Next we should allocate the local frame.  No more prologue insns
 440      are found after allocating the local frame.
 441
 442      Search for add imm8,sp (0xf8feXX)
 443      or add imm16,sp (0xfafeXXXX)
 444      or add imm32,sp (0xfcfeXXXXXXXX).
 445
 446      If none of the above was found, then this prologue has no
 447      additional stack.  */
 448
 449   status = read_memory_nobpt (addr, buf, 2);
 450   if (status != 0)
 451     {
 452       /* Fix fi->frame if it's bogus at this point.  */
 453       fix_frame_pointer (fi, 0);
 454
 455       /* Note if/where callee saved registers were saved.  */
 456       set_movm_offsets (fi, movm_args);
 457       return addr;
 458     }
 459
 460   imm_size = 0;
 461   if (buf[0] == 0xf8 && buf[1] == 0xfe)
 462     imm_size = 1;
 463   else if (buf[0] == 0xfa && buf[1] == 0xfe)
 464     imm_size = 2;
 465   else if (buf[0] == 0xfc && buf[1] == 0xfe)
 466     imm_size = 4;
 467
 468   if (imm_size != 0)
 469     {
 470       /* Suck in imm_size more bytes, they'll hold the size of the
 471          current frame.  */
 472       status = read_memory_nobpt (addr + 2, buf, imm_size);
 473       if (status != 0)
 474         {
 475           /* Fix fi->frame if it's bogus at this point.  */
 476           fix_frame_pointer (fi, 0);
 477
 478           /* Note if/where callee saved registers were saved.  */
 479           set_movm_offsets (fi, movm_args);
 480           return addr;
 481         }
 482
 483       /* Note the size of the stack in the frame info structure.  */
 484       stack_size = extract_signed_integer (buf, imm_size);
 485       if (fi)
 486         fi->extra_info->stack_size = stack_size;
 487
 488       /* We just consumed 2 + imm_size bytes.  */
 489       addr += 2 + imm_size;
 490
 491       /* No more prologue insns follow, so begin preparation to return.  */
 492       /* Fix fi->frame if it's bogus at this point.  */
 493       fix_frame_pointer (fi, stack_size);
 494
 495       /* Note if/where callee saved registers were saved.  */
 496       set_movm_offsets (fi, movm_args);
 497       return addr;
 498     }
 499
 500   /* We never found an insn which allocates local stack space, regardless
 501      this is the end of the prologue.  */
 502   /* Fix fi->frame if it's bogus at this point.  */
 503   fix_frame_pointer (fi, 0);
 504
 505   /* Note if/where callee saved registers were saved.  */
 506   set_movm_offsets (fi, movm_args);
 507   return addr;
 508 }
 509
 510 /* Function: frame_chain
 511    Figure out and return the caller's frame pointer given current
 512    frame_info struct.
 513
 514    We don't handle dummy frames yet but we would probably just return the
 515    stack pointer that was in use at the time the function call was made?  */
 516
 517 CORE_ADDR
 518 mn10300_frame_chain (fi)
 519      struct frame_info *fi;
 520 {
 521   struct frame_info *dummy;
 522   /* Walk through the prologue to determine the stack size,
 523      location of saved registers, end of the prologue, etc.  */
 524   if (fi->extra_info->status == 0)
 525     mn10300_analyze_prologue (fi, (CORE_ADDR) 0);
 526
 527   /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES.  */
 528   if (fi->extra_info->status & NO_MORE_FRAMES)
 529     return 0;
 530
 531   /* Now that we've analyzed our prologue, determine the frame
 532      pointer for our caller.
 533
 534      If our caller has a frame pointer, then we need to
 535      find the entry value of $a3 to our function.
 536
 537      If fsr.regs[A3_REGNUM] is nonzero, then it's at the memory
 538      location pointed to by fsr.regs[A3_REGNUM].
 539
 540      Else it's still in $a3.
 541
 542      If our caller does not have a frame pointer, then his
 543      frame base is fi->frame + -caller's stack size.  */
 544
 545   /* The easiest way to get that info is to analyze our caller's frame.
 546      So we set up a dummy frame and call mn10300_analyze_prologue to
 547      find stuff for us.  */
 548   dummy = analyze_dummy_frame (FRAME_SAVED_PC (fi), fi->frame);
 549
 550   if (dummy->extra_info->status & MY_FRAME_IN_FP)
 551     {
 552       /* Our caller has a frame pointer.  So find the frame in $a3 or
 553          in the stack.  */
 554       if (fi->saved_regs[A3_REGNUM])
 555         return (read_memory_integer (fi->saved_regs[A3_REGNUM], REGISTER_SIZE));
 556       else
 557         return read_register (A3_REGNUM);
 558     }
 559   else
 560     {
 561       int adjust = 0;
 562
 563       adjust += (fi->saved_regs[D2_REGNUM] ? 4 : 0);
 564       adjust += (fi->saved_regs[D3_REGNUM] ? 4 : 0);
 565       adjust += (fi->saved_regs[A2_REGNUM] ? 4 : 0);
 566       adjust += (fi->saved_regs[A3_REGNUM] ? 4 : 0);
 567       if (am33_mode)
 568         {
 569           adjust += (fi->saved_regs[E0_REGNUM + 5] ? 4 : 0);
 570           adjust += (fi->saved_regs[E0_REGNUM + 4] ? 4 : 0);
 571           adjust += (fi->saved_regs[E0_REGNUM + 3] ? 4 : 0);
 572           adjust += (fi->saved_regs[E0_REGNUM + 2] ? 4 : 0);
 573         }
 574
 575       /* Our caller does not have a frame pointer.  So his frame starts
 576          at the base of our frame (fi->frame) + register save space
 577          + <his size>.  */
 578       return fi->frame + adjust + -dummy->extra_info->stack_size;
 579     }
 580 }
 581
 582 /* Function: skip_prologue
 583    Return the address of the first inst past the prologue of the function.  */
 584
 585 CORE_ADDR
 586 mn10300_skip_prologue (pc)
 587      CORE_ADDR pc;
 588 {
 589   /* We used to check the debug symbols, but that can lose if
 590      we have a null prologue.  */
 591   return mn10300_analyze_prologue (NULL, pc);
 592 }
 593
 594
 595 /* Function: pop_frame
 596    This routine gets called when either the user uses the `return'
 597    command, or the call dummy breakpoint gets hit.  */
 598
 599 void
 600 mn10300_pop_frame (frame)
 601      struct frame_info *frame;
 602 {
 603   int regnum;
 604
 605   if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
 606     generic_pop_dummy_frame ();
 607   else
 608     {
 609       write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
 610
 611       /* Restore any saved registers.  */
 612       for (regnum = 0; regnum < NUM_REGS; regnum++)
 613         if (frame->saved_regs[regnum] != 0)
 614           {
 615             ULONGEST value;
 616
 617             value = read_memory_unsigned_integer (frame->saved_regs[regnum],
 618                                                 REGISTER_RAW_SIZE (regnum));
 619             write_register (regnum, value);
 620           }
 621
 622       /* Actually cut back the stack.  */
 623       write_register (SP_REGNUM, FRAME_FP (frame));
 624
 625       /* Don't we need to set the PC?!?  XXX FIXME.  */
 626     }
 627
 628   /* Throw away any cached frame information.  */
 629   flush_cached_frames ();
 630 }
 631
 632 /* Function: push_arguments
 633    Setup arguments for a call to the target.  Arguments go in
 634    order on the stack.  */
 635
 636 CORE_ADDR
 637 mn10300_push_arguments (nargs, args, sp, struct_return, struct_addr)
 638      int nargs;
 639      value_ptr *args;
 640      CORE_ADDR sp;
 641      unsigned char struct_return;
 642      CORE_ADDR struct_addr;
 643 {
 644   int argnum = 0;
 645   int len = 0;
 646   int stack_offset = 0;
 647   int regsused = struct_return ? 1 : 0;
 648
 649   /* This should be a nop, but align the stack just in case something
 650      went wrong.  Stacks are four byte aligned on the mn10300.  */
 651   sp &= ~3;
 652
 653   /* Now make space on the stack for the args.
 654
 655      XXX This doesn't appear to handle pass-by-invisible reference
 656      arguments.  */
 657   for (argnum = 0; argnum < nargs; argnum++)
 658     {
 659       int arg_length = (TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3;
 660
 661       while (regsused < 2 && arg_length > 0)
 662         {
 663           regsused++;
 664           arg_length -= 4;
 665         }
 666       len += arg_length;
 667     }
 668
 669   /* Allocate stack space.  */
 670   sp -= len;
 671
 672   regsused = struct_return ? 1 : 0;
 673   /* Push all arguments onto the stack. */
 674   for (argnum = 0; argnum < nargs; argnum++)
 675     {
 676       int len;
 677       char *val;
 678
 679       /* XXX Check this.  What about UNIONS?  */
 680       if (TYPE_CODE (VALUE_TYPE (*args)) == TYPE_CODE_STRUCT
 681           && TYPE_LENGTH (VALUE_TYPE (*args)) > 8)
 682         {
 683           /* XXX Wrong, we want a pointer to this argument.  */
 684           len = TYPE_LENGTH (VALUE_TYPE (*args));
 685           val = (char *) VALUE_CONTENTS (*args);
 686         }
 687       else
 688         {
 689           len = TYPE_LENGTH (VALUE_TYPE (*args));
 690           val = (char *) VALUE_CONTENTS (*args);
 691         }
 692
 693       while (regsused < 2 && len > 0)
 694         {
 695           write_register (regsused, extract_unsigned_integer (val, 4));
 696           val += 4;
 697           len -= 4;
 698           regsused++;
 699         }
 700
 701       while (len > 0)
 702         {
 703           write_memory (sp + stack_offset, val, 4);
 704           len -= 4;
 705           val += 4;
 706           stack_offset += 4;
 707         }
 708
 709       args++;
 710     }
 711
 712   /* Make space for the flushback area.  */
 713   sp -= 8;
 714   return sp;
 715 }
 716
 717 /* Function: push_return_address (pc)
 718    Set up the return address for the inferior function call.
 719    Needed for targets where we don't actually execute a JSR/BSR instruction */
 720
 721 CORE_ADDR
 722 mn10300_push_return_address (pc, sp)
 723      CORE_ADDR pc;
 724      CORE_ADDR sp;
 725 {
 726   unsigned char buf[4];
 727
 728   store_unsigned_integer (buf, 4, CALL_DUMMY_ADDRESS ());
 729   write_memory (sp - 4, buf, 4);
 730   return sp - 4;
 731 }
 732
 733 /* Function: store_struct_return (addr,sp)
 734    Store the structure value return address for an inferior function
 735    call.  */
 736
 737 CORE_ADDR
 738 mn10300_store_struct_return (addr, sp)
 739      CORE_ADDR addr;
 740      CORE_ADDR sp;
 741 {
 742   /* The structure return address is passed as the first argument.  */
 743   write_register (0, addr);
 744   return sp;
 745 }
 746
 747 /* Function: frame_saved_pc
 748    Find the caller of this frame.  We do this by seeing if RP_REGNUM
 749    is saved in the stack anywhere, otherwise we get it from the
 750    registers.  If the inner frame is a dummy frame, return its PC
 751    instead of RP, because that's where "caller" of the dummy-frame
 752    will be found.  */
 753
 754 CORE_ADDR
 755 mn10300_frame_saved_pc (fi)
 756      struct frame_info *fi;
 757 {
 758   int adjust = 0;
 759
 760   adjust += (fi->saved_regs[D2_REGNUM] ? 4 : 0);
 761   adjust += (fi->saved_regs[D3_REGNUM] ? 4 : 0);
 762   adjust += (fi->saved_regs[A2_REGNUM] ? 4 : 0);
 763   adjust += (fi->saved_regs[A3_REGNUM] ? 4 : 0);
 764   if (am33_mode)
 765     {
 766       adjust += (fi->saved_regs[E0_REGNUM + 5] ? 4 : 0);
 767       adjust += (fi->saved_regs[E0_REGNUM + 4] ? 4 : 0);
 768       adjust += (fi->saved_regs[E0_REGNUM + 3] ? 4 : 0);
 769       adjust += (fi->saved_regs[E0_REGNUM + 2] ? 4 : 0);
 770     }
 771
 772   return (read_memory_integer (fi->frame + adjust, REGISTER_SIZE));
 773 }
 774
 775 /* Function: mn10300_init_extra_frame_info
 776    Setup the frame's frame pointer, pc, and frame addresses for saved
 777    registers.  Most of the work is done in mn10300_analyze_prologue().
 778
 779    Note that when we are called for the last frame (currently active frame),
 780    that fi->pc and fi->frame will already be setup.  However, fi->frame will
 781    be valid only if this routine uses FP.  For previous frames, fi-frame will
 782    always be correct.  mn10300_analyze_prologue will fix fi->frame if
 783    it's not valid.
 784
 785    We can be called with the PC in the call dummy under two circumstances.
 786    First, during normal backtracing, second, while figuring out the frame
 787    pointer just prior to calling the target function (see run_stack_dummy).  */
 788
 789 void
 790 mn10300_init_extra_frame_info (fi)
 791      struct frame_info *fi;
 792 {
 793   if (fi->next)
 794     fi->pc = FRAME_SAVED_PC (fi->next);
 795
 796   frame_saved_regs_zalloc (fi);
 797   fi->extra_info = (struct frame_extra_info *)
 798     frame_obstack_alloc (sizeof (struct frame_extra_info));
 799
 800   fi->extra_info->status = 0;
 801   fi->extra_info->stack_size = 0;
 802
 803   mn10300_analyze_prologue (fi, 0);
 804 }
 805
 806 /* Function: mn10300_virtual_frame_pointer
 807    Return the register that the function uses for a frame pointer,
 808    plus any necessary offset to be applied to the register before
 809    any frame pointer offsets.  */
 810
 811 void
 812 mn10300_virtual_frame_pointer (pc, reg, offset)
 813      CORE_ADDR pc;
 814      long *reg;
 815      long *offset;
 816 {
 817   struct frame_info *dummy = analyze_dummy_frame (pc, 0);
 818   /* Set up a dummy frame_info, Analyze the prolog and fill in the
 819      extra info.  */
 820   /* Results will tell us which type of frame it uses.  */
 821   if (dummy->extra_info->status & MY_FRAME_IN_SP)
 822     {
 823       *reg = SP_REGNUM;
 824       *offset = -(dummy->extra_info->stack_size);
 825     }
 826   else
 827     {
 828       *reg = A3_REGNUM;
 829       *offset = 0;
 830     }
 831 }
 832
 833 /* This can be made more generic later.  */
 834 static void
 835 set_machine_hook (filename)
 836      char *filename;
 837 {
 838   int i;
 839
 840   if (bfd_get_mach (exec_bfd) == bfd_mach_mn10300
 841       || bfd_get_mach (exec_bfd) == 0)
 842     {
 843       mn10300_register_names = mn10300_generic_register_names;
 844     }
 845
 846   am33_mode = 0;
 847   if (bfd_get_mach (exec_bfd) == bfd_mach_am33)
 848     {
 849
 850       mn10300_register_names = am33_register_names;
 851       am33_mode = 1;
 852     }
 853 }
 854
 855 void
 856 _initialize_mn10300_tdep ()
 857 {
 858 /*  printf("_initialize_mn10300_tdep\n"); */
 859
 860   tm_print_insn = print_insn_mn10300;
 861
 862   specify_exec_file_hook (set_machine_hook);
 863 }