OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [mn10300-tdep.c] - Blame information for rev 104

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.