rx-tdep.c revision 1.1
1/* Target-dependent code for the Renesas RX for GDB, the GNU debugger. 2 3 Copyright (C) 2008-2014 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 40/* Certain important register numbers. */ 41enum 42{ 43 RX_SP_REGNUM = 0, 44 RX_R1_REGNUM = 1, 45 RX_R4_REGNUM = 4, 46 RX_FP_REGNUM = 6, 47 RX_R15_REGNUM = 15, 48 RX_PC_REGNUM = 19, 49 RX_ACC_REGNUM = 25, 50 RX_NUM_REGS = 26 51}; 52 53/* Architecture specific data. */ 54struct gdbarch_tdep 55{ 56 /* The ELF header flags specify the multilib used. */ 57 int elf_flags; 58}; 59 60/* This structure holds the results of a prologue analysis. */ 61struct rx_prologue 62{ 63 /* The offset from the frame base to the stack pointer --- always 64 zero or negative. 65 66 Calling this a "size" is a bit misleading, but given that the 67 stack grows downwards, using offsets for everything keeps one 68 from going completely sign-crazy: you never change anything's 69 sign for an ADD instruction; always change the second operand's 70 sign for a SUB instruction; and everything takes care of 71 itself. */ 72 int frame_size; 73 74 /* Non-zero if this function has initialized the frame pointer from 75 the stack pointer, zero otherwise. */ 76 int has_frame_ptr; 77 78 /* If has_frame_ptr is non-zero, this is the offset from the frame 79 base to where the frame pointer points. This is always zero or 80 negative. */ 81 int frame_ptr_offset; 82 83 /* The address of the first instruction at which the frame has been 84 set up and the arguments are where the debug info says they are 85 --- as best as we can tell. */ 86 CORE_ADDR prologue_end; 87 88 /* reg_offset[R] is the offset from the CFA at which register R is 89 saved, or 1 if register R has not been saved. (Real values are 90 always zero or negative.) */ 91 int reg_offset[RX_NUM_REGS]; 92}; 93 94/* Implement the "register_name" gdbarch method. */ 95static const char * 96rx_register_name (struct gdbarch *gdbarch, int regnr) 97{ 98 static const char *const reg_names[] = { 99 "r0", 100 "r1", 101 "r2", 102 "r3", 103 "r4", 104 "r5", 105 "r6", 106 "r7", 107 "r8", 108 "r9", 109 "r10", 110 "r11", 111 "r12", 112 "r13", 113 "r14", 114 "r15", 115 "usp", 116 "isp", 117 "psw", 118 "pc", 119 "intb", 120 "bpsw", 121 "bpc", 122 "fintv", 123 "fpsw", 124 "acc" 125 }; 126 127 return reg_names[regnr]; 128} 129 130/* Implement the "register_type" gdbarch method. */ 131static struct type * 132rx_register_type (struct gdbarch *gdbarch, int reg_nr) 133{ 134 if (reg_nr == RX_PC_REGNUM) 135 return builtin_type (gdbarch)->builtin_func_ptr; 136 else if (reg_nr == RX_ACC_REGNUM) 137 return builtin_type (gdbarch)->builtin_unsigned_long_long; 138 else 139 return builtin_type (gdbarch)->builtin_unsigned_long; 140} 141 142 143/* Function for finding saved registers in a 'struct pv_area'; this 144 function is passed to pv_area_scan. 145 146 If VALUE is a saved register, ADDR says it was saved at a constant 147 offset from the frame base, and SIZE indicates that the whole 148 register was saved, record its offset. */ 149static void 150check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size, pv_t value) 151{ 152 struct rx_prologue *result = (struct rx_prologue *) result_untyped; 153 154 if (value.kind == pvk_register 155 && value.k == 0 156 && pv_is_register (addr, RX_SP_REGNUM) 157 && size == register_size (target_gdbarch (), value.reg)) 158 result->reg_offset[value.reg] = addr.k; 159} 160 161/* Define a "handle" struct for fetching the next opcode. */ 162struct rx_get_opcode_byte_handle 163{ 164 CORE_ADDR pc; 165}; 166 167/* Fetch a byte on behalf of the opcode decoder. HANDLE contains 168 the memory address of the next byte to fetch. If successful, 169 the address in the handle is updated and the byte fetched is 170 returned as the value of the function. If not successful, -1 171 is returned. */ 172static int 173rx_get_opcode_byte (void *handle) 174{ 175 struct rx_get_opcode_byte_handle *opcdata = handle; 176 int status; 177 gdb_byte byte; 178 179 status = target_read_memory (opcdata->pc, &byte, 1); 180 if (status == 0) 181 { 182 opcdata->pc += 1; 183 return byte; 184 } 185 else 186 return -1; 187} 188 189/* Analyze a prologue starting at START_PC, going no further than 190 LIMIT_PC. Fill in RESULT as appropriate. */ 191static void 192rx_analyze_prologue (CORE_ADDR start_pc, 193 CORE_ADDR limit_pc, struct rx_prologue *result) 194{ 195 CORE_ADDR pc, next_pc; 196 int rn; 197 pv_t reg[RX_NUM_REGS]; 198 struct pv_area *stack; 199 struct cleanup *back_to; 200 CORE_ADDR after_last_frame_setup_insn = start_pc; 201 202 memset (result, 0, sizeof (*result)); 203 204 for (rn = 0; rn < RX_NUM_REGS; rn++) 205 { 206 reg[rn] = pv_register (rn, 0); 207 result->reg_offset[rn] = 1; 208 } 209 210 stack = make_pv_area (RX_SP_REGNUM, gdbarch_addr_bit (target_gdbarch ())); 211 back_to = make_cleanup_free_pv_area (stack); 212 213 /* The call instruction has saved the return address on the stack. */ 214 reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4); 215 pv_area_store (stack, reg[RX_SP_REGNUM], 4, reg[RX_PC_REGNUM]); 216 217 pc = start_pc; 218 while (pc < limit_pc) 219 { 220 int bytes_read; 221 struct rx_get_opcode_byte_handle opcode_handle; 222 RX_Opcode_Decoded opc; 223 224 opcode_handle.pc = pc; 225 bytes_read = rx_decode_opcode (pc, &opc, rx_get_opcode_byte, 226 &opcode_handle); 227 next_pc = pc + bytes_read; 228 229 if (opc.id == RXO_pushm /* pushm r1, r2 */ 230 && opc.op[1].type == RX_Operand_Register 231 && opc.op[2].type == RX_Operand_Register) 232 { 233 int r1, r2; 234 int r; 235 236 r1 = opc.op[1].reg; 237 r2 = opc.op[2].reg; 238 for (r = r2; r >= r1; r--) 239 { 240 reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4); 241 pv_area_store (stack, reg[RX_SP_REGNUM], 4, reg[r]); 242 } 243 after_last_frame_setup_insn = next_pc; 244 } 245 else if (opc.id == RXO_mov /* mov.l rdst, rsrc */ 246 && opc.op[0].type == RX_Operand_Register 247 && opc.op[1].type == RX_Operand_Register 248 && opc.size == RX_Long) 249 { 250 int rdst, rsrc; 251 252 rdst = opc.op[0].reg; 253 rsrc = opc.op[1].reg; 254 reg[rdst] = reg[rsrc]; 255 if (rdst == RX_FP_REGNUM && rsrc == RX_SP_REGNUM) 256 after_last_frame_setup_insn = next_pc; 257 } 258 else if (opc.id == RXO_mov /* mov.l rsrc, [-SP] */ 259 && opc.op[0].type == RX_Operand_Predec 260 && opc.op[0].reg == RX_SP_REGNUM 261 && opc.op[1].type == RX_Operand_Register 262 && opc.size == RX_Long) 263 { 264 int rsrc; 265 266 rsrc = opc.op[1].reg; 267 reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4); 268 pv_area_store (stack, reg[RX_SP_REGNUM], 4, reg[rsrc]); 269 after_last_frame_setup_insn = next_pc; 270 } 271 else if (opc.id == RXO_add /* add #const, rsrc, rdst */ 272 && opc.op[0].type == RX_Operand_Register 273 && opc.op[1].type == RX_Operand_Immediate 274 && opc.op[2].type == RX_Operand_Register) 275 { 276 int rdst = opc.op[0].reg; 277 int addend = opc.op[1].addend; 278 int rsrc = opc.op[2].reg; 279 reg[rdst] = pv_add_constant (reg[rsrc], addend); 280 /* Negative adjustments to the stack pointer or frame pointer 281 are (most likely) part of the prologue. */ 282 if ((rdst == RX_SP_REGNUM || rdst == RX_FP_REGNUM) && addend < 0) 283 after_last_frame_setup_insn = next_pc; 284 } 285 else if (opc.id == RXO_mov 286 && opc.op[0].type == RX_Operand_Indirect 287 && opc.op[1].type == RX_Operand_Register 288 && opc.size == RX_Long 289 && (opc.op[0].reg == RX_SP_REGNUM 290 || opc.op[0].reg == RX_FP_REGNUM) 291 && (RX_R1_REGNUM <= opc.op[1].reg 292 && opc.op[1].reg <= RX_R4_REGNUM)) 293 { 294 /* This moves an argument register to the stack. Don't 295 record it, but allow it to be a part of the prologue. */ 296 } 297 else if (opc.id == RXO_branch 298 && opc.op[0].type == RX_Operand_Immediate 299 && next_pc < opc.op[0].addend) 300 { 301 /* When a loop appears as the first statement of a function 302 body, gcc 4.x will use a BRA instruction to branch to the 303 loop condition checking code. This BRA instruction is 304 marked as part of the prologue. We therefore set next_pc 305 to this branch target and also stop the prologue scan. 306 The instructions at and beyond the branch target should 307 no longer be associated with the prologue. 308 309 Note that we only consider forward branches here. We 310 presume that a forward branch is being used to skip over 311 a loop body. 312 313 A backwards branch is covered by the default case below. 314 If we were to encounter a backwards branch, that would 315 most likely mean that we've scanned through a loop body. 316 We definitely want to stop the prologue scan when this 317 happens and that is precisely what is done by the default 318 case below. */ 319 320 after_last_frame_setup_insn = opc.op[0].addend; 321 break; /* Scan no further if we hit this case. */ 322 } 323 else 324 { 325 /* Terminate the prologue scan. */ 326 break; 327 } 328 329 pc = next_pc; 330 } 331 332 /* Is the frame size (offset, really) a known constant? */ 333 if (pv_is_register (reg[RX_SP_REGNUM], RX_SP_REGNUM)) 334 result->frame_size = reg[RX_SP_REGNUM].k; 335 336 /* Was the frame pointer initialized? */ 337 if (pv_is_register (reg[RX_FP_REGNUM], RX_SP_REGNUM)) 338 { 339 result->has_frame_ptr = 1; 340 result->frame_ptr_offset = reg[RX_FP_REGNUM].k; 341 } 342 343 /* Record where all the registers were saved. */ 344 pv_area_scan (stack, check_for_saved, (void *) result); 345 346 result->prologue_end = after_last_frame_setup_insn; 347 348 do_cleanups (back_to); 349} 350 351 352/* Implement the "skip_prologue" gdbarch method. */ 353static CORE_ADDR 354rx_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) 355{ 356 const char *name; 357 CORE_ADDR func_addr, func_end; 358 struct rx_prologue p; 359 360 /* Try to find the extent of the function that contains PC. */ 361 if (!find_pc_partial_function (pc, &name, &func_addr, &func_end)) 362 return pc; 363 364 rx_analyze_prologue (pc, func_end, &p); 365 return p.prologue_end; 366} 367 368/* Given a frame described by THIS_FRAME, decode the prologue of its 369 associated function if there is not cache entry as specified by 370 THIS_PROLOGUE_CACHE. Save the decoded prologue in the cache and 371 return that struct as the value of this function. */ 372static struct rx_prologue * 373rx_analyze_frame_prologue (struct frame_info *this_frame, 374 void **this_prologue_cache) 375{ 376 if (!*this_prologue_cache) 377 { 378 CORE_ADDR func_start, stop_addr; 379 380 *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct rx_prologue); 381 382 func_start = get_frame_func (this_frame); 383 stop_addr = get_frame_pc (this_frame); 384 385 /* If we couldn't find any function containing the PC, then 386 just initialize the prologue cache, but don't do anything. */ 387 if (!func_start) 388 stop_addr = func_start; 389 390 rx_analyze_prologue (func_start, stop_addr, *this_prologue_cache); 391 } 392 393 return *this_prologue_cache; 394} 395 396/* Given the next frame and a prologue cache, return this frame's 397 base. */ 398static CORE_ADDR 399rx_frame_base (struct frame_info *this_frame, void **this_prologue_cache) 400{ 401 struct rx_prologue *p 402 = rx_analyze_frame_prologue (this_frame, this_prologue_cache); 403 404 /* In functions that use alloca, the distance between the stack 405 pointer and the frame base varies dynamically, so we can't use 406 the SP plus static information like prologue analysis to find the 407 frame base. However, such functions must have a frame pointer, 408 to be able to restore the SP on exit. So whenever we do have a 409 frame pointer, use that to find the base. */ 410 if (p->has_frame_ptr) 411 { 412 CORE_ADDR fp = get_frame_register_unsigned (this_frame, RX_FP_REGNUM); 413 return fp - p->frame_ptr_offset; 414 } 415 else 416 { 417 CORE_ADDR sp = get_frame_register_unsigned (this_frame, RX_SP_REGNUM); 418 return sp - p->frame_size; 419 } 420} 421 422/* Implement the "frame_this_id" method for unwinding frames. */ 423static void 424rx_frame_this_id (struct frame_info *this_frame, 425 void **this_prologue_cache, struct frame_id *this_id) 426{ 427 *this_id = frame_id_build (rx_frame_base (this_frame, this_prologue_cache), 428 get_frame_func (this_frame)); 429} 430 431/* Implement the "frame_prev_register" method for unwinding frames. */ 432static struct value * 433rx_frame_prev_register (struct frame_info *this_frame, 434 void **this_prologue_cache, int regnum) 435{ 436 struct rx_prologue *p 437 = rx_analyze_frame_prologue (this_frame, this_prologue_cache); 438 CORE_ADDR frame_base = rx_frame_base (this_frame, this_prologue_cache); 439 int reg_size = register_size (get_frame_arch (this_frame), regnum); 440 441 if (regnum == RX_SP_REGNUM) 442 return frame_unwind_got_constant (this_frame, regnum, frame_base); 443 444 /* If prologue analysis says we saved this register somewhere, 445 return a description of the stack slot holding it. */ 446 else if (p->reg_offset[regnum] != 1) 447 return frame_unwind_got_memory (this_frame, regnum, 448 frame_base + p->reg_offset[regnum]); 449 450 /* Otherwise, presume we haven't changed the value of this 451 register, and get it from the next frame. */ 452 else 453 return frame_unwind_got_register (this_frame, regnum, regnum); 454} 455 456static const struct frame_unwind rx_frame_unwind = { 457 NORMAL_FRAME, 458 default_frame_unwind_stop_reason, 459 rx_frame_this_id, 460 rx_frame_prev_register, 461 NULL, 462 default_frame_sniffer 463}; 464 465/* Implement the "unwind_pc" gdbarch method. */ 466static CORE_ADDR 467rx_unwind_pc (struct gdbarch *gdbarch, struct frame_info *this_frame) 468{ 469 ULONGEST pc; 470 471 pc = frame_unwind_register_unsigned (this_frame, RX_PC_REGNUM); 472 return pc; 473} 474 475/* Implement the "unwind_sp" gdbarch method. */ 476static CORE_ADDR 477rx_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame) 478{ 479 ULONGEST sp; 480 481 sp = frame_unwind_register_unsigned (this_frame, RX_SP_REGNUM); 482 return sp; 483} 484 485/* Implement the "dummy_id" gdbarch method. */ 486static struct frame_id 487rx_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) 488{ 489 return 490 frame_id_build (get_frame_register_unsigned (this_frame, RX_SP_REGNUM), 491 get_frame_pc (this_frame)); 492} 493 494/* Implement the "push_dummy_call" gdbarch method. */ 495static CORE_ADDR 496rx_push_dummy_call (struct gdbarch *gdbarch, struct value *function, 497 struct regcache *regcache, CORE_ADDR bp_addr, int nargs, 498 struct value **args, CORE_ADDR sp, int struct_return, 499 CORE_ADDR struct_addr) 500{ 501 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 502 int write_pass; 503 int sp_off = 0; 504 CORE_ADDR cfa; 505 int num_register_candidate_args; 506 507 struct type *func_type = value_type (function); 508 509 /* Dereference function pointer types. */ 510 while (TYPE_CODE (func_type) == TYPE_CODE_PTR) 511 func_type = TYPE_TARGET_TYPE (func_type); 512 513 /* The end result had better be a function or a method. */ 514 gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC 515 || TYPE_CODE (func_type) == TYPE_CODE_METHOD); 516 517 /* Functions with a variable number of arguments have all of their 518 variable arguments and the last non-variable argument passed 519 on the stack. 520 521 Otherwise, we can pass up to four arguments on the stack. 522 523 Once computed, we leave this value alone. I.e. we don't update 524 it in case of a struct return going in a register or an argument 525 requiring multiple registers, etc. We rely instead on the value 526 of the ``arg_reg'' variable to get these other details correct. */ 527 528 if (TYPE_VARARGS (func_type)) 529 num_register_candidate_args = TYPE_NFIELDS (func_type) - 1; 530 else 531 num_register_candidate_args = 4; 532 533 /* We make two passes; the first does the stack allocation, 534 the second actually stores the arguments. */ 535 for (write_pass = 0; write_pass <= 1; write_pass++) 536 { 537 int i; 538 int arg_reg = RX_R1_REGNUM; 539 540 if (write_pass) 541 sp = align_down (sp - sp_off, 4); 542 sp_off = 0; 543 544 if (struct_return) 545 { 546 struct type *return_type = TYPE_TARGET_TYPE (func_type); 547 548 gdb_assert (TYPE_CODE (return_type) == TYPE_CODE_STRUCT 549 || TYPE_CODE (func_type) == TYPE_CODE_UNION); 550 551 if (TYPE_LENGTH (return_type) > 16 552 || TYPE_LENGTH (return_type) % 4 != 0) 553 { 554 if (write_pass) 555 regcache_cooked_write_unsigned (regcache, RX_R15_REGNUM, 556 struct_addr); 557 } 558 } 559 560 /* Push the arguments. */ 561 for (i = 0; i < nargs; i++) 562 { 563 struct value *arg = args[i]; 564 const gdb_byte *arg_bits = value_contents_all (arg); 565 struct type *arg_type = check_typedef (value_type (arg)); 566 ULONGEST arg_size = TYPE_LENGTH (arg_type); 567 568 if (i == 0 && struct_addr != 0 && !struct_return 569 && TYPE_CODE (arg_type) == TYPE_CODE_PTR 570 && extract_unsigned_integer (arg_bits, 4, 571 byte_order) == struct_addr) 572 { 573 /* This argument represents the address at which C++ (and 574 possibly other languages) store their return value. 575 Put this value in R15. */ 576 if (write_pass) 577 regcache_cooked_write_unsigned (regcache, RX_R15_REGNUM, 578 struct_addr); 579 } 580 else if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT 581 && TYPE_CODE (arg_type) != TYPE_CODE_UNION) 582 { 583 /* Argument is a scalar. */ 584 if (arg_size == 8) 585 { 586 if (i < num_register_candidate_args 587 && arg_reg <= RX_R4_REGNUM - 1) 588 { 589 /* If argument registers are going to be used to pass 590 an 8 byte scalar, the ABI specifies that two registers 591 must be available. */ 592 if (write_pass) 593 { 594 regcache_cooked_write_unsigned (regcache, arg_reg, 595 extract_unsigned_integer 596 (arg_bits, 4, 597 byte_order)); 598 regcache_cooked_write_unsigned (regcache, 599 arg_reg + 1, 600 extract_unsigned_integer 601 (arg_bits + 4, 4, 602 byte_order)); 603 } 604 arg_reg += 2; 605 } 606 else 607 { 608 sp_off = align_up (sp_off, 4); 609 /* Otherwise, pass the 8 byte scalar on the stack. */ 610 if (write_pass) 611 write_memory (sp + sp_off, arg_bits, 8); 612 sp_off += 8; 613 } 614 } 615 else 616 { 617 ULONGEST u; 618 619 gdb_assert (arg_size <= 4); 620 621 u = 622 extract_unsigned_integer (arg_bits, arg_size, byte_order); 623 624 if (i < num_register_candidate_args 625 && arg_reg <= RX_R4_REGNUM) 626 { 627 if (write_pass) 628 regcache_cooked_write_unsigned (regcache, arg_reg, u); 629 arg_reg += 1; 630 } 631 else 632 { 633 int p_arg_size = 4; 634 635 if (TYPE_PROTOTYPED (func_type) 636 && i < TYPE_NFIELDS (func_type)) 637 { 638 struct type *p_arg_type = 639 TYPE_FIELD_TYPE (func_type, i); 640 p_arg_size = TYPE_LENGTH (p_arg_type); 641 } 642 643 sp_off = align_up (sp_off, p_arg_size); 644 645 if (write_pass) 646 write_memory_unsigned_integer (sp + sp_off, 647 p_arg_size, byte_order, 648 u); 649 sp_off += p_arg_size; 650 } 651 } 652 } 653 else 654 { 655 /* Argument is a struct or union. Pass as much of the struct 656 in registers, if possible. Pass the rest on the stack. */ 657 while (arg_size > 0) 658 { 659 if (i < num_register_candidate_args 660 && arg_reg <= RX_R4_REGNUM 661 && arg_size <= 4 * (RX_R4_REGNUM - arg_reg + 1) 662 && arg_size % 4 == 0) 663 { 664 int len = min (arg_size, 4); 665 666 if (write_pass) 667 regcache_cooked_write_unsigned (regcache, arg_reg, 668 extract_unsigned_integer 669 (arg_bits, len, 670 byte_order)); 671 arg_bits += len; 672 arg_size -= len; 673 arg_reg++; 674 } 675 else 676 { 677 sp_off = align_up (sp_off, 4); 678 if (write_pass) 679 write_memory (sp + sp_off, arg_bits, arg_size); 680 sp_off += align_up (arg_size, 4); 681 arg_size = 0; 682 } 683 } 684 } 685 } 686 } 687 688 /* Keep track of the stack address prior to pushing the return address. 689 This is the value that we'll return. */ 690 cfa = sp; 691 692 /* Push the return address. */ 693 sp = sp - 4; 694 write_memory_unsigned_integer (sp, 4, byte_order, bp_addr); 695 696 /* Update the stack pointer. */ 697 regcache_cooked_write_unsigned (regcache, RX_SP_REGNUM, sp); 698 699 return cfa; 700} 701 702/* Implement the "return_value" gdbarch method. */ 703static enum return_value_convention 704rx_return_value (struct gdbarch *gdbarch, 705 struct value *function, 706 struct type *valtype, 707 struct regcache *regcache, 708 gdb_byte *readbuf, const gdb_byte *writebuf) 709{ 710 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 711 ULONGEST valtype_len = TYPE_LENGTH (valtype); 712 713 if (TYPE_LENGTH (valtype) > 16 714 || ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT 715 || TYPE_CODE (valtype) == TYPE_CODE_UNION) 716 && TYPE_LENGTH (valtype) % 4 != 0)) 717 return RETURN_VALUE_STRUCT_CONVENTION; 718 719 if (readbuf) 720 { 721 ULONGEST u; 722 int argreg = RX_R1_REGNUM; 723 int offset = 0; 724 725 while (valtype_len > 0) 726 { 727 int len = min (valtype_len, 4); 728 729 regcache_cooked_read_unsigned (regcache, argreg, &u); 730 store_unsigned_integer (readbuf + offset, len, byte_order, u); 731 valtype_len -= len; 732 offset += len; 733 argreg++; 734 } 735 } 736 737 if (writebuf) 738 { 739 ULONGEST u; 740 int argreg = RX_R1_REGNUM; 741 int offset = 0; 742 743 while (valtype_len > 0) 744 { 745 int len = min (valtype_len, 4); 746 747 u = extract_unsigned_integer (writebuf + offset, len, byte_order); 748 regcache_cooked_write_unsigned (regcache, argreg, u); 749 valtype_len -= len; 750 offset += len; 751 argreg++; 752 } 753 } 754 755 return RETURN_VALUE_REGISTER_CONVENTION; 756} 757 758/* Implement the "breakpoint_from_pc" gdbarch method. */ 759static const gdb_byte * 760rx_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr) 761{ 762 static gdb_byte breakpoint[] = { 0x00 }; 763 *lenptr = sizeof breakpoint; 764 return breakpoint; 765} 766 767/* Allocate and initialize a gdbarch object. */ 768static struct gdbarch * 769rx_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 770{ 771 struct gdbarch *gdbarch; 772 struct gdbarch_tdep *tdep; 773 int elf_flags; 774 775 /* Extract the elf_flags if available. */ 776 if (info.abfd != NULL 777 && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour) 778 elf_flags = elf_elfheader (info.abfd)->e_flags; 779 else 780 elf_flags = 0; 781 782 783 /* Try to find the architecture in the list of already defined 784 architectures. */ 785 for (arches = gdbarch_list_lookup_by_info (arches, &info); 786 arches != NULL; 787 arches = gdbarch_list_lookup_by_info (arches->next, &info)) 788 { 789 if (gdbarch_tdep (arches->gdbarch)->elf_flags != elf_flags) 790 continue; 791 792 return arches->gdbarch; 793 } 794 795 /* None found, create a new architecture from the information 796 provided. */ 797 tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep)); 798 gdbarch = gdbarch_alloc (&info, tdep); 799 tdep->elf_flags = elf_flags; 800 801 set_gdbarch_num_regs (gdbarch, RX_NUM_REGS); 802 set_gdbarch_num_pseudo_regs (gdbarch, 0); 803 set_gdbarch_register_name (gdbarch, rx_register_name); 804 set_gdbarch_register_type (gdbarch, rx_register_type); 805 set_gdbarch_pc_regnum (gdbarch, RX_PC_REGNUM); 806 set_gdbarch_sp_regnum (gdbarch, RX_SP_REGNUM); 807 set_gdbarch_inner_than (gdbarch, core_addr_lessthan); 808 set_gdbarch_decr_pc_after_break (gdbarch, 1); 809 set_gdbarch_breakpoint_from_pc (gdbarch, rx_breakpoint_from_pc); 810 set_gdbarch_skip_prologue (gdbarch, rx_skip_prologue); 811 812 set_gdbarch_print_insn (gdbarch, print_insn_rx); 813 814 set_gdbarch_unwind_pc (gdbarch, rx_unwind_pc); 815 set_gdbarch_unwind_sp (gdbarch, rx_unwind_sp); 816 817 /* Target builtin data types. */ 818 set_gdbarch_char_signed (gdbarch, 0); 819 set_gdbarch_short_bit (gdbarch, 16); 820 set_gdbarch_int_bit (gdbarch, 32); 821 set_gdbarch_long_bit (gdbarch, 32); 822 set_gdbarch_long_long_bit (gdbarch, 64); 823 set_gdbarch_ptr_bit (gdbarch, 32); 824 set_gdbarch_float_bit (gdbarch, 32); 825 set_gdbarch_float_format (gdbarch, floatformats_ieee_single); 826 if (elf_flags & E_FLAG_RX_64BIT_DOUBLES) 827 { 828 set_gdbarch_double_bit (gdbarch, 64); 829 set_gdbarch_long_double_bit (gdbarch, 64); 830 set_gdbarch_double_format (gdbarch, floatformats_ieee_double); 831 set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double); 832 } 833 else 834 { 835 set_gdbarch_double_bit (gdbarch, 32); 836 set_gdbarch_long_double_bit (gdbarch, 32); 837 set_gdbarch_double_format (gdbarch, floatformats_ieee_single); 838 set_gdbarch_long_double_format (gdbarch, floatformats_ieee_single); 839 } 840 841 /* Frame unwinding. */ 842#if 0 843 /* Note: The test results are better with the dwarf2 unwinder disabled, 844 so it's turned off for now. */ 845 dwarf2_append_unwinders (gdbarch); 846#endif 847 frame_unwind_append_unwinder (gdbarch, &rx_frame_unwind); 848 849 /* Methods for saving / extracting a dummy frame's ID. 850 The ID's stack address must match the SP value returned by 851 PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */ 852 set_gdbarch_dummy_id (gdbarch, rx_dummy_id); 853 set_gdbarch_push_dummy_call (gdbarch, rx_push_dummy_call); 854 set_gdbarch_return_value (gdbarch, rx_return_value); 855 856 /* Virtual tables. */ 857 set_gdbarch_vbit_in_delta (gdbarch, 1); 858 859 return gdbarch; 860} 861 862/* -Wmissing-prototypes */ 863extern initialize_file_ftype _initialize_rx_tdep; 864 865/* Register the above initialization routine. */ 866 867void 868_initialize_rx_tdep (void) 869{ 870 register_gdbarch_init (bfd_arch_rx, rx_gdbarch_init); 871} 872