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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [iq2000-tdep.c] - Blame information for rev 24

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

Line No. Rev Author Line
1 24 jeremybenn
/* Target-dependent code for the IQ2000 architecture, for GDB, the GNU
2
   Debugger.
3
 
4
   Copyright (C) 2000, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
5
 
6
   Contributed by Red Hat.
7
 
8
   This file is part of GDB.
9
 
10
   This program is free software; you can redistribute it and/or modify
11
   it under the terms of the GNU General Public License as published by
12
   the Free Software Foundation; either version 3 of the License, or
13
   (at your option) any later version.
14
 
15
   This program is distributed in the hope that it will be useful,
16
   but WITHOUT ANY WARRANTY; without even the implied warranty of
17
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
   GNU General Public License for more details.
19
 
20
   You should have received a copy of the GNU General Public License
21
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
 
23
#include "defs.h"
24
#include "frame.h"
25
#include "frame-base.h"
26
#include "frame-unwind.h"
27
#include "dwarf2-frame.h"
28
#include "gdbtypes.h"
29
#include "value.h"
30
#include "dis-asm.h"
31
#include "gdb_string.h"
32
#include "arch-utils.h"
33
#include "regcache.h"
34
#include "osabi.h"
35
#include "gdbcore.h"
36
 
37
enum gdb_regnum
38
{
39
  E_R0_REGNUM,  E_R1_REGNUM,  E_R2_REGNUM,  E_R3_REGNUM,
40
  E_R4_REGNUM,  E_R5_REGNUM,  E_R6_REGNUM,  E_R7_REGNUM,
41
  E_R8_REGNUM,  E_R9_REGNUM,  E_R10_REGNUM, E_R11_REGNUM,
42
  E_R12_REGNUM, E_R13_REGNUM, E_R14_REGNUM, E_R15_REGNUM,
43
  E_R16_REGNUM, E_R17_REGNUM, E_R18_REGNUM, E_R19_REGNUM,
44
  E_R20_REGNUM, E_R21_REGNUM, E_R22_REGNUM, E_R23_REGNUM,
45
  E_R24_REGNUM, E_R25_REGNUM, E_R26_REGNUM, E_R27_REGNUM,
46
  E_R28_REGNUM, E_R29_REGNUM, E_R30_REGNUM, E_R31_REGNUM,
47
  E_PC_REGNUM,
48
  E_LR_REGNUM        = E_R31_REGNUM, /* Link register.  */
49
  E_SP_REGNUM        = E_R29_REGNUM, /* Stack pointer.  */
50
  E_FP_REGNUM        = E_R27_REGNUM, /* Frame pointer.  */
51
  E_FN_RETURN_REGNUM = E_R2_REGNUM,  /* Function return value register.  */
52
  E_1ST_ARGREG       = E_R4_REGNUM,  /* 1st  function arg register.  */
53
  E_LAST_ARGREG      = E_R11_REGNUM, /* Last function arg register.  */
54
  E_NUM_REGS         = E_PC_REGNUM + 1
55
};
56
 
57
/* Use an invalid address value as 'not available' marker.  */
58
enum { REG_UNAVAIL = (CORE_ADDR) -1 };
59
 
60
struct iq2000_frame_cache
61
{
62
  /* Base address.  */
63
  CORE_ADDR  base;
64
  CORE_ADDR  pc;
65
  LONGEST    framesize;
66
  int        using_fp;
67
  CORE_ADDR  saved_sp;
68
  CORE_ADDR  saved_regs [E_NUM_REGS];
69
};
70
 
71
/* Harvard methods: */
72
 
73
static CORE_ADDR
74
insn_ptr_from_addr (CORE_ADDR addr)     /* CORE_ADDR to target pointer.  */
75
{
76
  return addr & 0x7fffffffL;
77
}
78
 
79
static CORE_ADDR
80
insn_addr_from_ptr (CORE_ADDR ptr)      /* target_pointer to CORE_ADDR.  */
81
{
82
  return (ptr & 0x7fffffffL) | 0x80000000L;
83
}
84
 
85
/* Function: pointer_to_address
86
   Convert a target pointer to an address in host (CORE_ADDR) format. */
87
 
