gdb/mn10300-tdep.c

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