GDB (xrefs)
/tmp/gdb-7.10/gdb/m88k-tdep.c
Go to the documentation of this file.
1 /* Target-dependent code for the Motorola 88000 series.
2 
3  Copyright (C) 2004-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 "arch-utils.h"
22 #include "dis-asm.h"
23 #include "frame.h"
24 #include "frame-base.h"
25 #include "frame-unwind.h"
26 #include "gdbcore.h"
27 #include "gdbtypes.h"
28 #include "regcache.h"
29 #include "regset.h"
30 #include "symtab.h"
31 #include "trad-frame.h"
32 #include "value.h"
33 
34 #include "m88k-tdep.h"
35 
36 /* Fetch the instruction at PC. */
37 
38 static unsigned long
40 {
41  return read_memory_unsigned_integer (pc, 4, byte_order);
42 }
43 
44 /* Register information. */
45 
46 /* Return the name of register REGNUM. */
47 
48 static const char *
50 {
51  static char *register_names[] =
52  {
53  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
54  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
55  "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
56  "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
57  "epsr", "fpsr", "fpcr", "sxip", "snip", "sfip"
58  };
59 
60  if (regnum >= 0 && regnum < ARRAY_SIZE (register_names))
61  return register_names[regnum];
62 
63  return NULL;
64 }
65 
66 /* Return the GDB type object for the "standard" data type of data in
67  register REGNUM. */
68 
69 static struct type *
71 {
72  /* SXIP, SNIP, SFIP and R1 contain code addresses. */
73  if ((regnum >= M88K_SXIP_REGNUM && regnum <= M88K_SFIP_REGNUM)
74  || regnum == M88K_R1_REGNUM)
75  return builtin_type (gdbarch)->builtin_func_ptr;
76 
77  /* R30 and R31 typically contains data addresses. */
78  if (regnum == M88K_R30_REGNUM || regnum == M88K_R31_REGNUM)
79  return builtin_type (gdbarch)->builtin_data_ptr;
80 
81  return builtin_type (gdbarch)->builtin_int32;
82 }
83 
84 
85 static CORE_ADDR
87 {
88  /* All instructures are 4-byte aligned. The lower 2 bits of SXIP,
89  SNIP and SFIP are used for special purposes: bit 0 is the
90  exception bit and bit 1 is the valid bit. */
91  return addr & ~0x3;
92 }
93 
94 /* Use the program counter to determine the contents and size of a
95  breakpoint instruction. Return a pointer to a string of bytes that
96  encode a breakpoint instruction, store the length of the string in
97  *LEN and optionally adjust *PC to point to the correct memory
98  location for inserting the breakpoint. */
99 
100 static const gdb_byte *
102 {
103  /* tb 0,r0,511 */
104  static gdb_byte break_insn[] = { 0xf0, 0x00, 0xd1, 0xff };
105 
106  *len = sizeof (break_insn);
107  return break_insn;
108 }
109 
110 static CORE_ADDR
111 m88k_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
112 {
113  CORE_ADDR pc;
114 
116  return m88k_addr_bits_remove (gdbarch, pc);
117 }
118 
119 static void
121 {
122  /* According to the MC88100 RISC Microprocessor User's Manual,
123  section 6.4.3.1.2:
124 
125  "... can be made to return to a particular instruction by placing
126  a valid instruction address in the SNIP and the next sequential
127  instruction address in the SFIP (with V bits set and E bits
128  clear). The rte resumes execution at the instruction pointed to
129  by the SNIP, then the SFIP."
130 
131  The E bit is the least significant bit (bit 0). The V (valid)
132  bit is bit 1. This is why we logical or 2 into the values we are
133  writing below. It turns out that SXIP plays no role when
134  returning from an exception so nothing special has to be done
135  with it. We could even (presumably) give it a totally bogus
136  value. */
137 
140  regcache_cooked_write_unsigned (regcache, M88K_SFIP_REGNUM, (pc + 4) | 2);
141 }
142 
143 
144 /* The functions on this page are intended to be used to classify
145  function arguments. */
146 
147 /* Check whether TYPE is "Integral or Pointer". */
148 
149 static int
151 {
152  switch (TYPE_CODE (type))
153  {
154  case TYPE_CODE_INT:
155  case TYPE_CODE_BOOL:
156  case TYPE_CODE_CHAR:
157  case TYPE_CODE_ENUM:
158  case TYPE_CODE_RANGE:
159  {
160  /* We have byte, half-word, word and extended-word/doubleword
161  integral types. */
162  int len = TYPE_LENGTH (type);
163  return (len == 1 || len == 2 || len == 4 || len == 8);
164  }
165  return 1;
166  case TYPE_CODE_PTR:
167  case TYPE_CODE_REF:
168  {
169  /* Allow only 32-bit pointers. */
170  return (TYPE_LENGTH (type) == 4);
171  }
172  return 1;
173  default:
174  break;
175  }
176 
177  return 0;
178 }
179 
180 /* Check whether TYPE is "Floating". */
181 
182 static int
183 m88k_floating_p (const struct type *type)
184 {
185  switch (TYPE_CODE (type))
186  {
187  case TYPE_CODE_FLT:
188  {
189  int len = TYPE_LENGTH (type);
190  return (len == 4 || len == 8);
191  }
192  default:
193  break;
194  }
195 
196  return 0;
197 }
198 
199 /* Check whether TYPE is "Structure or Union". */
200 
201 static int
203 {
204  switch (TYPE_CODE (type))
205  {
206  case TYPE_CODE_STRUCT:
207  case TYPE_CODE_UNION:
208  return 1;
209  default:
210  break;
211  }
212 
213  return 0;
214 }
215 
216 /* Check whether TYPE has 8-byte alignment. */
217 
218 static int
220 {
221  if (m88k_structure_or_union_p (type))
222  {
223  int i;
224 
225  for (i = 0; i < TYPE_NFIELDS (type); i++)
226  {
227  struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
228 
229  if (m88k_8_byte_align_p (subtype))
230  return 1;
231  }
232  }
233 
234  if (m88k_integral_or_pointer_p (type) || m88k_floating_p (type))
235  return (TYPE_LENGTH (type) == 8);
236 
237  return 0;
238 }
239 
240 /* Check whether TYPE can be passed in a register. */
241 
242 static int
244 {
245  if (m88k_integral_or_pointer_p (type) || m88k_floating_p (type))
246  return 1;
247 
248  if (m88k_structure_or_union_p (type) && TYPE_LENGTH (type) == 4)
249  return 1;
250 
251  return 0;
252 }
253 
254 static CORE_ADDR
256  struct value **args, CORE_ADDR sp)
257 {
258  struct gdbarch *gdbarch = get_regcache_arch (regcache);
259  int num_register_words = 0;
260  int num_stack_words = 0;
261  int i;
262 
263  for (i = 0; i < nargs; i++)
264  {
265  struct type *type = value_type (args[i]);
266  int len = TYPE_LENGTH (type);
267 
268  if (m88k_integral_or_pointer_p (type) && len < 4)
269  {
270  args[i] = value_cast (builtin_type (gdbarch)->builtin_int32,
271  args[i]);
272  type = value_type (args[i]);
273  len = TYPE_LENGTH (type);
274  }
275 
276  if (m88k_in_register_p (type))
277  {
278  int num_words = 0;
279 
280  if (num_register_words % 2 == 1 && m88k_8_byte_align_p (type))
281  num_words++;
282 
283  num_words += ((len + 3) / 4);
284  if (num_register_words + num_words <= 8)
285  {
286  num_register_words += num_words;
287  continue;
288  }
289 
290  /* We've run out of available registers. Pass the argument
291  on the stack. */
292  }
293 
294  if (num_stack_words % 2 == 1 && m88k_8_byte_align_p (type))
295  num_stack_words++;
296 
297  num_stack_words += ((len + 3) / 4);
298  }
299 
300  /* Allocate stack space. */
301  sp = align_down (sp - 32 - num_stack_words * 4, 16);
302  num_stack_words = num_register_words = 0;
303 
304  for (i = 0; i < nargs; i++)
305  {
306  const bfd_byte *valbuf = value_contents (args[i]);
307  struct type *type = value_type (args[i]);
308  int len = TYPE_LENGTH (type);
309  int stack_word = num_stack_words;
310 
311  if (m88k_in_register_p (type))
312  {
313  int register_word = num_register_words;
314 
315  if (register_word % 2 == 1 && m88k_8_byte_align_p (type))
316  register_word++;
317 
318  gdb_assert (len == 4 || len == 8);
319 
320  if (register_word + len / 8 < 8)
321  {
322  int regnum = M88K_R2_REGNUM + register_word;
323 
324  regcache_raw_write (regcache, regnum, valbuf);
325  if (len > 4)
326  regcache_raw_write (regcache, regnum + 1, valbuf + 4);
327 
328  num_register_words = (register_word + len / 4);
329  continue;
330  }
331  }
332 
333  if (stack_word % 2 == -1 && m88k_8_byte_align_p (type))
334  stack_word++;
335 
336  write_memory (sp + stack_word * 4, valbuf, len);
337  num_stack_words = (stack_word + (len + 3) / 4);
338  }
339 
340  return sp;
341 }
342 
343 static CORE_ADDR
344 m88k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
345  struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
346  struct value **args, CORE_ADDR sp, int struct_return,
347  CORE_ADDR struct_addr)
348 {
349  /* Set up the function arguments. */
350  sp = m88k_store_arguments (regcache, nargs, args, sp);
351  gdb_assert (sp % 16 == 0);
352 
353  /* Store return value address. */
354  if (struct_return)
355  regcache_raw_write_unsigned (regcache, M88K_R12_REGNUM, struct_addr);
356 
357  /* Store the stack pointer and return address in the appropriate
358  registers. */
360  regcache_raw_write_unsigned (regcache, M88K_R1_REGNUM, bp_addr);
361 
362  /* Return the stack pointer. */
363  return sp;
364 }
365 
366 static struct frame_id
367 m88k_dummy_id (struct gdbarch *arch, struct frame_info *this_frame)
368 {
369  CORE_ADDR sp;
370 
371  sp = get_frame_register_unsigned (this_frame, M88K_R31_REGNUM);
372  return frame_id_build (sp, get_frame_pc (this_frame));
373 }
374 
375 
376 /* Determine, for architecture GDBARCH, how a return value of TYPE
377  should be returned. If it is supposed to be returned in registers,
378  and READBUF is non-zero, read the appropriate value from REGCACHE,
379  and copy it into READBUF. If WRITEBUF is non-zero, write the value
380  from WRITEBUF into REGCACHE. */
381 
382 static enum return_value_convention
383 m88k_return_value (struct gdbarch *gdbarch, struct value *function,
384  struct type *type, struct regcache *regcache,
385  gdb_byte *readbuf, const gdb_byte *writebuf)
386 {
387  int len = TYPE_LENGTH (type);
388  gdb_byte buf[8];
389 
390  if (!m88k_integral_or_pointer_p (type) && !m88k_floating_p (type))
392 
393  if (readbuf)
394  {
395  /* Read the contents of R2 and (if necessary) R3. */
396  regcache_cooked_read (regcache, M88K_R2_REGNUM, buf);
397  if (len > 4)
398  {
399  regcache_cooked_read (regcache, M88K_R3_REGNUM, buf + 4);
400  gdb_assert (len == 8);
401  memcpy (readbuf, buf, len);
402  }
403  else
404  {
405  /* Just stripping off any unused bytes should preserve the
406  signed-ness just fine. */
407  memcpy (readbuf, buf + 4 - len, len);
408  }
409  }
410 
411  if (writebuf)
412  {
413  /* Read the contents to R2 and (if necessary) R3. */
414  if (len > 4)
415  {
416  gdb_assert (len == 8);
417  memcpy (buf, writebuf, 8);
418  regcache_cooked_write (regcache, M88K_R3_REGNUM, buf + 4);
419  }
420  else
421  {
422  /* ??? Do we need to do any sign-extension here? */
423  memcpy (buf + 4 - len, writebuf, len);
424  }
425  regcache_cooked_write (regcache, M88K_R2_REGNUM, buf);
426  }
427 
429 }
430 
431 /* Default frame unwinder. */
432 
434 {
435  /* Base address. */
438 
441 
442  /* Table of saved registers. */
444 };
445 
446 /* Prologue analysis. */
447 
448 /* Macros for extracting fields from instructions. */
449 
450 #define BITMASK(pos, width) (((0x1 << (width)) - 1) << (pos))
451 #define EXTRACT_FIELD(val, pos, width) ((val) >> (pos) & BITMASK (0, width))
452 #define SUBU_OFFSET(x) ((unsigned)(x & 0xFFFF))
453 #define ST_OFFSET(x) ((unsigned)((x) & 0xFFFF))
454 #define ST_SRC(x) EXTRACT_FIELD ((x), 21, 5)
455 #define ADDU_OFFSET(x) ((unsigned)(x & 0xFFFF))
456 
457 /* Possible actions to be taken by the prologue analyzer for the
458  instructions it encounters. */
459 
461 {
462  M88K_PIA_SKIP, /* Ignore. */
463  M88K_PIA_NOTE_ST, /* Note register store. */
464  M88K_PIA_NOTE_STD, /* Note register pair store. */
465  M88K_PIA_NOTE_SP_ADJUSTMENT, /* Note stack pointer adjustment. */
466  M88K_PIA_NOTE_FP_ASSIGNMENT, /* Note frame pointer assignment. */
467  M88K_PIA_NOTE_BRANCH, /* Note branch. */
468  M88K_PIA_NOTE_PROLOGUE_END /* Note end of prologue. */
469 };
470 
471 /* Table of instructions that may comprise a function prologue. */
472 
474 {
475  unsigned long insn;
476  unsigned long mask;
478 };
479 
480 struct m88k_prologue_insn m88k_prologue_insn_table[] =
481 {
482  /* Various register move instructions. */
483  { 0x58000000, 0xf800ffff, M88K_PIA_SKIP }, /* or/or.u with immed of 0 */
484  { 0xf4005800, 0xfc1fffe0, M88K_PIA_SKIP }, /* or rd,r0,rs */
485  { 0xf4005800, 0xfc00ffff, M88K_PIA_SKIP }, /* or rd,rs,r0 */
486 
487  /* Various other instructions. */
488  { 0x58000000, 0xf8000000, M88K_PIA_SKIP }, /* or/or.u */
489 
490  /* Stack pointer setup: "subu sp,sp,n" where n is a multiple of 8. */
491  { 0x67ff0000, 0xffff0007, M88K_PIA_NOTE_SP_ADJUSTMENT },
492 
493  /* Frame pointer assignment: "addu r30,r31,n". */
494  { 0x63df0000, 0xffff0000, M88K_PIA_NOTE_FP_ASSIGNMENT },
495 
496  /* Store to stack instructions; either "st rx,sp,n" or "st.d rx,sp,n". */
497  { 0x241f0000, 0xfc1f0000, M88K_PIA_NOTE_ST }, /* st rx,sp,n */
498  { 0x201f0000, 0xfc1f0000, M88K_PIA_NOTE_STD }, /* st.d rs,sp,n */
499 
500  /* Instructions needed for setting up r25 for pic code. */
501  { 0x5f200000, 0xffff0000, M88K_PIA_SKIP }, /* or.u r25,r0,offset_high */
502  { 0xcc000002, 0xffffffff, M88K_PIA_SKIP }, /* bsr.n Lab */
503  { 0x5b390000, 0xffff0000, M88K_PIA_SKIP }, /* or r25,r25,offset_low */
504  { 0xf7396001, 0xffffffff, M88K_PIA_SKIP }, /* Lab: addu r25,r25,r1 */
505 
506  /* Various branch or jump instructions which have a delay slot --
507  these do not form part of the prologue, but the instruction in
508  the delay slot might be a store instruction which should be
509  noted. */
510  { 0xc4000000, 0xe4000000, M88K_PIA_NOTE_BRANCH },
511  /* br.n, bsr.n, bb0.n, or bb1.n */
512  { 0xec000000, 0xfc000000, M88K_PIA_NOTE_BRANCH }, /* bcnd.n */
513  { 0xf400c400, 0xfffff7e0, M88K_PIA_NOTE_BRANCH }, /* jmp.n or jsr.n */
514 
515  /* Catch all. Ends prologue analysis. */
516  { 0x00000000, 0x00000000, M88K_PIA_NOTE_PROLOGUE_END }
517 };
518 
519 /* Do a full analysis of the function prologue at PC and update CACHE
520  accordingly. Bail out early if LIMIT is reached. Return the
521  address where the analysis stopped. If LIMIT points beyond the
522  function prologue, the return address should be the end of the
523  prologue. */
524 
525 static CORE_ADDR
527  CORE_ADDR pc, CORE_ADDR limit,
528  struct m88k_frame_cache *cache)
529 {
530  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
531  CORE_ADDR end = limit;
532 
533  /* Provide a dummy cache if necessary. */
534  if (cache == NULL)
535  {
536  size_t sizeof_saved_regs =
537  (M88K_R31_REGNUM + 1) * sizeof (struct trad_frame_saved_reg);
538 
539  cache = alloca (sizeof (struct m88k_frame_cache));
540  cache->saved_regs = alloca (sizeof_saved_regs);
541 
542  /* We only initialize the members we care about. */
543  cache->saved_regs[M88K_R1_REGNUM].addr = -1;
544  cache->fp_offset = -1;
545  }
546 
547  while (pc < limit)
548  {
550  unsigned long insn = m88k_fetch_instruction (pc, byte_order);
551 
552  while ((insn & pi->mask) != pi->insn)
553  pi++;
554 
555  switch (pi->action)
556  {
557  case M88K_PIA_SKIP:
558  /* If we have a frame pointer, and R1 has been saved,
559  consider this instruction as not being part of the
560  prologue. */
561  if (cache->fp_offset != -1
562  && cache->saved_regs[M88K_R1_REGNUM].addr != -1)
563  return min (pc, end);
564  break;
565 
566  case M88K_PIA_NOTE_ST:
567  case M88K_PIA_NOTE_STD:
568  /* If no frame has been allocated, the stores aren't part of
569  the prologue. */
570  if (cache->sp_offset == 0)
571  return min (pc, end);
572 
573  /* Record location of saved registers. */
574  {
575  int regnum = ST_SRC (insn) + M88K_R0_REGNUM;
576  ULONGEST offset = ST_OFFSET (insn);
577 
578  cache->saved_regs[regnum].addr = offset;
579  if (pi->action == M88K_PIA_NOTE_STD && regnum < M88K_R31_REGNUM)
580  cache->saved_regs[regnum + 1].addr = offset + 4;
581  }
582  break;
583 
585  /* A second stack pointer adjustment isn't part of the
586  prologue. */
587  if (cache->sp_offset != 0)
588  return min (pc, end);
589 
590  /* Store stack pointer adjustment. */
591  cache->sp_offset = -SUBU_OFFSET (insn);
592  break;
593 
595  /* A second frame pointer assignment isn't part of the
596  prologue. */
597  if (cache->fp_offset != -1)
598  return min (pc, end);
599 
600  /* Record frame pointer assignment. */
601  cache->fp_offset = ADDU_OFFSET (insn);
602  break;
603 
605  /* The branch instruction isn't part of the prologue, but
606  the instruction in the delay slot might be. Limit the
607  prologue analysis to the delay slot and record the branch
608  instruction as the end of the prologue. */
609  limit = min (limit, pc + 2 * M88K_INSN_SIZE);
610  end = pc;
611  break;
612 
614  return min (pc, end);
615  }
616 
617  pc += M88K_INSN_SIZE;
618  }
619 
620  return end;
621 }
622 
623 /* An upper limit to the size of the prologue. */
625 
626 /* Return the address of first real instruction of the function
627  starting at PC. */
628 
629 static CORE_ADDR
631 {
632  struct symtab_and_line sal;
633  CORE_ADDR func_start, func_end;
634 
635  /* This is the preferred method, find the end of the prologue by
636  using the debugging information. */
637  if (find_pc_partial_function (pc, NULL, &func_start, &func_end))
638  {
639  sal = find_pc_line (func_start, 0);
640 
641  if (sal.end < func_end && pc <= sal.end)
642  return sal.end;
643  }
644 
645  return m88k_analyze_prologue (gdbarch, pc, pc + m88k_max_prologue_size,
646  NULL);
647 }
648 
649 static struct m88k_frame_cache *
650 m88k_frame_cache (struct frame_info *this_frame, void **this_cache)
651 {
652  struct gdbarch *gdbarch = get_frame_arch (this_frame);
653  struct m88k_frame_cache *cache;
654  CORE_ADDR frame_sp;
655 
656  if (*this_cache)
657  return *this_cache;
658 
659  cache = FRAME_OBSTACK_ZALLOC (struct m88k_frame_cache);
660  cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
661  cache->fp_offset = -1;
662 
663  cache->pc = get_frame_func (this_frame);
664  if (cache->pc != 0)
665  m88k_analyze_prologue (gdbarch, cache->pc, get_frame_pc (this_frame),
666  cache);
667 
668  /* Calculate the stack pointer used in the prologue. */
669  if (cache->fp_offset != -1)
670  {
671  CORE_ADDR fp;
672 
673  fp = get_frame_register_unsigned (this_frame, M88K_R30_REGNUM);
674  frame_sp = fp - cache->fp_offset;
675  }
676  else
677  {
678  /* If we know where the return address is saved, we can take a
679  solid guess at what the frame pointer should be. */
680  if (cache->saved_regs[M88K_R1_REGNUM].addr != -1)
681  cache->fp_offset = cache->saved_regs[M88K_R1_REGNUM].addr - 4;
682  frame_sp = get_frame_register_unsigned (this_frame, M88K_R31_REGNUM);
683  }
684 
685  /* Now that we know the stack pointer, adjust the location of the
686  saved registers. */
687  {
688  int regnum;
689 
690  for (regnum = M88K_R0_REGNUM; regnum < M88K_R31_REGNUM; regnum ++)
691  if (cache->saved_regs[regnum].addr != -1)
692  cache->saved_regs[regnum].addr += frame_sp;
693  }
694 
695  /* Calculate the frame's base. */
696  cache->base = frame_sp - cache->sp_offset;
698 
699  /* Identify SXIP with the return address in R1. */
701 
702  *this_cache = cache;
703  return cache;
704 }
705 
706 static void
707 m88k_frame_this_id (struct frame_info *this_frame, void **this_cache,
708  struct frame_id *this_id)
709 {
710  struct m88k_frame_cache *cache = m88k_frame_cache (this_frame, this_cache);
711 
712  /* This marks the outermost frame. */
713  if (cache->base == 0)
714  return;
715 
716  (*this_id) = frame_id_build (cache->base, cache->pc);
717 }
718 
719 static struct value *
721  void **this_cache, int regnum)
722 {
723  struct m88k_frame_cache *cache = m88k_frame_cache (this_frame, this_cache);
724 
725  if (regnum == M88K_SNIP_REGNUM || regnum == M88K_SFIP_REGNUM)
726  {
727  struct value *value;
728  CORE_ADDR pc;
729 
730  value = trad_frame_get_prev_register (this_frame, cache->saved_regs,
732  pc = value_as_long (value);
733  release_value (value);
734  value_free (value);
735 
736  if (regnum == M88K_SFIP_REGNUM)
737  pc += 4;
738 
739  return frame_unwind_got_constant (this_frame, regnum, pc + 4);
740  }
741 
742  return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
743 }
744 
745 static const struct frame_unwind m88k_frame_unwind =
746 {
747  NORMAL_FRAME,
751  NULL,
753 };
754 
755 
756 static CORE_ADDR
757 m88k_frame_base_address (struct frame_info *this_frame, void **this_cache)
758 {
759  struct m88k_frame_cache *cache = m88k_frame_cache (this_frame, this_cache);
760 
761  if (cache->fp_offset != -1)
762  return cache->base + cache->sp_offset + cache->fp_offset;
763 
764  return 0;
765 }
766 
767 static const struct frame_base m88k_frame_base =
768 {
772  m88k_frame_base_address
773 };
774 
775 
776 /* Core file support. */
777 
778 /* Supply register REGNUM from the buffer specified by GREGS and LEN
779  in the general-purpose register set REGSET to register cache
780  REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
781 
782 static void
784  struct regcache *regcache,
785  int regnum, const void *gregs, size_t len)
786 {
787  const gdb_byte *regs = gregs;
788  int i;
789 
790  for (i = 0; i < M88K_NUM_REGS; i++)
791  {
792  if (regnum == i || regnum == -1)
793  regcache_raw_supply (regcache, i, regs + i * 4);
794  }
795 }
796 
797 /* Motorola 88000 register set. */
798 
799 static const struct regset m88k_gregset =
800 {
801  NULL,
803 };
804 
805 /* Iterate over supported core file register note sections. */
806 
807 static void
810  void *cb_data,
811  const struct regcache *regcache)
812 {
813  cb (".reg", M88K_NUM_REGS * 4, &m88k_gregset, NULL, cb_data);
814 }
815 
816 
817 static struct gdbarch *
818 m88k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
819 {
820  struct gdbarch *gdbarch;
821 
822  /* If there is already a candidate, use it. */
823  arches = gdbarch_list_lookup_by_info (arches, &info);
824  if (arches != NULL)
825  return arches->gdbarch;
826 
827  /* Allocate space for the new architecture. */
828  gdbarch = gdbarch_alloc (&info, NULL);
829 
830  /* There is no real `long double'. */
831  set_gdbarch_long_double_bit (gdbarch, 64);
833 
837 
838  /* Register numbers of various important registers. */
841 
842  /* Core file support. */
845 
846  set_gdbarch_print_insn (gdbarch, print_insn_m88k);
847 
849 
850  /* Stack grows downward. */
852 
853  /* Call dummy code. */
856 
857  /* Return value info. */
859 
864 
865  frame_base_set_default (gdbarch, &m88k_frame_base);
866  frame_unwind_append_unwinder (gdbarch, &m88k_frame_unwind);
867 
868  return gdbarch;
869 }
870 
871 
872 /* Provide a prototype to silence -Wmissing-prototypes. */
873 void _initialize_m88k_tdep (void);
874 
875 void
877 {
878  gdbarch_register (bfd_arch_m88k, m88k_gdbarch_init, NULL);
879 }
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition: gdbarch.c:1909
static CORE_ADDR m88k_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: m88k-tdep.c:344
static void m88k_supply_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len)
Definition: m88k-tdep.c:783
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
static struct type * m88k_register_type(struct gdbarch *gdbarch, int regnum)
Definition: m88k-tdep.c:70
static int m88k_8_byte_align_p(struct type *type)
Definition: m88k-tdep.c:219
static void m88k_write_pc(struct regcache *regcache, CORE_ADDR pc)
Definition: m88k-tdep.c:120
enum m88k_prologue_insn_action action
Definition: m88k-tdep.c:477
struct type * builtin_func_ptr
Definition: gdbtypes.h:1544
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
bfd_vma CORE_ADDR
Definition: common-types.h:41
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
const struct floatformat * floatformats_ieee_double[BFD_ENDIAN_UNKNOWN]
Definition: gdbtypes.c:74
struct trad_frame_saved_reg * saved_regs
Definition: m88k-tdep.c:443
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
LONGEST value_as_long(struct value *val)
Definition: value.c:2654
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_write_pc(struct gdbarch *gdbarch, gdbarch_write_pc_ftype write_pc)
Definition: gdbarch.c:1802
void set_gdbarch_addr_bits_remove(struct gdbarch *gdbarch, gdbarch_addr_bits_remove_ftype addr_bits_remove)
Definition: gdbarch.c:3002
static struct m88k_frame_cache * m88k_frame_cache(struct frame_info *this_frame, void **this_cache)
Definition: m88k-tdep.c:650
static CORE_ADDR m88k_unwind_pc(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: m88k-tdep.c:111
ULONGEST align_down(ULONGEST v, int n)
Definition: utils.c:2971
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
#define ST_SRC(x)
Definition: m88k-tdep.c:454
#define M88K_INSN_SIZE
Definition: m88k-tdep.h:45
void value_free(struct value *val)
Definition: value.c:1518
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
Definition: gdbarch.c:4985
CORE_ADDR pc
Definition: m88k-tdep.c:437
#define ADDU_OFFSET(x)
Definition: m88k-tdep.c:455
m88k_prologue_insn_action
Definition: m88k-tdep.c:460
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1368
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
static struct frame_id m88k_dummy_id(struct gdbarch *arch, struct frame_info *this_frame)
Definition: m88k-tdep.c:367
struct value * frame_unwind_got_constant(struct frame_info *frame, int regnum, ULONGEST val)
Definition: frame-unwind.c:241
static CORE_ADDR m88k_frame_base_address(struct frame_info *this_frame, void **this_cache)
Definition: m88k-tdep.c:757
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep)
Definition: gdbarch.c:4933
Definition: regset.h:34
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
Definition: frame-base.c:94
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype register_type)
Definition: gdbarch.c:2151
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1329
static struct value * m88k_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
Definition: m88k-tdep.c:720
static enum return_value_convention m88k_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: m88k-tdep.c:383
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3315
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
Definition: gdbarch.c:1991
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype dummy_id)
Definition: gdbarch.c:2175
unsigned long insn
Definition: m88k-tdep.c:475
struct_return
Definition: arm-tdep.h:148
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
struct m88k_prologue_insn m88k_prologue_insn_table[]
Definition: m88k-tdep.c:480
static CORE_ADDR m88k_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: m88k-tdep.c:630
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
CORE_ADDR base
Definition: m88k-tdep.c:436
static const gdb_byte * m88k_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
Definition: m88k-tdep.c:101
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 int m88k_floating_p(const struct type *type)
Definition: m88k-tdep.c:183
#define gdb_assert(expr)
Definition: gdb_assert.h:33
#define min(a, b)
Definition: defs.h:106
struct value * value_cast(struct type *type, struct value *arg2)
Definition: valops.c:351
static int m88k_in_register_p(struct type *type)
Definition: m88k-tdep.c:243
#define SUBU_OFFSET(x)
Definition: m88k-tdep.c:452
struct gdbarch * gdbarch
Definition: gdbarch.h:1542
int regnum
Definition: aarch64-tdep.c:69
static CORE_ADDR m88k_store_arguments(struct regcache *regcache, int nargs, struct value **args, CORE_ADDR sp)
Definition: m88k-tdep.c:255
void( iterate_over_regset_sections_cb)(const char *sect_name, int size, const struct regset *regset, const char *human_name, void *cb_data)
Definition: gdbarch.h:98
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1194
static unsigned long m88k_fetch_instruction(CORE_ADDR pc, enum bfd_endian byte_order)
Definition: m88k-tdep.c:39
static int m88k_integral_or_pointer_p(const struct type *type)
Definition: m88k-tdep.c:150
Definition: value.c:172
#define ST_OFFSET(x)
Definition: m88k-tdep.c:453
struct trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct frame_info *this_frame)
Definition: trad-frame.c:52
void _initialize_m88k_tdep(void)
Definition: m88k-tdep.c:876
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 void m88k_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
Definition: m88k-tdep.c:808
static CORE_ADDR m88k_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: m88k-tdep.c:86
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition: regcache.c:871
struct type * builtin_data_ptr
Definition: gdbtypes.h:1533
const int m88k_max_prologue_size
Definition: m88k-tdep.c:624
int offset
Definition: agent.c:65
void regcache_raw_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition: regcache.c:723
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1241
enum register_status regcache_cooked_read(struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: regcache.c:737
static void m88k_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
Definition: m88k-tdep.c:707
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1041
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
void release_value(struct value *val)
Definition: value.c:1603
static int m88k_structure_or_union_p(const struct type *type)
Definition: m88k-tdep.c:202
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
Definition: gdbarch.c:1667
struct type * value_type(const struct value *value)
Definition: value.c:1021
unsigned long mask
Definition: m88k-tdep.c:476
static CORE_ADDR m88k_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR limit, struct m88k_frame_cache *cache)
Definition: m88k-tdep.c:526
static struct gdbarch * m88k_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
Definition: m88k-tdep.c:818
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
Definition: gdbarch.c:2556
static const struct frame_unwind m88k_frame_unwind
Definition: m88k-tdep.c:745
void set_gdbarch_long_double_format(struct gdbarch *gdbarch, const struct floatformat **long_double_format)
Definition: gdbarch.c:1683
#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
void set_gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype iterate_over_regset_sections)
Definition: gdbarch.c:3398
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
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
static const char * m88k_register_name(struct gdbarch *gdbarch, int regnum)
Definition: m88k-tdep.c:49
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
void regcache_cooked_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: regcache.c:930
void set_gdbarch_print_insn(struct gdbarch *gdbarch, gdbarch_print_insn_ftype print_insn)
Definition: gdbarch.c:3067
void regcache_raw_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: regcache.c:885
const ULONGEST const LONGEST len
Definition: target.h:309