88
static CORE_ADDR
89
iq2000_pointer_to_address (struct type * type, const gdb_byte * buf)
90
{
91
  enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
92
  CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
93
 
94
  if (target == TYPE_CODE_FUNC
95
      || target == TYPE_CODE_METHOD
96
      || (TYPE_FLAGS (TYPE_TARGET_TYPE (type)) & TYPE_FLAG_CODE_SPACE) != 0)
97
    addr = insn_addr_from_ptr (addr);
98
 
99
  return addr;
100
}
101
 
102
/* Function: address_to_pointer
103
   Convert a host-format address (CORE_ADDR) into a target pointer.  */
104
 
105
static void
106
iq2000_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr)
107
{
108
  enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
109
 
110
  if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
111
    addr = insn_ptr_from_addr (addr);
112
  store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
113
}
114
 
115
/* Real register methods: */
116
 
117
/* Function: register_name
118
   Returns the name of the iq2000 register number N.  */
119
 
120
static const char *
121
iq2000_register_name (struct gdbarch *gdbarch, int regnum)
122
{
123
  static const char * names[E_NUM_REGS] =
124
    {
125
      "r0",  "r1",  "r2",  "r3",  "r4",
126
      "r5",  "r6",  "r7",  "r8",  "r9",
127
      "r10", "r11", "r12", "r13", "r14",
128
      "r15", "r16", "r17", "r18", "r19",
129
      "r20", "r21", "r22", "r23", "r24",
130
      "r25", "r26", "r27", "r28", "r29",
131
      "r30", "r31",
132
      "pc"
133
    };
134
  if (regnum < 0 || regnum >= E_NUM_REGS)
135
    return NULL;
136
  return names[regnum];
137
}
138
 
139
/* Prologue analysis methods:  */
140
 
141
/* ADDIU insn (001001 rs(5) rt(5) imm(16)).  */
142
#define INSN_IS_ADDIU(X)        (((X) & 0xfc000000) == 0x24000000) 
143
#define ADDIU_REG_SRC(X)        (((X) & 0x03e00000) >> 21)
144
#define ADDIU_REG_TGT(X)        (((X) & 0x001f0000) >> 16)
145
#define ADDIU_IMMEDIATE(X)      ((signed short) ((X) & 0x0000ffff))
146
 
147
/* "MOVE" (OR) insn (000000 rs(5) rt(5) rd(5) 00000 100101).  */
148
#define INSN_IS_MOVE(X)         (((X) & 0xffe007ff) == 0x00000025)
149
#define MOVE_REG_SRC(X)         (((X) & 0x001f0000) >> 16)
150
#define MOVE_REG_TGT(X)         (((X) & 0x0000f800) >> 11)
151
 
152
/* STORE WORD insn (101011 rs(5) rt(5) offset(16)).  */
153
#define INSN_IS_STORE_WORD(X)   (((X) & 0xfc000000) == 0xac000000)
154
#define SW_REG_INDEX(X)         (((X) & 0x03e00000) >> 21)
155
#define SW_REG_SRC(X)           (((X) & 0x001f0000) >> 16)
156
#define SW_OFFSET(X)            ((signed short) ((X) & 0x0000ffff))
157
 
158
/* Function: find_last_line_symbol
159
 
160
   Given an address range, first find a line symbol corresponding to
161
   the starting address.  Then find the last line symbol within the
162
   range that has a line number less than or equal to the first line.
163
 
164
   For optimized code with code motion, this finds the last address
165
   for the lowest-numbered line within the address range.  */
166
 
167
static struct symtab_and_line
168
find_last_line_symbol (CORE_ADDR start, CORE_ADDR end, int notcurrent)
169
{
170
  struct symtab_and_line sal = find_pc_line (start, notcurrent);
171
  struct symtab_and_line best_sal = sal;
172
 
173
  if (sal.pc == 0 || sal.line == 0 || sal.end == 0)
174
    return sal;
175
 
176
  do
177
    {
178
      if (sal.line && sal.line <= best_sal.line)
179
        best_sal = sal;
180
      sal = find_pc_line (sal.end, notcurrent);
181
    }
182
  while (sal.pc && sal.pc < end);
183
 
184
  return best_sal;
185
}
186
 
187
/* Function: scan_prologue
188
   Decode the instructions within the given address range.
189
   Decide when we must have reached the end of the function prologue.
190
   If a frame_info pointer is provided, fill in its prologue information.
191
 
192
   Returns the address of the first instruction after the prologue.  */
193
 
