GDB (xrefs)
Loading...
Searching...
No Matches
/tmp/gdb-13.1/gdb/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 "gdb/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
548static const struct frame_base ft32_frame_base =
549{
554};
555
556/* Allocate and initialize the ft32 gdbarch object. */
557
558static struct gdbarch *
560{
561 struct gdbarch *gdbarch;
562 struct type *void_type;
563 struct type *func_void_type;
564
565 /* If there is already a candidate, use it. */
567 if (arches != NULL)
568 return arches->gdbarch;
569
570 /* Allocate space for the new architecture. */
572 gdbarch = gdbarch_alloc (&info, tdep);
573
574 /* Create a type for PC. We can't use builtin types here, as they may not
575 be defined. */
576 void_type = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
577 func_void_type = make_function_type (void_type, NULL);
578 tdep->pc_type = arch_pointer_type (gdbarch, 4 * TARGET_CHAR_BIT, NULL,
579 func_void_type);
582
583 set_gdbarch_num_regs (gdbarch, FT32_NUM_REGS);
584 set_gdbarch_sp_regnum (gdbarch, FT32_SP_REGNUM);
585 set_gdbarch_pc_regnum (gdbarch, FT32_PC_REGNUM);
588
590
592
595 set_gdbarch_breakpoint_kind_from_pc (gdbarch, ft32_breakpoint::kind_from_pc);
596 set_gdbarch_sw_breakpoint_from_kind (gdbarch, ft32_breakpoint::bp_from_kind);
598
600
601 /* Hook in ABI-specific overrides, if they have been registered. */
603
604 /* Hook in the default unwinders. */
606
607 /* Support simple overlay manager. */
609
615
616 return gdbarch;
617}
618
619/* Register this machine's init routine. */
620
622void
624{
625 gdbarch_register (bfd_arch_ft32, ft32_gdbarch_init);
626}
int regnum
Definition: aarch64-tdep.c:68
const char *const name
Definition: aarch64-tdep.c:67
gdb_static_assert(sizeof(splay_tree_key) >=sizeof(CORE_ADDR *))
static std::vector< const char * > arches
Definition: arch-utils.c:685
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep)
Definition: arch-utils.c:1256
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)
Definition: arch-utils.c:1298
#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:230
ULONGEST read_code_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:325
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition: defs.h:561
@ 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:526
return_value_convention
Definition: defs.h:258
@ RETURN_VALUE_REGISTER_CONVENTION
Definition: defs.h:261
@ RETURN_VALUE_STRUCT_CONVENTION
Definition: defs.h:268
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)
Definition: frame-unwind.c:217
struct value * frame_unwind_got_memory(frame_info_ptr frame, int regnum, CORE_ADDR addr)
Definition: frame-unwind.c:286
struct value * frame_unwind_got_register(frame_info_ptr frame, int regnum, int new_regnum)
Definition: frame-unwind.c:276
enum unwind_stop_reason default_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
Definition: frame-unwind.c:227
struct value * frame_unwind_got_constant(frame_info_ptr frame, int regnum, ULONGEST val)
Definition: frame-unwind.c:299
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:107
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
Definition: frame.c:1351
CORE_ADDR get_frame_pc(frame_info_ptr frame)
Definition: frame.c:2592
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:713
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition: frame.c:2907
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
Definition: frame.c:1050
@ NORMAL_FRAME
Definition: frame.h:179
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:608
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:623
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
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
@ REG_UNAVAIL
Definition: ft32-tdep.c:49
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
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1370
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:2016
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
Definition: gdbarch.c:2033
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:1910
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, struct gdbarch_tdep_base *tdep)
Definition: gdbarch.c:264
struct type * arch_pointer_type(struct gdbarch *gdbarch, int bit, const char *name, struct type *target_type)
Definition: gdbtypes.c:5920
struct type * arch_type(struct gdbarch *gdbarch, enum type_code code, int bit, const char *name)
Definition: gdbtypes.c:5815
struct type * make_function_type(struct type *type, struct type **typeptr)
Definition: gdbtypes.c:509
@ TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
Definition: gdbtypes.h:117
#define TYPE_ADDRESS_CLASS_1(t)
Definition: gdbtypes.h:203
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:363
def info(c)
Definition: gdbarch.py:184
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:790
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition: regcache.c:819
struct symbol * symbol
Definition: symtab.h:1494
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:2303
struct type * builtin_int32
Definition: gdbtypes.h:2287
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:501
CORE_ADDR end
Definition: symtab.h:2273
Definition: gdbtypes.h:922
ULONGEST length() const
Definition: gdbtypes.h:954
void set_instance_flags(type_instance_flags flags)
Definition: gdbtypes.h:1022
const type_instance_flags instance_flags() const
Definition: gdbtypes.h:1016
Definition: value.c:181
void simple_overlay_update(struct obj_section *osect)
Definition: symfile.c:3508
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:1967
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
Definition: symtab.c:3956
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3297
@ VAR_DOMAIN
Definition: symtab.h:881