GDB (xrefs)

/tmp/gdb-8.1/gdb/frv-tdep.c
Go to the documentation of this file.
1 /* Target-dependent code for the Fujitsu FR-V, for GDB, the GNU Debugger.
2
3 Copyright (C) 2002-2018 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 "inferior.h"
22 #include "gdbcore.h"
23 #include "arch-utils.h"
24 #include "regcache.h"
25 #include "frame.h"
26 #include "frame-unwind.h"
27 #include "frame-base.h"
28 #include "trad-frame.h"
29 #include "dis-asm.h"
30 #include "sim-regno.h"
31 #include "gdb/sim-frv.h"
32 #include "opcodes/frv-desc.h" /* for the H_SPR_... enums */
33 #include "symtab.h"
34 #include "elf-bfd.h"
35 #include "elf/frv.h"
36 #include "osabi.h"
37 #include "infcall.h"
38 #include "solib.h"
39 #include "frv-tdep.h"
40 #include "objfiles.h"
41
42 struct frv_unwind_cache /* was struct frame_extra_info */
43 {
44 /* The previous frame's inner-most stack address. Used as this
45 frame ID's stack_addr. */
46 CORE_ADDR prev_sp;
47
48 /* The frame's base, optionally used by the high-level debug info. */
49 CORE_ADDR base;
50
51 /* Table indicating the location of each and every register. */
52 struct trad_frame_saved_reg *saved_regs;
53 };
54
55 /* A structure describing a particular variant of the FRV.
56 We allocate and initialize one of these structures when we create
57 the gdbarch object for a variant.
58
59 At the moment, all the FR variants we support differ only in which
60 registers are present; the portable code of GDB knows that
61 registers whose names are the empty string don't exist, so the
62 `register_names' array captures all the per-variant information we
63 need.
64
65 in the future, if we need to have per-variant maps for raw size,
66 virtual type, etc., we should replace register_names with an array
67 of structures, each of which gives all the necessary info for one
68 register. Don't stick parallel arrays in here --- that's so
69 Fortran. */
70 struct gdbarch_tdep
71 {
72 /* Which ABI is in use? */
73 enum frv_abi frv_abi;
74
75 /* How many general-purpose registers does this variant have? */
76 int num_gprs;
77
78 /* How many floating-point registers does this variant have? */
79 int num_fprs;
80
81 /* How many hardware watchpoints can it support? */
82 int num_hw_watchpoints;
83
84 /* How many hardware breakpoints can it support? */
85 int num_hw_breakpoints;
86
87 /* Register names. */
88 const char **register_names;
89 };
90
91 /* Return the FR-V ABI associated with GDBARCH. */
92 enum frv_abi
93 frv_abi (struct gdbarch *gdbarch)
94 {
95 return gdbarch_tdep (gdbarch)->frv_abi;
96 }
97
98 /* Fetch the interpreter and executable loadmap addresses (for shared
99 library support) for the FDPIC ABI. Return 0 if successful, -1 if
100 not. (E.g, -1 will be returned if the ABI isn't the FDPIC ABI.) */
101 int
102 frv_fdpic_loadmap_addresses (struct gdbarch *gdbarch, CORE_ADDR *interp_addr,
103 CORE_ADDR *exec_addr)
104 {
105 if (frv_abi (gdbarch) != FRV_ABI_FDPIC)
106 return -1;
107 else
108 {
109 struct regcache *regcache = get_current_regcache ();
110
111 if (interp_addr != NULL)
112 {
113 ULONGEST val;
114 regcache_cooked_read_unsigned (regcache,
115 fdpic_loadmap_interp_regnum, &val);
116 *interp_addr = val;
117 }
118 if (exec_addr != NULL)
119 {
120 ULONGEST val;
121 regcache_cooked_read_unsigned (regcache,
122 fdpic_loadmap_exec_regnum, &val);
123 *exec_addr = val;
124 }
125 return 0;
126 }
127 }
128
129 /* Allocate a new variant structure, and set up default values for all
130 the fields. */
131 static struct gdbarch_tdep *
132 new_variant (void)
133 {
134 struct gdbarch_tdep *var;
135 int r;
136
137 var = XCNEW (struct gdbarch_tdep);
138
139 var->frv_abi = FRV_ABI_EABI;
140 var->num_gprs = 64;
141 var->num_fprs = 64;
142 var->num_hw_watchpoints = 0;
143 var->num_hw_breakpoints = 0;
144
145 /* By default, don't supply any general-purpose or floating-point
146 register names. */
147 var->register_names
148 = (const char **) xmalloc ((frv_num_regs + frv_num_pseudo_regs)
149 * sizeof (const char *));
150 for (r = 0; r < frv_num_regs + frv_num_pseudo_regs; r++)
151 var->register_names[r] = "";
152
153 /* Do, however, supply default names for the known special-purpose
154 registers. */
155
156 var->register_names[pc_regnum] = "pc";
157 var->register_names[lr_regnum] = "lr";
158 var->register_names[lcr_regnum] = "lcr";
159
160 var->register_names[psr_regnum] = "psr";
161 var->register_names[ccr_regnum] = "ccr";
162 var->register_names[cccr_regnum] = "cccr";
163 var->register_names[tbr_regnum] = "tbr";
164
165 /* Debug registers. */
166 var->register_names[brr_regnum] = "brr";
167 var->register_names[dbar0_regnum] = "dbar0";
168 var->register_names[dbar1_regnum] = "dbar1";
169 var->register_names[dbar2_regnum] = "dbar2";
170 var->register_names[dbar3_regnum] = "dbar3";
171
172 /* iacc0 (Only found on MB93405.) */
173 var->register_names[iacc0h_regnum] = "iacc0h";
174 var->register_names[iacc0l_regnum] = "iacc0l";
175 var->register_names[iacc0_regnum] = "iacc0";
176
177 /* fsr0 (Found on FR555 and FR501.) */
178 var->register_names[fsr0_regnum] = "fsr0";
179
180 /* acc0 - acc7. The architecture provides for the possibility of many
181 more (up to 64 total), but we don't want to make that big of a hole
182 in the G packet. If we need more in the future, we'll add them
183 elsewhere. */
184 for (r = acc0_regnum; r <= acc7_regnum; r++)
185 {
186 char *buf;
187 buf = xstrprintf ("acc%d", r - acc0_regnum);
188 var->register_names[r] = buf;
189 }
190
191 /* accg0 - accg7: These are one byte registers. The remote protocol
192 provides the raw values packed four into a slot. accg0123 and
193 accg4567 correspond to accg0 - accg3 and accg4-accg7 respectively.
194 We don't provide names for accg0123 and accg4567 since the user will
195 likely not want to see these raw values. */
196
197 for (r = accg0_regnum; r <= accg7_regnum; r++)
198 {
199 char *buf;
200 buf = xstrprintf ("accg%d", r - accg0_regnum);
201 var->register_names[r] = buf;
202 }
203
204 /* msr0 and msr1. */
205
206 var->register_names[msr0_regnum] = "msr0";
207 var->register_names[msr1_regnum] = "msr1";
208
209 /* gner and fner registers. */
210 var->register_names[gner0_regnum] = "gner0";
211 var->register_names[gner1_regnum] = "gner1";
212 var->register_names[fner0_regnum] = "fner0";
213 var->register_names[fner1_regnum] = "fner1";
214
215 return var;
216 }
217
218
219 /* Indicate that the variant VAR has NUM_GPRS general-purpose
220 registers, and fill in the names array appropriately. */
221 static void
222 set_variant_num_gprs (struct gdbarch_tdep *var, int num_gprs)
223 {
224 int r;
225
226 var->num_gprs = num_gprs;
227
228 for (r = 0; r < num_gprs; ++r)
229 {
230 char buf[20];
231
232 xsnprintf (buf, sizeof (buf), "gr%d", r);
233 var->register_names[first_gpr_regnum + r] = xstrdup (buf);
234 }
235 }
236
237
238 /* Indicate that the variant VAR has NUM_FPRS floating-point
239 registers, and fill in the names array appropriately. */
240 static void
241 set_variant_num_fprs (struct gdbarch_tdep *var, int num_fprs)
242 {
243 int r;
244
245 var->num_fprs = num_fprs;
246
247 for (r = 0; r < num_fprs; ++r)
248 {
249 char buf[20];
250
251 xsnprintf (buf, sizeof (buf), "fr%d", r);
252 var->register_names[first_fpr_regnum + r] = xstrdup (buf);
253 }
254 }
255
256 static void
257 set_variant_abi_fdpic (struct gdbarch_tdep *var)
258 {
259 var->frv_abi = FRV_ABI_FDPIC;
260 var->register_names[fdpic_loadmap_exec_regnum] = xstrdup ("loadmap_exec");
261 var->register_names[fdpic_loadmap_interp_regnum]
262 = xstrdup ("loadmap_interp");
263 }
264
265 static void
266 set_variant_scratch_registers (struct gdbarch_tdep *var)
267 {
268 var->register_names[scr0_regnum] = xstrdup ("scr0");
269 var->register_names[scr1_regnum] = xstrdup ("scr1");
270 var->register_names[scr2_regnum] = xstrdup ("scr2");
271 var->register_names[scr3_regnum] = xstrdup ("scr3");
272 }
273
274 static const char *
275 frv_register_name (struct gdbarch *gdbarch, int reg)
276 {
277 if (reg < 0)
278 return "?toosmall?";
279 if (reg >= frv_num_regs + frv_num_pseudo_regs)
280 return "?toolarge?";
281
282 return gdbarch_tdep (gdbarch)->register_names[reg];
283 }
284
285
286 static struct type *
287 frv_register_type (struct gdbarch *gdbarch, int reg)
288 {
289 if (reg >= first_fpr_regnum && reg <= last_fpr_regnum)
290 return builtin_type (gdbarch)->builtin_float;
291 else if (reg == iacc0_regnum)
292 return builtin_type (gdbarch)->builtin_int64;
293 else
294 return builtin_type (gdbarch)->builtin_int32;
295 }
296
297 static enum register_status
298 frv_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
299 int reg, gdb_byte *buffer)
300 {
301 enum register_status status;
302
303 if (reg == iacc0_regnum)
304 {
305 status = regcache_raw_read (regcache, iacc0h_regnum, buffer);
306 if (status == REG_VALID)
307 status = regcache_raw_read (regcache, iacc0l_regnum, (bfd_byte *) buffer + 4);
308 }
309 else if (accg0_regnum <= reg && reg <= accg7_regnum)
310 {
311 /* The accg raw registers have four values in each slot with the
312 lowest register number occupying the first byte. */
313
314 int raw_regnum = accg0123_regnum + (reg - accg0_regnum) / 4;
315 int byte_num = (reg - accg0_regnum) % 4;
316 gdb_byte buf[4];
317
318 status = regcache_raw_read (regcache, raw_regnum, buf);
319 if (status == REG_VALID)
320 {
321 memset (buffer, 0, 4);
322 /* FR-V is big endian, so put the requested byte in the
323 first byte of the buffer allocated to hold the
324 pseudo-register. */
325 buffer[0] = buf[byte_num];
326 }
327 }
328 else
329 gdb_assert_not_reached ("invalid pseudo register number");
330
331 return status;
332 }
333
334 static void
335 frv_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
336 int reg, const gdb_byte *buffer)
337 {
338 if (reg == iacc0_regnum)
339 {
340 regcache_raw_write (regcache, iacc0h_regnum, buffer);
341 regcache_raw_write (regcache, iacc0l_regnum, (bfd_byte *) buffer + 4);
342 }
343 else if (accg0_regnum <= reg && reg <= accg7_regnum)
344 {
345 /* The accg raw registers have four values in each slot with the
346 lowest register number occupying the first byte. */
347
348 int raw_regnum = accg0123_regnum + (reg - accg0_regnum) / 4;
349 int byte_num = (reg - accg0_regnum) % 4;
350 gdb_byte buf[4];
351
352 regcache_raw_read (regcache, raw_regnum, buf);
353 buf[byte_num] = ((bfd_byte *) buffer)[0];
354 regcache_raw_write (regcache, raw_regnum, buf);
355 }
356 }
357
358 static int
359 frv_register_sim_regno (struct gdbarch *gdbarch, int reg)
360 {
361 static const int spr_map[] =
362 {
363 H_SPR_PSR, /* psr_regnum */
364 H_SPR_CCR, /* ccr_regnum */
365 H_SPR_CCCR, /* cccr_regnum */
366 -1, /* fdpic_loadmap_exec_regnum */
367 -1, /* fdpic_loadmap_interp_regnum */
368 -1, /* 134 */
369 H_SPR_TBR, /* tbr_regnum */
370 H_SPR_BRR, /* brr_regnum */
371 H_SPR_DBAR0, /* dbar0_regnum */
372 H_SPR_DBAR1, /* dbar1_regnum */
373 H_SPR_DBAR2, /* dbar2_regnum */
374 H_SPR_DBAR3, /* dbar3_regnum */
375 H_SPR_SCR0, /* scr0_regnum */
376 H_SPR_SCR1, /* scr1_regnum */
377 H_SPR_SCR2, /* scr2_regnum */
378 H_SPR_SCR3, /* scr3_regnum */
379 H_SPR_LR, /* lr_regnum */
380 H_SPR_LCR, /* lcr_regnum */
381 H_SPR_IACC0H, /* iacc0h_regnum */
382 H_SPR_IACC0L, /* iacc0l_regnum */
383 H_SPR_FSR0, /* fsr0_regnum */
384 /* FIXME: Add infrastructure for fetching/setting ACC and ACCG regs. */
385 -1, /* acc0_regnum */
386 -1, /* acc1_regnum */
387 -1, /* acc2_regnum */
388 -1, /* acc3_regnum */
389 -1, /* acc4_regnum */
390 -1, /* acc5_regnum */
391 -1, /* acc6_regnum */
392 -1, /* acc7_regnum */
393 -1, /* acc0123_regnum */
394 -1, /* acc4567_regnum */
395 H_SPR_MSR0, /* msr0_regnum */
396 H_SPR_MSR1, /* msr1_regnum */
397 H_SPR_GNER0, /* gner0_regnum */
398 H_SPR_GNER1, /* gner1_regnum */
399 H_SPR_FNER0, /* fner0_regnum */
400 H_SPR_FNER1, /* fner1_regnum */
401 };
402
403 gdb_assert (reg >= 0 && reg < gdbarch_num_regs (gdbarch));
404
405 if (first_gpr_regnum <= reg && reg <= last_gpr_regnum)
406 return reg - first_gpr_regnum + SIM_FRV_GR0_REGNUM;
407 else if (first_fpr_regnum <= reg && reg <= last_fpr_regnum)
408 return reg - first_fpr_regnum + SIM_FRV_FR0_REGNUM;
409 else if (pc_regnum == reg)
410 return SIM_FRV_PC_REGNUM;
411 else if (reg >= first_spr_regnum
412 && reg < first_spr_regnum + sizeof (spr_map) / sizeof (spr_map[0]))
413 {
414 int spr_reg_offset = spr_map[reg - first_spr_regnum];
415
416 if (spr_reg_offset < 0)
417 return SIM_REGNO_DOES_NOT_EXIST;
418 else
419 return SIM_FRV_SPR0_REGNUM + spr_reg_offset;
420 }
421
422 internal_error (__FILE__, __LINE__, _("Bad register number %d"), reg);
423 }
424
425 constexpr gdb_byte frv_break_insn[] = {0xc0, 0x70, 0x00, 0x01};
426
427 typedef BP_MANIPULATION (frv_break_insn) frv_breakpoint;
428
429 /* Define the maximum number of instructions which may be packed into a
430 bundle (VLIW instruction). */
431 static const int max_instrs_per_bundle = 8;
432
433 /* Define the size (in bytes) of an FR-V instruction. */
434 static const int frv_instr_size = 4;
435
436 /* Adjust a breakpoint's address to account for the FR-V architecture's
437 constraint that a break instruction must not appear as any but the
438 first instruction in the bundle. */
439 static CORE_ADDR
440 frv_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
441 {
442 int count = max_instrs_per_bundle;
443 CORE_ADDR addr = bpaddr - frv_instr_size;
444 CORE_ADDR func_start = get_pc_function_start (bpaddr);
445
446 /* Find the end of the previous packing sequence. This will be indicated
447 by either attempting to access some inaccessible memory or by finding
448 an instruction word whose packing bit is set to one. */
449 while (count-- > 0 && addr >= func_start)
450 {
451 gdb_byte instr[frv_instr_size];
452 int status;
453
454 status = target_read_memory (addr, instr, sizeof instr);
455
456 if (status != 0)
457 break;
458
459 /* This is a big endian architecture, so byte zero will have most
460 significant byte. The most significant bit of this byte is the
461 packing bit. */
462 if (instr[0] & 0x80)
463 break;
464
465 addr -= frv_instr_size;
466 }
467
468 if (count > 0)
469 bpaddr = addr + frv_instr_size;
470
471 return bpaddr;
472 }
473
474
475 /* Return true if REG is a caller-saves ("scratch") register,
476 false otherwise. */
477 static int
478 is_caller_saves_reg (int reg)
479 {
480 return ((4 <= reg && reg <= 7)
481 || (14 <= reg && reg <= 15)
482 || (32 <= reg && reg <= 47));
483 }
484
485
486 /* Return true if REG is a callee-saves register, false otherwise. */
487 static int
488 is_callee_saves_reg (int reg)
489 {
490 return ((16 <= reg && reg <= 31)
491 || (48 <= reg && reg <= 63));
492 }
493
494
495 /* Return true if REG is an argument register, false otherwise. */
496 static int
497 is_argument_reg (int reg)
498 {
499 return (8 <= reg && reg <= 13);
500 }
501
502 /* Scan an FR-V prologue, starting at PC, until frame->PC.
503 If FRAME is non-zero, fill in its saved_regs with appropriate addresses.
504 We assume FRAME's saved_regs array has already been allocated and cleared.
505 Return the first PC value after the prologue.
506
507 Note that, for unoptimized code, we almost don't need this function
508 at all; all arguments and locals live on the stack, so we just need
509 the FP to find everything. The catch: structures passed by value
510 have their addresses living in registers; they're never spilled to
511 the stack. So if you ever want to be able to get to these
512 arguments in any frame but the top, you'll need to do this serious
513 prologue analysis. */
514 static CORE_ADDR
515 frv_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR pc,
516 struct frame_info *this_frame,
517 struct frv_unwind_cache *info)
518 {
519 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
520
521 /* When writing out instruction bitpatterns, we use the following
522 letters to label instruction fields:
523 P - The parallel bit. We don't use this.
524 J - The register number of GRj in the instruction description.
525 K - The register number of GRk in the instruction description.
526 I - The register number of GRi.
527 S - a signed imediate offset.
528 U - an unsigned immediate offset.
529
530 The dots below the numbers indicate where hex digit boundaries
531 fall, to make it easier to check the numbers. */
532
533 /* Non-zero iff we've seen the instruction that initializes the
534 frame pointer for this function's frame. */
535 int fp_set = 0;
536
537 /* If fp_set is non_zero, then this is the distance from
538 the stack pointer to frame pointer: fp = sp + fp_offset. */
539 int fp_offset = 0;
540
541 /* Total size of frame prior to any alloca operations. */
542 int framesize = 0;
543
544 /* Flag indicating if lr has been saved on the stack. */
545 int lr_saved_on_stack = 0;
546
547 /* The number of the general-purpose register we saved the return
548 address ("link register") in, or -1 if we haven't moved it yet. */
549 int lr_save_reg = -1;
550
551 /* Offset (from sp) at which lr has been saved on the stack. */
552
553 int lr_sp_offset = 0;
554
555 /* If gr_saved[i] is non-zero, then we've noticed that general
556 register i has been saved at gr_sp_offset[i] from the stack
557 pointer. */
558 char gr_saved[64];
559 int gr_sp_offset[64];
560
561 /* The address of the most recently scanned prologue instruction. */
562 CORE_ADDR last_prologue_pc;
563
564 /* The address of the next instruction. */
565 CORE_ADDR next_pc;
566
567 /* The upper bound to of the pc values to scan. */
568 CORE_ADDR lim_pc;
569
570 memset (gr_saved, 0, sizeof (gr_saved));
571
572 last_prologue_pc = pc;
573
574 /* Try to compute an upper limit (on how far to scan) based on the
575 line number info. */
576 lim_pc = skip_prologue_using_sal (gdbarch, pc);
577 /* If there's no line number info, lim_pc will be 0. In that case,
578 set the limit to be 100 instructions away from pc. Hopefully, this
579 will be far enough away to account for the entire prologue. Don't
580 worry about overshooting the end of the function. The scan loop
581 below contains some checks to avoid scanning unreasonably far. */
582 if (lim_pc == 0)
583 lim_pc = pc + 400;
584
585 /* If we have a frame, we don't want to scan past the frame's pc. This
586 will catch those cases where the pc is in the prologue. */
587 if (this_frame)
588 {
589 CORE_ADDR frame_pc = get_frame_pc (this_frame);
590 if (frame_pc < lim_pc)
591 lim_pc = frame_pc;
592 }
593
594 /* Scan the prologue. */
595 while (pc < lim_pc)
596 {
597 gdb_byte buf[frv_instr_size];
598 LONGEST op;
599
600 if (target_read_memory (pc, buf, sizeof buf) != 0)
601 break;
602 op = extract_signed_integer (buf, sizeof buf, byte_order);
603
604 next_pc = pc + 4;
605
606 /* The tests in this chain of ifs should be in order of
607 decreasing selectivity, so that more particular patterns get
608 to fire before less particular patterns. */
609
610 /* Some sort of control transfer instruction: stop scanning prologue.
611 Integer Conditional Branch:
612 X XXXX XX 0000110 XX XXXXXXXXXXXXXXXX
613 Floating-point / media Conditional Branch:
614 X XXXX XX 0000111 XX XXXXXXXXXXXXXXXX
615 LCR Conditional Branch to LR
616 X XXXX XX 0001110 XX XX 001 X XXXXXXXXXX
617 Integer conditional Branches to LR
618 X XXXX XX 0001110 XX XX 010 X XXXXXXXXXX
619 X XXXX XX 0001110 XX XX 011 X XXXXXXXXXX
620 Floating-point/Media Branches to LR
621 X XXXX XX 0001110 XX XX 110 X XXXXXXXXXX
622 X XXXX XX 0001110 XX XX 111 X XXXXXXXXXX
623 Jump and Link
624 X XXXXX X 0001100 XXXXXX XXXXXX XXXXXX
625 X XXXXX X 0001101 XXXXXX XXXXXX XXXXXX
626 Call
627 X XXXXXX 0001111 XXXXXXXXXXXXXXXXXX
628 Return from Trap
629 X XXXXX X 0000101 XXXXXX XXXXXX XXXXXX
630 Integer Conditional Trap
631 X XXXX XX 0000100 XXXXXX XXXX 00 XXXXXX
632 X XXXX XX 0011100 XXXXXX XXXXXXXXXXXX
633 Floating-point /media Conditional Trap
634 X XXXX XX 0000100 XXXXXX XXXX 01 XXXXXX
635 X XXXX XX 0011101 XXXXXX XXXXXXXXXXXX
636 Break
637 X XXXX XX 0000100 XXXXXX XXXX 11 XXXXXX
638 Media Trap
639 X XXXX XX 0000100 XXXXXX XXXX 10 XXXXXX */
640 if ((op & 0x01d80000) == 0x00180000 /* Conditional branches and Call */
641 || (op & 0x01f80000) == 0x00300000 /* Jump and Link */
642 || (op & 0x01f80000) == 0x00100000 /* Return from Trap, Trap */
643 || (op & 0x01f80000) == 0x00700000) /* Trap immediate */
644 {
645 /* Stop scanning; not in prologue any longer. */
646 break;
647 }
648
649 /* Loading something from memory into fp probably means that
650 we're in the epilogue. Stop scanning the prologue.
651 ld @(GRi, GRk), fp
652 X 000010 0000010 XXXXXX 000100 XXXXXX
653 ldi @(GRi, d12), fp
654 X 000010 0110010 XXXXXX XXXXXXXXXXXX */
655 else if ((op & 0x7ffc0fc0) == 0x04080100
656 || (op & 0x7ffc0000) == 0x04c80000)
657 {
658 break;
659 }
660
661 /* Setting the FP from the SP:
662 ori sp, 0, fp
663 P 000010 0100010 000001 000000000000 = 0x04881000
664 0 111111 1111111 111111 111111111111 = 0x7fffffff
665 . . . . . . . .
666 We treat this as part of the prologue. */
667 else if ((op & 0x7fffffff) == 0x04881000)
668 {
669 fp_set = 1;
670 fp_offset = 0;
671 last_prologue_pc = next_pc;
672 }
673
674 /* Move the link register to the scratch register grJ, before saving:
675 movsg lr, grJ
676 P 000100 0000011 010000 000111 JJJJJJ = 0x080d01c0
677 0 111111 1111111 111111 111111 000000 = 0x7fffffc0
678 . . . . . . . .
679 We treat this as part of the prologue. */
680 else if ((op & 0x7fffffc0) == 0x080d01c0)
681 {
682 int gr_j = op & 0x3f;
683
684 /* If we're moving it to a scratch register, that's fine. */
685 if (is_caller_saves_reg (gr_j))
686 {
687 lr_save_reg = gr_j;
688 last_prologue_pc = next_pc;
689 }
690 }
691
692 /* To save multiple callee-saves registers on the stack, at
693 offset zero:
694
695 std grK,@(sp,gr0)
696 P KKKKKK 0000011 000001 000011 000000 = 0x000c10c0
697 0 000000 1111111 111111 111111 111111 = 0x01ffffff
698
699 stq grK,@(sp,gr0)
700 P KKKKKK 0000011 000001 000100 000000 = 0x000c1100
701 0 000000 1111111 111111 111111 111111 = 0x01ffffff
702 . . . . . . . .
703 We treat this as part of the prologue, and record the register's
704 saved address in the frame structure. */
705 else if ((op & 0x01ffffff) == 0x000c10c0
706 || (op & 0x01ffffff) == 0x000c1100)
707 {
708 int gr_k = ((op >> 25) & 0x3f);
709 int ope = ((op >> 6) & 0x3f);
710 int count;
711 int i;
712
713 /* Is it an std or an stq? */
714 if (ope == 0x03)
715 count = 2;
716 else
717 count = 4;
718
719 /* Is it really a callee-saves register? */
720 if (is_callee_saves_reg (gr_k))
721 {
722 for (i = 0; i < count; i++)
723 {
724 gr_saved[gr_k + i] = 1;
725 gr_sp_offset[gr_k + i] = 4 * i;
726 }
727 last_prologue_pc = next_pc;
728 }
729 }
730
731 /* Adjusting the stack pointer. (The stack pointer is GR1.)
732 addi sp, S, sp
733 P 000001 0010000 000001 SSSSSSSSSSSS = 0x02401000
734 0 111111 1111111 111111 000000000000 = 0x7ffff000
735 . . . . . . . .
736 We treat this as part of the prologue. */
737 else if ((op & 0x7ffff000) == 0x02401000)
738 {
739 if (framesize == 0)
740 {
741 /* Sign-extend the twelve-bit field.
742 (Isn't there a better way to do this?) */
743 int s = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
744
745 framesize -= s;
746 last_prologue_pc = pc;
747 }
748 else
749 {
750 /* If the prologue is being adjusted again, we've
751 likely gone too far; i.e. we're probably in the
752 epilogue. */
753 break;
754 }
755 }
756
757 /* Setting the FP to a constant distance from the SP:
758 addi sp, S, fp
759 P 000010 0010000 000001 SSSSSSSSSSSS = 0x04401000
760 0 111111 1111111 111111 000000000000 = 0x7ffff000
761 . . . . . . . .
762 We treat this as part of the prologue. */
763 else if ((op & 0x7ffff000) == 0x04401000)
764 {
765 /* Sign-extend the twelve-bit field.
766 (Isn't there a better way to do this?) */
767 int s = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
768 fp_set = 1;
769 fp_offset = s;
770 last_prologue_pc = pc;
771 }
772
773 /* To spill an argument register to a scratch register:
774 ori GRi, 0, GRk
775 P KKKKKK 0100010 IIIIII 000000000000 = 0x00880000
776 0 000000 1111111 000000 111111111111 = 0x01fc0fff
777 . . . . . . . .
778 For the time being, we treat this as a prologue instruction,
779 assuming that GRi is an argument register. This one's kind
780 of suspicious, because it seems like it could be part of a
781 legitimate body instruction. But we only come here when the
782 source info wasn't helpful, so we have to do the best we can.
783 Hopefully once GCC and GDB agree on how to emit line number
784 info for prologues, then this code will never come into play. */
785 else if ((op & 0x01fc0fff) == 0x00880000)
786 {
787 int gr_i = ((op >> 12) & 0x3f);
788
789 /* Make sure that the source is an arg register; if it is, we'll
790 treat it as a prologue instruction. */
791 if (is_argument_reg (gr_i))
792 last_prologue_pc = next_pc;
793 }
794
795 /* To spill 16-bit values to the stack:
796 sthi GRk, @(fp, s)
797 P KKKKKK 1010001 000010 SSSSSSSSSSSS = 0x01442000
798 0 000000 1111111 111111 000000000000 = 0x01fff000
799 . . . . . . . .
800 And for 8-bit values, we use STB instructions.
801 stbi GRk, @(fp, s)
802 P KKKKKK 1010000 000010 SSSSSSSSSSSS = 0x01402000
803 0 000000 1111111 111111 000000000000 = 0x01fff000
804 . . . . . . . .
805 We check that GRk is really an argument register, and treat
806 all such as part of the prologue. */
807 else if ( (op & 0x01fff000) == 0x01442000
808 || (op & 0x01fff000) == 0x01402000)
809 {
810 int gr_k = ((op >> 25) & 0x3f);
811
812 /* Make sure that GRk is really an argument register; treat
813 it as a prologue instruction if so. */
814 if (is_argument_reg (gr_k))
815 last_prologue_pc = next_pc;
816 }
817
818 /* To save multiple callee-saves register on the stack, at a
819 non-zero offset:
820
821 stdi GRk, @(sp, s)
822 P KKKKKK 1010011 000001 SSSSSSSSSSSS = 0x014c1000
823 0 000000 1111111 111111 000000000000 = 0x01fff000
824 . . . . . . . .
825 stqi GRk, @(sp, s)
826 P KKKKKK 1010100 000001 SSSSSSSSSSSS = 0x01501000
827 0 000000 1111111 111111 000000000000 = 0x01fff000
828 . . . . . . . .
829 We treat this as part of the prologue, and record the register's
830 saved address in the frame structure. */
831 else if ((op & 0x01fff000) == 0x014c1000
832 || (op & 0x01fff000) == 0x01501000)
833 {
834 int gr_k = ((op >> 25) & 0x3f);
835 int count;
836 int i;
837
838 /* Is it a stdi or a stqi? */
839 if ((op & 0x01fff000) == 0x014c1000)
840 count = 2;
841 else
842 count = 4;
843
844 /* Is it really a callee-saves register? */
845 if (is_callee_saves_reg (gr_k))
846 {
847 /* Sign-extend the twelve-bit field.
848 (Isn't there a better way to do this?) */
849 int s = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
850
851 for (i = 0; i < count; i++)
852 {
853 gr_saved[gr_k + i] = 1;
854 gr_sp_offset[gr_k + i] = s + (4 * i);
855 }
856 last_prologue_pc = next_pc;
857 }
858 }
859
860 /* Storing any kind of integer register at any constant offset
861 from any other register.
862
863 st GRk, @(GRi, gr0)
864 P KKKKKK 0000011 IIIIII 000010 000000 = 0x000c0080
865 0 000000 1111111 000000 111111 111111 = 0x01fc0fff
866 . . . . . . . .
867 sti GRk, @(GRi, d12)
868 P KKKKKK 1010010 IIIIII SSSSSSSSSSSS = 0x01480000
869 0 000000 1111111 000000 000000000000 = 0x01fc0000
870 . . . . . . . .
871 These could be almost anything, but a lot of prologue
872 instructions fall into this pattern, so let's decode the
873 instruction once, and then work at a higher level. */
874 else if (((op & 0x01fc0fff) == 0x000c0080)
875 || ((op & 0x01fc0000) == 0x01480000))
876 {
877 int gr_k = ((op >> 25) & 0x3f);
878 int gr_i = ((op >> 12) & 0x3f);
879 int offset;
880
881 /* Are we storing with gr0 as an offset, or using an
882 immediate value? */
883 if ((op & 0x01fc0fff) == 0x000c0080)
884 offset = 0;
885 else
886 offset = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
887
888 /* If the address isn't relative to the SP or FP, it's not a
889 prologue instruction. */
890 if (gr_i != sp_regnum && gr_i != fp_regnum)
891 {
892 /* Do nothing; not a prologue instruction. */
893 }
894
895 /* Saving the old FP in the new frame (relative to the SP). */
896 else if (gr_k == fp_regnum && gr_i == sp_regnum)
897 {
898 gr_saved[fp_regnum] = 1;
899 gr_sp_offset[fp_regnum] = offset;
900 last_prologue_pc = next_pc;
901 }
902
903 /* Saving callee-saves register(s) on the stack, relative to
904 the SP. */
905 else if (gr_i == sp_regnum
906 && is_callee_saves_reg (gr_k))
907 {
908 gr_saved[gr_k] = 1;
909 if (gr_i == sp_regnum)
910 gr_sp_offset[gr_k] = offset;
911 else
912 gr_sp_offset[gr_k] = offset + fp_offset;
913 last_prologue_pc = next_pc;
914 }
915
916 /* Saving the scratch register holding the return address. */
917 else if (lr_save_reg != -1
918 && gr_k == lr_save_reg)
919 {
920 lr_saved_on_stack = 1;
921 if (gr_i == sp_regnum)
922 lr_sp_offset = offset;
923 else
924 lr_sp_offset = offset + fp_offset;
925 last_prologue_pc = next_pc;
926 }
927
928 /* Spilling int-sized arguments to the stack. */
929 else if (is_argument_reg (gr_k))
930 last_prologue_pc = next_pc;
931 }
932 pc = next_pc;
933 }
934
935 if (this_frame && info)
936 {
937 int i;
938 ULONGEST this_base;
939
940 /* If we know the relationship between the stack and frame
941 pointers, record the addresses of the registers we noticed.
942 Note that we have to do this as a separate step at the end,
943 because instructions may save relative to the SP, but we need
944 their addresses relative to the FP. */
945 if (fp_set)
946 this_base = get_frame_register_unsigned (this_frame, fp_regnum);
947 else
948 this_base = get_frame_register_unsigned (this_frame, sp_regnum);
949
950 for (i = 0; i < 64; i++)
951 if (gr_saved[i])
952 info->saved_regs[i].addr = this_base - fp_offset + gr_sp_offset[i];
953
954 info->prev_sp = this_base - fp_offset + framesize;
955 info->base = this_base;
956
957 /* If LR was saved on the stack, record its location. */
958 if (lr_saved_on_stack)
959 info->saved_regs[lr_regnum].addr
960 = this_base - fp_offset + lr_sp_offset;
961
962 /* The call instruction moves the caller's PC in the callee's LR.
963 Since this is an unwind, do the reverse. Copy the location of LR
964 into PC (the address / regnum) so that a request for PC will be
965 converted into a request for the LR. */
966 info->saved_regs[pc_regnum] = info->saved_regs[lr_regnum];
967
968 /* Save the previous frame's computed SP value. */
969 trad_frame_set_value (info->saved_regs, sp_regnum, info->prev_sp);
970 }
971
972 return last_prologue_pc;
973 }
974
975
976 static CORE_ADDR
977 frv_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
978 {
979 CORE_ADDR func_addr, func_end, new_pc;
980
981 new_pc = pc;
982
983 /* If the line table has entry for a line *within* the function
984 (i.e., not in the prologue, and not past the end), then that's
985 our location. */
986 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
987 {
988 struct symtab_and_line sal;
989
990 sal = find_pc_line (func_addr, 0);
991
992 if (sal.line != 0 && sal.end < func_end)
993 {
994 new_pc = sal.end;
995 }
996 }
997
998 /* The FR-V prologue is at least five instructions long (twenty bytes).
999 If we didn't find a real source location past that, then
1000 do a full analysis of the prologue. */
1001 if (new_pc < pc + 20)
1002 new_pc = frv_analyze_prologue (gdbarch, pc, 0, 0);
1003
1004 return new_pc;
1005 }
1006
1007
1008 /* Examine the instruction pointed to by PC. If it corresponds to
1009 a call to __main, return the address of the next instruction.
1010 Otherwise, return PC. */
1011
1012 static CORE_ADDR
1013 frv_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1014 {
1015 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1016 gdb_byte buf[4];
1017 unsigned long op;
1018 CORE_ADDR orig_pc = pc;
1019
1020 if (target_read_memory (pc, buf, 4))
1021 return pc;
1022 op = extract_unsigned_integer (buf, 4, byte_order);
1023
1024 /* In PIC code, GR15 may be loaded from some offset off of FP prior
1025 to the call instruction.
1026
1027 Skip over this instruction if present. It won't be present in
1028 non-PIC code, and even in PIC code, it might not be present.
1029 (This is due to the fact that GR15, the FDPIC register, already
1030 contains the correct value.)
1031
1032 The general form of the LDI is given first, followed by the
1033 specific instruction with the GRi and GRk filled in as FP and
1034 GR15.
1035
1036 ldi @(GRi, d12), GRk
1037 P KKKKKK 0110010 IIIIII SSSSSSSSSSSS = 0x00c80000
1038 0 000000 1111111 000000 000000000000 = 0x01fc0000
1039 . . . . . . . .
1040 ldi @(FP, d12), GR15
1041 P KKKKKK 0110010 IIIIII SSSSSSSSSSSS = 0x1ec82000
1042 0 001111 1111111 000010 000000000000 = 0x7ffff000
1043 . . . . . . . . */
1044
1045 if ((op & 0x7ffff000) == 0x1ec82000)
1046 {
1047 pc += 4;
1048 if (target_read_memory (pc, buf, 4))
1049 return orig_pc;
1050 op = extract_unsigned_integer (buf, 4, byte_order);
1051 }
1052
1053 /* The format of an FRV CALL instruction is as follows:
1054
1055 call label24
1056 P HHHHHH 0001111 LLLLLLLLLLLLLLLLLL = 0x003c0000
1057 0 000000 1111111 000000000000000000 = 0x01fc0000
1058 . . . . . . . .
1059
1060 where label24 is constructed by concatenating the H bits with the
1061 L bits. The call target is PC + (4 * sign_ext(label24)). */
1062
1063 if ((op & 0x01fc0000) == 0x003c0000)
1064 {
1065 LONGEST displ;
1066 CORE_ADDR call_dest;
1067 struct bound_minimal_symbol s;
1068
1069 displ = ((op & 0xfe000000) >> 7) | (op & 0x0003ffff);
1070 if ((displ & 0x00800000) != 0)
1071 displ |= ~((LONGEST) 0x00ffffff);
1072
1073 call_dest = pc + 4 * displ;
1074 s = lookup_minimal_symbol_by_pc (call_dest);
1075
1076 if (s.minsym != NULL
1077 && MSYMBOL_LINKAGE_NAME (s.minsym) != NULL
1078 && strcmp (MSYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0)
1079 {
1080 pc += 4;
1081 return pc;
1082 }
1083 }
1084 return orig_pc;
1085 }
1086
1087
1088 static struct frv_unwind_cache *
1089 frv_frame_unwind_cache (struct frame_info *this_frame,
1090 void **this_prologue_cache)
1091 {
1092 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1093 struct frv_unwind_cache *info;
1094
1095 if ((*this_prologue_cache))
1096 return (struct frv_unwind_cache *) (*this_prologue_cache);
1097
1098 info = FRAME_OBSTACK_ZALLOC (struct frv_unwind_cache);
1099 (*this_prologue_cache) = info;
1100 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1101
1102 /* Prologue analysis does the rest... */
1103 frv_analyze_prologue (gdbarch,
1104 get_frame_func (this_frame), this_frame, info);
1105
1106 return info;
1107 }
1108
1109 static void
1110 frv_extract_return_value (struct type *type, struct regcache *regcache,
1111 gdb_byte *valbuf)
1112 {
1113 struct gdbarch *gdbarch = regcache->arch ();
1114 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1115 int len = TYPE_LENGTH (type);
1116
1117 if (len <= 4)
1118 {
1119 ULONGEST gpr8_val;
1120 regcache_cooked_read_unsigned (regcache, 8, &gpr8_val);
1121 store_unsigned_integer (valbuf, len, byte_order, gpr8_val);
1122 }
1123 else if (len == 8)
1124 {
1125 ULONGEST regval;
1126
1127 regcache_cooked_read_unsigned (regcache, 8, &regval);
1128 store_unsigned_integer (valbuf, 4, byte_order, regval);
1129 regcache_cooked_read_unsigned (regcache, 9, &regval);
1130 store_unsigned_integer ((bfd_byte *) valbuf + 4, 4, byte_order, regval);
1131 }
1132 else
1133 internal_error (__FILE__, __LINE__,
1134 _("Illegal return value length: %d"), len);
1135 }
1136
1137 static CORE_ADDR
1138 frv_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
1139 {
1140 /* Require dword alignment. */
1141 return align_down (sp, 8);
1142 }
1143
1144 static CORE_ADDR
1145 find_func_descr (struct gdbarch *gdbarch, CORE_ADDR entry_point)
1146 {
1147 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1148 CORE_ADDR descr;
1149 gdb_byte valbuf[4];
1150 CORE_ADDR start_addr;
1151
1152 /* If we can't find the function in the symbol table, then we assume
1153 that the function address is already in descriptor form. */
1154 if (!find_pc_partial_function (entry_point, NULL, &start_addr, NULL)
1155 || entry_point != start_addr)
1156 return entry_point;
1157
1158 descr = frv_fdpic_find_canonical_descriptor (entry_point);
1159
1160 if (descr != 0)
1161 return descr;
1162
1163 /* Construct a non-canonical descriptor from space allocated on
1164 the stack. */
1165
1166 descr = value_as_long (value_allocate_space_in_inferior (8));
1167 store_unsigned_integer (valbuf, 4, byte_order, entry_point);
1168 write_memory (descr, valbuf, 4);
1169 store_unsigned_integer (valbuf, 4, byte_order,
1170 frv_fdpic_find_global_pointer (entry_point));
1171 write_memory (descr + 4, valbuf, 4);
1172 return descr;
1173 }
1174
1175 static CORE_ADDR
1176 frv_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
1177 struct target_ops *targ)
1178 {
1179 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1180 CORE_ADDR entry_point;
1181 CORE_ADDR got_address;
1182
1183 entry_point = get_target_memory_unsigned (targ, addr, 4, byte_order);
1184 got_address = get_target_memory_unsigned (targ, addr + 4, 4, byte_order);
1185
1186 if (got_address == frv_fdpic_find_global_pointer (entry_point))
1187 return entry_point;
1188 else
1189 return addr;
1190 }
1191
1192 static CORE_ADDR
1193 frv_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1194 struct regcache *regcache, CORE_ADDR bp_addr,
1195 int nargs, struct value **args, CORE_ADDR sp,
1196 int struct_return, CORE_ADDR struct_addr)
1197 {
1198 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1199 int argreg;
1200 int argnum;
1201 const gdb_byte *val;
1202 gdb_byte valbuf[4];
1203 struct value *arg;
1204 struct type *arg_type;
1205 int len;
1206 enum type_code typecode;
1207 CORE_ADDR regval;
1208 int stack_space;
1209 int stack_offset;
1210 enum frv_abi abi = frv_abi (gdbarch);
1211 CORE_ADDR func_addr = find_function_addr (function, NULL);
1212
1213 #if 0
1214 printf("Push %d args at sp = %x, struct_return=%d (%x)\n",
1215 nargs, (int) sp, struct_return, struct_addr);
1216 #endif
1217
1218 stack_space = 0;
1219 for (argnum = 0; argnum < nargs; ++argnum)
1220 stack_space += align_up (TYPE_LENGTH (value_type (args[argnum])), 4);
1221
1222 stack_space -= (6 * 4);
1223 if (stack_space > 0)
1224 sp -= stack_space;
1225
1226 /* Make sure stack is dword aligned. */
1227 sp = align_down (sp, 8);
1228
1229 stack_offset = 0;
1230
1231 argreg = 8;
1232
1233 if (struct_return)
1234 regcache_cooked_write_unsigned (regcache, struct_return_regnum,
1235 struct_addr);
1236
1237 for (argnum = 0; argnum < nargs; ++argnum)
1238 {
1239 arg = args[argnum];
1240 arg_type = check_typedef (value_type (arg));
1241 len = TYPE_LENGTH (arg_type);
1242 typecode = TYPE_CODE (arg_type);
1243
1244 if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
1245 {
1246 store_unsigned_integer (valbuf, 4, byte_order,
1247 value_address (arg));
1248 typecode = TYPE_CODE_PTR;
1249 len = 4;
1250 val = valbuf;
1251 }
1252 else if (abi == FRV_ABI_FDPIC
1253 && len == 4
1254 && typecode == TYPE_CODE_PTR
1255 && TYPE_CODE (TYPE_TARGET_TYPE (arg_type)) == TYPE_CODE_FUNC)
1256 {
1257 /* The FDPIC ABI requires function descriptors to be passed instead
1258 of entry points. */
1259 CORE_ADDR addr = extract_unsigned_integer
1260 (value_contents (arg), 4, byte_order);
1261 addr = find_func_descr (gdbarch, addr);
1262 store_unsigned_integer (valbuf, 4, byte_order, addr);
1263 typecode = TYPE_CODE_PTR;
1264 len = 4;
1265 val = valbuf;
1266 }
1267 else
1268 {
1269 val = value_contents (arg);
1270 }
1271
1272 while (len > 0)
1273 {
1274 int partial_len = (len < 4 ? len : 4);
1275
1276 if (argreg < 14)
1277 {
1278 regval = extract_unsigned_integer (val, partial_len, byte_order);
1279 #if 0
1280 printf(" Argnum %d data %x -> reg %d\n",
1281 argnum, (int) regval, argreg);
1282 #endif
1283 regcache_cooked_write_unsigned (regcache, argreg, regval);
1284 ++argreg;
1285 }
1286 else
1287 {
1288 #if 0
1289 printf(" Argnum %d data %x -> offset %d (%x)\n",
1290 argnum, *((int *)val), stack_offset,
1291 (int) (sp + stack_offset));
1292 #endif
1293 write_memory (sp + stack_offset, val, partial_len);
1294 stack_offset += align_up (partial_len, 4);
1295 }
1296 len -= partial_len;
1297 val += partial_len;
1298 }
1299 }
1300
1301 /* Set the return address. For the frv, the return breakpoint is
1302 always at BP_ADDR. */
1303 regcache_cooked_write_unsigned (regcache, lr_regnum, bp_addr);
1304
1305 if (abi == FRV_ABI_FDPIC)
1306 {
1307 /* Set the GOT register for the FDPIC ABI. */
1308 regcache_cooked_write_unsigned
1309 (regcache, first_gpr_regnum + 15,
1310 frv_fdpic_find_global_pointer (func_addr));
1311 }
1312
1313 /* Finally, update the SP register. */
1314 regcache_cooked_write_unsigned (regcache, sp_regnum, sp);
1315
1316 return sp;
1317 }
1318
1319 static void
1320 frv_store_return_value (struct type *type, struct regcache *regcache,
1321 const gdb_byte *valbuf)
1322 {
1323 int len = TYPE_LENGTH (type);
1324
1325 if (len <= 4)
1326 {
1327 bfd_byte val[4];
1328 memset (val, 0, sizeof (val));
1329 memcpy (val + (4 - len), valbuf, len);
1330 regcache_cooked_write (regcache, 8, val);
1331 }
1332 else if (len == 8)
1333 {
1334 regcache_cooked_write (regcache, 8, valbuf);
1335 regcache_cooked_write (regcache, 9, (bfd_byte *) valbuf + 4);
1336 }
1337 else
1338 internal_error (__FILE__, __LINE__,
1339 _("Don't know how to return a %d-byte value."), len);
1340 }
1341
1342 static enum return_value_convention
1343 frv_return_value (struct gdbarch *gdbarch, struct value *function,
1344 struct type *valtype, struct regcache *regcache,
1345 gdb_byte *readbuf, const gdb_byte *writebuf)
1346 {
1347 int struct_return = TYPE_CODE (valtype) == TYPE_CODE_STRUCT
1348 || TYPE_CODE (valtype) == TYPE_CODE_UNION
1349 || TYPE_CODE (valtype) == TYPE_CODE_ARRAY;
1350
1351 if (writebuf != NULL)
1352 {
1353 gdb_assert (!struct_return);
1354 frv_store_return_value (valtype, regcache, writebuf);
1355 }
1356
1357 if (readbuf != NULL)
1358 {
1359 gdb_assert (!struct_return);
1360 frv_extract_return_value (valtype, regcache, readbuf);
1361 }
1362
1363 if (struct_return)
1364 return RETURN_VALUE_STRUCT_CONVENTION;
1365 else
1366 return RETURN_VALUE_REGISTER_CONVENTION;
1367 }
1368
1369 static CORE_ADDR
1370 frv_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1371 {
1372 return frame_unwind_register_unsigned (next_frame, pc_regnum);
1373 }
1374
1375 /* Given a GDB frame, determine the address of the calling function's
1376 frame. This will be used to create a new GDB frame struct. */
1377
1378 static void
1379 frv_frame_this_id (struct frame_info *this_frame,
1380 void **this_prologue_cache, struct frame_id *this_id)
1381 {
1382 struct frv_unwind_cache *info
1383 = frv_frame_unwind_cache (this_frame, this_prologue_cache);
1384 CORE_ADDR base;
1385 CORE_ADDR func;
1386 struct bound_minimal_symbol msym_stack;
1387 struct frame_id id;
1388
1389 /* The FUNC is easy. */
1390 func = get_frame_func (this_frame);
1391
1392 /* Check if the stack is empty. */
1393 msym_stack = lookup_minimal_symbol ("_stack", NULL, NULL);
1394 if (msym_stack.minsym && info->base == BMSYMBOL_VALUE_ADDRESS (msym_stack))
1395 return;
1396
1397 /* Hopefully the prologue analysis either correctly determined the
1398 frame's base (which is the SP from the previous frame), or set
1399 that base to "NULL". */
1400 base = info->prev_sp;
1401 if (base == 0)
1402 return;
1403
1404 id = frame_id_build (base, func);
1405 (*this_id) = id;
1406 }
1407
1408 static struct value *
1409 frv_frame_prev_register (struct frame_info *this_frame,
1410 void **this_prologue_cache, int regnum)
1411 {
1412 struct frv_unwind_cache *info
1413 = frv_frame_unwind_cache (this_frame, this_prologue_cache);
1414 return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1415 }
1416
1417 static const struct frame_unwind frv_frame_unwind = {
1418 NORMAL_FRAME,
1419 default_frame_unwind_stop_reason,
1420 frv_frame_this_id,
1421 frv_frame_prev_register,
1422 NULL,
1423 default_frame_sniffer
1424 };
1425
1426 static CORE_ADDR
1427 frv_frame_base_address (struct frame_info *this_frame, void **this_cache)
1428 {
1429 struct frv_unwind_cache *info
1430 = frv_frame_unwind_cache (this_frame, this_cache);
1431 return info->base;
1432 }
1433
1434 static const struct frame_base frv_frame_base = {
1435 &frv_frame_unwind,
1436 frv_frame_base_address,
1437 frv_frame_base_address,
1438 frv_frame_base_address
1439 };
1440
1441 static CORE_ADDR
1442 frv_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
1443 {
1444 return frame_unwind_register_unsigned (next_frame, sp_regnum);
1445 }
1446
1447
1448 /* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy
1449 frame. The frame ID's base needs to match the TOS value saved by
1450 save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint. */
1451
1452 static struct frame_id
1453 frv_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1454 {
1455 CORE_ADDR sp = get_frame_register_unsigned (this_frame, sp_regnum);
1456 return frame_id_build (sp, get_frame_pc (this_frame));
1457 }
1458
1459 static struct gdbarch *
1460 frv_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1461 {
1462 struct gdbarch *gdbarch;
1463 struct gdbarch_tdep *var;
1464 int elf_flags = 0;
1465
1466 /* Check to see if we've already built an appropriate architecture
1467 object for this executable. */
1468 arches = gdbarch_list_lookup_by_info (arches, &info);
1469 if (arches)
1470 return arches->gdbarch;
1471
1472 /* Select the right tdep structure for this variant. */
1473 var = new_variant ();
1474 switch (info.bfd_arch_info->mach)
1475 {
1476 case bfd_mach_frv:
1477 case bfd_mach_frvsimple:
1478 case bfd_mach_fr300:
1479 case bfd_mach_fr500:
1480 case bfd_mach_frvtomcat:
1481 case bfd_mach_fr550:
1482 set_variant_num_gprs (var, 64);
1483 set_variant_num_fprs (var, 64);
1484 break;
1485
1486 case bfd_mach_fr400:
1487 case bfd_mach_fr450:
1488 set_variant_num_gprs (var, 32);
1489 set_variant_num_fprs (var, 32);
1490 break;
1491
1492 default:
1493 /* Never heard of this variant. */
1494 return 0;
1495 }
1496
1497 /* Extract the ELF flags, if available. */
1498 if (info.abfd && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
1499 elf_flags = elf_elfheader (info.abfd)->e_flags;
1500
1501 if (elf_flags & EF_FRV_FDPIC)
1502 set_variant_abi_fdpic (var);
1503
1504 if (elf_flags & EF_FRV_CPU_FR450)
1505 set_variant_scratch_registers (var);
1506
1507 gdbarch = gdbarch_alloc (&info, var);
1508
1509 set_gdbarch_short_bit (gdbarch, 16);
1510 set_gdbarch_int_bit (gdbarch, 32);
1511 set_gdbarch_long_bit (gdbarch, 32);
1512 set_gdbarch_long_long_bit (gdbarch, 64);
1513 set_gdbarch_float_bit (gdbarch, 32);
1514 set_gdbarch_double_bit (gdbarch, 64);
1515 set_gdbarch_long_double_bit (gdbarch, 64);
1516 set_gdbarch_ptr_bit (gdbarch, 32);
1517
1518 set_gdbarch_num_regs (gdbarch, frv_num_regs);
1519 set_gdbarch_num_pseudo_regs (gdbarch, frv_num_pseudo_regs);
1520
1521 set_gdbarch_sp_regnum (gdbarch, sp_regnum);
1522 set_gdbarch_deprecated_fp_regnum (gdbarch, fp_regnum);
1523 set_gdbarch_pc_regnum (gdbarch, pc_regnum);
1524
1525 set_gdbarch_register_name (gdbarch, frv_register_name);
1526 set_gdbarch_register_type (gdbarch, frv_register_type);
1527 set_gdbarch_register_sim_regno (gdbarch, frv_register_sim_regno);
1528
1529 set_gdbarch_pseudo_register_read (gdbarch, frv_pseudo_register_read);
1530 set_gdbarch_pseudo_register_write (gdbarch, frv_pseudo_register_write);
1531
1532 set_gdbarch_skip_prologue (gdbarch, frv_skip_prologue);
1533 set_gdbarch_skip_main_prologue (gdbarch, frv_skip_main_prologue);
1534 set_gdbarch_breakpoint_kind_from_pc (gdbarch, frv_breakpoint::kind_from_pc);
1535 set_gdbarch_sw_breakpoint_from_kind (gdbarch, frv_breakpoint::bp_from_kind);
1536 set_gdbarch_adjust_breakpoint_address
1537 (gdbarch, frv_adjust_breakpoint_address);
1538
1539 set_gdbarch_return_value (gdbarch, frv_return_value);
1540
1541 /* Frame stuff. */
1542 set_gdbarch_unwind_pc (gdbarch, frv_unwind_pc);
1543 set_gdbarch_unwind_sp (gdbarch, frv_unwind_sp);
1544 set_gdbarch_frame_align (gdbarch, frv_frame_align);
1545 frame_base_set_default (gdbarch, &frv_frame_base);
1546 /* We set the sniffer lower down after the OSABI hooks have been
1547 established. */
1548
1549 /* Settings for calling functions in the inferior. */
1550 set_gdbarch_push_dummy_call (gdbarch, frv_push_dummy_call);
1551 set_gdbarch_dummy_id (gdbarch, frv_dummy_id);
1552
1553 /* Settings that should be unnecessary. */
1554 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1555
1556 /* Hardware watchpoint / breakpoint support. */
1557 switch (info.bfd_arch_info->mach)
1558 {
1559 case bfd_mach_frv:
1560 case bfd_mach_frvsimple:
1561 case bfd_mach_fr300:
1562 case bfd_mach_fr500:
1563 case bfd_mach_frvtomcat:
1564 /* fr500-style hardware debugging support. */
1565 var->num_hw_watchpoints = 4;
1566 var->num_hw_breakpoints = 4;
1567 break;
1568
1569 case bfd_mach_fr400:
1570 case bfd_mach_fr450:
1571 /* fr400-style hardware debugging support. */
1572 var->num_hw_watchpoints = 2;
1573 var->num_hw_breakpoints = 4;
1574 break;
1575
1576 default:
1577 /* Otherwise, assume we don't have hardware debugging support. */
1578 var->num_hw_watchpoints = 0;
1579 var->num_hw_breakpoints = 0;
1580 break;
1581 }
1582
1583 if (frv_abi (gdbarch) == FRV_ABI_FDPIC)
1584 set_gdbarch_convert_from_func_ptr_addr (gdbarch,
1585 frv_convert_from_func_ptr_addr);
1586
1587 set_solib_ops (gdbarch, &frv_so_ops);
1588
1589 /* Hook in ABI-specific overrides, if they have been registered. */
1590 gdbarch_init_osabi (info, gdbarch);
1591
1592 /* Set the fallback (prologue based) frame sniffer. */
1593 frame_unwind_append_unwinder (gdbarch, &frv_frame_unwind);
1594
1595 /* Enable TLS support. */
1596 set_gdbarch_fetch_tls_load_module_address (gdbarch,
1597 frv_fetch_objfile_link_map);
1598
1599 return gdbarch;
1600 }
1601
1602 void
1603 _initialize_frv_tdep (void)
1604 {
1605 register_gdbarch_init (bfd_arch_frv, frv_gdbarch_init);
1606 }
frv_frame_base
static const struct frame_base frv_frame_base
Definition: frv-tdep.c:1434
frv_convert_from_func_ptr_addr
static CORE_ADDR frv_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition: frv-tdep.c:1176
set_gdbarch_num_regs
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition: gdbarch.c:2050
gdbarch
Definition: gdbarch.c:127
sp_regnum
Definition: frv-tdep.h:32
frv_unwind_cache
Definition: frv-tdep.c:42
accg7_regnum
Definition: frv-tdep.h:89
gner0_regnum
Definition: frv-tdep.h:74
set_gdbarch_double_bit
void set_gdbarch_double_bit(struct gdbarch *gdbarch, int double_bit)
Definition: gdbarch.c:1723
set_gdbarch_frame_align
void set_gdbarch_frame_align(struct gdbarch *gdbarch, gdbarch_frame_align_ftype frame_align)
Definition: gdbarch.c:3151
acc0_regnum
Definition: frv-tdep.h:68
frv_register_type
static struct type * frv_register_type(struct gdbarch *gdbarch, int reg)
Definition: frv-tdep.c:287
frv_abi
enum frv_abi frv_abi(struct gdbarch *gdbarch)
Definition: frv-tdep.c:93
type_code
type_code
Definition: gdbtypes.h:80
TYPE_CODE_ARRAY
Definition: gdbtypes.h:104
set_gdbarch_skip_main_prologue
void set_gdbarch_skip_main_prologue(struct gdbarch *gdbarch, gdbarch_skip_main_prologue_ftype skip_main_prologue)
Definition: gdbarch.c:2796
frame_id_build
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:624
fdpic_loadmap_interp_regnum
Definition: frv-tdep.h:52
scr2_regnum
Definition: frv-tdep.h:61
frv_fdpic_loadmap_addresses
int frv_fdpic_loadmap_addresses(struct gdbarch *gdbarch, CORE_ADDR *interp_addr, CORE_ADDR *exec_addr)
Definition: frv-tdep.c:102
frv_unwind_cache::base
CORE_ADDR base
Definition: frv-tdep.c:49
REG_VALID
Definition: common-regcache.h:32
dbar1_regnum
Definition: frv-tdep.h:56
scr1_regnum
Definition: frv-tdep.h:60
set_variant_scratch_registers
static void set_variant_scratch_registers(struct gdbarch_tdep *var)
Definition: frv-tdep.c:266
set_gdbarch_float_bit
void set_gdbarch_float_bit(struct gdbarch *gdbarch, int float_bit)
Definition: gdbarch.c:1690
get_frame_pc
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2376
MSYMBOL_LINKAGE_NAME
#define MSYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:707
infcall.h
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
set_gdbarch_fetch_tls_load_module_address
void set_gdbarch_fetch_tls_load_module_address(struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address)
Definition: gdbarch.c:3038
gdbarch_init_osabi
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: osabi.c:334
lr_regnum
Definition: frv-tdep.h:63
struct_return_regnum
Definition: frv-tdep.h:34
frv_pseudo_register_read
static enum register_status frv_pseudo_register_read(struct gdbarch *gdbarch, struct regcache *regcache, int reg, gdb_byte *buffer)
Definition: frv-tdep.c:298
trad_frame_get_prev_register
struct value * trad_frame_get_prev_register(struct frame_info *this_frame, struct trad_frame_saved_reg this_saved_regs[], int regnum)
Definition: trad-frame.c:142
set_variant_num_gprs
static void set_variant_num_gprs(struct gdbarch_tdep *var, int num_gprs)
Definition: frv-tdep.c:222
frv_extract_return_value
static void frv_extract_return_value(struct type *type, struct regcache *regcache, gdb_byte *valbuf)
Definition: frv-tdep.c:1110
value_as_long
LONGEST value_as_long(struct value *val)
Definition: value.c:2749
func
void(* func)(char *)
Definition: remote-fileio.c:1104
set_solib_ops
void set_solib_ops(struct gdbarch *gdbarch, const struct target_so_ops *new_ops)
Definition: solib.c:77
BMSYMBOL_VALUE_ADDRESS
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:691
trad_frame_set_value
void trad_frame_set_value(struct trad_frame_saved_reg this_saved_regs[], int regnum, LONGEST val)
Definition: trad-frame.c:99
frv_frame_align
static CORE_ADDR frv_frame_align(struct gdbarch *gdbarch, CORE_ADDR sp)
Definition: frv-tdep.c:1138
RETURN_VALUE_STRUCT_CONVENTION
Definition: defs.h:258
align_down
ULONGEST align_down(ULONGEST v, int n)
Definition: utils.c:3005
frame_unwind_register_unsigned
ULONGEST frame_unwind_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1279
set_gdbarch_short_bit
void set_gdbarch_short_bit(struct gdbarch *gdbarch, int short_bit)
Definition: gdbarch.c:1572
builtin_type
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:5217
memset
void * memset(T *s, int c, size_t n)=delete
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
gdbarch_tdep
Definition: aarch64-tdep.h:55
return_value_convention
return_value_convention
Definition: defs.h:247
frv_fdpic_find_global_pointer
CORE_ADDR frv_fdpic_find_global_pointer(CORE_ADDR addr)
Definition: solib-frv.c:920
first_spr_regnum
Definition: frv-tdep.h:47
frame_info
Definition: frame.c:85
is_caller_saves_reg
static int is_caller_saves_reg(int reg)
Definition: frv-tdep.c:478
iacc0_regnum
Definition: frv-tdep.h:87
gdbarch_list_lookup_by_info
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
Definition: gdbarch.c:5309
set_gdbarch_deprecated_fp_regnum
void set_gdbarch_deprecated_fp_regnum(struct gdbarch *gdbarch, int deprecated_fp_regnum)
Definition: gdbarch.c:2357
register_status
register_status
Definition: common-regcache.h:25
skip_prologue_using_sal
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
Definition: symtab.c:3854
gdbarch_num_regs
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:2039
new_variant
static struct gdbarch_tdep * new_variant(void)
Definition: frv-tdep.c:132
accg0123_regnum
Definition: frv-tdep.h:70
_
#define _(String)
Definition: gdb_locale.h:35
gdbarch_info::bfd_arch_info
const struct bfd_arch_info * bfd_arch_info
Definition: gdbarch.h:1629
scr3_regnum
Definition: frv-tdep.h:62
defs.h
gdbarch_tdep
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
Definition: gdbarch.c:1491
frv_abi
frv_abi
Definition: frv-tdep.h:20
msr1_regnum
Definition: frv-tdep.h:73
frame_unwind_append_unwinder
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:79
get_current_regcache
struct regcache * get_current_regcache(void)
Definition: regcache.c:446
builtin_type::builtin_int32
struct type * builtin_int32
Definition: gdbtypes.h:1538
frv_unwind_cache::saved_regs
struct trad_frame_saved_reg * saved_regs
Definition: frv-tdep.c:52
gdbarch_tdep::num_hw_watchpoints
int num_hw_watchpoints
Definition: frv-tdep.c:82
FRAME_OBSTACK_ZALLOC
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:678
tbr_regnum
Definition: frv-tdep.h:53
objfiles.h
frv_store_return_value
static void frv_store_return_value(struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
Definition: frv-tdep.c:1320
arch-utils.h
frv_frame_unwind
static const struct frame_unwind frv_frame_unwind
Definition: frv-tdep.c:1417
frv_analyze_prologue
static CORE_ADDR frv_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR pc, struct frame_info *this_frame, struct frv_unwind_cache *info)
Definition: frv-tdep.c:515
set_variant_num_fprs
static void set_variant_num_fprs(struct gdbarch_tdep *var, int num_fprs)
Definition: frv-tdep.c:241
fp_regnum
Definition: frv-tdep.h:33
frv_num_pseudo_regs
Definition: frv-tdep.h:92
accg0_regnum
Definition: frv-tdep.h:88
gdbarch_tdep::frv_abi
enum frv_abi frv_abi
Definition: frv-tdep.c:73
symtab.h
frame_base_set_default
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
Definition: frame-base.c:95
set_gdbarch_pseudo_register_write
void set_gdbarch_pseudo_register_write(struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype pseudo_register_write)
Definition: gdbarch.c:2032
fner0_regnum
Definition: frv-tdep.h:76
set_gdbarch_register_type
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype register_type)
Definition: gdbarch.c:2316
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
frv_frame_prev_register
static struct value * frv_frame_prev_register(struct frame_info *this_frame, void **this_prologue_cache, int regnum)
Definition: frv-tdep.c:1409
NORMAL_FRAME
Definition: frame.h:244
FRV_ABI_EABI
Definition: frv-tdep.h:22
value_contents
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1407
fner1_regnum
Definition: frv-tdep.h:77
get_target_memory_unsigned
ULONGEST get_target_memory_unsigned(struct target_ops *ops, CORE_ADDR addr, int len, enum bfd_endian byte_order)
Definition: target.c:1974
frv_frame_this_id
static void frv_frame_this_id(struct frame_info *this_frame, void **this_prologue_cache, struct frame_id *this_id)
Definition: frv-tdep.c:1379
find_pc_line
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3288
trad-frame.h
target_ops
Definition: target.h:412
dbar0_regnum
Definition: frv-tdep.h:55
gdbarch_tdep::num_gprs
int num_gprs
Definition: frv-tdep.c:76
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
regcache_cooked_read_unsigned
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:777
osabi.h
regcache.h
set_gdbarch_sp_regnum
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
Definition: gdbarch.c:2156
bound_minimal_symbol
Definition: minsyms.h:29
frv_fetch_objfile_link_map
CORE_ADDR frv_fetch_objfile_link_map(struct objfile *objfile)
Definition: solib-frv.c:1128
gdbarch_info::abfd
bfd * abfd
Definition: gdbarch.h:1637
set_gdbarch_dummy_id
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype dummy_id)
Definition: gdbarch.c:2340
struct_return
struct_return
Definition: arm-tdep.h:88
set_variant_abi_fdpic
static void set_variant_abi_fdpic(struct gdbarch_tdep *var)
Definition: frv-tdep.c:257
frame.h
gdb_assert_not_reached
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:55
frv_instr_size
static const int frv_instr_size
Definition: frv-linux-tdep.c:36
set_gdbarch_adjust_breakpoint_address
void set_gdbarch_adjust_breakpoint_address(struct gdbarch *gdbarch, gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address)
Definition: gdbarch.c:2929
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
inferior.h
set_gdbarch_register_sim_regno
void set_gdbarch_register_sim_regno(struct gdbarch *gdbarch, gdbarch_register_sim_regno_ftype register_sim_regno)
Definition: gdbarch.c:2514
TYPE_CODE_UNION
Definition: gdbtypes.h:107
type
Definition: gdbtypes.h:749
find_pc_partial_function
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:320
sim-regno.h
frame-unwind.h
frv_return_value
static enum return_value_convention frv_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: frv-tdep.c:1343
set_gdbarch_unwind_pc
void set_gdbarch_unwind_pc(struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype unwind_pc)
Definition: gdbarch.c:3079
iacc0h_regnum
Definition: frv-tdep.h:65
default_frame_sniffer
int default_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
Definition: frame-unwind.c:174
BP_MANIPULATION
typedef BP_MANIPULATION(frv_break_insn)
Definition: frv-tdep.c:427
solib.h
status
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition: gnu-nat.c:1822
frv_push_dummy_call
static CORE_ADDR frv_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
Definition: frv-tdep.c:1193
iacc0l_regnum
Definition: frv-tdep.h:66
set_gdbarch_unwind_sp
void set_gdbarch_unwind_sp(struct gdbarch *gdbarch, gdbarch_unwind_sp_ftype unwind_sp)
Definition: gdbarch.c:3103
pc_regnum
Definition: frv-tdep.h:43
frv_frame_base_address
static CORE_ADDR frv_frame_base_address(struct frame_info *this_frame, void **this_cache)
Definition: frv-tdep.c:1427
xstrprintf
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
gdbarch_list::gdbarch
struct gdbarch * gdbarch
Definition: gdbarch.h:1622
set_gdbarch_convert_from_func_ptr_addr
void set_gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
Definition: gdbarch.c:3201
regnum
int regnum
Definition: aarch64-tdep.c:77
frame_base
Definition: frame-base.h:58
get_frame_register_unsigned
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1308
xmalloc
void * xmalloc(YYSIZE_T)
frv_register_name
static const char * frv_register_name(struct gdbarch *gdbarch, int reg)
Definition: frv-tdep.c:275
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
frame-base.h
set_gdbarch_breakpoint_kind_from_pc
void set_gdbarch_breakpoint_kind_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_pc_ftype breakpoint_kind_from_pc)
Definition: gdbarch.c:2871
trad_frame_alloc_saved_regs
struct trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct gdbarch *gdbarch)
Definition: trad-frame.c:47
frv_unwind_sp
static CORE_ADDR frv_unwind_sp(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: frv-tdep.c:1442
set_gdbarch_long_long_bit
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
Definition: gdbarch.c:1623
TYPE_CODE_FUNC
Definition: gdbtypes.h:110
reg
Definition: regdef.h:22
psr_regnum
Definition: frv-tdep.h:48
ccr_regnum
Definition: frv-tdep.h:49
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
value
Definition: value.c:169
gdbarch_tdep::register_names
const char ** register_names
Definition: frv-tdep.c:88
acc7_regnum
Definition: frv-tdep.h:69
first_fpr_regnum
Definition: frv-tdep.h:39
trad_frame_saved_reg::addr
LONGEST addr
Definition: trad-frame.h:83
frv-tdep.h
frv_frame_unwind_cache
static struct frv_unwind_cache * frv_frame_unwind_cache(struct frame_info *this_frame, void **this_prologue_cache)
Definition: frv-tdep.c:1089
symtab_and_line
Definition: symtab.h:1746
fsr0_regnum
Definition: frv-tdep.h:67
is_callee_saves_reg
static int is_callee_saves_reg(int reg)
Definition: frv-tdep.c:488
TYPE_CODE_PTR
Definition: gdbtypes.h:84
core_addr_lessthan
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
Definition: arch-utils.c:117
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
fdpic_loadmap_exec_regnum
Definition: frv-tdep.h:51
_initialize_frv_tdep
void _initialize_frv_tdep(void)
Definition: frv-tdep.c:1603
set_gdbarch_pseudo_register_read
void set_gdbarch_pseudo_register_read(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype pseudo_register_read)
Definition: gdbarch.c:1984
align_up
ULONGEST align_up(ULONGEST v, int n)
Definition: utils.c:2997
TYPE_TARGET_TYPE
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1226
lookup_minimal_symbol_by_pc
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:928
first_gpr_regnum
Definition: frv-tdep.h:31
scr0_regnum
Definition: frv-tdep.h:59
XCNEW
#define XCNEW(T)
Definition: poison.h:121
gdbcore.h
dbar3_regnum
Definition: frv-tdep.h:58
xsnprintf
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
regcache_raw_read
enum register_status regcache_raw_read(struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: regcache.c:565
regcache_cooked_write_unsigned
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition: regcache.c:806
target_read_memory
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1370
SIM_REGNO_DOES_NOT_EXIST
Definition: sim-regno.h:33
FRV_ABI_FDPIC
Definition: frv-tdep.h:23
find_function_addr
CORE_ADDR find_function_addr(struct value *function, struct type **retval_type)
Definition: infcall.c:250
set_gdbarch_int_bit
void set_gdbarch_int_bit(struct gdbarch *gdbarch, int int_bit)
Definition: gdbarch.c:1589
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
frv_register_sim_regno
static int frv_register_sim_regno(struct gdbarch *gdbarch, int reg)
Definition: frv-tdep.c:359
frv_break_insn
constexpr gdb_byte frv_break_insn[]
Definition: frv-tdep.c:425
frv_num_regs
Definition: frv-tdep.h:81
frv_pseudo_register_write
static void frv_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int reg, const gdb_byte *buffer)
Definition: frv-tdep.c:335
frv_fdpic_find_canonical_descriptor
CORE_ADDR frv_fdpic_find_canonical_descriptor(CORE_ADDR entry_point)
Definition: solib-frv.c:955
frv_unwind_pc
static CORE_ADDR frv_unwind_pc(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: frv-tdep.c:1370
offset
int offset
Definition: agent.c:65
buffer
Definition: buffer.h:23
set_gdbarch_num_pseudo_regs
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
Definition: gdbarch.c:2067
regcache::arch
gdbarch * arch() const
Definition: regcache.c:221
is_argument_reg
static int is_argument_reg(int reg)
Definition: frv-tdep.c:497
symtab_and_line::pc
CORE_ADDR pc
Definition: symtab.h:1759
extract_signed_integer
static LONGEST extract_signed_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:570
frv_so_ops
struct target_so_ops frv_so_ops
Definition: solib-frv.c:1154
gdbarch_tdep::num_fprs
int num_fprs
Definition: frv-tdep.c:79
lcr_regnum
Definition: frv-tdep.h:64
frame_unwind
Definition: frame-unwind.h:144
last_gpr_regnum
Definition: frv-tdep.h:35
last_fpr_regnum
Definition: frv-tdep.h:40
msr0_regnum
Definition: frv-tdep.h:72
gner1_regnum
Definition: frv-tdep.h:75
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
gdbarch_tdep::num_hw_breakpoints
int num_hw_breakpoints
Definition: frv-tdep.c:85
default_frame_unwind_stop_reason
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
Definition: frame-unwind.c:184
find_func_descr
static CORE_ADDR find_func_descr(struct gdbarch *gdbarch, CORE_ADDR entry_point)
Definition: frv-tdep.c:1145
value_allocate_space_in_inferior
struct value * value_allocate_space_in_inferior(int len)
Definition: valops.c:185
regcache
Definition: regcache.h:232
gdbarch_info
Definition: gdbarch.h:1626
set_gdbarch_long_double_bit
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
Definition: gdbarch.c:1756
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
builtin_type::builtin_int64
struct type * builtin_int64
Definition: gdbtypes.h:1540
set_gdbarch_long_bit
void set_gdbarch_long_bit(struct gdbarch *gdbarch, int long_bit)
Definition: gdbarch.c:1606
set_gdbarch_return_value
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
Definition: gdbarch.c:2738
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
set_gdbarch_ptr_bit
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
Definition: gdbarch.c:1841
set_gdbarch_push_dummy_call
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype push_dummy_call)
Definition: gdbarch.c:2381
frv_unwind_cache::prev_sp
CORE_ADDR prev_sp
Definition: frv-tdep.c:46
cccr_regnum
Definition: frv-tdep.h:50
frv_skip_prologue
static CORE_ADDR frv_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: frv-tdep.c:977
get_pc_function_start
CORE_ADDR get_pc_function_start(CORE_ADDR pc)
Definition: blockframe.c:86
frv_gdbarch_init
static struct gdbarch * frv_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
Definition: frv-tdep.c:1460
set_gdbarch_sw_breakpoint_from_kind
void set_gdbarch_sw_breakpoint_from_kind(struct gdbarch *gdbarch, gdbarch_sw_breakpoint_from_kind_ftype sw_breakpoint_from_kind)
Definition: gdbarch.c:2888
register_gdbarch_init
void register_gdbarch_init(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init)
Definition: gdbarch.c:5299
write_memory
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:394
set_gdbarch_skip_prologue
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype skip_prologue)
Definition: gdbarch.c:2772
value_address
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1529
lookup_minimal_symbol
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:311
RETURN_VALUE_REGISTER_CONVENTION
Definition: defs.h:251
gdbarch::byte_order
enum bfd_endian byte_order
Definition: gdbarch.c:137
set_gdbarch_pc_regnum
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
Definition: gdbarch.c:2173
frv_dummy_id
static struct frame_id frv_dummy_id(struct gdbarch *gdbarch, struct frame_info *this_frame)
Definition: frv-tdep.c:1453
trad_frame_saved_reg
Definition: trad-frame.h:81
set_gdbarch_register_name
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype register_name)
Definition: gdbarch.c:2292
get_frame_func
CORE_ADDR get_frame_func(struct frame_info *this_frame)
Definition: frame.c:1001
frv_skip_main_prologue
static CORE_ADDR frv_skip_main_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: frv-tdep.c:1013
gdbarch_alloc
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, struct gdbarch_tdep *tdep)
Definition: gdbarch.c:361
set_gdbarch_inner_than
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype inner_than)
Definition: gdbarch.c:2837
frame_id
Definition: frame.h:111
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
LONGEST
long long LONGEST
Definition: common-types.h:52
regcache_cooked_write
void regcache_cooked_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: regcache.c:873
gdbarch_tdep::elf_flags
int elf_flags
Definition: m68hc11-tdep.c:142
dbar2_regnum
Definition: frv-tdep.h:57
brr_regnum
Definition: frv-tdep.h:54
builtin_type::builtin_float
struct type * builtin_float
Definition: gdbtypes.h:1510
store_unsigned_integer
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition: defs.h:604
regcache_raw_write
void regcache_raw_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: regcache.c:831
gdbarch_list
Definition: gdbarch.h:1620