*** empty log message ***
[deliverable/binutils-gdb.git] / gdb / iq2000-tdep.c
CommitLineData
20be272b
CV
1/* Target-dependent code for the IQ2000 architecture, for GDB, the GNU
2 Debugger.
3
7b6bb8da 4 Copyright (C) 2000, 2004, 2005, 2007, 2008, 2009, 2010, 2011
0fb0cc75 5 Free Software Foundation, Inc.
20be272b
CV
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
a9762ec7 13 the Free Software Foundation; either version 3 of the License, or
20be272b
CV
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
a9762ec7 22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20be272b
CV
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
38enum 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. */
59enum { REG_UNAVAIL = (CORE_ADDR) -1 };
60
61struct 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
74static CORE_ADDR
75insn_ptr_from_addr (CORE_ADDR addr) /* CORE_ADDR to target pointer. */
76{
77 return addr & 0x7fffffffL;
78}
79
80static CORE_ADDR
81insn_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
89static CORE_ADDR
9898f801
UW
90iq2000_pointer_to_address (struct gdbarch *gdbarch,
91 struct type * type, const gdb_byte * buf)
20be272b 92{
e17a4113 93 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
20be272b 94 enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
e17a4113
UW
95 CORE_ADDR addr
96 = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
20be272b
CV
97
98 if (target == TYPE_CODE_FUNC
99 || target == TYPE_CODE_METHOD
876cecd0 100 || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
20be272b
CV
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
109static void
9898f801
UW
110iq2000_address_to_pointer (struct gdbarch *gdbarch,
111 struct type *type, gdb_byte *buf, CORE_ADDR addr)
20be272b 112{
e17a4113 113 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
20be272b
CV
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);
e17a4113 118 store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
20be272b
CV
119}
120
121/* Real register methods: */
122
123/* Function: register_name
124 Returns the name of the iq2000 register number N. */
125
126static const char *
d93859e2 127iq2000_register_name (struct gdbarch *gdbarch, int regnum)
20be272b
CV
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
173static struct symtab_and_line
174find_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
200static CORE_ADDR
e17a4113
UW
201iq2000_scan_prologue (struct gdbarch *gdbarch,
202 CORE_ADDR scan_start,
20be272b
CV
203 CORE_ADDR scan_end,
204 struct frame_info *fi,
205 struct iq2000_frame_cache *cache)
206{
e17a4113 207 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
20be272b
CV
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);
706774f2
JK
227 else
228 sal.end = 0; /* Avoid GCC false warning. */
20be272b
CV
229 }
230
231 /* Saved registers:
232 We first have to save the saved register's offset, and
233 only later do we compute its actual address. Since the
234 offset can be zero, we must first initialize all the
235 saved regs to minus one (so we can later distinguish
236 between one that's not saved, and one that's saved at zero). */
237 for (srcreg = 0; srcreg < E_NUM_REGS; srcreg ++)
238 cache->saved_regs[srcreg] = -1;
239 cache->using_fp = 0;
240 cache->framesize = 0;
241
242 for (pc = scan_start; pc < loop_end; pc += 4)
243 {
e17a4113 244 LONGEST insn = read_memory_unsigned_integer (pc, 4, byte_order);
20be272b
CV
245 /* Skip any instructions writing to (sp) or decrementing the
246 SP. */
247 if ((insn & 0xffe00000) == 0xac200000)
248 {
249 /* sw using SP/%1 as base. */
250 /* LEGACY -- from assembly-only port. */
251 tgtreg = ((insn >> 16) & 0x1f);
252 if (tgtreg >= 0 && tgtreg < E_NUM_REGS)
253 cache->saved_regs[tgtreg] = -((signed short) (insn & 0xffff));
254
255 if (tgtreg == E_LR_REGNUM)
256 found_store_lr = 1;
257 continue;
258 }
259
260 if ((insn & 0xffff8000) == 0x20218000)
261 {
262 /* addi %1, %1, -N == addi %sp, %sp, -N */
263 /* LEGACY -- from assembly-only port */
264 found_decr_sp = 1;
265 cache->framesize = -((signed short) (insn & 0xffff));
266 continue;
267 }
268
269 if (INSN_IS_ADDIU (insn))
270 {
271 srcreg = ADDIU_REG_SRC (insn);
272 tgtreg = ADDIU_REG_TGT (insn);
273 offset = ADDIU_IMMEDIATE (insn);
274 if (srcreg == E_SP_REGNUM && tgtreg == E_SP_REGNUM)
275 cache->framesize = -offset;
276 continue;
277 }
278
279 if (INSN_IS_STORE_WORD (insn))
280 {
281 srcreg = SW_REG_SRC (insn);
282 tgtreg = SW_REG_INDEX (insn);
283 offset = SW_OFFSET (insn);
284
285 if (tgtreg == E_SP_REGNUM || tgtreg == E_FP_REGNUM)
286 {
287 /* "push" to stack (via SP or FP reg) */
288 if (cache->saved_regs[srcreg] == -1) /* Don't save twice. */
289 cache->saved_regs[srcreg] = offset;
290 continue;
291 }
292 }
293
294 if (INSN_IS_MOVE (insn))
295 {
296 srcreg = MOVE_REG_SRC (insn);
297 tgtreg = MOVE_REG_TGT (insn);
298
299 if (srcreg == E_SP_REGNUM && tgtreg == E_FP_REGNUM)
300 {
301 /* Copy sp to fp. */
302 cache->using_fp = 1;
303 continue;
304 }
305 }
306
307 /* Unknown instruction encountered in frame. Bail out?
308 1) If we have a subsequent line symbol, we can keep going.
309 2) If not, we need to bail out and quit scanning instructions. */
310
311 if (fi && sal.end && (pc < sal.end)) /* Keep scanning. */
312 continue;
313 else /* bail */
314 break;
315 }
316
317 return pc;
318}
319
320static void
321iq2000_init_frame_cache (struct iq2000_frame_cache *cache)
322{
323 int i;
324
325 cache->base = 0;
326 cache->framesize = 0;
327 cache->using_fp = 0;
328 cache->saved_sp = 0;
329 for (i = 0; i < E_NUM_REGS; i++)
330 cache->saved_regs[i] = -1;
331}
332
333/* Function: iq2000_skip_prologue
334 If the input address is in a function prologue,
335 returns the address of the end of the prologue;
336 else returns the input address.
337
338 Note: the input address is likely to be the function start,
339 since this function is mainly used for advancing a breakpoint
340 to the first line, or stepping to the first line when we have
341 stepped into a function call. */
342
343static CORE_ADDR
6093d2eb 344iq2000_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
20be272b
CV
345{
346 CORE_ADDR func_addr = 0 , func_end = 0;
347
348 if (find_pc_partial_function (pc, NULL, & func_addr, & func_end))
349 {
350 struct symtab_and_line sal;
351 struct iq2000_frame_cache cache;
352
353 /* Found a function. */
354 sal = find_pc_line (func_addr, 0);
355 if (sal.end && sal.end < func_end)
356 /* Found a line number, use it as end of prologue. */
357 return sal.end;
358
359 /* No useable line symbol. Use prologue parsing method. */
360 iq2000_init_frame_cache (&cache);
e17a4113 361 return iq2000_scan_prologue (gdbarch, func_addr, func_end, NULL, &cache);
20be272b
CV
362 }
363
364 /* No function symbol -- just return the PC. */
365 return (CORE_ADDR) pc;
366}
367
368static struct iq2000_frame_cache *
94afd7a6 369iq2000_frame_cache (struct frame_info *this_frame, void **this_cache)
20be272b 370{
e17a4113 371 struct gdbarch *gdbarch = get_frame_arch (this_frame);
20be272b
CV
372 struct iq2000_frame_cache *cache;
373 CORE_ADDR current_pc;
374 int i;
375
376 if (*this_cache)
377 return *this_cache;
378
379 cache = FRAME_OBSTACK_ZALLOC (struct iq2000_frame_cache);
380 iq2000_init_frame_cache (cache);
381 *this_cache = cache;
382
94afd7a6 383 cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
20be272b
CV
384 //if (cache->base == 0)
385 //return cache;
386
94afd7a6 387 current_pc = get_frame_pc (this_frame);
20be272b
CV
388 find_pc_partial_function (current_pc, NULL, &cache->pc, NULL);
389 if (cache->pc != 0)
e17a4113 390 iq2000_scan_prologue (gdbarch, cache->pc, current_pc, this_frame, cache);
20be272b 391 if (!cache->using_fp)
94afd7a6 392 cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
20be272b
CV
393
394 cache->saved_sp = cache->base + cache->framesize;
395
396 for (i = 0; i < E_NUM_REGS; i++)
397 if (cache->saved_regs[i] != -1)
398 cache->saved_regs[i] += cache->base;
399
400 return cache;
401}
402
94afd7a6
UW
403static struct value *
404iq2000_frame_prev_register (struct frame_info *this_frame, void **this_cache,
405 int regnum)
20be272b 406{
94afd7a6
UW
407 struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame, this_cache);
408
20be272b 409 if (regnum == E_SP_REGNUM && cache->saved_sp)
94afd7a6 410 return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
20be272b
CV
411
412 if (regnum == E_PC_REGNUM)
413 regnum = E_LR_REGNUM;
414
415 if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != -1)
94afd7a6
UW
416 return frame_unwind_got_memory (this_frame, regnum,
417 cache->saved_regs[regnum]);
20be272b 418
94afd7a6 419 return frame_unwind_got_register (this_frame, regnum, regnum);
20be272b
CV
420}
421
422static void
94afd7a6 423iq2000_frame_this_id (struct frame_info *this_frame, void **this_cache,
20be272b
CV
424 struct frame_id *this_id)
425{
94afd7a6 426 struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame, this_cache);
20be272b
CV
427
428 /* This marks the outermost frame. */
429 if (cache->base == 0)
430 return;
431
432 *this_id = frame_id_build (cache->saved_sp, cache->pc);
433}
434
435static const struct frame_unwind iq2000_frame_unwind = {
436 NORMAL_FRAME,
437 iq2000_frame_this_id,
94afd7a6
UW
438 iq2000_frame_prev_register,
439 NULL,
440 default_frame_sniffer
20be272b
CV
441};
442
20be272b
CV
443static CORE_ADDR
444iq2000_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
445{
446 return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
447}
448
449static CORE_ADDR
450iq2000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
451{
452 return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
453}
454
455static struct frame_id
94afd7a6 456iq2000_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
20be272b 457{
94afd7a6
UW
458 CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
459 return frame_id_build (sp, get_frame_pc (this_frame));
20be272b
CV
460}
461
462static CORE_ADDR
94afd7a6 463iq2000_frame_base_address (struct frame_info *this_frame, void **this_cache)
20be272b 464{
94afd7a6 465 struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame, this_cache);
20be272b
CV
466
467 return cache->base;
468}
469
470static const struct frame_base iq2000_frame_base = {
471 &iq2000_frame_unwind,
472 iq2000_frame_base_address,
473 iq2000_frame_base_address,
474 iq2000_frame_base_address
475};
476
477static const unsigned char *
67d57894
MD
478iq2000_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
479 int *lenptr)
20be272b
CV
480{
481 static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d };
482 static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 };
483
484 if ((*pcptr & 3) != 0)
485 error ("breakpoint_from_pc: invalid breakpoint address 0x%lx",
486 (long) *pcptr);
487
488 *lenptr = 4;
67d57894
MD
489 return (gdbarch_byte_order (gdbarch)
490 == BFD_ENDIAN_BIG) ? big_breakpoint : little_breakpoint;
20be272b
CV
491}
492
493/* Target function return value methods: */
494
495/* Function: store_return_value
496 Copy the function return value from VALBUF into the
497 proper location for a function return. */
498
499static void
500iq2000_store_return_value (struct type *type, struct regcache *regcache,
501 const void *valbuf)
502{
503 int len = TYPE_LENGTH (type);
504 int regno = E_FN_RETURN_REGNUM;
505
506 while (len > 0)
507 {
508 char buf[4];
509 int size = len % 4 ?: 4;
510
511 memset (buf, 0, 4);
512 memcpy (buf + 4 - size, valbuf, size);
513 regcache_raw_write (regcache, regno++, buf);
514 len -= size;
515 valbuf = ((char *) valbuf) + size;
516 }
517}
518
519/* Function: use_struct_convention
520 Returns non-zero if the given struct type will be returned using
521 a special convention, rather than the normal function return method. */
522
523static int
524iq2000_use_struct_convention (struct type *type)
525{
526 return ((TYPE_CODE (type) == TYPE_CODE_STRUCT)
527 || (TYPE_CODE (type) == TYPE_CODE_UNION))
528 && TYPE_LENGTH (type) > 8;
529}
530
531/* Function: extract_return_value
532 Copy the function's return value into VALBUF.
533 This function is called only in the context of "target function calls",
534 ie. when the debugger forces a function to be called in the child, and
535 when the debugger forces a function to return prematurely via the
536 "return" command. */
537
538static void
539iq2000_extract_return_value (struct type *type, struct regcache *regcache,
540 void *valbuf)
541{
e17a4113
UW
542 struct gdbarch *gdbarch = get_regcache_arch (regcache);
543 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
544
20be272b
CV
545 /* If the function's return value is 8 bytes or less, it is
546 returned in a register, and if larger than 8 bytes, it is
547 returned in a stack location which is pointed to by the same
548 register. */
20be272b
CV
549 int len = TYPE_LENGTH (type);
550
551 if (len <= (2 * 4))
552 {
553 int regno = E_FN_RETURN_REGNUM;
554
555 /* Return values of <= 8 bytes are returned in
556 FN_RETURN_REGNUM. */
557 while (len > 0)
558 {
559 ULONGEST tmp;
560 int size = len % 4 ?: 4;
561
562 /* By using store_unsigned_integer we avoid having to
563 do anything special for small big-endian values. */
564 regcache_cooked_read_unsigned (regcache, regno++, &tmp);
e17a4113 565 store_unsigned_integer (valbuf, size, byte_order, tmp);
20be272b
CV
566 len -= size;
567 valbuf = ((char *) valbuf) + size;
568 }
569 }
570 else
571 {
572 /* Return values > 8 bytes are returned in memory,
573 pointed to by FN_RETURN_REGNUM. */
ec20a626
UW
574 ULONGEST return_buffer;
575 regcache_cooked_read_unsigned (regcache, E_FN_RETURN_REGNUM,
576 &return_buffer);
20be272b
CV
577 read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
578 }
579}
580
581static enum return_value_convention
c055b101
CV
582iq2000_return_value (struct gdbarch *gdbarch, struct type *func_type,
583 struct type *type, struct regcache *regcache,
ec20a626 584 gdb_byte *readbuf, const gdb_byte *writebuf)
20be272b
CV
585{
586 if (iq2000_use_struct_convention (type))
587 return RETURN_VALUE_STRUCT_CONVENTION;
588 if (writebuf)
589 iq2000_store_return_value (type, regcache, writebuf);
590 else if (readbuf)
591 iq2000_extract_return_value (type, regcache, readbuf);
592 return RETURN_VALUE_REGISTER_CONVENTION;
593}
594
595/* Function: register_virtual_type
596 Returns the default type for register N. */
597
598static struct type *
599iq2000_register_type (struct gdbarch *gdbarch, int regnum)
600{
df4df182 601 return builtin_type (gdbarch)->builtin_int32;
20be272b
CV
602}
603
604static CORE_ADDR
605iq2000_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
606{
607 /* This is the same frame alignment used by gcc. */
608 return ((sp + 7) & ~7);
609}
610
611/* Convenience function to check 8-byte types for being a scalar type
612 or a struct with only one long long or double member. */
613static int
614iq2000_pass_8bytetype_by_address (struct type *type)
615{
616 struct type *ftype;
617
618 /* Skip typedefs. */
619 while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
620 type = TYPE_TARGET_TYPE (type);
621 /* Non-struct and non-union types are always passed by value. */
622 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
623 && TYPE_CODE (type) != TYPE_CODE_UNION)
624 return 0;
625 /* Structs with more than 1 field are always passed by address. */
626 if (TYPE_NFIELDS (type) != 1)
627 return 1;
628 /* Get field type. */
629 ftype = (TYPE_FIELDS (type))[0].type;
630 /* The field type must have size 8, otherwise pass by address. */
631 if (TYPE_LENGTH (ftype) != 8)
632 return 1;
633 /* Skip typedefs of field type. */
634 while (TYPE_CODE (ftype) == TYPE_CODE_TYPEDEF)
635 ftype = TYPE_TARGET_TYPE (ftype);
636 /* If field is int or float, pass by value. */
637 if (TYPE_CODE (ftype) == TYPE_CODE_FLT
638 || TYPE_CODE (ftype) == TYPE_CODE_INT)
639 return 0;
640 /* Everything else, pass by address. */
641 return 1;
642}
643
644static CORE_ADDR
645iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
646 struct regcache *regcache, CORE_ADDR bp_addr,
647 int nargs, struct value **args, CORE_ADDR sp,
648 int struct_return, CORE_ADDR struct_addr)
649{
e17a4113 650 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
20be272b
CV
651 const bfd_byte *val;
652 bfd_byte buf[4];
653 struct type *type;
654 int i, argreg, typelen, slacklen;
655 int stackspace = 0;
656 /* Used to copy struct arguments into the stack. */
657 CORE_ADDR struct_ptr;
658
659 /* First determine how much stack space we will need. */
660 for (i = 0, argreg = E_1ST_ARGREG + (struct_return != 0); i < nargs; i++)
661 {
662 type = value_type (args[i]);
663 typelen = TYPE_LENGTH (type);
664 if (typelen <= 4)
665 {
666 /* Scalars of up to 4 bytes,
667 structs of up to 4 bytes, and
668 pointers. */
669 if (argreg <= E_LAST_ARGREG)
670 argreg++;
671 else
672 stackspace += 4;
673 }
674 else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
675 {
676 /* long long,
677 double, and possibly
678 structs with a single field of long long or double. */
679 if (argreg <= E_LAST_ARGREG - 1)
680 {
681 /* 8-byte arg goes into a register pair
682 (must start with an even-numbered reg) */
683 if (((argreg - E_1ST_ARGREG) % 2) != 0)
684 argreg ++;
685 argreg += 2;
686 }
687 else
688 {
689 argreg = E_LAST_ARGREG + 1; /* no more argregs. */
690 /* 8-byte arg goes on stack, must be 8-byte aligned. */
691 stackspace = ((stackspace + 7) & ~7);
692 stackspace += 8;
693 }
694 }
695 else
696 {
697 /* Structs are passed as pointer to a copy of the struct.
698 So we need room on the stack for a copy of the struct
699 plus for the argument pointer. */
700 if (argreg <= E_LAST_ARGREG)
701 argreg++;
702 else
703 stackspace += 4;
704 /* Care for 8-byte alignment of structs saved on stack. */
705 stackspace += ((typelen + 7) & ~7);
706 }
707 }
708
709 /* Now copy params, in ascending order, into their assigned location
710 (either in a register or on the stack). */
711
712 sp -= (sp % 8); /* align */
713 struct_ptr = sp;
714 sp -= stackspace;
715 sp -= (sp % 8); /* align again */
716 stackspace = 0;
717
718 argreg = E_1ST_ARGREG;
719 if (struct_return)
720 {
721 /* A function that returns a struct will consume one argreg to do so.
722 */
723 regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
724 }
725
726 for (i = 0; i < nargs; i++)
727 {
728 type = value_type (args[i]);
729 typelen = TYPE_LENGTH (type);
730 val = value_contents (args[i]);
731 if (typelen <= 4)
732 {
733 /* Char, short, int, float, pointer, and structs <= four bytes. */
734 slacklen = (4 - (typelen % 4)) % 4;
735 memset (buf, 0, sizeof (buf));
736 memcpy (buf + slacklen, val, typelen);
737 if (argreg <= E_LAST_ARGREG)
738 {
739 /* Passed in a register. */
740 regcache_raw_write (regcache, argreg++, buf);
741 }
742 else
743 {
744 /* Passed on the stack. */
745 write_memory (sp + stackspace, buf, 4);
746 stackspace += 4;
747 }
748 }
749 else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
750 {
751 /* (long long), (double), or struct consisting of
752 a single (long long) or (double). */
753 if (argreg <= E_LAST_ARGREG - 1)
754 {
755 /* 8-byte arg goes into a register pair
756 (must start with an even-numbered reg) */
757 if (((argreg - E_1ST_ARGREG) % 2) != 0)
758 argreg++;
759 regcache_raw_write (regcache, argreg++, val);
760 regcache_raw_write (regcache, argreg++, val + 4);
761 }
762 else
763 {
764 /* 8-byte arg goes on stack, must be 8-byte aligned. */
765 argreg = E_LAST_ARGREG + 1; /* no more argregs. */
766 stackspace = ((stackspace + 7) & ~7);
767 write_memory (sp + stackspace, val, typelen);
768 stackspace += 8;
769 }
770 }
771 else
772 {
773 /* Store struct beginning at the upper end of the previously
774 computed stack space. Then store the address of the struct
775 using the usual rules for a 4 byte value. */
776 struct_ptr -= ((typelen + 7) & ~7);
777 write_memory (struct_ptr, val, typelen);
778 if (argreg <= E_LAST_ARGREG)
779 regcache_cooked_write_unsigned (regcache, argreg++, struct_ptr);
780 else
781 {
e17a4113 782 store_unsigned_integer (buf, 4, byte_order, struct_ptr);
20be272b
CV
783 write_memory (sp + stackspace, buf, 4);
784 stackspace += 4;
785 }
786 }
787 }
788
789 /* Store return address. */
790 regcache_cooked_write_unsigned (regcache, E_LR_REGNUM, bp_addr);
791
792 /* Update stack pointer. */
793 regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
794
795 /* And that should do it. Return the new stack pointer. */
796 return sp;
797}
798
799/* Function: gdbarch_init
800 Initializer function for the iq2000 gdbarch vector.
801 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
802
803static struct gdbarch *
804iq2000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
805{
806 struct gdbarch *gdbarch;
807
808 /* Look up list for candidates - only one. */
809 arches = gdbarch_list_lookup_by_info (arches, &info);
810 if (arches != NULL)
811 return arches->gdbarch;
812
813 gdbarch = gdbarch_alloc (&info, NULL);
814
815 set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
816 set_gdbarch_num_pseudo_regs (gdbarch, 0);
817 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
818 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
819 set_gdbarch_register_name (gdbarch, iq2000_register_name);
820 set_gdbarch_address_to_pointer (gdbarch, iq2000_address_to_pointer);
821 set_gdbarch_pointer_to_address (gdbarch, iq2000_pointer_to_address);
822 set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
823 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
824 set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
825 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
826 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
827 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
828 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
829 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
8da61cc4
DJ
830 set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
831 set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
832 set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
20be272b
CV
833 set_gdbarch_return_value (gdbarch, iq2000_return_value);
834 set_gdbarch_breakpoint_from_pc (gdbarch, iq2000_breakpoint_from_pc);
835 set_gdbarch_frame_args_skip (gdbarch, 0);
836 set_gdbarch_skip_prologue (gdbarch, iq2000_skip_prologue);
837 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
838 set_gdbarch_print_insn (gdbarch, print_insn_iq2000);
839 set_gdbarch_register_type (gdbarch, iq2000_register_type);
840 set_gdbarch_frame_align (gdbarch, iq2000_frame_align);
841 set_gdbarch_unwind_sp (gdbarch, iq2000_unwind_sp);
842 set_gdbarch_unwind_pc (gdbarch, iq2000_unwind_pc);
94afd7a6 843 set_gdbarch_dummy_id (gdbarch, iq2000_dummy_id);
20be272b
CV
844 frame_base_set_default (gdbarch, &iq2000_frame_base);
845 set_gdbarch_push_dummy_call (gdbarch, iq2000_push_dummy_call);
846
847 gdbarch_init_osabi (info, gdbarch);
848
94afd7a6
UW
849 dwarf2_append_unwinders (gdbarch);
850 frame_unwind_append_unwinder (gdbarch, &iq2000_frame_unwind);
20be272b
CV
851
852 return gdbarch;
853}
854
855/* Function: _initialize_iq2000_tdep
856 Initializer function for the iq2000 module.
857 Called by gdb at start-up. */
858
63807e1d
PA
859/* Provide a prototype to silence -Wmissing-prototypes. */
860extern initialize_file_ftype _initialize_iq2000_tdep;
861
20be272b
CV
862void
863_initialize_iq2000_tdep (void)
864{
865 register_gdbarch_init (bfd_arch_iq2000, iq2000_gdbarch_init);
866}
This page took 0.522877 seconds and 4 git commands to generate.