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