1 /* Target-dependent code for the IQ2000 architecture, for GDB, the GNU
4 Copyright (C) 2000, 2004, 2005, 2007 Free Software Foundation, Inc.
6 Contributed by Red Hat.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, USA. */
27 #include "frame-base.h"
28 #include "frame-unwind.h"
29 #include "dwarf2-frame.h"
33 #include "gdb_string.h"
34 #include "arch-utils.h"
41 E_R0_REGNUM, E_R1_REGNUM, E_R2_REGNUM, E_R3_REGNUM,
42 E_R4_REGNUM, E_R5_REGNUM, E_R6_REGNUM, E_R7_REGNUM,
43 E_R8_REGNUM, E_R9_REGNUM, E_R10_REGNUM, E_R11_REGNUM,
44 E_R12_REGNUM, E_R13_REGNUM, E_R14_REGNUM, E_R15_REGNUM,
45 E_R16_REGNUM, E_R17_REGNUM, E_R18_REGNUM, E_R19_REGNUM,
46 E_R20_REGNUM, E_R21_REGNUM, E_R22_REGNUM, E_R23_REGNUM,
47 E_R24_REGNUM, E_R25_REGNUM, E_R26_REGNUM, E_R27_REGNUM,
48 E_R28_REGNUM, E_R29_REGNUM, E_R30_REGNUM, E_R31_REGNUM,
50 E_LR_REGNUM = E_R31_REGNUM, /* Link register. */
51 E_SP_REGNUM = E_R29_REGNUM, /* Stack pointer. */
52 E_FP_REGNUM = E_R27_REGNUM, /* Frame pointer. */
53 E_FN_RETURN_REGNUM = E_R2_REGNUM, /* Function return value register. */
54 E_1ST_ARGREG = E_R4_REGNUM, /* 1st function arg register. */
55 E_LAST_ARGREG = E_R11_REGNUM, /* Last function arg register. */
56 E_NUM_REGS = E_PC_REGNUM + 1
59 /* Use an invalid address value as 'not available' marker. */
60 enum { REG_UNAVAIL = (CORE_ADDR) -1 };
62 struct iq2000_frame_cache
70 CORE_ADDR saved_regs [E_NUM_REGS];
73 /* Harvard methods: */
76 insn_ptr_from_addr (CORE_ADDR addr) /* CORE_ADDR to target pointer. */
78 return addr & 0x7fffffffL;
82 insn_addr_from_ptr (CORE_ADDR ptr) /* target_pointer to CORE_ADDR. */
84 return (ptr & 0x7fffffffL) | 0x80000000L;
87 /* Function: pointer_to_address
88 Convert a target pointer to an address in host (CORE_ADDR) format. */
91 iq2000_pointer_to_address (struct type * type, const void * buf)
93 enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
94 CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
96 if (target == TYPE_CODE_FUNC
97 || target == TYPE_CODE_METHOD
98 || (TYPE_FLAGS (TYPE_TARGET_TYPE (type)) & TYPE_FLAG_CODE_SPACE) != 0)
99 addr = insn_addr_from_ptr (addr);
104 /* Function: address_to_pointer
105 Convert a host-format address (CORE_ADDR) into a target pointer. */
108 iq2000_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
110 enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
112 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
113 addr = insn_ptr_from_addr (addr);
114 store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
117 /* Real register methods: */
119 /* Function: register_name
120 Returns the name of the iq2000 register number N. */
123 iq2000_register_name (int regnum)
125 static const char * names[E_NUM_REGS] =
127 "r0", "r1", "r2", "r3", "r4",
128 "r5", "r6", "r7", "r8", "r9",
129 "r10", "r11", "r12", "r13", "r14",
130 "r15", "r16", "r17", "r18", "r19",
131 "r20", "r21", "r22", "r23", "r24",
132 "r25", "r26", "r27", "r28", "r29",
136 if (regnum < 0 || regnum >= E_NUM_REGS)
138 return names[regnum];
141 /* Prologue analysis methods: */
143 /* ADDIU insn (001001 rs(5) rt(5) imm(16)). */
144 #define INSN_IS_ADDIU(X) (((X) & 0xfc000000) == 0x24000000)
145 #define ADDIU_REG_SRC(X) (((X) & 0x03e00000) >> 21)
146 #define ADDIU_REG_TGT(X) (((X) & 0x001f0000) >> 16)
147 #define ADDIU_IMMEDIATE(X) ((signed short) ((X) & 0x0000ffff))
149 /* "MOVE" (OR) insn (000000 rs(5) rt(5) rd(5) 00000 100101). */
150 #define INSN_IS_MOVE(X) (((X) & 0xffe007ff) == 0x00000025)
151 #define MOVE_REG_SRC(X) (((X) & 0x001f0000) >> 16)
152 #define MOVE_REG_TGT(X) (((X) & 0x0000f800) >> 11)
154 /* STORE WORD insn (101011 rs(5) rt(5) offset(16)). */
155 #define INSN_IS_STORE_WORD(X) (((X) & 0xfc000000) == 0xac000000)
156 #define SW_REG_INDEX(X) (((X) & 0x03e00000) >> 21)
157 #define SW_REG_SRC(X) (((X) & 0x001f0000) >> 16)
158 #define SW_OFFSET(X) ((signed short) ((X) & 0x0000ffff))
160 /* Function: find_last_line_symbol
162 Given an address range, first find a line symbol corresponding to
163 the starting address. Then find the last line symbol within the
164 range that has a line number less than or equal to the first line.
166 For optimized code with code motion, this finds the last address
167 for the lowest-numbered line within the address range. */
169 static struct symtab_and_line
170 find_last_line_symbol (CORE_ADDR start, CORE_ADDR end, int notcurrent)
172 struct symtab_and_line sal = find_pc_line (start, notcurrent);
173 struct symtab_and_line best_sal = sal;
175 if (sal.pc == 0 || sal.line == 0 || sal.end == 0)
180 if (sal.line && sal.line <= best_sal.line)
182 sal = find_pc_line (sal.end, notcurrent);
184 while (sal.pc && sal.pc < end);
189 /* Function: scan_prologue
190 Decode the instructions within the given address range.
191 Decide when we must have reached the end of the function prologue.
192 If a frame_info pointer is provided, fill in its prologue information.
194 Returns the address of the first instruction after the prologue. */
197 iq2000_scan_prologue (CORE_ADDR scan_start,
199 struct frame_info *fi,
200 struct iq2000_frame_cache *cache)
202 struct symtab_and_line sal;
205 int found_store_lr = 0;
206 int found_decr_sp = 0;
211 if (scan_end == (CORE_ADDR) 0)
213 loop_end = scan_start + 100;
214 sal.end = sal.pc = 0;
220 sal = find_last_line_symbol (scan_start, scan_end, 0);
224 We first have to save the saved register's offset, and
225 only later do we compute its actual address. Since the
226 offset can be zero, we must first initialize all the
227 saved regs to minus one (so we can later distinguish
228 between one that's not saved, and one that's saved at zero). */
229 for (srcreg = 0; srcreg < E_NUM_REGS; srcreg ++)
230 cache->saved_regs[srcreg] = -1;
232 cache->framesize = 0;
234 for (pc = scan_start; pc < loop_end; pc += 4)
236 LONGEST insn = read_memory_unsigned_integer (pc, 4);
237 /* Skip any instructions writing to (sp) or decrementing the
239 if ((insn & 0xffe00000) == 0xac200000)
241 /* sw using SP/%1 as base. */
242 /* LEGACY -- from assembly-only port. */
243 tgtreg = ((insn >> 16) & 0x1f);
244 if (tgtreg >= 0 && tgtreg < E_NUM_REGS)
245 cache->saved_regs[tgtreg] = -((signed short) (insn & 0xffff));
247 if (tgtreg == E_LR_REGNUM)
252 if ((insn & 0xffff8000) == 0x20218000)
254 /* addi %1, %1, -N == addi %sp, %sp, -N */
255 /* LEGACY -- from assembly-only port */
257 cache->framesize = -((signed short) (insn & 0xffff));
261 if (INSN_IS_ADDIU (insn))
263 srcreg = ADDIU_REG_SRC (insn);
264 tgtreg = ADDIU_REG_TGT (insn);
265 offset = ADDIU_IMMEDIATE (insn);
266 if (srcreg == E_SP_REGNUM && tgtreg == E_SP_REGNUM)
267 cache->framesize = -offset;
271 if (INSN_IS_STORE_WORD (insn))
273 srcreg = SW_REG_SRC (insn);
274 tgtreg = SW_REG_INDEX (insn);
275 offset = SW_OFFSET (insn);
277 if (tgtreg == E_SP_REGNUM || tgtreg == E_FP_REGNUM)
279 /* "push" to stack (via SP or FP reg) */
280 if (cache->saved_regs[srcreg] == -1) /* Don't save twice. */
281 cache->saved_regs[srcreg] = offset;
286 if (INSN_IS_MOVE (insn))
288 srcreg = MOVE_REG_SRC (insn);
289 tgtreg = MOVE_REG_TGT (insn);
291 if (srcreg == E_SP_REGNUM && tgtreg == E_FP_REGNUM)
299 /* Unknown instruction encountered in frame. Bail out?
300 1) If we have a subsequent line symbol, we can keep going.
301 2) If not, we need to bail out and quit scanning instructions. */
303 if (fi && sal.end && (pc < sal.end)) /* Keep scanning. */
313 iq2000_init_frame_cache (struct iq2000_frame_cache *cache)
318 cache->framesize = 0;
321 for (i = 0; i < E_NUM_REGS; i++)
322 cache->saved_regs[i] = -1;
325 /* Function: iq2000_skip_prologue
326 If the input address is in a function prologue,
327 returns the address of the end of the prologue;
328 else returns the input address.
330 Note: the input address is likely to be the function start,
331 since this function is mainly used for advancing a breakpoint
332 to the first line, or stepping to the first line when we have
333 stepped into a function call. */
336 iq2000_skip_prologue (CORE_ADDR pc)
338 CORE_ADDR func_addr = 0 , func_end = 0;
340 if (find_pc_partial_function (pc, NULL, & func_addr, & func_end))
342 struct symtab_and_line sal;
343 struct iq2000_frame_cache cache;
345 /* Found a function. */
346 sal = find_pc_line (func_addr, 0);
347 if (sal.end && sal.end < func_end)
348 /* Found a line number, use it as end of prologue. */
351 /* No useable line symbol. Use prologue parsing method. */
352 iq2000_init_frame_cache (&cache);
353 return iq2000_scan_prologue (func_addr, func_end, NULL, &cache);
356 /* No function symbol -- just return the PC. */
357 return (CORE_ADDR) pc;
360 static struct iq2000_frame_cache *
361 iq2000_frame_cache (struct frame_info *next_frame, void **this_cache)
363 struct iq2000_frame_cache *cache;
364 CORE_ADDR current_pc;
370 cache = FRAME_OBSTACK_ZALLOC (struct iq2000_frame_cache);
371 iq2000_init_frame_cache (cache);
374 cache->base = frame_unwind_register_unsigned (next_frame, E_FP_REGNUM);
375 //if (cache->base == 0)
378 current_pc = frame_pc_unwind (next_frame);
379 find_pc_partial_function (current_pc, NULL, &cache->pc, NULL);
381 iq2000_scan_prologue (cache->pc, current_pc, next_frame, cache);
382 if (!cache->using_fp)
383 cache->base = frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
385 cache->saved_sp = cache->base + cache->framesize;
387 for (i = 0; i < E_NUM_REGS; i++)
388 if (cache->saved_regs[i] != -1)
389 cache->saved_regs[i] += cache->base;
395 iq2000_frame_prev_register (struct frame_info *next_frame, void **this_cache,
396 int regnum, int *optimizedp,
397 enum lval_type *lvalp, CORE_ADDR *addrp,
398 int *realnump, void *valuep)
400 struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
401 if (regnum == E_SP_REGNUM && cache->saved_sp)
408 store_unsigned_integer (valuep, 4, cache->saved_sp);
412 if (regnum == E_PC_REGNUM)
413 regnum = E_LR_REGNUM;
415 if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != -1)
418 *lvalp = lval_memory;
419 *addrp = cache->saved_regs[regnum];
422 read_memory (*addrp, valuep, register_size (current_gdbarch, regnum));
427 *lvalp = lval_register;
431 frame_unwind_register (next_frame, (*realnump), valuep);
435 iq2000_frame_this_id (struct frame_info *next_frame, void **this_cache,
436 struct frame_id *this_id)
438 struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
440 /* This marks the outermost frame. */
441 if (cache->base == 0)
444 *this_id = frame_id_build (cache->saved_sp, cache->pc);
447 static const struct frame_unwind iq2000_frame_unwind = {
449 iq2000_frame_this_id,
450 iq2000_frame_prev_register
453 static const struct frame_unwind *
454 iq2000_frame_sniffer (struct frame_info *next_frame)
456 return &iq2000_frame_unwind;
460 iq2000_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
462 return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
466 iq2000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
468 return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
471 static struct frame_id
472 iq2000_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
474 return frame_id_build (iq2000_unwind_sp (gdbarch, next_frame),
475 frame_pc_unwind (next_frame));
479 iq2000_frame_base_address (struct frame_info *next_frame, void **this_cache)
481 struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
486 static const struct frame_base iq2000_frame_base = {
487 &iq2000_frame_unwind,
488 iq2000_frame_base_address,
489 iq2000_frame_base_address,
490 iq2000_frame_base_address
493 static const unsigned char *
494 iq2000_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
496 static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d };
497 static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 };
499 if ((*pcptr & 3) != 0)
500 error ("breakpoint_from_pc: invalid breakpoint address 0x%lx",
504 return (gdbarch_byte_order (current_gdbarch)
505 == BFD_ENDIAN_BIG) ? big_breakpoint
509 /* Target function return value methods: */
511 /* Function: store_return_value
512 Copy the function return value from VALBUF into the
513 proper location for a function return. */
516 iq2000_store_return_value (struct type *type, struct regcache *regcache,
519 int len = TYPE_LENGTH (type);
520 int regno = E_FN_RETURN_REGNUM;
525 int size = len % 4 ?: 4;
528 memcpy (buf + 4 - size, valbuf, size);
529 regcache_raw_write (regcache, regno++, buf);
531 valbuf = ((char *) valbuf) + size;
535 /* Function: use_struct_convention
536 Returns non-zero if the given struct type will be returned using
537 a special convention, rather than the normal function return method. */
540 iq2000_use_struct_convention (struct type *type)
542 return ((TYPE_CODE (type) == TYPE_CODE_STRUCT)
543 || (TYPE_CODE (type) == TYPE_CODE_UNION))
544 && TYPE_LENGTH (type) > 8;
547 /* Function: extract_return_value
548 Copy the function's return value into VALBUF.
549 This function is called only in the context of "target function calls",
550 ie. when the debugger forces a function to be called in the child, and
551 when the debugger forces a function to return prematurely via the
555 iq2000_extract_return_value (struct type *type, struct regcache *regcache,
558 /* If the function's return value is 8 bytes or less, it is
559 returned in a register, and if larger than 8 bytes, it is
560 returned in a stack location which is pointed to by the same
562 CORE_ADDR return_buffer;
563 int len = TYPE_LENGTH (type);
567 int regno = E_FN_RETURN_REGNUM;
569 /* Return values of <= 8 bytes are returned in
574 int size = len % 4 ?: 4;
576 /* By using store_unsigned_integer we avoid having to
577 do anything special for small big-endian values. */
578 regcache_cooked_read_unsigned (regcache, regno++, &tmp);
579 store_unsigned_integer (valbuf, size, tmp);
581 valbuf = ((char *) valbuf) + size;
586 /* Return values > 8 bytes are returned in memory,
587 pointed to by FN_RETURN_REGNUM. */
588 regcache_cooked_read (regcache, E_FN_RETURN_REGNUM, & return_buffer);
589 read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
593 static enum return_value_convention
594 iq2000_return_value (struct gdbarch *gdbarch, struct type *type,
595 struct regcache *regcache,
596 void *readbuf, const void *writebuf)
598 if (iq2000_use_struct_convention (type))
599 return RETURN_VALUE_STRUCT_CONVENTION;
601 iq2000_store_return_value (type, regcache, writebuf);
603 iq2000_extract_return_value (type, regcache, readbuf);
604 return RETURN_VALUE_REGISTER_CONVENTION;
607 /* Function: register_virtual_type
608 Returns the default type for register N. */
611 iq2000_register_type (struct gdbarch *gdbarch, int regnum)
613 return builtin_type_int32;
617 iq2000_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
619 /* This is the same frame alignment used by gcc. */
620 return ((sp + 7) & ~7);
623 /* Convenience function to check 8-byte types for being a scalar type
624 or a struct with only one long long or double member. */
626 iq2000_pass_8bytetype_by_address (struct type *type)
631 while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
632 type = TYPE_TARGET_TYPE (type);
633 /* Non-struct and non-union types are always passed by value. */
634 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
635 && TYPE_CODE (type) != TYPE_CODE_UNION)
637 /* Structs with more than 1 field are always passed by address. */
638 if (TYPE_NFIELDS (type) != 1)
640 /* Get field type. */
641 ftype = (TYPE_FIELDS (type))[0].type;
642 /* The field type must have size 8, otherwise pass by address. */
643 if (TYPE_LENGTH (ftype) != 8)
645 /* Skip typedefs of field type. */
646 while (TYPE_CODE (ftype) == TYPE_CODE_TYPEDEF)
647 ftype = TYPE_TARGET_TYPE (ftype);
648 /* If field is int or float, pass by value. */
649 if (TYPE_CODE (ftype) == TYPE_CODE_FLT
650 || TYPE_CODE (ftype) == TYPE_CODE_INT)
652 /* Everything else, pass by address. */
657 iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
658 struct regcache *regcache, CORE_ADDR bp_addr,
659 int nargs, struct value **args, CORE_ADDR sp,
660 int struct_return, CORE_ADDR struct_addr)
665 int i, argreg, typelen, slacklen;
667 /* Used to copy struct arguments into the stack. */
668 CORE_ADDR struct_ptr;
670 /* First determine how much stack space we will need. */
671 for (i = 0, argreg = E_1ST_ARGREG + (struct_return != 0); i < nargs; i++)
673 type = value_type (args[i]);
674 typelen = TYPE_LENGTH (type);
677 /* Scalars of up to 4 bytes,
678 structs of up to 4 bytes, and
680 if (argreg <= E_LAST_ARGREG)
685 else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
689 structs with a single field of long long or double. */
690 if (argreg <= E_LAST_ARGREG - 1)
692 /* 8-byte arg goes into a register pair
693 (must start with an even-numbered reg) */
694 if (((argreg - E_1ST_ARGREG) % 2) != 0)
700 argreg = E_LAST_ARGREG + 1; /* no more argregs. */
701 /* 8-byte arg goes on stack, must be 8-byte aligned. */
702 stackspace = ((stackspace + 7) & ~7);
708 /* Structs are passed as pointer to a copy of the struct.
709 So we need room on the stack for a copy of the struct
710 plus for the argument pointer. */
711 if (argreg <= E_LAST_ARGREG)
715 /* Care for 8-byte alignment of structs saved on stack. */
716 stackspace += ((typelen + 7) & ~7);
720 /* Now copy params, in ascending order, into their assigned location
721 (either in a register or on the stack). */
723 sp -= (sp % 8); /* align */
726 sp -= (sp % 8); /* align again */
729 argreg = E_1ST_ARGREG;
732 /* A function that returns a struct will consume one argreg to do so.
734 regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
737 for (i = 0; i < nargs; i++)
739 type = value_type (args[i]);
740 typelen = TYPE_LENGTH (type);
741 val = value_contents (args[i]);
744 /* Char, short, int, float, pointer, and structs <= four bytes. */
745 slacklen = (4 - (typelen % 4)) % 4;
746 memset (buf, 0, sizeof (buf));
747 memcpy (buf + slacklen, val, typelen);
748 if (argreg <= E_LAST_ARGREG)
750 /* Passed in a register. */
751 regcache_raw_write (regcache, argreg++, buf);
755 /* Passed on the stack. */
756 write_memory (sp + stackspace, buf, 4);
760 else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
762 /* (long long), (double), or struct consisting of
763 a single (long long) or (double). */
764 if (argreg <= E_LAST_ARGREG - 1)
766 /* 8-byte arg goes into a register pair
767 (must start with an even-numbered reg) */
768 if (((argreg - E_1ST_ARGREG) % 2) != 0)
770 regcache_raw_write (regcache, argreg++, val);
771 regcache_raw_write (regcache, argreg++, val + 4);
775 /* 8-byte arg goes on stack, must be 8-byte aligned. */
776 argreg = E_LAST_ARGREG + 1; /* no more argregs. */
777 stackspace = ((stackspace + 7) & ~7);
778 write_memory (sp + stackspace, val, typelen);
784 /* Store struct beginning at the upper end of the previously
785 computed stack space. Then store the address of the struct
786 using the usual rules for a 4 byte value. */
787 struct_ptr -= ((typelen + 7) & ~7);
788 write_memory (struct_ptr, val, typelen);
789 if (argreg <= E_LAST_ARGREG)
790 regcache_cooked_write_unsigned (regcache, argreg++, struct_ptr);
793 store_unsigned_integer (buf, 4, struct_ptr);
794 write_memory (sp + stackspace, buf, 4);
800 /* Store return address. */
801 regcache_cooked_write_unsigned (regcache, E_LR_REGNUM, bp_addr);
803 /* Update stack pointer. */
804 regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
806 /* And that should do it. Return the new stack pointer. */
810 /* Function: gdbarch_init
811 Initializer function for the iq2000 gdbarch vector.
812 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
814 static struct gdbarch *
815 iq2000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
817 struct gdbarch *gdbarch;
819 /* Look up list for candidates - only one. */
820 arches = gdbarch_list_lookup_by_info (arches, &info);
822 return arches->gdbarch;
824 gdbarch = gdbarch_alloc (&info, NULL);
826 set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
827 set_gdbarch_num_pseudo_regs (gdbarch, 0);
828 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
829 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
830 set_gdbarch_register_name (gdbarch, iq2000_register_name);
831 set_gdbarch_address_to_pointer (gdbarch, iq2000_address_to_pointer);
832 set_gdbarch_pointer_to_address (gdbarch, iq2000_pointer_to_address);
833 set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
834 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
835 set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
836 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
837 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
838 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
839 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
840 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
841 set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
842 set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
843 set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
844 set_gdbarch_return_value (gdbarch, iq2000_return_value);
845 set_gdbarch_breakpoint_from_pc (gdbarch, iq2000_breakpoint_from_pc);
846 set_gdbarch_frame_args_skip (gdbarch, 0);
847 set_gdbarch_skip_prologue (gdbarch, iq2000_skip_prologue);
848 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
849 set_gdbarch_print_insn (gdbarch, print_insn_iq2000);
850 set_gdbarch_register_type (gdbarch, iq2000_register_type);
851 set_gdbarch_frame_align (gdbarch, iq2000_frame_align);
852 set_gdbarch_unwind_sp (gdbarch, iq2000_unwind_sp);
853 set_gdbarch_unwind_pc (gdbarch, iq2000_unwind_pc);
854 set_gdbarch_unwind_dummy_id (gdbarch, iq2000_unwind_dummy_id);
855 frame_base_set_default (gdbarch, &iq2000_frame_base);
856 set_gdbarch_push_dummy_call (gdbarch, iq2000_push_dummy_call);
858 gdbarch_init_osabi (info, gdbarch);
860 frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
861 frame_unwind_append_sniffer (gdbarch, iq2000_frame_sniffer);
866 /* Function: _initialize_iq2000_tdep
867 Initializer function for the iq2000 module.
868 Called by gdb at start-up. */
871 _initialize_iq2000_tdep (void)
873 register_gdbarch_init (bfd_arch_iq2000, iq2000_gdbarch_init);