1 /* Target-dependent code for the IQ2000 architecture, for GDB, the GNU
4 Copyright (C) 2000, 2004, 2005, 2007, 2008, 2009
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 type * type, const gdb_byte * buf)
92 enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
93 CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
95 if (target == TYPE_CODE_FUNC
96 || target == TYPE_CODE_METHOD
97 || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
98 addr = insn_addr_from_ptr (addr);
103 /* Function: address_to_pointer
104 Convert a host-format address (CORE_ADDR) into a target pointer. */
107 iq2000_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr)
109 enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
111 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
112 addr = insn_ptr_from_addr (addr);
113 store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
116 /* Real register methods: */
118 /* Function: register_name
119 Returns the name of the iq2000 register number N. */
122 iq2000_register_name (struct gdbarch *gdbarch, int regnum)
124 static const char * names[E_NUM_REGS] =
126 "r0", "r1", "r2", "r3", "r4",
127 "r5", "r6", "r7", "r8", "r9",
128 "r10", "r11", "r12", "r13", "r14",
129 "r15", "r16", "r17", "r18", "r19",
130 "r20", "r21", "r22", "r23", "r24",
131 "r25", "r26", "r27", "r28", "r29",
135 if (regnum < 0 || regnum >= E_NUM_REGS)
137 return names[regnum];
140 /* Prologue analysis methods: */
142 /* ADDIU insn (001001 rs(5) rt(5) imm(16)). */
143 #define INSN_IS_ADDIU(X) (((X) & 0xfc000000) == 0x24000000)
144 #define ADDIU_REG_SRC(X) (((X) & 0x03e00000) >> 21)
145 #define ADDIU_REG_TGT(X) (((X) & 0x001f0000) >> 16)
146 #define ADDIU_IMMEDIATE(X) ((signed short) ((X) & 0x0000ffff))
148 /* "MOVE" (OR) insn (000000 rs(5) rt(5) rd(5) 00000 100101). */
149 #define INSN_IS_MOVE(X) (((X) & 0xffe007ff) == 0x00000025)
150 #define MOVE_REG_SRC(X) (((X) & 0x001f0000) >> 16)
151 #define MOVE_REG_TGT(X) (((X) & 0x0000f800) >> 11)
153 /* STORE WORD insn (101011 rs(5) rt(5) offset(16)). */
154 #define INSN_IS_STORE_WORD(X) (((X) & 0xfc000000) == 0xac000000)
155 #define SW_REG_INDEX(X) (((X) & 0x03e00000) >> 21)
156 #define SW_REG_SRC(X) (((X) & 0x001f0000) >> 16)
157 #define SW_OFFSET(X) ((signed short) ((X) & 0x0000ffff))
159 /* Function: find_last_line_symbol
161 Given an address range, first find a line symbol corresponding to
162 the starting address. Then find the last line symbol within the
163 range that has a line number less than or equal to the first line.
165 For optimized code with code motion, this finds the last address
166 for the lowest-numbered line within the address range. */
168 static struct symtab_and_line
169 find_last_line_symbol (CORE_ADDR start, CORE_ADDR end, int notcurrent)
171 struct symtab_and_line sal = find_pc_line (start, notcurrent);
172 struct symtab_and_line best_sal = sal;
174 if (sal.pc == 0 || sal.line == 0 || sal.end == 0)
179 if (sal.line && sal.line <= best_sal.line)
181 sal = find_pc_line (sal.end, notcurrent);
183 while (sal.pc && sal.pc < end);
188 /* Function: scan_prologue
189 Decode the instructions within the given address range.
190 Decide when we must have reached the end of the function prologue.
191 If a frame_info pointer is provided, fill in its prologue information.
193 Returns the address of the first instruction after the prologue. */
196 iq2000_scan_prologue (CORE_ADDR scan_start,
198 struct frame_info *fi,
199 struct iq2000_frame_cache *cache)
201 struct symtab_and_line sal;
204 int found_store_lr = 0;
205 int found_decr_sp = 0;
210 if (scan_end == (CORE_ADDR) 0)
212 loop_end = scan_start + 100;
213 sal.end = sal.pc = 0;
219 sal = find_last_line_symbol (scan_start, scan_end, 0);
223 We first have to save the saved register's offset, and
224 only later do we compute its actual address. Since the
225 offset can be zero, we must first initialize all the
226 saved regs to minus one (so we can later distinguish
227 between one that's not saved, and one that's saved at zero). */
228 for (srcreg = 0; srcreg < E_NUM_REGS; srcreg ++)
229 cache->saved_regs[srcreg] = -1;
231 cache->framesize = 0;
233 for (pc = scan_start; pc < loop_end; pc += 4)
235 LONGEST insn = read_memory_unsigned_integer (pc, 4);
236 /* Skip any instructions writing to (sp) or decrementing the
238 if ((insn & 0xffe00000) == 0xac200000)
240 /* sw using SP/%1 as base. */
241 /* LEGACY -- from assembly-only port. */
242 tgtreg = ((insn >> 16) & 0x1f);
243 if (tgtreg >= 0 && tgtreg < E_NUM_REGS)
244 cache->saved_regs[tgtreg] = -((signed short) (insn & 0xffff));
246 if (tgtreg == E_LR_REGNUM)
251 if ((insn & 0xffff8000) == 0x20218000)
253 /* addi %1, %1, -N == addi %sp, %sp, -N */
254 /* LEGACY -- from assembly-only port */
256 cache->framesize = -((signed short) (insn & 0xffff));
260 if (INSN_IS_ADDIU (insn))
262 srcreg = ADDIU_REG_SRC (insn);
263 tgtreg = ADDIU_REG_TGT (insn);
264 offset = ADDIU_IMMEDIATE (insn);
265 if (srcreg == E_SP_REGNUM && tgtreg == E_SP_REGNUM)
266 cache->framesize = -offset;
270 if (INSN_IS_STORE_WORD (insn))
272 srcreg = SW_REG_SRC (insn);
273 tgtreg = SW_REG_INDEX (insn);
274 offset = SW_OFFSET (insn);
276 if (tgtreg == E_SP_REGNUM || tgtreg == E_FP_REGNUM)
278 /* "push" to stack (via SP or FP reg) */
279 if (cache->saved_regs[srcreg] == -1) /* Don't save twice. */
280 cache->saved_regs[srcreg] = offset;
285 if (INSN_IS_MOVE (insn))
287 srcreg = MOVE_REG_SRC (insn);
288 tgtreg = MOVE_REG_TGT (insn);
290 if (srcreg == E_SP_REGNUM && tgtreg == E_FP_REGNUM)
298 /* Unknown instruction encountered in frame. Bail out?
299 1) If we have a subsequent line symbol, we can keep going.
300 2) If not, we need to bail out and quit scanning instructions. */
302 if (fi && sal.end && (pc < sal.end)) /* Keep scanning. */
312 iq2000_init_frame_cache (struct iq2000_frame_cache *cache)
317 cache->framesize = 0;
320 for (i = 0; i < E_NUM_REGS; i++)
321 cache->saved_regs[i] = -1;
324 /* Function: iq2000_skip_prologue
325 If the input address is in a function prologue,
326 returns the address of the end of the prologue;
327 else returns the input address.
329 Note: the input address is likely to be the function start,
330 since this function is mainly used for advancing a breakpoint
331 to the first line, or stepping to the first line when we have
332 stepped into a function call. */
335 iq2000_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
337 CORE_ADDR func_addr = 0 , func_end = 0;
339 if (find_pc_partial_function (pc, NULL, & func_addr, & func_end))
341 struct symtab_and_line sal;
342 struct iq2000_frame_cache cache;
344 /* Found a function. */
345 sal = find_pc_line (func_addr, 0);
346 if (sal.end && sal.end < func_end)
347 /* Found a line number, use it as end of prologue. */
350 /* No useable line symbol. Use prologue parsing method. */
351 iq2000_init_frame_cache (&cache);
352 return iq2000_scan_prologue (func_addr, func_end, NULL, &cache);
355 /* No function symbol -- just return the PC. */
356 return (CORE_ADDR) pc;
359 static struct iq2000_frame_cache *
360 iq2000_frame_cache (struct frame_info *this_frame, void **this_cache)
362 struct iq2000_frame_cache *cache;
363 CORE_ADDR current_pc;
369 cache = FRAME_OBSTACK_ZALLOC (struct iq2000_frame_cache);
370 iq2000_init_frame_cache (cache);
373 cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
374 //if (cache->base == 0)
377 current_pc = get_frame_pc (this_frame);
378 find_pc_partial_function (current_pc, NULL, &cache->pc, NULL);
380 iq2000_scan_prologue (cache->pc, current_pc, this_frame, cache);
381 if (!cache->using_fp)
382 cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
384 cache->saved_sp = cache->base + cache->framesize;
386 for (i = 0; i < E_NUM_REGS; i++)
387 if (cache->saved_regs[i] != -1)
388 cache->saved_regs[i] += cache->base;
393 static struct value *
394 iq2000_frame_prev_register (struct frame_info *this_frame, void **this_cache,
397 struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame, this_cache);
399 if (regnum == E_SP_REGNUM && cache->saved_sp)
400 return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
402 if (regnum == E_PC_REGNUM)
403 regnum = E_LR_REGNUM;
405 if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != -1)
406 return frame_unwind_got_memory (this_frame, regnum,
407 cache->saved_regs[regnum]);
409 return frame_unwind_got_register (this_frame, regnum, regnum);
413 iq2000_frame_this_id (struct frame_info *this_frame, void **this_cache,
414 struct frame_id *this_id)
416 struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame, this_cache);
418 /* This marks the outermost frame. */
419 if (cache->base == 0)
422 *this_id = frame_id_build (cache->saved_sp, cache->pc);
425 static const struct frame_unwind iq2000_frame_unwind = {
427 iq2000_frame_this_id,
428 iq2000_frame_prev_register,
430 default_frame_sniffer
434 iq2000_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
436 return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
440 iq2000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
442 return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
445 static struct frame_id
446 iq2000_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
448 CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
449 return frame_id_build (sp, get_frame_pc (this_frame));
453 iq2000_frame_base_address (struct frame_info *this_frame, void **this_cache)
455 struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame, this_cache);
460 static const struct frame_base iq2000_frame_base = {
461 &iq2000_frame_unwind,
462 iq2000_frame_base_address,
463 iq2000_frame_base_address,
464 iq2000_frame_base_address
467 static const unsigned char *
468 iq2000_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
471 static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d };
472 static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 };
474 if ((*pcptr & 3) != 0)
475 error ("breakpoint_from_pc: invalid breakpoint address 0x%lx",
479 return (gdbarch_byte_order (gdbarch)
480 == BFD_ENDIAN_BIG) ? big_breakpoint : little_breakpoint;
483 /* Target function return value methods: */
485 /* Function: store_return_value
486 Copy the function return value from VALBUF into the
487 proper location for a function return. */
490 iq2000_store_return_value (struct type *type, struct regcache *regcache,
493 int len = TYPE_LENGTH (type);
494 int regno = E_FN_RETURN_REGNUM;
499 int size = len % 4 ?: 4;
502 memcpy (buf + 4 - size, valbuf, size);
503 regcache_raw_write (regcache, regno++, buf);
505 valbuf = ((char *) valbuf) + size;
509 /* Function: use_struct_convention
510 Returns non-zero if the given struct type will be returned using
511 a special convention, rather than the normal function return method. */
514 iq2000_use_struct_convention (struct type *type)
516 return ((TYPE_CODE (type) == TYPE_CODE_STRUCT)
517 || (TYPE_CODE (type) == TYPE_CODE_UNION))
518 && TYPE_LENGTH (type) > 8;
521 /* Function: extract_return_value
522 Copy the function's return value into VALBUF.
523 This function is called only in the context of "target function calls",
524 ie. when the debugger forces a function to be called in the child, and
525 when the debugger forces a function to return prematurely via the
529 iq2000_extract_return_value (struct type *type, struct regcache *regcache,
532 /* If the function's return value is 8 bytes or less, it is
533 returned in a register, and if larger than 8 bytes, it is
534 returned in a stack location which is pointed to by the same
536 int len = TYPE_LENGTH (type);
540 int regno = E_FN_RETURN_REGNUM;
542 /* Return values of <= 8 bytes are returned in
547 int size = len % 4 ?: 4;
549 /* By using store_unsigned_integer we avoid having to
550 do anything special for small big-endian values. */
551 regcache_cooked_read_unsigned (regcache, regno++, &tmp);
552 store_unsigned_integer (valbuf, size, tmp);
554 valbuf = ((char *) valbuf) + size;
559 /* Return values > 8 bytes are returned in memory,
560 pointed to by FN_RETURN_REGNUM. */
561 ULONGEST return_buffer;
562 regcache_cooked_read_unsigned (regcache, E_FN_RETURN_REGNUM,
564 read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
568 static enum return_value_convention
569 iq2000_return_value (struct gdbarch *gdbarch, struct type *func_type,
570 struct type *type, struct regcache *regcache,
571 gdb_byte *readbuf, const gdb_byte *writebuf)
573 if (iq2000_use_struct_convention (type))
574 return RETURN_VALUE_STRUCT_CONVENTION;
576 iq2000_store_return_value (type, regcache, writebuf);
578 iq2000_extract_return_value (type, regcache, readbuf);
579 return RETURN_VALUE_REGISTER_CONVENTION;
582 /* Function: register_virtual_type
583 Returns the default type for register N. */
586 iq2000_register_type (struct gdbarch *gdbarch, int regnum)
588 return builtin_type_int32;
592 iq2000_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
594 /* This is the same frame alignment used by gcc. */
595 return ((sp + 7) & ~7);
598 /* Convenience function to check 8-byte types for being a scalar type
599 or a struct with only one long long or double member. */
601 iq2000_pass_8bytetype_by_address (struct type *type)
606 while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
607 type = TYPE_TARGET_TYPE (type);
608 /* Non-struct and non-union types are always passed by value. */
609 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
610 && TYPE_CODE (type) != TYPE_CODE_UNION)
612 /* Structs with more than 1 field are always passed by address. */
613 if (TYPE_NFIELDS (type) != 1)
615 /* Get field type. */
616 ftype = (TYPE_FIELDS (type))[0].type;
617 /* The field type must have size 8, otherwise pass by address. */
618 if (TYPE_LENGTH (ftype) != 8)
620 /* Skip typedefs of field type. */
621 while (TYPE_CODE (ftype) == TYPE_CODE_TYPEDEF)
622 ftype = TYPE_TARGET_TYPE (ftype);
623 /* If field is int or float, pass by value. */
624 if (TYPE_CODE (ftype) == TYPE_CODE_FLT
625 || TYPE_CODE (ftype) == TYPE_CODE_INT)
627 /* Everything else, pass by address. */
632 iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
633 struct regcache *regcache, CORE_ADDR bp_addr,
634 int nargs, struct value **args, CORE_ADDR sp,
635 int struct_return, CORE_ADDR struct_addr)
640 int i, argreg, typelen, slacklen;
642 /* Used to copy struct arguments into the stack. */
643 CORE_ADDR struct_ptr;
645 /* First determine how much stack space we will need. */
646 for (i = 0, argreg = E_1ST_ARGREG + (struct_return != 0); i < nargs; i++)
648 type = value_type (args[i]);
649 typelen = TYPE_LENGTH (type);
652 /* Scalars of up to 4 bytes,
653 structs of up to 4 bytes, and
655 if (argreg <= E_LAST_ARGREG)
660 else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
664 structs with a single field of long long or double. */
665 if (argreg <= E_LAST_ARGREG - 1)
667 /* 8-byte arg goes into a register pair
668 (must start with an even-numbered reg) */
669 if (((argreg - E_1ST_ARGREG) % 2) != 0)
675 argreg = E_LAST_ARGREG + 1; /* no more argregs. */
676 /* 8-byte arg goes on stack, must be 8-byte aligned. */
677 stackspace = ((stackspace + 7) & ~7);
683 /* Structs are passed as pointer to a copy of the struct.
684 So we need room on the stack for a copy of the struct
685 plus for the argument pointer. */
686 if (argreg <= E_LAST_ARGREG)
690 /* Care for 8-byte alignment of structs saved on stack. */
691 stackspace += ((typelen + 7) & ~7);
695 /* Now copy params, in ascending order, into their assigned location
696 (either in a register or on the stack). */
698 sp -= (sp % 8); /* align */
701 sp -= (sp % 8); /* align again */
704 argreg = E_1ST_ARGREG;
707 /* A function that returns a struct will consume one argreg to do so.
709 regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
712 for (i = 0; i < nargs; i++)
714 type = value_type (args[i]);
715 typelen = TYPE_LENGTH (type);
716 val = value_contents (args[i]);
719 /* Char, short, int, float, pointer, and structs <= four bytes. */
720 slacklen = (4 - (typelen % 4)) % 4;
721 memset (buf, 0, sizeof (buf));
722 memcpy (buf + slacklen, val, typelen);
723 if (argreg <= E_LAST_ARGREG)
725 /* Passed in a register. */
726 regcache_raw_write (regcache, argreg++, buf);
730 /* Passed on the stack. */
731 write_memory (sp + stackspace, buf, 4);
735 else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
737 /* (long long), (double), or struct consisting of
738 a single (long long) or (double). */
739 if (argreg <= E_LAST_ARGREG - 1)
741 /* 8-byte arg goes into a register pair
742 (must start with an even-numbered reg) */
743 if (((argreg - E_1ST_ARGREG) % 2) != 0)
745 regcache_raw_write (regcache, argreg++, val);
746 regcache_raw_write (regcache, argreg++, val + 4);
750 /* 8-byte arg goes on stack, must be 8-byte aligned. */
751 argreg = E_LAST_ARGREG + 1; /* no more argregs. */
752 stackspace = ((stackspace + 7) & ~7);
753 write_memory (sp + stackspace, val, typelen);
759 /* Store struct beginning at the upper end of the previously
760 computed stack space. Then store the address of the struct
761 using the usual rules for a 4 byte value. */
762 struct_ptr -= ((typelen + 7) & ~7);
763 write_memory (struct_ptr, val, typelen);
764 if (argreg <= E_LAST_ARGREG)
765 regcache_cooked_write_unsigned (regcache, argreg++, struct_ptr);
768 store_unsigned_integer (buf, 4, struct_ptr);
769 write_memory (sp + stackspace, buf, 4);
775 /* Store return address. */
776 regcache_cooked_write_unsigned (regcache, E_LR_REGNUM, bp_addr);
778 /* Update stack pointer. */
779 regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
781 /* And that should do it. Return the new stack pointer. */
785 /* Function: gdbarch_init
786 Initializer function for the iq2000 gdbarch vector.
787 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
789 static struct gdbarch *
790 iq2000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
792 struct gdbarch *gdbarch;
794 /* Look up list for candidates - only one. */
795 arches = gdbarch_list_lookup_by_info (arches, &info);
797 return arches->gdbarch;
799 gdbarch = gdbarch_alloc (&info, NULL);
801 set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
802 set_gdbarch_num_pseudo_regs (gdbarch, 0);
803 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
804 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
805 set_gdbarch_register_name (gdbarch, iq2000_register_name);
806 set_gdbarch_address_to_pointer (gdbarch, iq2000_address_to_pointer);
807 set_gdbarch_pointer_to_address (gdbarch, iq2000_pointer_to_address);
808 set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
809 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
810 set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
811 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
812 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
813 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
814 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
815 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
816 set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
817 set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
818 set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
819 set_gdbarch_return_value (gdbarch, iq2000_return_value);
820 set_gdbarch_breakpoint_from_pc (gdbarch, iq2000_breakpoint_from_pc);
821 set_gdbarch_frame_args_skip (gdbarch, 0);
822 set_gdbarch_skip_prologue (gdbarch, iq2000_skip_prologue);
823 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
824 set_gdbarch_print_insn (gdbarch, print_insn_iq2000);
825 set_gdbarch_register_type (gdbarch, iq2000_register_type);
826 set_gdbarch_frame_align (gdbarch, iq2000_frame_align);
827 set_gdbarch_unwind_sp (gdbarch, iq2000_unwind_sp);
828 set_gdbarch_unwind_pc (gdbarch, iq2000_unwind_pc);
829 set_gdbarch_dummy_id (gdbarch, iq2000_dummy_id);
830 frame_base_set_default (gdbarch, &iq2000_frame_base);
831 set_gdbarch_push_dummy_call (gdbarch, iq2000_push_dummy_call);
833 gdbarch_init_osabi (info, gdbarch);
835 dwarf2_append_unwinders (gdbarch);
836 frame_unwind_append_unwinder (gdbarch, &iq2000_frame_unwind);
841 /* Function: _initialize_iq2000_tdep
842 Initializer function for the iq2000 module.
843 Called by gdb at start-up. */
845 /* Provide a prototype to silence -Wmissing-prototypes. */
846 extern initialize_file_ftype _initialize_iq2000_tdep;
849 _initialize_iq2000_tdep (void)
851 register_gdbarch_init (bfd_arch_iq2000, iq2000_gdbarch_init);