gdb/mn10300-tdep.c

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