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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [mn10300-tdep.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom
/* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
2
   Copyright 1996, 1997, 1998, 1999, 2000, 2001
3
   Free Software Foundation, Inc.
4
 
5
   This file is part of GDB.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 2 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 59 Temple Place - Suite 330,
20
   Boston, MA 02111-1307, USA.  */
21
 
22
#include "defs.h"
23
#include "frame.h"
24
#include "inferior.h"
25
#include "obstack.h"
26
#include "target.h"
27
#include "value.h"
28
#include "bfd.h"
29
#include "gdb_string.h"
30
#include "gdbcore.h"
31
#include "symfile.h"
32
#include "regcache.h"
33
#include "arch-utils.h"
34
 
35
extern void _initialize_mn10300_tdep (void);
36
static CORE_ADDR mn10300_analyze_prologue (struct frame_info *fi,
37
                                           CORE_ADDR pc);
38
 
39
/* mn10300 private data */
40
struct gdbarch_tdep
41
{
42
  int am33_mode;
43
#define AM33_MODE (gdbarch_tdep (current_gdbarch)->am33_mode)
44
};
45
 
46
/* Additional info used by the frame */
47
 
48
struct frame_extra_info
49
  {
50
    int status;
51
    int stack_size;
52
  };
53
 
54
 
55
static char *
56
register_name (int reg, char **regs, long sizeof_regs)
57
{
58
  if (reg < 0 || reg >= sizeof_regs / sizeof (regs[0]))
59
    return NULL;
60
  else
61
    return regs[reg];
62
}
63
 
64
static char *
65
mn10300_generic_register_name (int reg)
66
{
67
  static char *regs[] =
68
  { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
69
    "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
70
    "", "", "", "", "", "", "", "",
71
    "", "", "", "", "", "", "", "fp"
72
  };
73
  return register_name (reg, regs, sizeof regs);
74
}
75
 
76
 
77
static char *
78
am33_register_name (int reg)
79
{
80
  static char *regs[] =
81
  { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
82
    "sp", "pc", "mdr", "psw", "lir", "lar", "",
83
    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
84
    "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
85
  };
86
  return register_name (reg, regs, sizeof regs);
87
}
88
 
89
static CORE_ADDR
90
mn10300_saved_pc_after_call (struct frame_info *fi)
91
{
92
  return read_memory_integer (read_register (SP_REGNUM), 4);
93
}
94
 
95
static void
96
mn10300_extract_return_value (struct type *type, char *regbuf, char *valbuf)
97
{
98
  if (TYPE_CODE (type) == TYPE_CODE_PTR)
99
    memcpy (valbuf, regbuf + REGISTER_BYTE (4), TYPE_LENGTH (type));
100
  else
101
    memcpy (valbuf, regbuf + REGISTER_BYTE (0), TYPE_LENGTH (type));
102
}
103
 
104
static CORE_ADDR
105
mn10300_extract_struct_value_address (char *regbuf)
106
{
107
  return extract_address (regbuf + REGISTER_BYTE (4),
108
                          REGISTER_RAW_SIZE (4));
109
}
110
 
111
static void
112
mn10300_store_return_value (struct type *type, char *valbuf)
113
{
114
  if (TYPE_CODE (type) == TYPE_CODE_PTR)
115
    write_register_bytes (REGISTER_BYTE (4), valbuf, TYPE_LENGTH (type));
116
  else
117
    write_register_bytes (REGISTER_BYTE (0), valbuf, TYPE_LENGTH (type));
118
}
119
 
120
static struct frame_info *analyze_dummy_frame (CORE_ADDR, CORE_ADDR);
121
static struct frame_info *
122
analyze_dummy_frame (CORE_ADDR pc, CORE_ADDR frame)
123
{
124
  static struct frame_info *dummy = NULL;
125
  if (dummy == NULL)
126
    {
127
      dummy = xmalloc (sizeof (struct frame_info));
128
      dummy->saved_regs = xmalloc (SIZEOF_FRAME_SAVED_REGS);
129
      dummy->extra_info = xmalloc (sizeof (struct frame_extra_info));
130
    }
131
  dummy->next = NULL;
132
  dummy->prev = NULL;
133
  dummy->pc = pc;
134
  dummy->frame = frame;
135
  dummy->extra_info->status = 0;
136
  dummy->extra_info->stack_size = 0;
137
  memset (dummy->saved_regs, '\000', SIZEOF_FRAME_SAVED_REGS);
138
  mn10300_analyze_prologue (dummy, 0);
139
  return dummy;
140
}
141
 
142
/* Values for frame_info.status */
143
 
144
#define MY_FRAME_IN_SP 0x1
145
#define MY_FRAME_IN_FP 0x2
146
#define NO_MORE_FRAMES 0x4
147
 
148
 
149
/* Should call_function allocate stack space for a struct return?  */
150
static int
151
mn10300_use_struct_convention (int gcc_p, struct type *type)
152
{
153
  return (TYPE_NFIELDS (type) > 1 || TYPE_LENGTH (type) > 8);
154
}
155
 
156
/* The breakpoint instruction must be the same size as the smallest
157
   instruction in the instruction set.
158
 
159
   The Matsushita mn10x00 processors have single byte instructions
160
   so we need a single byte breakpoint.  Matsushita hasn't defined
161
   one, so we defined it ourselves.  */
162
 
163
static unsigned char *
164
mn10300_breakpoint_from_pc (CORE_ADDR *bp_addr, int *bp_size)
165
{
166
  static char breakpoint[] =
167
  {0xff};
168
  *bp_size = 1;
169
  return breakpoint;
170
}
171
 
172
 
173
/* Fix fi->frame if it's bogus at this point.  This is a helper
174
   function for mn10300_analyze_prologue. */
175
 
176
static void
177
fix_frame_pointer (struct frame_info *fi, int stack_size)
178
{
179
  if (fi && fi->next == NULL)
180
    {
181
      if (fi->extra_info->status & MY_FRAME_IN_SP)
182
        fi->frame = read_sp () - stack_size;
183
      else if (fi->extra_info->status & MY_FRAME_IN_FP)
184
        fi->frame = read_register (A3_REGNUM);
185
    }
186
}
187
 
188
 
189
/* Set offsets of registers saved by movm instruction.
190
   This is a helper function for mn10300_analyze_prologue.  */
191
 
192
static void
193
set_movm_offsets (struct frame_info *fi, int movm_args)
194
{
195
  int offset = 0;
196
 
197
  if (fi == NULL || movm_args == 0)
198
    return;
199
 
200
  if (movm_args & movm_other_bit)
201
    {
202
      /* The `other' bit leaves a blank area of four bytes at the
203
         beginning of its block of saved registers, making it 32 bytes
204
         long in total.  */
205
      fi->saved_regs[LAR_REGNUM]    = fi->frame + offset + 4;
206
      fi->saved_regs[LIR_REGNUM]    = fi->frame + offset + 8;
207
      fi->saved_regs[MDR_REGNUM]    = fi->frame + offset + 12;
208
      fi->saved_regs[A0_REGNUM + 1] = fi->frame + offset + 16;
209
      fi->saved_regs[A0_REGNUM]     = fi->frame + offset + 20;
210
      fi->saved_regs[D0_REGNUM + 1] = fi->frame + offset + 24;
211
      fi->saved_regs[D0_REGNUM]     = fi->frame + offset + 28;
212
      offset += 32;
213
    }
214
  if (movm_args & movm_a3_bit)
215
    {
216
      fi->saved_regs[A3_REGNUM] = fi->frame + offset;
217
      offset += 4;
218
    }
219
  if (movm_args & movm_a2_bit)
220
    {
221
      fi->saved_regs[A2_REGNUM] = fi->frame + offset;
222
      offset += 4;
223
    }
224
  if (movm_args & movm_d3_bit)
225
    {
226
      fi->saved_regs[D3_REGNUM] = fi->frame + offset;
227
      offset += 4;
228
    }
229
  if (movm_args & movm_d2_bit)
230
    {
231
      fi->saved_regs[D2_REGNUM] = fi->frame + offset;
232
      offset += 4;
233
    }
234
  if (AM33_MODE)
235
    {
236
      if (movm_args & movm_exother_bit)
237
        {
238
          fi->saved_regs[MCVF_REGNUM]   = fi->frame + offset;
239
          fi->saved_regs[MCRL_REGNUM]   = fi->frame + offset + 4;
240
          fi->saved_regs[MCRH_REGNUM]   = fi->frame + offset + 8;
241
          fi->saved_regs[MDRQ_REGNUM]   = fi->frame + offset + 12;
242
          fi->saved_regs[E0_REGNUM + 1] = fi->frame + offset + 16;
243
          fi->saved_regs[E0_REGNUM + 0] = fi->frame + offset + 20;
244
          offset += 24;
245
        }
246
      if (movm_args & movm_exreg1_bit)
247
        {
248
          fi->saved_regs[E0_REGNUM + 7] = fi->frame + offset;
249
          fi->saved_regs[E0_REGNUM + 6] = fi->frame + offset + 4;
250
          fi->saved_regs[E0_REGNUM + 5] = fi->frame + offset + 8;
251
          fi->saved_regs[E0_REGNUM + 4] = fi->frame + offset + 12;
252
          offset += 16;
253
        }
254
      if (movm_args & movm_exreg0_bit)
255
        {
256
          fi->saved_regs[E0_REGNUM + 3] = fi->frame + offset;
257
          fi->saved_regs[E0_REGNUM + 2] = fi->frame + offset + 4;
258
          offset += 8;
259
        }
260
    }
261
}
262
 
263
 
264
/* The main purpose of this file is dealing with prologues to extract
265
   information about stack frames and saved registers.
266
 
267
   For reference here's how prologues look on the mn10300:
268
 
269
   With frame pointer:
270
   movm [d2,d3,a2,a3],sp
271
   mov sp,a3
272
   add <size>,sp
273
 
274
   Without frame pointer:
275
   movm [d2,d3,a2,a3],sp (if needed)
276
   add <size>,sp
277
 
278
   One day we might keep the stack pointer constant, that won't
279
   change the code for prologues, but it will make the frame
280
   pointerless case much more common.  */
281
 
282
/* Analyze the prologue to determine where registers are saved,
283
   the end of the prologue, etc etc.  Return the end of the prologue
284
   scanned.
285
 
286
   We store into FI (if non-null) several tidbits of information:
287
 
288
   * stack_size -- size of this stack frame.  Note that if we stop in
289
   certain parts of the prologue/epilogue we may claim the size of the
290
   current frame is zero.  This happens when the current frame has
291
   not been allocated yet or has already been deallocated.
292
 
293
   * fsr -- Addresses of registers saved in the stack by this frame.
294
 
295
   * status -- A (relatively) generic status indicator.  It's a bitmask
296
   with the following bits:
297
 
298
   MY_FRAME_IN_SP: The base of the current frame is actually in
299
   the stack pointer.  This can happen for frame pointerless
300
   functions, or cases where we're stopped in the prologue/epilogue
301
   itself.  For these cases mn10300_analyze_prologue will need up
302
   update fi->frame before returning or analyzing the register
303
   save instructions.
304
 
305
   MY_FRAME_IN_FP: The base of the current frame is in the
306
   frame pointer register ($a2).
307
 
308
   NO_MORE_FRAMES: Set this if the current frame is "start" or
309
   if the first instruction looks like mov <imm>,sp.  This tells
310
   frame chain to not bother trying to unwind past this frame.  */
311
 
312
static CORE_ADDR
313
mn10300_analyze_prologue (struct frame_info *fi, CORE_ADDR pc)
314
{
315
  CORE_ADDR func_addr, func_end, addr, stop;
316
  CORE_ADDR stack_size;
317
  int imm_size;
318
  unsigned char buf[4];
319
  int status, movm_args = 0;
320
  char *name;
321
 
322
  /* Use the PC in the frame if it's provided to look up the
323
     start of this function.  */
324
  pc = (fi ? fi->pc : pc);
325
 
326
  /* Find the start of this function.  */
327
  status = find_pc_partial_function (pc, &name, &func_addr, &func_end);
328
 
329
  /* Do nothing if we couldn't find the start of this function or if we're
330
     stopped at the first instruction in the prologue.  */
331
  if (status == 0)
332
    {
333
      return pc;
334
    }
335
 
336
  /* If we're in start, then give up.  */
337
  if (strcmp (name, "start") == 0)
338
    {
339
      if (fi != NULL)
340
        fi->extra_info->status = NO_MORE_FRAMES;
341
      return pc;
342
    }
343
 
344
  /* At the start of a function our frame is in the stack pointer.  */
345
  if (fi)
346
    fi->extra_info->status = MY_FRAME_IN_SP;
347
 
348
  /* Get the next two bytes into buf, we need two because rets is a two
349
     byte insn and the first isn't enough to uniquely identify it.  */
350
  status = read_memory_nobpt (pc, buf, 2);
351
  if (status != 0)
352
    return pc;
353
 
354
  /* If we're physically on an "rets" instruction, then our frame has
355
     already been deallocated.  Note this can also be true for retf
356
     and ret if they specify a size of zero.
357
 
358
     In this case fi->frame is bogus, we need to fix it.  */
359
  if (fi && buf[0] == 0xf0 && buf[1] == 0xfc)
360
    {
361
      if (fi->next == NULL)
362
        fi->frame = read_sp ();
363
      return fi->pc;
364
    }
365
 
366
  /* Similarly if we're stopped on the first insn of a prologue as our
367
     frame hasn't been allocated yet.  */
368
  if (fi && fi->pc == func_addr)
369
    {
370
      if (fi->next == NULL)
371
        fi->frame = read_sp ();
372
      return fi->pc;
373
    }
374
 
375
  /* Figure out where to stop scanning.  */
376
  stop = fi ? fi->pc : func_end;
377
 
378
  /* Don't walk off the end of the function.  */
379
  stop = stop > func_end ? func_end : stop;
380
 
381
  /* Start scanning on the first instruction of this function.  */
382
  addr = func_addr;
383
 
384
  /* Suck in two bytes.  */
385
  status = read_memory_nobpt (addr, buf, 2);
386
  if (status != 0)
387
    {
388
      fix_frame_pointer (fi, 0);
389
      return addr;
390
    }
391
 
392
  /* First see if this insn sets the stack pointer; if so, it's something
393
     we won't understand, so quit now.   */
394
  if (buf[0] == 0xf2 && (buf[1] & 0xf3) == 0xf0)
395
    {
396
      if (fi)
397
        fi->extra_info->status = NO_MORE_FRAMES;
398
      return addr;
399
    }
400
 
401
  /* Now look for movm [regs],sp, which saves the callee saved registers.
402
 
403
     At this time we don't know if fi->frame is valid, so we only note
404
     that we encountered a movm instruction.  Later, we'll set the entries
405
     in fsr.regs as needed.  */
406
  if (buf[0] == 0xcf)
407
    {
408
      /* Extract the register list for the movm instruction.  */
409
      status = read_memory_nobpt (addr + 1, buf, 1);
410
      movm_args = *buf;
411
 
412
      addr += 2;
413
 
414
      /* Quit now if we're beyond the stop point.  */
415
      if (addr >= stop)
416
        {
417
          /* Fix fi->frame since it's bogus at this point.  */
418
          if (fi && fi->next == NULL)
419
            fi->frame = read_sp ();
420
 
421
          /* Note if/where callee saved registers were saved.  */
422
          set_movm_offsets (fi, movm_args);
423
          return addr;
424
        }
425
 
426
      /* Get the next two bytes so the prologue scan can continue.  */
427
      status = read_memory_nobpt (addr, buf, 2);
428
      if (status != 0)
429
        {
430
          /* Fix fi->frame since it's bogus at this point.  */
431
          if (fi && fi->next == NULL)
432
            fi->frame = read_sp ();
433
 
434
          /* Note if/where callee saved registers were saved.  */
435
          set_movm_offsets (fi, movm_args);
436
          return addr;
437
        }
438
    }
439
 
440
  /* Now see if we set up a frame pointer via "mov sp,a3" */
441
  if (buf[0] == 0x3f)
442
    {
443
      addr += 1;
444
 
445
      /* The frame pointer is now valid.  */
446
      if (fi)
447
        {
448
          fi->extra_info->status |= MY_FRAME_IN_FP;
449
          fi->extra_info->status &= ~MY_FRAME_IN_SP;
450
        }
451
 
452
      /* Quit now if we're beyond the stop point.  */
453
      if (addr >= stop)
454
        {
455
          /* Fix fi->frame if it's bogus at this point.  */
456
          fix_frame_pointer (fi, 0);
457
 
458
          /* Note if/where callee saved registers were saved.  */
459
          set_movm_offsets (fi, movm_args);
460
          return addr;
461
        }
462
 
463
      /* Get two more bytes so scanning can continue.  */
464
      status = read_memory_nobpt (addr, buf, 2);
465
      if (status != 0)
466
        {
467
          /* Fix fi->frame if it's bogus at this point.  */
468
          fix_frame_pointer (fi, 0);
469
 
470
          /* Note if/where callee saved registers were saved.  */
471
          set_movm_offsets (fi, movm_args);
472
          return addr;
473
        }
474
    }
475
 
476
  /* Next we should allocate the local frame.  No more prologue insns
477
     are found after allocating the local frame.
478
 
479
     Search for add imm8,sp (0xf8feXX)
480
     or add imm16,sp (0xfafeXXXX)
481
     or add imm32,sp (0xfcfeXXXXXXXX).
482
 
483
     If none of the above was found, then this prologue has no
484
     additional stack.  */
485
 
486
  status = read_memory_nobpt (addr, buf, 2);
487
  if (status != 0)
488
    {
489
      /* Fix fi->frame if it's bogus at this point.  */
490
      fix_frame_pointer (fi, 0);
491
 
492
      /* Note if/where callee saved registers were saved.  */
493
      set_movm_offsets (fi, movm_args);
494
      return addr;
495
    }
496
 
497
  imm_size = 0;
498
  if (buf[0] == 0xf8 && buf[1] == 0xfe)
499
    imm_size = 1;
500
  else if (buf[0] == 0xfa && buf[1] == 0xfe)
501
    imm_size = 2;
502
  else if (buf[0] == 0xfc && buf[1] == 0xfe)
503
    imm_size = 4;
504
 
505
  if (imm_size != 0)
506
    {
507
      /* Suck in imm_size more bytes, they'll hold the size of the
508
         current frame.  */
509
      status = read_memory_nobpt (addr + 2, buf, imm_size);
510
      if (status != 0)
511
        {
512
          /* Fix fi->frame if it's bogus at this point.  */
513
          fix_frame_pointer (fi, 0);
514
 
515
          /* Note if/where callee saved registers were saved.  */
516
          set_movm_offsets (fi, movm_args);
517
          return addr;
518
        }
519
 
520
      /* Note the size of the stack in the frame info structure.  */
521
      stack_size = extract_signed_integer (buf, imm_size);
522
      if (fi)
523
        fi->extra_info->stack_size = stack_size;
524
 
525
      /* We just consumed 2 + imm_size bytes.  */
526
      addr += 2 + imm_size;
527
 
528
      /* No more prologue insns follow, so begin preparation to return.  */
529
      /* Fix fi->frame if it's bogus at this point.  */
530
      fix_frame_pointer (fi, stack_size);
531
 
532
      /* Note if/where callee saved registers were saved.  */
533
      set_movm_offsets (fi, movm_args);
534
      return addr;
535
    }
536
 
537
  /* We never found an insn which allocates local stack space, regardless
538
     this is the end of the prologue.  */
539
  /* Fix fi->frame if it's bogus at this point.  */
540
  fix_frame_pointer (fi, 0);
541
 
542
  /* Note if/where callee saved registers were saved.  */
543
  set_movm_offsets (fi, movm_args);
544
  return addr;
545
}
546
 
547
 
548
/* Function: saved_regs_size
549
   Return the size in bytes of the register save area, based on the
550
   saved_regs array in FI.  */
551
static int
552
saved_regs_size (struct frame_info *fi)
553
{
554
  int adjust = 0;
555
  int i;
556
 
557
  /* Reserve four bytes for every register saved.  */
558
  for (i = 0; i < NUM_REGS; i++)
559
    if (fi->saved_regs[i])
560
      adjust += 4;
561
 
562
  /* If we saved LIR, then it's most likely we used a `movm'
563
     instruction with the `other' bit set, in which case the SP is
564
     decremented by an extra four bytes, "to simplify calculation
565
     of the transfer area", according to the processor manual.  */
566
  if (fi->saved_regs[LIR_REGNUM])
567
    adjust += 4;
568
 
569
  return adjust;
570
}
571
 
572
 
573
/* Function: frame_chain
574
   Figure out and return the caller's frame pointer given current
575
   frame_info struct.
576
 
577
   We don't handle dummy frames yet but we would probably just return the
578
   stack pointer that was in use at the time the function call was made?  */
579
 
580
static CORE_ADDR
581
mn10300_frame_chain (struct frame_info *fi)
582
{
583
  struct frame_info *dummy;
584
  /* Walk through the prologue to determine the stack size,
585
     location of saved registers, end of the prologue, etc.  */
586
  if (fi->extra_info->status == 0)
587
    mn10300_analyze_prologue (fi, (CORE_ADDR) 0);
588
 
589
  /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES.  */
590
  if (fi->extra_info->status & NO_MORE_FRAMES)
591
    return 0;
592
 
593
  /* Now that we've analyzed our prologue, determine the frame
594
     pointer for our caller.
595
 
596
     If our caller has a frame pointer, then we need to
597
     find the entry value of $a3 to our function.
598
 
599
     If fsr.regs[A3_REGNUM] is nonzero, then it's at the memory
600
     location pointed to by fsr.regs[A3_REGNUM].
601
 
602
     Else it's still in $a3.
603
 
604
     If our caller does not have a frame pointer, then his
605
     frame base is fi->frame + -caller's stack size.  */
606
 
607
  /* The easiest way to get that info is to analyze our caller's frame.
608
     So we set up a dummy frame and call mn10300_analyze_prologue to
609
     find stuff for us.  */
610
  dummy = analyze_dummy_frame (FRAME_SAVED_PC (fi), fi->frame);
611
 
612
  if (dummy->extra_info->status & MY_FRAME_IN_FP)
613
    {
614
      /* Our caller has a frame pointer.  So find the frame in $a3 or
615
         in the stack.  */
616
      if (fi->saved_regs[A3_REGNUM])
617
        return (read_memory_integer (fi->saved_regs[A3_REGNUM], REGISTER_SIZE));
618
      else
619
        return read_register (A3_REGNUM);
620
    }
621
  else
622
    {
623
      int adjust = saved_regs_size (fi);
624
 
625
      /* Our caller does not have a frame pointer.  So his frame starts
626
         at the base of our frame (fi->frame) + register save space
627
         + <his size>.  */
628
      return fi->frame + adjust + -dummy->extra_info->stack_size;
629
    }
630
}
631
 
632
/* Function: skip_prologue
633
   Return the address of the first inst past the prologue of the function.  */
634
 
635
static CORE_ADDR
636
mn10300_skip_prologue (CORE_ADDR pc)
637
{
638
  /* We used to check the debug symbols, but that can lose if
639
     we have a null prologue.  */
640
  return mn10300_analyze_prologue (NULL, pc);
641
}
642
 
643
/* generic_pop_current_frame calls this function if the current
644
   frame isn't a dummy frame.  */
645
static void
646
mn10300_pop_frame_regular (struct frame_info *frame)
647
{
648
  int regnum;
649
 
650
  write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
651
 
652
  /* Restore any saved registers.  */
653
  for (regnum = 0; regnum < NUM_REGS; regnum++)
654
    if (frame->saved_regs[regnum] != 0)
655
      {
656
        ULONGEST value;
657
 
658
        value = read_memory_unsigned_integer (frame->saved_regs[regnum],
659
                                              REGISTER_RAW_SIZE (regnum));
660
        write_register (regnum, value);
661
      }
662
 
663
  /* Actually cut back the stack.  */
664
  write_register (SP_REGNUM, FRAME_FP (frame));
665
 
666
  /* Don't we need to set the PC?!?  XXX FIXME.  */
667
}
668
 
669
/* Function: pop_frame
670
   This routine gets called when either the user uses the `return'
671
   command, or the call dummy breakpoint gets hit.  */
672
static void
673
mn10300_pop_frame (void)
674
{
675
  /* This function checks for and handles generic dummy frames, and
676
     calls back to our function for ordinary frames.  */
677
  generic_pop_current_frame (mn10300_pop_frame_regular);
678
 
679
  /* Throw away any cached frame information.  */
680
  flush_cached_frames ();
681
}
682
 
683
/* Function: push_arguments
684
   Setup arguments for a call to the target.  Arguments go in
685
   order on the stack.  */
686
 
687
static CORE_ADDR
688
mn10300_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
689
                        int struct_return, CORE_ADDR struct_addr)