194
static CORE_ADDR
195
iq2000_scan_prologue (CORE_ADDR scan_start,
196
                      CORE_ADDR scan_end,
197
                      struct frame_info *fi,
198
                      struct iq2000_frame_cache *cache)
199
{
200
  struct symtab_and_line sal;
201
  CORE_ADDR pc;
202
  CORE_ADDR loop_end;
203
  int found_store_lr = 0;
204
  int found_decr_sp = 0;
205
  int srcreg;
206
  int tgtreg;
207
  signed short offset;
208
 
209
  if (scan_end == (CORE_ADDR) 0)
210
    {
211
      loop_end = scan_start + 100;
212
      sal.end = sal.pc = 0;
213
    }
214
  else
215
    {
216
      loop_end = scan_end;
217
      if (fi)
218
        sal = find_last_line_symbol (scan_start, scan_end, 0);
219
    }
220
 
221
  /* Saved registers:
222
     We first have to save the saved register's offset, and
223
     only later do we compute its actual address.  Since the
224
     offset can be zero, we must first initialize all the
225
     saved regs to minus one (so we can later distinguish
226
     between one that's not saved, and one that's saved at zero). */
227
  for (srcreg = 0; srcreg < E_NUM_REGS; srcreg ++)
228
    cache->saved_regs[srcreg] = -1;
229
  cache->using_fp = 0;
230
  cache->framesize = 0;
231
 
232
  for (pc = scan_start; pc < loop_end; pc += 4)
233
    {
234
      LONGEST insn = read_memory_unsigned_integer (pc, 4);
235
      /* Skip any instructions writing to (sp) or decrementing the
236
         SP. */
237
      if ((insn & 0xffe00000) == 0xac200000)
238
        {
239
          /* sw using SP/%1 as base.  */
240
          /* LEGACY -- from assembly-only port.  */
241
          tgtreg = ((insn >> 16) & 0x1f);
242
          if (tgtreg >= 0 && tgtreg < E_NUM_REGS)
243
            cache->saved_regs[tgtreg] = -((signed short) (insn & 0xffff));
244
 
245
          if (tgtreg == E_LR_REGNUM)
246
            found_store_lr = 1;
247
          continue;
248
        }
249
 
250
      if ((insn & 0xffff8000) == 0x20218000)
251
        {
252
          /* addi %1, %1, -N == addi %sp, %sp, -N */
253
          /* LEGACY -- from assembly-only port */
254
          found_decr_sp = 1;
255
          cache->framesize = -((signed short) (insn & 0xffff));
256
          continue;
257
        }
258
 
259
      if (INSN_IS_ADDIU (insn))
260
        {
261
          srcreg = ADDIU_REG_SRC (insn);
262
          tgtreg = ADDIU_REG_TGT (insn);
263
          offset = ADDIU_IMMEDIATE (insn);
264
          if (srcreg == E_SP_REGNUM && tgtreg == E_SP_REGNUM)
265
            cache->framesize = -offset;
266
          continue;
267
        }
268
 
269
      if (INSN_IS_STORE_WORD (insn))
270
        {
271
          srcreg = SW_REG_SRC (insn);
272
          tgtreg = SW_REG_INDEX (insn);
273
          offset = SW_OFFSET (insn);
274
 
275
          if (tgtreg == E_SP_REGNUM || tgtreg == E_FP_REGNUM)
276
            {
277
              /* "push" to stack (via SP or FP reg) */
278
              if (cache->saved_regs[srcreg] == -1) /* Don't save twice.  */
279
                cache->saved_regs[srcreg] = offset;
280
              continue;
281
            }
282
        }
283
 
284
      if (INSN_IS_MOVE (insn))
285
        {
286
          srcreg = MOVE_REG_SRC (insn);
287
          tgtreg = MOVE_REG_TGT (insn);
288
 
289
          if (srcreg == E_SP_REGNUM && tgtreg == E_FP_REGNUM)
290
            {
291
              /* Copy sp to fp.  */
292
              cache->using_fp = 1;
293
              continue;
294
            }
295
        }
296
 
297
      /* Unknown instruction encountered in frame.  Bail out?
298
         1) If we have a subsequent line symbol, we can keep going.
299
         2) If not, we need to bail out and quit scanning instructions.  */
300
 
301
      if (fi && sal.end && (pc < sal.end)) /* Keep scanning.  */
302
        continue;
303
      else /* bail */
304
        break;
305
    }
306
 
307
  return pc;
308
}
309
 
