1 /* Target-dependent code for the Renesas RX for GDB, the GNU debugger.
3 Copyright (C) 2008-2015 Free Software Foundation, Inc.
5 Contributed by Red Hat, Inc.
7 This file is part of GDB.
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.
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.
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/>. */
23 #include "arch-utils.h"
24 #include "prologue-value.h"
27 #include "opcode/rx.h"
31 #include "frame-unwind.h"
32 #include "frame-base.h"
35 #include "dwarf2-frame.h"
40 /* Certain important register numbers. */
61 RX_FRAME_TYPE_EXCEPTION
,
62 RX_FRAME_TYPE_FAST_INTERRUPT
65 /* Architecture specific data. */
68 /* The ELF header flags specify the multilib used. */
71 /* Type of PSW and BPSW. */
72 struct type
*rx_psw_type
;
75 struct type
*rx_fpsw_type
;
78 /* This structure holds the results of a prologue analysis. */
81 /* Frame type, either a normal frame or one of two types of exception
83 enum rx_frame_type frame_type
;
85 /* The offset from the frame base to the stack pointer --- always
88 Calling this a "size" is a bit misleading, but given that the
89 stack grows downwards, using offsets for everything keeps one
90 from going completely sign-crazy: you never change anything's
91 sign for an ADD instruction; always change the second operand's
92 sign for a SUB instruction; and everything takes care of
96 /* Non-zero if this function has initialized the frame pointer from
97 the stack pointer, zero otherwise. */
100 /* If has_frame_ptr is non-zero, this is the offset from the frame
101 base to where the frame pointer points. This is always zero or
103 int frame_ptr_offset
;
105 /* The address of the first instruction at which the frame has been
106 set up and the arguments are where the debug info says they are
107 --- as best as we can tell. */
108 CORE_ADDR prologue_end
;
110 /* reg_offset[R] is the offset from the CFA at which register R is
111 saved, or 1 if register R has not been saved. (Real values are
112 always zero or negative.) */
113 int reg_offset
[RX_NUM_REGS
];
116 /* Implement the "register_name" gdbarch method. */
118 rx_register_name (struct gdbarch
*gdbarch
, int regnr
)
120 static const char *const reg_names
[] = {
149 return reg_names
[regnr
];
152 /* Implement the "register_type" gdbarch method. */
154 rx_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
156 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
158 if (reg_nr
== RX_PC_REGNUM
)
159 return builtin_type (gdbarch
)->builtin_func_ptr
;
160 else if (reg_nr
== RX_PSW_REGNUM
|| reg_nr
== RX_BPSW_REGNUM
)
161 return tdep
->rx_psw_type
;
162 else if (reg_nr
== RX_FPSW_REGNUM
)
163 return tdep
->rx_fpsw_type
;
164 else if (reg_nr
== RX_ACC_REGNUM
)
165 return builtin_type (gdbarch
)->builtin_unsigned_long_long
;
167 return builtin_type (gdbarch
)->builtin_unsigned_long
;
171 /* Function for finding saved registers in a 'struct pv_area'; this
172 function is passed to pv_area_scan.
174 If VALUE is a saved register, ADDR says it was saved at a constant
175 offset from the frame base, and SIZE indicates that the whole
176 register was saved, record its offset. */
178 check_for_saved (void *result_untyped
, pv_t addr
, CORE_ADDR size
, pv_t value
)
180 struct rx_prologue
*result
= (struct rx_prologue
*) result_untyped
;
182 if (value
.kind
== pvk_register
184 && pv_is_register (addr
, RX_SP_REGNUM
)
185 && size
== register_size (target_gdbarch (), value
.reg
))
186 result
->reg_offset
[value
.reg
] = addr
.k
;
189 /* Define a "handle" struct for fetching the next opcode. */
190 struct rx_get_opcode_byte_handle
195 /* Fetch a byte on behalf of the opcode decoder. HANDLE contains
196 the memory address of the next byte to fetch. If successful,
197 the address in the handle is updated and the byte fetched is
198 returned as the value of the function. If not successful, -1
201 rx_get_opcode_byte (void *handle
)
203 struct rx_get_opcode_byte_handle
*opcdata
= handle
;
207 status
= target_read_code (opcdata
->pc
, &byte
, 1);
217 /* Analyze a prologue starting at START_PC, going no further than
218 LIMIT_PC. Fill in RESULT as appropriate. */
221 rx_analyze_prologue (CORE_ADDR start_pc
, CORE_ADDR limit_pc
,
222 enum rx_frame_type frame_type
,
223 struct rx_prologue
*result
)
225 CORE_ADDR pc
, next_pc
;
227 pv_t reg
[RX_NUM_REGS
];
228 struct pv_area
*stack
;
229 struct cleanup
*back_to
;
230 CORE_ADDR after_last_frame_setup_insn
= start_pc
;
232 memset (result
, 0, sizeof (*result
));
234 result
->frame_type
= frame_type
;
236 for (rn
= 0; rn
< RX_NUM_REGS
; rn
++)
238 reg
[rn
] = pv_register (rn
, 0);
239 result
->reg_offset
[rn
] = 1;
242 stack
= make_pv_area (RX_SP_REGNUM
, gdbarch_addr_bit (target_gdbarch ()));
243 back_to
= make_cleanup_free_pv_area (stack
);
245 if (frame_type
== RX_FRAME_TYPE_FAST_INTERRUPT
)
247 /* This code won't do anything useful at present, but this is
248 what happens for fast interrupts. */
249 reg
[RX_BPSW_REGNUM
] = reg
[RX_PSW_REGNUM
];
250 reg
[RX_BPC_REGNUM
] = reg
[RX_PC_REGNUM
];
254 /* When an exception occurs, the PSW is saved to the interrupt stack
256 if (frame_type
== RX_FRAME_TYPE_EXCEPTION
)
258 reg
[RX_SP_REGNUM
] = pv_add_constant (reg
[RX_SP_REGNUM
], -4);
259 pv_area_store (stack
, reg
[RX_SP_REGNUM
], 4, reg
[RX_PSW_REGNUM
]);
262 /* The call instruction (or an exception/interrupt) has saved the return
263 address on the stack. */
264 reg
[RX_SP_REGNUM
] = pv_add_constant (reg
[RX_SP_REGNUM
], -4);
265 pv_area_store (stack
, reg
[RX_SP_REGNUM
], 4, reg
[RX_PC_REGNUM
]);
271 while (pc
< limit_pc
)
274 struct rx_get_opcode_byte_handle opcode_handle
;
275 RX_Opcode_Decoded opc
;
277 opcode_handle
.pc
= pc
;
278 bytes_read
= rx_decode_opcode (pc
, &opc
, rx_get_opcode_byte
,
280 next_pc
= pc
+ bytes_read
;
282 if (opc
.id
== RXO_pushm
/* pushm r1, r2 */
283 && opc
.op
[1].type
== RX_Operand_Register
284 && opc
.op
[2].type
== RX_Operand_Register
)
291 for (r
= r2
; r
>= r1
; r
--)
293 reg
[RX_SP_REGNUM
] = pv_add_constant (reg
[RX_SP_REGNUM
], -4);
294 pv_area_store (stack
, reg
[RX_SP_REGNUM
], 4, reg
[r
]);
296 after_last_frame_setup_insn
= next_pc
;
298 else if (opc
.id
== RXO_mov
/* mov.l rdst, rsrc */
299 && opc
.op
[0].type
== RX_Operand_Register
300 && opc
.op
[1].type
== RX_Operand_Register
301 && opc
.size
== RX_Long
)
305 rdst
= opc
.op
[0].reg
;
306 rsrc
= opc
.op
[1].reg
;
307 reg
[rdst
] = reg
[rsrc
];
308 if (rdst
== RX_FP_REGNUM
&& rsrc
== RX_SP_REGNUM
)
309 after_last_frame_setup_insn
= next_pc
;
311 else if (opc
.id
== RXO_mov
/* mov.l rsrc, [-SP] */
312 && opc
.op
[0].type
== RX_Operand_Predec
313 && opc
.op
[0].reg
== RX_SP_REGNUM
314 && opc
.op
[1].type
== RX_Operand_Register
315 && opc
.size
== RX_Long
)
319 rsrc
= opc
.op
[1].reg
;
320 reg
[RX_SP_REGNUM
] = pv_add_constant (reg
[RX_SP_REGNUM
], -4);
321 pv_area_store (stack
, reg
[RX_SP_REGNUM
], 4, reg
[rsrc
]);
322 after_last_frame_setup_insn
= next_pc
;
324 else if (opc
.id
== RXO_add
/* add #const, rsrc, rdst */
325 && opc
.op
[0].type
== RX_Operand_Register
326 && opc
.op
[1].type
== RX_Operand_Immediate
327 && opc
.op
[2].type
== RX_Operand_Register
)
329 int rdst
= opc
.op
[0].reg
;
330 int addend
= opc
.op
[1].addend
;
331 int rsrc
= opc
.op
[2].reg
;
332 reg
[rdst
] = pv_add_constant (reg
[rsrc
], addend
);
333 /* Negative adjustments to the stack pointer or frame pointer
334 are (most likely) part of the prologue. */
335 if ((rdst
== RX_SP_REGNUM
|| rdst
== RX_FP_REGNUM
) && addend
< 0)
336 after_last_frame_setup_insn
= next_pc
;
338 else if (opc
.id
== RXO_mov
339 && opc
.op
[0].type
== RX_Operand_Indirect
340 && opc
.op
[1].type
== RX_Operand_Register
341 && opc
.size
== RX_Long
342 && (opc
.op
[0].reg
== RX_SP_REGNUM
343 || opc
.op
[0].reg
== RX_FP_REGNUM
)
344 && (RX_R1_REGNUM
<= opc
.op
[1].reg
345 && opc
.op
[1].reg
<= RX_R4_REGNUM
))
347 /* This moves an argument register to the stack. Don't
348 record it, but allow it to be a part of the prologue. */
350 else if (opc
.id
== RXO_branch
351 && opc
.op
[0].type
== RX_Operand_Immediate
352 && next_pc
< opc
.op
[0].addend
)
354 /* When a loop appears as the first statement of a function
355 body, gcc 4.x will use a BRA instruction to branch to the
356 loop condition checking code. This BRA instruction is
357 marked as part of the prologue. We therefore set next_pc
358 to this branch target and also stop the prologue scan.
359 The instructions at and beyond the branch target should
360 no longer be associated with the prologue.
362 Note that we only consider forward branches here. We
363 presume that a forward branch is being used to skip over
366 A backwards branch is covered by the default case below.
367 If we were to encounter a backwards branch, that would
368 most likely mean that we've scanned through a loop body.
369 We definitely want to stop the prologue scan when this
370 happens and that is precisely what is done by the default
373 after_last_frame_setup_insn
= opc
.op
[0].addend
;
374 break; /* Scan no further if we hit this case. */
378 /* Terminate the prologue scan. */
385 /* Is the frame size (offset, really) a known constant? */
386 if (pv_is_register (reg
[RX_SP_REGNUM
], RX_SP_REGNUM
))
387 result
->frame_size
= reg
[RX_SP_REGNUM
].k
;
389 /* Was the frame pointer initialized? */
390 if (pv_is_register (reg
[RX_FP_REGNUM
], RX_SP_REGNUM
))
392 result
->has_frame_ptr
= 1;
393 result
->frame_ptr_offset
= reg
[RX_FP_REGNUM
].k
;
396 /* Record where all the registers were saved. */
397 pv_area_scan (stack
, check_for_saved
, (void *) result
);
399 result
->prologue_end
= after_last_frame_setup_insn
;
401 do_cleanups (back_to
);
405 /* Implement the "skip_prologue" gdbarch method. */
407 rx_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
410 CORE_ADDR func_addr
, func_end
;
411 struct rx_prologue p
;
413 /* Try to find the extent of the function that contains PC. */
414 if (!find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
))
417 /* The frame type doesn't matter here, since we only care about
418 where the prologue ends. We'll use RX_FRAME_TYPE_NORMAL. */
419 rx_analyze_prologue (pc
, func_end
, RX_FRAME_TYPE_NORMAL
, &p
);
420 return p
.prologue_end
;
423 /* Given a frame described by THIS_FRAME, decode the prologue of its
424 associated function if there is not cache entry as specified by
425 THIS_PROLOGUE_CACHE. Save the decoded prologue in the cache and
426 return that struct as the value of this function. */
428 static struct rx_prologue
*
429 rx_analyze_frame_prologue (struct frame_info
*this_frame
,
430 enum rx_frame_type frame_type
,
431 void **this_prologue_cache
)
433 if (!*this_prologue_cache
)
435 CORE_ADDR func_start
, stop_addr
;
437 *this_prologue_cache
= FRAME_OBSTACK_ZALLOC (struct rx_prologue
);
439 func_start
= get_frame_func (this_frame
);
440 stop_addr
= get_frame_pc (this_frame
);
442 /* If we couldn't find any function containing the PC, then
443 just initialize the prologue cache, but don't do anything. */
445 stop_addr
= func_start
;
447 rx_analyze_prologue (func_start
, stop_addr
, frame_type
,
448 *this_prologue_cache
);
451 return *this_prologue_cache
;
454 /* Determine type of frame by scanning the function for a return
457 static enum rx_frame_type
458 rx_frame_type (struct frame_info
*this_frame
, void **this_cache
)
461 CORE_ADDR pc
, start_pc
, lim_pc
;
463 struct rx_get_opcode_byte_handle opcode_handle
;
464 RX_Opcode_Decoded opc
;
466 gdb_assert (this_cache
!= NULL
);
468 /* If we have a cached value, return it. */
470 if (*this_cache
!= NULL
)
472 struct rx_prologue
*p
= *this_cache
;
474 return p
->frame_type
;
477 /* No cached value; scan the function. The frame type is cached in
478 rx_analyze_prologue / rx_analyze_frame_prologue. */
480 pc
= get_frame_pc (this_frame
);
482 /* Attempt to find the last address in the function. If it cannot
483 be determined, set the limit to be a short ways past the frame's
485 if (!find_pc_partial_function (pc
, &name
, &start_pc
, &lim_pc
))
490 opcode_handle
.pc
= pc
;
491 bytes_read
= rx_decode_opcode (pc
, &opc
, rx_get_opcode_byte
,
494 if (bytes_read
<= 0 || opc
.id
== RXO_rts
)
495 return RX_FRAME_TYPE_NORMAL
;
496 else if (opc
.id
== RXO_rtfi
)
497 return RX_FRAME_TYPE_FAST_INTERRUPT
;
498 else if (opc
.id
== RXO_rte
)
499 return RX_FRAME_TYPE_EXCEPTION
;
504 return RX_FRAME_TYPE_NORMAL
;
508 /* Given the next frame and a prologue cache, return this frame's
512 rx_frame_base (struct frame_info
*this_frame
, void **this_cache
)
514 enum rx_frame_type frame_type
= rx_frame_type (this_frame
, this_cache
);
515 struct rx_prologue
*p
516 = rx_analyze_frame_prologue (this_frame
, frame_type
, this_cache
);
518 /* In functions that use alloca, the distance between the stack
519 pointer and the frame base varies dynamically, so we can't use
520 the SP plus static information like prologue analysis to find the
521 frame base. However, such functions must have a frame pointer,
522 to be able to restore the SP on exit. So whenever we do have a
523 frame pointer, use that to find the base. */
524 if (p
->has_frame_ptr
)
526 CORE_ADDR fp
= get_frame_register_unsigned (this_frame
, RX_FP_REGNUM
);
527 return fp
- p
->frame_ptr_offset
;
531 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, RX_SP_REGNUM
);
532 return sp
- p
->frame_size
;
536 /* Implement the "frame_this_id" method for unwinding frames. */
539 rx_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
540 struct frame_id
*this_id
)
542 *this_id
= frame_id_build (rx_frame_base (this_frame
, this_cache
),
543 get_frame_func (this_frame
));
546 /* Implement the "frame_prev_register" method for unwinding frames. */
548 static struct value
*
549 rx_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
552 enum rx_frame_type frame_type
= rx_frame_type (this_frame
, this_cache
);
553 struct rx_prologue
*p
554 = rx_analyze_frame_prologue (this_frame
, frame_type
, this_cache
);
555 CORE_ADDR frame_base
= rx_frame_base (this_frame
, this_cache
);
557 if (regnum
== RX_SP_REGNUM
)
559 if (frame_type
== RX_FRAME_TYPE_EXCEPTION
)
561 struct value
*psw_val
;
564 psw_val
= rx_frame_prev_register (this_frame
, this_cache
,
566 psw
= extract_unsigned_integer (value_contents_all (psw_val
), 4,
568 get_frame_arch (this_frame
)));
570 if ((psw
& 0x20000 /* U bit */) != 0)
571 return rx_frame_prev_register (this_frame
, this_cache
,
574 /* Fall through for the case where U bit is zero. */
577 return frame_unwind_got_constant (this_frame
, regnum
, frame_base
);
580 if (frame_type
== RX_FRAME_TYPE_FAST_INTERRUPT
)
582 if (regnum
== RX_PC_REGNUM
)
583 return rx_frame_prev_register (this_frame
, this_cache
,
585 if (regnum
== RX_PSW_REGNUM
)
586 return rx_frame_prev_register (this_frame
, this_cache
,
590 /* If prologue analysis says we saved this register somewhere,
591 return a description of the stack slot holding it. */
592 if (p
->reg_offset
[regnum
] != 1)
593 return frame_unwind_got_memory (this_frame
, regnum
,
594 frame_base
+ p
->reg_offset
[regnum
]);
596 /* Otherwise, presume we haven't changed the value of this
597 register, and get it from the next frame. */
598 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
601 /* Return TRUE if the frame indicated by FRAME_TYPE is a normal frame. */
604 normal_frame_p (enum rx_frame_type frame_type
)
606 return (frame_type
== RX_FRAME_TYPE_NORMAL
);
609 /* Return TRUE if the frame indicated by FRAME_TYPE is an exception
613 exception_frame_p (enum rx_frame_type frame_type
)
615 return (frame_type
== RX_FRAME_TYPE_EXCEPTION
616 || frame_type
== RX_FRAME_TYPE_FAST_INTERRUPT
);
619 /* Common code used by both normal and exception frame sniffers. */
622 rx_frame_sniffer_common (const struct frame_unwind
*self
,
623 struct frame_info
*this_frame
,
625 int (*sniff_p
)(enum rx_frame_type
) )
627 gdb_assert (this_cache
!= NULL
);
629 if (*this_cache
== NULL
)
631 enum rx_frame_type frame_type
= rx_frame_type (this_frame
, this_cache
);
633 if (sniff_p (frame_type
))
635 /* The call below will fill in the cache, including the frame
637 (void) rx_analyze_frame_prologue (this_frame
, frame_type
, this_cache
);
646 struct rx_prologue
*p
= *this_cache
;
648 return sniff_p (p
->frame_type
);
652 /* Frame sniffer for normal (non-exception) frames. */
655 rx_frame_sniffer (const struct frame_unwind
*self
,
656 struct frame_info
*this_frame
,
659 return rx_frame_sniffer_common (self
, this_frame
, this_cache
,
663 /* Frame sniffer for exception frames. */
666 rx_exception_sniffer (const struct frame_unwind
*self
,
667 struct frame_info
*this_frame
,
670 return rx_frame_sniffer_common (self
, this_frame
, this_cache
,
674 /* Data structure for normal code using instruction-based prologue
677 static const struct frame_unwind rx_frame_unwind
= {
679 default_frame_unwind_stop_reason
,
681 rx_frame_prev_register
,
686 /* Data structure for exception code using instruction-based prologue
689 static const struct frame_unwind rx_exception_unwind
= {
690 /* SIGTRAMP_FRAME could be used here, but backtraces are less informative. */
692 default_frame_unwind_stop_reason
,
694 rx_frame_prev_register
,
699 /* Implement the "unwind_pc" gdbarch method. */
701 rx_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
705 pc
= frame_unwind_register_unsigned (this_frame
, RX_PC_REGNUM
);
709 /* Implement the "unwind_sp" gdbarch method. */
711 rx_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
715 sp
= frame_unwind_register_unsigned (this_frame
, RX_SP_REGNUM
);
719 /* Implement the "dummy_id" gdbarch method. */
720 static struct frame_id
721 rx_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
724 frame_id_build (get_frame_register_unsigned (this_frame
, RX_SP_REGNUM
),
725 get_frame_pc (this_frame
));
728 /* Implement the "push_dummy_call" gdbarch method. */
730 rx_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
731 struct regcache
*regcache
, CORE_ADDR bp_addr
, int nargs
,
732 struct value
**args
, CORE_ADDR sp
, int struct_return
,
733 CORE_ADDR struct_addr
)
735 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
739 int num_register_candidate_args
;
741 struct type
*func_type
= value_type (function
);
743 /* Dereference function pointer types. */
744 while (TYPE_CODE (func_type
) == TYPE_CODE_PTR
)
745 func_type
= TYPE_TARGET_TYPE (func_type
);
747 /* The end result had better be a function or a method. */
748 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
749 || TYPE_CODE (func_type
) == TYPE_CODE_METHOD
);
751 /* Functions with a variable number of arguments have all of their
752 variable arguments and the last non-variable argument passed
755 Otherwise, we can pass up to four arguments on the stack.
757 Once computed, we leave this value alone. I.e. we don't update
758 it in case of a struct return going in a register or an argument
759 requiring multiple registers, etc. We rely instead on the value
760 of the ``arg_reg'' variable to get these other details correct. */
762 if (TYPE_VARARGS (func_type
))
763 num_register_candidate_args
= TYPE_NFIELDS (func_type
) - 1;
765 num_register_candidate_args
= 4;
767 /* We make two passes; the first does the stack allocation,
768 the second actually stores the arguments. */
769 for (write_pass
= 0; write_pass
<= 1; write_pass
++)
772 int arg_reg
= RX_R1_REGNUM
;
775 sp
= align_down (sp
- sp_off
, 4);
780 struct type
*return_type
= TYPE_TARGET_TYPE (func_type
);
782 gdb_assert (TYPE_CODE (return_type
) == TYPE_CODE_STRUCT
783 || TYPE_CODE (func_type
) == TYPE_CODE_UNION
);
785 if (TYPE_LENGTH (return_type
) > 16
786 || TYPE_LENGTH (return_type
) % 4 != 0)
789 regcache_cooked_write_unsigned (regcache
, RX_R15_REGNUM
,
794 /* Push the arguments. */
795 for (i
= 0; i
< nargs
; i
++)
797 struct value
*arg
= args
[i
];
798 const gdb_byte
*arg_bits
= value_contents_all (arg
);
799 struct type
*arg_type
= check_typedef (value_type (arg
));
800 ULONGEST arg_size
= TYPE_LENGTH (arg_type
);
802 if (i
== 0 && struct_addr
!= 0 && !struct_return
803 && TYPE_CODE (arg_type
) == TYPE_CODE_PTR
804 && extract_unsigned_integer (arg_bits
, 4,
805 byte_order
) == struct_addr
)
807 /* This argument represents the address at which C++ (and
808 possibly other languages) store their return value.
809 Put this value in R15. */
811 regcache_cooked_write_unsigned (regcache
, RX_R15_REGNUM
,
814 else if (TYPE_CODE (arg_type
) != TYPE_CODE_STRUCT
815 && TYPE_CODE (arg_type
) != TYPE_CODE_UNION
)
817 /* Argument is a scalar. */
820 if (i
< num_register_candidate_args
821 && arg_reg
<= RX_R4_REGNUM
- 1)
823 /* If argument registers are going to be used to pass
824 an 8 byte scalar, the ABI specifies that two registers
825 must be available. */
828 regcache_cooked_write_unsigned (regcache
, arg_reg
,
829 extract_unsigned_integer
832 regcache_cooked_write_unsigned (regcache
,
834 extract_unsigned_integer
842 sp_off
= align_up (sp_off
, 4);
843 /* Otherwise, pass the 8 byte scalar on the stack. */
845 write_memory (sp
+ sp_off
, arg_bits
, 8);
853 gdb_assert (arg_size
<= 4);
856 extract_unsigned_integer (arg_bits
, arg_size
, byte_order
);
858 if (i
< num_register_candidate_args
859 && arg_reg
<= RX_R4_REGNUM
)
862 regcache_cooked_write_unsigned (regcache
, arg_reg
, u
);
869 if (TYPE_PROTOTYPED (func_type
)
870 && i
< TYPE_NFIELDS (func_type
))
872 struct type
*p_arg_type
=
873 TYPE_FIELD_TYPE (func_type
, i
);
874 p_arg_size
= TYPE_LENGTH (p_arg_type
);
877 sp_off
= align_up (sp_off
, p_arg_size
);
880 write_memory_unsigned_integer (sp
+ sp_off
,
881 p_arg_size
, byte_order
,
883 sp_off
+= p_arg_size
;
889 /* Argument is a struct or union. Pass as much of the struct
890 in registers, if possible. Pass the rest on the stack. */
893 if (i
< num_register_candidate_args
894 && arg_reg
<= RX_R4_REGNUM
895 && arg_size
<= 4 * (RX_R4_REGNUM
- arg_reg
+ 1)
896 && arg_size
% 4 == 0)
898 int len
= min (arg_size
, 4);
901 regcache_cooked_write_unsigned (regcache
, arg_reg
,
902 extract_unsigned_integer
911 sp_off
= align_up (sp_off
, 4);
913 write_memory (sp
+ sp_off
, arg_bits
, arg_size
);
914 sp_off
+= align_up (arg_size
, 4);
922 /* Keep track of the stack address prior to pushing the return address.
923 This is the value that we'll return. */
926 /* Push the return address. */
928 write_memory_unsigned_integer (sp
, 4, byte_order
, bp_addr
);
930 /* Update the stack pointer. */
931 regcache_cooked_write_unsigned (regcache
, RX_SP_REGNUM
, sp
);
936 /* Implement the "return_value" gdbarch method. */
937 static enum return_value_convention
938 rx_return_value (struct gdbarch
*gdbarch
,
939 struct value
*function
,
940 struct type
*valtype
,
941 struct regcache
*regcache
,
942 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
944 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
945 ULONGEST valtype_len
= TYPE_LENGTH (valtype
);
947 if (TYPE_LENGTH (valtype
) > 16
948 || ((TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
949 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
)
950 && TYPE_LENGTH (valtype
) % 4 != 0))
951 return RETURN_VALUE_STRUCT_CONVENTION
;
956 int argreg
= RX_R1_REGNUM
;
959 while (valtype_len
> 0)
961 int len
= min (valtype_len
, 4);
963 regcache_cooked_read_unsigned (regcache
, argreg
, &u
);
964 store_unsigned_integer (readbuf
+ offset
, len
, byte_order
, u
);
974 int argreg
= RX_R1_REGNUM
;
977 while (valtype_len
> 0)
979 int len
= min (valtype_len
, 4);
981 u
= extract_unsigned_integer (writebuf
+ offset
, len
, byte_order
);
982 regcache_cooked_write_unsigned (regcache
, argreg
, u
);
989 return RETURN_VALUE_REGISTER_CONVENTION
;
992 /* Implement the "breakpoint_from_pc" gdbarch method. */
993 static const gdb_byte
*
994 rx_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
, int *lenptr
)
996 static gdb_byte breakpoint
[] = { 0x00 };
997 *lenptr
= sizeof breakpoint
;
1001 /* Implement the dwarf_reg_to_regnum" gdbarch method. */
1004 rx_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
1006 if (0 <= reg
&& reg
<= 15)
1009 return RX_PSW_REGNUM
;
1011 return RX_PC_REGNUM
;
1013 internal_error (__FILE__
, __LINE__
,
1014 _("Undefined dwarf2 register mapping of reg %d"),
1018 /* Allocate and initialize a gdbarch object. */
1019 static struct gdbarch
*
1020 rx_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1022 struct gdbarch
*gdbarch
;
1023 struct gdbarch_tdep
*tdep
;
1026 /* Extract the elf_flags if available. */
1027 if (info
.abfd
!= NULL
1028 && bfd_get_flavour (info
.abfd
) == bfd_target_elf_flavour
)
1029 elf_flags
= elf_elfheader (info
.abfd
)->e_flags
;
1034 /* Try to find the architecture in the list of already defined
1036 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1038 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
1040 if (gdbarch_tdep (arches
->gdbarch
)->elf_flags
!= elf_flags
)
1043 return arches
->gdbarch
;
1046 /* None found, create a new architecture from the information
1048 tdep
= (struct gdbarch_tdep
*) xmalloc (sizeof (struct gdbarch_tdep
));
1049 gdbarch
= gdbarch_alloc (&info
, tdep
);
1050 tdep
->elf_flags
= elf_flags
;
1052 /* Initialize the flags type for PSW and BPSW. */
1054 tdep
->rx_psw_type
= arch_flags_type (gdbarch
, "rx_psw_type", 4);
1055 append_flags_type_flag (tdep
->rx_psw_type
, 0, "C");
1056 append_flags_type_flag (tdep
->rx_psw_type
, 1, "Z");
1057 append_flags_type_flag (tdep
->rx_psw_type
, 2, "S");
1058 append_flags_type_flag (tdep
->rx_psw_type
, 3, "O");
1059 append_flags_type_flag (tdep
->rx_psw_type
, 16, "I");
1060 append_flags_type_flag (tdep
->rx_psw_type
, 17, "U");
1061 append_flags_type_flag (tdep
->rx_psw_type
, 20, "PM");
1062 append_flags_type_flag (tdep
->rx_psw_type
, 24, "IPL0");
1063 append_flags_type_flag (tdep
->rx_psw_type
, 25, "IPL1");
1064 append_flags_type_flag (tdep
->rx_psw_type
, 26, "IPL2");
1065 append_flags_type_flag (tdep
->rx_psw_type
, 27, "IPL3");
1067 /* Initialize flags type for FPSW. */
1069 tdep
->rx_fpsw_type
= arch_flags_type (gdbarch
, "rx_fpsw_type", 4);
1070 append_flags_type_flag (tdep
->rx_fpsw_type
, 0, "RM0");
1071 append_flags_type_flag (tdep
->rx_fpsw_type
, 1, "RM1");
1072 append_flags_type_flag (tdep
->rx_fpsw_type
, 2, "CV");
1073 append_flags_type_flag (tdep
->rx_fpsw_type
, 3, "CO");
1074 append_flags_type_flag (tdep
->rx_fpsw_type
, 4, "CZ");
1075 append_flags_type_flag (tdep
->rx_fpsw_type
, 5, "CU");
1076 append_flags_type_flag (tdep
->rx_fpsw_type
, 6, "CX");
1077 append_flags_type_flag (tdep
->rx_fpsw_type
, 7, "CE");
1078 append_flags_type_flag (tdep
->rx_fpsw_type
, 8, "DN");
1079 append_flags_type_flag (tdep
->rx_fpsw_type
, 10, "EV");
1080 append_flags_type_flag (tdep
->rx_fpsw_type
, 11, "EO");
1081 append_flags_type_flag (tdep
->rx_fpsw_type
, 12, "EZ");
1082 append_flags_type_flag (tdep
->rx_fpsw_type
, 13, "EU");
1083 append_flags_type_flag (tdep
->rx_fpsw_type
, 14, "EX");
1084 append_flags_type_flag (tdep
->rx_fpsw_type
, 26, "FV");
1085 append_flags_type_flag (tdep
->rx_fpsw_type
, 27, "FO");
1086 append_flags_type_flag (tdep
->rx_fpsw_type
, 28, "FZ");
1087 append_flags_type_flag (tdep
->rx_fpsw_type
, 29, "FU");
1088 append_flags_type_flag (tdep
->rx_fpsw_type
, 30, "FX");
1089 append_flags_type_flag (tdep
->rx_fpsw_type
, 31, "FS");
1091 set_gdbarch_num_regs (gdbarch
, RX_NUM_REGS
);
1092 set_gdbarch_num_pseudo_regs (gdbarch
, 0);
1093 set_gdbarch_register_name (gdbarch
, rx_register_name
);
1094 set_gdbarch_register_type (gdbarch
, rx_register_type
);
1095 set_gdbarch_pc_regnum (gdbarch
, RX_PC_REGNUM
);
1096 set_gdbarch_sp_regnum (gdbarch
, RX_SP_REGNUM
);
1097 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1098 set_gdbarch_decr_pc_after_break (gdbarch
, 1);
1099 set_gdbarch_breakpoint_from_pc (gdbarch
, rx_breakpoint_from_pc
);
1100 set_gdbarch_skip_prologue (gdbarch
, rx_skip_prologue
);
1102 set_gdbarch_print_insn (gdbarch
, print_insn_rx
);
1104 set_gdbarch_unwind_pc (gdbarch
, rx_unwind_pc
);
1105 set_gdbarch_unwind_sp (gdbarch
, rx_unwind_sp
);
1107 /* Target builtin data types. */
1108 set_gdbarch_char_signed (gdbarch
, 0);
1109 set_gdbarch_short_bit (gdbarch
, 16);
1110 set_gdbarch_int_bit (gdbarch
, 32);
1111 set_gdbarch_long_bit (gdbarch
, 32);
1112 set_gdbarch_long_long_bit (gdbarch
, 64);
1113 set_gdbarch_ptr_bit (gdbarch
, 32);
1114 set_gdbarch_float_bit (gdbarch
, 32);
1115 set_gdbarch_float_format (gdbarch
, floatformats_ieee_single
);
1116 if (elf_flags
& E_FLAG_RX_64BIT_DOUBLES
)
1118 set_gdbarch_double_bit (gdbarch
, 64);
1119 set_gdbarch_long_double_bit (gdbarch
, 64);
1120 set_gdbarch_double_format (gdbarch
, floatformats_ieee_double
);
1121 set_gdbarch_long_double_format (gdbarch
, floatformats_ieee_double
);
1125 set_gdbarch_double_bit (gdbarch
, 32);
1126 set_gdbarch_long_double_bit (gdbarch
, 32);
1127 set_gdbarch_double_format (gdbarch
, floatformats_ieee_single
);
1128 set_gdbarch_long_double_format (gdbarch
, floatformats_ieee_single
);
1131 /* DWARF register mapping. */
1132 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, rx_dwarf_reg_to_regnum
);
1134 /* Frame unwinding. */
1135 frame_unwind_append_unwinder (gdbarch
, &rx_exception_unwind
);
1136 dwarf2_append_unwinders (gdbarch
);
1137 frame_unwind_append_unwinder (gdbarch
, &rx_frame_unwind
);
1139 /* Methods for saving / extracting a dummy frame's ID.
1140 The ID's stack address must match the SP value returned by
1141 PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */
1142 set_gdbarch_dummy_id (gdbarch
, rx_dummy_id
);
1143 set_gdbarch_push_dummy_call (gdbarch
, rx_push_dummy_call
);
1144 set_gdbarch_return_value (gdbarch
, rx_return_value
);
1146 /* Virtual tables. */
1147 set_gdbarch_vbit_in_delta (gdbarch
, 1);
1152 /* -Wmissing-prototypes */
1153 extern initialize_file_ftype _initialize_rx_tdep
;
1155 /* Register the above initialization routine. */
1158 _initialize_rx_tdep (void)
1160 register_gdbarch_init (bfd_arch_rx
, rx_gdbarch_init
);