GDB (xrefs)

/tmp/gdb-8.1/gdb/mn10300-tdep.c
Go to the documentation of this file.
1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
2
3 Copyright (C) 1996-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include "defs.h"
21 #include "arch-utils.h"
22 #include "dis-asm.h"
23 #include "gdbtypes.h"
24 #include "regcache.h"
25 #include "gdbcore.h" /* For write_memory_unsigned_integer. */
26 #include "value.h"
27 #include "frame.h"
28 #include "frame-unwind.h"
29 #include "frame-base.h"
30 #include "symtab.h"
31 #include "dwarf2-frame.h"
32 #include "osabi.h"
33 #include "infcall.h"
34 #include "prologue-value.h"
35 #include "target.h"
36
37 #include "mn10300-tdep.h"
38
39
40 /* The am33-2 has 64 registers. */
41 #define MN10300_MAX_NUM_REGS 64
42
43 /* Big enough to hold the size of the largest register in bytes. */
44 #define MN10300_MAX_REGISTER_SIZE 64
45
46 /* This structure holds the results of a prologue analysis. */
47 struct mn10300_prologue
48 {
49 /* The architecture for which we generated this prologue info. */
50 struct gdbarch *gdbarch;
51
52 /* The offset from the frame base to the stack pointer --- always
53 zero or negative.
54
55 Calling this a "size" is a bit misleading, but given that the
56 stack grows downwards, using offsets for everything keeps one
57 from going completely sign-crazy: you never change anything's
58 sign for an ADD instruction; always change the second operand's
59 sign for a SUB instruction; and everything takes care of
60 itself. */
61 int frame_size;
62
63 /* Non-zero if this function has initialized the frame pointer from
64 the stack pointer, zero otherwise. */
65 int has_frame_ptr;
66
67 /* If has_frame_ptr is non-zero, this is the offset from the frame
68 base to where the frame pointer points. This is always zero or
69 negative. */
70 int frame_ptr_offset;
71
72 /* The address of the first instruction at which the frame has been
73 set up and the arguments are where the debug info says they are
74 --- as best as we can tell. */
75 CORE_ADDR prologue_end;
76
77 /* reg_offset[R] is the offset from the CFA at which register R is
78 saved, or 1 if register R has not been saved. (Real values are
79 always zero or negative.) */
80 int reg_offset[MN10300_MAX_NUM_REGS];
81 };
82
83
84 /* Compute the alignment required by a type. */
85
86 static int
87 mn10300_type_align (struct type *type)
88 {
89 int i, align = 1;
90
91 switch (TYPE_CODE (type))
92 {
93 case TYPE_CODE_INT:
94 case TYPE_CODE_ENUM:
95 case TYPE_CODE_SET:
96 case TYPE_CODE_RANGE:
97 case TYPE_CODE_CHAR:
98 case TYPE_CODE_BOOL:
99 case TYPE_CODE_FLT:
100 case TYPE_CODE_PTR:
101 case TYPE_CODE_REF:
102 case TYPE_CODE_RVALUE_REF:
103 return TYPE_LENGTH (type);
104
105 case TYPE_CODE_COMPLEX:
106 return TYPE_LENGTH (type) / 2;
107
108 case TYPE_CODE_STRUCT:
109 case TYPE_CODE_UNION:
110 for (i = 0; i < TYPE_NFIELDS (type); i++)
111 {
112 int falign = mn10300_type_align (TYPE_FIELD_TYPE (type, i));
113 while (align < falign)
114 align <<= 1;
115 }
116 return align;
117
118 case TYPE_CODE_ARRAY:
119 /* HACK! Structures containing arrays, even small ones, are not
120 elligible for returning in registers. */
121 return 256;
122
123 case TYPE_CODE_TYPEDEF:
124 return mn10300_type_align (check_typedef (type));
125
126 default:
127 internal_error (__FILE__, __LINE__, _("bad switch"));
128 }
129 }
130
131 /* Should call_function allocate stack space for a struct return? */
132 static int
133 mn10300_use_struct_convention (struct type *type)
134 {
135 /* Structures bigger than a pair of words can't be returned in
136 registers. */
137 if (TYPE_LENGTH (type) > 8)
138 return 1;
139
140 switch (TYPE_CODE (type))
141 {
142 case TYPE_CODE_STRUCT:
143 case TYPE_CODE_UNION:
144 /* Structures with a single field are handled as the field
145 itself. */
146 if (TYPE_NFIELDS (type) == 1)
147 return mn10300_use_struct_convention (TYPE_FIELD_TYPE (type, 0));
148
149 /* Structures with word or double-word size are passed in memory, as
150 long as they require at least word alignment. */
151 if (mn10300_type_align (type) >= 4)
152 return 0;
153
154 return 1;
155
156 /* Arrays are addressable, so they're never returned in
157 registers. This condition can only hold when the array is
158 the only field of a struct or union. */
159 case TYPE_CODE_ARRAY:
160 return 1;
161
162 case TYPE_CODE_TYPEDEF:
163 return mn10300_use_struct_convention (check_typedef (type));
164
165 default:
166 return 0;
167 }
168 }
169
170 static void
171 mn10300_store_return_value (struct gdbarch *gdbarch, struct type *type,
172 struct regcache *regcache, const gdb_byte *valbuf)
173 {
174 int len = TYPE_LENGTH (type);
175 int reg, regsz;
176
177 if (TYPE_CODE (type) == TYPE_CODE_PTR)
178 reg = 4;
179 else
180 reg = 0;
181
182 regsz = register_size (gdbarch, reg);
183
184 if (len <= regsz)
185 regcache_raw_write_part (regcache, reg, 0, len, valbuf);
186 else if (len <= 2 * regsz)
187 {
188 regcache_raw_write (regcache, reg, valbuf);
189 gdb_assert (regsz == register_size (gdbarch, reg + 1));
190 regcache_raw_write_part (regcache, reg+1, 0,
191 len - regsz, valbuf + regsz);
192 }
193 else
194 internal_error (__FILE__, __LINE__,
195 _("Cannot store return value %d bytes long."), len);
196 }
197
198 static void
199 mn10300_extract_return_value (struct gdbarch *gdbarch, struct type *type,
200 struct regcache *regcache, void *valbuf)
201 {
202 gdb_byte buf[MN10300_MAX_REGISTER_SIZE];
203 int len = TYPE_LENGTH (type);
204 int reg, regsz;
205
206 if (TYPE_CODE (type) == TYPE_CODE_PTR)
207 reg = 4;
208 else
209 reg = 0;
210
211 regsz = register_size (gdbarch, reg);
212 gdb_assert (regsz <= MN10300_MAX_REGISTER_SIZE);
213 if (len <= regsz)
214 {
215 regcache_raw_read (regcache, reg, buf);
216 memcpy (valbuf, buf, len);
217 }
218 else if (len <= 2 * regsz)
219 {
220 regcache_raw_read (regcache, reg, buf);
221 memcpy (valbuf, buf, regsz);
222 gdb_assert (regsz == register_size (gdbarch, reg + 1));
223 regcache_raw_read (regcache, reg + 1, buf);
224 memcpy ((char *) valbuf + regsz, buf, len - regsz);
225 }
226 else
227 internal_error (__FILE__, __LINE__,
228 _("Cannot extract return value %d bytes long."), len);
229 }
230
231 /* Determine, for architecture GDBARCH, how a return value of TYPE
232 should be returned. If it is supposed to be returned in registers,
233 and READBUF is non-zero, read the appropriate value from REGCACHE,
234 and copy it into READBUF. If WRITEBUF is non-zero, write the value
235 from WRITEBUF into REGCACHE. */
236
237 static enum return_value_convention
238 mn10300_return_value (struct gdbarch *gdbarch, struct value *function,
239 struct type *type, struct regcache *regcache,
240 gdb_byte *readbuf, const gdb_byte *writebuf)
241 {
242 if (mn10300_use_struct_convention (type))
243 return RETURN_VALUE_STRUCT_CONVENTION;
244
245 if (readbuf)
246 mn10300_extract_return_value (gdbarch, type, regcache, readbuf);
247 if (writebuf)
248 mn10300_store_return_value (gdbarch, type, regcache, writebuf);
249
250 return RETURN_VALUE_REGISTER_CONVENTION;
251 }
252
253 static const char *
254 register_name (int reg, const char **regs, long sizeof_regs)
255 {
256 if (reg < 0 || reg >= sizeof_regs / sizeof (regs[0]))
257 return NULL;
258 else
259 return regs[reg];
260 }
261
262 static const char *
263 mn10300_generic_register_name (struct gdbarch *gdbarch, int reg)
264 {
265 static const char *regs[] =
266 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
267 "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
268 "", "", "", "", "", "", "", "",
269 "", "", "", "", "", "", "", "fp"
270 };
271 return register_name (reg, regs, sizeof regs);
272 }
273
274
275 static const char *
276 am33_register_name (struct gdbarch *gdbarch, int reg)
277 {
278 static const char *regs[] =
279 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
280 "sp", "pc", "mdr", "psw", "lir", "lar", "",
281 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
282 "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
283 };
284 return register_name (reg, regs, sizeof regs);
285 }
286
287 static const char *
288 am33_2_register_name (struct gdbarch *gdbarch, int reg)
289 {
290 static const char *regs[] =
291 {
292 "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
293 "sp", "pc", "mdr", "psw", "lir", "lar", "mdrq", "r0",
294 "r1", "r2", "r3", "r4", "r5", "r6", "r7", "ssp",
295 "msp", "usp", "mcrh", "mcrl", "mcvf", "fpcr", "", "",
296 "fs0", "fs1", "fs2", "fs3", "fs4", "fs5", "fs6", "fs7",
297 "fs8", "fs9", "fs10", "fs11", "fs12", "fs13", "fs14", "fs15",
298 "fs16", "fs17", "fs18", "fs19", "fs20", "fs21", "fs22", "fs23",
299 "fs24", "fs25", "fs26", "fs27", "fs28", "fs29", "fs30", "fs31"
300 };
301 return register_name (reg, regs, sizeof regs);
302 }
303
304 static struct type *
305 mn10300_register_type (struct gdbarch *gdbarch, int reg)
306 {
307 return builtin_type (gdbarch)->builtin_int;
308 }
309
310 static CORE_ADDR
311 mn10300_read_pc (struct regcache *regcache)
312 {
313 ULONGEST val;
314 regcache_cooked_read_unsigned (regcache, E_PC_REGNUM, &val);
315 return val;
316 }
317
318 static void
319 mn10300_write_pc (struct regcache *regcache, CORE_ADDR val)
320 {
321 regcache_cooked_write_unsigned (regcache, E_PC_REGNUM, val);
322 }
323
324 /* The breakpoint instruction must be the same size as the smallest
325 instruction in the instruction set.
326
327 The Matsushita mn10x00 processors have single byte instructions
328 so we need a single byte breakpoint. Matsushita hasn't defined
329 one, so we defined it ourselves. */
330 constexpr gdb_byte mn10300_break_insn[] = {0xff};
331
332 typedef BP_MANIPULATION (mn10300_break_insn) mn10300_breakpoint;
333
334 /* Model the semantics of pushing a register onto the stack. This
335 is a helper function for mn10300_analyze_prologue, below. */
336 static void
337 push_reg (pv_t *regs, struct pv_area *stack, int regnum)
338 {
339 regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], -4);
340 stack->store (regs[E_SP_REGNUM], 4, regs[regnum]);
341 }
342
343 /* Translate an "r" register number extracted from an instruction encoding
344 into a GDB register number. Adapted from a simulator function
345 of the same name; see am33.igen. */
346 static int
347 translate_rreg (int rreg)
348 {
349 /* The higher register numbers actually correspond to the
350 basic machine's address and data registers. */
351 if (rreg > 7 && rreg < 12)
352 return E_A0_REGNUM + rreg - 8;
353 else if (rreg > 11 && rreg < 16)
354 return E_D0_REGNUM + rreg - 12;
355 else
356 return E_E0_REGNUM + rreg;
357 }
358
359 /* Find saved registers in a 'struct pv_area'; we pass this to pv_area::scan.
360
361 If VALUE is a saved register, ADDR says it was saved at a constant
362 offset from the frame base, and SIZE indicates that the whole
363 register was saved, record its offset in RESULT_UNTYPED. */
364 static void
365 check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size, pv_t value)
366 {
367 struct mn10300_prologue *result = (struct mn10300_prologue *) result_untyped;
368
369 if (value.kind == pvk_register
370 && value.k == 0
371 && pv_is_register (addr, E_SP_REGNUM)
372 && size == register_size (result->gdbarch, value.reg))
373 result->reg_offset[value.reg] = addr.k;
374 }
375
376 /* Analyze the prologue to determine where registers are saved,
377 the end of the prologue, etc. The result of this analysis is
378 returned in RESULT. See struct mn10300_prologue above for more
379 information. */
380 static void
381 mn10300_analyze_prologue (struct gdbarch *gdbarch,
382 CORE_ADDR start_pc, CORE_ADDR limit_pc,
383 struct mn10300_prologue *result)
384 {
385 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
386 CORE_ADDR pc;
387 int rn;
388 pv_t regs[MN10300_MAX_NUM_REGS];
389 CORE_ADDR after_last_frame_setup_insn = start_pc;
390 int am33_mode = AM33_MODE (gdbarch);
391
392 memset (result, 0, sizeof (*result));
393 result->gdbarch = gdbarch;
394
395 for (rn = 0; rn < MN10300_MAX_NUM_REGS; rn++)
396 {
397 regs[rn] = pv_register (rn, 0);
398 result->reg_offset[rn] = 1;
399 }
400 pv_area stack (E_SP_REGNUM, gdbarch_addr_bit (gdbarch));
401
402 /* The typical call instruction will have saved the return address on the
403 stack. Space for the return address has already been preallocated in
404 the caller's frame. It's possible, such as when using -mrelax with gcc
405 that other registers were saved as well. If this happens, we really
406 have no chance of deciphering the frame. DWARF info can save the day
407 when this happens. */
408 stack.store (regs[E_SP_REGNUM], 4, regs[E_PC_REGNUM]);
409
410 pc = start_pc;
411 while (pc < limit_pc)
412 {
413 int status;
414 gdb_byte instr[2];
415
416 /* Instructions can be as small as one byte; however, we usually
417 need at least two bytes to do the decoding, so fetch that many
418 to begin with. */
419 status = target_read_memory (pc, instr, 2);
420 if (status != 0)
421 break;
422
423 /* movm [regs], sp */
424 if (instr[0] == 0xcf)
425 {
426 gdb_byte save_mask;
427
428 save_mask = instr[1];
429
430 if ((save_mask & movm_exreg0_bit) && am33_mode)
431 {
432 push_reg (regs, &stack, E_E2_REGNUM);
433 push_reg (regs, &stack, E_E3_REGNUM);
434 }
435 if ((save_mask & movm_exreg1_bit) && am33_mode)
436 {
437 push_reg (regs, &stack, E_E4_REGNUM);
438 push_reg (regs, &stack, E_E5_REGNUM);
439 push_reg (regs, &stack, E_E6_REGNUM);
440 push_reg (regs, &stack, E_E7_REGNUM);
441 }
442 if ((save_mask & movm_exother_bit) && am33_mode)
443 {
444 push_reg (regs, &stack, E_E0_REGNUM);
445 push_reg (regs, &stack, E_E1_REGNUM);
446 push_reg (regs, &stack, E_MDRQ_REGNUM);
447 push_reg (regs, &stack, E_MCRH_REGNUM);
448 push_reg (regs, &stack, E_MCRL_REGNUM);
449 push_reg (regs, &stack, E_MCVF_REGNUM);
450 }
451 if (save_mask & movm_d2_bit)
452 push_reg (regs, &stack, E_D2_REGNUM);
453 if (save_mask & movm_d3_bit)
454 push_reg (regs, &stack, E_D3_REGNUM);
455 if (save_mask & movm_a2_bit)
456 push_reg (regs, &stack, E_A2_REGNUM);
457 if (save_mask & movm_a3_bit)
458 push_reg (regs, &stack, E_A3_REGNUM);
459 if (save_mask & movm_other_bit)
460 {
461 push_reg (regs, &stack, E_D0_REGNUM);
462 push_reg (regs, &stack, E_D1_REGNUM);
463 push_reg (regs, &stack, E_A0_REGNUM);
464 push_reg (regs, &stack, E_A1_REGNUM);
465 push_reg (regs, &stack, E_MDR_REGNUM);
466 push_reg (regs, &stack, E_LIR_REGNUM);
467 push_reg (regs, &stack, E_LAR_REGNUM);
468 /* The `other' bit leaves a blank area of four bytes at
469 the beginning of its block of saved registers, making
470 it 32 bytes long in total. */
471 regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], -4);
472 }
473
474 pc += 2;
475 after_last_frame_setup_insn = pc;
476 }
477 /* mov sp, aN */
478 else if ((instr[0] & 0xfc) == 0x3c)
479 {
480 int aN = instr[0] & 0x03;
481
482 regs[E_A0_REGNUM + aN] = regs[E_SP_REGNUM];
483
484 pc += 1;
485 if (aN == 3)
486 after_last_frame_setup_insn = pc;
487 }
488 /* mov aM, aN */
489 else if ((instr[0] & 0xf0) == 0x90
490 && (instr[0] & 0x03) != ((instr[0] & 0x0c) >> 2))
491 {
492 int aN = instr[0] & 0x03;
493 int aM = (instr[0] & 0x0c) >> 2;
494
495 regs[E_A0_REGNUM + aN] = regs[E_A0_REGNUM + aM];
496
497 pc += 1;
498 }
499 /* mov dM, dN */
500 else if ((instr[0] & 0xf0) == 0x80
501 && (instr[0] & 0x03) != ((instr[0] & 0x0c) >> 2))
502 {
503 int dN = instr[0] & 0x03;
504 int dM = (instr[0] & 0x0c) >> 2;
505
506 regs[E_D0_REGNUM + dN] = regs[E_D0_REGNUM + dM];
507
508 pc += 1;
509 }
510 /* mov aM, dN */
511 else if (instr[0] == 0xf1 && (instr[1] & 0xf0) == 0xd0)
512 {
513 int dN = instr[1] & 0x03;
514 int aM = (instr[1] & 0x0c) >> 2;
515
516 regs[E_D0_REGNUM + dN] = regs[E_A0_REGNUM + aM];
517
518 pc += 2;
519 }
520 /* mov dM, aN */
521 else if (instr[0] == 0xf1 && (instr[1] & 0xf0) == 0xe0)
522 {
523 int aN = instr[1] & 0x03;
524 int dM = (instr[1] & 0x0c) >> 2;
525
526 regs[E_A0_REGNUM + aN] = regs[E_D0_REGNUM + dM];
527
528 pc += 2;
529 }
530 /* add imm8, SP */
531 else if (instr[0] == 0xf8 && instr[1] == 0xfe)
532 {
533 gdb_byte buf[1];
534 LONGEST imm8;
535
536
537 status = target_read_memory (pc + 2, buf, 1);
538 if (status != 0)
539 break;
540
541 imm8 = extract_signed_integer (buf, 1, byte_order);
542 regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], imm8);
543
544 pc += 3;
545 /* Stack pointer adjustments are frame related. */
546 after_last_frame_setup_insn = pc;
547 }
548 /* add imm16, SP */
549 else if (instr[0] == 0xfa && instr[1] == 0xfe)
550 {
551 gdb_byte buf[2];
552 LONGEST imm16;
553
554 status = target_read_memory (pc + 2, buf, 2);
555 if (status != 0)
556 break;
557
558 imm16 = extract_signed_integer (buf, 2, byte_order);
559 regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], imm16);
560
561 pc += 4;
562 /* Stack pointer adjustments are frame related. */
563 after_last_frame_setup_insn = pc;
564 }
565 /* add imm32, SP */
566 else if (instr[0] == 0xfc && instr[1] == 0xfe)
567 {
568 gdb_byte buf[4];
569 LONGEST imm32;
570
571 status = target_read_memory (pc + 2, buf, 4);
572 if (status != 0)
573 break;
574
575
576 imm32 = extract_signed_integer (buf, 4, byte_order);
577 regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], imm32);
578
579 pc += 6;
580 /* Stack pointer adjustments are frame related. */
581 after_last_frame_setup_insn = pc;
582 }
583 /* add imm8, aN */
584 else if ((instr[0] & 0xfc) == 0x20)
585 {
586 int aN;
587 LONGEST imm8;
588
589 aN = instr[0] & 0x03;
590 imm8 = extract_signed_integer (&instr[1], 1, byte_order);
591
592 regs[E_A0_REGNUM + aN] = pv_add_constant (regs[E_A0_REGNUM + aN],
593 imm8);
594
595 pc += 2;
596 }
597 /* add imm16, aN */
598 else if (instr[0] == 0xfa && (instr[1] & 0xfc) == 0xd0)
599 {
600 int aN;
601 LONGEST imm16;
602 gdb_byte buf[2];
603
604 aN = instr[1] & 0x03;
605
606 status = target_read_memory (pc + 2, buf, 2);
607 if (status != 0)
608 break;
609
610
611 imm16 = extract_signed_integer (buf, 2, byte_order);
612
613 regs[E_A0_REGNUM + aN] = pv_add_constant (regs[E_A0_REGNUM + aN],
614 imm16);
615
616 pc += 4;
617 }
618 /* add imm32, aN */
619 else if (instr[0] == 0xfc && (instr[1] & 0xfc) == 0xd0)
620 {
621 int aN;
622 LONGEST imm32;
623 gdb_byte buf[4];
624
625 aN = instr[1] & 0x03;
626
627 status = target_read_memory (pc + 2, buf, 4);
628 if (status != 0)
629 break;
630
631 imm32 = extract_signed_integer (buf, 2, byte_order);
632
633 regs[E_A0_REGNUM + aN] = pv_add_constant (regs[E_A0_REGNUM + aN],
634 imm32);
635 pc += 6;
636 }
637 /* fmov fsM, (rN) */
638 else if (instr[0] == 0xf9 && (instr[1] & 0xfd) == 0x30)
639 {
640 int fsM, sM, Y, rN;
641 gdb_byte buf[1];
642
643 Y = (instr[1] & 0x02) >> 1;
644
645 status = target_read_memory (pc + 2, buf, 1);
646 if (status != 0)
647 break;
648
649 sM = (buf[0] & 0xf0) >> 4;
650 rN = buf[0] & 0x0f;
651 fsM = (Y << 4) | sM;
652
653 stack.store (regs[translate_rreg (rN)], 4,
654 regs[E_FS0_REGNUM + fsM]);
655
656 pc += 3;
657 }
658 /* fmov fsM, (sp) */
659 else if (instr[0] == 0xf9 && (instr[1] & 0xfd) == 0x34)
660 {
661 int fsM, sM, Y;
662 gdb_byte buf[1];
663
664 Y = (instr[1] & 0x02) >> 1;
665
666 status = target_read_memory (pc + 2, buf, 1);
667 if (status != 0)
668 break;
669
670 sM = (buf[0] & 0xf0) >> 4;
671 fsM = (Y << 4) | sM;
672
673 stack.store (regs[E_SP_REGNUM], 4,
674 regs[E_FS0_REGNUM + fsM]);
675
676 pc += 3;
677 }
678 /* fmov fsM, (rN, rI) */
679 else if (instr[0] == 0xfb && instr[1] == 0x37)
680 {
681 int fsM, sM, Z, rN, rI;
682 gdb_byte buf[2];
683
684
685 status = target_read_memory (pc + 2, buf, 2);
686 if (status != 0)
687 break;
688
689 rI = (buf[0] & 0xf0) >> 4;
690 rN = buf[0] & 0x0f;
691 sM = (buf[1] & 0xf0) >> 4;
692 Z = (buf[1] & 0x02) >> 1;
693 fsM = (Z << 4) | sM;
694
695 stack.store (pv_add (regs[translate_rreg (rN)],
696 regs[translate_rreg (rI)]),
697 4, regs[E_FS0_REGNUM + fsM]);
698
699 pc += 4;
700 }
701 /* fmov fsM, (d8, rN) */
702 else if (instr[0] == 0xfb && (instr[1] & 0xfd) == 0x30)
703 {
704 int fsM, sM, Y, rN;
705 LONGEST d8;
706 gdb_byte buf[2];
707
708 Y = (instr[1] & 0x02) >> 1;
709
710 status = target_read_memory (pc + 2, buf, 2);
711 if (status != 0)
712 break;
713
714 sM = (buf[0] & 0xf0) >> 4;
715 rN = buf[0] & 0x0f;
716 fsM = (Y << 4) | sM;
717 d8 = extract_signed_integer (&buf[1], 1, byte_order);
718
719 stack.store (pv_add_constant (regs[translate_rreg (rN)], d8),
720 4, regs[E_FS0_REGNUM + fsM]);
721
722 pc += 4;
723 }
724 /* fmov fsM, (d24, rN) */
725 else if (instr[0] == 0xfd && (instr[1] & 0xfd) == 0x30)
726 {
727 int fsM, sM, Y, rN;
728 LONGEST d24;
729 gdb_byte buf[4];
730
731 Y = (instr[1] & 0x02) >> 1;
732
733 status = target_read_memory (pc + 2, buf, 4);
734 if (status != 0)
735 break;
736
737 sM = (buf[0] & 0xf0) >> 4;
738 rN = buf[0] & 0x0f;
739 fsM = (Y << 4) | sM;
740 d24 = extract_signed_integer (&buf[1], 3, byte_order);
741
742 stack.store (pv_add_constant (regs[translate_rreg (rN)], d24),
743 4, regs[E_FS0_REGNUM + fsM]);
744
745 pc += 6;
746 }
747 /* fmov fsM, (d32, rN) */
748 else if (instr[0] == 0xfe && (instr[1] & 0xfd) == 0x30)
749 {
750 int fsM, sM, Y, rN;
751 LONGEST d32;
752 gdb_byte buf[5];
753
754 Y = (instr[1] & 0x02) >> 1;
755
756 status = target_read_memory (pc + 2, buf, 5);
757 if (status != 0)
758 break;
759
760 sM = (buf[0] & 0xf0) >> 4;
761 rN = buf[0] & 0x0f;
762 fsM = (Y << 4) | sM;
763 d32 = extract_signed_integer (&buf[1], 4, byte_order);
764
765 stack.store (pv_add_constant (regs[translate_rreg (rN)], d32),
766 4, regs[E_FS0_REGNUM + fsM]);
767
768 pc += 7;
769 }
770 /* fmov fsM, (d8, SP) */
771 else if (instr[0] == 0xfb && (instr[1] & 0xfd) == 0x34)
772 {
773 int fsM, sM, Y;
774 LONGEST d8;
775 gdb_byte buf[2];
776
777 Y = (instr[1] & 0x02) >> 1;
778
779 status = target_read_memory (pc + 2, buf, 2);
780 if (status != 0)
781 break;
782
783 sM = (buf[0] & 0xf0) >> 4;
784 fsM = (Y << 4) | sM;
785 d8 = extract_signed_integer (&buf[1], 1, byte_order);
786
787 stack.store (pv_add_constant (regs[E_SP_REGNUM], d8),
788 4, regs[E_FS0_REGNUM + fsM]);
789
790 pc += 4;
791 }
792 /* fmov fsM, (d24, SP) */
793 else if (instr[0] == 0xfd && (instr[1] & 0xfd) == 0x34)
794 {
795 int fsM, sM, Y;
796 LONGEST d24;
797 gdb_byte buf[4];
798
799 Y = (instr[1] & 0x02) >> 1;
800
801 status = target_read_memory (pc + 2, buf, 4);
802 if (status != 0)
803 break;
804
805 sM = (buf[0] & 0xf0) >> 4;
806 fsM = (Y << 4) | sM;
807 d24 = extract_signed_integer (&buf[1], 3, byte_order);
808
809 stack.store (pv_add_constant (regs[E_SP_REGNUM], d24),
810 4, regs[E_FS0_REGNUM + fsM]);
811
812 pc += 6;
813 }
814 /* fmov fsM, (d32, SP) */
815 else if (instr[0] == 0xfe && (instr[1] & 0xfd) == 0x34)
816 {
817 int fsM, sM, Y;
818 LONGEST d32;
819 gdb_byte buf[5];
820
821 Y = (instr[1] & 0x02) >> 1;
822
823 status = target_read_memory (pc + 2, buf, 5);
824 if (status != 0)
825 break;
826
827 sM = (buf[0] & 0xf0) >> 4;
828 fsM = (Y << 4) | sM;
829 d32 = extract_signed_integer (&buf[1], 4, byte_order);
830
831 stack.store (pv_add_constant (regs[E_SP_REGNUM], d32),
832 4, regs[E_FS0_REGNUM + fsM]);
833
834 pc += 7;
835 }
836 /* fmov fsM, (rN+) */
837 else if (instr[0] == 0xf9 && (instr[1] & 0xfd) == 0x31)
838 {
839 int fsM, sM, Y, rN, rN_regnum;
840 gdb_byte buf[1];
841
842 Y = (instr[1] & 0x02) >> 1;
843
844 status = target_read_memory (pc + 2, buf, 1);
845 if (status != 0)
846 break;
847
848 sM = (buf[0] & 0xf0) >> 4;
849 rN = buf[0] & 0x0f;
850 fsM = (Y << 4) | sM;
851
852 rN_regnum = translate_rreg (rN);
853
854 stack.store (regs[rN_regnum], 4,
855 regs[E_FS0_REGNUM + fsM]);
856 regs[rN_regnum] = pv_add_constant (regs[rN_regnum], 4);
857
858 pc += 3;
859 }
860 /* fmov fsM, (rN+, imm8) */
861 else if (instr[0] == 0xfb && (instr[1] & 0xfd) == 0x31)
862 {
863 int fsM, sM, Y, rN, rN_regnum;
864 LONGEST imm8;
865 gdb_byte buf[2];
866
867 Y = (instr[1] & 0x02) >> 1;
868
869 status = target_read_memory (pc + 2, buf, 2);
870 if (status != 0)
871 break;
872
873 sM = (buf[0] & 0xf0) >> 4;
874 rN = buf[0] & 0x0f;
875 fsM = (Y << 4) | sM;
876 imm8 = extract_signed_integer (&buf[1], 1, byte_order);
877
878 rN_regnum = translate_rreg (rN);
879
880 stack.store (regs[rN_regnum], 4, regs[E_FS0_REGNUM + fsM]);
881 regs[rN_regnum] = pv_add_constant (regs[rN_regnum], imm8);
882
883 pc += 4;
884 }
885 /* fmov fsM, (rN+, imm24) */
886 else if (instr[0] == 0xfd && (instr[1] & 0xfd) == 0x31)
887 {
888 int fsM, sM, Y, rN, rN_regnum;
889 LONGEST imm24;
890 gdb_byte buf[4];
891
892 Y = (instr[1] & 0x02) >> 1;
893
894 status = target_read_memory (pc + 2, buf, 4);
895 if (status != 0)
896 break;
897
898 sM = (buf[0] & 0xf0) >> 4;
899 rN = buf[0] & 0x0f;
900 fsM = (Y << 4) | sM;
901 imm24 = extract_signed_integer (&buf[1], 3, byte_order);
902
903 rN_regnum = translate_rreg (rN);
904
905 stack.store (regs[rN_regnum], 4, regs[E_FS0_REGNUM + fsM]);
906 regs[rN_regnum] = pv_add_constant (regs[rN_regnum], imm24);
907
908 pc += 6;
909 }
910 /* fmov fsM, (rN+, imm32) */
911 else if (instr[0] == 0xfe && (instr[1] & 0xfd) == 0x31)
912 {
913 int fsM, sM, Y, rN, rN_regnum;
914 LONGEST imm32;
915 gdb_byte buf[5];
916
917 Y = (instr[1] & 0x02) >> 1;
918
919 status = target_read_memory (pc + 2, buf, 5);
920 if (status != 0)
921 break;
922
923 sM = (buf[0] & 0xf0) >> 4;
924 rN = buf[0] & 0x0f;
925 fsM = (Y << 4) | sM;
926 imm32 = extract_signed_integer (&buf[1], 4, byte_order);
927
928 rN_regnum = translate_rreg (rN);
929
930 stack.store (regs[rN_regnum], 4, regs[E_FS0_REGNUM + fsM]);
931 regs[rN_regnum] = pv_add_constant (regs[rN_regnum], imm32);
932
933 pc += 7;
934 }
935 /* mov imm8, aN */
936 else if ((instr[0] & 0xf0) == 0x90)
937 {
938 int aN = instr[0] & 0x03;
939 LONGEST imm8;
940
941 imm8 = extract_signed_integer (&instr[1], 1, byte_order);
942
943 regs[E_A0_REGNUM + aN] = pv_constant (imm8);
944 pc += 2;
945 }
946 /* mov imm16, aN */
947 else if ((instr[0] & 0xfc) == 0x24)
948 {
949 int aN = instr[0] & 0x03;
950 gdb_byte buf[2];
951 LONGEST imm16;
952
953 status = target_read_memory (pc + 1, buf, 2);
954 if (status != 0)
955 break;
956
957 imm16 = extract_signed_integer (buf, 2, byte_order);
958 regs[E_A0_REGNUM + aN] = pv_constant (imm16);
959 pc += 3;
960 }
961 /* mov imm32, aN */
962 else if (instr[0] == 0xfc && ((instr[1] & 0xfc) == 0xdc))
963 {
964 int aN = instr[1] & 0x03;
965 gdb_byte buf[4];
966 LONGEST imm32;
967
968 status = target_read_memory (pc + 2, buf, 4);
969 if (status != 0)
970 break;
971
972 imm32 = extract_signed_integer (buf, 4, byte_order);
973 regs[E_A0_REGNUM + aN] = pv_constant (imm32);
974 pc += 6;
975 }
976 /* mov imm8, dN */
977 else if ((instr[0] & 0xf0) == 0x80)
978 {
979 int dN = instr[0] & 0x03;
980 LONGEST imm8;
981
982 imm8 = extract_signed_integer (&instr[1], 1, byte_order);
983
984 regs[E_D0_REGNUM + dN] = pv_constant (imm8);
985 pc += 2;
986 }
987 /* mov imm16, dN */
988 else if ((instr[0] & 0xfc) == 0x2c)
989 {
990 int dN = instr[0] & 0x03;
991 gdb_byte buf[2];
992 LONGEST imm16;
993
994 status = target_read_memory (pc + 1, buf, 2);
995 if (status != 0)
996 break;
997
998 imm16 = extract_signed_integer (buf, 2, byte_order);
999 regs[E_D0_REGNUM + dN] = pv_constant (imm16);
1000 pc += 3;
1001 }
1002 /* mov imm32, dN */
1003 else if (instr[0] == 0xfc && ((instr[1] & 0xfc) == 0xcc))
1004 {
1005 int dN = instr[1] & 0x03;
1006 gdb_byte buf[4];
1007 LONGEST imm32;
1008
1009 status = target_read_memory (pc + 2, buf, 4);
1010 if (status != 0)
1011 break;
1012
1013 imm32 = extract_signed_integer (buf, 4, byte_order);
1014 regs[E_D0_REGNUM + dN] = pv_constant (imm32);
1015 pc += 6;
1016 }
1017 else
1018 {
1019 /* We've hit some instruction that we don't recognize. Hopefully,
1020 we have enough to do prologue analysis. */
1021 break;
1022 }
1023 }
1024
1025 /* Is the frame size (offset, really) a known constant? */
1026 if (pv_is_register (regs[E_SP_REGNUM], E_SP_REGNUM))
1027 result->frame_size = regs[E_SP_REGNUM].k;
1028
1029 /* Was the frame pointer initialized? */
1030 if (pv_is_register (regs[E_A3_REGNUM], E_SP_REGNUM))
1031 {
1032 result->has_frame_ptr = 1;
1033 result->frame_ptr_offset = regs[E_A3_REGNUM].k;
1034 }
1035
1036 /* Record where all the registers were saved. */
1037 stack.scan (check_for_saved, (void *) result);
1038
1039 result->prologue_end = after_last_frame_setup_insn;
1040 }
1041
1042 /* Function: skip_prologue
1043 Return the address of the first inst past the prologue of the function. */
1044
1045 static CORE_ADDR
1046 mn10300_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1047 {
1048 const char *name;
1049 CORE_ADDR func_addr, func_end;
1050 struct mn10300_prologue p;
1051
1052 /* Try to find the extent of the function that contains PC. */
1053 if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
1054 return pc;
1055
1056 mn10300_analyze_prologue (gdbarch, pc, func_end, &p);
1057 return p.prologue_end;
1058 }
1059
1060 /* Wrapper for mn10300_analyze_prologue: find the function start;
1061 use the current frame PC as the limit, then
1062 invoke mn10300_analyze_prologue and return its result. */
1063 static struct mn10300_prologue *
1064 mn10300_analyze_frame_prologue (struct frame_info *this_frame,
1065 void **this_prologue_cache)
1066 {
1067 if (!*this_prologue_cache)
1068 {
1069 CORE_ADDR func_start, stop_addr;
1070
1071 *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct mn10300_prologue);
1072
1073 func_start = get_frame_func (this_frame);
1074 stop_addr = get_frame_pc (this_frame);
1075
1076 /* If we couldn't find any function containing the PC, then
1077 just initialize the prologue cache, but don't do anything. */
1078 if (!func_start)
1079 stop_addr = func_start;
1080
1081 mn10300_analyze_prologue (get_frame_arch (this_frame),
1082 func_start, stop_addr,
1083 ((struct mn10300_prologue *)
1084 *this_prologue_cache));
1085 }
1086
1087 return (struct mn10300_prologue *) *this_prologue_cache;
1088 }
1089
1090 /* Given the next frame and a prologue cache, return this frame's
1091 base. */
1092 static CORE_ADDR
1093 mn10300_frame_base (struct frame_info *this_frame, void **this_prologue_cache)
1094 {
1095 struct mn10300_prologue *p
1096 = mn10300_analyze_frame_prologue (this_frame, this_prologue_cache);
1097
1098 /* In functions that use alloca, the distance between the stack
1099 pointer and the frame base varies dynamically, so we can't use
1100 the SP plus static information like prologue analysis to find the
1101 frame base. However, such functions must have a frame pointer,
1102 to be able to restore the SP on exit. So whenever we do have a
1103 frame pointer, use that to find the base. */
1104 if (p->has_frame_ptr)
1105 {
1106 CORE_ADDR fp = get_frame_register_unsigned (this_frame, E_A3_REGNUM);
1107 return fp - p->frame_ptr_offset;
1108 }
1109 else
1110 {
1111 CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
1112 return sp - p->frame_size;
1113 }
1114 }
1115
1116 /* Here is a dummy implementation. */
1117 static struct frame_id
1118 mn10300_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1119 {
1120 CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
1121 CORE_ADDR pc = get_frame_register_unsigned (this_frame, E_PC_REGNUM);
1122 return frame_id_build (sp, pc);
1123 }
1124
1125 static void
1126 mn10300_frame_this_id (struct frame_info *this_frame,
1127 void **this_prologue_cache,
1128 struct frame_id *this_id)
1129 {
1130 *this_id = frame_id_build (mn10300_frame_base (this_frame,
1131 this_prologue_cache),
1132 get_frame_func (this_frame));
1133
1134 }
1135
1136 static struct value *
1137 mn10300_frame_prev_register (struct frame_info *this_frame,
1138 void **this_prologue_cache, int regnum)
1139 {
1140 struct mn10300_prologue *p
1141 = mn10300_analyze_frame_prologue (this_frame, this_prologue_cache);
1142 CORE_ADDR frame_base = mn10300_frame_base (this_frame, this_prologue_cache);
1143
1144 if (regnum == E_SP_REGNUM)
1145 return frame_unwind_got_constant (this_frame, regnum, frame_base);
1146
1147 /* If prologue analysis says we saved this register somewhere,
1148 return a description of the stack slot holding it. */
1149 if (p->reg_offset[regnum] != 1)
1150 return frame_unwind_got_memory (this_frame, regnum,
1151 frame_base + p->reg_offset[regnum]);
1152
1153 /* Otherwise, presume we haven't changed the value of this
1154 register, and get it from the next frame. */
1155 return frame_unwind_got_register (this_frame, regnum, regnum);
1156 }
1157
1158 static const struct frame_unwind mn10300_frame_unwind = {
1159 NORMAL_FRAME,
1160 default_frame_unwind_stop_reason,
1161 mn10300_frame_this_id,
1162 mn10300_frame_prev_register,
1163 NULL,
1164 default_frame_sniffer
1165 };
1166
1167 static CORE_ADDR
1168 mn10300_unwind_pc (struct gdbarch *gdbarch, struct frame_info *this_frame)
1169 {
1170 ULONGEST pc;
1171
1172 pc = frame_unwind_register_unsigned (this_frame, E_PC_REGNUM);
1173 return pc;
1174 }
1175
1176 static CORE_ADDR
1177 mn10300_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame)
1178 {
1179 ULONGEST sp;
1180
1181 sp = frame_unwind_register_unsigned (this_frame, E_SP_REGNUM);
1182 return sp;
1183 }
1184
1185 static void
1186 mn10300_frame_unwind_init (struct gdbarch *gdbarch)
1187 {
1188 dwarf2_append_unwinders (gdbarch);
1189 frame_unwind_append_unwinder (gdbarch, &mn10300_frame_unwind);
1190 set_gdbarch_dummy_id (gdbarch, mn10300_dummy_id);
1191 set_gdbarch_unwind_pc (gdbarch, mn10300_unwind_pc);
1192 set_gdbarch_unwind_sp (gdbarch, mn10300_unwind_sp);
1193 }
1194
1195 /* Function: push_dummy_call
1196 *
1197 * Set up machine state for a target call, including
1198 * function arguments, stack, return address, etc.
1199 *
1200 */
1201
1202 static CORE_ADDR
1203 mn10300_push_dummy_call (struct gdbarch *gdbarch,
1204 struct value *target_func,
1205 struct regcache *regcache,
1206 CORE_ADDR bp_addr,
1207 int nargs, struct value **args,
1208 CORE_ADDR sp,
1209 int struct_return,
1210 CORE_ADDR struct_addr)
1211 {
1212 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1213 const int push_size = register_size (gdbarch, E_PC_REGNUM);
1214 int regs_used;
1215 int len, arg_len;
1216 int stack_offset = 0;
1217 int argnum;
1218 const gdb_byte *val;
1219 gdb_byte valbuf[MN10300_MAX_REGISTER_SIZE];
1220
1221 /* This should be a nop, but align the stack just in case something
1222 went wrong. Stacks are four byte aligned on the mn10300. */
1223 sp &= ~3;
1224
1225 /* Now make space on the stack for the args.
1226
1227 XXX This doesn't appear to handle pass-by-invisible reference
1228 arguments. */
1229 regs_used = struct_return ? 1 : 0;
1230 for (len = 0, argnum = 0; argnum < nargs; argnum++)
1231 {
1232 arg_len = (TYPE_LENGTH (value_type (args[argnum])) + 3) & ~3;
1233 while (regs_used < 2 && arg_len > 0)
1234 {
1235 regs_used++;
1236 arg_len -= push_size;
1237 }
1238 len += arg_len;
1239 }
1240
1241 /* Allocate stack space. */
1242 sp -= len;
1243
1244 if (struct_return)
1245 {
1246 regs_used = 1;
1247 regcache_cooked_write_unsigned (regcache, E_D0_REGNUM, struct_addr);
1248 }
1249 else
1250 regs_used = 0;
1251
1252 /* Push all arguments onto the stack. */
1253 for (argnum = 0; argnum < nargs; argnum++)
1254 {
1255 /* FIXME what about structs? Unions? */
1256 if (TYPE_CODE (value_type (*args)) == TYPE_CODE_STRUCT
1257 && TYPE_LENGTH (value_type (*args)) > 8)
1258 {
1259 /* Change to pointer-to-type. */
1260 arg_len = push_size;
1261 gdb_assert (push_size <= MN10300_MAX_REGISTER_SIZE);
1262 store_unsigned_integer (valbuf, push_size, byte_order,
1263 value_address (*args));
1264 val = &valbuf[0];
1265 }
1266 else
1267 {
1268 arg_len = TYPE_LENGTH (value_type (*args));
1269 val = value_contents (*args);
1270 }
1271
1272 while (regs_used < 2 && arg_len > 0)
1273 {
1274 regcache_cooked_write_unsigned (regcache, regs_used,
1275 extract_unsigned_integer (val, push_size, byte_order));
1276 val += push_size;
1277 arg_len -= push_size;
1278 regs_used++;
1279 }
1280
1281 while (arg_len > 0)
1282 {
1283 write_memory (sp + stack_offset, val, push_size);
1284 arg_len -= push_size;
1285 val += push_size;
1286 stack_offset += push_size;
1287 }
1288
1289 args++;
1290 }
1291
1292 /* Make space for the flushback area. */
1293 sp -= 8;
1294
1295 /* Push the return address that contains the magic breakpoint. */
1296 sp -= 4;
1297 write_memory_unsigned_integer (sp, push_size, byte_order, bp_addr);
1298
1299 /* The CPU also writes the return address always into the
1300 MDR register on "call". */
1301 regcache_cooked_write_unsigned (regcache, E_MDR_REGNUM, bp_addr);
1302
1303 /* Update $sp. */
1304 regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
1305
1306 /* On the mn10300, it's possible to move some of the stack adjustment
1307 and saving of the caller-save registers out of the prologue and
1308 into the call sites. (When using gcc, this optimization can
1309 occur when using the -mrelax switch.) If this occurs, the dwarf2
1310 info will reflect this fact. We can test to see if this is the
1311 case by creating a new frame using the current stack pointer and
1312 the address of the function that we're about to call. We then
1313 unwind SP and see if it's different than the SP of our newly
1314 created frame. If the SP values are the same, the caller is not
1315 expected to allocate any additional stack. On the other hand, if
1316 the SP values are different, the difference determines the
1317 additional stack that must be allocated.
1318
1319 Note that we don't update the return value though because that's
1320 the value of the stack just after pushing the arguments, but prior
1321 to performing the call. This value is needed in order to
1322 construct the frame ID of the dummy call. */
1323 {
1324 CORE_ADDR func_addr = find_function_addr (target_func, NULL);
1325 CORE_ADDR unwound_sp
1326 = mn10300_unwind_sp (gdbarch, create_new_frame (sp, func_addr));
1327 if (sp != unwound_sp)
1328 regcache_cooked_write_unsigned (regcache, E_SP_REGNUM,
1329 sp - (unwound_sp - sp));
1330 }
1331
1332 return sp;
1333 }
1334
1335 /* If DWARF2 is a register number appearing in Dwarf2 debug info, then
1336 mn10300_dwarf2_reg_to_regnum (DWARF2) is the corresponding GDB
1337 register number. Why don't Dwarf2 and GDB use the same numbering?
1338 Who knows? But since people have object files lying around with
1339 the existing Dwarf2 numbering, and other people have written stubs
1340 to work with the existing GDB, neither of them can change. So we
1341 just have to cope. */
1342 static int
1343 mn10300_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2)
1344 {
1345 /* This table is supposed to be shaped like the gdbarch_register_name
1346 initializer in gcc/config/mn10300/mn10300.h. Registers which
1347 appear in GCC's numbering, but have no counterpart in GDB's
1348 world, are marked with a -1. */
1349 static int dwarf2_to_gdb[] = {
1350 E_D0_REGNUM, E_D1_REGNUM, E_D2_REGNUM, E_D3_REGNUM,
1351 E_A0_REGNUM, E_A1_REGNUM, E_A2_REGNUM, E_A3_REGNUM,
1352 -1, E_SP_REGNUM,
1353
1354 E_E0_REGNUM, E_E1_REGNUM, E_E2_REGNUM, E_E3_REGNUM,
1355 E_E4_REGNUM, E_E5_REGNUM, E_E6_REGNUM, E_E7_REGNUM,
1356
1357 E_FS0_REGNUM + 0, E_FS0_REGNUM + 1, E_FS0_REGNUM + 2, E_FS0_REGNUM + 3,
1358 E_FS0_REGNUM + 4, E_FS0_REGNUM + 5, E_FS0_REGNUM + 6, E_FS0_REGNUM + 7,
1359
1360 E_FS0_REGNUM + 8, E_FS0_REGNUM + 9, E_FS0_REGNUM + 10, E_FS0_REGNUM + 11,
1361 E_FS0_REGNUM + 12, E_FS0_REGNUM + 13, E_FS0_REGNUM + 14, E_FS0_REGNUM + 15,
1362
1363 E_FS0_REGNUM + 16, E_FS0_REGNUM + 17, E_FS0_REGNUM + 18, E_FS0_REGNUM + 19,
1364 E_FS0_REGNUM + 20, E_FS0_REGNUM + 21, E_FS0_REGNUM + 22, E_FS0_REGNUM + 23,
1365
1366 E_FS0_REGNUM + 24, E_FS0_REGNUM + 25, E_FS0_REGNUM + 26, E_FS0_REGNUM + 27,
1367 E_FS0_REGNUM + 28, E_FS0_REGNUM + 29, E_FS0_REGNUM + 30, E_FS0_REGNUM + 31,
1368
1369 E_MDR_REGNUM, E_PSW_REGNUM, E_PC_REGNUM
1370 };
1371
1372 if (dwarf2 < 0
1373 || dwarf2 >= ARRAY_SIZE (dwarf2_to_gdb))
1374 return -1;
1375
1376 return dwarf2_to_gdb[dwarf2];
1377 }
1378
1379 static struct gdbarch *
1380 mn10300_gdbarch_init (struct gdbarch_info info,
1381 struct gdbarch_list *arches)
1382 {
1383 struct gdbarch *gdbarch;
1384 struct gdbarch_tdep *tdep;
1385 int num_regs;
1386
1387 arches = gdbarch_list_lookup_by_info (arches, &info);
1388 if (arches != NULL)
1389 return arches->gdbarch;
1390
1391 tdep = XCNEW (struct gdbarch_tdep);
1392 gdbarch = gdbarch_alloc (&info, tdep);
1393
1394 switch (info.bfd_arch_info->mach)
1395 {
1396 case 0:
1397 case bfd_mach_mn10300:
1398 set_gdbarch_register_name (gdbarch, mn10300_generic_register_name);
1399 tdep->am33_mode = 0;
1400 num_regs = 32;
1401 break;
1402 case bfd_mach_am33:
1403 set_gdbarch_register_name (gdbarch, am33_register_name);
1404 tdep->am33_mode = 1;
1405 num_regs = 32;
1406 break;
1407 case bfd_mach_am33_2:
1408 set_gdbarch_register_name (gdbarch, am33_2_register_name);
1409 tdep->am33_mode = 2;
1410 num_regs = 64;
1411 set_gdbarch_fp0_regnum (gdbarch, 32);
1412 break;
1413 default:
1414 internal_error (__FILE__, __LINE__,
1415 _("mn10300_gdbarch_init: Unknown mn10300 variant"));
1416 break;
1417 }
1418
1419 /* By default, chars are unsigned. */
1420 set_gdbarch_char_signed (gdbarch, 0);
1421
1422 /* Registers. */
1423 set_gdbarch_num_regs (gdbarch, num_regs);
1424 set_gdbarch_register_type (gdbarch, mn10300_register_type);
1425 set_gdbarch_skip_prologue (gdbarch, mn10300_skip_prologue);
1426 set_gdbarch_read_pc (gdbarch, mn10300_read_pc);
1427 set_gdbarch_write_pc (gdbarch, mn10300_write_pc);
1428 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
1429 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
1430 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, mn10300_dwarf2_reg_to_regnum);
1431
1432 /* Stack unwinding. */
1433 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1434 /* Breakpoints. */
1435 set_gdbarch_breakpoint_kind_from_pc (gdbarch,
1436 mn10300_breakpoint::kind_from_pc);
1437 set_gdbarch_sw_breakpoint_from_kind (gdbarch,
1438 mn10300_breakpoint::bp_from_kind);
1439 /* decr_pc_after_break? */
1440
1441 /* Stage 2 */
1442 set_gdbarch_return_value (gdbarch, mn10300_return_value);
1443
1444 /* Stage 3 -- get target calls working. */
1445 set_gdbarch_push_dummy_call (gdbarch, mn10300_push_dummy_call);
1446 /* set_gdbarch_return_value (store, extract) */
1447
1448
1449 mn10300_frame_unwind_init (gdbarch);
1450
1451 /* Hook in ABI-specific overrides, if they have been registered. */
1452 gdbarch_init_osabi (info, gdbarch);
1453
1454 return gdbarch;
1455 }
1456
1457 /* Dump out the mn10300 specific architecture information. */
1458
1459 static void
1460 mn10300_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
1461 {
1462 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1463 fprintf_unfiltered (file, "mn10300_dump_tdep: am33_mode = %d\n",
1464 tdep->am33_mode);
1465 }
1466
1467 void
1468 _initialize_mn10300_tdep (void)
1469 {
1470 gdbarch_register (bfd_arch_mn10300, mn10300_gdbarch_init, mn10300_dump_tdep);
1471 }
1472
set_gdbarch_num_regs
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition: gdbarch.c:2050
gdbarch
Definition: gdbarch.c:127
E_SP_REGNUM
Definition: h8300-tdep.c:46
TYPE_CODE_BOOL
Definition: gdbtypes.h:164
TYPE_CODE_ARRAY
Definition: gdbtypes.h:104
frame_id_build
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:624
mn10300-tdep.h
mn10300_generic_register_name
static const char * mn10300_generic_register_name(struct gdbarch *gdbarch, int reg)
Definition: mn10300-tdep.c:263
TYPE_CODE_ENUM
Definition: gdbtypes.h:108
get_frame_pc
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2376
set_gdbarch_fp0_regnum
void set_gdbarch_fp0_regnum(struct gdbarch *gdbarch, int fp0_regnum)
Definition: gdbarch.c:2207
infcall.h
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
gdbarch_init_osabi
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: osabi.c:334
pv_add_constant
pv_t pv_add_constant(pv_t v, CORE_ADDR k)
Definition: prologue-value.c:105
movm_other_bit
Definition: mn10300-tdep.h:58
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
E_A3_REGNUM
Definition: mn10300-tdep.h:28
E_LIR_REGNUM
Definition: mn10300-tdep.h:33
BP_MANIPULATION
typedef BP_MANIPULATION(mn10300_break_insn)
Definition: mn10300-tdep.c:332
E_PC_REGNUM
Definition: h8300-tdep.c:48
set_gdbarch_write_pc
void set_gdbarch_write_pc(struct gdbarch *gdbarch, gdbarch_write_pc_ftype write_pc)
Definition: gdbarch.c:1943
check_for_saved
static void check_for_saved(void *result_untyped, pv_t addr, CORE_ADDR size, pv_t value)
Definition: mn10300-tdep.c:365
RETURN_VALUE_STRUCT_CONVENTION
Definition: defs.h:258
prologue-value.h
frame_unwind_register_unsigned
ULONGEST frame_unwind_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1279
TYPE_CODE_RANGE
Definition: gdbtypes.h:127
prologue_value
Definition: prologue-value.h:140
builtin_type
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:5217
TYPE_CODE_INT
Definition: gdbtypes.h:111
pv_is_register
int pv_is_register(pv_t a, int r)
Definition: prologue-value.c:216
memset
void * memset(T *s, int c, size_t n)=delete
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
TYPE_CODE_SET
Definition: gdbtypes.h:126
gdbarch_tdep
Definition: aarch64-tdep.h:55
return_value_convention
return_value_convention
Definition: defs.h:247
mn10300_dump_tdep
static void mn10300_dump_tdep(struct gdbarch *gdbarch, struct ui_file *file)
Definition: mn10300-tdep.c:1460
gdbarch_tdep::num_regs
int num_regs
Definition: m32c-tdep.c:113
frame_info
Definition: frame.c:85
mn10300_analyze_frame_prologue
static struct mn10300_prologue * mn10300_analyze_frame_prologue(struct frame_info *this_frame, void **this_prologue_cache)
Definition: mn10300-tdep.c:1064
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
mn10300_store_return_value
static void mn10300_store_return_value(struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
Definition: mn10300-tdep.c:171
_
#define _(String)
Definition: gdb_locale.h:35
gdbarch_info::bfd_arch_info
const struct bfd_arch_info * bfd_arch_info
Definition: gdbarch.h:1629
ui_file
Definition: ui-file.h:26
prologue_value::k
CORE_ADDR k
Definition: prologue-value.h:149
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
E_MCRH_REGNUM
Definition: mn10300-tdep.h:47
TYPE_CODE_RVALUE_REF
Definition: gdbtypes.h:158
defs.h
gdbarch_tdep
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
Definition: gdbarch.c:1491
E_MCVF_REGNUM
Definition: mn10300-tdep.h:49
TYPE_FIELD_TYPE
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1371
frame_unwind_append_unwinder
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:79
frame_info::this_id
struct frame_info::@60 this_id
pv_constant
pv_t pv_constant(CORE_ADDR k)
Definition: prologue-value.c:36
mn10300_prologue::prologue_end
CORE_ADDR prologue_end
Definition: mn10300-tdep.c:75
FRAME_OBSTACK_ZALLOC
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:678
arch-utils.h
frame_unwind_got_constant
struct value * frame_unwind_got_constant(struct frame_info *frame, int regnum, ULONGEST val)
Definition: frame-unwind.c:246
mn10300_dummy_id
static struct frame_id mn10300_dummy_id(struct gdbarch *gdbarch, struct frame_info *this_frame)
Definition: mn10300-tdep.c:1118
gdbarch_register
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep)
Definition: gdbarch.c:5257
mn10300_read_pc
static CORE_ADDR mn10300_read_pc(struct regcache *regcache)
Definition: mn10300-tdep.c:311
symtab.h
TYPE_CODE_TYPEDEF
Definition: gdbtypes.h:169
movm_exreg0_bit
Definition: mn10300-tdep.h:57
name
const char *const name
Definition: aarch64-tdep.c:76
E_E0_REGNUM
Definition: mn10300-tdep.h:36
mn10300_prologue::reg_offset
int reg_offset[MN10300_MAX_NUM_REGS]
Definition: mn10300-tdep.c:80
pvk_register
Definition: prologue-value.h:40
set_gdbarch_register_type
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype register_type)
Definition: gdbarch.c:2316
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
NORMAL_FRAME
Definition: frame.h:244
mn10300_unwind_sp
static CORE_ADDR mn10300_unwind_sp(struct gdbarch *gdbarch, struct frame_info *this_frame)
Definition: mn10300-tdep.c:1177
value_contents
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1407
TYPE_CODE_CHAR
Definition: gdbtypes.h:160
E_A2_REGNUM
Definition: mn10300-tdep.h:27
mn10300_break_insn
constexpr gdb_byte mn10300_break_insn[]
Definition: mn10300-tdep.c:330
value::reg
struct value::@186::@187 reg
AM33_MODE
#define AM33_MODE(gdbarch)
Definition: mn10300-tdep.h:79
mn10300_frame_this_id
static void mn10300_frame_this_id(struct frame_info *this_frame, void **this_prologue_cache, struct frame_id *this_id)
Definition: mn10300-tdep.c:1126
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
mn10300_dwarf2_reg_to_regnum
static int mn10300_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, int dwarf2)
Definition: mn10300-tdep.c:1343
osabi.h
movm_a3_bit
Definition: mn10300-tdep.h:59
regcache.h
set_gdbarch_sp_regnum
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
Definition: gdbarch.c:2156
mn10300_register_type
static struct type * mn10300_register_type(struct gdbarch *gdbarch, int reg)
Definition: mn10300-tdep.c:305
set_gdbarch_dummy_id
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype dummy_id)
Definition: gdbarch.c:2340
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
mn10300_type_align
static int mn10300_type_align(struct type *type)
Definition: mn10300-tdep.c:87
mn10300_analyze_prologue
static void mn10300_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR start_pc, CORE_ADDR limit_pc, struct mn10300_prologue *result)
Definition: mn10300-tdep.c:381
struct_return
struct_return
Definition: arm-tdep.h:88
frame.h
TYPE_CODE_FLT
Definition: gdbtypes.h:116
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
TYPE_CODE_UNION
Definition: gdbtypes.h:107
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
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
mn10300_frame_unwind
static const struct frame_unwind mn10300_frame_unwind
Definition: mn10300-tdep.c:1158
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
gdbarch_tdep::am33_mode
int am33_mode
Definition: mn10300-tdep.h:76
mn10300_use_struct_convention
static int mn10300_use_struct_convention(struct type *type)
Definition: mn10300-tdep.c:133
pv_area::store
void store(pv_t addr, CORE_ADDR size, pv_t value)
Definition: prologue-value.c:409
pv_area::scan
void scan(void(*func)(void *closure, pv_t addr, CORE_ADDR size, pv_t value), void *closure)
Definition: prologue-value.c:524
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
E_MDRQ_REGNUM
Definition: mn10300-tdep.h:35
set_gdbarch_read_pc
void set_gdbarch_read_pc(struct gdbarch *gdbarch, gdbarch_read_pc_ftype read_pc)
Definition: gdbarch.c:1919
pv_area
Definition: prologue-value.h:226
gdbarch_addr_bit
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1848
set_gdbarch_unwind_sp
void set_gdbarch_unwind_sp(struct gdbarch *gdbarch, gdbarch_unwind_sp_ftype unwind_sp)
Definition: gdbarch.c:3103
create_new_frame
struct frame_info * create_new_frame(CORE_ADDR addr, CORE_ADDR pc)
Definition: frame.c:1722
mn10300_frame_unwind_init
static void mn10300_frame_unwind_init(struct gdbarch *gdbarch)
Definition: mn10300-tdep.c:1186
mn10300_push_dummy_call
static CORE_ADDR mn10300_push_dummy_call(struct gdbarch *gdbarch, struct value *target_func, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
Definition: mn10300-tdep.c:1203
mn10300_prologue::gdbarch
struct gdbarch * gdbarch
Definition: mn10300-tdep.c:50
gdbarch_list::gdbarch
struct gdbarch * gdbarch
Definition: gdbarch.h:1622
regnum
int regnum
Definition: aarch64-tdep.c:77
frame_base
Definition: frame-base.h:58
E_D1_REGNUM
Definition: mn10300-tdep.h:22
get_frame_register_unsigned
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1308
movm_d2_bit
Definition: mn10300-tdep.h:62
E_E3_REGNUM
Definition: mn10300-tdep.h:39
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
frame-base.h
set_gdbarch_breakpoint_kind_from_pc
void set_gdbarch_breakpoint_kind_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_pc_ftype breakpoint_kind_from_pc)
Definition: gdbarch.c:2871
_initialize_mn10300_tdep
void _initialize_mn10300_tdep(void)
Definition: mn10300-tdep.c:1468
TYPE_CODE_REF
Definition: gdbtypes.h:156
mn10300_return_value
static enum return_value_convention mn10300_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: mn10300-tdep.c:238
reg
Definition: regdef.h:22
E_E1_REGNUM
Definition: mn10300-tdep.h:37
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
am33_register_name
static const char * am33_register_name(struct gdbarch *gdbarch, int reg)
Definition: mn10300-tdep.c:276
mn10300_prologue
Definition: mn10300-tdep.c:47
value
Definition: value.c:169
E_D2_REGNUM
Definition: mn10300-tdep.h:23
register_name
static const char * register_name(int reg, const char **regs, long sizeof_regs)
Definition: mn10300-tdep.c:254
translate_rreg
static int translate_rreg(int rreg)
Definition: mn10300-tdep.c:347
regcache_raw_write_part
void regcache_raw_write_part(struct regcache *regcache, int regnum, int offset, int len, const gdb_byte *buf)
Definition: regcache.c:957
TYPE_CODE_PTR
Definition: gdbtypes.h:84
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
mn10300_frame_base
static CORE_ADDR mn10300_frame_base(struct frame_info *this_frame, void **this_prologue_cache)
Definition: mn10300-tdep.c:1093
movm_exreg1_bit
Definition: mn10300-tdep.h:56
set_gdbarch_char_signed
void set_gdbarch_char_signed(struct gdbarch *gdbarch, int char_signed)
Definition: gdbarch.c:1895
E_E7_REGNUM
Definition: mn10300-tdep.h:43
mn10300_gdbarch_init
static struct gdbarch * mn10300_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
Definition: mn10300-tdep.c:1380
dwarf2-frame.h
XCNEW
#define XCNEW(T)
Definition: poison.h:121
gdbcore.h
mn10300_frame_prev_register
static struct value * mn10300_frame_prev_register(struct frame_info *this_frame, void **this_prologue_cache, int regnum)
Definition: mn10300-tdep.c:1137
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
regcache_raw_read
enum register_status regcache_raw_read(struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: regcache.c:565
frame_unwind_got_register
struct value * frame_unwind_got_register(struct frame_info *frame, int regnum, int new_regnum)
Definition: frame-unwind.c:223
regcache_cooked_write_unsigned
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition: regcache.c:806
target_read_memory
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1370
find_function_addr
CORE_ADDR find_function_addr(struct value *function, struct type **retval_type)
Definition: infcall.c:250
mn10300_unwind_pc
static CORE_ADDR mn10300_unwind_pc(struct gdbarch *gdbarch, struct frame_info *this_frame)
Definition: mn10300-tdep.c:1168
E_E6_REGNUM
Definition: mn10300-tdep.h:42
E_A1_REGNUM
Definition: mn10300-tdep.h:26
TYPE_NFIELDS
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1239
mn10300_extract_return_value
static void mn10300_extract_return_value(struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, void *valbuf)
Definition: mn10300-tdep.c:199
movm_a2_bit
Definition: mn10300-tdep.h:60
mn10300_prologue::frame_size
int frame_size
Definition: mn10300-tdep.c:61
dwarf2_append_unwinders
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
Definition: dwarf2-frame.c:1384
mn10300_prologue::has_frame_ptr
int has_frame_ptr
Definition: mn10300-tdep.c:65
mn10300_write_pc
static void mn10300_write_pc(struct regcache *regcache, CORE_ADDR val)
Definition: mn10300-tdep.c:319
extract_signed_integer
static LONGEST extract_signed_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:570
target.h
E_LAR_REGNUM
Definition: mn10300-tdep.h:34
mn10300_prologue::frame_ptr_offset
int frame_ptr_offset
Definition: mn10300-tdep.c:70
value.h
frame_unwind
Definition: frame-unwind.h:144
MN10300_MAX_NUM_REGS
#define MN10300_MAX_NUM_REGS
Definition: mn10300-tdep.c:41
E_FS0_REGNUM
Definition: mn10300-tdep.h:51
mn10300_skip_prologue
static CORE_ADDR mn10300_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: mn10300-tdep.c:1046
gdbtypes.h
movm_exother_bit
Definition: mn10300-tdep.h:55
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
E_E2_REGNUM
Definition: mn10300-tdep.h:38
E_E4_REGNUM
Definition: mn10300-tdep.h:40
register_size
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:164
regcache
Definition: regcache.h:232
gdbarch_info
Definition: gdbarch.h:1626
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
E_MCRL_REGNUM
Definition: mn10300-tdep.h:48
set_gdbarch_return_value
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
Definition: gdbarch.c:2738
E_MDR_REGNUM
Definition: mn10300-tdep.h:31
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
movm_d3_bit
Definition: mn10300-tdep.h:61
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
E_D0_REGNUM
Definition: mn10300-tdep.h:21
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
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
value_address
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1529
RETURN_VALUE_REGISTER_CONVENTION
Definition: defs.h:251
set_gdbarch_pc_regnum
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
Definition: gdbarch.c:2173
pv_add
pv_t pv_add(pv_t a, pv_t b)
Definition: prologue-value.c:82
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
pv_register
pv_t pv_register(int reg, CORE_ADDR k)
Definition: prologue-value.c:49
size
size_t size
Definition: go32-nat.c:242
E_A0_REGNUM
Definition: mn10300-tdep.h:25
E_D3_REGNUM
Definition: mn10300-tdep.h:24
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
E_PSW_REGNUM
Definition: mn10300-tdep.h:32
E_E5_REGNUM
Definition: mn10300-tdep.h:41
MN10300_MAX_REGISTER_SIZE
#define MN10300_MAX_REGISTER_SIZE
Definition: mn10300-tdep.c:44
frame_id
Definition: frame.h:111
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
LONGEST
long long LONGEST
Definition: common-types.h:52
TYPE_CODE_COMPLEX
Definition: gdbtypes.h:167
store_unsigned_integer
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition: defs.h:604
am33_2_register_name
static const char * am33_2_register_name(struct gdbarch *gdbarch, int reg)
Definition: mn10300-tdep.c:288
builtin_type::builtin_int
struct type * builtin_int
Definition: gdbtypes.h:1503
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