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