Update copyright year range in all GDB files.
[external/binutils.git] / gdb / iq2000-tdep.c
1 /* Target-dependent code for the IQ2000 architecture, for GDB, the GNU
2    Debugger.
3
4    Copyright (C) 2000-2019 Free Software Foundation, Inc.
5
6    Contributed by Red Hat.
7
8    This file is part of GDB.
9
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 3 of the License, or
13    (at your option) any later version.
14
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.
19
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
23 #include "defs.h"
24 #include "frame.h"
25 #include "frame-base.h"
26 #include "frame-unwind.h"
27 #include "dwarf2-frame.h"
28 #include "gdbtypes.h"
29 #include "value.h"
30 #include "dis-asm.h"
31 #include "arch-utils.h"
32 #include "regcache.h"
33 #include "osabi.h"
34 #include "gdbcore.h"
35
36 enum gdb_regnum
37 {
38   E_R0_REGNUM,  E_R1_REGNUM,  E_R2_REGNUM,  E_R3_REGNUM, 
39   E_R4_REGNUM,  E_R5_REGNUM,  E_R6_REGNUM,  E_R7_REGNUM, 
40   E_R8_REGNUM,  E_R9_REGNUM,  E_R10_REGNUM, E_R11_REGNUM, 
41   E_R12_REGNUM, E_R13_REGNUM, E_R14_REGNUM, E_R15_REGNUM, 
42   E_R16_REGNUM, E_R17_REGNUM, E_R18_REGNUM, E_R19_REGNUM, 
43   E_R20_REGNUM, E_R21_REGNUM, E_R22_REGNUM, E_R23_REGNUM, 
44   E_R24_REGNUM, E_R25_REGNUM, E_R26_REGNUM, E_R27_REGNUM, 
45   E_R28_REGNUM, E_R29_REGNUM, E_R30_REGNUM, E_R31_REGNUM, 
46   E_PC_REGNUM, 
47   E_LR_REGNUM        = E_R31_REGNUM, /* Link register.  */
48   E_SP_REGNUM        = E_R29_REGNUM, /* Stack pointer.  */
49   E_FP_REGNUM        = E_R27_REGNUM, /* Frame pointer.  */
50   E_FN_RETURN_REGNUM = E_R2_REGNUM,  /* Function return value register.  */
51   E_1ST_ARGREG       = E_R4_REGNUM,  /* 1st  function arg register.  */
52   E_LAST_ARGREG      = E_R11_REGNUM, /* Last function arg register.  */
53   E_NUM_REGS         = E_PC_REGNUM + 1
54 };
55
56 /* Use an invalid address value as 'not available' marker.  */
57 enum { REG_UNAVAIL = (CORE_ADDR) -1 };
58
59 struct iq2000_frame_cache
60 {
61   /* Base address.  */
62   CORE_ADDR  base;
63   CORE_ADDR  pc;
64   LONGEST    framesize;
65   int        using_fp;
66   CORE_ADDR  saved_sp;
67   CORE_ADDR  saved_regs [E_NUM_REGS];
68 };
69
70 /* Harvard methods: */
71
72 static CORE_ADDR
73 insn_ptr_from_addr (CORE_ADDR addr)     /* CORE_ADDR to target pointer.  */
74 {
75   return addr & 0x7fffffffL;
76 }
77
78 static CORE_ADDR
79 insn_addr_from_ptr (CORE_ADDR ptr)      /* target_pointer to CORE_ADDR.  */
80 {
81   return (ptr & 0x7fffffffL) | 0x80000000L;
82 }
83
84 /* Function: pointer_to_address
85    Convert a target pointer to an address in host (CORE_ADDR) format.  */
86
87 static CORE_ADDR
88 iq2000_pointer_to_address (struct gdbarch *gdbarch,
89                            struct type * type, const gdb_byte * buf)
90 {
91   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
92   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
93   CORE_ADDR addr
94     = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
95
96   if (target == TYPE_CODE_FUNC
97       || target == TYPE_CODE_METHOD
98       || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
99     addr = insn_addr_from_ptr (addr);
100
101   return addr;
102 }
103
104 /* Function: address_to_pointer
105    Convert a host-format address (CORE_ADDR) into a target pointer.  */
106
107 static void
108 iq2000_address_to_pointer (struct gdbarch *gdbarch,
109                            struct type *type, gdb_byte *buf, CORE_ADDR addr)
110 {
111   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
112   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
113
114   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
115     addr = insn_ptr_from_addr (addr);
116   store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
117 }
118
119 /* Real register methods: */
120
121 /* Function: register_name
122    Returns the name of the iq2000 register number N.  */
123
124 static const char *
125 iq2000_register_name (struct gdbarch *gdbarch, int regnum)
126 {
127   static const char * names[E_NUM_REGS] =
128     {
129       "r0",  "r1",  "r2",  "r3",  "r4",
130       "r5",  "r6",  "r7",  "r8",  "r9",
131       "r10", "r11", "r12", "r13", "r14",
132       "r15", "r16", "r17", "r18", "r19",
133       "r20", "r21", "r22", "r23", "r24",
134       "r25", "r26", "r27", "r28", "r29",
135       "r30", "r31",
136       "pc"
137     };
138   if (regnum < 0 || regnum >= E_NUM_REGS)
139     return NULL;
140   return names[regnum];
141 }
142
143 /* Prologue analysis methods:  */
144
145 /* ADDIU insn (001001 rs(5) rt(5) imm(16)).  */
146 #define INSN_IS_ADDIU(X)        (((X) & 0xfc000000) == 0x24000000) 
147 #define ADDIU_REG_SRC(X)        (((X) & 0x03e00000) >> 21)
148 #define ADDIU_REG_TGT(X)        (((X) & 0x001f0000) >> 16)
149 #define ADDIU_IMMEDIATE(X)      ((signed short) ((X) & 0x0000ffff))
150
151 /* "MOVE" (OR) insn (000000 rs(5) rt(5) rd(5) 00000 100101).  */
152 #define INSN_IS_MOVE(X)         (((X) & 0xffe007ff) == 0x00000025)
153 #define MOVE_REG_SRC(X)         (((X) & 0x001f0000) >> 16)
154 #define MOVE_REG_TGT(X)         (((X) & 0x0000f800) >> 11)
155
156 /* STORE WORD insn (101011 rs(5) rt(5) offset(16)).  */
157 #define INSN_IS_STORE_WORD(X)   (((X) & 0xfc000000) == 0xac000000)
158 #define SW_REG_INDEX(X)         (((X) & 0x03e00000) >> 21)
159 #define SW_REG_SRC(X)           (((X) & 0x001f0000) >> 16)
160 #define SW_OFFSET(X)            ((signed short) ((X) & 0x0000ffff))
161
162 /* Function: find_last_line_symbol
163
164    Given an address range, first find a line symbol corresponding to
165    the starting address.  Then find the last line symbol within the 
166    range that has a line number less than or equal to the first line.
167
168    For optimized code with code motion, this finds the last address
169    for the lowest-numbered line within the address range.  */
170
171 static struct symtab_and_line
172 find_last_line_symbol (CORE_ADDR start, CORE_ADDR end, int notcurrent)
173 {
174   struct symtab_and_line sal = find_pc_line (start, notcurrent);
175   struct symtab_and_line best_sal = sal;
176
177   if (sal.pc == 0 || sal.line == 0 || sal.end == 0)
178     return sal;
179
180   do
181     {
182       if (sal.line && sal.line <= best_sal.line)
183         best_sal = sal;
184       sal = find_pc_line (sal.end, notcurrent);
185     }
186   while (sal.pc && sal.pc < end);
187
188   return best_sal;
189 }
190
191 /* Function: scan_prologue
192    Decode the instructions within the given address range.
193    Decide when we must have reached the end of the function prologue.
194    If a frame_info pointer is provided, fill in its prologue information.
195
196    Returns the address of the first instruction after the prologue.  */
197
198 static CORE_ADDR
199 iq2000_scan_prologue (struct gdbarch *gdbarch,
200                       CORE_ADDR scan_start,
201                       CORE_ADDR scan_end,
202                       struct frame_info *fi,
203                       struct iq2000_frame_cache *cache)
204 {
205   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
206   struct symtab_and_line sal;
207   CORE_ADDR pc;
208   CORE_ADDR loop_end;
209   int srcreg;
210   int tgtreg;
211   signed short offset;
212
213   if (scan_end == (CORE_ADDR) 0)
214     {
215       loop_end = scan_start + 100;
216       sal.end = sal.pc = 0;
217     }
218   else
219     {
220       loop_end = scan_end;
221       if (fi)
222         sal = find_last_line_symbol (scan_start, scan_end, 0);
223       else
224         sal.end = 0;    /* Avoid GCC false warning.  */
225     }
226
227   /* Saved registers:
228      We first have to save the saved register's offset, and 
229      only later do we compute its actual address.  Since the
230      offset can be zero, we must first initialize all the 
231      saved regs to minus one (so we can later distinguish 
232      between one that's not saved, and one that's saved at zero).  */
233   for (srcreg = 0; srcreg < E_NUM_REGS; srcreg ++)
234     cache->saved_regs[srcreg] = -1;
235   cache->using_fp = 0;
236   cache->framesize = 0;
237
238   for (pc = scan_start; pc < loop_end; pc += 4)
239     {
240       LONGEST insn = read_memory_unsigned_integer (pc, 4, byte_order);
241       /* Skip any instructions writing to (sp) or decrementing the
242          SP.  */
243       if ((insn & 0xffe00000) == 0xac200000)
244         {
245           /* sw using SP/%1 as base.  */
246           /* LEGACY -- from assembly-only port.  */
247           tgtreg = ((insn >> 16) & 0x1f);
248           if (tgtreg >= 0 && tgtreg < E_NUM_REGS)
249             cache->saved_regs[tgtreg] = -((signed short) (insn & 0xffff));
250
251           continue;
252         }
253
254       if ((insn & 0xffff8000) == 0x20218000)
255         {
256           /* addi %1, %1, -N == addi %sp, %sp, -N */
257           /* LEGACY -- from assembly-only port.  */
258           cache->framesize = -((signed short) (insn & 0xffff));
259           continue;
260         }
261
262       if (INSN_IS_ADDIU (insn))
263         {
264           srcreg = ADDIU_REG_SRC (insn);
265           tgtreg = ADDIU_REG_TGT (insn);
266           offset = ADDIU_IMMEDIATE (insn);
267           if (srcreg == E_SP_REGNUM && tgtreg == E_SP_REGNUM)
268             cache->framesize = -offset;
269           continue;
270         }
271
272       if (INSN_IS_STORE_WORD (insn))
273         {
274           srcreg = SW_REG_SRC (insn);
275           tgtreg = SW_REG_INDEX (insn);
276           offset = SW_OFFSET (insn);
277
278           if (tgtreg == E_SP_REGNUM || tgtreg == E_FP_REGNUM)
279             {
280               /* "push" to stack (via SP or FP reg).  */
281               if (cache->saved_regs[srcreg] == -1) /* Don't save twice.  */
282                 cache->saved_regs[srcreg] = offset;
283               continue;
284             }
285         }
286
287       if (INSN_IS_MOVE (insn))
288         {
289           srcreg = MOVE_REG_SRC (insn);
290           tgtreg = MOVE_REG_TGT (insn);
291
292           if (srcreg == E_SP_REGNUM && tgtreg == E_FP_REGNUM)
293             {
294               /* Copy sp to fp.  */
295               cache->using_fp = 1;
296               continue;
297             }
298         }
299
300       /* Unknown instruction encountered in frame.  Bail out?
301          1) If we have a subsequent line symbol, we can keep going.
302          2) If not, we need to bail out and quit scanning instructions.  */
303
304       if (fi && sal.end && (pc < sal.end)) /* Keep scanning.  */
305         continue;
306       else /* bail */
307         break;
308     }
309
310   return pc;
311 }
312
313 static void
314 iq2000_init_frame_cache (struct iq2000_frame_cache *cache)
315 {
316   int i;
317
318   cache->base = 0;
319   cache->framesize = 0;
320   cache->using_fp = 0;
321   cache->saved_sp = 0;
322   for (i = 0; i < E_NUM_REGS; i++)
323     cache->saved_regs[i] = -1;
324 }
325
326 /* Function: iq2000_skip_prologue
327    If the input address is in a function prologue, 
328    returns the address of the end of the prologue;
329    else returns the input address.
330
331    Note: the input address is likely to be the function start, 
332    since this function is mainly used for advancing a breakpoint
333    to the first line, or stepping to the first line when we have
334    stepped into a function call.  */
335
336 static CORE_ADDR
337 iq2000_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
338 {
339   CORE_ADDR func_addr = 0 , func_end = 0;
340
341   if (find_pc_partial_function (pc, NULL, & func_addr, & func_end))
342     {
343       struct symtab_and_line sal;
344       struct iq2000_frame_cache cache;
345
346       /* Found a function.  */
347       sal = find_pc_line (func_addr, 0);
348       if (sal.end && sal.end < func_end)
349         /* Found a line number, use it as end of prologue.  */
350         return sal.end;
351
352       /* No useable line symbol.  Use prologue parsing method.  */
353       iq2000_init_frame_cache (&cache);
354       return iq2000_scan_prologue (gdbarch, func_addr, func_end, NULL, &cache);
355     }
356
357   /* No function symbol -- just return the PC.  */
358   return (CORE_ADDR) pc;
359 }
360
361 static struct iq2000_frame_cache *
362 iq2000_frame_cache (struct frame_info *this_frame, void **this_cache)
363 {
364   struct gdbarch *gdbarch = get_frame_arch (this_frame);
365   struct iq2000_frame_cache *cache;
366   CORE_ADDR current_pc;
367   int i;
368
369   if (*this_cache)
370     return (struct iq2000_frame_cache *) *this_cache;
371
372   cache = FRAME_OBSTACK_ZALLOC (struct iq2000_frame_cache);
373   iq2000_init_frame_cache (cache);
374   *this_cache = cache;
375
376   cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
377
378   current_pc = get_frame_pc (this_frame);
379   find_pc_partial_function (current_pc, NULL, &cache->pc, NULL);
380   if (cache->pc != 0)
381     iq2000_scan_prologue (gdbarch, cache->pc, current_pc, this_frame, cache);
382   if (!cache->using_fp)
383     cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
384
385   cache->saved_sp = cache->base + cache->framesize;
386
387   for (i = 0; i < E_NUM_REGS; i++)
388     if (cache->saved_regs[i] != -1)
389       cache->saved_regs[i] += cache->base;
390
391   return cache;
392 }
393
394 static struct value *
395 iq2000_frame_prev_register (struct frame_info *this_frame, void **this_cache,
396                             int regnum)
397 {
398   struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
399                                                          this_cache);
400
401   if (regnum == E_SP_REGNUM && cache->saved_sp)
402     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
403
404   if (regnum == E_PC_REGNUM)
405     regnum = E_LR_REGNUM;
406
407   if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != -1)
408     return frame_unwind_got_memory (this_frame, regnum,
409                                     cache->saved_regs[regnum]);
410
411   return frame_unwind_got_register (this_frame, regnum, regnum);
412 }
413
414 static void
415 iq2000_frame_this_id (struct frame_info *this_frame, void **this_cache,
416                       struct frame_id *this_id)
417 {
418   struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
419                                                          this_cache);
420
421   /* This marks the outermost frame.  */
422   if (cache->base == 0) 
423     return;
424
425   *this_id = frame_id_build (cache->saved_sp, cache->pc);
426 }
427
428 static const struct frame_unwind iq2000_frame_unwind = {
429   NORMAL_FRAME,
430   default_frame_unwind_stop_reason,
431   iq2000_frame_this_id,
432   iq2000_frame_prev_register,
433   NULL,
434   default_frame_sniffer
435 };
436
437 static CORE_ADDR
438 iq2000_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
439 {
440   return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
441 }   
442
443 static CORE_ADDR
444 iq2000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
445 {
446   return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
447 }
448
449 static struct frame_id
450 iq2000_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
451 {
452   CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
453   return frame_id_build (sp, get_frame_pc (this_frame));
454 }
455
456 static CORE_ADDR
457 iq2000_frame_base_address (struct frame_info *this_frame, void **this_cache)
458 {
459   struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
460                                                          this_cache);
461
462   return cache->base;
463 }
464   
465 static const struct frame_base iq2000_frame_base = {
466   &iq2000_frame_unwind,
467   iq2000_frame_base_address,
468   iq2000_frame_base_address, 
469   iq2000_frame_base_address
470 };
471
472 static int
473 iq2000_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)
474 {
475   if ((*pcptr & 3) != 0)
476     error (_("breakpoint_from_pc: invalid breakpoint address 0x%lx"),
477            (long) *pcptr);
478
479   return 4;
480 }
481
482 static const gdb_byte *
483 iq2000_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
484 {
485   static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d };
486   static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 };
487   *size = kind;
488
489   return (gdbarch_byte_order (gdbarch)
490           == BFD_ENDIAN_BIG) ? big_breakpoint : little_breakpoint;
491 }
492
493 /* Target function return value methods: */
494
495 /* Function: store_return_value
496    Copy the function return value from VALBUF into the 
497    proper location for a function return.  */
498
499 static void
500 iq2000_store_return_value (struct type *type, struct regcache *regcache,
501                            const void *valbuf)
502 {
503   int len = TYPE_LENGTH (type);
504   int regno = E_FN_RETURN_REGNUM;
505
506   while (len > 0)
507     {
508       gdb_byte buf[4];
509       int size = len % 4 ?: 4;
510
511       memset (buf, 0, 4);
512       memcpy (buf + 4 - size, valbuf, size);
513       regcache->raw_write (regno++, buf);
514       len -= size;
515       valbuf = ((char *) valbuf) + size;
516     }
517 }
518
519 /* Function: use_struct_convention 
520    Returns non-zero if the given struct type will be returned using
521    a special convention, rather than the normal function return method.  */
522
523 static int
524 iq2000_use_struct_convention (struct type *type)
525 {
526   return ((TYPE_CODE (type) == TYPE_CODE_STRUCT)
527           || (TYPE_CODE (type) == TYPE_CODE_UNION))
528          && TYPE_LENGTH (type) > 8;
529 }
530
531 /* Function: extract_return_value
532    Copy the function's return value into VALBUF. 
533    This function is called only in the context of "target function calls",
534    ie. when the debugger forces a function to be called in the child, and
535    when the debugger forces a function to return prematurely via the
536    "return" command.  */
537
538 static void
539 iq2000_extract_return_value (struct type *type, struct regcache *regcache,
540                              gdb_byte *valbuf)
541 {
542   struct gdbarch *gdbarch = regcache->arch ();
543   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
544
545   /* If the function's return value is 8 bytes or less, it is
546      returned in a register, and if larger than 8 bytes, it is 
547      returned in a stack location which is pointed to by the same
548      register.  */
549   int len = TYPE_LENGTH (type);
550
551   if (len <= (2 * 4))
552     {
553       int regno = E_FN_RETURN_REGNUM;
554
555       /* Return values of <= 8 bytes are returned in 
556          FN_RETURN_REGNUM.  */
557       while (len > 0)
558         {
559           ULONGEST tmp;
560           int size = len % 4 ?: 4;
561
562           /* By using store_unsigned_integer we avoid having to
563              do anything special for small big-endian values.  */
564           regcache_cooked_read_unsigned (regcache, regno++, &tmp);
565           store_unsigned_integer (valbuf, size, byte_order, tmp);
566           len -= size;
567           valbuf += size;
568         }
569     }
570   else
571     {
572       /* Return values > 8 bytes are returned in memory,
573          pointed to by FN_RETURN_REGNUM.  */
574       ULONGEST return_buffer;
575       regcache_cooked_read_unsigned (regcache, E_FN_RETURN_REGNUM,
576                                      &return_buffer);
577       read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
578     }
579 }
580
581 static enum return_value_convention
582 iq2000_return_value (struct gdbarch *gdbarch, struct value *function,
583                      struct type *type, struct regcache *regcache,
584                      gdb_byte *readbuf, const gdb_byte *writebuf)
585 {
586   if (iq2000_use_struct_convention (type))
587     return RETURN_VALUE_STRUCT_CONVENTION;
588   if (writebuf)
589     iq2000_store_return_value (type, regcache, writebuf);
590   else if (readbuf)
591     iq2000_extract_return_value (type, regcache, readbuf);
592   return RETURN_VALUE_REGISTER_CONVENTION;
593 }
594
595 /* Function: register_virtual_type
596    Returns the default type for register N.  */
597
598 static struct type *
599 iq2000_register_type (struct gdbarch *gdbarch, int regnum)
600 {
601   return builtin_type (gdbarch)->builtin_int32;
602 }
603
604 static CORE_ADDR
605 iq2000_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
606 {
607   /* This is the same frame alignment used by gcc.  */
608   return ((sp + 7) & ~7);
609 }
610
611 /* Convenience function to check 8-byte types for being a scalar type
612    or a struct with only one long long or double member.  */
613 static int
614 iq2000_pass_8bytetype_by_address (struct type *type)
615 {
616   struct type *ftype;
617
618   /* Skip typedefs.  */
619   while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
620     type = TYPE_TARGET_TYPE (type);
621   /* Non-struct and non-union types are always passed by value.  */
622   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
623       && TYPE_CODE (type) != TYPE_CODE_UNION)
624     return 0;
625   /* Structs with more than 1 field are always passed by address.  */
626   if (TYPE_NFIELDS (type) != 1)
627     return 1;
628   /* Get field type.  */
629   ftype = (TYPE_FIELDS (type))[0].type;
630   /* The field type must have size 8, otherwise pass by address.  */
631   if (TYPE_LENGTH (ftype) != 8)
632     return 1;
633   /* Skip typedefs of field type.  */
634   while (TYPE_CODE (ftype) == TYPE_CODE_TYPEDEF)
635     ftype = TYPE_TARGET_TYPE (ftype);
636   /* If field is int or float, pass by value.  */
637   if (TYPE_CODE (ftype) == TYPE_CODE_FLT
638       || TYPE_CODE (ftype) == TYPE_CODE_INT)
639     return 0;
640   /* Everything else, pass by address.  */
641   return 1;
642 }
643
644 static CORE_ADDR
645 iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
646                         struct regcache *regcache, CORE_ADDR bp_addr,
647                         int nargs, struct value **args, CORE_ADDR sp,
648                         function_call_return_method return_method,
649                         CORE_ADDR struct_addr)
650 {
651   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
652   const bfd_byte *val;
653   bfd_byte buf[4];
654   struct type *type;
655   int i, argreg, typelen, slacklen;
656   int stackspace = 0;
657   /* Used to copy struct arguments into the stack.  */
658   CORE_ADDR struct_ptr;
659
660   /* First determine how much stack space we will need.  */
661   for (i = 0, argreg = E_1ST_ARGREG + (return_method == return_method_struct);
662        i < nargs;
663        i++)
664     {
665       type = value_type (args[i]);
666       typelen = TYPE_LENGTH (type);
667       if (typelen <= 4)
668         {
669           /* Scalars of up to 4 bytes, 
670              structs of up to 4 bytes, and
671              pointers.  */
672           if (argreg <= E_LAST_ARGREG)
673             argreg++;
674           else
675             stackspace += 4;
676         }
677       else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
678         {
679           /* long long, 
680              double, and possibly
681              structs with a single field of long long or double.  */
682           if (argreg <= E_LAST_ARGREG - 1)
683             {
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)
687                 argreg ++;
688               argreg += 2;
689             }
690           else
691             {
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);
695               stackspace += 8;
696             }
697         }
698       else
699         {
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)
704             argreg++;
705           else
706             stackspace += 4;
707           /* Care for 8-byte alignment of structs saved on stack.  */
708           stackspace += ((typelen + 7) & ~7);
709         }
710     }
711
712   /* Now copy params, in ascending order, into their assigned location
713      (either in a register or on the stack).  */
714
715   sp -= (sp % 8);       /* align */
716   struct_ptr = sp;
717   sp -= stackspace;
718   sp -= (sp % 8);       /* align again */
719   stackspace = 0;
720
721   argreg = E_1ST_ARGREG;
722   if (return_method == return_method_struct)
723     {
724       /* A function that returns a struct will consume one argreg to do so.
725        */
726       regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
727     }
728
729   for (i = 0; i < nargs; i++)
730     {
731       type = value_type (args[i]);
732       typelen = TYPE_LENGTH (type);
733       val = value_contents (args[i]);
734       if (typelen <= 4)
735         {
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)
741             {
742               /* Passed in a register.  */
743               regcache->raw_write (argreg++, buf);
744             }
745           else
746             {
747               /* Passed on the stack.  */
748               write_memory (sp + stackspace, buf, 4);
749               stackspace += 4;
750             }
751         }
752       else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
753         {
754           /* (long long), (double), or struct consisting of 
755              a single (long long) or (double).  */
756           if (argreg <= E_LAST_ARGREG - 1)
757             {
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)
761                 argreg++;
762               regcache->raw_write (argreg++, val);
763               regcache->raw_write (argreg++, val + 4);
764             }
765           else
766             {
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);
771               stackspace += 8;
772             }
773         }
774       else
775         {
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);
783           else
784             {
785               store_unsigned_integer (buf, 4, byte_order, struct_ptr);
786               write_memory (sp + stackspace, buf, 4);
787               stackspace += 4;
788             }
789         }
790     }
791
792   /* Store return address.  */
793   regcache_cooked_write_unsigned (regcache, E_LR_REGNUM, bp_addr);
794
795   /* Update stack pointer.  */
796   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
797
798   /* And that should do it.  Return the new stack pointer.  */
799   return sp;
800 }
801
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.  */
805
806 static struct gdbarch *
807 iq2000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
808 {
809   struct gdbarch *gdbarch;
810
811   /* Look up list for candidates - only one.  */
812   arches = gdbarch_list_lookup_by_info (arches, &info);
813   if (arches != NULL)
814     return arches->gdbarch;
815
816   gdbarch = gdbarch_alloc (&info, NULL);
817
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_kind_from_pc (gdbarch,
838                                        iq2000_breakpoint_kind_from_pc);
839   set_gdbarch_sw_breakpoint_from_kind (gdbarch,
840                                        iq2000_sw_breakpoint_from_kind);
841   set_gdbarch_frame_args_skip      (gdbarch, 0);
842   set_gdbarch_skip_prologue        (gdbarch, iq2000_skip_prologue);
843   set_gdbarch_inner_than           (gdbarch, core_addr_lessthan);
844   set_gdbarch_register_type (gdbarch, iq2000_register_type);
845   set_gdbarch_frame_align (gdbarch, iq2000_frame_align);
846   set_gdbarch_unwind_sp (gdbarch, iq2000_unwind_sp);
847   set_gdbarch_unwind_pc (gdbarch, iq2000_unwind_pc);
848   set_gdbarch_dummy_id (gdbarch, iq2000_dummy_id);
849   frame_base_set_default (gdbarch, &iq2000_frame_base);
850   set_gdbarch_push_dummy_call (gdbarch, iq2000_push_dummy_call);
851
852   gdbarch_init_osabi (info, gdbarch);
853
854   dwarf2_append_unwinders (gdbarch);
855   frame_unwind_append_unwinder (gdbarch, &iq2000_frame_unwind);
856
857   return gdbarch;
858 }
859
860 /* Function: _initialize_iq2000_tdep
861    Initializer function for the iq2000 module.
862    Called by gdb at start-up.  */
863
864 void
865 _initialize_iq2000_tdep (void)
866 {
867   register_gdbarch_init (bfd_arch_iq2000, iq2000_gdbarch_init);
868 }