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