* gdbarch.sh (target_gdbarch): Remove macro.
[external/binutils.git] / gdb / rl78-tdep.c
1 /* Target-dependent code for the Renesas RL78 for GDB, the GNU debugger.
2
3    Copyright (C) 2011-2012 Free Software Foundation, Inc.
4
5    Contributed by Red Hat, Inc.
6
7    This file is part of GDB.
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
22 #include "defs.h"
23 #include "arch-utils.h"
24 #include "prologue-value.h"
25 #include "target.h"
26 #include "regcache.h"
27 #include "opcode/rl78.h"
28 #include "dis-asm.h"
29 #include "gdbtypes.h"
30 #include "frame.h"
31 #include "frame-unwind.h"
32 #include "frame-base.h"
33 #include "value.h"
34 #include "gdbcore.h"
35 #include "dwarf2-frame.h"
36 #include "reggroups.h"
37
38 #include "elf/rl78.h"
39 #include "elf-bfd.h"
40
41 /* Register Banks.  */
42
43 enum
44 {
45   RL78_BANK0 = 0,
46   RL78_BANK1 = 1,
47   RL78_BANK2 = 2,
48   RL78_BANK3 = 3,
49   RL78_NUMBANKS = 4,
50   RL78_REGS_PER_BANK = 8
51 };
52
53 /* Register Numbers.  */
54
55 enum
56 {
57   /* All general purpose registers are 8 bits wide.  */
58   RL78_RAW_BANK0_R0_REGNUM = 0,
59   RL78_RAW_BANK0_R1_REGNUM,
60   RL78_RAW_BANK0_R2_REGNUM,
61   RL78_RAW_BANK0_R3_REGNUM,
62   RL78_RAW_BANK0_R4_REGNUM,
63   RL78_RAW_BANK0_R5_REGNUM,
64   RL78_RAW_BANK0_R6_REGNUM,
65   RL78_RAW_BANK0_R7_REGNUM,
66
67   RL78_RAW_BANK1_R0_REGNUM,
68   RL78_RAW_BANK1_R1_REGNUM,
69   RL78_RAW_BANK1_R2_REGNUM,
70   RL78_RAW_BANK1_R3_REGNUM,
71   RL78_RAW_BANK1_R4_REGNUM,
72   RL78_RAW_BANK1_R5_REGNUM,
73   RL78_RAW_BANK1_R6_REGNUM,
74   RL78_RAW_BANK1_R7_REGNUM,
75
76   RL78_RAW_BANK2_R0_REGNUM,
77   RL78_RAW_BANK2_R1_REGNUM,
78   RL78_RAW_BANK2_R2_REGNUM,
79   RL78_RAW_BANK2_R3_REGNUM,
80   RL78_RAW_BANK2_R4_REGNUM,
81   RL78_RAW_BANK2_R5_REGNUM,
82   RL78_RAW_BANK2_R6_REGNUM,
83   RL78_RAW_BANK2_R7_REGNUM,
84
85   RL78_RAW_BANK3_R0_REGNUM,
86   RL78_RAW_BANK3_R1_REGNUM,
87   RL78_RAW_BANK3_R2_REGNUM,
88   RL78_RAW_BANK3_R3_REGNUM,
89   RL78_RAW_BANK3_R4_REGNUM,
90   RL78_RAW_BANK3_R5_REGNUM,
91   RL78_RAW_BANK3_R6_REGNUM,
92   RL78_RAW_BANK3_R7_REGNUM,
93
94   RL78_PSW_REGNUM,      /* 8 bits */
95   RL78_ES_REGNUM,       /* 8 bits */
96   RL78_CS_REGNUM,       /* 8 bits */
97   RL78_PC_REGNUM,       /* 20 bits; we'll use 32 bits for it.  */
98
99   /* Fixed address SFRs (some of those above are SFRs too.) */
100   RL78_SPL_REGNUM,      /* 8 bits; lower half of SP */
101   RL78_SPH_REGNUM,      /* 8 bits; upper half of SP */
102   RL78_PMC_REGNUM,      /* 8 bits */
103   RL78_MEM_REGNUM,      /* 8 bits ?? */
104
105   RL78_NUM_REGS,
106
107   /* Pseudo registers.  */
108   RL78_SP_REGNUM = RL78_NUM_REGS,
109
110   RL78_X_REGNUM,
111   RL78_A_REGNUM,
112   RL78_C_REGNUM,
113   RL78_B_REGNUM,
114   RL78_E_REGNUM,
115   RL78_D_REGNUM,
116   RL78_L_REGNUM,
117   RL78_H_REGNUM,
118
119   RL78_AX_REGNUM,
120   RL78_BC_REGNUM,
121   RL78_DE_REGNUM,
122   RL78_HL_REGNUM,
123
124   RL78_BANK0_R0_REGNUM,
125   RL78_BANK0_R1_REGNUM,
126   RL78_BANK0_R2_REGNUM,
127   RL78_BANK0_R3_REGNUM,
128   RL78_BANK0_R4_REGNUM,
129   RL78_BANK0_R5_REGNUM,
130   RL78_BANK0_R6_REGNUM,
131   RL78_BANK0_R7_REGNUM,
132
133   RL78_BANK1_R0_REGNUM,
134   RL78_BANK1_R1_REGNUM,
135   RL78_BANK1_R2_REGNUM,
136   RL78_BANK1_R3_REGNUM,
137   RL78_BANK1_R4_REGNUM,
138   RL78_BANK1_R5_REGNUM,
139   RL78_BANK1_R6_REGNUM,
140   RL78_BANK1_R7_REGNUM,
141
142   RL78_BANK2_R0_REGNUM,
143   RL78_BANK2_R1_REGNUM,
144   RL78_BANK2_R2_REGNUM,
145   RL78_BANK2_R3_REGNUM,
146   RL78_BANK2_R4_REGNUM,
147   RL78_BANK2_R5_REGNUM,
148   RL78_BANK2_R6_REGNUM,
149   RL78_BANK2_R7_REGNUM,
150
151   RL78_BANK3_R0_REGNUM,
152   RL78_BANK3_R1_REGNUM,
153   RL78_BANK3_R2_REGNUM,
154   RL78_BANK3_R3_REGNUM,
155   RL78_BANK3_R4_REGNUM,
156   RL78_BANK3_R5_REGNUM,
157   RL78_BANK3_R6_REGNUM,
158   RL78_BANK3_R7_REGNUM,
159
160   RL78_BANK0_RP0_REGNUM,
161   RL78_BANK0_RP1_REGNUM,
162   RL78_BANK0_RP2_REGNUM,
163   RL78_BANK0_RP3_REGNUM,
164
165   RL78_BANK1_RP0_REGNUM,
166   RL78_BANK1_RP1_REGNUM,
167   RL78_BANK1_RP2_REGNUM,
168   RL78_BANK1_RP3_REGNUM,
169
170   RL78_BANK2_RP0_REGNUM,
171   RL78_BANK2_RP1_REGNUM,
172   RL78_BANK2_RP2_REGNUM,
173   RL78_BANK2_RP3_REGNUM,
174
175   RL78_BANK3_RP0_REGNUM,
176   RL78_BANK3_RP1_REGNUM,
177   RL78_BANK3_RP2_REGNUM,
178   RL78_BANK3_RP3_REGNUM,
179
180   RL78_NUM_TOTAL_REGS,
181   RL78_NUM_PSEUDO_REGS = RL78_NUM_TOTAL_REGS - RL78_NUM_REGS
182 };
183
184 /* Architecture specific data.  */
185
186 struct gdbarch_tdep
187 {
188   /* The ELF header flags specify the multilib used.  */
189   int elf_flags;
190
191   struct type *rl78_void,
192               *rl78_uint8,
193               *rl78_int8,
194               *rl78_uint16,
195               *rl78_int16,
196               *rl78_uint32,
197               *rl78_int32,
198               *rl78_data_pointer,
199               *rl78_code_pointer;
200 };
201
202 /* This structure holds the results of a prologue analysis.  */
203
204 struct rl78_prologue
205 {
206   /* The offset from the frame base to the stack pointer --- always
207      zero or negative.
208
209      Calling this a "size" is a bit misleading, but given that the
210      stack grows downwards, using offsets for everything keeps one
211      from going completely sign-crazy: you never change anything's
212      sign for an ADD instruction; always change the second operand's
213      sign for a SUB instruction; and everything takes care of
214      itself.  */
215   int frame_size;
216
217   /* Non-zero if this function has initialized the frame pointer from
218      the stack pointer, zero otherwise.  */
219   int has_frame_ptr;
220
221   /* If has_frame_ptr is non-zero, this is the offset from the frame
222      base to where the frame pointer points.  This is always zero or
223      negative.  */
224   int frame_ptr_offset;
225
226   /* The address of the first instruction at which the frame has been
227      set up and the arguments are where the debug info says they are
228      --- as best as we can tell.  */
229   CORE_ADDR prologue_end;
230
231   /* reg_offset[R] is the offset from the CFA at which register R is
232      saved, or 1 if register R has not been saved.  (Real values are
233      always zero or negative.)  */
234   int reg_offset[RL78_NUM_TOTAL_REGS];
235 };
236
237 /* Implement the "register_type" gdbarch method.  */
238
239 static struct type *
240 rl78_register_type (struct gdbarch *gdbarch, int reg_nr)
241 {
242   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
243
244   if (reg_nr == RL78_PC_REGNUM)
245     return tdep->rl78_code_pointer;
246   else if (reg_nr <= RL78_MEM_REGNUM
247            || (RL78_X_REGNUM <= reg_nr && reg_nr <= RL78_H_REGNUM)
248            || (RL78_BANK0_R0_REGNUM <= reg_nr
249                && reg_nr <= RL78_BANK3_R7_REGNUM))
250     return tdep->rl78_int8;
251   else
252     return tdep->rl78_data_pointer;
253 }
254
255 /* Implement the "register_name" gdbarch method.  */
256
257 static const char *
258 rl78_register_name (struct gdbarch *gdbarch, int regnr)
259 {
260   static const char *const reg_names[] =
261   {
262     "",         /* bank0_r0 */
263     "",         /* bank0_r1 */
264     "",         /* bank0_r2 */
265     "",         /* bank0_r3 */
266     "",         /* bank0_r4 */
267     "",         /* bank0_r5 */
268     "",         /* bank0_r6 */
269     "",         /* bank0_r7 */
270
271     "",         /* bank1_r0 */
272     "",         /* bank1_r1 */
273     "",         /* bank1_r2 */
274     "",         /* bank1_r3 */
275     "",         /* bank1_r4 */
276     "",         /* bank1_r5 */
277     "",         /* bank1_r6 */
278     "",         /* bank1_r7 */
279
280     "",         /* bank2_r0 */
281     "",         /* bank2_r1 */
282     "",         /* bank2_r2 */
283     "",         /* bank2_r3 */
284     "",         /* bank2_r4 */
285     "",         /* bank2_r5 */
286     "",         /* bank2_r6 */
287     "",         /* bank2_r7 */
288
289     "",         /* bank3_r0 */
290     "",         /* bank3_r1 */
291     "",         /* bank3_r2 */
292     "",         /* bank3_r3 */
293     "",         /* bank3_r4 */
294     "",         /* bank3_r5 */
295     "",         /* bank3_r6 */
296     "",         /* bank3_r7 */
297
298     "psw",
299     "es",
300     "cs",
301     "pc",
302
303     "",         /* spl */
304     "",         /* sph */
305     "pmc",
306     "mem",
307
308     "sp",
309
310     "x",
311     "a",
312     "c",
313     "b",
314     "e",
315     "d",
316     "l",
317     "h",
318
319     "ax",
320     "bc",
321     "de",
322     "hl",
323
324     "bank0_r0",
325     "bank0_r1",
326     "bank0_r2",
327     "bank0_r3",
328     "bank0_r4",
329     "bank0_r5",
330     "bank0_r6",
331     "bank0_r7",
332
333     "bank1_r0",
334     "bank1_r1",
335     "bank1_r2",
336     "bank1_r3",
337     "bank1_r4",
338     "bank1_r5",
339     "bank1_r6",
340     "bank1_r7",
341
342     "bank2_r0",
343     "bank2_r1",
344     "bank2_r2",
345     "bank2_r3",
346     "bank2_r4",
347     "bank2_r5",
348     "bank2_r6",
349     "bank2_r7",
350
351     "bank3_r0",
352     "bank3_r1",
353     "bank3_r2",
354     "bank3_r3",
355     "bank3_r4",
356     "bank3_r5",
357     "bank3_r6",
358     "bank3_r7",
359
360     "bank0_rp0",
361     "bank0_rp1",
362     "bank0_rp2",
363     "bank0_rp3",
364
365     "bank1_rp0",
366     "bank1_rp1",
367     "bank1_rp2",
368     "bank1_rp3",
369
370     "bank2_rp0",
371     "bank2_rp1",
372     "bank2_rp2",
373     "bank2_rp3",
374
375     "bank3_rp0",
376     "bank3_rp1",
377     "bank3_rp2",
378     "bank3_rp3"
379   };
380
381   return reg_names[regnr];
382 }
383
384 /* Implement the "register_reggroup_p" gdbarch method.  */
385
386 static int
387 rl78_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
388                           struct reggroup *group)
389 {
390   if (group == all_reggroup)
391     return 1;
392
393   /* All other registers are saved and restored.  */
394   if (group == save_reggroup || group == restore_reggroup)
395     {
396       if (regnum < RL78_NUM_REGS)
397         return 1;
398       else
399         return 0;
400     }
401
402   if ((RL78_BANK0_R0_REGNUM <= regnum && regnum <= RL78_BANK3_R7_REGNUM)
403       || regnum == RL78_ES_REGNUM
404       || regnum == RL78_CS_REGNUM
405       || regnum == RL78_SPL_REGNUM
406       || regnum == RL78_SPH_REGNUM
407       || regnum == RL78_PMC_REGNUM
408       || regnum == RL78_MEM_REGNUM
409       || (RL78_BANK0_RP0_REGNUM <= regnum && regnum <= RL78_BANK3_RP3_REGNUM))
410     return group == system_reggroup;
411
412   return group == general_reggroup;
413 }
414
415 /* Strip bits to form an instruction address.  (When fetching a
416    32-bit address from the stack, the high eight bits are garbage.
417    This function strips off those unused bits.)  */
418
419 static CORE_ADDR
420 rl78_make_instruction_address (CORE_ADDR addr)
421 {
422   return addr & 0xffffff;
423 }
424
425 /* Set / clear bits necessary to make a data address.  */
426
427 static CORE_ADDR
428 rl78_make_data_address (CORE_ADDR addr)
429 {
430   return (addr & 0xffff) | 0xf0000;
431 }
432
433 /* Implement the "pseudo_register_read" gdbarch method.  */
434
435 static enum register_status
436 rl78_pseudo_register_read (struct gdbarch *gdbarch,
437                            struct regcache *regcache,
438                            int reg, gdb_byte *buffer)
439 {
440   enum register_status status;
441
442   if (RL78_BANK0_R0_REGNUM <= reg && reg <= RL78_BANK3_R7_REGNUM)
443     {
444       int raw_regnum = RL78_RAW_BANK0_R0_REGNUM
445                        + (reg - RL78_BANK0_R0_REGNUM);
446
447       status = regcache_raw_read (regcache, raw_regnum, buffer);
448     }
449   else if (RL78_BANK0_RP0_REGNUM <= reg && reg <= RL78_BANK3_RP3_REGNUM)
450     {
451       int raw_regnum = 2 * (reg - RL78_BANK0_RP0_REGNUM)
452                        + RL78_RAW_BANK0_R0_REGNUM;
453
454       status = regcache_raw_read (regcache, raw_regnum, buffer);
455       if (status == REG_VALID)
456         status = regcache_raw_read (regcache, raw_regnum + 1, buffer + 1);
457     }
458   else if (reg == RL78_SP_REGNUM)
459     {
460       status = regcache_raw_read (regcache, RL78_SPL_REGNUM, buffer);
461       if (status == REG_VALID)
462         status = regcache_raw_read (regcache, RL78_SPH_REGNUM, buffer + 1);
463     }
464   else if (RL78_X_REGNUM <= reg && reg <= RL78_H_REGNUM)
465     {
466       ULONGEST psw;
467
468       status = regcache_raw_read_unsigned (regcache, RL78_PSW_REGNUM, &psw);
469       if (status == REG_VALID)
470         {
471           /* RSB0 is at bit 3; RSBS1 is at bit 5.  */
472           int bank = ((psw >> 3) & 1) | ((psw >> 4) & 1);
473           int raw_regnum = RL78_RAW_BANK0_R0_REGNUM + bank * RL78_REGS_PER_BANK
474                            + (reg - RL78_X_REGNUM);
475           status = regcache_raw_read (regcache, raw_regnum, buffer);
476         }
477     }
478   else if (RL78_AX_REGNUM <= reg && reg <= RL78_HL_REGNUM)
479     {
480       ULONGEST psw;
481
482       status = regcache_raw_read_unsigned (regcache, RL78_PSW_REGNUM, &psw);
483       if (status == REG_VALID)
484         {
485           /* RSB0 is at bit 3; RSBS1 is at bit 5.  */
486           int bank = ((psw >> 3) & 1) | ((psw >> 4) & 1);
487           int raw_regnum = RL78_RAW_BANK0_R0_REGNUM + bank * RL78_REGS_PER_BANK
488                            + 2 * (reg - RL78_AX_REGNUM);
489           status = regcache_raw_read (regcache, raw_regnum, buffer);
490           if (status == REG_VALID)
491             status = regcache_raw_read (regcache, raw_regnum + 1,
492                                         buffer + 1);
493         }
494     }
495   else
496     gdb_assert_not_reached ("invalid pseudo register number");
497   return status;
498 }
499
500 /* Implement the "pseudo_register_write" gdbarch method.  */
501
502 static void
503 rl78_pseudo_register_write (struct gdbarch *gdbarch,
504                             struct regcache *regcache,
505                             int reg, const gdb_byte *buffer)
506 {
507   if (RL78_BANK0_R0_REGNUM <= reg && reg <= RL78_BANK3_R7_REGNUM)
508     {
509       int raw_regnum = RL78_RAW_BANK0_R0_REGNUM
510                        + (reg - RL78_BANK0_R0_REGNUM);
511
512       regcache_raw_write (regcache, raw_regnum, buffer);
513     }
514   else if (RL78_BANK0_RP0_REGNUM <= reg && reg <= RL78_BANK3_RP3_REGNUM)
515     {
516       int raw_regnum = 2 * (reg - RL78_BANK0_RP0_REGNUM)
517                        + RL78_RAW_BANK0_R0_REGNUM;
518
519       regcache_raw_write (regcache, raw_regnum, buffer);
520       regcache_raw_write (regcache, raw_regnum + 1, buffer + 1);
521     }
522   else if (reg == RL78_SP_REGNUM)
523     {
524       regcache_raw_write (regcache, RL78_SPL_REGNUM, buffer);
525       regcache_raw_write (regcache, RL78_SPH_REGNUM, buffer + 1);
526     }
527   else if (RL78_X_REGNUM <= reg && reg <= RL78_H_REGNUM)
528     {
529       ULONGEST psw;
530       int bank;
531       int raw_regnum;
532
533       regcache_raw_read_unsigned (regcache, RL78_PSW_REGNUM, &psw);
534       bank = ((psw >> 3) & 1) | ((psw >> 4) & 1);
535       /* RSB0 is at bit 3; RSBS1 is at bit 5.  */
536       raw_regnum = RL78_RAW_BANK0_R0_REGNUM + bank * RL78_REGS_PER_BANK
537                    + (reg - RL78_X_REGNUM);
538       regcache_raw_write (regcache, raw_regnum, buffer);
539     }
540   else if (RL78_AX_REGNUM <= reg && reg <= RL78_HL_REGNUM)
541     {
542       ULONGEST psw;
543       int bank, raw_regnum;
544
545       regcache_raw_read_unsigned (regcache, RL78_PSW_REGNUM, &psw);
546       bank = ((psw >> 3) & 1) | ((psw >> 4) & 1);
547       /* RSB0 is at bit 3; RSBS1 is at bit 5.  */
548       raw_regnum = RL78_RAW_BANK0_R0_REGNUM + bank * RL78_REGS_PER_BANK
549                    + 2 * (reg - RL78_AX_REGNUM);
550       regcache_raw_write (regcache, raw_regnum, buffer);
551       regcache_raw_write (regcache, raw_regnum + 1, buffer + 1);
552     }
553   else
554     gdb_assert_not_reached ("invalid pseudo register number");
555 }
556
557 /* Implement the "breakpoint_from_pc" gdbarch method.  */
558
559 static const gdb_byte *
560 rl78_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
561                          int *lenptr)
562 {
563   /* The documented BRK instruction is actually a two byte sequence,
564      {0x61, 0xcc}, but instructions may be as short as one byte.
565      Correspondence with Renesas revealed that the one byte sequence
566      0xff is used when a one byte breakpoint instruction is required.  */
567   static gdb_byte breakpoint[] = { 0xff };
568
569   *lenptr = sizeof breakpoint;
570   return breakpoint;
571 }
572
573 /* Define a "handle" struct for fetching the next opcode.  */
574
575 struct rl78_get_opcode_byte_handle
576 {
577   CORE_ADDR pc;
578 };
579
580 /* Fetch a byte on behalf of the opcode decoder.  HANDLE contains
581    the memory address of the next byte to fetch.  If successful,
582    the address in the handle is updated and the byte fetched is
583    returned as the value of the function.  If not successful, -1
584    is returned.  */
585
586 static int
587 rl78_get_opcode_byte (void *handle)
588 {
589   struct rl78_get_opcode_byte_handle *opcdata = handle;
590   int status;
591   gdb_byte byte;
592
593   status = target_read_memory (opcdata->pc, &byte, 1);
594   if (status == 0)
595     {
596       opcdata->pc += 1;
597       return byte;
598     }
599   else
600     return -1;
601 }
602
603 /* Function for finding saved registers in a 'struct pv_area'; this
604    function is passed to pv_area_scan.
605
606    If VALUE is a saved register, ADDR says it was saved at a constant
607    offset from the frame base, and SIZE indicates that the whole
608    register was saved, record its offset.  */
609
610 static void
611 check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size,
612                  pv_t value)
613 {
614   struct rl78_prologue *result = (struct rl78_prologue *) result_untyped;
615
616   if (value.kind == pvk_register
617       && value.k == 0
618       && pv_is_register (addr, RL78_SP_REGNUM)
619       && size == register_size (target_gdbarch (), value.reg))
620     result->reg_offset[value.reg] = addr.k;
621 }
622
623 /* Analyze a prologue starting at START_PC, going no further than
624    LIMIT_PC.  Fill in RESULT as appropriate.  */
625
626 static void
627 rl78_analyze_prologue (CORE_ADDR start_pc,
628                        CORE_ADDR limit_pc, struct rl78_prologue *result)
629 {
630   CORE_ADDR pc, next_pc;
631   int rn;
632   pv_t reg[RL78_NUM_TOTAL_REGS];
633   struct pv_area *stack;
634   struct cleanup *back_to;
635   CORE_ADDR after_last_frame_setup_insn = start_pc;
636   int bank = 0;
637
638   memset (result, 0, sizeof (*result));
639
640   for (rn = 0; rn < RL78_NUM_TOTAL_REGS; rn++)
641     {
642       reg[rn] = pv_register (rn, 0);
643       result->reg_offset[rn] = 1;
644     }
645
646   stack = make_pv_area (RL78_SP_REGNUM, gdbarch_addr_bit (target_gdbarch ()));
647   back_to = make_cleanup_free_pv_area (stack);
648
649   /* The call instruction has saved the return address on the stack.  */
650   reg[RL78_SP_REGNUM] = pv_add_constant (reg[RL78_SP_REGNUM], -4);
651   pv_area_store (stack, reg[RL78_SP_REGNUM], 4, reg[RL78_PC_REGNUM]);
652
653   pc = start_pc;
654   while (pc < limit_pc)
655     {
656       int bytes_read;
657       struct rl78_get_opcode_byte_handle opcode_handle;
658       RL78_Opcode_Decoded opc;
659
660       opcode_handle.pc = pc;
661       bytes_read = rl78_decode_opcode (pc, &opc, rl78_get_opcode_byte,
662                                      &opcode_handle);
663       next_pc = pc + bytes_read;
664
665       if (opc.id == RLO_sel)
666         {
667           bank = opc.op[1].addend;
668         }
669       else if (opc.id == RLO_mov
670                && opc.op[0].type == RL78_Operand_PreDec
671                && opc.op[0].reg == RL78_Reg_SP
672                && opc.op[1].type == RL78_Operand_Register)
673         {
674           int rsrc = (bank * RL78_REGS_PER_BANK) 
675                    + 2 * (opc.op[1].reg - RL78_Reg_AX);
676
677           reg[RL78_SP_REGNUM] = pv_add_constant (reg[RL78_SP_REGNUM], -1);
678           pv_area_store (stack, reg[RL78_SP_REGNUM], 1, reg[rsrc]);
679           reg[RL78_SP_REGNUM] = pv_add_constant (reg[RL78_SP_REGNUM], -1);
680           pv_area_store (stack, reg[RL78_SP_REGNUM], 1, reg[rsrc + 1]);
681           after_last_frame_setup_insn = next_pc;
682         }
683       else if (opc.id == RLO_sub
684                && opc.op[0].type == RL78_Operand_Register
685                && opc.op[0].reg == RL78_Reg_SP
686                && opc.op[1].type == RL78_Operand_Immediate)
687         {
688           int addend = opc.op[1].addend;
689
690           reg[RL78_SP_REGNUM] = pv_add_constant (reg[RL78_SP_REGNUM],
691                                                  -addend);
692           after_last_frame_setup_insn = next_pc;
693         }
694       else
695         {
696           /* Terminate the prologue scan.  */
697           break;
698         }
699
700       pc = next_pc;
701     }
702
703   /* Is the frame size (offset, really) a known constant?  */
704   if (pv_is_register (reg[RL78_SP_REGNUM], RL78_SP_REGNUM))
705     result->frame_size = reg[RL78_SP_REGNUM].k;
706
707   /* Record where all the registers were saved.  */
708   pv_area_scan (stack, check_for_saved, (void *) result);
709
710   result->prologue_end = after_last_frame_setup_insn;
711
712   do_cleanups (back_to);
713 }
714
715 /* Implement the "addr_bits_remove" gdbarch method.  */
716
717 static CORE_ADDR
718 rl78_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
719 {
720   return addr & 0xffffff;
721 }
722
723 /* Implement the "address_to_pointer" gdbarch method.  */
724
725 static void
726 rl78_address_to_pointer (struct gdbarch *gdbarch,
727                          struct type *type, gdb_byte *buf, CORE_ADDR addr)
728 {
729   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
730
731   store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order,
732                           addr & 0xffffff);
733 }
734
735 /* Implement the "pointer_to_address" gdbarch method.  */
736
737 static CORE_ADDR
738 rl78_pointer_to_address (struct gdbarch *gdbarch,
739                          struct type *type, const gdb_byte *buf)
740 {
741   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
742   CORE_ADDR addr
743     = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
744
745   /* Is it a code address?  */
746   if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
747       || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD
748       || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type))
749       || TYPE_LENGTH (type) == 4)
750     return rl78_make_instruction_address (addr);
751   else
752     return rl78_make_data_address (addr);
753 }
754
755 /* Implement the "skip_prologue" gdbarch method.  */
756
757 static CORE_ADDR
758 rl78_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
759 {
760   const char *name;
761   CORE_ADDR func_addr, func_end;
762   struct rl78_prologue p;
763
764   /* Try to find the extent of the function that contains PC.  */
765   if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
766     return pc;
767
768   rl78_analyze_prologue (pc, func_end, &p);
769   return p.prologue_end;
770 }
771
772 /* Implement the "unwind_pc" gdbarch method.  */
773
774 static CORE_ADDR
775 rl78_unwind_pc (struct gdbarch *arch, struct frame_info *next_frame)
776 {
777   return rl78_addr_bits_remove
778            (arch, frame_unwind_register_unsigned (next_frame,
779                                                   RL78_PC_REGNUM));
780 }
781
782 /* Implement the "unwind_sp" gdbarch method.  */
783
784 static CORE_ADDR
785 rl78_unwind_sp (struct gdbarch *arch, struct frame_info *next_frame)
786 {
787   return frame_unwind_register_unsigned (next_frame, RL78_SP_REGNUM);
788 }
789
790 /* Given a frame described by THIS_FRAME, decode the prologue of its
791    associated function if there is not cache entry as specified by
792    THIS_PROLOGUE_CACHE.  Save the decoded prologue in the cache and
793    return that struct as the value of this function.  */
794
795 static struct rl78_prologue *
796 rl78_analyze_frame_prologue (struct frame_info *this_frame,
797                            void **this_prologue_cache)
798 {
799   if (!*this_prologue_cache)
800     {
801       CORE_ADDR func_start, stop_addr;
802
803       *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct rl78_prologue);
804
805       func_start = get_frame_func (this_frame);
806       stop_addr = get_frame_pc (this_frame);
807
808       /* If we couldn't find any function containing the PC, then
809          just initialize the prologue cache, but don't do anything.  */
810       if (!func_start)
811         stop_addr = func_start;
812
813       rl78_analyze_prologue (func_start, stop_addr, *this_prologue_cache);
814     }
815
816   return *this_prologue_cache;
817 }
818
819 /* Given a frame and a prologue cache, return this frame's base.  */
820
821 static CORE_ADDR
822 rl78_frame_base (struct frame_info *this_frame, void **this_prologue_cache)
823 {
824   struct rl78_prologue *p
825     = rl78_analyze_frame_prologue (this_frame, this_prologue_cache);
826   CORE_ADDR sp = get_frame_register_unsigned (this_frame, RL78_SP_REGNUM);
827
828   return rl78_make_data_address (sp - p->frame_size);
829 }
830
831 /* Implement the "frame_this_id" method for unwinding frames.  */
832
833 static void
834 rl78_this_id (struct frame_info *this_frame,
835               void **this_prologue_cache, struct frame_id *this_id)
836 {
837   *this_id = frame_id_build (rl78_frame_base (this_frame,
838                                               this_prologue_cache),
839                              get_frame_func (this_frame));
840 }
841
842 /* Implement the "frame_prev_register" method for unwinding frames.  */
843
844 static struct value *
845 rl78_prev_register (struct frame_info *this_frame,
846                     void **this_prologue_cache, int regnum)
847 {
848   struct rl78_prologue *p
849     = rl78_analyze_frame_prologue (this_frame, this_prologue_cache);
850   CORE_ADDR frame_base = rl78_frame_base (this_frame, this_prologue_cache);
851
852   if (regnum == RL78_SP_REGNUM)
853     return frame_unwind_got_constant (this_frame, regnum, frame_base);
854
855   else if (regnum == RL78_SPL_REGNUM)
856     return frame_unwind_got_constant (this_frame, regnum,
857                                       (frame_base & 0xff));
858
859   else if (regnum == RL78_SPH_REGNUM)
860     return frame_unwind_got_constant (this_frame, regnum,
861                                       ((frame_base >> 8) & 0xff));
862
863   /* If prologue analysis says we saved this register somewhere,
864      return a description of the stack slot holding it.  */
865   else if (p->reg_offset[regnum] != 1)
866     {
867       struct value *rv =
868         frame_unwind_got_memory (this_frame, regnum,
869                                  frame_base + p->reg_offset[regnum]);
870
871       if (regnum == RL78_PC_REGNUM)
872         {
873           ULONGEST pc = rl78_make_instruction_address (value_as_long (rv));
874
875           return frame_unwind_got_constant (this_frame, regnum, pc);
876         }
877       return rv;
878     }
879
880   /* Otherwise, presume we haven't changed the value of this
881      register, and get it from the next frame.  */
882   else
883     return frame_unwind_got_register (this_frame, regnum, regnum);
884 }
885
886 static const struct frame_unwind rl78_unwind =
887 {
888   NORMAL_FRAME,
889   default_frame_unwind_stop_reason,
890   rl78_this_id,
891   rl78_prev_register,
892   NULL,
893   default_frame_sniffer
894 };
895
896 /* Implement the "dwarf_reg_to_regnum" gdbarch method.  */
897
898 static int
899 rl78_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
900 {
901   if (0 <= reg && reg <= 31)
902     {
903       if ((reg & 1) == 0)
904         /* Map even registers to their 16-bit counterparts.  This
905            is usually what is required from the DWARF info.  */
906         return (reg >> 1) + RL78_BANK0_RP0_REGNUM;
907       else
908         return reg;
909     }
910   else if (reg == 32)
911     return RL78_SP_REGNUM;
912   else if (reg == 33)
913     return RL78_PC_REGNUM;
914   else
915     internal_error (__FILE__, __LINE__,
916                     _("Undefined dwarf2 register mapping of reg %d"),
917                     reg);
918 }
919
920 /* Implement the `register_sim_regno' gdbarch method.  */
921
922 static int
923 rl78_register_sim_regno (struct gdbarch *gdbarch, int regnum)
924 {
925   gdb_assert (regnum < RL78_NUM_REGS);
926
927   /* So long as regnum is in [0, RL78_NUM_REGS), it's valid.  We
928      just want to override the default here which disallows register
929      numbers which have no names.  */
930   return regnum;
931 }
932
933 /* Implement the "return_value" gdbarch method.  */
934
935 static enum return_value_convention
936 rl78_return_value (struct gdbarch *gdbarch,
937                    struct value *function,
938                    struct type *valtype,
939                    struct regcache *regcache,
940                    gdb_byte *readbuf, const gdb_byte *writebuf)
941 {
942   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
943   ULONGEST valtype_len = TYPE_LENGTH (valtype);
944
945   if (valtype_len > 8)
946     return RETURN_VALUE_STRUCT_CONVENTION;
947
948   if (readbuf)
949     {
950       ULONGEST u;
951       int argreg = RL78_RAW_BANK1_R0_REGNUM;
952       int offset = 0;
953
954       while (valtype_len > 0)
955         {
956           regcache_cooked_read_unsigned (regcache, argreg, &u);
957           store_unsigned_integer (readbuf + offset, 1, byte_order, u);
958           valtype_len -= 1;
959           offset += 1;
960           argreg++;
961         }
962     }
963
964   if (writebuf)
965     {
966       ULONGEST u;
967       int argreg = RL78_RAW_BANK1_R0_REGNUM;
968       int offset = 0;
969
970       while (valtype_len > 0)
971         {
972           u = extract_unsigned_integer (writebuf + offset, 1, byte_order);
973           regcache_cooked_write_unsigned (regcache, argreg, u);
974           valtype_len -= 1;
975           offset += 1;
976           argreg++;
977         }
978     }
979
980   return RETURN_VALUE_REGISTER_CONVENTION;
981 }
982
983
984 /* Implement the "frame_align" gdbarch method.  */
985
986 static CORE_ADDR
987 rl78_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
988 {
989   return rl78_make_data_address (align_down (sp, 2));
990 }
991
992
993 /* Implement the "dummy_id" gdbarch method.  */
994
995 static struct frame_id
996 rl78_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
997 {
998   return
999     frame_id_build (rl78_make_data_address
1000                       (get_frame_register_unsigned
1001                         (this_frame, RL78_SP_REGNUM)),
1002                     get_frame_pc (this_frame));
1003 }
1004
1005
1006 /* Implement the "push_dummy_call" gdbarch method.  */
1007
1008 static CORE_ADDR
1009 rl78_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1010                       struct regcache *regcache, CORE_ADDR bp_addr,
1011                       int nargs, struct value **args, CORE_ADDR sp,
1012                       int struct_return, CORE_ADDR struct_addr)
1013 {
1014   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1015   gdb_byte buf[4];
1016   int i;
1017
1018   /* Push arguments in reverse order.  */
1019   for (i = nargs - 1; i >= 0; i--)
1020     {
1021       struct type *value_type = value_enclosing_type (args[i]);
1022       int len = TYPE_LENGTH (value_type);
1023       int container_len = (len + 1) & ~1;
1024
1025       sp -= container_len;
1026       write_memory (rl78_make_data_address (sp),
1027                     value_contents_all (args[i]), len);
1028     }
1029
1030   /* Store struct value address.  */
1031   if (struct_return)
1032     {
1033       store_unsigned_integer (buf, 2, byte_order, struct_addr);
1034       sp -= 2;
1035       write_memory (rl78_make_data_address (sp), buf, 2);
1036     }
1037
1038   /* Store return address.  */
1039   sp -= 4;
1040   store_unsigned_integer (buf, 4, byte_order, bp_addr);
1041   write_memory (rl78_make_data_address (sp), buf, 4);
1042
1043   /* Finally, update the stack pointer...  */
1044   regcache_cooked_write_unsigned (regcache, RL78_SP_REGNUM, sp);
1045
1046   /* DWARF2/GCC uses the stack address *before* the function call as a
1047      frame's CFA.  */
1048   return rl78_make_data_address (sp + 4);
1049 }
1050
1051 /* Allocate and initialize a gdbarch object.  */
1052
1053 static struct gdbarch *
1054 rl78_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1055 {
1056   struct gdbarch *gdbarch;
1057   struct gdbarch_tdep *tdep;
1058   int elf_flags;
1059
1060   /* Extract the elf_flags if available.  */
1061   if (info.abfd != NULL
1062       && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
1063     elf_flags = elf_elfheader (info.abfd)->e_flags;
1064   else
1065     elf_flags = 0;
1066
1067
1068   /* Try to find the architecture in the list of already defined
1069      architectures.  */
1070   for (arches = gdbarch_list_lookup_by_info (arches, &info);
1071        arches != NULL;
1072        arches = gdbarch_list_lookup_by_info (arches->next, &info))
1073     {
1074       if (gdbarch_tdep (arches->gdbarch)->elf_flags != elf_flags)
1075         continue;
1076
1077       return arches->gdbarch;
1078     }
1079
1080   /* None found, create a new architecture from the information
1081      provided.  */
1082   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
1083   gdbarch = gdbarch_alloc (&info, tdep);
1084   tdep->elf_flags = elf_flags;
1085
1086   /* Initialize types.  */
1087   tdep->rl78_void = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
1088   tdep->rl78_uint8 = arch_integer_type (gdbarch, 8, 1, "uint8_t");
1089   tdep->rl78_int8 = arch_integer_type (gdbarch, 8, 0, "int8_t");
1090   tdep->rl78_uint16 = arch_integer_type (gdbarch, 16, 1, "uint16_t");
1091   tdep->rl78_int16 = arch_integer_type (gdbarch, 16, 0, "int16_t");
1092   tdep->rl78_uint32 = arch_integer_type (gdbarch, 32, 1, "uint32_t");
1093   tdep->rl78_int32 = arch_integer_type (gdbarch, 32, 0, "int32_t");
1094
1095   tdep->rl78_data_pointer
1096     = arch_type (gdbarch, TYPE_CODE_PTR, 16 / TARGET_CHAR_BIT,
1097                  xstrdup ("rl78_data_addr_t"));
1098   TYPE_TARGET_TYPE (tdep->rl78_data_pointer) = tdep->rl78_void;
1099   TYPE_UNSIGNED (tdep->rl78_data_pointer) = 1;
1100
1101   tdep->rl78_code_pointer
1102     = arch_type (gdbarch, TYPE_CODE_PTR, 32 / TARGET_CHAR_BIT,
1103                  xstrdup ("rl78_code_addr_t"));
1104   TYPE_TARGET_TYPE (tdep->rl78_code_pointer) = tdep->rl78_void;
1105   TYPE_UNSIGNED (tdep->rl78_code_pointer) = 1;
1106
1107   /* Registers.  */
1108   set_gdbarch_num_regs (gdbarch, RL78_NUM_REGS);
1109   set_gdbarch_num_pseudo_regs (gdbarch, RL78_NUM_PSEUDO_REGS);
1110   set_gdbarch_register_name (gdbarch, rl78_register_name);
1111   set_gdbarch_register_type (gdbarch, rl78_register_type);
1112   set_gdbarch_pc_regnum (gdbarch, RL78_PC_REGNUM);
1113   set_gdbarch_sp_regnum (gdbarch, RL78_SP_REGNUM);
1114   set_gdbarch_pseudo_register_read (gdbarch, rl78_pseudo_register_read);
1115   set_gdbarch_pseudo_register_write (gdbarch, rl78_pseudo_register_write);
1116   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, rl78_dwarf_reg_to_regnum);
1117   set_gdbarch_register_reggroup_p (gdbarch, rl78_register_reggroup_p);
1118   set_gdbarch_register_sim_regno (gdbarch, rl78_register_sim_regno);
1119
1120   /* Data types.  */
1121   set_gdbarch_char_signed (gdbarch, 0);
1122   set_gdbarch_short_bit (gdbarch, 16);
1123   set_gdbarch_int_bit (gdbarch, 16);
1124   set_gdbarch_long_bit (gdbarch, 32);
1125   set_gdbarch_long_long_bit (gdbarch, 64);
1126   set_gdbarch_ptr_bit (gdbarch, 16);
1127   set_gdbarch_addr_bit (gdbarch, 32);
1128   set_gdbarch_float_bit (gdbarch, 32);
1129   set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
1130   set_gdbarch_double_bit (gdbarch, 32);
1131   set_gdbarch_long_double_bit (gdbarch, 64);
1132   set_gdbarch_double_format (gdbarch, floatformats_ieee_single);
1133   set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
1134   set_gdbarch_pointer_to_address (gdbarch, rl78_pointer_to_address);
1135   set_gdbarch_address_to_pointer (gdbarch, rl78_address_to_pointer);
1136   set_gdbarch_addr_bits_remove (gdbarch, rl78_addr_bits_remove);
1137
1138   /* Breakpoints.  */
1139   set_gdbarch_breakpoint_from_pc (gdbarch, rl78_breakpoint_from_pc);
1140   set_gdbarch_decr_pc_after_break (gdbarch, 1);
1141
1142   /* Disassembly.  */
1143   set_gdbarch_print_insn (gdbarch, print_insn_rl78);
1144
1145   /* Frames, prologues, etc.  */
1146   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1147   set_gdbarch_skip_prologue (gdbarch, rl78_skip_prologue);
1148   set_gdbarch_unwind_pc (gdbarch, rl78_unwind_pc);
1149   set_gdbarch_unwind_sp (gdbarch, rl78_unwind_sp);
1150   set_gdbarch_frame_align (gdbarch, rl78_frame_align);
1151   frame_unwind_append_unwinder (gdbarch, &rl78_unwind);
1152
1153   /* Dummy frames, return values.  */
1154   set_gdbarch_dummy_id (gdbarch, rl78_dummy_id);
1155   set_gdbarch_push_dummy_call (gdbarch, rl78_push_dummy_call);
1156   set_gdbarch_return_value (gdbarch, rl78_return_value);
1157
1158   /* Virtual tables.  */
1159   set_gdbarch_vbit_in_delta (gdbarch, 1);
1160
1161   return gdbarch;
1162 }
1163
1164 /* -Wmissing-prototypes */
1165 extern initialize_file_ftype _initialize_rl78_tdep;
1166
1167 /* Register the above initialization routine.  */
1168
1169 void
1170 _initialize_rl78_tdep (void)
1171 {
1172   register_gdbarch_init (bfd_arch_rl78, rl78_gdbarch_init);
1173 }