1 /* Target-dependent code for FT32.
3 Copyright (C) 2009-2021 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 "gdb/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
)
101 if (reg_nr
>= FT32_NUM_REGS
)
103 return ft32_register_names
[reg_nr
];
106 /* Implement the "register_type" gdbarch method. */
109 ft32_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
111 if (reg_nr
== FT32_PC_REGNUM
)
113 ft32_gdbarch_tdep
*tdep
= (ft32_gdbarch_tdep
*) gdbarch_tdep (gdbarch
);
114 return tdep
->pc_type
;
116 else if (reg_nr
== FT32_SP_REGNUM
|| reg_nr
== FT32_FP_REGNUM
)
117 return builtin_type (gdbarch
)->builtin_data_ptr
;
119 return builtin_type (gdbarch
)->builtin_int32
;
122 /* Write into appropriate registers a function return value
123 of type TYPE, given in virtual format. */
126 ft32_store_return_value (struct type
*type
, struct regcache
*regcache
,
127 const gdb_byte
*valbuf
)
129 struct gdbarch
*gdbarch
= regcache
->arch ();
130 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
132 int len
= TYPE_LENGTH (type
);
134 /* Things always get returned in RET1_REGNUM, RET2_REGNUM. */
135 regval
= extract_unsigned_integer (valbuf
, len
> 4 ? 4 : len
, byte_order
);
136 regcache_cooked_write_unsigned (regcache
, FT32_R0_REGNUM
, regval
);
139 regval
= extract_unsigned_integer (valbuf
+ 4,
140 len
- 4, byte_order
);
141 regcache_cooked_write_unsigned (regcache
, FT32_R1_REGNUM
, regval
);
145 /* Fetch a single 32-bit instruction from address a. If memory contains
146 a compressed instruction pair, return the expanded instruction. */
149 ft32_fetch_instruction (CORE_ADDR a
, int *isize
,
150 enum bfd_endian byte_order
)
155 CORE_ADDR a4
= a
& ~3;
156 inst
= read_code_unsigned_integer (a4
, 4, byte_order
);
157 *isize
= ft32_decode_shortcode (a4
, inst
, sc
) ? 2 : 4;
159 return sc
[1 & (a
>> 1)];
164 /* Decode the instructions within the given address range. Decide
165 when we must have reached the end of the function prologue. If a
166 frame_info pointer is provided, fill in its saved_regs etc.
168 Returns the address of the first instruction after the prologue. */
171 ft32_analyze_prologue (CORE_ADDR start_addr
, CORE_ADDR end_addr
,
172 struct ft32_frame_cache
*cache
,
173 struct gdbarch
*gdbarch
)
175 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
180 struct bound_minimal_symbol msymbol
;
181 const int first_saved_reg
= 13; /* The first saved register. */
182 /* PROLOGS are addresses of the subroutine prologs, PROLOGS[n]
183 is the address of __prolog_$rN.
184 __prolog_$rN pushes registers from 13 through n inclusive.
185 So for example CALL __prolog_$r15 is equivalent to:
189 Note that PROLOGS[0] through PROLOGS[12] are unused. */
190 CORE_ADDR prologs
[32];
192 cache
->saved_regs
[FT32_PC_REGNUM
] = 0;
193 cache
->framesize
= 0;
195 for (regnum
= first_saved_reg
; regnum
< 32; regnum
++)
197 char prolog_symbol
[32];
199 snprintf (prolog_symbol
, sizeof (prolog_symbol
), "__prolog_$r%02d",
201 msymbol
= lookup_minimal_symbol (prolog_symbol
, NULL
, NULL
);
203 prologs
[regnum
] = BMSYMBOL_VALUE_ADDRESS (msymbol
);
208 if (start_addr
>= end_addr
)
211 cache
->established
= 0;
212 for (next_addr
= start_addr
; next_addr
< end_addr
; next_addr
+= isize
)
214 inst
= ft32_fetch_instruction (next_addr
, &isize
, byte_order
);
216 if (FT32_IS_PUSH (inst
))
218 pushreg
= FT32_PUSH_REG (inst
);
219 cache
->framesize
+= 4;
220 cache
->saved_regs
[FT32_R0_REGNUM
+ pushreg
] = cache
->framesize
;
222 else if (FT32_IS_CALL (inst
))
224 for (regnum
= first_saved_reg
; regnum
< 32; regnum
++)
226 if ((4 * (inst
& 0x3ffff)) == prologs
[regnum
])
228 for (pushreg
= first_saved_reg
; pushreg
<= regnum
;
231 cache
->framesize
+= 4;
232 cache
->saved_regs
[FT32_R0_REGNUM
+ pushreg
] =
242 for (regnum
= FT32_R0_REGNUM
; regnum
< FT32_PC_REGNUM
; regnum
++)
244 if (cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
245 cache
->saved_regs
[regnum
] =
246 cache
->framesize
- cache
->saved_regs
[regnum
];
248 cache
->saved_regs
[FT32_PC_REGNUM
] = cache
->framesize
;
251 if (next_addr
< end_addr
)
253 inst
= ft32_fetch_instruction (next_addr
, &isize
, byte_order
);
254 if (FT32_IS_LINK (inst
))
256 cache
->established
= 1;
257 for (regnum
= FT32_R0_REGNUM
; regnum
< FT32_PC_REGNUM
; regnum
++)
259 if (cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
260 cache
->saved_regs
[regnum
] += 4;
262 cache
->saved_regs
[FT32_PC_REGNUM
] = cache
->framesize
+ 4;
263 cache
->saved_regs
[FT32_FP_REGNUM
] = 0;
264 cache
->framesize
+= FT32_LINK_SIZE (inst
);
272 /* Find the end of function prologue. */
275 ft32_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
277 CORE_ADDR func_addr
= 0, func_end
= 0;
278 const char *func_name
;
280 /* See if we can determine the end of the prologue via the symbol table.
281 If so, then return either PC, or the PC after the prologue, whichever
283 if (find_pc_partial_function (pc
, &func_name
, &func_addr
, &func_end
))
285 CORE_ADDR post_prologue_pc
286 = skip_prologue_using_sal (gdbarch
, func_addr
);
287 if (post_prologue_pc
!= 0)
288 return std::max (pc
, post_prologue_pc
);
291 /* Can't determine prologue from the symbol table, need to examine
293 struct symtab_and_line sal
;
295 struct ft32_frame_cache cache
;
298 memset (&cache
, 0, sizeof cache
);
300 plg_end
= ft32_analyze_prologue (func_addr
,
301 func_end
, &cache
, gdbarch
);
302 /* Found a function. */
303 sym
= lookup_symbol (func_name
, NULL
, VAR_DOMAIN
, NULL
).symbol
;
304 /* Don't use line number debug info for assembly source files. */
305 if ((sym
!= NULL
) && sym
->language () != language_asm
)
307 sal
= find_pc_line (func_addr
, 0);
308 if (sal
.end
&& sal
.end
< func_end
)
310 /* Found a line number, use it as end of prologue. */
314 /* No useable line symbol. Use result of prologue parsing method. */
319 /* No function symbol -- just return the PC. */
323 /* Implementation of `pointer_to_address' gdbarch method.
325 On FT32 address space zero is RAM, address space 1 is flash.
326 RAM appears at address RAM_BIAS, flash at address 0. */
329 ft32_pointer_to_address (struct gdbarch
*gdbarch
,
330 struct type
*type
, const gdb_byte
*buf
)
332 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
334 = extract_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
);
336 if (TYPE_ADDRESS_CLASS_1 (type
))
339 return addr
| RAM_BIAS
;
342 /* Implementation of `address_class_type_flags' gdbarch method.
344 This method maps DW_AT_address_class attributes to a
345 type_instance_flag_value. */
347 static type_instance_flags
348 ft32_address_class_type_flags (int byte_size
, int dwarf2_addr_class
)
350 /* The value 1 of the DW_AT_address_class attribute corresponds to the
351 __flash__ qualifier, meaning pointer to data in FT32 program memory.
353 if (dwarf2_addr_class
== 1)
354 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
358 /* Implementation of `address_class_type_flags_to_name' gdbarch method.
360 Convert a type_instance_flag_value to an address space qualifier. */
363 ft32_address_class_type_flags_to_name (struct gdbarch
*gdbarch
,
364 type_instance_flags type_flags
)
366 if (type_flags
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
)
372 /* Implementation of `address_class_name_to_type_flags' gdbarch method.
374 Convert an address space qualifier to a type_instance_flag_value. */
377 ft32_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
379 type_instance_flags
*type_flags_ptr
)
381 if (strcmp (name
, "flash") == 0)
383 *type_flags_ptr
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
390 /* Given a return value in `regbuf' with a type `valtype',
391 extract and copy its value into `valbuf'. */
394 ft32_extract_return_value (struct type
*type
, struct regcache
*regcache
,
397 struct gdbarch
*gdbarch
= regcache
->arch ();
398 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
399 bfd_byte
*valbuf
= dst
;
400 int len
= TYPE_LENGTH (type
);
403 /* By using store_unsigned_integer we avoid having to do
404 anything special for small big-endian values. */
405 regcache_cooked_read_unsigned (regcache
, FT32_R0_REGNUM
, &tmp
);
406 store_unsigned_integer (valbuf
, (len
> 4 ? len
- 4 : len
), byte_order
, tmp
);
408 /* Ignore return values more than 8 bytes in size because the ft32
409 returns anything more than 8 bytes in the stack. */
412 regcache_cooked_read_unsigned (regcache
, FT32_R1_REGNUM
, &tmp
);
413 store_unsigned_integer (valbuf
+ len
- 4, 4, byte_order
, tmp
);
417 /* Implement the "return_value" gdbarch method. */
419 static enum return_value_convention
420 ft32_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
421 struct type
*valtype
, struct regcache
*regcache
,
422 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
424 if (TYPE_LENGTH (valtype
) > 8)
425 return RETURN_VALUE_STRUCT_CONVENTION
;
429 ft32_extract_return_value (valtype
, regcache
, readbuf
);
430 if (writebuf
!= NULL
)
431 ft32_store_return_value (valtype
, regcache
, writebuf
);
432 return RETURN_VALUE_REGISTER_CONVENTION
;
436 /* Allocate and initialize a ft32_frame_cache object. */
438 static struct ft32_frame_cache
*
439 ft32_alloc_frame_cache (void)
441 struct ft32_frame_cache
*cache
;
444 cache
= FRAME_OBSTACK_ZALLOC (struct ft32_frame_cache
);
446 for (i
= 0; i
< FT32_NUM_REGS
; ++i
)
447 cache
->saved_regs
[i
] = REG_UNAVAIL
;
452 /* Populate a ft32_frame_cache object for this_frame. */
454 static struct ft32_frame_cache
*
455 ft32_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
457 struct ft32_frame_cache
*cache
;
458 CORE_ADDR current_pc
;
462 return (struct ft32_frame_cache
*) *this_cache
;
464 cache
= ft32_alloc_frame_cache ();
467 cache
->base
= get_frame_register_unsigned (this_frame
, FT32_FP_REGNUM
);
468 if (cache
->base
== 0)
471 cache
->pc
= get_frame_func (this_frame
);
472 current_pc
= get_frame_pc (this_frame
);
475 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
477 ft32_analyze_prologue (cache
->pc
, current_pc
, cache
, gdbarch
);
478 if (!cache
->established
)
479 cache
->base
= get_frame_register_unsigned (this_frame
, FT32_SP_REGNUM
);
482 cache
->saved_sp
= cache
->base
- 4;
484 for (i
= 0; i
< FT32_NUM_REGS
; ++i
)
485 if (cache
->saved_regs
[i
] != REG_UNAVAIL
)
486 cache
->saved_regs
[i
] = cache
->base
+ cache
->saved_regs
[i
];
491 /* Given a GDB frame, determine the address of the calling function's
492 frame. This will be used to create a new GDB frame struct. */
495 ft32_frame_this_id (struct frame_info
*this_frame
,
496 void **this_prologue_cache
, struct frame_id
*this_id
)
498 struct ft32_frame_cache
*cache
= ft32_frame_cache (this_frame
,
499 this_prologue_cache
);
501 /* This marks the outermost frame. */
502 if (cache
->base
== 0)
505 *this_id
= frame_id_build (cache
->saved_sp
, cache
->pc
);
508 /* Get the value of register regnum in the previous stack frame. */
510 static struct value
*
511 ft32_frame_prev_register (struct frame_info
*this_frame
,
512 void **this_prologue_cache
, int regnum
)
514 struct ft32_frame_cache
*cache
= ft32_frame_cache (this_frame
,
515 this_prologue_cache
);
517 gdb_assert (regnum
>= 0);
519 if (regnum
== FT32_SP_REGNUM
&& cache
->saved_sp
)
520 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
522 if (regnum
< FT32_NUM_REGS
&& cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
523 return frame_unwind_got_memory (this_frame
, regnum
,
524 RAM_BIAS
| cache
->saved_regs
[regnum
]);
526 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
529 static const struct frame_unwind ft32_frame_unwind
=
533 default_frame_unwind_stop_reason
,
535 ft32_frame_prev_register
,
537 default_frame_sniffer
540 /* Return the base address of this_frame. */
543 ft32_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
545 struct ft32_frame_cache
*cache
= ft32_frame_cache (this_frame
,
551 static const struct frame_base ft32_frame_base
=
554 ft32_frame_base_address
,
555 ft32_frame_base_address
,
556 ft32_frame_base_address
559 /* Allocate and initialize the ft32 gdbarch object. */
561 static struct gdbarch
*
562 ft32_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
564 struct gdbarch
*gdbarch
;
565 struct type
*void_type
;
566 struct type
*func_void_type
;
568 /* If there is already a candidate, use it. */
569 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
571 return arches
->gdbarch
;
573 /* Allocate space for the new architecture. */
574 ft32_gdbarch_tdep
*tdep
= new ft32_gdbarch_tdep
;
575 gdbarch
= gdbarch_alloc (&info
, tdep
);
577 /* Create a type for PC. We can't use builtin types here, as they may not
579 void_type
= arch_type (gdbarch
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, "void");
580 func_void_type
= make_function_type (void_type
, NULL
);
581 tdep
->pc_type
= arch_pointer_type (gdbarch
, 4 * TARGET_CHAR_BIT
, NULL
,
583 tdep
->pc_type
->set_instance_flags (tdep
->pc_type
->instance_flags ()
584 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
);
586 set_gdbarch_num_regs (gdbarch
, FT32_NUM_REGS
);
587 set_gdbarch_sp_regnum (gdbarch
, FT32_SP_REGNUM
);
588 set_gdbarch_pc_regnum (gdbarch
, FT32_PC_REGNUM
);
589 set_gdbarch_register_name (gdbarch
, ft32_register_name
);
590 set_gdbarch_register_type (gdbarch
, ft32_register_type
);
592 set_gdbarch_return_value (gdbarch
, ft32_return_value
);
594 set_gdbarch_pointer_to_address (gdbarch
, ft32_pointer_to_address
);
596 set_gdbarch_skip_prologue (gdbarch
, ft32_skip_prologue
);
597 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
598 set_gdbarch_breakpoint_kind_from_pc (gdbarch
, ft32_breakpoint::kind_from_pc
);
599 set_gdbarch_sw_breakpoint_from_kind (gdbarch
, ft32_breakpoint::bp_from_kind
);
600 set_gdbarch_frame_align (gdbarch
, ft32_frame_align
);
602 frame_base_set_default (gdbarch
, &ft32_frame_base
);
604 /* Hook in ABI-specific overrides, if they have been registered. */
605 gdbarch_init_osabi (info
, gdbarch
);
607 /* Hook in the default unwinders. */
608 frame_unwind_append_unwinder (gdbarch
, &ft32_frame_unwind
);
610 /* Support simple overlay manager. */
611 set_gdbarch_overlay_update (gdbarch
, simple_overlay_update
);
613 set_gdbarch_address_class_type_flags (gdbarch
, ft32_address_class_type_flags
);
614 set_gdbarch_address_class_name_to_type_flags
615 (gdbarch
, ft32_address_class_name_to_type_flags
);
616 set_gdbarch_address_class_type_flags_to_name
617 (gdbarch
, ft32_address_class_type_flags_to_name
);
622 /* Register this machine's init routine. */
624 void _initialize_ft32_tdep ();
626 _initialize_ft32_tdep ()
628 register_gdbarch_init (bfd_arch_ft32
, ft32_gdbarch_init
);