GDB (xrefs)
Loading...
Searching...
No Matches
m32r-tdep.c
Go to the documentation of this file.
1/* Target-dependent code for Renesas M32R, for GDB.
2
3 Copyright (C) 1996-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 "m32r-tdep.h"
39#include <algorithm>
40
41/* The size of the argument registers (r0 - r3) in bytes. */
42#define M32R_ARG_REGISTER_SIZE 4
43
44/* Local functions */
45
46static CORE_ADDR
47m32r_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
48{
49 /* Align to the size of an instruction (so that they can safely be
50 pushed onto the stack. */
51 return sp & ~3;
52}
53
54
55/* Breakpoints
56
57 The little endian mode of M32R is unique. In most of architectures,
58 two 16-bit instructions, A and B, are placed as the following:
59
60 Big endian:
61 A0 A1 B0 B1
62
63 Little endian:
64 A1 A0 B1 B0
65
66 In M32R, they are placed like this:
67
68 Big endian:
69 A0 A1 B0 B1
70
71 Little endian:
72 B1 B0 A1 A0
73
74 This is because M32R always fetches instructions in 32-bit.
75
76 The following functions take care of this behavior. */
77
78static int
80 struct bp_target_info *bp_tgt)
81{
82 CORE_ADDR addr = bp_tgt->placed_address = bp_tgt->reqstd_address;
83 int val;
84 gdb_byte buf[4];
85 gdb_byte contents_cache[4];
86 gdb_byte bp_entry[] = { 0x10, 0xf1 }; /* dpt */
87
88 /* Save the memory contents. */
89 val = target_read_memory (addr & 0xfffffffc, contents_cache, 4);
90 if (val != 0)
91 return val; /* return error */
92
93 memcpy (bp_tgt->shadow_contents, contents_cache, 4);
94 bp_tgt->shadow_len = 4;
95
96 /* Determine appropriate breakpoint contents and size for this address. */
97 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
98 {
99 if ((addr & 3) == 0)
100 {
101 buf[0] = bp_entry[0];
102 buf[1] = bp_entry[1];
103 buf[2] = contents_cache[2] & 0x7f;
104 buf[3] = contents_cache[3];
105 }
106 else
107 {
108 buf[0] = contents_cache[0];
109 buf[1] = contents_cache[1];
110 buf[2] = bp_entry[0];
111 buf[3] = bp_entry[1];
112 }
113 }
114 else /* little-endian */
115 {
116 if ((addr & 3) == 0)
117 {
118 buf[0] = contents_cache[0];
119 buf[1] = contents_cache[1] & 0x7f;
120 buf[2] = bp_entry[1];
121 buf[3] = bp_entry[0];
122 }
123 else
124 {
125 buf[0] = bp_entry[1];
126 buf[1] = bp_entry[0];
127 buf[2] = contents_cache[2];
128 buf[3] = contents_cache[3];
129 }
130 }
131
132 /* Write the breakpoint. */
133 val = target_write_memory (addr & 0xfffffffc, buf, 4);
134 return val;
135}
136
137static int
139 struct bp_target_info *bp_tgt)
140{
141 CORE_ADDR addr = bp_tgt->placed_address;
142 int val;
143 gdb_byte buf[4];
144 gdb_byte *contents_cache = bp_tgt->shadow_contents;
145
146 buf[0] = contents_cache[0];
147 buf[1] = contents_cache[1];
148 buf[2] = contents_cache[2];
149 buf[3] = contents_cache[3];
150
151 /* Remove parallel bit. */
152 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
153 {
154 if ((buf[0] & 0x80) == 0 && (buf[2] & 0x80) != 0)
155 buf[2] &= 0x7f;
156 }
157 else /* little-endian */
158 {
159 if ((buf[3] & 0x80) == 0 && (buf[1] & 0x80) != 0)
160 buf[1] &= 0x7f;
161 }
162
163 /* Write contents. */
164 val = target_write_raw_memory (addr & 0xfffffffc, buf, 4);
165 return val;
166}
167
168/* Implement the breakpoint_kind_from_pc gdbarch method. */
169
170static int
172{
173 if ((*pcptr & 3) == 0)
174 return 4;
175 else
176 return 2;
177}
178
179/* Implement the sw_breakpoint_from_kind gdbarch method. */
180
181static const gdb_byte *
183{
184 static gdb_byte be_bp_entry[] = {
185 0x10, 0xf1, 0x70, 0x00
186 }; /* dpt -> nop */
187 static gdb_byte le_bp_entry[] = {
188 0x00, 0x70, 0xf1, 0x10
189 }; /* dpt -> nop */
190
191 *size = kind;
192
193 /* Determine appropriate breakpoint. */
194 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
195 return be_bp_entry;
196 else
197 {
198 if (kind == 4)
199 return le_bp_entry;
200 else
201 return le_bp_entry + 2;
202 }
203}
204
205static const char * const m32r_register_names[] = {
206 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
207 "r8", "r9", "r10", "r11", "r12", "fp", "lr", "sp",
208 "psw", "cbr", "spi", "spu", "bpc", "pc", "accl", "acch",
209 "evb"
210};
211
212static const char *
213m32r_register_name (struct gdbarch *gdbarch, int reg_nr)
214{
216 return m32r_register_names[reg_nr];
217}
218
219
220/* Return the GDB type object for the "standard" data type
221 of data in register N. */
222
223static struct type *
224m32r_register_type (struct gdbarch *gdbarch, int reg_nr)
225{
226 if (reg_nr == M32R_PC_REGNUM)
228 else if (reg_nr == M32R_SP_REGNUM || reg_nr == M32R_FP_REGNUM)
230 else
232}
233
234
235/* Write into appropriate registers a function return value
236 of type TYPE, given in virtual format.
237
238 Things always get returned in RET1_REGNUM, RET2_REGNUM. */
239
240static void
242 const gdb_byte *valbuf)
243{
244 struct gdbarch *gdbarch = regcache->arch ();
245 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
246 CORE_ADDR regval;
247 int len = type->length ();
248
249 regval = extract_unsigned_integer (valbuf, len > 4 ? 4 : len, byte_order);
251
252 if (len > 4)
253 {
254 regval = extract_unsigned_integer (valbuf + 4,
255 len - 4, byte_order);
257 }
258}
259
260/* This is required by skip_prologue. The results of decoding a prologue
261 should be cached because this thrashing is getting nuts. */
262
263static int
265 CORE_ADDR start_pc, CORE_ADDR scan_limit,
266 CORE_ADDR *pl_endptr, unsigned long *framelength)
267{
268 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
269 unsigned long framesize;
270 int insn;
271 int op1;
272 CORE_ADDR after_prologue = 0;
273 CORE_ADDR after_push = 0;
274 CORE_ADDR after_stack_adjust = 0;
275 CORE_ADDR current_pc;
276 LONGEST return_value;
277
278 framesize = 0;
279 after_prologue = 0;
280
281 for (current_pc = start_pc; current_pc < scan_limit; current_pc += 2)
282 {
283 /* Check if current pc's location is readable. */
284 if (!safe_read_memory_integer (current_pc, 2, byte_order, &return_value))
285 return -1;
286
287 insn = read_memory_unsigned_integer (current_pc, 2, byte_order);
288
289 if (insn == 0x0000)
290 break;
291
292 /* If this is a 32 bit instruction, we dont want to examine its
293 immediate data as though it were an instruction. */
294 if (current_pc & 0x02)
295 {
296 /* Decode this instruction further. */
297 insn &= 0x7fff;
298 }
299 else
300 {
301 if (insn & 0x8000)
302 {
303 if (current_pc == scan_limit)
304 scan_limit += 2; /* extend the search */
305
306 current_pc += 2; /* skip the immediate data */
307
308 /* Check if current pc's location is readable. */
309 if (!safe_read_memory_integer (current_pc, 2, byte_order,
310 &return_value))
311 return -1;
312
313 if (insn == 0x8faf) /* add3 sp, sp, xxxx */
314 /* add 16 bit sign-extended offset */
315 {
316 framesize +=
317 -((short) read_memory_unsigned_integer (current_pc,
318 2, byte_order));
319 }
320 else
321 {
322 if (((insn >> 8) == 0xe4) /* ld24 r4, xxxxxx; sub sp, r4 */
323 && safe_read_memory_integer (current_pc + 2,
324 2, byte_order,
325 &return_value)
326 && read_memory_unsigned_integer (current_pc + 2,
327 2, byte_order)
328 == 0x0f24)
329 {
330 /* Subtract 24 bit sign-extended negative-offset. */
331 insn = read_memory_unsigned_integer (current_pc - 2,
332 4, byte_order);
333 if (insn & 0x00800000) /* sign extend */
334 insn |= 0xff000000; /* negative */
335 else
336 insn &= 0x00ffffff; /* positive */
337 framesize += insn;
338 }
339 }
340 after_push = current_pc + 2;
341 continue;
342 }
343 }
344 op1 = insn & 0xf000; /* Isolate just the first nibble. */
345
346 if ((insn & 0xf0ff) == 0x207f)
347 { /* st reg, @-sp */
348 framesize += 4;
349 after_prologue = 0;
350 continue;
351 }
352 if ((insn >> 8) == 0x4f) /* addi sp, xx */
353 /* Add 8 bit sign-extended offset. */
354 {
355 int stack_adjust = (signed char) (insn & 0xff);
356
357 /* there are probably two of these stack adjustments:
358 1) A negative one in the prologue, and
359 2) A positive one in the epilogue.
360 We are only interested in the first one. */
361
362 if (stack_adjust < 0)
363 {
364 framesize -= stack_adjust;
365 after_prologue = 0;
366 /* A frameless function may have no "mv fp, sp".
367 In that case, this is the end of the prologue. */
368 after_stack_adjust = current_pc + 2;
369 }
370 continue;
371 }
372 if (insn == 0x1d8f)
373 { /* mv fp, sp */
374 after_prologue = current_pc + 2;
375 break; /* end of stack adjustments */
376 }
377
378 /* Nop looks like a branch, continue explicitly. */
379 if (insn == 0x7000)
380 {
381 after_prologue = current_pc + 2;
382 continue; /* nop occurs between pushes. */
383 }
384 /* End of prolog if any of these are trap instructions. */
385 if ((insn & 0xfff0) == 0x10f0)
386 {
387 after_prologue = current_pc;
388 break;
389 }
390 /* End of prolog if any of these are branch instructions. */
391 if ((op1 == 0x7000) || (op1 == 0xb000) || (op1 == 0xf000))
392 {
393 after_prologue = current_pc;
394 continue;
395 }
396 /* Some of the branch instructions are mixed with other types. */
397 if (op1 == 0x1000)
398 {
399 int subop = insn & 0x0ff0;
400 if ((subop == 0x0ec0) || (subop == 0x0fc0))
401 {
402 after_prologue = current_pc;
403 continue; /* jmp , jl */
404 }
405 }
406 }
407
408 if (framelength)
409 *framelength = framesize;
410
411 if (current_pc >= scan_limit)
412 {
413 if (pl_endptr)
414 {
415 if (after_stack_adjust != 0)
416 /* We did not find a "mv fp,sp", but we DID find
417 a stack_adjust. Is it safe to use that as the
418 end of the prologue? I just don't know. */
419 {
420 *pl_endptr = after_stack_adjust;
421 }
422 else if (after_push != 0)
423 /* We did not find a "mv fp,sp", but we DID find
424 a push. Is it safe to use that as the
425 end of the prologue? I just don't know. */
426 {
427 *pl_endptr = after_push;
428 }
429 else
430 /* We reached the end of the loop without finding the end
431 of the prologue. No way to win -- we should report
432 failure. The way we do that is to return the original
433 start_pc. GDB will set a breakpoint at the start of
434 the function (etc.) */
435 *pl_endptr = start_pc;
436 }
437 return 0;
438 }
439
440 if (after_prologue == 0)
441 after_prologue = current_pc;
442
443 if (pl_endptr)
444 *pl_endptr = after_prologue;
445
446 return 0;
447} /* decode_prologue */
448
449/* Function: skip_prologue
450 Find end of function prologue. */
451
452#define DEFAULT_SEARCH_LIMIT 128
453
454static CORE_ADDR
455m32r_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
456{
457 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
458 CORE_ADDR func_addr, func_end;
459 struct symtab_and_line sal;
460 LONGEST return_value;
461
462 /* See what the symbol table says. */
463
464 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
465 {
466 sal = find_pc_line (func_addr, 0);
467
468 if (sal.line != 0 && sal.end <= func_end)
469 {
470 func_end = sal.end;
471 }
472 else
473 /* Either there's no line info, or the line after the prologue is after
474 the end of the function. In this case, there probably isn't a
475 prologue. */
476 {
477 func_end = std::min (func_end, func_addr + DEFAULT_SEARCH_LIMIT);
478 }
479 }
480 else
481 func_end = pc + DEFAULT_SEARCH_LIMIT;
482
483 /* If pc's location is not readable, just quit. */
484 if (!safe_read_memory_integer (pc, 4, byte_order, &return_value))
485 return pc;
486
487 /* Find the end of prologue. */
488 if (decode_prologue (gdbarch, pc, func_end, &sal.end, NULL) < 0)
489 return pc;
490
491 return sal.end;
492}
493
495{
496 /* The previous frame's inner most stack address. Used as this
497 frame ID's stack_addr. */
498 CORE_ADDR prev_sp;
499 /* The frame's base, optionally used by the high-level debug info. */
500 CORE_ADDR base;
501 int size;
502 /* How far the SP and r13 (FP) have been offset from the start of
503 the stack frame (as defined by the previous frame's stack
504 pointer). */
505 LONGEST sp_offset;
506 LONGEST r13_offset;
508 /* Table indicating the location of each and every register. */
510};
511
512/* Put here the code to store, into fi->saved_regs, the addresses of
513 the saved registers of frame described by FRAME_INFO. This
514 includes special registers such as pc and fp saved in special ways
515 in the stack frame. sp is even more special: the address we return
516 for it IS the sp for the next frame. */
517
518static struct m32r_unwind_cache *
520 void **this_prologue_cache)
521{
522 CORE_ADDR pc, scan_limit;
523 ULONGEST prev_sp;
524 ULONGEST this_base;
525 unsigned long op;
526 int i;
527 struct m32r_unwind_cache *info;
528
529
530 if ((*this_prologue_cache))
531 return (struct m32r_unwind_cache *) (*this_prologue_cache);
532
534 (*this_prologue_cache) = info;
535 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
536
537 info->size = 0;
538 info->sp_offset = 0;
539 info->uses_frame = 0;
540
541 scan_limit = get_frame_pc (this_frame);
542 for (pc = get_frame_func (this_frame);
543 pc > 0 && pc < scan_limit; pc += 2)
544 {
545 if ((pc & 2) == 0)
546 {
547 op = get_frame_memory_unsigned (this_frame, pc, 4);
548 if ((op & 0x80000000) == 0x80000000)
549 {
550 /* 32-bit instruction */
551 if ((op & 0xffff0000) == 0x8faf0000)
552 {
553 /* add3 sp,sp,xxxx */
554 short n = op & 0xffff;
555 info->sp_offset += n;
556 }
557 else if (((op >> 8) == 0xe4)
558 && get_frame_memory_unsigned (this_frame, pc + 2,
559 2) == 0x0f24)
560 {
561 /* ld24 r4, xxxxxx; sub sp, r4 */
562 unsigned long n = op & 0xffffff;
563 info->sp_offset += n;
564 pc += 2; /* skip sub instruction */
565 }
566
567 if (pc == scan_limit)
568 scan_limit += 2; /* extend the search */
569 pc += 2; /* skip the immediate data */
570 continue;
571 }
572 }
573
574 /* 16-bit instructions */
575 op = get_frame_memory_unsigned (this_frame, pc, 2) & 0x7fff;
576 if ((op & 0xf0ff) == 0x207f)
577 {
578 /* st rn, @-sp */
579 int regno = ((op >> 8) & 0xf);
580 info->sp_offset -= 4;
581 info->saved_regs[regno].set_addr (info->sp_offset);
582 }
583 else if ((op & 0xff00) == 0x4f00)
584 {
585 /* addi sp, xx */
586 int n = (signed char) (op & 0xff);
587 info->sp_offset += n;
588 }
589 else if (op == 0x1d8f)
590 {
591 /* mv fp, sp */
592 info->uses_frame = 1;
593 info->r13_offset = info->sp_offset;
594 break; /* end of stack adjustments */
595 }
596 else if ((op & 0xfff0) == 0x10f0)
597 {
598 /* End of prologue if this is a trap instruction. */
599 break; /* End of stack adjustments. */
600 }
601 }
602
603 info->size = -info->sp_offset;
604
605 /* Compute the previous frame's stack pointer (which is also the
606 frame's ID's stack address), and this frame's base pointer. */
607 if (info->uses_frame)
608 {
609 /* The SP was moved to the FP. This indicates that a new frame
610 was created. Get THIS frame's FP value by unwinding it from
611 the next frame. */
612 this_base = get_frame_register_unsigned (this_frame, M32R_FP_REGNUM);
613 /* The FP points at the last saved register. Adjust the FP back
614 to before the first saved register giving the SP. */
615 prev_sp = this_base + info->size;
616 }
617 else
618 {
619 /* Assume that the FP is this frame's SP but with that pushed
620 stack space added back. */
621 this_base = get_frame_register_unsigned (this_frame, M32R_SP_REGNUM);
622 prev_sp = this_base + info->size;
623 }
624
625 /* Convert that SP/BASE into real addresses. */
626 info->prev_sp = prev_sp;
627 info->base = this_base;
628
629 /* Adjust all the saved registers so that they contain addresses and
630 not offsets. */
631 for (i = 0; i < gdbarch_num_regs (get_frame_arch (this_frame)) - 1; i++)
632 if (info->saved_regs[i].is_addr ())
633 info->saved_regs[i].set_addr (info->prev_sp
634 + info->saved_regs[i].addr ());
635
636 /* The call instruction moves the caller's PC in the callee's LR.
637 Since this is an unwind, do the reverse. Copy the location of LR
638 into PC (the address / regnum) so that a request for PC will be
639 converted into a request for the LR. */
640 info->saved_regs[M32R_PC_REGNUM] = info->saved_regs[LR_REGNUM];
641
642 /* The previous frame's SP needed to be computed. Save the computed
643 value. */
644 info->saved_regs[M32R_SP_REGNUM].set_value (prev_sp);
645
646 return info;
647}
648
649static CORE_ADDR
650m32r_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
651 struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
652 struct value **args, CORE_ADDR sp,
653 function_call_return_method return_method,
654 CORE_ADDR struct_addr)
655{
656 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
657 int stack_offset, stack_alloc;
658 int argreg = ARG1_REGNUM;
659 int argnum;
660 struct type *type;
661 enum type_code typecode;
662 CORE_ADDR regval;
663 gdb_byte *val;
664 gdb_byte valbuf[M32R_ARG_REGISTER_SIZE];
665 int len;
666
667 /* First force sp to a 4-byte alignment. */
668 sp = sp & ~3;
669
670 /* Set the return address. For the m32r, the return breakpoint is
671 always at BP_ADDR. */
673
674 /* If STRUCT_RETURN is true, then the struct return address (in
675 STRUCT_ADDR) will consume the first argument-passing register.
676 Both adjust the register count and store that value. */
677 if (return_method == return_method_struct)
678 {
679 regcache_cooked_write_unsigned (regcache, argreg, struct_addr);
680 argreg++;
681 }
682
683 /* Now make sure there's space on the stack. */
684 for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)
685 stack_alloc += ((args[argnum]->type ()->length () + 3) & ~3);
686 sp -= stack_alloc; /* Make room on stack for args. */
687
688 for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
689 {
690 type = args[argnum]->type ();
691 typecode = type->code ();
692 len = type->length ();
693
694 memset (valbuf, 0, sizeof (valbuf));
695
696 /* Passes structures that do not fit in 2 registers by reference. */
697 if (len > 8
698 && (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION))
699 {
700 store_unsigned_integer (valbuf, 4, byte_order,
701 args[argnum]->address ());
702 typecode = TYPE_CODE_PTR;
703 len = 4;
704 val = valbuf;
705 }
706 else if (len < 4)
707 {
708 /* Value gets right-justified in the register or stack word. */
709 memcpy (valbuf + (register_size (gdbarch, argreg) - len),
710 (gdb_byte *) args[argnum]->contents ().data (), len);
711 val = valbuf;
712 }
713 else
714 val = (gdb_byte *) args[argnum]->contents ().data ();
715
716 while (len > 0)
717 {
718 if (argreg > ARGN_REGNUM)
719 {
720 /* Must go on the stack. */
721 write_memory (sp + stack_offset, val, 4);
722 stack_offset += 4;
723 }
724 else if (argreg <= ARGN_REGNUM)
725 {
726 /* There's room in a register. */
727 regval =
729 register_size (gdbarch, argreg),
730 byte_order);
731 regcache_cooked_write_unsigned (regcache, argreg++, regval);
732 }
733
734 /* Store the value 4 bytes at a time. This means that things
735 larger than 4 bytes may go partly in registers and partly
736 on the stack. */
737 len -= register_size (gdbarch, argreg);
738 val += register_size (gdbarch, argreg);
739 }
740 }
741
742 /* Finally, update the SP register. */
744
745 return sp;
746}
747
748
749/* Given a return value in `regbuf' with a type `valtype',
750 extract and copy its value into `valbuf'. */
751
752static void
754 gdb_byte *dst)
755{
756 struct gdbarch *gdbarch = regcache->arch ();
757 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
758 int len = type->length ();
759 ULONGEST tmp;
760
761 /* By using store_unsigned_integer we avoid having to do
762 anything special for small big-endian values. */
764 store_unsigned_integer (dst, (len > 4 ? len - 4 : len), byte_order, tmp);
765
766 /* Ignore return values more than 8 bytes in size because the m32r
767 returns anything more than 8 bytes in the stack. */
768 if (len > 4)
769 {
771 store_unsigned_integer (dst + len - 4, 4, byte_order, tmp);
772 }
773}
774
775static enum return_value_convention
776m32r_return_value (struct gdbarch *gdbarch, struct value *function,
777 struct type *valtype, struct regcache *regcache,
778 gdb_byte *readbuf, const gdb_byte *writebuf)
779{
780 if (valtype->length () > 8)
782 else
783 {
784 if (readbuf != NULL)
785 m32r_extract_return_value (valtype, regcache, readbuf);
786 if (writebuf != NULL)
787 m32r_store_return_value (valtype, regcache, writebuf);
789 }
790}
791
792/* Given a GDB frame, determine the address of the calling function's
793 frame. This will be used to create a new GDB frame struct. */
794
795static void
797 void **this_prologue_cache, struct frame_id *this_id)
798{
799 struct m32r_unwind_cache *info
800 = m32r_frame_unwind_cache (this_frame, this_prologue_cache);
801 CORE_ADDR base;
802 CORE_ADDR func;
803 struct bound_minimal_symbol msym_stack;
804 struct frame_id id;
805
806 /* The FUNC is easy. */
807 func = get_frame_func (this_frame);
808
809 /* Check if the stack is empty. */
810 msym_stack = lookup_minimal_symbol ("_stack", NULL, NULL);
811 if (msym_stack.minsym && info->base == msym_stack.value_address ())
812 return;
813
814 /* Hopefully the prologue analysis either correctly determined the
815 frame's base (which is the SP from the previous frame), or set
816 that base to "NULL". */
817 base = info->prev_sp;
818 if (base == 0)
819 return;
820
821 id = frame_id_build (base, func);
822 (*this_id) = id;
823}
824
825static struct value *
827 void **this_prologue_cache, int regnum)
828{
829 struct m32r_unwind_cache *info
830 = m32r_frame_unwind_cache (this_frame, this_prologue_cache);
831 return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
832}
833
843
844static CORE_ADDR
845m32r_frame_base_address (frame_info_ptr this_frame, void **this_cache)
846{
847 struct m32r_unwind_cache *info
848 = m32r_frame_unwind_cache (this_frame, this_cache);
849 return info->base;
850}
851
858
860
861static struct gdbarch *
863{
864 /* If there is already a candidate, use it. */
866 if (arches != NULL)
867 return arches->gdbarch;
868
869 /* Allocate space for the new architecture. */
872
875
881
884
893
895
897
898 /* Hook in ABI-specific overrides, if they have been registered. */
900
901 /* Hook in the default unwinders. */
903
904 /* Support simple overlay manager. */
906
907 return gdbarch;
908}
909
911void
int regnum
gdb_static_assert(sizeof(splay_tree_key) >=sizeof(CORE_ADDR *))
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep, gdbarch_supports_arch_info_ftype *supports_arch_info)
static std::vector< const char * > arches
Definition arch-utils.c:685
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
Definition arch-utils.c:177
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
Definition blockframe.c:373
gdbarch * arch() const
Definition regcache.c:231
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition corefile.c:347
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition corefile.c:306
int safe_read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order, LONGEST *return_value)
Definition corefile.c:264
@ ARG1_REGNUM
Definition cris-tdep.c:88
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition defs.h:515
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:480
return_value_convention
Definition defs.h:257
@ RETURN_VALUE_REGISTER_CONVENTION
Definition defs.h:260
@ RETURN_VALUE_STRUCT_CONVENTION
Definition defs.h:267
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
Definition frame-base.c:93
int default_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
enum unwind_stop_reason default_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
Definition frame.c:1399
CORE_ADDR get_frame_pc(frame_info_ptr frame)
Definition frame.c:2712
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition frame.c:736
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:3027
ULONGEST get_frame_memory_unsigned(frame_info_ptr this_frame, CORE_ADDR addr, int len)
Definition frame.c:3007
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
Definition frame.c:1098
@ NORMAL_FRAME
Definition frame.h:187
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition frame.h:825
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
void set_gdbarch_breakpoint_kind_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_pc_ftype *breakpoint_kind_from_pc)
void set_gdbarch_frame_align(struct gdbarch *gdbarch, gdbarch_frame_align_ftype *frame_align)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue)
void set_gdbarch_wchar_bit(struct gdbarch *gdbarch, int wchar_bit)
Definition gdbarch.c:1680
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_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value)
void set_gdbarch_wchar_signed(struct gdbarch *gdbarch, int wchar_signed)
Definition gdbarch.c:1698
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition gdbarch.c:1930
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than)
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
Definition gdbarch.c:2047
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
Definition gdbarch.c:2064
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type)
void set_gdbarch_memory_remove_breakpoint(struct gdbarch *gdbarch, gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint)
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition gdbarch.c:1941
void set_gdbarch_sw_breakpoint_from_kind(struct gdbarch *gdbarch, gdbarch_sw_breakpoint_from_kind_ftype *sw_breakpoint_from_kind)
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call)
void set_gdbarch_memory_insert_breakpoint(struct gdbarch *gdbarch, gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint)
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, gdbarch_tdep_up tdep)
Definition gdbarch.c:266
std::unique_ptr< gdbarch_tdep_base > gdbarch_tdep_up
Definition gdbarch.h:73
struct gdbarch * gdbarch_init_ftype(struct gdbarch_info info, struct gdbarch_list *arches)
Definition gdbarch.h:271
function_call_return_method
Definition gdbarch.h:114
@ return_method_struct
Definition gdbarch.h:126
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition gdbtypes.c:6168
type_code
Definition gdbtypes.h:82
size_t size
Definition go32-nat.c:239
static CORE_ADDR after_prologue(CORE_ADDR pc)
Definition hppa-tdep.c:1766
static int m32r_memory_remove_breakpoint(struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition m32r-tdep.c:138
static int m32r_memory_insert_breakpoint(struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition m32r-tdep.c:79
void _initialize_m32r_tdep()
Definition m32r-tdep.c:912
static const gdb_byte * m32r_sw_breakpoint_from_kind(struct gdbarch *gdbarch, int kind, int *size)
Definition m32r-tdep.c:182
#define M32R_ARG_REGISTER_SIZE
Definition m32r-tdep.c:42
static int m32r_breakpoint_kind_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr)
Definition m32r-tdep.c:171
static CORE_ADDR m32r_frame_base_address(frame_info_ptr this_frame, void **this_cache)
Definition m32r-tdep.c:845
static struct type * m32r_register_type(struct gdbarch *gdbarch, int reg_nr)
Definition m32r-tdep.c:224
static void m32r_frame_this_id(frame_info_ptr this_frame, void **this_prologue_cache, struct frame_id *this_id)
Definition m32r-tdep.c:796
static CORE_ADDR m32r_frame_align(struct gdbarch *gdbarch, CORE_ADDR sp)
Definition m32r-tdep.c:47
static void m32r_extract_return_value(struct type *type, struct regcache *regcache, gdb_byte *dst)
Definition m32r-tdep.c:753
static struct m32r_unwind_cache * m32r_frame_unwind_cache(frame_info_ptr this_frame, void **this_prologue_cache)
Definition m32r-tdep.c:519
static const struct frame_unwind m32r_frame_unwind
Definition m32r-tdep.c:834
static const char *const m32r_register_names[]
Definition m32r-tdep.c:205
static gdbarch_init_ftype m32r_gdbarch_init
Definition m32r-tdep.c:859
static const char * m32r_register_name(struct gdbarch *gdbarch, int reg_nr)
Definition m32r-tdep.c:213
static struct value * m32r_frame_prev_register(frame_info_ptr this_frame, void **this_prologue_cache, int regnum)
Definition m32r-tdep.c:826
static CORE_ADDR m32r_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, function_call_return_method return_method, CORE_ADDR struct_addr)
Definition m32r-tdep.c:650
static const struct frame_base m32r_frame_base
Definition m32r-tdep.c:852
#define DEFAULT_SEARCH_LIMIT
Definition m32r-tdep.c:452
static void m32r_store_return_value(struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
Definition m32r-tdep.c:241
static CORE_ADDR m32r_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition m32r-tdep.c:455
static int decode_prologue(struct gdbarch *gdbarch, CORE_ADDR start_pc, CORE_ADDR scan_limit, CORE_ADDR *pl_endptr, unsigned long *framelength)
Definition m32r-tdep.c:264
static enum return_value_convention m32r_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition m32r-tdep.c:776
@ M32R_SP_REGNUM
Definition m32r-tdep.h:38
@ RET1_REGNUM
Definition m32r-tdep.h:47
@ M32R_FP_REGNUM
Definition m32r-tdep.h:36
@ M32R_PC_REGNUM
Definition m32r-tdep.h:43
@ LR_REGNUM
Definition m32r-tdep.h:37
@ ARGN_REGNUM
Definition m32r-tdep.h:46
#define M32R_NUM_REGS
Definition m32r-tdep.h:50
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition minsyms.c:363
info(Component c)
Definition gdbarch.py:41
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition osabi.c:382
int register_size(struct gdbarch *gdbarch, int regnum)
Definition regcache.c:170
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition regcache.c:796
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition regcache.c:825
void(* func)(remote_target *remote, char *)
enum var_types type
Definition scm-param.c:142
CORE_ADDR value_address() const
Definition minsyms.h:41
struct minimal_symbol * minsym
Definition minsyms.h:49
gdb_byte shadow_contents[BREAKPOINT_MAX]
Definition breakpoint.h:279
CORE_ADDR placed_address
Definition breakpoint.h:266
CORE_ADDR reqstd_address
Definition breakpoint.h:269
struct type * builtin_func_ptr
Definition gdbtypes.h:2146
struct type * builtin_data_ptr
Definition gdbtypes.h:2135
struct type * builtin_int32
Definition gdbtypes.h:2119
trad_frame_saved_reg * saved_regs
Definition m32r-tdep.c:509
CORE_ADDR prev_sp
Definition m32r-tdep.c:498
CORE_ADDR pc
Definition symtab.h:2337
CORE_ADDR end
Definition symtab.h:2338
type_code code() const
Definition gdbtypes.h:956
ULONGEST length() const
Definition gdbtypes.h:983
Definition value.h:130
void simple_overlay_update(struct obj_section *osect)
Definition symfile.c:3542
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition symtab.c:3295
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition target.c:1861
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1785
int target_write_raw_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition target.c:1878
trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct gdbarch *gdbarch)
Definition trad-frame.c:62
struct value * trad_frame_get_prev_register(frame_info_ptr this_frame, trad_frame_saved_reg this_saved_regs[], int regnum)
Definition trad-frame.c:187