310
static void
311
iq2000_init_frame_cache (struct iq2000_frame_cache *cache)
312
{
313
  int i;
314
 
315
  cache->base = 0;
316
  cache->framesize = 0;
317
  cache->using_fp = 0;
318
  cache->saved_sp = 0;
319
  for (i = 0; i < E_NUM_REGS; i++)
320
    cache->saved_regs[i] = -1;
321
}
322
 
323
/* Function: iq2000_skip_prologue
324
   If the input address is in a function prologue,
325
   returns the address of the end of the prologue;
326
   else returns the input address.
327
 
328
   Note: the input address is likely to be the function start,
329
   since this function is mainly used for advancing a breakpoint
330
   to the first line, or stepping to the first line when we have
331
   stepped into a function call.  */
332
 
333
static CORE_ADDR
334
iq2000_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
335
{
336
  CORE_ADDR func_addr = 0 , func_end = 0;
337
 
338
  if (find_pc_partial_function (pc, NULL, & func_addr, & func_end))
339
    {
340
      struct symtab_and_line sal;
341
      struct iq2000_frame_cache cache;
342
 
343
      /* Found a function.  */
344
      sal = find_pc_line (func_addr, 0);
345
      if (sal.end && sal.end < func_end)
346
        /* Found a line number, use it as end of prologue.  */
347
        return sal.end;
348
 
349
      /* No useable line symbol.  Use prologue parsing method.  */
350
      iq2000_init_frame_cache (&cache);
351
      return iq2000_scan_prologue (func_addr, func_end, NULL, &cache);
352
    }
353
 
354
  /* No function symbol -- just return the PC.  */
355
  return (CORE_ADDR) pc;
356
}
357
 
358
static struct iq2000_frame_cache *
359
iq2000_frame_cache (struct frame_info *next_frame, void **this_cache)
360
{
361
  struct iq2000_frame_cache *cache;
362
  CORE_ADDR current_pc;
363
  int i;
364
 
365
  if (*this_cache)
366
    return *this_cache;
367
 
368
  cache = FRAME_OBSTACK_ZALLOC (struct iq2000_frame_cache);
369
  iq2000_init_frame_cache (cache);
370
  *this_cache = cache;
371
 
372
  cache->base = frame_unwind_register_unsigned (next_frame, E_FP_REGNUM);
373
  //if (cache->base == 0)
374
    //return cache;
375
 
376
  current_pc = frame_pc_unwind (next_frame);
377
  find_pc_partial_function (current_pc, NULL, &cache->pc, NULL);
378
  if (cache->pc != 0)
379
    iq2000_scan_prologue (cache->pc, current_pc, next_frame, cache);
380
  if (!cache->using_fp)
381
    cache->base = frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
382
 
383
  cache->saved_sp = cache->base + cache->framesize;
384
 
385
  for (i = 0; i < E_NUM_REGS; i++)
386
    if (cache->saved_regs[i] != -1)
387
      cache->saved_regs[i] += cache->base;
388
 
389
  return cache;
390
}
391
 
392
static void
393
iq2000_frame_prev_register (struct frame_info *next_frame, void **this_cache,
394
                            int regnum, int *optimizedp,
395
                            enum lval_type *lvalp, CORE_ADDR *addrp,
396
                            int *realnump, gdb_byte *valuep)
397
{
398
  struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
399
  if (regnum == E_SP_REGNUM && cache->saved_sp)
400
    {
401
      *optimizedp = 0;
402
      *lvalp = not_lval;
403
      *addrp = 0;
404
      *realnump = -1;
405
      if (valuep)
406
        store_unsigned_integer (valuep, 4, cache->saved_sp);
407
      return;
408
    }
409
 
410
  if (regnum == E_PC_REGNUM)
411
    regnum = E_LR_REGNUM;
412
 
413
  if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != -1)
414
    {
415
      *optimizedp = 0;
416
      *lvalp = lval_memory;
417
      *addrp = cache->saved_regs[regnum];
418
      *realnump = -1;
419
      if (valuep)
420
        read_memory (*addrp, valuep,
421
                     register_size (get_frame_arch (next_frame), regnum));
422
      return;
423
    }
424
 
425
  *optimizedp = 0;
426
  *lvalp = lval_register;
427
  *addrp = 0;
428
  *realnump = regnum;
429
  if (valuep)
430
    frame_unwind_register (next_frame, (*realnump), valuep);
