GDB (xrefs)
Loading...
Searching...
No Matches
ft32-tdep.c
Go to the documentation of this file.
1/* Target-dependent code for FT32.
2
3 Copyright (C) 2009-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21#include "frame.h"
22#include "frame-unwind.h"
23#include "frame-base.h"
24#include "symtab.h"
25#include "gdbtypes.h"
26#include "gdbcmd.h"
27#include "gdbcore.h"
28#include "value.h"
29#include "inferior.h"
30#include "symfile.h"
31#include "objfiles.h"
32#include "osabi.h"
33#include "language.h"
34#include "arch-utils.h"
35#include "regcache.h"
36#include "trad-frame.h"
37#include "dis-asm.h"
38#include "record.h"
39
40#include "opcode/ft32.h"
41
42#include "ft32-tdep.h"
43#include "sim/sim-ft32.h"
44#include <algorithm>
45
46#define RAM_BIAS 0x800000 /* Bias added to RAM addresses. */
47
48/* Use an invalid address -1 as 'not available' marker. */
49enum { REG_UNAVAIL = (CORE_ADDR) (-1) };
50
52{
53 /* Base address of the frame */
54 CORE_ADDR base;
55 /* Function this frame belongs to */
56 CORE_ADDR pc;
57 /* Total size of this frame */
58 LONGEST framesize;
59 /* Saved registers in this frame */
60 CORE_ADDR saved_regs[FT32_NUM_REGS];
61 /* Saved SP in this frame */
62 CORE_ADDR saved_sp;
63 /* Has the new frame been LINKed. */
64 bfd_boolean established;
65};
66
67/* Implement the "frame_align" gdbarch method. */
68
69static CORE_ADDR
70ft32_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
71{
72 /* Align to the size of an instruction (so that they can safely be
73 pushed onto the stack. */
74 return sp & ~1;
75}
76
77
78constexpr gdb_byte ft32_break_insn[] = { 0x02, 0x00, 0x34, 0x00 };
79
80typedef BP_MANIPULATION (ft32_break_insn) ft32_breakpoint;
81
82/* FT32 register names. */
83
84static const char *const ft32_register_names[] =
85{
86 "fp", "sp",
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",
91 "pc"
92};
93
94/* Implement the "register_name" gdbarch method. */
95
96static const char *
97ft32_register_name (struct gdbarch *gdbarch, int reg_nr)
98{
99 gdb_static_assert (ARRAY_SIZE (ft32_register_names) == FT32_NUM_REGS);
100 return ft32_register_names[reg_nr];
101}
102
103/* Implement the "register_type" gdbarch method. */
104
105static struct type *
106ft32_register_type (struct gdbarch *gdbarch, int reg_nr)
107{
108 if (reg_nr == FT32_PC_REGNUM)
109 {
110 ft32_gdbarch_tdep *tdep = gdbarch_tdep<ft32_gdbarch_tdep> (gdbarch);
111 return tdep->pc_type;
112 }
113 else if (reg_nr == FT32_SP_REGNUM || reg_nr == FT32_FP_REGNUM)
115 else
117}
118
119/* Write into appropriate registers a function return value
120 of type TYPE, given in virtual format. */
121
122static void
124 const gdb_byte *valbuf)
125{
126 struct gdbarch *gdbarch = regcache->arch ();
127 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
128 CORE_ADDR regval;
129 int len = type->length ();
130
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);
134 if (len > 4)
135 {
136 regval = extract_unsigned_integer (valbuf + 4,
137 len - 4, byte_order);
138 regcache_cooked_write_unsigned (regcache, FT32_R1_REGNUM, regval);
139 }
140}
141
142/* Fetch a single 32-bit instruction from address a. If memory contains
143 a compressed instruction pair, return the expanded instruction. */
144
145static ULONGEST
146ft32_fetch_instruction (CORE_ADDR a, int *isize,
147 enum bfd_endian byte_order)
148{
149 unsigned int sc[2];
150 ULONGEST inst;
151
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;
155 if (*isize == 2)
156 return sc[1 & (a >> 1)];
157 else
158 return inst;
159}
160
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.
164
165 Returns the address of the first instruction after the prologue. */
166
167static CORE_ADDR
168ft32_analyze_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
169 struct ft32_frame_cache *cache,
170 struct gdbarch *gdbarch)
171{
172 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
173 CORE_ADDR next_addr;
174 ULONGEST inst;
175 int isize = 0;
176 int regnum, pushreg;
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:
183 PUSH $r13
184 PUSH $r14
185 PUSH $r15
186 Note that PROLOGS[0] through PROLOGS[12] are unused. */
187 CORE_ADDR prologs[32];
188
189 cache->saved_regs[FT32_PC_REGNUM] = 0;
190 cache->framesize = 0;
191
192 for (regnum = first_saved_reg; regnum < 32; regnum++)
193 {
194 char prolog_symbol[32];
195
196 snprintf (prolog_symbol, sizeof (prolog_symbol), "__prolog_$r%02d",
197 regnum);
198 msymbol = lookup_minimal_symbol (prolog_symbol, NULL, NULL);
199 if (msymbol.minsym)
200 prologs[regnum] = msymbol.value_address ();
201 else
202 prologs[regnum] = 0;
203 }
204
205 if (start_addr >= end_addr)
206 return end_addr;
207
208 cache->established = 0;
209 for (next_addr = start_addr; next_addr < end_addr; next_addr += isize)
210 {
211 inst = ft32_fetch_instruction (next_addr, &isize, byte_order);
212
213 if (FT32_IS_PUSH (inst))
214 {
215 pushreg = FT32_PUSH_REG (inst);
216 cache->framesize += 4;
217 cache->saved_regs[FT32_R0_REGNUM + pushreg] = cache->framesize;
218 }
219 else if (FT32_IS_CALL (inst))
220 {
221 for (regnum = first_saved_reg; regnum < 32; regnum++)
222 {
223 if ((4 * (inst & 0x3ffff)) == prologs[regnum])
224 {
225 for (pushreg = first_saved_reg; pushreg <= regnum;
226 pushreg++)
227 {
228 cache->framesize += 4;
229 cache->saved_regs[FT32_R0_REGNUM + pushreg] =
230 cache->framesize;
231 }
232 }
233 }
234 break;
235 }
236 else
237 break;
238 }
239 for (regnum = FT32_R0_REGNUM; regnum < FT32_PC_REGNUM; regnum++)
240 {
241 if (cache->saved_regs[regnum] != REG_UNAVAIL)
242 cache->saved_regs[regnum] =
243 cache->framesize - cache->saved_regs[regnum];
244 }
245 cache->saved_regs[FT32_PC_REGNUM] = cache->framesize;
246
247 /* It is a LINK? */
248 if (next_addr < end_addr)
249 {
250 inst = ft32_fetch_instruction (next_addr, &isize, byte_order);
251 if (FT32_IS_LINK (inst))
252 {
253 cache->established = 1;
254 for (regnum = FT32_R0_REGNUM; regnum < FT32_PC_REGNUM; regnum++)
255 {
256 if (cache->saved_regs[regnum] != REG_UNAVAIL)
257 cache->saved_regs[regnum] += 4;
258 }
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);
262 next_addr += isize;
263 }
264 }
265
266 return next_addr;
267}
268
269/* Find the end of function prologue. */
270
271static CORE_ADDR
272ft32_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
273{
274 CORE_ADDR func_addr = 0, func_end = 0;
275 const char *func_name;
276
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
279 is greater. */
280 if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
281 {
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);
286 else
287 {
288 /* Can't determine prologue from the symbol table, need to examine
289 instructions. */
290 struct symtab_and_line sal;
291 struct symbol *sym;
292 struct ft32_frame_cache cache;
293 CORE_ADDR plg_end;
294
295 memset (&cache, 0, sizeof cache);
296
297 plg_end = ft32_analyze_prologue (func_addr,
298 func_end, &cache, gdbarch);
299 /* Found a function. */
300 sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol;
301 /* Don't use line number debug info for assembly source files. */
302 if ((sym != NULL) && sym->language () != language_asm)
303 {
304 sal = find_pc_line (func_addr, 0);
305 if (sal.end && sal.end < func_end)
306 {
307 /* Found a line number, use it as end of prologue. */
308 return sal.end;
309 }
310 }
311 /* No useable line symbol. Use result of prologue parsing method. */
312 return plg_end;
313 }
314 }
315
316 /* No function symbol -- just return the PC. */
317 return pc;
318}
319
320/* Implementation of `pointer_to_address' gdbarch method.
321
322 On FT32 address space zero is RAM, address space 1 is flash.
323 RAM appears at address RAM_BIAS, flash at address 0. */
324
325static CORE_ADDR
327 struct type *type, const gdb_byte *buf)
328{
329 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
330 CORE_ADDR addr
331 = extract_unsigned_integer (buf, type->length (), byte_order);
332
334 return addr;
335 else
336 return addr | RAM_BIAS;
337}
338
339/* Implementation of `address_class_type_flags' gdbarch method.
340
341 This method maps DW_AT_address_class attributes to a
342 type_instance_flag_value. */
343
344static type_instance_flags
345ft32_address_class_type_flags (int byte_size, int dwarf2_addr_class)
346{
347 /* The value 1 of the DW_AT_address_class attribute corresponds to the
348 __flash__ qualifier, meaning pointer to data in FT32 program memory.
349 */
350 if (dwarf2_addr_class == 1)
352 return 0;
353}
354
355/* Implementation of `address_class_type_flags_to_name' gdbarch method.
356
357 Convert a type_instance_flag_value to an address space qualifier. */
358
359static const char*
361 type_instance_flags type_flags)
362{
363 if (type_flags & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
364 return "flash";
365 else
366 return NULL;
367}
368
369/* Implementation of `address_class_name_to_type_flags' gdbarch method.
370
371 Convert an address space qualifier to a type_instance_flag_value. */
372
373static bool
375 const char* name,
376 type_instance_flags *type_flags_ptr)
377{
378 if (strcmp (name, "flash") == 0)
379 {
380 *type_flags_ptr = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
381 return true;
382 }
383 else
384 return false;
385}
386
387/* Given a return value in `regbuf' with a type `valtype',
388 extract and copy its value into `valbuf'. */
389
390static void
392 gdb_byte *dst)
393{
394 struct gdbarch *gdbarch = regcache->arch ();
395 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
396 bfd_byte *valbuf = dst;
397 int len = type->length ();
398 ULONGEST tmp;
399
400 /* By using store_unsigned_integer we avoid having to do
401 anything special for small big-endian values. */
402 regcache_cooked_read_unsigned (regcache, FT32_R0_REGNUM, &tmp);
403 store_unsigned_integer (valbuf, (len > 4 ? len - 4 : len), byte_order, tmp);
404
405 /* Ignore return values more than 8 bytes in size because the ft32
406 returns anything more than 8 bytes in the stack. */
407 if (len > 4)
408 {
409 regcache_cooked_read_unsigned (regcache, FT32_R1_REGNUM, &tmp);
410 store_unsigned_integer (valbuf + len - 4, 4, byte_order, tmp);
411 }
412}
413
414/* Implement the "return_value" gdbarch method. */
415
416static enum return_value_convention
417ft32_return_value (struct gdbarch *gdbarch, struct value *function,
418 struct type *valtype, struct regcache *regcache,
419 gdb_byte *readbuf, const gdb_byte *writebuf)
420{
421 if (valtype->length () > 8)
423 else
424 {
425 if (readbuf != NULL)
426 ft32_extract_return_value (valtype, regcache, readbuf);
427 if (writebuf != NULL)
428 ft32_store_return_value (valtype, regcache, writebuf);
430 }
431}
432
433/* Allocate and initialize a ft32_frame_cache object. */
434
435static struct ft32_frame_cache *
437{
438 struct ft32_frame_cache *cache;
439 int i;
440
441 cache = FRAME_OBSTACK_ZALLOC (struct ft32_frame_cache);
442
443 for (i = 0; i < FT32_NUM_REGS; ++i)
444 cache->saved_regs[i] = REG_UNAVAIL;
445
446 return cache;
447}
448
449/* Populate a ft32_frame_cache object for this_frame. */
450
451static struct ft32_frame_cache *
452ft32_frame_cache (frame_info_ptr this_frame, void **this_cache)
453{
454 struct ft32_frame_cache *cache;
455 CORE_ADDR current_pc;
456 int i;
457
458 if (*this_cache)
459 return (struct ft32_frame_cache *) *this_cache;
460
461 cache = ft32_alloc_frame_cache ();
462 *this_cache = cache;
463
464 cache->base = get_frame_register_unsigned (this_frame, FT32_FP_REGNUM);
465 if (cache->base == 0)
466 return cache;
467
468 cache->pc = get_frame_func (this_frame);
469 current_pc = get_frame_pc (this_frame);
470 if (cache->pc)
471 {
472 struct gdbarch *gdbarch = get_frame_arch (this_frame);
473
474 ft32_analyze_prologue (cache->pc, current_pc, cache, gdbarch);
475 if (!cache->established)
476 cache->base = get_frame_register_unsigned (this_frame, FT32_SP_REGNUM);
477 }
478
479 cache->saved_sp = cache->base - 4;
480
481 for (i = 0; i < FT32_NUM_REGS; ++i)
482 if (cache->saved_regs[i] != REG_UNAVAIL)
483 cache->saved_regs[i] = cache->base + cache->saved_regs[i];
484
485 return cache;
486}
487
488/* Given a GDB frame, determine the address of the calling function's
489 frame. This will be used to create a new GDB frame struct. */
490
491static void
493 void **this_prologue_cache, struct frame_id *this_id)
494{
495 struct ft32_frame_cache *cache = ft32_frame_cache (this_frame,
496 this_prologue_cache);
497
498 /* This marks the outermost frame. */
499 if (cache->base == 0)
500 return;
501
502 *this_id = frame_id_build (cache->saved_sp, cache->pc);
503}
504
505/* Get the value of register regnum in the previous stack frame. */
506
507static struct value *
509 void **this_prologue_cache, int regnum)
510{
511 struct ft32_frame_cache *cache = ft32_frame_cache (this_frame,
512 this_prologue_cache);
513
514 gdb_assert (regnum >= 0);
515
516 if (regnum == FT32_SP_REGNUM && cache->saved_sp)
517 return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
518
519 if (regnum < FT32_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
520 return frame_unwind_got_memory (this_frame, regnum,
521 RAM_BIAS | cache->saved_regs[regnum]);
522
523 return frame_unwind_got_register (this_frame, regnum, regnum);
524}
525
526static const struct frame_unwind ft32_frame_unwind =
527{
528 "ft32 prologue",
533 NULL,
535};
536
537/* Return the base address of this_frame. */
538
539static CORE_ADDR
540ft32_frame_base_address (frame_info_ptr this_frame, void **this_cache)
541{
542 struct ft32_frame_cache *cache = ft32_frame_cache (this_frame,
543 this_cache);
544
545 return cache->base;
546}
547
555
556/* Allocate and initialize the ft32 gdbarch object. */
557
558static struct gdbarch *
560{
561 struct type *void_type;
562 struct type *func_void_type;
563
564 /* If there is already a candidate, use it. */
566 if (arches != NULL)
567 return arches->gdbarch;
568
569 /* Allocate space for the new architecture. */
572 ft32_gdbarch_tdep *tdep = gdbarch_tdep<ft32_gdbarch_tdep> (gdbarch);
573
574 /* Create a type for PC. We can't use builtin types here, as they may not
575 be defined. */
576 type_allocator alloc (gdbarch);
577 void_type = alloc.new_type (TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
578 func_void_type = make_function_type (void_type, NULL);
579 tdep->pc_type = init_pointer_type (alloc, 4 * TARGET_CHAR_BIT, NULL,
580 func_void_type);
583
584 set_gdbarch_num_regs (gdbarch, FT32_NUM_REGS);
585 set_gdbarch_sp_regnum (gdbarch, FT32_SP_REGNUM);
586 set_gdbarch_pc_regnum (gdbarch, FT32_PC_REGNUM);
589
591
593
596 set_gdbarch_breakpoint_kind_from_pc (gdbarch, ft32_breakpoint::kind_from_pc);
597 set_gdbarch_sw_breakpoint_from_kind (gdbarch, ft32_breakpoint::bp_from_kind);
599
601
602 /* Hook in ABI-specific overrides, if they have been registered. */
604
605 /* Hook in the default unwinders. */
607
608 /* Support simple overlay manager. */
610
616
617 return gdbarch;
618}
619
620/* Register this machine's init routine. */
621
623void
int regnum
const char *const name
gdb_static_assert(sizeof(splay_tree_key) >=sizeof(CORE_ADDR *))
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep, gdbarch_supports_arch_info_ftype *supports_arch_info)
static std::vector< const char * > arches
Definition arch-utils.c:685
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
Definition arch-utils.c:177
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
#define BP_MANIPULATION(BREAK_INSN)
Definition arch-utils.h:70
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
Definition blockframe.c:373
gdbarch * arch() const
Definition regcache.c:231
type * new_type()
Definition gdbtypes.c:208
ULONGEST read_code_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition corefile.c:326
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition defs.h:515
@ language_asm
Definition defs.h:221
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:480
return_value_convention
Definition defs.h:257
@ RETURN_VALUE_REGISTER_CONVENTION
Definition defs.h:260
@ RETURN_VALUE_STRUCT_CONVENTION
Definition defs.h:267
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
Definition frame-base.c:93
int default_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
struct value * frame_unwind_got_memory(frame_info_ptr frame, int regnum, CORE_ADDR addr)
struct value * frame_unwind_got_register(frame_info_ptr frame, int regnum, int new_regnum)
enum unwind_stop_reason default_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
struct value * frame_unwind_got_constant(frame_info_ptr frame, int regnum, ULONGEST val)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
Definition frame.c:1399
CORE_ADDR get_frame_pc(frame_info_ptr frame)
Definition frame.c:2712
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition frame.c:736
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:3027
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
Definition frame.c:1098
@ NORMAL_FRAME
Definition frame.h:187
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition frame.h:825
static const struct frame_base ft32_frame_base
Definition ft32-tdep.c:548
static CORE_ADDR ft32_frame_align(struct gdbarch *gdbarch, CORE_ADDR sp)
Definition ft32-tdep.c:70
static void ft32_frame_this_id(frame_info_ptr this_frame, void **this_prologue_cache, struct frame_id *this_id)
Definition ft32-tdep.c:492
static struct ft32_frame_cache * ft32_alloc_frame_cache(void)
Definition ft32-tdep.c:436
static struct gdbarch * ft32_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
Definition ft32-tdep.c:559
void _initialize_ft32_tdep()
Definition ft32-tdep.c:624
static CORE_ADDR ft32_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition ft32-tdep.c:272
static const char * ft32_register_name(struct gdbarch *gdbarch, int reg_nr)
Definition ft32-tdep.c:97
static struct type * ft32_register_type(struct gdbarch *gdbarch, int reg_nr)
Definition ft32-tdep.c:106
static void ft32_extract_return_value(struct type *type, struct regcache *regcache, gdb_byte *dst)
Definition ft32-tdep.c:391
#define RAM_BIAS
Definition ft32-tdep.c:46
static struct value * ft32_frame_prev_register(frame_info_ptr this_frame, void **this_prologue_cache, int regnum)
Definition ft32-tdep.c:508
@ REG_UNAVAIL
Definition ft32-tdep.c:49
static CORE_ADDR ft32_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
Definition ft32-tdep.c:326
static bool ft32_address_class_name_to_type_flags(struct gdbarch *gdbarch, const char *name, type_instance_flags *type_flags_ptr)
Definition ft32-tdep.c:374
constexpr gdb_byte ft32_break_insn[]
Definition ft32-tdep.c:78
static const char * ft32_address_class_type_flags_to_name(struct gdbarch *gdbarch, type_instance_flags type_flags)
Definition ft32-tdep.c:360
static const struct frame_unwind ft32_frame_unwind
Definition ft32-tdep.c:526
static ULONGEST ft32_fetch_instruction(CORE_ADDR a, int *isize, enum bfd_endian byte_order)
Definition ft32-tdep.c:146
static void ft32_store_return_value(struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
Definition ft32-tdep.c:123
static CORE_ADDR ft32_frame_base_address(frame_info_ptr this_frame, void **this_cache)
Definition ft32-tdep.c:540
static enum return_value_convention ft32_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition ft32-tdep.c:417
static CORE_ADDR ft32_analyze_prologue(CORE_ADDR start_addr, CORE_ADDR end_addr, struct ft32_frame_cache *cache, struct gdbarch *gdbarch)
Definition ft32-tdep.c:168
static type_instance_flags ft32_address_class_type_flags(int byte_size, int dwarf2_addr_class)
Definition ft32-tdep.c:345
static struct ft32_frame_cache * ft32_frame_cache(frame_info_ptr this_frame, void **this_cache)
Definition ft32-tdep.c:452
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
void set_gdbarch_breakpoint_kind_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_pc_ftype *breakpoint_kind_from_pc)
void set_gdbarch_frame_align(struct gdbarch *gdbarch, gdbarch_frame_align_ftype *frame_align)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue)
void set_gdbarch_address_class_type_flags_to_name(struct gdbarch *gdbarch, gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name)
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name)
void set_gdbarch_overlay_update(struct gdbarch *gdbarch, gdbarch_overlay_update_ftype *overlay_update)
void set_gdbarch_address_class_type_flags(struct gdbarch *gdbarch, gdbarch_address_class_type_flags_ftype *address_class_type_flags)
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value)
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than)
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
Definition gdbarch.c:2047
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
Definition gdbarch.c:2064
void set_gdbarch_address_class_name_to_type_flags(struct gdbarch *gdbarch, gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags)
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type)
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition gdbarch.c:1941
void set_gdbarch_sw_breakpoint_from_kind(struct gdbarch *gdbarch, gdbarch_sw_breakpoint_from_kind_ftype *sw_breakpoint_from_kind)
void set_gdbarch_pointer_to_address(struct gdbarch *gdbarch, gdbarch_pointer_to_address_ftype *pointer_to_address)
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, gdbarch_tdep_up tdep)
Definition gdbarch.c:266
std::unique_ptr< gdbarch_tdep_base > gdbarch_tdep_up
Definition gdbarch.h:73
struct type * init_pointer_type(type_allocator &alloc, int bit, const char *name, struct type *target_type)
Definition gdbtypes.c:3485
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition gdbtypes.c:6168
struct type * make_function_type(struct type *type, struct type **typeptr)
Definition gdbtypes.c:537
@ TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
Definition gdbtypes.h:100
#define TYPE_ADDRESS_CLASS_1(t)
Definition gdbtypes.h:186
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition minsyms.c:363
info(Component c)
Definition gdbarch.py:41
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition osabi.c:382
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition regcache.c:796
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition regcache.c:825
struct symbol * symbol
Definition symtab.h:1533
CORE_ADDR value_address() const
Definition minsyms.h:41
struct minimal_symbol * minsym
Definition minsyms.h:49
struct type * builtin_data_ptr
Definition gdbtypes.h:2135
struct type * builtin_int32
Definition gdbtypes.h:2119
CORE_ADDR base
Definition ft32-tdep.c:54
CORE_ADDR saved_regs[FT32_NUM_REGS]
Definition ft32-tdep.c:60
LONGEST framesize
Definition ft32-tdep.c:58
CORE_ADDR pc
Definition ft32-tdep.c:56
CORE_ADDR saved_sp
Definition ft32-tdep.c:62
bfd_boolean established
Definition ft32-tdep.c:64
struct type * pc_type
Definition ft32-tdep.h:28
enum language language() const
Definition symtab.h:502
CORE_ADDR end
Definition symtab.h:2338
ULONGEST length() const
Definition gdbtypes.h:983
void set_instance_flags(type_instance_flags flags)
Definition gdbtypes.h:1059
const type_instance_flags instance_flags() const
Definition gdbtypes.h:1053
Definition value.h:130
void simple_overlay_update(struct obj_section *osect)
Definition symfile.c:3542
struct block_symbol lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition symtab.c:1964
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
Definition symtab.c:3963
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition symtab.c:3295
@ VAR_DOMAIN
Definition symtab.h:910