* m32c-tdep.c (make_types): When calling `arch_type', pass size of
[external/binutils.git] / gdb / m32c-tdep.c
1 /* Renesas M32C target-dependent code for GDB, the GNU debugger.
2
3    Copyright 2004, 2005, 2007, 2008, 2009, 2010 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
22 #include <stdarg.h>
23
24 #if defined (HAVE_STRING_H)
25 #include <string.h>
26 #endif
27
28 #include "gdb_assert.h"
29 #include "elf-bfd.h"
30 #include "elf/m32c.h"
31 #include "gdb/sim-m32c.h"
32 #include "dis-asm.h"
33 #include "gdbtypes.h"
34 #include "regcache.h"
35 #include "arch-utils.h"
36 #include "frame.h"
37 #include "frame-unwind.h"
38 #include "dwarf2-frame.h"
39 #include "dwarf2expr.h"
40 #include "symtab.h"
41 #include "gdbcore.h"
42 #include "value.h"
43 #include "reggroups.h"
44 #include "prologue-value.h"
45 #include "target.h"
46
47 \f
48 /* The m32c tdep structure.  */
49
50 static struct reggroup *m32c_dma_reggroup;
51
52 struct m32c_reg;
53
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,
58                                 void *buf);
59
60 struct m32c_reg
61 {
62   /* The name of this register.  */
63   const char *name;
64
65   /* Its type.  */
66   struct type *type;
67
68   /* The architecture this register belongs to.  */
69   struct gdbarch *arch;
70
71   /* Its GDB register number.  */
72   int num;
73
74   /* Its sim register number.  */
75   int sim_num;
76
77   /* Its DWARF register number, or -1 if it doesn't have one.  */
78   int dwarf_num;
79
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;
85
86   /* Functions to read its value from a regcache, and write its value
87      to a regcache.  */
88   m32c_move_reg_t *read, *write;
89
90   /* Data for READ and WRITE functions.  The exact meaning depends on
91      the specific functions selected; see the comments for those
92      functions.  */
93   struct m32c_reg *rx, *ry;
94   int n;
95 };
96
97
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)
103
104 /* The largest assigned DWARF register number.  */
105 #define M32C_MAX_DWARF_REGNUM (40)
106
107
108 struct gdbarch_tdep
109 {
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];
113
114   /* The number of valid registers.  */
115   int num_regs;
116
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;
122
123   /* A table indexed by DWARF register numbers, pointing into
124      REGS.  */
125   struct m32c_reg *dwarf_regs[M32C_MAX_DWARF_REGNUM + 1];
126
127   /* Types for this architecture.  We can't use the builtin_type_foo
128      types, because they're not initialized when building a gdbarch
129      structure.  */
130   struct type *voyd, *ptr_voyd, *func_voyd;
131   struct type *uint8, *uint16;
132   struct type *int8, *int16, *int32, *int64;
133
134   /* The types for data address and code address registers.  */
135   struct type *data_addr_reg_type, *code_addr_reg_type;
136
137   /* The number of bytes a return address pushed by a 'jsr' instruction
138      occupies on the stack.  */
139   int ret_addr_bytes;
140
141   /* The number of bytes an address register occupies on the stack
142      when saved by an 'enter' or 'pushm' instruction.  */
143   int push_addr_bytes;
144 };
145
146 \f
147 /* Types.  */
148
149 static void
150 make_types (struct gdbarch *arch)
151 {
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;
155   char type_name[50];
156
157 #if 0
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);
163 #else
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);
168 #endif
169
170   set_gdbarch_int_bit (arch, 16);
171   switch (mach)
172     {
173     case bfd_mach_m16c:
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;
179       break;
180
181     case bfd_mach_m32c:
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;
187       break;
188
189     default:
190       gdb_assert (0);
191     }
192
193   /* The builtin_type_mumble variables are sometimes uninitialized when
194      this is called, so we avoid using them.  */
195   tdep->voyd = arch_type (arch, TYPE_CODE_VOID, 1, "void");
196   tdep->ptr_voyd
197     = arch_type (arch, TYPE_CODE_PTR, gdbarch_ptr_bit (arch) / TARGET_CHAR_BIT,
198                  NULL);
199   TYPE_TARGET_TYPE (tdep->ptr_voyd) = tdep->voyd;
200   TYPE_UNSIGNED (tdep->ptr_voyd) = 1;
201   tdep->func_voyd = lookup_function_type (tdep->voyd);
202
203   sprintf (type_name, "%s_data_addr_t",
204            gdbarch_bfd_arch_info (arch)->printable_name);
205   tdep->data_addr_reg_type
206     = arch_type (arch, TYPE_CODE_PTR, data_addr_reg_bits / TARGET_CHAR_BIT,
207                  xstrdup (type_name));
208   TYPE_TARGET_TYPE (tdep->data_addr_reg_type) = tdep->voyd;
209   TYPE_UNSIGNED (tdep->data_addr_reg_type) = 1;
210
211   sprintf (type_name, "%s_code_addr_t",
212            gdbarch_bfd_arch_info (arch)->printable_name);
213   tdep->code_addr_reg_type
214     = arch_type (arch, TYPE_CODE_PTR, code_addr_reg_bits / TARGET_CHAR_BIT,
215                  xstrdup (type_name));
216   TYPE_TARGET_TYPE (tdep->code_addr_reg_type) = tdep->func_voyd;
217   TYPE_UNSIGNED (tdep->code_addr_reg_type) = 1;
218
219   tdep->uint8  = arch_integer_type (arch,  8, 1, "uint8_t");
220   tdep->uint16 = arch_integer_type (arch, 16, 1, "uint16_t");
221   tdep->int8   = arch_integer_type (arch,  8, 0, "int8_t");
222   tdep->int16  = arch_integer_type (arch, 16, 0, "int16_t");
223   tdep->int32  = arch_integer_type (arch, 32, 0, "int32_t");
224   tdep->int64  = arch_integer_type (arch, 64, 0, "int64_t");
225 }
226
227
228 \f
229 /* Register set.  */
230
231 static const char *
232 m32c_register_name (struct gdbarch *gdbarch, int num)
233 {
234   return gdbarch_tdep (gdbarch)->regs[num].name;
235 }
236
237
238 static struct type *
239 m32c_register_type (struct gdbarch *arch, int reg_nr)
240 {
241   return gdbarch_tdep (arch)->regs[reg_nr].type;
242 }
243
244
245 static int
246 m32c_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
247 {
248   return gdbarch_tdep (gdbarch)->regs[reg_nr].sim_num;
249 }
250
251
252 static int
253 m32c_debug_info_reg_to_regnum (struct gdbarch *gdbarch, int reg_nr)
254 {
255   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
256   if (0 <= reg_nr && reg_nr <= M32C_MAX_DWARF_REGNUM
257       && tdep->dwarf_regs[reg_nr])
258     return tdep->dwarf_regs[reg_nr]->num;
259   else
260     /* The DWARF CFI code expects to see -1 for invalid register
261        numbers.  */
262     return -1;
263 }
264
265
266 static int
267 m32c_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
268                           struct reggroup *group)
269 {
270   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
271   struct m32c_reg *reg = &tdep->regs[regnum];
272
273   /* The anonymous raw registers aren't in any groups.  */
274   if (! reg->name)
275     return 0;
276
277   if (group == all_reggroup)
278     return 1;
279
280   if (group == general_reggroup
281       && reg->general_p)
282     return 1;
283
284   if (group == m32c_dma_reggroup
285       && reg->dma_p)
286     return 1;
287
288   if (group == system_reggroup
289       && reg->system_p)
290     return 1;
291
292   /* Since the m32c DWARF register numbers refer to cooked registers, not
293      raw registers, and frame_pop depends on the save and restore groups
294      containing registers the DWARF CFI will actually mention, our save
295      and restore groups are cooked registers, not raw registers.  (This is
296      why we can't use the default reggroup function.)  */
297   if ((group == save_reggroup
298        || group == restore_reggroup)
299       && reg->save_restore_p)
300     return 1;
301
302   return 0;
303 }
304
305
306 /* Register move functions.  We declare them here using
307    m32c_move_reg_t to check the types.  */
308 static m32c_move_reg_t m32c_raw_read,      m32c_raw_write;
309 static m32c_move_reg_t m32c_banked_read,   m32c_banked_write;
310 static m32c_move_reg_t m32c_sb_read,       m32c_sb_write;
311 static m32c_move_reg_t m32c_part_read,     m32c_part_write;
312 static m32c_move_reg_t m32c_cat_read,      m32c_cat_write;
313 static m32c_move_reg_t m32c_r3r2r1r0_read, m32c_r3r2r1r0_write;
314
315
316 /* Copy the value of the raw register REG from CACHE to BUF.  */
317 static void
318 m32c_raw_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
319 {
320   regcache_raw_read (cache, reg->num, buf);
321 }
322
323
324 /* Copy the value of the raw register REG from BUF to CACHE.  */
325 static void
326 m32c_raw_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
327 {
328   regcache_raw_write (cache, reg->num, (const void *) buf);
329 }
330
331
332 /* Return the value of the 'flg' register in CACHE.  */
333 static int
334 m32c_read_flg (struct regcache *cache)
335 {
336   struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (cache));
337   ULONGEST flg;
338   regcache_raw_read_unsigned (cache, tdep->flg->num, &flg);
339   return flg & 0xffff;
340 }
341
342
343 /* Evaluate the real register number of a banked register.  */
344 static struct m32c_reg *
345 m32c_banked_register (struct m32c_reg *reg, struct regcache *cache)
346 {
347   return ((m32c_read_flg (cache) & reg->n) ? reg->ry : reg->rx);
348 }
349
350
351 /* Move the value of a banked register from CACHE to BUF.
352    If the value of the 'flg' register in CACHE has any of the bits
353    masked in REG->n set, then read REG->ry.  Otherwise, read
354    REG->rx.  */
355 static void
356 m32c_banked_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
357 {
358   struct m32c_reg *bank_reg = m32c_banked_register (reg, cache);
359   regcache_raw_read (cache, bank_reg->num, buf);
360 }
361
362
363 /* Move the value of a banked register from BUF to CACHE.
364    If the value of the 'flg' register in CACHE has any of the bits
365    masked in REG->n set, then write REG->ry.  Otherwise, write
366    REG->rx.  */
367 static void
368 m32c_banked_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
369 {
370   struct m32c_reg *bank_reg = m32c_banked_register (reg, cache);
371   regcache_raw_write (cache, bank_reg->num, (const void *) buf);
372 }
373
374
375 /* Move the value of SB from CACHE to BUF.  On bfd_mach_m32c, SB is a
376    banked register; on bfd_mach_m16c, it's not.  */
377 static void
378 m32c_sb_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
379 {
380   if (gdbarch_bfd_arch_info (reg->arch)->mach == bfd_mach_m16c)
381     m32c_raw_read (reg->rx, cache, buf);
382   else
383     m32c_banked_read (reg, cache, buf);
384 }
385
386
387 /* Move the value of SB from BUF to CACHE.  On bfd_mach_m32c, SB is a
388    banked register; on bfd_mach_m16c, it's not.  */
389 static void
390 m32c_sb_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
391 {
392   if (gdbarch_bfd_arch_info (reg->arch)->mach == bfd_mach_m16c)
393     m32c_raw_write (reg->rx, cache, buf);
394   else
395     m32c_banked_write (reg, cache, buf);
396 }
397
398
399 /* Assuming REG uses m32c_part_read and m32c_part_write, set *OFFSET_P
400    and *LEN_P to the offset and length, in bytes, of the part REG
401    occupies in its underlying register.  The offset is from the
402    lower-addressed end, regardless of the architecture's endianness.
403    (The M32C family is always little-endian, but let's keep those
404    assumptions out of here.)  */
405 static void
406 m32c_find_part (struct m32c_reg *reg, int *offset_p, int *len_p)
407 {
408   /* The length of the containing register, of which REG is one part.  */
409   int containing_len = TYPE_LENGTH (reg->rx->type);
410
411   /* The length of one "element" in our imaginary array.  */
412   int elt_len = TYPE_LENGTH (reg->type);
413
414   /* The offset of REG's "element" from the least significant end of
415      the containing register.  */
416   int elt_offset = reg->n * elt_len;
417
418   /* If we extend off the end, trim the length of the element.  */
419   if (elt_offset + elt_len > containing_len)
420     {
421       elt_len = containing_len - elt_offset;
422       /* We shouldn't be declaring partial registers that go off the
423          end of their containing registers.  */
424       gdb_assert (elt_len > 0);
425     }
426
427   /* Flip the offset around if we're big-endian.  */
428   if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG)
429     elt_offset = TYPE_LENGTH (reg->rx->type) - elt_offset - elt_len;
430
431   *offset_p = elt_offset;
432   *len_p = elt_len;
433 }
434
435
436 /* Move the value of a partial register (r0h, intbl, etc.) from CACHE
437    to BUF.  Treating the value of the register REG->rx as an array of
438    REG->type values, where higher indices refer to more significant
439    bits, read the value of the REG->n'th element.  */
440 static void
441 m32c_part_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
442 {
443   int offset, len;
444   memset (buf, 0, TYPE_LENGTH (reg->type));
445   m32c_find_part (reg, &offset, &len);
446   regcache_cooked_read_part (cache, reg->rx->num, offset, len, buf);
447 }
448
449
450 /* Move the value of a banked register from BUF to CACHE.
451    Treating the value of the register REG->rx as an array of REG->type
452    values, where higher indices refer to more significant bits, write
453    the value of the REG->n'th element.  */
454 static void
455 m32c_part_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
456 {
457   int offset, len;
458   m32c_find_part (reg, &offset, &len);
459   regcache_cooked_write_part (cache, reg->rx->num, offset, len, buf);
460 }
461
462
463 /* Move the value of REG from CACHE to BUF.  REG's value is the
464    concatenation of the values of the registers REG->rx and REG->ry,
465    with REG->rx contributing the more significant bits.  */
466 static void
467 m32c_cat_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
468 {
469   int high_bytes = TYPE_LENGTH (reg->rx->type);
470   int low_bytes  = TYPE_LENGTH (reg->ry->type);
471   /* For address arithmetic.  */
472   unsigned char *cbuf = buf;
473
474   gdb_assert (TYPE_LENGTH (reg->type) == high_bytes + low_bytes);
475
476   if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG)
477     {
478       regcache_cooked_read (cache, reg->rx->num, cbuf);
479       regcache_cooked_read (cache, reg->ry->num, cbuf + high_bytes);
480     }
481   else
482     {
483       regcache_cooked_read (cache, reg->rx->num, cbuf + low_bytes);
484       regcache_cooked_read (cache, reg->ry->num, cbuf);
485     }
486 }
487
488
489 /* Move the value of REG from CACHE to BUF.  REG's value is the
490    concatenation of the values of the registers REG->rx and REG->ry,
491    with REG->rx contributing the more significant bits.  */
492 static void
493 m32c_cat_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
494 {
495   int high_bytes = TYPE_LENGTH (reg->rx->type);
496   int low_bytes  = TYPE_LENGTH (reg->ry->type);
497   /* For address arithmetic.  */
498   unsigned char *cbuf = buf;
499
500   gdb_assert (TYPE_LENGTH (reg->type) == high_bytes + low_bytes);
501
502   if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG)
503     {
504       regcache_cooked_write (cache, reg->rx->num, cbuf);
505       regcache_cooked_write (cache, reg->ry->num, cbuf + high_bytes);
506     }
507   else
508     {
509       regcache_cooked_write (cache, reg->rx->num, cbuf + low_bytes);
510       regcache_cooked_write (cache, reg->ry->num, cbuf);
511     }
512 }
513
514
515 /* Copy the value of the raw register REG from CACHE to BUF.  REG is
516    the concatenation (from most significant to least) of r3, r2, r1,
517    and r0.  */
518 static void
519 m32c_r3r2r1r0_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
520 {
521   struct gdbarch_tdep *tdep = gdbarch_tdep (reg->arch);
522   int len = TYPE_LENGTH (tdep->r0->type);
523
524   /* For address arithmetic.  */
525   unsigned char *cbuf = buf;
526
527   if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG)
528     {
529       regcache_cooked_read (cache, tdep->r0->num, cbuf + len * 3);
530       regcache_cooked_read (cache, tdep->r1->num, cbuf + len * 2);
531       regcache_cooked_read (cache, tdep->r2->num, cbuf + len * 1);
532       regcache_cooked_read (cache, tdep->r3->num, cbuf);
533     }
534   else
535     {
536       regcache_cooked_read (cache, tdep->r0->num, cbuf);
537       regcache_cooked_read (cache, tdep->r1->num, cbuf + len * 1);
538       regcache_cooked_read (cache, tdep->r2->num, cbuf + len * 2);
539       regcache_cooked_read (cache, tdep->r3->num, cbuf + len * 3);
540     }
541 }
542
543
544 /* Copy the value of the raw register REG from BUF to CACHE.  REG is
545    the concatenation (from most significant to least) of r3, r2, r1,
546    and r0.  */
547 static void
548 m32c_r3r2r1r0_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
549 {
550   struct gdbarch_tdep *tdep = gdbarch_tdep (reg->arch);
551   int len = TYPE_LENGTH (tdep->r0->type);
552
553   /* For address arithmetic.  */
554   unsigned char *cbuf = buf;
555
556   if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG)
557     {
558       regcache_cooked_write (cache, tdep->r0->num, cbuf + len * 3);
559       regcache_cooked_write (cache, tdep->r1->num, cbuf + len * 2);
560       regcache_cooked_write (cache, tdep->r2->num, cbuf + len * 1);
561       regcache_cooked_write (cache, tdep->r3->num, cbuf);
562     }
563   else
564     {
565       regcache_cooked_write (cache, tdep->r0->num, cbuf);
566       regcache_cooked_write (cache, tdep->r1->num, cbuf + len * 1);
567       regcache_cooked_write (cache, tdep->r2->num, cbuf + len * 2);
568       regcache_cooked_write (cache, tdep->r3->num, cbuf + len * 3);
569     }
570 }
571
572
573 static void
574 m32c_pseudo_register_read (struct gdbarch *arch,
575                            struct regcache *cache,
576                            int cookednum,
577                            gdb_byte *buf)
578 {
579   struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
580   struct m32c_reg *reg;
581
582   gdb_assert (0 <= cookednum && cookednum < tdep->num_regs);
583   gdb_assert (arch == get_regcache_arch (cache));
584   gdb_assert (arch == tdep->regs[cookednum].arch);
585   reg = &tdep->regs[cookednum];
586
587   reg->read (reg, cache, buf);
588 }
589
590
591 static void
592 m32c_pseudo_register_write (struct gdbarch *arch,
593                             struct regcache *cache,
594                             int cookednum,
595                             const gdb_byte *buf)
596 {
597   struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
598   struct m32c_reg *reg;
599
600   gdb_assert (0 <= cookednum && cookednum < tdep->num_regs);
601   gdb_assert (arch == get_regcache_arch (cache));
602   gdb_assert (arch == tdep->regs[cookednum].arch);
603   reg = &tdep->regs[cookednum];
604
605   reg->write (reg, cache, (void *) buf);
606 }
607
608
609 /* Add a register with the given fields to the end of ARCH's table.
610    Return a pointer to the newly added register.  */
611 static struct m32c_reg *
612 add_reg (struct gdbarch *arch,
613          const char *name,
614          struct type *type,
615          int sim_num,
616          m32c_move_reg_t *read,
617          m32c_move_reg_t *write,
618          struct m32c_reg *rx,
619          struct m32c_reg *ry,
620          int n)
621 {
622   struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
623   struct m32c_reg *r = &tdep->regs[tdep->num_regs];
624
625   gdb_assert (tdep->num_regs < M32C_MAX_NUM_REGS);
626
627   r->name           = name;
628   r->type           = type;
629   r->arch           = arch;
630   r->num            = tdep->num_regs;
631   r->sim_num        = sim_num;
632   r->dwarf_num      = -1;
633   r->general_p      = 0;
634   r->dma_p          = 0;
635   r->system_p       = 0;
636   r->save_restore_p = 0;
637   r->read           = read;
638   r->write          = write;
639   r->rx             = rx;
640   r->ry             = ry;
641   r->n              = n;
642
643   tdep->num_regs++;
644
645   return r;
646 }
647
648
649 /* Record NUM as REG's DWARF register number.  */
650 static void
651 set_dwarf_regnum (struct m32c_reg *reg, int num)
652 {
653   gdb_assert (num < M32C_MAX_NUM_REGS);
654
655   /* Update the reg->DWARF mapping.  Only count the first number
656      assigned to this register.  */
657   if (reg->dwarf_num == -1)
658     reg->dwarf_num = num;
659
660   /* Update the DWARF->reg mapping.  */
661   gdbarch_tdep (reg->arch)->dwarf_regs[num] = reg;
662 }
663
664
665 /* Mark REG as a general-purpose register, and return it.  */
666 static struct m32c_reg *
667 mark_general (struct m32c_reg *reg)
668 {
669   reg->general_p = 1;
670   return reg;
671 }
672
673
674 /* Mark REG as a DMA register, and return it.  */
675 static struct m32c_reg *
676 mark_dma (struct m32c_reg *reg)
677 {
678   reg->dma_p = 1;
679   return reg;
680 }
681
682
683 /* Mark REG as a SYSTEM register, and return it.  */
684 static struct m32c_reg *
685 mark_system (struct m32c_reg *reg)
686 {
687   reg->system_p = 1;
688   return reg;
689 }
690
691
692 /* Mark REG as a save-restore register, and return it.  */
693 static struct m32c_reg *
694 mark_save_restore (struct m32c_reg *reg)
695 {
696   reg->save_restore_p = 1;
697   return reg;
698 }
699
700
701 #define FLAGBIT_B       0x0010
702 #define FLAGBIT_U       0x0080
703
704 /* Handy macros for declaring registers.  These all evaluate to
705    pointers to the register declared.  Macros that define two
706    registers evaluate to a pointer to the first.  */
707
708 /* A raw register named NAME, with type TYPE and sim number SIM_NUM.  */
709 #define R(name, type, sim_num)                                  \
710   (add_reg (arch, (name), (type), (sim_num),                    \
711             m32c_raw_read, m32c_raw_write, NULL, NULL, 0))
712
713 /* The simulator register number for a raw register named NAME.  */
714 #define SIM(name) (m32c_sim_reg_ ## name)
715
716 /* A raw unsigned 16-bit data register named NAME.
717    NAME should be an identifier, not a string.  */
718 #define R16U(name)                                              \
719   (R(#name, tdep->uint16, SIM (name)))
720
721 /* A raw data address register named NAME.
722    NAME should be an identifier, not a string.  */
723 #define RA(name)                                                \
724   (R(#name, tdep->data_addr_reg_type, SIM (name)))
725
726 /* A raw code address register named NAME.  NAME should
727    be an identifier, not a string.  */
728 #define RC(name)                                                \
729   (R(#name, tdep->code_addr_reg_type, SIM (name)))
730
731 /* A pair of raw registers named NAME0 and NAME1, with type TYPE.
732    NAME should be an identifier, not a string.  */
733 #define RP(name, type)                          \
734   (R(#name "0", (type), SIM (name ## 0)),       \
735    R(#name "1", (type), SIM (name ## 1)) - 1)
736
737 /* A raw banked general-purpose data register named NAME.
738    NAME should be an identifier, not a string.  */
739 #define RBD(name)                                               \
740   (R(NULL, tdep->int16, SIM (name ## _bank0)),          \
741    R(NULL, tdep->int16, SIM (name ## _bank1)) - 1)
742
743 /* A raw banked data address register named NAME.
744    NAME should be an identifier, not a string.  */
745 #define RBA(name)                                               \
746   (R(NULL, tdep->data_addr_reg_type, SIM (name ## _bank0)),     \
747    R(NULL, tdep->data_addr_reg_type, SIM (name ## _bank1)) - 1)
748
749 /* A cooked register named NAME referring to a raw banked register
750    from the bank selected by the current value of FLG.  RAW_PAIR
751    should be a pointer to the first register in the banked pair.
752    NAME must be an identifier, not a string.  */
753 #define CB(name, raw_pair)                              \
754   (add_reg (arch, #name, (raw_pair)->type, 0,           \
755             m32c_banked_read, m32c_banked_write,        \
756             (raw_pair), (raw_pair + 1), FLAGBIT_B))
757
758 /* A pair of registers named NAMEH and NAMEL, of type TYPE, that
759    access the top and bottom halves of the register pointed to by
760    NAME.  NAME should be an identifier.  */
761 #define CHL(name, type)                                                 \
762   (add_reg (arch, #name "h", (type), 0,                                 \
763             m32c_part_read, m32c_part_write, name, NULL, 1),            \
764    add_reg (arch, #name "l", (type), 0,                                 \
765             m32c_part_read, m32c_part_write, name, NULL, 0) - 1)
766
767 /* A register constructed by concatenating the two registers HIGH and
768    LOW, whose name is HIGHLOW and whose type is TYPE.  */
769 #define CCAT(high, low, type)                                   \
770   (add_reg (arch, #high #low, (type), 0,                        \
771             m32c_cat_read, m32c_cat_write, (high), (low), 0))
772
773 /* Abbreviations for marking register group membership.  */
774 #define G(reg)   (mark_general (reg))
775 #define S(reg)   (mark_system  (reg))
776 #define DMA(reg) (mark_dma     (reg))
777
778
779 /* Construct the register set for ARCH.  */
780 static void
781 make_regs (struct gdbarch *arch)
782 {
783   struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
784   int mach = gdbarch_bfd_arch_info (arch)->mach;
785   int num_raw_regs;
786   int num_cooked_regs;
787
788   struct m32c_reg *r0;
789   struct m32c_reg *r1;
790   struct m32c_reg *r2;
791   struct m32c_reg *r3;
792   struct m32c_reg *a0;
793   struct m32c_reg *a1;
794   struct m32c_reg *fb;
795   struct m32c_reg *sb;
796   struct m32c_reg *sp;
797   struct m32c_reg *r0hl;
798   struct m32c_reg *r1hl;
799   struct m32c_reg *r2hl;
800   struct m32c_reg *r3hl;
801   struct m32c_reg *intbhl;
802   struct m32c_reg *r2r0;
803   struct m32c_reg *r3r1;
804   struct m32c_reg *r3r1r2r0;
805   struct m32c_reg *r3r2r1r0;
806   struct m32c_reg *a1a0;
807
808   struct m32c_reg *raw_r0_pair = RBD (r0);
809   struct m32c_reg *raw_r1_pair = RBD (r1);
810   struct m32c_reg *raw_r2_pair = RBD (r2);
811   struct m32c_reg *raw_r3_pair = RBD (r3);
812   struct m32c_reg *raw_a0_pair = RBA (a0);
813   struct m32c_reg *raw_a1_pair = RBA (a1);
814   struct m32c_reg *raw_fb_pair = RBA (fb);
815
816   /* sb is banked on the bfd_mach_m32c, but not on bfd_mach_m16c.
817      We always declare both raw registers, and deal with the distinction
818      in the pseudoregister.  */
819   struct m32c_reg *raw_sb_pair = RBA (sb);
820
821   struct m32c_reg *usp         = S (RA (usp));
822   struct m32c_reg *isp         = S (RA (isp));
823   struct m32c_reg *intb        = S (RC (intb));
824   struct m32c_reg *pc          = G (RC (pc));
825   struct m32c_reg *flg         = G (R16U (flg));
826
827   if (mach == bfd_mach_m32c)
828     {
829       struct m32c_reg *svf     = S (R16U (svf));
830       struct m32c_reg *svp     = S (RC (svp));
831       struct m32c_reg *vct     = S (RC (vct));
832
833       struct m32c_reg *dmd01   = DMA (RP (dmd, tdep->uint8));
834       struct m32c_reg *dct01   = DMA (RP (dct, tdep->uint16));
835       struct m32c_reg *drc01   = DMA (RP (drc, tdep->uint16));
836       struct m32c_reg *dma01   = DMA (RP (dma, tdep->data_addr_reg_type));
837       struct m32c_reg *dsa01   = DMA (RP (dsa, tdep->data_addr_reg_type));
838       struct m32c_reg *dra01   = DMA (RP (dra, tdep->data_addr_reg_type));
839     }
840
841   num_raw_regs = tdep->num_regs;
842
843   r0          = G (CB (r0, raw_r0_pair));
844   r1          = G (CB (r1, raw_r1_pair));
845   r2          = G (CB (r2, raw_r2_pair));
846   r3          = G (CB (r3, raw_r3_pair));
847   a0          = G (CB (a0, raw_a0_pair));
848   a1          = G (CB (a1, raw_a1_pair));
849   fb          = G (CB (fb, raw_fb_pair));
850
851   /* sb is banked on the bfd_mach_m32c, but not on bfd_mach_m16c.
852      Specify custom read/write functions that do the right thing.  */
853   sb          = G (add_reg (arch, "sb", raw_sb_pair->type, 0,
854                             m32c_sb_read, m32c_sb_write,
855                             raw_sb_pair, raw_sb_pair + 1, 0));
856
857   /* The current sp is either usp or isp, depending on the value of
858      the FLG register's U bit.  */
859   sp          = G (add_reg (arch, "sp", usp->type, 0,
860                             m32c_banked_read, m32c_banked_write,
861                             isp, usp, FLAGBIT_U));
862
863   r0hl        = CHL (r0, tdep->int8);
864   r1hl        = CHL (r1, tdep->int8);
865   r2hl        = CHL (r2, tdep->int8);
866   r3hl        = CHL (r3, tdep->int8);
867   intbhl      = CHL (intb, tdep->int16);
868
869   r2r0        = CCAT (r2,   r0,   tdep->int32);
870   r3r1        = CCAT (r3,   r1,   tdep->int32);
871   r3r1r2r0    = CCAT (r3r1, r2r0, tdep->int64);
872
873   r3r2r1r0
874     = add_reg (arch, "r3r2r1r0", tdep->int64, 0,
875                m32c_r3r2r1r0_read, m32c_r3r2r1r0_write, NULL, NULL, 0);
876
877   if (mach == bfd_mach_m16c)
878     a1a0 = CCAT (a1, a0, tdep->int32);
879   else
880     a1a0 = NULL;
881
882   num_cooked_regs = tdep->num_regs - num_raw_regs;
883
884   tdep->pc       = pc;
885   tdep->flg      = flg;
886   tdep->r0       = r0;
887   tdep->r1       = r1;
888   tdep->r2       = r2;
889   tdep->r3       = r3;
890   tdep->r2r0     = r2r0;
891   tdep->r3r2r1r0 = r3r2r1r0;
892   tdep->r3r1r2r0 = r3r1r2r0;
893   tdep->a0       = a0;
894   tdep->a1       = a1;
895   tdep->sb       = sb;
896   tdep->fb       = fb;
897   tdep->sp       = sp;
898
899   /* Set up the DWARF register table.  */
900   memset (tdep->dwarf_regs, 0, sizeof (tdep->dwarf_regs));
901   set_dwarf_regnum (r0hl + 1, 0x01);
902   set_dwarf_regnum (r0hl + 0, 0x02);
903   set_dwarf_regnum (r1hl + 1, 0x03);
904   set_dwarf_regnum (r1hl + 0, 0x04);
905   set_dwarf_regnum (r0,       0x05);
906   set_dwarf_regnum (r1,       0x06);
907   set_dwarf_regnum (r2,       0x07);
908   set_dwarf_regnum (r3,       0x08);
909   set_dwarf_regnum (a0,       0x09);
910   set_dwarf_regnum (a1,       0x0a);
911   set_dwarf_regnum (fb,       0x0b);
912   set_dwarf_regnum (sp,       0x0c);
913   set_dwarf_regnum (pc,       0x0d); /* GCC's invention */
914   set_dwarf_regnum (sb,       0x13);
915   set_dwarf_regnum (r2r0,     0x15);
916   set_dwarf_regnum (r3r1,     0x16);
917   if (a1a0)
918     set_dwarf_regnum (a1a0,   0x17);
919
920   /* Enumerate the save/restore register group.
921
922      The regcache_save and regcache_restore functions apply their read
923      function to each register in this group.
924
925      Since frame_pop supplies frame_unwind_register as its read
926      function, the registers meaningful to the Dwarf unwinder need to
927      be in this group.
928
929      On the other hand, when we make inferior calls, save_inferior_status
930      and restore_inferior_status use them to preserve the current register
931      values across the inferior call.  For this, you'd kind of like to
932      preserve all the raw registers, to protect the interrupted code from
933      any sort of bank switching the callee might have done.  But we handle
934      those cases so badly anyway --- for example, it matters whether we
935      restore FLG before or after we restore the general-purpose registers,
936      but there's no way to express that --- that it isn't worth worrying
937      about.
938
939      We omit control registers like inthl: if you call a function that
940      changes those, it's probably because you wanted that change to be
941      visible to the interrupted code.  */
942   mark_save_restore (r0);
943   mark_save_restore (r1);
944   mark_save_restore (r2);
945   mark_save_restore (r3);
946   mark_save_restore (a0);
947   mark_save_restore (a1);
948   mark_save_restore (sb);
949   mark_save_restore (fb);
950   mark_save_restore (sp);
951   mark_save_restore (pc);
952   mark_save_restore (flg);
953
954   set_gdbarch_num_regs (arch, num_raw_regs);
955   set_gdbarch_num_pseudo_regs (arch, num_cooked_regs);
956   set_gdbarch_pc_regnum (arch, pc->num);
957   set_gdbarch_sp_regnum (arch, sp->num);
958   set_gdbarch_register_name (arch, m32c_register_name);
959   set_gdbarch_register_type (arch, m32c_register_type);
960   set_gdbarch_pseudo_register_read (arch, m32c_pseudo_register_read);
961   set_gdbarch_pseudo_register_write (arch, m32c_pseudo_register_write);
962   set_gdbarch_register_sim_regno (arch, m32c_register_sim_regno);
963   set_gdbarch_stab_reg_to_regnum (arch, m32c_debug_info_reg_to_regnum);
964   set_gdbarch_dwarf2_reg_to_regnum (arch, m32c_debug_info_reg_to_regnum);
965   set_gdbarch_register_reggroup_p (arch, m32c_register_reggroup_p);
966
967   reggroup_add (arch, general_reggroup);
968   reggroup_add (arch, all_reggroup);
969   reggroup_add (arch, save_reggroup);
970   reggroup_add (arch, restore_reggroup);
971   reggroup_add (arch, system_reggroup);
972   reggroup_add (arch, m32c_dma_reggroup);
973 }
974
975
976 \f
977 /* Breakpoints.  */
978
979 static const unsigned char *
980 m32c_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
981 {
982   static unsigned char break_insn[] = { 0x00 }; /* brk */
983
984   *len = sizeof (break_insn);
985   return break_insn;
986 }
987
988
989 \f
990 /* Prologue analysis.  */
991
992 struct m32c_prologue
993 {
994   /* For consistency with the DWARF 2 .debug_frame info generated by
995      GCC, a frame's CFA is the address immediately after the saved
996      return address.  */
997
998   /* The architecture for which we generated this prologue info.  */
999   struct gdbarch *arch;
1000
1001   enum {
1002     /* This function uses a frame pointer.  */
1003     prologue_with_frame_ptr,
1004
1005     /* This function has no frame pointer.  */
1006     prologue_sans_frame_ptr,
1007
1008     /* This function sets up the stack, so its frame is the first
1009        frame on the stack.  */
1010     prologue_first_frame
1011
1012   } kind;
1013
1014   /* If KIND is prologue_with_frame_ptr, this is the offset from the
1015      CFA to where the frame pointer points.  This is always zero or
1016      negative.  */
1017   LONGEST frame_ptr_offset;
1018
1019   /* If KIND is prologue_sans_frame_ptr, the offset from the CFA to
1020      the stack pointer --- always zero or negative.
1021
1022      Calling this a "size" is a bit misleading, but given that the
1023      stack grows downwards, using offsets for everything keeps one
1024      from going completely sign-crazy: you never change anything's
1025      sign for an ADD instruction; always change the second operand's
1026      sign for a SUB instruction; and everything takes care of
1027      itself.
1028
1029      Functions that use alloca don't have a constant frame size.  But
1030      they always have frame pointers, so we must use that to find the
1031      CFA (and perhaps to unwind the stack pointer).  */
1032   LONGEST frame_size;
1033
1034   /* The address of the first instruction at which the frame has been
1035      set up and the arguments are where the debug info says they are
1036      --- as best as we can tell.  */
1037   CORE_ADDR prologue_end;
1038
1039   /* reg_offset[R] is the offset from the CFA at which register R is
1040      saved, or 1 if register R has not been saved.  (Real values are
1041      always zero or negative.)  */
1042   LONGEST reg_offset[M32C_MAX_NUM_REGS];
1043 };
1044
1045
1046 /* The longest I've seen, anyway.  */
1047 #define M32C_MAX_INSN_LEN (9)
1048
1049 /* Processor state, for the prologue analyzer.  */
1050 struct m32c_pv_state
1051 {
1052   struct gdbarch *arch;
1053   pv_t r0, r1, r2, r3;
1054   pv_t a0, a1;
1055   pv_t sb, fb, sp;
1056   pv_t pc;
1057   struct pv_area *stack;
1058
1059   /* Bytes from the current PC, the address they were read from,
1060      and the address of the next unconsumed byte.  */
1061   gdb_byte insn[M32C_MAX_INSN_LEN];
1062   CORE_ADDR scan_pc, next_addr;
1063 };
1064
1065
1066 /* Push VALUE on STATE's stack, occupying SIZE bytes.  Return zero if
1067    all went well, or non-zero if simulating the action would trash our
1068    state.  */
1069 static int
1070 m32c_pv_push (struct m32c_pv_state *state, pv_t value, int size)
1071 {
1072   if (pv_area_store_would_trash (state->stack, state->sp))
1073     return 1;
1074
1075   state->sp = pv_add_constant (state->sp, -size);
1076   pv_area_store (state->stack, state->sp, size, value);
1077
1078   return 0;
1079 }
1080
1081
1082 /* A source or destination location for an m16c or m32c
1083    instruction.  */
1084 struct srcdest
1085 {
1086   /* If srcdest_reg, the location is a register pointed to by REG.
1087      If srcdest_partial_reg, the location is part of a register pointed
1088      to by REG.  We don't try to handle this too well.
1089      If srcdest_mem, the location is memory whose address is ADDR.  */
1090   enum { srcdest_reg, srcdest_partial_reg, srcdest_mem } kind;
1091   pv_t *reg, addr;
1092 };
1093
1094
1095 /* Return the SIZE-byte value at LOC in STATE.  */
1096 static pv_t
1097 m32c_srcdest_fetch (struct m32c_pv_state *state, struct srcdest loc, int size)
1098 {
1099   if (loc.kind == srcdest_mem)
1100     return pv_area_fetch (state->stack, loc.addr, size);
1101   else if (loc.kind == srcdest_partial_reg)
1102     return pv_unknown ();
1103   else
1104     return *loc.reg;
1105 }
1106
1107
1108 /* Write VALUE, a SIZE-byte value, to LOC in STATE.  Return zero if
1109    all went well, or non-zero if simulating the store would trash our
1110    state.  */
1111 static int
1112 m32c_srcdest_store (struct m32c_pv_state *state, struct srcdest loc,
1113                     pv_t value, int size)
1114 {
1115   if (loc.kind == srcdest_mem)
1116     {
1117       if (pv_area_store_would_trash (state->stack, loc.addr))
1118         return 1;
1119       pv_area_store (state->stack, loc.addr, size, value);
1120     }
1121   else if (loc.kind == srcdest_partial_reg)
1122     *loc.reg = pv_unknown ();
1123   else
1124     *loc.reg = value;
1125
1126   return 0;
1127 }
1128
1129
1130 static int
1131 m32c_sign_ext (int v, int bits)
1132 {
1133   int mask = 1 << (bits - 1);
1134   return (v ^ mask) - mask;
1135 }
1136
1137 static unsigned int
1138 m32c_next_byte (struct m32c_pv_state *st)
1139 {
1140   gdb_assert (st->next_addr - st->scan_pc < sizeof (st->insn));
1141   return st->insn[st->next_addr++ - st->scan_pc];
1142 }
1143
1144 static int
1145 m32c_udisp8 (struct m32c_pv_state *st)
1146 {
1147   return m32c_next_byte (st);
1148 }
1149
1150
1151 static int
1152 m32c_sdisp8 (struct m32c_pv_state *st)
1153 {
1154   return m32c_sign_ext (m32c_next_byte (st), 8);
1155 }
1156
1157
1158 static int
1159 m32c_udisp16 (struct m32c_pv_state *st)
1160 {
1161   int low  = m32c_next_byte (st);
1162   int high = m32c_next_byte (st);
1163
1164   return low + (high << 8);
1165 }
1166
1167
1168 static int
1169 m32c_sdisp16 (struct m32c_pv_state *st)
1170 {
1171   int low  = m32c_next_byte (st);
1172   int high = m32c_next_byte (st);
1173
1174   return m32c_sign_ext (low + (high << 8), 16);
1175 }
1176
1177
1178 static int
1179 m32c_udisp24 (struct m32c_pv_state *st)
1180 {
1181   int low  = m32c_next_byte (st);
1182   int mid  = m32c_next_byte (st);
1183   int high = m32c_next_byte (st);
1184
1185   return low + (mid << 8) + (high << 16);
1186 }
1187
1188
1189 /* Extract the 'source' field from an m32c MOV.size:G-format instruction.  */
1190 static int
1191 m32c_get_src23 (unsigned char *i)
1192 {
1193   return (((i[0] & 0x70) >> 2)
1194           | ((i[1] & 0x30) >> 4));
1195 }
1196
1197
1198 /* Extract the 'dest' field from an m32c MOV.size:G-format instruction.  */
1199 static int
1200 m32c_get_dest23 (unsigned char *i)
1201 {
1202   return (((i[0] & 0x0e) << 1)
1203           | ((i[1] & 0xc0) >> 6));
1204 }
1205
1206
1207 static struct srcdest
1208 m32c_decode_srcdest4 (struct m32c_pv_state *st,
1209                       int code, int size)
1210 {
1211   struct srcdest sd;
1212
1213   if (code < 6)
1214     sd.kind = (size == 2 ? srcdest_reg : srcdest_partial_reg);
1215   else
1216     sd.kind = srcdest_mem;
1217
1218   sd.addr = pv_unknown ();
1219   sd.reg = 0;
1220
1221   switch (code)
1222     {
1223     case 0x0: sd.reg = (size == 1 ? &st->r0 : &st->r0); break;
1224     case 0x1: sd.reg = (size == 1 ? &st->r0 : &st->r1); break;
1225     case 0x2: sd.reg = (size == 1 ? &st->r1 : &st->r2); break;
1226     case 0x3: sd.reg = (size == 1 ? &st->r1 : &st->r3); break;
1227
1228     case 0x4: sd.reg = &st->a0; break;
1229     case 0x5: sd.reg = &st->a1; break;
1230
1231     case 0x6: sd.addr = st->a0; break;
1232     case 0x7: sd.addr = st->a1; break;
1233
1234     case 0x8: sd.addr = pv_add_constant (st->a0, m32c_udisp8 (st)); break;
1235     case 0x9: sd.addr = pv_add_constant (st->a1, m32c_udisp8 (st)); break;
1236     case 0xa: sd.addr = pv_add_constant (st->sb, m32c_udisp8 (st)); break;
1237     case 0xb: sd.addr = pv_add_constant (st->fb, m32c_sdisp8 (st)); break;
1238
1239     case 0xc: sd.addr = pv_add_constant (st->a0, m32c_udisp16 (st)); break;
1240     case 0xd: sd.addr = pv_add_constant (st->a1, m32c_udisp16 (st)); break;
1241     case 0xe: sd.addr = pv_add_constant (st->sb, m32c_udisp16 (st)); break;
1242     case 0xf: sd.addr = pv_constant (m32c_udisp16 (st)); break;
1243
1244     default:
1245       gdb_assert (0);
1246     }
1247
1248   return sd;
1249 }
1250
1251
1252 static struct srcdest
1253 m32c_decode_sd23 (struct m32c_pv_state *st, int code, int size, int ind)
1254 {
1255   struct srcdest sd;
1256
1257   sd.addr = pv_unknown ();
1258   sd.reg = 0;
1259
1260   switch (code)
1261     {
1262     case 0x12:
1263     case 0x13:
1264     case 0x10:
1265     case 0x11:
1266       sd.kind = (size == 1) ? srcdest_partial_reg : srcdest_reg;
1267       break;
1268
1269     case 0x02:
1270     case 0x03:
1271       sd.kind = (size == 4) ? srcdest_reg : srcdest_partial_reg;
1272       break;
1273
1274     default:
1275       sd.kind = srcdest_mem;
1276       break;
1277
1278     }
1279
1280   switch (code)
1281     {
1282     case 0x12: sd.reg = &st->r0; break;
1283     case 0x13: sd.reg = &st->r1; break;
1284     case 0x10: sd.reg = ((size == 1) ? &st->r0 : &st->r2); break;
1285     case 0x11: sd.reg = ((size == 1) ? &st->r1 : &st->r3); break;
1286     case 0x02: sd.reg = &st->a0; break;
1287     case 0x03: sd.reg = &st->a1; break;
1288
1289     case 0x00: sd.addr = st->a0; break;
1290     case 0x01: sd.addr = st->a1; break;
1291     case 0x04: sd.addr = pv_add_constant (st->a0, m32c_udisp8 (st)); break;
1292     case 0x05: sd.addr = pv_add_constant (st->a1, m32c_udisp8 (st)); break;
1293     case 0x06: sd.addr = pv_add_constant (st->sb, m32c_udisp8 (st)); break;
1294     case 0x07: sd.addr = pv_add_constant (st->fb, m32c_sdisp8 (st)); break;
1295     case 0x08: sd.addr = pv_add_constant (st->a0, m32c_udisp16 (st)); break;
1296     case 0x09: sd.addr = pv_add_constant (st->a1, m32c_udisp16 (st)); break;
1297     case 0x0a: sd.addr = pv_add_constant (st->sb, m32c_udisp16 (st)); break;
1298     case 0x0b: sd.addr = pv_add_constant (st->fb, m32c_sdisp16 (st)); break;
1299     case 0x0c: sd.addr = pv_add_constant (st->a0, m32c_udisp24 (st)); break;
1300     case 0x0d: sd.addr = pv_add_constant (st->a1, m32c_udisp24 (st)); break;
1301     case 0x0f: sd.addr = pv_constant (m32c_udisp16 (st)); break;
1302     case 0x0e: sd.addr = pv_constant (m32c_udisp24 (st)); break;
1303     default:
1304       gdb_assert (0);
1305     }
1306
1307   if (ind)
1308     {
1309       sd.addr = m32c_srcdest_fetch (st, sd, 4);
1310       sd.kind = srcdest_mem;
1311     }
1312
1313   return sd;
1314 }
1315
1316
1317 /* The r16c and r32c machines have instructions with similar
1318    semantics, but completely different machine language encodings.  So
1319    we break out the semantics into their own functions, and leave
1320    machine-specific decoding in m32c_analyze_prologue.
1321
1322    The following functions all expect their arguments already decoded,
1323    and they all return zero if analysis should continue past this
1324    instruction, or non-zero if analysis should stop.  */
1325
1326
1327 /* Simulate an 'enter SIZE' instruction in STATE.  */
1328 static int
1329 m32c_pv_enter (struct m32c_pv_state *state, int size)
1330 {
1331   struct gdbarch_tdep *tdep = gdbarch_tdep (state->arch);
1332
1333   /* If simulating this store would require us to forget
1334      everything we know about the stack frame in the name of
1335      accuracy, it would be better to just quit now.  */
1336   if (pv_area_store_would_trash (state->stack, state->sp))
1337     return 1;
1338
1339   if (m32c_pv_push (state, state->fb, tdep->push_addr_bytes))
1340     return 1;
1341   state->fb = state->sp;
1342   state->sp = pv_add_constant (state->sp, -size);
1343
1344   return 0;
1345 }
1346
1347
1348 static int
1349 m32c_pv_pushm_one (struct m32c_pv_state *state, pv_t reg,
1350                    int bit, int src, int size)
1351 {
1352   if (bit & src)
1353     {
1354       if (m32c_pv_push (state, reg, size))
1355         return 1;
1356     }
1357
1358   return 0;
1359 }
1360
1361
1362 /* Simulate a 'pushm SRC' instruction in STATE.  */
1363 static int
1364 m32c_pv_pushm (struct m32c_pv_state *state, int src)
1365 {
1366   struct gdbarch_tdep *tdep = gdbarch_tdep (state->arch);
1367
1368   /* The bits in SRC indicating which registers to save are:
1369      r0 r1 r2 r3 a0 a1 sb fb */
1370   return
1371     (   m32c_pv_pushm_one (state, state->fb, 0x01, src, tdep->push_addr_bytes)
1372      || m32c_pv_pushm_one (state, state->sb, 0x02, src, tdep->push_addr_bytes)
1373      || m32c_pv_pushm_one (state, state->a1, 0x04, src, tdep->push_addr_bytes)
1374      || m32c_pv_pushm_one (state, state->a0, 0x08, src, tdep->push_addr_bytes)
1375      || m32c_pv_pushm_one (state, state->r3, 0x10, src, 2)
1376      || m32c_pv_pushm_one (state, state->r2, 0x20, src, 2)
1377      || m32c_pv_pushm_one (state, state->r1, 0x40, src, 2)
1378      || m32c_pv_pushm_one (state, state->r0, 0x80, src, 2));
1379 }
1380
1381 /* Return non-zero if VALUE is the first incoming argument register.  */
1382
1383 static int
1384 m32c_is_1st_arg_reg (struct m32c_pv_state *state, pv_t value)
1385 {
1386   struct gdbarch_tdep *tdep = gdbarch_tdep (state->arch);
1387   return (value.kind == pvk_register
1388           && (gdbarch_bfd_arch_info (state->arch)->mach == bfd_mach_m16c
1389               ? (value.reg == tdep->r1->num)
1390               : (value.reg == tdep->r0->num))
1391           && value.k == 0);
1392 }
1393
1394 /* Return non-zero if VALUE is an incoming argument register.  */
1395
1396 static int
1397 m32c_is_arg_reg (struct m32c_pv_state *state, pv_t value)
1398 {
1399   struct gdbarch_tdep *tdep = gdbarch_tdep (state->arch);
1400   return (value.kind == pvk_register
1401           && (gdbarch_bfd_arch_info (state->arch)->mach == bfd_mach_m16c
1402               ? (value.reg == tdep->r1->num || value.reg == tdep->r2->num)
1403               : (value.reg == tdep->r0->num))
1404           && value.k == 0);
1405 }
1406
1407 /* Return non-zero if a store of VALUE to LOC is probably spilling an
1408    argument register to its stack slot in STATE.  Such instructions
1409    should be included in the prologue, if possible.
1410
1411    The store is a spill if:
1412    - the value being stored is the original value of an argument register;
1413    - the value has not already been stored somewhere in STACK; and
1414    - LOC is a stack slot (e.g., a memory location whose address is
1415      relative to the original value of the SP).  */
1416
1417 static int
1418 m32c_is_arg_spill (struct m32c_pv_state *st, 
1419                    struct srcdest loc, 
1420                    pv_t value)
1421 {
1422   struct gdbarch_tdep *tdep = gdbarch_tdep (st->arch);
1423
1424   return (m32c_is_arg_reg (st, value)
1425           && loc.kind == srcdest_mem
1426           && pv_is_register (loc.addr, tdep->sp->num)
1427           && ! pv_area_find_reg (st->stack, st->arch, value.reg, 0));
1428 }
1429
1430 /* Return non-zero if a store of VALUE to LOC is probably 
1431    copying the struct return address into an address register
1432    for immediate use.  This is basically a "spill" into the
1433    address register, instead of onto the stack. 
1434
1435    The prerequisites are:
1436    - value being stored is original value of the FIRST arg register;
1437    - value has not already been stored on stack; and
1438    - LOC is an address register (a0 or a1).  */
1439
1440 static int
1441 m32c_is_struct_return (struct m32c_pv_state *st,
1442                        struct srcdest loc, 
1443                        pv_t value)
1444 {
1445   struct gdbarch_tdep *tdep = gdbarch_tdep (st->arch);
1446
1447   return (m32c_is_1st_arg_reg (st, value)
1448           && !pv_area_find_reg (st->stack, st->arch, value.reg, 0)
1449           && loc.kind == srcdest_reg
1450           && (pv_is_register (*loc.reg, tdep->a0->num)
1451               || pv_is_register (*loc.reg, tdep->a1->num)));
1452 }
1453
1454 /* Return non-zero if a 'pushm' saving the registers indicated by SRC
1455    was a register save:
1456    - all the named registers should have their original values, and
1457    - the stack pointer should be at a constant offset from the
1458      original stack pointer.  */
1459 static int
1460 m32c_pushm_is_reg_save (struct m32c_pv_state *st, int src)
1461 {
1462   struct gdbarch_tdep *tdep = gdbarch_tdep (st->arch);
1463   /* The bits in SRC indicating which registers to save are:
1464      r0 r1 r2 r3 a0 a1 sb fb */
1465   return
1466     (pv_is_register (st->sp, tdep->sp->num)
1467      && (! (src & 0x01) || pv_is_register_k (st->fb, tdep->fb->num, 0))
1468      && (! (src & 0x02) || pv_is_register_k (st->sb, tdep->sb->num, 0))
1469      && (! (src & 0x04) || pv_is_register_k (st->a1, tdep->a1->num, 0))
1470      && (! (src & 0x08) || pv_is_register_k (st->a0, tdep->a0->num, 0))
1471      && (! (src & 0x10) || pv_is_register_k (st->r3, tdep->r3->num, 0))
1472      && (! (src & 0x20) || pv_is_register_k (st->r2, tdep->r2->num, 0))
1473      && (! (src & 0x40) || pv_is_register_k (st->r1, tdep->r1->num, 0))
1474      && (! (src & 0x80) || pv_is_register_k (st->r0, tdep->r0->num, 0)));
1475 }
1476
1477
1478 /* Function for finding saved registers in a 'struct pv_area'; we pass
1479    this to pv_area_scan.
1480
1481    If VALUE is a saved register, ADDR says it was saved at a constant
1482    offset from the frame base, and SIZE indicates that the whole
1483    register was saved, record its offset in RESULT_UNTYPED.  */
1484 static void
1485 check_for_saved (void *prologue_untyped, pv_t addr, CORE_ADDR size, pv_t value)
1486 {
1487   struct m32c_prologue *prologue = (struct m32c_prologue *) prologue_untyped;
1488   struct gdbarch *arch = prologue->arch;
1489   struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
1490
1491   /* Is this the unchanged value of some register being saved on the
1492      stack?  */
1493   if (value.kind == pvk_register
1494       && value.k == 0
1495       && pv_is_register (addr, tdep->sp->num))
1496     {
1497       /* Some registers require special handling: they're saved as a
1498          larger value than the register itself.  */
1499       CORE_ADDR saved_size = register_size (arch, value.reg);
1500
1501       if (value.reg == tdep->pc->num)
1502         saved_size = tdep->ret_addr_bytes;
1503       else if (register_type (arch, value.reg)
1504                == tdep->data_addr_reg_type)
1505         saved_size = tdep->push_addr_bytes;
1506
1507       if (size == saved_size)
1508         {
1509           /* Find which end of the saved value corresponds to our
1510              register.  */
1511           if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG)
1512             prologue->reg_offset[value.reg]
1513               = (addr.k + saved_size - register_size (arch, value.reg));
1514           else
1515             prologue->reg_offset[value.reg] = addr.k;
1516         }
1517     }
1518 }
1519
1520
1521 /* Analyze the function prologue for ARCH at START, going no further
1522    than LIMIT, and place a description of what we found in
1523    PROLOGUE.  */
1524 static void
1525 m32c_analyze_prologue (struct gdbarch *arch,
1526                        CORE_ADDR start, CORE_ADDR limit,
1527                        struct m32c_prologue *prologue)
1528 {
1529   struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
1530   unsigned long mach = gdbarch_bfd_arch_info (arch)->mach;
1531   CORE_ADDR after_last_frame_related_insn;
1532   struct cleanup *back_to;
1533   struct m32c_pv_state st;
1534
1535   st.arch = arch;
1536   st.r0 = pv_register (tdep->r0->num, 0);
1537   st.r1 = pv_register (tdep->r1->num, 0);
1538   st.r2 = pv_register (tdep->r2->num, 0);
1539   st.r3 = pv_register (tdep->r3->num, 0);
1540   st.a0 = pv_register (tdep->a0->num, 0);
1541   st.a1 = pv_register (tdep->a1->num, 0);
1542   st.sb = pv_register (tdep->sb->num, 0);
1543   st.fb = pv_register (tdep->fb->num, 0);
1544   st.sp = pv_register (tdep->sp->num, 0);
1545   st.pc = pv_register (tdep->pc->num, 0);
1546   st.stack = make_pv_area (tdep->sp->num, gdbarch_addr_bit (arch));
1547   back_to = make_cleanup_free_pv_area (st.stack);
1548
1549   /* Record that the call instruction has saved the return address on
1550      the stack.  */
1551   m32c_pv_push (&st, st.pc, tdep->ret_addr_bytes);
1552
1553   memset (prologue, 0, sizeof (*prologue));
1554   prologue->arch = arch;
1555   {
1556     int i;
1557     for (i = 0; i < M32C_MAX_NUM_REGS; i++)
1558       prologue->reg_offset[i] = 1;
1559   }
1560
1561   st.scan_pc = after_last_frame_related_insn = start;
1562
1563   while (st.scan_pc < limit)
1564     {
1565       pv_t pre_insn_fb = st.fb;
1566       pv_t pre_insn_sp = st.sp;
1567
1568       /* In theory we could get in trouble by trying to read ahead
1569          here, when we only know we're expecting one byte.  In
1570          practice I doubt anyone will care, and it makes the rest of
1571          the code easier.  */
1572       if (target_read_memory (st.scan_pc, st.insn, sizeof (st.insn)))
1573         /* If we can't fetch the instruction from memory, stop here
1574            and hope for the best.  */
1575         break;
1576       st.next_addr = st.scan_pc;
1577
1578       /* The assembly instructions are written as they appear in the
1579          section of the processor manuals that describe the
1580          instruction encodings.
1581
1582          When a single assembly language instruction has several
1583          different machine-language encodings, the manual
1584          distinguishes them by a number in parens, before the
1585          mnemonic.  Those numbers are included, as well.
1586
1587          The srcdest decoding instructions have the same names as the
1588          analogous functions in the simulator.  */
1589       if (mach == bfd_mach_m16c)
1590         {
1591           /* (1) ENTER #imm8 */
1592           if (st.insn[0] == 0x7c && st.insn[1] == 0xf2)
1593             {
1594               if (m32c_pv_enter (&st, st.insn[2]))
1595                 break;
1596               st.next_addr += 3;
1597             }
1598           /* (1) PUSHM src */
1599           else if (st.insn[0] == 0xec)
1600             {
1601               int src = st.insn[1];
1602               if (m32c_pv_pushm (&st, src))
1603                 break;
1604               st.next_addr += 2;
1605
1606               if (m32c_pushm_is_reg_save (&st, src))
1607                 after_last_frame_related_insn = st.next_addr;
1608             }
1609
1610           /* (6) MOV.size:G src, dest */
1611           else if ((st.insn[0] & 0xfe) == 0x72)
1612             {
1613               int size = (st.insn[0] & 0x01) ? 2 : 1;
1614               struct srcdest src;
1615               struct srcdest dest;
1616               pv_t src_value;
1617               st.next_addr += 2;
1618
1619               src
1620                 = m32c_decode_srcdest4 (&st, (st.insn[1] >> 4) & 0xf, size);
1621               dest
1622                 = m32c_decode_srcdest4 (&st, st.insn[1] & 0xf, size);
1623               src_value = m32c_srcdest_fetch (&st, src, size);
1624
1625               if (m32c_is_arg_spill (&st, dest, src_value))
1626                 after_last_frame_related_insn = st.next_addr;
1627               else if (m32c_is_struct_return (&st, dest, src_value))
1628                 after_last_frame_related_insn = st.next_addr;
1629
1630               if (m32c_srcdest_store (&st, dest, src_value, size))
1631                 break;
1632             }
1633
1634           /* (1) LDC #IMM16, sp */
1635           else if (st.insn[0] == 0xeb
1636                    && st.insn[1] == 0x50)
1637             {
1638               st.next_addr += 2;
1639               st.sp = pv_constant (m32c_udisp16 (&st));
1640             }
1641
1642           else
1643             /* We've hit some instruction we don't know how to simulate.
1644                Strictly speaking, we should set every value we're
1645                tracking to "unknown".  But we'll be optimistic, assume
1646                that we have enough information already, and stop
1647                analysis here.  */
1648             break;
1649         }
1650       else
1651         {
1652           int src_indirect = 0;
1653           int dest_indirect = 0;
1654           int i = 0;
1655
1656           gdb_assert (mach == bfd_mach_m32c);
1657
1658           /* Check for prefix bytes indicating indirect addressing.  */
1659           if (st.insn[0] == 0x41)
1660             {
1661               src_indirect = 1;
1662               i++;
1663             }
1664           else if (st.insn[0] == 0x09)
1665             {
1666               dest_indirect = 1;
1667               i++;
1668             }
1669           else if (st.insn[0] == 0x49)
1670             {
1671               src_indirect = dest_indirect = 1;
1672               i++;
1673             }
1674
1675           /* (1) ENTER #imm8 */
1676           if (st.insn[i] == 0xec)
1677             {
1678               if (m32c_pv_enter (&st, st.insn[i + 1]))
1679                 break;
1680               st.next_addr += 2;
1681             }
1682
1683           /* (1) PUSHM src */
1684           else if (st.insn[i] == 0x8f)
1685             {
1686               int src = st.insn[i + 1];
1687               if (m32c_pv_pushm (&st, src))
1688                 break;
1689               st.next_addr += 2;
1690
1691               if (m32c_pushm_is_reg_save (&st, src))
1692                 after_last_frame_related_insn = st.next_addr;
1693             }
1694
1695           /* (7) MOV.size:G src, dest */
1696           else if ((st.insn[i] & 0x80) == 0x80
1697                    && (st.insn[i + 1] & 0x0f) == 0x0b
1698                    && m32c_get_src23 (&st.insn[i]) < 20
1699                    && m32c_get_dest23 (&st.insn[i]) < 20)
1700             {
1701               struct srcdest src;
1702               struct srcdest dest;
1703               pv_t src_value;
1704               int bw = st.insn[i] & 0x01;
1705               int size = bw ? 2 : 1;
1706               st.next_addr += 2;
1707
1708               src
1709                 = m32c_decode_sd23 (&st, m32c_get_src23 (&st.insn[i]),
1710                                     size, src_indirect);
1711               dest
1712                 = m32c_decode_sd23 (&st, m32c_get_dest23 (&st.insn[i]),
1713                                     size, dest_indirect);
1714               src_value = m32c_srcdest_fetch (&st, src, size);
1715
1716               if (m32c_is_arg_spill (&st, dest, src_value))
1717                 after_last_frame_related_insn = st.next_addr;
1718
1719               if (m32c_srcdest_store (&st, dest, src_value, size))
1720                 break;
1721             }
1722           /* (2) LDC #IMM24, sp */
1723           else if (st.insn[i] == 0xd5
1724                    && st.insn[i + 1] == 0x29)
1725             {
1726               st.next_addr += 2;
1727               st.sp = pv_constant (m32c_udisp24 (&st));
1728             }
1729           else
1730             /* We've hit some instruction we don't know how to simulate.
1731                Strictly speaking, we should set every value we're
1732                tracking to "unknown".  But we'll be optimistic, assume
1733                that we have enough information already, and stop
1734                analysis here.  */
1735             break;
1736         }
1737
1738       /* If this instruction changed the FB or decreased the SP (i.e.,
1739          allocated more stack space), then this may be a good place to
1740          declare the prologue finished.  However, there are some
1741          exceptions:
1742
1743          - If the instruction just changed the FB back to its original
1744            value, then that's probably a restore instruction.  The
1745            prologue should definitely end before that.
1746
1747          - If the instruction increased the value of the SP (that is,
1748            shrunk the frame), then it's probably part of a frame
1749            teardown sequence, and the prologue should end before
1750            that.  */
1751
1752       if (! pv_is_identical (st.fb, pre_insn_fb))
1753         {
1754           if (! pv_is_register_k (st.fb, tdep->fb->num, 0))
1755             after_last_frame_related_insn = st.next_addr;
1756         }
1757       else if (! pv_is_identical (st.sp, pre_insn_sp))
1758         {
1759           /* The comparison of the constants looks odd, there, because
1760              .k is unsigned.  All it really means is that the SP is
1761              lower than it was before the instruction.  */
1762           if (   pv_is_register (pre_insn_sp, tdep->sp->num)
1763               && pv_is_register (st.sp,       tdep->sp->num)
1764               && ((pre_insn_sp.k - st.sp.k) < (st.sp.k - pre_insn_sp.k)))
1765             after_last_frame_related_insn = st.next_addr;
1766         }
1767
1768       st.scan_pc = st.next_addr;
1769     }
1770
1771   /* Did we load a constant value into the stack pointer?  */
1772   if (pv_is_constant (st.sp))
1773     prologue->kind = prologue_first_frame;
1774
1775   /* Alternatively, did we initialize the frame pointer?  Remember
1776      that the CFA is the address after the return address.  */
1777   if (pv_is_register (st.fb, tdep->sp->num))
1778     {
1779       prologue->kind = prologue_with_frame_ptr;
1780       prologue->frame_ptr_offset = st.fb.k;
1781     }
1782
1783   /* Is the frame size a known constant?  Remember that frame_size is
1784      actually the offset from the CFA to the SP (i.e., a negative
1785      value).  */
1786   else if (pv_is_register (st.sp, tdep->sp->num))
1787     {
1788       prologue->kind = prologue_sans_frame_ptr;
1789       prologue->frame_size = st.sp.k;
1790     }
1791
1792   /* We haven't been able to make sense of this function's frame.  Treat
1793      it as the first frame.  */
1794   else
1795     prologue->kind = prologue_first_frame;
1796
1797   /* Record where all the registers were saved.  */
1798   pv_area_scan (st.stack, check_for_saved, (void *) prologue);
1799
1800   prologue->prologue_end = after_last_frame_related_insn;
1801
1802   do_cleanups (back_to);
1803 }
1804
1805
1806 static CORE_ADDR
1807 m32c_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
1808 {
1809   char *name;
1810   CORE_ADDR func_addr, func_end, sal_end;
1811   struct m32c_prologue p;
1812
1813   /* Try to find the extent of the function that contains IP.  */
1814   if (! find_pc_partial_function (ip, &name, &func_addr, &func_end))
1815     return ip;
1816
1817   /* Find end by prologue analysis.  */
1818   m32c_analyze_prologue (gdbarch, ip, func_end, &p);
1819   /* Find end by line info.  */
1820   sal_end = skip_prologue_using_sal (gdbarch, ip);
1821   /* Return whichever is lower.  */
1822   if (sal_end != 0 && sal_end != ip && sal_end < p.prologue_end)
1823     return sal_end;
1824   else
1825     return p.prologue_end;
1826 }
1827
1828
1829 \f
1830 /* Stack unwinding.  */
1831
1832 static struct m32c_prologue *
1833 m32c_analyze_frame_prologue (struct frame_info *this_frame,
1834                              void **this_prologue_cache)
1835 {
1836   if (! *this_prologue_cache)
1837     {
1838       CORE_ADDR func_start = get_frame_func (this_frame);
1839       CORE_ADDR stop_addr = get_frame_pc (this_frame);
1840
1841       /* If we couldn't find any function containing the PC, then
1842          just initialize the prologue cache, but don't do anything.  */
1843       if (! func_start)
1844         stop_addr = func_start;
1845
1846       *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct m32c_prologue);
1847       m32c_analyze_prologue (get_frame_arch (this_frame),
1848                              func_start, stop_addr, *this_prologue_cache);
1849     }
1850
1851   return *this_prologue_cache;
1852 }
1853
1854
1855 static CORE_ADDR
1856 m32c_frame_base (struct frame_info *this_frame,
1857                 void **this_prologue_cache)
1858 {
1859   struct m32c_prologue *p
1860     = m32c_analyze_frame_prologue (this_frame, this_prologue_cache);
1861   struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
1862
1863   /* In functions that use alloca, the distance between the stack
1864      pointer and the frame base varies dynamically, so we can't use
1865      the SP plus static information like prologue analysis to find the
1866      frame base.  However, such functions must have a frame pointer,
1867      to be able to restore the SP on exit.  So whenever we do have a
1868      frame pointer, use that to find the base.  */
1869   switch (p->kind)
1870     {
1871     case prologue_with_frame_ptr:
1872       {
1873         CORE_ADDR fb
1874           = get_frame_register_unsigned (this_frame, tdep->fb->num);
1875         return fb - p->frame_ptr_offset;
1876       }
1877
1878     case prologue_sans_frame_ptr:
1879       {
1880         CORE_ADDR sp
1881           = get_frame_register_unsigned (this_frame, tdep->sp->num);
1882         return sp - p->frame_size;
1883       }
1884
1885     case prologue_first_frame:
1886       return 0;
1887
1888     default:
1889       gdb_assert (0);
1890     }
1891 }
1892
1893
1894 static void
1895 m32c_this_id (struct frame_info *this_frame,
1896               void **this_prologue_cache,
1897               struct frame_id *this_id)
1898 {
1899   CORE_ADDR base = m32c_frame_base (this_frame, this_prologue_cache);
1900
1901   if (base)
1902     *this_id = frame_id_build (base, get_frame_func (this_frame));
1903   /* Otherwise, leave it unset, and that will terminate the backtrace.  */
1904 }
1905
1906
1907 static struct value *
1908 m32c_prev_register (struct frame_info *this_frame,
1909                     void **this_prologue_cache, int regnum)
1910 {
1911   struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
1912   struct m32c_prologue *p
1913     = m32c_analyze_frame_prologue (this_frame, this_prologue_cache);
1914   CORE_ADDR frame_base = m32c_frame_base (this_frame, this_prologue_cache);
1915   int reg_size = register_size (get_frame_arch (this_frame), regnum);
1916
1917   if (regnum == tdep->sp->num)
1918     return frame_unwind_got_constant (this_frame, regnum, frame_base);
1919
1920   /* If prologue analysis says we saved this register somewhere,
1921      return a description of the stack slot holding it.  */
1922   if (p->reg_offset[regnum] != 1)
1923     return frame_unwind_got_memory (this_frame, regnum,
1924                                     frame_base + p->reg_offset[regnum]);
1925
1926   /* Otherwise, presume we haven't changed the value of this
1927      register, and get it from the next frame.  */
1928   return frame_unwind_got_register (this_frame, regnum, regnum);
1929 }
1930
1931
1932 static const struct frame_unwind m32c_unwind = {
1933   NORMAL_FRAME,
1934   m32c_this_id,
1935   m32c_prev_register,
1936   NULL,
1937   default_frame_sniffer
1938 };
1939
1940
1941 static CORE_ADDR
1942 m32c_unwind_pc (struct gdbarch *arch, struct frame_info *next_frame)
1943 {
1944   struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
1945   return frame_unwind_register_unsigned (next_frame, tdep->pc->num);
1946 }
1947
1948
1949 static CORE_ADDR
1950 m32c_unwind_sp (struct gdbarch *arch, struct frame_info *next_frame)
1951 {
1952   struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
1953   return frame_unwind_register_unsigned (next_frame, tdep->sp->num);
1954 }
1955
1956 \f
1957 /* Inferior calls.  */
1958
1959 /* The calling conventions, according to GCC:
1960
1961    r8c, m16c
1962    ---------
1963    First arg may be passed in r1l or r1 if it (1) fits (QImode or
1964    HImode), (2) is named, and (3) is an integer or pointer type (no
1965    structs, floats, etc).  Otherwise, it's passed on the stack.
1966
1967    Second arg may be passed in r2, same restrictions (but not QImode),
1968    even if the first arg is passed on the stack.
1969
1970    Third and further args are passed on the stack.  No padding is
1971    used, stack "alignment" is 8 bits.
1972
1973    m32cm, m32c
1974    -----------
1975
1976    First arg may be passed in r0l or r0, same restrictions as above.
1977
1978    Second and further args are passed on the stack.  Padding is used
1979    after QImode parameters (i.e. lower-addressed byte is the value,
1980    higher-addressed byte is the padding), stack "alignment" is 16
1981    bits.  */
1982
1983
1984 /* Return true if TYPE is a type that can be passed in registers.  (We
1985    ignore the size, and pay attention only to the type code;
1986    acceptable sizes depends on which register is being considered to
1987    hold it.)  */
1988 static int
1989 m32c_reg_arg_type (struct type *type)
1990 {
1991   enum type_code code = TYPE_CODE (type);
1992
1993   return (code == TYPE_CODE_INT
1994           || code == TYPE_CODE_ENUM
1995           || code == TYPE_CODE_PTR
1996           || code == TYPE_CODE_REF
1997           || code == TYPE_CODE_BOOL
1998           || code == TYPE_CODE_CHAR);
1999 }
2000
2001
2002 static CORE_ADDR
2003 m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
2004                       struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
2005                       struct value **args, CORE_ADDR sp, int struct_return,
2006                       CORE_ADDR struct_addr)
2007 {
2008   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2009   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2010   unsigned long mach = gdbarch_bfd_arch_info (gdbarch)->mach;
2011   CORE_ADDR cfa;
2012   int i;
2013
2014   /* The number of arguments given in this function's prototype, or
2015      zero if it has a non-prototyped function type.  The m32c ABI
2016      passes arguments mentioned in the prototype differently from
2017      those in the ellipsis of a varargs function, or from those passed
2018      to a non-prototyped function.  */
2019   int num_prototyped_args = 0;
2020
2021   {
2022     struct type *func_type = value_type (function);
2023
2024     /* Dereference function pointer types.  */
2025     if (TYPE_CODE (func_type) == TYPE_CODE_PTR)
2026       func_type = TYPE_TARGET_TYPE (func_type);
2027
2028     gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC ||
2029                 TYPE_CODE (func_type) == TYPE_CODE_METHOD);
2030
2031 #if 0
2032     /* The ABI description in gcc/config/m32c/m32c.abi says that
2033        we need to handle prototyped and non-prototyped functions
2034        separately, but the code in GCC doesn't actually do so.  */
2035     if (TYPE_PROTOTYPED (func_type))
2036 #endif
2037       num_prototyped_args = TYPE_NFIELDS (func_type);
2038   }
2039
2040   /* First, if the function returns an aggregate by value, push a
2041      pointer to a buffer for it.  This doesn't affect the way
2042      subsequent arguments are allocated to registers.  */
2043   if (struct_return)
2044     {
2045       int ptr_len = TYPE_LENGTH (tdep->ptr_voyd);
2046       sp -= ptr_len;
2047       write_memory_unsigned_integer (sp, ptr_len, byte_order, struct_addr);
2048     }
2049
2050   /* Push the arguments.  */
2051   for (i = nargs - 1; i >= 0; i--)
2052     {
2053       struct value *arg = args[i];
2054       const gdb_byte *arg_bits = value_contents (arg);
2055       struct type *arg_type = value_type (arg);
2056       ULONGEST arg_size = TYPE_LENGTH (arg_type);
2057
2058       /* Can it go in r1 or r1l (for m16c) or r0 or r0l (for m32c)?  */
2059       if (i == 0
2060           && arg_size <= 2
2061           && i < num_prototyped_args
2062           && m32c_reg_arg_type (arg_type))
2063         {
2064           /* Extract and re-store as an integer as a terse way to make
2065              sure it ends up in the least significant end of r1.  (GDB
2066              should avoid assuming endianness, even on uni-endian
2067              processors.)  */
2068           ULONGEST u = extract_unsigned_integer (arg_bits, arg_size,
2069                                                  byte_order);
2070           struct m32c_reg *reg = (mach == bfd_mach_m16c) ? tdep->r1 : tdep->r0;
2071           regcache_cooked_write_unsigned (regcache, reg->num, u);
2072         }
2073
2074       /* Can it go in r2?  */
2075       else if (mach == bfd_mach_m16c
2076                && i == 1
2077                && arg_size == 2
2078                && i < num_prototyped_args
2079                && m32c_reg_arg_type (arg_type))
2080         regcache_cooked_write (regcache, tdep->r2->num, arg_bits);
2081
2082       /* Everything else goes on the stack.  */
2083       else
2084         {
2085           sp -= arg_size;
2086
2087           /* Align the stack.  */
2088           if (mach == bfd_mach_m32c)
2089             sp &= ~1;
2090
2091           write_memory (sp, arg_bits, arg_size);
2092         }
2093     }
2094
2095   /* This is the CFA we use to identify the dummy frame.  */
2096   cfa = sp;
2097
2098   /* Push the return address.  */
2099   sp -= tdep->ret_addr_bytes;
2100   write_memory_unsigned_integer (sp, tdep->ret_addr_bytes, byte_order,
2101                                  bp_addr);
2102
2103   /* Update the stack pointer.  */
2104   regcache_cooked_write_unsigned (regcache, tdep->sp->num, sp);
2105
2106   /* We need to borrow an odd trick from the i386 target here.
2107
2108      The value we return from this function gets used as the stack
2109      address (the CFA) for the dummy frame's ID.  The obvious thing is
2110      to return the new TOS.  However, that points at the return
2111      address, saved on the stack, which is inconsistent with the CFA's
2112      described by GCC's DWARF 2 .debug_frame information: DWARF 2
2113      .debug_frame info uses the address immediately after the saved
2114      return address.  So you end up with a dummy frame whose CFA
2115      points at the return address, but the frame for the function
2116      being called has a CFA pointing after the return address: the
2117      younger CFA is *greater than* the older CFA.  The sanity checks
2118      in frame.c don't like that.
2119
2120      So we try to be consistent with the CFA's used by DWARF 2.
2121      Having a dummy frame and a real frame with the *same* CFA is
2122      tolerable.  */
2123   return cfa;
2124 }
2125
2126
2127 static struct frame_id
2128 m32c_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2129 {
2130   /* This needs to return a frame ID whose PC is the return address
2131      passed to m32c_push_dummy_call, and whose stack_addr is the SP
2132      m32c_push_dummy_call returned.
2133
2134      m32c_unwind_sp gives us the CFA, which is the value the SP had
2135      before the return address was pushed.  */
2136   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2137   CORE_ADDR sp = get_frame_register_unsigned (this_frame, tdep->sp->num);
2138   return frame_id_build (sp, get_frame_pc (this_frame));
2139 }
2140
2141
2142 \f
2143 /* Return values.  */
2144
2145 /* Return value conventions, according to GCC:
2146
2147    r8c, m16c
2148    ---------
2149
2150    QImode in r0l
2151    HImode in r0
2152    SImode in r2r0
2153    near pointer in r0
2154    far pointer in r2r0
2155
2156    Aggregate values (regardless of size) are returned by pushing a
2157    pointer to a temporary area on the stack after the args are pushed.
2158    The function fills in this area with the value.  Note that this
2159    pointer on the stack does not affect how register arguments, if any,
2160    are configured.
2161
2162    m32cm, m32c
2163    -----------
2164    Same.  */
2165
2166 /* Return non-zero if values of type TYPE are returned by storing them
2167    in a buffer whose address is passed on the stack, ahead of the
2168    other arguments.  */
2169 static int
2170 m32c_return_by_passed_buf (struct type *type)
2171 {
2172   enum type_code code = TYPE_CODE (type);
2173
2174   return (code == TYPE_CODE_STRUCT
2175           || code == TYPE_CODE_UNION);
2176 }
2177
2178 static enum return_value_convention
2179 m32c_return_value (struct gdbarch *gdbarch,
2180                    struct type *func_type,
2181                    struct type *valtype,
2182                    struct regcache *regcache,
2183                    gdb_byte *readbuf,
2184                    const gdb_byte *writebuf)
2185 {
2186   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2187   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2188   enum return_value_convention conv;
2189   ULONGEST valtype_len = TYPE_LENGTH (valtype);
2190
2191   if (m32c_return_by_passed_buf (valtype))
2192     conv = RETURN_VALUE_STRUCT_CONVENTION;
2193   else
2194     conv = RETURN_VALUE_REGISTER_CONVENTION;
2195
2196   if (readbuf)
2197     {
2198       /* We should never be called to find values being returned by
2199          RETURN_VALUE_STRUCT_CONVENTION.  Those can't be located,
2200          unless we made the call ourselves.  */
2201       gdb_assert (conv == RETURN_VALUE_REGISTER_CONVENTION);
2202
2203       gdb_assert (valtype_len <= 8);
2204
2205       /* Anything that fits in r0 is returned there.  */
2206       if (valtype_len <= TYPE_LENGTH (tdep->r0->type))
2207         {
2208           ULONGEST u;
2209           regcache_cooked_read_unsigned (regcache, tdep->r0->num, &u);
2210           store_unsigned_integer (readbuf, valtype_len, byte_order, u);
2211         }
2212       else
2213         {
2214           /* Everything else is passed in mem0, using as many bytes as
2215              needed.  This is not what the Renesas tools do, but it's
2216              what GCC does at the moment.  */
2217           struct minimal_symbol *mem0
2218             = lookup_minimal_symbol ("mem0", NULL, NULL);
2219
2220           if (! mem0)
2221             error ("The return value is stored in memory at 'mem0', "
2222                    "but GDB cannot find\n"
2223                    "its address.");
2224           read_memory (SYMBOL_VALUE_ADDRESS (mem0), readbuf, valtype_len);
2225         }
2226     }
2227
2228   if (writebuf)
2229     {
2230       /* We should never be called to store values to be returned
2231          using RETURN_VALUE_STRUCT_CONVENTION.  We have no way of
2232          finding the buffer, unless we made the call ourselves.  */
2233       gdb_assert (conv == RETURN_VALUE_REGISTER_CONVENTION);
2234
2235       gdb_assert (valtype_len <= 8);
2236
2237       /* Anything that fits in r0 is returned there.  */
2238       if (valtype_len <= TYPE_LENGTH (tdep->r0->type))
2239         {
2240           ULONGEST u = extract_unsigned_integer (writebuf, valtype_len,
2241                                                  byte_order);
2242           regcache_cooked_write_unsigned (regcache, tdep->r0->num, u);
2243         }
2244       else
2245         {
2246           /* Everything else is passed in mem0, using as many bytes as
2247              needed.  This is not what the Renesas tools do, but it's
2248              what GCC does at the moment.  */
2249           struct minimal_symbol *mem0
2250             = lookup_minimal_symbol ("mem0", NULL, NULL);
2251
2252           if (! mem0)
2253             error ("The return value is stored in memory at 'mem0', "
2254                    "but GDB cannot find\n"
2255                    " its address.");
2256           write_memory (SYMBOL_VALUE_ADDRESS (mem0),
2257                         (char *) writebuf, valtype_len);
2258         }
2259     }
2260
2261   return conv;
2262 }
2263
2264
2265 \f
2266 /* Trampolines.  */
2267
2268 /* The m16c and m32c use a trampoline function for indirect function
2269    calls.  An indirect call looks like this:
2270
2271              ... push arguments ...
2272              ... push target function address ...
2273              jsr.a m32c_jsri16
2274
2275    The code for m32c_jsri16 looks like this:
2276
2277      m32c_jsri16:
2278
2279              # Save return address.
2280              pop.w      m32c_jsri_ret
2281              pop.b      m32c_jsri_ret+2
2282
2283              # Store target function address.
2284              pop.w      m32c_jsri_addr
2285
2286              # Re-push return address.
2287              push.b     m32c_jsri_ret+2
2288              push.w     m32c_jsri_ret
2289
2290              # Call the target function.
2291              jmpi.a     m32c_jsri_addr
2292
2293    Without further information, GDB will treat calls to m32c_jsri16
2294    like calls to any other function.  Since m32c_jsri16 doesn't have
2295    debugging information, that normally means that GDB sets a step-
2296    resume breakpoint and lets the program continue --- which is not
2297    what the user wanted.  (Giving the trampoline debugging info
2298    doesn't help: the user expects the program to stop in the function
2299    their program is calling, not in some trampoline code they've never
2300    seen before.)
2301
2302    The gdbarch_skip_trampoline_code method tells GDB how to step
2303    through such trampoline functions transparently to the user.  When
2304    given the address of a trampoline function's first instruction,
2305    gdbarch_skip_trampoline_code should return the address of the first
2306    instruction of the function really being called.  If GDB decides it
2307    wants to step into that function, it will set a breakpoint there
2308    and silently continue to it.
2309
2310    We recognize the trampoline by name, and extract the target address
2311    directly from the stack.  This isn't great, but recognizing by its
2312    code sequence seems more fragile.  */
2313
2314 static CORE_ADDR
2315 m32c_skip_trampoline_code (struct frame_info *frame, CORE_ADDR stop_pc)
2316 {
2317   struct gdbarch *gdbarch = get_frame_arch (frame);
2318   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2319   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2320
2321   /* It would be nicer to simply look up the addresses of known
2322      trampolines once, and then compare stop_pc with them.  However,
2323      we'd need to ensure that that cached address got invalidated when
2324      someone loaded a new executable, and I'm not quite sure of the
2325      best way to do that.  find_pc_partial_function does do some
2326      caching, so we'll see how this goes.  */
2327   char *name;
2328   CORE_ADDR start, end;
2329
2330   if (find_pc_partial_function (stop_pc, &name, &start, &end))
2331     {
2332       /* Are we stopped at the beginning of the trampoline function?  */
2333       if (strcmp (name, "m32c_jsri16") == 0
2334           && stop_pc == start)
2335         {
2336           /* Get the stack pointer.  The return address is at the top,
2337              and the target function's address is just below that.  We
2338              know it's a two-byte address, since the trampoline is
2339              m32c_jsri*16*.  */
2340           CORE_ADDR sp = get_frame_sp (get_current_frame ());
2341           CORE_ADDR target
2342             = read_memory_unsigned_integer (sp + tdep->ret_addr_bytes,
2343                                             2, byte_order);
2344
2345           /* What we have now is the address of a jump instruction.
2346              What we need is the destination of that jump.
2347              The opcode is 1 byte, and the destination is the next 3 bytes.
2348           */
2349           target = read_memory_unsigned_integer (target + 1, 3, byte_order);
2350           return target;
2351         }
2352     }
2353
2354   return 0;
2355 }
2356
2357
2358 /* Address/pointer conversions.  */
2359
2360 /* On the m16c, there is a 24-bit address space, but only a very few
2361    instructions can generate addresses larger than 0xffff: jumps,
2362    jumps to subroutines, and the lde/std (load/store extended)
2363    instructions.
2364
2365    Since GCC can only support one size of pointer, we can't have
2366    distinct 'near' and 'far' pointer types; we have to pick one size
2367    for everything.  If we wanted to use 24-bit pointers, then GCC
2368    would have to use lde and ste for all memory references, which
2369    would be terrible for performance and code size.  So the GNU
2370    toolchain uses 16-bit pointers for everything, and gives up the
2371    ability to have pointers point outside the first 64k of memory.
2372
2373    However, as a special hack, we let the linker place functions at
2374    addresses above 0xffff, as long as it also places a trampoline in
2375    the low 64k for every function whose address is taken.  Each
2376    trampoline consists of a single jmp.a instruction that jumps to the
2377    function's real entry point.  Pointers to functions can be 16 bits
2378    long, even though the functions themselves are at higher addresses:
2379    the pointers refer to the trampolines, not the functions.
2380
2381    This complicates things for GDB, however: given the address of a
2382    function (from debug info or linker symbols, say) which could be
2383    anywhere in the 24-bit address space, how can we find an
2384    appropriate 16-bit value to use as a pointer to it?
2385
2386    If the linker has not generated a trampoline for the function,
2387    we're out of luck.  Well, I guess we could malloc some space and
2388    write a jmp.a instruction to it, but I'm not going to get into that
2389    at the moment.
2390
2391    If the linker has generated a trampoline for the function, then it
2392    also emitted a symbol for the trampoline: if the function's linker
2393    symbol is named NAME, then the function's trampoline's linker
2394    symbol is named NAME.plt.
2395
2396    So, given a code address:
2397    - We try to find a linker symbol at that address.
2398    - If we find such a symbol named NAME, we look for a linker symbol
2399      named NAME.plt.
2400    - If we find such a symbol, we assume it is a trampoline, and use
2401      its address as the pointer value.
2402
2403    And, given a function pointer:
2404    - We try to find a linker symbol at that address named NAME.plt.
2405    - If we find such a symbol, we look for a linker symbol named NAME.
2406    - If we find that, we provide that as the function's address.
2407    - If any of the above steps fail, we return the original address
2408      unchanged; it might really be a function in the low 64k.
2409
2410    See?  You *knew* there was a reason you wanted to be a computer
2411    programmer!  :)  */
2412
2413 static void
2414 m32c_m16c_address_to_pointer (struct gdbarch *gdbarch,
2415                               struct type *type, gdb_byte *buf, CORE_ADDR addr)
2416 {
2417   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2418   enum type_code target_code;
2419   gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR ||
2420               TYPE_CODE (type) == TYPE_CODE_REF);
2421
2422   target_code = TYPE_CODE (TYPE_TARGET_TYPE (type));
2423
2424   if (target_code == TYPE_CODE_FUNC || target_code == TYPE_CODE_METHOD)
2425     {
2426       char *func_name;
2427       char *tramp_name;
2428       struct minimal_symbol *tramp_msym;
2429
2430       /* Try to find a linker symbol at this address.  */
2431       struct minimal_symbol *func_msym = lookup_minimal_symbol_by_pc (addr);
2432
2433       if (! func_msym)
2434         error ("Cannot convert code address %s to function pointer:\n"
2435                "couldn't find a symbol at that address, to find trampoline.",
2436                paddress (gdbarch, addr));
2437
2438       func_name = SYMBOL_LINKAGE_NAME (func_msym);
2439       tramp_name = xmalloc (strlen (func_name) + 5);
2440       strcpy (tramp_name, func_name);
2441       strcat (tramp_name, ".plt");
2442
2443       /* Try to find a linker symbol for the trampoline.  */
2444       tramp_msym = lookup_minimal_symbol (tramp_name, NULL, NULL);
2445
2446       /* We've either got another copy of the name now, or don't need
2447          the name any more.  */
2448       xfree (tramp_name);
2449
2450       if (! tramp_msym)
2451         error ("Cannot convert code address %s to function pointer:\n"
2452                "couldn't find trampoline named '%s.plt'.",
2453                paddress (gdbarch, addr), func_name);
2454
2455       /* The trampoline's address is our pointer.  */
2456       addr = SYMBOL_VALUE_ADDRESS (tramp_msym);
2457     }
2458
2459   store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
2460 }
2461
2462
2463 static CORE_ADDR
2464 m32c_m16c_pointer_to_address (struct gdbarch *gdbarch,
2465                               struct type *type, const gdb_byte *buf)
2466 {
2467   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2468   CORE_ADDR ptr;
2469   enum type_code target_code;
2470
2471   gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR ||
2472               TYPE_CODE (type) == TYPE_CODE_REF);
2473
2474   ptr = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
2475
2476   target_code = TYPE_CODE (TYPE_TARGET_TYPE (type));
2477
2478   if (target_code == TYPE_CODE_FUNC || target_code == TYPE_CODE_METHOD)
2479     {
2480       /* See if there is a minimal symbol at that address whose name is
2481          "NAME.plt".  */
2482       struct minimal_symbol *ptr_msym = lookup_minimal_symbol_by_pc (ptr);
2483
2484       if (ptr_msym)
2485         {
2486           char *ptr_msym_name = SYMBOL_LINKAGE_NAME (ptr_msym);
2487           int len = strlen (ptr_msym_name);
2488
2489           if (len > 4
2490               && strcmp (ptr_msym_name + len - 4, ".plt") == 0)
2491             {
2492               struct minimal_symbol *func_msym;
2493               /* We have a .plt symbol; try to find the symbol for the
2494                  corresponding function.
2495
2496                  Since the trampoline contains a jump instruction, we
2497                  could also just extract the jump's target address.  I
2498                  don't see much advantage one way or the other.  */
2499               char *func_name = xmalloc (len - 4 + 1);
2500               memcpy (func_name, ptr_msym_name, len - 4);
2501               func_name[len - 4] = '\0';
2502               func_msym
2503                 = lookup_minimal_symbol (func_name, NULL, NULL);
2504
2505               /* If we do have such a symbol, return its value as the
2506                  function's true address.  */
2507               if (func_msym)
2508                 ptr = SYMBOL_VALUE_ADDRESS (func_msym);
2509             }
2510         }
2511     }
2512
2513   return ptr;
2514 }
2515
2516 static void
2517 m32c_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc,
2518                             int *frame_regnum,
2519                             LONGEST *frame_offset)
2520 {
2521   char *name;
2522   CORE_ADDR func_addr, func_end, sal_end;
2523   struct m32c_prologue p;
2524
2525   struct regcache *regcache = get_current_regcache ();
2526   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2527   
2528   if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
2529     internal_error (__FILE__, __LINE__, _("No virtual frame pointer available"));
2530
2531   m32c_analyze_prologue (gdbarch, func_addr, pc, &p);
2532   switch (p.kind)
2533     {
2534     case prologue_with_frame_ptr:
2535       *frame_regnum = m32c_banked_register (tdep->fb, regcache)->num;
2536       *frame_offset = p.frame_ptr_offset;
2537       break;
2538     case prologue_sans_frame_ptr:
2539       *frame_regnum = m32c_banked_register (tdep->sp, regcache)->num;
2540       *frame_offset = p.frame_size;
2541       break;
2542     default:
2543       *frame_regnum = m32c_banked_register (tdep->sp, regcache)->num;
2544       *frame_offset = 0;
2545       break;
2546     }
2547   /* Sanity check */
2548   if (*frame_regnum > gdbarch_num_regs (gdbarch))
2549     internal_error (__FILE__, __LINE__, _("No virtual frame pointer available"));
2550 }
2551
2552 \f
2553 /* Initialization.  */
2554
2555 static struct gdbarch *
2556 m32c_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2557 {
2558   struct gdbarch *arch;
2559   struct gdbarch_tdep *tdep;
2560   unsigned long mach = info.bfd_arch_info->mach;
2561
2562   /* Find a candidate among the list of architectures we've created
2563      already.  */
2564   for (arches = gdbarch_list_lookup_by_info (arches, &info);
2565        arches != NULL;
2566        arches = gdbarch_list_lookup_by_info (arches->next, &info))
2567     return arches->gdbarch;
2568
2569   tdep = xcalloc (1, sizeof (*tdep));
2570   arch = gdbarch_alloc (&info, tdep);
2571
2572   /* Essential types.  */
2573   make_types (arch);
2574
2575   /* Address/pointer conversions.  */
2576   if (mach == bfd_mach_m16c)
2577     {
2578       set_gdbarch_address_to_pointer (arch, m32c_m16c_address_to_pointer);
2579       set_gdbarch_pointer_to_address (arch, m32c_m16c_pointer_to_address);
2580     }
2581
2582   /* Register set.  */
2583   make_regs (arch);
2584
2585   /* Disassembly.  */
2586   set_gdbarch_print_insn (arch, print_insn_m32c);
2587
2588   /* Breakpoints.  */
2589   set_gdbarch_breakpoint_from_pc (arch, m32c_breakpoint_from_pc);
2590
2591   /* Prologue analysis and unwinding.  */
2592   set_gdbarch_inner_than (arch, core_addr_lessthan);
2593   set_gdbarch_skip_prologue (arch, m32c_skip_prologue);
2594   set_gdbarch_unwind_pc (arch, m32c_unwind_pc);
2595   set_gdbarch_unwind_sp (arch, m32c_unwind_sp);
2596 #if 0
2597   /* I'm dropping the dwarf2 sniffer because it has a few problems.
2598      They may be in the dwarf2 cfi code in GDB, or they may be in
2599      the debug info emitted by the upstream toolchain.  I don't 
2600      know which, but I do know that the prologue analyzer works better.
2601      MVS 04/13/06
2602   */
2603   dwarf2_append_sniffers (arch);
2604 #endif
2605   frame_unwind_append_unwinder (arch, &m32c_unwind);
2606
2607   /* Inferior calls.  */
2608   set_gdbarch_push_dummy_call (arch, m32c_push_dummy_call);
2609   set_gdbarch_return_value (arch, m32c_return_value);
2610   set_gdbarch_dummy_id (arch, m32c_dummy_id);
2611
2612   /* Trampolines.  */
2613   set_gdbarch_skip_trampoline_code (arch, m32c_skip_trampoline_code);
2614
2615   set_gdbarch_virtual_frame_pointer (arch, m32c_virtual_frame_pointer);
2616
2617   /* m32c function boundary addresses are not necessarily even.
2618      Therefore, the `vbit', which indicates a pointer to a virtual
2619      member function, is stored in the delta field, rather than as
2620      the low bit of a function pointer address.  
2621
2622      In order to verify this, see the definition of
2623      TARGET_PTRMEMFUNC_VBIT_LOCATION in gcc/defaults.h along with the
2624      definition of FUNCTION_BOUNDARY in gcc/config/m32c/m32c.h.  */
2625   set_gdbarch_vbit_in_delta (arch, 1);
2626
2627   return arch;
2628 }
2629
2630 /* Provide a prototype to silence -Wmissing-prototypes.  */
2631 extern initialize_file_ftype _initialize_m32c_tdep;
2632
2633 void
2634 _initialize_m32c_tdep (void)
2635 {
2636   register_gdbarch_init (bfd_arch_m32c, m32c_gdbarch_init);
2637
2638   m32c_dma_reggroup = reggroup_new ("dma", USER_REGGROUP);
2639 }