690
{
691
  int argnum = 0;
692
  int len = 0;
693
  int stack_offset = 0;
694
  int regsused = struct_return ? 1 : 0;
695
 
696
  /* This should be a nop, but align the stack just in case something
697
     went wrong.  Stacks are four byte aligned on the mn10300.  */
698
  sp &= ~3;
699
 
700
  /* Now make space on the stack for the args.
701
 
702
     XXX This doesn't appear to handle pass-by-invisible reference
703
     arguments.  */
704
  for (argnum = 0; argnum < nargs; argnum++)
705
    {
706
      int arg_length = (TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3;
707
 
708
      while (regsused < 2 && arg_length > 0)
709
        {
710
          regsused++;
711
          arg_length -= 4;
712
        }
713
      len += arg_length;
714
    }
715
 
716
  /* Allocate stack space.  */
717
  sp -= len;
718
 
719
  regsused = struct_return ? 1 : 0;
720
  /* Push all arguments onto the stack. */
721
  for (argnum = 0; argnum < nargs; argnum++)
722
    {
723
      int len;
724
      char *val;
725
 
726
      /* XXX Check this.  What about UNIONS?  */
727
      if (TYPE_CODE (VALUE_TYPE (*args)) == TYPE_CODE_STRUCT
728
          && TYPE_LENGTH (VALUE_TYPE (*args)) > 8)
729
        {
730
          /* XXX Wrong, we want a pointer to this argument.  */
731
          len = TYPE_LENGTH (VALUE_TYPE (*args));
732
          val = (char *) VALUE_CONTENTS (*args);
733
        }
734
      else
735
        {
736
          len = TYPE_LENGTH (VALUE_TYPE (*args));
737
          val = (char *) VALUE_CONTENTS (*args);
738
        }
739
 
740
      while (regsused < 2 && len > 0)
741
        {
742
          write_register (regsused, extract_unsigned_integer (val, 4));
743
          val += 4;
744
          len -= 4;
745
          regsused++;
746
        }
747
 
748
      while (len > 0)
749
        {
750
          write_memory (sp + stack_offset, val, 4);
751
          len -= 4;
752
          val += 4;
753
          stack_offset += 4;
754
        }
755
 
756
      args++;
757
    }
758
 
759
  /* Make space for the flushback area.  */
760
  sp -= 8;
761
  return sp;
762
}
763
 
764
/* Function: push_return_address (pc)
765
   Set up the return address for the inferior function call.
766
   Needed for targets where we don't actually execute a JSR/BSR instruction */
767
 
768
static CORE_ADDR
769
mn10300_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
770
{
771
  unsigned char buf[4];
772
 
773
  store_unsigned_integer (buf, 4, CALL_DUMMY_ADDRESS ());
774
  write_memory (sp - 4, buf, 4);
775
  return sp - 4;
776
}
777
 
778
/* Function: store_struct_return (addr,sp)
779
   Store the structure value return address for an inferior function
780
   call.  */
781
 
782
static void
783
mn10300_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
784
{
785
  /* The structure return address is passed as the first argument.  */
786
  write_register (0, addr);
787
}
788
 
789
/* Function: frame_saved_pc
790
   Find the caller of this frame.  We do this by seeing if RP_REGNUM
791
   is saved in the stack anywhere, otherwise we get it from the
792
   registers.  If the inner frame is a dummy frame, return its PC
793
   instead of RP, because that's where "caller" of the dummy-frame
794
   will be found.  */
795
 
796
static CORE_ADDR
797
mn10300_frame_saved_pc (struct frame_info *fi)
798
{
799
  int adjust = saved_regs_size (fi);
800
 
801
  return (read_memory_integer (fi->frame + adjust, REGISTER_SIZE));
802
}
803
 
804
/* Function: mn10300_init_extra_frame_info
805
   Setup the frame's frame pointer, pc, and frame addresses for saved
806
   registers.  Most of the work is done in mn10300_analyze_prologue().
807
 
808
   Note that when we are called for the last frame (currently active frame),
809
   that fi->pc and fi->frame will already be setup.  However, fi->frame will
810
   be valid only if this routine uses FP.  For previous frames, fi-frame will
811
   always be correct.  mn10300_analyze_prologue will fix fi->frame if
812
   it's not valid.
813
 
814
   We can be called with the PC in the call dummy under two circumstances.
815
   First, during normal backtracing, second, while figuring out the frame
816
   pointer just prior to calling the target function (see run_stack_dummy).  */
817
 
818
static void
819
mn10300_init_extra_frame_info (int fromleaf, struct frame_info *fi)
820
{
821
  if (fi->next)
822
    fi->pc = FRAME_SAVED_PC (fi->next);
823
 
824
  frame_saved_regs_zalloc (fi);
825
  fi->extra_info = (struct frame_extra_info *)
826
    frame_obstack_alloc (sizeof (struct frame_extra_info));
827
 
828
  fi->extra_info->status = 0;
829
  fi->extra_info->stack_size = 0;
830
 
831
  mn10300_analyze_prologue (fi, 0);
832
}
833
 
834
 
835
/* This function's job is handled by init_extra_frame_info.  */
836
static void
837
mn10300_frame_init_saved_regs (struct frame_info *frame)
838
{
839
}
840
 
841
 
842
/* Function: mn10300_virtual_frame_pointer
843
   Return the register that the function uses for a frame pointer,
844
   plus any necessary offset to be applied to the register before
845
   any frame pointer offsets.  */
846
 
847
void
848
mn10300_virtual_frame_pointer (CORE_ADDR pc, long *reg, long *offset)
849
{
850
  struct frame_info *dummy = analyze_dummy_frame (pc, 0);
851
  /* Set up a dummy frame_info, Analyze the prolog and fill in the
852
     extra info.  */
853
  /* Results will tell us which type of frame it uses.  */
854
  if (dummy->extra_info->status & MY_FRAME_IN_SP)
855
    {
856
      *reg = SP_REGNUM;
857
      *offset = -(dummy->extra_info->stack_size);
858
    }
859
  else
860
    {
861
      *reg = A3_REGNUM;
862
      *offset = 0;
863
    }
864
}
865
 
866
static int
867
mn10300_reg_struct_has_addr (int gcc_p, struct type *type)
868
{
869
  return (TYPE_LENGTH (type) > 8);
870
}
871
 
872
static struct type *
873
mn10300_register_virtual_type (int reg)
874
{
875
  return builtin_type_int;
876
}
877
 
878
static int
879
mn10300_register_byte (int reg)
880
{
881
  return (reg * 4);
882
}
883
 
884
static int
885
mn10300_register_virtual_size (int reg)
886
{
887
  return 4;
888
}
889
 
890
static int
891
mn10300_register_raw_size (int reg)
892
{
893
  return 4;
894
}
895
 
896
/* If DWARF2 is a register number appearing in Dwarf2 debug info, then
897
   mn10300_dwarf2_reg_to_regnum (DWARF2) is the corresponding GDB
898
   register number.  Why don't Dwarf2 and GDB use the same numbering?
899
   Who knows?  But since people have object files lying around with
900
   the existing Dwarf2 numbering, and other people have written stubs
901
   to work with the existing GDB, neither of them can change.  So we
902
   just have to cope.  */
903
static int
904
mn10300_dwarf2_reg_to_regnum (int dwarf2)
905
{
906
  /* This table is supposed to be shaped like the REGISTER_NAMES
907
     initializer in gcc/config/mn10300/mn10300.h.  Registers which
908
     appear in GCC's numbering, but have no counterpart in GDB's
909
     world, are marked with a -1.  */
910
  static int dwarf2_to_gdb[] = {
911
    0,  1,  2,  3,  4,  5,  6,  7, -1, 8,
912
    15, 16, 17, 18, 19, 20, 21, 22
913
  };
914
  int gdb;
915
 
916
  if (dwarf2 < 0
917
      || dwarf2 >= (sizeof (dwarf2_to_gdb) / sizeof (dwarf2_to_gdb[0]))
918
      || dwarf2_to_gdb[dwarf2] == -1)
919
    internal_error (__FILE__, __LINE__,
920
                    "bogus register number in debug info: %d", dwarf2);
921
 
922
  return dwarf2_to_gdb[dwarf2];
923
}
924
 
925
static void
926
mn10300_print_register (const char *name, int regnum, int reg_width)
927
{
928
  char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
929
 
930
  if (reg_width)
931
    printf_filtered ("%*s: ", reg_width, name);
932
  else
933
    printf_filtered ("%s: ", name);
934
 
935
  /* Get the data */
936
  if (read_relative_register_raw_bytes (regnum, raw_buffer))
937
    {
938
      printf_filtered ("[invalid]");
939
      return;
940
    }
941
  else
942
    {
943
      int byte;
944
      if (TARGET_BYTE_ORDER == BIG_ENDIAN)
945
        {
946
          for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
947
               byte < REGISTER_RAW_SIZE (regnum);
948
               byte++)
949
            printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
950
        }
951
      else
952
        {
953
          for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
954
               byte >= 0;
955
               byte--)
956
            printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
957
        }
958
    }
