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 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 2 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, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  23    Boston, MA 02110-1301, USA.  */
  24
  25 #include "defs.h"
  26 #include "frame.h"
  27 #include "frame-base.h"
  28 #include "frame-unwind.h"
  29 #include "dwarf2-frame.h"
  30 #include "gdbtypes.h"
  31 #include "value.h"
  32 #include "dis-asm.h"
  33 #include "gdb_string.h"
  34 #include "arch-utils.h"
  35 #include "regcache.h"
  36 #include "osabi.h"
  37 #include "gdbcore.h"
  38
  39 enum gdb_regnum
  40 {
  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,
  49   E_PC_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
  57 };
  58
  59 /* Use an invalid address value as 'not available' marker.  */
  60 enum { REG_UNAVAIL = (CORE_ADDR) -1 };
  61
  62 struct iq2000_frame_cache
  63 {
  64   /* Base address.  */
  65   CORE_ADDR  base;
  66   CORE_ADDR  pc;
  67   LONGEST    framesize;
  68   int        using_fp;
  69   CORE_ADDR  saved_sp;
  70   CORE_ADDR  saved_regs [E_NUM_REGS];
  71 };
  72
  73 /* Harvard methods: */
  74
  75 static CORE_ADDR
  76 insn_ptr_from_addr (CORE_ADDR addr)     /* CORE_ADDR to target pointer.  */
  77 {
  78   return addr & 0x7fffffffL;
  79 }
  80
  81 static CORE_ADDR
  82 insn_addr_from_ptr (CORE_ADDR ptr)      /* target_pointer to CORE_ADDR.  */
  83 {
  84   return (ptr & 0x7fffffffL) | 0x80000000L;
  85 }
  86
  87 /* Function: pointer_to_address
  88    Convert a target pointer to an address in host (CORE_ADDR) format. */
  89
  90 static CORE_ADDR
  91 iq2000_pointer_to_address (struct type * type, const void * 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_FLAGS (TYPE_TARGET_TYPE (type)) & TYPE_FLAG_CODE_SPACE) != 0)
  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 type *type, void *buf, CORE_ADDR addr)
 109 {
 110   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
 111
 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);
 115 }
 116
 117 /* Real register methods: */
 118
 119 /* Function: register_name
 120    Returns the name of the iq2000 register number N.  */
 121
 122 static const char *
 123 iq2000_register_name (int regnum)
 124 {
 125   static const char * names[E_NUM_REGS] =
 126     {
 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",
 133       "r30", "r31",
 134       "pc"
 135     };
 136   if (regnum < 0 || regnum >= E_NUM_REGS)
 137     return NULL;
 138   return names[regnum];
 139 }
 140
 141 /* Prologue analysis methods:  */
 142
 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))
 148
 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)
 153
 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))
 159
 160 /* Function: find_last_line_symbol
 161
 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.
 165
 166    For optimized code with code motion, this finds the last address
 167    for the lowest-numbered line within the address range.  */
 168
 169 static struct symtab_and_line
 170 find_last_line_symbol (CORE_ADDR start, CORE_ADDR end, int notcurrent)
 171 {
 172   struct symtab_and_line sal = find_pc_line (start, notcurrent);
 173   struct symtab_and_line best_sal = sal;
 174
 175   if (sal.pc == 0 || sal.line == 0 || sal.end == 0)
 176     return sal;
 177
 178   do
 179     {
 180       if (sal.line && sal.line <= best_sal.line)
 181         best_sal = sal;
 182       sal = find_pc_line (sal.end, notcurrent);
 183     }
 184   while (sal.pc && sal.pc < end);
 185
 186   return best_sal;
 187 }
 188
 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.
 193
 194    Returns the address of the first instruction after the prologue.  */
 195
 196 static CORE_ADDR
 197 iq2000_scan_prologue (CORE_ADDR scan_start,
 198                       CORE_ADDR scan_end,
 199                       struct frame_info *fi,
 200                       struct iq2000_frame_cache *cache)
 201 {
 202   struct symtab_and_line sal;
 203   CORE_ADDR pc;
 204   CORE_ADDR loop_end;
 205   int found_store_lr = 0;
 206   int found_decr_sp = 0;
 207   int srcreg;
 208   int tgtreg;
 209   signed short offset;
 210
 211   if (scan_end == (CORE_ADDR) 0)
 212     {
 213       loop_end = scan_start + 100;
 214       sal.end = sal.pc = 0;
 215     }
 216   else
 217     {
 218       loop_end = scan_end;
 219       if (fi)
 220         sal = find_last_line_symbol (scan_start, scan_end, 0);
 221     }
 222
 223   /* Saved registers:
 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;
 231   cache->using_fp = 0;
 232   cache->framesize = 0;
 233
 234   for (pc = scan_start; pc < loop_end; pc += 4)
 235     {
 236       LONGEST insn = read_memory_unsigned_integer (pc, 4);
 237       /* Skip any instructions writing to (sp) or decrementing the
 238          SP. */
 239       if ((insn & 0xffe00000) == 0xac200000)
 240         {
 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));
 246
 247           if (tgtreg == E_LR_REGNUM)
 248             found_store_lr = 1;
 249           continue;
 250         }
 251
 252       if ((insn & 0xffff8000) == 0x20218000)
 253         {
 254           /* addi %1, %1, -N == addi %sp, %sp, -N */
 255           /* LEGACY -- from assembly-only port */
 256           found_decr_sp = 1;
 257           cache->framesize = -((signed short) (insn & 0xffff));
 258           continue;
 259         }
 260
 261       if (INSN_IS_ADDIU (insn))
 262         {
 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;
 268           continue;
 269         }
 270
 271       if (INSN_IS_STORE_WORD (insn))
 272         {
 273           srcreg = SW_REG_SRC (insn);
 274           tgtreg = SW_REG_INDEX (insn);
 275           offset = SW_OFFSET (insn);
 276
 277           if (tgtreg == E_SP_REGNUM || tgtreg == E_FP_REGNUM)
 278             {
 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;
 282               continue;
 283             }
 284         }
 285
 286       if (INSN_IS_MOVE (insn))
 287         {
 288           srcreg = MOVE_REG_SRC (insn);
 289           tgtreg = MOVE_REG_TGT (insn);
 290
 291           if (srcreg == E_SP_REGNUM && tgtreg == E_FP_REGNUM)
 292             {
 293               /* Copy sp to fp.  */
 294               cache->using_fp = 1;
 295               continue;
 296             }
 297         }
 298
 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.  */
 302
 303       if (fi && sal.end && (pc < sal.end)) /* Keep scanning.  */
 304         continue;
 305       else /* bail */
 306         break;
 307     }
 308
 309   return pc;
 310 }
 311
 312 static void
 313 iq2000_init_frame_cache (struct iq2000_frame_cache *cache)
 314 {
 315   int i;
 316
 317   cache->base = 0;
 318   cache->framesize = 0;
 319   cache->using_fp = 0;
 320   cache->saved_sp = 0;
 321   for (i = 0; i < E_NUM_REGS; i++)
 322     cache->saved_regs[i] = -1;
 323 }
 324
 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.
 329
 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.  */
 334
 335 static CORE_ADDR
 336 iq2000_skip_prologue (CORE_ADDR pc)
 337 {
 338   CORE_ADDR func_addr = 0 , func_end = 0;
 339
 340   if (find_pc_partial_function (pc, NULL, & func_addr, & func_end))
 341     {
 342       struct symtab_and_line sal;
 343       struct iq2000_frame_cache cache;
 344
 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.  */
 349         return sal.end;
 350
 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);
 354     }
 355
 356   /* No function symbol -- just return the PC.  */
 357   return (CORE_ADDR) pc;
 358 }
 359
 360 static struct iq2000_frame_cache *
 361 iq2000_frame_cache (struct frame_info *next_frame, void **this_cache)
 362 {
 363   struct iq2000_frame_cache *cache;
 364   CORE_ADDR current_pc;
 365   int i;
 366
 367   if (*this_cache)
 368     return *this_cache;
 369
 370   cache = FRAME_OBSTACK_ZALLOC (struct iq2000_frame_cache);
 371   iq2000_init_frame_cache (cache);
 372   *this_cache = cache;
 373
 374   cache->base = frame_unwind_register_unsigned (next_frame, E_FP_REGNUM);
 375   //if (cache->base == 0)
 376     //return cache;
 377
 378   current_pc = frame_pc_unwind (next_frame);
 379   find_pc_partial_function (current_pc, NULL, &cache->pc, NULL);
 380   if (cache->pc != 0)
 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);
 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 void
 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)
 399 {
 400   struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
 401   if (regnum == E_SP_REGNUM && cache->saved_sp)
 402     {
 403       *optimizedp = 0;
 404       *lvalp = not_lval;
 405       *addrp = 0;
 406       *realnump = -1;
 407       if (valuep)
 408         store_unsigned_integer (valuep, 4, cache->saved_sp);
 409       return;
 410     }
 411
 412   if (regnum == E_PC_REGNUM)
 413     regnum = E_LR_REGNUM;
 414
 415   if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != -1)
 416     {
 417       *optimizedp = 0;
 418       *lvalp = lval_memory;
 419       *addrp = cache->saved_regs[regnum];
 420       *realnump = -1;
 421       if (valuep)
 422         read_memory (*addrp, valuep, register_size (current_gdbarch, regnum));
 423       return;
 424     }
 425
 426   *optimizedp = 0;
 427   *lvalp = lval_register;
 428   *addrp = 0;
 429   *realnump = regnum;
 430   if (valuep)
 431     frame_unwind_register (next_frame, (*realnump), valuep);
 432 }
 433
 434 static void
 435 iq2000_frame_this_id (struct frame_info *next_frame, void **this_cache,
 436                       struct frame_id *this_id)
 437 {
 438   struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
 439
 440   /* This marks the outermost frame.  */
 441   if (cache->base == 0)
 442     return;
 443
 444   *this_id = frame_id_build (cache->saved_sp, cache->pc);
 445 }
 446
 447 static const struct frame_unwind iq2000_frame_unwind = {
 448   NORMAL_FRAME,
 449   iq2000_frame_this_id,
 450   iq2000_frame_prev_register
 451 };
 452
 453 static const struct frame_unwind *
 454 iq2000_frame_sniffer (struct frame_info *next_frame)
 455 {
 456   return &iq2000_frame_unwind;
 457 }
 458
 459 static CORE_ADDR
 460 iq2000_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 461 {
 462   return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
 463 }
 464
 465 static CORE_ADDR
 466 iq2000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 467 {
 468   return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
 469 }
 470
 471 static struct frame_id
 472 iq2000_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
 473 {
 474   return frame_id_build (iq2000_unwind_sp (gdbarch, next_frame),
 475                          frame_pc_unwind (next_frame));
 476 }
 477
 478 static CORE_ADDR
 479 iq2000_frame_base_address (struct frame_info *next_frame, void **this_cache)
 480 {
 481   struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
 482
 483   return cache->base;
 484 }
 485
 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
 491 };
 492
 493 static const unsigned char *
 494 iq2000_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 495 {
 496   static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d };
 497   static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 };
 498
 499   if ((*pcptr & 3) != 0)
 500     error ("breakpoint_from_pc: invalid breakpoint address 0x%lx",
 501            (long) *pcptr);
 502
 503   *lenptr = 4;
 504   return (gdbarch_byte_order (current_gdbarch)
 505           == BFD_ENDIAN_BIG) ? big_breakpoint
 506                                                : little_breakpoint;
 507 }
 508
 509 /* Target function return value methods: */
 510
 511 /* Function: store_return_value
 512    Copy the function return value from VALBUF into the
 513    proper location for a function return.  */
 514
 515 static void
 516 iq2000_store_return_value (struct type *type, struct regcache *regcache,
 517                            const void *valbuf)
 518 {
 519   int len = TYPE_LENGTH (type);
 520   int regno = E_FN_RETURN_REGNUM;
 521
 522   while (len > 0)
 523     {
 524       char buf[4];
 525       int size = len % 4 ?: 4;
 526
 527       memset (buf, 0, 4);
 528       memcpy (buf + 4 - size, valbuf, size);
 529       regcache_raw_write (regcache, regno++, buf);
 530       len -= size;
 531       valbuf = ((char *) valbuf) + size;
 532     }
 533 }
 534
 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.  */
 538
 539 static int
 540 iq2000_use_struct_convention (struct type *type)
 541 {
 542   return ((TYPE_CODE (type) == TYPE_CODE_STRUCT)
 543           || (TYPE_CODE (type) == TYPE_CODE_UNION))
 544          && TYPE_LENGTH (type) > 8;
 545 }
 546
 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
 552    "return" command.  */
 553
 554 static void
 555 iq2000_extract_return_value (struct type *type, struct regcache *regcache,
 556                              void *valbuf)
 557 {
 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
 561      register.  */
 562   CORE_ADDR return_buffer;
 563   int len = TYPE_LENGTH (type);
 564
 565   if (len <= (2 * 4))
 566     {
 567       int regno = E_FN_RETURN_REGNUM;
 568
 569       /* Return values of <= 8 bytes are returned in
 570          FN_RETURN_REGNUM.  */
 571       while (len > 0)
 572         {
 573           ULONGEST tmp;
 574           int size = len % 4 ?: 4;
 575
 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);
 580           len -= size;
 581           valbuf = ((char *) valbuf) + size;
 582         }
 583     }
 584   else
 585     {
 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));
 590     }
 591 }
 592
 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)
 597 {
 598   if (iq2000_use_struct_convention (type))
 599     return RETURN_VALUE_STRUCT_CONVENTION;
 600   if (writebuf)
 601     iq2000_store_return_value (type, regcache, writebuf);
 602   else if (readbuf)
 603     iq2000_extract_return_value (type, regcache, readbuf);
 604   return RETURN_VALUE_REGISTER_CONVENTION;
 605 }
 606
 607 /* Function: register_virtual_type
 608    Returns the default type for register N.  */
 609
 610 static struct type *
 611 iq2000_register_type (struct gdbarch *gdbarch, int regnum)
 612 {
 613   return builtin_type_int32;
 614 }
 615
 616 static CORE_ADDR
 617 iq2000_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
 618 {
 619   /* This is the same frame alignment used by gcc.  */
 620   return ((sp + 7) & ~7);
 621 }
 622
 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. */
 625 static int
 626 iq2000_pass_8bytetype_by_address (struct type *type)
 627 {
 628   struct type *ftype;
 629
 630   /* Skip typedefs.  */
 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)
 636     return 0;
 637   /* Structs with more than 1 field are always passed by address.  */
 638   if (TYPE_NFIELDS (type) != 1)
 639     return 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)
 644     return 1;
 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)
 651     return 0;
 652   /* Everything else, pass by address. */
 653   return 1;
 654 }
 655
 656 static CORE_ADDR
 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)
 661 {
 662   const bfd_byte *val;
 663   bfd_byte buf[4];
 664   struct type *type;
 665   int i, argreg, typelen, slacklen;
 666   int stackspace = 0;
 667   /* Used to copy struct arguments into the stack. */
 668   CORE_ADDR struct_ptr;
 669
 670   /* First determine how much stack space we will need. */
 671   for (i = 0, argreg = E_1ST_ARGREG + (struct_return != 0); i < nargs; i++)
 672     {
 673       type = value_type (args[i]);
 674       typelen = TYPE_LENGTH (type);
 675       if (typelen <= 4)
 676         {
 677           /* Scalars of up to 4 bytes,
 678              structs of up to 4 bytes, and
 679              pointers.  */
 680           if (argreg <= E_LAST_ARGREG)
 681             argreg++;
 682           else
 683             stackspace += 4;
 684         }
 685       else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
 686         {
 687           /* long long,
 688              double, and possibly
 689              structs with a single field of long long or double. */
 690           if (argreg <= E_LAST_ARGREG - 1)
 691             {
 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)
 695                 argreg ++;
 696               argreg += 2;
 697             }
 698           else
 699             {
 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);
 703               stackspace += 8;
 704             }
 705         }
 706       else
 707         {
 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)
 712             argreg++;
 713           else
 714             stackspace += 4;
 715           /* Care for 8-byte alignment of structs saved on stack.  */
 716           stackspace += ((typelen + 7) & ~7);
 717         }
 718     }
 719
 720   /* Now copy params, in ascending order, into their assigned location
 721      (either in a register or on the stack). */
 722
 723   sp -= (sp % 8);       /* align */
 724   struct_ptr = sp;
 725   sp -= stackspace;
 726   sp -= (sp % 8);       /* align again */
 727   stackspace = 0;
 728
 729   argreg = E_1ST_ARGREG;
 730   if (struct_return)
 731     {
 732       /* A function that returns a struct will consume one argreg to do so.
 733        */
 734       regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
 735     }
 736
 737   for (i = 0; i < nargs; i++)
 738     {
 739       type = value_type (args[i]);
 740       typelen = TYPE_LENGTH (type);
 741       val = value_contents (args[i]);
 742       if (typelen <= 4)
 743         {
 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)
 749             {
 750               /* Passed in a register. */
 751               regcache_raw_write (regcache, argreg++, buf);
 752             }
 753           else
 754             {
 755               /* Passed on the stack. */
 756               write_memory (sp + stackspace, buf, 4);
 757               stackspace += 4;
 758             }
 759         }
 760       else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
 761         {
 762           /* (long long), (double), or struct consisting of
 763              a single (long long) or (double). */
 764           if (argreg <= E_LAST_ARGREG - 1)
 765             {
 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)
 769                 argreg++;
 770               regcache_raw_write (regcache, argreg++, val);
 771               regcache_raw_write (regcache, argreg++, val + 4);
 772             }
 773           else
 774             {
 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);
 779               stackspace += 8;
 780             }
 781         }
 782       else
 783         {
 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);
 791           else
 792             {
 793               store_unsigned_integer (buf, 4, struct_ptr);
 794               write_memory (sp + stackspace, buf, 4);
 795               stackspace += 4;
 796             }
 797         }
 798     }
 799
 800   /* Store return address. */
 801   regcache_cooked_write_unsigned (regcache, E_LR_REGNUM, bp_addr);
 802
 803   /* Update stack pointer.  */
 804   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
 805
 806   /* And that should do it.  Return the new stack pointer. */
 807   return sp;
 808 }
 809
 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.  */
 813
 814 static struct gdbarch *
 815 iq2000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 816 {
 817   struct gdbarch *gdbarch;
 818
 819   /* Look up list for candidates - only one.  */
 820   arches = gdbarch_list_lookup_by_info (arches, &info);
 821   if (arches != NULL)
 822     return arches->gdbarch;
 823
 824   gdbarch = gdbarch_alloc (&info, NULL);
 825
 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);
 857
 858   gdbarch_init_osabi (info, gdbarch);
 859
 860   frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
 861   frame_unwind_append_sniffer (gdbarch, iq2000_frame_sniffer);
 862
 863   return gdbarch;
 864 }
 865
 866 /* Function: _initialize_iq2000_tdep
 867    Initializer function for the iq2000 module.
 868    Called by gdb at start-up. */
 869
 870 void
 871 _initialize_iq2000_tdep (void)
 872 {
 873   register_gdbarch_init (bfd_arch_iq2000, iq2000_gdbarch_init);
 874 }