gdb/iq2000-tdep.c

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