1 /* Target-dependent code for FT32.
3 Copyright (C) 2009-2015 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 "gdb_assert.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 builtin_type (gdbarch
)->builtin_func_ptr
;
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. */
158 #define IS_PUSH(inst) (((inst) & 0xfff00000) == 0x84000000)
159 #define PUSH_REG(inst) (FT32_R0_REGNUM + (((inst) >> 15) & 0x1f))
160 #define IS_LINK(inst) (((inst) & 0xffff0000) == 0x95d00000)
161 #define LINK_SIZE(inst) ((inst) & 0xffff)
164 ft32_analyze_prologue (CORE_ADDR start_addr
, CORE_ADDR end_addr
,
165 struct ft32_frame_cache
*cache
,
166 struct gdbarch
*gdbarch
)
168 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
170 ULONGEST inst
, inst2
;
174 cache
->saved_regs
[FT32_PC_REGNUM
] = 0;
175 cache
->framesize
= 0;
177 if (start_addr
>= end_addr
)
180 cache
->established
= 0;
181 for (next_addr
= start_addr
; next_addr
< end_addr
; )
183 inst
= read_memory_unsigned_integer (next_addr
, 4, byte_order
);
187 regnum
= PUSH_REG (inst
);
188 cache
->framesize
+= 4;
189 cache
->saved_regs
[regnum
] = cache
->framesize
;
195 for (regnum
= FT32_R0_REGNUM
; regnum
< FT32_PC_REGNUM
; regnum
++)
197 if (cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
198 cache
->saved_regs
[regnum
] = cache
->framesize
- cache
->saved_regs
[regnum
];
200 cache
->saved_regs
[FT32_PC_REGNUM
] = cache
->framesize
;
203 if (next_addr
< end_addr
)
205 inst
= read_memory_unsigned_integer (next_addr
, 4, byte_order
);
208 cache
->established
= 1;
209 for (regnum
= FT32_R0_REGNUM
; regnum
< FT32_PC_REGNUM
; regnum
++)
211 if (cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
212 cache
->saved_regs
[regnum
] += 4;
214 cache
->saved_regs
[FT32_PC_REGNUM
] = cache
->framesize
+ 4;
215 cache
->saved_regs
[FT32_FP_REGNUM
] = 0;
216 cache
->framesize
+= LINK_SIZE (inst
);
224 /* Find the end of function prologue. */
227 ft32_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
229 CORE_ADDR func_addr
= 0, func_end
= 0;
230 const char *func_name
;
232 /* See if we can determine the end of the prologue via the symbol table.
233 If so, then return either PC, or the PC after the prologue, whichever
235 if (find_pc_partial_function (pc
, &func_name
, &func_addr
, &func_end
))
237 CORE_ADDR post_prologue_pc
238 = skip_prologue_using_sal (gdbarch
, func_addr
);
239 if (post_prologue_pc
!= 0)
240 return max (pc
, post_prologue_pc
);
243 /* Can't determine prologue from the symbol table, need to examine
245 struct symtab_and_line sal
;
247 struct ft32_frame_cache cache
;
250 memset (&cache
, 0, sizeof cache
);
252 plg_end
= ft32_analyze_prologue (func_addr
,
253 func_end
, &cache
, gdbarch
);
254 /* Found a function. */
255 sym
= lookup_symbol (func_name
, NULL
, VAR_DOMAIN
, NULL
);
256 /* Don't use line number debug info for assembly source files. */
257 if ((sym
!= NULL
) && SYMBOL_LANGUAGE (sym
) != language_asm
)
259 sal
= find_pc_line (func_addr
, 0);
260 if (sal
.end
&& sal
.end
< func_end
)
262 /* Found a line number, use it as end of prologue. */
266 /* No useable line symbol. Use result of prologue parsing method. */
271 /* No function symbol -- just return the PC. */
275 /* Implement the "read_pc" gdbarch method. */
278 ft32_read_pc (struct regcache
*regcache
)
282 regcache_cooked_read_unsigned (regcache
, FT32_PC_REGNUM
, &pc
);
286 /* Implement the "write_pc" gdbarch method. */
289 ft32_write_pc (struct regcache
*regcache
, CORE_ADDR val
)
291 regcache_cooked_write_unsigned (regcache
, FT32_PC_REGNUM
, val
);
294 /* Implement the "unwind_sp" gdbarch method. */
297 ft32_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
299 return frame_unwind_register_unsigned (next_frame
, FT32_SP_REGNUM
);
302 /* Given a return value in `regbuf' with a type `valtype',
303 extract and copy its value into `valbuf'. */
306 ft32_extract_return_value (struct type
*type
, struct regcache
*regcache
,
309 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
310 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
311 bfd_byte
*valbuf
= dst
;
312 int len
= TYPE_LENGTH (type
);
315 /* By using store_unsigned_integer we avoid having to do
316 anything special for small big-endian values. */
317 regcache_cooked_read_unsigned (regcache
, FT32_R0_REGNUM
, &tmp
);
318 store_unsigned_integer (valbuf
, (len
> 4 ? len
- 4 : len
), byte_order
, tmp
);
320 /* Ignore return values more than 8 bytes in size because the ft32
321 returns anything more than 8 bytes in the stack. */
324 regcache_cooked_read_unsigned (regcache
, FT32_R1_REGNUM
, &tmp
);
325 store_unsigned_integer (valbuf
+ len
- 4, 4, byte_order
, tmp
);
329 /* Implement the "return_value" gdbarch method. */
331 static enum return_value_convention
332 ft32_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
333 struct type
*valtype
, struct regcache
*regcache
,
334 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
336 if (TYPE_LENGTH (valtype
) > 8)
337 return RETURN_VALUE_STRUCT_CONVENTION
;
341 ft32_extract_return_value (valtype
, regcache
, readbuf
);
342 if (writebuf
!= NULL
)
343 ft32_store_return_value (valtype
, regcache
, writebuf
);
344 return RETURN_VALUE_REGISTER_CONVENTION
;
348 /* Allocate and initialize a ft32_frame_cache object. */
350 static struct ft32_frame_cache
*
351 ft32_alloc_frame_cache (void)
353 struct ft32_frame_cache
*cache
;
356 cache
= FRAME_OBSTACK_ZALLOC (struct ft32_frame_cache
);
358 for (i
= 0; i
< FT32_NUM_REGS
; ++i
)
359 cache
->saved_regs
[i
] = REG_UNAVAIL
;
364 /* Populate a ft32_frame_cache object for this_frame. */
366 static struct ft32_frame_cache
*
367 ft32_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
369 struct ft32_frame_cache
*cache
;
370 CORE_ADDR current_pc
;
376 cache
= ft32_alloc_frame_cache ();
379 cache
->base
= get_frame_register_unsigned (this_frame
, FT32_FP_REGNUM
);
380 if (cache
->base
== 0)
383 cache
->pc
= get_frame_func (this_frame
);
384 current_pc
= get_frame_pc (this_frame
);
387 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
389 ft32_analyze_prologue (cache
->pc
, current_pc
, cache
, gdbarch
);
390 if (!cache
->established
)
391 cache
->base
= get_frame_register_unsigned (this_frame
, FT32_SP_REGNUM
);
394 cache
->saved_sp
= cache
->base
- 4;
396 for (i
= 0; i
< FT32_NUM_REGS
; ++i
)
397 if (cache
->saved_regs
[i
] != REG_UNAVAIL
)
398 cache
->saved_regs
[i
] = cache
->base
+ cache
->saved_regs
[i
];
403 /* Implement the "unwind_pc" gdbarch method. */
406 ft32_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
408 return frame_unwind_register_unsigned (next_frame
, FT32_PC_REGNUM
);
411 /* Given a GDB frame, determine the address of the calling function's
412 frame. This will be used to create a new GDB frame struct. */
415 ft32_frame_this_id (struct frame_info
*this_frame
,
416 void **this_prologue_cache
, struct frame_id
*this_id
)
418 struct ft32_frame_cache
*cache
= ft32_frame_cache (this_frame
,
419 this_prologue_cache
);
421 /* This marks the outermost frame. */
422 if (cache
->base
== 0)
425 *this_id
= frame_id_build (cache
->saved_sp
, cache
->pc
);
428 /* Get the value of register regnum in the previous stack frame. */
430 static struct value
*
431 ft32_frame_prev_register (struct frame_info
*this_frame
,
432 void **this_prologue_cache
, int regnum
)
434 struct ft32_frame_cache
*cache
= ft32_frame_cache (this_frame
,
435 this_prologue_cache
);
437 gdb_assert (regnum
>= 0);
439 if (regnum
== FT32_SP_REGNUM
&& cache
->saved_sp
)
440 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
442 if (regnum
< FT32_NUM_REGS
&& cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
443 return frame_unwind_got_memory (this_frame
, regnum
,
444 RAM_BIAS
| cache
->saved_regs
[regnum
]);
446 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
449 static const struct frame_unwind ft32_frame_unwind
=
452 default_frame_unwind_stop_reason
,
454 ft32_frame_prev_register
,
456 default_frame_sniffer
459 /* Return the base address of this_frame. */
462 ft32_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
464 struct ft32_frame_cache
*cache
= ft32_frame_cache (this_frame
,
470 static const struct frame_base ft32_frame_base
=
473 ft32_frame_base_address
,
474 ft32_frame_base_address
,
475 ft32_frame_base_address
478 static struct frame_id
479 ft32_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
481 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, FT32_SP_REGNUM
);
483 return frame_id_build (sp
, get_frame_pc (this_frame
));
486 /* Allocate and initialize the ft32 gdbarch object. */
488 static struct gdbarch
*
489 ft32_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
491 struct gdbarch
*gdbarch
;
492 struct gdbarch_tdep
*tdep
;
494 /* If there is already a candidate, use it. */
495 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
497 return arches
->gdbarch
;
499 /* Allocate space for the new architecture. */
500 tdep
= XNEW (struct gdbarch_tdep
);
501 gdbarch
= gdbarch_alloc (&info
, tdep
);
503 set_gdbarch_read_pc (gdbarch
, ft32_read_pc
);
504 set_gdbarch_write_pc (gdbarch
, ft32_write_pc
);
505 set_gdbarch_unwind_sp (gdbarch
, ft32_unwind_sp
);
507 set_gdbarch_num_regs (gdbarch
, FT32_NUM_REGS
);
508 set_gdbarch_sp_regnum (gdbarch
, FT32_SP_REGNUM
);
509 set_gdbarch_pc_regnum (gdbarch
, FT32_PC_REGNUM
);
510 set_gdbarch_register_name (gdbarch
, ft32_register_name
);
511 set_gdbarch_register_type (gdbarch
, ft32_register_type
);
513 set_gdbarch_return_value (gdbarch
, ft32_return_value
);
515 set_gdbarch_skip_prologue (gdbarch
, ft32_skip_prologue
);
516 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
517 set_gdbarch_breakpoint_from_pc (gdbarch
, ft32_breakpoint_from_pc
);
518 set_gdbarch_frame_align (gdbarch
, ft32_frame_align
);
520 frame_base_set_default (gdbarch
, &ft32_frame_base
);
522 /* Methods for saving / extracting a dummy frame's ID. The ID's
523 stack address must match the SP value returned by
524 PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */
525 set_gdbarch_dummy_id (gdbarch
, ft32_dummy_id
);
527 set_gdbarch_unwind_pc (gdbarch
, ft32_unwind_pc
);
529 set_gdbarch_print_insn (gdbarch
, print_insn_ft32
);
531 /* Hook in ABI-specific overrides, if they have been registered. */
532 gdbarch_init_osabi (info
, gdbarch
);
534 /* Hook in the default unwinders. */
535 frame_unwind_append_unwinder (gdbarch
, &ft32_frame_unwind
);
537 /* Support simple overlay manager. */
538 set_gdbarch_overlay_update (gdbarch
, simple_overlay_update
);
543 /* Register this machine's init routine. */
546 _initialize_ft32_tdep (void)
548 register_gdbarch_init (bfd_arch_ft32
, ft32_gdbarch_init
);