gdb/iq2000-tdep.c

   1 /* Target-dependent code for the IQ2000 architecture, for GDB, the GNU
   2    Debugger.
   3
   4    Copyright (C) 2000, 2004, 2005, 2007, 2008, 2009
   5    Free Software Foundation, Inc.
   6
   7    Contributed by Red Hat.
   8
   9    This file is part of GDB.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  23
  24 #include "defs.h"
  25 #include "frame.h"
  26 #include "frame-base.h"
  27 #include "frame-unwind.h"
  28 #include "dwarf2-frame.h"
  29 #include "gdbtypes.h"
  30 #include "value.h"
  31 #include "dis-asm.h"
  32 #include "gdb_string.h"
  33 #include "arch-utils.h"
  34 #include "regcache.h"
  35 #include "osabi.h"
  36 #include "gdbcore.h"
  37
  38 enum gdb_regnum
  39 {
  40   E_R0_REGNUM,  E_R1_REGNUM,  E_R2_REGNUM,  E_R3_REGNUM,
  41   E_R4_REGNUM,  E_R5_REGNUM,  E_R6_REGNUM,  E_R7_REGNUM,
  42   E_R8_REGNUM,  E_R9_REGNUM,  E_R10_REGNUM, E_R11_REGNUM,
  43   E_R12_REGNUM, E_R13_REGNUM, E_R14_REGNUM, E_R15_REGNUM,
  44   E_R16_REGNUM, E_R17_REGNUM, E_R18_REGNUM, E_R19_REGNUM,
  45   E_R20_REGNUM, E_R21_REGNUM, E_R22_REGNUM, E_R23_REGNUM,
  46   E_R24_REGNUM, E_R25_REGNUM, E_R26_REGNUM, E_R27_REGNUM,
  47   E_R28_REGNUM, E_R29_REGNUM, E_R30_REGNUM, E_R31_REGNUM,
  48   E_PC_REGNUM,
  49   E_LR_REGNUM        = E_R31_REGNUM, /* Link register.  */
  50   E_SP_REGNUM        = E_R29_REGNUM, /* Stack pointer.  */
  51   E_FP_REGNUM        = E_R27_REGNUM, /* Frame pointer.  */
  52   E_FN_RETURN_REGNUM = E_R2_REGNUM,  /* Function return value register.  */
  53   E_1ST_ARGREG       = E_R4_REGNUM,  /* 1st  function arg register.  */
  54   E_LAST_ARGREG      = E_R11_REGNUM, /* Last function arg register.  */
  55   E_NUM_REGS         = E_PC_REGNUM + 1
  56 };
  57
  58 /* Use an invalid address value as 'not available' marker.  */
  59 enum { REG_UNAVAIL = (CORE_ADDR) -1 };
  60
  61 struct iq2000_frame_cache
  62 {
  63   /* Base address.  */
  64   CORE_ADDR  base;
  65   CORE_ADDR  pc;
  66   LONGEST    framesize;
  67   int        using_fp;
  68   CORE_ADDR  saved_sp;
  69   CORE_ADDR  saved_regs [E_NUM_REGS];
  70 };
  71
  72 /* Harvard methods: */
  73
  74 static CORE_ADDR
  75 insn_ptr_from_addr (CORE_ADDR addr)     /* CORE_ADDR to target pointer.  */
  76 {
  77   return addr & 0x7fffffffL;
  78 }
  79
  80 static CORE_ADDR
  81 insn_addr_from_ptr (CORE_ADDR ptr)      /* target_pointer to CORE_ADDR.  */
  82 {
  83   return (ptr & 0x7fffffffL) | 0x80000000L;
  84 }
  85
  86 /* Function: pointer_to_address
  87    Convert a target pointer to an address in host (CORE_ADDR) format. */
  88
  89 static CORE_ADDR
  90 iq2000_pointer_to_address (struct gdbarch *gdbarch,
  91                            struct type * type, const gdb_byte * buf)
  92 {
  93   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
  94   CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
  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 type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
 112
 113   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
 114     addr = insn_ptr_from_addr (addr);
 115   store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
 116 }
 117
 118 /* Real register methods: */
 119
 120 /* Function: register_name
 121    Returns the name of the iq2000 register number N.  */
 122
 123 static const char *
 124 iq2000_register_name (struct gdbarch *gdbarch, int regnum)
 125 {
 126   static const char * names[E_NUM_REGS] =
 127     {
 128       "r0",  "r1",  "r2",  "r3",  "r4",
 129       "r5",  "r6",  "r7",  "r8",  "r9",
 130       "r10", "r11", "r12", "r13", "r14",
 131       "r15", "r16", "r17", "r18", "r19",
 132       "r20", "r21", "r22", "r23", "r24",
 133       "r25", "r26", "r27", "r28", "r29",
 134       "r30", "r31",
 135       "pc"
 136     };
 137   if (regnum < 0 || regnum >= E_NUM_REGS)
 138     return NULL;
 139   return names[regnum];
 140 }
 141
 142 /* Prologue analysis methods:  */
 143
 144 /* ADDIU insn (001001 rs(5) rt(5) imm(16)).  */
 145 #define INSN_IS_ADDIU(X)        (((X) & 0xfc000000) == 0x24000000)
 146 #define ADDIU_REG_SRC(X)        (((X) & 0x03e00000) >> 21)
 147 #define ADDIU_REG_TGT(X)        (((X) & 0x001f0000) >> 16)
 148 #define ADDIU_IMMEDIATE(X)      ((signed short) ((X) & 0x0000ffff))
 149
 150 /* "MOVE" (OR) insn (000000 rs(5) rt(5) rd(5) 00000 100101).  */
 151 #define INSN_IS_MOVE(X)         (((X) & 0xffe007ff) == 0x00000025)
 152 #define MOVE_REG_SRC(X)         (((X) & 0x001f0000) >> 16)
 153 #define MOVE_REG_TGT(X)         (((X) & 0x0000f800) >> 11)
 154
 155 /* STORE WORD insn (101011 rs(5) rt(5) offset(16)).  */
 156 #define INSN_IS_STORE_WORD(X)   (((X) & 0xfc000000) == 0xac000000)
 157 #define SW_REG_INDEX(X)         (((X) & 0x03e00000) >> 21)
 158 #define SW_REG_SRC(X)           (((X) & 0x001f0000) >> 16)
 159 #define SW_OFFSET(X)            ((signed short) ((X) & 0x0000ffff))
 160
 161 /* Function: find_last_line_symbol
 162
 163    Given an address range, first find a line symbol corresponding to
 164    the starting address.  Then find the last line symbol within the
 165    range that has a line number less than or equal to the first line.
 166
 167    For optimized code with code motion, this finds the last address
 168    for the lowest-numbered line within the address range.  */
 169
 170 static struct symtab_and_line
 171 find_last_line_symbol (CORE_ADDR start, CORE_ADDR end, int notcurrent)
 172 {
 173   struct symtab_and_line sal = find_pc_line (start, notcurrent);
 174   struct symtab_and_line best_sal = sal;
 175
 176   if (sal.pc == 0 || sal.line == 0 || sal.end == 0)
 177     return sal;
 178
 179   do
 180     {
 181       if (sal.line && sal.line <= best_sal.line)
 182         best_sal = sal;
 183       sal = find_pc_line (sal.end, notcurrent);
 184     }
 185   while (sal.pc && sal.pc < end);
 186
 187   return best_sal;
 188 }
 189
 190 /* Function: scan_prologue
 191    Decode the instructions within the given address range.
 192    Decide when we must have reached the end of the function prologue.
 193    If a frame_info pointer is provided, fill in its prologue information.
 194
 195    Returns the address of the first instruction after the prologue.  */
 196
 197 static CORE_ADDR
 198 iq2000_scan_prologue (CORE_ADDR scan_start,
 199                       CORE_ADDR scan_end,
 200                       struct frame_info *fi,
 201                       struct iq2000_frame_cache *cache)
 202 {
 203   struct symtab_and_line sal;
 204   CORE_ADDR pc;
 205   CORE_ADDR loop_end;
 206   int found_store_lr = 0;
 207   int found_decr_sp = 0;
 208   int srcreg;
 209   int tgtreg;
 210   signed short offset;
 211
 212   if (scan_end == (CORE_ADDR) 0)
 213     {
 214       loop_end = scan_start + 100;
 215       sal.end = sal.pc = 0;
 216     }
 217   else
 218     {
 219       loop_end = scan_end;
 220       if (fi)
 221         sal = find_last_line_symbol (scan_start, scan_end, 0);
 222     }
 223
 224   /* Saved registers:
 225      We first have to save the saved register's offset, and
 226      only later do we compute its actual address.  Since the
 227      offset can be zero, we must first initialize all the
 228      saved regs to minus one (so we can later distinguish
 229      between one that's not saved, and one that's saved at zero). */
 230   for (srcreg = 0; srcreg < E_NUM_REGS; srcreg ++)
 231     cache->saved_regs[srcreg] = -1;
 232   cache->using_fp = 0;
 233   cache->framesize = 0;
 234
 235   for (pc = scan_start; pc < loop_end; pc += 4)
 236     {
 237       LONGEST insn = read_memory_unsigned_integer (pc, 4);
 238       /* Skip any instructions writing to (sp) or decrementing the
 239          SP. */
 240       if ((insn & 0xffe00000) == 0xac200000)
 241         {
 242           /* sw using SP/%1 as base.  */
 243           /* LEGACY -- from assembly-only port.  */
 244           tgtreg = ((insn >> 16) & 0x1f);
 245           if (tgtreg >= 0 && tgtreg < E_NUM_REGS)
 246             cache->saved_regs[tgtreg] = -((signed short) (insn & 0xffff));
 247
 248           if (tgtreg == E_LR_REGNUM)
 249             found_store_lr = 1;
 250           continue;
 251         }
 252
 253       if ((insn & 0xffff8000) == 0x20218000)
 254         {
 255           /* addi %1, %1, -N == addi %sp, %sp, -N */
 256           /* LEGACY -- from assembly-only port */
 257           found_decr_sp = 1;
 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 (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 iq2000_frame_cache *cache;
 365   CORE_ADDR current_pc;
 366   int i;
 367
 368   if (*this_cache)
 369     return *this_cache;
 370
 371   cache = FRAME_OBSTACK_ZALLOC (struct iq2000_frame_cache);
 372   iq2000_init_frame_cache (cache);
 373   *this_cache = cache;
 374
 375   cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
 376   //if (cache->base == 0)
 377     //return cache;
 378
 379   current_pc = get_frame_pc (this_frame);
 380   find_pc_partial_function (current_pc, NULL, &cache->pc, NULL);
 381   if (cache->pc != 0)
 382     iq2000_scan_prologue (cache->pc, current_pc, this_frame, cache);
 383   if (!cache->using_fp)
 384     cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 385
 386   cache->saved_sp = cache->base + cache->framesize;
 387
 388   for (i = 0; i < E_NUM_REGS; i++)
 389     if (cache->saved_regs[i] != -1)
 390       cache->saved_regs[i] += cache->base;
 391
 392   return cache;
 393 }
 394
 395 static struct value *
 396 iq2000_frame_prev_register (struct frame_info *this_frame, void **this_cache,
 397                             int regnum)
 398 {
 399   struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame, 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, this_cache);
 419
 420   /* This marks the outermost frame.  */
 421   if (cache->base == 0)
 422     return;
 423
 424   *this_id = frame_id_build (cache->saved_sp, cache->pc);
 425 }
 426
 427 static const struct frame_unwind iq2000_frame_unwind = {
 428   NORMAL_FRAME,
 429   iq2000_frame_this_id,
 430   iq2000_frame_prev_register,
 431   NULL,
 432   default_frame_sniffer
 433 };
 434
 435 static CORE_ADDR
 436 iq2000_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 437 {
 438   return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
 439 }
 440
 441 static CORE_ADDR
 442 iq2000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 443 {
 444   return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
 445 }
 446
 447 static struct frame_id
 448 iq2000_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 449 {
 450   CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 451   return frame_id_build (sp, get_frame_pc (this_frame));
 452 }
 453
 454 static CORE_ADDR
 455 iq2000_frame_base_address (struct frame_info *this_frame, void **this_cache)
 456 {
 457   struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame, this_cache);
 458
 459   return cache->base;
 460 }
 461
 462 static const struct frame_base iq2000_frame_base = {
 463   &iq2000_frame_unwind,
 464   iq2000_frame_base_address,
 465   iq2000_frame_base_address,
 466   iq2000_frame_base_address
 467 };
 468
 469 static const unsigned char *
 470 iq2000_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
 471                            int *lenptr)
 472 {
 473   static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d };
 474   static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 };
 475
 476   if ((*pcptr & 3) != 0)
 477     error ("breakpoint_from_pc: invalid breakpoint address 0x%lx",
 478            (long) *pcptr);
 479
 480   *lenptr = 4;
 481   return (gdbarch_byte_order (gdbarch)
 482           == BFD_ENDIAN_BIG) ? big_breakpoint : little_breakpoint;
 483 }
 484
 485 /* Target function return value methods: */
 486
 487 /* Function: store_return_value
 488    Copy the function return value from VALBUF into the
 489    proper location for a function return.  */
 490
 491 static void
 492 iq2000_store_return_value (struct type *type, struct regcache *regcache,
 493                            const void *valbuf)
 494 {
 495   int len = TYPE_LENGTH (type);
 496   int regno = E_FN_RETURN_REGNUM;
 497
 498   while (len > 0)
 499     {
 500       char buf[4];
 501       int size = len % 4 ?: 4;
 502
 503       memset (buf, 0, 4);
 504       memcpy (buf + 4 - size, valbuf, size);
 505       regcache_raw_write (regcache, regno++, buf);
 506       len -= size;
 507       valbuf = ((char *) valbuf) + size;
 508     }
 509 }
 510
 511 /* Function: use_struct_convention
 512    Returns non-zero if the given struct type will be returned using
 513    a special convention, rather than the normal function return method.  */
 514
 515 static int
 516 iq2000_use_struct_convention (struct type *type)
 517 {
 518   return ((TYPE_CODE (type) == TYPE_CODE_STRUCT)
 519           || (TYPE_CODE (type) == TYPE_CODE_UNION))
 520          && TYPE_LENGTH (type) > 8;
 521 }
 522
 523 /* Function: extract_return_value
 524    Copy the function's return value into VALBUF.
 525    This function is called only in the context of "target function calls",
 526    ie. when the debugger forces a function to be called in the child, and
 527    when the debugger forces a function to return prematurely via the
 528    "return" command.  */
 529
 530 static void
 531 iq2000_extract_return_value (struct type *type, struct regcache *regcache,
 532                              void *valbuf)
 533 {
 534   /* If the function's return value is 8 bytes or less, it is
 535      returned in a register, and if larger than 8 bytes, it is
 536      returned in a stack location which is pointed to by the same
 537      register.  */
 538   int len = TYPE_LENGTH (type);
 539
 540   if (len <= (2 * 4))
 541     {
 542       int regno = E_FN_RETURN_REGNUM;
 543
 544       /* Return values of <= 8 bytes are returned in
 545          FN_RETURN_REGNUM.  */
 546       while (len > 0)
 547         {
 548           ULONGEST tmp;
 549           int size = len % 4 ?: 4;
 550
 551           /* By using store_unsigned_integer we avoid having to
 552              do anything special for small big-endian values.  */
 553           regcache_cooked_read_unsigned (regcache, regno++, &tmp);
 554           store_unsigned_integer (valbuf, size, tmp);
 555           len -= size;
 556           valbuf = ((char *) valbuf) + size;
 557         }
 558     }
 559   else
 560     {
 561       /* Return values > 8 bytes are returned in memory,
 562          pointed to by FN_RETURN_REGNUM.  */
 563       ULONGEST return_buffer;
 564       regcache_cooked_read_unsigned (regcache, E_FN_RETURN_REGNUM,
 565                                      &return_buffer);
 566       read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
 567     }
 568 }
 569
 570 static enum return_value_convention
 571 iq2000_return_value (struct gdbarch *gdbarch, struct type *func_type,
 572                      struct type *type, struct regcache *regcache,
 573                      gdb_byte *readbuf, const gdb_byte *writebuf)
 574 {
 575   if (iq2000_use_struct_convention (type))
 576     return RETURN_VALUE_STRUCT_CONVENTION;
 577   if (writebuf)
 578     iq2000_store_return_value (type, regcache, writebuf);
 579   else if (readbuf)
 580     iq2000_extract_return_value (type, regcache, readbuf);
 581   return RETURN_VALUE_REGISTER_CONVENTION;
 582 }
 583
 584 /* Function: register_virtual_type
 585    Returns the default type for register N.  */
 586
 587 static struct type *
 588 iq2000_register_type (struct gdbarch *gdbarch, int regnum)
 589 {
 590   return builtin_type_int32;
 591 }
 592
 593 static CORE_ADDR
 594 iq2000_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
 595 {
 596   /* This is the same frame alignment used by gcc.  */
 597   return ((sp + 7) & ~7);
 598 }
 599
 600 /* Convenience function to check 8-byte types for being a scalar type
 601    or a struct with only one long long or double member. */
 602 static int
 603 iq2000_pass_8bytetype_by_address (struct type *type)
 604 {
 605   struct type *ftype;
 606
 607   /* Skip typedefs.  */
 608   while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
 609     type = TYPE_TARGET_TYPE (type);
 610   /* Non-struct and non-union types are always passed by value.  */
 611   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 612       && TYPE_CODE (type) != TYPE_CODE_UNION)
 613     return 0;
 614   /* Structs with more than 1 field are always passed by address.  */
 615   if (TYPE_NFIELDS (type) != 1)
 616     return 1;
 617   /* Get field type.  */
 618   ftype = (TYPE_FIELDS (type))[0].type;
 619   /* The field type must have size 8, otherwise pass by address.  */
 620   if (TYPE_LENGTH (ftype) != 8)
 621     return 1;
 622   /* Skip typedefs of field type.  */
 623   while (TYPE_CODE (ftype) == TYPE_CODE_TYPEDEF)
 624     ftype = TYPE_TARGET_TYPE (ftype);
 625   /* If field is int or float, pass by value.  */
 626   if (TYPE_CODE (ftype) == TYPE_CODE_FLT
 627       || TYPE_CODE (ftype) == TYPE_CODE_INT)
 628     return 0;
 629   /* Everything else, pass by address. */
 630   return 1;
 631 }
 632
 633 static CORE_ADDR
 634 iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 635                         struct regcache *regcache, CORE_ADDR bp_addr,
 636                         int nargs, struct value **args, CORE_ADDR sp,
 637                         int struct_return, CORE_ADDR struct_addr)
 638 {
 639   const bfd_byte *val;
 640   bfd_byte buf[4];
 641   struct type *type;
 642   int i, argreg, typelen, slacklen;
 643   int stackspace = 0;
 644   /* Used to copy struct arguments into the stack. */
 645   CORE_ADDR struct_ptr;
 646
 647   /* First determine how much stack space we will need. */
 648   for (i = 0, argreg = E_1ST_ARGREG + (struct_return != 0); i < nargs; i++)
 649     {
 650       type = value_type (args[i]);
 651       typelen = TYPE_LENGTH (type);
 652       if (typelen <= 4)
 653         {
 654           /* Scalars of up to 4 bytes,
 655              structs of up to 4 bytes, and
 656              pointers.  */
 657           if (argreg <= E_LAST_ARGREG)
 658             argreg++;
 659           else
 660             stackspace += 4;
 661         }
 662       else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
 663         {
 664           /* long long,
 665              double, and possibly
 666              structs with a single field of long long or double. */
 667           if (argreg <= E_LAST_ARGREG - 1)
 668             {
 669               /* 8-byte arg goes into a register pair
 670                  (must start with an even-numbered reg) */
 671               if (((argreg - E_1ST_ARGREG) % 2) != 0)
 672                 argreg ++;
 673               argreg += 2;
 674             }
 675           else
 676             {
 677               argreg = E_LAST_ARGREG + 1;       /* no more argregs. */
 678               /* 8-byte arg goes on stack, must be 8-byte aligned. */
 679               stackspace = ((stackspace + 7) & ~7);
 680               stackspace += 8;
 681             }
 682         }
 683       else
 684         {
 685           /* Structs are passed as pointer to a copy of the struct.
 686              So we need room on the stack for a copy of the struct
 687              plus for the argument pointer. */
 688           if (argreg <= E_LAST_ARGREG)
 689             argreg++;
 690           else
 691             stackspace += 4;
 692           /* Care for 8-byte alignment of structs saved on stack.  */
 693           stackspace += ((typelen + 7) & ~7);
 694         }
 695     }
 696
 697   /* Now copy params, in ascending order, into their assigned location
 698      (either in a register or on the stack). */
 699
 700   sp -= (sp % 8);       /* align */
 701   struct_ptr = sp;
 702   sp -= stackspace;
 703   sp -= (sp % 8);       /* align again */
 704   stackspace = 0;
 705
 706   argreg = E_1ST_ARGREG;
 707   if (struct_return)
 708     {
 709       /* A function that returns a struct will consume one argreg to do so.
 710        */
 711       regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
 712     }
 713
 714   for (i = 0; i < nargs; i++)
 715     {
 716       type = value_type (args[i]);
 717       typelen = TYPE_LENGTH (type);
 718       val = value_contents (args[i]);
 719       if (typelen <= 4)
 720         {
 721           /* Char, short, int, float, pointer, and structs <= four bytes. */
 722           slacklen = (4 - (typelen % 4)) % 4;
 723           memset (buf, 0, sizeof (buf));
 724           memcpy (buf + slacklen, val, typelen);
 725           if (argreg <= E_LAST_ARGREG)
 726             {
 727               /* Passed in a register. */
 728               regcache_raw_write (regcache, argreg++, buf);
 729             }
 730           else
 731             {
 732               /* Passed on the stack. */
 733               write_memory (sp + stackspace, buf, 4);
 734               stackspace += 4;
 735             }
 736         }
 737       else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
 738         {
 739           /* (long long), (double), or struct consisting of
 740              a single (long long) or (double). */
 741           if (argreg <= E_LAST_ARGREG - 1)
 742             {
 743               /* 8-byte arg goes into a register pair
 744                  (must start with an even-numbered reg) */
 745               if (((argreg - E_1ST_ARGREG) % 2) != 0)
 746                 argreg++;
 747               regcache_raw_write (regcache, argreg++, val);
 748               regcache_raw_write (regcache, argreg++, val + 4);
 749             }
 750           else
 751             {
 752               /* 8-byte arg goes on stack, must be 8-byte aligned. */
 753               argreg = E_LAST_ARGREG + 1;       /* no more argregs. */
 754               stackspace = ((stackspace + 7) & ~7);
 755               write_memory (sp + stackspace, val, typelen);
 756               stackspace += 8;
 757             }
 758         }
 759       else
 760         {
 761           /* Store struct beginning at the upper end of the previously
 762              computed stack space.  Then store the address of the struct
 763              using the usual rules for a 4 byte value.  */
 764           struct_ptr -= ((typelen + 7) & ~7);
 765           write_memory (struct_ptr, val, typelen);
 766           if (argreg <= E_LAST_ARGREG)
 767             regcache_cooked_write_unsigned (regcache, argreg++, struct_ptr);
 768           else
 769             {
 770               store_unsigned_integer (buf, 4, struct_ptr);
 771               write_memory (sp + stackspace, buf, 4);
 772               stackspace += 4;
 773             }
 774         }
 775     }
 776
 777   /* Store return address. */
 778   regcache_cooked_write_unsigned (regcache, E_LR_REGNUM, bp_addr);
 779
 780   /* Update stack pointer.  */
 781   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
 782
 783   /* And that should do it.  Return the new stack pointer. */
 784   return sp;
 785 }
 786
 787 /* Function: gdbarch_init
 788    Initializer function for the iq2000 gdbarch vector.
 789    Called by gdbarch.  Sets up the gdbarch vector(s) for this target.  */
 790
 791 static struct gdbarch *
 792 iq2000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 793 {
 794   struct gdbarch *gdbarch;
 795
 796   /* Look up list for candidates - only one.  */
 797   arches = gdbarch_list_lookup_by_info (arches, &info);
 798   if (arches != NULL)
 799     return arches->gdbarch;
 800
 801   gdbarch = gdbarch_alloc (&info, NULL);
 802
 803   set_gdbarch_num_regs             (gdbarch, E_NUM_REGS);
 804   set_gdbarch_num_pseudo_regs      (gdbarch, 0);
 805   set_gdbarch_sp_regnum            (gdbarch, E_SP_REGNUM);
 806   set_gdbarch_pc_regnum            (gdbarch, E_PC_REGNUM);
 807   set_gdbarch_register_name        (gdbarch, iq2000_register_name);
 808   set_gdbarch_address_to_pointer   (gdbarch, iq2000_address_to_pointer);
 809   set_gdbarch_pointer_to_address   (gdbarch, iq2000_pointer_to_address);
 810   set_gdbarch_ptr_bit              (gdbarch, 4 * TARGET_CHAR_BIT);
 811   set_gdbarch_short_bit            (gdbarch, 2 * TARGET_CHAR_BIT);
 812   set_gdbarch_int_bit              (gdbarch, 4 * TARGET_CHAR_BIT);
 813   set_gdbarch_long_bit             (gdbarch, 4 * TARGET_CHAR_BIT);
 814   set_gdbarch_long_long_bit        (gdbarch, 8 * TARGET_CHAR_BIT);
 815   set_gdbarch_float_bit            (gdbarch, 4 * TARGET_CHAR_BIT);
 816   set_gdbarch_double_bit           (gdbarch, 8 * TARGET_CHAR_BIT);
 817   set_gdbarch_long_double_bit      (gdbarch, 8 * TARGET_CHAR_BIT);
 818   set_gdbarch_float_format         (gdbarch, floatformats_ieee_single);
 819   set_gdbarch_double_format        (gdbarch, floatformats_ieee_double);
 820   set_gdbarch_long_double_format   (gdbarch, floatformats_ieee_double);
 821   set_gdbarch_return_value         (gdbarch, iq2000_return_value);
 822   set_gdbarch_breakpoint_from_pc   (gdbarch, iq2000_breakpoint_from_pc);
 823   set_gdbarch_frame_args_skip      (gdbarch, 0);
 824   set_gdbarch_skip_prologue        (gdbarch, iq2000_skip_prologue);
 825   set_gdbarch_inner_than           (gdbarch, core_addr_lessthan);
 826   set_gdbarch_print_insn           (gdbarch, print_insn_iq2000);
 827   set_gdbarch_register_type (gdbarch, iq2000_register_type);
 828   set_gdbarch_frame_align (gdbarch, iq2000_frame_align);
 829   set_gdbarch_unwind_sp (gdbarch, iq2000_unwind_sp);
 830   set_gdbarch_unwind_pc (gdbarch, iq2000_unwind_pc);
 831   set_gdbarch_dummy_id (gdbarch, iq2000_dummy_id);
 832   frame_base_set_default (gdbarch, &iq2000_frame_base);
 833   set_gdbarch_push_dummy_call (gdbarch, iq2000_push_dummy_call);
 834
 835   gdbarch_init_osabi (info, gdbarch);
 836
 837   dwarf2_append_unwinders (gdbarch);
 838   frame_unwind_append_unwinder (gdbarch, &iq2000_frame_unwind);
 839
 840   return gdbarch;
 841 }
 842
 843 /* Function: _initialize_iq2000_tdep
 844    Initializer function for the iq2000 module.
 845    Called by gdb at start-up. */
 846
 847 /* Provide a prototype to silence -Wmissing-prototypes.  */
 848 extern initialize_file_ftype _initialize_iq2000_tdep;
 849
 850 void
 851 _initialize_iq2000_tdep (void)
 852 {
 853   register_gdbarch_init (bfd_arch_iq2000, iq2000_gdbarch_init);
 854 }