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