431
}
432
 
433
static void
434
iq2000_frame_this_id (struct frame_info *next_frame, void **this_cache,
435
                      struct frame_id *this_id)
436
{
437
  struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
438
 
439
  /* This marks the outermost frame.  */
440
  if (cache->base == 0)
441
    return;
442
 
443
  *this_id = frame_id_build (cache->saved_sp, cache->pc);
444
}
445
 
446
static const struct frame_unwind iq2000_frame_unwind = {
447
  NORMAL_FRAME,
448
  iq2000_frame_this_id,
449
  iq2000_frame_prev_register
450
};
451
 
452
static const struct frame_unwind *
453
iq2000_frame_sniffer (struct frame_info *next_frame)
454
{
455
  return &iq2000_frame_unwind;
456
}
457
 
458
static CORE_ADDR
459
iq2000_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
460
{
461
  return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
462
}
463
 
464
static CORE_ADDR
465
iq2000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
466
{
467
  return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
468
}
469
 
470
static struct frame_id
471
iq2000_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
472
{
473
  return frame_id_build (iq2000_unwind_sp (gdbarch, next_frame),
474
                         frame_pc_unwind (next_frame));
475
}
476
 
477
static CORE_ADDR
478
iq2000_frame_base_address (struct frame_info *next_frame, void **this_cache)
479
{
480
  struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
481
 
482
  return cache->base;
483
}
484
 
485
static const struct frame_base iq2000_frame_base = {
486
  &iq2000_frame_unwind,
487
  iq2000_frame_base_address,
488
  iq2000_frame_base_address,
489
  iq2000_frame_base_address
490
};
491
 
492
static const unsigned char *
493
iq2000_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
494
                           int *lenptr)
495
{
496
  static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d };
497
  static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 };
498
 
499
  if ((*pcptr & 3) != 0)
500
    error ("breakpoint_from_pc: invalid breakpoint address 0x%lx",
501
           (long) *pcptr);
502
 
503
  *lenptr = 4;
504
  return (gdbarch_byte_order (gdbarch)
505
          == BFD_ENDIAN_BIG) ? big_breakpoint : little_breakpoint;
506
}
507
 
508
/* Target function return value methods: */
509
 
510
/* Function: store_return_value
511
   Copy the function return value from VALBUF into the
512
   proper location for a function return.  */
513
 
514
static void
515
iq2000_store_return_value (struct type *type, struct regcache *regcache,
516
                           const void *valbuf)
517
{
518
  int len = TYPE_LENGTH (type);
519
  int regno = E_FN_RETURN_REGNUM;
520
 
521
  while (len > 0)
522
    {
523
      char buf[4];
524
      int size = len % 4 ?: 4;
525
 
526
      memset (buf, 0, 4);
527
      memcpy (buf + 4 - size, valbuf, size);
528
      regcache_raw_write (regcache, regno++, buf);
529
      len -= size;
530
      valbuf = ((char *) valbuf) + size;
531
    }
532
}
533
 
534
/* Function: use_struct_convention
535
   Returns non-zero if the given struct type will be returned using
536
   a special convention, rather than the normal function return method.  */
537
 
538
static int
539
iq2000_use_struct_convention (struct type *type)
540
{
541
  return ((TYPE_CODE (type) == TYPE_CODE_STRUCT)
542
          || (TYPE_CODE (type) == TYPE_CODE_UNION))
543
         && TYPE_LENGTH (type) > 8;
544
}
545
 
546
/* Function: extract_return_value
547
   Copy the function's return value into VALBUF.
548
   This function is called only in the context of "target function calls",
549
   ie. when the debugger forces a function to be called in the child, and
550
   when the debugger forces a function to return prematurely via the
551
   "return" command.  */
552
 
553
static void
554
iq2000_extract_return_value (struct type *type, struct regcache *regcache,
555
                             void *valbuf)