959
}
960
 
961
static void
962
mn10300_do_registers_info (int regnum, int fpregs)
963
{
964
  if (regnum >= 0)
965
    {
966
      const char *name = REGISTER_NAME (regnum);
967
      if (name == NULL || name[0] == '\0')
968
        error ("Not a valid register for the current processor type");
969
      mn10300_print_register (name, regnum, 0);
970
      printf_filtered ("\n");
971
    }
972
  else
973
    {
974
      /* print registers in an array 4x8 */
975
      int r;
976
      int reg;
977
      const int nr_in_row = 4;
978
      const int reg_width = 4;
979
      for (r = 0; r < NUM_REGS; r += nr_in_row)
980
        {
981
          int c;
982
          int printing = 0;
983
          int padding = 0;
984
          for (c = r; c < r + nr_in_row; c++)
985
            {
986
              const char *name = REGISTER_NAME (c);
987
              if (name != NULL && *name != '\0')
988
                {
989
                  printing = 1;
990
                  while (padding > 0)
991
                    {
992
                      printf_filtered (" ");
993
                      padding--;
994
                    }
995
                  mn10300_print_register (name, c, reg_width);
996
                  printf_filtered (" ");
997
                }
998
              else
999
                {
1000
                  padding += (reg_width + 2 + 8 + 1);
1001
                }
1002
            }
1003
          if (printing)
1004
            printf_filtered ("\n");
1005
        }
1006
    }
1007
}
1008
 
