gdb/mn10300-tdep.c

   1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
   2    Copyright 1996, 1997, 1998, 2000 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 (struct frame_info *fi,
  34                                            CORE_ADDR pc);
  35
  36 /* mn10300 private data */
  37 struct gdbarch_tdep
  38 {
  39   int am33_mode;
  40 #define AM33_MODE (gdbarch_tdep (current_gdbarch)->am33_mode)
  41 };
  42
  43 /* Additional info used by the frame */
  44
  45 struct frame_extra_info
  46   {
  47     int status;
  48     int stack_size;
  49   };
  50
  51
  52 static char *
  53 register_name (int reg, char **regs, long sizeof_regs)
  54 {
  55   if (reg < 0 || reg >= sizeof_regs / sizeof (regs[0]))
  56     return NULL;
  57   else
  58     return regs[reg];
  59 }
  60
  61 static char *
  62 mn10300_generic_register_name (int reg)
  63 {
  64   static char *regs[] =
  65   { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
  66     "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
  67     "", "", "", "", "", "", "", "",
  68     "", "", "", "", "", "", "", "fp"
  69   };
  70   return register_name (reg, regs, sizeof regs);
  71 }
  72
  73
  74 static char *
  75 am33_register_name (int reg)
  76 {
  77   static char *regs[] =
  78   { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
  79     "sp", "pc", "mdr", "psw", "lir", "lar", "",
  80     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
  81     "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
  82   };
  83   return register_name (reg, regs, sizeof regs);
  84 }
  85
  86 CORE_ADDR
  87 mn10300_saved_pc_after_call (struct frame_info *fi)
  88 {
  89   return read_memory_integer (read_register (SP_REGNUM), 4);
  90 }
  91
  92 void
  93 mn10300_extract_return_value (struct type *type, char *regbuf, char *valbuf)
  94 {
  95   if (TYPE_CODE (type) == TYPE_CODE_PTR)
  96     memcpy (valbuf, regbuf + REGISTER_BYTE (4), TYPE_LENGTH (type));
  97   else
  98     memcpy (valbuf, regbuf + REGISTER_BYTE (0), TYPE_LENGTH (type));
  99 }
 100
 101 CORE_ADDR
 102 mn10300_extract_struct_value_address (char *regbuf)
 103 {
 104   return extract_address (regbuf + REGISTER_BYTE (4),
 105                           REGISTER_RAW_SIZE (4));
 106 }
 107
 108 void
 109 mn10300_store_return_value (struct type *type, char *valbuf)
 110 {
 111   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 112     write_register_bytes (REGISTER_BYTE (4), valbuf, TYPE_LENGTH (type));
 113   else
 114     write_register_bytes (REGISTER_BYTE (0), valbuf, TYPE_LENGTH (type));
 115 }
 116
 117 static struct frame_info *analyze_dummy_frame (CORE_ADDR, CORE_ADDR);
 118 static struct frame_info *
 119 analyze_dummy_frame (CORE_ADDR pc, CORE_ADDR frame)
 120 {
 121   static struct frame_info *dummy = NULL;
 122   if (dummy == NULL)
 123     {
 124       dummy = xmalloc (sizeof (struct frame_info));
 125       dummy->saved_regs = xmalloc (SIZEOF_FRAME_SAVED_REGS);
 126       dummy->extra_info = xmalloc (sizeof (struct frame_extra_info));
 127     }
 128   dummy->next = NULL;
 129   dummy->prev = NULL;
 130   dummy->pc = pc;
 131   dummy->frame = frame;
 132   dummy->extra_info->status = 0;
 133   dummy->extra_info->stack_size = 0;
 134   memset (dummy->saved_regs, '\000', SIZEOF_FRAME_SAVED_REGS);
 135   mn10300_analyze_prologue (dummy, 0);
 136   return dummy;
 137 }
 138
 139 /* Values for frame_info.status */
 140
 141 #define MY_FRAME_IN_SP 0x1
 142 #define MY_FRAME_IN_FP 0x2
 143 #define NO_MORE_FRAMES 0x4
 144
 145
 146 /* Should call_function allocate stack space for a struct return?  */
 147 int
 148 mn10300_use_struct_convention (int gcc_p, struct type *type)
 149 {
 150   return (TYPE_NFIELDS (type) > 1 || TYPE_LENGTH (type) > 8);
 151 }
 152
 153 /* The breakpoint instruction must be the same size as the smallest
 154    instruction in the instruction set.
 155
 156    The Matsushita mn10x00 processors have single byte instructions
 157    so we need a single byte breakpoint.  Matsushita hasn't defined
 158    one, so we defined it ourselves.  */
 159
 160 unsigned char *
 161 mn10300_breakpoint_from_pc (CORE_ADDR *bp_addr, int *bp_size)
 162 {
 163   static char breakpoint[] =
 164   {0xff};
 165   *bp_size = 1;
 166   return breakpoint;
 167 }
 168
 169
 170 /* Fix fi->frame if it's bogus at this point.  This is a helper
 171    function for mn10300_analyze_prologue. */
 172
 173 static void
 174 fix_frame_pointer (struct frame_info *fi, int stack_size)
 175 {
 176   if (fi && fi->next == NULL)
 177     {
 178       if (fi->extra_info->status & MY_FRAME_IN_SP)
 179         fi->frame = read_sp () - stack_size;
 180       else if (fi->extra_info->status & MY_FRAME_IN_FP)
 181         fi->frame = read_register (A3_REGNUM);
 182     }
 183 }
 184
 185
 186 /* Set offsets of registers saved by movm instruction.
 187    This is a helper function for mn10300_analyze_prologue.  */
 188
 189 static void
 190 set_movm_offsets (struct frame_info *fi, int movm_args)
 191 {
 192   int offset = 0;
 193
 194   if (fi == NULL || movm_args == 0)
 195     return;
 196
 197   if (movm_args & 0x10)
 198     {
 199       fi->saved_regs[A3_REGNUM] = fi->frame + offset;
 200       offset += 4;
 201     }
 202   if (movm_args & 0x20)
 203     {
 204       fi->saved_regs[A2_REGNUM] = fi->frame + offset;
 205       offset += 4;
 206     }
 207   if (movm_args & 0x40)
 208     {
 209       fi->saved_regs[D3_REGNUM] = fi->frame + offset;
 210       offset += 4;
 211     }
 212   if (movm_args & 0x80)
 213     {
 214       fi->saved_regs[D2_REGNUM] = fi->frame + offset;
 215       offset += 4;
 216     }
 217   if (AM33_MODE && movm_args & 0x02)
 218     {
 219       fi->saved_regs[E0_REGNUM + 5] = fi->frame + offset;
 220       fi->saved_regs[E0_REGNUM + 4] = fi->frame + offset + 4;
 221       fi->saved_regs[E0_REGNUM + 3] = fi->frame + offset + 8;
 222       fi->saved_regs[E0_REGNUM + 2] = fi->frame + offset + 12;
 223     }
 224 }
 225
 226
 227 /* The main purpose of this file is dealing with prologues to extract
 228    information about stack frames and saved registers.
 229
 230    For reference here's how prologues look on the mn10300:
 231
 232    With frame pointer:
 233    movm [d2,d3,a2,a3],sp
 234    mov sp,a3
 235    add <size>,sp
 236
 237    Without frame pointer:
 238    movm [d2,d3,a2,a3],sp (if needed)
 239    add <size>,sp
 240
 241    One day we might keep the stack pointer constant, that won't
 242    change the code for prologues, but it will make the frame
 243    pointerless case much more common.  */
 244
 245 /* Analyze the prologue to determine where registers are saved,
 246    the end of the prologue, etc etc.  Return the end of the prologue
 247    scanned.
 248
 249    We store into FI (if non-null) several tidbits of information:
 250
 251    * stack_size -- size of this stack frame.  Note that if we stop in
 252    certain parts of the prologue/epilogue we may claim the size of the
 253    current frame is zero.  This happens when the current frame has
 254    not been allocated yet or has already been deallocated.
 255
 256    * fsr -- Addresses of registers saved in the stack by this frame.
 257
 258    * status -- A (relatively) generic status indicator.  It's a bitmask
 259    with the following bits:
 260
 261    MY_FRAME_IN_SP: The base of the current frame is actually in
 262    the stack pointer.  This can happen for frame pointerless
 263    functions, or cases where we're stopped in the prologue/epilogue
 264    itself.  For these cases mn10300_analyze_prologue will need up
 265    update fi->frame before returning or analyzing the register
 266    save instructions.
 267
 268    MY_FRAME_IN_FP: The base of the current frame is in the
 269    frame pointer register ($a2).
 270
 271    NO_MORE_FRAMES: Set this if the current frame is "start" or
 272    if the first instruction looks like mov <imm>,sp.  This tells
 273    frame chain to not bother trying to unwind past this frame.  */
 274
 275 static CORE_ADDR
 276 mn10300_analyze_prologue (struct frame_info *fi, 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 (struct frame_info *fi)
 519 {
 520   struct frame_info *dummy;
 521   /* Walk through the prologue to determine the stack size,
 522      location of saved registers, end of the prologue, etc.  */
 523   if (fi->extra_info->status == 0)
 524     mn10300_analyze_prologue (fi, (CORE_ADDR) 0);
 525
 526   /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES.  */
 527   if (fi->extra_info->status & NO_MORE_FRAMES)
 528     return 0;
 529
 530   /* Now that we've analyzed our prologue, determine the frame
 531      pointer for our caller.
 532
 533      If our caller has a frame pointer, then we need to
 534      find the entry value of $a3 to our function.
 535
 536      If fsr.regs[A3_REGNUM] is nonzero, then it's at the memory
 537      location pointed to by fsr.regs[A3_REGNUM].
 538
 539      Else it's still in $a3.
 540
 541      If our caller does not have a frame pointer, then his
 542      frame base is fi->frame + -caller's stack size.  */
 543
 544   /* The easiest way to get that info is to analyze our caller's frame.
 545      So we set up a dummy frame and call mn10300_analyze_prologue to
 546      find stuff for us.  */
 547   dummy = analyze_dummy_frame (FRAME_SAVED_PC (fi), fi->frame);
 548
 549   if (dummy->extra_info->status & MY_FRAME_IN_FP)
 550     {
 551       /* Our caller has a frame pointer.  So find the frame in $a3 or
 552          in the stack.  */
 553       if (fi->saved_regs[A3_REGNUM])
 554         return (read_memory_integer (fi->saved_regs[A3_REGNUM], REGISTER_SIZE));
 555       else
 556         return read_register (A3_REGNUM);
 557     }
 558   else
 559     {
 560       int adjust = 0;
 561
 562       adjust += (fi->saved_regs[D2_REGNUM] ? 4 : 0);
 563       adjust += (fi->saved_regs[D3_REGNUM] ? 4 : 0);
 564       adjust += (fi->saved_regs[A2_REGNUM] ? 4 : 0);
 565       adjust += (fi->saved_regs[A3_REGNUM] ? 4 : 0);
 566       if (AM33_MODE)
 567         {
 568           adjust += (fi->saved_regs[E0_REGNUM + 5] ? 4 : 0);
 569           adjust += (fi->saved_regs[E0_REGNUM + 4] ? 4 : 0);
 570           adjust += (fi->saved_regs[E0_REGNUM + 3] ? 4 : 0);
 571           adjust += (fi->saved_regs[E0_REGNUM + 2] ? 4 : 0);
 572         }
 573
 574       /* Our caller does not have a frame pointer.  So his frame starts
 575          at the base of our frame (fi->frame) + register save space
 576          + <his size>.  */
 577       return fi->frame + adjust + -dummy->extra_info->stack_size;
 578     }
 579 }
 580
 581 /* Function: skip_prologue
 582    Return the address of the first inst past the prologue of the function.  */
 583
 584 CORE_ADDR
 585 mn10300_skip_prologue (CORE_ADDR pc)
 586 {
 587   /* We used to check the debug symbols, but that can lose if
 588      we have a null prologue.  */
 589   return mn10300_analyze_prologue (NULL, pc);
 590 }
 591
 592
 593 /* Function: pop_frame
 594    This routine gets called when either the user uses the `return'
 595    command, or the call dummy breakpoint gets hit.  */
 596
 597 void
 598 mn10300_pop_frame (struct frame_info *frame)
 599 {
 600   int regnum;
 601
 602   if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
 603     generic_pop_dummy_frame ();
 604   else
 605     {
 606       write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
 607
 608       /* Restore any saved registers.  */
 609       for (regnum = 0; regnum < NUM_REGS; regnum++)
 610         if (frame->saved_regs[regnum] != 0)
 611           {
 612             ULONGEST value;
 613
 614             value = read_memory_unsigned_integer (frame->saved_regs[regnum],
 615                                                 REGISTER_RAW_SIZE (regnum));
 616             write_register (regnum, value);
 617           }
 618
 619       /* Actually cut back the stack.  */
 620       write_register (SP_REGNUM, FRAME_FP (frame));
 621
 622       /* Don't we need to set the PC?!?  XXX FIXME.  */
 623     }
 624
 625   /* Throw away any cached frame information.  */
 626   flush_cached_frames ();
 627 }
 628
 629 /* Function: push_arguments
 630    Setup arguments for a call to the target.  Arguments go in
 631    order on the stack.  */
 632
 633 CORE_ADDR
 634 mn10300_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 635                         int struct_return, CORE_ADDR struct_addr)
 636 {
 637   int argnum = 0;
 638   int len = 0;
 639   int stack_offset = 0;
 640   int regsused = struct_return ? 1 : 0;
 641
 642   /* This should be a nop, but align the stack just in case something
 643      went wrong.  Stacks are four byte aligned on the mn10300.  */
 644   sp &= ~3;
 645
 646   /* Now make space on the stack for the args.
 647
 648      XXX This doesn't appear to handle pass-by-invisible reference
 649      arguments.  */
 650   for (argnum = 0; argnum < nargs; argnum++)
 651     {
 652       int arg_length = (TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3;
 653
 654       while (regsused < 2 && arg_length > 0)
 655         {
 656           regsused++;
 657           arg_length -= 4;
 658         }
 659       len += arg_length;
 660     }
 661
 662   /* Allocate stack space.  */
 663   sp -= len;
 664
 665   regsused = struct_return ? 1 : 0;
 666   /* Push all arguments onto the stack. */
 667   for (argnum = 0; argnum < nargs; argnum++)
 668     {
 669       int len;
 670       char *val;
 671
 672       /* XXX Check this.  What about UNIONS?  */
 673       if (TYPE_CODE (VALUE_TYPE (*args)) == TYPE_CODE_STRUCT
 674           && TYPE_LENGTH (VALUE_TYPE (*args)) > 8)
 675         {
 676           /* XXX Wrong, we want a pointer to this argument.  */
 677           len = TYPE_LENGTH (VALUE_TYPE (*args));
 678           val = (char *) VALUE_CONTENTS (*args);
 679         }
 680       else
 681         {
 682           len = TYPE_LENGTH (VALUE_TYPE (*args));
 683           val = (char *) VALUE_CONTENTS (*args);
 684         }
 685
 686       while (regsused < 2 && len > 0)
 687         {
 688           write_register (regsused, extract_unsigned_integer (val, 4));
 689           val += 4;
 690           len -= 4;
 691           regsused++;
 692         }
 693
 694       while (len > 0)
 695         {
 696           write_memory (sp + stack_offset, val, 4);
 697           len -= 4;
 698           val += 4;
 699           stack_offset += 4;
 700         }
 701
 702       args++;
 703     }
 704
 705   /* Make space for the flushback area.  */
 706   sp -= 8;
 707   return sp;
 708 }
 709
 710 /* Function: push_return_address (pc)
 711    Set up the return address for the inferior function call.
 712    Needed for targets where we don't actually execute a JSR/BSR instruction */
 713
 714 CORE_ADDR
 715 mn10300_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
 716 {
 717   unsigned char buf[4];
 718
 719   store_unsigned_integer (buf, 4, CALL_DUMMY_ADDRESS ());
 720   write_memory (sp - 4, buf, 4);
 721   return sp - 4;
 722 }
 723
 724 /* Function: store_struct_return (addr,sp)
 725    Store the structure value return address for an inferior function
 726    call.  */
 727
 728 CORE_ADDR
 729 mn10300_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
 730 {
 731   /* The structure return address is passed as the first argument.  */
 732   write_register (0, addr);
 733   return sp;
 734 }
 735
 736 /* Function: frame_saved_pc
 737    Find the caller of this frame.  We do this by seeing if RP_REGNUM
 738    is saved in the stack anywhere, otherwise we get it from the
 739    registers.  If the inner frame is a dummy frame, return its PC
 740    instead of RP, because that's where "caller" of the dummy-frame
 741    will be found.  */
 742
 743 CORE_ADDR
 744 mn10300_frame_saved_pc (struct frame_info *fi)
 745 {
 746   int adjust = 0;
 747
 748   adjust += (fi->saved_regs[D2_REGNUM] ? 4 : 0);
 749   adjust += (fi->saved_regs[D3_REGNUM] ? 4 : 0);
 750   adjust += (fi->saved_regs[A2_REGNUM] ? 4 : 0);
 751   adjust += (fi->saved_regs[A3_REGNUM] ? 4 : 0);
 752   if (AM33_MODE)
 753     {
 754       adjust += (fi->saved_regs[E0_REGNUM + 5] ? 4 : 0);
 755       adjust += (fi->saved_regs[E0_REGNUM + 4] ? 4 : 0);
 756       adjust += (fi->saved_regs[E0_REGNUM + 3] ? 4 : 0);
 757       adjust += (fi->saved_regs[E0_REGNUM + 2] ? 4 : 0);
 758     }
 759
 760   return (read_memory_integer (fi->frame + adjust, REGISTER_SIZE));
 761 }
 762
 763 /* Function: mn10300_init_extra_frame_info
 764    Setup the frame's frame pointer, pc, and frame addresses for saved
 765    registers.  Most of the work is done in mn10300_analyze_prologue().
 766
 767    Note that when we are called for the last frame (currently active frame),
 768    that fi->pc and fi->frame will already be setup.  However, fi->frame will
 769    be valid only if this routine uses FP.  For previous frames, fi-frame will
 770    always be correct.  mn10300_analyze_prologue will fix fi->frame if
 771    it's not valid.
 772
 773    We can be called with the PC in the call dummy under two circumstances.
 774    First, during normal backtracing, second, while figuring out the frame
 775    pointer just prior to calling the target function (see run_stack_dummy).  */
 776
 777 void
 778 mn10300_init_extra_frame_info (struct frame_info *fi)
 779 {
 780   if (fi->next)
 781     fi->pc = FRAME_SAVED_PC (fi->next);
 782
 783   frame_saved_regs_zalloc (fi);
 784   fi->extra_info = (struct frame_extra_info *)
 785     frame_obstack_alloc (sizeof (struct frame_extra_info));
 786
 787   fi->extra_info->status = 0;
 788   fi->extra_info->stack_size = 0;
 789
 790   mn10300_analyze_prologue (fi, 0);
 791 }
 792
 793 /* Function: mn10300_virtual_frame_pointer
 794    Return the register that the function uses for a frame pointer,
 795    plus any necessary offset to be applied to the register before
 796    any frame pointer offsets.  */
 797
 798 void
 799 mn10300_virtual_frame_pointer (CORE_ADDR pc, long *reg, long *offset)
 800 {
 801   struct frame_info *dummy = analyze_dummy_frame (pc, 0);
 802   /* Set up a dummy frame_info, Analyze the prolog and fill in the
 803      extra info.  */
 804   /* Results will tell us which type of frame it uses.  */
 805   if (dummy->extra_info->status & MY_FRAME_IN_SP)
 806     {
 807       *reg = SP_REGNUM;
 808       *offset = -(dummy->extra_info->stack_size);
 809     }
 810   else
 811     {
 812       *reg = A3_REGNUM;
 813       *offset = 0;
 814     }
 815 }
 816
 817 static int
 818 mn10300_reg_struct_has_addr (int gcc_p, struct type *type)
 819 {
 820   return (TYPE_LENGTH (type) > 8);
 821 }
 822
 823 static struct type *
 824 mn10300_register_virtual_type (int reg)
 825 {
 826   return builtin_type_int;
 827 }
 828
 829 static int
 830 mn10300_register_byte (int reg)
 831 {
 832   return (reg * 4);
 833 }
 834
 835 static int
 836 mn10300_register_virtual_size (int reg)
 837 {
 838   return 4;
 839 }
 840
 841 static int
 842 mn10300_register_raw_size (int reg)
 843 {
 844   return 4;
 845 }
 846
 847 static void
 848 mn10300_print_register (const char *name, int regnum, int reg_width)
 849 {
 850   char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
 851
 852   if (reg_width)
 853     printf_filtered ("%*s: ", reg_width, name);
 854   else
 855     printf_filtered ("%s: ", name);
 856
 857   /* Get the data */
 858   if (read_relative_register_raw_bytes (regnum, raw_buffer))
 859     {
 860       printf_filtered ("[invalid]");
 861       return;
 862     }
 863   else
 864     {
 865       int byte;
 866       if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 867         {
 868           for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
 869                byte < REGISTER_RAW_SIZE (regnum);
 870                byte++)
 871             printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
 872         }
 873       else
 874         {
 875           for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
 876                byte >= 0;
 877                byte--)
 878             printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
 879         }
 880     }
 881 }
 882
 883 static void
 884 mn10300_do_registers_info (int regnum, int fpregs)
 885 {
 886   if (regnum >= 0)
 887     {
 888       const char *name = REGISTER_NAME (regnum);
 889       if (name == NULL || name[0] == '\0')
 890         error ("Not a valid register for the current processor type");
 891       mn10300_print_register (name, regnum, 0);
 892       printf_filtered ("\n");
 893     }
 894   else
 895     {
 896       /* print registers in an array 4x8 */
 897       int r;
 898       int reg;
 899       const int nr_in_row = 4;
 900       const int reg_width = 4;
 901       for (r = 0; r < NUM_REGS; r += nr_in_row)
 902         {
 903           int c;
 904           int printing = 0;
 905           int padding = 0;
 906           for (c = r; c < r + nr_in_row; c++)
 907             {
 908               const char *name = REGISTER_NAME (c);
 909               if (name != NULL && *name != '\0')
 910                 {
 911                   printing = 1;
 912                   while (padding > 0)
 913                     {
 914                       printf_filtered (" ");
 915                       padding--;
 916                     }
 917                   mn10300_print_register (name, c, reg_width);
 918                   printf_filtered (" ");
 919                 }
 920               else
 921                 {
 922                   padding += (reg_width + 2 + 8 + 1);
 923                 }
 924             }
 925           if (printing)
 926             printf_filtered ("\n");
 927         }
 928     }
 929 }
 930
 931 /* Dump out the mn10300 speciic architecture information. */
 932
 933 static void
 934 mn10300_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
 935 {
 936   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 937   fprintf_unfiltered (file, "mn10300_dump_tdep: am33_mode = %d\n",
 938                       tdep->am33_mode);
 939 }
 940
 941 static struct gdbarch *
 942 mn10300_gdbarch_init (struct gdbarch_info info,
 943                       struct gdbarch_list *arches)
 944 {
 945   struct gdbarch *gdbarch;
 946   struct gdbarch_tdep *tdep = NULL;
 947   int am33_mode;
 948   gdbarch_register_name_ftype *register_name;
 949   int mach;
 950   int num_regs;
 951
 952   arches = gdbarch_list_lookup_by_info (arches, &info);
 953   if (arches != NULL)
 954     return arches->gdbarch;
 955   tdep = xmalloc (sizeof (struct gdbarch_tdep));
 956   gdbarch = gdbarch_alloc (&info, tdep);
 957
 958   if (info.bfd_arch_info != NULL
 959       && info.bfd_arch_info->arch == bfd_arch_mn10300)
 960     mach = info.bfd_arch_info->mach;
 961   else
 962     mach = 0;
 963   switch (mach)
 964     {
 965     case 0:
 966     case bfd_mach_mn10300:
 967       am33_mode = 0;
 968       register_name = mn10300_generic_register_name;
 969       num_regs = 32;
 970       break;
 971     case bfd_mach_am33:
 972       am33_mode = 1;
 973       register_name = am33_register_name;
 974       num_regs = 32;
 975       break;
 976     default:
 977       internal_error ("mn10300_gdbarch_init: Unknown mn10300 variant");
 978       return NULL; /* keep GCC happy. */
 979     }
 980
 981   set_gdbarch_register_size (gdbarch, 4);
 982   set_gdbarch_max_register_raw_size (gdbarch, 4);
 983   set_gdbarch_register_virtual_type (gdbarch, mn10300_register_virtual_type);
 984   set_gdbarch_register_byte (gdbarch, mn10300_register_byte);
 985   set_gdbarch_register_virtual_size (gdbarch, mn10300_register_virtual_size);
 986   set_gdbarch_register_raw_size (gdbarch, mn10300_register_raw_size);
 987   set_gdbarch_call_dummy_p (gdbarch, 1);
 988   set_gdbarch_register_name (gdbarch, register_name);
 989   set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
 990   set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 0);
 991   set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
 992   set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register);
 993   set_gdbarch_push_arguments (gdbarch, mn10300_push_arguments);
 994   set_gdbarch_push_return_address (gdbarch, mn10300_push_return_address);
 995   set_gdbarch_frame_chain_valid (gdbarch, generic_file_frame_chain_valid);
 996   set_gdbarch_reg_struct_has_addr (gdbarch, mn10300_reg_struct_has_addr);
 997   set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
 998   set_gdbarch_num_regs (gdbarch, num_regs);
 999   set_gdbarch_do_registers_info (gdbarch, mn10300_do_registers_info);
1000
1001   tdep->am33_mode = am33_mode;
1002
1003   return gdbarch;
1004 }
1005
1006 void
1007 _initialize_mn10300_tdep (void)
1008 {
1009 /*  printf("_initialize_mn10300_tdep\n"); */
1010
1011   tm_print_insn = print_insn_mn10300;
1012
1013   register_gdbarch_init (bfd_arch_mn10300, mn10300_gdbarch_init);
1014 }