556
{
557
  /* If the function's return value is 8 bytes or less, it is
558
     returned in a register, and if larger than 8 bytes, it is
559
     returned in a stack location which is pointed to by the same
560
     register.  */
561
  int len = TYPE_LENGTH (type);
562
 
563
  if (len <= (2 * 4))
564
    {
565
      int regno = E_FN_RETURN_REGNUM;
566
 
567
      /* Return values of <= 8 bytes are returned in
568
         FN_RETURN_REGNUM.  */
569
      while (len > 0)
570
        {
571
          ULONGEST tmp;
572
          int size = len % 4 ?: 4;
573
 
574
          /* By using store_unsigned_integer we avoid having to
575
             do anything special for small big-endian values.  */
576
          regcache_cooked_read_unsigned (regcache, regno++, &tmp);
577
          store_unsigned_integer (valbuf, size, tmp);
578
          len -= size;
579
          valbuf = ((char *) valbuf) + size;
580
        }
581
    }
582
  else
583
    {
584
      /* Return values > 8 bytes are returned in memory,
585
         pointed to by FN_RETURN_REGNUM.  */
586
      ULONGEST return_buffer;
587
      regcache_cooked_read_unsigned (regcache, E_FN_RETURN_REGNUM,
588
                                     &return_buffer);
589
      read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
590
    }
591
}
592
 
593
static enum return_value_convention
594
iq2000_return_value (struct gdbarch *gdbarch, struct type *type,
595
                     struct regcache *regcache,
596
                     gdb_byte *readbuf, const gdb_byte *writebuf)
597
{
598
  if (iq2000_use_struct_convention (type))
599
    return RETURN_VALUE_STRUCT_CONVENTION;
600
  if (writebuf)
601
    iq2000_store_return_value (type, regcache, writebuf);
602
  else if (readbuf)
603
    iq2000_extract_return_value (type, regcache, readbuf);
604
  return RETURN_VALUE_REGISTER_CONVENTION;
605
}
606
 
607
/* Function: register_virtual_type
608
   Returns the default type for register N.  */
609
 
610
static struct type *
611
iq2000_register_type (struct gdbarch *gdbarch, int regnum)
612
{
613
  return builtin_type_int32;
614
}
615
 
616
static CORE_ADDR
617
iq2000_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
618
{
619
  /* This is the same frame alignment used by gcc.  */
620
  return ((sp + 7) & ~7);
621
}
622
 
623
/* Convenience function to check 8-byte types for being a scalar type
624
   or a struct with only one long long or double member. */
625
static int
626
iq2000_pass_8bytetype_by_address (struct type *type)
627
{
628
  struct type *ftype;
629
 
630
  /* Skip typedefs.  */
631
  while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
632
    type = TYPE_TARGET_TYPE (type);
633
  /* Non-struct and non-union types are always passed by value.  */
634
  if (TYPE_CODE (type) != TYPE_CODE_STRUCT
635
      && TYPE_CODE (type) != TYPE_CODE_UNION)
636
    return 0;
637
  /* Structs with more than 1 field are always passed by address.  */
638
  if (TYPE_NFIELDS (type) != 1)
639
    return 1;
640
  /* Get field type.  */
641
  ftype = (TYPE_FIELDS (type))[0].type;
642
  /* The field type must have size 8, otherwise pass by address.  */
643
  if (TYPE_LENGTH (ftype) != 8)
644
    return 1;
645
  /* Skip typedefs of field type.  */
646
  while (TYPE_CODE (ftype) == TYPE_CODE_TYPEDEF)
647
    ftype = TYPE_TARGET_TYPE (ftype);
648
  /* If field is int or float, pass by value.  */
649
  if (TYPE_CODE (ftype) == TYPE_CODE_FLT
650
      || TYPE_CODE (ftype) == TYPE_CODE_INT)
651
    return 0;
652
  /* Everything else, pass by address. */
653
  return 1;
654
}
655
 
656
static CORE_ADDR
657
iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
658
                        struct regcache *regcache, CORE_ADDR bp_addr,
659
                        int nargs, struct value **args, CORE_ADDR sp,
660
                        int struct_return, CORE_ADDR struct_addr)
