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, 2010, 2011
   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 bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  94   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
  95   CORE_ADDR addr
  96     = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
  97
  98   if (target == TYPE_CODE_FUNC
  99       || target == TYPE_CODE_METHOD
 100       || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
 101     addr = insn_addr_from_ptr (addr);
 102
 103   return addr;
 104 }
 105
 106 /* Function: address_to_pointer
 107    Convert a host-format address (CORE_ADDR) into a target pointer.  */
 108
 109 static void
 110 iq2000_address_to_pointer (struct gdbarch *gdbarch,
 111                            struct type *type, gdb_byte *buf, CORE_ADDR addr)
 112 {
 113   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 114   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
 115
 116   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
 117     addr = insn_ptr_from_addr (addr);
 118   store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
 119 }
 120
 121 /* Real register methods: */
 122
 123 /* Function: register_name
 124    Returns the name of the iq2000 register number N.  */
 125
 126 static const char *
 127 iq2000_register_name (struct gdbarch *gdbarch, int regnum)
 128 {
 129   static const char * names[E_NUM_REGS] =
 130     {
 131       "r0",  "r1",  "r2",  "r3",  "r4",
 132       "r5",  "r6",  "r7",  "r8",  "r9",
 133       "r10", "r11", "r12", "r13", "r14",
 134       "r15", "r16", "r17", "r18", "r19",
 135       "r20", "r21", "r22", "r23", "r24",
 136       "r25", "r26", "r27", "r28", "r29",
 137       "r30", "r31",
 138       "pc"
 139     };
 140   if (regnum < 0 || regnum >= E_NUM_REGS)
 141     return NULL;
 142   return names[regnum];
 143 }
 144
 145 /* Prologue analysis methods:  */
 146
 147 /* ADDIU insn (001001 rs(5) rt(5) imm(16)).  */
 148 #define INSN_IS_ADDIU(X)        (((X) & 0xfc000000) == 0x24000000)
 149 #define ADDIU_REG_SRC(X)        (((X) & 0x03e00000) >> 21)
 150 #define ADDIU_REG_TGT(X)        (((X) & 0x001f0000) >> 16)
 151 #define ADDIU_IMMEDIATE(X)      ((signed short) ((X) & 0x0000ffff))
 152
 153 /* "MOVE" (OR) insn (000000 rs(5) rt(5) rd(5) 00000 100101).  */
 154 #define INSN_IS_MOVE(X)         (((X) & 0xffe007ff) == 0x00000025)
 155 #define MOVE_REG_SRC(X)         (((X) & 0x001f0000) >> 16)
 156 #define MOVE_REG_TGT(X)         (((X) & 0x0000f800) >> 11)
 157
 158 /* STORE WORD insn (101011 rs(5) rt(5) offset(16)).  */
 159 #define INSN_IS_STORE_WORD(X)   (((X) & 0xfc000000) == 0xac000000)
 160 #define SW_REG_INDEX(X)         (((X) & 0x03e00000) >> 21)
 161 #define SW_REG_SRC(X)           (((X) & 0x001f0000) >> 16)
 162 #define SW_OFFSET(X)            ((signed short) ((X) & 0x0000ffff))
 163
 164 /* Function: find_last_line_symbol
 165
 166    Given an address range, first find a line symbol corresponding to
 167    the starting address.  Then find the last line symbol within the
 168    range that has a line number less than or equal to the first line.
 169
 170    For optimized code with code motion, this finds the last address
 171    for the lowest-numbered line within the address range.  */
 172
 173 static struct symtab_and_line
 174 find_last_line_symbol (CORE_ADDR start, CORE_ADDR end, int notcurrent)
 175 {
 176   struct symtab_and_line sal = find_pc_line (start, notcurrent);
 177   struct symtab_and_line best_sal = sal;
 178
 179   if (sal.pc == 0 || sal.line == 0 || sal.end == 0)
 180     return sal;
 181
 182   do
 183     {
 184       if (sal.line && sal.line <= best_sal.line)
 185         best_sal = sal;
 186       sal = find_pc_line (sal.end, notcurrent);
 187     }
 188   while (sal.pc && sal.pc < end);
 189
 190   return best_sal;
 191 }
 192
 193 /* Function: scan_prologue
 194    Decode the instructions within the given address range.
 195    Decide when we must have reached the end of the function prologue.
 196    If a frame_info pointer is provided, fill in its prologue information.
 197
 198    Returns the address of the first instruction after the prologue.  */
 199
 200 static CORE_ADDR
 201 iq2000_scan_prologue (struct gdbarch *gdbarch,
 202                       CORE_ADDR scan_start,
 203                       CORE_ADDR scan_end,
 204                       struct frame_info *fi,
 205                       struct iq2000_frame_cache *cache)
 206 {
 207   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 208   struct symtab_and_line sal;
 209   CORE_ADDR pc;
 210   CORE_ADDR loop_end;
 211   int found_store_lr = 0;
 212   int found_decr_sp = 0;
 213   int srcreg;
 214   int tgtreg;
 215   signed short offset;
 216
 217   if (scan_end == (CORE_ADDR) 0)
 218     {
 219       loop_end = scan_start + 100;
 220       sal.end = sal.pc = 0;
 221     }
 222   else
 223     {
 224       loop_end = scan_end;
 225       if (fi)
 226         sal = find_last_line_symbol (scan_start, scan_end, 0);
 227       else
 228         sal.end = 0;    /* Avoid GCC false warning.  */
 229     }
 230
 231   /* Saved registers:
 232      We first have to save the saved register's offset, and
 233      only later do we compute its actual address.  Since the
 234      offset can be zero, we must first initialize all the
 235      saved regs to minus one (so we can later distinguish
 236      between one that's not saved, and one that's saved at zero).  */
 237   for (srcreg = 0; srcreg < E_NUM_REGS; srcreg ++)
 238     cache->saved_regs[srcreg] = -1;
 239   cache->using_fp = 0;
 240   cache->framesize = 0;
 241
 242   for (pc = scan_start; pc < loop_end; pc += 4)
 243     {
 244       LONGEST insn = read_memory_unsigned_integer (pc, 4, byte_order);
 245       /* Skip any instructions writing to (sp) or decrementing the
 246          SP.  */
 247       if ((insn & 0xffe00000) == 0xac200000)
 248         {
 249           /* sw using SP/%1 as base.  */
 250           /* LEGACY -- from assembly-only port.  */
 251           tgtreg = ((insn >> 16) & 0x1f);
 252           if (tgtreg >= 0 && tgtreg < E_NUM_REGS)
 253             cache->saved_regs[tgtreg] = -((signed short) (insn & 0xffff));
 254
 255           if (tgtreg == E_LR_REGNUM)
 256             found_store_lr = 1;
 257           continue;
 258         }
 259
 260       if ((insn & 0xffff8000) == 0x20218000)
 261         {
 262           /* addi %1, %1, -N == addi %sp, %sp, -N */
 263           /* LEGACY -- from assembly-only port.  */
 264           found_decr_sp = 1;
 265           cache->framesize = -((signed short) (insn & 0xffff));
 266           continue;
 267         }
 268
 269       if (INSN_IS_ADDIU (insn))
 270         {
 271           srcreg = ADDIU_REG_SRC (insn);
 272           tgtreg = ADDIU_REG_TGT (insn);
 273           offset = ADDIU_IMMEDIATE (insn);
 274           if (srcreg == E_SP_REGNUM && tgtreg == E_SP_REGNUM)
 275             cache->framesize = -offset;
 276           continue;
 277         }
 278
 279       if (INSN_IS_STORE_WORD (insn))
 280         {
 281           srcreg = SW_REG_SRC (insn);
 282           tgtreg = SW_REG_INDEX (insn);
 283           offset = SW_OFFSET (insn);
 284
 285           if (tgtreg == E_SP_REGNUM || tgtreg == E_FP_REGNUM)
 286             {
 287               /* "push" to stack (via SP or FP reg).  */
 288               if (cache->saved_regs[srcreg] == -1) /* Don't save twice.  */
 289                 cache->saved_regs[srcreg] = offset;
 290               continue;
 291             }
 292         }
 293
 294       if (INSN_IS_MOVE (insn))
 295         {
 296           srcreg = MOVE_REG_SRC (insn);
 297           tgtreg = MOVE_REG_TGT (insn);
 298
 299           if (srcreg == E_SP_REGNUM && tgtreg == E_FP_REGNUM)
 300             {
 301               /* Copy sp to fp.  */
 302               cache->using_fp = 1;
 303               continue;
 304             }
 305         }
 306
 307       /* Unknown instruction encountered in frame.  Bail out?
 308          1) If we have a subsequent line symbol, we can keep going.
 309          2) If not, we need to bail out and quit scanning instructions.  */
 310
 311       if (fi && sal.end && (pc < sal.end)) /* Keep scanning.  */
 312         continue;
 313       else /* bail */
 314         break;
 315     }
 316
 317   return pc;
 318 }
 319
 320 static void
 321 iq2000_init_frame_cache (struct iq2000_frame_cache *cache)
 322 {
 323   int i;
 324
 325   cache->base = 0;
 326   cache->framesize = 0;
 327   cache->using_fp = 0;
 328   cache->saved_sp = 0;
 329   for (i = 0; i < E_NUM_REGS; i++)
 330     cache->saved_regs[i] = -1;
 331 }
 332
 333 /* Function: iq2000_skip_prologue
 334    If the input address is in a function prologue,
 335    returns the address of the end of the prologue;
 336    else returns the input address.
 337
 338    Note: the input address is likely to be the function start,
 339    since this function is mainly used for advancing a breakpoint
 340    to the first line, or stepping to the first line when we have
 341    stepped into a function call.  */
 342
 343 static CORE_ADDR
 344 iq2000_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 345 {
 346   CORE_ADDR func_addr = 0 , func_end = 0;
 347
 348   if (find_pc_partial_function (pc, NULL, & func_addr, & func_end))
 349     {
 350       struct symtab_and_line sal;
 351       struct iq2000_frame_cache cache;
 352
 353       /* Found a function.  */
 354       sal = find_pc_line (func_addr, 0);
 355       if (sal.end && sal.end < func_end)
 356         /* Found a line number, use it as end of prologue.  */
 357         return sal.end;
 358
 359       /* No useable line symbol.  Use prologue parsing method.  */
 360       iq2000_init_frame_cache (&cache);
 361       return iq2000_scan_prologue (gdbarch, func_addr, func_end, NULL, &cache);
 362     }
 363
 364   /* No function symbol -- just return the PC.  */
 365   return (CORE_ADDR) pc;
 366 }
 367
 368 static struct iq2000_frame_cache *
 369 iq2000_frame_cache (struct frame_info *this_frame, void **this_cache)
 370 {
 371   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 372   struct iq2000_frame_cache *cache;
 373   CORE_ADDR current_pc;
 374   int i;
 375
 376   if (*this_cache)
 377     return *this_cache;
 378
 379   cache = FRAME_OBSTACK_ZALLOC (struct iq2000_frame_cache);
 380   iq2000_init_frame_cache (cache);
 381   *this_cache = cache;
 382
 383   cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
 384   //if (cache->base == 0)
 385     //return cache;
 386
 387   current_pc = get_frame_pc (this_frame);
 388   find_pc_partial_function (current_pc, NULL, &cache->pc, NULL);
 389   if (cache->pc != 0)
 390     iq2000_scan_prologue (gdbarch, cache->pc, current_pc, this_frame, cache);
 391   if (!cache->using_fp)
 392     cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 393
 394   cache->saved_sp = cache->base + cache->framesize;
 395
 396   for (i = 0; i < E_NUM_REGS; i++)
 397     if (cache->saved_regs[i] != -1)
 398       cache->saved_regs[i] += cache->base;
 399
 400   return cache;
 401 }
 402
 403 static struct value *
 404 iq2000_frame_prev_register (struct frame_info *this_frame, void **this_cache,
 405                             int regnum)
 406 {
 407   struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
 408                                                          this_cache);
 409
 410   if (regnum == E_SP_REGNUM && cache->saved_sp)
 411     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
 412
 413   if (regnum == E_PC_REGNUM)
 414     regnum = E_LR_REGNUM;
 415
 416   if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != -1)
 417     return frame_unwind_got_memory (this_frame, regnum,
 418                                     cache->saved_regs[regnum]);
 419
 420   return frame_unwind_got_register (this_frame, regnum, regnum);
 421 }
 422
 423 static void
 424 iq2000_frame_this_id (struct frame_info *this_frame, void **this_cache,
 425                       struct frame_id *this_id)
 426 {
 427   struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
 428                                                          this_cache);
 429
 430   /* This marks the outermost frame.  */
 431   if (cache->base == 0)
 432     return;
 433
 434   *this_id = frame_id_build (cache->saved_sp, cache->pc);
 435 }
 436
 437 static const struct frame_unwind iq2000_frame_unwind = {
 438   NORMAL_FRAME,
 439   iq2000_frame_this_id,
 440   iq2000_frame_prev_register,
 441   NULL,
 442   default_frame_sniffer
 443 };
 444
 445 static CORE_ADDR
 446 iq2000_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 447 {
 448   return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
 449 }
 450
 451 static CORE_ADDR
 452 iq2000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 453 {
 454   return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
 455 }
 456
 457 static struct frame_id
 458 iq2000_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 459 {
 460   CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 461   return frame_id_build (sp, get_frame_pc (this_frame));
 462 }
 463
 464 static CORE_ADDR
 465 iq2000_frame_base_address (struct frame_info *this_frame, void **this_cache)
 466 {
 467   struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
 468                                                          this_cache);
 469
 470   return cache->base;
 471 }
 472
 473 static const struct frame_base iq2000_frame_base = {
 474   &iq2000_frame_unwind,
 475   iq2000_frame_base_address,
 476   iq2000_frame_base_address,
 477   iq2000_frame_base_address
 478 };
 479
 480 static const unsigned char *
 481 iq2000_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
 482                            int *lenptr)
 483 {
 484   static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d };
 485   static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 };
 486
 487   if ((*pcptr & 3) != 0)
 488     error (_("breakpoint_from_pc: invalid breakpoint address 0x%lx"),
 489            (long) *pcptr);
 490
 491   *lenptr = 4;
 492   return (gdbarch_byte_order (gdbarch)
 493           == BFD_ENDIAN_BIG) ? big_breakpoint : little_breakpoint;
 494 }
 495
 496 /* Target function return value methods: */
 497
 498 /* Function: store_return_value
 499    Copy the function return value from VALBUF into the
 500    proper location for a function return.  */
 501
 502 static void
 503 iq2000_store_return_value (struct type *type, struct regcache *regcache,
 504                            const void *valbuf)
 505 {
 506   int len = TYPE_LENGTH (type);
 507   int regno = E_FN_RETURN_REGNUM;
 508
 509   while (len > 0)
 510     {
 511       char buf[4];
 512       int size = len % 4 ?: 4;
 513
 514       memset (buf, 0, 4);
 515       memcpy (buf + 4 - size, valbuf, size);
 516       regcache_raw_write (regcache, regno++, buf);
 517       len -= size;
 518       valbuf = ((char *) valbuf) + size;
 519     }
 520 }
 521
 522 /* Function: use_struct_convention
 523    Returns non-zero if the given struct type will be returned using
 524    a special convention, rather than the normal function return method.  */
 525
 526 static int
 527 iq2000_use_struct_convention (struct type *type)
 528 {
 529   return ((TYPE_CODE (type) == TYPE_CODE_STRUCT)
 530           || (TYPE_CODE (type) == TYPE_CODE_UNION))
 531          && TYPE_LENGTH (type) > 8;
 532 }
 533
 534 /* Function: extract_return_value
 535    Copy the function's return value into VALBUF.
 536    This function is called only in the context of "target function calls",
 537    ie. when the debugger forces a function to be called in the child, and
 538    when the debugger forces a function to return prematurely via the
 539    "return" command.  */
 540
 541 static void
 542 iq2000_extract_return_value (struct type *type, struct regcache *regcache,
 543                              void *valbuf)
 544 {
 545   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 546   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 547
 548   /* If the function's return value is 8 bytes or less, it is
 549      returned in a register, and if larger than 8 bytes, it is
 550      returned in a stack location which is pointed to by the same
 551      register.  */
 552   int len = TYPE_LENGTH (type);
 553
 554   if (len <= (2 * 4))
 555     {
 556       int regno = E_FN_RETURN_REGNUM;
 557
 558       /* Return values of <= 8 bytes are returned in
 559          FN_RETURN_REGNUM.  */
 560       while (len > 0)
 561         {
 562           ULONGEST tmp;
 563           int size = len % 4 ?: 4;
 564
 565           /* By using store_unsigned_integer we avoid having to
 566              do anything special for small big-endian values.  */
 567           regcache_cooked_read_unsigned (regcache, regno++, &tmp);
 568           store_unsigned_integer (valbuf, size, byte_order, tmp);
 569           len -= size;
 570           valbuf = ((char *) valbuf) + size;
 571         }
 572     }
 573   else
 574     {
 575       /* Return values > 8 bytes are returned in memory,
 576          pointed to by FN_RETURN_REGNUM.  */
 577       ULONGEST return_buffer;
 578       regcache_cooked_read_unsigned (regcache, E_FN_RETURN_REGNUM,
 579                                      &return_buffer);
 580       read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
 581     }
 582 }
 583
 584 static enum return_value_convention
 585 iq2000_return_value (struct gdbarch *gdbarch, struct type *func_type,
 586                      struct type *type, struct regcache *regcache,
 587                      gdb_byte *readbuf, const gdb_byte *writebuf)
 588 {
 589   if (iq2000_use_struct_convention (type))
 590     return RETURN_VALUE_STRUCT_CONVENTION;
 591   if (writebuf)
 592     iq2000_store_return_value (type, regcache, writebuf);
 593   else if (readbuf)
 594     iq2000_extract_return_value (type, regcache, readbuf);
 595   return RETURN_VALUE_REGISTER_CONVENTION;
 596 }
 597
 598 /* Function: register_virtual_type
 599    Returns the default type for register N.  */
 600
 601 static struct type *
 602 iq2000_register_type (struct gdbarch *gdbarch, int regnum)
 603 {
 604   return builtin_type (gdbarch)->builtin_int32;
 605 }
 606
 607 static CORE_ADDR
 608 iq2000_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
 609 {
 610   /* This is the same frame alignment used by gcc.  */
 611   return ((sp + 7) & ~7);
 612 }
 613
 614 /* Convenience function to check 8-byte types for being a scalar type
 615    or a struct with only one long long or double member.  */
 616 static int
 617 iq2000_pass_8bytetype_by_address (struct type *type)
 618 {
 619   struct type *ftype;
 620
 621   /* Skip typedefs.  */
 622   while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
 623     type = TYPE_TARGET_TYPE (type);
 624   /* Non-struct and non-union types are always passed by value.  */
 625   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 626       && TYPE_CODE (type) != TYPE_CODE_UNION)
 627     return 0;
 628   /* Structs with more than 1 field are always passed by address.  */
 629   if (TYPE_NFIELDS (type) != 1)
 630     return 1;
 631   /* Get field type.  */
 632   ftype = (TYPE_FIELDS (type))[0].type;
 633   /* The field type must have size 8, otherwise pass by address.  */
 634   if (TYPE_LENGTH (ftype) != 8)
 635     return 1;
 636   /* Skip typedefs of field type.  */
 637   while (TYPE_CODE (ftype) == TYPE_CODE_TYPEDEF)
 638     ftype = TYPE_TARGET_TYPE (ftype);
 639   /* If field is int or float, pass by value.  */
 640   if (TYPE_CODE (ftype) == TYPE_CODE_FLT
 641       || TYPE_CODE (ftype) == TYPE_CODE_INT)
 642     return 0;
 643   /* Everything else, pass by address.  */
 644   return 1;
 645 }
 646
 647 static CORE_ADDR
 648 iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 649                         struct regcache *regcache, CORE_ADDR bp_addr,
 650                         int nargs, struct value **args, CORE_ADDR sp,
 651                         int struct_return, CORE_ADDR struct_addr)
 652 {
 653   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 654   const bfd_byte *val;
 655   bfd_byte buf[4];
 656   struct type *type;
 657   int i, argreg, typelen, slacklen;
 658   int stackspace = 0;
 659   /* Used to copy struct arguments into the stack.  */
 660   CORE_ADDR struct_ptr;
 661
 662   /* First determine how much stack space we will need.  */
 663   for (i = 0, argreg = E_1ST_ARGREG + (struct_return != 0); i < nargs; 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 (struct_return)
 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 (regcache, 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 (regcache, argreg++, val);
 763               regcache_raw_write (regcache, 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_from_pc   (gdbarch, iq2000_breakpoint_from_pc);
 838   set_gdbarch_frame_args_skip      (gdbarch, 0);
 839   set_gdbarch_skip_prologue        (gdbarch, iq2000_skip_prologue);
 840   set_gdbarch_inner_than           (gdbarch, core_addr_lessthan);
 841   set_gdbarch_print_insn           (gdbarch, print_insn_iq2000);
 842   set_gdbarch_register_type (gdbarch, iq2000_register_type);
 843   set_gdbarch_frame_align (gdbarch, iq2000_frame_align);
 844   set_gdbarch_unwind_sp (gdbarch, iq2000_unwind_sp);
 845   set_gdbarch_unwind_pc (gdbarch, iq2000_unwind_pc);
 846   set_gdbarch_dummy_id (gdbarch, iq2000_dummy_id);
 847   frame_base_set_default (gdbarch, &iq2000_frame_base);
 848   set_gdbarch_push_dummy_call (gdbarch, iq2000_push_dummy_call);
 849
 850   gdbarch_init_osabi (info, gdbarch);
 851
 852   dwarf2_append_unwinders (gdbarch);
 853   frame_unwind_append_unwinder (gdbarch, &iq2000_frame_unwind);
 854
 855   return gdbarch;
 856 }
 857
 858 /* Function: _initialize_iq2000_tdep
 859    Initializer function for the iq2000 module.
 860    Called by gdb at start-up.  */
 861
 862 /* Provide a prototype to silence -Wmissing-prototypes.  */
 863 extern initialize_file_ftype _initialize_iq2000_tdep;
 864
 865 void
 866 _initialize_iq2000_tdep (void)
 867 {
 868   register_gdbarch_init (bfd_arch_iq2000, iq2000_gdbarch_init);
 869 }