GDB (xrefs)

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