1 /* Target-dependent code for the CSKY architecture, for GDB. 2 3 Copyright (C) 2010-2019 Free Software Foundation, Inc. 4 5 Contributed by C-SKY Microsystems and Mentor Graphics. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "common/gdb_assert.h" 24 #include "frame.h" 25 #include "inferior.h" 26 #include "symtab.h" 27 #include "value.h" 28 #include "gdbcmd.h" 29 #include "language.h" 30 #include "gdbcore.h" 31 #include "symfile.h" 32 #include "objfiles.h" 33 #include "gdbtypes.h" 34 #include "target.h" 35 #include "arch-utils.h" 36 #include "regcache.h" 37 #include "osabi.h" 38 #include "block.h" 39 #include "reggroups.h" 40 #include "elf/csky.h" 41 #include "elf-bfd.h" 42 #include "symcat.h" 43 #include "sim-regno.h" 44 #include "dis-asm.h" 45 #include "frame-unwind.h" 46 #include "frame-base.h" 47 #include "trad-frame.h" 48 #include "infcall.h" 49 #include "floatformat.h" 50 #include "remote.h" 51 #include "target-descriptions.h" 52 #include "dwarf2-frame.h" 53 #include "user-regs.h" 54 #include "valprint.h" 55 #include "csky-tdep.h" 56 #include "regset.h" 57 #include "opcode/csky.h" 58 #include <algorithm> 59 #include <vector> 60 61 /* Control debugging information emitted in this file. */ 62 static int csky_debug = 0; 63 64 static struct reggroup *cr_reggroup; 65 static struct reggroup *fr_reggroup; 66 static struct reggroup *vr_reggroup; 67 static struct reggroup *mmu_reggroup; 68 static struct reggroup *prof_reggroup; 69 70 /* Convenience function to print debug messages in prologue analysis. */ 71 72 static void 73 print_savedreg_msg (int regno, int offsets[], bool print_continuing) 74 { 75 fprintf_unfiltered (gdb_stdlog, "csky: r%d saved at offset 0x%x\n", 76 regno, offsets[regno]); 77 if (print_continuing) 78 fprintf_unfiltered (gdb_stdlog, "csky: continuing\n"); 79 } 80 81 /* Check whether the instruction at ADDR is 16-bit or not. */ 82 83 static int 84 csky_pc_is_csky16 (struct gdbarch *gdbarch, CORE_ADDR addr) 85 { 86 gdb_byte target_mem[2]; 87 int status; 88 unsigned int insn; 89 int ret = 1; 90 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 91 92 status = target_read_memory (addr, target_mem, 2); 93 /* Assume a 16-bit instruction if we can't read memory. */ 94 if (status) 95 return 1; 96 97 /* Get instruction from memory. */ 98 insn = extract_unsigned_integer (target_mem, 2, byte_order); 99 if ((insn & CSKY_32_INSN_MASK) == CSKY_32_INSN_MASK) 100 ret = 0; 101 else if (insn == CSKY_BKPT_INSN) 102 { 103 /* Check for 32-bit bkpt instruction which is all 0. */ 104 status = target_read_memory (addr + 2, target_mem, 2); 105 if (status) 106 return 1; 107 108 insn = extract_unsigned_integer (target_mem, 2, byte_order); 109 if (insn == CSKY_BKPT_INSN) 110 ret = 0; 111 } 112 return ret; 113 } 114 115 /* Get one instruction at ADDR and store it in INSN. Return 2 for 116 a 16-bit instruction or 4 for a 32-bit instruction. */ 117 118 static int 119 csky_get_insn (struct gdbarch *gdbarch, CORE_ADDR addr, unsigned int *insn) 120 { 121 gdb_byte target_mem[2]; 122 unsigned int insn_type; 123 int status; 124 int insn_len = 2; 125 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 126 127 status = target_read_memory (addr, target_mem, 2); 128 if (status) 129 memory_error (TARGET_XFER_E_IO, addr); 130 131 insn_type = extract_unsigned_integer (target_mem, 2, byte_order); 132 if (CSKY_32_INSN_MASK == (insn_type & CSKY_32_INSN_MASK)) 133 { 134 status = target_read_memory (addr + 2, target_mem, 2); 135 if (status) 136 memory_error (TARGET_XFER_E_IO, addr); 137 insn_type = ((insn_type << 16) 138 | extract_unsigned_integer (target_mem, 2, byte_order)); 139 insn_len = 4; 140 } 141 *insn = insn_type; 142 return insn_len; 143 } 144 145 /* Implement the read_pc gdbarch method. */ 146 147 static CORE_ADDR 148 csky_read_pc (readable_regcache *regcache) 149 { 150 ULONGEST pc; 151 regcache->cooked_read (CSKY_PC_REGNUM, &pc); 152 return pc; 153 } 154 155 /* Implement the write_pc gdbarch method. */ 156 157 static void 158 csky_write_pc (regcache *regcache, CORE_ADDR val) 159 { 160 regcache_cooked_write_unsigned (regcache, CSKY_PC_REGNUM, val); 161 } 162 163 /* Implement the unwind_sp gdbarch method. */ 164 165 static CORE_ADDR 166 csky_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) 167 { 168 return frame_unwind_register_unsigned (next_frame, CSKY_SP_REGNUM); 169 } 170 171 /* C-Sky ABI register names. */ 172 173 static const char *csky_register_names[] = 174 { 175 /* General registers 0 - 31. */ 176 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 177 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 178 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", 179 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", 180 181 /* DSP hilo registers 36 and 37. */ 182 "", "", "", "", "hi", "lo", "", "", 183 184 /* FPU/VPU general registers 40 - 71. */ 185 "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7", 186 "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15", 187 "vr0", "vr1", "vr2", "vr3", "vr4", "vr5", "vr6", "vr7", 188 "vr8", "vr9", "vr10", "vr11", "vr12", "vr13", "vr14", "vr15", 189 190 /* Program counter 72. */ 191 "pc", 192 193 /* Optional registers (ar) 73 - 88. */ 194 "ar0", "ar1", "ar2", "ar3", "ar4", "ar5", "ar6", "ar7", 195 "ar8", "ar9", "ar10", "ar11", "ar12", "ar13", "ar14", "ar15", 196 197 /* Control registers (cr) 89 - 119. */ 198 "psr", "vbr", "epsr", "fpsr", "epc", "fpc", "ss0", "ss1", 199 "ss2", "ss3", "ss4", "gcr", "gsr", "cr13", "cr14", "cr15", 200 "cr16", "cr17", "cr18", "cr19", "cr20", "cr21", "cr22", "cr23", 201 "cr24", "cr25", "cr26", "cr27", "cr28", "cr29", "cr30", "cr31", 202 203 /* FPU/VPU control registers 121 ~ 123. */ 204 /* User sp 127. */ 205 "fid", "fcr", "fesr", "", "", "", "usp", 206 207 /* MMU control registers: 128 - 136. */ 208 "mcr0", "mcr2", "mcr3", "mcr4", "mcr6", "mcr8", "mcr29", "mcr30", 209 "mcr31", "", "", "", 210 211 /* Profiling control registers 140 - 143. */ 212 /* Profiling software general registers 144 - 157. */ 213 "profcr0", "profcr1", "profcr2", "profcr3", "profsgr0", "profsgr1", 214 "profsgr2", "profsgr3", "profsgr4", "profsgr5", "profsgr6", "profsgr7", 215 "profsgr8", "profsgr9", "profsgr10","profsgr11","profsgr12", "profsgr13", 216 "", "", 217 218 /* Profiling architecture general registers 160 - 174. */ 219 "profagr0", "profagr1", "profagr2", "profagr3", "profagr4", "profagr5", 220 "profagr6", "profagr7", "profagr8", "profagr9", "profagr10","profagr11", 221 "profagr12","profagr13","profagr14", "", 222 223 /* Profiling extension general registers 176 - 188. */ 224 "profxgr0", "profxgr1", "profxgr2", "profxgr3", "profxgr4", "profxgr5", 225 "profxgr6", "profxgr7", "profxgr8", "profxgr9", "profxgr10","profxgr11", 226 "profxgr12", 227 228 /* Control registers in bank1. */ 229 "", "", "", "", "", "", "", "", 230 "", "", "", "", "", "", "", "", 231 "cp1cr16", "cp1cr17", "cp1cr18", "cp1cr19", "cp1cr20", "", "", "", 232 "", "", "", "", "", "", "", "", 233 234 /* Control registers in bank3 (ICE). */ 235 "sepsr", "sevbr", "seepsr", "", "seepc", "", "nsssp", "seusp", 236 "sedcr", "", "", "", "", "", "", "", 237 "", "", "", "", "", "", "", "", 238 "", "", "", "", "", "", "", "" 239 }; 240 241 /* Implement the register_name gdbarch method. */ 242 243 static const char * 244 csky_register_name (struct gdbarch *gdbarch, int reg_nr) 245 { 246 if (tdesc_has_registers (gdbarch_target_desc (gdbarch))) 247 return tdesc_register_name (gdbarch, reg_nr); 248 249 if (reg_nr < 0) 250 return NULL; 251 252 if (reg_nr >= gdbarch_num_regs (gdbarch)) 253 return NULL; 254 255 return csky_register_names[reg_nr]; 256 } 257 258 /* Construct vector type for vrx registers. */ 259 260 static struct type * 261 csky_vector_type (struct gdbarch *gdbarch) 262 { 263 const struct builtin_type *bt = builtin_type (gdbarch); 264 265 struct type *t; 266 267 t = arch_composite_type (gdbarch, "__gdb_builtin_type_vec128i", 268 TYPE_CODE_UNION); 269 270 append_composite_type_field (t, "u32", 271 init_vector_type (bt->builtin_int32, 4)); 272 append_composite_type_field (t, "u16", 273 init_vector_type (bt->builtin_int16, 8)); 274 append_composite_type_field (t, "u8", 275 init_vector_type (bt->builtin_int8, 16)); 276 277 TYPE_VECTOR (t) = 1; 278 TYPE_NAME (t) = "builtin_type_vec128i"; 279 280 return t; 281 } 282 283 /* Return the GDB type object for the "standard" data type 284 of data in register N. */ 285 286 static struct type * 287 csky_register_type (struct gdbarch *gdbarch, int reg_nr) 288 { 289 /* PC, EPC, FPC is a text pointer. */ 290 if ((reg_nr == CSKY_PC_REGNUM) || (reg_nr == CSKY_EPC_REGNUM) 291 || (reg_nr == CSKY_FPC_REGNUM)) 292 return builtin_type (gdbarch)->builtin_func_ptr; 293 294 /* VBR is a data pointer. */ 295 if (reg_nr == CSKY_VBR_REGNUM) 296 return builtin_type (gdbarch)->builtin_data_ptr; 297 298 /* Float register has 64 bits, and only in ck810. */ 299 if ((reg_nr >=CSKY_FR0_REGNUM) && (reg_nr <= CSKY_FR0_REGNUM + 15)) 300 return arch_float_type (gdbarch, 64, "builtin_type_csky_ext", 301 floatformats_ieee_double); 302 303 /* Vector register has 128 bits, and only in ck810. */ 304 if ((reg_nr >= CSKY_VR0_REGNUM) && (reg_nr <= CSKY_VR0_REGNUM + 15)) 305 return csky_vector_type (gdbarch); 306 307 /* Profiling general register has 48 bits, we use 64bit. */ 308 if ((reg_nr >= CSKY_PROFGR_REGNUM) && (reg_nr <= CSKY_PROFGR_REGNUM + 44)) 309 return builtin_type (gdbarch)->builtin_uint64; 310 311 if (reg_nr == CSKY_SP_REGNUM) 312 return builtin_type (gdbarch)->builtin_data_ptr; 313 314 /* Others are 32 bits. */ 315 return builtin_type (gdbarch)->builtin_int32; 316 } 317 318 /* Data structure to marshall items in a dummy stack frame when 319 calling a function in the inferior. */ 320 321 struct stack_item 322 { 323 stack_item (int len_, const gdb_byte *data_) 324 : len (len_), data (data_) 325 {} 326 327 int len; 328 const gdb_byte *data; 329 }; 330 331 /* Implement the push_dummy_call gdbarch method. */ 332 333 static CORE_ADDR 334 csky_push_dummy_call (struct gdbarch *gdbarch, struct value *function, 335 struct regcache *regcache, CORE_ADDR bp_addr, 336 int nargs, struct value **args, CORE_ADDR sp, 337 function_call_return_method return_method, 338 CORE_ADDR struct_addr) 339 { 340 int argnum; 341 int argreg = CSKY_ABI_A0_REGNUM; 342 int last_arg_regnum = CSKY_ABI_LAST_ARG_REGNUM; 343 int need_dummy_stack = 0; 344 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 345 std::vector<stack_item> stack_items; 346 347 /* Set the return address. For CSKY, the return breakpoint is 348 always at BP_ADDR. */ 349 regcache_cooked_write_unsigned (regcache, CSKY_LR_REGNUM, bp_addr); 350 351 /* The struct_return pointer occupies the first parameter 352 passing register. */ 353 if (return_method == return_method_struct) 354 { 355 if (csky_debug) 356 { 357 fprintf_unfiltered (gdb_stdlog, 358 "csky: struct return in %s = %s\n", 359 gdbarch_register_name (gdbarch, argreg), 360 paddress (gdbarch, struct_addr)); 361 } 362 regcache_cooked_write_unsigned (regcache, argreg, struct_addr); 363 argreg++; 364 } 365 366 /* Put parameters into argument registers in REGCACHE. 367 In ABI argument registers are r0 through r3. */ 368 for (argnum = 0; argnum < nargs; argnum++) 369 { 370 int len; 371 struct type *arg_type; 372 const gdb_byte *val; 373 374 arg_type = check_typedef (value_type (args[argnum])); 375 len = TYPE_LENGTH (arg_type); 376 val = value_contents (args[argnum]); 377 378 /* Copy the argument to argument registers or the dummy stack. 379 Large arguments are split between registers and stack. 380 381 If len < 4, there is no need to worry about endianness since 382 the arguments will always be stored in the low address. */ 383 if (len < 4) 384 { 385 CORE_ADDR regval 386 = extract_unsigned_integer (val, len, byte_order); 387 regcache_cooked_write_unsigned (regcache, argreg, regval); 388 argreg++; 389 } 390 else 391 { 392 while (len > 0) 393 { 394 int partial_len = len < 4 ? len : 4; 395 if (argreg <= last_arg_regnum) 396 { 397 /* The argument is passed in an argument register. */ 398 CORE_ADDR regval 399 = extract_unsigned_integer (val, partial_len, 400 byte_order); 401 if (byte_order == BFD_ENDIAN_BIG) 402 regval <<= (4 - partial_len) * 8; 403 404 /* Put regval into register in REGCACHE. */ 405 regcache_cooked_write_unsigned (regcache, argreg, 406 regval); 407 argreg++; 408 } 409 else 410 { 411 /* The argument should be pushed onto the dummy stack. */ 412 stack_items.emplace_back (4, val); 413 need_dummy_stack += 4; 414 } 415 len -= partial_len; 416 val += partial_len; 417 } 418 } 419 } 420 421 /* Transfer the dummy stack frame to the target. */ 422 std::vector<stack_item>::reverse_iterator iter; 423 for (iter = stack_items.rbegin (); iter != stack_items.rend (); ++iter) 424 { 425 sp -= iter->len; 426 write_memory (sp, iter->data, iter->len); 427 } 428 429 /* Finally, update the SP register. */ 430 regcache_cooked_write_unsigned (regcache, CSKY_SP_REGNUM, sp); 431 return sp; 432 } 433 434 /* Implement the return_value gdbarch method. */ 435 436 static enum return_value_convention 437 csky_return_value (struct gdbarch *gdbarch, struct value *function, 438 struct type *valtype, struct regcache *regcache, 439 gdb_byte *readbuf, const gdb_byte *writebuf) 440 { 441 CORE_ADDR regval; 442 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 443 int len = TYPE_LENGTH (valtype); 444 unsigned int ret_regnum = CSKY_RET_REGNUM; 445 446 /* Csky abi specifies that return values larger than 8 bytes 447 are put on the stack. */ 448 if (len > 8) 449 return RETURN_VALUE_STRUCT_CONVENTION; 450 else 451 { 452 if (readbuf != NULL) 453 { 454 ULONGEST tmp; 455 /* By using store_unsigned_integer we avoid having to do 456 anything special for small big-endian values. */ 457 regcache->cooked_read (ret_regnum, &tmp); 458 store_unsigned_integer (readbuf, (len > 4 ? 4 : len), 459 byte_order, tmp); 460 if (len > 4) 461 { 462 regcache->cooked_read (ret_regnum + 1, &tmp); 463 store_unsigned_integer (readbuf + 4, 4, byte_order, tmp); 464 } 465 } 466 if (writebuf != NULL) 467 { 468 regval = extract_unsigned_integer (writebuf, len > 4 ? 4 : len, 469 byte_order); 470 regcache_cooked_write_unsigned (regcache, ret_regnum, regval); 471 if (len > 4) 472 { 473 regval = extract_unsigned_integer ((gdb_byte *) writebuf + 4, 474 4, byte_order); 475 regcache_cooked_write_unsigned (regcache, ret_regnum + 1, 476 regval); 477 } 478 479 } 480 return RETURN_VALUE_REGISTER_CONVENTION; 481 } 482 } 483 484 /* Implement the frame_align gdbarch method. 485 486 Adjust the address downward (direction of stack growth) so that it 487 is correctly aligned for a new stack frame. */ 488 489 static CORE_ADDR 490 csky_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr) 491 { 492 return align_down (addr, 4); 493 } 494 495 /* Unwind cache used for gdbarch fallback unwinder. */ 496 497 struct csky_unwind_cache 498 { 499 /* The stack pointer at the time this frame was created; i.e. the 500 caller's stack pointer when this function was called. It is used 501 to identify this frame. */ 502 CORE_ADDR prev_sp; 503 504 /* The frame base for this frame is just prev_sp - frame size. 505 FRAMESIZE is the distance from the frame pointer to the 506 initial stack pointer. */ 507 int framesize; 508 509 /* The register used to hold the frame pointer for this frame. */ 510 int framereg; 511 512 /* Saved register offsets. */ 513 struct trad_frame_saved_reg *saved_regs; 514 }; 515 516 /* Do prologue analysis, returning the PC of the first instruction 517 after the function prologue. */ 518 519 static CORE_ADDR 520 csky_analyze_prologue (struct gdbarch *gdbarch, 521 CORE_ADDR start_pc, 522 CORE_ADDR limit_pc, 523 CORE_ADDR end_pc, 524 struct frame_info *this_frame, 525 struct csky_unwind_cache *this_cache, 526 lr_type_t lr_type) 527 { 528 CORE_ADDR addr; 529 unsigned int insn, rn; 530 int framesize = 0; 531 int stacksize = 0; 532 int register_offsets[CSKY_NUM_GREGS_SAVED_GREGS]; 533 int insn_len; 534 /* For adjusting fp. */ 535 int is_fp_saved = 0; 536 int adjust_fp = 0; 537 538 /* REGISTER_OFFSETS will contain offsets from the top of the frame 539 (NOT the frame pointer) for the various saved registers, or -1 540 if the register is not saved. */ 541 for (rn = 0; rn < CSKY_NUM_GREGS_SAVED_GREGS; rn++) 542 register_offsets[rn] = -1; 543 544 /* Analyze the prologue. Things we determine from analyzing the 545 prologue include the size of the frame and which registers are 546 saved (and where). */ 547 if (csky_debug) 548 { 549 fprintf_unfiltered (gdb_stdlog, 550 "csky: Scanning prologue: start_pc = 0x%x," 551 "limit_pc = 0x%x\n", (unsigned int) start_pc, 552 (unsigned int) limit_pc); 553 } 554 555 /* Default to 16 bit instruction. */ 556 insn_len = 2; 557 stacksize = 0; 558 for (addr = start_pc; addr < limit_pc; addr += insn_len) 559 { 560 /* Get next insn. */ 561 insn_len = csky_get_insn (gdbarch, addr, &insn); 562 563 /* Check if 32 bit. */ 564 if (insn_len == 4) 565 { 566 /* subi32 sp,sp oimm12. */ 567 if (CSKY_32_IS_SUBI0 (insn)) 568 { 569 /* Got oimm12. */ 570 int offset = CSKY_32_SUBI_IMM (insn); 571 if (csky_debug) 572 { 573 fprintf_unfiltered (gdb_stdlog, 574 "csky: got subi sp,%d; continuing\n", 575 offset); 576 } 577 stacksize += offset; 578 continue; 579 } 580 /* stm32 ry-rz,(sp). */ 581 else if (CSKY_32_IS_STMx0 (insn)) 582 { 583 /* Spill register(s). */ 584 int start_register; 585 int reg_count; 586 int offset; 587 588 /* BIG WARNING! The CKCore ABI does not restrict functions 589 to taking only one stack allocation. Therefore, when 590 we save a register, we record the offset of where it was 591 saved relative to the current stacksize. This will 592 then give an offset from the SP upon entry to our 593 function. Remember, stacksize is NOT constant until 594 we're done scanning the prologue. */ 595 start_register = CSKY_32_STM_VAL_REGNUM (insn); 596 reg_count = CSKY_32_STM_SIZE (insn); 597 if (csky_debug) 598 { 599 fprintf_unfiltered (gdb_stdlog, 600 "csky: got stm r%d-r%d,(sp)\n", 601 start_register, 602 start_register + reg_count); 603 } 604 605 for (rn = start_register, offset = 0; 606 rn <= start_register + reg_count; 607 rn++, offset += 4) 608 { 609 register_offsets[rn] = stacksize - offset; 610 if (csky_debug) 611 { 612 fprintf_unfiltered (gdb_stdlog, 613 "csky: r%d saved at 0x%x" 614 " (offset %d)\n", 615 rn, register_offsets[rn], 616 offset); 617 } 618 } 619 if (csky_debug) 620 fprintf_unfiltered (gdb_stdlog, "csky: continuing\n"); 621 continue; 622 } 623 /* stw ry,(sp,disp). */ 624 else if (CSKY_32_IS_STWx0 (insn)) 625 { 626 /* Spill register: see note for IS_STM above. */ 627 int disp; 628 629 rn = CSKY_32_ST_VAL_REGNUM (insn); 630 disp = CSKY_32_ST_OFFSET (insn); 631 register_offsets[rn] = stacksize - disp; 632 if (csky_debug) 633 print_savedreg_msg (rn, register_offsets, true); 634 continue; 635 } 636 else if (CSKY_32_IS_MOV_FP_SP (insn)) 637 { 638 /* SP is saved to FP reg, means code afer prologue may 639 modify SP. */ 640 is_fp_saved = 1; 641 adjust_fp = stacksize; 642 continue; 643 } 644 else if (CSKY_32_IS_MFCR_EPSR (insn)) 645 { 646 unsigned int insn2; 647 addr += 4; 648 int mfcr_regnum = insn & 0x1f; 649 insn_len = csky_get_insn (gdbarch, addr, &insn2); 650 if (insn_len == 2) 651 { 652 int stw_regnum = (insn2 >> 5) & 0x7; 653 if (CSKY_16_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum)) 654 { 655 int offset; 656 657 /* CSKY_EPSR_REGNUM. */ 658 rn = CSKY_NUM_GREGS; 659 offset = CSKY_16_STWx0_OFFSET (insn2); 660 register_offsets[rn] = stacksize - offset; 661 if (csky_debug) 662 print_savedreg_msg (rn, register_offsets, true); 663 continue; 664 } 665 break; 666 } 667 else 668 { 669 /* INSN_LEN == 4. */ 670 int stw_regnum = (insn2 >> 21) & 0x1f; 671 if (CSKY_32_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum)) 672 { 673 int offset; 674 675 /* CSKY_EPSR_REGNUM. */ 676 rn = CSKY_NUM_GREGS; 677 offset = CSKY_32_ST_OFFSET (insn2); 678 register_offsets[rn] = framesize - offset; 679 if (csky_debug) 680 print_savedreg_msg (rn, register_offsets, true); 681 continue; 682 } 683 break; 684 } 685 } 686 else if (CSKY_32_IS_MFCR_FPSR (insn)) 687 { 688 unsigned int insn2; 689 addr += 4; 690 int mfcr_regnum = insn & 0x1f; 691 insn_len = csky_get_insn (gdbarch, addr, &insn2); 692 if (insn_len == 2) 693 { 694 int stw_regnum = (insn2 >> 5) & 0x7; 695 if (CSKY_16_IS_STWx0 (insn2) && (mfcr_regnum 696 == stw_regnum)) 697 { 698 int offset; 699 700 /* CSKY_FPSR_REGNUM. */ 701 rn = CSKY_NUM_GREGS + 1; 702 offset = CSKY_16_STWx0_OFFSET (insn2); 703 register_offsets[rn] = stacksize - offset; 704 if (csky_debug) 705 print_savedreg_msg (rn, register_offsets, true); 706 continue; 707 } 708 break; 709 } 710 else 711 { 712 /* INSN_LEN == 4. */ 713 int stw_regnum = (insn2 >> 21) & 0x1f; 714 if (CSKY_32_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum)) 715 { 716 int offset; 717 718 /* CSKY_FPSR_REGNUM. */ 719 rn = CSKY_NUM_GREGS + 1; 720 offset = CSKY_32_ST_OFFSET (insn2); 721 register_offsets[rn] = framesize - offset; 722 if (csky_debug) 723 print_savedreg_msg (rn, register_offsets, true); 724 continue; 725 } 726 break; 727 } 728 } 729 else if (CSKY_32_IS_MFCR_EPC (insn)) 730 { 731 unsigned int insn2; 732 addr += 4; 733 int mfcr_regnum = insn & 0x1f; 734 insn_len = csky_get_insn (gdbarch, addr, &insn2); 735 if (insn_len == 2) 736 { 737 int stw_regnum = (insn2 >> 5) & 0x7; 738 if (CSKY_16_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum)) 739 { 740 int offset; 741 742 /* CSKY_EPC_REGNUM. */ 743 rn = CSKY_NUM_GREGS + 2; 744 offset = CSKY_16_STWx0_OFFSET (insn2); 745 register_offsets[rn] = stacksize - offset; 746 if (csky_debug) 747 print_savedreg_msg (rn, register_offsets, true); 748 continue; 749 } 750 break; 751 } 752 else 753 { 754 /* INSN_LEN == 4. */ 755 int stw_regnum = (insn2 >> 21) & 0x1f; 756 if (CSKY_32_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum)) 757 { 758 int offset; 759 760 /* CSKY_EPC_REGNUM. */ 761 rn = CSKY_NUM_GREGS + 2; 762 offset = CSKY_32_ST_OFFSET (insn2); 763 register_offsets[rn] = framesize - offset; 764 if (csky_debug) 765 print_savedreg_msg (rn, register_offsets, true); 766 continue; 767 } 768 break; 769 } 770 } 771 else if (CSKY_32_IS_MFCR_FPC (insn)) 772 { 773 unsigned int insn2; 774 addr += 4; 775 int mfcr_regnum = insn & 0x1f; 776 insn_len = csky_get_insn (gdbarch, addr, &insn2); 777 if (insn_len == 2) 778 { 779 int stw_regnum = (insn2 >> 5) & 0x7; 780 if (CSKY_16_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum)) 781 { 782 int offset; 783 784 /* CSKY_FPC_REGNUM. */ 785 rn = CSKY_NUM_GREGS + 3; 786 offset = CSKY_16_STWx0_OFFSET (insn2); 787 register_offsets[rn] = stacksize - offset; 788 if (csky_debug) 789 print_savedreg_msg (rn, register_offsets, true); 790 continue; 791 } 792 break; 793 } 794 else 795 { 796 /* INSN_LEN == 4. */ 797 int stw_regnum = (insn2 >> 21) & 0x1f; 798 if (CSKY_32_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum)) 799 { 800 int offset; 801 802 /* CSKY_FPC_REGNUM. */ 803 rn = CSKY_NUM_GREGS + 3; 804 offset = CSKY_32_ST_OFFSET (insn2); 805 register_offsets[rn] = framesize - offset; 806 if (csky_debug) 807 print_savedreg_msg (rn, register_offsets, true); 808 continue; 809 } 810 break; 811 } 812 } 813 else if (CSKY_32_IS_PUSH (insn)) 814 { 815 /* Push for 32_bit. */ 816 int offset = 0; 817 if (CSKY_32_IS_PUSH_R29 (insn)) 818 { 819 stacksize += 4; 820 register_offsets[29] = stacksize; 821 if (csky_debug) 822 print_savedreg_msg (29, register_offsets, false); 823 offset += 4; 824 } 825 if (CSKY_32_PUSH_LIST2 (insn)) 826 { 827 int num = CSKY_32_PUSH_LIST2 (insn); 828 int tmp = 0; 829 stacksize += num * 4; 830 offset += num * 4; 831 if (csky_debug) 832 { 833 fprintf_unfiltered (gdb_stdlog, 834 "csky: push regs_array: r16-r%d\n", 835 16 + num - 1); 836 } 837 for (rn = 16; rn <= 16 + num - 1; rn++) 838 { 839 register_offsets[rn] = stacksize - tmp; 840 if (csky_debug) 841 { 842 fprintf_unfiltered (gdb_stdlog, 843 "csky: r%d saved at 0x%x" 844 " (offset %d)\n", rn, 845 register_offsets[rn], tmp); 846 } 847 tmp += 4; 848 } 849 } 850 if (CSKY_32_IS_PUSH_R15 (insn)) 851 { 852 stacksize += 4; 853 register_offsets[15] = stacksize; 854 if (csky_debug) 855 print_savedreg_msg (15, register_offsets, false); 856 offset += 4; 857 } 858 if (CSKY_32_PUSH_LIST1 (insn)) 859 { 860 int num = CSKY_32_PUSH_LIST1 (insn); 861 int tmp = 0; 862 stacksize += num * 4; 863 offset += num * 4; 864 if (csky_debug) 865 { 866 fprintf_unfiltered (gdb_stdlog, 867 "csky: push regs_array: r4-r%d\n", 868 4 + num - 1); 869 } 870 for (rn = 4; rn <= 4 + num - 1; rn++) 871 { 872 register_offsets[rn] = stacksize - tmp; 873 if (csky_debug) 874 { 875 fprintf_unfiltered (gdb_stdlog, 876 "csky: r%d saved at 0x%x" 877 " (offset %d)\n", rn, 878 register_offsets[rn], tmp); 879 } 880 tmp += 4; 881 } 882 } 883 884 framesize = stacksize; 885 if (csky_debug) 886 fprintf_unfiltered (gdb_stdlog, "csky: continuing\n"); 887 continue; 888 } 889 else if (CSKY_32_IS_LRW4 (insn) || CSKY_32_IS_MOVI4 (insn) 890 || CSKY_32_IS_MOVIH4 (insn) || CSKY_32_IS_BMASKI4 (insn)) 891 { 892 int adjust = 0; 893 int offset = 0; 894 unsigned int insn2; 895 896 if (csky_debug) 897 { 898 fprintf_unfiltered (gdb_stdlog, 899 "csky: looking at large frame\n"); 900 } 901 if (CSKY_32_IS_LRW4 (insn)) 902 { 903 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 904 int literal_addr = (addr + ((insn & 0xffff) << 2)) 905 & 0xfffffffc; 906 adjust = read_memory_unsigned_integer (literal_addr, 4, 907 byte_order); 908 } 909 else if (CSKY_32_IS_MOVI4 (insn)) 910 adjust = (insn & 0xffff); 911 else if (CSKY_32_IS_MOVIH4 (insn)) 912 adjust = (insn & 0xffff) << 16; 913 else 914 { 915 /* CSKY_32_IS_BMASKI4 (insn). */ 916 adjust = (1 << (((insn & 0x3e00000) >> 21) + 1)) - 1; 917 } 918 919 if (csky_debug) 920 { 921 fprintf_unfiltered (gdb_stdlog, 922 "csky: base stacksize=0x%x\n", adjust); 923 924 /* May have zero or more insns which modify r4. */ 925 fprintf_unfiltered (gdb_stdlog, 926 "csky: looking for r4 adjusters...\n"); 927 } 928 929 offset = 4; 930 insn_len = csky_get_insn (gdbarch, addr + offset, &insn2); 931 while (CSKY_IS_R4_ADJUSTER (insn2)) 932 { 933 if (CSKY_32_IS_ADDI4 (insn2)) 934 { 935 int imm = (insn2 & 0xfff) + 1; 936 adjust += imm; 937 if (csky_debug) 938 { 939 fprintf_unfiltered (gdb_stdlog, 940 "csky: addi r4,%d\n", imm); 941 } 942 } 943 else if (CSKY_32_IS_SUBI4 (insn2)) 944 { 945 int imm = (insn2 & 0xfff) + 1; 946 adjust -= imm; 947 if (csky_debug) 948 { 949 fprintf_unfiltered (gdb_stdlog, 950 "csky: subi r4,%d\n", imm); 951 } 952 } 953 else if (CSKY_32_IS_NOR4 (insn2)) 954 { 955 adjust = ~adjust; 956 if (csky_debug) 957 { 958 fprintf_unfiltered (gdb_stdlog, 959 "csky: nor r4,r4,r4\n"); 960 } 961 } 962 else if (CSKY_32_IS_ROTLI4 (insn2)) 963 { 964 int imm = ((insn2 >> 21) & 0x1f); 965 int temp = adjust >> (32 - imm); 966 adjust <<= imm; 967 adjust |= temp; 968 if (csky_debug) 969 { 970 fprintf_unfiltered (gdb_stdlog, 971 "csky: rotli r4,r4,%d\n", imm); 972 } 973 } 974 else if (CSKY_32_IS_LISI4 (insn2)) 975 { 976 int imm = ((insn2 >> 21) & 0x1f); 977 adjust <<= imm; 978 if (csky_debug) 979 { 980 fprintf_unfiltered (gdb_stdlog, 981 "csky: lsli r4,r4,%d\n", imm); 982 } 983 } 984 else if (CSKY_32_IS_BSETI4 (insn2)) 985 { 986 int imm = ((insn2 >> 21) & 0x1f); 987 adjust |= (1 << imm); 988 if (csky_debug) 989 { 990 fprintf_unfiltered (gdb_stdlog, 991 "csky: bseti r4,r4 %d\n", imm); 992 } 993 } 994 else if (CSKY_32_IS_BCLRI4 (insn2)) 995 { 996 int imm = ((insn2 >> 21) & 0x1f); 997 adjust &= ~(1 << imm); 998 if (csky_debug) 999 { 1000 fprintf_unfiltered (gdb_stdlog, 1001 "csky: bclri r4,r4 %d\n", imm); 1002 } 1003 } 1004 else if (CSKY_32_IS_IXH4 (insn2)) 1005 { 1006 adjust *= 3; 1007 if (csky_debug) 1008 { 1009 fprintf_unfiltered (gdb_stdlog, 1010 "csky: ixh r4,r4,r4\n"); 1011 } 1012 } 1013 else if (CSKY_32_IS_IXW4 (insn2)) 1014 { 1015 adjust *= 5; 1016 if (csky_debug) 1017 { 1018 fprintf_unfiltered (gdb_stdlog, 1019 "csky: ixw r4,r4,r4\n"); 1020 } 1021 } 1022 else if (CSKY_16_IS_ADDI4 (insn2)) 1023 { 1024 int imm = (insn2 & 0xff) + 1; 1025 adjust += imm; 1026 if (csky_debug) 1027 { 1028 fprintf_unfiltered (gdb_stdlog, 1029 "csky: addi r4,%d\n", imm); 1030 } 1031 } 1032 else if (CSKY_16_IS_SUBI4 (insn2)) 1033 { 1034 int imm = (insn2 & 0xff) + 1; 1035 adjust -= imm; 1036 if (csky_debug) 1037 { 1038 fprintf_unfiltered (gdb_stdlog, 1039 "csky: subi r4,%d\n", imm); 1040 } 1041 } 1042 else if (CSKY_16_IS_NOR4 (insn2)) 1043 { 1044 adjust = ~adjust; 1045 if (csky_debug) 1046 { 1047 fprintf_unfiltered (gdb_stdlog, 1048 "csky: nor r4,r4\n"); 1049 } 1050 } 1051 else if (CSKY_16_IS_BSETI4 (insn2)) 1052 { 1053 int imm = (insn2 & 0x1f); 1054 adjust |= (1 << imm); 1055 if (csky_debug) 1056 { 1057 fprintf_unfiltered (gdb_stdlog, 1058 "csky: bseti r4, %d\n", imm); 1059 } 1060 } 1061 else if (CSKY_16_IS_BCLRI4 (insn2)) 1062 { 1063 int imm = (insn2 & 0x1f); 1064 adjust &= ~(1 << imm); 1065 if (csky_debug) 1066 { 1067 fprintf_unfiltered (gdb_stdlog, 1068 "csky: bclri r4, %d\n", imm); 1069 } 1070 } 1071 else if (CSKY_16_IS_LSLI4 (insn2)) 1072 { 1073 int imm = (insn2 & 0x1f); 1074 adjust <<= imm; 1075 if (csky_debug) 1076 { 1077 fprintf_unfiltered (gdb_stdlog, 1078 "csky: lsli r4,r4, %d\n", imm); 1079 } 1080 } 1081 1082 offset += insn_len; 1083 insn_len = csky_get_insn (gdbarch, addr + offset, &insn2); 1084 }; 1085 1086 if (csky_debug) 1087 { 1088 fprintf_unfiltered (gdb_stdlog, "csky: done looking for" 1089 " r4 adjusters\n"); 1090 } 1091 1092 /* If the next insn adjusts the stack pointer, we keep 1093 everything; if not, we scrap it and we've found the 1094 end of the prologue. */ 1095 if (CSKY_IS_SUBU4 (insn2)) 1096 { 1097 addr += offset; 1098 stacksize += adjust; 1099 if (csky_debug) 1100 { 1101 fprintf_unfiltered (gdb_stdlog, 1102 "csky: found stack adjustment of" 1103 " 0x%x bytes.\n", adjust); 1104 fprintf_unfiltered (gdb_stdlog, 1105 "csky: skipping to new address %s\n", 1106 core_addr_to_string_nz (addr)); 1107 fprintf_unfiltered (gdb_stdlog, 1108 "csky: continuing\n"); 1109 } 1110 continue; 1111 } 1112 1113 /* None of these instructions are prologue, so don't touch 1114 anything. */ 1115 if (csky_debug) 1116 { 1117 fprintf_unfiltered (gdb_stdlog, 1118 "csky: no subu sp,sp,r4; NOT altering" 1119 " stacksize.\n"); 1120 } 1121 break; 1122 } 1123 } 1124 else 1125 { 1126 /* insn_len != 4. */ 1127 1128 /* subi.sp sp,disp. */ 1129 if (CSKY_16_IS_SUBI0 (insn)) 1130 { 1131 int offset = CSKY_16_SUBI_IMM (insn); 1132 if (csky_debug) 1133 { 1134 fprintf_unfiltered (gdb_stdlog, 1135 "csky: got subi r0,%d; continuing\n", 1136 offset); 1137 } 1138 stacksize += offset; 1139 continue; 1140 } 1141 /* stw.16 rz,(sp,disp). */ 1142 else if (CSKY_16_IS_STWx0 (insn)) 1143 { 1144 /* Spill register: see note for IS_STM above. */ 1145 int disp; 1146 1147 rn = CSKY_16_ST_VAL_REGNUM (insn); 1148 disp = CSKY_16_ST_OFFSET (insn); 1149 register_offsets[rn] = stacksize - disp; 1150 if (csky_debug) 1151 print_savedreg_msg (rn, register_offsets, true); 1152 continue; 1153 } 1154 else if (CSKY_16_IS_MOV_FP_SP (insn)) 1155 { 1156 /* SP is saved to FP reg, means prologue may modify SP. */ 1157 is_fp_saved = 1; 1158 adjust_fp = stacksize; 1159 continue; 1160 } 1161 else if (CSKY_16_IS_PUSH (insn)) 1162 { 1163 /* Push for 16_bit. */ 1164 int offset = 0; 1165 if (CSKY_16_IS_PUSH_R15 (insn)) 1166 { 1167 stacksize += 4; 1168 register_offsets[15] = stacksize; 1169 if (csky_debug) 1170 print_savedreg_msg (15, register_offsets, false); 1171 offset += 4; 1172 } 1173 if (CSKY_16_PUSH_LIST1 (insn)) 1174 { 1175 int num = CSKY_16_PUSH_LIST1 (insn); 1176 int tmp = 0; 1177 stacksize += num * 4; 1178 offset += num * 4; 1179 if (csky_debug) 1180 { 1181 fprintf_unfiltered (gdb_stdlog, 1182 "csky: push regs_array: r4-r%d\n", 1183 4 + num - 1); 1184 } 1185 for (rn = 4; rn <= 4 + num - 1; rn++) 1186 { 1187 register_offsets[rn] = stacksize - tmp; 1188 if (csky_debug) 1189 { 1190 fprintf_unfiltered (gdb_stdlog, 1191 "csky: r%d saved at 0x%x" 1192 " (offset %d)\n", rn, 1193 register_offsets[rn], offset); 1194 } 1195 tmp += 4; 1196 } 1197 } 1198 1199 framesize = stacksize; 1200 if (csky_debug) 1201 fprintf_unfiltered (gdb_stdlog, "csky: continuing\n"); 1202 continue; 1203 } 1204 else if (CSKY_16_IS_LRW4 (insn) || CSKY_16_IS_MOVI4 (insn)) 1205 { 1206 int adjust = 0; 1207 unsigned int insn2; 1208 1209 if (csky_debug) 1210 { 1211 fprintf_unfiltered (gdb_stdlog, 1212 "csky: looking at large frame\n"); 1213 } 1214 if (CSKY_16_IS_LRW4 (insn)) 1215 { 1216 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1217 int offset = ((insn & 0x300) >> 3) | (insn & 0x1f); 1218 int literal_addr = (addr + ( offset << 2)) & 0xfffffffc; 1219 adjust = read_memory_unsigned_integer (literal_addr, 4, 1220 byte_order); 1221 } 1222 else 1223 { 1224 /* CSKY_16_IS_MOVI4 (insn). */ 1225 adjust = (insn & 0xff); 1226 } 1227 1228 if (csky_debug) 1229 { 1230 fprintf_unfiltered (gdb_stdlog, 1231 "csky: base stacksize=0x%x\n", adjust); 1232 } 1233 1234 /* May have zero or more instructions which modify r4. */ 1235 if (csky_debug) 1236 { 1237 fprintf_unfiltered (gdb_stdlog, 1238 "csky: looking for r4 adjusters...\n"); 1239 } 1240 int offset = 2; 1241 insn_len = csky_get_insn (gdbarch, addr + offset, &insn2); 1242 while (CSKY_IS_R4_ADJUSTER (insn2)) 1243 { 1244 if (CSKY_32_IS_ADDI4 (insn2)) 1245 { 1246 int imm = (insn2 & 0xfff) + 1; 1247 adjust += imm; 1248 if (csky_debug) 1249 { 1250 fprintf_unfiltered (gdb_stdlog, 1251 "csky: addi r4,%d\n", imm); 1252 } 1253 } 1254 else if (CSKY_32_IS_SUBI4 (insn2)) 1255 { 1256 int imm = (insn2 & 0xfff) + 1; 1257 adjust -= imm; 1258 if (csky_debug) 1259 { 1260 fprintf_unfiltered (gdb_stdlog, 1261 "csky: subi r4,%d\n", imm); 1262 } 1263 } 1264 else if (CSKY_32_IS_NOR4 (insn2)) 1265 { 1266 adjust = ~adjust; 1267 if (csky_debug) 1268 { 1269 fprintf_unfiltered (gdb_stdlog, 1270 "csky: nor r4,r4,r4\n"); 1271 } 1272 } 1273 else if (CSKY_32_IS_ROTLI4 (insn2)) 1274 { 1275 int imm = ((insn2 >> 21) & 0x1f); 1276 int temp = adjust >> (32 - imm); 1277 adjust <<= imm; 1278 adjust |= temp; 1279 if (csky_debug) 1280 { 1281 fprintf_unfiltered (gdb_stdlog, 1282 "csky: rotli r4,r4,%d\n", imm); 1283 } 1284 } 1285 else if (CSKY_32_IS_LISI4 (insn2)) 1286 { 1287 int imm = ((insn2 >> 21) & 0x1f); 1288 adjust <<= imm; 1289 if (csky_debug) 1290 { 1291 fprintf_unfiltered (gdb_stdlog, 1292 "csky: lsli r4,r4,%d\n", imm); 1293 } 1294 } 1295 else if (CSKY_32_IS_BSETI4 (insn2)) 1296 { 1297 int imm = ((insn2 >> 21) & 0x1f); 1298 adjust |= (1 << imm); 1299 if (csky_debug) 1300 { 1301 fprintf_unfiltered (gdb_stdlog, 1302 "csky: bseti r4,r4 %d\n", imm); 1303 } 1304 } 1305 else if (CSKY_32_IS_BCLRI4 (insn2)) 1306 { 1307 int imm = ((insn2 >> 21) & 0x1f); 1308 adjust &= ~(1 << imm); 1309 if (csky_debug) 1310 { 1311 fprintf_unfiltered (gdb_stdlog, 1312 "csky: bclri r4,r4 %d\n", imm); 1313 } 1314 } 1315 else if (CSKY_32_IS_IXH4 (insn2)) 1316 { 1317 adjust *= 3; 1318 if (csky_debug) 1319 { 1320 fprintf_unfiltered (gdb_stdlog, 1321 "csky: ixh r4,r4,r4\n"); 1322 } 1323 } 1324 else if (CSKY_32_IS_IXW4 (insn2)) 1325 { 1326 adjust *= 5; 1327 if (csky_debug) 1328 { 1329 fprintf_unfiltered (gdb_stdlog, 1330 "csky: ixw r4,r4,r4\n"); 1331 } 1332 } 1333 else if (CSKY_16_IS_ADDI4 (insn2)) 1334 { 1335 int imm = (insn2 & 0xff) + 1; 1336 adjust += imm; 1337 if (csky_debug) 1338 { 1339 fprintf_unfiltered (gdb_stdlog, 1340 "csky: addi r4,%d\n", imm); 1341 } 1342 } 1343 else if (CSKY_16_IS_SUBI4 (insn2)) 1344 { 1345 int imm = (insn2 & 0xff) + 1; 1346 adjust -= imm; 1347 if (csky_debug) 1348 { 1349 fprintf_unfiltered (gdb_stdlog, 1350 "csky: subi r4,%d\n", imm); 1351 } 1352 } 1353 else if (CSKY_16_IS_NOR4 (insn2)) 1354 { 1355 adjust = ~adjust; 1356 if (csky_debug) 1357 { 1358 fprintf_unfiltered (gdb_stdlog, 1359 "csky: nor r4,r4\n"); 1360 } 1361 } 1362 else if (CSKY_16_IS_BSETI4 (insn2)) 1363 { 1364 int imm = (insn2 & 0x1f); 1365 adjust |= (1 << imm); 1366 if (csky_debug) 1367 { 1368 fprintf_unfiltered (gdb_stdlog, 1369 "csky: bseti r4, %d\n", imm); 1370 } 1371 } 1372 else if (CSKY_16_IS_BCLRI4 (insn2)) 1373 { 1374 int imm = (insn2 & 0x1f); 1375 adjust &= ~(1 << imm); 1376 if (csky_debug) 1377 { 1378 fprintf_unfiltered (gdb_stdlog, 1379 "csky: bclri r4, %d\n", imm); 1380 } 1381 } 1382 else if (CSKY_16_IS_LSLI4 (insn2)) 1383 { 1384 int imm = (insn2 & 0x1f); 1385 adjust <<= imm; 1386 if (csky_debug) 1387 { 1388 fprintf_unfiltered (gdb_stdlog, 1389 "csky: lsli r4,r4, %d\n", imm); 1390 } 1391 } 1392 1393 offset += insn_len; 1394 insn_len = csky_get_insn (gdbarch, addr + offset, &insn2); 1395 }; 1396 1397 if (csky_debug) 1398 { 1399 fprintf_unfiltered (gdb_stdlog, "csky: " 1400 "done looking for r4 adjusters\n"); 1401 } 1402 1403 /* If the next instruction adjusts the stack pointer, we keep 1404 everything; if not, we scrap it and we've found the end 1405 of the prologue. */ 1406 if (CSKY_IS_SUBU4 (insn2)) 1407 { 1408 addr += offset; 1409 stacksize += adjust; 1410 if (csky_debug) 1411 { 1412 fprintf_unfiltered (gdb_stdlog, "csky: " 1413 "found stack adjustment of 0x%x" 1414 " bytes.\n", adjust); 1415 fprintf_unfiltered (gdb_stdlog, "csky: " 1416 "skipping to new address %s\n", 1417 core_addr_to_string_nz (addr)); 1418 fprintf_unfiltered (gdb_stdlog, "csky: continuing\n"); 1419 } 1420 continue; 1421 } 1422 1423 /* None of these instructions are prologue, so don't touch 1424 anything. */ 1425 if (csky_debug) 1426 { 1427 fprintf_unfiltered (gdb_stdlog, "csky: no subu sp,r4; " 1428 "NOT altering stacksize.\n"); 1429 } 1430 break; 1431 } 1432 } 1433 1434 /* This is not a prologue instruction, so stop here. */ 1435 if (csky_debug) 1436 { 1437 fprintf_unfiltered (gdb_stdlog, "csky: insn is not a prologue" 1438 " insn -- ending scan\n"); 1439 } 1440 break; 1441 } 1442 1443 if (this_cache) 1444 { 1445 CORE_ADDR unwound_fp; 1446 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1447 this_cache->framesize = framesize; 1448 1449 if (is_fp_saved) 1450 { 1451 this_cache->framereg = CSKY_FP_REGNUM; 1452 unwound_fp = get_frame_register_unsigned (this_frame, 1453 this_cache->framereg); 1454 this_cache->prev_sp = unwound_fp + adjust_fp; 1455 } 1456 else 1457 { 1458 this_cache->framereg = CSKY_SP_REGNUM; 1459 unwound_fp = get_frame_register_unsigned (this_frame, 1460 this_cache->framereg); 1461 this_cache->prev_sp = unwound_fp + stacksize; 1462 } 1463 1464 /* Note where saved registers are stored. The offsets in 1465 REGISTER_OFFSETS are computed relative to the top of the frame. */ 1466 for (rn = 0; rn < CSKY_NUM_GREGS; rn++) 1467 { 1468 if (register_offsets[rn] >= 0) 1469 { 1470 this_cache->saved_regs[rn].addr 1471 = this_cache->prev_sp - register_offsets[rn]; 1472 if (csky_debug) 1473 { 1474 CORE_ADDR rn_value = read_memory_unsigned_integer ( 1475 this_cache->saved_regs[rn].addr, 4, byte_order); 1476 fprintf_unfiltered (gdb_stdlog, "Saved register %s " 1477 "stored at 0x%08lx, value=0x%08lx\n", 1478 csky_register_names[rn], 1479 (unsigned long) 1480 this_cache->saved_regs[rn].addr, 1481 (unsigned long) rn_value); 1482 } 1483 } 1484 } 1485 if (lr_type == LR_TYPE_EPC) 1486 { 1487 /* rte || epc . */ 1488 this_cache->saved_regs[CSKY_PC_REGNUM] 1489 = this_cache->saved_regs[CSKY_EPC_REGNUM]; 1490 } 1491 else if (lr_type == LR_TYPE_FPC) 1492 { 1493 /* rfi || fpc . */ 1494 this_cache->saved_regs[CSKY_PC_REGNUM] 1495 = this_cache->saved_regs[CSKY_FPC_REGNUM]; 1496 } 1497 else 1498 { 1499 this_cache->saved_regs[CSKY_PC_REGNUM] 1500 = this_cache->saved_regs[CSKY_LR_REGNUM]; 1501 } 1502 } 1503 1504 return addr; 1505 } 1506 1507 /* Detect whether PC is at a point where the stack frame has been 1508 destroyed. */ 1509 1510 static int 1511 csky_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc) 1512 { 1513 unsigned int insn; 1514 CORE_ADDR addr; 1515 CORE_ADDR func_start, func_end; 1516 1517 if (!find_pc_partial_function (pc, NULL, &func_start, &func_end)) 1518 return 0; 1519 1520 bool fp_saved = false; 1521 int insn_len; 1522 for (addr = func_start; addr < func_end; addr += insn_len) 1523 { 1524 /* Get next insn. */ 1525 insn_len = csky_get_insn (gdbarch, addr, &insn); 1526 1527 if (insn_len == 2) 1528 { 1529 /* Is sp is saved to fp. */ 1530 if (CSKY_16_IS_MOV_FP_SP (insn)) 1531 fp_saved = true; 1532 /* If sp was saved to fp and now being restored from 1533 fp then it indicates the start of epilog. */ 1534 else if (fp_saved && CSKY_16_IS_MOV_SP_FP (insn)) 1535 return pc >= addr; 1536 } 1537 } 1538 return 0; 1539 } 1540 1541 /* Implement the skip_prologue gdbarch hook. */ 1542 1543 static CORE_ADDR 1544 csky_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) 1545 { 1546 CORE_ADDR func_addr, func_end; 1547 struct symtab_and_line sal; 1548 const int default_search_limit = 128; 1549 1550 /* See if we can find the end of the prologue using the symbol table. */ 1551 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end)) 1552 { 1553 CORE_ADDR post_prologue_pc 1554 = skip_prologue_using_sal (gdbarch, func_addr); 1555 1556 if (post_prologue_pc != 0) 1557 return std::max (pc, post_prologue_pc); 1558 } 1559 else 1560 func_end = pc + default_search_limit; 1561 1562 /* Find the end of prologue. Default lr_type. */ 1563 return csky_analyze_prologue (gdbarch, pc, func_end, func_end, 1564 NULL, NULL, LR_TYPE_R15); 1565 } 1566 1567 /* Implement the breakpoint_kind_from_pc gdbarch method. */ 1568 1569 static int 1570 csky_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr) 1571 { 1572 if (csky_pc_is_csky16 (gdbarch, *pcptr)) 1573 return CSKY_INSN_SIZE16; 1574 else 1575 return CSKY_INSN_SIZE32; 1576 } 1577 1578 /* Implement the sw_breakpoint_from_kind gdbarch method. */ 1579 1580 static const gdb_byte * 1581 csky_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size) 1582 { 1583 *size = kind; 1584 if (kind == CSKY_INSN_SIZE16) 1585 { 1586 static gdb_byte csky_16_breakpoint[] = { 0, 0 }; 1587 return csky_16_breakpoint; 1588 } 1589 else 1590 { 1591 static gdb_byte csky_32_breakpoint[] = { 0, 0, 0, 0 }; 1592 return csky_32_breakpoint; 1593 } 1594 } 1595 1596 /* Implement the memory_insert_breakpoint gdbarch method. */ 1597 1598 static int 1599 csky_memory_insert_breakpoint (struct gdbarch *gdbarch, 1600 struct bp_target_info *bp_tgt) 1601 { 1602 int val; 1603 const unsigned char *bp; 1604 gdb_byte bp_write_record1[] = { 0, 0, 0, 0 }; 1605 gdb_byte bp_write_record2[] = { 0, 0, 0, 0 }; 1606 gdb_byte bp_record[] = { 0, 0, 0, 0 }; 1607 1608 /* Sanity-check bp_address. */ 1609 if (bp_tgt->reqstd_address % 2) 1610 warning (_("Invalid breakpoint address 0x%x is an odd number."), 1611 (unsigned int) bp_tgt->reqstd_address); 1612 scoped_restore restore_memory 1613 = make_scoped_restore_show_memory_breakpoints (1); 1614 1615 /* Determine appropriate breakpoint_kind for this address. */ 1616 bp_tgt->kind = csky_breakpoint_kind_from_pc (gdbarch, 1617 &bp_tgt->reqstd_address); 1618 1619 /* Save the memory contents. */ 1620 bp_tgt->shadow_len = bp_tgt->kind; 1621 1622 /* Fill bp_tgt->placed_address. */ 1623 bp_tgt->placed_address = bp_tgt->reqstd_address; 1624 1625 if (bp_tgt->kind == CSKY_INSN_SIZE16) 1626 { 1627 if ((bp_tgt->reqstd_address % 4) == 0) 1628 { 1629 /* Read two bytes. */ 1630 val = target_read_memory (bp_tgt->reqstd_address, 1631 bp_tgt->shadow_contents, 2); 1632 if (val) 1633 return val; 1634 1635 /* Read two bytes. */ 1636 val = target_read_memory (bp_tgt->reqstd_address + 2, 1637 bp_record, 2); 1638 if (val) 1639 return val; 1640 1641 /* Write the breakpoint. */ 1642 bp_write_record1[2] = bp_record[0]; 1643 bp_write_record1[3] = bp_record[1]; 1644 bp = bp_write_record1; 1645 val = target_write_raw_memory (bp_tgt->reqstd_address, bp, 1646 CSKY_WR_BKPT_MODE); 1647 } 1648 else 1649 { 1650 val = target_read_memory (bp_tgt->reqstd_address, 1651 bp_tgt->shadow_contents, 2); 1652 if (val) 1653 return val; 1654 1655 val = target_read_memory (bp_tgt->reqstd_address - 2, 1656 bp_record, 2); 1657 if (val) 1658 return val; 1659 1660 /* Write the breakpoint. */ 1661 bp_write_record1[0] = bp_record[0]; 1662 bp_write_record1[1] = bp_record[1]; 1663 bp = bp_write_record1; 1664 val = target_write_raw_memory (bp_tgt->reqstd_address - 2, 1665 bp, CSKY_WR_BKPT_MODE); 1666 } 1667 } 1668 else 1669 { 1670 if (bp_tgt->placed_address % 4 == 0) 1671 { 1672 val = target_read_memory (bp_tgt->reqstd_address, 1673 bp_tgt->shadow_contents, 1674 CSKY_WR_BKPT_MODE); 1675 if (val) 1676 return val; 1677 1678 /* Write the breakpoint. */ 1679 bp = bp_write_record1; 1680 val = target_write_raw_memory (bp_tgt->reqstd_address, 1681 bp, CSKY_WR_BKPT_MODE); 1682 } 1683 else 1684 { 1685 val = target_read_memory (bp_tgt->reqstd_address, 1686 bp_tgt->shadow_contents, 1687 CSKY_WR_BKPT_MODE); 1688 if (val) 1689 return val; 1690 1691 val = target_read_memory (bp_tgt->reqstd_address - 2, 1692 bp_record, 2); 1693 if (val) 1694 return val; 1695 1696 val = target_read_memory (bp_tgt->reqstd_address + 4, 1697 bp_record + 2, 2); 1698 if (val) 1699 return val; 1700 1701 bp_write_record1[0] = bp_record[0]; 1702 bp_write_record1[1] = bp_record[1]; 1703 bp_write_record2[2] = bp_record[2]; 1704 bp_write_record2[3] = bp_record[3]; 1705 1706 /* Write the breakpoint. */ 1707 bp = bp_write_record1; 1708 val = target_write_raw_memory (bp_tgt->reqstd_address - 2, bp, 1709 CSKY_WR_BKPT_MODE); 1710 if (val) 1711 return val; 1712 1713 /* Write the breakpoint. */ 1714 bp = bp_write_record2; 1715 val = target_write_raw_memory (bp_tgt->reqstd_address + 2, bp, 1716 CSKY_WR_BKPT_MODE); 1717 } 1718 } 1719 return val; 1720 } 1721 1722 /* Restore the breakpoint shadow_contents to the target. */ 1723 1724 static int 1725 csky_memory_remove_breakpoint (struct gdbarch *gdbarch, 1726 struct bp_target_info *bp_tgt) 1727 { 1728 int val; 1729 gdb_byte bp_record[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; 1730 /* Different for shadow_len 2 or 4. */ 1731 if (bp_tgt->shadow_len == 2) 1732 { 1733 /* Do word-sized writes on word-aligned boundaries and read 1734 padding bytes as necessary. */ 1735 if (bp_tgt->reqstd_address % 4 == 0) 1736 { 1737 val = target_read_memory (bp_tgt->reqstd_address + 2, 1738 bp_record + 2, 2); 1739 if (val) 1740 return val; 1741 bp_record[0] = bp_tgt->shadow_contents[0]; 1742 bp_record[1] = bp_tgt->shadow_contents[1]; 1743 return target_write_raw_memory (bp_tgt->reqstd_address, 1744 bp_record, CSKY_WR_BKPT_MODE); 1745 } 1746 else 1747 { 1748 val = target_read_memory (bp_tgt->reqstd_address - 2, 1749 bp_record, 2); 1750 if (val) 1751 return val; 1752 bp_record[2] = bp_tgt->shadow_contents[0]; 1753 bp_record[3] = bp_tgt->shadow_contents[1]; 1754 return target_write_raw_memory (bp_tgt->reqstd_address - 2, 1755 bp_record, CSKY_WR_BKPT_MODE); 1756 } 1757 } 1758 else 1759 { 1760 /* Do word-sized writes on word-aligned boundaries and read 1761 padding bytes as necessary. */ 1762 if (bp_tgt->placed_address % 4 == 0) 1763 { 1764 return target_write_raw_memory (bp_tgt->reqstd_address, 1765 bp_tgt->shadow_contents, 1766 CSKY_WR_BKPT_MODE); 1767 } 1768 else 1769 { 1770 val = target_read_memory (bp_tgt->reqstd_address - 2, 1771 bp_record, 2); 1772 if (val) 1773 return val; 1774 val = target_read_memory (bp_tgt->reqstd_address + 4, 1775 bp_record+6, 2); 1776 if (val) 1777 return val; 1778 1779 bp_record[2] = bp_tgt->shadow_contents[0]; 1780 bp_record[3] = bp_tgt->shadow_contents[1]; 1781 bp_record[4] = bp_tgt->shadow_contents[2]; 1782 bp_record[5] = bp_tgt->shadow_contents[3]; 1783 1784 return target_write_raw_memory (bp_tgt->reqstd_address - 2, 1785 bp_record, 1786 CSKY_WR_BKPT_MODE * 2); 1787 } 1788 } 1789 } 1790 1791 /* Determine link register type. */ 1792 1793 static lr_type_t 1794 csky_analyze_lr_type (struct gdbarch *gdbarch, 1795 CORE_ADDR start_pc, CORE_ADDR end_pc) 1796 { 1797 CORE_ADDR addr; 1798 unsigned int insn, insn_len; 1799 insn_len = 2; 1800 1801 for (addr = start_pc; addr < end_pc; addr += insn_len) 1802 { 1803 insn_len = csky_get_insn (gdbarch, addr, &insn); 1804 if (insn_len == 4) 1805 { 1806 if (CSKY_32_IS_MFCR_EPSR (insn) || CSKY_32_IS_MFCR_EPC (insn) 1807 || CSKY_32_IS_RTE (insn)) 1808 return LR_TYPE_EPC; 1809 } 1810 else if (CSKY_32_IS_MFCR_FPSR (insn) || CSKY_32_IS_MFCR_FPC (insn) 1811 || CSKY_32_IS_RFI (insn)) 1812 return LR_TYPE_FPC; 1813 else if (CSKY_32_IS_JMP (insn) || CSKY_32_IS_BR (insn) 1814 || CSKY_32_IS_JMPIX (insn) || CSKY_32_IS_JMPI (insn)) 1815 return LR_TYPE_R15; 1816 else 1817 { 1818 /* 16 bit instruction. */ 1819 if (CSKY_16_IS_JMP (insn) || CSKY_16_IS_BR (insn) 1820 || CSKY_16_IS_JMPIX (insn)) 1821 return LR_TYPE_R15; 1822 } 1823 } 1824 return LR_TYPE_R15; 1825 } 1826 1827 /* Heuristic unwinder. */ 1828 1829 static struct csky_unwind_cache * 1830 csky_frame_unwind_cache (struct frame_info *this_frame) 1831 { 1832 CORE_ADDR prologue_start, prologue_end, func_end, prev_pc, block_addr; 1833 struct csky_unwind_cache *cache; 1834 const struct block *bl; 1835 unsigned long func_size = 0; 1836 struct gdbarch *gdbarch = get_frame_arch (this_frame); 1837 unsigned int sp_regnum = CSKY_SP_REGNUM; 1838 1839 /* Default lr type is r15. */ 1840 lr_type_t lr_type = LR_TYPE_R15; 1841 1842 cache = FRAME_OBSTACK_ZALLOC (struct csky_unwind_cache); 1843 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame); 1844 1845 /* Assume there is no frame until proven otherwise. */ 1846 cache->framereg = sp_regnum; 1847 1848 cache->framesize = 0; 1849 1850 prev_pc = get_frame_pc (this_frame); 1851 block_addr = get_frame_address_in_block (this_frame); 1852 if (find_pc_partial_function (block_addr, NULL, &prologue_start, 1853 &func_end) == 0) 1854 /* We couldn't find a function containing block_addr, so bail out 1855 and hope for the best. */ 1856 return cache; 1857 1858 /* Get the (function) symbol matching prologue_start. */ 1859 bl = block_for_pc (prologue_start); 1860 if (bl != NULL) 1861 func_size = bl->endaddr - bl->startaddr; 1862 else 1863 { 1864 struct bound_minimal_symbol msymbol 1865 = lookup_minimal_symbol_by_pc (prologue_start); 1866 if (msymbol.minsym != NULL) 1867 func_size = MSYMBOL_SIZE (msymbol.minsym); 1868 } 1869 1870 /* If FUNC_SIZE is 0 we may have a special-case use of lr 1871 e.g. exception or interrupt. */ 1872 if (func_size == 0) 1873 lr_type = csky_analyze_lr_type (gdbarch, prologue_start, func_end); 1874 1875 prologue_end = std::min (func_end, prev_pc); 1876 1877 /* Analyze the function prologue. */ 1878 csky_analyze_prologue (gdbarch, prologue_start, prologue_end, 1879 func_end, this_frame, cache, lr_type); 1880 1881 /* gdbarch_sp_regnum contains the value and not the address. */ 1882 trad_frame_set_value (cache->saved_regs, sp_regnum, cache->prev_sp); 1883 return cache; 1884 } 1885 1886 /* Implement the unwind_pc gdbarch method. */ 1887 1888 static CORE_ADDR 1889 csky_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) 1890 { 1891 return frame_unwind_register_unsigned (next_frame, CSKY_PC_REGNUM); 1892 } 1893 1894 /* Implement the this_id function for the normal unwinder. */ 1895 1896 static void 1897 csky_frame_this_id (struct frame_info *this_frame, 1898 void **this_prologue_cache, struct frame_id *this_id) 1899 { 1900 struct csky_unwind_cache *cache; 1901 struct frame_id id; 1902 1903 if (*this_prologue_cache == NULL) 1904 *this_prologue_cache = csky_frame_unwind_cache (this_frame); 1905 cache = (struct csky_unwind_cache *) *this_prologue_cache; 1906 1907 /* This marks the outermost frame. */ 1908 if (cache->prev_sp == 0) 1909 return; 1910 1911 id = frame_id_build (cache->prev_sp, get_frame_func (this_frame)); 1912 *this_id = id; 1913 } 1914 1915 /* Implement the prev_register function for the normal unwinder. */ 1916 1917 static struct value * 1918 csky_frame_prev_register (struct frame_info *this_frame, 1919 void **this_prologue_cache, int regnum) 1920 { 1921 struct csky_unwind_cache *cache; 1922 1923 if (*this_prologue_cache == NULL) 1924 *this_prologue_cache = csky_frame_unwind_cache (this_frame); 1925 cache = (struct csky_unwind_cache *) *this_prologue_cache; 1926 1927 return trad_frame_get_prev_register (this_frame, cache->saved_regs, 1928 regnum); 1929 } 1930 1931 /* Data structures for the normal prologue-analysis-based 1932 unwinder. */ 1933 1934 static const struct frame_unwind csky_unwind_cache = { 1935 NORMAL_FRAME, 1936 default_frame_unwind_stop_reason, 1937 csky_frame_this_id, 1938 csky_frame_prev_register, 1939 NULL, 1940 default_frame_sniffer, 1941 NULL, 1942 NULL 1943 }; 1944 1945 1946 1947 static int 1948 csky_stub_unwind_sniffer (const struct frame_unwind *self, 1949 struct frame_info *this_frame, 1950 void **this_prologue_cache) 1951 { 1952 CORE_ADDR addr_in_block; 1953 1954 addr_in_block = get_frame_address_in_block (this_frame); 1955 1956 if (find_pc_partial_function (addr_in_block, NULL, NULL, NULL) == 0 1957 || in_plt_section (addr_in_block)) 1958 return 1; 1959 1960 return 0; 1961 } 1962 1963 static struct csky_unwind_cache * 1964 csky_make_stub_cache (struct frame_info *this_frame) 1965 { 1966 struct csky_unwind_cache *cache; 1967 1968 cache = FRAME_OBSTACK_ZALLOC (struct csky_unwind_cache); 1969 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame); 1970 cache->prev_sp = get_frame_register_unsigned (this_frame, CSKY_SP_REGNUM); 1971 1972 return cache; 1973 } 1974 1975 static void 1976 csky_stub_this_id (struct frame_info *this_frame, 1977 void **this_cache, 1978 struct frame_id *this_id) 1979 { 1980 struct csky_unwind_cache *cache; 1981 1982 if (*this_cache == NULL) 1983 *this_cache = csky_make_stub_cache (this_frame); 1984 cache = (struct csky_unwind_cache *) *this_cache; 1985 1986 /* Our frame ID for a stub frame is the current SP and LR. */ 1987 *this_id = frame_id_build (cache->prev_sp, get_frame_pc (this_frame)); 1988 } 1989 1990 static struct value * 1991 csky_stub_prev_register (struct frame_info *this_frame, 1992 void **this_cache, 1993 int prev_regnum) 1994 { 1995 struct csky_unwind_cache *cache; 1996 1997 if (*this_cache == NULL) 1998 *this_cache = csky_make_stub_cache (this_frame); 1999 cache = (struct csky_unwind_cache *) *this_cache; 2000 2001 /* If we are asked to unwind the PC, then return the LR. */ 2002 if (prev_regnum == CSKY_PC_REGNUM) 2003 { 2004 CORE_ADDR lr; 2005 2006 lr = frame_unwind_register_unsigned (this_frame, CSKY_LR_REGNUM); 2007 return frame_unwind_got_constant (this_frame, prev_regnum, lr); 2008 } 2009 2010 if (prev_regnum == CSKY_SP_REGNUM) 2011 return frame_unwind_got_constant (this_frame, prev_regnum, cache->prev_sp); 2012 2013 return trad_frame_get_prev_register (this_frame, cache->saved_regs, 2014 prev_regnum); 2015 } 2016 2017 struct frame_unwind csky_stub_unwind = { 2018 NORMAL_FRAME, 2019 default_frame_unwind_stop_reason, 2020 csky_stub_this_id, 2021 csky_stub_prev_register, 2022 NULL, 2023 csky_stub_unwind_sniffer 2024 }; 2025 2026 /* Implement the this_base, this_locals, and this_args hooks 2027 for the normal unwinder. */ 2028 2029 static CORE_ADDR 2030 csky_frame_base_address (struct frame_info *this_frame, void **this_cache) 2031 { 2032 struct csky_unwind_cache *cache; 2033 2034 if (*this_cache == NULL) 2035 *this_cache = csky_frame_unwind_cache (this_frame); 2036 cache = (struct csky_unwind_cache *) *this_cache; 2037 2038 return cache->prev_sp - cache->framesize; 2039 } 2040 2041 static const struct frame_base csky_frame_base = { 2042 &csky_unwind_cache, 2043 csky_frame_base_address, 2044 csky_frame_base_address, 2045 csky_frame_base_address 2046 }; 2047 2048 /* Implement the dummy_id gdbarch method. The frame ID's base 2049 needs to match the TOS value saved by save_dummy_frame_tos, 2050 and the PC should match the dummy frame's breakpoint. */ 2051 2052 static struct frame_id 2053 csky_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) 2054 { 2055 unsigned int sp_regnum = CSKY_SP_REGNUM; 2056 2057 CORE_ADDR sp = get_frame_register_unsigned (this_frame, sp_regnum); 2058 return frame_id_build (sp, get_frame_pc (this_frame)); 2059 } 2060 2061 /* Initialize register access method. */ 2062 2063 static void 2064 csky_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum, 2065 struct dwarf2_frame_state_reg *reg, 2066 struct frame_info *this_frame) 2067 { 2068 if (regnum == gdbarch_pc_regnum (gdbarch)) 2069 reg->how = DWARF2_FRAME_REG_RA; 2070 else if (regnum == gdbarch_sp_regnum (gdbarch)) 2071 reg->how = DWARF2_FRAME_REG_CFA; 2072 } 2073 2074 /* Create csky register groups. */ 2075 2076 static void 2077 csky_init_reggroup () 2078 { 2079 cr_reggroup = reggroup_new ("cr", USER_REGGROUP); 2080 fr_reggroup = reggroup_new ("fr", USER_REGGROUP); 2081 vr_reggroup = reggroup_new ("vr", USER_REGGROUP); 2082 mmu_reggroup = reggroup_new ("mmu", USER_REGGROUP); 2083 prof_reggroup = reggroup_new ("profiling", USER_REGGROUP); 2084 } 2085 2086 /* Add register groups into reggroup list. */ 2087 2088 static void 2089 csky_add_reggroups (struct gdbarch *gdbarch) 2090 { 2091 reggroup_add (gdbarch, all_reggroup); 2092 reggroup_add (gdbarch, general_reggroup); 2093 reggroup_add (gdbarch, cr_reggroup); 2094 reggroup_add (gdbarch, fr_reggroup); 2095 reggroup_add (gdbarch, vr_reggroup); 2096 reggroup_add (gdbarch, mmu_reggroup); 2097 reggroup_add (gdbarch, prof_reggroup); 2098 } 2099 2100 /* Return the groups that a CSKY register can be categorised into. */ 2101 2102 static int 2103 csky_register_reggroup_p (struct gdbarch *gdbarch, int regnum, 2104 struct reggroup *reggroup) 2105 { 2106 int raw_p; 2107 2108 if (gdbarch_register_name (gdbarch, regnum) == NULL 2109 || gdbarch_register_name (gdbarch, regnum)[0] == '\0') 2110 return 0; 2111 2112 if (reggroup == all_reggroup) 2113 return 1; 2114 2115 raw_p = regnum < gdbarch_num_regs (gdbarch); 2116 if (reggroup == save_reggroup || reggroup == restore_reggroup) 2117 return raw_p; 2118 2119 if (((regnum >= CSKY_R0_REGNUM) && (regnum <= CSKY_R0_REGNUM + 31)) 2120 && (reggroup == general_reggroup)) 2121 return 1; 2122 2123 if (((regnum == CSKY_PC_REGNUM) 2124 || ((regnum >= CSKY_CR0_REGNUM) 2125 && (regnum <= CSKY_CR0_REGNUM + 30))) 2126 && (reggroup == cr_reggroup)) 2127 return 2; 2128 2129 if ((((regnum >= CSKY_VR0_REGNUM) && (regnum <= CSKY_VR0_REGNUM + 15)) 2130 || ((regnum >= CSKY_VCR0_REGNUM) 2131 && (regnum <= CSKY_VCR0_REGNUM + 2))) 2132 && (reggroup == vr_reggroup)) 2133 return 3; 2134 2135 if (((regnum >= CSKY_MMU_REGNUM) && (regnum <= CSKY_MMU_REGNUM + 8)) 2136 && (reggroup == mmu_reggroup)) 2137 return 4; 2138 2139 if (((regnum >= CSKY_PROFCR_REGNUM) 2140 && (regnum <= CSKY_PROFCR_REGNUM + 48)) 2141 && (reggroup == prof_reggroup)) 2142 return 5; 2143 2144 if ((((regnum >= CSKY_FR0_REGNUM) && (regnum <= CSKY_FR0_REGNUM + 15)) 2145 || ((regnum >= CSKY_VCR0_REGNUM) && (regnum <= CSKY_VCR0_REGNUM + 2))) 2146 && (reggroup == fr_reggroup)) 2147 return 6; 2148 2149 return 0; 2150 } 2151 2152 /* Implement the dwarf2_reg_to_regnum gdbarch method. */ 2153 2154 static int 2155 csky_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dw_reg) 2156 { 2157 if (dw_reg < 0 || dw_reg >= CSKY_NUM_REGS) 2158 return -1; 2159 return dw_reg; 2160 } 2161 2162 /* Override interface for command: info register. */ 2163 2164 static void 2165 csky_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, 2166 struct frame_info *frame, int regnum, int all) 2167 { 2168 /* Call default print_registers_info function. */ 2169 default_print_registers_info (gdbarch, file, frame, regnum, all); 2170 2171 /* For command: info register. */ 2172 if (regnum == -1 && all == 0) 2173 { 2174 default_print_registers_info (gdbarch, file, frame, 2175 CSKY_PC_REGNUM, 0); 2176 default_print_registers_info (gdbarch, file, frame, 2177 CSKY_EPC_REGNUM, 0); 2178 default_print_registers_info (gdbarch, file, frame, 2179 CSKY_CR0_REGNUM, 0); 2180 default_print_registers_info (gdbarch, file, frame, 2181 CSKY_EPSR_REGNUM, 0); 2182 } 2183 return; 2184 } 2185 2186 /* Initialize the current architecture based on INFO. If possible, 2187 re-use an architecture from ARCHES, which is a list of 2188 architectures already created during this debugging session. 2189 2190 Called at program startup, when reading a core file, and when 2191 reading a binary file. */ 2192 2193 static struct gdbarch * 2194 csky_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 2195 { 2196 struct gdbarch *gdbarch; 2197 struct gdbarch_tdep *tdep; 2198 2199 /* Find a candidate among the list of pre-declared architectures. */ 2200 arches = gdbarch_list_lookup_by_info (arches, &info); 2201 if (arches != NULL) 2202 return arches->gdbarch; 2203 2204 /* None found, create a new architecture from the information 2205 provided. */ 2206 tdep = XCNEW (struct gdbarch_tdep); 2207 gdbarch = gdbarch_alloc (&info, tdep); 2208 2209 /* Target data types. */ 2210 set_gdbarch_ptr_bit (gdbarch, 32); 2211 set_gdbarch_addr_bit (gdbarch, 32); 2212 set_gdbarch_short_bit (gdbarch, 16); 2213 set_gdbarch_int_bit (gdbarch, 32); 2214 set_gdbarch_long_bit (gdbarch, 32); 2215 set_gdbarch_long_long_bit (gdbarch, 64); 2216 set_gdbarch_float_bit (gdbarch, 32); 2217 set_gdbarch_double_bit (gdbarch, 64); 2218 set_gdbarch_float_format (gdbarch, floatformats_ieee_single); 2219 set_gdbarch_double_format (gdbarch, floatformats_ieee_double); 2220 2221 /* Information about the target architecture. */ 2222 set_gdbarch_return_value (gdbarch, csky_return_value); 2223 set_gdbarch_breakpoint_kind_from_pc (gdbarch, csky_breakpoint_kind_from_pc); 2224 set_gdbarch_sw_breakpoint_from_kind (gdbarch, csky_sw_breakpoint_from_kind); 2225 2226 /* Register architecture. */ 2227 set_gdbarch_num_regs (gdbarch, CSKY_NUM_REGS); 2228 set_gdbarch_pc_regnum (gdbarch, CSKY_PC_REGNUM); 2229 set_gdbarch_sp_regnum (gdbarch, CSKY_SP_REGNUM); 2230 set_gdbarch_register_name (gdbarch, csky_register_name); 2231 set_gdbarch_register_type (gdbarch, csky_register_type); 2232 set_gdbarch_read_pc (gdbarch, csky_read_pc); 2233 set_gdbarch_write_pc (gdbarch, csky_write_pc); 2234 set_gdbarch_print_registers_info (gdbarch, csky_print_registers_info); 2235 csky_add_reggroups (gdbarch); 2236 set_gdbarch_register_reggroup_p (gdbarch, csky_register_reggroup_p); 2237 set_gdbarch_stab_reg_to_regnum (gdbarch, csky_dwarf_reg_to_regnum); 2238 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, csky_dwarf_reg_to_regnum); 2239 dwarf2_frame_set_init_reg (gdbarch, csky_dwarf2_frame_init_reg); 2240 2241 /* Functions to analyze frames. */ 2242 frame_base_set_default (gdbarch, &csky_frame_base); 2243 set_gdbarch_skip_prologue (gdbarch, csky_skip_prologue); 2244 set_gdbarch_inner_than (gdbarch, core_addr_lessthan); 2245 set_gdbarch_frame_align (gdbarch, csky_frame_align); 2246 set_gdbarch_stack_frame_destroyed_p (gdbarch, csky_stack_frame_destroyed_p); 2247 2248 /* Functions to access frame data. */ 2249 set_gdbarch_unwind_pc (gdbarch, csky_unwind_pc); 2250 set_gdbarch_unwind_sp (gdbarch, csky_unwind_sp); 2251 2252 /* Functions handling dummy frames. */ 2253 set_gdbarch_push_dummy_call (gdbarch, csky_push_dummy_call); 2254 set_gdbarch_dummy_id (gdbarch, csky_dummy_id); 2255 2256 /* Frame unwinders. Use DWARF debug info if available, 2257 otherwise use our own unwinder. */ 2258 dwarf2_append_unwinders (gdbarch); 2259 frame_unwind_append_unwinder (gdbarch, &csky_stub_unwind); 2260 frame_unwind_append_unwinder (gdbarch, &csky_unwind_cache); 2261 2262 /* Breakpoints. */ 2263 set_gdbarch_memory_insert_breakpoint (gdbarch, 2264 csky_memory_insert_breakpoint); 2265 set_gdbarch_memory_remove_breakpoint (gdbarch, 2266 csky_memory_remove_breakpoint); 2267 2268 /* Hook in ABI-specific overrides, if they have been registered. */ 2269 gdbarch_init_osabi (info, gdbarch); 2270 2271 /* Support simple overlay manager. */ 2272 set_gdbarch_overlay_update (gdbarch, simple_overlay_update); 2273 set_gdbarch_char_signed (gdbarch, 0); 2274 return gdbarch; 2275 } 2276 2277 void 2278 _initialize_csky_tdep (void) 2279 { 2280 2281 register_gdbarch_init (bfd_arch_csky, csky_gdbarch_init); 2282 2283 csky_init_reggroup (); 2284 2285 /* Allow debugging this file's internals. */ 2286 add_setshow_boolean_cmd ("csky", class_maintenance, &csky_debug, 2287 _("Set C-Sky debugging."), 2288 _("Show C-Sky debugging."), 2289 _("When on, C-Sky specific debugging is enabled."), 2290 NULL, 2291 NULL, 2292 &setdebuglist, &showdebuglist); 2293 } 2294