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   default_frame_unwind_stop_reason,
 440   iq2000_frame_this_id,
 441   iq2000_frame_prev_register,
 442   NULL,
 443   default_frame_sniffer
 444 };
 445
 446 static CORE_ADDR
 447 iq2000_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 448 {
 449   return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
 450 }
 451
 452 static CORE_ADDR
 453 iq2000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 454 {
 455   return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
 456 }
 457
 458 static struct frame_id
 459 iq2000_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 460 {
 461   CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 462   return frame_id_build (sp, get_frame_pc (this_frame));
 463 }
 464
 465 static CORE_ADDR
 466 iq2000_frame_base_address (struct frame_info *this_frame, void **this_cache)
 467 {
 468   struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
 469                                                          this_cache);
 470
 471   return cache->base;
 472 }
 473
 474 static const struct frame_base iq2000_frame_base = {
 475   &iq2000_frame_unwind,
 476   iq2000_frame_base_address,
 477   iq2000_frame_base_address,
 478   iq2000_frame_base_address
 479 };
 480
 481 static const unsigned char *
 482 iq2000_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
 483                            int *lenptr)
 484 {
 485   static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d };
 486   static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 };
 487
 488   if ((*pcptr & 3) != 0)
 489     error (_("breakpoint_from_pc: invalid breakpoint address 0x%lx"),
 490            (long) *pcptr);
 491
 492   *lenptr = 4;
 493   return (gdbarch_byte_order (gdbarch)
 494           == BFD_ENDIAN_BIG) ? big_breakpoint : little_breakpoint;
 495 }
 496
 497 /* Target function return value methods: */
 498
 499 /* Function: store_return_value
 500    Copy the function return value from VALBUF into the
 501    proper location for a function return.  */
 502
 503 static void
 504 iq2000_store_return_value (struct type *type, struct regcache *regcache,
 505                            const void *valbuf)
 506 {
 507   int len = TYPE_LENGTH (type);
 508   int regno = E_FN_RETURN_REGNUM;
 509
 510   while (len > 0)
 511     {
 512       char buf[4];
 513       int size = len % 4 ?: 4;
 514
 515       memset (buf, 0, 4);
 516       memcpy (buf + 4 - size, valbuf, size);
 517       regcache_raw_write (regcache, regno++, buf);
 518       len -= size;
 519       valbuf = ((char *) valbuf) + size;
 520     }
 521 }
 522
 523 /* Function: use_struct_convention
 524    Returns non-zero if the given struct type will be returned using
 525    a special convention, rather than the normal function return method.  */
 526
 527 static int
 528 iq2000_use_struct_convention (struct type *type)
 529 {
 530   return ((TYPE_CODE (type) == TYPE_CODE_STRUCT)
 531           || (TYPE_CODE (type) == TYPE_CODE_UNION))
 532          && TYPE_LENGTH (type) > 8;
 533 }
 534
 535 /* Function: extract_return_value
 536    Copy the function's return value into VALBUF.
 537    This function is called only in the context of "target function calls",
 538    ie. when the debugger forces a function to be called in the child, and
 539    when the debugger forces a function to return prematurely via the
 540    "return" command.  */
 541
 542 static void
 543 iq2000_extract_return_value (struct type *type, struct regcache *regcache,
 544                              void *valbuf)
 545 {
 546   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 547   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 548
 549   /* If the function's return value is 8 bytes or less, it is
 550      returned in a register, and if larger than 8 bytes, it is
 551      returned in a stack location which is pointed to by the same
 552      register.  */
 553   int len = TYPE_LENGTH (type);
 554
 555   if (len <= (2 * 4))
 556     {
 557       int regno = E_FN_RETURN_REGNUM;
 558
 559       /* Return values of <= 8 bytes are returned in
 560          FN_RETURN_REGNUM.  */
 561       while (len > 0)
 562         {
 563           ULONGEST tmp;
 564           int size = len % 4 ?: 4;
 565
 566           /* By using store_unsigned_integer we avoid having to
 567              do anything special for small big-endian values.  */
 568           regcache_cooked_read_unsigned (regcache, regno++, &tmp);
 569           store_unsigned_integer (valbuf, size, byte_order, tmp);
 570           len -= size;
 571           valbuf = ((char *) valbuf) + size;
 572         }
 573     }
 574   else
 575     {
 576       /* Return values > 8 bytes are returned in memory,
 577          pointed to by FN_RETURN_REGNUM.  */
 578       ULONGEST return_buffer;
 579       regcache_cooked_read_unsigned (regcache, E_FN_RETURN_REGNUM,
 580                                      &return_buffer);
 581       read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
 582     }
 583 }
 584
 585 static enum return_value_convention
 586 iq2000_return_value (struct gdbarch *gdbarch, struct type *func_type,
 587                      struct type *type, struct regcache *regcache,
 588                      gdb_byte *readbuf, const gdb_byte *writebuf)
 589 {
 590   if (iq2000_use_struct_convention (type))
 591     return RETURN_VALUE_STRUCT_CONVENTION;
 592   if (writebuf)
 593     iq2000_store_return_value (type, regcache, writebuf);
 594   else if (readbuf)
 595     iq2000_extract_return_value (type, regcache, readbuf);
 596   return RETURN_VALUE_REGISTER_CONVENTION;
 597 }
 598
 599 /* Function: register_virtual_type
 600    Returns the default type for register N.  */
 601
 602 static struct type *
 603 iq2000_register_type (struct gdbarch *gdbarch, int regnum)
 604 {
 605   return builtin_type (gdbarch)->builtin_int32;
 606 }
 607
 608 static CORE_ADDR
 609 iq2000_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
 610 {
 611   /* This is the same frame alignment used by gcc.  */
 612   return ((sp + 7) & ~7);
 613 }
 614
 615 /* Convenience function to check 8-byte types for being a scalar type
 616    or a struct with only one long long or double member.  */
 617 static int
 618 iq2000_pass_8bytetype_by_address (struct type *type)
 619 {
 620   struct type *ftype;
 621
 622   /* Skip typedefs.  */
 623   while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
 624     type = TYPE_TARGET_TYPE (type);
 625   /* Non-struct and non-union types are always passed by value.  */
 626   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 627       && TYPE_CODE (type) != TYPE_CODE_UNION)
 628     return 0;
 629   /* Structs with more than 1 field are always passed by address.  */
 630   if (TYPE_NFIELDS (type) != 1)
 631     return 1;
 632   /* Get field type.  */
 633   ftype = (TYPE_FIELDS (type))[0].type;
 634   /* The field type must have size 8, otherwise pass by address.  */
 635   if (TYPE_LENGTH (ftype) != 8)
 636     return 1;
 637   /* Skip typedefs of field type.  */
 638   while (TYPE_CODE (ftype) == TYPE_CODE_TYPEDEF)
 639     ftype = TYPE_TARGET_TYPE (ftype);
 640   /* If field is int or float, pass by value.  */
 641   if (TYPE_CODE (ftype) == TYPE_CODE_FLT
 642       || TYPE_CODE (ftype) == TYPE_CODE_INT)
 643     return 0;
 644   /* Everything else, pass by address.  */
 645   return 1;
 646 }
 647
 648 static CORE_ADDR
 649 iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 650                         struct regcache *regcache, CORE_ADDR bp_addr,
 651                         int nargs, struct value **args, CORE_ADDR sp,
 652                         int struct_return, CORE_ADDR struct_addr)
 653 {
 654   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 655   const bfd_byte *val;
 656   bfd_byte buf[4];
 657   struct type *type;
 658   int i, argreg, typelen, slacklen;
 659   int stackspace = 0;
 660   /* Used to copy struct arguments into the stack.  */
 661   CORE_ADDR struct_ptr;
 662
 663   /* First determine how much stack space we will need.  */
 664   for (i = 0, argreg = E_1ST_ARGREG + (struct_return != 0); i < nargs; i++)
 665     {
 666       type = value_type (args[i]);
 667       typelen = TYPE_LENGTH (type);
 668       if (typelen <= 4)
 669         {
 670           /* Scalars of up to 4 bytes,
 671              structs of up to 4 bytes, and
 672              pointers.  */
 673           if (argreg <= E_LAST_ARGREG)
 674             argreg++;
 675           else
 676             stackspace += 4;
 677         }
 678       else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
 679         {
 680           /* long long,
 681              double, and possibly
 682              structs with a single field of long long or double.  */
 683           if (argreg <= E_LAST_ARGREG - 1)
 684             {
 685               /* 8-byte arg goes into a register pair
 686                  (must start with an even-numbered reg).  */
 687               if (((argreg - E_1ST_ARGREG) % 2) != 0)
 688                 argreg ++;
 689               argreg += 2;
 690             }
 691           else
 692             {
 693               argreg = E_LAST_ARGREG + 1;       /* no more argregs.  */
 694               /* 8-byte arg goes on stack, must be 8-byte aligned.  */
 695               stackspace = ((stackspace + 7) & ~7);
 696               stackspace += 8;
 697             }
 698         }
 699       else
 700         {
 701           /* Structs are passed as pointer to a copy of the struct.
 702              So we need room on the stack for a copy of the struct
 703              plus for the argument pointer.  */
 704           if (argreg <= E_LAST_ARGREG)
 705             argreg++;
 706           else
 707             stackspace += 4;
 708           /* Care for 8-byte alignment of structs saved on stack.  */
 709           stackspace += ((typelen + 7) & ~7);
 710         }
 711     }
 712
 713   /* Now copy params, in ascending order, into their assigned location
 714      (either in a register or on the stack).  */
 715
 716   sp -= (sp % 8);       /* align */
 717   struct_ptr = sp;
 718   sp -= stackspace;
 719   sp -= (sp % 8);       /* align again */
 720   stackspace = 0;
 721
 722   argreg = E_1ST_ARGREG;
 723   if (struct_return)
 724     {
 725       /* A function that returns a struct will consume one argreg to do so.
 726        */
 727       regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
 728     }
 729
 730   for (i = 0; i < nargs; i++)
 731     {
 732       type = value_type (args[i]);
 733       typelen = TYPE_LENGTH (type);
 734       val = value_contents (args[i]);
 735       if (typelen <= 4)
 736         {
 737           /* Char, short, int, float, pointer, and structs <= four bytes.  */
 738           slacklen = (4 - (typelen % 4)) % 4;
 739           memset (buf, 0, sizeof (buf));
 740           memcpy (buf + slacklen, val, typelen);
 741           if (argreg <= E_LAST_ARGREG)
 742             {
 743               /* Passed in a register.  */
 744               regcache_raw_write (regcache, argreg++, buf);
 745             }
 746           else
 747             {
 748               /* Passed on the stack.  */
 749               write_memory (sp + stackspace, buf, 4);
 750               stackspace += 4;
 751             }
 752         }
 753       else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
 754         {
 755           /* (long long), (double), or struct consisting of
 756              a single (long long) or (double).  */
 757           if (argreg <= E_LAST_ARGREG - 1)
 758             {
 759               /* 8-byte arg goes into a register pair
 760                  (must start with an even-numbered reg).  */
 761               if (((argreg - E_1ST_ARGREG) % 2) != 0)
 762                 argreg++;
 763               regcache_raw_write (regcache, argreg++, val);
 764               regcache_raw_write (regcache, argreg++, val + 4);
 765             }
 766           else
 767             {
 768               /* 8-byte arg goes on stack, must be 8-byte aligned.  */
 769               argreg = E_LAST_ARGREG + 1;       /* no more argregs.  */
 770               stackspace = ((stackspace + 7) & ~7);
 771               write_memory (sp + stackspace, val, typelen);
 772               stackspace += 8;
 773             }
 774         }
 775       else
 776         {
 777           /* Store struct beginning at the upper end of the previously
 778              computed stack space.  Then store the address of the struct
 779              using the usual rules for a 4 byte value.  */
 780           struct_ptr -= ((typelen + 7) & ~7);
 781           write_memory (struct_ptr, val, typelen);
 782           if (argreg <= E_LAST_ARGREG)
 783             regcache_cooked_write_unsigned (regcache, argreg++, struct_ptr);
 784           else
 785             {
 786               store_unsigned_integer (buf, 4, byte_order, struct_ptr);
 787               write_memory (sp + stackspace, buf, 4);
 788               stackspace += 4;
 789             }
 790         }
 791     }
 792
 793   /* Store return address.  */
 794   regcache_cooked_write_unsigned (regcache, E_LR_REGNUM, bp_addr);
 795
 796   /* Update stack pointer.  */
 797   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
 798
 799   /* And that should do it.  Return the new stack pointer.  */
 800   return sp;
 801 }
 802
 803 /* Function: gdbarch_init
 804    Initializer function for the iq2000 gdbarch vector.
 805    Called by gdbarch.  Sets up the gdbarch vector(s) for this target.  */
 806
 807 static struct gdbarch *
 808 iq2000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 809 {
 810   struct gdbarch *gdbarch;
 811
 812   /* Look up list for candidates - only one.  */
 813   arches = gdbarch_list_lookup_by_info (arches, &info);
 814   if (arches != NULL)
 815     return arches->gdbarch;
 816
 817   gdbarch = gdbarch_alloc (&info, NULL);
 818
 819   set_gdbarch_num_regs             (gdbarch, E_NUM_REGS);
 820   set_gdbarch_num_pseudo_regs      (gdbarch, 0);
 821   set_gdbarch_sp_regnum            (gdbarch, E_SP_REGNUM);
 822   set_gdbarch_pc_regnum            (gdbarch, E_PC_REGNUM);
 823   set_gdbarch_register_name        (gdbarch, iq2000_register_name);
 824   set_gdbarch_address_to_pointer   (gdbarch, iq2000_address_to_pointer);
 825   set_gdbarch_pointer_to_address   (gdbarch, iq2000_pointer_to_address);
 826   set_gdbarch_ptr_bit              (gdbarch, 4 * TARGET_CHAR_BIT);
 827   set_gdbarch_short_bit            (gdbarch, 2 * TARGET_CHAR_BIT);
 828   set_gdbarch_int_bit              (gdbarch, 4 * TARGET_CHAR_BIT);
 829   set_gdbarch_long_bit             (gdbarch, 4 * TARGET_CHAR_BIT);
 830   set_gdbarch_long_long_bit        (gdbarch, 8 * TARGET_CHAR_BIT);
 831   set_gdbarch_float_bit            (gdbarch, 4 * TARGET_CHAR_BIT);
 832   set_gdbarch_double_bit           (gdbarch, 8 * TARGET_CHAR_BIT);
 833   set_gdbarch_long_double_bit      (gdbarch, 8 * TARGET_CHAR_BIT);
 834   set_gdbarch_float_format         (gdbarch, floatformats_ieee_single);
 835   set_gdbarch_double_format        (gdbarch, floatformats_ieee_double);
 836   set_gdbarch_long_double_format   (gdbarch, floatformats_ieee_double);
 837   set_gdbarch_return_value         (gdbarch, iq2000_return_value);
 838   set_gdbarch_breakpoint_from_pc   (gdbarch, iq2000_breakpoint_from_pc);
 839   set_gdbarch_frame_args_skip      (gdbarch, 0);
 840   set_gdbarch_skip_prologue        (gdbarch, iq2000_skip_prologue);
 841   set_gdbarch_inner_than           (gdbarch, core_addr_lessthan);
 842   set_gdbarch_print_insn           (gdbarch, print_insn_iq2000);
 843   set_gdbarch_register_type (gdbarch, iq2000_register_type);
 844   set_gdbarch_frame_align (gdbarch, iq2000_frame_align);
 845   set_gdbarch_unwind_sp (gdbarch, iq2000_unwind_sp);
 846   set_gdbarch_unwind_pc (gdbarch, iq2000_unwind_pc);
 847   set_gdbarch_dummy_id (gdbarch, iq2000_dummy_id);
 848   frame_base_set_default (gdbarch, &iq2000_frame_base);
 849   set_gdbarch_push_dummy_call (gdbarch, iq2000_push_dummy_call);
 850
 851   gdbarch_init_osabi (info, gdbarch);
 852
 853   dwarf2_append_unwinders (gdbarch);
 854   frame_unwind_append_unwinder (gdbarch, &iq2000_frame_unwind);
 855
 856   return gdbarch;
 857 }
 858
 859 /* Function: _initialize_iq2000_tdep
 860    Initializer function for the iq2000 module.
 861    Called by gdb at start-up.  */
 862
 863 /* Provide a prototype to silence -Wmissing-prototypes.  */
 864 extern initialize_file_ftype _initialize_iq2000_tdep;
 865
 866 void
 867 _initialize_iq2000_tdep (void)
 868 {
 869   register_gdbarch_init (bfd_arch_iq2000, iq2000_gdbarch_init);
 870 }