1 /* Target-dependent code for the CSKY architecture, for GDB.
3 Copyright (C) 2010-2018 Free Software Foundation, Inc.
5 Contributed by C-SKY Microsystems and Mentor Graphics.
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 "gdb_assert.h"
35 #include "arch-utils.h"
39 #include "reggroups.h"
43 #include "sim-regno.h"
45 #include "frame-unwind.h"
46 #include "frame-base.h"
47 #include "trad-frame.h"
49 #include "floatformat.h"
51 #include "target-descriptions.h"
52 #include "dwarf2-frame.h"
53 #include "user-regs.h"
55 #include "reggroups.h"
56 #include "csky-tdep.h"
59 #include "opcode/csky.h"
63 /* Control debugging information emitted in this file. */
64 static int csky_debug
= 0;
66 static struct reggroup
*cr_reggroup
;
67 static struct reggroup
*fr_reggroup
;
68 static struct reggroup
*vr_reggroup
;
69 static struct reggroup
*mmu_reggroup
;
70 static struct reggroup
*prof_reggroup
;
72 /* Convenience function to print debug messages in prologue analysis. */
75 print_savedreg_msg (int regno
, int offsets
[], bool print_continuing
)
77 fprintf_unfiltered (gdb_stdlog
, "csky: r%d saved at offset 0x%x\n",
78 regno
, offsets
[regno
]);
80 fprintf_unfiltered (gdb_stdlog
, "csky: continuing\n");
83 /* Check whether the instruction at ADDR is 16-bit or not. */
86 csky_pc_is_csky16 (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
88 gdb_byte target_mem
[2];
92 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
94 status
= target_read_memory (addr
, target_mem
, 2);
95 /* Assume a 16-bit instruction if we can't read memory. */
99 /* Get instruction from memory. */
100 insn
= extract_unsigned_integer (target_mem
, 2, byte_order
);
101 if ((insn
& CSKY_32_INSN_MASK
) == CSKY_32_INSN_MASK
)
103 else if (insn
== CSKY_BKPT_INSN
)
105 /* Check for 32-bit bkpt instruction which is all 0. */
106 status
= target_read_memory (addr
+ 2, target_mem
, 2);
110 insn
= extract_unsigned_integer (target_mem
, 2, byte_order
);
111 if (insn
== CSKY_BKPT_INSN
)
117 /* Get one instruction at ADDR and store it in INSN. Return 2 for
118 a 16-bit instruction or 4 for a 32-bit instruction. */
121 csky_get_insn (struct gdbarch
*gdbarch
, CORE_ADDR addr
, unsigned int *insn
)
123 gdb_byte target_mem
[2];
124 unsigned int insn_type
;
127 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
129 status
= target_read_memory (addr
, target_mem
, 2);
131 memory_error (TARGET_XFER_E_IO
, addr
);
133 insn_type
= extract_unsigned_integer (target_mem
, 2, byte_order
);
134 if (CSKY_32_INSN_MASK
== (insn_type
& CSKY_32_INSN_MASK
))
136 status
= target_read_memory (addr
+ 2, target_mem
, 2);
138 memory_error (TARGET_XFER_E_IO
, addr
);
139 insn_type
= ((insn_type
<< 16)
140 | extract_unsigned_integer (target_mem
, 2, byte_order
));
147 /* Implement the read_pc gdbarch method. */
150 csky_read_pc (readable_regcache
*regcache
)
153 regcache
->cooked_read (CSKY_PC_REGNUM
, &pc
);
157 /* Implement the write_pc gdbarch method. */
160 csky_write_pc (regcache
*regcache
, CORE_ADDR val
)
162 regcache_cooked_write_unsigned (regcache
, CSKY_PC_REGNUM
, val
);
165 /* Implement the unwind_sp gdbarch method. */
168 csky_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
170 return frame_unwind_register_unsigned (next_frame
, CSKY_SP_REGNUM
);
173 /* C-Sky ABI register names. */
175 static const char *csky_register_names
[] =
177 /* General registers 0 - 31. */
178 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
179 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
180 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
181 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
183 /* DSP hilo registers 36 and 37. */
184 "", "", "", "", "hi", "lo", "", "",
186 /* FPU/VPU general registers 40 - 71. */
187 "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
188 "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
189 "vr0", "vr1", "vr2", "vr3", "vr4", "vr5", "vr6", "vr7",
190 "vr8", "vr9", "vr10", "vr11", "vr12", "vr13", "vr14", "vr15",
192 /* Program counter 72. */
195 /* Optional registers (ar) 73 - 88. */
196 "ar0", "ar1", "ar2", "ar3", "ar4", "ar5", "ar6", "ar7",
197 "ar8", "ar9", "ar10", "ar11", "ar12", "ar13", "ar14", "ar15",
199 /* Control registers (cr) 89 - 119. */
200 "psr", "vbr", "epsr", "fpsr", "epc", "fpc", "ss0", "ss1",
201 "ss2", "ss3", "ss4", "gcr", "gsr", "cr13", "cr14", "cr15",
202 "cr16", "cr17", "cr18", "cr19", "cr20", "cr21", "cr22", "cr23",
203 "cr24", "cr25", "cr26", "cr27", "cr28", "cr29", "cr30", "cr31",
205 /* FPU/VPU control registers 121 ~ 123. */
207 "fid", "fcr", "fesr", "", "", "", "usp",
209 /* MMU control registers: 128 - 136. */
210 "mcr0", "mcr2", "mcr3", "mcr4", "mcr6", "mcr8", "mcr29", "mcr30",
213 /* Profiling control registers 140 - 143. */
214 /* Profiling software general registers 144 - 157. */
215 "profcr0", "profcr1", "profcr2", "profcr3", "profsgr0", "profsgr1",
216 "profsgr2", "profsgr3", "profsgr4", "profsgr5", "profsgr6", "profsgr7",
217 "profsgr8", "profsgr9", "profsgr10","profsgr11","profsgr12", "profsgr13",
220 /* Profiling architecture general registers 160 - 174. */
221 "profagr0", "profagr1", "profagr2", "profagr3", "profagr4", "profagr5",
222 "profagr6", "profagr7", "profagr8", "profagr9", "profagr10","profagr11",
223 "profagr12","profagr13","profagr14", "",
225 /* Profiling extension general registers 176 - 188. */
226 "profxgr0", "profxgr1", "profxgr2", "profxgr3", "profxgr4", "profxgr5",
227 "profxgr6", "profxgr7", "profxgr8", "profxgr9", "profxgr10","profxgr11",
230 /* Control registers in bank1. */
231 "", "", "", "", "", "", "", "",
232 "", "", "", "", "", "", "", "",
233 "cp1cr16", "cp1cr17", "cp1cr18", "cp1cr19", "cp1cr20", "", "", "",
234 "", "", "", "", "", "", "", "",
236 /* Control registers in bank3 (ICE). */
237 "sepsr", "sevbr", "seepsr", "", "seepc", "", "nsssp", "seusp",
238 "sedcr", "", "", "", "", "", "", "",
239 "", "", "", "", "", "", "", "",
240 "", "", "", "", "", "", "", ""
243 /* Implement the register_name gdbarch method. */
246 csky_register_name (struct gdbarch
*gdbarch
, int reg_nr
)
248 if (tdesc_has_registers (gdbarch_target_desc (gdbarch
)))
249 return tdesc_register_name (gdbarch
, reg_nr
);
254 if (reg_nr
>= gdbarch_num_regs (gdbarch
))
257 return csky_register_names
[reg_nr
];
260 /* Construct vector type for vrx registers. */
263 csky_vector_type (struct gdbarch
*gdbarch
)
265 const struct builtin_type
*bt
= builtin_type (gdbarch
);
269 t
= arch_composite_type (gdbarch
, "__gdb_builtin_type_vec128i",
272 append_composite_type_field (t
, "u32",
273 init_vector_type (bt
->builtin_int32
, 4));
274 append_composite_type_field (t
, "u16",
275 init_vector_type (bt
->builtin_int16
, 8));
276 append_composite_type_field (t
, "u8",
277 init_vector_type (bt
->builtin_int8
, 16));
280 TYPE_NAME (t
) = "builtin_type_vec128i";
285 /* Return the GDB type object for the "standard" data type
286 of data in register N. */
289 csky_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
291 /* PC, EPC, FPC is a text pointer. */
292 if ((reg_nr
== CSKY_PC_REGNUM
) || (reg_nr
== CSKY_EPC_REGNUM
)
293 || (reg_nr
== CSKY_FPC_REGNUM
))
294 return builtin_type (gdbarch
)->builtin_func_ptr
;
296 /* VBR is a data pointer. */
297 if (reg_nr
== CSKY_VBR_REGNUM
)
298 return builtin_type (gdbarch
)->builtin_data_ptr
;
300 /* Float register has 64 bits, and only in ck810. */
301 if ((reg_nr
>=CSKY_FR0_REGNUM
) && (reg_nr
<= CSKY_FR0_REGNUM
+ 15))
302 return arch_float_type (gdbarch
, 64, "builtin_type_csky_ext",
303 floatformats_ieee_double
);
305 /* Vector register has 128 bits, and only in ck810. */
306 if ((reg_nr
>= CSKY_VR0_REGNUM
) && (reg_nr
<= CSKY_VR0_REGNUM
+ 15))
307 return csky_vector_type (gdbarch
);
309 /* Profiling general register has 48 bits, we use 64bit. */
310 if ((reg_nr
>= CSKY_PROFGR_REGNUM
) && (reg_nr
<= CSKY_PROFGR_REGNUM
+ 44))
311 return builtin_type (gdbarch
)->builtin_uint64
;
313 if (reg_nr
== CSKY_SP_REGNUM
)
314 return builtin_type (gdbarch
)->builtin_data_ptr
;
316 /* Others are 32 bits. */
317 return builtin_type (gdbarch
)->builtin_int32
;
320 /* Data structure to marshall items in a dummy stack frame when
321 calling a function in the inferior. */
325 stack_item (int len_
, const gdb_byte
*data_
)
326 : len (len_
), data (data_
)
330 const gdb_byte
*data
;
333 /* Implement the push_dummy_call gdbarch method. */
336 csky_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
337 struct regcache
*regcache
, CORE_ADDR bp_addr
,
338 int nargs
, struct value
**args
, CORE_ADDR sp
,
339 int struct_return
, CORE_ADDR struct_addr
)
342 int argreg
= CSKY_ABI_A0_REGNUM
;
343 int last_arg_regnum
= CSKY_ABI_LAST_ARG_REGNUM
;
344 int need_dummy_stack
= 0;
345 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
346 std::vector
<stack_item
> stack_items
;
348 /* Set the return address. For CSKY, the return breakpoint is
349 always at BP_ADDR. */
350 regcache_cooked_write_unsigned (regcache
, CSKY_LR_REGNUM
, bp_addr
);
352 /* The struct_return pointer occupies the first parameter
358 fprintf_unfiltered (gdb_stdlog
,
359 "csky: struct return in %s = %s\n",
360 gdbarch_register_name (gdbarch
, argreg
),
361 paddress (gdbarch
, struct_addr
));
363 regcache_cooked_write_unsigned (regcache
, argreg
, struct_addr
);
367 /* Put parameters into argument registers in REGCACHE.
368 In ABI argument registers are r0 through r3. */
369 for (argnum
= 0; argnum
< nargs
; argnum
++)
372 struct type
*arg_type
;
375 arg_type
= check_typedef (value_type (args
[argnum
]));
376 len
= TYPE_LENGTH (arg_type
);
377 val
= value_contents (args
[argnum
]);
379 /* Copy the argument to argument registers or the dummy stack.
380 Large arguments are split between registers and stack.
382 If len < 4, there is no need to worry about endianness since
383 the arguments will always be stored in the low address. */
387 = extract_unsigned_integer (val
, len
, byte_order
);
388 regcache_cooked_write_unsigned (regcache
, argreg
, regval
);
395 int partial_len
= len
< 4 ? len
: 4;
396 if (argreg
<= last_arg_regnum
)
398 /* The argument is passed in an argument register. */
400 = extract_unsigned_integer (val
, partial_len
,
402 if (byte_order
== BFD_ENDIAN_BIG
)
403 regval
<<= (4 - partial_len
) * 8;
405 /* Put regval into register in REGCACHE. */
406 regcache_cooked_write_unsigned (regcache
, argreg
,
412 /* The argument should be pushed onto the dummy stack. */
413 stack_items
.emplace_back (4, val
);
414 need_dummy_stack
+= 4;
422 /* Transfer the dummy stack frame to the target. */
423 std::vector
<stack_item
>::reverse_iterator iter
;
424 for (iter
= stack_items
.rbegin (); iter
!= stack_items
.rend (); ++iter
)
427 write_memory (sp
, iter
->data
, iter
->len
);
430 /* Finally, update the SP register. */
431 regcache_cooked_write_unsigned (regcache
, CSKY_SP_REGNUM
, sp
);
435 /* Implement the return_value gdbarch method. */
437 static enum return_value_convention
438 csky_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
439 struct type
*valtype
, struct regcache
*regcache
,
440 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
443 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
444 int len
= TYPE_LENGTH (valtype
);
445 unsigned int ret_regnum
= CSKY_RET_REGNUM
;
447 /* Csky abi specifies that return values larger than 8 bytes
448 are put on the stack. */
450 return RETURN_VALUE_STRUCT_CONVENTION
;
456 /* By using store_unsigned_integer we avoid having to do
457 anything special for small big-endian values. */
458 regcache
->cooked_read (ret_regnum
, &tmp
);
459 store_unsigned_integer (readbuf
, (len
> 4 ? 4 : len
),
463 regcache
->cooked_read (ret_regnum
+ 1, &tmp
);
464 store_unsigned_integer (readbuf
+ 4, 4, byte_order
, tmp
);
467 if (writebuf
!= NULL
)
469 regval
= extract_unsigned_integer (writebuf
, len
> 4 ? 4 : len
,
471 regcache_cooked_write_unsigned (regcache
, ret_regnum
, regval
);
474 regval
= extract_unsigned_integer ((gdb_byte
*) writebuf
+ 4,
476 regcache_cooked_write_unsigned (regcache
, ret_regnum
+ 1,
481 return RETURN_VALUE_REGISTER_CONVENTION
;
485 /* Implement the frame_align gdbarch method.
487 Adjust the address downward (direction of stack growth) so that it
488 is correctly aligned for a new stack frame. */
491 csky_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
493 return align_down (addr
, 4);
496 /* Unwind cache used for gdbarch fallback unwinder. */
498 struct csky_unwind_cache
500 /* The stack pointer at the time this frame was created; i.e. the
501 caller's stack pointer when this function was called. It is used
502 to identify this frame. */
505 /* The frame base for this frame is just prev_sp - frame size.
506 FRAMESIZE is the distance from the frame pointer to the
507 initial stack pointer. */
510 /* The register used to hold the frame pointer for this frame. */
513 /* Saved register offsets. */
514 struct trad_frame_saved_reg
*saved_regs
;
517 /* Do prologue analysis, returning the PC of the first instruction
518 after the function prologue. */
521 csky_analyze_prologue (struct gdbarch
*gdbarch
,
525 struct frame_info
*this_frame
,
526 struct csky_unwind_cache
*this_cache
,
530 unsigned int insn
, rn
;
533 int register_offsets
[CSKY_NUM_GREGS_SAVED_GREGS
];
535 /* For adjusting fp. */
539 /* REGISTER_OFFSETS will contain offsets from the top of the frame
540 (NOT the frame pointer) for the various saved registers, or -1
541 if the register is not saved. */
542 for (rn
= 0; rn
< CSKY_NUM_GREGS_SAVED_GREGS
; rn
++)
543 register_offsets
[rn
] = -1;
545 /* Analyze the prologue. Things we determine from analyzing the
546 prologue include the size of the frame and which registers are
547 saved (and where). */
550 fprintf_unfiltered (gdb_stdlog
,
551 "csky: Scanning prologue: start_pc = 0x%x,"
552 "limit_pc = 0x%x\n", (unsigned int) start_pc
,
553 (unsigned int) limit_pc
);
556 /* Default to 16 bit instruction. */
559 for (addr
= start_pc
; addr
< limit_pc
; addr
+= insn_len
)
562 insn_len
= csky_get_insn (gdbarch
, addr
, &insn
);
564 /* Check if 32 bit. */
567 /* subi32 sp,sp oimm12. */
568 if (CSKY_32_IS_SUBI0 (insn
))
571 int offset
= CSKY_32_SUBI_IMM (insn
);
574 fprintf_unfiltered (gdb_stdlog
,
575 "csky: got subi sp,%d; continuing\n",
581 /* stm32 ry-rz,(sp). */
582 else if (CSKY_32_IS_STMx0 (insn
))
584 /* Spill register(s). */
589 /* BIG WARNING! The CKCore ABI does not restrict functions
590 to taking only one stack allocation. Therefore, when
591 we save a register, we record the offset of where it was
592 saved relative to the current stacksize. This will
593 then give an offset from the SP upon entry to our
594 function. Remember, stacksize is NOT constant until
595 we're done scanning the prologue. */
596 start_register
= CSKY_32_STM_VAL_REGNUM (insn
);
597 reg_count
= CSKY_32_STM_SIZE (insn
);
600 fprintf_unfiltered (gdb_stdlog
,
601 "csky: got stm r%d-r%d,(sp)\n",
603 start_register
+ reg_count
);
606 for (rn
= start_register
, offset
= 0;
607 rn
<= start_register
+ reg_count
;
610 register_offsets
[rn
] = stacksize
- offset
;
613 fprintf_unfiltered (gdb_stdlog
,
614 "csky: r%d saved at 0x%x"
616 rn
, register_offsets
[rn
],
621 fprintf_unfiltered (gdb_stdlog
, "csky: continuing\n");
624 /* stw ry,(sp,disp). */
625 else if (CSKY_32_IS_STWx0 (insn
))
627 /* Spill register: see note for IS_STM above. */
630 rn
= CSKY_32_ST_VAL_REGNUM (insn
);
631 disp
= CSKY_32_ST_OFFSET (insn
);
632 register_offsets
[rn
] = stacksize
- disp
;
634 print_savedreg_msg (rn
, register_offsets
, true);
637 else if (CSKY_32_IS_MOV_FP_SP (insn
))
639 /* SP is saved to FP reg, means code afer prologue may
642 adjust_fp
= stacksize
;
645 else if (CSKY_32_IS_MFCR_EPSR (insn
))
649 int mfcr_regnum
= insn
& 0x1f;
650 insn_len
= csky_get_insn (gdbarch
, addr
, &insn2
);
653 int stw_regnum
= (insn2
>> 5) & 0x7;
654 if (CSKY_16_IS_STWx0 (insn2
) && (mfcr_regnum
== stw_regnum
))
658 /* CSKY_EPSR_REGNUM. */
660 offset
= CSKY_16_STWx0_OFFSET (insn2
);
661 register_offsets
[rn
] = stacksize
- offset
;
663 print_savedreg_msg (rn
, register_offsets
, true);
671 int stw_regnum
= (insn2
>> 21) & 0x1f;
672 if (CSKY_32_IS_STWx0 (insn2
) && (mfcr_regnum
== stw_regnum
))
676 /* CSKY_EPSR_REGNUM. */
678 offset
= CSKY_32_ST_OFFSET (insn2
);
679 register_offsets
[rn
] = framesize
- offset
;
681 print_savedreg_msg (rn
, register_offsets
, true);
687 else if (CSKY_32_IS_MFCR_FPSR (insn
))
691 int mfcr_regnum
= insn
& 0x1f;
692 insn_len
= csky_get_insn (gdbarch
, addr
, &insn2
);
695 int stw_regnum
= (insn2
>> 5) & 0x7;
696 if (CSKY_16_IS_STWx0 (insn2
) && (mfcr_regnum
701 /* CSKY_FPSR_REGNUM. */
702 rn
= CSKY_NUM_GREGS
+ 1;
703 offset
= CSKY_16_STWx0_OFFSET (insn2
);
704 register_offsets
[rn
] = stacksize
- offset
;
706 print_savedreg_msg (rn
, register_offsets
, true);
714 int stw_regnum
= (insn2
>> 21) & 0x1f;
715 if (CSKY_32_IS_STWx0 (insn2
) && (mfcr_regnum
== stw_regnum
))
719 /* CSKY_FPSR_REGNUM. */
720 rn
= CSKY_NUM_GREGS
+ 1;
721 offset
= CSKY_32_ST_OFFSET (insn2
);
722 register_offsets
[rn
] = framesize
- offset
;
724 print_savedreg_msg (rn
, register_offsets
, true);
730 else if (CSKY_32_IS_MFCR_EPC (insn
))
734 int mfcr_regnum
= insn
& 0x1f;
735 insn_len
= csky_get_insn (gdbarch
, addr
, &insn2
);
738 int stw_regnum
= (insn2
>> 5) & 0x7;
739 if (CSKY_16_IS_STWx0 (insn2
) && (mfcr_regnum
== stw_regnum
))
743 /* CSKY_EPC_REGNUM. */
744 rn
= CSKY_NUM_GREGS
+ 2;
745 offset
= CSKY_16_STWx0_OFFSET (insn2
);
746 register_offsets
[rn
] = stacksize
- offset
;
748 print_savedreg_msg (rn
, register_offsets
, true);
756 int stw_regnum
= (insn2
>> 21) & 0x1f;
757 if (CSKY_32_IS_STWx0 (insn2
) && (mfcr_regnum
== stw_regnum
))
761 /* CSKY_EPC_REGNUM. */
762 rn
= CSKY_NUM_GREGS
+ 2;
763 offset
= CSKY_32_ST_OFFSET (insn2
);
764 register_offsets
[rn
] = framesize
- offset
;
766 print_savedreg_msg (rn
, register_offsets
, true);
772 else if (CSKY_32_IS_MFCR_FPC (insn
))
776 int mfcr_regnum
= insn
& 0x1f;
777 insn_len
= csky_get_insn (gdbarch
, addr
, &insn2
);
780 int stw_regnum
= (insn2
>> 5) & 0x7;
781 if (CSKY_16_IS_STWx0 (insn2
) && (mfcr_regnum
== stw_regnum
))
785 /* CSKY_FPC_REGNUM. */
786 rn
= CSKY_NUM_GREGS
+ 3;
787 offset
= CSKY_16_STWx0_OFFSET (insn2
);
788 register_offsets
[rn
] = stacksize
- offset
;
790 print_savedreg_msg (rn
, register_offsets
, true);
798 int stw_regnum
= (insn2
>> 21) & 0x1f;
799 if (CSKY_32_IS_STWx0 (insn2
) && (mfcr_regnum
== stw_regnum
))
803 /* CSKY_FPC_REGNUM. */
804 rn
= CSKY_NUM_GREGS
+ 3;
805 offset
= CSKY_32_ST_OFFSET (insn2
);
806 register_offsets
[rn
] = framesize
- offset
;
808 print_savedreg_msg (rn
, register_offsets
, true);
814 else if (CSKY_32_IS_PUSH (insn
))
816 /* Push for 32_bit. */
818 if (CSKY_32_IS_PUSH_R29 (insn
))
821 register_offsets
[29] = stacksize
;
823 print_savedreg_msg (29, register_offsets
, false);
826 if (CSKY_32_PUSH_LIST2 (insn
))
828 int num
= CSKY_32_PUSH_LIST2 (insn
);
830 stacksize
+= num
* 4;
834 fprintf_unfiltered (gdb_stdlog
,
835 "csky: push regs_array: r16-r%d\n",
838 for (rn
= 16; rn
<= 16 + num
- 1; rn
++)
840 register_offsets
[rn
] = stacksize
- tmp
;
843 fprintf_unfiltered (gdb_stdlog
,
844 "csky: r%d saved at 0x%x"
845 " (offset %d)\n", rn
,
846 register_offsets
[rn
], tmp
);
851 if (CSKY_32_IS_PUSH_R15 (insn
))
854 register_offsets
[15] = stacksize
;
856 print_savedreg_msg (15, register_offsets
, false);
859 if (CSKY_32_PUSH_LIST1 (insn
))
861 int num
= CSKY_32_PUSH_LIST1 (insn
);
863 stacksize
+= num
* 4;
867 fprintf_unfiltered (gdb_stdlog
,
868 "csky: push regs_array: r4-r%d\n",
871 for (rn
= 4; rn
<= 4 + num
- 1; rn
++)
873 register_offsets
[rn
] = stacksize
- tmp
;
876 fprintf_unfiltered (gdb_stdlog
,
877 "csky: r%d saved at 0x%x"
878 " (offset %d)\n", rn
,
879 register_offsets
[rn
], tmp
);
885 framesize
= stacksize
;
887 fprintf_unfiltered (gdb_stdlog
, "csky: continuing\n");
890 else if (CSKY_32_IS_LRW4 (insn
) || CSKY_32_IS_MOVI4 (insn
)
891 || CSKY_32_IS_MOVIH4 (insn
) || CSKY_32_IS_BMASKI4 (insn
))
899 fprintf_unfiltered (gdb_stdlog
,
900 "csky: looking at large frame\n");
902 if (CSKY_32_IS_LRW4 (insn
))
904 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
905 int literal_addr
= (addr
+ ((insn
& 0xffff) << 2))
907 adjust
= read_memory_unsigned_integer (literal_addr
, 4,
910 else if (CSKY_32_IS_MOVI4 (insn
))
911 adjust
= (insn
& 0xffff);
912 else if (CSKY_32_IS_MOVIH4 (insn
))
913 adjust
= (insn
& 0xffff) << 16;
916 /* CSKY_32_IS_BMASKI4 (insn). */
917 adjust
= (1 << (((insn
& 0x3e00000) >> 21) + 1)) - 1;
922 fprintf_unfiltered (gdb_stdlog
,
923 "csky: base stacksize=0x%x\n", adjust
);
925 /* May have zero or more insns which modify r4. */
926 fprintf_unfiltered (gdb_stdlog
,
927 "csky: looking for r4 adjusters...\n");
931 insn_len
= csky_get_insn (gdbarch
, addr
+ offset
, &insn2
);
932 while (CSKY_IS_R4_ADJUSTER (insn2
))
934 if (CSKY_32_IS_ADDI4 (insn2
))
936 int imm
= (insn2
& 0xfff) + 1;
940 fprintf_unfiltered (gdb_stdlog
,
941 "csky: addi r4,%d\n", imm
);
944 else if (CSKY_32_IS_SUBI4 (insn2
))
946 int imm
= (insn2
& 0xfff) + 1;
950 fprintf_unfiltered (gdb_stdlog
,
951 "csky: subi r4,%d\n", imm
);
954 else if (CSKY_32_IS_NOR4 (insn2
))
959 fprintf_unfiltered (gdb_stdlog
,
960 "csky: nor r4,r4,r4\n");
963 else if (CSKY_32_IS_ROTLI4 (insn2
))
965 int imm
= ((insn2
>> 21) & 0x1f);
966 int temp
= adjust
>> (32 - imm
);
971 fprintf_unfiltered (gdb_stdlog
,
972 "csky: rotli r4,r4,%d\n", imm
);
975 else if (CSKY_32_IS_LISI4 (insn2
))
977 int imm
= ((insn2
>> 21) & 0x1f);
981 fprintf_unfiltered (gdb_stdlog
,
982 "csky: lsli r4,r4,%d\n", imm
);
985 else if (CSKY_32_IS_BSETI4 (insn2
))
987 int imm
= ((insn2
>> 21) & 0x1f);
988 adjust
|= (1 << imm
);
991 fprintf_unfiltered (gdb_stdlog
,
992 "csky: bseti r4,r4 %d\n", imm
);
995 else if (CSKY_32_IS_BCLRI4 (insn2
))
997 int imm
= ((insn2
>> 21) & 0x1f);
998 adjust
&= ~(1 << imm
);
1001 fprintf_unfiltered (gdb_stdlog
,
1002 "csky: bclri r4,r4 %d\n", imm
);
1005 else if (CSKY_32_IS_IXH4 (insn2
))
1010 fprintf_unfiltered (gdb_stdlog
,
1011 "csky: ixh r4,r4,r4\n");
1014 else if (CSKY_32_IS_IXW4 (insn2
))
1019 fprintf_unfiltered (gdb_stdlog
,
1020 "csky: ixw r4,r4,r4\n");
1023 else if (CSKY_16_IS_ADDI4 (insn2
))
1025 int imm
= (insn2
& 0xff) + 1;
1029 fprintf_unfiltered (gdb_stdlog
,
1030 "csky: addi r4,%d\n", imm
);
1033 else if (CSKY_16_IS_SUBI4 (insn2
))
1035 int imm
= (insn2
& 0xff) + 1;
1039 fprintf_unfiltered (gdb_stdlog
,
1040 "csky: subi r4,%d\n", imm
);
1043 else if (CSKY_16_IS_NOR4 (insn2
))
1048 fprintf_unfiltered (gdb_stdlog
,
1049 "csky: nor r4,r4\n");
1052 else if (CSKY_16_IS_BSETI4 (insn2
))
1054 int imm
= (insn2
& 0x1f);
1055 adjust
|= (1 << imm
);
1058 fprintf_unfiltered (gdb_stdlog
,
1059 "csky: bseti r4, %d\n", imm
);
1062 else if (CSKY_16_IS_BCLRI4 (insn2
))
1064 int imm
= (insn2
& 0x1f);
1065 adjust
&= ~(1 << imm
);
1068 fprintf_unfiltered (gdb_stdlog
,
1069 "csky: bclri r4, %d\n", imm
);
1072 else if (CSKY_16_IS_LSLI4 (insn2
))
1074 int imm
= (insn2
& 0x1f);
1078 fprintf_unfiltered (gdb_stdlog
,
1079 "csky: lsli r4,r4, %d\n", imm
);
1084 insn_len
= csky_get_insn (gdbarch
, addr
+ offset
, &insn2
);
1089 fprintf_unfiltered (gdb_stdlog
, "csky: done looking for"
1093 /* If the next insn adjusts the stack pointer, we keep
1094 everything; if not, we scrap it and we've found the
1095 end of the prologue. */
1096 if (CSKY_IS_SUBU4 (insn2
))
1099 stacksize
+= adjust
;
1102 fprintf_unfiltered (gdb_stdlog
,
1103 "csky: found stack adjustment of"
1104 " 0x%x bytes.\n", adjust
);
1105 fprintf_unfiltered (gdb_stdlog
,
1106 "csky: skipping to new address %s\n",
1107 core_addr_to_string_nz (addr
));
1108 fprintf_unfiltered (gdb_stdlog
,
1109 "csky: continuing\n");
1114 /* None of these instructions are prologue, so don't touch
1118 fprintf_unfiltered (gdb_stdlog
,
1119 "csky: no subu sp,sp,r4; NOT altering"
1127 /* insn_len != 4. */
1129 /* subi.sp sp,disp. */
1130 if (CSKY_16_IS_SUBI0 (insn
))
1132 int offset
= CSKY_16_SUBI_IMM (insn
);
1135 fprintf_unfiltered (gdb_stdlog
,
1136 "csky: got subi r0,%d; continuing\n",
1139 stacksize
+= offset
;
1142 /* stw.16 rz,(sp,disp). */
1143 else if (CSKY_16_IS_STWx0 (insn
))
1145 /* Spill register: see note for IS_STM above. */
1148 rn
= CSKY_16_ST_VAL_REGNUM (insn
);
1149 disp
= CSKY_16_ST_OFFSET (insn
);
1150 register_offsets
[rn
] = stacksize
- disp
;
1152 print_savedreg_msg (rn
, register_offsets
, true);
1155 else if (CSKY_16_IS_MOV_FP_SP (insn
))
1157 /* SP is saved to FP reg, means prologue may modify SP. */
1159 adjust_fp
= stacksize
;
1162 else if (CSKY_16_IS_PUSH (insn
))
1164 /* Push for 16_bit. */
1166 if (CSKY_16_IS_PUSH_R15 (insn
))
1169 register_offsets
[15] = stacksize
;
1171 print_savedreg_msg (15, register_offsets
, false);
1174 if (CSKY_16_PUSH_LIST1 (insn
))
1176 int num
= CSKY_16_PUSH_LIST1 (insn
);
1178 stacksize
+= num
* 4;
1182 fprintf_unfiltered (gdb_stdlog
,
1183 "csky: push regs_array: r4-r%d\n",
1186 for (rn
= 4; rn
<= 4 + num
- 1; rn
++)
1188 register_offsets
[rn
] = stacksize
- tmp
;
1191 fprintf_unfiltered (gdb_stdlog
,
1192 "csky: r%d saved at 0x%x"
1193 " (offset %d)\n", rn
,
1194 register_offsets
[rn
], offset
);
1200 framesize
= stacksize
;
1202 fprintf_unfiltered (gdb_stdlog
, "csky: continuing\n");
1205 else if (CSKY_16_IS_LRW4 (insn
) || CSKY_16_IS_MOVI4 (insn
))
1213 fprintf_unfiltered (gdb_stdlog
,
1214 "csky: looking at large frame\n");
1216 if (CSKY_16_IS_LRW4 (insn
))
1218 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1219 int offset
= ((insn
& 0x300) >> 3) | (insn
& 0x1f);
1220 int literal_addr
= (addr
+ ( offset
<< 2)) & 0xfffffffc;
1221 adjust
= read_memory_unsigned_integer (literal_addr
, 4,
1226 /* CSKY_16_IS_MOVI4 (insn). */
1227 adjust
= (insn
& 0xff);
1232 fprintf_unfiltered (gdb_stdlog
,
1233 "csky: base stacksize=0x%x\n", adjust
);
1236 /* May have zero or more instructions which modify r4. */
1239 fprintf_unfiltered (gdb_stdlog
,
1240 "csky: looking for r4 adjusters...\n");
1243 insn_len
= csky_get_insn (gdbarch
, addr
+ offset
, &insn2
);
1244 while (CSKY_IS_R4_ADJUSTER (insn2
))
1246 if (CSKY_32_IS_ADDI4 (insn2
))
1248 int imm
= (insn2
& 0xfff) + 1;
1252 fprintf_unfiltered (gdb_stdlog
,
1253 "csky: addi r4,%d\n", imm
);
1256 else if (CSKY_32_IS_SUBI4 (insn2
))
1258 int imm
= (insn2
& 0xfff) + 1;
1262 fprintf_unfiltered (gdb_stdlog
,
1263 "csky: subi r4,%d\n", imm
);
1266 else if (CSKY_32_IS_NOR4 (insn2
))
1271 fprintf_unfiltered (gdb_stdlog
,
1272 "csky: nor r4,r4,r4\n");
1275 else if (CSKY_32_IS_ROTLI4 (insn2
))
1277 int imm
= ((insn2
>> 21) & 0x1f);
1278 int temp
= adjust
>> (32 - imm
);
1283 fprintf_unfiltered (gdb_stdlog
,
1284 "csky: rotli r4,r4,%d\n", imm
);
1287 else if (CSKY_32_IS_LISI4 (insn2
))
1289 int imm
= ((insn2
>> 21) & 0x1f);
1293 fprintf_unfiltered (gdb_stdlog
,
1294 "csky: lsli r4,r4,%d\n", imm
);
1297 else if (CSKY_32_IS_BSETI4 (insn2
))
1299 int imm
= ((insn2
>> 21) & 0x1f);
1300 adjust
|= (1 << imm
);
1303 fprintf_unfiltered (gdb_stdlog
,
1304 "csky: bseti r4,r4 %d\n", imm
);
1307 else if (CSKY_32_IS_BCLRI4 (insn2
))
1309 int imm
= ((insn2
>> 21) & 0x1f);
1310 adjust
&= ~(1 << imm
);
1313 fprintf_unfiltered (gdb_stdlog
,
1314 "csky: bclri r4,r4 %d\n", imm
);
1317 else if (CSKY_32_IS_IXH4 (insn2
))
1322 fprintf_unfiltered (gdb_stdlog
,
1323 "csky: ixh r4,r4,r4\n");
1326 else if (CSKY_32_IS_IXW4 (insn2
))
1331 fprintf_unfiltered (gdb_stdlog
,
1332 "csky: ixw r4,r4,r4\n");
1335 else if (CSKY_16_IS_ADDI4 (insn2
))
1337 int imm
= (insn2
& 0xff) + 1;
1341 fprintf_unfiltered (gdb_stdlog
,
1342 "csky: addi r4,%d\n", imm
);
1345 else if (CSKY_16_IS_SUBI4 (insn2
))
1347 int imm
= (insn2
& 0xff) + 1;
1351 fprintf_unfiltered (gdb_stdlog
,
1352 "csky: subi r4,%d\n", imm
);
1355 else if (CSKY_16_IS_NOR4 (insn2
))
1360 fprintf_unfiltered (gdb_stdlog
,
1361 "csky: nor r4,r4\n");
1364 else if (CSKY_16_IS_BSETI4 (insn2
))
1366 int imm
= (insn2
& 0x1f);
1367 adjust
|= (1 << imm
);
1370 fprintf_unfiltered (gdb_stdlog
,
1371 "csky: bseti r4, %d\n", imm
);
1374 else if (CSKY_16_IS_BCLRI4 (insn2
))
1376 int imm
= (insn2
& 0x1f);
1377 adjust
&= ~(1 << imm
);
1380 fprintf_unfiltered (gdb_stdlog
,
1381 "csky: bclri r4, %d\n", imm
);
1384 else if (CSKY_16_IS_LSLI4 (insn2
))
1386 int imm
= (insn2
& 0x1f);
1390 fprintf_unfiltered (gdb_stdlog
,
1391 "csky: lsli r4,r4, %d\n", imm
);
1396 insn_len
= csky_get_insn (gdbarch
, addr
+ offset
, &insn2
);
1401 fprintf_unfiltered (gdb_stdlog
, "csky: "
1402 "done looking for r4 adjusters\n");
1405 /* If the next instruction adjusts the stack pointer, we keep
1406 everything; if not, we scrap it and we've found the end
1408 if (CSKY_IS_SUBU4 (insn2
))
1411 stacksize
+= adjust
;
1414 fprintf_unfiltered (gdb_stdlog
, "csky: "
1415 "found stack adjustment of 0x%x"
1416 " bytes.\n", adjust
);
1417 fprintf_unfiltered (gdb_stdlog
, "csky: "
1418 "skipping to new address %s\n",
1419 core_addr_to_string_nz (addr
));
1420 fprintf_unfiltered (gdb_stdlog
, "csky: continuing\n");
1425 /* None of these instructions are prologue, so don't touch
1429 fprintf_unfiltered (gdb_stdlog
, "csky: no subu sp,r4; "
1430 "NOT altering stacksize.\n");
1436 /* This is not a prologue instruction, so stop here. */
1439 fprintf_unfiltered (gdb_stdlog
, "csky: insn is not a prologue"
1440 " insn -- ending scan\n");
1447 CORE_ADDR unwound_fp
;
1448 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1449 this_cache
->framesize
= framesize
;
1453 this_cache
->framereg
= CSKY_FP_REGNUM
;
1454 unwound_fp
= get_frame_register_unsigned (this_frame
,
1455 this_cache
->framereg
);
1456 this_cache
->prev_sp
= unwound_fp
+ adjust_fp
;
1460 this_cache
->framereg
= CSKY_SP_REGNUM
;
1461 unwound_fp
= get_frame_register_unsigned (this_frame
,
1462 this_cache
->framereg
);
1463 this_cache
->prev_sp
= unwound_fp
+ stacksize
;
1466 /* Note where saved registers are stored. The offsets in
1467 REGISTER_OFFSETS are computed relative to the top of the frame. */
1468 for (rn
= 0; rn
< CSKY_NUM_GREGS
; rn
++)
1470 if (register_offsets
[rn
] >= 0)
1472 this_cache
->saved_regs
[rn
].addr
1473 = this_cache
->prev_sp
- register_offsets
[rn
];
1476 CORE_ADDR rn_value
= read_memory_unsigned_integer (
1477 this_cache
->saved_regs
[rn
].addr
, 4, byte_order
);
1478 fprintf_unfiltered (gdb_stdlog
, "Saved register %s "
1479 "stored at 0x%08lx, value=0x%08lx\n",
1480 csky_register_names
[rn
],
1482 this_cache
->saved_regs
[rn
].addr
,
1483 (unsigned long) rn_value
);
1487 if (lr_type
== LR_TYPE_EPC
)
1490 this_cache
->saved_regs
[CSKY_PC_REGNUM
]
1491 = this_cache
->saved_regs
[CSKY_EPC_REGNUM
];
1493 else if (lr_type
== LR_TYPE_FPC
)
1496 this_cache
->saved_regs
[CSKY_PC_REGNUM
]
1497 = this_cache
->saved_regs
[CSKY_FPC_REGNUM
];
1501 this_cache
->saved_regs
[CSKY_PC_REGNUM
]
1502 = this_cache
->saved_regs
[CSKY_LR_REGNUM
];
1509 /* Detect whether PC is at a point where the stack frame has been
1513 csky_stack_frame_destroyed_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1517 CORE_ADDR func_start
, func_end
;
1519 if (!find_pc_partial_function (pc
, NULL
, &func_start
, &func_end
))
1522 bool fp_saved
= false;
1524 for (addr
= func_start
; addr
< func_end
; addr
+= insn_len
)
1526 /* Get next insn. */
1527 insn_len
= csky_get_insn (gdbarch
, addr
, &insn
);
1531 /* Is sp is saved to fp. */
1532 if (CSKY_16_IS_MOV_FP_SP (insn
))
1534 /* If sp was saved to fp and now being restored from
1535 fp then it indicates the start of epilog. */
1536 else if (fp_saved
&& CSKY_16_IS_MOV_SP_FP (insn
))
1543 /* Implement the skip_prologue gdbarch hook. */
1546 csky_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1548 CORE_ADDR func_addr
, func_end
;
1549 struct symtab_and_line sal
;
1550 const int default_search_limit
= 128;
1552 /* See if we can find the end of the prologue using the symbol table. */
1553 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1555 CORE_ADDR post_prologue_pc
1556 = skip_prologue_using_sal (gdbarch
, func_addr
);
1558 if (post_prologue_pc
!= 0)
1559 return std::max (pc
, post_prologue_pc
);
1562 func_end
= pc
+ default_search_limit
;
1564 /* Find the end of prologue. Default lr_type. */
1565 return csky_analyze_prologue (gdbarch
, pc
, func_end
, func_end
,
1566 NULL
, NULL
, LR_TYPE_R15
);
1569 /* Implement the breakpoint_kind_from_pc gdbarch method. */
1572 csky_breakpoint_kind_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
)
1574 if (csky_pc_is_csky16 (gdbarch
, *pcptr
))
1575 return CSKY_INSN_SIZE16
;
1577 return CSKY_INSN_SIZE32
;
1580 /* Implement the sw_breakpoint_from_kind gdbarch method. */
1582 static const gdb_byte
*
1583 csky_sw_breakpoint_from_kind (struct gdbarch
*gdbarch
, int kind
, int *size
)
1586 if (kind
== CSKY_INSN_SIZE16
)
1588 static gdb_byte csky_16_breakpoint
[] = { 0, 0 };
1589 return csky_16_breakpoint
;
1593 static gdb_byte csky_32_breakpoint
[] = { 0, 0, 0, 0 };
1594 return csky_32_breakpoint
;
1598 /* Implement the memory_insert_breakpoint gdbarch method. */
1601 csky_memory_insert_breakpoint (struct gdbarch
*gdbarch
,
1602 struct bp_target_info
*bp_tgt
)
1605 const unsigned char *bp
;
1606 gdb_byte bp_write_record1
[] = { 0, 0, 0, 0 };
1607 gdb_byte bp_write_record2
[] = { 0, 0, 0, 0 };
1608 gdb_byte bp_record
[] = { 0, 0, 0, 0 };
1610 /* Sanity-check bp_address. */
1611 if (bp_tgt
->reqstd_address
% 2)
1612 warning (_("Invalid breakpoint address 0x%x is an odd number."),
1613 (unsigned int) bp_tgt
->reqstd_address
);
1614 scoped_restore restore_memory
1615 = make_scoped_restore_show_memory_breakpoints (1);
1617 /* Determine appropriate breakpoint_kind for this address. */
1618 bp_tgt
->kind
= csky_breakpoint_kind_from_pc (gdbarch
,
1619 &bp_tgt
->reqstd_address
);
1621 /* Save the memory contents. */
1622 bp_tgt
->shadow_len
= bp_tgt
->kind
;
1624 /* Fill bp_tgt->placed_address. */
1625 bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
1627 if (bp_tgt
->kind
== CSKY_INSN_SIZE16
)
1629 if ((bp_tgt
->reqstd_address
% 4) == 0)
1631 /* Read two bytes. */
1632 val
= target_read_memory (bp_tgt
->reqstd_address
,
1633 bp_tgt
->shadow_contents
, 2);
1637 /* Read two bytes. */
1638 val
= target_read_memory (bp_tgt
->reqstd_address
+ 2,
1643 /* Write the breakpoint. */
1644 bp_write_record1
[2] = bp_record
[0];
1645 bp_write_record1
[3] = bp_record
[1];
1646 bp
= bp_write_record1
;
1647 val
= target_write_raw_memory (bp_tgt
->reqstd_address
, bp
,
1652 val
= target_read_memory (bp_tgt
->reqstd_address
,
1653 bp_tgt
->shadow_contents
, 2);
1657 val
= target_read_memory (bp_tgt
->reqstd_address
- 2,
1662 /* Write the breakpoint. */
1663 bp_write_record1
[0] = bp_record
[0];
1664 bp_write_record1
[1] = bp_record
[1];
1665 bp
= bp_write_record1
;
1666 val
= target_write_raw_memory (bp_tgt
->reqstd_address
- 2,
1667 bp
, CSKY_WR_BKPT_MODE
);
1672 if (bp_tgt
->placed_address
% 4 == 0)
1674 val
= target_read_memory (bp_tgt
->reqstd_address
,
1675 bp_tgt
->shadow_contents
,
1680 /* Write the breakpoint. */
1681 bp
= bp_write_record1
;
1682 val
= target_write_raw_memory (bp_tgt
->reqstd_address
,
1683 bp
, CSKY_WR_BKPT_MODE
);
1687 val
= target_read_memory (bp_tgt
->reqstd_address
,
1688 bp_tgt
->shadow_contents
,
1693 val
= target_read_memory (bp_tgt
->reqstd_address
- 2,
1698 val
= target_read_memory (bp_tgt
->reqstd_address
+ 4,
1703 bp_write_record1
[0] = bp_record
[0];
1704 bp_write_record1
[1] = bp_record
[1];
1705 bp_write_record2
[2] = bp_record
[2];
1706 bp_write_record2
[3] = bp_record
[3];
1708 /* Write the breakpoint. */
1709 bp
= bp_write_record1
;
1710 val
= target_write_raw_memory (bp_tgt
->reqstd_address
- 2, bp
,
1715 /* Write the breakpoint. */
1716 bp
= bp_write_record2
;
1717 val
= target_write_raw_memory (bp_tgt
->reqstd_address
+ 2, bp
,
1724 /* Restore the breakpoint shadow_contents to the target. */
1727 csky_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
1728 struct bp_target_info
*bp_tgt
)
1731 gdb_byte bp_record
[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
1732 /* Different for shadow_len 2 or 4. */
1733 if (bp_tgt
->shadow_len
== 2)
1735 /* Do word-sized writes on word-aligned boundaries and read
1736 padding bytes as necessary. */
1737 if (bp_tgt
->reqstd_address
% 4 == 0)
1739 val
= target_read_memory (bp_tgt
->reqstd_address
+ 2,
1743 bp_record
[0] = bp_tgt
->shadow_contents
[0];
1744 bp_record
[1] = bp_tgt
->shadow_contents
[1];
1745 return target_write_raw_memory (bp_tgt
->reqstd_address
,
1746 bp_record
, CSKY_WR_BKPT_MODE
);
1750 val
= target_read_memory (bp_tgt
->reqstd_address
- 2,
1754 bp_record
[2] = bp_tgt
->shadow_contents
[0];
1755 bp_record
[3] = bp_tgt
->shadow_contents
[1];
1756 return target_write_raw_memory (bp_tgt
->reqstd_address
- 2,
1757 bp_record
, CSKY_WR_BKPT_MODE
);
1762 /* Do word-sized writes on word-aligned boundaries and read
1763 padding bytes as necessary. */
1764 if (bp_tgt
->placed_address
% 4 == 0)
1766 return target_write_raw_memory (bp_tgt
->reqstd_address
,
1767 bp_tgt
->shadow_contents
,
1772 val
= target_read_memory (bp_tgt
->reqstd_address
- 2,
1776 val
= target_read_memory (bp_tgt
->reqstd_address
+ 4,
1781 bp_record
[2] = bp_tgt
->shadow_contents
[0];
1782 bp_record
[3] = bp_tgt
->shadow_contents
[1];
1783 bp_record
[4] = bp_tgt
->shadow_contents
[2];
1784 bp_record
[5] = bp_tgt
->shadow_contents
[3];
1786 return target_write_raw_memory (bp_tgt
->reqstd_address
- 2,
1788 CSKY_WR_BKPT_MODE
* 2);
1793 /* Determine link register type. */
1796 csky_analyze_lr_type (struct gdbarch
*gdbarch
,
1797 CORE_ADDR start_pc
, CORE_ADDR end_pc
)
1800 unsigned int insn
, insn_len
;
1803 for (addr
= start_pc
; addr
< end_pc
; addr
+= insn_len
)
1805 insn_len
= csky_get_insn (gdbarch
, addr
, &insn
);
1808 if (CSKY_32_IS_MFCR_EPSR (insn
) || CSKY_32_IS_MFCR_EPC (insn
)
1809 || CSKY_32_IS_RTE (insn
))
1812 else if (CSKY_32_IS_MFCR_FPSR (insn
) || CSKY_32_IS_MFCR_FPC (insn
)
1813 || CSKY_32_IS_RFI (insn
))
1815 else if (CSKY_32_IS_JMP (insn
) || CSKY_32_IS_BR (insn
)
1816 || CSKY_32_IS_JMPIX (insn
) || CSKY_32_IS_JMPI (insn
))
1820 /* 16 bit instruction. */
1821 if (CSKY_16_IS_JMP (insn
) || CSKY_16_IS_BR (insn
)
1822 || CSKY_16_IS_JMPIX (insn
))
1829 /* Heuristic unwinder. */
1831 static struct csky_unwind_cache
*
1832 csky_frame_unwind_cache (struct frame_info
*this_frame
)
1834 CORE_ADDR prologue_start
, prologue_end
, func_end
, prev_pc
, block_addr
;
1835 struct csky_unwind_cache
*cache
;
1836 const struct block
*bl
;
1837 unsigned long func_size
= 0;
1838 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1839 unsigned int sp_regnum
= CSKY_SP_REGNUM
;
1841 /* Default lr type is r15. */
1842 lr_type_t lr_type
= LR_TYPE_R15
;
1844 cache
= FRAME_OBSTACK_ZALLOC (struct csky_unwind_cache
);
1845 cache
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
1847 /* Assume there is no frame until proven otherwise. */
1848 cache
->framereg
= sp_regnum
;
1850 cache
->framesize
= 0;
1852 prev_pc
= get_frame_pc (this_frame
);
1853 block_addr
= get_frame_address_in_block (this_frame
);
1854 if (find_pc_partial_function (block_addr
, NULL
, &prologue_start
,
1856 /* We couldn't find a function containing block_addr, so bail out
1857 and hope for the best. */
1860 /* Get the (function) symbol matching prologue_start. */
1861 bl
= block_for_pc (prologue_start
);
1863 func_size
= bl
->endaddr
- bl
->startaddr
;
1866 struct bound_minimal_symbol msymbol
1867 = lookup_minimal_symbol_by_pc (prologue_start
);
1868 if (msymbol
.minsym
!= NULL
)
1869 func_size
= MSYMBOL_SIZE (msymbol
.minsym
);
1872 /* If FUNC_SIZE is 0 we may have a special-case use of lr
1873 e.g. exception or interrupt. */
1875 lr_type
= csky_analyze_lr_type (gdbarch
, prologue_start
, func_end
);
1877 prologue_end
= std::min (func_end
, prev_pc
);
1879 /* Analyze the function prologue. */
1880 csky_analyze_prologue (gdbarch
, prologue_start
, prologue_end
,
1881 func_end
, this_frame
, cache
, lr_type
);
1883 /* gdbarch_sp_regnum contains the value and not the address. */
1884 trad_frame_set_value (cache
->saved_regs
, sp_regnum
, cache
->prev_sp
);
1888 /* Implement the unwind_pc gdbarch method. */
1891 csky_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1893 return frame_unwind_register_unsigned (next_frame
, CSKY_PC_REGNUM
);
1896 /* Implement the this_id function for the normal unwinder. */
1899 csky_frame_this_id (struct frame_info
*this_frame
,
1900 void **this_prologue_cache
, struct frame_id
*this_id
)
1902 struct csky_unwind_cache
*cache
;
1905 if (*this_prologue_cache
== NULL
)
1906 *this_prologue_cache
= csky_frame_unwind_cache (this_frame
);
1907 cache
= (struct csky_unwind_cache
*) *this_prologue_cache
;
1909 /* This marks the outermost frame. */
1910 if (cache
->prev_sp
== 0)
1913 id
= frame_id_build (cache
->prev_sp
, get_frame_func (this_frame
));
1917 /* Implement the prev_register function for the normal unwinder. */
1919 static struct value
*
1920 csky_frame_prev_register (struct frame_info
*this_frame
,
1921 void **this_prologue_cache
, int regnum
)
1923 struct csky_unwind_cache
*cache
;
1925 if (*this_prologue_cache
== NULL
)
1926 *this_prologue_cache
= csky_frame_unwind_cache (this_frame
);
1927 cache
= (struct csky_unwind_cache
*) *this_prologue_cache
;
1929 return trad_frame_get_prev_register (this_frame
, cache
->saved_regs
,
1933 /* Data structures for the normal prologue-analysis-based
1936 static const struct frame_unwind csky_unwind_cache
= {
1938 default_frame_unwind_stop_reason
,
1940 csky_frame_prev_register
,
1942 default_frame_sniffer
,
1950 csky_stub_unwind_sniffer (const struct frame_unwind
*self
,
1951 struct frame_info
*this_frame
,
1952 void **this_prologue_cache
)
1954 CORE_ADDR addr_in_block
;
1956 addr_in_block
= get_frame_address_in_block (this_frame
);
1958 if (find_pc_partial_function (addr_in_block
, NULL
, NULL
, NULL
) == 0
1959 || in_plt_section (addr_in_block
))
1965 static struct csky_unwind_cache
*
1966 csky_make_stub_cache (struct frame_info
*this_frame
)
1968 struct csky_unwind_cache
*cache
;
1970 cache
= FRAME_OBSTACK_ZALLOC (struct csky_unwind_cache
);
1971 cache
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
1972 cache
->prev_sp
= get_frame_register_unsigned (this_frame
, CSKY_SP_REGNUM
);
1978 csky_stub_this_id (struct frame_info
*this_frame
,
1980 struct frame_id
*this_id
)
1982 struct csky_unwind_cache
*cache
;
1984 if (*this_cache
== NULL
)
1985 *this_cache
= csky_make_stub_cache (this_frame
);
1986 cache
= (struct csky_unwind_cache
*) *this_cache
;
1988 /* Our frame ID for a stub frame is the current SP and LR. */
1989 *this_id
= frame_id_build (cache
->prev_sp
, get_frame_pc (this_frame
));
1992 static struct value
*
1993 csky_stub_prev_register (struct frame_info
*this_frame
,
1997 struct csky_unwind_cache
*cache
;
1999 if (*this_cache
== NULL
)
2000 *this_cache
= csky_make_stub_cache (this_frame
);
2001 cache
= (struct csky_unwind_cache
*) *this_cache
;
2003 /* If we are asked to unwind the PC, then return the LR. */
2004 if (prev_regnum
== CSKY_PC_REGNUM
)
2008 lr
= frame_unwind_register_unsigned (this_frame
, CSKY_LR_REGNUM
);
2009 return frame_unwind_got_constant (this_frame
, prev_regnum
, lr
);
2012 if (prev_regnum
== CSKY_SP_REGNUM
)
2013 return frame_unwind_got_constant (this_frame
, prev_regnum
, cache
->prev_sp
);
2015 return trad_frame_get_prev_register (this_frame
, cache
->saved_regs
,
2019 struct frame_unwind csky_stub_unwind
= {
2021 default_frame_unwind_stop_reason
,
2023 csky_stub_prev_register
,
2025 csky_stub_unwind_sniffer
2028 /* Implement the this_base, this_locals, and this_args hooks
2029 for the normal unwinder. */
2032 csky_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
2034 struct csky_unwind_cache
*cache
;
2036 if (*this_cache
== NULL
)
2037 *this_cache
= csky_frame_unwind_cache (this_frame
);
2038 cache
= (struct csky_unwind_cache
*) *this_cache
;
2040 return cache
->prev_sp
- cache
->framesize
;
2043 static const struct frame_base csky_frame_base
= {
2045 csky_frame_base_address
,
2046 csky_frame_base_address
,
2047 csky_frame_base_address
2050 /* Implement the dummy_id gdbarch method. The frame ID's base
2051 needs to match the TOS value saved by save_dummy_frame_tos,
2052 and the PC should match the dummy frame's breakpoint. */
2054 static struct frame_id
2055 csky_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
2057 unsigned int sp_regnum
= CSKY_SP_REGNUM
;
2059 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, sp_regnum
);
2060 return frame_id_build (sp
, get_frame_pc (this_frame
));
2063 /* Initialize register access method. */
2066 csky_dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
2067 struct dwarf2_frame_state_reg
*reg
,
2068 struct frame_info
*this_frame
)
2070 if (regnum
== gdbarch_pc_regnum (gdbarch
))
2071 reg
->how
= DWARF2_FRAME_REG_RA
;
2072 else if (regnum
== gdbarch_sp_regnum (gdbarch
))
2073 reg
->how
= DWARF2_FRAME_REG_CFA
;
2076 /* Create csky register groups. */
2079 csky_init_reggroup ()
2081 cr_reggroup
= reggroup_new ("cr", USER_REGGROUP
);
2082 fr_reggroup
= reggroup_new ("fr", USER_REGGROUP
);
2083 vr_reggroup
= reggroup_new ("vr", USER_REGGROUP
);
2084 mmu_reggroup
= reggroup_new ("mmu", USER_REGGROUP
);
2085 prof_reggroup
= reggroup_new ("profiling", USER_REGGROUP
);
2088 /* Add register groups into reggroup list. */
2091 csky_add_reggroups (struct gdbarch
*gdbarch
)
2093 reggroup_add (gdbarch
, all_reggroup
);
2094 reggroup_add (gdbarch
, general_reggroup
);
2095 reggroup_add (gdbarch
, cr_reggroup
);
2096 reggroup_add (gdbarch
, fr_reggroup
);
2097 reggroup_add (gdbarch
, vr_reggroup
);
2098 reggroup_add (gdbarch
, mmu_reggroup
);
2099 reggroup_add (gdbarch
, prof_reggroup
);
2102 /* Return the groups that a CSKY register can be categorised into. */
2105 csky_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
2106 struct reggroup
*reggroup
)
2110 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2111 || gdbarch_register_name (gdbarch
, regnum
)[0] == '\0')
2114 if (reggroup
== all_reggroup
)
2117 raw_p
= regnum
< gdbarch_num_regs (gdbarch
);
2118 if (reggroup
== save_reggroup
|| reggroup
== restore_reggroup
)
2121 if (((regnum
>= CSKY_R0_REGNUM
) && (regnum
<= CSKY_R0_REGNUM
+ 31))
2122 && (reggroup
== general_reggroup
))
2125 if (((regnum
== CSKY_PC_REGNUM
)
2126 || ((regnum
>= CSKY_CR0_REGNUM
)
2127 && (regnum
<= CSKY_CR0_REGNUM
+ 30)))
2128 && (reggroup
== cr_reggroup
))
2131 if ((((regnum
>= CSKY_VR0_REGNUM
) && (regnum
<= CSKY_VR0_REGNUM
+ 15))
2132 || ((regnum
>= CSKY_VCR0_REGNUM
)
2133 && (regnum
<= CSKY_VCR0_REGNUM
+ 2)))
2134 && (reggroup
== vr_reggroup
))
2137 if (((regnum
>= CSKY_MMU_REGNUM
) && (regnum
<= CSKY_MMU_REGNUM
+ 8))
2138 && (reggroup
== mmu_reggroup
))
2141 if (((regnum
>= CSKY_PROFCR_REGNUM
)
2142 && (regnum
<= CSKY_PROFCR_REGNUM
+ 48))
2143 && (reggroup
== prof_reggroup
))
2146 if ((((regnum
>= CSKY_FR0_REGNUM
) && (regnum
<= CSKY_FR0_REGNUM
+ 15))
2147 || ((regnum
>= CSKY_VCR0_REGNUM
) && (regnum
<= CSKY_VCR0_REGNUM
+ 2)))
2148 && (reggroup
== fr_reggroup
))
2154 /* Implement the dwarf2_reg_to_regnum gdbarch method. */
2157 csky_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int dw_reg
)
2159 if (dw_reg
< 0 || dw_reg
>= CSKY_NUM_REGS
)
2164 /* Override interface for command: info register. */
2167 csky_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
2168 struct frame_info
*frame
, int regnum
, int all
)
2170 /* Call default print_registers_info function. */
2171 default_print_registers_info (gdbarch
, file
, frame
, regnum
, all
);
2173 /* For command: info register. */
2174 if (regnum
== -1 && all
== 0)
2176 default_print_registers_info (gdbarch
, file
, frame
,
2178 default_print_registers_info (gdbarch
, file
, frame
,
2179 CSKY_EPC_REGNUM
, 0);
2180 default_print_registers_info (gdbarch
, file
, frame
,
2181 CSKY_CR0_REGNUM
, 0);
2182 default_print_registers_info (gdbarch
, file
, frame
,
2183 CSKY_EPSR_REGNUM
, 0);
2188 /* Initialize the current architecture based on INFO. If possible,
2189 re-use an architecture from ARCHES, which is a list of
2190 architectures already created during this debugging session.
2192 Called at program startup, when reading a core file, and when
2193 reading a binary file. */
2195 static struct gdbarch
*
2196 csky_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2198 struct gdbarch
*gdbarch
;
2199 struct gdbarch_tdep
*tdep
;
2201 /* Find a candidate among the list of pre-declared architectures. */
2202 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
2204 return arches
->gdbarch
;
2206 /* None found, create a new architecture from the information
2208 tdep
= XCNEW (struct gdbarch_tdep
);
2209 gdbarch
= gdbarch_alloc (&info
, tdep
);
2211 /* Target data types. */
2212 set_gdbarch_ptr_bit (gdbarch
, 32);
2213 set_gdbarch_addr_bit (gdbarch
, 32);
2214 set_gdbarch_short_bit (gdbarch
, 16);
2215 set_gdbarch_int_bit (gdbarch
, 32);
2216 set_gdbarch_long_bit (gdbarch
, 32);
2217 set_gdbarch_long_long_bit (gdbarch
, 64);
2218 set_gdbarch_float_bit (gdbarch
, 32);
2219 set_gdbarch_double_bit (gdbarch
, 64);
2220 set_gdbarch_float_format (gdbarch
, floatformats_ieee_single
);
2221 set_gdbarch_double_format (gdbarch
, floatformats_ieee_double
);
2223 /* Information about the target architecture. */
2224 set_gdbarch_return_value (gdbarch
, csky_return_value
);
2225 set_gdbarch_breakpoint_kind_from_pc (gdbarch
, csky_breakpoint_kind_from_pc
);
2226 set_gdbarch_sw_breakpoint_from_kind (gdbarch
, csky_sw_breakpoint_from_kind
);
2228 /* Register architecture. */
2229 set_gdbarch_num_regs (gdbarch
, CSKY_NUM_REGS
);
2230 set_gdbarch_pc_regnum (gdbarch
, CSKY_PC_REGNUM
);
2231 set_gdbarch_sp_regnum (gdbarch
, CSKY_SP_REGNUM
);
2232 set_gdbarch_register_name (gdbarch
, csky_register_name
);
2233 set_gdbarch_register_type (gdbarch
, csky_register_type
);
2234 set_gdbarch_read_pc (gdbarch
, csky_read_pc
);
2235 set_gdbarch_write_pc (gdbarch
, csky_write_pc
);
2236 set_gdbarch_print_registers_info (gdbarch
, csky_print_registers_info
);
2237 csky_add_reggroups (gdbarch
);
2238 set_gdbarch_register_reggroup_p (gdbarch
, csky_register_reggroup_p
);
2239 set_gdbarch_stab_reg_to_regnum (gdbarch
, csky_dwarf_reg_to_regnum
);
2240 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, csky_dwarf_reg_to_regnum
);
2241 dwarf2_frame_set_init_reg (gdbarch
, csky_dwarf2_frame_init_reg
);
2243 /* Functions to analyze frames. */
2244 frame_base_set_default (gdbarch
, &csky_frame_base
);
2245 set_gdbarch_skip_prologue (gdbarch
, csky_skip_prologue
);
2246 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
2247 set_gdbarch_frame_align (gdbarch
, csky_frame_align
);
2248 set_gdbarch_stack_frame_destroyed_p (gdbarch
, csky_stack_frame_destroyed_p
);
2250 /* Functions to access frame data. */
2251 set_gdbarch_unwind_pc (gdbarch
, csky_unwind_pc
);
2252 set_gdbarch_unwind_sp (gdbarch
, csky_unwind_sp
);
2254 /* Functions handling dummy frames. */
2255 set_gdbarch_push_dummy_call (gdbarch
, csky_push_dummy_call
);
2256 set_gdbarch_dummy_id (gdbarch
, csky_dummy_id
);
2258 /* Frame unwinders. Use DWARF debug info if available,
2259 otherwise use our own unwinder. */
2260 dwarf2_append_unwinders (gdbarch
);
2261 frame_unwind_append_unwinder (gdbarch
, &csky_stub_unwind
);
2262 frame_unwind_append_unwinder (gdbarch
, &csky_unwind_cache
);
2265 set_gdbarch_memory_insert_breakpoint (gdbarch
,
2266 csky_memory_insert_breakpoint
);
2267 set_gdbarch_memory_remove_breakpoint (gdbarch
,
2268 csky_memory_remove_breakpoint
);
2270 /* Hook in ABI-specific overrides, if they have been registered. */
2271 gdbarch_init_osabi (info
, gdbarch
);
2273 /* Support simple overlay manager. */
2274 set_gdbarch_overlay_update (gdbarch
, simple_overlay_update
);
2275 set_gdbarch_char_signed (gdbarch
, 0);
2280 _initialize_csky_tdep (void)
2283 register_gdbarch_init (bfd_arch_csky
, csky_gdbarch_init
);
2285 csky_init_reggroup ();
2287 /* Allow debugging this file's internals. */
2288 add_setshow_boolean_cmd ("csky", class_maintenance
, &csky_debug
,
2289 _("Set C-Sky debugging."),
2290 _("Show C-Sky debugging."),
2291 _("When on, C-Sky specific debugging is enabled."),
2294 &setdebuglist
, &showdebuglist
);