GDB (xrefs)
/tmp/gdb-7.10/gdb/xstormy16-tdep.c
Go to the documentation of this file.
1 /* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
2 
3  Copyright (C) 2001-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 #include "defs.h"
21 #include "frame.h"
22 #include "frame-base.h"
23 #include "frame-unwind.h"
24 #include "dwarf2-frame.h"
25 #include "symtab.h"
26 #include "gdbtypes.h"
27 #include "gdbcmd.h"
28 #include "gdbcore.h"
29 #include "value.h"
30 #include "dis-asm.h"
31 #include "inferior.h"
32 #include "arch-utils.h"
33 #include "floatformat.h"
34 #include "regcache.h"
35 #include "doublest.h"
36 #include "osabi.h"
37 #include "objfiles.h"
38 
40 {
41  /* Xstormy16 has 16 general purpose registers (R0-R15) plus PC.
42  Functions will return their values in register R2-R7 as they fit.
43  Otherwise a hidden pointer to an big enough area is given as argument
44  to the function in r2. Further arguments are beginning in r3 then.
45  R13 is used as frame pointer when GCC compiles w/o optimization
46  R14 is used as "PSW", displaying the CPU status.
47  R15 is used implicitely as stack pointer. */
66 };
67 
68 /* Use an invalid address value as 'not available' marker. */
69 enum { REG_UNAVAIL = (CORE_ADDR) -1 };
70 
72 {
73  /* Base address. */
77  int uses_fp;
80 };
81 
82 /* Size of instructions, registers, etc. */
83 enum
84 {
88 };
89 
90 /* Size of return datatype which fits into the remaining return registers. */
91 #define E_MAX_RETTYPE_SIZE(regnum) ((E_LST_ARG_REGNUM - (regnum) + 1) \
92  * xstormy16_reg_size)
93 
94 /* Size of return datatype which fits into all return registers. */
95 enum
96 {
98 };
99 
100 /* Function: xstormy16_register_name
101  Returns the name of the standard Xstormy16 register N. */
102 
103 static const char *
104 xstormy16_register_name (struct gdbarch *gdbarch, int regnum)
105 {
106  static char *register_names[] = {
107  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
108  "r8", "r9", "r10", "r11", "r12", "r13",
109  "psw", "sp", "pc"
110  };
111 
112  if (regnum < 0 || regnum >= E_NUM_REGS)
113  internal_error (__FILE__, __LINE__,
114  _("xstormy16_register_name: illegal register number %d"),
115  regnum);
116  else
117  return register_names[regnum];
118 
119 }
120 
121 static struct type *
122 xstormy16_register_type (struct gdbarch *gdbarch, int regnum)
123 {
124  if (regnum == E_PC_REGNUM)
125  return builtin_type (gdbarch)->builtin_uint32;
126  else
127  return builtin_type (gdbarch)->builtin_uint16;
128 }
129 
130 /* Function: xstormy16_type_is_scalar
131  Makes the decision if a given type is a scalar types. Scalar
132  types are returned in the registers r2-r7 as they fit. */
133 
134 static int
136 {
137  return (TYPE_CODE(t) != TYPE_CODE_STRUCT
138  && TYPE_CODE(t) != TYPE_CODE_UNION
139  && TYPE_CODE(t) != TYPE_CODE_ARRAY);
140 }
141 
142 /* Function: xstormy16_use_struct_convention
143  Returns non-zero if the given struct type will be returned using
144  a special convention, rather than the normal function return method.
145  7sed in the contexts of the "return" command, and of
146  target function calls from the debugger. */
147 
148 static int
150 {
151  return !xstormy16_type_is_scalar (type)
153 }
154 
155 /* Function: xstormy16_extract_return_value
156  Find a function's return value in the appropriate registers (in
157  regbuf), and copy it into valbuf. */
158 
159 static void
161  gdb_byte *valbuf)
162 {
163  int len = TYPE_LENGTH (type);
164  int i, regnum = E_1ST_ARG_REGNUM;
165 
166  for (i = 0; i < len; i += xstormy16_reg_size)
167  regcache_raw_read (regcache, regnum++, valbuf + i);
168 }
169 
170 /* Function: xstormy16_store_return_value
171  Copy the function return value from VALBUF into the
172  proper location for a function return.
173  Called only in the context of the "return" command. */
174 
175 static void
177  const gdb_byte *valbuf)
178 {
179  if (TYPE_LENGTH (type) == 1)
180  {
181  /* Add leading zeros to the value. */
183  memset (buf, 0, xstormy16_reg_size);
184  memcpy (buf, valbuf, 1);
185  regcache_raw_write (regcache, E_1ST_ARG_REGNUM, buf);
186  }
187  else
188  {
189  int len = TYPE_LENGTH (type);
190  int i, regnum = E_1ST_ARG_REGNUM;
191 
192  for (i = 0; i < len; i += xstormy16_reg_size)
193  regcache_raw_write (regcache, regnum++, valbuf + i);
194  }
195 }
196 
197 static enum return_value_convention
198 xstormy16_return_value (struct gdbarch *gdbarch, struct value *function,
199  struct type *type, struct regcache *regcache,
200  gdb_byte *readbuf, const gdb_byte *writebuf)
201 {
204  if (writebuf)
205  xstormy16_store_return_value (type, regcache, writebuf);
206  else if (readbuf)
207  xstormy16_extract_return_value (type, regcache, readbuf);
209 }
210 
211 static CORE_ADDR
212 xstormy16_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
213 {
214  if (addr & 1)
215  ++addr;
216  return addr;
217 }
218 
219 /* Function: xstormy16_push_dummy_call
220  Setup the function arguments for GDB to call a function in the inferior.
221  Called only in the context of a target function call from the debugger.
222  Returns the value of the SP register after the args are pushed. */
223 
224 static CORE_ADDR
225 xstormy16_push_dummy_call (struct gdbarch *gdbarch,
226  struct value *function,
227  struct regcache *regcache,
228  CORE_ADDR bp_addr, int nargs,
229  struct value **args,
230  CORE_ADDR sp, int struct_return,
231  CORE_ADDR struct_addr)
232 {
233  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
234  CORE_ADDR stack_dest = sp;
235  int argreg = E_1ST_ARG_REGNUM;
236  int i, j;
237  int typelen, slacklen;
238  const gdb_byte *val;
240 
241  /* If struct_return is true, then the struct return address will
242  consume one argument-passing register. */
243  if (struct_return)
244  {
245  regcache_cooked_write_unsigned (regcache, E_PTR_RET_REGNUM, struct_addr);
246  argreg++;
247  }
248 
249  /* Arguments are passed in R2-R7 as they fit. If an argument doesn't
250  fit in the remaining registers we're switching over to the stack.
251  No argument is put on stack partially and as soon as we switched
252  over to stack no further argument is put in a register even if it
253  would fit in the remaining unused registers. */
254  for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++)
255  {
256  typelen = TYPE_LENGTH (value_enclosing_type (args[i]));
257  if (typelen > E_MAX_RETTYPE_SIZE (argreg))
258  break;
259 
260  /* Put argument into registers wordwise. */
261  val = value_contents (args[i]);
262  for (j = 0; j < typelen; j += xstormy16_reg_size)
263  {
264  ULONGEST regval;
265  int size = (typelen - j == 1) ? 1 : xstormy16_reg_size;
266 
267  regval = extract_unsigned_integer (val + j, size, byte_order);
268  regcache_cooked_write_unsigned (regcache, argreg++, regval);
269  }
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  gdb_byte *val;
280  struct cleanup *back_to;
281  const gdb_byte *bytes = value_contents (args[j]);
282 
283  typelen = TYPE_LENGTH (value_enclosing_type (args[j]));
284  slacklen = typelen & 1;
285  val = xmalloc (typelen + slacklen);
286  back_to = make_cleanup (xfree, val);
287  memcpy (val, bytes, typelen);
288  memset (val + typelen, 0, slacklen);
289 
290  /* Now write this data to the stack. The stack grows upwards. */
291  write_memory (stack_dest, val, typelen + slacklen);
292  stack_dest += typelen + slacklen;
293  do_cleanups (back_to);
294  }
295 
296  store_unsigned_integer (buf, xstormy16_pc_size, byte_order, bp_addr);
297  write_memory (stack_dest, buf, xstormy16_pc_size);
298  stack_dest += xstormy16_pc_size;
299 
300  /* Update stack pointer. */
301  regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, stack_dest);
302 
303  /* Return the new stack pointer minus the return address slot since
304  that's what DWARF2/GCC uses as the frame's CFA. */
305  return stack_dest - xstormy16_pc_size;
306 }
307 
308 /* Function: xstormy16_scan_prologue
309  Decode the instructions within the given address range.
310  Decide when we must have reached the end of the function prologue.
311  If a frame_info pointer is provided, fill in its saved_regs etc.
312 
313  Returns the address of the first instruction after the prologue. */
314 
315 static CORE_ADDR
316 xstormy16_analyze_prologue (struct gdbarch *gdbarch,
317  CORE_ADDR start_addr, CORE_ADDR end_addr,
318  struct xstormy16_frame_cache *cache,
319  struct frame_info *this_frame)
320 {
321  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
322  CORE_ADDR next_addr;
323  ULONGEST inst, inst2;
324  LONGEST offset;
325  int regnum;
326 
327  /* Initialize framesize with size of PC put on stack by CALLF inst. */
328  cache->saved_regs[E_PC_REGNUM] = 0;
329  cache->framesize = xstormy16_pc_size;
330 
331  if (start_addr >= end_addr)
332  return end_addr;
333 
334  for (next_addr = start_addr;
335  next_addr < end_addr; next_addr += xstormy16_inst_size)
336  {
337  inst = read_memory_unsigned_integer (next_addr,
338  xstormy16_inst_size, byte_order);
340  xstormy16_inst_size, byte_order);
341 
342  if (inst >= 0x0082 && inst <= 0x008d) /* push r2 .. push r13 */
343  {
344  regnum = inst & 0x000f;
345  cache->saved_regs[regnum] = cache->framesize;
346  cache->framesize += xstormy16_reg_size;
347  }
348 
349  /* Optional stack allocation for args and local vars <= 4 byte. */
350  else if (inst == 0x301f || inst == 0x303f) /* inc r15, #0x1/#0x3 */
351  {
352  cache->framesize += ((inst & 0x0030) >> 4) + 1;
353  }
354 
355  /* optional stack allocation for args and local vars > 4 && < 16 byte */
356  else if ((inst & 0xff0f) == 0x510f) /* 51Hf add r15, #0xH */
357  {
358  cache->framesize += (inst & 0x00f0) >> 4;
359  }
360 
361  /* Optional stack allocation for args and local vars >= 16 byte. */
362  else if (inst == 0x314f && inst2 >= 0x0010) /* 314f HHHH add r15, #0xH */
363  {
364  cache->framesize += inst2;
365  next_addr += xstormy16_inst_size;
366  }
367 
368  else if (inst == 0x46fd) /* mov r13, r15 */
369  {
370  cache->uses_fp = 1;
371  }
372 
373  /* optional copying of args in r2-r7 to r10-r13. */
374  /* Probably only in optimized case but legal action for prologue. */
375  else if ((inst & 0xff00) == 0x4600 /* 46SD mov rD, rS */
376  && (inst & 0x00f0) >= 0x0020 && (inst & 0x00f0) <= 0x0070
377  && (inst & 0x000f) >= 0x000a && (inst & 0x000f) <= 0x000d)
378  ;
379 
380  /* Optional copying of args in r2-r7 to stack. */
381  /* 72DS HHHH mov.b (rD, 0xHHHH), r(S-8)
382  (bit3 always 1, bit2-0 = reg) */
383  /* 73DS HHHH mov.w (rD, 0xHHHH), r(S-8) */
384  else if ((inst & 0xfed8) == 0x72d8 && (inst & 0x0007) >= 2)
385  {
386  regnum = inst & 0x0007;
387  /* Only 12 of 16 bits of the argument are used for the
388  signed offset. */
389  offset = (LONGEST) (inst2 & 0x0fff);
390  if (offset & 0x0800)
391  offset -= 0x1000;
392 
393  cache->saved_regs[regnum] = cache->framesize + offset;
394  next_addr += xstormy16_inst_size;
395  }
396 
397  else /* Not a prologue instruction. */
398  break;
399  }
400 
401  return next_addr;
402 }
403 
404 /* Function: xstormy16_skip_prologue
405  If the input address is in a function prologue,
406  returns the address of the end of the prologue;
407  else returns the input address.
408 
409  Note: the input address is likely to be the function start,
410  since this function is mainly used for advancing a breakpoint
411  to the first line, or stepping to the first line when we have
412  stepped into a function call. */
413 
414 static CORE_ADDR
415 xstormy16_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
416 {
417  CORE_ADDR func_addr = 0, func_end = 0;
418  const char *func_name;
419 
420  if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
421  {
422  struct symtab_and_line sal;
423  struct symbol *sym;
424  struct xstormy16_frame_cache cache;
425  CORE_ADDR plg_end;
426 
427  memset (&cache, 0, sizeof cache);
428 
429  /* Don't trust line number debug info in frameless functions. */
430  plg_end = xstormy16_analyze_prologue (gdbarch, func_addr, func_end,
431  &cache, NULL);
432  if (!cache.uses_fp)
433  return plg_end;
434 
435  /* Found a function. */
436  sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL);
437  /* Don't use line number debug info for assembly source files. */
438  if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
439  {
440  sal = find_pc_line (func_addr, 0);
441  if (sal.end && sal.end < func_end)
442  {
443  /* Found a line number, use it as end of prologue. */
444  return sal.end;
445  }
446  }
447  /* No useable line symbol. Use result of prologue parsing method. */
448  return plg_end;
449  }
450 
451  /* No function symbol -- just return the PC. */
452 
453  return (CORE_ADDR) pc;
454 }
455 
456 /* Implement the stack_frame_destroyed_p gdbarch method.
457 
458  The epilogue is defined here as the area at the end of a function,
459  either on the `ret' instruction itself or after an instruction which
460  destroys the function's stack frame. */
461 
462 static int
464 {
465  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
466  CORE_ADDR func_addr = 0, func_end = 0;
467 
468  if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
469  {
470  ULONGEST inst, inst2;
471  CORE_ADDR addr = func_end - xstormy16_inst_size;
472 
473  /* The Xstormy16 epilogue is max. 14 bytes long. */
474  if (pc < func_end - 7 * xstormy16_inst_size)
475  return 0;
476 
477  /* Check if we're on a `ret' instruction. Otherwise it's
478  too dangerous to proceed. */
479  inst = read_memory_unsigned_integer (addr,
480  xstormy16_inst_size, byte_order);
481  if (inst != 0x0003)
482  return 0;
483 
484  while ((addr -= xstormy16_inst_size) >= func_addr)
485  {
486  inst = read_memory_unsigned_integer (addr,
487  xstormy16_inst_size,
488  byte_order);
489  if (inst >= 0x009a && inst <= 0x009d) /* pop r10...r13 */
490  continue;
491  if (inst == 0x305f || inst == 0x307f) /* dec r15, #0x1/#0x3 */
492  break;
493  inst2 = read_memory_unsigned_integer (addr - xstormy16_inst_size,
494  xstormy16_inst_size,
495  byte_order);
496  if (inst2 == 0x314f && inst >= 0x8000) /* add r15, neg. value */
497  {
498  addr -= xstormy16_inst_size;
499  break;
500  }
501  return 0;
502  }
503  if (pc > addr)
504  return 1;
505  }
506  return 0;
507 }
508 
509 static const unsigned char *
510 xstormy16_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
511  int *lenptr)
512 {
513  static unsigned char breakpoint[] = { 0x06, 0x0 };
514  *lenptr = sizeof (breakpoint);
515  return breakpoint;
516 }
517 
518 /* Given a pointer to a jump table entry, return the address
519  of the function it jumps to. Return 0 if not found. */
520 static CORE_ADDR
521 xstormy16_resolve_jmp_table_entry (struct gdbarch *gdbarch, CORE_ADDR faddr)
522 {
523  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
524  struct obj_section *faddr_sect = find_pc_section (faddr);
525 
526  if (faddr_sect)
527  {
528  LONGEST inst, inst2, addr;
529  gdb_byte buf[2 * xstormy16_inst_size];
530 
531  /* Return faddr if it's not pointing into the jump table. */
532  if (strcmp (faddr_sect->the_bfd_section->name, ".plt"))
533  return faddr;
534 
535  if (!target_read_memory (faddr, buf, sizeof buf))
536  {
537  inst = extract_unsigned_integer (buf,
538  xstormy16_inst_size, byte_order);
540  xstormy16_inst_size, byte_order);
541  addr = inst2 << 8 | (inst & 0xff);
542  return addr;
543  }
544  }
545  return 0;
546 }
547 
548 /* Given a function's address, attempt to find (and return) the
549  address of the corresponding jump table entry. Return 0 if
550  not found. */
551 static CORE_ADDR
552 xstormy16_find_jmp_table_entry (struct gdbarch *gdbarch, CORE_ADDR faddr)
553 {
554  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
555  struct obj_section *faddr_sect = find_pc_section (faddr);
556 
557  if (faddr_sect)
558  {
559  struct obj_section *osect;
560 
561  /* Return faddr if it's already a pointer to a jump table entry. */
562  if (!strcmp (faddr_sect->the_bfd_section->name, ".plt"))
563  return faddr;
564 
565  ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
566  {
567  if (!strcmp (osect->the_bfd_section->name, ".plt"))
568  break;
569  }
570 
571  if (osect < faddr_sect->objfile->sections_end)
572  {
573  CORE_ADDR addr, endaddr;
574 
575  addr = obj_section_addr (osect);
576  endaddr = obj_section_endaddr (osect);
577 
578  for (; addr < endaddr; addr += 2 * xstormy16_inst_size)
579  {
580  LONGEST inst, inst2, faddr2;
581  gdb_byte buf[2 * xstormy16_inst_size];
582 
583  if (target_read_memory (addr, buf, sizeof buf))
584  return 0;
585  inst = extract_unsigned_integer (buf,
587  byte_order);
590  byte_order);
591  faddr2 = inst2 << 8 | (inst & 0xff);
592  if (faddr == faddr2)
593  return addr;
594  }
595  }
596  }
597  return 0;
598 }
599 
600 static CORE_ADDR
602 {
603  struct gdbarch *gdbarch = get_frame_arch (frame);
604  CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (gdbarch, pc);
605 
606  if (tmp && tmp != pc)
607  return tmp;
608  return 0;
609 }
610 
611 /* Function pointers are 16 bit. The address space is 24 bit, using
612  32 bit addresses. Pointers to functions on the XStormy16 are implemented
613  by using 16 bit pointers, which are either direct pointers in case the
614  function begins below 0x10000, or indirect pointers into a jump table.
615  The next two functions convert 16 bit pointers into 24 (32) bit addresses
616  and vice versa. */
617 
618 static CORE_ADDR
619 xstormy16_pointer_to_address (struct gdbarch *gdbarch,
620  struct type *type, const gdb_byte *buf)
621 {
622  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
623  enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
624  CORE_ADDR addr
625  = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
626 
627  if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
628  {
629  CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (gdbarch, addr);
630  if (addr2)
631  addr = addr2;
632  }
633 
634  return addr;
635 }
636 
637 static void
638 xstormy16_address_to_pointer (struct gdbarch *gdbarch,
639  struct type *type, gdb_byte *buf, CORE_ADDR addr)
640 {
641  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
642  enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
643 
644  if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
645  {
646  CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (gdbarch, addr);
647  if (addr2)
648  addr = addr2;
649  }
650  store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
651 }
652 
653 static struct xstormy16_frame_cache *
655 {
656  struct xstormy16_frame_cache *cache;
657  int i;
658 
660 
661  cache->base = 0;
662  cache->saved_sp = 0;
663  cache->pc = 0;
664  cache->uses_fp = 0;
665  cache->framesize = 0;
666  for (i = 0; i < E_NUM_REGS; ++i)
667  cache->saved_regs[i] = REG_UNAVAIL;
668 
669  return cache;
670 }
671 
672 static struct xstormy16_frame_cache *
673 xstormy16_frame_cache (struct frame_info *this_frame, void **this_cache)
674 {
675  struct gdbarch *gdbarch = get_frame_arch (this_frame);
676  struct xstormy16_frame_cache *cache;
677  CORE_ADDR current_pc;
678  int i;
679 
680  if (*this_cache)
681  return *this_cache;
682 
683  cache = xstormy16_alloc_frame_cache ();
684  *this_cache = cache;
685 
686  cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
687  if (cache->base == 0)
688  return cache;
689 
690  cache->pc = get_frame_func (this_frame);
691  current_pc = get_frame_pc (this_frame);
692  if (cache->pc)
693  xstormy16_analyze_prologue (gdbarch, cache->pc, current_pc,
694  cache, this_frame);
695 
696  if (!cache->uses_fp)
697  cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
698 
699  cache->saved_sp = cache->base - cache->framesize;
700 
701  for (i = 0; i < E_NUM_REGS; ++i)
702  if (cache->saved_regs[i] != REG_UNAVAIL)
703  cache->saved_regs[i] += cache->saved_sp;
704 
705  return cache;
706 }
707 
708 static struct value *
710  void **this_cache, int regnum)
711 {
712  struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
713  this_cache);
714  gdb_assert (regnum >= 0);
715 
716  if (regnum == E_SP_REGNUM && cache->saved_sp)
717  return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
718 
719  if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
720  return frame_unwind_got_memory (this_frame, regnum,
721  cache->saved_regs[regnum]);
722 
723  return frame_unwind_got_register (this_frame, regnum, regnum);
724 }
725 
726 static void
727 xstormy16_frame_this_id (struct frame_info *this_frame, void **this_cache,
728  struct frame_id *this_id)
729 {
730  struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
731  this_cache);
732 
733  /* This marks the outermost frame. */
734  if (cache->base == 0)
735  return;
736 
737  *this_id = frame_id_build (cache->saved_sp, cache->pc);
738 }
739 
740 static CORE_ADDR
741 xstormy16_frame_base_address (struct frame_info *this_frame, void **this_cache)
742 {
743  struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
744  this_cache);
745  return cache->base;
746 }
747 
748 static const struct frame_unwind xstormy16_frame_unwind = {
749  NORMAL_FRAME,
753  NULL,
755 };
756 
757 static const struct frame_base xstormy16_frame_base = {
761  xstormy16_frame_base_address
762 };
763 
764 static CORE_ADDR
765 xstormy16_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
766 {
767  return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
768 }
769 
770 static CORE_ADDR
771 xstormy16_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
772 {
773  return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
774 }
775 
776 static struct frame_id
777 xstormy16_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
778 {
780  return frame_id_build (sp, get_frame_pc (this_frame));
781 }
782 
783 
784 /* Function: xstormy16_gdbarch_init
785  Initializer function for the xstormy16 gdbarch vector.
786  Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
787 
788 static struct gdbarch *
789 xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
790 {
791  struct gdbarch *gdbarch;
792 
793  /* find a candidate among the list of pre-declared architectures. */
794  arches = gdbarch_list_lookup_by_info (arches, &info);
795  if (arches != NULL)
796  return (arches->gdbarch);
797 
798  gdbarch = gdbarch_alloc (&info, NULL);
799 
800  /*
801  * Basic register fields and methods, datatype sizes and stuff.
802  */
803 
804  set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
805  set_gdbarch_num_pseudo_regs (gdbarch, 0);
810 
811  set_gdbarch_char_signed (gdbarch, 0);
812  set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
813  set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
814  set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
816 
817  set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
820 
821  set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
822  set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
823  set_gdbarch_dwarf2_addr_size (gdbarch, 4);
824 
827 
828  /* Stack grows up. */
830 
831  /*
832  * Frame Info
833  */
838  frame_base_set_default (gdbarch, &xstormy16_frame_base);
839 
843 
844  /* These values and methods are used when gdb calls a target function. */
848 
850 
851  set_gdbarch_print_insn (gdbarch, print_insn_xstormy16);
852 
853  gdbarch_init_osabi (info, gdbarch);
854 
855  dwarf2_append_unwinders (gdbarch);
856  frame_unwind_append_unwinder (gdbarch, &xstormy16_frame_unwind);
857 
858  return gdbarch;
859 }
860 
861 /* Function: _initialize_xstormy16_tdep
862  Initializer function for the Sanyo Xstormy16a module.
863  Called by gdb at start-up. */
864 
865 /* -Wmissing-prototypes */
867 
868 void
870 {
871  register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);
872 }
static CORE_ADDR xstormy16_frame_align(struct gdbarch *gdbarch, CORE_ADDR addr)
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition: gdbarch.c:1909
void set_gdbarch_double_bit(struct gdbarch *gdbarch, int double_bit)
Definition: gdbarch.c:1634
void set_gdbarch_frame_align(struct gdbarch *gdbarch, gdbarch_frame_align_ftype frame_align)
Definition: gdbarch.c:2935
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
type_code
Definition: gdbtypes.h:85
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
static void xstormy16_address_to_pointer(struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
void set_gdbarch_float_bit(struct gdbarch *gdbarch, int float_bit)
Definition: gdbarch.c:1601
static void xstormy16_extract_return_value(struct type *type, struct regcache *regcache, gdb_byte *valbuf)
void set_gdbarch_dwarf2_addr_size(struct gdbarch *gdbarch, int dwarf2_addr_size)
Definition: gdbarch.c:1736
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
bfd_vma CORE_ADDR
Definition: common-types.h:41
static struct gdbarch * xstormy16_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: osabi.c:341
void xfree(void *)
Definition: common-utils.c:97
static const unsigned char * xstormy16_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
struct value * frame_unwind_got_memory(struct frame_info *frame, int regnum, CORE_ADDR addr)
Definition: frame-unwind.c:228
struct bfd_section * the_bfd_section
Definition: objfiles.h:121
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
Definition: gdbarch.c:3084
CORE_ADDR end
Definition: symtab.h:1377
initialize_file_ftype _initialize_xstormy16_tdep
static CORE_ADDR xstormy16_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR start_addr, CORE_ADDR end_addr, struct xstormy16_frame_cache *cache, struct frame_info *this_frame)
ULONGEST frame_unwind_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1182
void set_gdbarch_short_bit(struct gdbarch *gdbarch, int short_bit)
Definition: gdbarch.c:1483
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
static struct value * xstormy16_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
static const struct frame_unwind xstormy16_frame_unwind
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
#define obj_section_endaddr(s)
Definition: objfiles.h:141
return_value_convention
Definition: defs.h:206
static CORE_ADDR xstormy16_skip_trampoline_code(struct frame_info *frame, CORE_ADDR pc)
struct type * builtin_uint16
Definition: gdbtypes.h:1517
static CORE_ADDR xstormy16_resolve_jmp_table_entry(struct gdbarch *gdbarch, CORE_ADDR faddr)
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
Definition: objfiles.h:627
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
Definition: gdbarch.c:4985
#define _(String)
Definition: gdb_locale.h:40
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:78
static int xstormy16_stack_frame_destroyed_p(struct gdbarch *gdbarch, CORE_ADDR pc)
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:660
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
Definition: findvar.c:212
struct value * frame_unwind_got_constant(struct frame_info *frame, int regnum, ULONGEST val)
Definition: frame-unwind.c:241
#define obj_section_addr(s)
Definition: objfiles.h:135
void set_gdbarch_addr_bit(struct gdbarch *gdbarch, int addr_bit)
Definition: gdbarch.c:1718
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
Definition: frame-base.c:94
static int xstormy16_type_is_scalar(struct type *t)
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype register_type)
Definition: gdbarch.c:2151
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1329
static CORE_ADDR xstormy16_unwind_sp(struct gdbarch *gdbarch, struct frame_info *next_frame)
void initialize_file_ftype(void)
Definition: defs.h:281
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3315
static CORE_ADDR xstormy16_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
void set_gdbarch_stack_frame_destroyed_p(struct gdbarch *gdbarch, gdbarch_stack_frame_destroyed_p_ftype stack_frame_destroyed_p)
Definition: gdbarch.c:3135
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
Definition: gdbarch.c:1991
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype dummy_id)
Definition: gdbarch.c:2175
static CORE_ADDR xstormy16_unwind_pc(struct gdbarch *gdbarch, struct frame_info *next_frame)
struct_return
Definition: arm-tdep.h:148
void set_gdbarch_address_to_pointer(struct gdbarch *gdbarch, gdbarch_address_to_pointer_ftype address_to_pointer)
Definition: gdbarch.c:2508
struct type * value_enclosing_type(struct value *value)
Definition: value.c:1098
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
static CORE_ADDR xstormy16_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
Definition: gdbtypes.h:749
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:321
void set_gdbarch_unwind_pc(struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype unwind_pc)
Definition: gdbarch.c:2863
void set_gdbarch_breakpoint_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
Definition: gdbarch.c:2672
struct type * builtin_uint32
Definition: gdbtypes.h:1519
int default_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
Definition: frame-unwind.c:170
static CORE_ADDR xstormy16_frame_base_address(struct frame_info *this_frame, void **this_cache)
#define gdb_assert(expr)
Definition: gdb_assert.h:33
void set_gdbarch_pointer_to_address(struct gdbarch *gdbarch, gdbarch_pointer_to_address_ftype pointer_to_address)
Definition: gdbarch.c:2491
void set_gdbarch_unwind_sp(struct gdbarch *gdbarch, gdbarch_unwind_sp_ftype unwind_sp)
Definition: gdbarch.c:2887
struct gdbarch * gdbarch
Definition: gdbarch.h:1542
int regnum
Definition: aarch64-tdep.c:69
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition: objfiles.c:1337
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1194
void * xmalloc(YYSIZE_T)
CORE_ADDR saved_regs[E_NUM_REGS]
gdb_regnum
Definition: arm-tdep.h:29
static const char * xstormy16_register_name(struct gdbarch *gdbarch, int regnum)
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
Definition: gdbarch.c:1534
Definition: value.c:172
static CORE_ADDR xstormy16_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
bfd_byte gdb_byte
Definition: common-types.h:38
static int xstormy16_use_struct_convention(struct type *type)
void set_gdbarch_char_signed(struct gdbarch *gdbarch, int char_signed)
Definition: gdbarch.c:1754
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
static void xstormy16_store_return_value(struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
static void xstormy16_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
enum register_status regcache_raw_read(struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: regcache.c:637
struct value * frame_unwind_got_register(struct frame_info *frame, int regnum, int new_regnum)
Definition: frame-unwind.c:218
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition: regcache.c:871
static CORE_ADDR xstormy16_find_jmp_table_entry(struct gdbarch *gdbarch, CORE_ADDR faddr)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
static struct xstormy16_frame_cache * xstormy16_alloc_frame_cache(void)
struct obj_section * sections_end
Definition: objfiles.h:386
void set_gdbarch_int_bit(struct gdbarch *gdbarch, int int_bit)
Definition: gdbarch.c:1500
struct symbol * lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1967
int offset
Definition: agent.c:65
struct objfile * objfile
Definition: objfiles.h:124
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
Definition: gdbarch.c:1926
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
#define SYMBOL_LANGUAGE(symbol)
Definition: symtab.h:187
static enum return_value_convention xstormy16_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
unsigned long long ULONGEST
Definition: common-types.h:53
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
Definition: frame-unwind.c:180
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
Definition: gdbarch.c:1667
static struct frame_id xstormy16_dummy_id(struct gdbarch *gdbarch, struct frame_info *this_frame)
void set_gdbarch_long_bit(struct gdbarch *gdbarch, int long_bit)
Definition: gdbarch.c:1517
Definition: symtab.h:703
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
Definition: gdbarch.c:2556
static struct type * xstormy16_register_type(struct gdbarch *gdbarch, int regnum)
int core_addr_greaterthan(CORE_ADDR lhs, CORE_ADDR rhs)
Definition: arch-utils.c:144
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
Definition: gdbarch.c:1700
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype push_dummy_call)
Definition: gdbarch.c:2216
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:321
void register_gdbarch_init(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init)
Definition: gdbarch.c:4975
static struct xstormy16_frame_cache * xstormy16_frame_cache(struct frame_info *this_frame, void **this_cache)
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:389
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype skip_prologue)
Definition: gdbarch.c:2590
enum bfd_endian byte_order
Definition: gdbarch.c:128
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
Definition: gdbarch.c:2008
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype register_name)
Definition: gdbarch.c:2127
CORE_ADDR get_frame_func(struct frame_info *this_frame)
Definition: frame.c:920
size_t size
Definition: go32-nat.c:242
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, struct gdbarch_tdep *tdep)
Definition: gdbarch.c:339
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype inner_than)
Definition: gdbarch.c:2655
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
long long LONGEST
Definition: common-types.h:52
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void set_gdbarch_print_insn(struct gdbarch *gdbarch, gdbarch_print_insn_ftype print_insn)
Definition: gdbarch.c:3067
#define E_MAX_RETTYPE_SIZE(regnum)
void regcache_raw_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: regcache.c:885
const ULONGEST const LONGEST len
Definition: target.h:309