gdb/m32r-tdep.c

   1 /* Target-dependent code for the Mitsubishi m32r for GDB, the GNU debugger.
   2    Copyright 1996, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "frame.h"
  23 #include "inferior.h"
  24 #include "target.h"
  25 #include "value.h"
  26 #include "bfd.h"
  27 #include "gdb_string.h"
  28 #include "gdbcore.h"
  29 #include "symfile.h"
  30 #include "regcache.h"
  31
  32 /* Function: m32r_use_struct_convention
  33    Return nonzero if call_function should allocate stack space for a
  34    struct return? */
  35 int
  36 m32r_use_struct_convention (int gcc_p, struct type *type)
  37 {
  38   return (TYPE_LENGTH (type) > 8);
  39 }
  40
  41 /* Function: frame_find_saved_regs
  42    Return the frame_saved_regs structure for the frame.
  43    Doesn't really work for dummy frames, but it does pass back
  44    an empty frame_saved_regs, so I guess that's better than total failure */
  45
  46 void
  47 m32r_frame_find_saved_regs (struct frame_info *fi,
  48                             struct frame_saved_regs *regaddr)
  49 {
  50   memcpy (regaddr, &fi->fsr, sizeof (struct frame_saved_regs));
  51 }
  52
  53 /* Turn this on if you want to see just how much instruction decoding
  54    if being done, its quite a lot
  55  */
  56 #if 0
  57 static void
  58 dump_insn (char *commnt, CORE_ADDR pc, int insn)
  59 {
  60   printf_filtered ("  %s %08x %08x ",
  61                    commnt, (unsigned int) pc, (unsigned int) insn);
  62   TARGET_PRINT_INSN (pc, &tm_print_insn_info);
  63   printf_filtered ("\n");
  64 }
  65 #define insn_debug(args) { printf_filtered args; }
  66 #else
  67 #define dump_insn(a,b,c) {}
  68 #define insn_debug(args) {}
  69 #endif
  70
  71 #define DEFAULT_SEARCH_LIMIT 44
  72
  73 /* Function: scan_prologue
  74    This function decodes the target function prologue to determine
  75    1) the size of the stack frame, and 2) which registers are saved on it.
  76    It saves the offsets of saved regs in the frame_saved_regs argument,
  77    and returns the frame size.  */
  78
  79 /*
  80    The sequence it currently generates is:
  81
  82    if (varargs function) { ddi sp,#n }
  83    push registers
  84    if (additional stack <= 256) {       addi sp,#-stack }
  85    else if (additional stack < 65k) { add3 sp,sp,#-stack
  86
  87    } else if (additional stack) {
  88    seth sp,#(stack & 0xffff0000)
  89    or3 sp,sp,#(stack & 0x0000ffff)
  90    sub sp,r4
  91    }
  92    if (frame pointer) {
  93    mv sp,fp
  94    }
  95
  96    These instructions are scheduled like everything else, so you should stop at
  97    the first branch instruction.
  98
  99  */
 100
 101 /* This is required by skip prologue and by m32r_init_extra_frame_info.
 102    The results of decoding a prologue should be cached because this
 103    thrashing is getting nuts.
 104    I am thinking of making a container class with two indexes, name and
 105    address. It may be better to extend the symbol table.
 106  */
 107
 108 static void
 109 decode_prologue (CORE_ADDR start_pc, CORE_ADDR scan_limit, CORE_ADDR *pl_endptr,        /* var parameter */
 110                  unsigned long *framelength, struct frame_info *fi,
 111                  struct frame_saved_regs *fsr)
 112 {
 113   unsigned long framesize;
 114   int insn;
 115   int op1;
 116   int maybe_one_more = 0;
 117   CORE_ADDR after_prologue = 0;
 118   CORE_ADDR after_stack_adjust = 0;
 119   CORE_ADDR current_pc;
 120
 121
 122   framesize = 0;
 123   after_prologue = 0;
 124   insn_debug (("rd prolog l(%d)\n", scan_limit - current_pc));
 125
 126   for (current_pc = start_pc; current_pc < scan_limit; current_pc += 2)
 127     {
 128
 129       insn = read_memory_unsigned_integer (current_pc, 2);
 130       dump_insn ("insn-1", current_pc, insn);   /* MTZ */
 131
 132       /* If this is a 32 bit instruction, we dont want to examine its
 133          immediate data as though it were an instruction */
 134       if (current_pc & 0x02)
 135         {                       /* Clear the parallel execution bit from 16 bit instruction */
 136           if (maybe_one_more)
 137             {                   /* The last instruction was a branch, usually terminates
 138                                    the series, but if this is a parallel instruction,
 139                                    it may be a stack framing instruction */
 140               if (!(insn & 0x8000))
 141                 {
 142                   insn_debug (("Really done"));
 143                   break;        /* nope, we are really done */
 144                 }
 145             }
 146           insn &= 0x7fff;       /* decode this instruction further */
 147         }
 148       else
 149         {
 150           if (maybe_one_more)
 151             break;              /* This isnt the one more */
 152           if (insn & 0x8000)
 153             {
 154               insn_debug (("32 bit insn\n"));
 155               if (current_pc == scan_limit)
 156                 scan_limit += 2;        /* extend the search */
 157               current_pc += 2;  /* skip the immediate data */
 158               if (insn == 0x8faf)       /* add3 sp, sp, xxxx */
 159                 /* add 16 bit sign-extended offset */
 160                 {
 161                   insn_debug (("stack increment\n"));
 162                   framesize += -((short) read_memory_unsigned_integer (current_pc, 2));
 163                 }
 164               else
 165                 {
 166                   if (((insn >> 8) == 0xe4) &&  /* ld24 r4, xxxxxx; sub sp, r4 */
 167                   read_memory_unsigned_integer (current_pc + 2, 2) == 0x0f24)
 168                     {           /* subtract 24 bit sign-extended negative-offset */
 169                       dump_insn ("insn-2", current_pc + 2, insn);
 170                       insn = read_memory_unsigned_integer (current_pc - 2, 4);
 171                       dump_insn ("insn-3(l4)", current_pc - 2, insn);
 172                       if (insn & 0x00800000)    /* sign extend */
 173                         insn |= 0xff000000;     /* negative */
 174                       else
 175                         insn &= 0x00ffffff;     /* positive */
 176                       framesize += insn;
 177                     }
 178                 }
 179               after_prologue = current_pc;
 180               continue;
 181             }
 182         }
 183       op1 = insn & 0xf000;      /* isolate just the first nibble */
 184
 185       if ((insn & 0xf0ff) == 0x207f)
 186         {                       /* st reg, @-sp */
 187           int regno;
 188           insn_debug (("push\n"));
 189 #if 0                           /* No, PUSH FP is not an indication that we will use a frame pointer. */
 190           if (((insn & 0xffff) == 0x2d7f) && fi)
 191             fi->using_frame_pointer = 1;
 192 #endif
 193           framesize += 4;
 194 #if 0
 195 /* Why should we increase the scan limit, just because we did a push?
 196    And if there is a reason, surely we would only want to do it if we
 197    had already reached the scan limit... */
 198           if (current_pc == scan_limit)
 199             scan_limit += 2;
 200 #endif
 201           regno = ((insn >> 8) & 0xf);
 202           if (fsr)              /* save_regs offset */
 203             fsr->regs[regno] = framesize;
 204           after_prologue = 0;
 205           continue;
 206         }
 207       if ((insn >> 8) == 0x4f)  /* addi sp, xx */
 208         /* add 8 bit sign-extended offset */
 209         {
 210           int stack_adjust = (char) (insn & 0xff);
 211
 212           /* there are probably two of these stack adjustments:
 213              1) A negative one in the prologue, and
 214              2) A positive one in the epilogue.
 215              We are only interested in the first one.  */
 216
 217           if (stack_adjust < 0)
 218             {
 219               framesize -= stack_adjust;
 220               after_prologue = 0;
 221               /* A frameless function may have no "mv fp, sp".
 222                  In that case, this is the end of the prologue.  */
 223               after_stack_adjust = current_pc + 2;
 224             }
 225           continue;
 226         }
 227       if (insn == 0x1d8f)
 228         {                       /* mv fp, sp */
 229           if (fi)
 230             fi->using_frame_pointer = 1;        /* fp is now valid */
 231           insn_debug (("done fp found\n"));
 232           after_prologue = current_pc + 2;
 233           break;                /* end of stack adjustments */
 234         }
 235       if (insn == 0x7000)       /* Nop looks like a branch, continue explicitly */
 236         {
 237           insn_debug (("nop\n"));
 238           after_prologue = current_pc + 2;
 239           continue;             /* nop occurs between pushes */
 240         }
 241       /* End of prolog if any of these are branch instructions */
 242       if ((op1 == 0x7000)
 243           || (op1 == 0xb000)
 244           || (op1 == 0xf000))
 245         {
 246           after_prologue = current_pc;
 247           insn_debug (("Done: branch\n"));
 248           maybe_one_more = 1;
 249           continue;
 250         }
 251       /* Some of the branch instructions are mixed with other types */
 252       if (op1 == 0x1000)
 253         {
 254           int subop = insn & 0x0ff0;
 255           if ((subop == 0x0ec0) || (subop == 0x0fc0))
 256             {
 257               insn_debug (("done: jmp\n"));
 258               after_prologue = current_pc;
 259               maybe_one_more = 1;
 260               continue;         /* jmp , jl */
 261             }
 262         }
 263     }
 264
 265   if (current_pc >= scan_limit)
 266     {
 267       if (pl_endptr)
 268         {
 269 #if 1
 270           if (after_stack_adjust != 0)
 271             /* We did not find a "mv fp,sp", but we DID find
 272                a stack_adjust.  Is it safe to use that as the
 273                end of the prologue?  I just don't know. */
 274             {
 275               *pl_endptr = after_stack_adjust;
 276               if (framelength)
 277                 *framelength = framesize;
 278             }
 279           else
 280 #endif
 281             /* We reached the end of the loop without finding the end
 282                of the prologue.  No way to win -- we should report failure.
 283                The way we do that is to return the original start_pc.
 284                GDB will set a breakpoint at the start of the function (etc.) */
 285             *pl_endptr = start_pc;
 286         }
 287       return;
 288     }
 289   if (after_prologue == 0)
 290     after_prologue = current_pc;
 291
 292   insn_debug ((" framesize %d, firstline %08x\n", framesize, after_prologue));
 293   if (framelength)
 294     *framelength = framesize;
 295   if (pl_endptr)
 296     *pl_endptr = after_prologue;
 297 }                               /*  decode_prologue */
 298
 299 /* Function: skip_prologue
 300    Find end of function prologue */
 301
 302 CORE_ADDR
 303 m32r_skip_prologue (CORE_ADDR pc)
 304 {
 305   CORE_ADDR func_addr, func_end;
 306   struct symtab_and_line sal;
 307
 308   /* See what the symbol table says */
 309
 310   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 311     {
 312       sal = find_pc_line (func_addr, 0);
 313
 314       if (sal.line != 0 && sal.end <= func_end)
 315         {
 316
 317           insn_debug (("BP after prologue %08x\n", sal.end));
 318           func_end = sal.end;
 319         }
 320       else
 321         /* Either there's no line info, or the line after the prologue is after
 322            the end of the function.  In this case, there probably isn't a
 323            prologue.  */
 324         {
 325           insn_debug (("No line info, line(%x) sal_end(%x) funcend(%x)\n",
 326                        sal.line, sal.end, func_end));
 327           func_end = min (func_end, func_addr + DEFAULT_SEARCH_LIMIT);
 328         }
 329     }
 330   else
 331     func_end = pc + DEFAULT_SEARCH_LIMIT;
 332   decode_prologue (pc, func_end, &sal.end, 0, 0, 0);
 333   return sal.end;
 334 }
 335
 336 static unsigned long
 337 m32r_scan_prologue (struct frame_info *fi, struct frame_saved_regs *fsr)
 338 {
 339   struct symtab_and_line sal;
 340   CORE_ADDR prologue_start, prologue_end, current_pc;
 341   unsigned long framesize = 0;
 342
 343   /* this code essentially duplicates skip_prologue,
 344      but we need the start address below.  */
 345
 346   if (find_pc_partial_function (fi->pc, NULL, &prologue_start, &prologue_end))
 347     {
 348       sal = find_pc_line (prologue_start, 0);
 349
 350       if (sal.line == 0)        /* no line info, use current PC */
 351         if (prologue_start == entry_point_address ())
 352           return 0;
 353     }
 354   else
 355     {
 356       prologue_start = fi->pc;
 357       prologue_end = prologue_start + 48;       /* We're in the boondocks:
 358                                                    allow for 16 pushes, an add,
 359                                                    and "mv fp,sp" */
 360     }
 361 #if 0
 362   prologue_end = min (prologue_end, fi->pc);
 363 #endif
 364   insn_debug (("fipc(%08x) start(%08x) end(%08x)\n",
 365                fi->pc, prologue_start, prologue_end));
 366   prologue_end = min (prologue_end, prologue_start + DEFAULT_SEARCH_LIMIT);
 367   decode_prologue (prologue_start, prologue_end, &prologue_end, &framesize,
 368                    fi, fsr);
 369   return framesize;
 370 }
 371
 372 /* Function: init_extra_frame_info
 373    This function actually figures out the frame address for a given pc and
 374    sp.  This is tricky on the m32r because we sometimes don't use an explicit
 375    frame pointer, and the previous stack pointer isn't necessarily recorded
 376    on the stack.  The only reliable way to get this info is to
 377    examine the prologue.  */
 378
 379 void
 380 m32r_init_extra_frame_info (struct frame_info *fi)
 381 {
 382   int reg;
 383
 384   if (fi->next)
 385     fi->pc = FRAME_SAVED_PC (fi->next);
 386
 387   memset (fi->fsr.regs, '\000', sizeof fi->fsr.regs);
 388
 389   if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
 390     {
 391       /* We need to setup fi->frame here because run_stack_dummy gets it wrong
 392          by assuming it's always FP.  */
 393       fi->frame = deprecated_read_register_dummy (fi->pc, fi->frame,
 394                                                   SP_REGNUM);
 395       fi->framesize = 0;
 396       return;
 397     }
 398   else
 399     {
 400       fi->using_frame_pointer = 0;
 401       fi->framesize = m32r_scan_prologue (fi, &fi->fsr);
 402
 403       if (!fi->next)
 404         if (fi->using_frame_pointer)
 405           {
 406             fi->frame = read_register (FP_REGNUM);
 407           }
 408         else
 409           fi->frame = read_register (SP_REGNUM);
 410       else
 411         /* fi->next means this is not the innermost frame */ if (fi->using_frame_pointer)
 412         /* we have an FP */
 413         if (fi->next->fsr.regs[FP_REGNUM] != 0)         /* caller saved our FP */
 414           fi->frame = read_memory_integer (fi->next->fsr.regs[FP_REGNUM], 4);
 415       for (reg = 0; reg < NUM_REGS; reg++)
 416         if (fi->fsr.regs[reg] != 0)
 417           fi->fsr.regs[reg] = fi->frame + fi->framesize - fi->fsr.regs[reg];
 418     }
 419 }
 420
 421 /* Function: m32r_virtual_frame_pointer
 422    Return the register that the function uses for a frame pointer,
 423    plus any necessary offset to be applied to the register before
 424    any frame pointer offsets.  */
 425
 426 void
 427 m32r_virtual_frame_pointer (CORE_ADDR pc, long *reg, long *offset)
 428 {
 429   struct frame_info *fi = deprecated_frame_xmalloc ();
 430   struct cleanup *old_chain = make_cleanup (xfree, fi);
 431
 432   /* Set up a dummy frame_info. */
 433   fi->next = NULL;
 434   fi->prev = NULL;
 435   fi->frame = 0;
 436   fi->pc = pc;
 437
 438   /* Analyze the prolog and fill in the extra info.  */
 439   m32r_init_extra_frame_info (fi);
 440
 441   /* Results will tell us which type of frame it uses.  */
 442   if (fi->using_frame_pointer)
 443     {
 444       *reg = FP_REGNUM;
 445       *offset = 0;
 446     }
 447   else
 448     {
 449       *reg = SP_REGNUM;
 450       *offset = 0;
 451     }
 452   do_cleanups (old_chain);
 453 }
 454
 455 /* Function: find_callers_reg
 456    Find REGNUM on the stack.  Otherwise, it's in an active register.  One thing
 457    we might want to do here is to check REGNUM against the clobber mask, and
 458    somehow flag it as invalid if it isn't saved on the stack somewhere.  This
 459    would provide a graceful failure mode when trying to get the value of
 460    caller-saves registers for an inner frame.  */
 461
 462 CORE_ADDR
 463 m32r_find_callers_reg (struct frame_info *fi, int regnum)
 464 {
 465   for (; fi; fi = fi->next)
 466     if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
 467       return deprecated_read_register_dummy (fi->pc, fi->frame, regnum);
 468     else if (fi->fsr.regs[regnum] != 0)
 469       return read_memory_integer (fi->fsr.regs[regnum],
 470                                   REGISTER_RAW_SIZE (regnum));
 471   return read_register (regnum);
 472 }
 473
 474 /* Function: frame_chain Given a GDB frame, determine the address of
 475    the calling function's frame.  This will be used to create a new
 476    GDB frame struct, and then INIT_EXTRA_FRAME_INFO and
 477    DEPRECATED_INIT_FRAME_PC will be called for the new frame.  For
 478    m32r, we save the frame size when we initialize the frame_info.  */
 479
 480 CORE_ADDR
 481 m32r_frame_chain (struct frame_info *fi)
 482 {
 483   CORE_ADDR fn_start, callers_pc, fp;
 484
 485   /* is this a dummy frame? */
 486   if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
 487     return fi->frame;           /* dummy frame same as caller's frame */
 488
 489   /* is caller-of-this a dummy frame? */
 490   callers_pc = FRAME_SAVED_PC (fi);     /* find out who called us: */
 491   fp = m32r_find_callers_reg (fi, FP_REGNUM);
 492   if (DEPRECATED_PC_IN_CALL_DUMMY (callers_pc, fp, fp))
 493     return fp;                  /* dummy frame's frame may bear no relation to ours */
 494
 495   if (find_pc_partial_function (fi->pc, 0, &fn_start, 0))
 496     if (fn_start == entry_point_address ())
 497       return 0;                 /* in _start fn, don't chain further */
 498   if (fi->framesize == 0)
 499     {
 500       printf_filtered ("cannot determine frame size @ %s , pc(%s)\n",
 501                        paddr (fi->frame),
 502                        paddr (fi->pc));
 503       return 0;
 504     }
 505   insn_debug (("m32rx frame %08x\n", fi->frame + fi->framesize));
 506   return fi->frame + fi->framesize;
 507 }
 508
 509 /* Function: push_return_address (pc)
 510    Set up the return address for the inferior function call.
 511    Necessary for targets that don't actually execute a JSR/BSR instruction
 512    (ie. when using an empty CALL_DUMMY) */
 513
 514 CORE_ADDR
 515 m32r_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
 516 {
 517   write_register (RP_REGNUM, CALL_DUMMY_ADDRESS ());
 518   return sp;
 519 }
 520
 521
 522 /* Function: pop_frame
 523    Discard from the stack the innermost frame,
 524    restoring all saved registers.  */
 525
 526 struct frame_info *
 527 m32r_pop_frame (struct frame_info *frame)
 528 {
 529   int regnum;
 530
 531   if (DEPRECATED_PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
 532     generic_pop_dummy_frame ();
 533   else
 534     {
 535       for (regnum = 0; regnum < NUM_REGS; regnum++)
 536         if (frame->fsr.regs[regnum] != 0)
 537           write_register (regnum,
 538                           read_memory_integer (frame->fsr.regs[regnum], 4));
 539
 540       write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
 541       write_register (SP_REGNUM, read_register (FP_REGNUM));
 542       if (read_register (PSW_REGNUM) & 0x80)
 543         write_register (SPU_REGNUM, read_register (SP_REGNUM));
 544       else
 545         write_register (SPI_REGNUM, read_register (SP_REGNUM));
 546     }
 547   flush_cached_frames ();
 548   return NULL;
 549 }
 550
 551 /* Function: frame_saved_pc
 552    Find the caller of this frame.  We do this by seeing if RP_REGNUM is saved
 553    in the stack anywhere, otherwise we get it from the registers. */
 554
 555 CORE_ADDR
 556 m32r_frame_saved_pc (struct frame_info *fi)
 557 {
 558   if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
 559     return deprecated_read_register_dummy (fi->pc, fi->frame, PC_REGNUM);
 560   else
 561     return m32r_find_callers_reg (fi, RP_REGNUM);
 562 }
 563
 564 /* Function: push_arguments
 565    Setup the function arguments for calling a function in the inferior.
 566
 567    On the Mitsubishi M32R architecture, there are four registers (R0 to R3)
 568    which are dedicated for passing function arguments.  Up to the first
 569    four arguments (depending on size) may go into these registers.
 570    The rest go on the stack.
 571
 572    Arguments that are smaller than 4 bytes will still take up a whole
 573    register or a whole 32-bit word on the stack, and will be
 574    right-justified in the register or the stack word.  This includes
 575    chars, shorts, and small aggregate types.
 576
 577    Arguments of 8 bytes size are split between two registers, if
 578    available.  If only one register is available, the argument will
 579    be split between the register and the stack.  Otherwise it is
 580    passed entirely on the stack.  Aggregate types with sizes between
 581    4 and 8 bytes are passed entirely on the stack, and are left-justified
 582    within the double-word (as opposed to aggregates smaller than 4 bytes
 583    which are right-justified).
 584
 585    Aggregates of greater than 8 bytes are first copied onto the stack,
 586    and then a pointer to the copy is passed in the place of the normal
 587    argument (either in a register if available, or on the stack).
 588
 589    Functions that must return an aggregate type can return it in the
 590    normal return value registers (R0 and R1) if its size is 8 bytes or
 591    less.  For larger return values, the caller must allocate space for
 592    the callee to copy the return value to.  A pointer to this space is
 593    passed as an implicit first argument, always in R0. */
 594
 595 CORE_ADDR
 596 m32r_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 597                      unsigned char struct_return, CORE_ADDR struct_addr)
 598 {
 599   int stack_offset, stack_alloc;
 600   int argreg;
 601   int argnum;
 602   struct type *type;
 603   CORE_ADDR regval;
 604   char *val;
 605   char valbuf[4];
 606   int len;
 607   int odd_sized_struct;
 608
 609   /* first force sp to a 4-byte alignment */
 610   sp = sp & ~3;
 611
 612   argreg = ARG0_REGNUM;
 613   /* The "struct return pointer" pseudo-argument goes in R0 */
 614   if (struct_return)
 615     write_register (argreg++, struct_addr);
 616
 617   /* Now make sure there's space on the stack */
 618   for (argnum = 0, stack_alloc = 0;
 619        argnum < nargs; argnum++)
 620     stack_alloc += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3);
 621   sp -= stack_alloc;            /* make room on stack for args */
 622
 623
 624   /* Now load as many as possible of the first arguments into
 625      registers, and push the rest onto the stack.  There are 16 bytes
 626      in four registers available.  Loop thru args from first to last.  */
 627
 628   argreg = ARG0_REGNUM;
 629   for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
 630     {
 631       type = VALUE_TYPE (args[argnum]);
 632       len = TYPE_LENGTH (type);
 633       memset (valbuf, 0, sizeof (valbuf));
 634       if (len < 4)
 635         {                       /* value gets right-justified in the register or stack word */
 636           memcpy (valbuf + (4 - len),
 637                   (char *) VALUE_CONTENTS (args[argnum]), len);
 638           val = valbuf;
 639         }
 640       else
 641         val = (char *) VALUE_CONTENTS (args[argnum]);
 642
 643       if (len > 4 && (len & 3) != 0)
 644         odd_sized_struct = 1;   /* such structs go entirely on stack */
 645       else
 646         odd_sized_struct = 0;
 647       while (len > 0)
 648         {
 649           if (argreg > ARGLAST_REGNUM || odd_sized_struct)
 650             {                   /* must go on the stack */
 651               write_memory (sp + stack_offset, val, 4);
 652               stack_offset += 4;
 653             }
 654           /* NOTE WELL!!!!!  This is not an "else if" clause!!!
 655              That's because some *&^%$ things get passed on the stack
 656              AND in the registers!   */
 657           if (argreg <= ARGLAST_REGNUM)
 658             {                   /* there's room in a register */
 659               regval = extract_address (val, REGISTER_RAW_SIZE (argreg));
 660               write_register (argreg++, regval);
 661             }
 662           /* Store the value 4 bytes at a time.  This means that things
 663              larger than 4 bytes may go partly in registers and partly
 664              on the stack.  */
 665           len -= REGISTER_RAW_SIZE (argreg);
 666           val += REGISTER_RAW_SIZE (argreg);
 667         }
 668     }
 669   return sp;
 670 }
 671
 672 /* Function: fix_call_dummy
 673    If there is real CALL_DUMMY code (eg. on the stack), this function
 674    has the responsability to insert the address of the actual code that
 675    is the target of the target function call.  */
 676
 677 void
 678 m32r_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
 679                      struct value **args, struct type *type, int gcc_p)
 680 {
 681   /* ld24 r8, <(imm24) fun> */
 682   *(unsigned long *) (dummy) = (fun & 0x00ffffff) | 0xe8000000;
 683 }
 684
 685
 686 /* Function: m32r_write_sp
 687    Because SP is really a read-only register that mirrors either SPU or SPI,
 688    we must actually write one of those two as well, depending on PSW. */
 689
 690 void
 691 m32r_write_sp (CORE_ADDR val)
 692 {
 693   unsigned long psw = read_register (PSW_REGNUM);
 694
 695   if (psw & 0x80)               /* stack mode: user or interrupt */
 696     write_register (SPU_REGNUM, val);
 697   else
 698     write_register (SPI_REGNUM, val);
 699   write_register (SP_REGNUM, val);
 700 }
 701
 702 void
 703 _initialize_m32r_tdep (void)
 704 {
 705   tm_print_insn = print_insn_m32r;
 706 }