GDB (xrefs)
Loading...
Searching...
No Matches
m68hc11-tdep.c
Go to the documentation of this file.
1/* Target-dependent code for Motorola 68HC11 & 68HC12
2
3 Copyright (C) 1999-2023 Free Software Foundation, Inc.
4
5 Contributed by Stephane Carrez, stcarrez@nerim.fr
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22
23#include "defs.h"
24#include "frame.h"
25#include "frame-unwind.h"
26#include "frame-base.h"
27#include "dwarf2/frame.h"
28#include "trad-frame.h"
29#include "symtab.h"
30#include "gdbtypes.h"
31#include "gdbcmd.h"
32#include "gdbcore.h"
33#include "value.h"
34#include "inferior.h"
35#include "dis-asm.h"
36#include "symfile.h"
37#include "objfiles.h"
38#include "arch-utils.h"
39#include "regcache.h"
40#include "reggroups.h"
41#include "gdbarch.h"
42
43#include "target.h"
44#include "opcode/m68hc11.h"
45#include "elf/m68hc11.h"
46#include "elf-bfd.h"
47
48/* Macros for setting and testing a bit in a minimal symbol.
49 For 68HC11/68HC12 we have two flags that tell which return
50 type the function is using. This is used for prologue and frame
51 analysis to compute correct stack frame layout.
52
53 The MSB of the minimal symbol's "info" field is used for this purpose.
54
55 MSYMBOL_SET_RTC Actually sets the "RTC" bit.
56 MSYMBOL_SET_RTI Actually sets the "RTI" bit.
57 MSYMBOL_IS_RTC Tests the "RTC" bit in a minimal symbol.
58 MSYMBOL_IS_RTI Tests the "RTC" bit in a minimal symbol. */
59
60#define MSYMBOL_SET_RTC(msym) \
61 (msym)->set_target_flag_1 (true)
62
63#define MSYMBOL_SET_RTI(msym) \
64 (msym)->set_target_flag_2 (true)
65
66#define MSYMBOL_IS_RTC(msym) \
67 (msym)->target_flag_1 ()
68
69#define MSYMBOL_IS_RTI(msym) \
70 (msym)->target_flag_2 ()
71
77
78
79/* Register numbers of various important registers. */
80
81#define HARD_X_REGNUM 0
82#define HARD_D_REGNUM 1
83#define HARD_Y_REGNUM 2
84#define HARD_SP_REGNUM 3
85#define HARD_PC_REGNUM 4
86
87#define HARD_A_REGNUM 5
88#define HARD_B_REGNUM 6
89#define HARD_CCR_REGNUM 7
90
91/* 68HC12 page number register.
92 Note: to keep a compatibility with gcc register naming, we must
93 not have to rename FP and other soft registers. The page register
94 is a real hard register and must therefore be counted by gdbarch_num_regs.
95 For this it has the same number as Z register (which is not used). */
96#define HARD_PAGE_REGNUM 8
97#define M68HC11_LAST_HARD_REG (HARD_PAGE_REGNUM)
98
99/* Z is replaced by X or Y by gcc during machine reorg.
100 ??? There is no way to get it and even know whether
101 it's in X or Y or in ZS. */
102#define SOFT_Z_REGNUM 8
103
104/* Soft registers. These registers are special. There are treated
105 like normal hard registers by gcc and gdb (ie, within dwarf2 info).
106 They are physically located in memory. */
107#define SOFT_FP_REGNUM 9
108#define SOFT_TMP_REGNUM 10
109#define SOFT_ZS_REGNUM 11
110#define SOFT_XY_REGNUM 12
111#define SOFT_UNUSED_REGNUM 13
112#define SOFT_D1_REGNUM 14
113#define SOFT_D32_REGNUM (SOFT_D1_REGNUM+31)
114#define M68HC11_MAX_SOFT_REGS 32
115
116#define M68HC11_NUM_REGS (M68HC11_LAST_HARD_REG + 1)
117#define M68HC11_NUM_PSEUDO_REGS (M68HC11_MAX_SOFT_REGS+5)
118#define M68HC11_ALL_REGS (M68HC11_NUM_REGS+M68HC11_NUM_PSEUDO_REGS)
119
120#define M68HC11_REG_SIZE (2)
121
122#define M68HC12_NUM_REGS (9)
123#define M68HC12_NUM_PSEUDO_REGS ((M68HC11_MAX_SOFT_REGS+5)+1-1)
124#define M68HC12_HARD_PC_REGNUM (SOFT_D32_REGNUM+1)
125
126struct insn_sequence;
128 {
129 /* Stack pointer correction value. For 68hc11, the stack pointer points
130 to the next push location. An offset of 1 must be applied to obtain
131 the address where the last value is saved. For 68hc12, the stack
132 pointer points to the last value pushed. No offset is necessary. */
134
135 /* Description of instructions in the prologue. */
136 struct insn_sequence *prologue = nullptr;
137
138 /* True if the page memory bank register is available
139 and must be used. */
141
142 /* ELF flags for ABI. */
143 int elf_flags = 0;
144 };
145
146static int
148{
149 m68gc11_gdbarch_tdep *tdep = gdbarch_tdep<m68gc11_gdbarch_tdep> (arch);
150 return tdep->stack_correction;
151}
152
153static int
155{
156 m68gc11_gdbarch_tdep *tdep = gdbarch_tdep<m68gc11_gdbarch_tdep> (arch);
157 return tdep->stack_correction;
158}
159
161{
162 /* The previous frame's inner most stack address. Used as this
163 frame ID's stack_addr. */
164 CORE_ADDR prev_sp;
165 /* The frame's base, optionally used by the high-level debug info. */
166 CORE_ADDR base;
167 CORE_ADDR pc;
168 int size;
170 CORE_ADDR return_pc;
171 CORE_ADDR sp_offset;
174
175 /* Table indicating the location of each and every register. */
177};
178
179/* Table of registers for 68HC11. This includes the hard registers
180 and the soft registers used by GCC. */
181static const char *
183{
184 "x", "d", "y", "sp", "pc", "a", "b",
185 "ccr", "page", "frame","tmp", "zs", "xy", 0,
186 "d1", "d2", "d3", "d4", "d5", "d6", "d7",
187 "d8", "d9", "d10", "d11", "d12", "d13", "d14",
188 "d15", "d16", "d17", "d18", "d19", "d20", "d21",
189 "d22", "d23", "d24", "d25", "d26", "d27", "d28",
190 "d29", "d30", "d31", "d32"
191};
192
194{
195 const char *name;
196 CORE_ADDR addr;
197};
198
200
201#define M68HC11_FP_ADDR soft_regs[SOFT_FP_REGNUM].addr
202
203static int soft_min_addr;
204static int soft_max_addr;
205static int soft_reg_initialized = 0;
206
207/* Look in the symbol table for the address of a pseudo register
208 in memory. If we don't find it, pretend the register is not used
209 and not available. */
210static void
212{
213 struct bound_minimal_symbol msymbol;
214
215 msymbol = lookup_minimal_symbol (name, NULL, NULL);
216 if (msymbol.minsym)
217 {
218 reg->addr = msymbol.value_address ();
219 reg->name = xstrdup (name);
220
221 /* Keep track of the address range for soft registers. */
222 if (reg->addr < (CORE_ADDR) soft_min_addr)
223 soft_min_addr = reg->addr;
224 if (reg->addr > (CORE_ADDR) soft_max_addr)
225 soft_max_addr = reg->addr;
226 }
227 else
228 {
229 reg->name = 0;
230 reg->addr = 0;
231 }
232}
233
234/* Initialize the table of soft register addresses according
235 to the symbol table. */
236 static void
238{
239 int i;
240
242 return;
243
244 soft_min_addr = INT_MAX;
245 soft_max_addr = 0;
246 for (i = 0; i < M68HC11_ALL_REGS; i++)
247 {
248 soft_regs[i].name = 0;
249 }
250
256
257 for (i = SOFT_D1_REGNUM; i < M68HC11_MAX_SOFT_REGS; i++)
258 {
259 char buf[10];
260
261 xsnprintf (buf, sizeof (buf), "_.d%d", i - SOFT_D1_REGNUM + 1);
263 }
264
265 if (soft_regs[SOFT_FP_REGNUM].name == 0)
266 warning (_("No frame soft register found in the symbol table.\n"
267 "Stack backtrace will not work."));
269}
270
271/* Given an address in memory, return the soft register number if
272 that address corresponds to a soft register. Returns -1 if not. */
273static int
275{
276 int i;
277
278 if (addr < soft_min_addr || addr > soft_max_addr)
279 return -1;
280
281 for (i = SOFT_FP_REGNUM; i < M68HC11_ALL_REGS; i++)
282 {
283 if (soft_regs[i].name && soft_regs[i].addr == addr)
284 return i;
285 }
286 return -1;
287}
288
289/* Fetch a pseudo register. The 68hc11 soft registers are treated like
290 pseudo registers. They are located in memory. Translate the register
291 fetch into a memory read. */
292static enum register_status
295 int regno, gdb_byte *buf)
296{
297 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
298
299 /* The PC is a pseudo reg only for 68HC12 with the memory bank
300 addressing mode. */
301 if (regno == M68HC12_HARD_PC_REGNUM)
302 {
303 ULONGEST pc;
304 const int regsize = 4;
305 enum register_status status;
306
308 if (status != REG_VALID)
309 return status;
310 if (pc >= 0x8000 && pc < 0xc000)
311 {
312 ULONGEST page;
313
315 pc -= 0x8000;
316 pc += (page << 14);
317 pc += 0x1000000;
318 }
319 store_unsigned_integer (buf, regsize, byte_order, pc);
320 return REG_VALID;
321 }
322
324
325 /* Fetch a soft register: translate into a memory read. */
326 if (soft_regs[regno].name)
327 {
328 target_read_memory (soft_regs[regno].addr, buf, 2);
329 }
330 else
331 {
332 memset (buf, 0, 2);
333 }
334
335 return REG_VALID;
336}
337
338/* Store a pseudo register. Translate the register store
339 into a memory write. */
340static void
342 struct regcache *regcache,
343 int regno, const gdb_byte *buf)
344{
345 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
346
347 /* The PC is a pseudo reg only for 68HC12 with the memory bank
348 addressing mode. */
349 if (regno == M68HC12_HARD_PC_REGNUM)
350 {
351 const int regsize = 4;
352 gdb_byte *tmp = (gdb_byte *) alloca (regsize);
353 CORE_ADDR pc;
354
355 memcpy (tmp, buf, regsize);
356 pc = extract_unsigned_integer (tmp, regsize, byte_order);
357 if (pc >= 0x1000000)
358 {
359 pc -= 0x1000000;
361 (pc >> 14) & 0x0ff);
362 pc &= 0x03fff;
364 pc + 0x8000);
365 }
366 else
368 return;
369 }
370
372
373 /* Store a soft register: translate into a memory write. */
374 if (soft_regs[regno].name)
375 {
376 const int regsize = 2;
377 gdb_byte *tmp = (gdb_byte *) alloca (regsize);
378 memcpy (tmp, buf, regsize);
379 target_write_memory (soft_regs[regno].addr, tmp, regsize);
380 }
381}
382
383static const char *
385{
387 return "pc";
388
389 if (reg_nr == HARD_PC_REGNUM && use_page_register (gdbarch))
390 return "ppc";
391
392 if (reg_nr >= M68HC11_ALL_REGS)
393 return "";
394
396
397 /* If we don't know the address of a soft register, pretend it
398 does not exist. */
399 if (reg_nr > M68HC11_LAST_HARD_REG && soft_regs[reg_nr].name == 0)
400 return "";
401
402 return m68hc11_register_names[reg_nr];
403}
404
405constexpr gdb_byte m68hc11_break_insn[] = {0x0};
406
407typedef BP_MANIPULATION (m68hc11_break_insn) m68hc11_breakpoint;
408
409/* 68HC11 & 68HC12 prologue analysis. */
410
411#define MAX_CODES 12
412
413/* 68HC11 opcodes. */
414#undef M6811_OP_PAGE2
415#define M6811_OP_PAGE2 (0x18)
416#define M6811_OP_LDX (0xde)
417#define M6811_OP_LDX_EXT (0xfe)
418#define M6811_OP_PSHX (0x3c)
419#define M6811_OP_STS (0x9f)
420#define M6811_OP_STS_EXT (0xbf)
421#define M6811_OP_TSX (0x30)
422#define M6811_OP_XGDX (0x8f)
423#define M6811_OP_ADDD (0xc3)
424#define M6811_OP_TXS (0x35)
425#define M6811_OP_DES (0x34)
426
427/* 68HC12 opcodes. */
428#define M6812_OP_PAGE2 (0x18)
429#define M6812_OP_MOVW (0x01)
430#define M6812_PB_PSHW (0xae)
431#define M6812_OP_STS (0x5f)
432#define M6812_OP_STS_EXT (0x7f)
433#define M6812_OP_LEAS (0x1b)
434#define M6812_OP_PSHX (0x34)
435#define M6812_OP_PSHY (0x35)
436
437/* Operand extraction. */
438#define OP_DIRECT (0x100) /* 8-byte direct addressing. */
439#define OP_IMM_LOW (0x200) /* Low part of 16-bit constant/address. */
440#define OP_IMM_HIGH (0x300) /* High part of 16-bit constant/address. */
441#define OP_PBYTE (0x400) /* 68HC12 indexed operand. */
442
443/* Identification of the sequence. */
444enum m6811_seq_type
445{
446 P_LAST = 0,
447 P_SAVE_REG, /* Save a register on the stack. */
448 P_SET_FRAME, /* Setup the frame pointer. */
449 P_LOCAL_1, /* Allocate 1 byte for locals. */
450 P_LOCAL_2, /* Allocate 2 bytes for locals. */
451 P_LOCAL_N /* Allocate N bytes for locals. */
452};
453
455 enum m6811_seq_type type;
456 unsigned length;
457 unsigned short code[MAX_CODES];
458};
459
460/* Sequence of instructions in the 68HC11 function prologue. */
461static struct insn_sequence m6811_prologue[] = {
462 /* Sequences to save a soft-register. */
463 { P_SAVE_REG, 3, { M6811_OP_LDX, OP_DIRECT,
464 M6811_OP_PSHX } },
465 { P_SAVE_REG, 5, { M6811_OP_PAGE2, M6811_OP_LDX, OP_DIRECT,
467 { P_SAVE_REG, 4, { M6811_OP_LDX_EXT, OP_IMM_HIGH, OP_IMM_LOW,
468 M6811_OP_PSHX } },
471
472 /* Sequences to allocate local variables. */
473 { P_LOCAL_N, 7, { M6811_OP_TSX,
477 M6811_OP_TXS } },
478 { P_LOCAL_N, 11, { M6811_OP_PAGE2, M6811_OP_TSX,
483 { P_LOCAL_1, 1, { M6811_OP_DES } },
484 { P_LOCAL_2, 1, { M6811_OP_PSHX } },
485 { P_LOCAL_2, 2, { M6811_OP_PAGE2, M6811_OP_PSHX } },
486
487 /* Initialize the frame pointer. */
488 { P_SET_FRAME, 2, { M6811_OP_STS, OP_DIRECT } },
489 { P_SET_FRAME, 3, { M6811_OP_STS_EXT, OP_IMM_HIGH, OP_IMM_LOW } },
490 { P_LAST, 0, { 0 } }
491};
492
493
494/* Sequence of instructions in the 68HC12 function prologue. */
495static struct insn_sequence m6812_prologue[] = {
496 { P_SAVE_REG, 5, { M6812_OP_PAGE2, M6812_OP_MOVW, M6812_PB_PSHW,
498 { P_SET_FRAME, 2, { M6812_OP_STS, OP_DIRECT } },
499 { P_SET_FRAME, 3, { M6812_OP_STS_EXT, OP_IMM_HIGH, OP_IMM_LOW } },
500 { P_LOCAL_N, 2, { M6812_OP_LEAS, OP_PBYTE } },
501 { P_LOCAL_2, 1, { M6812_OP_PSHX } },
502 { P_LOCAL_2, 1, { M6812_OP_PSHY } },
503 { P_LAST, 0 }
504};
505
506
507/* Analyze the sequence of instructions starting at the given address.
508 Returns a pointer to the sequence when it is recognized and
509 the optional value (constant/address) associated with it. */
510static struct insn_sequence *
512 struct insn_sequence *seq, CORE_ADDR pc,
513 CORE_ADDR *val)
514{
515 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
516 unsigned char buffer[MAX_CODES];
517 unsigned bufsize;
518 unsigned j;
519 CORE_ADDR cur_val;
520 short v = 0;
521
522 bufsize = 0;
523 for (; seq->type != P_LAST; seq++)
524 {
525 cur_val = 0;
526 for (j = 0; j < seq->length; j++)
527 {
528 if (bufsize < j + 1)
529 {
530 buffer[bufsize] = read_memory_unsigned_integer (pc + bufsize,
531 1, byte_order);
532 bufsize++;
533 }
534 /* Continue while we match the opcode. */
535 if (seq->code[j] == buffer[j])
536 continue;
537
538 if ((seq->code[j] & 0xf00) == 0)
539 break;
540
541 /* Extract a sequence parameter (address or constant). */
542 switch (seq->code[j])
543 {
544 case OP_DIRECT:
545 cur_val = (CORE_ADDR) buffer[j];
546 break;
547
548 case OP_IMM_HIGH:
549 cur_val = cur_val & 0x0ff;
550 cur_val |= (buffer[j] << 8);
551 break;
552
553 case OP_IMM_LOW:
554 cur_val &= 0x0ff00;
555 cur_val |= buffer[j];
556 break;
557
558 case OP_PBYTE:
559 if ((buffer[j] & 0xE0) == 0x80)
560 {
561 v = buffer[j] & 0x1f;
562 if (v & 0x10)
563 v |= 0xfff0;
564 }
565 else if ((buffer[j] & 0xfe) == 0xf0)
566 {
567 v = read_memory_unsigned_integer (pc + j + 1, 1, byte_order);
568 if (buffer[j] & 1)
569 v |= 0xff00;
570 }
571 else if (buffer[j] == 0xf2)
572 {
573 v = read_memory_unsigned_integer (pc + j + 1, 2, byte_order);
574 }
575 cur_val = v;
576 break;
577 }
578 }
579
580 /* We have a full match. */
581 if (j == seq->length)
582 {
583 *val = cur_val;
584 return seq;
585 }
586 }
587 return 0;
588}
589
590/* Return the instruction that the function at the PC is using. */
591static enum insn_return_kind
593{
594 struct bound_minimal_symbol sym;
595
596 /* A flag indicating that this is a STO_M68HC12_FAR or STO_M68HC12_INTERRUPT
597 function is stored by elfread.c in the high bit of the info field.
598 Use this to decide which instruction the function uses to return. */
600 if (sym.minsym == 0)
601 return RETURN_RTS;
602
603 if (MSYMBOL_IS_RTC (sym.minsym))
604 return RETURN_RTC;
605 else if (MSYMBOL_IS_RTI (sym.minsym))
606 return RETURN_RTI;
607 else
608 return RETURN_RTS;
609}
610
611/* Analyze the function prologue to find some information
612 about the function:
613 - the PC of the first line (for m68hc11_skip_prologue)
614 - the offset of the previous frame saved address (from current frame)
615 - the soft registers which are pushed. */
616static CORE_ADDR
617m68hc11_scan_prologue (struct gdbarch *gdbarch, CORE_ADDR pc,
618 CORE_ADDR current_pc, struct m68hc11_unwind_cache *info)
619{
620 LONGEST save_addr;
621 CORE_ADDR func_end;
622 int size;
623 int found_frame_point;
624 int saved_reg;
625 int done = 0;
626 struct insn_sequence *seq_table;
627
628 info->size = 0;
629 info->sp_offset = 0;
630 if (pc >= current_pc)
631 return current_pc;
632
633 size = 0;
634
636 if (pc == 0)
637 {
638 info->size = 0;
639 return pc;
640 }
641
642 m68gc11_gdbarch_tdep *tdep = gdbarch_tdep<m68gc11_gdbarch_tdep> (gdbarch);
643 seq_table = tdep->prologue;
644
645 /* The 68hc11 stack is as follows:
646
647
648 | |
649 +-----------+
650 | |
651 | args |
652 | |
653 +-----------+
654 | PC-return |
655 +-----------+
656 | Old frame |
657 +-----------+
658 | |
659 | Locals |
660 | |
661 +-----------+ <--- current frame
662 | |
663
664 With most processors (like 68K) the previous frame can be computed
665 easily because it is always at a fixed offset (see link/unlink).
666 That is, locals are accessed with negative offsets, arguments are
667 accessed with positive ones. Since 68hc11 only supports offsets
668 in the range [0..255], the frame is defined at the bottom of
669 locals (see picture).
670
671 The purpose of the analysis made here is to find out the size
672 of locals in this function. An alternative to this is to use
673 DWARF2 info. This would be better but I don't know how to
674 access dwarf2 debug from this function.
675
676 Walk from the function entry point to the point where we save
677 the frame. While walking instructions, compute the size of bytes
678 which are pushed. This gives us the index to access the previous
679 frame.
680
681 We limit the search to 128 bytes so that the algorithm is bounded
682 in case of random and wrong code. We also stop and abort if
683 we find an instruction which is not supposed to appear in the
684 prologue (as generated by gcc 2.95, 2.96). */
685
686 func_end = pc + 128;
687 found_frame_point = 0;
688 info->size = 0;
689 save_addr = 0;
690 while (!done && pc + 2 < func_end)
691 {
692 struct insn_sequence *seq;
693 CORE_ADDR val;
694
695 seq = m68hc11_analyze_instruction (gdbarch, seq_table, pc, &val);
696 if (seq == 0)
697 break;
698
699 /* If we are within the instruction group, we can't advance the
700 pc nor the stack offset. Otherwise the caller's stack computed
701 from the current stack can be wrong. */
702 if (pc + seq->length > current_pc)
703 break;
704
705 pc = pc + seq->length;
706 if (seq->type == P_SAVE_REG)
707 {
708 if (found_frame_point)
709 {
711 if (saved_reg < 0)
712 break;
713
714 save_addr -= 2;
715 if (info->saved_regs)
716 info->saved_regs[saved_reg].set_addr (save_addr);
717 }
718 else
719 {
720 size += 2;
721 }
722 }
723 else if (seq->type == P_SET_FRAME)
724 {
725 found_frame_point = 1;
726 info->size = size;
727 }
728 else if (seq->type == P_LOCAL_1)
729 {
730 size += 1;
731 }
732 else if (seq->type == P_LOCAL_2)
733 {
734 size += 2;
735 }
736 else if (seq->type == P_LOCAL_N)
737 {
738 /* Stack pointer is decremented for the allocation. */
739 if (val & 0x8000)
740 size -= (int) (val) | 0xffff0000;
741 else
742 size -= val;
743 }
744 }
745 if (found_frame_point == 0)
746 info->sp_offset = size;
747 else
748 info->sp_offset = -1;
749 return pc;
750}
751
752static CORE_ADDR
753m68hc11_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
754{
755 CORE_ADDR func_addr, func_end;
756 struct symtab_and_line sal;
757 struct m68hc11_unwind_cache tmp_cache = { 0 };
758
759 /* If we have line debugging information, then the end of the
760 prologue should be the first assembly instruction of the
761 first source line. */
762 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
763 {
764 sal = find_pc_line (func_addr, 0);
765 if (sal.end && sal.end < func_end)
766 return sal.end;
767 }
768
769 pc = m68hc11_scan_prologue (gdbarch, pc, (CORE_ADDR) -1, &tmp_cache);
770 return pc;
771}
772
773/* Put here the code to store, into fi->saved_regs, the addresses of
774 the saved registers of frame described by FRAME_INFO. This
775 includes special registers such as pc and fp saved in special ways
776 in the stack frame. sp is even more special: the address we return
777 for it IS the sp for the next frame. */
778
779static struct m68hc11_unwind_cache *
781 void **this_prologue_cache)
782{
783 struct gdbarch *gdbarch = get_frame_arch (this_frame);
784 ULONGEST prev_sp;
785 ULONGEST this_base;
786 struct m68hc11_unwind_cache *info;
787 CORE_ADDR current_pc;
788 int i;
789
790 if ((*this_prologue_cache))
791 return (struct m68hc11_unwind_cache *) (*this_prologue_cache);
792
794 (*this_prologue_cache) = info;
795 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
796
797 info->pc = get_frame_func (this_frame);
798
799 info->size = 0;
800 info->return_kind = m68hc11_get_return_insn (info->pc);
801
802 /* The SP was moved to the FP. This indicates that a new frame
803 was created. Get THIS frame's FP value by unwinding it from
804 the next frame. */
805 this_base = get_frame_register_unsigned (this_frame, SOFT_FP_REGNUM);
806 if (this_base == 0)
807 {
808 info->base = 0;
809 return info;
810 }
811
812 current_pc = get_frame_pc (this_frame);
813 if (info->pc != 0)
814 m68hc11_scan_prologue (gdbarch, info->pc, current_pc, info);
815
816 info->saved_regs[HARD_PC_REGNUM].set_addr (info->size);
817
818 if (info->sp_offset != (CORE_ADDR) -1)
819 {
820 info->saved_regs[HARD_PC_REGNUM].set_addr (info->sp_offset);
821 this_base = get_frame_register_unsigned (this_frame, HARD_SP_REGNUM);
822 prev_sp = this_base + info->sp_offset + 2;
823 this_base += stack_correction (gdbarch);
824 }
825 else
826 {
827 /* The FP points at the last saved register. Adjust the FP back
828 to before the first saved register giving the SP. */
829 prev_sp = this_base + info->size + 2;
830
831 this_base += stack_correction (gdbarch);
833 info->saved_regs[SOFT_FP_REGNUM].set_addr (info->size - 2);
834 }
835
836 if (info->return_kind == RETURN_RTC)
837 {
838 prev_sp += 1;
839 info->saved_regs[HARD_PAGE_REGNUM].set_addr (info->size);
840 info->saved_regs[HARD_PC_REGNUM].set_addr (info->size + 1);
841 }
842 else if (info->return_kind == RETURN_RTI)
843 {
844 prev_sp += 7;
845 info->saved_regs[HARD_CCR_REGNUM].set_addr (info->size);
846 info->saved_regs[HARD_D_REGNUM].set_addr (info->size + 1);
847 info->saved_regs[HARD_X_REGNUM].set_addr (info->size + 3);
848 info->saved_regs[HARD_Y_REGNUM].set_addr (info->size + 5);
849 info->saved_regs[HARD_PC_REGNUM].set_addr (info->size + 7);
850 }
851
852 /* Add 1 here to adjust for the post-decrement nature of the push
853 instruction. */
854 info->prev_sp = prev_sp;
855
856 info->base = this_base;
857
858 /* Adjust all the saved registers so that they contain addresses and not
859 offsets. */
860 for (i = 0; i < gdbarch_num_cooked_regs (gdbarch); i++)
861 if (info->saved_regs[i].is_addr ())
862 {
863 info->saved_regs[i].set_addr (info->saved_regs[i].addr () + this_base);
864 }
865
866 /* The previous frame's SP needed to be computed. Save the computed
867 value. */
868 info->saved_regs[HARD_SP_REGNUM].set_value (info->prev_sp);
869
870 return info;
871}
872
873/* Given a GDB frame, determine the address of the calling function's
874 frame. This will be used to create a new GDB frame struct. */
875
876static void
878 void **this_prologue_cache,
879 struct frame_id *this_id)
880{
881 struct m68hc11_unwind_cache *info
882 = m68hc11_frame_unwind_cache (this_frame, this_prologue_cache);
883 CORE_ADDR base;
884 CORE_ADDR func;
885 struct frame_id id;
886
887 /* The FUNC is easy. */
888 func = get_frame_func (this_frame);
889
890 /* Hopefully the prologue analysis either correctly determined the
891 frame's base (which is the SP from the previous frame), or set
892 that base to "NULL". */
893 base = info->prev_sp;
894 if (base == 0)
895 return;
896
897 id = frame_id_build (base, func);
898 (*this_id) = id;
899}
900
901static struct value *
903 void **this_prologue_cache, int regnum)
904{
905 struct value *value;
906 struct m68hc11_unwind_cache *info
907 = m68hc11_frame_unwind_cache (this_frame, this_prologue_cache);
908
909 value = trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
910
911 /* Take into account the 68HC12 specific call (PC + page). */
913 && info->return_kind == RETURN_RTC
914 && use_page_register (get_frame_arch (this_frame)))
915 {
916 CORE_ADDR pc = value_as_long (value);
917 if (pc >= 0x08000 && pc < 0x0c000)
918 {
919 CORE_ADDR page;
920
922
923 value = trad_frame_get_prev_register (this_frame, info->saved_regs,
925 page = value_as_long (value);
927
928 pc -= 0x08000;
929 pc += ((page & 0x0ff) << 14);
930 pc += 0x1000000;
931
932 return frame_unwind_got_constant (this_frame, regnum, pc);
933 }
934 }
935
936 return value;
937}
938
948
949static CORE_ADDR
950m68hc11_frame_base_address (frame_info_ptr this_frame, void **this_cache)
951{
952 struct m68hc11_unwind_cache *info
953 = m68hc11_frame_unwind_cache (this_frame, this_cache);
954
955 return info->base;
956}
957
958static CORE_ADDR
959m68hc11_frame_args_address (frame_info_ptr this_frame, void **this_cache)
960{
961 CORE_ADDR addr;
962 struct m68hc11_unwind_cache *info
963 = m68hc11_frame_unwind_cache (this_frame, this_cache);
964
965 addr = info->base + info->size;
966 if (info->return_kind == RETURN_RTC)
967 addr += 1;
968 else if (info->return_kind == RETURN_RTI)
969 addr += 7;
970
971 return addr;
972}
973
980
981/* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy
982 frame. The frame ID's base needs to match the TOS value saved by
983 save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint. */
984
985static struct frame_id
987{
988 ULONGEST tos;
989 CORE_ADDR pc = get_frame_pc (this_frame);
990
992 tos += 2;
993 return frame_id_build (tos, pc);
994}
995
996
997/* Get and print the register from the given frame. */
998static void
1000 frame_info_ptr frame, int regno)
1001{
1002 LONGEST rval;
1003
1004 if (regno == HARD_PC_REGNUM || regno == HARD_SP_REGNUM
1005 || regno == SOFT_FP_REGNUM || regno == M68HC12_HARD_PC_REGNUM)
1006 rval = get_frame_register_unsigned (frame, regno);
1007 else
1008 rval = get_frame_register_signed (frame, regno);
1009
1010 if (regno == HARD_A_REGNUM || regno == HARD_B_REGNUM
1011 || regno == HARD_CCR_REGNUM || regno == HARD_PAGE_REGNUM)
1012 {
1013 gdb_printf (file, "0x%02x ", (unsigned char) rval);
1014 if (regno != HARD_CCR_REGNUM)
1015 print_longest (file, 'd', 1, rval);
1016 }
1017 else
1018 {
1020 = gdbarch_tdep<m68gc11_gdbarch_tdep> (gdbarch);
1021
1022 if (regno == HARD_PC_REGNUM && tdep->use_page_register)
1023 {
1024 ULONGEST page;
1025
1027 gdb_printf (file, "0x%02x:%04x ", (unsigned) page,
1028 (unsigned) rval);
1029 }
1030 else
1031 {
1032 gdb_printf (file, "0x%04x ", (unsigned) rval);
1033 if (regno != HARD_PC_REGNUM && regno != HARD_SP_REGNUM
1034 && regno != SOFT_FP_REGNUM && regno != M68HC12_HARD_PC_REGNUM)
1035 print_longest (file, 'd', 1, rval);
1036 }
1037 }
1038
1039 if (regno == HARD_CCR_REGNUM)
1040 {
1041 /* CCR register */
1042 int C, Z, N, V;
1043 unsigned char l = rval & 0xff;
1044
1045 gdb_printf (file, "%c%c%c%c%c%c%c%c ",
1046 l & M6811_S_BIT ? 'S' : '-',
1047 l & M6811_X_BIT ? 'X' : '-',
1048 l & M6811_H_BIT ? 'H' : '-',
1049 l & M6811_I_BIT ? 'I' : '-',
1050 l & M6811_N_BIT ? 'N' : '-',
1051 l & M6811_Z_BIT ? 'Z' : '-',
1052 l & M6811_V_BIT ? 'V' : '-',
1053 l & M6811_C_BIT ? 'C' : '-');
1054 N = (l & M6811_N_BIT) != 0;
1055 Z = (l & M6811_Z_BIT) != 0;
1056 V = (l & M6811_V_BIT) != 0;
1057 C = (l & M6811_C_BIT) != 0;
1058
1059 /* Print flags following the h8300. */
1060 if ((C | Z) == 0)
1061 gdb_printf (file, "u> ");
1062 else if ((C | Z) == 1)
1063 gdb_printf (file, "u<= ");
1064 else if (C == 0)
1065 gdb_printf (file, "u< ");
1066
1067 if (Z == 0)
1068 gdb_printf (file, "!= ");
1069 else
1070 gdb_printf (file, "== ");
1071
1072 if ((N ^ V) == 0)
1073 gdb_printf (file, ">= ");
1074 else
1075 gdb_printf (file, "< ");
1076
1077 if ((Z | (N ^ V)) == 0)
1078 gdb_printf (file, "> ");
1079 else
1080 gdb_printf (file, "<= ");
1081 }
1082}
1083
1084/* Same as 'info reg' but prints the registers in a different way. */
1085static void
1087 frame_info_ptr frame, int regno, int cpregs)
1088{
1089 if (regno >= 0)
1090 {
1091 const char *name = gdbarch_register_name (gdbarch, regno);
1092
1093 if (*name == '\0')
1094 return;
1095
1096 gdb_printf (file, "%-10s ", name);
1097 m68hc11_print_register (gdbarch, file, frame, regno);
1098 gdb_printf (file, "\n");
1099 }
1100 else
1101 {
1102 int i, nr;
1103
1104 gdb_printf (file, "PC=");
1106
1107 gdb_printf (file, " SP=");
1109
1110 gdb_printf (file, " FP=");
1112
1113 gdb_printf (file, "\nCCR=");
1115
1116 gdb_printf (file, "\nD=");
1118
1119 gdb_printf (file, " X=");
1121
1122 gdb_printf (file, " Y=");
1124
1125 m68gc11_gdbarch_tdep *tdep = gdbarch_tdep<m68gc11_gdbarch_tdep> (gdbarch);
1126
1127 if (tdep->use_page_register)
1128 {
1129 gdb_printf (file, "\nPage=");
1131 }
1132 gdb_printf (file, "\n");
1133
1134 nr = 0;
1135 for (i = SOFT_D1_REGNUM; i < M68HC11_ALL_REGS; i++)
1136 {
1137 /* Skip registers which are not defined in the symbol table. */
1138 if (soft_regs[i].name == 0)
1139 continue;
1140
1141 gdb_printf (file, "D%d=", i - SOFT_D1_REGNUM + 1);
1142 m68hc11_print_register (gdbarch, file, frame, i);
1143 nr++;
1144 if ((nr % 8) == 7)
1145 gdb_printf (file, "\n");
1146 else
1147 gdb_printf (file, " ");
1148 }
1149 if (nr && (nr % 8) != 7)
1150 gdb_printf (file, "\n");
1151 }
1152}
1153
1154static CORE_ADDR
1156 struct regcache *regcache, CORE_ADDR bp_addr,
1157 int nargs, struct value **args, CORE_ADDR sp,
1158 function_call_return_method return_method,
1159 CORE_ADDR struct_addr)
1160{
1161 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1162 int argnum;
1163 int first_stack_argnum;
1164 struct type *type;
1165 const gdb_byte *val;
1166 gdb_byte buf[2];
1167
1168 first_stack_argnum = 0;
1169 if (return_method == return_method_struct)
1171 else if (nargs > 0)
1172 {
1173 type = args[0]->type ();
1174
1175 /* First argument is passed in D and X registers. */
1176 if (type->length () <= 4)
1177 {
1178 ULONGEST v;
1179
1180 v = extract_unsigned_integer (args[0]->contents ().data (),
1181 type->length (), byte_order);
1182 first_stack_argnum = 1;
1183
1185 if (type->length () > 2)
1186 {
1187 v >>= 16;
1189 }
1190 }
1191 }
1192
1193 for (argnum = nargs - 1; argnum >= first_stack_argnum; argnum--)
1194 {
1195 type = args[argnum]->type ();
1196
1197 if (type->length () & 1)
1198 {
1199 static gdb_byte zero = 0;
1200
1201 sp--;
1202 write_memory (sp, &zero, 1);
1203 }
1204 val = args[argnum]->contents ().data ();
1205 sp -= type->length ();
1206 write_memory (sp, val, type->length ());
1207 }
1208
1209 /* Store return address. */
1210 sp -= 2;
1211 store_unsigned_integer (buf, 2, byte_order, bp_addr);
1212 write_memory (sp, buf, 2);
1213
1214 /* Finally, update the stack pointer... */
1215 sp -= stack_correction (gdbarch);
1217
1218 /* ...and fake a frame pointer. */
1220
1221 /* DWARF2/GCC uses the stack address *before* the function call as a
1222 frame's CFA. */
1223 return sp + 2;
1224}
1225
1226
1227/* Return the GDB type object for the "standard" data type
1228 of data in register N. */
1229
1230static struct type *
1232{
1233 switch (reg_nr)
1234 {
1235 case HARD_PAGE_REGNUM:
1236 case HARD_A_REGNUM:
1237 case HARD_B_REGNUM:
1238 case HARD_CCR_REGNUM:
1240
1243
1244 default:
1246 }
1247}
1248
1249static void
1251 const gdb_byte *valbuf)
1252{
1253 int len;
1254
1255 len = type->length ();
1256
1257 /* First argument is passed in D and X registers. */
1258 if (len <= 2)
1259 regcache->raw_write_part (HARD_D_REGNUM, 2 - len, len, valbuf);
1260 else if (len <= 4)
1261 {
1262 regcache->raw_write_part (HARD_X_REGNUM, 4 - len, len - 2, valbuf);
1263 regcache->raw_write (HARD_D_REGNUM, valbuf + (len - 2));
1264 }
1265 else
1266 error (_("return of value > 4 is not supported."));
1267}
1268
1269
1270/* Given a return value in `regcache' with a type `type',
1271 extract and copy its value into `valbuf'. */
1272
1273static void
1275 void *valbuf)
1276{
1277 gdb_byte buf[M68HC11_REG_SIZE];
1278
1280 switch (type->length ())
1281 {
1282 case 1:
1283 memcpy (valbuf, buf + 1, 1);
1284 break;
1285
1286 case 2:
1287 memcpy (valbuf, buf, 2);
1288 break;
1289
1290 case 3:
1291 memcpy ((char*) valbuf + 1, buf, 2);
1293 memcpy (valbuf, buf + 1, 1);
1294 break;
1295
1296 case 4:
1297 memcpy ((char*) valbuf + 2, buf, 2);
1299 memcpy (valbuf, buf, 2);
1300 break;
1301
1302 default:
1303 error (_("bad size for return value"));
1304 }
1305}
1306
1307static enum return_value_convention
1308m68hc11_return_value (struct gdbarch *gdbarch, struct value *function,
1309 struct type *valtype, struct regcache *regcache,
1310 gdb_byte *readbuf, const gdb_byte *writebuf)
1311{
1312 if (valtype->code () == TYPE_CODE_STRUCT
1313 || valtype->code () == TYPE_CODE_UNION
1314 || valtype->code () == TYPE_CODE_ARRAY
1315 || valtype->length () > 4)
1317 else
1318 {
1319 if (readbuf != NULL)
1320 m68hc11_extract_return_value (valtype, regcache, readbuf);
1321 if (writebuf != NULL)
1322 m68hc11_store_return_value (valtype, regcache, writebuf);
1324 }
1325}
1326
1327/* Test whether the ELF symbol corresponds to a function using rtc or
1328 rti to return. */
1329
1330static void
1332{
1333 unsigned char flags;
1334
1335 flags = ((elf_symbol_type *)sym)->internal_elf_sym.st_other;
1336 if (flags & STO_M68HC12_FAR)
1337 MSYMBOL_SET_RTC (msym);
1338 if (flags & STO_M68HC12_INTERRUPT)
1339 MSYMBOL_SET_RTI (msym);
1340}
1341
1342
1343/* 68HC11/68HC12 register groups.
1344 Identify real hard registers and soft registers used by gcc. */
1345
1348
1349static void
1355
1356static void
1362
1363static int
1365 const struct reggroup *group)
1366{
1367 /* We must save the real hard register as well as gcc
1368 soft registers including the frame pointer. */
1369 if (group == save_reggroup || group == restore_reggroup)
1370 {
1371 return (regnum <= gdbarch_num_regs (gdbarch)
1372 || ((regnum == SOFT_FP_REGNUM
1375 || regnum == SOFT_XY_REGNUM)
1377 }
1378
1379 /* Group to identify gcc soft registers (d1..dN). */
1380 if (group == m68hc11_soft_reggroup)
1381 {
1382 return regnum >= SOFT_D1_REGNUM
1384 }
1385
1386 if (group == m68hc11_hard_reggroup)
1387 {
1391 }
1393}
1394
1395static struct gdbarch *
1397 struct gdbarch_list *arches)
1398{
1399 int elf_flags;
1400
1402
1403 /* Extract the elf_flags if available. */
1404 if (info.abfd != NULL
1405 && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
1406 elf_flags = elf_elfheader (info.abfd)->e_flags;
1407 else
1408 elf_flags = 0;
1409
1410 /* Try to find a pre-existing architecture. */
1412 arches != NULL;
1414 {
1416 = gdbarch_tdep<m68gc11_gdbarch_tdep> (arches->gdbarch);
1417
1418 if (tdep->elf_flags != elf_flags)
1419 continue;
1420
1421 return arches->gdbarch;
1422 }
1423
1424 /* Need a new architecture. Fill in a target specific vector. */
1427 m68gc11_gdbarch_tdep *tdep = gdbarch_tdep<m68gc11_gdbarch_tdep> (gdbarch);
1428
1429 tdep->elf_flags = elf_flags;
1430
1431 switch (info.bfd_arch_info->arch)
1432 {
1433 case bfd_arch_m68hc11:
1434 tdep->stack_correction = 1;
1435 tdep->use_page_register = 0;
1436 tdep->prologue = m6811_prologue;
1441 break;
1442
1443 case bfd_arch_m68hc12:
1444 tdep->stack_correction = 0;
1445 tdep->use_page_register = elf_flags & E_M68HC12_BANKS;
1446 tdep->prologue = m6812_prologue;
1447 set_gdbarch_addr_bit (gdbarch, elf_flags & E_M68HC12_BANKS ? 32 : 16);
1449 elf_flags & E_M68HC12_BANKS
1452 set_gdbarch_pc_regnum (gdbarch, elf_flags & E_M68HC12_BANKS
1454 set_gdbarch_num_regs (gdbarch, elf_flags & E_M68HC12_BANKS
1456 break;
1457
1458 default:
1459 break;
1460 }
1461
1462 /* Initially set everything according to the ABI.
1463 Use 16-bit integers since it will be the case for most
1464 programs. The size of these types should normally be set
1465 according to the dwarf2 debug information. */
1467 set_gdbarch_int_bit (gdbarch, elf_flags & E_M68HC11_I32 ? 32 : 16);
1469 if (elf_flags & E_M68HC11_F64)
1470 {
1473 }
1474 else
1475 {
1478 }
1483
1484 /* Characters are unsigned. */
1486
1487 /* Set register info. */
1489
1495
1497
1502 m68hc11_breakpoint::kind_from_pc);
1504 m68hc11_breakpoint::bp_from_kind);
1505
1509
1510 /* Hook in the DWARF CFI frame unwinder. */
1512
1515
1516 /* Methods for saving / extracting a dummy frame's ID. The ID's
1517 stack address must match the SP value returned by
1518 PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */
1520
1521 /* Minsymbol frobbing. */
1524
1526
1527 return gdbarch;
1528}
1529
1531void
1533{
1534 gdbarch_register (bfd_arch_m68hc11, m68hc11_gdbarch_init);
1535 gdbarch_register (bfd_arch_m68hc12, m68hc11_gdbarch_init);
1537}
1538
int regnum
const char *const name
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep, gdbarch_supports_arch_info_ftype *supports_arch_info)
static std::vector< const char * > arches
Definition arch-utils.c:685
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
Definition arch-utils.c:177
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
#define BP_MANIPULATION(BREAK_INSN)
Definition arch-utils.h:70
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
Definition blockframe.c:373
enum register_status raw_read(int regnum, gdb_byte *buf)
Definition regcache.c:611
enum register_status cooked_read(int regnum, gdb_byte *buf)
Definition regcache.c:698
void raw_write_part(int regnum, int offset, int len, const gdb_byte *buf)
Definition regcache.c:1032
void raw_write(int regnum, const gdb_byte *buf)
Definition regcache.c:833
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition corefile.c:347
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition corefile.c:306
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition defs.h:515
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:480
return_value_convention
Definition defs.h:257
@ RETURN_VALUE_REGISTER_CONVENTION
Definition defs.h:260
@ RETURN_VALUE_STRUCT_CONVENTION
Definition defs.h:267
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
Definition frame.c:1369
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
Definition frame-base.c:93
int default_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
enum unwind_stop_reason default_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
struct value * frame_unwind_got_constant(frame_info_ptr frame, int regnum, ULONGEST val)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
Definition frame.c:1399
LONGEST get_frame_register_signed(frame_info_ptr frame, int regnum)
Definition frame.c:1365
CORE_ADDR get_frame_pc(frame_info_ptr frame)
Definition frame.c:2712
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition frame.c:736
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:3027
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
Definition frame.c:1098
@ NORMAL_FRAME
Definition frame.h:187
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition frame.h:825
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
Definition gdbarch.c:1493
void set_gdbarch_addr_bit(struct gdbarch *gdbarch, int addr_bit)
Definition gdbarch.c:1750
void set_gdbarch_char_signed(struct gdbarch *gdbarch, int char_signed)
Definition gdbarch.c:1786
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
void set_gdbarch_breakpoint_kind_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_pc_ftype *breakpoint_kind_from_pc)
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition gdbarch.c:2173
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue)
void set_gdbarch_elf_make_msymbol_special(struct gdbarch *gdbarch, gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special)
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name)
void set_gdbarch_int_bit(struct gdbarch *gdbarch, int int_bit)
Definition gdbarch.c:1459
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value)
void set_gdbarch_believe_pcc_promotion(struct gdbarch *gdbarch, int believe_pcc_promotion)
Definition gdbarch.c:2470
void set_gdbarch_print_registers_info(struct gdbarch *gdbarch, gdbarch_print_registers_info_ftype *print_registers_info)
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition gdbarch.c:1930
void set_gdbarch_fp0_regnum(struct gdbarch *gdbarch, int fp0_regnum)
Definition gdbarch.c:2098
void set_gdbarch_double_bit(struct gdbarch *gdbarch, int double_bit)
Definition gdbarch.c:1612
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than)
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
Definition gdbarch.c:2047
void set_gdbarch_register_reggroup_p(struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype *register_reggroup_p)
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
Definition gdbarch.c:2064
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type)
void set_gdbarch_float_bit(struct gdbarch *gdbarch, int float_bit)
Definition gdbarch.c:1578
void set_gdbarch_short_bit(struct gdbarch *gdbarch, int short_bit)
Definition gdbarch.c:1442
void set_gdbarch_pseudo_register_write(struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype *pseudo_register_write)
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
Definition gdbarch.c:1958
void set_gdbarch_long_bit(struct gdbarch *gdbarch, int long_bit)
Definition gdbarch.c:1476
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
Definition gdbarch.c:1732
void set_gdbarch_pseudo_register_read(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype *pseudo_register_read)
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition gdbarch.c:1941
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
Definition gdbarch.c:1646
void set_gdbarch_sw_breakpoint_from_kind(struct gdbarch *gdbarch, gdbarch_sw_breakpoint_from_kind_ftype *sw_breakpoint_from_kind)
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype *dummy_id)
void set_gdbarch_double_format(struct gdbarch *gdbarch, const struct floatformat **double_format)
Definition gdbarch.c:1629
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call)
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, gdbarch_tdep_up tdep)
Definition gdbarch.c:266
std::unique_ptr< gdbarch_tdep_base > gdbarch_tdep_up
Definition gdbarch.h:73
static int gdbarch_num_cooked_regs(gdbarch *arch)
Definition gdbarch.h:390
function_call_return_method
Definition gdbarch.h:114
@ return_method_struct
Definition gdbarch.h:126
const struct floatformat * floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:85
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition gdbtypes.c:6168
const struct floatformat * floatformats_ieee_double[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:89
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition gnu-nat.c:1861
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition gnu-nat.c:1790
size_t size
Definition go32-nat.c:239
static int soft_reg_initialized
#define M6812_OP_PAGE2
static void m68hc11_add_reggroups(struct gdbarch *gdbarch)
static struct type * m68hc11_register_type(struct gdbarch *gdbarch, int reg_nr)
#define M68HC11_ALL_REGS
#define MAX_CODES
#define M68HC12_NUM_REGS
#define SOFT_FP_REGNUM
#define HARD_X_REGNUM
#define M68HC11_LAST_HARD_REG
static const reggroup * m68hc11_soft_reggroup
#define M68HC11_MAX_SOFT_REGS
#define SOFT_XY_REGNUM
static const char * m68hc11_register_names[]
#define M6811_OP_PSHX
#define HARD_B_REGNUM
static int stack_correction(gdbarch *arch)
static CORE_ADDR m68hc11_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
#define M6811_OP_STS
#define SOFT_ZS_REGNUM
static void m68hc11_store_return_value(struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
static void m68hc11_print_register(struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, int regno)
insn_return_kind
@ RETURN_RTS
@ RETURN_RTC
@ RETURN_RTI
static void m68hc11_elf_make_msymbol_special(asymbol *sym, struct minimal_symbol *msym)
#define M6811_OP_TXS
#define MSYMBOL_SET_RTI(msym)
static struct m68hc11_unwind_cache * m68hc11_frame_unwind_cache(frame_info_ptr this_frame, void **this_prologue_cache)
#define HARD_CCR_REGNUM
static void m68hc11_get_register_info(struct m68hc11_soft_reg *reg, const char *name)
#define SOFT_TMP_REGNUM
#define M6812_OP_MOVW
static struct value * m68hc11_frame_prev_register(frame_info_ptr this_frame, void **this_prologue_cache, int regnum)
static struct frame_id m68hc11_dummy_id(struct gdbarch *gdbarch, frame_info_ptr this_frame)
#define M6811_OP_TSX
#define M6811_OP_LDX_EXT
#define OP_DIRECT
#define M6812_OP_LEAS
#define MSYMBOL_IS_RTI(msym)
static enum register_status m68hc11_pseudo_register_read(struct gdbarch *gdbarch, readable_regcache *regcache, int regno, gdb_byte *buf)
static CORE_ADDR m68hc11_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, function_call_return_method return_method, CORE_ADDR struct_addr)
static struct insn_sequence * m68hc11_analyze_instruction(struct gdbarch *gdbarch, struct insn_sequence *seq, CORE_ADDR pc, CORE_ADDR *val)
#define M6811_OP_LDX
static struct gdbarch * m68hc11_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
static enum insn_return_kind m68hc11_get_return_insn(CORE_ADDR pc)
constexpr gdb_byte m68hc11_break_insn[]
static CORE_ADDR m68hc11_frame_base_address(frame_info_ptr this_frame, void **this_cache)
#define M68HC11_NUM_REGS
#define OP_IMM_HIGH
#define MSYMBOL_IS_RTC(msym)
#define OP_IMM_LOW
#define M6812_OP_PSHY
#define HARD_A_REGNUM
static int soft_min_addr
static const reggroup * m68hc11_hard_reggroup
void _initialize_m68hc11_tdep()
static CORE_ADDR m68hc11_frame_args_address(frame_info_ptr this_frame, void **this_cache)
static int m68hc11_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *group)
#define M6812_OP_STS
#define OP_PBYTE
static int soft_max_addr
#define SOFT_Z_REGNUM
#define M6812_PB_PSHW
static void m68hc11_print_registers_info(struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, int regno, int cpregs)
static int m68hc11_which_soft_register(CORE_ADDR addr)
#define MSYMBOL_SET_RTC(msym)
static const struct frame_base m68hc11_frame_base
#define HARD_PC_REGNUM
#define SOFT_D1_REGNUM
static struct insn_sequence m6812_prologue[]
#define M6812_OP_STS_EXT
static struct m68hc11_soft_reg soft_regs[M68HC11_ALL_REGS]
#define M6811_OP_ADDD
static void m68hc11_init_reggroups(void)
#define M68HC12_NUM_PSEUDO_REGS
#define HARD_D_REGNUM
static struct insn_sequence m6811_prologue[]
#define HARD_Y_REGNUM
static void m68hc11_frame_this_id(frame_info_ptr this_frame, void **this_prologue_cache, struct frame_id *this_id)
#define HARD_PAGE_REGNUM
static enum return_value_convention m68hc11_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
static void m68hc11_initialize_register_info(void)
static const struct frame_unwind m68hc11_frame_unwind
static void m68hc11_extract_return_value(struct type *type, struct regcache *regcache, void *valbuf)
#define M68HC12_HARD_PC_REGNUM
#define M68HC11_REG_SIZE
#define M6811_OP_XGDX
#define HARD_SP_REGNUM
static const char * m68hc11_register_name(struct gdbarch *gdbarch, int reg_nr)
static int use_page_register(gdbarch *arch)
#define M68HC11_NUM_PSEUDO_REGS
#define M6811_OP_DES
#define M6811_OP_PAGE2
#define M6812_OP_PSHX
#define M6811_OP_STS_EXT
static CORE_ADDR m68hc11_scan_prologue(struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR current_pc, struct m68hc11_unwind_cache *info)
static void m68hc11_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int regno, const gdb_byte *buf)
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition minsyms.c:363
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition minsyms.c:996
info(Component c)
Definition gdbarch.py:41
int value
Definition py-param.c:79
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition regcache.c:825
int default_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *group)
Definition reggroups.c:147
const reggroup * reggroup_new(const char *name, enum reggroup_type type)
Definition reggroups.c:34
const reggroup *const save_reggroup
Definition reggroups.c:256
void reggroup_add(struct gdbarch *gdbarch, const reggroup *group)
Definition reggroups.c:124
const reggroup *const restore_reggroup
Definition reggroups.c:257
@ USER_REGGROUP
Definition reggroups.h:32
void(* func)(remote_target *remote, char *)
enum var_types type
Definition scm-param.c:142
CORE_ADDR value_address() const
Definition minsyms.h:41
struct minimal_symbol * minsym
Definition minsyms.h:49
struct type * builtin_uint16
Definition gdbtypes.h:2116
struct type * builtin_uint32
Definition gdbtypes.h:2120
struct type * builtin_uint8
Definition gdbtypes.h:2114
enum m6811_seq_type type
unsigned short code[MAX_CODES]
unsigned length
struct insn_sequence * prologue
const char * name
trad_frame_saved_reg * saved_regs
enum insn_return_kind return_kind
CORE_ADDR end
Definition symtab.h:2338
type_code code() const
Definition gdbtypes.h:956
ULONGEST length() const
Definition gdbtypes.h:983
Definition value.h:130
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition symtab.c:3295
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition target.c:1861
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1785
trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct gdbarch *gdbarch)
Definition trad-frame.c:62
struct value * trad_frame_get_prev_register(frame_info_ptr this_frame, trad_frame_saved_reg this_saved_regs[], int regnum)
Definition trad-frame.c:187
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
void print_longest(struct ui_file *stream, int format, int use_c_format, LONGEST val_long)
Definition valprint.c:1335
LONGEST value_as_long(struct value *val)
Definition value.c:2554
value_ref_ptr release_value(struct value *val)
Definition value.c:1450