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