Copyright year update in most files of the GDB Project.
[deliverable/binutils-gdb.git] / gdb / iq2000-tdep.c
1 /* Target-dependent code for the IQ2000 architecture, for GDB, the GNU
2 Debugger.
3
4 Copyright (C) 2000, 2004-2005, 2007-2012 Free Software Foundation,
5 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 else
228 sal.end = 0; /* Avoid GCC false warning. */
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 {
244 LONGEST insn = read_memory_unsigned_integer (pc, 4, byte_order);
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
320 static void
321 iq2000_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
343 static CORE_ADDR
344 iq2000_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
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);
361 return iq2000_scan_prologue (gdbarch, func_addr, func_end, NULL, &cache);
362 }
363
364 /* No function symbol -- just return the PC. */
365 return (CORE_ADDR) pc;
366 }
367
368 static struct iq2000_frame_cache *
369 iq2000_frame_cache (struct frame_info *this_frame, void **this_cache)
370 {
371 struct gdbarch *gdbarch = get_frame_arch (this_frame);
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
383 cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
384 //if (cache->base == 0)
385 //return cache;
386
387 current_pc = get_frame_pc (this_frame);
388 find_pc_partial_function (current_pc, NULL, &cache->pc, NULL);
389 if (cache->pc != 0)
390 iq2000_scan_prologue (gdbarch, cache->pc, current_pc, this_frame, cache);
391 if (!cache->using_fp)
392 cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
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
403 static struct value *
404 iq2000_frame_prev_register (struct frame_info *this_frame, void **this_cache,
405 int regnum)
406 {
407 struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
408 this_cache);
409
410 if (regnum == E_SP_REGNUM && cache->saved_sp)
411 return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
412
413 if (regnum == E_PC_REGNUM)
414 regnum = E_LR_REGNUM;
415
416 if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != -1)
417 return frame_unwind_got_memory (this_frame, regnum,
418 cache->saved_regs[regnum]);
419
420 return frame_unwind_got_register (this_frame, regnum, regnum);
421 }
422
423 static void
424 iq2000_frame_this_id (struct frame_info *this_frame, void **this_cache,
425 struct frame_id *this_id)
426 {
427 struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
428 this_cache);
429
430 /* This marks the outermost frame. */
431 if (cache->base == 0)
432 return;
433
434 *this_id = frame_id_build (cache->saved_sp, cache->pc);
435 }
436
437 static const struct frame_unwind iq2000_frame_unwind = {
438 NORMAL_FRAME,
439 default_frame_unwind_stop_reason,
440 iq2000_frame_this_id,
441 iq2000_frame_prev_register,
442 NULL,
443 default_frame_sniffer
444 };
445
446 static CORE_ADDR
447 iq2000_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
448 {
449 return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
450 }
451
452 static CORE_ADDR
453 iq2000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
454 {
455 return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
456 }
457
458 static struct frame_id
459 iq2000_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
460 {
461 CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
462 return frame_id_build (sp, get_frame_pc (this_frame));
463 }
464
465 static CORE_ADDR
466 iq2000_frame_base_address (struct frame_info *this_frame, void **this_cache)
467 {
468 struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
469 this_cache);
470
471 return cache->base;
472 }
473
474 static const struct frame_base iq2000_frame_base = {
475 &iq2000_frame_unwind,
476 iq2000_frame_base_address,
477 iq2000_frame_base_address,
478 iq2000_frame_base_address
479 };
480
481 static const unsigned char *
482 iq2000_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
483 int *lenptr)
484 {
485 static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d };
486 static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 };
487
488 if ((*pcptr & 3) != 0)
489 error (_("breakpoint_from_pc: invalid breakpoint address 0x%lx"),
490 (long) *pcptr);
491
492 *lenptr = 4;
493 return (gdbarch_byte_order (gdbarch)
494 == BFD_ENDIAN_BIG) ? big_breakpoint : little_breakpoint;
495 }
496
497 /* Target function return value methods: */
498
499 /* Function: store_return_value
500 Copy the function return value from VALBUF into the
501 proper location for a function return. */
502
503 static void
504 iq2000_store_return_value (struct type *type, struct regcache *regcache,
505 const void *valbuf)
506 {
507 int len = TYPE_LENGTH (type);
508 int regno = E_FN_RETURN_REGNUM;
509
510 while (len > 0)
511 {
512 char buf[4];
513 int size = len % 4 ?: 4;
514
515 memset (buf, 0, 4);
516 memcpy (buf + 4 - size, valbuf, size);
517 regcache_raw_write (regcache, regno++, buf);
518 len -= size;
519 valbuf = ((char *) valbuf) + size;
520 }
521 }
522
523 /* Function: use_struct_convention
524 Returns non-zero if the given struct type will be returned using
525 a special convention, rather than the normal function return method. */
526
527 static int
528 iq2000_use_struct_convention (struct type *type)
529 {
530 return ((TYPE_CODE (type) == TYPE_CODE_STRUCT)
531 || (TYPE_CODE (type) == TYPE_CODE_UNION))
532 && TYPE_LENGTH (type) > 8;
533 }
534
535 /* Function: extract_return_value
536 Copy the function's return value into VALBUF.
537 This function is called only in the context of "target function calls",
538 ie. when the debugger forces a function to be called in the child, and
539 when the debugger forces a function to return prematurely via the
540 "return" command. */
541
542 static void
543 iq2000_extract_return_value (struct type *type, struct regcache *regcache,
544 void *valbuf)
545 {
546 struct gdbarch *gdbarch = get_regcache_arch (regcache);
547 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
548
549 /* If the function's return value is 8 bytes or less, it is
550 returned in a register, and if larger than 8 bytes, it is
551 returned in a stack location which is pointed to by the same
552 register. */
553 int len = TYPE_LENGTH (type);
554
555 if (len <= (2 * 4))
556 {
557 int regno = E_FN_RETURN_REGNUM;
558
559 /* Return values of <= 8 bytes are returned in
560 FN_RETURN_REGNUM. */
561 while (len > 0)
562 {
563 ULONGEST tmp;
564 int size = len % 4 ?: 4;
565
566 /* By using store_unsigned_integer we avoid having to
567 do anything special for small big-endian values. */
568 regcache_cooked_read_unsigned (regcache, regno++, &tmp);
569 store_unsigned_integer (valbuf, size, byte_order, tmp);
570 len -= size;
571 valbuf = ((char *) valbuf) + size;
572 }
573 }
574 else
575 {
576 /* Return values > 8 bytes are returned in memory,
577 pointed to by FN_RETURN_REGNUM. */
578 ULONGEST return_buffer;
579 regcache_cooked_read_unsigned (regcache, E_FN_RETURN_REGNUM,
580 &return_buffer);
581 read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
582 }
583 }
584
585 static enum return_value_convention
586 iq2000_return_value (struct gdbarch *gdbarch, struct type *func_type,
587 struct type *type, struct regcache *regcache,
588 gdb_byte *readbuf, const gdb_byte *writebuf)
589 {
590 if (iq2000_use_struct_convention (type))
591 return RETURN_VALUE_STRUCT_CONVENTION;
592 if (writebuf)
593 iq2000_store_return_value (type, regcache, writebuf);
594 else if (readbuf)
595 iq2000_extract_return_value (type, regcache, readbuf);
596 return RETURN_VALUE_REGISTER_CONVENTION;
597 }
598
599 /* Function: register_virtual_type
600 Returns the default type for register N. */
601
602 static struct type *
603 iq2000_register_type (struct gdbarch *gdbarch, int regnum)
604 {
605 return builtin_type (gdbarch)->builtin_int32;
606 }
607
608 static CORE_ADDR
609 iq2000_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
610 {
611 /* This is the same frame alignment used by gcc. */
612 return ((sp + 7) & ~7);
613 }
614
615 /* Convenience function to check 8-byte types for being a scalar type
616 or a struct with only one long long or double member. */
617 static int
618 iq2000_pass_8bytetype_by_address (struct type *type)
619 {
620 struct type *ftype;
621
622 /* Skip typedefs. */
623 while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
624 type = TYPE_TARGET_TYPE (type);
625 /* Non-struct and non-union types are always passed by value. */
626 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
627 && TYPE_CODE (type) != TYPE_CODE_UNION)
628 return 0;
629 /* Structs with more than 1 field are always passed by address. */
630 if (TYPE_NFIELDS (type) != 1)
631 return 1;
632 /* Get field type. */
633 ftype = (TYPE_FIELDS (type))[0].type;
634 /* The field type must have size 8, otherwise pass by address. */
635 if (TYPE_LENGTH (ftype) != 8)
636 return 1;
637 /* Skip typedefs of field type. */
638 while (TYPE_CODE (ftype) == TYPE_CODE_TYPEDEF)
639 ftype = TYPE_TARGET_TYPE (ftype);
640 /* If field is int or float, pass by value. */
641 if (TYPE_CODE (ftype) == TYPE_CODE_FLT
642 || TYPE_CODE (ftype) == TYPE_CODE_INT)
643 return 0;
644 /* Everything else, pass by address. */
645 return 1;
646 }
647
648 static CORE_ADDR
649 iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
650 struct regcache *regcache, CORE_ADDR bp_addr,
651 int nargs, struct value **args, CORE_ADDR sp,
652 int struct_return, CORE_ADDR struct_addr)
653 {
654 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
655 const bfd_byte *val;
656 bfd_byte buf[4];
657 struct type *type;
658 int i, argreg, typelen, slacklen;
659 int stackspace = 0;
660 /* Used to copy struct arguments into the stack. */
661 CORE_ADDR struct_ptr;
662
663 /* First determine how much stack space we will need. */
664 for (i = 0, argreg = E_1ST_ARGREG + (struct_return != 0); i < nargs; i++)
665 {
666 type = value_type (args[i]);
667 typelen = TYPE_LENGTH (type);
668 if (typelen <= 4)
669 {
670 /* Scalars of up to 4 bytes,
671 structs of up to 4 bytes, and
672 pointers. */
673 if (argreg <= E_LAST_ARGREG)
674 argreg++;
675 else
676 stackspace += 4;
677 }
678 else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
679 {
680 /* long long,
681 double, and possibly
682 structs with a single field of long long or double. */
683 if (argreg <= E_LAST_ARGREG - 1)
684 {
685 /* 8-byte arg goes into a register pair
686 (must start with an even-numbered reg). */
687 if (((argreg - E_1ST_ARGREG) % 2) != 0)
688 argreg ++;
689 argreg += 2;
690 }
691 else
692 {
693 argreg = E_LAST_ARGREG + 1; /* no more argregs. */
694 /* 8-byte arg goes on stack, must be 8-byte aligned. */
695 stackspace = ((stackspace + 7) & ~7);
696 stackspace += 8;
697 }
698 }
699 else
700 {
701 /* Structs are passed as pointer to a copy of the struct.
702 So we need room on the stack for a copy of the struct
703 plus for the argument pointer. */
704 if (argreg <= E_LAST_ARGREG)
705 argreg++;
706 else
707 stackspace += 4;
708 /* Care for 8-byte alignment of structs saved on stack. */
709 stackspace += ((typelen + 7) & ~7);
710 }
711 }
712
713 /* Now copy params, in ascending order, into their assigned location
714 (either in a register or on the stack). */
715
716 sp -= (sp % 8); /* align */
717 struct_ptr = sp;
718 sp -= stackspace;
719 sp -= (sp % 8); /* align again */
720 stackspace = 0;
721
722 argreg = E_1ST_ARGREG;
723 if (struct_return)
724 {
725 /* A function that returns a struct will consume one argreg to do so.
726 */
727 regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
728 }
729
730 for (i = 0; i < nargs; i++)
731 {
732 type = value_type (args[i]);
733 typelen = TYPE_LENGTH (type);
734 val = value_contents (args[i]);
735 if (typelen <= 4)
736 {
737 /* Char, short, int, float, pointer, and structs <= four bytes. */
738 slacklen = (4 - (typelen % 4)) % 4;
739 memset (buf, 0, sizeof (buf));
740 memcpy (buf + slacklen, val, typelen);
741 if (argreg <= E_LAST_ARGREG)
742 {
743 /* Passed in a register. */
744 regcache_raw_write (regcache, argreg++, buf);
745 }
746 else
747 {
748 /* Passed on the stack. */
749 write_memory (sp + stackspace, buf, 4);
750 stackspace += 4;
751 }
752 }
753 else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
754 {
755 /* (long long), (double), or struct consisting of
756 a single (long long) or (double). */
757 if (argreg <= E_LAST_ARGREG - 1)
758 {
759 /* 8-byte arg goes into a register pair
760 (must start with an even-numbered reg). */
761 if (((argreg - E_1ST_ARGREG) % 2) != 0)
762 argreg++;
763 regcache_raw_write (regcache, argreg++, val);
764 regcache_raw_write (regcache, argreg++, val + 4);
765 }
766 else
767 {
768 /* 8-byte arg goes on stack, must be 8-byte aligned. */
769 argreg = E_LAST_ARGREG + 1; /* no more argregs. */
770 stackspace = ((stackspace + 7) & ~7);
771 write_memory (sp + stackspace, val, typelen);
772 stackspace += 8;
773 }
774 }
775 else
776 {
777 /* Store struct beginning at the upper end of the previously
778 computed stack space. Then store the address of the struct
779 using the usual rules for a 4 byte value. */
780 struct_ptr -= ((typelen + 7) & ~7);
781 write_memory (struct_ptr, val, typelen);
782 if (argreg <= E_LAST_ARGREG)
783 regcache_cooked_write_unsigned (regcache, argreg++, struct_ptr);
784 else
785 {
786 store_unsigned_integer (buf, 4, byte_order, struct_ptr);
787 write_memory (sp + stackspace, buf, 4);
788 stackspace += 4;
789 }
790 }
791 }
792
793 /* Store return address. */
794 regcache_cooked_write_unsigned (regcache, E_LR_REGNUM, bp_addr);
795
796 /* Update stack pointer. */
797 regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
798
799 /* And that should do it. Return the new stack pointer. */
800 return sp;
801 }
802
803 /* Function: gdbarch_init
804 Initializer function for the iq2000 gdbarch vector.
805 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
806
807 static struct gdbarch *
808 iq2000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
809 {
810 struct gdbarch *gdbarch;
811
812 /* Look up list for candidates - only one. */
813 arches = gdbarch_list_lookup_by_info (arches, &info);
814 if (arches != NULL)
815 return arches->gdbarch;
816
817 gdbarch = gdbarch_alloc (&info, NULL);
818
819 set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
820 set_gdbarch_num_pseudo_regs (gdbarch, 0);
821 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
822 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
823 set_gdbarch_register_name (gdbarch, iq2000_register_name);
824 set_gdbarch_address_to_pointer (gdbarch, iq2000_address_to_pointer);
825 set_gdbarch_pointer_to_address (gdbarch, iq2000_pointer_to_address);
826 set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
827 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
828 set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
829 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
830 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
831 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
832 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
833 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
834 set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
835 set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
836 set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
837 set_gdbarch_return_value (gdbarch, iq2000_return_value);
838 set_gdbarch_breakpoint_from_pc (gdbarch, iq2000_breakpoint_from_pc);
839 set_gdbarch_frame_args_skip (gdbarch, 0);
840 set_gdbarch_skip_prologue (gdbarch, iq2000_skip_prologue);
841 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
842 set_gdbarch_print_insn (gdbarch, print_insn_iq2000);
843 set_gdbarch_register_type (gdbarch, iq2000_register_type);
844 set_gdbarch_frame_align (gdbarch, iq2000_frame_align);
845 set_gdbarch_unwind_sp (gdbarch, iq2000_unwind_sp);
846 set_gdbarch_unwind_pc (gdbarch, iq2000_unwind_pc);
847 set_gdbarch_dummy_id (gdbarch, iq2000_dummy_id);
848 frame_base_set_default (gdbarch, &iq2000_frame_base);
849 set_gdbarch_push_dummy_call (gdbarch, iq2000_push_dummy_call);
850
851 gdbarch_init_osabi (info, gdbarch);
852
853 dwarf2_append_unwinders (gdbarch);
854 frame_unwind_append_unwinder (gdbarch, &iq2000_frame_unwind);
855
856 return gdbarch;
857 }
858
859 /* Function: _initialize_iq2000_tdep
860 Initializer function for the iq2000 module.
861 Called by gdb at start-up. */
862
863 /* Provide a prototype to silence -Wmissing-prototypes. */
864 extern initialize_file_ftype _initialize_iq2000_tdep;
865
866 void
867 _initialize_iq2000_tdep (void)
868 {
869 register_gdbarch_init (bfd_arch_iq2000, iq2000_gdbarch_init);
870 }
This page took 0.047238 seconds and 5 git commands to generate.