rx-tdep.c revision 1.8
1/* Target-dependent code for the Renesas RX for GDB, the GNU debugger. 2 3 Copyright (C) 2008-2019 Free Software Foundation, Inc. 4 5 Contributed by Red Hat, Inc. 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 "arch-utils.h" 24#include "prologue-value.h" 25#include "target.h" 26#include "regcache.h" 27#include "opcode/rx.h" 28#include "dis-asm.h" 29#include "gdbtypes.h" 30#include "frame.h" 31#include "frame-unwind.h" 32#include "frame-base.h" 33#include "value.h" 34#include "gdbcore.h" 35#include "dwarf2-frame.h" 36 37#include "elf/rx.h" 38#include "elf-bfd.h" 39#include <algorithm> 40 41/* Certain important register numbers. */ 42enum 43{ 44 RX_SP_REGNUM = 0, 45 RX_R1_REGNUM = 1, 46 RX_R4_REGNUM = 4, 47 RX_FP_REGNUM = 6, 48 RX_R15_REGNUM = 15, 49 RX_USP_REGNUM = 16, 50 RX_PSW_REGNUM = 18, 51 RX_PC_REGNUM = 19, 52 RX_BPSW_REGNUM = 21, 53 RX_BPC_REGNUM = 22, 54 RX_FPSW_REGNUM = 24, 55 RX_ACC_REGNUM = 25, 56 RX_NUM_REGS = 26 57}; 58 59/* RX frame types. */ 60enum rx_frame_type { 61 RX_FRAME_TYPE_NORMAL, 62 RX_FRAME_TYPE_EXCEPTION, 63 RX_FRAME_TYPE_FAST_INTERRUPT 64}; 65 66/* Architecture specific data. */ 67struct gdbarch_tdep 68{ 69 /* The ELF header flags specify the multilib used. */ 70 int elf_flags; 71 72 /* Type of PSW and BPSW. */ 73 struct type *rx_psw_type; 74 75 /* Type of FPSW. */ 76 struct type *rx_fpsw_type; 77}; 78 79/* This structure holds the results of a prologue analysis. */ 80struct rx_prologue 81{ 82 /* Frame type, either a normal frame or one of two types of exception 83 frames. */ 84 enum rx_frame_type frame_type; 85 86 /* The offset from the frame base to the stack pointer --- always 87 zero or negative. 88 89 Calling this a "size" is a bit misleading, but given that the 90 stack grows downwards, using offsets for everything keeps one 91 from going completely sign-crazy: you never change anything's 92 sign for an ADD instruction; always change the second operand's 93 sign for a SUB instruction; and everything takes care of 94 itself. */ 95 int frame_size; 96 97 /* Non-zero if this function has initialized the frame pointer from 98 the stack pointer, zero otherwise. */ 99 int has_frame_ptr; 100 101 /* If has_frame_ptr is non-zero, this is the offset from the frame 102 base to where the frame pointer points. This is always zero or 103 negative. */ 104 int frame_ptr_offset; 105 106 /* The address of the first instruction at which the frame has been 107 set up and the arguments are where the debug info says they are 108 --- as best as we can tell. */ 109 CORE_ADDR prologue_end; 110 111 /* reg_offset[R] is the offset from the CFA at which register R is 112 saved, or 1 if register R has not been saved. (Real values are 113 always zero or negative.) */ 114 int reg_offset[RX_NUM_REGS]; 115}; 116 117/* Implement the "register_name" gdbarch method. */ 118static const char * 119rx_register_name (struct gdbarch *gdbarch, int regnr) 120{ 121 static const char *const reg_names[] = { 122 "r0", 123 "r1", 124 "r2", 125 "r3", 126 "r4", 127 "r5", 128 "r6", 129 "r7", 130 "r8", 131 "r9", 132 "r10", 133 "r11", 134 "r12", 135 "r13", 136 "r14", 137 "r15", 138 "usp", 139 "isp", 140 "psw", 141 "pc", 142 "intb", 143 "bpsw", 144 "bpc", 145 "fintv", 146 "fpsw", 147 "acc" 148 }; 149 150 return reg_names[regnr]; 151} 152 153/* Construct the flags type for PSW and BPSW. */ 154 155static struct type * 156rx_psw_type (struct gdbarch *gdbarch) 157{ 158 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 159 160 if (tdep->rx_psw_type == NULL) 161 { 162 tdep->rx_psw_type = arch_flags_type (gdbarch, "rx_psw_type", 32); 163 append_flags_type_flag (tdep->rx_psw_type, 0, "C"); 164 append_flags_type_flag (tdep->rx_psw_type, 1, "Z"); 165 append_flags_type_flag (tdep->rx_psw_type, 2, "S"); 166 append_flags_type_flag (tdep->rx_psw_type, 3, "O"); 167 append_flags_type_flag (tdep->rx_psw_type, 16, "I"); 168 append_flags_type_flag (tdep->rx_psw_type, 17, "U"); 169 append_flags_type_flag (tdep->rx_psw_type, 20, "PM"); 170 append_flags_type_flag (tdep->rx_psw_type, 24, "IPL0"); 171 append_flags_type_flag (tdep->rx_psw_type, 25, "IPL1"); 172 append_flags_type_flag (tdep->rx_psw_type, 26, "IPL2"); 173 append_flags_type_flag (tdep->rx_psw_type, 27, "IPL3"); 174 } 175 return tdep->rx_psw_type; 176} 177 178/* Construct flags type for FPSW. */ 179 180static struct type * 181rx_fpsw_type (struct gdbarch *gdbarch) 182{ 183 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 184 185 if (tdep->rx_fpsw_type == NULL) 186 { 187 tdep->rx_fpsw_type = arch_flags_type (gdbarch, "rx_fpsw_type", 32); 188 append_flags_type_flag (tdep->rx_fpsw_type, 0, "RM0"); 189 append_flags_type_flag (tdep->rx_fpsw_type, 1, "RM1"); 190 append_flags_type_flag (tdep->rx_fpsw_type, 2, "CV"); 191 append_flags_type_flag (tdep->rx_fpsw_type, 3, "CO"); 192 append_flags_type_flag (tdep->rx_fpsw_type, 4, "CZ"); 193 append_flags_type_flag (tdep->rx_fpsw_type, 5, "CU"); 194 append_flags_type_flag (tdep->rx_fpsw_type, 6, "CX"); 195 append_flags_type_flag (tdep->rx_fpsw_type, 7, "CE"); 196 append_flags_type_flag (tdep->rx_fpsw_type, 8, "DN"); 197 append_flags_type_flag (tdep->rx_fpsw_type, 10, "EV"); 198 append_flags_type_flag (tdep->rx_fpsw_type, 11, "EO"); 199 append_flags_type_flag (tdep->rx_fpsw_type, 12, "EZ"); 200 append_flags_type_flag (tdep->rx_fpsw_type, 13, "EU"); 201 append_flags_type_flag (tdep->rx_fpsw_type, 14, "EX"); 202 append_flags_type_flag (tdep->rx_fpsw_type, 26, "FV"); 203 append_flags_type_flag (tdep->rx_fpsw_type, 27, "FO"); 204 append_flags_type_flag (tdep->rx_fpsw_type, 28, "FZ"); 205 append_flags_type_flag (tdep->rx_fpsw_type, 29, "FU"); 206 append_flags_type_flag (tdep->rx_fpsw_type, 30, "FX"); 207 append_flags_type_flag (tdep->rx_fpsw_type, 31, "FS"); 208 } 209 210 return tdep->rx_fpsw_type; 211} 212 213/* Implement the "register_type" gdbarch method. */ 214static struct type * 215rx_register_type (struct gdbarch *gdbarch, int reg_nr) 216{ 217 if (reg_nr == RX_PC_REGNUM) 218 return builtin_type (gdbarch)->builtin_func_ptr; 219 else if (reg_nr == RX_PSW_REGNUM || reg_nr == RX_BPSW_REGNUM) 220 return rx_psw_type (gdbarch); 221 else if (reg_nr == RX_FPSW_REGNUM) 222 return rx_fpsw_type (gdbarch); 223 else if (reg_nr == RX_ACC_REGNUM) 224 return builtin_type (gdbarch)->builtin_unsigned_long_long; 225 else 226 return builtin_type (gdbarch)->builtin_unsigned_long; 227} 228 229 230/* Function for finding saved registers in a 'struct pv_area'; this 231 function is passed to pv_area::scan. 232 233 If VALUE is a saved register, ADDR says it was saved at a constant 234 offset from the frame base, and SIZE indicates that the whole 235 register was saved, record its offset. */ 236static void 237check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size, pv_t value) 238{ 239 struct rx_prologue *result = (struct rx_prologue *) result_untyped; 240 241 if (value.kind == pvk_register 242 && value.k == 0 243 && pv_is_register (addr, RX_SP_REGNUM) 244 && size == register_size (target_gdbarch (), value.reg)) 245 result->reg_offset[value.reg] = addr.k; 246} 247 248/* Define a "handle" struct for fetching the next opcode. */ 249struct rx_get_opcode_byte_handle 250{ 251 CORE_ADDR pc; 252}; 253 254/* Fetch a byte on behalf of the opcode decoder. HANDLE contains 255 the memory address of the next byte to fetch. If successful, 256 the address in the handle is updated and the byte fetched is 257 returned as the value of the function. If not successful, -1 258 is returned. */ 259static int 260rx_get_opcode_byte (void *handle) 261{ 262 struct rx_get_opcode_byte_handle *opcdata 263 = (struct rx_get_opcode_byte_handle *) handle; 264 int status; 265 gdb_byte byte; 266 267 status = target_read_code (opcdata->pc, &byte, 1); 268 if (status == 0) 269 { 270 opcdata->pc += 1; 271 return byte; 272 } 273 else 274 return -1; 275} 276 277/* Analyze a prologue starting at START_PC, going no further than 278 LIMIT_PC. Fill in RESULT as appropriate. */ 279 280static void 281rx_analyze_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc, 282 enum rx_frame_type frame_type, 283 struct rx_prologue *result) 284{ 285 CORE_ADDR pc, next_pc; 286 int rn; 287 pv_t reg[RX_NUM_REGS]; 288 CORE_ADDR after_last_frame_setup_insn = start_pc; 289 290 memset (result, 0, sizeof (*result)); 291 292 result->frame_type = frame_type; 293 294 for (rn = 0; rn < RX_NUM_REGS; rn++) 295 { 296 reg[rn] = pv_register (rn, 0); 297 result->reg_offset[rn] = 1; 298 } 299 300 pv_area stack (RX_SP_REGNUM, gdbarch_addr_bit (target_gdbarch ())); 301 302 if (frame_type == RX_FRAME_TYPE_FAST_INTERRUPT) 303 { 304 /* This code won't do anything useful at present, but this is 305 what happens for fast interrupts. */ 306 reg[RX_BPSW_REGNUM] = reg[RX_PSW_REGNUM]; 307 reg[RX_BPC_REGNUM] = reg[RX_PC_REGNUM]; 308 } 309 else 310 { 311 /* When an exception occurs, the PSW is saved to the interrupt stack 312 first. */ 313 if (frame_type == RX_FRAME_TYPE_EXCEPTION) 314 { 315 reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4); 316 stack.store (reg[RX_SP_REGNUM], 4, reg[RX_PSW_REGNUM]); 317 } 318 319 /* The call instruction (or an exception/interrupt) has saved the return 320 address on the stack. */ 321 reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4); 322 stack.store (reg[RX_SP_REGNUM], 4, reg[RX_PC_REGNUM]); 323 324 } 325 326 327 pc = start_pc; 328 while (pc < limit_pc) 329 { 330 int bytes_read; 331 struct rx_get_opcode_byte_handle opcode_handle; 332 RX_Opcode_Decoded opc; 333 334 opcode_handle.pc = pc; 335 bytes_read = rx_decode_opcode (pc, &opc, rx_get_opcode_byte, 336 &opcode_handle); 337 next_pc = pc + bytes_read; 338 339 if (opc.id == RXO_pushm /* pushm r1, r2 */ 340 && opc.op[1].type == RX_Operand_Register 341 && opc.op[2].type == RX_Operand_Register) 342 { 343 int r1, r2; 344 int r; 345 346 r1 = opc.op[1].reg; 347 r2 = opc.op[2].reg; 348 for (r = r2; r >= r1; r--) 349 { 350 reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4); 351 stack.store (reg[RX_SP_REGNUM], 4, reg[r]); 352 } 353 after_last_frame_setup_insn = next_pc; 354 } 355 else if (opc.id == RXO_mov /* mov.l rdst, rsrc */ 356 && opc.op[0].type == RX_Operand_Register 357 && opc.op[1].type == RX_Operand_Register 358 && opc.size == RX_Long) 359 { 360 int rdst, rsrc; 361 362 rdst = opc.op[0].reg; 363 rsrc = opc.op[1].reg; 364 reg[rdst] = reg[rsrc]; 365 if (rdst == RX_FP_REGNUM && rsrc == RX_SP_REGNUM) 366 after_last_frame_setup_insn = next_pc; 367 } 368 else if (opc.id == RXO_mov /* mov.l rsrc, [-SP] */ 369 && opc.op[0].type == RX_Operand_Predec 370 && opc.op[0].reg == RX_SP_REGNUM 371 && opc.op[1].type == RX_Operand_Register 372 && opc.size == RX_Long) 373 { 374 int rsrc; 375 376 rsrc = opc.op[1].reg; 377 reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4); 378 stack.store (reg[RX_SP_REGNUM], 4, reg[rsrc]); 379 after_last_frame_setup_insn = next_pc; 380 } 381 else if (opc.id == RXO_add /* add #const, rsrc, rdst */ 382 && opc.op[0].type == RX_Operand_Register 383 && opc.op[1].type == RX_Operand_Immediate 384 && opc.op[2].type == RX_Operand_Register) 385 { 386 int rdst = opc.op[0].reg; 387 int addend = opc.op[1].addend; 388 int rsrc = opc.op[2].reg; 389 reg[rdst] = pv_add_constant (reg[rsrc], addend); 390 /* Negative adjustments to the stack pointer or frame pointer 391 are (most likely) part of the prologue. */ 392 if ((rdst == RX_SP_REGNUM || rdst == RX_FP_REGNUM) && addend < 0) 393 after_last_frame_setup_insn = next_pc; 394 } 395 else if (opc.id == RXO_mov 396 && opc.op[0].type == RX_Operand_Indirect 397 && opc.op[1].type == RX_Operand_Register 398 && opc.size == RX_Long 399 && (opc.op[0].reg == RX_SP_REGNUM 400 || opc.op[0].reg == RX_FP_REGNUM) 401 && (RX_R1_REGNUM <= opc.op[1].reg 402 && opc.op[1].reg <= RX_R4_REGNUM)) 403 { 404 /* This moves an argument register to the stack. Don't 405 record it, but allow it to be a part of the prologue. */ 406 } 407 else if (opc.id == RXO_branch 408 && opc.op[0].type == RX_Operand_Immediate 409 && next_pc < opc.op[0].addend) 410 { 411 /* When a loop appears as the first statement of a function 412 body, gcc 4.x will use a BRA instruction to branch to the 413 loop condition checking code. This BRA instruction is 414 marked as part of the prologue. We therefore set next_pc 415 to this branch target and also stop the prologue scan. 416 The instructions at and beyond the branch target should 417 no longer be associated with the prologue. 418 419 Note that we only consider forward branches here. We 420 presume that a forward branch is being used to skip over 421 a loop body. 422 423 A backwards branch is covered by the default case below. 424 If we were to encounter a backwards branch, that would 425 most likely mean that we've scanned through a loop body. 426 We definitely want to stop the prologue scan when this 427 happens and that is precisely what is done by the default 428 case below. */ 429 430 after_last_frame_setup_insn = opc.op[0].addend; 431 break; /* Scan no further if we hit this case. */ 432 } 433 else 434 { 435 /* Terminate the prologue scan. */ 436 break; 437 } 438 439 pc = next_pc; 440 } 441 442 /* Is the frame size (offset, really) a known constant? */ 443 if (pv_is_register (reg[RX_SP_REGNUM], RX_SP_REGNUM)) 444 result->frame_size = reg[RX_SP_REGNUM].k; 445 446 /* Was the frame pointer initialized? */ 447 if (pv_is_register (reg[RX_FP_REGNUM], RX_SP_REGNUM)) 448 { 449 result->has_frame_ptr = 1; 450 result->frame_ptr_offset = reg[RX_FP_REGNUM].k; 451 } 452 453 /* Record where all the registers were saved. */ 454 stack.scan (check_for_saved, (void *) result); 455 456 result->prologue_end = after_last_frame_setup_insn; 457} 458 459 460/* Implement the "skip_prologue" gdbarch method. */ 461static CORE_ADDR 462rx_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) 463{ 464 const char *name; 465 CORE_ADDR func_addr, func_end; 466 struct rx_prologue p; 467 468 /* Try to find the extent of the function that contains PC. */ 469 if (!find_pc_partial_function (pc, &name, &func_addr, &func_end)) 470 return pc; 471 472 /* The frame type doesn't matter here, since we only care about 473 where the prologue ends. We'll use RX_FRAME_TYPE_NORMAL. */ 474 rx_analyze_prologue (pc, func_end, RX_FRAME_TYPE_NORMAL, &p); 475 return p.prologue_end; 476} 477 478/* Given a frame described by THIS_FRAME, decode the prologue of its 479 associated function if there is not cache entry as specified by 480 THIS_PROLOGUE_CACHE. Save the decoded prologue in the cache and 481 return that struct as the value of this function. */ 482 483static struct rx_prologue * 484rx_analyze_frame_prologue (struct frame_info *this_frame, 485 enum rx_frame_type frame_type, 486 void **this_prologue_cache) 487{ 488 if (!*this_prologue_cache) 489 { 490 CORE_ADDR func_start, stop_addr; 491 492 *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct rx_prologue); 493 494 func_start = get_frame_func (this_frame); 495 stop_addr = get_frame_pc (this_frame); 496 497 /* If we couldn't find any function containing the PC, then 498 just initialize the prologue cache, but don't do anything. */ 499 if (!func_start) 500 stop_addr = func_start; 501 502 rx_analyze_prologue (func_start, stop_addr, frame_type, 503 (struct rx_prologue *) *this_prologue_cache); 504 } 505 506 return (struct rx_prologue *) *this_prologue_cache; 507} 508 509/* Determine type of frame by scanning the function for a return 510 instruction. */ 511 512static enum rx_frame_type 513rx_frame_type (struct frame_info *this_frame, void **this_cache) 514{ 515 const char *name; 516 CORE_ADDR pc, start_pc, lim_pc; 517 int bytes_read; 518 struct rx_get_opcode_byte_handle opcode_handle; 519 RX_Opcode_Decoded opc; 520 521 gdb_assert (this_cache != NULL); 522 523 /* If we have a cached value, return it. */ 524 525 if (*this_cache != NULL) 526 { 527 struct rx_prologue *p = (struct rx_prologue *) *this_cache; 528 529 return p->frame_type; 530 } 531 532 /* No cached value; scan the function. The frame type is cached in 533 rx_analyze_prologue / rx_analyze_frame_prologue. */ 534 535 pc = get_frame_pc (this_frame); 536 537 /* Attempt to find the last address in the function. If it cannot 538 be determined, set the limit to be a short ways past the frame's 539 pc. */ 540 if (!find_pc_partial_function (pc, &name, &start_pc, &lim_pc)) 541 lim_pc = pc + 20; 542 543 while (pc < lim_pc) 544 { 545 opcode_handle.pc = pc; 546 bytes_read = rx_decode_opcode (pc, &opc, rx_get_opcode_byte, 547 &opcode_handle); 548 549 if (bytes_read <= 0 || opc.id == RXO_rts) 550 return RX_FRAME_TYPE_NORMAL; 551 else if (opc.id == RXO_rtfi) 552 return RX_FRAME_TYPE_FAST_INTERRUPT; 553 else if (opc.id == RXO_rte) 554 return RX_FRAME_TYPE_EXCEPTION; 555 556 pc += bytes_read; 557 } 558 559 return RX_FRAME_TYPE_NORMAL; 560} 561 562 563/* Given the next frame and a prologue cache, return this frame's 564 base. */ 565 566static CORE_ADDR 567rx_frame_base (struct frame_info *this_frame, void **this_cache) 568{ 569 enum rx_frame_type frame_type = rx_frame_type (this_frame, this_cache); 570 struct rx_prologue *p 571 = rx_analyze_frame_prologue (this_frame, frame_type, this_cache); 572 573 /* In functions that use alloca, the distance between the stack 574 pointer and the frame base varies dynamically, so we can't use 575 the SP plus static information like prologue analysis to find the 576 frame base. However, such functions must have a frame pointer, 577 to be able to restore the SP on exit. So whenever we do have a 578 frame pointer, use that to find the base. */ 579 if (p->has_frame_ptr) 580 { 581 CORE_ADDR fp = get_frame_register_unsigned (this_frame, RX_FP_REGNUM); 582 return fp - p->frame_ptr_offset; 583 } 584 else 585 { 586 CORE_ADDR sp = get_frame_register_unsigned (this_frame, RX_SP_REGNUM); 587 return sp - p->frame_size; 588 } 589} 590 591/* Implement the "frame_this_id" method for unwinding frames. */ 592 593static void 594rx_frame_this_id (struct frame_info *this_frame, void **this_cache, 595 struct frame_id *this_id) 596{ 597 *this_id = frame_id_build (rx_frame_base (this_frame, this_cache), 598 get_frame_func (this_frame)); 599} 600 601/* Implement the "frame_prev_register" method for unwinding frames. */ 602 603static struct value * 604rx_frame_prev_register (struct frame_info *this_frame, void **this_cache, 605 int regnum) 606{ 607 enum rx_frame_type frame_type = rx_frame_type (this_frame, this_cache); 608 struct rx_prologue *p 609 = rx_analyze_frame_prologue (this_frame, frame_type, this_cache); 610 CORE_ADDR frame_base = rx_frame_base (this_frame, this_cache); 611 612 if (regnum == RX_SP_REGNUM) 613 { 614 if (frame_type == RX_FRAME_TYPE_EXCEPTION) 615 { 616 struct value *psw_val; 617 CORE_ADDR psw; 618 619 psw_val = rx_frame_prev_register (this_frame, this_cache, 620 RX_PSW_REGNUM); 621 psw = extract_unsigned_integer (value_contents_all (psw_val), 4, 622 gdbarch_byte_order ( 623 get_frame_arch (this_frame))); 624 625 if ((psw & 0x20000 /* U bit */) != 0) 626 return rx_frame_prev_register (this_frame, this_cache, 627 RX_USP_REGNUM); 628 629 /* Fall through for the case where U bit is zero. */ 630 } 631 632 return frame_unwind_got_constant (this_frame, regnum, frame_base); 633 } 634 635 if (frame_type == RX_FRAME_TYPE_FAST_INTERRUPT) 636 { 637 if (regnum == RX_PC_REGNUM) 638 return rx_frame_prev_register (this_frame, this_cache, 639 RX_BPC_REGNUM); 640 if (regnum == RX_PSW_REGNUM) 641 return rx_frame_prev_register (this_frame, this_cache, 642 RX_BPSW_REGNUM); 643 } 644 645 /* If prologue analysis says we saved this register somewhere, 646 return a description of the stack slot holding it. */ 647 if (p->reg_offset[regnum] != 1) 648 return frame_unwind_got_memory (this_frame, regnum, 649 frame_base + p->reg_offset[regnum]); 650 651 /* Otherwise, presume we haven't changed the value of this 652 register, and get it from the next frame. */ 653 return frame_unwind_got_register (this_frame, regnum, regnum); 654} 655 656/* Return TRUE if the frame indicated by FRAME_TYPE is a normal frame. */ 657 658static int 659normal_frame_p (enum rx_frame_type frame_type) 660{ 661 return (frame_type == RX_FRAME_TYPE_NORMAL); 662} 663 664/* Return TRUE if the frame indicated by FRAME_TYPE is an exception 665 frame. */ 666 667static int 668exception_frame_p (enum rx_frame_type frame_type) 669{ 670 return (frame_type == RX_FRAME_TYPE_EXCEPTION 671 || frame_type == RX_FRAME_TYPE_FAST_INTERRUPT); 672} 673 674/* Common code used by both normal and exception frame sniffers. */ 675 676static int 677rx_frame_sniffer_common (const struct frame_unwind *self, 678 struct frame_info *this_frame, 679 void **this_cache, 680 int (*sniff_p)(enum rx_frame_type) ) 681{ 682 gdb_assert (this_cache != NULL); 683 684 if (*this_cache == NULL) 685 { 686 enum rx_frame_type frame_type = rx_frame_type (this_frame, this_cache); 687 688 if (sniff_p (frame_type)) 689 { 690 /* The call below will fill in the cache, including the frame 691 type. */ 692 (void) rx_analyze_frame_prologue (this_frame, frame_type, this_cache); 693 694 return 1; 695 } 696 else 697 return 0; 698 } 699 else 700 { 701 struct rx_prologue *p = (struct rx_prologue *) *this_cache; 702 703 return sniff_p (p->frame_type); 704 } 705} 706 707/* Frame sniffer for normal (non-exception) frames. */ 708 709static int 710rx_frame_sniffer (const struct frame_unwind *self, 711 struct frame_info *this_frame, 712 void **this_cache) 713{ 714 return rx_frame_sniffer_common (self, this_frame, this_cache, 715 normal_frame_p); 716} 717 718/* Frame sniffer for exception frames. */ 719 720static int 721rx_exception_sniffer (const struct frame_unwind *self, 722 struct frame_info *this_frame, 723 void **this_cache) 724{ 725 return rx_frame_sniffer_common (self, this_frame, this_cache, 726 exception_frame_p); 727} 728 729/* Data structure for normal code using instruction-based prologue 730 analyzer. */ 731 732static const struct frame_unwind rx_frame_unwind = { 733 NORMAL_FRAME, 734 default_frame_unwind_stop_reason, 735 rx_frame_this_id, 736 rx_frame_prev_register, 737 NULL, 738 rx_frame_sniffer 739}; 740 741/* Data structure for exception code using instruction-based prologue 742 analyzer. */ 743 744static const struct frame_unwind rx_exception_unwind = { 745 /* SIGTRAMP_FRAME could be used here, but backtraces are less informative. */ 746 NORMAL_FRAME, 747 default_frame_unwind_stop_reason, 748 rx_frame_this_id, 749 rx_frame_prev_register, 750 NULL, 751 rx_exception_sniffer 752}; 753 754/* Implement the "unwind_pc" gdbarch method. */ 755static CORE_ADDR 756rx_unwind_pc (struct gdbarch *gdbarch, struct frame_info *this_frame) 757{ 758 ULONGEST pc; 759 760 pc = frame_unwind_register_unsigned (this_frame, RX_PC_REGNUM); 761 return pc; 762} 763 764/* Implement the "unwind_sp" gdbarch method. */ 765static CORE_ADDR 766rx_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame) 767{ 768 ULONGEST sp; 769 770 sp = frame_unwind_register_unsigned (this_frame, RX_SP_REGNUM); 771 return sp; 772} 773 774/* Implement the "dummy_id" gdbarch method. */ 775static struct frame_id 776rx_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) 777{ 778 return 779 frame_id_build (get_frame_register_unsigned (this_frame, RX_SP_REGNUM), 780 get_frame_pc (this_frame)); 781} 782 783/* Implement the "push_dummy_call" gdbarch method. */ 784static CORE_ADDR 785rx_push_dummy_call (struct gdbarch *gdbarch, struct value *function, 786 struct regcache *regcache, CORE_ADDR bp_addr, int nargs, 787 struct value **args, CORE_ADDR sp, 788 function_call_return_method return_method, 789 CORE_ADDR struct_addr) 790{ 791 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 792 int write_pass; 793 int sp_off = 0; 794 CORE_ADDR cfa; 795 int num_register_candidate_args; 796 797 struct type *func_type = value_type (function); 798 799 /* Dereference function pointer types. */ 800 while (TYPE_CODE (func_type) == TYPE_CODE_PTR) 801 func_type = TYPE_TARGET_TYPE (func_type); 802 803 /* The end result had better be a function or a method. */ 804 gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC 805 || TYPE_CODE (func_type) == TYPE_CODE_METHOD); 806 807 /* Functions with a variable number of arguments have all of their 808 variable arguments and the last non-variable argument passed 809 on the stack. 810 811 Otherwise, we can pass up to four arguments on the stack. 812 813 Once computed, we leave this value alone. I.e. we don't update 814 it in case of a struct return going in a register or an argument 815 requiring multiple registers, etc. We rely instead on the value 816 of the ``arg_reg'' variable to get these other details correct. */ 817 818 if (TYPE_VARARGS (func_type)) 819 num_register_candidate_args = TYPE_NFIELDS (func_type) - 1; 820 else 821 num_register_candidate_args = 4; 822 823 /* We make two passes; the first does the stack allocation, 824 the second actually stores the arguments. */ 825 for (write_pass = 0; write_pass <= 1; write_pass++) 826 { 827 int i; 828 int arg_reg = RX_R1_REGNUM; 829 830 if (write_pass) 831 sp = align_down (sp - sp_off, 4); 832 sp_off = 0; 833 834 if (return_method == return_method_struct) 835 { 836 struct type *return_type = TYPE_TARGET_TYPE (func_type); 837 838 gdb_assert (TYPE_CODE (return_type) == TYPE_CODE_STRUCT 839 || TYPE_CODE (func_type) == TYPE_CODE_UNION); 840 841 if (TYPE_LENGTH (return_type) > 16 842 || TYPE_LENGTH (return_type) % 4 != 0) 843 { 844 if (write_pass) 845 regcache_cooked_write_unsigned (regcache, RX_R15_REGNUM, 846 struct_addr); 847 } 848 } 849 850 /* Push the arguments. */ 851 for (i = 0; i < nargs; i++) 852 { 853 struct value *arg = args[i]; 854 const gdb_byte *arg_bits = value_contents_all (arg); 855 struct type *arg_type = check_typedef (value_type (arg)); 856 ULONGEST arg_size = TYPE_LENGTH (arg_type); 857 858 if (i == 0 && struct_addr != 0 859 && return_method != return_method_struct 860 && TYPE_CODE (arg_type) == TYPE_CODE_PTR 861 && extract_unsigned_integer (arg_bits, 4, 862 byte_order) == struct_addr) 863 { 864 /* This argument represents the address at which C++ (and 865 possibly other languages) store their return value. 866 Put this value in R15. */ 867 if (write_pass) 868 regcache_cooked_write_unsigned (regcache, RX_R15_REGNUM, 869 struct_addr); 870 } 871 else if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT 872 && TYPE_CODE (arg_type) != TYPE_CODE_UNION 873 && arg_size <= 8) 874 { 875 /* Argument is a scalar. */ 876 if (arg_size == 8) 877 { 878 if (i < num_register_candidate_args 879 && arg_reg <= RX_R4_REGNUM - 1) 880 { 881 /* If argument registers are going to be used to pass 882 an 8 byte scalar, the ABI specifies that two registers 883 must be available. */ 884 if (write_pass) 885 { 886 regcache_cooked_write_unsigned (regcache, arg_reg, 887 extract_unsigned_integer 888 (arg_bits, 4, 889 byte_order)); 890 regcache_cooked_write_unsigned (regcache, 891 arg_reg + 1, 892 extract_unsigned_integer 893 (arg_bits + 4, 4, 894 byte_order)); 895 } 896 arg_reg += 2; 897 } 898 else 899 { 900 sp_off = align_up (sp_off, 4); 901 /* Otherwise, pass the 8 byte scalar on the stack. */ 902 if (write_pass) 903 write_memory (sp + sp_off, arg_bits, 8); 904 sp_off += 8; 905 } 906 } 907 else 908 { 909 ULONGEST u; 910 911 gdb_assert (arg_size <= 4); 912 913 u = 914 extract_unsigned_integer (arg_bits, arg_size, byte_order); 915 916 if (i < num_register_candidate_args 917 && arg_reg <= RX_R4_REGNUM) 918 { 919 if (write_pass) 920 regcache_cooked_write_unsigned (regcache, arg_reg, u); 921 arg_reg += 1; 922 } 923 else 924 { 925 int p_arg_size = 4; 926 927 if (TYPE_PROTOTYPED (func_type) 928 && i < TYPE_NFIELDS (func_type)) 929 { 930 struct type *p_arg_type = 931 TYPE_FIELD_TYPE (func_type, i); 932 p_arg_size = TYPE_LENGTH (p_arg_type); 933 } 934 935 sp_off = align_up (sp_off, p_arg_size); 936 937 if (write_pass) 938 write_memory_unsigned_integer (sp + sp_off, 939 p_arg_size, byte_order, 940 u); 941 sp_off += p_arg_size; 942 } 943 } 944 } 945 else 946 { 947 /* Argument is a struct or union. Pass as much of the struct 948 in registers, if possible. Pass the rest on the stack. */ 949 while (arg_size > 0) 950 { 951 if (i < num_register_candidate_args 952 && arg_reg <= RX_R4_REGNUM 953 && arg_size <= 4 * (RX_R4_REGNUM - arg_reg + 1) 954 && arg_size % 4 == 0) 955 { 956 int len = std::min (arg_size, (ULONGEST) 4); 957 958 if (write_pass) 959 regcache_cooked_write_unsigned (regcache, arg_reg, 960 extract_unsigned_integer 961 (arg_bits, len, 962 byte_order)); 963 arg_bits += len; 964 arg_size -= len; 965 arg_reg++; 966 } 967 else 968 { 969 sp_off = align_up (sp_off, 4); 970 if (write_pass) 971 write_memory (sp + sp_off, arg_bits, arg_size); 972 sp_off += align_up (arg_size, 4); 973 arg_size = 0; 974 } 975 } 976 } 977 } 978 } 979 980 /* Keep track of the stack address prior to pushing the return address. 981 This is the value that we'll return. */ 982 cfa = sp; 983 984 /* Push the return address. */ 985 sp = sp - 4; 986 write_memory_unsigned_integer (sp, 4, byte_order, bp_addr); 987 988 /* Update the stack pointer. */ 989 regcache_cooked_write_unsigned (regcache, RX_SP_REGNUM, sp); 990 991 return cfa; 992} 993 994/* Implement the "return_value" gdbarch method. */ 995static enum return_value_convention 996rx_return_value (struct gdbarch *gdbarch, 997 struct value *function, 998 struct type *valtype, 999 struct regcache *regcache, 1000 gdb_byte *readbuf, const gdb_byte *writebuf) 1001{ 1002 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1003 ULONGEST valtype_len = TYPE_LENGTH (valtype); 1004 1005 if (TYPE_LENGTH (valtype) > 16 1006 || ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT 1007 || TYPE_CODE (valtype) == TYPE_CODE_UNION) 1008 && TYPE_LENGTH (valtype) % 4 != 0)) 1009 return RETURN_VALUE_STRUCT_CONVENTION; 1010 1011 if (readbuf) 1012 { 1013 ULONGEST u; 1014 int argreg = RX_R1_REGNUM; 1015 int offset = 0; 1016 1017 while (valtype_len > 0) 1018 { 1019 int len = std::min (valtype_len, (ULONGEST) 4); 1020 1021 regcache_cooked_read_unsigned (regcache, argreg, &u); 1022 store_unsigned_integer (readbuf + offset, len, byte_order, u); 1023 valtype_len -= len; 1024 offset += len; 1025 argreg++; 1026 } 1027 } 1028 1029 if (writebuf) 1030 { 1031 ULONGEST u; 1032 int argreg = RX_R1_REGNUM; 1033 int offset = 0; 1034 1035 while (valtype_len > 0) 1036 { 1037 int len = std::min (valtype_len, (ULONGEST) 4); 1038 1039 u = extract_unsigned_integer (writebuf + offset, len, byte_order); 1040 regcache_cooked_write_unsigned (regcache, argreg, u); 1041 valtype_len -= len; 1042 offset += len; 1043 argreg++; 1044 } 1045 } 1046 1047 return RETURN_VALUE_REGISTER_CONVENTION; 1048} 1049 1050constexpr gdb_byte rx_break_insn[] = { 0x00 }; 1051 1052typedef BP_MANIPULATION (rx_break_insn) rx_breakpoint; 1053 1054/* Implement the dwarf_reg_to_regnum" gdbarch method. */ 1055 1056static int 1057rx_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg) 1058{ 1059 if (0 <= reg && reg <= 15) 1060 return reg; 1061 else if (reg == 16) 1062 return RX_PSW_REGNUM; 1063 else if (reg == 17) 1064 return RX_PC_REGNUM; 1065 else 1066 return -1; 1067} 1068 1069/* Allocate and initialize a gdbarch object. */ 1070static struct gdbarch * 1071rx_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 1072{ 1073 struct gdbarch *gdbarch; 1074 struct gdbarch_tdep *tdep; 1075 int elf_flags; 1076 1077 /* Extract the elf_flags if available. */ 1078 if (info.abfd != NULL 1079 && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour) 1080 elf_flags = elf_elfheader (info.abfd)->e_flags; 1081 else 1082 elf_flags = 0; 1083 1084 1085 /* Try to find the architecture in the list of already defined 1086 architectures. */ 1087 for (arches = gdbarch_list_lookup_by_info (arches, &info); 1088 arches != NULL; 1089 arches = gdbarch_list_lookup_by_info (arches->next, &info)) 1090 { 1091 if (gdbarch_tdep (arches->gdbarch)->elf_flags != elf_flags) 1092 continue; 1093 1094 return arches->gdbarch; 1095 } 1096 1097 /* None found, create a new architecture from the information 1098 provided. */ 1099 tdep = XCNEW (struct gdbarch_tdep); 1100 gdbarch = gdbarch_alloc (&info, tdep); 1101 tdep->elf_flags = elf_flags; 1102 1103 set_gdbarch_num_regs (gdbarch, RX_NUM_REGS); 1104 set_gdbarch_num_pseudo_regs (gdbarch, 0); 1105 set_gdbarch_register_name (gdbarch, rx_register_name); 1106 set_gdbarch_register_type (gdbarch, rx_register_type); 1107 set_gdbarch_pc_regnum (gdbarch, RX_PC_REGNUM); 1108 set_gdbarch_sp_regnum (gdbarch, RX_SP_REGNUM); 1109 set_gdbarch_inner_than (gdbarch, core_addr_lessthan); 1110 set_gdbarch_decr_pc_after_break (gdbarch, 1); 1111 set_gdbarch_breakpoint_kind_from_pc (gdbarch, rx_breakpoint::kind_from_pc); 1112 set_gdbarch_sw_breakpoint_from_kind (gdbarch, rx_breakpoint::bp_from_kind); 1113 set_gdbarch_skip_prologue (gdbarch, rx_skip_prologue); 1114 1115 set_gdbarch_unwind_pc (gdbarch, rx_unwind_pc); 1116 set_gdbarch_unwind_sp (gdbarch, rx_unwind_sp); 1117 1118 /* Target builtin data types. */ 1119 set_gdbarch_char_signed (gdbarch, 0); 1120 set_gdbarch_short_bit (gdbarch, 16); 1121 set_gdbarch_int_bit (gdbarch, 32); 1122 set_gdbarch_long_bit (gdbarch, 32); 1123 set_gdbarch_long_long_bit (gdbarch, 64); 1124 set_gdbarch_ptr_bit (gdbarch, 32); 1125 set_gdbarch_float_bit (gdbarch, 32); 1126 set_gdbarch_float_format (gdbarch, floatformats_ieee_single); 1127 if (elf_flags & E_FLAG_RX_64BIT_DOUBLES) 1128 { 1129 set_gdbarch_double_bit (gdbarch, 64); 1130 set_gdbarch_long_double_bit (gdbarch, 64); 1131 set_gdbarch_double_format (gdbarch, floatformats_ieee_double); 1132 set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double); 1133 } 1134 else 1135 { 1136 set_gdbarch_double_bit (gdbarch, 32); 1137 set_gdbarch_long_double_bit (gdbarch, 32); 1138 set_gdbarch_double_format (gdbarch, floatformats_ieee_single); 1139 set_gdbarch_long_double_format (gdbarch, floatformats_ieee_single); 1140 } 1141 1142 /* DWARF register mapping. */ 1143 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, rx_dwarf_reg_to_regnum); 1144 1145 /* Frame unwinding. */ 1146 frame_unwind_append_unwinder (gdbarch, &rx_exception_unwind); 1147 dwarf2_append_unwinders (gdbarch); 1148 frame_unwind_append_unwinder (gdbarch, &rx_frame_unwind); 1149 1150 /* Methods for saving / extracting a dummy frame's ID. 1151 The ID's stack address must match the SP value returned by 1152 PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */ 1153 set_gdbarch_dummy_id (gdbarch, rx_dummy_id); 1154 set_gdbarch_push_dummy_call (gdbarch, rx_push_dummy_call); 1155 set_gdbarch_return_value (gdbarch, rx_return_value); 1156 1157 /* Virtual tables. */ 1158 set_gdbarch_vbit_in_delta (gdbarch, 1); 1159 1160 return gdbarch; 1161} 1162 1163/* Register the above initialization routine. */ 1164 1165void 1166_initialize_rx_tdep (void) 1167{ 1168 register_gdbarch_init (bfd_arch_rx, rx_gdbarch_init); 1169} 1170