661
{
662
  const bfd_byte *val;
663
  bfd_byte buf[4];
664
  struct type *type;
665
  int i, argreg, typelen, slacklen;
666
  int stackspace = 0;
667
  /* Used to copy struct arguments into the stack. */
668
  CORE_ADDR struct_ptr;
669
 
670
  /* First determine how much stack space we will need. */
671
  for (i = 0, argreg = E_1ST_ARGREG + (struct_return != 0); i < nargs; i++)
672
    {
673
      type = value_type (args[i]);
674
      typelen = TYPE_LENGTH (type);
675
      if (typelen <= 4)
676
        {
677
          /* Scalars of up to 4 bytes,
678
             structs of up to 4 bytes, and
679
             pointers.  */
680
          if (argreg <= E_LAST_ARGREG)
681
            argreg++;
682
          else
683
            stackspace += 4;
684
        }
685
      else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
686
        {
687
          /* long long,
688
             double, and possibly
689
             structs with a single field of long long or double. */
690
          if (argreg <= E_LAST_ARGREG - 1)
691
            {
692
              /* 8-byte arg goes into a register pair
693
                 (must start with an even-numbered reg) */
694
              if (((argreg - E_1ST_ARGREG) % 2) != 0)
695
                argreg ++;
696
              argreg += 2;
697
            }
698
          else
699
            {
700
              argreg = E_LAST_ARGREG + 1;       /* no more argregs. */
701
              /* 8-byte arg goes on stack, must be 8-byte aligned. */
702
              stackspace = ((stackspace + 7) & ~7);
703
              stackspace += 8;
704
            }
705
        }
706
      else
707
        {
708
          /* Structs are passed as pointer to a copy of the struct.
709
             So we need room on the stack for a copy of the struct
710
             plus for the argument pointer. */
711
          if (argreg <= E_LAST_ARGREG)
712
            argreg++;
713
          else
714
            stackspace += 4;
715
          /* Care for 8-byte alignment of structs saved on stack.  */
716
          stackspace += ((typelen + 7) & ~7);
717
        }
718
    }
719
 
720
  /* Now copy params, in ascending order, into their assigned location
721
     (either in a register or on the stack). */
722
 
723
  sp -= (sp % 8);       /* align */
724
  struct_ptr = sp;
725
  sp -= stackspace;
726
  sp -= (sp % 8);       /* align again */
727
  stackspace = 0;
728
 
729
  argreg = E_1ST_ARGREG;
730
  if (struct_return)
731
    {
732
      /* A function that returns a struct will consume one argreg to do so.
733
       */
734
      regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
735
    }
736
 
737
  for (i = 0; i < nargs; i++)
738
    {
739
      type = value_type (args[i]);
740
      typelen = TYPE_LENGTH (type);
741
      val = value_contents (args[i]);
742
      if (typelen <= 4)
743
        {
744
          /* Char, short, int, float, pointer, and structs <= four bytes. */
745
          slacklen = (4 - (typelen % 4)) % 4;
746
          memset (buf, 0, sizeof (buf));
747
          memcpy (buf + slacklen, val, typelen);
748
          if (argreg <= E_LAST_ARGREG)
749
            {
750
              /* Passed in a register. */
751
              regcache_raw_write (regcache, argreg++, buf);
752
            }
753
          else
754
            {
755
              /* Passed on the stack. */
756
              write_memory (sp + stackspace, buf, 4);
757
              stackspace += 4;
758
            }
759
        }
760
      else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
761
        {
762
          /* (long long), (double), or struct consisting of
763
             a single (long long) or (double). */
764
          if (argreg <= E_LAST_ARGREG - 1)
765
            {
766
              /* 8-byte arg goes into a register pair
767
                 (must start with an even-numbered reg) */
768
              if (((argreg - E_1ST_ARGREG) % 2) != 0)
769
                argreg++;
770
              regcache_raw_write (regcache, argreg++, val);
771
              regcache_raw_write (regcache, argreg++, val + 4);
772
            }
773
          else
774
            {
775
              /* 8-byte arg goes on stack, must be 8-byte aligned. */
776
              argreg = E_LAST_ARGREG + 1;       /* no more argregs. */
777
              stackspace = ((stackspace + 7) & ~7);
778
              write_memory (sp + stackspace, val, typelen);
779
              stackspace += 8;
780
            }
781
        }
782
      else
783
        {
784
          /* Store struct beginning at the upper end of the previously
785
             computed stack space.  Then store the address of the struct
786
             using the usual rules for a 4 byte value.  */
787
          struct_ptr -= ((typelen + 7) & ~7);
788
          write_memory (struct_ptr, val, typelen);
789
          if (argreg <= E_LAST_ARGREG)
790
            regcache_cooked_write_unsigned (regcache, argreg++, struct_ptr);
791
          else
792
            {
793
              store_unsigned_integer (buf, 4, struct_ptr);
794
              write_memory (sp + stackspace, buf, 4);
795
              stackspace += 4;
796
            }
797
        }
798
    }
799
 
800
  /* Store return address. */
801
  regcache_cooked_write_unsigned (regcache, E_LR_REGNUM, bp_addr);
802
 
803
  /* Update stack pointer.  */
804
  regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
805
 
806
  /* And that should do it.  Return the new stack pointer. */
807
  return sp;
808
}
809
 