1009
/* Dump out the mn10300 speciic architecture information. */
1010
 
1011
static void
1012
mn10300_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
1013
{
1014
  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1015
  fprintf_unfiltered (file, "mn10300_dump_tdep: am33_mode = %d\n",
1016
                      tdep->am33_mode);
1017
}
1018
 
1019
static struct gdbarch *
1020
mn10300_gdbarch_init (struct gdbarch_info info,
1021
                      struct gdbarch_list *arches)
1022
{
1023
  static LONGEST mn10300_call_dummy_words[] = { 0 };
1024
  struct gdbarch *gdbarch;
1025
  struct gdbarch_tdep *tdep = NULL;
1026
  int am33_mode;
1027
  gdbarch_register_name_ftype *register_name;
1028
  int mach;
1029
  int num_regs;
1030
 
1031
  arches = gdbarch_list_lookup_by_info (arches, &info);
1032
  if (arches != NULL)
1033
    return arches->gdbarch;
1034
  tdep = xmalloc (sizeof (struct gdbarch_tdep));
1035
  gdbarch = gdbarch_alloc (&info, tdep);
1036
 
1037
  if (info.bfd_arch_info != NULL
1038
      && info.bfd_arch_info->arch == bfd_arch_mn10300)
1039
    mach = info.bfd_arch_info->mach;
1040
  else
1041
    mach = 0;
1042
  switch (mach)
1043
    {
1044
    case 0:
1045
    case bfd_mach_mn10300:
1046
      am33_mode = 0;
1047
      register_name = mn10300_generic_register_name;
1048
      num_regs = 32;
1049
      break;
1050
    case bfd_mach_am33:
1051
      am33_mode = 1;
1052
      register_name = am33_register_name;
1053
      num_regs = 32;
1054
      break;
1055
    default:
1056
      internal_error (__FILE__, __LINE__,
1057
                      "mn10300_gdbarch_init: Unknown mn10300 variant");
1058
      return NULL; /* keep GCC happy. */
1059
    }
1060
 
1061
  /* Registers.  */
1062
  set_gdbarch_num_regs (gdbarch, num_regs);
1063
  set_gdbarch_register_name (gdbarch, register_name);
1064
  set_gdbarch_register_size (gdbarch, 4);
1065
  set_gdbarch_register_bytes (gdbarch,
1066
                              num_regs * gdbarch_register_size (gdbarch));
1067
  set_gdbarch_max_register_raw_size (gdbarch, 4);
1068
  set_gdbarch_register_raw_size (gdbarch, mn10300_register_raw_size);
1069
  set_gdbarch_register_byte (gdbarch, mn10300_register_byte);
1070
  set_gdbarch_max_register_virtual_size (gdbarch, 4);
1071
  set_gdbarch_register_virtual_size (gdbarch, mn10300_register_virtual_size);
1072
  set_gdbarch_register_virtual_type (gdbarch, mn10300_register_virtual_type);
1073
  set_gdbarch_dwarf2_reg_to_regnum (gdbarch, mn10300_dwarf2_reg_to_regnum);
1074
  set_gdbarch_do_registers_info (gdbarch, mn10300_do_registers_info);
1075
  set_gdbarch_fp_regnum (gdbarch, 31);
1076
 
1077
  /* Breakpoints.  */
1078
  set_gdbarch_breakpoint_from_pc (gdbarch, mn10300_breakpoint_from_pc);
1079
  set_gdbarch_function_start_offset (gdbarch, 0);
1080
  set_gdbarch_decr_pc_after_break (gdbarch, 0);
1081
 
1082
  /* Stack unwinding.  */
1083
  set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register);
