GDB (xrefs)
/tmp/gdb-7.10/gdb/h8300-tdep.c
Go to the documentation of this file.
1 /* Target-machine dependent code for Renesas H8/300, for GDB.
2 
3  Copyright (C) 1988-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 /*
21  Contributed by Steve Chamberlain
22  sac@cygnus.com
23  */
24 
25 #include "defs.h"
26 #include "value.h"
27 #include "arch-utils.h"
28 #include "regcache.h"
29 #include "gdbcore.h"
30 #include "objfiles.h"
31 #include "dis-asm.h"
32 #include "dwarf2-frame.h"
33 #include "frame-base.h"
34 #include "frame-unwind.h"
35 
37 {
57 };
58 
59 #define H8300_MAX_NUM_REGS 18
60 
61 #define E_PSEUDO_CCR_REGNUM(gdbarch) (gdbarch_num_regs (gdbarch))
62 #define E_PSEUDO_EXR_REGNUM(gdbarch) (gdbarch_num_regs (gdbarch)+1)
63 
65 {
66  /* Base address. */
70 
71  /* Flag showing that a frame has been created in the prologue code. */
72  int uses_fp;
73 
74  /* Saved registers. */
77 };
78 
79 enum
80 {
84 };
85 
86 static int is_h8300hmode (struct gdbarch *gdbarch);
87 static int is_h8300smode (struct gdbarch *gdbarch);
88 static int is_h8300sxmode (struct gdbarch *gdbarch);
89 static int is_h8300_normal_mode (struct gdbarch *gdbarch);
90 
91 #define BINWORD(gdbarch) ((is_h8300hmode (gdbarch) \
92  && !is_h8300_normal_mode (gdbarch)) \
93  ? h8300h_reg_size : h8300_reg_size)
94 
95 static CORE_ADDR
96 h8300_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
97 {
98  return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
99 }
100 
101 static CORE_ADDR
102 h8300_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
103 {
104  return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
105 }
106 
107 static struct frame_id
108 h8300_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
109 {
111  return frame_id_build (sp, get_frame_pc (this_frame));
112 }
113 
114 /* Normal frames. */
115 
116 /* Allocate and initialize a frame cache. */
117 
118 static void
119 h8300_init_frame_cache (struct gdbarch *gdbarch,
120  struct h8300_frame_cache *cache)
121 {
122  int i;
123 
124  /* Base address. */
125  cache->base = 0;
126  cache->sp_offset = 0;
127  cache->pc = 0;
128 
129  /* Frameless until proven otherwise. */
130  cache->uses_fp = 0;
131 
132  /* Saved registers. We initialize these to -1 since zero is a valid
133  offset (that's where %fp is supposed to be stored). */
134  for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
135  cache->saved_regs[i] = -1;
136 }
137 
138 #define IS_MOVB_RnRm(x) (((x) & 0xff88) == 0x0c88)
139 #define IS_MOVW_RnRm(x) (((x) & 0xff88) == 0x0d00)
140 #define IS_MOVL_RnRm(x) (((x) & 0xff88) == 0x0f80)
141 #define IS_MOVB_Rn16_SP(x) (((x) & 0xfff0) == 0x6ee0)
142 #define IS_MOVB_EXT(x) ((x) == 0x7860)
143 #define IS_MOVB_Rn24_SP(x) (((x) & 0xfff0) == 0x6aa0)
144 #define IS_MOVW_Rn16_SP(x) (((x) & 0xfff0) == 0x6fe0)
145 #define IS_MOVW_EXT(x) ((x) == 0x78e0)
146 #define IS_MOVW_Rn24_SP(x) (((x) & 0xfff0) == 0x6ba0)
147 /* Same instructions as mov.w, just prefixed with 0x0100. */
148 #define IS_MOVL_PRE(x) ((x) == 0x0100)
149 #define IS_MOVL_Rn16_SP(x) (((x) & 0xfff0) == 0x6fe0)
150 #define IS_MOVL_EXT(x) ((x) == 0x78e0)
151 #define IS_MOVL_Rn24_SP(x) (((x) & 0xfff0) == 0x6ba0)
152 
153 #define IS_PUSHFP_MOVESPFP(x) ((x) == 0x6df60d76)
154 #define IS_PUSH_FP(x) ((x) == 0x01006df6)
155 #define IS_MOV_SP_FP(x) ((x) == 0x0ff6)
156 #define IS_SUB2_SP(x) ((x) == 0x1b87)
157 #define IS_SUB4_SP(x) ((x) == 0x1b97)
158 #define IS_ADD_IMM_SP(x) ((x) == 0x7a1f)
159 #define IS_SUB_IMM_SP(x) ((x) == 0x7a3f)
160 #define IS_SUBL4_SP(x) ((x) == 0x1acf)
161 #define IS_MOV_IMM_Rn(x) (((x) & 0xfff0) == 0x7905)
162 #define IS_SUB_RnSP(x) (((x) & 0xff0f) == 0x1907)
163 #define IS_ADD_RnSP(x) (((x) & 0xff0f) == 0x0907)
164 #define IS_PUSH(x) (((x) & 0xfff0) == 0x6df0)
165 
166 /* If the instruction at PC is an argument register spill, return its
167  length. Otherwise, return zero.
168 
169  An argument register spill is an instruction that moves an argument
170  from the register in which it was passed to the stack slot in which
171  it really lives. It is a byte, word, or longword move from an
172  argument register to a negative offset from the frame pointer.
173 
174  CV, 2003-06-16: Or, in optimized code or when the `register' qualifier
175  is used, it could be a byte, word or long move to registers r3-r5. */
176 
177 static int
178 h8300_is_argument_spill (struct gdbarch *gdbarch, CORE_ADDR pc)
179 {
180  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
181  int w = read_memory_unsigned_integer (pc, 2, byte_order);
182 
183  if ((IS_MOVB_RnRm (w) || IS_MOVW_RnRm (w) || IS_MOVL_RnRm (w))
184  && (w & 0x70) <= 0x20 /* Rs is R0, R1 or R2 */
185  && (w & 0x7) >= 0x3 && (w & 0x7) <= 0x5) /* Rd is R3, R4 or R5 */
186  return 2;
187 
188  if (IS_MOVB_Rn16_SP (w)
189  && 8 <= (w & 0xf) && (w & 0xf) <= 10) /* Rs is R0L, R1L, or R2L */
190  {
191  /* ... and d:16 is negative. */
192  if (read_memory_integer (pc + 2, 2, byte_order) < 0)
193  return 4;
194  }
195  else if (IS_MOVB_EXT (w))
196  {
198  2, byte_order)))
199  {
200  LONGEST disp = read_memory_integer (pc + 4, 4, byte_order);
201 
202  /* ... and d:24 is negative. */
203  if (disp < 0 && disp > 0xffffff)
204  return 8;
205  }
206  }
207  else if (IS_MOVW_Rn16_SP (w)
208  && (w & 0xf) <= 2) /* Rs is R0, R1, or R2 */
209  {
210  /* ... and d:16 is negative. */
211  if (read_memory_integer (pc + 2, 2, byte_order) < 0)
212  return 4;
213  }
214  else if (IS_MOVW_EXT (w))
215  {
217  2, byte_order)))
218  {
219  LONGEST disp = read_memory_integer (pc + 4, 4, byte_order);
220 
221  /* ... and d:24 is negative. */
222  if (disp < 0 && disp > 0xffffff)
223  return 8;
224  }
225  }
226  else if (IS_MOVL_PRE (w))
227  {
228  int w2 = read_memory_integer (pc + 2, 2, byte_order);
229 
230  if (IS_MOVL_Rn16_SP (w2)
231  && (w2 & 0xf) <= 2) /* Rs is ER0, ER1, or ER2 */
232  {
233  /* ... and d:16 is negative. */
234  if (read_memory_integer (pc + 4, 2, byte_order) < 0)
235  return 6;
236  }
237  else if (IS_MOVL_EXT (w2))
238  {
239  int w3 = read_memory_integer (pc + 4, 2, byte_order);
240 
241  if (IS_MOVL_Rn24_SP (read_memory_integer (pc + 4, 2, byte_order)))
242  {
243  LONGEST disp = read_memory_integer (pc + 6, 4, byte_order);
244 
245  /* ... and d:24 is negative. */
246  if (disp < 0 && disp > 0xffffff)
247  return 10;
248  }
249  }
250  }
251 
252  return 0;
253 }
254 
255 /* Do a full analysis of the prologue at PC and update CACHE
256  accordingly. Bail out early if CURRENT_PC is reached. Return the
257  address where the analysis stopped.
258 
259  We handle all cases that can be generated by gcc.
260 
261  For allocating a stack frame:
262 
263  mov.w r6,@-sp
264  mov.w sp,r6
265  mov.w #-n,rN
266  add.w rN,sp
267 
268  mov.w r6,@-sp
269  mov.w sp,r6
270  subs #2,sp
271  (repeat)
272 
273  mov.l er6,@-sp
274  mov.l sp,er6
275  add.l #-n,sp
276 
277  mov.w r6,@-sp
278  mov.w sp,r6
279  subs #4,sp
280  (repeat)
281 
282  For saving registers:
283 
284  mov.w rN,@-sp
285  mov.l erN,@-sp
286  stm.l reglist,@-sp
287 
288  */
289 
290 static CORE_ADDR
291 h8300_analyze_prologue (struct gdbarch *gdbarch,
292  CORE_ADDR pc, CORE_ADDR current_pc,
293  struct h8300_frame_cache *cache)
294 {
295  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
296  unsigned int op;
297  int regno, i, spill_size;
298 
299  cache->sp_offset = 0;
300 
301  if (pc >= current_pc)
302  return current_pc;
303 
304  op = read_memory_unsigned_integer (pc, 4, byte_order);
305 
306  if (IS_PUSHFP_MOVESPFP (op))
307  {
308  cache->saved_regs[E_FP_REGNUM] = 0;
309  cache->uses_fp = 1;
310  pc += 4;
311  }
312  else if (IS_PUSH_FP (op))
313  {
314  cache->saved_regs[E_FP_REGNUM] = 0;
315  pc += 4;
316  if (pc >= current_pc)
317  return current_pc;
318  op = read_memory_unsigned_integer (pc, 2, byte_order);
319  if (IS_MOV_SP_FP (op))
320  {
321  cache->uses_fp = 1;
322  pc += 2;
323  }
324  }
325 
326  while (pc < current_pc)
327  {
328  op = read_memory_unsigned_integer (pc, 2, byte_order);
329  if (IS_SUB2_SP (op))
330  {
331  cache->sp_offset += 2;
332  pc += 2;
333  }
334  else if (IS_SUB4_SP (op))
335  {
336  cache->sp_offset += 4;
337  pc += 2;
338  }
339  else if (IS_ADD_IMM_SP (op))
340  {
341  cache->sp_offset += -read_memory_integer (pc + 2, 2, byte_order);
342  pc += 4;
343  }
344  else if (IS_SUB_IMM_SP (op))
345  {
346  cache->sp_offset += read_memory_integer (pc + 2, 2, byte_order);
347  pc += 4;
348  }
349  else if (IS_SUBL4_SP (op))
350  {
351  cache->sp_offset += 4;
352  pc += 2;
353  }
354  else if (IS_MOV_IMM_Rn (op))
355  {
356  int offset = read_memory_integer (pc + 2, 2, byte_order);
357  regno = op & 0x000f;
358  op = read_memory_unsigned_integer (pc + 4, 2, byte_order);
359  if (IS_ADD_RnSP (op) && (op & 0x00f0) == regno)
360  {
361  cache->sp_offset -= offset;
362  pc += 6;
363  }
364  else if (IS_SUB_RnSP (op) && (op & 0x00f0) == regno)
365  {
366  cache->sp_offset += offset;
367  pc += 6;
368  }
369  else
370  break;
371  }
372  else if (IS_PUSH (op))
373  {
374  regno = op & 0x000f;
375  cache->sp_offset += 2;
376  cache->saved_regs[regno] = cache->sp_offset;
377  pc += 2;
378  }
379  else if (op == 0x0100)
380  {
381  op = read_memory_unsigned_integer (pc + 2, 2, byte_order);
382  if (IS_PUSH (op))
383  {
384  regno = op & 0x000f;
385  cache->sp_offset += 4;
386  cache->saved_regs[regno] = cache->sp_offset;
387  pc += 4;
388  }
389  else
390  break;
391  }
392  else if ((op & 0xffcf) == 0x0100)
393  {
394  int op1;
395  op1 = read_memory_unsigned_integer (pc + 2, 2, byte_order);
396  if (IS_PUSH (op1))
397  {
398  /* Since the prefix is 0x01x0, this is not a simple pushm but a
399  stm.l reglist,@-sp */
400  i = ((op & 0x0030) >> 4) + 1;
401  regno = op1 & 0x000f;
402  for (; i > 0; regno++, --i)
403  {
404  cache->sp_offset += 4;
405  cache->saved_regs[regno] = cache->sp_offset;
406  }
407  pc += 4;
408  }
409  else
410  break;
411  }
412  else
413  break;
414  }
415 
416  /* Check for spilling an argument register to the stack frame.
417  This could also be an initializing store from non-prologue code,
418  but I don't think there's any harm in skipping that. */
419  while ((spill_size = h8300_is_argument_spill (gdbarch, pc)) > 0
420  && pc + spill_size <= current_pc)
421  pc += spill_size;
422 
423  return pc;
424 }
425 
426 static struct h8300_frame_cache *
427 h8300_frame_cache (struct frame_info *this_frame, void **this_cache)
428 {
429  struct gdbarch *gdbarch = get_frame_arch (this_frame);
430  struct h8300_frame_cache *cache;
431  int i;
432  CORE_ADDR current_pc;
433 
434  if (*this_cache)
435  return *this_cache;
436 
437  cache = FRAME_OBSTACK_ZALLOC (struct h8300_frame_cache);
438  h8300_init_frame_cache (gdbarch, cache);
439  *this_cache = cache;
440 
441  /* In principle, for normal frames, %fp holds the frame pointer,
442  which holds the base address for the current stack frame.
443  However, for functions that don't need it, the frame pointer is
444  optional. For these "frameless" functions the frame pointer is
445  actually the frame pointer of the calling frame. */
446 
447  cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
448  if (cache->base == 0)
449  return cache;
450 
451  cache->saved_regs[E_PC_REGNUM] = -BINWORD (gdbarch);
452 
453  cache->pc = get_frame_func (this_frame);
454  current_pc = get_frame_pc (this_frame);
455  if (cache->pc != 0)
456  h8300_analyze_prologue (gdbarch, cache->pc, current_pc, cache);
457 
458  if (!cache->uses_fp)
459  {
460  /* We didn't find a valid frame, which means that CACHE->base
461  currently holds the frame pointer for our calling frame. If
462  we're at the start of a function, or somewhere half-way its
463  prologue, the function's frame probably hasn't been fully
464  setup yet. Try to reconstruct the base address for the stack
465  frame by looking at the stack pointer. For truly "frameless"
466  functions this might work too. */
467 
468  cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM)
469  + cache->sp_offset;
470  cache->saved_sp = cache->base + BINWORD (gdbarch);
471  cache->saved_regs[E_PC_REGNUM] = 0;
472  }
473  else
474  {
475  cache->saved_sp = cache->base + 2 * BINWORD (gdbarch);
476  cache->saved_regs[E_PC_REGNUM] = -BINWORD (gdbarch);
477  }
478 
479  /* Adjust all the saved registers such that they contain addresses
480  instead of offsets. */
481  for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
482  if (cache->saved_regs[i] != -1)
483  cache->saved_regs[i] = cache->base - cache->saved_regs[i];
484 
485  return cache;
486 }
487 
488 static void
489 h8300_frame_this_id (struct frame_info *this_frame, void **this_cache,
490  struct frame_id *this_id)
491 {
492  struct h8300_frame_cache *cache =
493  h8300_frame_cache (this_frame, this_cache);
494 
495  /* This marks the outermost frame. */
496  if (cache->base == 0)
497  return;
498 
499  *this_id = frame_id_build (cache->saved_sp, cache->pc);
500 }
501 
502 static struct value *
503 h8300_frame_prev_register (struct frame_info *this_frame, void **this_cache,
504  int regnum)
505 {
506  struct gdbarch *gdbarch = get_frame_arch (this_frame);
507  struct h8300_frame_cache *cache =
508  h8300_frame_cache (this_frame, this_cache);
509 
510  gdb_assert (regnum >= 0);
511 
512  if (regnum == E_SP_REGNUM && cache->saved_sp)
513  return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
514 
515  if (regnum < gdbarch_num_regs (gdbarch)
516  && cache->saved_regs[regnum] != -1)
517  return frame_unwind_got_memory (this_frame, regnum,
518  cache->saved_regs[regnum]);
519 
520  return frame_unwind_got_register (this_frame, regnum, regnum);
521 }
522 
523 static const struct frame_unwind h8300_frame_unwind = {
524  NORMAL_FRAME,
528  NULL,
530 };
531 
532 static CORE_ADDR
533 h8300_frame_base_address (struct frame_info *this_frame, void **this_cache)
534 {
535  struct h8300_frame_cache *cache = h8300_frame_cache (this_frame, this_cache);
536  return cache->base;
537 }
538 
539 static const struct frame_base h8300_frame_base = {
543  h8300_frame_base_address
544 };
545 
546 static CORE_ADDR
547 h8300_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
548 {
549  CORE_ADDR func_addr = 0 , func_end = 0;
550 
551  if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
552  {
553  struct symtab_and_line sal;
554  struct h8300_frame_cache cache;
555 
556  /* Found a function. */
557  sal = find_pc_line (func_addr, 0);
558  if (sal.end && sal.end < func_end)
559  /* Found a line number, use it as end of prologue. */
560  return sal.end;
561 
562  /* No useable line symbol. Use prologue parsing method. */
563  h8300_init_frame_cache (gdbarch, &cache);
564  return h8300_analyze_prologue (gdbarch, func_addr, func_end, &cache);
565  }
566 
567  /* No function symbol -- just return the PC. */
568  return (CORE_ADDR) pc;
569 }
570 
571 /* Function: push_dummy_call
572  Setup the function arguments for calling a function in the inferior.
573  In this discussion, a `word' is 16 bits on the H8/300s, and 32 bits
574  on the H8/300H.
575 
576  There are actually two ABI's here: -mquickcall (the default) and
577  -mno-quickcall. With -mno-quickcall, all arguments are passed on
578  the stack after the return address, word-aligned. With
579  -mquickcall, GCC tries to use r0 -- r2 to pass registers. Since
580  GCC doesn't indicate in the object file which ABI was used to
581  compile it, GDB only supports the default --- -mquickcall.
582 
583  Here are the rules for -mquickcall, in detail:
584 
585  Each argument, whether scalar or aggregate, is padded to occupy a
586  whole number of words. Arguments smaller than a word are padded at
587  the most significant end; those larger than a word are padded at
588  the least significant end.
589 
590  The initial arguments are passed in r0 -- r2. Earlier arguments go in
591  lower-numbered registers. Multi-word arguments are passed in
592  consecutive registers, with the most significant end in the
593  lower-numbered register.
594 
595  If an argument doesn't fit entirely in the remaining registers, it
596  is passed entirely on the stack. Stack arguments begin just after
597  the return address. Once an argument has overflowed onto the stack
598  this way, all subsequent arguments are passed on the stack.
599 
600  The above rule has odd consequences. For example, on the h8/300s,
601  if a function takes two longs and an int as arguments:
602  - the first long will be passed in r0/r1,
603  - the second long will be passed entirely on the stack, since it
604  doesn't fit in r2,
605  - and the int will be passed on the stack, even though it could fit
606  in r2.
607 
608  A weird exception: if an argument is larger than a word, but not a
609  whole number of words in length (before padding), it is passed on
610  the stack following the rules for stack arguments above, even if
611  there are sufficient registers available to hold it. Stranger
612  still, the argument registers are still `used up' --- even though
613  there's nothing in them.
614 
615  So, for example, on the h8/300s, if a function expects a three-byte
616  structure and an int, the structure will go on the stack, and the
617  int will go in r2, not r0.
618 
619  If the function returns an aggregate type (struct, union, or class)
620  by value, the caller must allocate space to hold the return value,
621  and pass the callee a pointer to this space as an invisible first
622  argument, in R0.
623 
624  For varargs functions, the last fixed argument and all the variable
625  arguments are always passed on the stack. This means that calls to
626  varargs functions don't work properly unless there is a prototype
627  in scope.
628 
629  Basically, this ABI is not good, for the following reasons:
630  - You can't call vararg functions properly unless a prototype is in scope.
631  - Structure passing is inconsistent, to no purpose I can see.
632  - It often wastes argument registers, of which there are only three
633  to begin with. */
634 
635 static CORE_ADDR
636 h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
637  struct regcache *regcache, CORE_ADDR bp_addr,
638  int nargs, struct value **args, CORE_ADDR sp,
639  int struct_return, CORE_ADDR struct_addr)
640 {
641  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
642  int stack_alloc = 0, stack_offset = 0;
643  int wordsize = BINWORD (gdbarch);
644  int reg = E_ARG0_REGNUM;
645  int argument;
646 
647  /* First, make sure the stack is properly aligned. */
648  sp = align_down (sp, wordsize);
649 
650  /* Now make sure there's space on the stack for the arguments. We
651  may over-allocate a little here, but that won't hurt anything. */
652  for (argument = 0; argument < nargs; argument++)
653  stack_alloc += align_up (TYPE_LENGTH (value_type (args[argument])),
654  wordsize);
655  sp -= stack_alloc;
656 
657  /* Now load as many arguments as possible into registers, and push
658  the rest onto the stack.
659  If we're returning a structure by value, then we must pass a
660  pointer to the buffer for the return value as an invisible first
661  argument. */
662  if (struct_return)
663  regcache_cooked_write_unsigned (regcache, reg++, struct_addr);
664 
665  for (argument = 0; argument < nargs; argument++)
666  {
667  struct cleanup *back_to;
668  struct type *type = value_type (args[argument]);
669  int len = TYPE_LENGTH (type);
670  char *contents = (char *) value_contents (args[argument]);
671 
672  /* Pad the argument appropriately. */
673  int padded_len = align_up (len, wordsize);
674  gdb_byte *padded = xmalloc (padded_len);
675  back_to = make_cleanup (xfree, padded);
676 
677  memset (padded, 0, padded_len);
678  memcpy (len < wordsize ? padded + padded_len - len : padded,
679  contents, len);
680 
681  /* Could the argument fit in the remaining registers? */
682  if (padded_len <= (E_ARGLAST_REGNUM - reg + 1) * wordsize)
683  {
684  /* Are we going to pass it on the stack anyway, for no good
685  reason? */
686  if (len > wordsize && len % wordsize)
687  {
688  /* I feel so unclean. */
689  write_memory (sp + stack_offset, padded, padded_len);
690  stack_offset += padded_len;
691 
692  /* That's right --- even though we passed the argument
693  on the stack, we consume the registers anyway! Love
694  me, love my dog. */
695  reg += padded_len / wordsize;
696  }
697  else
698  {
699  /* Heavens to Betsy --- it's really going in registers!
700  Note that on the h8/300s, there are gaps between the
701  registers in the register file. */
702  int offset;
703 
704  for (offset = 0; offset < padded_len; offset += wordsize)
705  {
706  ULONGEST word
707  = extract_unsigned_integer (padded + offset,
708  wordsize, byte_order);
709  regcache_cooked_write_unsigned (regcache, reg++, word);
710  }
711  }
712  }
713  else
714  {
715  /* It doesn't fit in registers! Onto the stack it goes. */
716  write_memory (sp + stack_offset, padded, padded_len);
717  stack_offset += padded_len;
718 
719  /* Once one argument has spilled onto the stack, all
720  subsequent arguments go on the stack. */
721  reg = E_ARGLAST_REGNUM + 1;
722  }
723 
724  do_cleanups (back_to);
725  }
726 
727  /* Store return address. */
728  sp -= wordsize;
729  write_memory_unsigned_integer (sp, wordsize, byte_order, bp_addr);
730 
731  /* Update stack pointer. */
733 
734  /* Return the new stack pointer minus the return address slot since
735  that's what DWARF2/GCC uses as the frame's CFA. */
736  return sp + wordsize;
737 }
738 
739 /* Function: extract_return_value
740  Figure out where in REGBUF the called function has left its return value.
741  Copy that into VALBUF. Be sure to account for CPU type. */
742 
743 static void
745  void *valbuf)
746 {
747  struct gdbarch *gdbarch = get_regcache_arch (regcache);
748  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
749  int len = TYPE_LENGTH (type);
750  ULONGEST c, addr;
751 
752  switch (len)
753  {
754  case 1:
755  case 2:
757  store_unsigned_integer (valbuf, len, byte_order, c);
758  break;
759  case 4: /* Needs two registers on plain H8/300 */
761  store_unsigned_integer (valbuf, 2, byte_order, c);
763  store_unsigned_integer ((void *)((char *) valbuf + 2), 2, byte_order, c);
764  break;
765  case 8: /* long long is now 8 bytes. */
766  if (TYPE_CODE (type) == TYPE_CODE_INT)
767  {
768  regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &addr);
769  c = read_memory_unsigned_integer ((CORE_ADDR) addr, len, byte_order);
770  store_unsigned_integer (valbuf, len, byte_order, c);
771  }
772  else
773  {
774  error (_("I don't know how this 8 byte value is returned."));
775  }
776  break;
777  }
778 }
779 
780 static void
782  void *valbuf)
783 {
784  struct gdbarch *gdbarch = get_regcache_arch (regcache);
785  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
786  ULONGEST c;
787 
788  switch (TYPE_LENGTH (type))
789  {
790  case 1:
791  case 2:
792  case 4:
794  store_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order, c);
795  break;
796  case 8: /* long long is now 8 bytes. */
797  if (TYPE_CODE (type) == TYPE_CODE_INT)
798  {
800  store_unsigned_integer (valbuf, 4, byte_order, c);
802  store_unsigned_integer ((void *) ((char *) valbuf + 4), 4,
803  byte_order, c);
804  }
805  else
806  {
807  error (_("I don't know how this 8 byte value is returned."));
808  }
809  break;
810  }
811 }
812 
813 static int
815 {
816  /* Types of 1, 2 or 4 bytes are returned in R0/R1, everything else on the
817  stack. */
818 
819  if (TYPE_CODE (value_type) == TYPE_CODE_STRUCT
820  || TYPE_CODE (value_type) == TYPE_CODE_UNION)
821  return 1;
822  return !(TYPE_LENGTH (value_type) == 1
823  || TYPE_LENGTH (value_type) == 2
824  || TYPE_LENGTH (value_type) == 4);
825 }
826 
827 static int
829 {
830  /* Types of 1, 2 or 4 bytes are returned in R0, INT types of 8 bytes are
831  returned in R0/R1, everything else on the stack. */
832  if (TYPE_CODE (value_type) == TYPE_CODE_STRUCT
833  || TYPE_CODE (value_type) == TYPE_CODE_UNION)
834  return 1;
835  return !(TYPE_LENGTH (value_type) == 1
836  || TYPE_LENGTH (value_type) == 2
837  || TYPE_LENGTH (value_type) == 4
838  || (TYPE_LENGTH (value_type) == 8
839  && TYPE_CODE (value_type) == TYPE_CODE_INT));
840 }
841 
842 /* Function: store_return_value
843  Place the appropriate value in the appropriate registers.
844  Primarily used by the RETURN command. */
845 
846 static void
848  const void *valbuf)
849 {
850  struct gdbarch *gdbarch = get_regcache_arch (regcache);
851  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
852  ULONGEST val;
853 
854  switch (TYPE_LENGTH (type))
855  {
856  case 1:
857  case 2: /* short... */
858  val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order);
860  break;
861  case 4: /* long, float */
862  val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order);
864  (val >> 16) & 0xffff);
865  regcache_cooked_write_unsigned (regcache, E_RET1_REGNUM, val & 0xffff);
866  break;
867  case 8: /* long long, double and long double
868  are all defined as 4 byte types so
869  far so this shouldn't happen. */
870  error (_("I don't know how to return an 8 byte value."));
871  break;
872  }
873 }
874 
875 static void
877  const void *valbuf)
878 {
879  struct gdbarch *gdbarch = get_regcache_arch (regcache);
880  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
881  ULONGEST val;
882 
883  switch (TYPE_LENGTH (type))
884  {
885  case 1:
886  case 2:
887  case 4: /* long, float */
888  val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order);
890  break;
891  case 8:
892  val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order);
894  (val >> 32) & 0xffffffff);
896  val & 0xffffffff);
897  break;
898  }
899 }
900 
901 static enum return_value_convention
902 h8300_return_value (struct gdbarch *gdbarch, struct value *function,
903  struct type *type, struct regcache *regcache,
904  gdb_byte *readbuf, const gdb_byte *writebuf)
905 {
906  if (h8300_use_struct_convention (type))
908  if (writebuf)
909  h8300_store_return_value (type, regcache, writebuf);
910  else if (readbuf)
911  h8300_extract_return_value (type, regcache, readbuf);
913 }
914 
915 static enum return_value_convention
916 h8300h_return_value (struct gdbarch *gdbarch, struct value *function,
917  struct type *type, struct regcache *regcache,
918  gdb_byte *readbuf, const gdb_byte *writebuf)
919 {
920  if (h8300h_use_struct_convention (type))
921  {
922  if (readbuf)
923  {
924  ULONGEST addr;
925 
926  regcache_raw_read_unsigned (regcache, E_R0_REGNUM, &addr);
927  read_memory (addr, readbuf, TYPE_LENGTH (type));
928  }
929 
931  }
932  if (writebuf)
933  h8300h_store_return_value (type, regcache, writebuf);
934  else if (readbuf)
935  h8300h_extract_return_value (type, regcache, readbuf);
937 }
938 
939 /* Implementation of 'register_sim_regno' gdbarch method. */
940 
941 static int
942 h8300_register_sim_regno (struct gdbarch *gdbarch, int regnum)
943 {
944  /* Only makes sense to supply raw registers. */
945  gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
946 
947  /* We hide the raw ccr from the user by making it nameless. Because
948  the default register_sim_regno hook returns
949  LEGACY_SIM_REGNO_IGNORE for unnamed registers, we need to
950  override it. The sim register numbering is compatible with
951  gdb's. */
952  return regnum;
953 }
954 
955 static const char *
956 h8300_register_name (struct gdbarch *gdbarch, int regno)
957 {
958  /* The register names change depending on which h8300 processor
959  type is selected. */
960  static char *register_names[] = {
961  "r0", "r1", "r2", "r3", "r4", "r5", "r6",
962  "sp", "", "pc", "cycles", "tick", "inst",
963  "ccr", /* pseudo register */
964  };
965  if (regno < 0
966  || regno >= (sizeof (register_names) / sizeof (*register_names)))
967  internal_error (__FILE__, __LINE__,
968  _("h8300_register_name: illegal register number %d"),
969  regno);
970  else
971  return register_names[regno];
972 }
973 
974 static const char *
975 h8300s_register_name (struct gdbarch *gdbarch, int regno)
976 {
977  static char *register_names[] = {
978  "er0", "er1", "er2", "er3", "er4", "er5", "er6",
979  "sp", "", "pc", "cycles", "", "tick", "inst",
980  "mach", "macl",
981  "ccr", "exr" /* pseudo registers */
982  };
983  if (regno < 0
984  || regno >= (sizeof (register_names) / sizeof (*register_names)))
985  internal_error (__FILE__, __LINE__,
986  _("h8300s_register_name: illegal register number %d"),
987  regno);
988  else
989  return register_names[regno];
990 }
991 
992 static const char *
993 h8300sx_register_name (struct gdbarch *gdbarch, int regno)
994 {
995  static char *register_names[] = {
996  "er0", "er1", "er2", "er3", "er4", "er5", "er6",
997  "sp", "", "pc", "cycles", "", "tick", "inst",
998  "mach", "macl", "sbr", "vbr",
999  "ccr", "exr" /* pseudo registers */
1000  };
1001  if (regno < 0
1002  || regno >= (sizeof (register_names) / sizeof (*register_names)))
1003  internal_error (__FILE__, __LINE__,
1004  _("h8300sx_register_name: illegal register number %d"),
1005  regno);
1006  else
1007  return register_names[regno];
1008 }
1009 
1010 static void
1011 h8300_print_register (struct gdbarch *gdbarch, struct ui_file *file,
1012  struct frame_info *frame, int regno)
1013 {
1014  LONGEST rval;
1015  const char *name = gdbarch_register_name (gdbarch, regno);
1016 
1017  if (!name || !*name)
1018  return;
1019 
1020  rval = get_frame_register_signed (frame, regno);
1021 
1022  fprintf_filtered (file, "%-14s ", name);
1023  if ((regno == E_PSEUDO_CCR_REGNUM (gdbarch)) || \
1024  (regno == E_PSEUDO_EXR_REGNUM (gdbarch) && is_h8300smode (gdbarch)))
1025  {
1026  fprintf_filtered (file, "0x%02x ", (unsigned char) rval);
1027  print_longest (file, 'u', 1, rval);
1028  }
1029  else
1030  {
1031  fprintf_filtered (file, "0x%s ", phex ((ULONGEST) rval,
1032  BINWORD (gdbarch)));
1033  print_longest (file, 'd', 1, rval);
1034  }
1035  if (regno == E_PSEUDO_CCR_REGNUM (gdbarch))
1036  {
1037  /* CCR register */
1038  int C, Z, N, V;
1039  unsigned char l = rval & 0xff;
1040  fprintf_filtered (file, "\t");
1041  fprintf_filtered (file, "I-%d ", (l & 0x80) != 0);
1042  fprintf_filtered (file, "UI-%d ", (l & 0x40) != 0);
1043  fprintf_filtered (file, "H-%d ", (l & 0x20) != 0);
1044  fprintf_filtered (file, "U-%d ", (l & 0x10) != 0);
1045  N = (l & 0x8) != 0;
1046  Z = (l & 0x4) != 0;
1047  V = (l & 0x2) != 0;
1048  C = (l & 0x1) != 0;
1049  fprintf_filtered (file, "N-%d ", N);
1050  fprintf_filtered (file, "Z-%d ", Z);
1051  fprintf_filtered (file, "V-%d ", V);
1052  fprintf_filtered (file, "C-%d ", C);
1053  if ((C | Z) == 0)
1054  fprintf_filtered (file, "u> ");
1055  if ((C | Z) == 1)
1056  fprintf_filtered (file, "u<= ");
1057  if ((C == 0))
1058  fprintf_filtered (file, "u>= ");
1059  if (C == 1)
1060  fprintf_filtered (file, "u< ");
1061  if (Z == 0)
1062  fprintf_filtered (file, "!= ");
1063  if (Z == 1)
1064  fprintf_filtered (file, "== ");
1065  if ((N ^ V) == 0)
1066  fprintf_filtered (file, ">= ");
1067  if ((N ^ V) == 1)
1068  fprintf_filtered (file, "< ");
1069  if ((Z | (N ^ V)) == 0)
1070  fprintf_filtered (file, "> ");
1071  if ((Z | (N ^ V)) == 1)
1072  fprintf_filtered (file, "<= ");
1073  }
1074  else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch) && is_h8300smode (gdbarch))
1075  {
1076  /* EXR register */
1077  unsigned char l = rval & 0xff;
1078  fprintf_filtered (file, "\t");
1079  fprintf_filtered (file, "T-%d - - - ", (l & 0x80) != 0);
1080  fprintf_filtered (file, "I2-%d ", (l & 4) != 0);
1081  fprintf_filtered (file, "I1-%d ", (l & 2) != 0);
1082  fprintf_filtered (file, "I0-%d", (l & 1) != 0);
1083  }
1084  fprintf_filtered (file, "\n");
1085 }
1086 
1087 static void
1088 h8300_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
1089  struct frame_info *frame, int regno, int cpregs)
1090 {
1091  if (regno < 0)
1092  {
1093  for (regno = E_R0_REGNUM; regno <= E_SP_REGNUM; ++regno)
1094  h8300_print_register (gdbarch, file, frame, regno);
1095  h8300_print_register (gdbarch, file, frame,
1096  E_PSEUDO_CCR_REGNUM (gdbarch));
1097  h8300_print_register (gdbarch, file, frame, E_PC_REGNUM);
1098  if (is_h8300smode (gdbarch))
1099  {
1100  h8300_print_register (gdbarch, file, frame,
1101  E_PSEUDO_EXR_REGNUM (gdbarch));
1102  if (is_h8300sxmode (gdbarch))
1103  {
1104  h8300_print_register (gdbarch, file, frame, E_SBR_REGNUM);
1105  h8300_print_register (gdbarch, file, frame, E_VBR_REGNUM);
1106  }
1107  h8300_print_register (gdbarch, file, frame, E_MACH_REGNUM);
1108  h8300_print_register (gdbarch, file, frame, E_MACL_REGNUM);
1109  h8300_print_register (gdbarch, file, frame, E_CYCLES_REGNUM);
1110  h8300_print_register (gdbarch, file, frame, E_TICKS_REGNUM);
1111  h8300_print_register (gdbarch, file, frame, E_INSTS_REGNUM);
1112  }
1113  else
1114  {
1115  h8300_print_register (gdbarch, file, frame, E_CYCLES_REGNUM);
1116  h8300_print_register (gdbarch, file, frame, E_TICK_REGNUM);
1117  h8300_print_register (gdbarch, file, frame, E_INST_REGNUM);
1118  }
1119  }
1120  else
1121  {
1122  if (regno == E_CCR_REGNUM)
1123  h8300_print_register (gdbarch, file, frame,
1124  E_PSEUDO_CCR_REGNUM (gdbarch));
1125  else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch)
1126  && is_h8300smode (gdbarch))
1127  h8300_print_register (gdbarch, file, frame,
1128  E_PSEUDO_EXR_REGNUM (gdbarch));
1129  else
1130  h8300_print_register (gdbarch, file, frame, regno);
1131  }
1132 }
1133 
1134 static struct type *
1135 h8300_register_type (struct gdbarch *gdbarch, int regno)
1136 {
1137  if (regno < 0 || regno >= gdbarch_num_regs (gdbarch)
1138  + gdbarch_num_pseudo_regs (gdbarch))
1139  internal_error (__FILE__, __LINE__,
1140  _("h8300_register_type: illegal register number %d"),
1141  regno);
1142  else
1143  {
1144  switch (regno)
1145  {
1146  case E_PC_REGNUM:
1147  return builtin_type (gdbarch)->builtin_func_ptr;
1148  case E_SP_REGNUM:
1149  case E_FP_REGNUM:
1150  return builtin_type (gdbarch)->builtin_data_ptr;
1151  default:
1152  if (regno == E_PSEUDO_CCR_REGNUM (gdbarch))
1153  return builtin_type (gdbarch)->builtin_uint8;
1154  else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch))
1155  return builtin_type (gdbarch)->builtin_uint8;
1156  else if (is_h8300hmode (gdbarch))
1157  return builtin_type (gdbarch)->builtin_int32;
1158  else
1159  return builtin_type (gdbarch)->builtin_int16;
1160  }
1161  }
1162 }
1163 
1164 /* Helpers for h8300_pseudo_register_read. We expose ccr/exr as
1165  pseudo-registers to users with smaller sizes than the corresponding
1166  raw registers. These helpers extend/narrow the values. */
1167 
1168 static enum register_status
1169 pseudo_from_raw_register (struct gdbarch *gdbarch, struct regcache *regcache,
1170  gdb_byte *buf, int pseudo_regno, int raw_regno)
1171 {
1172  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1173  enum register_status status;
1174  ULONGEST val;
1175 
1176  status = regcache_raw_read_unsigned (regcache, raw_regno, &val);
1177  if (status == REG_VALID)
1179  register_size (gdbarch, pseudo_regno),
1180  byte_order, val);
1181  return status;
1182 }
1183 
1184 /* See pseudo_from_raw_register. */
1185 
1186 static void
1187 raw_from_pseudo_register (struct gdbarch *gdbarch, struct regcache *regcache,
1188  const gdb_byte *buf, int raw_regno, int pseudo_regno)
1189 {
1190  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1191  ULONGEST val;
1192 
1193  val = extract_unsigned_integer (buf, register_size (gdbarch, pseudo_regno),
1194  byte_order);
1195  regcache_raw_write_unsigned (regcache, raw_regno, val);
1196 }
1197 
1198 static enum register_status
1199 h8300_pseudo_register_read (struct gdbarch *gdbarch,
1200  struct regcache *regcache, int regno,
1201  gdb_byte *buf)
1202 {
1203  if (regno == E_PSEUDO_CCR_REGNUM (gdbarch))
1204  {
1205  return pseudo_from_raw_register (gdbarch, regcache, buf,
1206  regno, E_CCR_REGNUM);
1207  }
1208  else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch))
1209  {
1210  return pseudo_from_raw_register (gdbarch, regcache, buf,
1211  regno, E_EXR_REGNUM);
1212  }
1213  else
1214  return regcache_raw_read (regcache, regno, buf);
1215 }
1216 
1217 static void
1218 h8300_pseudo_register_write (struct gdbarch *gdbarch,
1219  struct regcache *regcache, int regno,
1220  const gdb_byte *buf)
1221 {
1222  if (regno == E_PSEUDO_CCR_REGNUM (gdbarch))
1223  raw_from_pseudo_register (gdbarch, regcache, buf, E_CCR_REGNUM, regno);
1224  else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch))
1225  raw_from_pseudo_register (gdbarch, regcache, buf, E_EXR_REGNUM, regno);
1226  else
1227  regcache_raw_write (regcache, regno, buf);
1228 }
1229 
1230 static int
1231 h8300_dbg_reg_to_regnum (struct gdbarch *gdbarch, int regno)
1232 {
1233  if (regno == E_CCR_REGNUM)
1234  return E_PSEUDO_CCR_REGNUM (gdbarch);
1235  return regno;
1236 }
1237 
1238 static int
1239 h8300s_dbg_reg_to_regnum (struct gdbarch *gdbarch, int regno)
1240 {
1241  if (regno == E_CCR_REGNUM)
1242  return E_PSEUDO_CCR_REGNUM (gdbarch);
1243  if (regno == E_EXR_REGNUM)
1244  return E_PSEUDO_EXR_REGNUM (gdbarch);
1245  return regno;
1246 }
1247 
1248 static const unsigned char *
1249 h8300_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
1250  int *lenptr)
1251 {
1252  /*static unsigned char breakpoint[] = { 0x7A, 0xFF }; *//* ??? */
1253  static unsigned char breakpoint[] = { 0x01, 0x80 }; /* Sleep */
1254 
1255  *lenptr = sizeof (breakpoint);
1256  return breakpoint;
1257 }
1258 
1259 static struct gdbarch *
1260 h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1261 {
1262  struct gdbarch_tdep *tdep = NULL;
1263  struct gdbarch *gdbarch;
1264 
1265  arches = gdbarch_list_lookup_by_info (arches, &info);
1266  if (arches != NULL)
1267  return arches->gdbarch;
1268 
1269 #if 0
1270  tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
1271 #endif
1272 
1273  if (info.bfd_arch_info->arch != bfd_arch_h8300)
1274  return NULL;
1275 
1276  gdbarch = gdbarch_alloc (&info, 0);
1277 
1279 
1280  switch (info.bfd_arch_info->mach)
1281  {
1282  case bfd_mach_h8300:
1283  set_gdbarch_num_regs (gdbarch, 13);
1284  set_gdbarch_num_pseudo_regs (gdbarch, 1);
1289  set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1290  set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1292  set_gdbarch_print_insn (gdbarch, print_insn_h8300);
1293  break;
1294  case bfd_mach_h8300h:
1295  case bfd_mach_h8300hn:
1296  set_gdbarch_num_regs (gdbarch, 13);
1297  set_gdbarch_num_pseudo_regs (gdbarch, 1);
1302  if (info.bfd_arch_info->mach != bfd_mach_h8300hn)
1303  {
1304  set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1305  set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1306  }
1307  else
1308  {
1309  set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1310  set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1311  }
1313  set_gdbarch_print_insn (gdbarch, print_insn_h8300h);
1314  break;
1315  case bfd_mach_h8300s:
1316  case bfd_mach_h8300sn:
1317  set_gdbarch_num_regs (gdbarch, 16);
1318  set_gdbarch_num_pseudo_regs (gdbarch, 2);
1323  if (info.bfd_arch_info->mach != bfd_mach_h8300sn)
1324  {
1325  set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1326  set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1327  }
1328  else
1329  {
1330  set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1331  set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1332  }
1334  set_gdbarch_print_insn (gdbarch, print_insn_h8300s);
1335  break;
1336  case bfd_mach_h8300sx:
1337  case bfd_mach_h8300sxn:
1338  set_gdbarch_num_regs (gdbarch, 18);
1339  set_gdbarch_num_pseudo_regs (gdbarch, 2);
1344  if (info.bfd_arch_info->mach != bfd_mach_h8300sxn)
1345  {
1346  set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1347  set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1348  }
1349  else
1350  {
1351  set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1352  set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1353  }
1355  set_gdbarch_print_insn (gdbarch, print_insn_h8300s);
1356  break;
1357  }
1358 
1361 
1362  /*
1363  * Basic register fields and methods.
1364  */
1365 
1370 
1371  /*
1372  * Frame Info
1373  */
1375 
1376  /* Frame unwinder. */
1380  frame_base_set_default (gdbarch, &h8300_frame_base);
1381 
1382  /*
1383  * Miscelany
1384  */
1385  /* Stack grows up. */
1387 
1390 
1391  set_gdbarch_char_signed (gdbarch, 0);
1392  set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1393  set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1395  set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1399 
1400  set_gdbarch_believe_pcc_promotion (gdbarch, 1);
1401 
1402  /* Hook in the DWARF CFI frame unwinder. */
1403  dwarf2_append_unwinders (gdbarch);
1404  frame_unwind_append_unwinder (gdbarch, &h8300_frame_unwind);
1405 
1406  return gdbarch;
1407 
1408 }
1409 
1410 extern initialize_file_ftype _initialize_h8300_tdep; /* -Wmissing-prototypes */
1411 
1412 void
1414 {
1415  register_gdbarch_init (bfd_arch_h8300, h8300_gdbarch_init);
1416 }
1417 
1418 static int
1419 is_h8300hmode (struct gdbarch *gdbarch)
1420 {
1421  return gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sx
1422  || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sxn
1423  || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300s
1424  || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sn
1425  || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300h
1426  || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300hn;
1427 }
1428 
1429 static int
1430 is_h8300smode (struct gdbarch *gdbarch)
1431 {
1432  return gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sx
1433  || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sxn
1434  || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300s
1435  || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sn;
1436 }
1437 
1438 static int
1439 is_h8300sxmode (struct gdbarch *gdbarch)
1440 {
1441  return gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sx
1442  || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sxn;
1443 }
1444 
1445 static int
1446 is_h8300_normal_mode (struct gdbarch *gdbarch)
1447 {
1448  return gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sxn
1449  || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sn
1450  || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300hn;
1451 }
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 IS_MOVL_EXT(x)
Definition: h8300-tdep.c:150
CORE_ADDR sp_offset
Definition: h8300-tdep.c:68
static void h8300_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int regno, const gdb_byte *buf)
Definition: h8300-tdep.c:1218
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
#define IS_ADD_IMM_SP(x)
Definition: h8300-tdep.c:158
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
#define IS_SUB4_SP(x)
Definition: h8300-tdep.c:157
static void h8300h_store_return_value(struct type *type, struct regcache *regcache, const void *valbuf)
Definition: h8300-tdep.c:876
#define BINWORD(gdbarch)
Definition: h8300-tdep.c:91
#define E_PSEUDO_CCR_REGNUM(gdbarch)
Definition: h8300-tdep.c:61
struct type * builtin_func_ptr
Definition: gdbtypes.h:1544
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
bfd_vma CORE_ADDR
Definition: common-types.h:41
#define IS_MOVW_Rn24_SP(x)
Definition: h8300-tdep.c:146
static int h8300_dbg_reg_to_regnum(struct gdbarch *gdbarch, int regno)
Definition: h8300-tdep.c:1231
void xfree(void *)
Definition: common-utils.c:97
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
struct value * frame_unwind_got_memory(struct frame_info *frame, int regnum, CORE_ADDR addr)
Definition: frame-unwind.c:228
void write_memory_unsigned_integer(CORE_ADDR addr, int len, enum bfd_endian byte_order, ULONGEST value)
Definition: corefile.c:412
static const char * h8300sx_register_name(struct gdbarch *gdbarch, int regno)
Definition: h8300-tdep.c:993
void set_gdbarch_stab_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
Definition: gdbarch.c:2059
ULONGEST align_down(ULONGEST v, int n)
Definition: utils.c:2971
ULONGEST frame_unwind_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1182
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
static struct gdbarch * h8300_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
Definition: h8300-tdep.c:1260
static void h8300_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
Definition: h8300-tdep.c:489
return_value_convention
Definition: defs.h:206
struct type * builtin_uint8
Definition: gdbtypes.h:1515
static void h8300_print_register(struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regno)
Definition: h8300-tdep.c:1011
static const char * h8300_register_name(struct gdbarch *gdbarch, int regno)
Definition: h8300-tdep.c:956
#define IS_PUSH(x)
Definition: h8300-tdep.c:164
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
Definition: gdbarch.c:4985
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1898
#define _(String)
Definition: gdb_locale.h:40
const struct bfd_arch_info * bfd_arch_info
Definition: gdbarch.h:1549
static int h8300_register_sim_regno(struct gdbarch *gdbarch, int regnum)
Definition: h8300-tdep.c:942
void set_gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
Definition: gdbarch.c:2110
static int h8300s_dbg_reg_to_regnum(struct gdbarch *gdbarch, int regno)
Definition: h8300-tdep.c:1239
static CORE_ADDR h8300_unwind_pc(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: h8300-tdep.c:96
static enum register_status pseudo_from_raw_register(struct gdbarch *gdbarch, struct regcache *regcache, gdb_byte *buf, int pseudo_regno, int raw_regno)
Definition: h8300-tdep.c:1169
static CORE_ADDR h8300_unwind_sp(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: h8300-tdep.c:102
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
struct type * builtin_int32
Definition: gdbtypes.h:1518
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:660
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
Definition: findvar.c:212
struct value * frame_unwind_got_constant(struct frame_info *frame, int regnum, ULONGEST val)
Definition: frame-unwind.c:241
static void h8300_init_frame_cache(struct gdbarch *gdbarch, struct h8300_frame_cache *cache)
Definition: h8300-tdep.c:119
static const char * h8300s_register_name(struct gdbarch *gdbarch, int regno)
Definition: h8300-tdep.c:975
#define IS_MOVB_RnRm(x)
Definition: h8300-tdep.c:138
int gdbarch_num_pseudo_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1916
void set_gdbarch_addr_bit(struct gdbarch *gdbarch, int addr_bit)
Definition: gdbarch.c:1718
static int is_h8300sxmode(struct gdbarch *gdbarch)
Definition: h8300-tdep.c:1439
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_ecoff_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
Definition: gdbarch.c:2076
void set_gdbarch_pseudo_register_write(struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype pseudo_register_write)
Definition: gdbarch.c:1891
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype register_type)
Definition: gdbarch.c:2151
LONGEST read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:311
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1329
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 void h8300_extract_return_value(struct type *type, struct regcache *regcache, void *valbuf)
Definition: h8300-tdep.c:744
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
register_status
Definition: regcache.h:50
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:837
#define IS_MOV_IMM_Rn(x)
Definition: h8300-tdep.c:161
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
Definition: gdbarch.c:1991
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype dummy_id)
Definition: gdbarch.c:2175
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
static enum return_value_convention h8300_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: h8300-tdep.c:902
struct_return
Definition: arm-tdep.h:148
void set_gdbarch_believe_pcc_promotion(struct gdbarch *gdbarch, int believe_pcc_promotion)
Definition: gdbarch.c:2406
#define IS_ADD_RnSP(x)
Definition: h8300-tdep.c:163
struct type * builtin_int16
Definition: gdbtypes.h:1516
static struct h8300_frame_cache * h8300_frame_cache(struct frame_info *this_frame, void **this_cache)
Definition: h8300-tdep.c:427
CORE_ADDR saved_sp
Definition: h8300-tdep.c:76
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
void set_gdbarch_register_sim_regno(struct gdbarch *gdbarch, gdbarch_register_sim_regno_ftype register_sim_regno)
Definition: gdbarch.c:2332
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
initialize_file_ftype _initialize_h8300_tdep
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
const char * word
Definition: symtab.h:1448
static void h8300_store_return_value(struct type *type, struct regcache *regcache, const void *valbuf)
Definition: h8300-tdep.c:847
void set_gdbarch_unwind_pc(struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype unwind_pc)
Definition: gdbarch.c:2863
void set_gdbarch_breakpoint_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
Definition: gdbarch.c:2672
int default_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
Definition: frame-unwind.c:170
#define IS_MOVW_RnRm(x)
Definition: h8300-tdep.c:139
#define gdb_assert(expr)
Definition: gdb_assert.h:33
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition: gdbarch.c:2117
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:690
#define IS_SUBL4_SP(x)
Definition: h8300-tdep.c:160
void set_gdbarch_unwind_sp(struct gdbarch *gdbarch, gdbarch_unwind_sp_ftype unwind_sp)
Definition: gdbarch.c:2887
static int is_h8300smode(struct gdbarch *gdbarch)
Definition: h8300-tdep.c:1430
CORE_ADDR base
Definition: h8300-tdep.c:67
struct gdbarch * gdbarch
Definition: gdbarch.h:1542
static enum return_value_convention h8300h_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: h8300-tdep.c:916
int regnum
Definition: aarch64-tdep.c:69
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:244
static int h8300_use_struct_convention(struct type *value_type)
Definition: h8300-tdep.c:814
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1194
void * xmalloc(YYSIZE_T)
gdb_regnum
Definition: arm-tdep.h:29
static CORE_ADDR h8300_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: h8300-tdep.c:547
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
Definition: gdbarch.c:1534
#define IS_MOVL_Rn24_SP(x)
Definition: h8300-tdep.c:151
Definition: regdef.h:22
static struct value * h8300_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
Definition: h8300-tdep.c:503
Definition: value.c:172
#define IS_MOVL_Rn16_SP(x)
Definition: h8300-tdep.c:149
const struct floatformat * floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]
Definition: gdbtypes.c:70
static struct type * h8300_register_type(struct gdbarch *gdbarch, int regno)
Definition: h8300-tdep.c:1135
#define IS_MOVL_PRE(x)
Definition: h8300-tdep.c:148
static CORE_ADDR h8300_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR current_pc, struct h8300_frame_cache *cache)
Definition: h8300-tdep.c:291
static int h8300h_use_struct_convention(struct type *value_type)
Definition: h8300-tdep.c:828
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
Definition: arch-utils.c:138
bfd_byte gdb_byte
Definition: common-types.h:38
CORE_ADDR saved_regs[H8300_MAX_NUM_REGS]
Definition: h8300-tdep.c:75
#define IS_MOVB_Rn16_SP(x)
Definition: h8300-tdep.c:141
static int is_h8300hmode(struct gdbarch *gdbarch)
Definition: h8300-tdep.c:1419
void set_gdbarch_pseudo_register_read(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype pseudo_register_read)
Definition: gdbarch.c:1843
ULONGEST align_up(ULONGEST v, int n)
Definition: utils.c:2963
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
#define IS_PUSH_FP(x)
Definition: h8300-tdep.c:154
#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
struct value * frame_unwind_got_register(struct frame_info *frame, int regnum, int new_regnum)
Definition: frame-unwind.c:218
static int is_h8300_normal_mode(struct gdbarch *gdbarch)
Definition: h8300-tdep.c:1446
struct type * builtin_data_ptr
Definition: gdbtypes.h:1533
void set_gdbarch_int_bit(struct gdbarch *gdbarch, int int_bit)
Definition: gdbarch.c:1500
static const struct frame_unwind h8300_frame_unwind
Definition: h8300-tdep.c:523
int offset
Definition: agent.c:65
void regcache_raw_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition: regcache.c:723
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
Definition: gdbarch.c:1926
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
static const unsigned char * h8300_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
Definition: h8300-tdep.c:1249
static enum register_status h8300_pseudo_register_read(struct gdbarch *gdbarch, struct regcache *regcache, int regno, gdb_byte *buf)
Definition: h8300-tdep.c:1199
static struct frame_id h8300_dummy_id(struct gdbarch *gdbarch, struct frame_info *this_frame)
Definition: h8300-tdep.c:108
void set_gdbarch_double_format(struct gdbarch *gdbarch, const struct floatformat **double_format)
Definition: gdbarch.c:1650
#define IS_MOVB_EXT(x)
Definition: h8300-tdep.c:142
#define IS_MOVL_RnRm(x)
Definition: h8300-tdep.c:140
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
#define IS_MOVB_Rn24_SP(x)
Definition: h8300-tdep.c:143
CORE_ADDR pc
Definition: h8300-tdep.c:69
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:169
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
Definition: gdbarch.c:1667
#define IS_MOV_SP_FP(x)
Definition: h8300-tdep.c:155
struct type * value_type(const struct value *value)
Definition: value.c:1021
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
static void h8300h_extract_return_value(struct type *type, struct regcache *regcache, void *valbuf)
Definition: h8300-tdep.c:781
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition: gdbarch.c:1411
#define IS_SUB_IMM_SP(x)
Definition: h8300-tdep.c:159
static void h8300_print_registers_info(struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regno, int cpregs)
Definition: h8300-tdep.c:1088
void set_gdbarch_long_double_format(struct gdbarch *gdbarch, const struct floatformat **long_double_format)
Definition: gdbarch.c:1683
#define IS_SUB_RnSP(x)
Definition: h8300-tdep.c:162
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
Definition: gdbarch.c:1700
#define E_PSEUDO_EXR_REGNUM(gdbarch)
Definition: h8300-tdep.c:62
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 h8300_is_argument_spill(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: h8300-tdep.c:178
static void raw_from_pseudo_register(struct gdbarch *gdbarch, struct regcache *regcache, const gdb_byte *buf, int raw_regno, int pseudo_regno)
Definition: h8300-tdep.c:1187
#define IS_PUSHFP_MOVESPFP(x)
Definition: h8300-tdep.c:153
void register_gdbarch_init(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init)
Definition: gdbarch.c:4975
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 IS_MOVW_Rn16_SP(x)
Definition: h8300-tdep.c:144
enum bfd_endian byte_order
Definition: gdbarch.c:128
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
Definition: gdbarch.c:2008
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype register_name)
Definition: gdbarch.c:2127
CORE_ADDR get_frame_func(struct frame_info *this_frame)
Definition: frame.c:920
void error(const char *fmt,...)
Definition: errors.c:38
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, struct gdbarch_tdep *tdep)
Definition: gdbarch.c:339
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype inner_than)
Definition: gdbarch.c:2655
static CORE_ADDR h8300_frame_base_address(struct frame_info *this_frame, void **this_cache)
Definition: h8300-tdep.c:533
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
#define H8300_MAX_NUM_REGS
Definition: h8300-tdep.c:59
long long LONGEST
Definition: common-types.h:52
#define wordsize
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
#define IS_SUB2_SP(x)
Definition: h8300-tdep.c:156
void set_gdbarch_print_insn(struct gdbarch *gdbarch, gdbarch_print_insn_ftype print_insn)
Definition: gdbarch.c:3067
#define IS_MOVW_EXT(x)
Definition: h8300-tdep.c:145
static CORE_ADDR h8300_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
Definition: h8300-tdep.c:636
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