810
/* Function: gdbarch_init
811
   Initializer function for the iq2000 gdbarch vector.
812
   Called by gdbarch.  Sets up the gdbarch vector(s) for this target.  */
813
 
814
static struct gdbarch *
815
iq2000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
816
{
817
  struct gdbarch *gdbarch;
818
 
819
  /* Look up list for candidates - only one.  */
820
  arches = gdbarch_list_lookup_by_info (arches, &info);
821
  if (arches != NULL)
822
    return arches->gdbarch;
823
 
824
  gdbarch = gdbarch_alloc (&info, NULL);
825
 
826
  set_gdbarch_num_regs             (gdbarch, E_NUM_REGS);
827
  set_gdbarch_num_pseudo_regs      (gdbarch, 0);
828
  set_gdbarch_sp_regnum            (gdbarch, E_SP_REGNUM);
829
  set_gdbarch_pc_regnum            (gdbarch, E_PC_REGNUM);
830
  set_gdbarch_register_name        (gdbarch, iq2000_register_name);
831
  set_gdbarch_address_to_pointer   (gdbarch, iq2000_address_to_pointer);
832
  set_gdbarch_pointer_to_address   (gdbarch, iq2000_pointer_to_address);
833
  set_gdbarch_ptr_bit              (gdbarch, 4 * TARGET_CHAR_BIT);
834
  set_gdbarch_short_bit            (gdbarch, 2 * TARGET_CHAR_BIT);
835
  set_gdbarch_int_bit              (gdbarch, 4 * TARGET_CHAR_BIT);
836
  set_gdbarch_long_bit             (gdbarch, 4 * TARGET_CHAR_BIT);
837
  set_gdbarch_long_long_bit        (gdbarch, 8 * TARGET_CHAR_BIT);
838
  set_gdbarch_float_bit            (gdbarch, 4 * TARGET_CHAR_BIT);
839
  set_gdbarch_double_bit           (gdbarch, 8 * TARGET_CHAR_BIT);
840
  set_gdbarch_long_double_bit      (gdbarch, 8 * TARGET_CHAR_BIT);
841
  set_gdbarch_float_format         (gdbarch, floatformats_ieee_single);
842
  set_gdbarch_double_format        (gdbarch, floatformats_ieee_double);
843
  set_gdbarch_long_double_format   (gdbarch, floatformats_ieee_double);
844
  set_gdbarch_return_value         (gdbarch, iq2000_return_value);
845
  set_gdbarch_breakpoint_from_pc   (gdbarch, iq2000_breakpoint_from_pc);
846
  set_gdbarch_frame_args_skip      (gdbarch, 0);
847
  set_gdbarch_skip_prologue        (gdbarch, iq2000_skip_prologue);
848
  set_gdbarch_inner_than           (gdbarch, core_addr_lessthan);
849
  set_gdbarch_print_insn           (gdbarch, print_insn_iq2000);
850
  set_gdbarch_register_type (gdbarch, iq2000_register_type);
851
  set_gdbarch_frame_align (gdbarch, iq2000_frame_align);
852
  set_gdbarch_unwind_sp (gdbarch, iq2000_unwind_sp);
853
  set_gdbarch_unwind_pc (gdbarch, iq2000_unwind_pc);
854
  set_gdbarch_unwind_dummy_id (gdbarch, iq2000_unwind_dummy_id);
855
  frame_base_set_default (gdbarch, &iq2000_frame_base);
856
  set_gdbarch_push_dummy_call (gdbarch, iq2000_push_dummy_call);
857
 
858
  gdbarch_init_osabi (info, gdbarch);
859
 
860
  frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
861
  frame_unwind_append_sniffer (gdbarch, iq2000_frame_sniffer);
862
 
863
  return gdbarch;
864
}
865
 
866
/* Function: _initialize_iq2000_tdep
867
   Initializer function for the iq2000 module.
868
   Called by gdb at start-up. */
869
 
870
void
871
_initialize_iq2000_tdep (void)
872
{
873
  register_gdbarch_init (bfd_arch_iq2000, iq2000_gdbarch_init);
874
}

powered by: WebSVN 2.1.0

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