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 37enum 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. */ 58enum { REG_UNAVAIL = (CORE_ADDR) -1 }; 59 60struct 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 73static CORE_ADDR 74insn_ptr_from_addr (CORE_ADDR addr) /* CORE_ADDR to target pointer. */ 75{ 76 return addr & 0x7fffffffL; 77} 78 79static CORE_ADDR 80insn_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 88static CORE_ADDR 89iq2000_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 105static void 106iq2000_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 120static const char * 121iq2000_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 167static struct symtab_and_line 168find_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 194static CORE_ADDR 195iq2000_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 310static void 311iq2000_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 333static CORE_ADDR 334iq2000_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 358static struct iq2000_frame_cache * 359iq2000_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 392static void 393iq2000_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 432static void 433iq2000_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 445static const struct frame_unwind iq2000_frame_unwind = { 446 NORMAL_FRAME, 447 iq2000_frame_this_id, 448 iq2000_frame_prev_register 449}; 450 451static const struct frame_unwind * 452iq2000_frame_sniffer (struct frame_info *next_frame) 453{ 454 return &iq2000_frame_unwind; 455} 456 457static CORE_ADDR 458iq2000_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) 459{ 460 return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM); 461} 462 463static CORE_ADDR 464iq2000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) 465{ 466 return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM); 467} 468 469static struct frame_id 470iq2000_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 476static CORE_ADDR 477iq2000_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 484static 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 491static const unsigned char * 492iq2000_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 513static void 514iq2000_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 537static int 538iq2000_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 552static void 553iq2000_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 591static enum return_value_convention 592iq2000_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 608static struct type * 609iq2000_register_type (struct gdbarch *gdbarch, int regnum) 610{ 611 return builtin_type_int32; 612} 613 614static CORE_ADDR 615iq2000_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. */ 623static int 624iq2000_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 654static CORE_ADDR 655iq2000_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 812static struct gdbarch * 813iq2000_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 868void 869_initialize_iq2000_tdep (void) 870{ 871 register_gdbarch_init (bfd_arch_iq2000, iq2000_gdbarch_init); 872} 873