gdb/iq2000-tdep.c

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