]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/xstormy16-tdep.c
Copyright updates for 2007.
[thirdparty/binutils-gdb.git] / gdb / xstormy16-tdep.c
CommitLineData
0c884e17 1/* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
f4f9705a 2
6aba47ca
DJ
3 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007
4 Free Software Foundation, Inc.
0c884e17
CV
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
197e01b6
EZ
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
0c884e17
CV
22
23#include "defs.h"
b6fcb393
CV
24#include "frame.h"
25#include "frame-base.h"
26#include "frame-unwind.h"
27#include "dwarf2-frame.h"
28#include "symtab.h"
29#include "gdbtypes.h"
30#include "gdbcmd.h"
31#include "gdbcore.h"
0c884e17 32#include "value.h"
b6fcb393 33#include "dis-asm.h"
0c884e17 34#include "inferior.h"
b6fcb393
CV
35#include "gdb_string.h"
36#include "gdb_assert.h"
0c884e17 37#include "arch-utils.h"
b6fcb393 38#include "floatformat.h"
0c884e17 39#include "regcache.h"
b6fcb393
CV
40#include "doublest.h"
41#include "osabi.h"
0c884e17 42#include "objfiles.h"
0c884e17
CV
43
44enum gdb_regnum
45{
46 /* Xstormy16 has 16 general purpose registers (R0-R15) plus PC.
47 Functions will return their values in register R2-R7 as they fit.
48 Otherwise a hidden pointer to an big enough area is given as argument
49 to the function in r2. Further arguments are beginning in r3 then.
50 R13 is used as frame pointer when GCC compiles w/o optimization
51 R14 is used as "PSW", displaying the CPU status.
52 R15 is used implicitely as stack pointer. */
53 E_R0_REGNUM,
54 E_R1_REGNUM,
55 E_R2_REGNUM, E_1ST_ARG_REGNUM = E_R2_REGNUM, E_PTR_RET_REGNUM = E_R2_REGNUM,
56 E_R3_REGNUM,
57 E_R4_REGNUM,
58 E_R5_REGNUM,
59 E_R6_REGNUM,
60 E_R7_REGNUM, E_LST_ARG_REGNUM = E_R7_REGNUM,
61 E_R8_REGNUM,
62 E_R9_REGNUM,
63 E_R10_REGNUM,
64 E_R11_REGNUM,
65 E_R12_REGNUM,
66 E_R13_REGNUM, E_FP_REGNUM = E_R13_REGNUM,
67 E_R14_REGNUM, E_PSW_REGNUM = E_R14_REGNUM,
68 E_R15_REGNUM, E_SP_REGNUM = E_R15_REGNUM,
69 E_PC_REGNUM,
70 E_NUM_REGS
71};
72
b6fcb393
CV
73/* Use an invalid address value as 'not available' marker. */
74enum { REG_UNAVAIL = (CORE_ADDR) -1 };
75
76struct xstormy16_frame_cache
77{
78 /* Base address. */
79 CORE_ADDR base;
80 CORE_ADDR pc;
81 LONGEST framesize;
82 int uses_fp;
83 CORE_ADDR saved_regs[E_NUM_REGS];
84 CORE_ADDR saved_sp;
85};
86
0c884e17
CV
87/* Size of instructions, registers, etc. */
88enum
89{
90 xstormy16_inst_size = 2,
91 xstormy16_reg_size = 2,
92 xstormy16_pc_size = 4
93};
94
95/* Size of return datatype which fits into the remaining return registers. */
96#define E_MAX_RETTYPE_SIZE(regnum) ((E_LST_ARG_REGNUM - (regnum) + 1) \
97 * xstormy16_reg_size)
98
99/* Size of return datatype which fits into all return registers. */
100enum
101{
102 E_MAX_RETTYPE_SIZE_IN_REGS = E_MAX_RETTYPE_SIZE (E_R2_REGNUM)
103};
104
0c884e17 105/* Function: xstormy16_register_name
b6fcb393 106 Returns the name of the standard Xstormy16 register N. */
0c884e17 107
fa88f677 108static const char *
0c884e17
CV
109xstormy16_register_name (int regnum)
110{
111 static char *register_names[] = {
112 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
113 "r8", "r9", "r10", "r11", "r12", "r13",
114 "psw", "sp", "pc"
115 };
116
b6fcb393 117 if (regnum < 0 || regnum >= E_NUM_REGS)
0c884e17 118 internal_error (__FILE__, __LINE__,
e2e0b3e5 119 _("xstormy16_register_name: illegal register number %d"),
0c884e17
CV
120 regnum);
121 else
122 return register_names[regnum];
123
124}
125
0c884e17 126static struct type *
b6fcb393 127xstormy16_register_type (struct gdbarch *gdbarch, int regnum)
0c884e17 128{
b6fcb393 129 if (regnum == E_PC_REGNUM)
0c884e17
CV
130 return builtin_type_uint32;
131 else
132 return builtin_type_uint16;
133}
134
0c884e17
CV
135/* Function: xstormy16_type_is_scalar
136 Makes the decision if a given type is a scalar types. Scalar
b6fcb393 137 types are returned in the registers r2-r7 as they fit. */
0c884e17
CV
138
139static int
140xstormy16_type_is_scalar (struct type *t)
141{
142 return (TYPE_CODE(t) != TYPE_CODE_STRUCT
143 && TYPE_CODE(t) != TYPE_CODE_UNION
144 && TYPE_CODE(t) != TYPE_CODE_ARRAY);
145}
146
b6fcb393
CV
147/* Function: xstormy16_use_struct_convention
148 Returns non-zero if the given struct type will be returned using
149 a special convention, rather than the normal function return method.
150 7sed in the contexts of the "return" command, and of
151 target function calls from the debugger. */
152
153static int
154xstormy16_use_struct_convention (struct type *type)
155{
156 return !xstormy16_type_is_scalar (type)
157 || TYPE_LENGTH (type) > E_MAX_RETTYPE_SIZE_IN_REGS;
158}
159
0c884e17 160/* Function: xstormy16_extract_return_value
b6fcb393
CV
161 Find a function's return value in the appropriate registers (in
162 regbuf), and copy it into valbuf. */
0c884e17
CV
163
164static void
b6fcb393
CV
165xstormy16_extract_return_value (struct type *type, struct regcache *regcache,
166 void *valbuf)
0c884e17 167{
b6fcb393
CV
168 int len = TYPE_LENGTH (type);
169 int i, regnum = E_1ST_ARG_REGNUM;
0c884e17 170
b6fcb393
CV
171 for (i = 0; i < len; i += xstormy16_reg_size)
172 regcache_raw_read (regcache, regnum++, (char *) valbuf + i);
173}
174
175/* Function: xstormy16_store_return_value
176 Copy the function return value from VALBUF into the
177 proper location for a function return.
178 Called only in the context of the "return" command. */
179
180static void
181xstormy16_store_return_value (struct type *type, struct regcache *regcache,
182 const void *valbuf)
183{
184 if (TYPE_LENGTH (type) == 1)
185 {
186 /* Add leading zeros to the value. */
187 char buf[xstormy16_reg_size];
188 memset (buf, 0, xstormy16_reg_size);
189 memcpy (buf, valbuf, 1);
190 regcache_raw_write (regcache, E_1ST_ARG_REGNUM, buf);
0c884e17
CV
191 }
192 else
193 {
b6fcb393
CV
194 int len = TYPE_LENGTH (type);
195 int i, regnum = E_1ST_ARG_REGNUM;
0c884e17 196
b6fcb393
CV
197 for (i = 0; i < len; i += xstormy16_reg_size)
198 regcache_raw_write (regcache, regnum++, (char *) valbuf + i);
0c884e17
CV
199 }
200}
201
b6fcb393
CV
202static enum return_value_convention
203xstormy16_return_value (struct gdbarch *gdbarch, struct type *type,
204 struct regcache *regcache,
05c6a9a1 205 gdb_byte *readbuf, const gdb_byte *writebuf)
b6fcb393
CV
206{
207 if (xstormy16_use_struct_convention (type))
208 return RETURN_VALUE_STRUCT_CONVENTION;
209 if (writebuf)
210 xstormy16_store_return_value (type, regcache, writebuf);
211 else if (readbuf)
212 xstormy16_extract_return_value (type, regcache, readbuf);
213 return RETURN_VALUE_REGISTER_CONVENTION;
214}
215
216static CORE_ADDR
217xstormy16_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
218{
219 if (addr & 1)
220 ++addr;
221 return addr;
222}
223
224/* Function: xstormy16_push_dummy_call
0c884e17
CV
225 Setup the function arguments for GDB to call a function in the inferior.
226 Called only in the context of a target function call from the debugger.
b6fcb393 227 Returns the value of the SP register after the args are pushed. */
0c884e17
CV
228
229static CORE_ADDR
b6fcb393
CV
230xstormy16_push_dummy_call (struct gdbarch *gdbarch,
231 struct value *function,
232 struct regcache *regcache,
233 CORE_ADDR bp_addr, int nargs,
234 struct value **args,
235 CORE_ADDR sp, int struct_return,
236 CORE_ADDR struct_addr)
0c884e17
CV
237{
238 CORE_ADDR stack_dest = sp;
239 int argreg = E_1ST_ARG_REGNUM;
240 int i, j;
241 int typelen, slacklen;
05c6a9a1 242 const gdb_byte *val;
b6fcb393 243 char buf[xstormy16_pc_size];
0c884e17
CV
244
245 /* If struct_return is true, then the struct return address will
246 consume one argument-passing register. */
247 if (struct_return)
b6fcb393
CV
248 {
249 regcache_cooked_write_unsigned (regcache, E_PTR_RET_REGNUM, struct_addr);
250 argreg++;
251 }
0c884e17
CV
252
253 /* Arguments are passed in R2-R7 as they fit. If an argument doesn't
254 fit in the remaining registers we're switching over to the stack.
255 No argument is put on stack partially and as soon as we switched
256 over to stack no further argument is put in a register even if it
b6fcb393 257 would fit in the remaining unused registers. */
0c884e17
CV
258 for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++)
259 {
4754a64e 260 typelen = TYPE_LENGTH (value_enclosing_type (args[i]));
0c884e17
CV
261 if (typelen > E_MAX_RETTYPE_SIZE (argreg))
262 break;
263
264 /* Put argument into registers wordwise. */
0fd88904 265 val = value_contents (args[i]);
0c884e17 266 for (j = 0; j < typelen; j += xstormy16_reg_size)
b6fcb393 267 regcache_cooked_write_unsigned (regcache, argreg++,
0c884e17
CV
268 extract_unsigned_integer (val + j,
269 typelen - j ==
270 1 ? 1 :
271 xstormy16_reg_size));
272 }
273
274 /* Align SP */
b6fcb393 275 stack_dest = xstormy16_frame_align (gdbarch, stack_dest);
0c884e17
CV
276
277 /* Loop backwards through remaining arguments and push them on the stack,
b6fcb393 278 wordaligned. */
0c884e17
CV
279 for (j = nargs - 1; j >= i; j--)
280 {
05c6a9a1
MS
281 char *val;
282
4754a64e 283 typelen = TYPE_LENGTH (value_enclosing_type (args[j]));
0c884e17
CV
284 slacklen = typelen & 1;
285 val = alloca (typelen + slacklen);
0fd88904 286 memcpy (val, value_contents (args[j]), typelen);
0c884e17
CV
287 memset (val + typelen, 0, slacklen);
288
289 /* Now write this data to the stack. The stack grows upwards. */
290 write_memory (stack_dest, val, typelen + slacklen);
291 stack_dest += typelen + slacklen;
292 }
293
b6fcb393
CV
294 store_unsigned_integer (buf, xstormy16_pc_size, bp_addr);
295 write_memory (stack_dest, buf, xstormy16_pc_size);
296 stack_dest += xstormy16_pc_size;
0c884e17 297
b6fcb393
CV
298 /* Update stack pointer. */
299 regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, stack_dest);
0c884e17 300
b6fcb393
CV
301 /* Return the new stack pointer minus the return address slot since
302 that's what DWARF2/GCC uses as the frame's CFA. */
303 return stack_dest - xstormy16_pc_size;
0c884e17
CV
304}
305
306/* Function: xstormy16_scan_prologue
307 Decode the instructions within the given address range.
308 Decide when we must have reached the end of the function prologue.
309 If a frame_info pointer is provided, fill in its saved_regs etc.
310
b6fcb393 311 Returns the address of the first instruction after the prologue. */
0c884e17
CV
312
313static CORE_ADDR
b6fcb393
CV
314xstormy16_analyze_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
315 struct xstormy16_frame_cache *cache,
316 struct frame_info *next_frame)
0c884e17 317{
0c884e17
CV
318 CORE_ADDR next_addr;
319 ULONGEST inst, inst2;
320 LONGEST offset;
321 int regnum;
322
b6fcb393
CV
323 /* Initialize framesize with size of PC put on stack by CALLF inst. */
324 cache->saved_regs[E_PC_REGNUM] = 0;
325 cache->framesize = xstormy16_pc_size;
326
327 if (start_addr >= end_addr)
328 return end_addr;
329
0c884e17
CV
330 for (next_addr = start_addr;
331 next_addr < end_addr; next_addr += xstormy16_inst_size)
332 {
333 inst = read_memory_unsigned_integer (next_addr, xstormy16_inst_size);
334 inst2 = read_memory_unsigned_integer (next_addr + xstormy16_inst_size,
335 xstormy16_inst_size);
336
337 if (inst >= 0x0082 && inst <= 0x008d) /* push r2 .. push r13 */
338 {
b6fcb393
CV
339 regnum = inst & 0x000f;
340 cache->saved_regs[regnum] = cache->framesize;
341 cache->framesize += xstormy16_reg_size;
0c884e17
CV
342 }
343
344 /* optional stack allocation for args and local vars <= 4 byte */
345 else if (inst == 0x301f || inst == 0x303f) /* inc r15, #0x1/#0x3 */
346 {
b6fcb393 347 cache->framesize += ((inst & 0x0030) >> 4) + 1;
0c884e17
CV
348 }
349
350 /* optional stack allocation for args and local vars > 4 && < 16 byte */
351 else if ((inst & 0xff0f) == 0x510f) /* 51Hf add r15, #0xH */
352 {
b6fcb393 353 cache->framesize += (inst & 0x00f0) >> 4;
0c884e17
CV
354 }
355
356 /* optional stack allocation for args and local vars >= 16 byte */
357 else if (inst == 0x314f && inst2 >= 0x0010) /* 314f HHHH add r15, #0xH */
358 {
b6fcb393 359 cache->framesize += inst2;
0c884e17
CV
360 next_addr += xstormy16_inst_size;
361 }
362
363 else if (inst == 0x46fd) /* mov r13, r15 */
364 {
b6fcb393 365 cache->uses_fp = 1;
0c884e17
CV
366 }
367
368 /* optional copying of args in r2-r7 to r10-r13 */
369 /* Probably only in optimized case but legal action for prologue */
370 else if ((inst & 0xff00) == 0x4600 /* 46SD mov rD, rS */
371 && (inst & 0x00f0) >= 0x0020 && (inst & 0x00f0) <= 0x0070
372 && (inst & 0x000f) >= 0x00a0 && (inst & 0x000f) <= 0x000d)
373 ;
374
375 /* optional copying of args in r2-r7 to stack */
376 /* 72DS HHHH mov.b (rD, 0xHHHH), r(S-8) (bit3 always 1, bit2-0 = reg) */
377 /* 73DS HHHH mov.w (rD, 0xHHHH), r(S-8) */
378 else if ((inst & 0xfed8) == 0x72d8 && (inst & 0x0007) >= 2)
379 {
b6fcb393
CV
380 regnum = inst & 0x0007;
381 /* Only 12 of 16 bits of the argument are used for the
382 signed offset. */
383 offset = (LONGEST) (inst2 & 0x0fff);
384 if (offset & 0x0800)
385 offset -= 0x1000;
386
387 cache->saved_regs[regnum] = cache->framesize + offset;
0c884e17
CV
388 next_addr += xstormy16_inst_size;
389 }
0c884e17
CV
390
391 else /* Not a prologue instruction. */
392 break;
393 }
394
0c884e17
CV
395 return next_addr;
396}
397
398/* Function: xstormy16_skip_prologue
399 If the input address is in a function prologue,
400 returns the address of the end of the prologue;
401 else returns the input address.
402
403 Note: the input address is likely to be the function start,
404 since this function is mainly used for advancing a breakpoint
405 to the first line, or stepping to the first line when we have
406 stepped into a function call. */
407
408static CORE_ADDR
409xstormy16_skip_prologue (CORE_ADDR pc)
410{
411 CORE_ADDR func_addr = 0, func_end = 0;
412 char *func_name;
413
414 if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
415 {
416 struct symtab_and_line sal;
417 struct symbol *sym;
b6fcb393 418 struct xstormy16_frame_cache cache;
0c884e17 419
28fe5f6a
KB
420 memset (&cache, 0, sizeof cache);
421
211a4f69 422 /* Don't trust line number debug info in frameless functions. */
b6fcb393
CV
423 CORE_ADDR plg_end = xstormy16_analyze_prologue (func_addr, func_end,
424 &cache, NULL);
425 if (!cache.uses_fp)
211a4f69
CV
426 return plg_end;
427
0c884e17 428 /* Found a function. */
176620f1 429 sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL, NULL);
211a4f69 430 /* Don't use line number debug info for assembly source files. */
0c884e17
CV
431 if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
432 {
0c884e17
CV
433 sal = find_pc_line (func_addr, 0);
434 if (sal.end && sal.end < func_end)
435 {
436 /* Found a line number, use it as end of prologue. */
437 return sal.end;
438 }
439 }
211a4f69
CV
440 /* No useable line symbol. Use result of prologue parsing method. */
441 return plg_end;
0c884e17
CV
442 }
443
444 /* No function symbol -- just return the PC. */
445
446 return (CORE_ADDR) pc;
447}
448
449/* The epilogue is defined here as the area at the end of a function,
450 either on the `ret' instruction itself or after an instruction which
451 destroys the function's stack frame. */
452static int
453xstormy16_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
454{
b6fcb393 455 CORE_ADDR func_addr = 0, func_end = 0;
0c884e17
CV
456
457 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
458 {
459 ULONGEST inst, inst2;
460 CORE_ADDR addr = func_end - xstormy16_inst_size;
461
462 /* The Xstormy16 epilogue is max. 14 bytes long. */
463 if (pc < func_end - 7 * xstormy16_inst_size)
464 return 0;
465
466 /* Check if we're on a `ret' instruction. Otherwise it's
467 too dangerous to proceed. */
468 inst = read_memory_unsigned_integer (addr, xstormy16_inst_size);
469 if (inst != 0x0003)
470 return 0;
471
472 while ((addr -= xstormy16_inst_size) >= func_addr)
473 {
474 inst = read_memory_unsigned_integer (addr, xstormy16_inst_size);
475 if (inst >= 0x009a && inst <= 0x009d) /* pop r10...r13 */
476 continue;
477 if (inst == 0x305f || inst == 0x307f) /* dec r15, #0x1/#0x3 */
478 break;
479 inst2 = read_memory_unsigned_integer (addr - xstormy16_inst_size,
480 xstormy16_inst_size);
481 if (inst2 == 0x314f && inst >= 0x8000) /* add r15, neg. value */
482 {
483 addr -= xstormy16_inst_size;
484 break;
485 }
486 return 0;
487 }
488 if (pc > addr)
489 return 1;
490 }
491 return 0;
492}
493
f4f9705a 494const static unsigned char *
0c884e17
CV
495xstormy16_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
496{
497 static unsigned char breakpoint[] = { 0x06, 0x0 };
498 *lenptr = sizeof (breakpoint);
499 return breakpoint;
500}
501
502/* Given a pointer to a jump table entry, return the address
503 of the function it jumps to. Return 0 if not found. */
504static CORE_ADDR
505xstormy16_resolve_jmp_table_entry (CORE_ADDR faddr)
506{
507 struct obj_section *faddr_sect = find_pc_section (faddr);
508
509 if (faddr_sect)
510 {
511 LONGEST inst, inst2, addr;
512 char buf[2 * xstormy16_inst_size];
513
514 /* Return faddr if it's not pointing into the jump table. */
515 if (strcmp (faddr_sect->the_bfd_section->name, ".plt"))
516 return faddr;
517
518 if (!target_read_memory (faddr, buf, sizeof buf))
519 {
520 inst = extract_unsigned_integer (buf, xstormy16_inst_size);
521 inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
522 xstormy16_inst_size);
523 addr = inst2 << 8 | (inst & 0xff);
524 return addr;
525 }
526 }
527 return 0;
528}
529
530/* Given a function's address, attempt to find (and return) the
531 address of the corresponding jump table entry. Return 0 if
532 not found. */
533static CORE_ADDR
534xstormy16_find_jmp_table_entry (CORE_ADDR faddr)
535{
536 struct obj_section *faddr_sect = find_pc_section (faddr);
537
538 if (faddr_sect)
539 {
540 struct obj_section *osect;
541
542 /* Return faddr if it's already a pointer to a jump table entry. */
543 if (!strcmp (faddr_sect->the_bfd_section->name, ".plt"))
544 return faddr;
545
546 ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
547 {
548 if (!strcmp (osect->the_bfd_section->name, ".plt"))
549 break;
550 }
551
552 if (osect < faddr_sect->objfile->sections_end)
553 {
554 CORE_ADDR addr;
555 for (addr = osect->addr;
556 addr < osect->endaddr; addr += 2 * xstormy16_inst_size)
557 {
0c884e17
CV
558 LONGEST inst, inst2, faddr2;
559 char buf[2 * xstormy16_inst_size];
560
561 if (target_read_memory (addr, buf, sizeof buf))
562 return 0;
563 inst = extract_unsigned_integer (buf, xstormy16_inst_size);
564 inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
565 xstormy16_inst_size);
566 faddr2 = inst2 << 8 | (inst & 0xff);
567 if (faddr == faddr2)
568 return addr;
569 }
570 }
571 }
572 return 0;
573}
574
575static CORE_ADDR
576xstormy16_skip_trampoline_code (CORE_ADDR pc)
577{
b6fcb393 578 CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (pc);
0c884e17
CV
579
580 if (tmp && tmp != pc)
581 return tmp;
582 return 0;
583}
584
b6fcb393
CV
585/* Function pointers are 16 bit. The address space is 24 bit, using
586 32 bit addresses. Pointers to functions on the XStormy16 are implemented
587 by using 16 bit pointers, which are either direct pointers in case the
588 function begins below 0x10000, or indirect pointers into a jump table.
589 The next two functions convert 16 bit pointers into 24 (32) bit addresses
590 and vice versa. */
591
0c884e17 592static CORE_ADDR
05c6a9a1 593xstormy16_pointer_to_address (struct type *type, const gdb_byte *buf)
0c884e17
CV
594{
595 enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
7c0b4a20 596 CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
0c884e17
CV
597
598 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
599 {
600 CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (addr);
601 if (addr2)
602 addr = addr2;
603 }
604
605 return addr;
606}
607
608static void
05c6a9a1 609xstormy16_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr)
0c884e17
CV
610{
611 enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
612
613 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
614 {
615 CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (addr);
616 if (addr2)
617 addr = addr2;
618 }
fbd9dcd3 619 store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
0c884e17
CV
620}
621
b6fcb393
CV
622static struct xstormy16_frame_cache *
623xstormy16_alloc_frame_cache (void)
0c884e17 624{
b6fcb393
CV
625 struct xstormy16_frame_cache *cache;
626 int i;
627
628 cache = FRAME_OBSTACK_ZALLOC (struct xstormy16_frame_cache);
629
630 cache->base = 0;
631 cache->saved_sp = 0;
632 cache->pc = 0;
633 cache->uses_fp = 0;
634 cache->framesize = 0;
635 for (i = 0; i < E_NUM_REGS; ++i)
636 cache->saved_regs[i] = REG_UNAVAIL;
637
638 return cache;
639}
640
641static struct xstormy16_frame_cache *
642xstormy16_frame_cache (struct frame_info *next_frame, void **this_cache)
643{
644 struct xstormy16_frame_cache *cache;
645 CORE_ADDR current_pc;
646 int i;
647
648 if (*this_cache)
649 return *this_cache;
650
651 cache = xstormy16_alloc_frame_cache ();
652 *this_cache = cache;
653
654 cache->base = frame_unwind_register_unsigned (next_frame, E_FP_REGNUM);
655 if (cache->base == 0)
656 return cache;
657
658 cache->pc = frame_func_unwind (next_frame);
659 current_pc = frame_pc_unwind (next_frame);
660 if (cache->pc)
661 xstormy16_analyze_prologue (cache->pc, current_pc, cache, next_frame);
662
663 if (!cache->uses_fp)
664 cache->base = frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
665
666 cache->saved_sp = cache->base - cache->framesize;
667
668 for (i = 0; i < E_NUM_REGS; ++i)
669 if (cache->saved_regs[i] != REG_UNAVAIL)
670 cache->saved_regs[i] += cache->saved_sp;
671
672 return cache;
0c884e17
CV
673}
674
a78f21af 675static void
05c6a9a1
MS
676xstormy16_frame_prev_register (struct frame_info *next_frame,
677 void **this_cache,
b6fcb393
CV
678 int regnum, int *optimizedp,
679 enum lval_type *lvalp, CORE_ADDR *addrp,
05c6a9a1 680 int *realnump, gdb_byte *valuep)
b6fcb393
CV
681{
682 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (next_frame,
683 this_cache);
684 gdb_assert (regnum >= 0);
685
686 if (regnum == E_SP_REGNUM && cache->saved_sp)
687 {
688 *optimizedp = 0;
689 *lvalp = not_lval;
690 *addrp = 0;
691 *realnump = -1;
692 if (valuep)
693 {
694 /* Store the value. */
695 store_unsigned_integer (valuep, xstormy16_reg_size, cache->saved_sp);
696 }
697 return;
698 }
699
700 if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
701 {
702 *optimizedp = 0;
703 *lvalp = lval_memory;
704 *addrp = cache->saved_regs[regnum];
705 *realnump = -1;
706 if (valuep)
707 {
708 /* Read the value in from memory. */
709 read_memory (*addrp, valuep,
710 register_size (current_gdbarch, regnum));
711 }
712 return;
713 }
714
00b25ff3
AC
715 *optimizedp = 0;
716 *lvalp = lval_register;
717 *addrp = 0;
718 *realnump = regnum;
719 if (valuep)
720 frame_unwind_register (next_frame, (*realnump), valuep);
b6fcb393
CV
721}
722
723static void
724xstormy16_frame_this_id (struct frame_info *next_frame, void **this_cache,
725 struct frame_id *this_id)
726{
727 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (next_frame,
728 this_cache);
729
730 /* This marks the outermost frame. */
731 if (cache->base == 0)
732 return;
733
734 *this_id = frame_id_build (cache->saved_sp, cache->pc);
735}
736
737static CORE_ADDR
738xstormy16_frame_base_address (struct frame_info *next_frame, void **this_cache)
739{
740 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (next_frame,
741 this_cache);
742 return cache->base;
743}
744
745static const struct frame_unwind xstormy16_frame_unwind = {
746 NORMAL_FRAME,
747 xstormy16_frame_this_id,
748 xstormy16_frame_prev_register
749};
750
751static const struct frame_base xstormy16_frame_base = {
752 &xstormy16_frame_unwind,
753 xstormy16_frame_base_address,
754 xstormy16_frame_base_address,
755 xstormy16_frame_base_address
756};
757
758static const struct frame_unwind *
759xstormy16_frame_sniffer (struct frame_info *next_frame)
760{
761 return &xstormy16_frame_unwind;
762}
763
764static CORE_ADDR
765xstormy16_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
766{
767 return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
768}
769
770static CORE_ADDR
771xstormy16_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
0c884e17 772{
b6fcb393 773 return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
0c884e17
CV
774}
775
b6fcb393
CV
776static struct frame_id
777xstormy16_unwind_dummy_id (struct gdbarch *gdbarch,
778 struct frame_info *next_frame)
779{
780 return frame_id_build (xstormy16_unwind_sp (gdbarch, next_frame),
781 frame_pc_unwind (next_frame));
782}
783
784
0c884e17
CV
785/* Function: xstormy16_gdbarch_init
786 Initializer function for the xstormy16 gdbarch vector.
787 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
788
789static struct gdbarch *
790xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
791{
0c884e17
CV
792 struct gdbarch *gdbarch;
793
794 /* find a candidate among the list of pre-declared architectures. */
795 arches = gdbarch_list_lookup_by_info (arches, &info);
796 if (arches != NULL)
797 return (arches->gdbarch);
798
b6fcb393 799 gdbarch = gdbarch_alloc (&info, NULL);
a5afb99f 800
0c884e17 801 /*
b6fcb393 802 * Basic register fields and methods, datatype sizes and stuff.
0c884e17
CV
803 */
804
805 set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
806 set_gdbarch_num_pseudo_regs (gdbarch, 0);
807 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
0c884e17
CV
808 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
809 set_gdbarch_register_name (gdbarch, xstormy16_register_name);
b6fcb393 810 set_gdbarch_register_type (gdbarch, xstormy16_register_type);
0c884e17 811
71c08af0 812 set_gdbarch_char_signed (gdbarch, 0);
b6fcb393 813 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
0c884e17 814 set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
b6fcb393
CV
815 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
816 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
817
818 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
819 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
820 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
821
0c884e17
CV
822 set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
823 set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
0c884e17
CV
824
825 set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
826 set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);
827
b6fcb393 828 set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
0c884e17 829
b6fcb393
CV
830 /* Stack grows up. */
831 set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
0c884e17 832
b6fcb393
CV
833 /*
834 * Frame Info
835 */
836 set_gdbarch_unwind_sp (gdbarch, xstormy16_unwind_sp);
837 set_gdbarch_unwind_pc (gdbarch, xstormy16_unwind_pc);
838 set_gdbarch_unwind_dummy_id (gdbarch, xstormy16_unwind_dummy_id);
839 set_gdbarch_frame_align (gdbarch, xstormy16_frame_align);
840 frame_base_set_default (gdbarch, &xstormy16_frame_base);
0c884e17 841
b6fcb393
CV
842 set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue);
843 set_gdbarch_in_function_epilogue_p (gdbarch,
844 xstormy16_in_function_epilogue_p);
845
846 /* These values and methods are used when gdb calls a target function. */
847 set_gdbarch_push_dummy_call (gdbarch, xstormy16_push_dummy_call);
848 set_gdbarch_breakpoint_from_pc (gdbarch, xstormy16_breakpoint_from_pc);
849 set_gdbarch_return_value (gdbarch, xstormy16_return_value);
850
851 set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code);
0c884e17 852
36482093
AC
853 set_gdbarch_print_insn (gdbarch, print_insn_xstormy16);
854
b6fcb393
CV
855 gdbarch_init_osabi (info, gdbarch);
856
857 frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
858 frame_unwind_append_sniffer (gdbarch, xstormy16_frame_sniffer);
859
0c884e17
CV
860 return gdbarch;
861}
862
863/* Function: _initialize_xstormy16_tdep
864 Initializer function for the Sanyo Xstormy16a module.
865 Called by gdb at start-up. */
866
a78f21af
AC
867extern initialize_file_ftype _initialize_xstormy16_tdep; /* -Wmissing-prototypes */
868
0c884e17
CV
869void
870_initialize_xstormy16_tdep (void)
871{
0c884e17 872 register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);
0c884e17 873}