1 /* Target-dependent code for FT32.
3 Copyright (C) 2009-2024 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "frame-unwind.h"
23 #include "frame-base.h"
34 #include "arch-utils.h"
36 #include "trad-frame.h"
40 #include "opcode/ft32.h"
42 #include "ft32-tdep.h"
43 #include "sim/sim-ft32.h"
46 #define RAM_BIAS 0x800000 /* Bias added to RAM addresses. */
48 /* Use an invalid address -1 as 'not available' marker. */
49 enum { REG_UNAVAIL
= (CORE_ADDR
) (-1) };
51 struct ft32_frame_cache
53 /* Base address of the frame */
55 /* Function this frame belongs to */
57 /* Total size of this frame */
59 /* Saved registers in this frame */
60 CORE_ADDR saved_regs
[FT32_NUM_REGS
];
61 /* Saved SP in this frame */
63 /* Has the new frame been LINKed. */
64 bfd_boolean established
;
67 /* Implement the "frame_align" gdbarch method. */
70 ft32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
72 /* Align to the size of an instruction (so that they can safely be
73 pushed onto the stack. */
78 constexpr gdb_byte ft32_break_insn
[] = { 0x02, 0x00, 0x34, 0x00 };
80 typedef BP_MANIPULATION (ft32_break_insn
) ft32_breakpoint
;
82 /* FT32 register names. */
84 static const char *const ft32_register_names
[] =
87 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
88 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
89 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
90 "r24", "r25", "r26", "r27", "r28", "cc",
94 /* Implement the "register_name" gdbarch method. */
97 ft32_register_name (struct gdbarch
*gdbarch
, int reg_nr
)
99 static_assert (ARRAY_SIZE (ft32_register_names
) == FT32_NUM_REGS
);
100 return ft32_register_names
[reg_nr
];
103 /* Implement the "register_type" gdbarch method. */
106 ft32_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
108 if (reg_nr
== FT32_PC_REGNUM
)
110 ft32_gdbarch_tdep
*tdep
= gdbarch_tdep
<ft32_gdbarch_tdep
> (gdbarch
);
111 return tdep
->pc_type
;
113 else if (reg_nr
== FT32_SP_REGNUM
|| reg_nr
== FT32_FP_REGNUM
)
114 return builtin_type (gdbarch
)->builtin_data_ptr
;
116 return builtin_type (gdbarch
)->builtin_int32
;
119 /* Write into appropriate registers a function return value
120 of type TYPE, given in virtual format. */
123 ft32_store_return_value (struct type
*type
, struct regcache
*regcache
,
124 const gdb_byte
*valbuf
)
126 struct gdbarch
*gdbarch
= regcache
->arch ();
127 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
129 int len
= type
->length ();
131 /* Things always get returned in RET1_REGNUM, RET2_REGNUM. */
132 regval
= extract_unsigned_integer (valbuf
, len
> 4 ? 4 : len
, byte_order
);
133 regcache_cooked_write_unsigned (regcache
, FT32_R0_REGNUM
, regval
);
136 regval
= extract_unsigned_integer (valbuf
+ 4,
137 len
- 4, byte_order
);
138 regcache_cooked_write_unsigned (regcache
, FT32_R1_REGNUM
, regval
);
142 /* Fetch a single 32-bit instruction from address a. If memory contains
143 a compressed instruction pair, return the expanded instruction. */
146 ft32_fetch_instruction (CORE_ADDR a
, int *isize
,
147 enum bfd_endian byte_order
)
152 CORE_ADDR a4
= a
& ~3;
153 inst
= read_code_unsigned_integer (a4
, 4, byte_order
);
154 *isize
= ft32_decode_shortcode (a4
, inst
, sc
) ? 2 : 4;
156 return sc
[1 & (a
>> 1)];
161 /* Decode the instructions within the given address range. Decide
162 when we must have reached the end of the function prologue. If a
163 frame_info pointer is provided, fill in its saved_regs etc.
165 Returns the address of the first instruction after the prologue. */
168 ft32_analyze_prologue (CORE_ADDR start_addr
, CORE_ADDR end_addr
,
169 struct ft32_frame_cache
*cache
,
170 struct gdbarch
*gdbarch
)
172 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
177 struct bound_minimal_symbol msymbol
;
178 const int first_saved_reg
= 13; /* The first saved register. */
179 /* PROLOGS are addresses of the subroutine prologs, PROLOGS[n]
180 is the address of __prolog_$rN.
181 __prolog_$rN pushes registers from 13 through n inclusive.
182 So for example CALL __prolog_$r15 is equivalent to:
186 Note that PROLOGS[0] through PROLOGS[12] are unused. */
187 CORE_ADDR prologs
[32];
189 cache
->saved_regs
[FT32_PC_REGNUM
] = 0;
190 cache
->framesize
= 0;
192 for (regnum
= first_saved_reg
; regnum
< 32; regnum
++)
194 char prolog_symbol
[32];
196 snprintf (prolog_symbol
, sizeof (prolog_symbol
), "__prolog_$r%02d",
198 msymbol
= lookup_minimal_symbol (prolog_symbol
, NULL
, NULL
);
200 prologs
[regnum
] = msymbol
.value_address ();
205 if (start_addr
>= end_addr
)
208 cache
->established
= 0;
209 for (next_addr
= start_addr
; next_addr
< end_addr
; next_addr
+= isize
)
211 inst
= ft32_fetch_instruction (next_addr
, &isize
, byte_order
);
213 if (FT32_IS_PUSH (inst
))
215 pushreg
= FT32_PUSH_REG (inst
);
216 cache
->framesize
+= 4;
217 cache
->saved_regs
[FT32_R0_REGNUM
+ pushreg
] = cache
->framesize
;
219 else if (FT32_IS_CALL (inst
))
221 for (regnum
= first_saved_reg
; regnum
< 32; regnum
++)
223 if ((4 * (inst
& 0x3ffff)) == prologs
[regnum
])
225 for (pushreg
= first_saved_reg
; pushreg
<= regnum
;
228 cache
->framesize
+= 4;
229 cache
->saved_regs
[FT32_R0_REGNUM
+ pushreg
] =
239 for (regnum
= FT32_R0_REGNUM
; regnum
< FT32_PC_REGNUM
; regnum
++)
241 if (cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
242 cache
->saved_regs
[regnum
] =
243 cache
->framesize
- cache
->saved_regs
[regnum
];
245 cache
->saved_regs
[FT32_PC_REGNUM
] = cache
->framesize
;
248 if (next_addr
< end_addr
)
250 inst
= ft32_fetch_instruction (next_addr
, &isize
, byte_order
);
251 if (FT32_IS_LINK (inst
))
253 cache
->established
= 1;
254 for (regnum
= FT32_R0_REGNUM
; regnum
< FT32_PC_REGNUM
; regnum
++)
256 if (cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
257 cache
->saved_regs
[regnum
] += 4;
259 cache
->saved_regs
[FT32_PC_REGNUM
] = cache
->framesize
+ 4;
260 cache
->saved_regs
[FT32_FP_REGNUM
] = 0;
261 cache
->framesize
+= FT32_LINK_SIZE (inst
);
269 /* Find the end of function prologue. */
272 ft32_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
274 CORE_ADDR func_addr
= 0, func_end
= 0;
275 const char *func_name
;
277 /* See if we can determine the end of the prologue via the symbol table.
278 If so, then return either PC, or the PC after the prologue, whichever
280 if (find_pc_partial_function (pc
, &func_name
, &func_addr
, &func_end
))
282 CORE_ADDR post_prologue_pc
283 = skip_prologue_using_sal (gdbarch
, func_addr
);
284 if (post_prologue_pc
!= 0)
285 return std::max (pc
, post_prologue_pc
);
288 /* Can't determine prologue from the symbol table, need to examine
290 struct symtab_and_line sal
;
292 struct ft32_frame_cache cache
;
295 memset (&cache
, 0, sizeof cache
);
297 plg_end
= ft32_analyze_prologue (func_addr
,
298 func_end
, &cache
, gdbarch
);
299 /* Found a function. */
300 sym
= lookup_symbol (func_name
, nullptr, SEARCH_FUNCTION_DOMAIN
,
302 /* Don't use line number debug info for assembly source files. */
303 if ((sym
!= NULL
) && sym
->language () != language_asm
)
305 sal
= find_pc_line (func_addr
, 0);
306 if (sal
.end
&& sal
.end
< func_end
)
308 /* Found a line number, use it as end of prologue. */
312 /* No useable line symbol. Use result of prologue parsing method. */
317 /* No function symbol -- just return the PC. */
321 /* Implementation of `pointer_to_address' gdbarch method.
323 On FT32 address space zero is RAM, address space 1 is flash.
324 RAM appears at address RAM_BIAS, flash at address 0. */
327 ft32_pointer_to_address (struct gdbarch
*gdbarch
,
328 struct type
*type
, const gdb_byte
*buf
)
330 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
332 = extract_unsigned_integer (buf
, type
->length (), byte_order
);
334 if (TYPE_ADDRESS_CLASS_1 (type
))
337 return addr
| RAM_BIAS
;
340 /* Implementation of `address_class_type_flags' gdbarch method.
342 This method maps DW_AT_address_class attributes to a
343 type_instance_flag_value. */
345 static type_instance_flags
346 ft32_address_class_type_flags (int byte_size
, int dwarf2_addr_class
)
348 /* The value 1 of the DW_AT_address_class attribute corresponds to the
349 __flash__ qualifier, meaning pointer to data in FT32 program memory.
351 if (dwarf2_addr_class
== 1)
352 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
356 /* Implementation of `address_class_type_flags_to_name' gdbarch method.
358 Convert a type_instance_flag_value to an address space qualifier. */
361 ft32_address_class_type_flags_to_name (struct gdbarch
*gdbarch
,
362 type_instance_flags type_flags
)
364 if (type_flags
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
)
370 /* Implementation of `address_class_name_to_type_flags' gdbarch method.
372 Convert an address space qualifier to a type_instance_flag_value. */
375 ft32_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
377 type_instance_flags
*type_flags_ptr
)
379 if (strcmp (name
, "flash") == 0)
381 *type_flags_ptr
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
388 /* Given a return value in `regbuf' with a type `valtype',
389 extract and copy its value into `valbuf'. */
392 ft32_extract_return_value (struct type
*type
, struct regcache
*regcache
,
395 struct gdbarch
*gdbarch
= regcache
->arch ();
396 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
397 bfd_byte
*valbuf
= dst
;
398 int len
= type
->length ();
401 /* By using store_unsigned_integer we avoid having to do
402 anything special for small big-endian values. */
403 regcache_cooked_read_unsigned (regcache
, FT32_R0_REGNUM
, &tmp
);
404 store_unsigned_integer (valbuf
, (len
> 4 ? len
- 4 : len
), byte_order
, tmp
);
406 /* Ignore return values more than 8 bytes in size because the ft32
407 returns anything more than 8 bytes in the stack. */
410 regcache_cooked_read_unsigned (regcache
, FT32_R1_REGNUM
, &tmp
);
411 store_unsigned_integer (valbuf
+ len
- 4, 4, byte_order
, tmp
);
415 /* Implement the "return_value" gdbarch method. */
417 static enum return_value_convention
418 ft32_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
419 struct type
*valtype
, struct regcache
*regcache
,
420 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
422 if (valtype
->length () > 8)
423 return RETURN_VALUE_STRUCT_CONVENTION
;
427 ft32_extract_return_value (valtype
, regcache
, readbuf
);
428 if (writebuf
!= NULL
)
429 ft32_store_return_value (valtype
, regcache
, writebuf
);
430 return RETURN_VALUE_REGISTER_CONVENTION
;
434 /* Allocate and initialize a ft32_frame_cache object. */
436 static struct ft32_frame_cache
*
437 ft32_alloc_frame_cache (void)
439 struct ft32_frame_cache
*cache
;
442 cache
= FRAME_OBSTACK_ZALLOC (struct ft32_frame_cache
);
444 for (i
= 0; i
< FT32_NUM_REGS
; ++i
)
445 cache
->saved_regs
[i
] = REG_UNAVAIL
;
450 /* Populate a ft32_frame_cache object for this_frame. */
452 static struct ft32_frame_cache
*
453 ft32_frame_cache (const frame_info_ptr
&this_frame
, void **this_cache
)
455 struct ft32_frame_cache
*cache
;
456 CORE_ADDR current_pc
;
460 return (struct ft32_frame_cache
*) *this_cache
;
462 cache
= ft32_alloc_frame_cache ();
465 cache
->base
= get_frame_register_unsigned (this_frame
, FT32_FP_REGNUM
);
466 if (cache
->base
== 0)
469 cache
->pc
= get_frame_func (this_frame
);
470 current_pc
= get_frame_pc (this_frame
);
473 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
475 ft32_analyze_prologue (cache
->pc
, current_pc
, cache
, gdbarch
);
476 if (!cache
->established
)
477 cache
->base
= get_frame_register_unsigned (this_frame
, FT32_SP_REGNUM
);
480 cache
->saved_sp
= cache
->base
- 4;
482 for (i
= 0; i
< FT32_NUM_REGS
; ++i
)
483 if (cache
->saved_regs
[i
] != REG_UNAVAIL
)
484 cache
->saved_regs
[i
] = cache
->base
+ cache
->saved_regs
[i
];
489 /* Given a GDB frame, determine the address of the calling function's
490 frame. This will be used to create a new GDB frame struct. */
493 ft32_frame_this_id (const frame_info_ptr
&this_frame
,
494 void **this_prologue_cache
, struct frame_id
*this_id
)
496 struct ft32_frame_cache
*cache
= ft32_frame_cache (this_frame
,
497 this_prologue_cache
);
499 /* This marks the outermost frame. */
500 if (cache
->base
== 0)
503 *this_id
= frame_id_build (cache
->saved_sp
, cache
->pc
);
506 /* Get the value of register regnum in the previous stack frame. */
508 static struct value
*
509 ft32_frame_prev_register (const frame_info_ptr
&this_frame
,
510 void **this_prologue_cache
, int regnum
)
512 struct ft32_frame_cache
*cache
= ft32_frame_cache (this_frame
,
513 this_prologue_cache
);
515 gdb_assert (regnum
>= 0);
517 if (regnum
== FT32_SP_REGNUM
&& cache
->saved_sp
)
518 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
520 if (regnum
< FT32_NUM_REGS
&& cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
521 return frame_unwind_got_memory (this_frame
, regnum
,
522 RAM_BIAS
| cache
->saved_regs
[regnum
]);
524 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
527 static const struct frame_unwind ft32_frame_unwind
=
531 default_frame_unwind_stop_reason
,
533 ft32_frame_prev_register
,
535 default_frame_sniffer
538 /* Return the base address of this_frame. */
541 ft32_frame_base_address (const frame_info_ptr
&this_frame
, void **this_cache
)
543 struct ft32_frame_cache
*cache
= ft32_frame_cache (this_frame
,
549 static const struct frame_base ft32_frame_base
=
552 ft32_frame_base_address
,
553 ft32_frame_base_address
,
554 ft32_frame_base_address
557 /* Allocate and initialize the ft32 gdbarch object. */
559 static struct gdbarch
*
560 ft32_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
562 struct type
*void_type
;
563 struct type
*func_void_type
;
565 /* If there is already a candidate, use it. */
566 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
568 return arches
->gdbarch
;
570 /* Allocate space for the new architecture. */
572 = gdbarch_alloc (&info
, gdbarch_tdep_up (new ft32_gdbarch_tdep
));
573 ft32_gdbarch_tdep
*tdep
= gdbarch_tdep
<ft32_gdbarch_tdep
> (gdbarch
);
575 /* Create a type for PC. We can't use builtin types here, as they may not
577 type_allocator
alloc (gdbarch
);
578 void_type
= alloc
.new_type (TYPE_CODE_VOID
, TARGET_CHAR_BIT
, "void");
579 func_void_type
= make_function_type (void_type
, NULL
);
580 tdep
->pc_type
= init_pointer_type (alloc
, 4 * TARGET_CHAR_BIT
, NULL
,
582 tdep
->pc_type
->set_instance_flags (tdep
->pc_type
->instance_flags ()
583 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
);
585 set_gdbarch_num_regs (gdbarch
, FT32_NUM_REGS
);
586 set_gdbarch_sp_regnum (gdbarch
, FT32_SP_REGNUM
);
587 set_gdbarch_pc_regnum (gdbarch
, FT32_PC_REGNUM
);
588 set_gdbarch_register_name (gdbarch
, ft32_register_name
);
589 set_gdbarch_register_type (gdbarch
, ft32_register_type
);
591 set_gdbarch_return_value (gdbarch
, ft32_return_value
);
593 set_gdbarch_pointer_to_address (gdbarch
, ft32_pointer_to_address
);
595 set_gdbarch_skip_prologue (gdbarch
, ft32_skip_prologue
);
596 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
597 set_gdbarch_breakpoint_kind_from_pc (gdbarch
, ft32_breakpoint::kind_from_pc
);
598 set_gdbarch_sw_breakpoint_from_kind (gdbarch
, ft32_breakpoint::bp_from_kind
);
599 set_gdbarch_frame_align (gdbarch
, ft32_frame_align
);
601 frame_base_set_default (gdbarch
, &ft32_frame_base
);
603 /* Hook in ABI-specific overrides, if they have been registered. */
604 gdbarch_init_osabi (info
, gdbarch
);
606 /* Hook in the default unwinders. */
607 frame_unwind_append_unwinder (gdbarch
, &ft32_frame_unwind
);
609 /* Support simple overlay manager. */
610 set_gdbarch_overlay_update (gdbarch
, simple_overlay_update
);
612 set_gdbarch_address_class_type_flags (gdbarch
, ft32_address_class_type_flags
);
613 set_gdbarch_address_class_name_to_type_flags
614 (gdbarch
, ft32_address_class_name_to_type_flags
);
615 set_gdbarch_address_class_type_flags_to_name
616 (gdbarch
, ft32_address_class_type_flags_to_name
);
621 /* Register this machine's init routine. */
623 void _initialize_ft32_tdep ();
625 _initialize_ft32_tdep ()
627 gdbarch_register (bfd_arch_ft32
, ft32_gdbarch_init
);