1 /* Target-dependent code for FT32.
3 Copyright (C) 2009-2016 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"
45 #define RAM_BIAS 0x800000 /* Bias added to RAM addresses. */
47 /* Local functions. */
49 extern void _initialize_ft32_tdep (void);
51 /* Use an invalid address -1 as 'not available' marker. */
52 enum { REG_UNAVAIL
= (CORE_ADDR
) (-1) };
54 struct ft32_frame_cache
56 /* Base address of the frame */
58 /* Function this frame belongs to */
60 /* Total size of this frame */
62 /* Saved registers in this frame */
63 CORE_ADDR saved_regs
[FT32_NUM_REGS
];
64 /* Saved SP in this frame */
66 /* Has the new frame been LINKed. */
67 bfd_boolean established
;
70 /* Implement the "frame_align" gdbarch method. */
73 ft32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
75 /* Align to the size of an instruction (so that they can safely be
76 pushed onto the stack. */
80 /* Implement the "breakpoint_from_pc" gdbarch method. */
82 static const unsigned char *
83 ft32_breakpoint_from_pc (struct gdbarch
*gdbarch
,
84 CORE_ADDR
*pcptr
, int *lenptr
)
86 static const gdb_byte breakpoint
[] = { 0x02, 0x00, 0x34, 0x00 };
88 *lenptr
= sizeof (breakpoint
);
92 /* FT32 register names. */
94 static const char *const ft32_register_names
[] =
97 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
98 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
99 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
100 "r24", "r25", "r26", "r27", "r28", "cc",
104 /* Implement the "register_name" gdbarch method. */
107 ft32_register_name (struct gdbarch
*gdbarch
, int reg_nr
)
111 if (reg_nr
>= FT32_NUM_REGS
)
113 return ft32_register_names
[reg_nr
];
116 /* Implement the "register_type" gdbarch method. */
119 ft32_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
121 if (reg_nr
== FT32_PC_REGNUM
)
122 return gdbarch_tdep (gdbarch
)->pc_type
;
123 else if (reg_nr
== FT32_SP_REGNUM
|| reg_nr
== FT32_FP_REGNUM
)
124 return builtin_type (gdbarch
)->builtin_data_ptr
;
126 return builtin_type (gdbarch
)->builtin_int32
;
129 /* Write into appropriate registers a function return value
130 of type TYPE, given in virtual format. */
133 ft32_store_return_value (struct type
*type
, struct regcache
*regcache
,
134 const gdb_byte
*valbuf
)
136 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
137 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
139 int len
= TYPE_LENGTH (type
);
141 /* Things always get returned in RET1_REGNUM, RET2_REGNUM. */
142 regval
= extract_unsigned_integer (valbuf
, len
> 4 ? 4 : len
, byte_order
);
143 regcache_cooked_write_unsigned (regcache
, FT32_R0_REGNUM
, regval
);
146 regval
= extract_unsigned_integer (valbuf
+ 4,
147 len
- 4, byte_order
);
148 regcache_cooked_write_unsigned (regcache
, FT32_R1_REGNUM
, regval
);
152 /* Decode the instructions within the given address range. Decide
153 when we must have reached the end of the function prologue. If a
154 frame_info pointer is provided, fill in its saved_regs etc.
156 Returns the address of the first instruction after the prologue. */
159 ft32_analyze_prologue (CORE_ADDR start_addr
, CORE_ADDR end_addr
,
160 struct ft32_frame_cache
*cache
,
161 struct gdbarch
*gdbarch
)
163 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
167 struct bound_minimal_symbol msymbol
;
168 const int first_saved_reg
= 13; /* The first saved register. */
169 /* PROLOGS are addresses of the subroutine prologs, PROLOGS[n]
170 is the address of __prolog_$rN.
171 __prolog_$rN pushes registers from 13 through n inclusive.
172 So for example CALL __prolog_$r15 is equivalent to:
176 Note that PROLOGS[0] through PROLOGS[12] are unused. */
177 CORE_ADDR prologs
[32];
179 cache
->saved_regs
[FT32_PC_REGNUM
] = 0;
180 cache
->framesize
= 0;
182 for (regnum
= first_saved_reg
; regnum
< 32; regnum
++)
184 char prolog_symbol
[32];
186 snprintf (prolog_symbol
, sizeof (prolog_symbol
), "__prolog_$r%02d",
188 msymbol
= lookup_minimal_symbol (prolog_symbol
, NULL
, NULL
);
190 prologs
[regnum
] = BMSYMBOL_VALUE_ADDRESS (msymbol
);
195 if (start_addr
>= end_addr
)
198 cache
->established
= 0;
199 for (next_addr
= start_addr
; next_addr
< end_addr
;)
201 inst
= read_memory_unsigned_integer (next_addr
, 4, byte_order
);
203 if (FT32_IS_PUSH (inst
))
205 pushreg
= FT32_PUSH_REG (inst
);
206 cache
->framesize
+= 4;
207 cache
->saved_regs
[FT32_R0_REGNUM
+ pushreg
] = cache
->framesize
;
210 else if (FT32_IS_CALL (inst
))
212 for (regnum
= first_saved_reg
; regnum
< 32; regnum
++)
214 if ((4 * (inst
& 0x3ffff)) == prologs
[regnum
])
216 for (pushreg
= first_saved_reg
; pushreg
<= regnum
;
219 cache
->framesize
+= 4;
220 cache
->saved_regs
[FT32_R0_REGNUM
+ pushreg
] =
231 for (regnum
= FT32_R0_REGNUM
; regnum
< FT32_PC_REGNUM
; regnum
++)
233 if (cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
234 cache
->saved_regs
[regnum
] =
235 cache
->framesize
- cache
->saved_regs
[regnum
];
237 cache
->saved_regs
[FT32_PC_REGNUM
] = cache
->framesize
;
240 if (next_addr
< end_addr
)
242 inst
= read_memory_unsigned_integer (next_addr
, 4, byte_order
);
243 if (FT32_IS_LINK (inst
))
245 cache
->established
= 1;
246 for (regnum
= FT32_R0_REGNUM
; regnum
< FT32_PC_REGNUM
; regnum
++)
248 if (cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
249 cache
->saved_regs
[regnum
] += 4;
251 cache
->saved_regs
[FT32_PC_REGNUM
] = cache
->framesize
+ 4;
252 cache
->saved_regs
[FT32_FP_REGNUM
] = 0;
253 cache
->framesize
+= FT32_LINK_SIZE (inst
);
261 /* Find the end of function prologue. */
264 ft32_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
266 CORE_ADDR func_addr
= 0, func_end
= 0;
267 const char *func_name
;
269 /* See if we can determine the end of the prologue via the symbol table.
270 If so, then return either PC, or the PC after the prologue, whichever
272 if (find_pc_partial_function (pc
, &func_name
, &func_addr
, &func_end
))
274 CORE_ADDR post_prologue_pc
275 = skip_prologue_using_sal (gdbarch
, func_addr
);
276 if (post_prologue_pc
!= 0)
277 return max (pc
, post_prologue_pc
);
280 /* Can't determine prologue from the symbol table, need to examine
282 struct symtab_and_line sal
;
284 struct ft32_frame_cache cache
;
287 memset (&cache
, 0, sizeof cache
);
289 plg_end
= ft32_analyze_prologue (func_addr
,
290 func_end
, &cache
, gdbarch
);
291 /* Found a function. */
292 sym
= lookup_symbol (func_name
, NULL
, VAR_DOMAIN
, NULL
).symbol
;
293 /* Don't use line number debug info for assembly source files. */
294 if ((sym
!= NULL
) && SYMBOL_LANGUAGE (sym
) != language_asm
)
296 sal
= find_pc_line (func_addr
, 0);
297 if (sal
.end
&& sal
.end
< func_end
)
299 /* Found a line number, use it as end of prologue. */
303 /* No useable line symbol. Use result of prologue parsing method. */
308 /* No function symbol -- just return the PC. */
312 /* Implementation of `pointer_to_address' gdbarch method.
314 On FT32 address space zero is RAM, address space 1 is flash.
315 RAM appears at address RAM_BIAS, flash at address 0. */
318 ft32_pointer_to_address (struct gdbarch
*gdbarch
,
319 struct type
*type
, const gdb_byte
*buf
)
321 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
323 = extract_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
);
325 if (TYPE_ADDRESS_CLASS_1 (type
))
328 return addr
| RAM_BIAS
;
331 /* Implementation of `address_class_type_flags' gdbarch method.
333 This method maps DW_AT_address_class attributes to a
334 type_instance_flag_value. */
337 ft32_address_class_type_flags (int byte_size
, int dwarf2_addr_class
)
339 /* The value 1 of the DW_AT_address_class attribute corresponds to the
340 __flash__ qualifier, meaning pointer to data in FT32 program memory.
342 if (dwarf2_addr_class
== 1)
343 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
347 /* Implementation of `address_class_type_flags_to_name' gdbarch method.
349 Convert a type_instance_flag_value to an address space qualifier. */
352 ft32_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
354 if (type_flags
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
)
360 /* Implementation of `address_class_name_to_type_flags' gdbarch method.
362 Convert an address space qualifier to a type_instance_flag_value. */
365 ft32_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
369 if (strcmp (name
, "flash") == 0)
371 *type_flags_ptr
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
379 /* Implement the "read_pc" gdbarch method. */
382 ft32_read_pc (struct regcache
*regcache
)
386 regcache_cooked_read_unsigned (regcache
, FT32_PC_REGNUM
, &pc
);
390 /* Implement the "write_pc" gdbarch method. */
393 ft32_write_pc (struct regcache
*regcache
, CORE_ADDR val
)
395 regcache_cooked_write_unsigned (regcache
, FT32_PC_REGNUM
, val
);
398 /* Implement the "unwind_sp" gdbarch method. */
401 ft32_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
403 return frame_unwind_register_unsigned (next_frame
, FT32_SP_REGNUM
);
406 /* Given a return value in `regbuf' with a type `valtype',
407 extract and copy its value into `valbuf'. */
410 ft32_extract_return_value (struct type
*type
, struct regcache
*regcache
,
413 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
414 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
415 bfd_byte
*valbuf
= dst
;
416 int len
= TYPE_LENGTH (type
);
419 /* By using store_unsigned_integer we avoid having to do
420 anything special for small big-endian values. */
421 regcache_cooked_read_unsigned (regcache
, FT32_R0_REGNUM
, &tmp
);
422 store_unsigned_integer (valbuf
, (len
> 4 ? len
- 4 : len
), byte_order
, tmp
);
424 /* Ignore return values more than 8 bytes in size because the ft32
425 returns anything more than 8 bytes in the stack. */
428 regcache_cooked_read_unsigned (regcache
, FT32_R1_REGNUM
, &tmp
);
429 store_unsigned_integer (valbuf
+ len
- 4, 4, byte_order
, tmp
);
433 /* Implement the "return_value" gdbarch method. */
435 static enum return_value_convention
436 ft32_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
437 struct type
*valtype
, struct regcache
*regcache
,
438 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
440 if (TYPE_LENGTH (valtype
) > 8)
441 return RETURN_VALUE_STRUCT_CONVENTION
;
445 ft32_extract_return_value (valtype
, regcache
, readbuf
);
446 if (writebuf
!= NULL
)
447 ft32_store_return_value (valtype
, regcache
, writebuf
);
448 return RETURN_VALUE_REGISTER_CONVENTION
;
452 /* Allocate and initialize a ft32_frame_cache object. */
454 static struct ft32_frame_cache
*
455 ft32_alloc_frame_cache (void)
457 struct ft32_frame_cache
*cache
;
460 cache
= FRAME_OBSTACK_ZALLOC (struct ft32_frame_cache
);
462 for (i
= 0; i
< FT32_NUM_REGS
; ++i
)
463 cache
->saved_regs
[i
] = REG_UNAVAIL
;
468 /* Populate a ft32_frame_cache object for this_frame. */
470 static struct ft32_frame_cache
*
471 ft32_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
473 struct ft32_frame_cache
*cache
;
474 CORE_ADDR current_pc
;
478 return (struct ft32_frame_cache
*) *this_cache
;
480 cache
= ft32_alloc_frame_cache ();
483 cache
->base
= get_frame_register_unsigned (this_frame
, FT32_FP_REGNUM
);
484 if (cache
->base
== 0)
487 cache
->pc
= get_frame_func (this_frame
);
488 current_pc
= get_frame_pc (this_frame
);
491 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
493 ft32_analyze_prologue (cache
->pc
, current_pc
, cache
, gdbarch
);
494 if (!cache
->established
)
495 cache
->base
= get_frame_register_unsigned (this_frame
, FT32_SP_REGNUM
);
498 cache
->saved_sp
= cache
->base
- 4;
500 for (i
= 0; i
< FT32_NUM_REGS
; ++i
)
501 if (cache
->saved_regs
[i
] != REG_UNAVAIL
)
502 cache
->saved_regs
[i
] = cache
->base
+ cache
->saved_regs
[i
];
507 /* Implement the "unwind_pc" gdbarch method. */
510 ft32_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
512 return frame_unwind_register_unsigned (next_frame
, FT32_PC_REGNUM
);
515 /* Given a GDB frame, determine the address of the calling function's
516 frame. This will be used to create a new GDB frame struct. */
519 ft32_frame_this_id (struct frame_info
*this_frame
,
520 void **this_prologue_cache
, struct frame_id
*this_id
)
522 struct ft32_frame_cache
*cache
= ft32_frame_cache (this_frame
,
523 this_prologue_cache
);
525 /* This marks the outermost frame. */
526 if (cache
->base
== 0)
529 *this_id
= frame_id_build (cache
->saved_sp
, cache
->pc
);
532 /* Get the value of register regnum in the previous stack frame. */
534 static struct value
*
535 ft32_frame_prev_register (struct frame_info
*this_frame
,
536 void **this_prologue_cache
, int regnum
)
538 struct ft32_frame_cache
*cache
= ft32_frame_cache (this_frame
,
539 this_prologue_cache
);
541 gdb_assert (regnum
>= 0);
543 if (regnum
== FT32_SP_REGNUM
&& cache
->saved_sp
)
544 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
546 if (regnum
< FT32_NUM_REGS
&& cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
547 return frame_unwind_got_memory (this_frame
, regnum
,
548 RAM_BIAS
| cache
->saved_regs
[regnum
]);
550 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
553 static const struct frame_unwind ft32_frame_unwind
=
556 default_frame_unwind_stop_reason
,
558 ft32_frame_prev_register
,
560 default_frame_sniffer
563 /* Return the base address of this_frame. */
566 ft32_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
568 struct ft32_frame_cache
*cache
= ft32_frame_cache (this_frame
,
574 static const struct frame_base ft32_frame_base
=
577 ft32_frame_base_address
,
578 ft32_frame_base_address
,
579 ft32_frame_base_address
582 static struct frame_id
583 ft32_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
585 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, FT32_SP_REGNUM
);
587 return frame_id_build (sp
, get_frame_pc (this_frame
));
590 /* Allocate and initialize the ft32 gdbarch object. */
592 static struct gdbarch
*
593 ft32_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
595 struct gdbarch
*gdbarch
;
596 struct gdbarch_tdep
*tdep
;
597 struct type
*void_type
;
598 struct type
*func_void_type
;
600 /* If there is already a candidate, use it. */
601 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
603 return arches
->gdbarch
;
605 /* Allocate space for the new architecture. */
606 tdep
= XNEW (struct gdbarch_tdep
);
607 gdbarch
= gdbarch_alloc (&info
, tdep
);
609 /* Create a type for PC. We can't use builtin types here, as they may not
611 void_type
= arch_type (gdbarch
, TYPE_CODE_VOID
, 1, "void");
612 func_void_type
= make_function_type (void_type
, NULL
);
613 tdep
->pc_type
= arch_type (gdbarch
, TYPE_CODE_PTR
, 4, NULL
);
614 TYPE_TARGET_TYPE (tdep
->pc_type
) = func_void_type
;
615 TYPE_UNSIGNED (tdep
->pc_type
) = 1;
616 TYPE_INSTANCE_FLAGS (tdep
->pc_type
) |= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
618 set_gdbarch_read_pc (gdbarch
, ft32_read_pc
);
619 set_gdbarch_write_pc (gdbarch
, ft32_write_pc
);
620 set_gdbarch_unwind_sp (gdbarch
, ft32_unwind_sp
);
622 set_gdbarch_num_regs (gdbarch
, FT32_NUM_REGS
);
623 set_gdbarch_sp_regnum (gdbarch
, FT32_SP_REGNUM
);
624 set_gdbarch_pc_regnum (gdbarch
, FT32_PC_REGNUM
);
625 set_gdbarch_register_name (gdbarch
, ft32_register_name
);
626 set_gdbarch_register_type (gdbarch
, ft32_register_type
);
628 set_gdbarch_return_value (gdbarch
, ft32_return_value
);
630 set_gdbarch_pointer_to_address (gdbarch
, ft32_pointer_to_address
);
632 set_gdbarch_skip_prologue (gdbarch
, ft32_skip_prologue
);
633 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
634 set_gdbarch_breakpoint_from_pc (gdbarch
, ft32_breakpoint_from_pc
);
635 set_gdbarch_frame_align (gdbarch
, ft32_frame_align
);
637 frame_base_set_default (gdbarch
, &ft32_frame_base
);
639 /* Methods for saving / extracting a dummy frame's ID. The ID's
640 stack address must match the SP value returned by
641 PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */
642 set_gdbarch_dummy_id (gdbarch
, ft32_dummy_id
);
644 set_gdbarch_unwind_pc (gdbarch
, ft32_unwind_pc
);
646 set_gdbarch_print_insn (gdbarch
, print_insn_ft32
);
648 /* Hook in ABI-specific overrides, if they have been registered. */
649 gdbarch_init_osabi (info
, gdbarch
);
651 /* Hook in the default unwinders. */
652 frame_unwind_append_unwinder (gdbarch
, &ft32_frame_unwind
);
654 /* Support simple overlay manager. */
655 set_gdbarch_overlay_update (gdbarch
, simple_overlay_update
);
657 set_gdbarch_address_class_type_flags (gdbarch
, ft32_address_class_type_flags
);
658 set_gdbarch_address_class_name_to_type_flags
659 (gdbarch
, ft32_address_class_name_to_type_flags
);
660 set_gdbarch_address_class_type_flags_to_name
661 (gdbarch
, ft32_address_class_type_flags_to_name
);
666 /* Register this machine's init routine. */
669 _initialize_ft32_tdep (void)
671 register_gdbarch_init (bfd_arch_ft32
, ft32_gdbarch_init
);