GDB (xrefs)
/tmp/gdb-7.10/gdb/m32r-tdep.c
Go to the documentation of this file.
1 /* Target-dependent code for Renesas M32R, for GDB.
2 
3  Copyright (C) 1996-2015 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 "objfiles.h"
39 
40 #include "m32r-tdep.h"
41 
42 /* Local functions */
43 
44 extern void _initialize_m32r_tdep (void);
45 
46 static CORE_ADDR
47 m32r_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 
78 static int
79 m32r_memory_insert_breakpoint (struct gdbarch *gdbarch,
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->placed_size = 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 
137 static int
138 m32r_memory_remove_breakpoint (struct gdbarch *gdbarch,
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 static const gdb_byte *
169 m32r_breakpoint_from_pc (struct gdbarch *gdbarch,
170  CORE_ADDR *pcptr, int *lenptr)
171 {
172  static gdb_byte be_bp_entry[] = {
173  0x10, 0xf1, 0x70, 0x00
174  }; /* dpt -> nop */
175  static gdb_byte le_bp_entry[] = {
176  0x00, 0x70, 0xf1, 0x10
177  }; /* dpt -> nop */
178  gdb_byte *bp;
179 
180  /* Determine appropriate breakpoint. */
181  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
182  {
183  if ((*pcptr & 3) == 0)
184  {
185  bp = be_bp_entry;
186  *lenptr = 4;
187  }
188  else
189  {
190  bp = be_bp_entry;
191  *lenptr = 2;
192  }
193  }
194  else
195  {
196  if ((*pcptr & 3) == 0)
197  {
198  bp = le_bp_entry;
199  *lenptr = 4;
200  }
201  else
202  {
203  bp = le_bp_entry + 2;
204  *lenptr = 2;
205  }
206  }
207 
208  return bp;
209 }
210 
211 
213  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
214  "r8", "r9", "r10", "r11", "r12", "fp", "lr", "sp",
215  "psw", "cbr", "spi", "spu", "bpc", "pc", "accl", "acch",
216  "evb"
217 };
218 
219 static const char *
220 m32r_register_name (struct gdbarch *gdbarch, int reg_nr)
221 {
222  if (reg_nr < 0)
223  return NULL;
224  if (reg_nr >= M32R_NUM_REGS)
225  return NULL;
226  return m32r_register_names[reg_nr];
227 }
228 
229 
230 /* Return the GDB type object for the "standard" data type
231  of data in register N. */
232 
233 static struct type *
234 m32r_register_type (struct gdbarch *gdbarch, int reg_nr)
235 {
236  if (reg_nr == M32R_PC_REGNUM)
237  return builtin_type (gdbarch)->builtin_func_ptr;
238  else if (reg_nr == M32R_SP_REGNUM || reg_nr == M32R_FP_REGNUM)
239  return builtin_type (gdbarch)->builtin_data_ptr;
240  else
241  return builtin_type (gdbarch)->builtin_int32;
242 }
243 
244 
245 /* Write into appropriate registers a function return value
246  of type TYPE, given in virtual format.
247 
248  Things always get returned in RET1_REGNUM, RET2_REGNUM. */
249 
250 static void
252  const void *valbuf)
253 {
254  struct gdbarch *gdbarch = get_regcache_arch (regcache);
255  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
256  CORE_ADDR regval;
257  int len = TYPE_LENGTH (type);
258 
259  regval = extract_unsigned_integer (valbuf, len > 4 ? 4 : len, byte_order);
260  regcache_cooked_write_unsigned (regcache, RET1_REGNUM, regval);
261 
262  if (len > 4)
263  {
264  regval = extract_unsigned_integer ((gdb_byte *) valbuf + 4,
265  len - 4, byte_order);
266  regcache_cooked_write_unsigned (regcache, RET1_REGNUM + 1, regval);
267  }
268 }
269 
270 /* This is required by skip_prologue. The results of decoding a prologue
271  should be cached because this thrashing is getting nuts. */
272 
273 static int
274 decode_prologue (struct gdbarch *gdbarch,
275  CORE_ADDR start_pc, CORE_ADDR scan_limit,
276  CORE_ADDR *pl_endptr, unsigned long *framelength)
277 {
278  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
279  unsigned long framesize;
280  int insn;
281  int op1;
283  CORE_ADDR after_push = 0;
284  CORE_ADDR after_stack_adjust = 0;
285  CORE_ADDR current_pc;
287 
288  framesize = 0;
289  after_prologue = 0;
290 
291  for (current_pc = start_pc; current_pc < scan_limit; current_pc += 2)
292  {
293  /* Check if current pc's location is readable. */
294  if (!safe_read_memory_integer (current_pc, 2, byte_order, &return_value))
295  return -1;
296 
297  insn = read_memory_unsigned_integer (current_pc, 2, byte_order);
298 
299  if (insn == 0x0000)
300  break;
301 
302  /* If this is a 32 bit instruction, we dont want to examine its
303  immediate data as though it were an instruction. */
304  if (current_pc & 0x02)
305  {
306  /* Decode this instruction further. */
307  insn &= 0x7fff;
308  }
309  else
310  {
311  if (insn & 0x8000)
312  {
313  if (current_pc == scan_limit)
314  scan_limit += 2; /* extend the search */
315 
316  current_pc += 2; /* skip the immediate data */
317 
318  /* Check if current pc's location is readable. */
319  if (!safe_read_memory_integer (current_pc, 2, byte_order,
320  &return_value))
321  return -1;
322 
323  if (insn == 0x8faf) /* add3 sp, sp, xxxx */
324  /* add 16 bit sign-extended offset */
325  {
326  framesize +=
327  -((short) read_memory_unsigned_integer (current_pc,
328  2, byte_order));
329  }
330  else
331  {
332  if (((insn >> 8) == 0xe4) /* ld24 r4, xxxxxx; sub sp, r4 */
333  && safe_read_memory_integer (current_pc + 2,
334  2, byte_order,
335  &return_value)
336  && read_memory_unsigned_integer (current_pc + 2,
337  2, byte_order)
338  == 0x0f24)
339  {
340  /* Subtract 24 bit sign-extended negative-offset. */
341  insn = read_memory_unsigned_integer (current_pc - 2,
342  4, byte_order);
343  if (insn & 0x00800000) /* sign extend */
344  insn |= 0xff000000; /* negative */
345  else
346  insn &= 0x00ffffff; /* positive */
347  framesize += insn;
348  }
349  }
350  after_push = current_pc + 2;
351  continue;
352  }
353  }
354  op1 = insn & 0xf000; /* Isolate just the first nibble. */
355 
356  if ((insn & 0xf0ff) == 0x207f)
357  { /* st reg, @-sp */
358  int regno;
359  framesize += 4;
360  regno = ((insn >> 8) & 0xf);
361  after_prologue = 0;
362  continue;
363  }
364  if ((insn >> 8) == 0x4f) /* addi sp, xx */
365  /* Add 8 bit sign-extended offset. */
366  {
367  int stack_adjust = (signed char) (insn & 0xff);
368 
369  /* there are probably two of these stack adjustments:
370  1) A negative one in the prologue, and
371  2) A positive one in the epilogue.
372  We are only interested in the first one. */
373 
374  if (stack_adjust < 0)
375  {
376  framesize -= stack_adjust;
377  after_prologue = 0;
378  /* A frameless function may have no "mv fp, sp".
379  In that case, this is the end of the prologue. */
380  after_stack_adjust = current_pc + 2;
381  }
382  continue;
383  }
384  if (insn == 0x1d8f)
385  { /* mv fp, sp */
386  after_prologue = current_pc + 2;
387  break; /* end of stack adjustments */
388  }
389 
390  /* Nop looks like a branch, continue explicitly. */
391  if (insn == 0x7000)
392  {
393  after_prologue = current_pc + 2;
394  continue; /* nop occurs between pushes. */
395  }
396  /* End of prolog if any of these are trap instructions. */
397  if ((insn & 0xfff0) == 0x10f0)
398  {
399  after_prologue = current_pc;
400  break;
401  }
402  /* End of prolog if any of these are branch instructions. */
403  if ((op1 == 0x7000) || (op1 == 0xb000) || (op1 == 0xf000))
404  {
405  after_prologue = current_pc;
406  continue;
407  }
408  /* Some of the branch instructions are mixed with other types. */
409  if (op1 == 0x1000)
410  {
411  int subop = insn & 0x0ff0;
412  if ((subop == 0x0ec0) || (subop == 0x0fc0))
413  {
414  after_prologue = current_pc;
415  continue; /* jmp , jl */
416  }
417  }
418  }
419 
420  if (framelength)
421  *framelength = framesize;
422 
423  if (current_pc >= scan_limit)
424  {
425  if (pl_endptr)
426  {
427  if (after_stack_adjust != 0)
428  /* We did not find a "mv fp,sp", but we DID find
429  a stack_adjust. Is it safe to use that as the
430  end of the prologue? I just don't know. */
431  {
432  *pl_endptr = after_stack_adjust;
433  }
434  else if (after_push != 0)
435  /* We did not find a "mv fp,sp", but we DID find
436  a push. Is it safe to use that as the
437  end of the prologue? I just don't know. */
438  {
439  *pl_endptr = after_push;
440  }
441  else
442  /* We reached the end of the loop without finding the end
443  of the prologue. No way to win -- we should report
444  failure. The way we do that is to return the original
445  start_pc. GDB will set a breakpoint at the start of
446  the function (etc.) */
447  *pl_endptr = start_pc;
448  }
449  return 0;
450  }
451 
452  if (after_prologue == 0)
453  after_prologue = current_pc;
454 
455  if (pl_endptr)
456  *pl_endptr = after_prologue;
457 
458  return 0;
459 } /* decode_prologue */
460 
461 /* Function: skip_prologue
462  Find end of function prologue. */
463 
464 #define DEFAULT_SEARCH_LIMIT 128
465 
466 static CORE_ADDR
467 m32r_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
468 {
469  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
470  CORE_ADDR func_addr, func_end;
471  struct symtab_and_line sal;
472  LONGEST return_value;
473 
474  /* See what the symbol table says. */
475 
476  if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
477  {
478  sal = find_pc_line (func_addr, 0);
479 
480  if (sal.line != 0 && sal.end <= func_end)
481  {
482  func_end = sal.end;
483  }
484  else
485  /* Either there's no line info, or the line after the prologue is after
486  the end of the function. In this case, there probably isn't a
487  prologue. */
488  {
489  func_end = min (func_end, func_addr + DEFAULT_SEARCH_LIMIT);
490  }
491  }
492  else
493  func_end = pc + DEFAULT_SEARCH_LIMIT;
494 
495  /* If pc's location is not readable, just quit. */
496  if (!safe_read_memory_integer (pc, 4, byte_order, &return_value))
497  return pc;
498 
499  /* Find the end of prologue. */
500  if (decode_prologue (gdbarch, pc, func_end, &sal.end, NULL) < 0)
501  return pc;
502 
503  return sal.end;
504 }
505 
507 {
508  /* The previous frame's inner most stack address. Used as this
509  frame ID's stack_addr. */
511  /* The frame's base, optionally used by the high-level debug info. */
513  int size;
514  /* How far the SP and r13 (FP) have been offset from the start of
515  the stack frame (as defined by the previous frame's stack
516  pointer). */
520  /* Table indicating the location of each and every register. */
522 };
523 
524 /* Put here the code to store, into fi->saved_regs, the addresses of
525  the saved registers of frame described by FRAME_INFO. This
526  includes special registers such as pc and fp saved in special ways
527  in the stack frame. sp is even more special: the address we return
528  for it IS the sp for the next frame. */
529 
530 static struct m32r_unwind_cache *
532  void **this_prologue_cache)
533 {
534  CORE_ADDR pc, scan_limit;
536  ULONGEST this_base;
537  unsigned long op;
538  int i;
539  struct m32r_unwind_cache *info;
540 
541 
542  if ((*this_prologue_cache))
543  return (*this_prologue_cache);
544 
545  info = FRAME_OBSTACK_ZALLOC (struct m32r_unwind_cache);
546  (*this_prologue_cache) = info;
547  info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
548 
549  info->size = 0;
550  info->sp_offset = 0;
551  info->uses_frame = 0;
552 
553  scan_limit = get_frame_pc (this_frame);
554  for (pc = get_frame_func (this_frame);
555  pc > 0 && pc < scan_limit; pc += 2)
556  {
557  if ((pc & 2) == 0)
558  {
559  op = get_frame_memory_unsigned (this_frame, pc, 4);
560  if ((op & 0x80000000) == 0x80000000)
561  {
562  /* 32-bit instruction */
563  if ((op & 0xffff0000) == 0x8faf0000)
564  {
565  /* add3 sp,sp,xxxx */
566  short n = op & 0xffff;
567  info->sp_offset += n;
568  }
569  else if (((op >> 8) == 0xe4)
570  && get_frame_memory_unsigned (this_frame, pc + 2,
571  2) == 0x0f24)
572  {
573  /* ld24 r4, xxxxxx; sub sp, r4 */
574  unsigned long n = op & 0xffffff;
575  info->sp_offset += n;
576  pc += 2; /* skip sub instruction */
577  }
578 
579  if (pc == scan_limit)
580  scan_limit += 2; /* extend the search */
581  pc += 2; /* skip the immediate data */
582  continue;
583  }
584  }
585 
586  /* 16-bit instructions */
587  op = get_frame_memory_unsigned (this_frame, pc, 2) & 0x7fff;
588  if ((op & 0xf0ff) == 0x207f)
589  {
590  /* st rn, @-sp */
591  int regno = ((op >> 8) & 0xf);
592  info->sp_offset -= 4;
593  info->saved_regs[regno].addr = info->sp_offset;
594  }
595  else if ((op & 0xff00) == 0x4f00)
596  {
597  /* addi sp, xx */
598  int n = (signed char) (op & 0xff);
599  info->sp_offset += n;
600  }
601  else if (op == 0x1d8f)
602  {
603  /* mv fp, sp */
604  info->uses_frame = 1;
605  info->r13_offset = info->sp_offset;
606  break; /* end of stack adjustments */
607  }
608  else if ((op & 0xfff0) == 0x10f0)
609  {
610  /* End of prologue if this is a trap instruction. */
611  break; /* End of stack adjustments. */
612  }
613  }
614 
615  info->size = -info->sp_offset;
616 
617  /* Compute the previous frame's stack pointer (which is also the
618  frame's ID's stack address), and this frame's base pointer. */
619  if (info->uses_frame)
620  {
621  /* The SP was moved to the FP. This indicates that a new frame
622  was created. Get THIS frame's FP value by unwinding it from
623  the next frame. */
624  this_base = get_frame_register_unsigned (this_frame, M32R_FP_REGNUM);
625  /* The FP points at the last saved register. Adjust the FP back
626  to before the first saved register giving the SP. */
627  prev_sp = this_base + info->size;
628  }
629  else
630  {
631  /* Assume that the FP is this frame's SP but with that pushed
632  stack space added back. */
633  this_base = get_frame_register_unsigned (this_frame, M32R_SP_REGNUM);
634  prev_sp = this_base + info->size;
635  }
636 
637  /* Convert that SP/BASE into real addresses. */
638  info->prev_sp = prev_sp;
639  info->base = this_base;
640 
641  /* Adjust all the saved registers so that they contain addresses and
642  not offsets. */
643  for (i = 0; i < gdbarch_num_regs (get_frame_arch (this_frame)) - 1; i++)
644  if (trad_frame_addr_p (info->saved_regs, i))
645  info->saved_regs[i].addr = (info->prev_sp + info->saved_regs[i].addr);
646 
647  /* The call instruction moves the caller's PC in the callee's LR.
648  Since this is an unwind, do the reverse. Copy the location of LR
649  into PC (the address / regnum) so that a request for PC will be
650  converted into a request for the LR. */
652 
653  /* The previous frame's SP needed to be computed. Save the computed
654  value. */
656 
657  return info;
658 }
659 
660 static CORE_ADDR
662 {
663  ULONGEST pc;
665  return pc;
666 }
667 
668 static CORE_ADDR
669 m32r_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
670 {
671  return frame_unwind_register_unsigned (next_frame, M32R_SP_REGNUM);
672 }
673 
674 
675 static CORE_ADDR
676 m32r_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
677  struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
678  struct value **args, CORE_ADDR sp, int struct_return,
679  CORE_ADDR struct_addr)
680 {
681  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
682  int stack_offset, stack_alloc;
683  int argreg = ARG1_REGNUM;
684  int argnum;
685  struct type *type;
686  enum type_code typecode;
687  CORE_ADDR regval;
688  gdb_byte *val;
689  gdb_byte valbuf[MAX_REGISTER_SIZE];
690  int len;
691 
692  /* First force sp to a 4-byte alignment. */
693  sp = sp & ~3;
694 
695  /* Set the return address. For the m32r, the return breakpoint is
696  always at BP_ADDR. */
697  regcache_cooked_write_unsigned (regcache, LR_REGNUM, bp_addr);
698 
699  /* If STRUCT_RETURN is true, then the struct return address (in
700  STRUCT_ADDR) will consume the first argument-passing register.
701  Both adjust the register count and store that value. */
702  if (struct_return)
703  {
704  regcache_cooked_write_unsigned (regcache, argreg, struct_addr);
705  argreg++;
706  }
707 
708  /* Now make sure there's space on the stack. */
709  for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)
710  stack_alloc += ((TYPE_LENGTH (value_type (args[argnum])) + 3) & ~3);
711  sp -= stack_alloc; /* Make room on stack for args. */
712 
713  for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
714  {
715  type = value_type (args[argnum]);
716  typecode = TYPE_CODE (type);
717  len = TYPE_LENGTH (type);
718 
719  memset (valbuf, 0, sizeof (valbuf));
720 
721  /* Passes structures that do not fit in 2 registers by reference. */
722  if (len > 8
723  && (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION))
724  {
725  store_unsigned_integer (valbuf, 4, byte_order,
726  value_address (args[argnum]));
727  typecode = TYPE_CODE_PTR;
728  len = 4;
729  val = valbuf;
730  }
731  else if (len < 4)
732  {
733  /* Value gets right-justified in the register or stack word. */
734  memcpy (valbuf + (register_size (gdbarch, argreg) - len),
735  (gdb_byte *) value_contents (args[argnum]), len);
736  val = valbuf;
737  }
738  else
739  val = (gdb_byte *) value_contents (args[argnum]);
740 
741  while (len > 0)
742  {
743  if (argreg > ARGN_REGNUM)
744  {
745  /* Must go on the stack. */
746  write_memory (sp + stack_offset, val, 4);
747  stack_offset += 4;
748  }
749  else if (argreg <= ARGN_REGNUM)
750  {
751  /* There's room in a register. */
752  regval =
754  register_size (gdbarch, argreg),
755  byte_order);
756  regcache_cooked_write_unsigned (regcache, argreg++, regval);
757  }
758 
759  /* Store the value 4 bytes at a time. This means that things
760  larger than 4 bytes may go partly in registers and partly
761  on the stack. */
762  len -= register_size (gdbarch, argreg);
763  val += register_size (gdbarch, argreg);
764  }
765  }
766 
767  /* Finally, update the SP register. */
769 
770  return sp;
771 }
772 
773 
774 /* Given a return value in `regbuf' with a type `valtype',
775  extract and copy its value into `valbuf'. */
776 
777 static void
779  void *dst)
780 {
781  struct gdbarch *gdbarch = get_regcache_arch (regcache);
782  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
783  bfd_byte *valbuf = dst;
784  int len = TYPE_LENGTH (type);
785  ULONGEST tmp;
786 
787  /* By using store_unsigned_integer we avoid having to do
788  anything special for small big-endian values. */
789  regcache_cooked_read_unsigned (regcache, RET1_REGNUM, &tmp);
790  store_unsigned_integer (valbuf, (len > 4 ? len - 4 : len), byte_order, tmp);
791 
792  /* Ignore return values more than 8 bytes in size because the m32r
793  returns anything more than 8 bytes in the stack. */
794  if (len > 4)
795  {
796  regcache_cooked_read_unsigned (regcache, RET1_REGNUM + 1, &tmp);
797  store_unsigned_integer (valbuf + len - 4, 4, byte_order, tmp);
798  }
799 }
800 
801 static enum return_value_convention
802 m32r_return_value (struct gdbarch *gdbarch, struct value *function,
803  struct type *valtype, struct regcache *regcache,
804  gdb_byte *readbuf, const gdb_byte *writebuf)
805 {
806  if (TYPE_LENGTH (valtype) > 8)
808  else
809  {
810  if (readbuf != NULL)
811  m32r_extract_return_value (valtype, regcache, readbuf);
812  if (writebuf != NULL)
813  m32r_store_return_value (valtype, regcache, writebuf);
815  }
816 }
817 
818 
819 
820 static CORE_ADDR
821 m32r_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
822 {
823  return frame_unwind_register_unsigned (next_frame, M32R_PC_REGNUM);
824 }
825 
826 /* Given a GDB frame, determine the address of the calling function's
827  frame. This will be used to create a new GDB frame struct. */
828 
829 static void
830 m32r_frame_this_id (struct frame_info *this_frame,
831  void **this_prologue_cache, struct frame_id *this_id)
832 {
833  struct m32r_unwind_cache *info
834  = m32r_frame_unwind_cache (this_frame, this_prologue_cache);
835  CORE_ADDR base;
836  CORE_ADDR func;
837  struct bound_minimal_symbol msym_stack;
838  struct frame_id id;
839 
840  /* The FUNC is easy. */
841  func = get_frame_func (this_frame);
842 
843  /* Check if the stack is empty. */
844  msym_stack = lookup_minimal_symbol ("_stack", NULL, NULL);
845  if (msym_stack.minsym && info->base == BMSYMBOL_VALUE_ADDRESS (msym_stack))
846  return;
847 
848  /* Hopefully the prologue analysis either correctly determined the
849  frame's base (which is the SP from the previous frame), or set
850  that base to "NULL". */
851  base = info->prev_sp;
852  if (base == 0)
853  return;
854 
855  id = frame_id_build (base, func);
856  (*this_id) = id;
857 }
858 
859 static struct value *
861  void **this_prologue_cache, int regnum)
862 {
863  struct m32r_unwind_cache *info
864  = m32r_frame_unwind_cache (this_frame, this_prologue_cache);
865  return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
866 }
867 
868 static const struct frame_unwind m32r_frame_unwind = {
869  NORMAL_FRAME,
873  NULL,
875 };
876 
877 static CORE_ADDR
878 m32r_frame_base_address (struct frame_info *this_frame, void **this_cache)
879 {
880  struct m32r_unwind_cache *info
881  = m32r_frame_unwind_cache (this_frame, this_cache);
882  return info->base;
883 }
884 
885 static const struct frame_base m32r_frame_base = {
889  m32r_frame_base_address
890 };
891 
892 /* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy
893  frame. The frame ID's base needs to match the TOS value saved by
894  save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint. */
895 
896 static struct frame_id
897 m32r_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
898 {
900  return frame_id_build (sp, get_frame_pc (this_frame));
901 }
902 
903 
905 
906 static struct gdbarch *
907 m32r_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
908 {
909  struct gdbarch *gdbarch;
910  struct gdbarch_tdep *tdep;
911 
912  /* If there is already a candidate, use it. */
913  arches = gdbarch_list_lookup_by_info (arches, &info);
914  if (arches != NULL)
915  return arches->gdbarch;
916 
917  /* Allocate space for the new architecture. */
918  tdep = XNEW (struct gdbarch_tdep);
919  gdbarch = gdbarch_alloc (&info, tdep);
920 
923 
929 
932 
940 
942 
943  frame_base_set_default (gdbarch, &m32r_frame_base);
944 
945  /* Methods for saving / extracting a dummy frame's ID. The ID's
946  stack address must match the SP value returned by
947  PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */
949 
950  /* Return the unwound PC value. */
952 
953  set_gdbarch_print_insn (gdbarch, print_insn_m32r);
954 
955  /* Hook in ABI-specific overrides, if they have been registered. */
956  gdbarch_init_osabi (info, gdbarch);
957 
958  /* Hook in the default unwinders. */
959  frame_unwind_append_unwinder (gdbarch, &m32r_frame_unwind);
960 
961  /* Support simple overlay manager. */
963 
964  return gdbarch;
965 }
966 
967 void
969 {
970  register_gdbarch_init (bfd_arch_m32r, m32r_gdbarch_init);
971 }
static const struct frame_unwind m32r_frame_unwind
Definition: m32r-tdep.c:868
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition: gdbarch.c:1909
void set_gdbarch_frame_align(struct gdbarch *gdbarch, gdbarch_frame_align_ftype frame_align)
Definition: gdbarch.c:2935
CORE_ADDR reqstd_address
Definition: breakpoint.h:235
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
type_code
Definition: gdbtypes.h:85
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
struct type * builtin_func_ptr
Definition: gdbtypes.h:1544
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
static void m32r_extract_return_value(struct type *type, struct regcache *regcache, void *dst)
Definition: m32r-tdep.c:778
bfd_vma CORE_ADDR
Definition: common-types.h:41
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: osabi.c:341
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition: target.c:1474
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:135
int trad_frame_addr_p(struct trad_frame_saved_reg this_saved_regs[], int regnum)
Definition: trad-frame.c:77
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
void(* func)(char *)
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
CORE_ADDR end
Definition: symtab.h:1377
void trad_frame_set_value(struct trad_frame_saved_reg this_saved_regs[], int regnum, LONGEST val)
Definition: trad-frame.c:92
void set_gdbarch_overlay_update(struct gdbarch *gdbarch, gdbarch_overlay_update_ftype overlay_update)
Definition: gdbarch.c:3792
LONGEST r13_offset
Definition: m32r-tdep.c:518
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, int struct_return, CORE_ADDR struct_addr)
Definition: m32r-tdep.c:676
ULONGEST frame_unwind_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1182
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
return_value_convention
Definition: defs.h:206
static CORE_ADDR after_prologue(CORE_ADDR pc)
Definition: hppa-tdep.c:1797
int safe_read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order, LONGEST *return_value)
Definition: corefile.c:297
#define DEFAULT_SEARCH_LIMIT
Definition: m32r-tdep.c:464
CORE_ADDR base
Definition: m32r-tdep.c:512
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
Definition: gdbarch.c:4985
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1898
ULONGEST get_frame_memory_unsigned(struct frame_info *this_frame, CORE_ADDR addr, int len)
Definition: frame.c:2515
static const gdb_byte * m32r_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
Definition: m32r-tdep.c:169
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:78
struct type * builtin_int32
Definition: gdbtypes.h:1518
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:660
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
Definition: findvar.c:212
static CORE_ADDR m32r_unwind_sp(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: m32r-tdep.c:669
static CORE_ADDR m32r_unwind_pc(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: m32r-tdep.c:821
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:274
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
Definition: frame-base.c:94
static CORE_ADDR m32r_frame_align(struct gdbarch *gdbarch, CORE_ADDR sp)
Definition: m32r-tdep.c:47
char * m32r_register_names[]
Definition: m32r-tdep.c:212
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype register_type)
Definition: gdbarch.c:2151
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1329
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3315
struct gdbarch *( gdbarch_init_ftype)(struct gdbarch_info info, struct gdbarch_list *arches)
Definition: gdbarch.h:1569
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:837
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
Definition: gdbarch.c:1991
static struct m32r_unwind_cache * m32r_frame_unwind_cache(struct frame_info *this_frame, void **this_prologue_cache)
Definition: m32r-tdep.c:531
static struct type * m32r_register_type(struct gdbarch *gdbarch, int reg_nr)
Definition: m32r-tdep.c:234
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype dummy_id)
Definition: gdbarch.c:2175
struct_return
Definition: arm-tdep.h:148
static CORE_ADDR m32r_read_pc(struct regcache *regcache)
Definition: m32r-tdep.c:661
gdb_byte shadow_contents[BREAKPOINT_MAX]
Definition: breakpoint.h:245
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
int target_write_raw_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition: target.c:1492
Definition: gdbtypes.h:749
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:321
static struct value * m32r_frame_prev_register(struct frame_info *this_frame, void **this_prologue_cache, int regnum)
Definition: m32r-tdep.c:860
void _initialize_m32r_tdep(void)
Definition: m32r-tdep.c:968
void set_gdbarch_unwind_pc(struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype unwind_pc)
Definition: gdbarch.c:2863
void set_gdbarch_breakpoint_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
Definition: gdbarch.c:2672
int default_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
Definition: frame-unwind.c:170
static const char * type
Definition: language.c:103
#define min(a, b)
Definition: defs.h:106
#define M32R_NUM_REGS
Definition: m32r-tdep.h:48
void set_gdbarch_read_pc(struct gdbarch *gdbarch, gdbarch_read_pc_ftype read_pc)
Definition: gdbarch.c:1778
void simple_overlay_update(struct obj_section *osect)
Definition: symfile.c:3671
void set_gdbarch_unwind_sp(struct gdbarch *gdbarch, gdbarch_unwind_sp_ftype unwind_sp)
Definition: gdbarch.c:2887
struct gdbarch * gdbarch
Definition: gdbarch.h:1542
int regnum
Definition: aarch64-tdep.c:69
CORE_ADDR placed_address
Definition: breakpoint.h:232
struct trad_frame_saved_reg * saved_regs
Definition: m32r-tdep.c:521
CORE_ADDR prev_sp
Definition: m32r-tdep.c:510
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1194
Definition: value.c:172
static CORE_ADDR m32r_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: m32r-tdep.c:467
struct trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct frame_info *this_frame)
Definition: trad-frame.c:52
gdbarch_return_value_ftype * return_value
Definition: gdbarch.c:222
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
Definition: arch-utils.c:138
bfd_byte gdb_byte
Definition: common-types.h:38
static int m32r_memory_insert_breakpoint(struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: m32r-tdep.c:79
void set_gdbarch_memory_insert_breakpoint(struct gdbarch *gdbarch, gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
Definition: gdbarch.c:2730
static CORE_ADDR m32r_frame_base_address(struct frame_info *this_frame, void **this_cache)
Definition: m32r-tdep.c:878
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition: regcache.c:871
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
struct type * builtin_data_ptr
Definition: gdbtypes.h:1533
struct minimal_symbol * minsym
Definition: minsyms.h:32
LONGEST sp_offset
Definition: m32r-tdep.c:517
CORE_ADDR pc
Definition: symtab.h:1376
struct m32c_reg * sp
Definition: m32c-tdep.c:114
void set_gdbarch_memory_remove_breakpoint(struct gdbarch *gdbarch, gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
Definition: gdbarch.c:2747
unsigned long long ULONGEST
Definition: common-types.h:53
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
Definition: frame-unwind.c:180
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:169
struct type * value_type(const struct value *value)
Definition: value.c:1021
static struct frame_id m32r_dummy_id(struct gdbarch *gdbarch, struct frame_info *this_frame)
Definition: m32r-tdep.c:897
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
Definition: gdbarch.c:2556
static gdbarch_init_ftype m32r_gdbarch_init
Definition: m32r-tdep.c:904
static int m32r_memory_remove_breakpoint(struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: m32r-tdep.c:138
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype push_dummy_call)
Definition: gdbarch.c:2216
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:321
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:802
void register_gdbarch_init(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init)
Definition: gdbarch.c:4975
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:389
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype skip_prologue)
Definition: gdbarch.c:2590
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1440
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:163
static const char * m32r_register_name(struct gdbarch *gdbarch, int reg_nr)
Definition: m32r-tdep.c:220
enum bfd_endian byte_order
Definition: gdbarch.c:128
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
Definition: gdbarch.c:2008
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype register_name)
Definition: gdbarch.c:2127
CORE_ADDR get_frame_func(struct frame_info *this_frame)
Definition: frame.c:920
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, struct gdbarch_tdep *tdep)
Definition: gdbarch.c:339
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype inner_than)
Definition: gdbarch.c:2655
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
long long LONGEST
Definition: common-types.h:52
static void m32r_store_return_value(struct type *type, struct regcache *regcache, const void *valbuf)
Definition: m32r-tdep.c:251
static void m32r_frame_this_id(struct frame_info *this_frame, void **this_prologue_cache, struct frame_id *this_id)
Definition: m32r-tdep.c:830
void set_gdbarch_print_insn(struct gdbarch *gdbarch, gdbarch_print_insn_ftype print_insn)
Definition: gdbarch.c:3067
const ULONGEST const LONGEST len
Definition: target.h:309