1084
  set_gdbarch_frame_chain_valid (gdbarch, generic_file_frame_chain_valid);
1085
  set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1086
  set_gdbarch_frame_chain_valid (gdbarch, generic_file_frame_chain_valid);
1087
  set_gdbarch_saved_pc_after_call (gdbarch, mn10300_saved_pc_after_call);
1088
  set_gdbarch_init_extra_frame_info (gdbarch, mn10300_init_extra_frame_info);
1089
  set_gdbarch_frame_init_saved_regs (gdbarch, mn10300_frame_init_saved_regs);
1090
  set_gdbarch_frame_chain (gdbarch, mn10300_frame_chain);
1091
  set_gdbarch_frame_saved_pc (gdbarch, mn10300_frame_saved_pc);
1092
  set_gdbarch_extract_return_value (gdbarch, mn10300_extract_return_value);
1093
  set_gdbarch_extract_struct_value_address
1094
    (gdbarch, mn10300_extract_struct_value_address);
1095
  set_gdbarch_store_return_value (gdbarch, mn10300_store_return_value);
1096
  set_gdbarch_store_struct_return (gdbarch, mn10300_store_struct_return);
1097
  set_gdbarch_pop_frame (gdbarch, mn10300_pop_frame);
1098
  set_gdbarch_skip_prologue (gdbarch, mn10300_skip_prologue);
