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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [iq2000-tdep.c] - Blame information for rev 842

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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