1 /* Target-dependent code for the IQ2000 architecture, for GDB, the GNU
4 Copyright (C) 2000, 2004, 2005, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
7 Contributed by Red Hat.
9 This file is part of GDB.
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.
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.
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/>. */
26 #include "frame-base.h"
27 #include "frame-unwind.h"
28 #include "dwarf2-frame.h"
32 #include "gdb_string.h"
33 #include "arch-utils.h"
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
,
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
58 /* Use an invalid address value as 'not available' marker. */
59 enum { REG_UNAVAIL
= (CORE_ADDR
) -1 };
61 struct iq2000_frame_cache
69 CORE_ADDR saved_regs
[E_NUM_REGS
];
72 /* Harvard methods: */
75 insn_ptr_from_addr (CORE_ADDR addr
) /* CORE_ADDR to target pointer. */
77 return addr
& 0x7fffffffL
;
81 insn_addr_from_ptr (CORE_ADDR ptr
) /* target_pointer to CORE_ADDR. */
83 return (ptr
& 0x7fffffffL
) | 0x80000000L
;
86 /* Function: pointer_to_address
87 Convert a target pointer to an address in host (CORE_ADDR) format. */
90 iq2000_pointer_to_address (struct gdbarch
*gdbarch
,
91 struct type
* type
, const gdb_byte
* buf
)
93 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
94 enum type_code target
= TYPE_CODE (TYPE_TARGET_TYPE (type
));
96 = extract_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
);
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
);
106 /* Function: address_to_pointer
107 Convert a host-format address (CORE_ADDR) into a target pointer. */
110 iq2000_address_to_pointer (struct gdbarch
*gdbarch
,
111 struct type
*type
, gdb_byte
*buf
, CORE_ADDR addr
)
113 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
114 enum type_code target
= TYPE_CODE (TYPE_TARGET_TYPE (type
));
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
);
121 /* Real register methods: */
123 /* Function: register_name
124 Returns the name of the iq2000 register number N. */
127 iq2000_register_name (struct gdbarch
*gdbarch
, int regnum
)
129 static const char * names
[E_NUM_REGS
] =
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",
140 if (regnum
< 0 || regnum
>= E_NUM_REGS
)
142 return names
[regnum
];
145 /* Prologue analysis methods: */
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))
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)
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))
164 /* Function: find_last_line_symbol
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.
170 For optimized code with code motion, this finds the last address
171 for the lowest-numbered line within the address range. */
173 static struct symtab_and_line
174 find_last_line_symbol (CORE_ADDR start
, CORE_ADDR end
, int notcurrent
)
176 struct symtab_and_line sal
= find_pc_line (start
, notcurrent
);
177 struct symtab_and_line best_sal
= sal
;
179 if (sal
.pc
== 0 || sal
.line
== 0 || sal
.end
== 0)
184 if (sal
.line
&& sal
.line
<= best_sal
.line
)
186 sal
= find_pc_line (sal
.end
, notcurrent
);
188 while (sal
.pc
&& sal
.pc
< end
);
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.
198 Returns the address of the first instruction after the prologue. */
201 iq2000_scan_prologue (struct gdbarch
*gdbarch
,
202 CORE_ADDR scan_start
,
204 struct frame_info
*fi
,
205 struct iq2000_frame_cache
*cache
)
207 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
208 struct symtab_and_line sal
;
211 int found_store_lr
= 0;
212 int found_decr_sp
= 0;
217 if (scan_end
== (CORE_ADDR
) 0)
219 loop_end
= scan_start
+ 100;
220 sal
.end
= sal
.pc
= 0;
226 sal
= find_last_line_symbol (scan_start
, scan_end
, 0);
228 sal
.end
= 0; /* Avoid GCC false warning. */
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;
240 cache
->framesize
= 0;
242 for (pc
= scan_start
; pc
< loop_end
; pc
+= 4)
244 LONGEST insn
= read_memory_unsigned_integer (pc
, 4, byte_order
);
245 /* Skip any instructions writing to (sp) or decrementing the
247 if ((insn
& 0xffe00000) == 0xac200000)
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));
255 if (tgtreg
== E_LR_REGNUM
)
260 if ((insn
& 0xffff8000) == 0x20218000)
262 /* addi %1, %1, -N == addi %sp, %sp, -N */
263 /* LEGACY -- from assembly-only port. */
265 cache
->framesize
= -((signed short) (insn
& 0xffff));
269 if (INSN_IS_ADDIU (insn
))
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
;
279 if (INSN_IS_STORE_WORD (insn
))
281 srcreg
= SW_REG_SRC (insn
);
282 tgtreg
= SW_REG_INDEX (insn
);
283 offset
= SW_OFFSET (insn
);
285 if (tgtreg
== E_SP_REGNUM
|| tgtreg
== E_FP_REGNUM
)
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
;
294 if (INSN_IS_MOVE (insn
))
296 srcreg
= MOVE_REG_SRC (insn
);
297 tgtreg
= MOVE_REG_TGT (insn
);
299 if (srcreg
== E_SP_REGNUM
&& tgtreg
== E_FP_REGNUM
)
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. */
311 if (fi
&& sal
.end
&& (pc
< sal
.end
)) /* Keep scanning. */
321 iq2000_init_frame_cache (struct iq2000_frame_cache
*cache
)
326 cache
->framesize
= 0;
329 for (i
= 0; i
< E_NUM_REGS
; i
++)
330 cache
->saved_regs
[i
] = -1;
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.
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. */
344 iq2000_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
346 CORE_ADDR func_addr
= 0 , func_end
= 0;
348 if (find_pc_partial_function (pc
, NULL
, & func_addr
, & func_end
))
350 struct symtab_and_line sal
;
351 struct iq2000_frame_cache cache
;
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. */
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
);
364 /* No function symbol -- just return the PC. */
365 return (CORE_ADDR
) pc
;
368 static struct iq2000_frame_cache
*
369 iq2000_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
371 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
372 struct iq2000_frame_cache
*cache
;
373 CORE_ADDR current_pc
;
379 cache
= FRAME_OBSTACK_ZALLOC (struct iq2000_frame_cache
);
380 iq2000_init_frame_cache (cache
);
383 cache
->base
= get_frame_register_unsigned (this_frame
, E_FP_REGNUM
);
384 //if (cache->base == 0)
387 current_pc
= get_frame_pc (this_frame
);
388 find_pc_partial_function (current_pc
, NULL
, &cache
->pc
, NULL
);
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
);
394 cache
->saved_sp
= cache
->base
+ cache
->framesize
;
396 for (i
= 0; i
< E_NUM_REGS
; i
++)
397 if (cache
->saved_regs
[i
] != -1)
398 cache
->saved_regs
[i
] += cache
->base
;
403 static struct value
*
404 iq2000_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
407 struct iq2000_frame_cache
*cache
= iq2000_frame_cache (this_frame
,
410 if (regnum
== E_SP_REGNUM
&& cache
->saved_sp
)
411 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
413 if (regnum
== E_PC_REGNUM
)
414 regnum
= E_LR_REGNUM
;
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
]);
420 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
424 iq2000_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
425 struct frame_id
*this_id
)
427 struct iq2000_frame_cache
*cache
= iq2000_frame_cache (this_frame
,
430 /* This marks the outermost frame. */
431 if (cache
->base
== 0)
434 *this_id
= frame_id_build (cache
->saved_sp
, cache
->pc
);
437 static const struct frame_unwind iq2000_frame_unwind
= {
439 iq2000_frame_this_id
,
440 iq2000_frame_prev_register
,
442 default_frame_sniffer
446 iq2000_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
448 return frame_unwind_register_unsigned (next_frame
, E_SP_REGNUM
);
452 iq2000_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
454 return frame_unwind_register_unsigned (next_frame
, E_PC_REGNUM
);
457 static struct frame_id
458 iq2000_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
460 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, E_SP_REGNUM
);
461 return frame_id_build (sp
, get_frame_pc (this_frame
));
465 iq2000_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
467 struct iq2000_frame_cache
*cache
= iq2000_frame_cache (this_frame
,
473 static const struct frame_base iq2000_frame_base
= {
474 &iq2000_frame_unwind
,
475 iq2000_frame_base_address
,
476 iq2000_frame_base_address
,
477 iq2000_frame_base_address
480 static const unsigned char *
481 iq2000_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
,
484 static const unsigned char big_breakpoint
[] = { 0x00, 0x00, 0x00, 0x0d };
485 static const unsigned char little_breakpoint
[] = { 0x0d, 0x00, 0x00, 0x00 };
487 if ((*pcptr
& 3) != 0)
488 error (_("breakpoint_from_pc: invalid breakpoint address 0x%lx"),
492 return (gdbarch_byte_order (gdbarch
)
493 == BFD_ENDIAN_BIG
) ? big_breakpoint
: little_breakpoint
;
496 /* Target function return value methods: */
498 /* Function: store_return_value
499 Copy the function return value from VALBUF into the
500 proper location for a function return. */
503 iq2000_store_return_value (struct type
*type
, struct regcache
*regcache
,
506 int len
= TYPE_LENGTH (type
);
507 int regno
= E_FN_RETURN_REGNUM
;
512 int size
= len
% 4 ?: 4;
515 memcpy (buf
+ 4 - size
, valbuf
, size
);
516 regcache_raw_write (regcache
, regno
++, buf
);
518 valbuf
= ((char *) valbuf
) + size
;
522 /* Function: use_struct_convention
523 Returns non-zero if the given struct type will be returned using
524 a special convention, rather than the normal function return method. */
527 iq2000_use_struct_convention (struct type
*type
)
529 return ((TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
530 || (TYPE_CODE (type
) == TYPE_CODE_UNION
))
531 && TYPE_LENGTH (type
) > 8;
534 /* Function: extract_return_value
535 Copy the function's return value into VALBUF.
536 This function is called only in the context of "target function calls",
537 ie. when the debugger forces a function to be called in the child, and
538 when the debugger forces a function to return prematurely via the
542 iq2000_extract_return_value (struct type
*type
, struct regcache
*regcache
,
545 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
546 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
548 /* If the function's return value is 8 bytes or less, it is
549 returned in a register, and if larger than 8 bytes, it is
550 returned in a stack location which is pointed to by the same
552 int len
= TYPE_LENGTH (type
);
556 int regno
= E_FN_RETURN_REGNUM
;
558 /* Return values of <= 8 bytes are returned in
563 int size
= len
% 4 ?: 4;
565 /* By using store_unsigned_integer we avoid having to
566 do anything special for small big-endian values. */
567 regcache_cooked_read_unsigned (regcache
, regno
++, &tmp
);
568 store_unsigned_integer (valbuf
, size
, byte_order
, tmp
);
570 valbuf
= ((char *) valbuf
) + size
;
575 /* Return values > 8 bytes are returned in memory,
576 pointed to by FN_RETURN_REGNUM. */
577 ULONGEST return_buffer
;
578 regcache_cooked_read_unsigned (regcache
, E_FN_RETURN_REGNUM
,
580 read_memory (return_buffer
, valbuf
, TYPE_LENGTH (type
));
584 static enum return_value_convention
585 iq2000_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
586 struct type
*type
, struct regcache
*regcache
,
587 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
589 if (iq2000_use_struct_convention (type
))
590 return RETURN_VALUE_STRUCT_CONVENTION
;
592 iq2000_store_return_value (type
, regcache
, writebuf
);
594 iq2000_extract_return_value (type
, regcache
, readbuf
);
595 return RETURN_VALUE_REGISTER_CONVENTION
;
598 /* Function: register_virtual_type
599 Returns the default type for register N. */
602 iq2000_register_type (struct gdbarch
*gdbarch
, int regnum
)
604 return builtin_type (gdbarch
)->builtin_int32
;
608 iq2000_frame_align (struct gdbarch
*ignore
, CORE_ADDR sp
)
610 /* This is the same frame alignment used by gcc. */
611 return ((sp
+ 7) & ~7);
614 /* Convenience function to check 8-byte types for being a scalar type
615 or a struct with only one long long or double member. */
617 iq2000_pass_8bytetype_by_address (struct type
*type
)
622 while (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
623 type
= TYPE_TARGET_TYPE (type
);
624 /* Non-struct and non-union types are always passed by value. */
625 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
626 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
628 /* Structs with more than 1 field are always passed by address. */
629 if (TYPE_NFIELDS (type
) != 1)
631 /* Get field type. */
632 ftype
= (TYPE_FIELDS (type
))[0].type
;
633 /* The field type must have size 8, otherwise pass by address. */
634 if (TYPE_LENGTH (ftype
) != 8)
636 /* Skip typedefs of field type. */
637 while (TYPE_CODE (ftype
) == TYPE_CODE_TYPEDEF
)
638 ftype
= TYPE_TARGET_TYPE (ftype
);
639 /* If field is int or float, pass by value. */
640 if (TYPE_CODE (ftype
) == TYPE_CODE_FLT
641 || TYPE_CODE (ftype
) == TYPE_CODE_INT
)
643 /* Everything else, pass by address. */
648 iq2000_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
649 struct regcache
*regcache
, CORE_ADDR bp_addr
,
650 int nargs
, struct value
**args
, CORE_ADDR sp
,
651 int struct_return
, CORE_ADDR struct_addr
)
653 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
657 int i
, argreg
, typelen
, slacklen
;
659 /* Used to copy struct arguments into the stack. */
660 CORE_ADDR struct_ptr
;
662 /* First determine how much stack space we will need. */
663 for (i
= 0, argreg
= E_1ST_ARGREG
+ (struct_return
!= 0); i
< nargs
; i
++)
665 type
= value_type (args
[i
]);
666 typelen
= TYPE_LENGTH (type
);
669 /* Scalars of up to 4 bytes,
670 structs of up to 4 bytes, and
672 if (argreg
<= E_LAST_ARGREG
)
677 else if (typelen
== 8 && !iq2000_pass_8bytetype_by_address (type
))
681 structs with a single field of long long or double. */
682 if (argreg
<= E_LAST_ARGREG
- 1)
684 /* 8-byte arg goes into a register pair
685 (must start with an even-numbered reg). */
686 if (((argreg
- E_1ST_ARGREG
) % 2) != 0)
692 argreg
= E_LAST_ARGREG
+ 1; /* no more argregs. */
693 /* 8-byte arg goes on stack, must be 8-byte aligned. */
694 stackspace
= ((stackspace
+ 7) & ~7);
700 /* Structs are passed as pointer to a copy of the struct.
701 So we need room on the stack for a copy of the struct
702 plus for the argument pointer. */
703 if (argreg
<= E_LAST_ARGREG
)
707 /* Care for 8-byte alignment of structs saved on stack. */
708 stackspace
+= ((typelen
+ 7) & ~7);
712 /* Now copy params, in ascending order, into their assigned location
713 (either in a register or on the stack). */
715 sp
-= (sp
% 8); /* align */
718 sp
-= (sp
% 8); /* align again */
721 argreg
= E_1ST_ARGREG
;
724 /* A function that returns a struct will consume one argreg to do so.
726 regcache_cooked_write_unsigned (regcache
, argreg
++, struct_addr
);
729 for (i
= 0; i
< nargs
; i
++)
731 type
= value_type (args
[i
]);
732 typelen
= TYPE_LENGTH (type
);
733 val
= value_contents (args
[i
]);
736 /* Char, short, int, float, pointer, and structs <= four bytes. */
737 slacklen
= (4 - (typelen
% 4)) % 4;
738 memset (buf
, 0, sizeof (buf
));
739 memcpy (buf
+ slacklen
, val
, typelen
);
740 if (argreg
<= E_LAST_ARGREG
)
742 /* Passed in a register. */
743 regcache_raw_write (regcache
, argreg
++, buf
);
747 /* Passed on the stack. */
748 write_memory (sp
+ stackspace
, buf
, 4);
752 else if (typelen
== 8 && !iq2000_pass_8bytetype_by_address (type
))
754 /* (long long), (double), or struct consisting of
755 a single (long long) or (double). */
756 if (argreg
<= E_LAST_ARGREG
- 1)
758 /* 8-byte arg goes into a register pair
759 (must start with an even-numbered reg). */
760 if (((argreg
- E_1ST_ARGREG
) % 2) != 0)
762 regcache_raw_write (regcache
, argreg
++, val
);
763 regcache_raw_write (regcache
, argreg
++, val
+ 4);
767 /* 8-byte arg goes on stack, must be 8-byte aligned. */
768 argreg
= E_LAST_ARGREG
+ 1; /* no more argregs. */
769 stackspace
= ((stackspace
+ 7) & ~7);
770 write_memory (sp
+ stackspace
, val
, typelen
);
776 /* Store struct beginning at the upper end of the previously
777 computed stack space. Then store the address of the struct
778 using the usual rules for a 4 byte value. */
779 struct_ptr
-= ((typelen
+ 7) & ~7);
780 write_memory (struct_ptr
, val
, typelen
);
781 if (argreg
<= E_LAST_ARGREG
)
782 regcache_cooked_write_unsigned (regcache
, argreg
++, struct_ptr
);
785 store_unsigned_integer (buf
, 4, byte_order
, struct_ptr
);
786 write_memory (sp
+ stackspace
, buf
, 4);
792 /* Store return address. */
793 regcache_cooked_write_unsigned (regcache
, E_LR_REGNUM
, bp_addr
);
795 /* Update stack pointer. */
796 regcache_cooked_write_unsigned (regcache
, E_SP_REGNUM
, sp
);
798 /* And that should do it. Return the new stack pointer. */
802 /* Function: gdbarch_init
803 Initializer function for the iq2000 gdbarch vector.
804 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
806 static struct gdbarch
*
807 iq2000_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
809 struct gdbarch
*gdbarch
;
811 /* Look up list for candidates - only one. */
812 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
814 return arches
->gdbarch
;
816 gdbarch
= gdbarch_alloc (&info
, NULL
);
818 set_gdbarch_num_regs (gdbarch
, E_NUM_REGS
);
819 set_gdbarch_num_pseudo_regs (gdbarch
, 0);
820 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
821 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
822 set_gdbarch_register_name (gdbarch
, iq2000_register_name
);
823 set_gdbarch_address_to_pointer (gdbarch
, iq2000_address_to_pointer
);
824 set_gdbarch_pointer_to_address (gdbarch
, iq2000_pointer_to_address
);
825 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
826 set_gdbarch_short_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
827 set_gdbarch_int_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
828 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
829 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
830 set_gdbarch_float_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
831 set_gdbarch_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
832 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
833 set_gdbarch_float_format (gdbarch
, floatformats_ieee_single
);
834 set_gdbarch_double_format (gdbarch
, floatformats_ieee_double
);
835 set_gdbarch_long_double_format (gdbarch
, floatformats_ieee_double
);
836 set_gdbarch_return_value (gdbarch
, iq2000_return_value
);
837 set_gdbarch_breakpoint_from_pc (gdbarch
, iq2000_breakpoint_from_pc
);
838 set_gdbarch_frame_args_skip (gdbarch
, 0);
839 set_gdbarch_skip_prologue (gdbarch
, iq2000_skip_prologue
);
840 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
841 set_gdbarch_print_insn (gdbarch
, print_insn_iq2000
);
842 set_gdbarch_register_type (gdbarch
, iq2000_register_type
);
843 set_gdbarch_frame_align (gdbarch
, iq2000_frame_align
);
844 set_gdbarch_unwind_sp (gdbarch
, iq2000_unwind_sp
);
845 set_gdbarch_unwind_pc (gdbarch
, iq2000_unwind_pc
);
846 set_gdbarch_dummy_id (gdbarch
, iq2000_dummy_id
);
847 frame_base_set_default (gdbarch
, &iq2000_frame_base
);
848 set_gdbarch_push_dummy_call (gdbarch
, iq2000_push_dummy_call
);
850 gdbarch_init_osabi (info
, gdbarch
);
852 dwarf2_append_unwinders (gdbarch
);
853 frame_unwind_append_unwinder (gdbarch
, &iq2000_frame_unwind
);
858 /* Function: _initialize_iq2000_tdep
859 Initializer function for the iq2000 module.
860 Called by gdb at start-up. */
862 /* Provide a prototype to silence -Wmissing-prototypes. */
863 extern initialize_file_ftype _initialize_iq2000_tdep
;
866 _initialize_iq2000_tdep (void)
868 register_gdbarch_init (bfd_arch_iq2000
, iq2000_gdbarch_init
);