1099
  set_gdbarch_frame_args_skip (gdbarch, 0);
1100
  set_gdbarch_frame_args_address (gdbarch, default_frame_address);
1101
  set_gdbarch_frame_locals_address (gdbarch, default_frame_address);
1102
  set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
1103
  /* That's right, we're using the stack pointer as our frame pointer.  */
1104
  set_gdbarch_read_fp (gdbarch, generic_target_read_sp);
1105
 
1106
  /* Calling functions in the inferior from GDB.  */
1107
  set_gdbarch_call_dummy_p (gdbarch, 1);
1108
  set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
1109
  set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
1110
  set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
1111
  set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
1112
  set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
1113
  set_gdbarch_call_dummy_words (gdbarch, mn10300_call_dummy_words);
1114
  set_gdbarch_sizeof_call_dummy_words (gdbarch,
1115
                                       sizeof (mn10300_call_dummy_words));
1116
  set_gdbarch_call_dummy_length (gdbarch, 0);
1117
  set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
1118
  set_gdbarch_call_dummy_start_offset (gdbarch, 0);
1119
  set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_at_entry_point);
1120
  set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
1121
  set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
1122
  set_gdbarch_push_arguments (gdbarch, mn10300_push_arguments);
1123
  set_gdbarch_reg_struct_has_addr (gdbarch, mn10300_reg_struct_has_addr);
1124
  set_gdbarch_push_return_address (gdbarch, mn10300_push_return_address);
1125
  set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
1126
  set_gdbarch_use_struct_convention (gdbarch, mn10300_use_struct_convention);
1127
 
1128
  tdep->am33_mode = am33_mode;
1129
 
1130
  return gdbarch;
1131
}
1132
 
1133
void
1134
_initialize_mn10300_tdep (void)
1135
{
1136
/*  printf("_initialize_mn10300_tdep\n"); */
1137
 
1138
  tm_print_insn = print_insn_mn10300;
1139
 
1140
  register_gdbarch_init (bfd_arch_mn10300, mn10300_gdbarch_init);
1141
}

powered by: WebSVN 2.1.0

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