1/* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor. 2 3 Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 59 Temple Place - Suite 330, 20 Boston, MA 02111-1307, USA. */ 21 22#include "defs.h" 23#include "frame.h" 24#include "frame-base.h" 25#include "frame-unwind.h" 26#include "dwarf2-frame.h" 27#include "symtab.h" 28#include "gdbtypes.h" 29#include "gdbcmd.h" 30#include "gdbcore.h" 31#include "value.h" 32#include "dis-asm.h" 33#include "inferior.h" 34#include "gdb_string.h" 35#include "gdb_assert.h" 36#include "arch-utils.h" 37#include "floatformat.h" 38#include "regcache.h" 39#include "doublest.h" 40#include "osabi.h" 41#include "objfiles.h" 42 43enum gdb_regnum 44{ 45 /* Xstormy16 has 16 general purpose registers (R0-R15) plus PC. 46 Functions will return their values in register R2-R7 as they fit. 47 Otherwise a hidden pointer to an big enough area is given as argument 48 to the function in r2. Further arguments are beginning in r3 then. 49 R13 is used as frame pointer when GCC compiles w/o optimization 50 R14 is used as "PSW", displaying the CPU status. 51 R15 is used implicitely as stack pointer. */ 52 E_R0_REGNUM, 53 E_R1_REGNUM, 54 E_R2_REGNUM, E_1ST_ARG_REGNUM = E_R2_REGNUM, E_PTR_RET_REGNUM = E_R2_REGNUM, 55 E_R3_REGNUM, 56 E_R4_REGNUM, 57 E_R5_REGNUM, 58 E_R6_REGNUM, 59 E_R7_REGNUM, E_LST_ARG_REGNUM = E_R7_REGNUM, 60 E_R8_REGNUM, 61 E_R9_REGNUM, 62 E_R10_REGNUM, 63 E_R11_REGNUM, 64 E_R12_REGNUM, 65 E_R13_REGNUM, E_FP_REGNUM = E_R13_REGNUM, 66 E_R14_REGNUM, E_PSW_REGNUM = E_R14_REGNUM, 67 E_R15_REGNUM, E_SP_REGNUM = E_R15_REGNUM, 68 E_PC_REGNUM, 69 E_NUM_REGS 70}; 71 72/* Use an invalid address value as 'not available' marker. */ 73enum { REG_UNAVAIL = (CORE_ADDR) -1 }; 74 75struct xstormy16_frame_cache 76{ 77 /* Base address. */ 78 CORE_ADDR base; 79 CORE_ADDR pc; 80 LONGEST framesize; 81 int uses_fp; 82 CORE_ADDR saved_regs[E_NUM_REGS]; 83 CORE_ADDR saved_sp; 84}; 85 86/* Size of instructions, registers, etc. */ 87enum 88{ 89 xstormy16_inst_size = 2, 90 xstormy16_reg_size = 2, 91 xstormy16_pc_size = 4 92}; 93 94/* Size of return datatype which fits into the remaining return registers. */ 95#define E_MAX_RETTYPE_SIZE(regnum) ((E_LST_ARG_REGNUM - (regnum) + 1) \ 96 * xstormy16_reg_size) 97 98/* Size of return datatype which fits into all return registers. */ 99enum 100{ 101 E_MAX_RETTYPE_SIZE_IN_REGS = E_MAX_RETTYPE_SIZE (E_R2_REGNUM) 102}; 103 104/* Function: xstormy16_register_name 105 Returns the name of the standard Xstormy16 register N. */ 106 107static const char * 108xstormy16_register_name (int regnum) 109{ 110 static char *register_names[] = { 111 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 112 "r8", "r9", "r10", "r11", "r12", "r13", 113 "psw", "sp", "pc" 114 }; 115 116 if (regnum < 0 || regnum >= E_NUM_REGS) 117 internal_error (__FILE__, __LINE__, 118 "xstormy16_register_name: illegal register number %d", 119 regnum); 120 else 121 return register_names[regnum]; 122 123} 124 125static struct type * 126xstormy16_register_type (struct gdbarch *gdbarch, int regnum) 127{ 128 if (regnum == E_PC_REGNUM) 129 return builtin_type_uint32; 130 else 131 return builtin_type_uint16; 132} 133 134/* Function: xstormy16_type_is_scalar 135 Makes the decision if a given type is a scalar types. Scalar 136 types are returned in the registers r2-r7 as they fit. */ 137 138static int 139xstormy16_type_is_scalar (struct type *t) 140{ 141 return (TYPE_CODE(t) != TYPE_CODE_STRUCT 142 && TYPE_CODE(t) != TYPE_CODE_UNION 143 && TYPE_CODE(t) != TYPE_CODE_ARRAY); 144} 145 146/* Function: xstormy16_use_struct_convention 147 Returns non-zero if the given struct type will be returned using 148 a special convention, rather than the normal function return method. 149 7sed in the contexts of the "return" command, and of 150 target function calls from the debugger. */ 151 152static int 153xstormy16_use_struct_convention (struct type *type) 154{ 155 return !xstormy16_type_is_scalar (type) 156 || TYPE_LENGTH (type) > E_MAX_RETTYPE_SIZE_IN_REGS; 157} 158 159/* Function: xstormy16_extract_return_value 160 Find a function's return value in the appropriate registers (in 161 regbuf), and copy it into valbuf. */ 162 163static void 164xstormy16_extract_return_value (struct type *type, struct regcache *regcache, 165 void *valbuf) 166{ 167 int len = TYPE_LENGTH (type); 168 int i, regnum = E_1ST_ARG_REGNUM; 169 170 for (i = 0; i < len; i += xstormy16_reg_size) 171 regcache_raw_read (regcache, regnum++, (char *) valbuf + i); 172} 173 174/* Function: xstormy16_store_return_value 175 Copy the function return value from VALBUF into the 176 proper location for a function return. 177 Called only in the context of the "return" command. */ 178 179static void 180xstormy16_store_return_value (struct type *type, struct regcache *regcache, 181 const void *valbuf) 182{ 183 if (TYPE_LENGTH (type) == 1) 184 { 185 /* Add leading zeros to the value. */ 186 char buf[xstormy16_reg_size]; 187 memset (buf, 0, xstormy16_reg_size); 188 memcpy (buf, valbuf, 1); 189 regcache_raw_write (regcache, E_1ST_ARG_REGNUM, buf); 190 } 191 else 192 { 193 int len = TYPE_LENGTH (type); 194 int i, regnum = E_1ST_ARG_REGNUM; 195 196 for (i = 0; i < len; i += xstormy16_reg_size) 197 regcache_raw_write (regcache, regnum++, (char *) valbuf + i); 198 } 199} 200 201static enum return_value_convention 202xstormy16_return_value (struct gdbarch *gdbarch, struct type *type, 203 struct regcache *regcache, 204 void *readbuf, const void *writebuf) 205{ 206 if (xstormy16_use_struct_convention (type)) 207 return RETURN_VALUE_STRUCT_CONVENTION; 208 if (writebuf) 209 xstormy16_store_return_value (type, regcache, writebuf); 210 else if (readbuf) 211 xstormy16_extract_return_value (type, regcache, readbuf); 212 return RETURN_VALUE_REGISTER_CONVENTION; 213} 214 215static CORE_ADDR 216xstormy16_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr) 217{ 218 if (addr & 1) 219 ++addr; 220 return addr; 221} 222 223/* Function: xstormy16_push_dummy_call 224 Setup the function arguments for GDB to call a function in the inferior. 225 Called only in the context of a target function call from the debugger. 226 Returns the value of the SP register after the args are pushed. */ 227 228static CORE_ADDR 229xstormy16_push_dummy_call (struct gdbarch *gdbarch, 230 struct value *function, 231 struct regcache *regcache, 232 CORE_ADDR bp_addr, int nargs, 233 struct value **args, 234 CORE_ADDR sp, int struct_return, 235 CORE_ADDR struct_addr) 236{ 237 CORE_ADDR stack_dest = sp; 238 int argreg = E_1ST_ARG_REGNUM; 239 int i, j; 240 int typelen, slacklen; 241 char *val; 242 char buf[xstormy16_pc_size]; 243 244 /* If struct_return is true, then the struct return address will 245 consume one argument-passing register. */ 246 if (struct_return) 247 { 248 regcache_cooked_write_unsigned (regcache, E_PTR_RET_REGNUM, struct_addr); 249 argreg++; 250 } 251 252 /* Arguments are passed in R2-R7 as they fit. If an argument doesn't 253 fit in the remaining registers we're switching over to the stack. 254 No argument is put on stack partially and as soon as we switched 255 over to stack no further argument is put in a register even if it 256 would fit in the remaining unused registers. */ 257 for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++) 258 { 259 typelen = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i])); 260 if (typelen > E_MAX_RETTYPE_SIZE (argreg)) 261 break; 262 263 /* Put argument into registers wordwise. */ 264 val = VALUE_CONTENTS (args[i]); 265 for (j = 0; j < typelen; j += xstormy16_reg_size) 266 regcache_cooked_write_unsigned (regcache, argreg++, 267 extract_unsigned_integer (val + j, 268 typelen - j == 269 1 ? 1 : 270 xstormy16_reg_size)); 271 } 272 273 /* Align SP */ 274 stack_dest = xstormy16_frame_align (gdbarch, stack_dest); 275 276 /* Loop backwards through remaining arguments and push them on the stack, 277 wordaligned. */ 278 for (j = nargs - 1; j >= i; j--) 279 { 280 typelen = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[j])); 281 slacklen = typelen & 1; 282 val = alloca (typelen + slacklen); 283 memcpy (val, VALUE_CONTENTS (args[j]), typelen); 284 memset (val + typelen, 0, slacklen); 285 286 /* Now write this data to the stack. The stack grows upwards. */ 287 write_memory (stack_dest, val, typelen + slacklen); 288 stack_dest += typelen + slacklen; 289 } 290 291 store_unsigned_integer (buf, xstormy16_pc_size, bp_addr); 292 write_memory (stack_dest, buf, xstormy16_pc_size); 293 stack_dest += xstormy16_pc_size; 294 295 /* Update stack pointer. */ 296 regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, stack_dest); 297 298 /* Return the new stack pointer minus the return address slot since 299 that's what DWARF2/GCC uses as the frame's CFA. */ 300 return stack_dest - xstormy16_pc_size; 301} 302 303/* Function: xstormy16_scan_prologue 304 Decode the instructions within the given address range. 305 Decide when we must have reached the end of the function prologue. 306 If a frame_info pointer is provided, fill in its saved_regs etc. 307 308 Returns the address of the first instruction after the prologue. */ 309 310static CORE_ADDR 311xstormy16_analyze_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr, 312 struct xstormy16_frame_cache *cache, 313 struct frame_info *next_frame) 314{ 315 CORE_ADDR next_addr; 316 ULONGEST inst, inst2; 317 LONGEST offset; 318 int regnum; 319 320 /* Initialize framesize with size of PC put on stack by CALLF inst. */ 321 cache->saved_regs[E_PC_REGNUM] = 0; 322 cache->framesize = xstormy16_pc_size; 323 324 if (start_addr >= end_addr) 325 return end_addr; 326 327 for (next_addr = start_addr; 328 next_addr < end_addr; next_addr += xstormy16_inst_size) 329 { 330 inst = read_memory_unsigned_integer (next_addr, xstormy16_inst_size); 331 inst2 = read_memory_unsigned_integer (next_addr + xstormy16_inst_size, 332 xstormy16_inst_size); 333 334 if (inst >= 0x0082 && inst <= 0x008d) /* push r2 .. push r13 */ 335 { 336 regnum = inst & 0x000f; 337 cache->saved_regs[regnum] = cache->framesize; 338 cache->framesize += xstormy16_reg_size; 339 } 340 341 /* optional stack allocation for args and local vars <= 4 byte */ 342 else if (inst == 0x301f || inst == 0x303f) /* inc r15, #0x1/#0x3 */ 343 { 344 cache->framesize += ((inst & 0x0030) >> 4) + 1; 345 } 346 347 /* optional stack allocation for args and local vars > 4 && < 16 byte */ 348 else if ((inst & 0xff0f) == 0x510f) /* 51Hf add r15, #0xH */ 349 { 350 cache->framesize += (inst & 0x00f0) >> 4; 351 } 352 353 /* optional stack allocation for args and local vars >= 16 byte */ 354 else if (inst == 0x314f && inst2 >= 0x0010) /* 314f HHHH add r15, #0xH */ 355 { 356 cache->framesize += inst2; 357 next_addr += xstormy16_inst_size; 358 } 359 360 else if (inst == 0x46fd) /* mov r13, r15 */ 361 { 362 cache->uses_fp = 1; 363 } 364 365 /* optional copying of args in r2-r7 to r10-r13 */ 366 /* Probably only in optimized case but legal action for prologue */ 367 else if ((inst & 0xff00) == 0x4600 /* 46SD mov rD, rS */ 368 && (inst & 0x00f0) >= 0x0020 && (inst & 0x00f0) <= 0x0070 369 && (inst & 0x000f) >= 0x00a0 && (inst & 0x000f) <= 0x000d) 370 ; 371 372 /* optional copying of args in r2-r7 to stack */ 373 /* 72DS HHHH mov.b (rD, 0xHHHH), r(S-8) (bit3 always 1, bit2-0 = reg) */ 374 /* 73DS HHHH mov.w (rD, 0xHHHH), r(S-8) */ 375 else if ((inst & 0xfed8) == 0x72d8 && (inst & 0x0007) >= 2) 376 { 377 regnum = inst & 0x0007; 378 /* Only 12 of 16 bits of the argument are used for the 379 signed offset. */ 380 offset = (LONGEST) (inst2 & 0x0fff); 381 if (offset & 0x0800) 382 offset -= 0x1000; 383 384 cache->saved_regs[regnum] = cache->framesize + offset; 385 next_addr += xstormy16_inst_size; 386 } 387 388 else /* Not a prologue instruction. */ 389 break; 390 } 391 392 return next_addr; 393} 394 395/* Function: xstormy16_skip_prologue 396 If the input address is in a function prologue, 397 returns the address of the end of the prologue; 398 else returns the input address. 399 400 Note: the input address is likely to be the function start, 401 since this function is mainly used for advancing a breakpoint 402 to the first line, or stepping to the first line when we have 403 stepped into a function call. */ 404 405static CORE_ADDR 406xstormy16_skip_prologue (CORE_ADDR pc) 407{ 408 CORE_ADDR func_addr = 0, func_end = 0; 409 char *func_name; 410 411 if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end)) 412 { 413 struct symtab_and_line sal; 414 struct symbol *sym; 415 struct xstormy16_frame_cache cache; 416 417 /* Don't trust line number debug info in frameless functions. */ 418 CORE_ADDR plg_end = xstormy16_analyze_prologue (func_addr, func_end, 419 &cache, NULL); 420 if (!cache.uses_fp) 421 return plg_end; 422 423 /* Found a function. */ 424 sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL, NULL); 425 /* Don't use line number debug info for assembly source files. */ 426 if (sym && SYMBOL_LANGUAGE (sym) != language_asm) 427 { 428 sal = find_pc_line (func_addr, 0); 429 if (sal.end && sal.end < func_end) 430 { 431 /* Found a line number, use it as end of prologue. */ 432 return sal.end; 433 } 434 } 435 /* No useable line symbol. Use result of prologue parsing method. */ 436 return plg_end; 437 } 438 439 /* No function symbol -- just return the PC. */ 440 441 return (CORE_ADDR) pc; 442} 443 444/* The epilogue is defined here as the area at the end of a function, 445 either on the `ret' instruction itself or after an instruction which 446 destroys the function's stack frame. */ 447static int 448xstormy16_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc) 449{ 450 CORE_ADDR func_addr = 0, func_end = 0; 451 452 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end)) 453 { 454 ULONGEST inst, inst2; 455 CORE_ADDR addr = func_end - xstormy16_inst_size; 456 457 /* The Xstormy16 epilogue is max. 14 bytes long. */ 458 if (pc < func_end - 7 * xstormy16_inst_size) 459 return 0; 460 461 /* Check if we're on a `ret' instruction. Otherwise it's 462 too dangerous to proceed. */ 463 inst = read_memory_unsigned_integer (addr, xstormy16_inst_size); 464 if (inst != 0x0003) 465 return 0; 466 467 while ((addr -= xstormy16_inst_size) >= func_addr) 468 { 469 inst = read_memory_unsigned_integer (addr, xstormy16_inst_size); 470 if (inst >= 0x009a && inst <= 0x009d) /* pop r10...r13 */ 471 continue; 472 if (inst == 0x305f || inst == 0x307f) /* dec r15, #0x1/#0x3 */ 473 break; 474 inst2 = read_memory_unsigned_integer (addr - xstormy16_inst_size, 475 xstormy16_inst_size); 476 if (inst2 == 0x314f && inst >= 0x8000) /* add r15, neg. value */ 477 { 478 addr -= xstormy16_inst_size; 479 break; 480 } 481 return 0; 482 } 483 if (pc > addr) 484 return 1; 485 } 486 return 0; 487} 488 489const static unsigned char * 490xstormy16_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr) 491{ 492 static unsigned char breakpoint[] = { 0x06, 0x0 }; 493 *lenptr = sizeof (breakpoint); 494 return breakpoint; 495} 496 497/* Given a pointer to a jump table entry, return the address 498 of the function it jumps to. Return 0 if not found. */ 499static CORE_ADDR 500xstormy16_resolve_jmp_table_entry (CORE_ADDR faddr) 501{ 502 struct obj_section *faddr_sect = find_pc_section (faddr); 503 504 if (faddr_sect) 505 { 506 LONGEST inst, inst2, addr; 507 char buf[2 * xstormy16_inst_size]; 508 509 /* Return faddr if it's not pointing into the jump table. */ 510 if (strcmp (faddr_sect->the_bfd_section->name, ".plt")) 511 return faddr; 512 513 if (!target_read_memory (faddr, buf, sizeof buf)) 514 { 515 inst = extract_unsigned_integer (buf, xstormy16_inst_size); 516 inst2 = extract_unsigned_integer (buf + xstormy16_inst_size, 517 xstormy16_inst_size); 518 addr = inst2 << 8 | (inst & 0xff); 519 return addr; 520 } 521 } 522 return 0; 523} 524 525/* Given a function's address, attempt to find (and return) the 526 address of the corresponding jump table entry. Return 0 if 527 not found. */ 528static CORE_ADDR 529xstormy16_find_jmp_table_entry (CORE_ADDR faddr) 530{ 531 struct obj_section *faddr_sect = find_pc_section (faddr); 532 533 if (faddr_sect) 534 { 535 struct obj_section *osect; 536 537 /* Return faddr if it's already a pointer to a jump table entry. */ 538 if (!strcmp (faddr_sect->the_bfd_section->name, ".plt")) 539 return faddr; 540 541 ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect) 542 { 543 if (!strcmp (osect->the_bfd_section->name, ".plt")) 544 break; 545 } 546 547 if (osect < faddr_sect->objfile->sections_end) 548 { 549 CORE_ADDR addr; 550 for (addr = osect->addr; 551 addr < osect->endaddr; addr += 2 * xstormy16_inst_size) 552 { 553 LONGEST inst, inst2, faddr2; 554 char buf[2 * xstormy16_inst_size]; 555 556 if (target_read_memory (addr, buf, sizeof buf)) 557 return 0; 558 inst = extract_unsigned_integer (buf, xstormy16_inst_size); 559 inst2 = extract_unsigned_integer (buf + xstormy16_inst_size, 560 xstormy16_inst_size); 561 faddr2 = inst2 << 8 | (inst & 0xff); 562 if (faddr == faddr2) 563 return addr; 564 } 565 } 566 } 567 return 0; 568} 569 570static CORE_ADDR 571xstormy16_skip_trampoline_code (CORE_ADDR pc) 572{ 573 CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (pc); 574 575 if (tmp && tmp != pc) 576 return tmp; 577 return 0; 578} 579 580static int 581xstormy16_in_solib_call_trampoline (CORE_ADDR pc, char *name) 582{ 583 return xstormy16_skip_trampoline_code (pc) != 0; 584} 585 586/* Function pointers are 16 bit. The address space is 24 bit, using 587 32 bit addresses. Pointers to functions on the XStormy16 are implemented 588 by using 16 bit pointers, which are either direct pointers in case the 589 function begins below 0x10000, or indirect pointers into a jump table. 590 The next two functions convert 16 bit pointers into 24 (32) bit addresses 591 and vice versa. */ 592 593static CORE_ADDR 594xstormy16_pointer_to_address (struct type *type, const void *buf) 595{ 596 enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type)); 597 CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type)); 598 599 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD) 600 { 601 CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (addr); 602 if (addr2) 603 addr = addr2; 604 } 605 606 return addr; 607} 608 609static void 610xstormy16_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr) 611{ 612 enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type)); 613 614 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD) 615 { 616 CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (addr); 617 if (addr2) 618 addr = addr2; 619 } 620 store_unsigned_integer (buf, TYPE_LENGTH (type), addr); 621} 622 623static struct xstormy16_frame_cache * 624xstormy16_alloc_frame_cache (void) 625{ 626 struct xstormy16_frame_cache *cache; 627 int i; 628 629 cache = FRAME_OBSTACK_ZALLOC (struct xstormy16_frame_cache); 630 631 cache->base = 0; 632 cache->saved_sp = 0; 633 cache->pc = 0; 634 cache->uses_fp = 0; 635 cache->framesize = 0; 636 for (i = 0; i < E_NUM_REGS; ++i) 637 cache->saved_regs[i] = REG_UNAVAIL; 638 639 return cache; 640} 641 642static struct xstormy16_frame_cache * 643xstormy16_frame_cache (struct frame_info *next_frame, void **this_cache) 644{ 645 struct xstormy16_frame_cache *cache; 646 CORE_ADDR current_pc; 647 int i; 648 649 if (*this_cache) 650 return *this_cache; 651 652 cache = xstormy16_alloc_frame_cache (); 653 *this_cache = cache; 654 655 cache->base = frame_unwind_register_unsigned (next_frame, E_FP_REGNUM); 656 if (cache->base == 0) 657 return cache; 658 659 cache->pc = frame_func_unwind (next_frame); 660 current_pc = frame_pc_unwind (next_frame); 661 if (cache->pc) 662 xstormy16_analyze_prologue (cache->pc, current_pc, cache, next_frame); 663 664 if (!cache->uses_fp) 665 cache->base = frame_unwind_register_unsigned (next_frame, E_SP_REGNUM); 666 667 cache->saved_sp = cache->base - cache->framesize; 668 669 for (i = 0; i < E_NUM_REGS; ++i) 670 if (cache->saved_regs[i] != REG_UNAVAIL) 671 cache->saved_regs[i] += cache->saved_sp; 672 673 return cache; 674} 675 676static void 677xstormy16_frame_prev_register (struct frame_info *next_frame, void **this_cache, 678 int regnum, int *optimizedp, 679 enum lval_type *lvalp, CORE_ADDR *addrp, 680 int *realnump, void *valuep) 681{ 682 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (next_frame, 683 this_cache); 684 gdb_assert (regnum >= 0); 685 686 if (regnum == E_SP_REGNUM && cache->saved_sp) 687 { 688 *optimizedp = 0; 689 *lvalp = not_lval; 690 *addrp = 0; 691 *realnump = -1; 692 if (valuep) 693 { 694 /* Store the value. */ 695 store_unsigned_integer (valuep, xstormy16_reg_size, cache->saved_sp); 696 } 697 return; 698 } 699 700 if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL) 701 { 702 *optimizedp = 0; 703 *lvalp = lval_memory; 704 *addrp = cache->saved_regs[regnum]; 705 *realnump = -1; 706 if (valuep) 707 { 708 /* Read the value in from memory. */ 709 read_memory (*addrp, valuep, 710 register_size (current_gdbarch, regnum)); 711 } 712 return; 713 } 714 715 frame_register_unwind (next_frame, regnum, 716 optimizedp, lvalp, addrp, realnump, valuep); 717} 718 719static void 720xstormy16_frame_this_id (struct frame_info *next_frame, void **this_cache, 721 struct frame_id *this_id) 722{ 723 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (next_frame, 724 this_cache); 725 726 /* This marks the outermost frame. */ 727 if (cache->base == 0) 728 return; 729 730 *this_id = frame_id_build (cache->saved_sp, cache->pc); 731} 732 733static CORE_ADDR 734xstormy16_frame_base_address (struct frame_info *next_frame, void **this_cache) 735{ 736 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (next_frame, 737 this_cache); 738 return cache->base; 739} 740 741static const struct frame_unwind xstormy16_frame_unwind = { 742 NORMAL_FRAME, 743 xstormy16_frame_this_id, 744 xstormy16_frame_prev_register 745}; 746 747static const struct frame_base xstormy16_frame_base = { 748 &xstormy16_frame_unwind, 749 xstormy16_frame_base_address, 750 xstormy16_frame_base_address, 751 xstormy16_frame_base_address 752}; 753 754static const struct frame_unwind * 755xstormy16_frame_sniffer (struct frame_info *next_frame) 756{ 757 return &xstormy16_frame_unwind; 758} 759 760static CORE_ADDR 761xstormy16_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) 762{ 763 return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM); 764} 765 766static CORE_ADDR 767xstormy16_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) 768{ 769 return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM); 770} 771 772static struct frame_id 773xstormy16_unwind_dummy_id (struct gdbarch *gdbarch, 774 struct frame_info *next_frame) 775{ 776 return frame_id_build (xstormy16_unwind_sp (gdbarch, next_frame), 777 frame_pc_unwind (next_frame)); 778} 779 780 781/* Function: xstormy16_gdbarch_init 782 Initializer function for the xstormy16 gdbarch vector. 783 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */ 784 785static struct gdbarch * 786xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 787{ 788 struct gdbarch *gdbarch; 789 790 /* find a candidate among the list of pre-declared architectures. */ 791 arches = gdbarch_list_lookup_by_info (arches, &info); 792 if (arches != NULL) 793 return (arches->gdbarch); 794 795 gdbarch = gdbarch_alloc (&info, NULL); 796 797 /* 798 * Basic register fields and methods, datatype sizes and stuff. 799 */ 800 801 set_gdbarch_num_regs (gdbarch, E_NUM_REGS); 802 set_gdbarch_num_pseudo_regs (gdbarch, 0); 803 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM); 804 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM); 805 set_gdbarch_register_name (gdbarch, xstormy16_register_name); 806 set_gdbarch_register_type (gdbarch, xstormy16_register_type); 807 808 set_gdbarch_char_signed (gdbarch, 0); 809 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT); 810 set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT); 811 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT); 812 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT); 813 814 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT); 815 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT); 816 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT); 817 818 set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT); 819 set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT); 820 821 set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer); 822 set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address); 823 824 set_gdbarch_write_pc (gdbarch, generic_target_write_pc); 825 826 /* Stack grows up. */ 827 set_gdbarch_inner_than (gdbarch, core_addr_greaterthan); 828 829 /* 830 * Frame Info 831 */ 832 set_gdbarch_unwind_sp (gdbarch, xstormy16_unwind_sp); 833 set_gdbarch_unwind_pc (gdbarch, xstormy16_unwind_pc); 834 set_gdbarch_unwind_dummy_id (gdbarch, xstormy16_unwind_dummy_id); 835 set_gdbarch_frame_align (gdbarch, xstormy16_frame_align); 836 frame_base_set_default (gdbarch, &xstormy16_frame_base); 837 838 set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue); 839 set_gdbarch_in_function_epilogue_p (gdbarch, 840 xstormy16_in_function_epilogue_p); 841 842 /* These values and methods are used when gdb calls a target function. */ 843 set_gdbarch_push_dummy_call (gdbarch, xstormy16_push_dummy_call); 844 set_gdbarch_breakpoint_from_pc (gdbarch, xstormy16_breakpoint_from_pc); 845 set_gdbarch_return_value (gdbarch, xstormy16_return_value); 846 847 set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code); 848 set_gdbarch_in_solib_call_trampoline (gdbarch, 849 xstormy16_in_solib_call_trampoline); 850 851 set_gdbarch_print_insn (gdbarch, print_insn_xstormy16); 852 853 gdbarch_init_osabi (info, gdbarch); 854 855 frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer); 856 frame_unwind_append_sniffer (gdbarch, xstormy16_frame_sniffer); 857 858 return gdbarch; 859} 860 861/* Function: _initialize_xstormy16_tdep 862 Initializer function for the Sanyo Xstormy16a module. 863 Called by gdb at start-up. */ 864 865extern initialize_file_ftype _initialize_xstormy16_tdep; /* -Wmissing-prototypes */ 866 867void 868_initialize_xstormy16_tdep (void) 869{ 870 register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init); 871} 872