1 /* Renesas M32C target-dependent code for GDB, the GNU debugger.
3 Copyright 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
24 #if defined (HAVE_STRING_H)
28 #include "gdb_assert.h"
31 #include "gdb/sim-m32c.h"
35 #include "arch-utils.h"
37 #include "frame-unwind.h"
38 #include "dwarf2-frame.h"
39 #include "dwarf2expr.h"
43 #include "reggroups.h"
44 #include "prologue-value.h"
48 /* The m32c tdep structure. */
50 static struct reggroup *m32c_dma_reggroup;
54 /* The type of a function that moves the value of REG between CACHE or
55 BUF --- in either direction. */
56 typedef void (m32c_move_reg_t) (struct m32c_reg *reg,
57 struct regcache *cache,
62 /* The name of this register. */
68 /* The architecture this register belongs to. */
71 /* Its GDB register number. */
74 /* Its sim register number. */
77 /* Its DWARF register number, or -1 if it doesn't have one. */
80 /* Register group memberships. */
81 unsigned int general_p : 1;
82 unsigned int dma_p : 1;
83 unsigned int system_p : 1;
84 unsigned int save_restore_p : 1;
86 /* Functions to read its value from a regcache, and write its value
88 m32c_move_reg_t *read, *write;
90 /* Data for READ and WRITE functions. The exact meaning depends on
91 the specific functions selected; see the comments for those
93 struct m32c_reg *rx, *ry;
98 /* An overestimate of the number of raw and pseudoregisters we will
99 have. The exact answer depends on the variant of the architecture
100 at hand, but we can use this to declare statically allocated
101 arrays, and bump it up when needed. */
102 #define M32C_MAX_NUM_REGS (75)
104 /* The largest assigned DWARF register number. */
105 #define M32C_MAX_DWARF_REGNUM (40)
110 /* All the registers for this variant, indexed by GDB register
111 number, and the number of registers present. */
112 struct m32c_reg regs[M32C_MAX_NUM_REGS];
114 /* The number of valid registers. */
117 /* Interesting registers. These are pointers into REGS. */
118 struct m32c_reg *pc, *flg;
119 struct m32c_reg *r0, *r1, *r2, *r3, *a0, *a1;
120 struct m32c_reg *r2r0, *r3r2r1r0, *r3r1r2r0;
121 struct m32c_reg *sb, *fb, *sp;
123 /* A table indexed by DWARF register numbers, pointing into
125 struct m32c_reg *dwarf_regs[M32C_MAX_DWARF_REGNUM + 1];
127 /* Types for this architecture. We can't use the builtin_type_foo
128 types, because they're not initialized when building a gdbarch
130 struct type *voyd, *ptr_voyd, *func_voyd;
131 struct type *uint8, *uint16;
132 struct type *int8, *int16, *int32, *int64;
134 /* The types for data address and code address registers. */
135 struct type *data_addr_reg_type, *code_addr_reg_type;
137 /* The number of bytes a return address pushed by a 'jsr' instruction
138 occupies on the stack. */
141 /* The number of bytes an address register occupies on the stack
142 when saved by an 'enter' or 'pushm' instruction. */
150 make_types (struct gdbarch *arch)
152 struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
153 unsigned long mach = gdbarch_bfd_arch_info (arch)->mach;
154 int data_addr_reg_bits, code_addr_reg_bits;
158 /* This is used to clip CORE_ADDR values, so this value is
159 appropriate both on the m32c, where pointers are 32 bits long,
160 and on the m16c, where pointers are sixteen bits long, but there
161 may be code above the 64k boundary. */
162 set_gdbarch_addr_bit (arch, 24);
164 /* GCC uses 32 bits for addrs in the dwarf info, even though
165 only 16/24 bits are used. Setting addr_bit to 24 causes
166 errors in reading the dwarf addresses. */
167 set_gdbarch_addr_bit (arch, 32);
170 set_gdbarch_int_bit (arch, 16);
174 data_addr_reg_bits = 16;
175 code_addr_reg_bits = 24;
176 set_gdbarch_ptr_bit (arch, 16);
177 tdep->ret_addr_bytes = 3;
178 tdep->push_addr_bytes = 2;
182 data_addr_reg_bits = 24;
183 code_addr_reg_bits = 24;
184 set_gdbarch_ptr_bit (arch, 32);
185 tdep->ret_addr_bytes = 4;
186 tdep->push_addr_bytes = 4;
193 /* The builtin_type_mumble variables are sometimes uninitialized when
194 this is called, so we avoid using them. */
195 tdep->voyd = init_type (TYPE_CODE_VOID, 1, 0, "void", NULL);
196 tdep->ptr_voyd = init_type (TYPE_CODE_PTR, gdbarch_ptr_bit (arch) / 8,
197 TYPE_FLAG_UNSIGNED, NULL, NULL);
198 TYPE_TARGET_TYPE (tdep->ptr_voyd) = tdep->voyd;
199 tdep->func_voyd = lookup_function_type (tdep->voyd);
201 sprintf (type_name, "%s_data_addr_t",
202 gdbarch_bfd_arch_info (arch)->printable_name);
203 tdep->data_addr_reg_type
204 = init_type (TYPE_CODE_PTR, data_addr_reg_bits / 8,
205 TYPE_FLAG_UNSIGNED, xstrdup (type_name), NULL);
206 TYPE_TARGET_TYPE (tdep->data_addr_reg_type) = tdep->voyd;
208 sprintf (type_name, "%s_code_addr_t",
209 gdbarch_bfd_arch_info (arch)->printable_name);
210 tdep->code_addr_reg_type
211 = init_type (TYPE_CODE_PTR, code_addr_reg_bits / 8,
212 TYPE_FLAG_UNSIGNED, xstrdup (type_name), NULL);
213 TYPE_TARGET_TYPE (tdep->code_addr_reg_type) = tdep->func_voyd;
215 tdep->uint8 = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
217 tdep->uint16 = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
219 tdep->int8 = init_type (TYPE_CODE_INT, 1, 0, "int8_t", NULL);
220 tdep->int16 = init_type (TYPE_CODE_INT, 2, 0, "int16_t", NULL);
221 tdep->int32 = init_type (TYPE_CODE_INT, 4, 0, "int32_t", NULL);
222 tdep->int64 = init_type (TYPE_CODE_INT, 8, 0, "int64_t", NULL);
230 m32c_register_name (struct gdbarch *gdbarch, int num)
232 return gdbarch_tdep (gdbarch)->regs[num].name;
237 m32c_register_type (struct gdbarch *arch, int reg_nr)
239 return gdbarch_tdep (arch)->regs[reg_nr].type;
244 m32c_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
246 return gdbarch_tdep (gdbarch)->regs[reg_nr].sim_num;
251 m32c_debug_info_reg_to_regnum (struct gdbarch *gdbarch, int reg_nr)
253 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
254 if (0 <= reg_nr && reg_nr <= M32C_MAX_DWARF_REGNUM
255 && tdep->dwarf_regs[reg_nr])
256 return tdep->dwarf_regs[reg_nr]->num;
258 /* The DWARF CFI code expects to see -1 for invalid register
265 m32c_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
266 struct reggroup *group)
268 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
269 struct m32c_reg *reg = &tdep->regs[regnum];
271 /* The anonymous raw registers aren't in any groups. */
275 if (group == all_reggroup)
278 if (group == general_reggroup
282 if (group == m32c_dma_reggroup
286 if (group == system_reggroup
290 /* Since the m32c DWARF register numbers refer to cooked registers, not
291 raw registers, and frame_pop depends on the save and restore groups
292 containing registers the DWARF CFI will actually mention, our save
293 and restore groups are cooked registers, not raw registers. (This is
294 why we can't use the default reggroup function.) */
295 if ((group == save_reggroup
296 || group == restore_reggroup)
297 && reg->save_restore_p)
304 /* Register move functions. We declare them here using
305 m32c_move_reg_t to check the types. */
306 static m32c_move_reg_t m32c_raw_read, m32c_raw_write;
307 static m32c_move_reg_t m32c_banked_read, m32c_banked_write;
308 static m32c_move_reg_t m32c_sb_read, m32c_sb_write;
309 static m32c_move_reg_t m32c_part_read, m32c_part_write;
310 static m32c_move_reg_t m32c_cat_read, m32c_cat_write;
311 static m32c_move_reg_t m32c_r3r2r1r0_read, m32c_r3r2r1r0_write;
314 /* Copy the value of the raw register REG from CACHE to BUF. */
316 m32c_raw_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
318 regcache_raw_read (cache, reg->num, buf);
322 /* Copy the value of the raw register REG from BUF to CACHE. */
324 m32c_raw_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
326 regcache_raw_write (cache, reg->num, (const void *) buf);
330 /* Return the value of the 'flg' register in CACHE. */
332 m32c_read_flg (struct regcache *cache)
334 struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (cache));
336 regcache_raw_read_unsigned (cache, tdep->flg->num, &flg);
341 /* Evaluate the real register number of a banked register. */
342 static struct m32c_reg *
343 m32c_banked_register (struct m32c_reg *reg, struct regcache *cache)
345 return ((m32c_read_flg (cache) & reg->n) ? reg->ry : reg->rx);
349 /* Move the value of a banked register from CACHE to BUF.
350 If the value of the 'flg' register in CACHE has any of the bits
351 masked in REG->n set, then read REG->ry. Otherwise, read
354 m32c_banked_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
356 struct m32c_reg *bank_reg = m32c_banked_register (reg, cache);
357 regcache_raw_read (cache, bank_reg->num, buf);
361 /* Move the value of a banked register from BUF to CACHE.
362 If the value of the 'flg' register in CACHE has any of the bits
363 masked in REG->n set, then write REG->ry. Otherwise, write
366 m32c_banked_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
368 struct m32c_reg *bank_reg = m32c_banked_register (reg, cache);
369 regcache_raw_write (cache, bank_reg->num, (const void *) buf);
373 /* Move the value of SB from CACHE to BUF. On bfd_mach_m32c, SB is a
374 banked register; on bfd_mach_m16c, it's not. */
376 m32c_sb_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
378 if (gdbarch_bfd_arch_info (reg->arch)->mach == bfd_mach_m16c)
379 m32c_raw_read (reg->rx, cache, buf);
381 m32c_banked_read (reg, cache, buf);
385 /* Move the value of SB from BUF to CACHE. On bfd_mach_m32c, SB is a
386 banked register; on bfd_mach_m16c, it's not. */
388 m32c_sb_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
390 if (gdbarch_bfd_arch_info (reg->arch)->mach == bfd_mach_m16c)
391 m32c_raw_write (reg->rx, cache, buf);
393 m32c_banked_write (reg, cache, buf);
397 /* Assuming REG uses m32c_part_read and m32c_part_write, set *OFFSET_P
398 and *LEN_P to the offset and length, in bytes, of the part REG
399 occupies in its underlying register. The offset is from the
400 lower-addressed end, regardless of the architecture's endianness.
401 (The M32C family is always little-endian, but let's keep those
402 assumptions out of here.) */
404 m32c_find_part (struct m32c_reg *reg, int *offset_p, int *len_p)
406 /* The length of the containing register, of which REG is one part. */
407 int containing_len = TYPE_LENGTH (reg->rx->type);
409 /* The length of one "element" in our imaginary array. */
410 int elt_len = TYPE_LENGTH (reg->type);
412 /* The offset of REG's "element" from the least significant end of
413 the containing register. */
414 int elt_offset = reg->n * elt_len;
416 /* If we extend off the end, trim the length of the element. */
417 if (elt_offset + elt_len > containing_len)
419 elt_len = containing_len - elt_offset;
420 /* We shouldn't be declaring partial registers that go off the
421 end of their containing registers. */
422 gdb_assert (elt_len > 0);
425 /* Flip the offset around if we're big-endian. */
426 if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG)
427 elt_offset = TYPE_LENGTH (reg->rx->type) - elt_offset - elt_len;
429 *offset_p = elt_offset;
434 /* Move the value of a partial register (r0h, intbl, etc.) from CACHE
435 to BUF. Treating the value of the register REG->rx as an array of
436 REG->type values, where higher indices refer to more significant
437 bits, read the value of the REG->n'th element. */
439 m32c_part_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
442 memset (buf, 0, TYPE_LENGTH (reg->type));
443 m32c_find_part (reg, &offset, &len);
444 regcache_cooked_read_part (cache, reg->rx->num, offset, len, buf);
448 /* Move the value of a banked register from BUF to CACHE.
449 Treating the value of the register REG->rx as an array of REG->type
450 values, where higher indices refer to more significant bits, write
451 the value of the REG->n'th element. */
453 m32c_part_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
456 m32c_find_part (reg, &offset, &len);
457 regcache_cooked_write_part (cache, reg->rx->num, offset, len, buf);
461 /* Move the value of REG from CACHE to BUF. REG's value is the
462 concatenation of the values of the registers REG->rx and REG->ry,
463 with REG->rx contributing the more significant bits. */
465 m32c_cat_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
467 int high_bytes = TYPE_LENGTH (reg->rx->type);
468 int low_bytes = TYPE_LENGTH (reg->ry->type);
469 /* For address arithmetic. */
470 unsigned char *cbuf = buf;
472 gdb_assert (TYPE_LENGTH (reg->type) == high_bytes + low_bytes);
474 if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG)
476 regcache_cooked_read (cache, reg->rx->num, cbuf);
477 regcache_cooked_read (cache, reg->ry->num, cbuf + high_bytes);
481 regcache_cooked_read (cache, reg->rx->num, cbuf + low_bytes);
482 regcache_cooked_read (cache, reg->ry->num, cbuf);
487 /* Move the value of REG from CACHE to BUF. REG's value is the
488 concatenation of the values of the registers REG->rx and REG->ry,
489 with REG->rx contributing the more significant bits. */
491 m32c_cat_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
493 int high_bytes = TYPE_LENGTH (reg->rx->type);
494 int low_bytes = TYPE_LENGTH (reg->ry->type);
495 /* For address arithmetic. */
496 unsigned char *cbuf = buf;
498 gdb_assert (TYPE_LENGTH (reg->type) == high_bytes + low_bytes);
500 if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG)
502 regcache_cooked_write (cache, reg->rx->num, cbuf);
503 regcache_cooked_write (cache, reg->ry->num, cbuf + high_bytes);
507 regcache_cooked_write (cache, reg->rx->num, cbuf + low_bytes);
508 regcache_cooked_write (cache, reg->ry->num, cbuf);
513 /* Copy the value of the raw register REG from CACHE to BUF. REG is
514 the concatenation (from most significant to least) of r3, r2, r1,
517 m32c_r3r2r1r0_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
519 struct gdbarch_tdep *tdep = gdbarch_tdep (reg->arch);
520 int len = TYPE_LENGTH (tdep->r0->type);
522 /* For address arithmetic. */
523 unsigned char *cbuf = buf;
525 if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG)
527 regcache_cooked_read (cache, tdep->r0->num, cbuf + len * 3);
528 regcache_cooked_read (cache, tdep->r1->num, cbuf + len * 2);
529 regcache_cooked_read (cache, tdep->r2->num, cbuf + len * 1);
530 regcache_cooked_read (cache, tdep->r3->num, cbuf);
534 regcache_cooked_read (cache, tdep->r0->num, cbuf);
535 regcache_cooked_read (cache, tdep->r1->num, cbuf + len * 1);
536 regcache_cooked_read (cache, tdep->r2->num, cbuf + len * 2);
537 regcache_cooked_read (cache, tdep->r3->num, cbuf + len * 3);
542 /* Copy the value of the raw register REG from BUF to CACHE. REG is
543 the concatenation (from most significant to least) of r3, r2, r1,
546 m32c_r3r2r1r0_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
548 struct gdbarch_tdep *tdep = gdbarch_tdep (reg->arch);
549 int len = TYPE_LENGTH (tdep->r0->type);
551 /* For address arithmetic. */
552 unsigned char *cbuf = buf;
554 if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG)
556 regcache_cooked_write (cache, tdep->r0->num, cbuf + len * 3);
557 regcache_cooked_write (cache, tdep->r1->num, cbuf + len * 2);
558 regcache_cooked_write (cache, tdep->r2->num, cbuf + len * 1);
559 regcache_cooked_write (cache, tdep->r3->num, cbuf);
563 regcache_cooked_write (cache, tdep->r0->num, cbuf);
564 regcache_cooked_write (cache, tdep->r1->num, cbuf + len * 1);
565 regcache_cooked_write (cache, tdep->r2->num, cbuf + len * 2);
566 regcache_cooked_write (cache, tdep->r3->num, cbuf + len * 3);
572 m32c_pseudo_register_read (struct gdbarch *arch,
573 struct regcache *cache,
577 struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
578 struct m32c_reg *reg;
580 gdb_assert (0 <= cookednum && cookednum < tdep->num_regs);
581 gdb_assert (arch == get_regcache_arch (cache));
582 gdb_assert (arch == tdep->regs[cookednum].arch);
583 reg = &tdep->regs[cookednum];
585 reg->read (reg, cache, buf);
590 m32c_pseudo_register_write (struct gdbarch *arch,
591 struct regcache *cache,
595 struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
596 struct m32c_reg *reg;
598 gdb_assert (0 <= cookednum && cookednum < tdep->num_regs);
599 gdb_assert (arch == get_regcache_arch (cache));
600 gdb_assert (arch == tdep->regs[cookednum].arch);
601 reg = &tdep->regs[cookednum];
603 reg->write (reg, cache, (void *) buf);
607 /* Add a register with the given fields to the end of ARCH's table.
608 Return a pointer to the newly added register. */
609 static struct m32c_reg *
610 add_reg (struct gdbarch *arch,
614 m32c_move_reg_t *read,
615 m32c_move_reg_t *write,
620 struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
621 struct m32c_reg *r = &tdep->regs[tdep->num_regs];
623 gdb_assert (tdep->num_regs < M32C_MAX_NUM_REGS);
628 r->num = tdep->num_regs;
629 r->sim_num = sim_num;
634 r->save_restore_p = 0;
647 /* Record NUM as REG's DWARF register number. */
649 set_dwarf_regnum (struct m32c_reg *reg, int num)
651 gdb_assert (num < M32C_MAX_NUM_REGS);
653 /* Update the reg->DWARF mapping. Only count the first number
654 assigned to this register. */
655 if (reg->dwarf_num == -1)
656 reg->dwarf_num = num;
658 /* Update the DWARF->reg mapping. */
659 gdbarch_tdep (reg->arch)->dwarf_regs[num] = reg;
663 /* Mark REG as a general-purpose register, and return it. */
664 static struct m32c_reg *
665 mark_general (struct m32c_reg *reg)
672 /* Mark REG as a DMA register, and return it. */
673 static struct m32c_reg *
674 mark_dma (struct m32c_reg *reg)
681 /* Mark REG as a SYSTEM register, and return it. */
682 static struct m32c_reg *
683 mark_system (struct m32c_reg *reg)
690 /* Mark REG as a save-restore register, and return it. */
691 static struct m32c_reg *
692 mark_save_restore (struct m32c_reg *reg)
694 reg->save_restore_p = 1;
699 #define FLAGBIT_B 0x0010
700 #define FLAGBIT_U 0x0080
702 /* Handy macros for declaring registers. These all evaluate to
703 pointers to the register declared. Macros that define two
704 registers evaluate to a pointer to the first. */
706 /* A raw register named NAME, with type TYPE and sim number SIM_NUM. */
707 #define R(name, type, sim_num) \
708 (add_reg (arch, (name), (type), (sim_num), \
709 m32c_raw_read, m32c_raw_write, NULL, NULL, 0))
711 /* The simulator register number for a raw register named NAME. */
712 #define SIM(name) (m32c_sim_reg_ ## name)
714 /* A raw unsigned 16-bit data register named NAME.
715 NAME should be an identifier, not a string. */
717 (R(#name, tdep->uint16, SIM (name)))
719 /* A raw data address register named NAME.
720 NAME should be an identifier, not a string. */
722 (R(#name, tdep->data_addr_reg_type, SIM (name)))
724 /* A raw code address register named NAME. NAME should
725 be an identifier, not a string. */
727 (R(#name, tdep->code_addr_reg_type, SIM (name)))
729 /* A pair of raw registers named NAME0 and NAME1, with type TYPE.
730 NAME should be an identifier, not a string. */
731 #define RP(name, type) \
732 (R(#name "0", (type), SIM (name ## 0)), \
733 R(#name "1", (type), SIM (name ## 1)) - 1)
735 /* A raw banked general-purpose data register named NAME.
736 NAME should be an identifier, not a string. */
738 (R(NULL, tdep->int16, SIM (name ## _bank0)), \
739 R(NULL, tdep->int16, SIM (name ## _bank1)) - 1)
741 /* A raw banked data address register named NAME.
742 NAME should be an identifier, not a string. */
744 (R(NULL, tdep->data_addr_reg_type, SIM (name ## _bank0)), \
745 R(NULL, tdep->data_addr_reg_type, SIM (name ## _bank1)) - 1)
747 /* A cooked register named NAME referring to a raw banked register
748 from the bank selected by the current value of FLG. RAW_PAIR
749 should be a pointer to the first register in the banked pair.
750 NAME must be an identifier, not a string. */
751 #define CB(name, raw_pair) \
752 (add_reg (arch, #name, (raw_pair)->type, 0, \
753 m32c_banked_read, m32c_banked_write, \
754 (raw_pair), (raw_pair + 1), FLAGBIT_B))
756 /* A pair of registers named NAMEH and NAMEL, of type TYPE, that
757 access the top and bottom halves of the register pointed to by
758 NAME. NAME should be an identifier. */
759 #define CHL(name, type) \
760 (add_reg (arch, #name "h", (type), 0, \
761 m32c_part_read, m32c_part_write, name, NULL, 1), \
762 add_reg (arch, #name "l", (type), 0, \
763 m32c_part_read, m32c_part_write, name, NULL, 0) - 1)
765 /* A register constructed by concatenating the two registers HIGH and
766 LOW, whose name is HIGHLOW and whose type is TYPE. */
767 #define CCAT(high, low, type) \
768 (add_reg (arch, #high #low, (type), 0, \
769 m32c_cat_read, m32c_cat_write, (high), (low), 0))
771 /* Abbreviations for marking register group membership. */
772 #define G(reg) (mark_general (reg))
773 #define S(reg) (mark_system (reg))
774 #define DMA(reg) (mark_dma (reg))
777 /* Construct the register set for ARCH. */
779 make_regs (struct gdbarch *arch)
781 struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
782 int mach = gdbarch_bfd_arch_info (arch)->mach;
795 struct m32c_reg *r0hl;
796 struct m32c_reg *r1hl;
797 struct m32c_reg *r2hl;
798 struct m32c_reg *r3hl;
799 struct m32c_reg *intbhl;
800 struct m32c_reg *r2r0;
801 struct m32c_reg *r3r1;
802 struct m32c_reg *r3r1r2r0;
803 struct m32c_reg *r3r2r1r0;
804 struct m32c_reg *a1a0;
806 struct m32c_reg *raw_r0_pair = RBD (r0);
807 struct m32c_reg *raw_r1_pair = RBD (r1);
808 struct m32c_reg *raw_r2_pair = RBD (r2);
809 struct m32c_reg *raw_r3_pair = RBD (r3);
810 struct m32c_reg *raw_a0_pair = RBA (a0);
811 struct m32c_reg *raw_a1_pair = RBA (a1);
812 struct m32c_reg *raw_fb_pair = RBA (fb);
814 /* sb is banked on the bfd_mach_m32c, but not on bfd_mach_m16c.
815 We always declare both raw registers, and deal with the distinction
816 in the pseudoregister. */
817 struct m32c_reg *raw_sb_pair = RBA (sb);
819 struct m32c_reg *usp = S (RA (usp));
820 struct m32c_reg *isp = S (RA (isp));
821 struct m32c_reg *intb = S (RC (intb));
822 struct m32c_reg *pc = G (RC (pc));
823 struct m32c_reg *flg = G (R16U (flg));
825 if (mach == bfd_mach_m32c)
827 struct m32c_reg *svf = S (R16U (svf));
828 struct m32c_reg *svp = S (RC (svp));
829 struct m32c_reg *vct = S (RC (vct));
831 struct m32c_reg *dmd01 = DMA (RP (dmd, tdep->uint8));
832 struct m32c_reg *dct01 = DMA (RP (dct, tdep->uint16));
833 struct m32c_reg *drc01 = DMA (RP (drc, tdep->uint16));
834 struct m32c_reg *dma01 = DMA (RP (dma, tdep->data_addr_reg_type));
835 struct m32c_reg *dsa01 = DMA (RP (dsa, tdep->data_addr_reg_type));
836 struct m32c_reg *dra01 = DMA (RP (dra, tdep->data_addr_reg_type));
839 num_raw_regs = tdep->num_regs;
841 r0 = G (CB (r0, raw_r0_pair));
842 r1 = G (CB (r1, raw_r1_pair));
843 r2 = G (CB (r2, raw_r2_pair));
844 r3 = G (CB (r3, raw_r3_pair));
845 a0 = G (CB (a0, raw_a0_pair));
846 a1 = G (CB (a1, raw_a1_pair));
847 fb = G (CB (fb, raw_fb_pair));
849 /* sb is banked on the bfd_mach_m32c, but not on bfd_mach_m16c.
850 Specify custom read/write functions that do the right thing. */
851 sb = G (add_reg (arch, "sb", raw_sb_pair->type, 0,
852 m32c_sb_read, m32c_sb_write,
853 raw_sb_pair, raw_sb_pair + 1, 0));
855 /* The current sp is either usp or isp, depending on the value of
856 the FLG register's U bit. */
857 sp = G (add_reg (arch, "sp", usp->type, 0,
858 m32c_banked_read, m32c_banked_write,
859 isp, usp, FLAGBIT_U));
861 r0hl = CHL (r0, tdep->int8);
862 r1hl = CHL (r1, tdep->int8);
863 r2hl = CHL (r2, tdep->int8);
864 r3hl = CHL (r3, tdep->int8);
865 intbhl = CHL (intb, tdep->int16);
867 r2r0 = CCAT (r2, r0, tdep->int32);
868 r3r1 = CCAT (r3, r1, tdep->int32);
869 r3r1r2r0 = CCAT (r3r1, r2r0, tdep->int64);
872 = add_reg (arch, "r3r2r1r0", tdep->int64, 0,
873 m32c_r3r2r1r0_read, m32c_r3r2r1r0_write, NULL, NULL, 0);
875 if (mach == bfd_mach_m16c)
876 a1a0 = CCAT (a1, a0, tdep->int32);
880 num_cooked_regs = tdep->num_regs - num_raw_regs;
889 tdep->r3r2r1r0 = r3r2r1r0;
890 tdep->r3r1r2r0 = r3r1r2r0;
897 /* Set up the DWARF register table. */
898 memset (tdep->dwarf_regs, 0, sizeof (tdep->dwarf_regs));
899 set_dwarf_regnum (r0hl + 1, 0x01);
900 set_dwarf_regnum (r0hl + 0, 0x02);
901 set_dwarf_regnum (r1hl + 1, 0x03);
902 set_dwarf_regnum (r1hl + 0, 0x04);
903 set_dwarf_regnum (r0, 0x05);
904 set_dwarf_regnum (r1, 0x06);
905 set_dwarf_regnum (r2, 0x07);
906 set_dwarf_regnum (r3, 0x08);
907 set_dwarf_regnum (a0, 0x09);
908 set_dwarf_regnum (a1, 0x0a);
909 set_dwarf_regnum (fb, 0x0b);
910 set_dwarf_regnum (sp, 0x0c);
911 set_dwarf_regnum (pc, 0x0d); /* GCC's invention */
912 set_dwarf_regnum (sb, 0x13);
913 set_dwarf_regnum (r2r0, 0x15);
914 set_dwarf_regnum (r3r1, 0x16);
916 set_dwarf_regnum (a1a0, 0x17);
918 /* Enumerate the save/restore register group.
920 The regcache_save and regcache_restore functions apply their read
921 function to each register in this group.
923 Since frame_pop supplies frame_unwind_register as its read
924 function, the registers meaningful to the Dwarf unwinder need to
927 On the other hand, when we make inferior calls, save_inferior_status
928 and restore_inferior_status use them to preserve the current register
929 values across the inferior call. For this, you'd kind of like to
930 preserve all the raw registers, to protect the interrupted code from
931 any sort of bank switching the callee might have done. But we handle
932 those cases so badly anyway --- for example, it matters whether we
933 restore FLG before or after we restore the general-purpose registers,
934 but there's no way to express that --- that it isn't worth worrying
937 We omit control registers like inthl: if you call a function that
938 changes those, it's probably because you wanted that change to be
939 visible to the interrupted code. */
940 mark_save_restore (r0);
941 mark_save_restore (r1);
942 mark_save_restore (r2);
943 mark_save_restore (r3);
944 mark_save_restore (a0);
945 mark_save_restore (a1);
946 mark_save_restore (sb);
947 mark_save_restore (fb);
948 mark_save_restore (sp);
949 mark_save_restore (pc);
950 mark_save_restore (flg);
952 set_gdbarch_num_regs (arch, num_raw_regs);
953 set_gdbarch_num_pseudo_regs (arch, num_cooked_regs);
954 set_gdbarch_pc_regnum (arch, pc->num);
955 set_gdbarch_sp_regnum (arch, sp->num);
956 set_gdbarch_register_name (arch, m32c_register_name);
957 set_gdbarch_register_type (arch, m32c_register_type);
958 set_gdbarch_pseudo_register_read (arch, m32c_pseudo_register_read);
959 set_gdbarch_pseudo_register_write (arch, m32c_pseudo_register_write);
960 set_gdbarch_register_sim_regno (arch, m32c_register_sim_regno);
961 set_gdbarch_stab_reg_to_regnum (arch, m32c_debug_info_reg_to_regnum);
962 set_gdbarch_dwarf2_reg_to_regnum (arch, m32c_debug_info_reg_to_regnum);
963 set_gdbarch_register_reggroup_p (arch, m32c_register_reggroup_p);
965 reggroup_add (arch, general_reggroup);
966 reggroup_add (arch, all_reggroup);
967 reggroup_add (arch, save_reggroup);
968 reggroup_add (arch, restore_reggroup);
969 reggroup_add (arch, system_reggroup);
970 reggroup_add (arch, m32c_dma_reggroup);
977 static const unsigned char *
978 m32c_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
980 static unsigned char break_insn[] = { 0x00 }; /* brk */
982 *len = sizeof (break_insn);
988 /* Prologue analysis. */
992 /* For consistency with the DWARF 2 .debug_frame info generated by
993 GCC, a frame's CFA is the address immediately after the saved
996 /* The architecture for which we generated this prologue info. */
997 struct gdbarch *arch;
1000 /* This function uses a frame pointer. */
1001 prologue_with_frame_ptr,
1003 /* This function has no frame pointer. */
1004 prologue_sans_frame_ptr,
1006 /* This function sets up the stack, so its frame is the first
1007 frame on the stack. */
1008 prologue_first_frame
1012 /* If KIND is prologue_with_frame_ptr, this is the offset from the
1013 CFA to where the frame pointer points. This is always zero or
1015 LONGEST frame_ptr_offset;
1017 /* If KIND is prologue_sans_frame_ptr, the offset from the CFA to
1018 the stack pointer --- always zero or negative.
1020 Calling this a "size" is a bit misleading, but given that the
1021 stack grows downwards, using offsets for everything keeps one
1022 from going completely sign-crazy: you never change anything's
1023 sign for an ADD instruction; always change the second operand's
1024 sign for a SUB instruction; and everything takes care of
1027 Functions that use alloca don't have a constant frame size. But
1028 they always have frame pointers, so we must use that to find the
1029 CFA (and perhaps to unwind the stack pointer). */
1032 /* The address of the first instruction at which the frame has been
1033 set up and the arguments are where the debug info says they are
1034 --- as best as we can tell. */
1035 CORE_ADDR prologue_end;
1037 /* reg_offset[R] is the offset from the CFA at which register R is
1038 saved, or 1 if register R has not been saved. (Real values are
1039 always zero or negative.) */
1040 LONGEST reg_offset[M32C_MAX_NUM_REGS];
1044 /* The longest I've seen, anyway. */
1045 #define M32C_MAX_INSN_LEN (9)
1047 /* Processor state, for the prologue analyzer. */
1048 struct m32c_pv_state
1050 struct gdbarch *arch;
1051 pv_t r0, r1, r2, r3;
1055 struct pv_area *stack;
1057 /* Bytes from the current PC, the address they were read from,
1058 and the address of the next unconsumed byte. */
1059 gdb_byte insn[M32C_MAX_INSN_LEN];
1060 CORE_ADDR scan_pc, next_addr;
1064 /* Push VALUE on STATE's stack, occupying SIZE bytes. Return zero if
1065 all went well, or non-zero if simulating the action would trash our
1068 m32c_pv_push (struct m32c_pv_state *state, pv_t value, int size)
1070 if (pv_area_store_would_trash (state->stack, state->sp))
1073 state->sp = pv_add_constant (state->sp, -size);
1074 pv_area_store (state->stack, state->sp, size, value);
1080 /* A source or destination location for an m16c or m32c
1084 /* If srcdest_reg, the location is a register pointed to by REG.
1085 If srcdest_partial_reg, the location is part of a register pointed
1086 to by REG. We don't try to handle this too well.
1087 If srcdest_mem, the location is memory whose address is ADDR. */
1088 enum { srcdest_reg, srcdest_partial_reg, srcdest_mem } kind;
1093 /* Return the SIZE-byte value at LOC in STATE. */
1095 m32c_srcdest_fetch (struct m32c_pv_state *state, struct srcdest loc, int size)
1097 if (loc.kind == srcdest_mem)
1098 return pv_area_fetch (state->stack, loc.addr, size);
1099 else if (loc.kind == srcdest_partial_reg)
1100 return pv_unknown ();
1106 /* Write VALUE, a SIZE-byte value, to LOC in STATE. Return zero if
1107 all went well, or non-zero if simulating the store would trash our
1110 m32c_srcdest_store (struct m32c_pv_state *state, struct srcdest loc,
1111 pv_t value, int size)
1113 if (loc.kind == srcdest_mem)
1115 if (pv_area_store_would_trash (state->stack, loc.addr))
1117 pv_area_store (state->stack, loc.addr, size, value);
1119 else if (loc.kind == srcdest_partial_reg)
1120 *loc.reg = pv_unknown ();
1129 m32c_sign_ext (int v, int bits)
1131 int mask = 1 << (bits - 1);
1132 return (v ^ mask) - mask;
1136 m32c_next_byte (struct m32c_pv_state *st)
1138 gdb_assert (st->next_addr - st->scan_pc < sizeof (st->insn));
1139 return st->insn[st->next_addr++ - st->scan_pc];
1143 m32c_udisp8 (struct m32c_pv_state *st)
1145 return m32c_next_byte (st);
1150 m32c_sdisp8 (struct m32c_pv_state *st)
1152 return m32c_sign_ext (m32c_next_byte (st), 8);
1157 m32c_udisp16 (struct m32c_pv_state *st)
1159 int low = m32c_next_byte (st);
1160 int high = m32c_next_byte (st);
1162 return low + (high << 8);
1167 m32c_sdisp16 (struct m32c_pv_state *st)
1169 int low = m32c_next_byte (st);
1170 int high = m32c_next_byte (st);
1172 return m32c_sign_ext (low + (high << 8), 16);
1177 m32c_udisp24 (struct m32c_pv_state *st)
1179 int low = m32c_next_byte (st);
1180 int mid = m32c_next_byte (st);
1181 int high = m32c_next_byte (st);
1183 return low + (mid << 8) + (high << 16);
1187 /* Extract the 'source' field from an m32c MOV.size:G-format instruction. */
1189 m32c_get_src23 (unsigned char *i)
1191 return (((i[0] & 0x70) >> 2)
1192 | ((i[1] & 0x30) >> 4));
1196 /* Extract the 'dest' field from an m32c MOV.size:G-format instruction. */
1198 m32c_get_dest23 (unsigned char *i)
1200 return (((i[0] & 0x0e) << 1)
1201 | ((i[1] & 0xc0) >> 6));
1205 static struct srcdest
1206 m32c_decode_srcdest4 (struct m32c_pv_state *st,
1212 sd.kind = (size == 2 ? srcdest_reg : srcdest_partial_reg);
1214 sd.kind = srcdest_mem;
1216 sd.addr = pv_unknown ();
1221 case 0x0: sd.reg = (size == 1 ? &st->r0 : &st->r0); break;
1222 case 0x1: sd.reg = (size == 1 ? &st->r0 : &st->r1); break;
1223 case 0x2: sd.reg = (size == 1 ? &st->r1 : &st->r2); break;
1224 case 0x3: sd.reg = (size == 1 ? &st->r1 : &st->r3); break;
1226 case 0x4: sd.reg = &st->a0; break;
1227 case 0x5: sd.reg = &st->a1; break;
1229 case 0x6: sd.addr = st->a0; break;
1230 case 0x7: sd.addr = st->a1; break;
1232 case 0x8: sd.addr = pv_add_constant (st->a0, m32c_udisp8 (st)); break;
1233 case 0x9: sd.addr = pv_add_constant (st->a1, m32c_udisp8 (st)); break;
1234 case 0xa: sd.addr = pv_add_constant (st->sb, m32c_udisp8 (st)); break;
1235 case 0xb: sd.addr = pv_add_constant (st->fb, m32c_sdisp8 (st)); break;
1237 case 0xc: sd.addr = pv_add_constant (st->a0, m32c_udisp16 (st)); break;
1238 case 0xd: sd.addr = pv_add_constant (st->a1, m32c_udisp16 (st)); break;
1239 case 0xe: sd.addr = pv_add_constant (st->sb, m32c_udisp16 (st)); break;
1240 case 0xf: sd.addr = pv_constant (m32c_udisp16 (st)); break;
1250 static struct srcdest
1251 m32c_decode_sd23 (struct m32c_pv_state *st, int code, int size, int ind)
1255 sd.addr = pv_unknown ();
1264 sd.kind = (size == 1) ? srcdest_partial_reg : srcdest_reg;
1269 sd.kind = (size == 4) ? srcdest_reg : srcdest_partial_reg;
1273 sd.kind = srcdest_mem;
1280 case 0x12: sd.reg = &st->r0; break;
1281 case 0x13: sd.reg = &st->r1; break;
1282 case 0x10: sd.reg = ((size == 1) ? &st->r0 : &st->r2); break;
1283 case 0x11: sd.reg = ((size == 1) ? &st->r1 : &st->r3); break;
1284 case 0x02: sd.reg = &st->a0; break;
1285 case 0x03: sd.reg = &st->a1; break;
1287 case 0x00: sd.addr = st->a0; break;
1288 case 0x01: sd.addr = st->a1; break;
1289 case 0x04: sd.addr = pv_add_constant (st->a0, m32c_udisp8 (st)); break;
1290 case 0x05: sd.addr = pv_add_constant (st->a1, m32c_udisp8 (st)); break;
1291 case 0x06: sd.addr = pv_add_constant (st->sb, m32c_udisp8 (st)); break;
1292 case 0x07: sd.addr = pv_add_constant (st->fb, m32c_sdisp8 (st)); break;
1293 case 0x08: sd.addr = pv_add_constant (st->a0, m32c_udisp16 (st)); break;
1294 case 0x09: sd.addr = pv_add_constant (st->a1, m32c_udisp16 (st)); break;
1295 case 0x0a: sd.addr = pv_add_constant (st->sb, m32c_udisp16 (st)); break;
1296 case 0x0b: sd.addr = pv_add_constant (st->fb, m32c_sdisp16 (st)); break;
1297 case 0x0c: sd.addr = pv_add_constant (st->a0, m32c_udisp24 (st)); break;
1298 case 0x0d: sd.addr = pv_add_constant (st->a1, m32c_udisp24 (st)); break;
1299 case 0x0f: sd.addr = pv_constant (m32c_udisp16 (st)); break;
1300 case 0x0e: sd.addr = pv_constant (m32c_udisp24 (st)); break;
1307 sd.addr = m32c_srcdest_fetch (st, sd, 4);
1308 sd.kind = srcdest_mem;
1315 /* The r16c and r32c machines have instructions with similar
1316 semantics, but completely different machine language encodings. So
1317 we break out the semantics into their own functions, and leave
1318 machine-specific decoding in m32c_analyze_prologue.
1320 The following functions all expect their arguments already decoded,
1321 and they all return zero if analysis should continue past this
1322 instruction, or non-zero if analysis should stop. */
1325 /* Simulate an 'enter SIZE' instruction in STATE. */
1327 m32c_pv_enter (struct m32c_pv_state *state, int size)
1329 struct gdbarch_tdep *tdep = gdbarch_tdep (state->arch);
1331 /* If simulating this store would require us to forget
1332 everything we know about the stack frame in the name of
1333 accuracy, it would be better to just quit now. */
1334 if (pv_area_store_would_trash (state->stack, state->sp))
1337 if (m32c_pv_push (state, state->fb, tdep->push_addr_bytes))
1339 state->fb = state->sp;
1340 state->sp = pv_add_constant (state->sp, -size);
1347 m32c_pv_pushm_one (struct m32c_pv_state *state, pv_t reg,
1348 int bit, int src, int size)
1352 if (m32c_pv_push (state, reg, size))
1360 /* Simulate a 'pushm SRC' instruction in STATE. */
1362 m32c_pv_pushm (struct m32c_pv_state *state, int src)
1364 struct gdbarch_tdep *tdep = gdbarch_tdep (state->arch);
1366 /* The bits in SRC indicating which registers to save are:
1367 r0 r1 r2 r3 a0 a1 sb fb */
1369 ( m32c_pv_pushm_one (state, state->fb, 0x01, src, tdep->push_addr_bytes)
1370 || m32c_pv_pushm_one (state, state->sb, 0x02, src, tdep->push_addr_bytes)
1371 || m32c_pv_pushm_one (state, state->a1, 0x04, src, tdep->push_addr_bytes)
1372 || m32c_pv_pushm_one (state, state->a0, 0x08, src, tdep->push_addr_bytes)
1373 || m32c_pv_pushm_one (state, state->r3, 0x10, src, 2)
1374 || m32c_pv_pushm_one (state, state->r2, 0x20, src, 2)
1375 || m32c_pv_pushm_one (state, state->r1, 0x40, src, 2)
1376 || m32c_pv_pushm_one (state, state->r0, 0x80, src, 2));
1379 /* Return non-zero if VALUE is the first incoming argument register. */
1382 m32c_is_1st_arg_reg (struct m32c_pv_state *state, pv_t value)
1384 struct gdbarch_tdep *tdep = gdbarch_tdep (state->arch);
1385 return (value.kind == pvk_register
1386 && (gdbarch_bfd_arch_info (state->arch)->mach == bfd_mach_m16c
1387 ? (value.reg == tdep->r1->num)
1388 : (value.reg == tdep->r0->num))
1392 /* Return non-zero if VALUE is an incoming argument register. */
1395 m32c_is_arg_reg (struct m32c_pv_state *state, pv_t value)
1397 struct gdbarch_tdep *tdep = gdbarch_tdep (state->arch);
1398 return (value.kind == pvk_register
1399 && (gdbarch_bfd_arch_info (state->arch)->mach == bfd_mach_m16c
1400 ? (value.reg == tdep->r1->num || value.reg == tdep->r2->num)
1401 : (value.reg == tdep->r0->num))
1405 /* Return non-zero if a store of VALUE to LOC is probably spilling an
1406 argument register to its stack slot in STATE. Such instructions
1407 should be included in the prologue, if possible.
1409 The store is a spill if:
1410 - the value being stored is the original value of an argument register;
1411 - the value has not already been stored somewhere in STACK; and
1412 - LOC is a stack slot (e.g., a memory location whose address is
1413 relative to the original value of the SP). */
1416 m32c_is_arg_spill (struct m32c_pv_state *st,
1420 struct gdbarch_tdep *tdep = gdbarch_tdep (st->arch);
1422 return (m32c_is_arg_reg (st, value)
1423 && loc.kind == srcdest_mem
1424 && pv_is_register (loc.addr, tdep->sp->num)
1425 && ! pv_area_find_reg (st->stack, st->arch, value.reg, 0));
1428 /* Return non-zero if a store of VALUE to LOC is probably
1429 copying the struct return address into an address register
1430 for immediate use. This is basically a "spill" into the
1431 address register, instead of onto the stack.
1433 The prerequisites are:
1434 - value being stored is original value of the FIRST arg register;
1435 - value has not already been stored on stack; and
1436 - LOC is an address register (a0 or a1). */
1439 m32c_is_struct_return (struct m32c_pv_state *st,
1443 struct gdbarch_tdep *tdep = gdbarch_tdep (st->arch);
1445 return (m32c_is_1st_arg_reg (st, value)
1446 && !pv_area_find_reg (st->stack, st->arch, value.reg, 0)
1447 && loc.kind == srcdest_reg
1448 && (pv_is_register (*loc.reg, tdep->a0->num)
1449 || pv_is_register (*loc.reg, tdep->a1->num)));
1452 /* Return non-zero if a 'pushm' saving the registers indicated by SRC
1453 was a register save:
1454 - all the named registers should have their original values, and
1455 - the stack pointer should be at a constant offset from the
1456 original stack pointer. */
1458 m32c_pushm_is_reg_save (struct m32c_pv_state *st, int src)
1460 struct gdbarch_tdep *tdep = gdbarch_tdep (st->arch);
1461 /* The bits in SRC indicating which registers to save are:
1462 r0 r1 r2 r3 a0 a1 sb fb */
1464 (pv_is_register (st->sp, tdep->sp->num)
1465 && (! (src & 0x01) || pv_is_register_k (st->fb, tdep->fb->num, 0))
1466 && (! (src & 0x02) || pv_is_register_k (st->sb, tdep->sb->num, 0))
1467 && (! (src & 0x04) || pv_is_register_k (st->a1, tdep->a1->num, 0))
1468 && (! (src & 0x08) || pv_is_register_k (st->a0, tdep->a0->num, 0))
1469 && (! (src & 0x10) || pv_is_register_k (st->r3, tdep->r3->num, 0))
1470 && (! (src & 0x20) || pv_is_register_k (st->r2, tdep->r2->num, 0))
1471 && (! (src & 0x40) || pv_is_register_k (st->r1, tdep->r1->num, 0))
1472 && (! (src & 0x80) || pv_is_register_k (st->r0, tdep->r0->num, 0)));
1476 /* Function for finding saved registers in a 'struct pv_area'; we pass
1477 this to pv_area_scan.
1479 If VALUE is a saved register, ADDR says it was saved at a constant
1480 offset from the frame base, and SIZE indicates that the whole
1481 register was saved, record its offset in RESULT_UNTYPED. */
1483 check_for_saved (void *prologue_untyped, pv_t addr, CORE_ADDR size, pv_t value)
1485 struct m32c_prologue *prologue = (struct m32c_prologue *) prologue_untyped;
1486 struct gdbarch *arch = prologue->arch;
1487 struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
1489 /* Is this the unchanged value of some register being saved on the
1491 if (value.kind == pvk_register
1493 && pv_is_register (addr, tdep->sp->num))
1495 /* Some registers require special handling: they're saved as a
1496 larger value than the register itself. */
1497 CORE_ADDR saved_size = register_size (arch, value.reg);
1499 if (value.reg == tdep->pc->num)
1500 saved_size = tdep->ret_addr_bytes;
1501 else if (register_type (arch, value.reg)
1502 == tdep->data_addr_reg_type)
1503 saved_size = tdep->push_addr_bytes;
1505 if (size == saved_size)
1507 /* Find which end of the saved value corresponds to our
1509 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG)
1510 prologue->reg_offset[value.reg]
1511 = (addr.k + saved_size - register_size (arch, value.reg));
1513 prologue->reg_offset[value.reg] = addr.k;
1519 /* Analyze the function prologue for ARCH at START, going no further
1520 than LIMIT, and place a description of what we found in
1523 m32c_analyze_prologue (struct gdbarch *arch,
1524 CORE_ADDR start, CORE_ADDR limit,
1525 struct m32c_prologue *prologue)
1527 struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
1528 unsigned long mach = gdbarch_bfd_arch_info (arch)->mach;
1529 CORE_ADDR after_last_frame_related_insn;
1530 struct cleanup *back_to;
1531 struct m32c_pv_state st;
1534 st.r0 = pv_register (tdep->r0->num, 0);
1535 st.r1 = pv_register (tdep->r1->num, 0);
1536 st.r2 = pv_register (tdep->r2->num, 0);
1537 st.r3 = pv_register (tdep->r3->num, 0);
1538 st.a0 = pv_register (tdep->a0->num, 0);
1539 st.a1 = pv_register (tdep->a1->num, 0);
1540 st.sb = pv_register (tdep->sb->num, 0);
1541 st.fb = pv_register (tdep->fb->num, 0);
1542 st.sp = pv_register (tdep->sp->num, 0);
1543 st.pc = pv_register (tdep->pc->num, 0);
1544 st.stack = make_pv_area (tdep->sp->num);
1545 back_to = make_cleanup_free_pv_area (st.stack);
1547 /* Record that the call instruction has saved the return address on
1549 m32c_pv_push (&st, st.pc, tdep->ret_addr_bytes);
1551 memset (prologue, 0, sizeof (*prologue));
1552 prologue->arch = arch;
1555 for (i = 0; i < M32C_MAX_NUM_REGS; i++)
1556 prologue->reg_offset[i] = 1;
1559 st.scan_pc = after_last_frame_related_insn = start;
1561 while (st.scan_pc < limit)
1563 pv_t pre_insn_fb = st.fb;
1564 pv_t pre_insn_sp = st.sp;
1566 /* In theory we could get in trouble by trying to read ahead
1567 here, when we only know we're expecting one byte. In
1568 practice I doubt anyone will care, and it makes the rest of
1570 if (target_read_memory (st.scan_pc, st.insn, sizeof (st.insn)))
1571 /* If we can't fetch the instruction from memory, stop here
1572 and hope for the best. */
1574 st.next_addr = st.scan_pc;
1576 /* The assembly instructions are written as they appear in the
1577 section of the processor manuals that describe the
1578 instruction encodings.
1580 When a single assembly language instruction has several
1581 different machine-language encodings, the manual
1582 distinguishes them by a number in parens, before the
1583 mnemonic. Those numbers are included, as well.
1585 The srcdest decoding instructions have the same names as the
1586 analogous functions in the simulator. */
1587 if (mach == bfd_mach_m16c)
1589 /* (1) ENTER #imm8 */
1590 if (st.insn[0] == 0x7c && st.insn[1] == 0xf2)
1592 if (m32c_pv_enter (&st, st.insn[2]))
1597 else if (st.insn[0] == 0xec)
1599 int src = st.insn[1];
1600 if (m32c_pv_pushm (&st, src))
1604 if (m32c_pushm_is_reg_save (&st, src))
1605 after_last_frame_related_insn = st.next_addr;
1608 /* (6) MOV.size:G src, dest */
1609 else if ((st.insn[0] & 0xfe) == 0x72)
1611 int size = (st.insn[0] & 0x01) ? 2 : 1;
1613 struct srcdest dest;
1618 = m32c_decode_srcdest4 (&st, (st.insn[1] >> 4) & 0xf, size);
1620 = m32c_decode_srcdest4 (&st, st.insn[1] & 0xf, size);
1621 src_value = m32c_srcdest_fetch (&st, src, size);
1623 if (m32c_is_arg_spill (&st, dest, src_value))
1624 after_last_frame_related_insn = st.next_addr;
1625 else if (m32c_is_struct_return (&st, dest, src_value))
1626 after_last_frame_related_insn = st.next_addr;
1628 if (m32c_srcdest_store (&st, dest, src_value, size))
1632 /* (1) LDC #IMM16, sp */
1633 else if (st.insn[0] == 0xeb
1634 && st.insn[1] == 0x50)
1637 st.sp = pv_constant (m32c_udisp16 (&st));
1641 /* We've hit some instruction we don't know how to simulate.
1642 Strictly speaking, we should set every value we're
1643 tracking to "unknown". But we'll be optimistic, assume
1644 that we have enough information already, and stop
1650 int src_indirect = 0;
1651 int dest_indirect = 0;
1654 gdb_assert (mach == bfd_mach_m32c);
1656 /* Check for prefix bytes indicating indirect addressing. */
1657 if (st.insn[0] == 0x41)
1662 else if (st.insn[0] == 0x09)
1667 else if (st.insn[0] == 0x49)
1669 src_indirect = dest_indirect = 1;
1673 /* (1) ENTER #imm8 */
1674 if (st.insn[i] == 0xec)
1676 if (m32c_pv_enter (&st, st.insn[i + 1]))
1682 else if (st.insn[i] == 0x8f)
1684 int src = st.insn[i + 1];
1685 if (m32c_pv_pushm (&st, src))
1689 if (m32c_pushm_is_reg_save (&st, src))
1690 after_last_frame_related_insn = st.next_addr;
1693 /* (7) MOV.size:G src, dest */
1694 else if ((st.insn[i] & 0x80) == 0x80
1695 && (st.insn[i + 1] & 0x0f) == 0x0b
1696 && m32c_get_src23 (&st.insn[i]) < 20
1697 && m32c_get_dest23 (&st.insn[i]) < 20)
1700 struct srcdest dest;
1702 int bw = st.insn[i] & 0x01;
1703 int size = bw ? 2 : 1;
1707 = m32c_decode_sd23 (&st, m32c_get_src23 (&st.insn[i]),
1708 size, src_indirect);
1710 = m32c_decode_sd23 (&st, m32c_get_dest23 (&st.insn[i]),
1711 size, dest_indirect);
1712 src_value = m32c_srcdest_fetch (&st, src, size);
1714 if (m32c_is_arg_spill (&st, dest, src_value))
1715 after_last_frame_related_insn = st.next_addr;
1717 if (m32c_srcdest_store (&st, dest, src_value, size))
1720 /* (2) LDC #IMM24, sp */
1721 else if (st.insn[i] == 0xd5
1722 && st.insn[i + 1] == 0x29)
1725 st.sp = pv_constant (m32c_udisp24 (&st));
1728 /* We've hit some instruction we don't know how to simulate.
1729 Strictly speaking, we should set every value we're
1730 tracking to "unknown". But we'll be optimistic, assume
1731 that we have enough information already, and stop
1736 /* If this instruction changed the FB or decreased the SP (i.e.,
1737 allocated more stack space), then this may be a good place to
1738 declare the prologue finished. However, there are some
1741 - If the instruction just changed the FB back to its original
1742 value, then that's probably a restore instruction. The
1743 prologue should definitely end before that.
1745 - If the instruction increased the value of the SP (that is,
1746 shrunk the frame), then it's probably part of a frame
1747 teardown sequence, and the prologue should end before
1750 if (! pv_is_identical (st.fb, pre_insn_fb))
1752 if (! pv_is_register_k (st.fb, tdep->fb->num, 0))
1753 after_last_frame_related_insn = st.next_addr;
1755 else if (! pv_is_identical (st.sp, pre_insn_sp))
1757 /* The comparison of the constants looks odd, there, because
1758 .k is unsigned. All it really means is that the SP is
1759 lower than it was before the instruction. */
1760 if ( pv_is_register (pre_insn_sp, tdep->sp->num)
1761 && pv_is_register (st.sp, tdep->sp->num)
1762 && ((pre_insn_sp.k - st.sp.k) < (st.sp.k - pre_insn_sp.k)))
1763 after_last_frame_related_insn = st.next_addr;
1766 st.scan_pc = st.next_addr;
1769 /* Did we load a constant value into the stack pointer? */
1770 if (pv_is_constant (st.sp))
1771 prologue->kind = prologue_first_frame;
1773 /* Alternatively, did we initialize the frame pointer? Remember
1774 that the CFA is the address after the return address. */
1775 if (pv_is_register (st.fb, tdep->sp->num))
1777 prologue->kind = prologue_with_frame_ptr;
1778 prologue->frame_ptr_offset = st.fb.k;
1781 /* Is the frame size a known constant? Remember that frame_size is
1782 actually the offset from the CFA to the SP (i.e., a negative
1784 else if (pv_is_register (st.sp, tdep->sp->num))
1786 prologue->kind = prologue_sans_frame_ptr;
1787 prologue->frame_size = st.sp.k;
1790 /* We haven't been able to make sense of this function's frame. Treat
1791 it as the first frame. */
1793 prologue->kind = prologue_first_frame;
1795 /* Record where all the registers were saved. */
1796 pv_area_scan (st.stack, check_for_saved, (void *) prologue);
1798 prologue->prologue_end = after_last_frame_related_insn;
1800 do_cleanups (back_to);
1805 m32c_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
1808 CORE_ADDR func_addr, func_end, sal_end;
1809 struct m32c_prologue p;
1811 /* Try to find the extent of the function that contains IP. */
1812 if (! find_pc_partial_function (ip, &name, &func_addr, &func_end))
1815 /* Find end by prologue analysis. */
1816 m32c_analyze_prologue (gdbarch, ip, func_end, &p);
1817 /* Find end by line info. */
1818 sal_end = skip_prologue_using_sal (ip);
1819 /* Return whichever is lower. */
1820 if (sal_end != 0 && sal_end != ip && sal_end < p.prologue_end)
1823 return p.prologue_end;
1828 /* Stack unwinding. */
1830 static struct m32c_prologue *
1831 m32c_analyze_frame_prologue (struct frame_info *this_frame,
1832 void **this_prologue_cache)
1834 if (! *this_prologue_cache)
1836 CORE_ADDR func_start = get_frame_func (this_frame);
1837 CORE_ADDR stop_addr = get_frame_pc (this_frame);
1839 /* If we couldn't find any function containing the PC, then
1840 just initialize the prologue cache, but don't do anything. */
1842 stop_addr = func_start;
1844 *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct m32c_prologue);
1845 m32c_analyze_prologue (get_frame_arch (this_frame),
1846 func_start, stop_addr, *this_prologue_cache);
1849 return *this_prologue_cache;
1854 m32c_frame_base (struct frame_info *this_frame,
1855 void **this_prologue_cache)
1857 struct m32c_prologue *p
1858 = m32c_analyze_frame_prologue (this_frame, this_prologue_cache);
1859 struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
1861 /* In functions that use alloca, the distance between the stack
1862 pointer and the frame base varies dynamically, so we can't use
1863 the SP plus static information like prologue analysis to find the
1864 frame base. However, such functions must have a frame pointer,
1865 to be able to restore the SP on exit. So whenever we do have a
1866 frame pointer, use that to find the base. */
1869 case prologue_with_frame_ptr:
1872 = get_frame_register_unsigned (this_frame, tdep->fb->num);
1873 return fb - p->frame_ptr_offset;
1876 case prologue_sans_frame_ptr:
1879 = get_frame_register_unsigned (this_frame, tdep->sp->num);
1880 return sp - p->frame_size;
1883 case prologue_first_frame:
1893 m32c_this_id (struct frame_info *this_frame,
1894 void **this_prologue_cache,
1895 struct frame_id *this_id)
1897 CORE_ADDR base = m32c_frame_base (this_frame, this_prologue_cache);
1900 *this_id = frame_id_build (base, get_frame_func (this_frame));
1901 /* Otherwise, leave it unset, and that will terminate the backtrace. */
1905 static struct value *
1906 m32c_prev_register (struct frame_info *this_frame,
1907 void **this_prologue_cache, int regnum)
1909 struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
1910 struct m32c_prologue *p
1911 = m32c_analyze_frame_prologue (this_frame, this_prologue_cache);
1912 CORE_ADDR frame_base = m32c_frame_base (this_frame, this_prologue_cache);
1913 int reg_size = register_size (get_frame_arch (this_frame), regnum);
1915 if (regnum == tdep->sp->num)
1916 return frame_unwind_got_constant (this_frame, regnum, frame_base);
1918 /* If prologue analysis says we saved this register somewhere,
1919 return a description of the stack slot holding it. */
1920 if (p->reg_offset[regnum] != 1)
1921 return frame_unwind_got_memory (this_frame, regnum,
1922 frame_base + p->reg_offset[regnum]);
1924 /* Otherwise, presume we haven't changed the value of this
1925 register, and get it from the next frame. */
1926 return frame_unwind_got_register (this_frame, regnum, regnum);
1930 static const struct frame_unwind m32c_unwind = {
1935 default_frame_sniffer
1940 m32c_unwind_pc (struct gdbarch *arch, struct frame_info *next_frame)
1942 struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
1943 return frame_unwind_register_unsigned (next_frame, tdep->pc->num);
1948 m32c_unwind_sp (struct gdbarch *arch, struct frame_info *next_frame)
1950 struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
1951 return frame_unwind_register_unsigned (next_frame, tdep->sp->num);
1955 /* Inferior calls. */
1957 /* The calling conventions, according to GCC:
1961 First arg may be passed in r1l or r1 if it (1) fits (QImode or
1962 HImode), (2) is named, and (3) is an integer or pointer type (no
1963 structs, floats, etc). Otherwise, it's passed on the stack.
1965 Second arg may be passed in r2, same restrictions (but not QImode),
1966 even if the first arg is passed on the stack.
1968 Third and further args are passed on the stack. No padding is
1969 used, stack "alignment" is 8 bits.
1974 First arg may be passed in r0l or r0, same restrictions as above.
1976 Second and further args are passed on the stack. Padding is used
1977 after QImode parameters (i.e. lower-addressed byte is the value,
1978 higher-addressed byte is the padding), stack "alignment" is 16
1982 /* Return true if TYPE is a type that can be passed in registers. (We
1983 ignore the size, and pay attention only to the type code;
1984 acceptable sizes depends on which register is being considered to
1987 m32c_reg_arg_type (struct type *type)
1989 enum type_code code = TYPE_CODE (type);
1991 return (code == TYPE_CODE_INT
1992 || code == TYPE_CODE_ENUM
1993 || code == TYPE_CODE_PTR
1994 || code == TYPE_CODE_REF
1995 || code == TYPE_CODE_BOOL
1996 || code == TYPE_CODE_CHAR);
2001 m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
2002 struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
2003 struct value **args, CORE_ADDR sp, int struct_return,
2004 CORE_ADDR struct_addr)
2006 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2007 unsigned long mach = gdbarch_bfd_arch_info (gdbarch)->mach;
2011 /* The number of arguments given in this function's prototype, or
2012 zero if it has a non-prototyped function type. The m32c ABI
2013 passes arguments mentioned in the prototype differently from
2014 those in the ellipsis of a varargs function, or from those passed
2015 to a non-prototyped function. */
2016 int num_prototyped_args = 0;
2019 struct type *func_type = value_type (function);
2021 /* Dereference function pointer types. */
2022 if (TYPE_CODE (func_type) == TYPE_CODE_PTR)
2023 func_type = TYPE_TARGET_TYPE (func_type);
2025 gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC ||
2026 TYPE_CODE (func_type) == TYPE_CODE_METHOD);
2029 /* The ABI description in gcc/config/m32c/m32c.abi says that
2030 we need to handle prototyped and non-prototyped functions
2031 separately, but the code in GCC doesn't actually do so. */
2032 if (TYPE_PROTOTYPED (func_type))
2034 num_prototyped_args = TYPE_NFIELDS (func_type);
2037 /* First, if the function returns an aggregate by value, push a
2038 pointer to a buffer for it. This doesn't affect the way
2039 subsequent arguments are allocated to registers. */
2042 int ptr_len = TYPE_LENGTH (tdep->ptr_voyd);
2044 write_memory_unsigned_integer (sp, ptr_len, struct_addr);
2047 /* Push the arguments. */
2048 for (i = nargs - 1; i >= 0; i--)
2050 struct value *arg = args[i];
2051 const gdb_byte *arg_bits = value_contents (arg);
2052 struct type *arg_type = value_type (arg);
2053 ULONGEST arg_size = TYPE_LENGTH (arg_type);
2055 /* Can it go in r1 or r1l (for m16c) or r0 or r0l (for m32c)? */
2058 && i < num_prototyped_args
2059 && m32c_reg_arg_type (arg_type))
2061 /* Extract and re-store as an integer as a terse way to make
2062 sure it ends up in the least significant end of r1. (GDB
2063 should avoid assuming endianness, even on uni-endian
2065 ULONGEST u = extract_unsigned_integer (arg_bits, arg_size);
2066 struct m32c_reg *reg = (mach == bfd_mach_m16c) ? tdep->r1 : tdep->r0;
2067 regcache_cooked_write_unsigned (regcache, reg->num, u);
2070 /* Can it go in r2? */
2071 else if (mach == bfd_mach_m16c
2074 && i < num_prototyped_args
2075 && m32c_reg_arg_type (arg_type))
2076 regcache_cooked_write (regcache, tdep->r2->num, arg_bits);
2078 /* Everything else goes on the stack. */
2083 /* Align the stack. */
2084 if (mach == bfd_mach_m32c)
2087 write_memory (sp, arg_bits, arg_size);
2091 /* This is the CFA we use to identify the dummy frame. */
2094 /* Push the return address. */
2095 sp -= tdep->ret_addr_bytes;
2096 write_memory_unsigned_integer (sp, tdep->ret_addr_bytes, bp_addr);
2098 /* Update the stack pointer. */
2099 regcache_cooked_write_unsigned (regcache, tdep->sp->num, sp);
2101 /* We need to borrow an odd trick from the i386 target here.
2103 The value we return from this function gets used as the stack
2104 address (the CFA) for the dummy frame's ID. The obvious thing is
2105 to return the new TOS. However, that points at the return
2106 address, saved on the stack, which is inconsistent with the CFA's
2107 described by GCC's DWARF 2 .debug_frame information: DWARF 2
2108 .debug_frame info uses the address immediately after the saved
2109 return address. So you end up with a dummy frame whose CFA
2110 points at the return address, but the frame for the function
2111 being called has a CFA pointing after the return address: the
2112 younger CFA is *greater than* the older CFA. The sanity checks
2113 in frame.c don't like that.
2115 So we try to be consistent with the CFA's used by DWARF 2.
2116 Having a dummy frame and a real frame with the *same* CFA is
2122 static struct frame_id
2123 m32c_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2125 /* This needs to return a frame ID whose PC is the return address
2126 passed to m32c_push_dummy_call, and whose stack_addr is the SP
2127 m32c_push_dummy_call returned.
2129 m32c_unwind_sp gives us the CFA, which is the value the SP had
2130 before the return address was pushed. */
2131 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2132 CORE_ADDR sp = get_frame_register_unsigned (this_frame, tdep->sp->num);
2133 return frame_id_build (sp, get_frame_pc (this_frame));
2138 /* Return values. */
2140 /* Return value conventions, according to GCC:
2151 Aggregate values (regardless of size) are returned by pushing a
2152 pointer to a temporary area on the stack after the args are pushed.
2153 The function fills in this area with the value. Note that this
2154 pointer on the stack does not affect how register arguments, if any,
2161 /* Return non-zero if values of type TYPE are returned by storing them
2162 in a buffer whose address is passed on the stack, ahead of the
2165 m32c_return_by_passed_buf (struct type *type)
2167 enum type_code code = TYPE_CODE (type);
2169 return (code == TYPE_CODE_STRUCT
2170 || code == TYPE_CODE_UNION);
2173 static enum return_value_convention
2174 m32c_return_value (struct gdbarch *gdbarch,
2175 struct type *func_type,
2176 struct type *valtype,
2177 struct regcache *regcache,
2179 const gdb_byte *writebuf)
2181 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2182 enum return_value_convention conv;
2183 ULONGEST valtype_len = TYPE_LENGTH (valtype);
2185 if (m32c_return_by_passed_buf (valtype))
2186 conv = RETURN_VALUE_STRUCT_CONVENTION;
2188 conv = RETURN_VALUE_REGISTER_CONVENTION;
2192 /* We should never be called to find values being returned by
2193 RETURN_VALUE_STRUCT_CONVENTION. Those can't be located,
2194 unless we made the call ourselves. */
2195 gdb_assert (conv == RETURN_VALUE_REGISTER_CONVENTION);
2197 gdb_assert (valtype_len <= 8);
2199 /* Anything that fits in r0 is returned there. */
2200 if (valtype_len <= TYPE_LENGTH (tdep->r0->type))
2203 regcache_cooked_read_unsigned (regcache, tdep->r0->num, &u);
2204 store_unsigned_integer (readbuf, valtype_len, u);
2208 /* Everything else is passed in mem0, using as many bytes as
2209 needed. This is not what the Renesas tools do, but it's
2210 what GCC does at the moment. */
2211 struct minimal_symbol *mem0
2212 = lookup_minimal_symbol ("mem0", NULL, NULL);
2215 error ("The return value is stored in memory at 'mem0', "
2216 "but GDB cannot find\n"
2218 read_memory (SYMBOL_VALUE_ADDRESS (mem0), readbuf, valtype_len);
2224 /* We should never be called to store values to be returned
2225 using RETURN_VALUE_STRUCT_CONVENTION. We have no way of
2226 finding the buffer, unless we made the call ourselves. */
2227 gdb_assert (conv == RETURN_VALUE_REGISTER_CONVENTION);
2229 gdb_assert (valtype_len <= 8);
2231 /* Anything that fits in r0 is returned there. */
2232 if (valtype_len <= TYPE_LENGTH (tdep->r0->type))
2234 ULONGEST u = extract_unsigned_integer (writebuf, valtype_len);
2235 regcache_cooked_write_unsigned (regcache, tdep->r0->num, u);
2239 /* Everything else is passed in mem0, using as many bytes as
2240 needed. This is not what the Renesas tools do, but it's
2241 what GCC does at the moment. */
2242 struct minimal_symbol *mem0
2243 = lookup_minimal_symbol ("mem0", NULL, NULL);
2246 error ("The return value is stored in memory at 'mem0', "
2247 "but GDB cannot find\n"
2249 write_memory (SYMBOL_VALUE_ADDRESS (mem0),
2250 (char *) writebuf, valtype_len);
2261 /* The m16c and m32c use a trampoline function for indirect function
2262 calls. An indirect call looks like this:
2264 ... push arguments ...
2265 ... push target function address ...
2268 The code for m32c_jsri16 looks like this:
2272 # Save return address.
2274 pop.b m32c_jsri_ret+2
2276 # Store target function address.
2277 pop.w m32c_jsri_addr
2279 # Re-push return address.
2280 push.b m32c_jsri_ret+2
2281 push.w m32c_jsri_ret
2283 # Call the target function.
2284 jmpi.a m32c_jsri_addr
2286 Without further information, GDB will treat calls to m32c_jsri16
2287 like calls to any other function. Since m32c_jsri16 doesn't have
2288 debugging information, that normally means that GDB sets a step-
2289 resume breakpoint and lets the program continue --- which is not
2290 what the user wanted. (Giving the trampoline debugging info
2291 doesn't help: the user expects the program to stop in the function
2292 their program is calling, not in some trampoline code they've never
2295 The gdbarch_skip_trampoline_code method tells GDB how to step
2296 through such trampoline functions transparently to the user. When
2297 given the address of a trampoline function's first instruction,
2298 gdbarch_skip_trampoline_code should return the address of the first
2299 instruction of the function really being called. If GDB decides it
2300 wants to step into that function, it will set a breakpoint there
2301 and silently continue to it.
2303 We recognize the trampoline by name, and extract the target address
2304 directly from the stack. This isn't great, but recognizing by its
2305 code sequence seems more fragile. */
2308 m32c_skip_trampoline_code (struct frame_info *frame, CORE_ADDR stop_pc)
2310 struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
2312 /* It would be nicer to simply look up the addresses of known
2313 trampolines once, and then compare stop_pc with them. However,
2314 we'd need to ensure that that cached address got invalidated when
2315 someone loaded a new executable, and I'm not quite sure of the
2316 best way to do that. find_pc_partial_function does do some
2317 caching, so we'll see how this goes. */
2319 CORE_ADDR start, end;
2321 if (find_pc_partial_function (stop_pc, &name, &start, &end))
2323 /* Are we stopped at the beginning of the trampoline function? */
2324 if (strcmp (name, "m32c_jsri16") == 0
2325 && stop_pc == start)
2327 /* Get the stack pointer. The return address is at the top,
2328 and the target function's address is just below that. We
2329 know it's a two-byte address, since the trampoline is
2331 CORE_ADDR sp = get_frame_sp (get_current_frame ());
2333 = read_memory_unsigned_integer (sp + tdep->ret_addr_bytes, 2);
2335 /* What we have now is the address of a jump instruction.
2336 What we need is the destination of that jump.
2337 The opcode is 1 byte, and the destination is the next 3 bytes.
2339 target = read_memory_unsigned_integer (target + 1, 3);
2348 /* Address/pointer conversions. */
2350 /* On the m16c, there is a 24-bit address space, but only a very few
2351 instructions can generate addresses larger than 0xffff: jumps,
2352 jumps to subroutines, and the lde/std (load/store extended)
2355 Since GCC can only support one size of pointer, we can't have
2356 distinct 'near' and 'far' pointer types; we have to pick one size
2357 for everything. If we wanted to use 24-bit pointers, then GCC
2358 would have to use lde and ste for all memory references, which
2359 would be terrible for performance and code size. So the GNU
2360 toolchain uses 16-bit pointers for everything, and gives up the
2361 ability to have pointers point outside the first 64k of memory.
2363 However, as a special hack, we let the linker place functions at
2364 addresses above 0xffff, as long as it also places a trampoline in
2365 the low 64k for every function whose address is taken. Each
2366 trampoline consists of a single jmp.a instruction that jumps to the
2367 function's real entry point. Pointers to functions can be 16 bits
2368 long, even though the functions themselves are at higher addresses:
2369 the pointers refer to the trampolines, not the functions.
2371 This complicates things for GDB, however: given the address of a
2372 function (from debug info or linker symbols, say) which could be
2373 anywhere in the 24-bit address space, how can we find an
2374 appropriate 16-bit value to use as a pointer to it?
2376 If the linker has not generated a trampoline for the function,
2377 we're out of luck. Well, I guess we could malloc some space and
2378 write a jmp.a instruction to it, but I'm not going to get into that
2381 If the linker has generated a trampoline for the function, then it
2382 also emitted a symbol for the trampoline: if the function's linker
2383 symbol is named NAME, then the function's trampoline's linker
2384 symbol is named NAME.plt.
2386 So, given a code address:
2387 - We try to find a linker symbol at that address.
2388 - If we find such a symbol named NAME, we look for a linker symbol
2390 - If we find such a symbol, we assume it is a trampoline, and use
2391 its address as the pointer value.
2393 And, given a function pointer:
2394 - We try to find a linker symbol at that address named NAME.plt.
2395 - If we find such a symbol, we look for a linker symbol named NAME.
2396 - If we find that, we provide that as the function's address.
2397 - If any of the above steps fail, we return the original address
2398 unchanged; it might really be a function in the low 64k.
2400 See? You *knew* there was a reason you wanted to be a computer
2404 m32c_m16c_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr)
2406 enum type_code target_code;
2407 gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR ||
2408 TYPE_CODE (type) == TYPE_CODE_REF);
2410 target_code = TYPE_CODE (TYPE_TARGET_TYPE (type));
2412 if (target_code == TYPE_CODE_FUNC || target_code == TYPE_CODE_METHOD)
2416 struct minimal_symbol *tramp_msym;
2418 /* Try to find a linker symbol at this address. */
2419 struct minimal_symbol *func_msym = lookup_minimal_symbol_by_pc (addr);
2422 error ("Cannot convert code address %s to function pointer:\n"
2423 "couldn't find a symbol at that address, to find trampoline.",
2426 func_name = SYMBOL_LINKAGE_NAME (func_msym);
2427 tramp_name = xmalloc (strlen (func_name) + 5);
2428 strcpy (tramp_name, func_name);
2429 strcat (tramp_name, ".plt");
2431 /* Try to find a linker symbol for the trampoline. */
2432 tramp_msym = lookup_minimal_symbol (tramp_name, NULL, NULL);
2434 /* We've either got another copy of the name now, or don't need
2435 the name any more. */
2439 error ("Cannot convert code address %s to function pointer:\n"
2440 "couldn't find trampoline named '%s.plt'.",
2441 paddr_nz (addr), func_name);
2443 /* The trampoline's address is our pointer. */
2444 addr = SYMBOL_VALUE_ADDRESS (tramp_msym);
2447 store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
2452 m32c_m16c_pointer_to_address (struct type *type, const gdb_byte *buf)
2455 enum type_code target_code;
2457 gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR ||
2458 TYPE_CODE (type) == TYPE_CODE_REF);
2460 ptr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
2462 target_code = TYPE_CODE (TYPE_TARGET_TYPE (type));
2464 if (target_code == TYPE_CODE_FUNC || target_code == TYPE_CODE_METHOD)
2466 /* See if there is a minimal symbol at that address whose name is
2468 struct minimal_symbol *ptr_msym = lookup_minimal_symbol_by_pc (ptr);
2472 char *ptr_msym_name = SYMBOL_LINKAGE_NAME (ptr_msym);
2473 int len = strlen (ptr_msym_name);
2476 && strcmp (ptr_msym_name + len - 4, ".plt") == 0)
2478 struct minimal_symbol *func_msym;
2479 /* We have a .plt symbol; try to find the symbol for the
2480 corresponding function.
2482 Since the trampoline contains a jump instruction, we
2483 could also just extract the jump's target address. I
2484 don't see much advantage one way or the other. */
2485 char *func_name = xmalloc (len - 4 + 1);
2486 memcpy (func_name, ptr_msym_name, len - 4);
2487 func_name[len - 4] = '\0';
2489 = lookup_minimal_symbol (func_name, NULL, NULL);
2491 /* If we do have such a symbol, return its value as the
2492 function's true address. */
2494 ptr = SYMBOL_VALUE_ADDRESS (func_msym);
2503 m32c_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc,
2505 LONGEST *frame_offset)
2508 CORE_ADDR func_addr, func_end, sal_end;
2509 struct m32c_prologue p;
2511 struct regcache *regcache = get_current_regcache ();
2512 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2514 if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
2515 internal_error (__FILE__, __LINE__, _("No virtual frame pointer available"));
2517 m32c_analyze_prologue (gdbarch, func_addr, pc, &p);
2520 case prologue_with_frame_ptr:
2521 *frame_regnum = m32c_banked_register (tdep->fb, regcache)->num;
2522 *frame_offset = p.frame_ptr_offset;
2524 case prologue_sans_frame_ptr:
2525 *frame_regnum = m32c_banked_register (tdep->sp, regcache)->num;
2526 *frame_offset = p.frame_size;
2529 *frame_regnum = m32c_banked_register (tdep->sp, regcache)->num;
2534 if (*frame_regnum > gdbarch_num_regs (gdbarch))
2535 internal_error (__FILE__, __LINE__, _("No virtual frame pointer available"));
2539 /* Initialization. */
2541 static struct gdbarch *
2542 m32c_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2544 struct gdbarch *arch;
2545 struct gdbarch_tdep *tdep;
2546 unsigned long mach = info.bfd_arch_info->mach;
2548 /* Find a candidate among the list of architectures we've created
2550 for (arches = gdbarch_list_lookup_by_info (arches, &info);
2552 arches = gdbarch_list_lookup_by_info (arches->next, &info))
2553 return arches->gdbarch;
2555 tdep = xcalloc (1, sizeof (*tdep));
2556 arch = gdbarch_alloc (&info, tdep);
2558 /* Essential types. */
2561 /* Address/pointer conversions. */
2562 if (mach == bfd_mach_m16c)
2564 set_gdbarch_address_to_pointer (arch, m32c_m16c_address_to_pointer);
2565 set_gdbarch_pointer_to_address (arch, m32c_m16c_pointer_to_address);
2572 set_gdbarch_print_insn (arch, print_insn_m32c);
2575 set_gdbarch_breakpoint_from_pc (arch, m32c_breakpoint_from_pc);
2577 /* Prologue analysis and unwinding. */
2578 set_gdbarch_inner_than (arch, core_addr_lessthan);
2579 set_gdbarch_skip_prologue (arch, m32c_skip_prologue);
2580 set_gdbarch_unwind_pc (arch, m32c_unwind_pc);
2581 set_gdbarch_unwind_sp (arch, m32c_unwind_sp);
2583 /* I'm dropping the dwarf2 sniffer because it has a few problems.
2584 They may be in the dwarf2 cfi code in GDB, or they may be in
2585 the debug info emitted by the upstream toolchain. I don't
2586 know which, but I do know that the prologue analyzer works better.
2589 dwarf2_append_sniffers (arch);
2591 frame_unwind_append_unwinder (arch, &m32c_unwind);
2593 /* Inferior calls. */
2594 set_gdbarch_push_dummy_call (arch, m32c_push_dummy_call);
2595 set_gdbarch_return_value (arch, m32c_return_value);
2596 set_gdbarch_dummy_id (arch, m32c_dummy_id);
2599 set_gdbarch_skip_trampoline_code (arch, m32c_skip_trampoline_code);
2601 set_gdbarch_virtual_frame_pointer (arch, m32c_virtual_frame_pointer);
2603 /* m32c function boundary addresses are not necessarily even.
2604 Therefore, the `vbit', which indicates a pointer to a virtual
2605 member function, is stored in the delta field, rather than as
2606 the low bit of a function pointer address.
2608 In order to verify this, see the definition of
2609 TARGET_PTRMEMFUNC_VBIT_LOCATION in gcc/defaults.h along with the
2610 definition of FUNCTION_BOUNDARY in gcc/config/m32c/m32c.h. */
2611 set_gdbarch_vbit_in_delta (arch, 1);
2618 _initialize_m32c_tdep (void)
2620 register_gdbarch_init (bfd_arch_m32c, m32c_gdbarch_init);
2622 m32c_dma_reggroup = reggroup_new ("dma", USER_REGGROUP);