GDB (xrefs)
/tmp/gdb-7.10/gdb/m68k-tdep.c
Go to the documentation of this file.
1 /* Target-dependent code for the Motorola 68000 series.
2 
3  Copyright (C) 1990-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 "dwarf2-frame.h"
22 #include "frame.h"
23 #include "frame-base.h"
24 #include "frame-unwind.h"
25 #include "gdbtypes.h"
26 #include "symtab.h"
27 #include "gdbcore.h"
28 #include "value.h"
29 #include "inferior.h"
30 #include "regcache.h"
31 #include "arch-utils.h"
32 #include "osabi.h"
33 #include "dis-asm.h"
34 #include "target-descriptions.h"
35 
36 #include "m68k-tdep.h"
37 
38 
39 #define P_LINKL_FP 0x480e
40 #define P_LINKW_FP 0x4e56
41 #define P_PEA_FP 0x4856
42 #define P_MOVEAL_SP_FP 0x2c4f
43 #define P_ADDAW_SP 0xdefc
44 #define P_ADDAL_SP 0xdffc
45 #define P_SUBQW_SP 0x514f
46 #define P_SUBQL_SP 0x518f
47 #define P_LEA_SP_SP 0x4fef
48 #define P_LEA_PC_A5 0x4bfb0170
49 #define P_FMOVEMX_SP 0xf227
50 #define P_MOVEL_SP 0x2f00
51 #define P_MOVEML_SP 0x48e7
52 
53 /* Offset from SP to first arg on stack at first instruction of a function. */
54 #define SP_ARG0 (1 * 4)
55 
56 #if !defined (BPT_VECTOR)
57 #define BPT_VECTOR 0xf
58 #endif
59 
60 static const gdb_byte *
61 m68k_local_breakpoint_from_pc (struct gdbarch *gdbarch,
62  CORE_ADDR *pcptr, int *lenptr)
63 {
64  static gdb_byte break_insn[] = {0x4e, (0x40 | BPT_VECTOR)};
65  *lenptr = sizeof (break_insn);
66  return break_insn;
67 }
68 
69 
70 /* Construct types for ISA-specific registers. */
71 static struct type *
72 m68k_ps_type (struct gdbarch *gdbarch)
73 {
74  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
75 
76  if (!tdep->m68k_ps_type)
77  {
78  struct type *type;
79 
80  type = arch_flags_type (gdbarch, "builtin_type_m68k_ps", 4);
81  append_flags_type_flag (type, 0, "C");
82  append_flags_type_flag (type, 1, "V");
83  append_flags_type_flag (type, 2, "Z");
84  append_flags_type_flag (type, 3, "N");
85  append_flags_type_flag (type, 4, "X");
86  append_flags_type_flag (type, 8, "I0");
87  append_flags_type_flag (type, 9, "I1");
88  append_flags_type_flag (type, 10, "I2");
89  append_flags_type_flag (type, 12, "M");
90  append_flags_type_flag (type, 13, "S");
91  append_flags_type_flag (type, 14, "T0");
92  append_flags_type_flag (type, 15, "T1");
93 
94  tdep->m68k_ps_type = type;
95  }
96 
97  return tdep->m68k_ps_type;
98 }
99 
100 static struct type *
101 m68881_ext_type (struct gdbarch *gdbarch)
102 {
103  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
104 
105  if (!tdep->m68881_ext_type)
106  tdep->m68881_ext_type
107  = arch_float_type (gdbarch, -1, "builtin_type_m68881_ext",
109 
110  return tdep->m68881_ext_type;
111 }
112 
113 /* Return the GDB type object for the "standard" data type of data in
114  register N. This should be int for D0-D7, SR, FPCONTROL and
115  FPSTATUS, long double for FP0-FP7, and void pointer for all others
116  (A0-A7, PC, FPIADDR). Note, for registers which contain
117  addresses return pointer to void, not pointer to char, because we
118  don't want to attempt to print the string after printing the
119  address. */
120 
121 static struct type *
122 m68k_register_type (struct gdbarch *gdbarch, int regnum)
123 {
124  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
125 
126  if (tdep->fpregs_present)
127  {
128  if (regnum >= gdbarch_fp0_regnum (gdbarch)
129  && regnum <= gdbarch_fp0_regnum (gdbarch) + 7)
130  {
131  if (tdep->flavour == m68k_coldfire_flavour)
132  return builtin_type (gdbarch)->builtin_double;
133  else
134  return m68881_ext_type (gdbarch);
135  }
136 
137  if (regnum == M68K_FPI_REGNUM)
138  return builtin_type (gdbarch)->builtin_func_ptr;
139 
140  if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM)
141  return builtin_type (gdbarch)->builtin_int32;
142  }
143  else
144  {
145  if (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FPI_REGNUM)
146  return builtin_type (gdbarch)->builtin_int0;
147  }
148 
149  if (regnum == gdbarch_pc_regnum (gdbarch))
150  return builtin_type (gdbarch)->builtin_func_ptr;
151 
152  if (regnum >= M68K_A0_REGNUM && regnum <= M68K_A0_REGNUM + 7)
153  return builtin_type (gdbarch)->builtin_data_ptr;
154 
155  if (regnum == M68K_PS_REGNUM)
156  return m68k_ps_type (gdbarch);
157 
158  return builtin_type (gdbarch)->builtin_int32;
159 }
160 
161 static const char *m68k_register_names[] = {
162  "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
163  "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
164  "ps", "pc",
165  "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
166  "fpcontrol", "fpstatus", "fpiaddr"
167  };
168 
169 /* Function: m68k_register_name
170  Returns the name of the standard m68k register regnum. */
171 
172 static const char *
173 m68k_register_name (struct gdbarch *gdbarch, int regnum)
174 {
175  if (regnum < 0 || regnum >= ARRAY_SIZE (m68k_register_names))
176  internal_error (__FILE__, __LINE__,
177  _("m68k_register_name: illegal register number %d"),
178  regnum);
179  else if (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FPI_REGNUM
180  && gdbarch_tdep (gdbarch)->fpregs_present == 0)
181  return "";
182  else
183  return m68k_register_names[regnum];
184 }
185 
186 /* Return nonzero if a value of type TYPE stored in register REGNUM
187  needs any special handling. */
188 
189 static int
190 m68k_convert_register_p (struct gdbarch *gdbarch,
191  int regnum, struct type *type)
192 {
193  if (!gdbarch_tdep (gdbarch)->fpregs_present)
194  return 0;
195  return (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FP0_REGNUM + 7
196  && type != register_type (gdbarch, M68K_FP0_REGNUM));
197 }
198 
199 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
200  return its contents in TO. */
201 
202 static int
204  struct type *type, gdb_byte *to,
205  int *optimizedp, int *unavailablep)
206 {
208  struct type *fpreg_type = register_type (get_frame_arch (frame),
210 
211  /* We only support floating-point values. */
212  if (TYPE_CODE (type) != TYPE_CODE_FLT)
213  {
214  warning (_("Cannot convert floating-point register value "
215  "to non-floating-point type."));
216  *optimizedp = *unavailablep = 0;
217  return 0;
218  }
219 
220  /* Convert to TYPE. */
221 
222  /* Convert to TYPE. */
223  if (!get_frame_register_bytes (frame, regnum, 0, TYPE_LENGTH (type),
224  from, optimizedp, unavailablep))
225  return 0;
226 
227  convert_typed_floating (from, fpreg_type, to, type);
228  *optimizedp = *unavailablep = 0;
229  return 1;
230 }
231 
232 /* Write the contents FROM of a value of type TYPE into register
233  REGNUM in frame FRAME. */
234 
235 static void
237  struct type *type, const gdb_byte *from)
238 {
240  struct type *fpreg_type = register_type (get_frame_arch (frame),
242 
243  /* We only support floating-point values. */
244  if (TYPE_CODE (type) != TYPE_CODE_FLT)
245  {
246  warning (_("Cannot convert non-floating-point type "
247  "to floating-point register value."));
248  return;
249  }
250 
251  /* Convert from TYPE. */
252  convert_typed_floating (from, type, to, fpreg_type);
253  put_frame_register (frame, regnum, to);
254 }
255 
256 
257 /* There is a fair number of calling conventions that are in somewhat
258  wide use. The 68000/08/10 don't support an FPU, not even as a
259  coprocessor. All function return values are stored in %d0/%d1.
260  Structures are returned in a static buffer, a pointer to which is
261  returned in %d0. This means that functions returning a structure
262  are not re-entrant. To avoid this problem some systems use a
263  convention where the caller passes a pointer to a buffer in %a1
264  where the return values is to be stored. This convention is the
265  default, and is implemented in the function m68k_return_value.
266 
267  The 68020/030/040/060 do support an FPU, either as a coprocessor
268  (68881/2) or built-in (68040/68060). That's why System V release 4
269  (SVR4) instroduces a new calling convention specified by the SVR4
270  psABI. Integer values are returned in %d0/%d1, pointer return
271  values in %a0 and floating values in %fp0. When calling functions
272  returning a structure the caller should pass a pointer to a buffer
273  for the return value in %a0. This convention is implemented in the
274  function m68k_svr4_return_value, and by appropriately setting the
275  struct_value_regnum member of `struct gdbarch_tdep'.
276 
277  GNU/Linux returns values in the same way as SVR4 does, but uses %a1
278  for passing the structure return value buffer.
279 
280  GCC can also generate code where small structures are returned in
281  %d0/%d1 instead of in memory by using -freg-struct-return. This is
282  the default on NetBSD a.out, OpenBSD and GNU/Linux and several
283  embedded systems. This convention is implemented by setting the
284  struct_return member of `struct gdbarch_tdep' to reg_struct_return. */
285 
286 /* Read a function return value of TYPE from REGCACHE, and copy that
287  into VALBUF. */
288 
289 static void
291  gdb_byte *valbuf)
292 {
293  int len = TYPE_LENGTH (type);
295 
296  if (len <= 4)
297  {
298  regcache_raw_read (regcache, M68K_D0_REGNUM, buf);
299  memcpy (valbuf, buf + (4 - len), len);
300  }
301  else if (len <= 8)
302  {
303  regcache_raw_read (regcache, M68K_D0_REGNUM, buf);
304  memcpy (valbuf, buf + (8 - len), len - 4);
305  regcache_raw_read (regcache, M68K_D1_REGNUM, valbuf + (len - 4));
306  }
307  else
308  internal_error (__FILE__, __LINE__,
309  _("Cannot extract return value of %d bytes long."), len);
310 }
311 
312 static void
314  gdb_byte *valbuf)
315 {
317  struct gdbarch *gdbarch = get_regcache_arch (regcache);
318  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
319 
320  if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT)
321  {
322  struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM);
323  regcache_raw_read (regcache, M68K_FP0_REGNUM, buf);
324  convert_typed_floating (buf, fpreg_type, valbuf, type);
325  }
326  else if (TYPE_CODE (type) == TYPE_CODE_PTR && TYPE_LENGTH (type) == 4)
327  regcache_raw_read (regcache, M68K_A0_REGNUM, valbuf);
328  else
329  m68k_extract_return_value (type, regcache, valbuf);
330 }
331 
332 /* Write a function return value of TYPE from VALBUF into REGCACHE. */
333 
334 static void
336  const gdb_byte *valbuf)
337 {
338  int len = TYPE_LENGTH (type);
339 
340  if (len <= 4)
341  regcache_raw_write_part (regcache, M68K_D0_REGNUM, 4 - len, len, valbuf);
342  else if (len <= 8)
343  {
344  regcache_raw_write_part (regcache, M68K_D0_REGNUM, 8 - len,
345  len - 4, valbuf);
346  regcache_raw_write (regcache, M68K_D1_REGNUM, valbuf + (len - 4));
347  }
348  else
349  internal_error (__FILE__, __LINE__,
350  _("Cannot store return value of %d bytes long."), len);
351 }
352 
353 static void
355  const gdb_byte *valbuf)
356 {
357  struct gdbarch *gdbarch = get_regcache_arch (regcache);
358  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
359 
360  if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT)
361  {
362  struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM);
364  convert_typed_floating (valbuf, type, buf, fpreg_type);
365  regcache_raw_write (regcache, M68K_FP0_REGNUM, buf);
366  }
367  else if (TYPE_CODE (type) == TYPE_CODE_PTR && TYPE_LENGTH (type) == 4)
368  {
369  regcache_raw_write (regcache, M68K_A0_REGNUM, valbuf);
370  regcache_raw_write (regcache, M68K_D0_REGNUM, valbuf);
371  }
372  else
373  m68k_store_return_value (type, regcache, valbuf);
374 }
375 
376 /* Return non-zero if TYPE, which is assumed to be a structure, union or
377  complex type, should be returned in registers for architecture
378  GDBARCH. */
379 
380 static int
381 m68k_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type)
382 {
383  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
384  enum type_code code = TYPE_CODE (type);
385  int len = TYPE_LENGTH (type);
386 
387  gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION
388  || code == TYPE_CODE_COMPLEX);
389 
390  if (tdep->struct_return == pcc_struct_return)
391  return 0;
392 
393  return (len == 1 || len == 2 || len == 4 || len == 8);
394 }
395 
396 /* Determine, for architecture GDBARCH, how a return value of TYPE
397  should be returned. If it is supposed to be returned in registers,
398  and READBUF is non-zero, read the appropriate value from REGCACHE,
399  and copy it into READBUF. If WRITEBUF is non-zero, write the value
400  from WRITEBUF into REGCACHE. */
401 
402 static enum return_value_convention
403 m68k_return_value (struct gdbarch *gdbarch, struct value *function,
404  struct type *type, struct regcache *regcache,
405  gdb_byte *readbuf, const gdb_byte *writebuf)
406 {
407  enum type_code code = TYPE_CODE (type);
408 
409  /* GCC returns a `long double' in memory too. */
410  if (((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION
411  || code == TYPE_CODE_COMPLEX)
412  && !m68k_reg_struct_return_p (gdbarch, type))
413  || (code == TYPE_CODE_FLT && TYPE_LENGTH (type) == 12))
414  {
415  /* The default on m68k is to return structures in static memory.
416  Consequently a function must return the address where we can
417  find the return value. */
418 
419  if (readbuf)
420  {
421  ULONGEST addr;
422 
423  regcache_raw_read_unsigned (regcache, M68K_D0_REGNUM, &addr);
424  read_memory (addr, readbuf, TYPE_LENGTH (type));
425  }
426 
428  }
429 
430  if (readbuf)
431  m68k_extract_return_value (type, regcache, readbuf);
432  if (writebuf)
433  m68k_store_return_value (type, regcache, writebuf);
434 
436 }
437 
438 static enum return_value_convention
439 m68k_svr4_return_value (struct gdbarch *gdbarch, struct value *function,
440  struct type *type, struct regcache *regcache,
441  gdb_byte *readbuf, const gdb_byte *writebuf)
442 {
443  enum type_code code = TYPE_CODE (type);
444 
445  if ((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION
446  || code == TYPE_CODE_COMPLEX)
447  && !m68k_reg_struct_return_p (gdbarch, type))
448  {
449  /* The System V ABI says that:
450 
451  "A function returning a structure or union also sets %a0 to
452  the value it finds in %a0. Thus when the caller receives
453  control again, the address of the returned object resides in
454  register %a0."
455 
456  So the ABI guarantees that we can always find the return
457  value just after the function has returned. */
458 
459  if (readbuf)
460  {
461  ULONGEST addr;
462 
463  regcache_raw_read_unsigned (regcache, M68K_A0_REGNUM, &addr);
464  read_memory (addr, readbuf, TYPE_LENGTH (type));
465  }
466 
468  }
469 
470  /* This special case is for structures consisting of a single
471  `float' or `double' member. These structures are returned in
472  %fp0. For these structures, we call ourselves recursively,
473  changing TYPE into the type of the first member of the structure.
474  Since that should work for all structures that have only one
475  member, we don't bother to check the member's type here. */
476  if (code == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
477  {
478  type = check_typedef (TYPE_FIELD_TYPE (type, 0));
479  return m68k_svr4_return_value (gdbarch, function, type, regcache,
480  readbuf, writebuf);
481  }
482 
483  if (readbuf)
484  m68k_svr4_extract_return_value (type, regcache, readbuf);
485  if (writebuf)
486  m68k_svr4_store_return_value (type, regcache, writebuf);
487 
489 }
490 
491 
492 /* Always align the frame to a 4-byte boundary. This is required on
493  coldfire and harmless on the rest. */
494 
495 static CORE_ADDR
496 m68k_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
497 {
498  /* Align the stack to four bytes. */
499  return sp & ~3;
500 }
501 
502 static CORE_ADDR
503 m68k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
504  struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
505  struct value **args, CORE_ADDR sp, int struct_return,
506  CORE_ADDR struct_addr)
507 {
508  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
509  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
510  gdb_byte buf[4];
511  int i;
512 
513  /* Push arguments in reverse order. */
514  for (i = nargs - 1; i >= 0; i--)
515  {
516  struct type *value_type = value_enclosing_type (args[i]);
517  int len = TYPE_LENGTH (value_type);
518  int container_len = (len + 3) & ~3;
519  int offset;
520 
521  /* Non-scalars bigger than 4 bytes are left aligned, others are
522  right aligned. */
523  if ((TYPE_CODE (value_type) == TYPE_CODE_STRUCT
524  || TYPE_CODE (value_type) == TYPE_CODE_UNION
525  || TYPE_CODE (value_type) == TYPE_CODE_ARRAY)
526  && len > 4)
527  offset = 0;
528  else
529  offset = container_len - len;
530  sp -= container_len;
531  write_memory (sp + offset, value_contents_all (args[i]), len);
532  }
533 
534  /* Store struct value address. */
535  if (struct_return)
536  {
537  store_unsigned_integer (buf, 4, byte_order, struct_addr);
538  regcache_cooked_write (regcache, tdep->struct_value_regnum, buf);
539  }
540 
541  /* Store return address. */
542  sp -= 4;
543  store_unsigned_integer (buf, 4, byte_order, bp_addr);
544  write_memory (sp, buf, 4);
545 
546  /* Finally, update the stack pointer... */
547  store_unsigned_integer (buf, 4, byte_order, sp);
548  regcache_cooked_write (regcache, M68K_SP_REGNUM, buf);
549 
550  /* ...and fake a frame pointer. */
551  regcache_cooked_write (regcache, M68K_FP_REGNUM, buf);
552 
553  /* DWARF2/GCC uses the stack address *before* the function call as a
554  frame's CFA. */
555  return sp + 8;
556 }
557 
558 /* Convert a dwarf or dwarf2 regnumber to a GDB regnum. */
559 
560 static int
561 m68k_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int num)
562 {
563  if (num < 8)
564  /* d0..7 */
565  return (num - 0) + M68K_D0_REGNUM;
566  else if (num < 16)
567  /* a0..7 */
568  return (num - 8) + M68K_A0_REGNUM;
569  else if (num < 24 && gdbarch_tdep (gdbarch)->fpregs_present)
570  /* fp0..7 */
571  return (num - 16) + M68K_FP0_REGNUM;
572  else if (num == 25)
573  /* pc */
574  return M68K_PC_REGNUM;
575  else
576  return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
577 }
578 
579 
581 {
582  /* Base address. */
586 
587  /* Saved registers. */
590 
591  /* Stack space reserved for local variables. */
592  long locals;
593 };
594 
595 /* Allocate and initialize a frame cache. */
596 
597 static struct m68k_frame_cache *
599 {
600  struct m68k_frame_cache *cache;
601  int i;
602 
603  cache = FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache);
604 
605  /* Base address. */
606  cache->base = 0;
607  cache->sp_offset = -4;
608  cache->pc = 0;
609 
610  /* Saved registers. We initialize these to -1 since zero is a valid
611  offset (that's where %fp is supposed to be stored). */
612  for (i = 0; i < M68K_NUM_REGS; i++)
613  cache->saved_regs[i] = -1;
614 
615  /* Frameless until proven otherwise. */
616  cache->locals = -1;
617 
618  return cache;
619 }
620 
621 /* Check whether PC points at a code that sets up a new stack frame.
622  If so, it updates CACHE and returns the address of the first
623  instruction after the sequence that sets removes the "hidden"
624  argument from the stack or CURRENT_PC, whichever is smaller.
625  Otherwise, return PC. */
626 
627 static CORE_ADDR
628 m68k_analyze_frame_setup (struct gdbarch *gdbarch,
629  CORE_ADDR pc, CORE_ADDR current_pc,
630  struct m68k_frame_cache *cache)
631 {
632  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
633  int op;
634 
635  if (pc >= current_pc)
636  return current_pc;
637 
638  op = read_memory_unsigned_integer (pc, 2, byte_order);
639 
640  if (op == P_LINKW_FP || op == P_LINKL_FP || op == P_PEA_FP)
641  {
642  cache->saved_regs[M68K_FP_REGNUM] = 0;
643  cache->sp_offset += 4;
644  if (op == P_LINKW_FP)
645  {
646  /* link.w %fp, #-N */
647  /* link.w %fp, #0; adda.l #-N, %sp */
648  cache->locals = -read_memory_integer (pc + 2, 2, byte_order);
649 
650  if (pc + 4 < current_pc && cache->locals == 0)
651  {
652  op = read_memory_unsigned_integer (pc + 4, 2, byte_order);
653  if (op == P_ADDAL_SP)
654  {
655  cache->locals = read_memory_integer (pc + 6, 4, byte_order);
656  return pc + 10;
657  }
658  }
659 
660  return pc + 4;
661  }
662  else if (op == P_LINKL_FP)
663  {
664  /* link.l %fp, #-N */
665  cache->locals = -read_memory_integer (pc + 2, 4, byte_order);
666  return pc + 6;
667  }
668  else
669  {
670  /* pea (%fp); movea.l %sp, %fp */
671  cache->locals = 0;
672 
673  if (pc + 2 < current_pc)
674  {
675  op = read_memory_unsigned_integer (pc + 2, 2, byte_order);
676 
677  if (op == P_MOVEAL_SP_FP)
678  {
679  /* move.l %sp, %fp */
680  return pc + 4;
681  }
682  }
683 
684  return pc + 2;
685  }
686  }
687  else if ((op & 0170777) == P_SUBQW_SP || (op & 0170777) == P_SUBQL_SP)
688  {
689  /* subq.[wl] #N,%sp */
690  /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
691  cache->locals = (op & 07000) == 0 ? 8 : (op & 07000) >> 9;
692  if (pc + 2 < current_pc)
693  {
694  op = read_memory_unsigned_integer (pc + 2, 2, byte_order);
695  if ((op & 0170777) == P_SUBQW_SP || (op & 0170777) == P_SUBQL_SP)
696  {
697  cache->locals += (op & 07000) == 0 ? 8 : (op & 07000) >> 9;
698  return pc + 4;
699  }
700  }
701  return pc + 2;
702  }
703  else if (op == P_ADDAW_SP || op == P_LEA_SP_SP)
704  {
705  /* adda.w #-N,%sp */
706  /* lea (-N,%sp),%sp */
707  cache->locals = -read_memory_integer (pc + 2, 2, byte_order);
708  return pc + 4;
709  }
710  else if (op == P_ADDAL_SP)
711  {
712  /* adda.l #-N,%sp */
713  cache->locals = -read_memory_integer (pc + 2, 4, byte_order);
714  return pc + 6;
715  }
716 
717  return pc;
718 }
719 
720 /* Check whether PC points at code that saves registers on the stack.
721  If so, it updates CACHE and returns the address of the first
722  instruction after the register saves or CURRENT_PC, whichever is
723  smaller. Otherwise, return PC. */
724 
725 static CORE_ADDR
726 m68k_analyze_register_saves (struct gdbarch *gdbarch, CORE_ADDR pc,
727  CORE_ADDR current_pc,
728  struct m68k_frame_cache *cache)
729 {
730  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
731 
732  if (cache->locals >= 0)
733  {
735  int op;
736  int i, mask, regno;
737 
738  offset = -4 - cache->locals;
739  while (pc < current_pc)
740  {
741  op = read_memory_unsigned_integer (pc, 2, byte_order);
742  if (op == P_FMOVEMX_SP
743  && gdbarch_tdep (gdbarch)->fpregs_present)
744  {
745  /* fmovem.x REGS,-(%sp) */
746  op = read_memory_unsigned_integer (pc + 2, 2, byte_order);
747  if ((op & 0xff00) == 0xe000)
748  {
749  mask = op & 0xff;
750  for (i = 0; i < 16; i++, mask >>= 1)
751  {
752  if (mask & 1)
753  {
754  cache->saved_regs[i + M68K_FP0_REGNUM] = offset;
755  offset -= 12;
756  }
757  }
758  pc += 4;
759  }
760  else
761  break;
762  }
763  else if ((op & 0177760) == P_MOVEL_SP)
764  {
765  /* move.l %R,-(%sp) */
766  regno = op & 017;
767  cache->saved_regs[regno] = offset;
768  offset -= 4;
769  pc += 2;
770  }
771  else if (op == P_MOVEML_SP)
772  {
773  /* movem.l REGS,-(%sp) */
774  mask = read_memory_unsigned_integer (pc + 2, 2, byte_order);
775  for (i = 0; i < 16; i++, mask >>= 1)
776  {
777  if (mask & 1)
778  {
779  cache->saved_regs[15 - i] = offset;
780  offset -= 4;
781  }
782  }
783  pc += 4;
784  }
785  else
786  break;
787  }
788  }
789 
790  return pc;
791 }
792 
793 
794 /* Do a full analysis of the prologue at PC and update CACHE
795  accordingly. Bail out early if CURRENT_PC is reached. Return the
796  address where the analysis stopped.
797 
798  We handle all cases that can be generated by gcc.
799 
800  For allocating a stack frame:
801 
802  link.w %a6,#-N
803  link.l %a6,#-N
804  pea (%fp); move.l %sp,%fp
805  link.w %a6,#0; add.l #-N,%sp
806  subq.l #N,%sp
807  subq.w #N,%sp
808  subq.w #8,%sp; subq.w #N-8,%sp
809  add.w #-N,%sp
810  lea (-N,%sp),%sp
811  add.l #-N,%sp
812 
813  For saving registers:
814 
815  fmovem.x REGS,-(%sp)
816  move.l R1,-(%sp)
817  move.l R1,-(%sp); move.l R2,-(%sp)
818  movem.l REGS,-(%sp)
819 
820  For setting up the PIC register:
821 
822  lea (%pc,N),%a5
823 
824  */
825 
826 static CORE_ADDR
827 m68k_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR pc,
828  CORE_ADDR current_pc, struct m68k_frame_cache *cache)
829 {
830  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
831  unsigned int op;
832 
833  pc = m68k_analyze_frame_setup (gdbarch, pc, current_pc, cache);
834  pc = m68k_analyze_register_saves (gdbarch, pc, current_pc, cache);
835  if (pc >= current_pc)
836  return current_pc;
837 
838  /* Check for GOT setup. */
839  op = read_memory_unsigned_integer (pc, 4, byte_order);
840  if (op == P_LEA_PC_A5)
841  {
842  /* lea (%pc,N),%a5 */
843  return pc + 8;
844  }
845 
846  return pc;
847 }
848 
849 /* Return PC of first real instruction. */
850 
851 static CORE_ADDR
852 m68k_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
853 {
854  struct m68k_frame_cache cache;
855  CORE_ADDR pc;
856 
857  cache.locals = -1;
858  pc = m68k_analyze_prologue (gdbarch, start_pc, (CORE_ADDR) -1, &cache);
859  if (cache.locals < 0)
860  return start_pc;
861  return pc;
862 }
863 
864 static CORE_ADDR
865 m68k_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
866 {
867  gdb_byte buf[8];
868 
869  frame_unwind_register (next_frame, gdbarch_pc_regnum (gdbarch), buf);
870  return extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr);
871 }
872 
873 /* Normal frames. */
874 
875 static struct m68k_frame_cache *
876 m68k_frame_cache (struct frame_info *this_frame, void **this_cache)
877 {
878  struct gdbarch *gdbarch = get_frame_arch (this_frame);
879  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
880  struct m68k_frame_cache *cache;
881  gdb_byte buf[4];
882  int i;
883 
884  if (*this_cache)
885  return *this_cache;
886 
887  cache = m68k_alloc_frame_cache ();
888  *this_cache = cache;
889 
890  /* In principle, for normal frames, %fp holds the frame pointer,
891  which holds the base address for the current stack frame.
892  However, for functions that don't need it, the frame pointer is
893  optional. For these "frameless" functions the frame pointer is
894  actually the frame pointer of the calling frame. Signal
895  trampolines are just a special case of a "frameless" function.
896  They (usually) share their frame pointer with the frame that was
897  in progress when the signal occurred. */
898 
899  get_frame_register (this_frame, M68K_FP_REGNUM, buf);
900  cache->base = extract_unsigned_integer (buf, 4, byte_order);
901  if (cache->base == 0)
902  return cache;
903 
904  /* For normal frames, %pc is stored at 4(%fp). */
905  cache->saved_regs[M68K_PC_REGNUM] = 4;
906 
907  cache->pc = get_frame_func (this_frame);
908  if (cache->pc != 0)
909  m68k_analyze_prologue (get_frame_arch (this_frame), cache->pc,
910  get_frame_pc (this_frame), cache);
911 
912  if (cache->locals < 0)
913  {
914  /* We didn't find a valid frame, which means that CACHE->base
915  currently holds the frame pointer for our calling frame. If
916  we're at the start of a function, or somewhere half-way its
917  prologue, the function's frame probably hasn't been fully
918  setup yet. Try to reconstruct the base address for the stack
919  frame by looking at the stack pointer. For truly "frameless"
920  functions this might work too. */
921 
922  get_frame_register (this_frame, M68K_SP_REGNUM, buf);
923  cache->base = extract_unsigned_integer (buf, 4, byte_order)
924  + cache->sp_offset;
925  }
926 
927  /* Now that we have the base address for the stack frame we can
928  calculate the value of %sp in the calling frame. */
929  cache->saved_sp = cache->base + 8;
930 
931  /* Adjust all the saved registers such that they contain addresses
932  instead of offsets. */
933  for (i = 0; i < M68K_NUM_REGS; i++)
934  if (cache->saved_regs[i] != -1)
935  cache->saved_regs[i] += cache->base;
936 
937  return cache;
938 }
939 
940 static void
941 m68k_frame_this_id (struct frame_info *this_frame, void **this_cache,
942  struct frame_id *this_id)
943 {
944  struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
945 
946  /* This marks the outermost frame. */
947  if (cache->base == 0)
948  return;
949 
950  /* See the end of m68k_push_dummy_call. */
951  *this_id = frame_id_build (cache->base + 8, cache->pc);
952 }
953 
954 static struct value *
955 m68k_frame_prev_register (struct frame_info *this_frame, void **this_cache,
956  int regnum)
957 {
958  struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
959 
960  gdb_assert (regnum >= 0);
961 
962  if (regnum == M68K_SP_REGNUM && cache->saved_sp)
963  return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
964 
965  if (regnum < M68K_NUM_REGS && cache->saved_regs[regnum] != -1)
966  return frame_unwind_got_memory (this_frame, regnum,
967  cache->saved_regs[regnum]);
968 
969  return frame_unwind_got_register (this_frame, regnum, regnum);
970 }
971 
972 static const struct frame_unwind m68k_frame_unwind =
973 {
974  NORMAL_FRAME,
978  NULL,
980 };
981 
982 static CORE_ADDR
983 m68k_frame_base_address (struct frame_info *this_frame, void **this_cache)
984 {
985  struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
986 
987  return cache->base;
988 }
989 
990 static const struct frame_base m68k_frame_base =
991 {
995  m68k_frame_base_address
996 };
997 
998 static struct frame_id
999 m68k_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1000 {
1001  CORE_ADDR fp;
1002 
1003  fp = get_frame_register_unsigned (this_frame, M68K_FP_REGNUM);
1004 
1005  /* See the end of m68k_push_dummy_call. */
1006  return frame_id_build (fp + 8, get_frame_pc (this_frame));
1007 }
1008 
1009 
1010 /* Figure out where the longjmp will land. Slurp the args out of the stack.
1011  We expect the first arg to be a pointer to the jmp_buf structure from which
1012  we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
1013  This routine returns true on success. */
1014 
1015 static int
1017 {
1018  gdb_byte *buf;
1019  CORE_ADDR sp, jb_addr;
1020  struct gdbarch *gdbarch = get_frame_arch (frame);
1021  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1022  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1023 
1024  if (tdep->jb_pc < 0)
1025  {
1026  internal_error (__FILE__, __LINE__,
1027  _("m68k_get_longjmp_target: not implemented"));
1028  return 0;
1029  }
1030 
1031  buf = alloca (gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
1032  sp = get_frame_register_unsigned (frame, gdbarch_sp_regnum (gdbarch));
1033 
1034  if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack. */
1035  buf, gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT))
1036  return 0;
1037 
1038  jb_addr = extract_unsigned_integer (buf, gdbarch_ptr_bit (gdbarch)
1039  / TARGET_CHAR_BIT, byte_order);
1040 
1041  if (target_read_memory (jb_addr + tdep->jb_pc * tdep->jb_elt_size, buf,
1042  gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT),
1043  byte_order)
1044  return 0;
1045 
1046  *pc = extract_unsigned_integer (buf, gdbarch_ptr_bit (gdbarch)
1047  / TARGET_CHAR_BIT, byte_order);
1048  return 1;
1049 }
1050 
1051 
1052 /* This is the implementation of gdbarch method
1053  return_in_first_hidden_param_p. */
1054 
1055 static int
1056 m68k_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
1057  struct type *type)
1058 {
1059  return 0;
1060 }
1061 
1062 /* System V Release 4 (SVR4). */
1063 
1064 void
1065 m68k_svr4_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1066 {
1067  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1068 
1069  /* SVR4 uses a different calling convention. */
1071 
1072  /* SVR4 uses %a0 instead of %a1. */
1074 }
1075 
1076 
1077 /* Function: m68k_gdbarch_init
1078  Initializer function for the m68k gdbarch vector.
1079  Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
1080 
1081 static struct gdbarch *
1082 m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1083 {
1084  struct gdbarch_tdep *tdep = NULL;
1085  struct gdbarch *gdbarch;
1086  struct gdbarch_list *best_arch;
1087  struct tdesc_arch_data *tdesc_data = NULL;
1088  int i;
1089  enum m68k_flavour flavour = m68k_no_flavour;
1090  int has_fp = 1;
1091  const struct floatformat **long_double_format = floatformats_m68881_ext;
1092 
1093  /* Check any target description for validity. */
1094  if (tdesc_has_registers (info.target_desc))
1095  {
1096  const struct tdesc_feature *feature;
1097  int valid_p;
1098 
1099  feature = tdesc_find_feature (info.target_desc,
1100  "org.gnu.gdb.m68k.core");
1101 
1102  if (feature == NULL)
1103  {
1104  feature = tdesc_find_feature (info.target_desc,
1105  "org.gnu.gdb.coldfire.core");
1106  if (feature != NULL)
1107  flavour = m68k_coldfire_flavour;
1108  }
1109 
1110  if (feature == NULL)
1111  {
1112  feature = tdesc_find_feature (info.target_desc,
1113  "org.gnu.gdb.fido.core");
1114  if (feature != NULL)
1115  flavour = m68k_fido_flavour;
1116  }
1117 
1118  if (feature == NULL)
1119  return NULL;
1120 
1121  tdesc_data = tdesc_data_alloc ();
1122 
1123  valid_p = 1;
1124  for (i = 0; i <= M68K_PC_REGNUM; i++)
1125  valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
1126  m68k_register_names[i]);
1127 
1128  if (!valid_p)
1129  {
1130  tdesc_data_cleanup (tdesc_data);
1131  return NULL;
1132  }
1133 
1134  feature = tdesc_find_feature (info.target_desc,
1135  "org.gnu.gdb.coldfire.fp");
1136  if (feature != NULL)
1137  {
1138  valid_p = 1;
1139  for (i = M68K_FP0_REGNUM; i <= M68K_FPI_REGNUM; i++)
1140  valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
1141  m68k_register_names[i]);
1142  if (!valid_p)
1143  {
1144  tdesc_data_cleanup (tdesc_data);
1145  return NULL;
1146  }
1147  }
1148  else
1149  has_fp = 0;
1150  }
1151 
1152  /* The mechanism for returning floating values from function
1153  and the type of long double depend on whether we're
1154  on ColdFire or standard m68k. */
1155 
1156  if (info.bfd_arch_info && info.bfd_arch_info->mach != 0)
1157  {
1158  const bfd_arch_info_type *coldfire_arch =
1159  bfd_lookup_arch (bfd_arch_m68k, bfd_mach_mcf_isa_a_nodiv);
1160 
1161  if (coldfire_arch
1162  && ((*info.bfd_arch_info->compatible)
1163  (info.bfd_arch_info, coldfire_arch)))
1164  flavour = m68k_coldfire_flavour;
1165  }
1166 
1167  /* If there is already a candidate, use it. */
1168  for (best_arch = gdbarch_list_lookup_by_info (arches, &info);
1169  best_arch != NULL;
1170  best_arch = gdbarch_list_lookup_by_info (best_arch->next, &info))
1171  {
1172  if (flavour != gdbarch_tdep (best_arch->gdbarch)->flavour)
1173  continue;
1174 
1175  if (has_fp != gdbarch_tdep (best_arch->gdbarch)->fpregs_present)
1176  continue;
1177 
1178  break;
1179  }
1180 
1181  if (best_arch != NULL)
1182  {
1183  if (tdesc_data != NULL)
1184  tdesc_data_cleanup (tdesc_data);
1185  return best_arch->gdbarch;
1186  }
1187 
1188  tdep = xzalloc (sizeof (struct gdbarch_tdep));
1189  gdbarch = gdbarch_alloc (&info, tdep);
1190  tdep->fpregs_present = has_fp;
1191  tdep->flavour = flavour;
1192 
1193  if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
1194  long_double_format = floatformats_ieee_double;
1195  set_gdbarch_long_double_format (gdbarch, long_double_format);
1196  set_gdbarch_long_double_bit (gdbarch, long_double_format[0]->totalsize);
1197 
1200 
1201  /* Stack grows down. */
1204 
1205  set_gdbarch_believe_pcc_promotion (gdbarch, 1);
1206  if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
1207  set_gdbarch_decr_pc_after_break (gdbarch, 2);
1208 
1209  set_gdbarch_frame_args_skip (gdbarch, 8);
1211 
1221 
1222  if (has_fp)
1224 
1225  /* Try to figure out if the arch uses floating registers to return
1226  floating point values from functions. */
1227  if (has_fp)
1228  {
1229  /* On ColdFire, floating point values are returned in D0. */
1230  if (flavour == m68k_coldfire_flavour)
1231  tdep->float_return = 0;
1232  else
1233  tdep->float_return = 1;
1234  }
1235  else
1236  {
1237  /* No floating registers, so can't use them for returning values. */
1238  tdep->float_return = 0;
1239  }
1240 
1241  /* Function call & return. */
1246 
1247 
1248  /* Disassembler. */
1249  set_gdbarch_print_insn (gdbarch, print_insn_m68k);
1250 
1251 #if defined JB_PC && defined JB_ELEMENT_SIZE
1252  tdep->jb_pc = JB_PC;
1253  tdep->jb_elt_size = JB_ELEMENT_SIZE;
1254 #else
1255  tdep->jb_pc = -1;
1256 #endif
1259 
1260  /* Frame unwinder. */
1263 
1264  /* Hook in the DWARF CFI frame unwinder. */
1265  dwarf2_append_unwinders (gdbarch);
1266 
1267  frame_base_set_default (gdbarch, &m68k_frame_base);
1268 
1269  /* Hook in ABI-specific overrides, if they have been registered. */
1270  gdbarch_init_osabi (info, gdbarch);
1271 
1272  /* Now we have tuned the configuration, set a few final things,
1273  based on what the OS ABI has told us. */
1274 
1275  if (tdep->jb_pc >= 0)
1277 
1278  frame_unwind_append_unwinder (gdbarch, &m68k_frame_unwind);
1279 
1280  if (tdesc_data)
1281  tdesc_use_registers (gdbarch, info.target_desc, tdesc_data);
1282 
1283  return gdbarch;
1284 }
1285 
1286 
1287 static void
1288 m68k_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
1289 {
1290  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1291 
1292  if (tdep == NULL)
1293  return;
1294 }
1295 
1296 extern initialize_file_ftype _initialize_m68k_tdep; /* -Wmissing-prototypes */
1297 
1298 void
1300 {
1302 }
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
void m68k_svr4_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: m68k-tdep.c:1065
void set_gdbarch_value_to_register(struct gdbarch *gdbarch, gdbarch_value_to_register_ftype value_to_register)
Definition: gdbarch.c:2457
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
type_code
Definition: gdbtypes.h:85
void set_gdbarch_ps_regnum(struct gdbarch *gdbarch, int ps_regnum)
Definition: gdbarch.c:2025
static int m68k_dwarf_reg_to_regnum(struct gdbarch *gdbarch, int num)
Definition: m68k-tdep.c:561
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
#define P_MOVEML_SP
Definition: m68k-tdep.c:51
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition: findvar.c:169
void set_gdbarch_get_longjmp_target(struct gdbarch *gdbarch, gdbarch_get_longjmp_target_ftype get_longjmp_target)
Definition: gdbarch.c:2390
#define P_LINKW_FP
Definition: m68k-tdep.c:40
struct type * builtin_func_ptr
Definition: gdbtypes.h:1544
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
static int m68k_return_in_first_hidden_param_p(struct gdbarch *gdbarch, struct type *type)
Definition: m68k-tdep.c:1056
void set_gdbarch_fp0_regnum(struct gdbarch *gdbarch, int fp0_regnum)
Definition: gdbarch.c:2042
bfd_vma CORE_ADDR
Definition: common-types.h:41
int float_return
Definition: m68k-tdep.h:86
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: osabi.c:341
const struct floatformat * floatformats_ieee_double[BFD_ENDIAN_UNKNOWN]
Definition: gdbtypes.c:74
static CORE_ADDR m68k_frame_base_address(struct frame_info *this_frame, void **this_cache)
Definition: m68k-tdep.c:983
static int m68k_register_to_value(struct frame_info *frame, int regnum, struct type *type, gdb_byte *to, int *optimizedp, int *unavailablep)
Definition: m68k-tdep.c:203
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
struct value * frame_unwind_got_memory(struct frame_info *frame, int regnum, CORE_ADDR addr)
Definition: frame-unwind.c:228
static void m68k_value_to_register(struct frame_info *frame, int regnum, struct type *type, const gdb_byte *from)
Definition: m68k-tdep.c:236
struct type * arch_flags_type(struct gdbarch *gdbarch, char *name, int length)
Definition: gdbtypes.c:4643
#define BPT_VECTOR
Definition: m68k-tdep.c:57
void warning(const char *fmt,...)
Definition: errors.c:26
static struct value * m68k_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
Definition: m68k-tdep.c:955
#define SP_ARG0
Definition: m68k-tdep.c:54
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1690
struct type * arch_float_type(struct gdbarch *gdbarch, int bit, char *name, const struct floatformat **floatformats)
Definition: gdbtypes.c:4606
void convert_typed_floating(const void *from, const struct type *from_type, void *to, const struct type *to_type)
Definition: doublest.c:862
#define M68K_NUM_REGS
Definition: m68k-tdep.h:47
#define M68K_MAX_REGISTER_SIZE
Definition: m68k-tdep.h:50
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
CORE_ADDR saved_regs[M68K_NUM_REGS]
Definition: m68k-tdep.c:588
m68k_flavour
Definition: m68k-tdep.h:61
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
void frame_unwind_register(struct frame_info *frame, int regnum, gdb_byte *buf)
Definition: frame.c:1065
#define P_ADDAW_SP
Definition: m68k-tdep.c:43
static int m68k_convert_register_p(struct gdbarch *gdbarch, int regnum, struct type *type)
Definition: m68k-tdep.c:190
void append_flags_type_flag(struct type *type, int bitpos, char *name)
Definition: gdbtypes.c:4660
return_value_convention
Definition: defs.h:206
static const gdb_byte * m68k_local_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
Definition: m68k-tdep.c:61
static void m68k_extract_return_value(struct type *type, struct regcache *regcache, gdb_byte *valbuf)
Definition: m68k-tdep.c:290
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
Definition: gdbarch.c:4985
struct gdbarch_list * next
Definition: gdbarch.h:1543
static void m68k_store_return_value(struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
Definition: m68k-tdep.c:335
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1898
#define _(String)
Definition: gdb_locale.h:40
CORE_ADDR base
Definition: m68k-tdep.c:583
const struct bfd_arch_info * bfd_arch_info
Definition: gdbarch.h:1549
void set_gdbarch_return_in_first_hidden_param_p(struct gdbarch *gdbarch, gdbarch_return_in_first_hidden_param_p_ftype return_in_first_hidden_param_p)
Definition: gdbarch.c:2573
enum m68k_flavour flavour
Definition: m68k-tdep.h:89
void set_gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
Definition: gdbarch.c:2110
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
Definition: gdbarch.c:1402
void tdesc_data_cleanup(void *data_untyped)
static int m68k_reg_struct_return_p(struct gdbarch *gdbarch, struct type *type)
Definition: m68k-tdep.c:381
#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
static struct type * m68k_ps_type(struct gdbarch *gdbarch)
Definition: m68k-tdep.c:72
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
struct value * frame_unwind_got_constant(struct frame_info *frame, int regnum, ULONGEST val)
Definition: frame-unwind.c:241
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep)
Definition: gdbarch.c:4933
static struct m68k_frame_cache * m68k_alloc_frame_cache(void)
Definition: m68k-tdep.c:598
CORE_ADDR pc
Definition: m68k-tdep.c:585
int gdbarch_num_pseudo_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1916
#define P_FMOVEMX_SP
Definition: m68k-tdep.c:49
int tdesc_numbered_register(const struct tdesc_feature *feature, struct tdesc_arch_data *data, int regno, const char *name)
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
Definition: frame-base.c:94
int * from
Definition: varobj.h:282
static CORE_ADDR m68k_analyze_register_saves(struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR current_pc, struct m68k_frame_cache *cache)
Definition: m68k-tdep.c:726
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
static struct frame_id m68k_dummy_id(struct gdbarch *gdbarch, struct frame_info *this_frame)
Definition: m68k-tdep.c:999
LONGEST read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:311
const struct floatformat * floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN]
Definition: gdbtypes.c:86
initialize_file_ftype _initialize_m68k_tdep
static CORE_ADDR m68k_unwind_pc(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: m68k-tdep.c:865
enum struct_return struct_return
Definition: arm-tdep.h:197
void initialize_file_ftype(void)
Definition: defs.h:281
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:1981
static CORE_ADDR m68k_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR current_pc, struct m68k_frame_cache *cache)
Definition: m68k-tdep.c:827
void * xzalloc(size_t size)
Definition: common-utils.c:91
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
Definition: gdbarch.c:1991
void set_gdbarch_decr_pc_after_break(struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break)
Definition: gdbarch.c:2764
struct type * register_type(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:157
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype dummy_id)
Definition: gdbarch.c:2175
static void m68k_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
Definition: m68k-tdep.c:941
struct_return
Definition: arm-tdep.h:148
void set_gdbarch_believe_pcc_promotion(struct gdbarch *gdbarch, int believe_pcc_promotion)
Definition: gdbarch.c:2406
const gdb_byte * value_contents_all(struct value *value)
Definition: value.c:1188
static CORE_ADDR m68k_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: m68k-tdep.c:503
struct type * value_enclosing_type(struct value *value)
Definition: value.c:1098
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
static enum return_value_convention m68k_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: m68k-tdep.c:403
static struct type * m68881_ext_type(struct gdbarch *gdbarch)
Definition: m68k-tdep.c:101
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
Definition: gdbtypes.h:749
struct type * builtin_int0
Definition: gdbtypes.h:1513
CORE_ADDR saved_sp
Definition: m68k-tdep.c:589
void set_gdbarch_register_to_value(struct gdbarch *gdbarch, gdbarch_register_to_value_ftype register_to_value)
Definition: gdbarch.c:2440
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 gdb_assert(expr)
Definition: gdb_assert.h:33
#define P_LEA_PC_A5
Definition: m68k-tdep.c:48
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:690
static struct m68k_frame_cache * m68k_frame_cache(struct frame_info *this_frame, void **this_cache)
Definition: m68k-tdep.c:876
struct gdbarch * gdbarch
Definition: gdbarch.h:1542
int regnum
Definition: aarch64-tdep.c:69
#define P_MOVEAL_SP_FP
Definition: m68k-tdep.c:42
#define P_ADDAL_SP
Definition: m68k-tdep.c:44
#define P_MOVEL_SP
Definition: m68k-tdep.c:50
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:244
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1194
#define P_SUBQW_SP
Definition: m68k-tdep.c:45
void set_gdbarch_frame_args_skip(struct gdbarch *gdbarch, CORE_ADDR frame_args_skip)
Definition: gdbarch.c:2839
static const char * m68k_register_name(struct gdbarch *gdbarch, int regnum)
Definition: m68k-tdep.c:173
size_t jb_elt_size
Definition: aarch64-tdep.h:83
void put_frame_register(struct frame_info *frame, int regnum, const gdb_byte *buf)
Definition: frame.c:1220
const struct target_desc * target_desc
Definition: gdbarch.h:1566
Definition: value.c:172
#define P_LEA_SP_SP
Definition: m68k-tdep.c:47
void regcache_raw_write_part(struct regcache *regcache, int regnum, int offset, int len, const gdb_byte *buf)
Definition: regcache.c:1006
void tdesc_use_registers(struct gdbarch *gdbarch, const struct target_desc *target_desc, struct tdesc_arch_data *early_data)
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
Definition: arch-utils.c:138
bfd_byte gdb_byte
Definition: common-types.h:38
struct type * builtin_double
Definition: gdbtypes.h:1491
void set_gdbarch_convert_register_p(struct gdbarch *gdbarch, gdbarch_convert_register_p_ftype convert_register_p)
Definition: gdbarch.c:2423
#define P_PEA_FP
Definition: m68k-tdep.c:41
int gdbarch_fp0_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:2032
#define P_LINKL_FP
Definition: m68k-tdep.c:39
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
enum register_status regcache_raw_read(struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: regcache.c:637
struct value * frame_unwind_got_register(struct frame_info *frame, int regnum, int new_regnum)
Definition: frame-unwind.c:218
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
static CORE_ADDR m68k_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR start_pc)
Definition: m68k-tdep.c:852
int offset
Definition: agent.c:65
int code
Definition: ser-unix.c:684
void get_frame_register(struct frame_info *frame, int regnum, gdb_byte *buf)
Definition: frame.c:1085
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1241
static const struct frame_unwind m68k_frame_unwind
Definition: m68k-tdep.c:972
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
static CORE_ADDR m68k_analyze_frame_setup(struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR current_pc, struct m68k_frame_cache *cache)
Definition: m68k-tdep.c:628
struct m32c_reg * sp
Definition: m32c-tdep.c:114
CORE_ADDR sp_offset
Definition: m68k-tdep.c:584
struct tdesc_arch_data * tdesc_data_alloc(void)
int get_frame_register_bytes(struct frame_info *frame, int regnum, CORE_ADDR offset, int len, gdb_byte *myaddr, int *optimizedp, int *unavailablep)
Definition: frame.c:1274
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
const struct tdesc_feature * tdesc_find_feature(const struct target_desc *target_desc, const char *name)
int fpregs_present
Definition: m68k-tdep.h:93
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
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
Definition: gdbarch.c:2556
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:1998
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
int int * to
Definition: varobj.h:282
struct type * m68881_ext_type
Definition: m68k-tdep.h:97
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype push_dummy_call)
Definition: gdbarch.c:2216
static void m68k_svr4_store_return_value(struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
Definition: m68k-tdep.c:354
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:321
static CORE_ADDR m68k_frame_align(struct gdbarch *gdbarch, CORE_ADDR sp)
Definition: m68k-tdep.c:496
static struct gdbarch * m68k_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
Definition: m68k-tdep.c:1082
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
static struct gdbarch_data * tdesc_data
enum bfd_endian byte_order
Definition: gdbarch.c:128
struct type * m68k_ps_type
Definition: m68k-tdep.h:96
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
Definition: gdbarch.c:2008
int tdesc_has_registers(const struct target_desc *target_desc)
#define P_SUBQL_SP
Definition: m68k-tdep.c:46
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
void regcache_cooked_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: regcache.c:930
static void m68k_dump_tdep(struct gdbarch *gdbarch, struct ui_file *file)
Definition: m68k-tdep.c:1288
static void m68k_svr4_extract_return_value(struct type *type, struct regcache *regcache, gdb_byte *valbuf)
Definition: m68k-tdep.c:313
void set_gdbarch_print_insn(struct gdbarch *gdbarch, gdbarch_print_insn_ftype print_insn)
Definition: gdbarch.c:3067
static enum return_value_convention m68k_svr4_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: m68k-tdep.c:439
int struct_value_regnum
Definition: m68k-tdep.h:80
static struct type * m68k_register_type(struct gdbarch *gdbarch, int regnum)
Definition: m68k-tdep.c:122
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
static int m68k_get_longjmp_target(struct frame_info *frame, CORE_ADDR *pc)
Definition: m68k-tdep.c:1016