GDB (xrefs)

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