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