gdb/mn10300-tdep.c

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