iq2000-tdep.c revision 1.5
10Sduke/* Target-dependent code for the IQ2000 architecture, for GDB, the GNU 217209Smsheppar Debugger. 30Sduke 40Sduke Copyright (C) 2000-2015 Free Software Foundation, Inc. 50Sduke 60Sduke Contributed by Red Hat. 70Sduke 80Sduke This file is part of GDB. 90Sduke 100Sduke This program is free software; you can redistribute it and/or modify 110Sduke it under the terms of the GNU General Public License as published by 120Sduke the Free Software Foundation; either version 3 of the License, or 130Sduke (at your option) any later version. 140Sduke 150Sduke This program is distributed in the hope that it will be useful, 160Sduke but WITHOUT ANY WARRANTY; without even the implied warranty of 170Sduke MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 180Sduke GNU General Public License for more details. 192362Sohair 202362Sohair You should have received a copy of the GNU General Public License 212362Sohair along with this program. If not, see <http://www.gnu.org/licenses/>. */ 220Sduke 230Sduke#include "defs.h" 240Sduke#include "frame.h" 250Sduke#include "frame-base.h" 260Sduke#include "frame-unwind.h" 270Sduke#include "dwarf2-frame.h" 280Sduke#include "gdbtypes.h" 290Sduke#include "value.h" 300Sduke#include "dis-asm.h" 310Sduke#include "arch-utils.h" 320Sduke#include "regcache.h" 330Sduke#include "osabi.h" 340Sduke#include "gdbcore.h" 350Sduke 360Sdukeenum gdb_regnum 370Sduke{ 380Sduke E_R0_REGNUM, E_R1_REGNUM, E_R2_REGNUM, E_R3_REGNUM, 390Sduke E_R4_REGNUM, E_R5_REGNUM, E_R6_REGNUM, E_R7_REGNUM, 400Sduke E_R8_REGNUM, E_R9_REGNUM, E_R10_REGNUM, E_R11_REGNUM, 410Sduke E_R12_REGNUM, E_R13_REGNUM, E_R14_REGNUM, E_R15_REGNUM, 420Sduke E_R16_REGNUM, E_R17_REGNUM, E_R18_REGNUM, E_R19_REGNUM, 4317209Smsheppar E_R20_REGNUM, E_R21_REGNUM, E_R22_REGNUM, E_R23_REGNUM, 4417209Smsheppar E_R24_REGNUM, E_R25_REGNUM, E_R26_REGNUM, E_R27_REGNUM, 4517209Smsheppar E_R28_REGNUM, E_R29_REGNUM, E_R30_REGNUM, E_R31_REGNUM, 4617209Smsheppar E_PC_REGNUM, 470Sduke E_LR_REGNUM = E_R31_REGNUM, /* Link register. */ 480Sduke E_SP_REGNUM = E_R29_REGNUM, /* Stack pointer. */ 490Sduke E_FP_REGNUM = E_R27_REGNUM, /* Frame pointer. */ 500Sduke E_FN_RETURN_REGNUM = E_R2_REGNUM, /* Function return value register. */ 510Sduke E_1ST_ARGREG = E_R4_REGNUM, /* 1st function arg register. */ 520Sduke E_LAST_ARGREG = E_R11_REGNUM, /* Last function arg register. */ 530Sduke E_NUM_REGS = E_PC_REGNUM + 1 540Sduke}; 550Sduke 560Sduke/* Use an invalid address value as 'not available' marker. */ 570Sdukeenum { REG_UNAVAIL = (CORE_ADDR) -1 }; 580Sduke 590Sdukestruct iq2000_frame_cache 600Sduke{ 610Sduke /* Base address. */ 620Sduke CORE_ADDR base; 630Sduke CORE_ADDR pc; 640Sduke LONGEST framesize; 650Sduke int using_fp; 660Sduke CORE_ADDR saved_sp; 670Sduke CORE_ADDR saved_regs [E_NUM_REGS]; 680Sduke}; 690Sduke 700Sduke/* Harvard methods: */ 710Sduke 720Sdukestatic CORE_ADDR 730Sdukeinsn_ptr_from_addr (CORE_ADDR addr) /* CORE_ADDR to target pointer. */ 741720Schegar{ 751720Schegar return addr & 0x7fffffffL; 760Sduke} 771703Sptisnovs 7817209Smshepparstatic CORE_ADDR 791720Schegarinsn_addr_from_ptr (CORE_ADDR ptr) /* target_pointer to CORE_ADDR. */ 801720Schegar{ 811720Schegar return (ptr & 0x7fffffffL) | 0x80000000L; 821720Schegar} 832612Schegar 842612Schegar/* Function: pointer_to_address 852612Schegar Convert a target pointer to an address in host (CORE_ADDR) format. */ 862612Schegar 871720Schegarstatic CORE_ADDR 881720Schegariq2000_pointer_to_address (struct gdbarch *gdbarch, 891720Schegar struct type * type, const gdb_byte * buf) 901720Schegar{ 911720Schegar enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 921720Schegar enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type)); 931720Schegar CORE_ADDR addr 941720Schegar = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order); 951720Schegar 961720Schegar if (target == TYPE_CODE_FUNC 971720Schegar || target == TYPE_CODE_METHOD 9817209Smsheppar || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type))) 9917209Smsheppar addr = insn_addr_from_ptr (addr); 1001720Schegar 1010Sduke return addr; 1021720Schegar} 1030Sduke 1040Sduke/* Function: address_to_pointer 1050Sduke Convert a host-format address (CORE_ADDR) into a target pointer. */ 1060Sduke 1071720Schegarstatic void 1080Sdukeiq2000_address_to_pointer (struct gdbarch *gdbarch, 1090Sduke struct type *type, gdb_byte *buf, CORE_ADDR addr) 1101720Schegar{ 1110Sduke enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1121720Schegar enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type)); 1130Sduke 1140Sduke if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD) 1151720Schegar addr = insn_ptr_from_addr (addr); 1161720Schegar store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr); 1171720Schegar} 1180Sduke 1191720Schegar/* Real register methods: */ 1201720Schegar 1211720Schegar/* Function: register_name 1221720Schegar Returns the name of the iq2000 register number N. */ 1231720Schegar 1241720Schegarstatic const char * 1251720Schegariq2000_register_name (struct gdbarch *gdbarch, int regnum) 1261720Schegar{ 1271720Schegar static const char * names[E_NUM_REGS] = 1281720Schegar { 1291720Schegar "r0", "r1", "r2", "r3", "r4", 1301720Schegar "r5", "r6", "r7", "r8", "r9", 1311720Schegar "r10", "r11", "r12", "r13", "r14", 1321720Schegar "r15", "r16", "r17", "r18", "r19", 1331720Schegar "r20", "r21", "r22", "r23", "r24", 1341720Schegar "r25", "r26", "r27", "r28", "r29", 1350Sduke "r30", "r31", 1360Sduke "pc" 1370Sduke }; 1380Sduke if (regnum < 0 || regnum >= E_NUM_REGS) 1390Sduke return NULL; 1400Sduke return names[regnum]; 1410Sduke} 1420Sduke 1431720Schegar/* Prologue analysis methods: */ 1441720Schegar 1451720Schegar/* ADDIU insn (001001 rs(5) rt(5) imm(16)). */ 1461720Schegar#define INSN_IS_ADDIU(X) (((X) & 0xfc000000) == 0x24000000) 1471720Schegar#define ADDIU_REG_SRC(X) (((X) & 0x03e00000) >> 21) 1481720Schegar#define ADDIU_REG_TGT(X) (((X) & 0x001f0000) >> 16) 1490Sduke#define ADDIU_IMMEDIATE(X) ((signed short) ((X) & 0x0000ffff)) 1501720Schegar 1511720Schegar/* "MOVE" (OR) insn (000000 rs(5) rt(5) rd(5) 00000 100101). */ 1521720Schegar#define INSN_IS_MOVE(X) (((X) & 0xffe007ff) == 0x00000025) 1531720Schegar#define MOVE_REG_SRC(X) (((X) & 0x001f0000) >> 16) 1541720Schegar#define MOVE_REG_TGT(X) (((X) & 0x0000f800) >> 11) 1551720Schegar 1561720Schegar/* STORE WORD insn (101011 rs(5) rt(5) offset(16)). */ 1571720Schegar#define INSN_IS_STORE_WORD(X) (((X) & 0xfc000000) == 0xac000000) 1581720Schegar#define SW_REG_INDEX(X) (((X) & 0x03e00000) >> 21) 1591720Schegar#define SW_REG_SRC(X) (((X) & 0x001f0000) >> 16) 1601720Schegar#define SW_OFFSET(X) ((signed short) ((X) & 0x0000ffff)) 1610Sduke 1621720Schegar/* Function: find_last_line_symbol 1631720Schegar 1641720Schegar Given an address range, first find a line symbol corresponding to 16512047Smsheppar the starting address. Then find the last line symbol within the 16612047Smsheppar range that has a line number less than or equal to the first line. 16712047Smsheppar 1681720Schegar For optimized code with code motion, this finds the last address 1691720Schegar for the lowest-numbered line within the address range. */ 1701720Schegar 17112047Smshepparstatic struct symtab_and_line 1721720Schegarfind_last_line_symbol (CORE_ADDR start, CORE_ADDR end, int notcurrent) 1731720Schegar{ 1741720Schegar struct symtab_and_line sal = find_pc_line (start, notcurrent); 1750Sduke struct symtab_and_line best_sal = sal; 1761720Schegar 1771720Schegar if (sal.pc == 0 || sal.line == 0 || sal.end == 0) 1780Sduke return sal; 17917209Smsheppar 18017209Smsheppar do 18117209Smsheppar { 18217209Smsheppar if (sal.line && sal.line <= best_sal.line) 18317209Smsheppar best_sal = sal; 18417209Smsheppar sal = find_pc_line (sal.end, notcurrent); 18517209Smsheppar } 18617209Smsheppar while (sal.pc && sal.pc < end); 18717209Smsheppar 1881720Schegar return best_sal; 1891720Schegar} 1901720Schegar 1911720Schegar/* Function: scan_prologue 1921720Schegar Decode the instructions within the given address range. 1930Sduke Decide when we must have reached the end of the function prologue. 1940Sduke If a frame_info pointer is provided, fill in its prologue information. 1950Sduke 1960Sduke Returns the address of the first instruction after the prologue. */ 1971720Schegar 1981720Schegarstatic CORE_ADDR 1990Sdukeiq2000_scan_prologue (struct gdbarch *gdbarch, 2000Sduke CORE_ADDR scan_start, 2011720Schegar CORE_ADDR scan_end, 2021720Schegar struct frame_info *fi, 2031720Schegar struct iq2000_frame_cache *cache) 2041720Schegar{ 2051720Schegar enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 2060Sduke struct symtab_and_line sal; 2070Sduke CORE_ADDR pc; 2080Sduke CORE_ADDR loop_end; 2090Sduke int found_store_lr = 0; 2100Sduke int found_decr_sp = 0; 2110Sduke int srcreg; 2121720Schegar int tgtreg; 2131720Schegar signed short offset; 2140Sduke 2150Sduke if (scan_end == (CORE_ADDR) 0) 2161720Schegar { 2171720Schegar loop_end = scan_start + 100; 2181720Schegar sal.end = sal.pc = 0; 2190Sduke } 2200Sduke else 2211720Schegar { 2221720Schegar loop_end = scan_end; 2230Sduke if (fi) 2241720Schegar sal = find_last_line_symbol (scan_start, scan_end, 0); 2250Sduke else 2260Sduke sal.end = 0; /* Avoid GCC false warning. */ 2270Sduke } 2280Sduke 2290Sduke /* Saved registers: 2300Sduke We first have to save the saved register's offset, and 2311720Schegar only later do we compute its actual address. Since the 2321720Schegar offset can be zero, we must first initialize all the 2331720Schegar saved regs to minus one (so we can later distinguish 2341720Schegar between one that's not saved, and one that's saved at zero). */ 2351720Schegar for (srcreg = 0; srcreg < E_NUM_REGS; srcreg ++) 2361720Schegar cache->saved_regs[srcreg] = -1; 2371720Schegar cache->using_fp = 0; 2381720Schegar cache->framesize = 0; 2391720Schegar 2401720Schegar for (pc = scan_start; pc < loop_end; pc += 4) 2411720Schegar { 2421720Schegar LONGEST insn = read_memory_unsigned_integer (pc, 4, byte_order); 2431720Schegar /* Skip any instructions writing to (sp) or decrementing the 2441720Schegar SP. */ 2451720Schegar if ((insn & 0xffe00000) == 0xac200000) 2461720Schegar { 2471720Schegar /* sw using SP/%1 as base. */ 2481720Schegar /* LEGACY -- from assembly-only port. */ 2491720Schegar tgtreg = ((insn >> 16) & 0x1f); 2501720Schegar if (tgtreg >= 0 && tgtreg < E_NUM_REGS) 2511720Schegar cache->saved_regs[tgtreg] = -((signed short) (insn & 0xffff)); 2521720Schegar 2531720Schegar if (tgtreg == E_LR_REGNUM) 2541720Schegar found_store_lr = 1; 2551720Schegar continue; 2561720Schegar } 2571720Schegar 2581720Schegar if ((insn & 0xffff8000) == 0x20218000) 2591720Schegar { 2601720Schegar /* addi %1, %1, -N == addi %sp, %sp, -N */ 2611720Schegar /* LEGACY -- from assembly-only port. */ 2621720Schegar found_decr_sp = 1; 2631720Schegar cache->framesize = -((signed short) (insn & 0xffff)); 2641720Schegar continue; 2651720Schegar } 2661720Schegar 2671720Schegar if (INSN_IS_ADDIU (insn)) 2681720Schegar { 2691720Schegar srcreg = ADDIU_REG_SRC (insn); 2701720Schegar tgtreg = ADDIU_REG_TGT (insn); 2711720Schegar offset = ADDIU_IMMEDIATE (insn); 2721720Schegar if (srcreg == E_SP_REGNUM && tgtreg == E_SP_REGNUM) 2731720Schegar cache->framesize = -offset; 2741720Schegar continue; 2751720Schegar } 2761720Schegar 2771720Schegar if (INSN_IS_STORE_WORD (insn)) 2781720Schegar { 2791720Schegar srcreg = SW_REG_SRC (insn); 2801720Schegar tgtreg = SW_REG_INDEX (insn); 2811720Schegar offset = SW_OFFSET (insn); 2821720Schegar 2831720Schegar if (tgtreg == E_SP_REGNUM || tgtreg == E_FP_REGNUM) 2841720Schegar { 285 /* "push" to stack (via SP or FP reg). */ 286 if (cache->saved_regs[srcreg] == -1) /* Don't save twice. */ 287 cache->saved_regs[srcreg] = offset; 288 continue; 289 } 290 } 291 292 if (INSN_IS_MOVE (insn)) 293 { 294 srcreg = MOVE_REG_SRC (insn); 295 tgtreg = MOVE_REG_TGT (insn); 296 297 if (srcreg == E_SP_REGNUM && tgtreg == E_FP_REGNUM) 298 { 299 /* Copy sp to fp. */ 300 cache->using_fp = 1; 301 continue; 302 } 303 } 304 305 /* Unknown instruction encountered in frame. Bail out? 306 1) If we have a subsequent line symbol, we can keep going. 307 2) If not, we need to bail out and quit scanning instructions. */ 308 309 if (fi && sal.end && (pc < sal.end)) /* Keep scanning. */ 310 continue; 311 else /* bail */ 312 break; 313 } 314 315 return pc; 316} 317 318static void 319iq2000_init_frame_cache (struct iq2000_frame_cache *cache) 320{ 321 int i; 322 323 cache->base = 0; 324 cache->framesize = 0; 325 cache->using_fp = 0; 326 cache->saved_sp = 0; 327 for (i = 0; i < E_NUM_REGS; i++) 328 cache->saved_regs[i] = -1; 329} 330 331/* Function: iq2000_skip_prologue 332 If the input address is in a function prologue, 333 returns the address of the end of the prologue; 334 else returns the input address. 335 336 Note: the input address is likely to be the function start, 337 since this function is mainly used for advancing a breakpoint 338 to the first line, or stepping to the first line when we have 339 stepped into a function call. */ 340 341static CORE_ADDR 342iq2000_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) 343{ 344 CORE_ADDR func_addr = 0 , func_end = 0; 345 346 if (find_pc_partial_function (pc, NULL, & func_addr, & func_end)) 347 { 348 struct symtab_and_line sal; 349 struct iq2000_frame_cache cache; 350 351 /* Found a function. */ 352 sal = find_pc_line (func_addr, 0); 353 if (sal.end && sal.end < func_end) 354 /* Found a line number, use it as end of prologue. */ 355 return sal.end; 356 357 /* No useable line symbol. Use prologue parsing method. */ 358 iq2000_init_frame_cache (&cache); 359 return iq2000_scan_prologue (gdbarch, func_addr, func_end, NULL, &cache); 360 } 361 362 /* No function symbol -- just return the PC. */ 363 return (CORE_ADDR) pc; 364} 365 366static struct iq2000_frame_cache * 367iq2000_frame_cache (struct frame_info *this_frame, void **this_cache) 368{ 369 struct gdbarch *gdbarch = get_frame_arch (this_frame); 370 struct iq2000_frame_cache *cache; 371 CORE_ADDR current_pc; 372 int i; 373 374 if (*this_cache) 375 return *this_cache; 376 377 cache = FRAME_OBSTACK_ZALLOC (struct iq2000_frame_cache); 378 iq2000_init_frame_cache (cache); 379 *this_cache = cache; 380 381 cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM); 382 383 current_pc = get_frame_pc (this_frame); 384 find_pc_partial_function (current_pc, NULL, &cache->pc, NULL); 385 if (cache->pc != 0) 386 iq2000_scan_prologue (gdbarch, cache->pc, current_pc, this_frame, cache); 387 if (!cache->using_fp) 388 cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM); 389 390 cache->saved_sp = cache->base + cache->framesize; 391 392 for (i = 0; i < E_NUM_REGS; i++) 393 if (cache->saved_regs[i] != -1) 394 cache->saved_regs[i] += cache->base; 395 396 return cache; 397} 398 399static struct value * 400iq2000_frame_prev_register (struct frame_info *this_frame, void **this_cache, 401 int regnum) 402{ 403 struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame, 404 this_cache); 405 406 if (regnum == E_SP_REGNUM && cache->saved_sp) 407 return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp); 408 409 if (regnum == E_PC_REGNUM) 410 regnum = E_LR_REGNUM; 411 412 if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != -1) 413 return frame_unwind_got_memory (this_frame, regnum, 414 cache->saved_regs[regnum]); 415 416 return frame_unwind_got_register (this_frame, regnum, regnum); 417} 418 419static void 420iq2000_frame_this_id (struct frame_info *this_frame, void **this_cache, 421 struct frame_id *this_id) 422{ 423 struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame, 424 this_cache); 425 426 /* This marks the outermost frame. */ 427 if (cache->base == 0) 428 return; 429 430 *this_id = frame_id_build (cache->saved_sp, cache->pc); 431} 432 433static const struct frame_unwind iq2000_frame_unwind = { 434 NORMAL_FRAME, 435 default_frame_unwind_stop_reason, 436 iq2000_frame_this_id, 437 iq2000_frame_prev_register, 438 NULL, 439 default_frame_sniffer 440}; 441 442static CORE_ADDR 443iq2000_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) 444{ 445 return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM); 446} 447 448static CORE_ADDR 449iq2000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) 450{ 451 return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM); 452} 453 454static struct frame_id 455iq2000_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) 456{ 457 CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM); 458 return frame_id_build (sp, get_frame_pc (this_frame)); 459} 460 461static CORE_ADDR 462iq2000_frame_base_address (struct frame_info *this_frame, void **this_cache) 463{ 464 struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame, 465 this_cache); 466 467 return cache->base; 468} 469 470static const struct frame_base iq2000_frame_base = { 471 &iq2000_frame_unwind, 472 iq2000_frame_base_address, 473 iq2000_frame_base_address, 474 iq2000_frame_base_address 475}; 476 477static const unsigned char * 478iq2000_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, 479 int *lenptr) 480{ 481 static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d }; 482 static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 }; 483 484 if ((*pcptr & 3) != 0) 485 error (_("breakpoint_from_pc: invalid breakpoint address 0x%lx"), 486 (long) *pcptr); 487 488 *lenptr = 4; 489 return (gdbarch_byte_order (gdbarch) 490 == BFD_ENDIAN_BIG) ? big_breakpoint : little_breakpoint; 491} 492 493/* Target function return value methods: */ 494 495/* Function: store_return_value 496 Copy the function return value from VALBUF into the 497 proper location for a function return. */ 498 499static void 500iq2000_store_return_value (struct type *type, struct regcache *regcache, 501 const void *valbuf) 502{ 503 int len = TYPE_LENGTH (type); 504 int regno = E_FN_RETURN_REGNUM; 505 506 while (len > 0) 507 { 508 gdb_byte buf[4]; 509 int size = len % 4 ?: 4; 510 511 memset (buf, 0, 4); 512 memcpy (buf + 4 - size, valbuf, size); 513 regcache_raw_write (regcache, regno++, buf); 514 len -= size; 515 valbuf = ((char *) valbuf) + size; 516 } 517} 518 519/* Function: use_struct_convention 520 Returns non-zero if the given struct type will be returned using 521 a special convention, rather than the normal function return method. */ 522 523static int 524iq2000_use_struct_convention (struct type *type) 525{ 526 return ((TYPE_CODE (type) == TYPE_CODE_STRUCT) 527 || (TYPE_CODE (type) == TYPE_CODE_UNION)) 528 && TYPE_LENGTH (type) > 8; 529} 530 531/* Function: extract_return_value 532 Copy the function's return value into VALBUF. 533 This function is called only in the context of "target function calls", 534 ie. when the debugger forces a function to be called in the child, and 535 when the debugger forces a function to return prematurely via the 536 "return" command. */ 537 538static void 539iq2000_extract_return_value (struct type *type, struct regcache *regcache, 540 void *valbuf) 541{ 542 struct gdbarch *gdbarch = get_regcache_arch (regcache); 543 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 544 545 /* If the function's return value is 8 bytes or less, it is 546 returned in a register, and if larger than 8 bytes, it is 547 returned in a stack location which is pointed to by the same 548 register. */ 549 int len = TYPE_LENGTH (type); 550 551 if (len <= (2 * 4)) 552 { 553 int regno = E_FN_RETURN_REGNUM; 554 555 /* Return values of <= 8 bytes are returned in 556 FN_RETURN_REGNUM. */ 557 while (len > 0) 558 { 559 ULONGEST tmp; 560 int size = len % 4 ?: 4; 561 562 /* By using store_unsigned_integer we avoid having to 563 do anything special for small big-endian values. */ 564 regcache_cooked_read_unsigned (regcache, regno++, &tmp); 565 store_unsigned_integer (valbuf, size, byte_order, tmp); 566 len -= size; 567 valbuf = ((char *) valbuf) + size; 568 } 569 } 570 else 571 { 572 /* Return values > 8 bytes are returned in memory, 573 pointed to by FN_RETURN_REGNUM. */ 574 ULONGEST return_buffer; 575 regcache_cooked_read_unsigned (regcache, E_FN_RETURN_REGNUM, 576 &return_buffer); 577 read_memory (return_buffer, valbuf, TYPE_LENGTH (type)); 578 } 579} 580 581static enum return_value_convention 582iq2000_return_value (struct gdbarch *gdbarch, struct value *function, 583 struct type *type, struct regcache *regcache, 584 gdb_byte *readbuf, const gdb_byte *writebuf) 585{ 586 if (iq2000_use_struct_convention (type)) 587 return RETURN_VALUE_STRUCT_CONVENTION; 588 if (writebuf) 589 iq2000_store_return_value (type, regcache, writebuf); 590 else if (readbuf) 591 iq2000_extract_return_value (type, regcache, readbuf); 592 return RETURN_VALUE_REGISTER_CONVENTION; 593} 594 595/* Function: register_virtual_type 596 Returns the default type for register N. */ 597 598static struct type * 599iq2000_register_type (struct gdbarch *gdbarch, int regnum) 600{ 601 return builtin_type (gdbarch)->builtin_int32; 602} 603 604static CORE_ADDR 605iq2000_frame_align (struct gdbarch *ignore, CORE_ADDR sp) 606{ 607 /* This is the same frame alignment used by gcc. */ 608 return ((sp + 7) & ~7); 609} 610 611/* Convenience function to check 8-byte types for being a scalar type 612 or a struct with only one long long or double member. */ 613static int 614iq2000_pass_8bytetype_by_address (struct type *type) 615{ 616 struct type *ftype; 617 618 /* Skip typedefs. */ 619 while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) 620 type = TYPE_TARGET_TYPE (type); 621 /* Non-struct and non-union types are always passed by value. */ 622 if (TYPE_CODE (type) != TYPE_CODE_STRUCT 623 && TYPE_CODE (type) != TYPE_CODE_UNION) 624 return 0; 625 /* Structs with more than 1 field are always passed by address. */ 626 if (TYPE_NFIELDS (type) != 1) 627 return 1; 628 /* Get field type. */ 629 ftype = (TYPE_FIELDS (type))[0].type; 630 /* The field type must have size 8, otherwise pass by address. */ 631 if (TYPE_LENGTH (ftype) != 8) 632 return 1; 633 /* Skip typedefs of field type. */ 634 while (TYPE_CODE (ftype) == TYPE_CODE_TYPEDEF) 635 ftype = TYPE_TARGET_TYPE (ftype); 636 /* If field is int or float, pass by value. */ 637 if (TYPE_CODE (ftype) == TYPE_CODE_FLT 638 || TYPE_CODE (ftype) == TYPE_CODE_INT) 639 return 0; 640 /* Everything else, pass by address. */ 641 return 1; 642} 643 644static CORE_ADDR 645iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function, 646 struct regcache *regcache, CORE_ADDR bp_addr, 647 int nargs, struct value **args, CORE_ADDR sp, 648 int struct_return, CORE_ADDR struct_addr) 649{ 650 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 651 const bfd_byte *val; 652 bfd_byte buf[4]; 653 struct type *type; 654 int i, argreg, typelen, slacklen; 655 int stackspace = 0; 656 /* Used to copy struct arguments into the stack. */ 657 CORE_ADDR struct_ptr; 658 659 /* First determine how much stack space we will need. */ 660 for (i = 0, argreg = E_1ST_ARGREG + (struct_return != 0); i < nargs; i++) 661 { 662 type = value_type (args[i]); 663 typelen = TYPE_LENGTH (type); 664 if (typelen <= 4) 665 { 666 /* Scalars of up to 4 bytes, 667 structs of up to 4 bytes, and 668 pointers. */ 669 if (argreg <= E_LAST_ARGREG) 670 argreg++; 671 else 672 stackspace += 4; 673 } 674 else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type)) 675 { 676 /* long long, 677 double, and possibly 678 structs with a single field of long long or double. */ 679 if (argreg <= E_LAST_ARGREG - 1) 680 { 681 /* 8-byte arg goes into a register pair 682 (must start with an even-numbered reg). */ 683 if (((argreg - E_1ST_ARGREG) % 2) != 0) 684 argreg ++; 685 argreg += 2; 686 } 687 else 688 { 689 argreg = E_LAST_ARGREG + 1; /* no more argregs. */ 690 /* 8-byte arg goes on stack, must be 8-byte aligned. */ 691 stackspace = ((stackspace + 7) & ~7); 692 stackspace += 8; 693 } 694 } 695 else 696 { 697 /* Structs are passed as pointer to a copy of the struct. 698 So we need room on the stack for a copy of the struct 699 plus for the argument pointer. */ 700 if (argreg <= E_LAST_ARGREG) 701 argreg++; 702 else 703 stackspace += 4; 704 /* Care for 8-byte alignment of structs saved on stack. */ 705 stackspace += ((typelen + 7) & ~7); 706 } 707 } 708 709 /* Now copy params, in ascending order, into their assigned location 710 (either in a register or on the stack). */ 711 712 sp -= (sp % 8); /* align */ 713 struct_ptr = sp; 714 sp -= stackspace; 715 sp -= (sp % 8); /* align again */ 716 stackspace = 0; 717 718 argreg = E_1ST_ARGREG; 719 if (struct_return) 720 { 721 /* A function that returns a struct will consume one argreg to do so. 722 */ 723 regcache_cooked_write_unsigned (regcache, argreg++, struct_addr); 724 } 725 726 for (i = 0; i < nargs; i++) 727 { 728 type = value_type (args[i]); 729 typelen = TYPE_LENGTH (type); 730 val = value_contents (args[i]); 731 if (typelen <= 4) 732 { 733 /* Char, short, int, float, pointer, and structs <= four bytes. */ 734 slacklen = (4 - (typelen % 4)) % 4; 735 memset (buf, 0, sizeof (buf)); 736 memcpy (buf + slacklen, val, typelen); 737 if (argreg <= E_LAST_ARGREG) 738 { 739 /* Passed in a register. */ 740 regcache_raw_write (regcache, argreg++, buf); 741 } 742 else 743 { 744 /* Passed on the stack. */ 745 write_memory (sp + stackspace, buf, 4); 746 stackspace += 4; 747 } 748 } 749 else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type)) 750 { 751 /* (long long), (double), or struct consisting of 752 a single (long long) or (double). */ 753 if (argreg <= E_LAST_ARGREG - 1) 754 { 755 /* 8-byte arg goes into a register pair 756 (must start with an even-numbered reg). */ 757 if (((argreg - E_1ST_ARGREG) % 2) != 0) 758 argreg++; 759 regcache_raw_write (regcache, argreg++, val); 760 regcache_raw_write (regcache, argreg++, val + 4); 761 } 762 else 763 { 764 /* 8-byte arg goes on stack, must be 8-byte aligned. */ 765 argreg = E_LAST_ARGREG + 1; /* no more argregs. */ 766 stackspace = ((stackspace + 7) & ~7); 767 write_memory (sp + stackspace, val, typelen); 768 stackspace += 8; 769 } 770 } 771 else 772 { 773 /* Store struct beginning at the upper end of the previously 774 computed stack space. Then store the address of the struct 775 using the usual rules for a 4 byte value. */ 776 struct_ptr -= ((typelen + 7) & ~7); 777 write_memory (struct_ptr, val, typelen); 778 if (argreg <= E_LAST_ARGREG) 779 regcache_cooked_write_unsigned (regcache, argreg++, struct_ptr); 780 else 781 { 782 store_unsigned_integer (buf, 4, byte_order, struct_ptr); 783 write_memory (sp + stackspace, buf, 4); 784 stackspace += 4; 785 } 786 } 787 } 788 789 /* Store return address. */ 790 regcache_cooked_write_unsigned (regcache, E_LR_REGNUM, bp_addr); 791 792 /* Update stack pointer. */ 793 regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp); 794 795 /* And that should do it. Return the new stack pointer. */ 796 return sp; 797} 798 799/* Function: gdbarch_init 800 Initializer function for the iq2000 gdbarch vector. 801 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */ 802 803static struct gdbarch * 804iq2000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 805{ 806 struct gdbarch *gdbarch; 807 808 /* Look up list for candidates - only one. */ 809 arches = gdbarch_list_lookup_by_info (arches, &info); 810 if (arches != NULL) 811 return arches->gdbarch; 812 813 gdbarch = gdbarch_alloc (&info, NULL); 814 815 set_gdbarch_num_regs (gdbarch, E_NUM_REGS); 816 set_gdbarch_num_pseudo_regs (gdbarch, 0); 817 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM); 818 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM); 819 set_gdbarch_register_name (gdbarch, iq2000_register_name); 820 set_gdbarch_address_to_pointer (gdbarch, iq2000_address_to_pointer); 821 set_gdbarch_pointer_to_address (gdbarch, iq2000_pointer_to_address); 822 set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT); 823 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT); 824 set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT); 825 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT); 826 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT); 827 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT); 828 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT); 829 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT); 830 set_gdbarch_float_format (gdbarch, floatformats_ieee_single); 831 set_gdbarch_double_format (gdbarch, floatformats_ieee_double); 832 set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double); 833 set_gdbarch_return_value (gdbarch, iq2000_return_value); 834 set_gdbarch_breakpoint_from_pc (gdbarch, iq2000_breakpoint_from_pc); 835 set_gdbarch_frame_args_skip (gdbarch, 0); 836 set_gdbarch_skip_prologue (gdbarch, iq2000_skip_prologue); 837 set_gdbarch_inner_than (gdbarch, core_addr_lessthan); 838 set_gdbarch_print_insn (gdbarch, print_insn_iq2000); 839 set_gdbarch_register_type (gdbarch, iq2000_register_type); 840 set_gdbarch_frame_align (gdbarch, iq2000_frame_align); 841 set_gdbarch_unwind_sp (gdbarch, iq2000_unwind_sp); 842 set_gdbarch_unwind_pc (gdbarch, iq2000_unwind_pc); 843 set_gdbarch_dummy_id (gdbarch, iq2000_dummy_id); 844 frame_base_set_default (gdbarch, &iq2000_frame_base); 845 set_gdbarch_push_dummy_call (gdbarch, iq2000_push_dummy_call); 846 847 gdbarch_init_osabi (info, gdbarch); 848 849 dwarf2_append_unwinders (gdbarch); 850 frame_unwind_append_unwinder (gdbarch, &iq2000_frame_unwind); 851 852 return gdbarch; 853} 854 855/* Function: _initialize_iq2000_tdep 856 Initializer function for the iq2000 module. 857 Called by gdb at start-up. */ 858 859/* Provide a prototype to silence -Wmissing-prototypes. */ 860extern initialize_file_ftype _initialize_iq2000_tdep; 861 862void 863_initialize_iq2000_tdep (void) 864{ 865 register_gdbarch_init (bfd_arch_iq2000, iq2000_gdbarch_init); 866} 867