GDB (xrefs)
/tmp/gdb-7.10/gdb/sh-tdep.c
Go to the documentation of this file.
1 /* Target-dependent code for Renesas Super-H, for GDB.
2 
3  Copyright (C) 1993-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 /* Contributed by Steve Chamberlain
21  sac@cygnus.com. */
22 
23 #include "defs.h"
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"
32 #include "value.h"
33 #include "dis-asm.h"
34 #include "inferior.h"
35 #include "arch-utils.h"
36 #include "floatformat.h"
37 #include "regcache.h"
38 #include "doublest.h"
39 #include "osabi.h"
40 #include "reggroups.h"
41 #include "regset.h"
42 #include "objfiles.h"
43 
44 #include "sh-tdep.h"
45 #include "sh64-tdep.h"
46 
47 #include "elf-bfd.h"
48 #include "solib-svr4.h"
49 
50 /* sh flags */
51 #include "elf/sh.h"
52 #include "dwarf2.h"
53 /* registers numbers shared with the simulator. */
54 #include "gdb/sim-sh.h"
55 
56 /* List of "set sh ..." and "show sh ..." commands. */
57 static struct cmd_list_element *setshcmdlist = NULL;
58 static struct cmd_list_element *showshcmdlist = NULL;
59 
60 static const char sh_cc_gcc[] = "gcc";
61 static const char sh_cc_renesas[] = "renesas";
62 static const char *const sh_cc_enum[] = {
63  sh_cc_gcc,
65  NULL
66 };
67 
69 
70 #define SH_NUM_REGS 67
71 
73 {
74  /* Base address. */
78 
79  /* Flag showing that a frame has been created in the prologue code. */
80  int uses_fp;
81 
82  /* Saved registers. */
85 };
86 
87 static int
89 {
90  int val = 0;
91 
92  if (func_type)
93  {
94  func_type = check_typedef (func_type);
95 
96  if (TYPE_CODE (func_type) == TYPE_CODE_PTR)
97  func_type = check_typedef (TYPE_TARGET_TYPE (func_type));
98 
99  if (TYPE_CODE (func_type) == TYPE_CODE_FUNC
100  && TYPE_CALLING_CONVENTION (func_type) == DW_CC_GNU_renesas_sh)
101  val = 1;
102  }
103 
105  val = 1;
106 
107  return val;
108 }
109 
110 static const char *
111 sh_sh_register_name (struct gdbarch *gdbarch, int reg_nr)
112 {
113  static char *register_names[] = {
114  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
115  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
116  "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
117  "", "",
118  "", "", "", "", "", "", "", "",
119  "", "", "", "", "", "", "", "",
120  "", "",
121  "", "", "", "", "", "", "", "",
122  "", "", "", "", "", "", "", "",
123  "", "", "", "", "", "", "", "",
124  };
125  if (reg_nr < 0)
126  return NULL;
127  if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
128  return NULL;
129  return register_names[reg_nr];
130 }
131 
132 static const char *
133 sh_sh3_register_name (struct gdbarch *gdbarch, int reg_nr)
134 {
135  static char *register_names[] = {
136  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
137  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
138  "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
139  "", "",
140  "", "", "", "", "", "", "", "",
141  "", "", "", "", "", "", "", "",
142  "ssr", "spc",
143  "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
144  "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1"
145  "", "", "", "", "", "", "", "",
146  };
147  if (reg_nr < 0)
148  return NULL;
149  if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
150  return NULL;
151  return register_names[reg_nr];
152 }
153 
154 static const char *
155 sh_sh3e_register_name (struct gdbarch *gdbarch, int reg_nr)
156 {
157  static char *register_names[] = {
158  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
159  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
160  "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
161  "fpul", "fpscr",
162  "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
163  "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
164  "ssr", "spc",
165  "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
166  "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
167  "", "", "", "", "", "", "", "",
168  };
169  if (reg_nr < 0)
170  return NULL;
171  if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
172  return NULL;
173  return register_names[reg_nr];
174 }
175 
176 static const char *
177 sh_sh2e_register_name (struct gdbarch *gdbarch, int reg_nr)
178 {
179  static char *register_names[] = {
180  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
181  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
182  "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
183  "fpul", "fpscr",
184  "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
185  "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
186  "", "",
187  "", "", "", "", "", "", "", "",
188  "", "", "", "", "", "", "", "",
189  "", "", "", "", "", "", "", "",
190  };
191  if (reg_nr < 0)
192  return NULL;
193  if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
194  return NULL;
195  return register_names[reg_nr];
196 }
197 
198 static const char *
199 sh_sh2a_register_name (struct gdbarch *gdbarch, int reg_nr)
200 {
201  static char *register_names[] = {
202  /* general registers 0-15 */
203  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
204  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
205  /* 16 - 22 */
206  "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
207  /* 23, 24 */
208  "fpul", "fpscr",
209  /* floating point registers 25 - 40 */
210  "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
211  "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
212  /* 41, 42 */
213  "", "",
214  /* 43 - 62. Banked registers. The bank number used is determined by
215  the bank register (63). */
216  "r0b", "r1b", "r2b", "r3b", "r4b", "r5b", "r6b", "r7b",
217  "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b",
218  "machb", "ivnb", "prb", "gbrb", "maclb",
219  /* 63: register bank number, not a real register but used to
220  communicate the register bank currently get/set. This register
221  is hidden to the user, who manipulates it using the pseudo
222  register called "bank" (67). See below. */
223  "",
224  /* 64 - 66 */
225  "ibcr", "ibnr", "tbr",
226  /* 67: register bank number, the user visible pseudo register. */
227  "bank",
228  /* double precision (pseudo) 68 - 75 */
229  "dr0", "dr2", "dr4", "dr6", "dr8", "dr10", "dr12", "dr14",
230  };
231  if (reg_nr < 0)
232  return NULL;
233  if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
234  return NULL;
235  return register_names[reg_nr];
236 }
237 
238 static const char *
239 sh_sh2a_nofpu_register_name (struct gdbarch *gdbarch, int reg_nr)
240 {
241  static char *register_names[] = {
242  /* general registers 0-15 */
243  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
244  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
245  /* 16 - 22 */
246  "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
247  /* 23, 24 */
248  "", "",
249  /* floating point registers 25 - 40 */
250  "", "", "", "", "", "", "", "",
251  "", "", "", "", "", "", "", "",
252  /* 41, 42 */
253  "", "",
254  /* 43 - 62. Banked registers. The bank number used is determined by
255  the bank register (63). */
256  "r0b", "r1b", "r2b", "r3b", "r4b", "r5b", "r6b", "r7b",
257  "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b",
258  "machb", "ivnb", "prb", "gbrb", "maclb",
259  /* 63: register bank number, not a real register but used to
260  communicate the register bank currently get/set. This register
261  is hidden to the user, who manipulates it using the pseudo
262  register called "bank" (67). See below. */
263  "",
264  /* 64 - 66 */
265  "ibcr", "ibnr", "tbr",
266  /* 67: register bank number, the user visible pseudo register. */
267  "bank",
268  /* double precision (pseudo) 68 - 75 */
269  "", "", "", "", "", "", "", "",
270  };
271  if (reg_nr < 0)
272  return NULL;
273  if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
274  return NULL;
275  return register_names[reg_nr];
276 }
277 
278 static const char *
279 sh_sh_dsp_register_name (struct gdbarch *gdbarch, int reg_nr)
280 {
281  static char *register_names[] = {
282  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
283  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
284  "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
285  "", "dsr",
286  "a0g", "a0", "a1g", "a1", "m0", "m1", "x0", "x1",
287  "y0", "y1", "", "", "", "", "", "mod",
288  "", "",
289  "rs", "re", "", "", "", "", "", "",
290  "", "", "", "", "", "", "", "",
291  "", "", "", "", "", "", "", "",
292  };
293  if (reg_nr < 0)
294  return NULL;
295  if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
296  return NULL;
297  return register_names[reg_nr];
298 }
299 
300 static const char *
301 sh_sh3_dsp_register_name (struct gdbarch *gdbarch, int reg_nr)
302 {
303  static char *register_names[] = {
304  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
305  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
306  "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
307  "", "dsr",
308  "a0g", "a0", "a1g", "a1", "m0", "m1", "x0", "x1",
309  "y0", "y1", "", "", "", "", "", "mod",
310  "ssr", "spc",
311  "rs", "re", "", "", "", "", "", "",
312  "r0b", "r1b", "r2b", "r3b", "r4b", "r5b", "r6b", "r7b",
313  "", "", "", "", "", "", "", "",
314  "", "", "", "", "", "", "", "",
315  };
316  if (reg_nr < 0)
317  return NULL;
318  if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
319  return NULL;
320  return register_names[reg_nr];
321 }
322 
323 static const char *
324 sh_sh4_register_name (struct gdbarch *gdbarch, int reg_nr)
325 {
326  static char *register_names[] = {
327  /* general registers 0-15 */
328  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
329  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
330  /* 16 - 22 */
331  "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
332  /* 23, 24 */
333  "fpul", "fpscr",
334  /* floating point registers 25 - 40 */
335  "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
336  "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
337  /* 41, 42 */
338  "ssr", "spc",
339  /* bank 0 43 - 50 */
340  "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
341  /* bank 1 51 - 58 */
342  "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
343  /* 59 - 66 */
344  "", "", "", "", "", "", "", "",
345  /* pseudo bank register. */
346  "",
347  /* double precision (pseudo) 68 - 75 */
348  "dr0", "dr2", "dr4", "dr6", "dr8", "dr10", "dr12", "dr14",
349  /* vectors (pseudo) 76 - 79 */
350  "fv0", "fv4", "fv8", "fv12",
351  /* FIXME: missing XF */
352  /* FIXME: missing XD */
353  };
354  if (reg_nr < 0)
355  return NULL;
356  if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
357  return NULL;
358  return register_names[reg_nr];
359 }
360 
361 static const char *
362 sh_sh4_nofpu_register_name (struct gdbarch *gdbarch, int reg_nr)
363 {
364  static char *register_names[] = {
365  /* general registers 0-15 */
366  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
367  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
368  /* 16 - 22 */
369  "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
370  /* 23, 24 */
371  "", "",
372  /* floating point registers 25 - 40 -- not for nofpu target */
373  "", "", "", "", "", "", "", "",
374  "", "", "", "", "", "", "", "",
375  /* 41, 42 */
376  "ssr", "spc",
377  /* bank 0 43 - 50 */
378  "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
379  /* bank 1 51 - 58 */
380  "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
381  /* 59 - 66 */
382  "", "", "", "", "", "", "", "",
383  /* pseudo bank register. */
384  "",
385  /* double precision (pseudo) 68 - 75 -- not for nofpu target */
386  "", "", "", "", "", "", "", "",
387  /* vectors (pseudo) 76 - 79 -- not for nofpu target */
388  "", "", "", "",
389  };
390  if (reg_nr < 0)
391  return NULL;
392  if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
393  return NULL;
394  return register_names[reg_nr];
395 }
396 
397 static const char *
398 sh_sh4al_dsp_register_name (struct gdbarch *gdbarch, int reg_nr)
399 {
400  static char *register_names[] = {
401  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
402  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
403  "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
404  "", "dsr",
405  "a0g", "a0", "a1g", "a1", "m0", "m1", "x0", "x1",
406  "y0", "y1", "", "", "", "", "", "mod",
407  "ssr", "spc",
408  "rs", "re", "", "", "", "", "", "",
409  "r0b", "r1b", "r2b", "r3b", "r4b", "r5b", "r6b", "r7b",
410  "", "", "", "", "", "", "", "",
411  "", "", "", "", "", "", "", "",
412  };
413  if (reg_nr < 0)
414  return NULL;
415  if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
416  return NULL;
417  return register_names[reg_nr];
418 }
419 
420 static const unsigned char *
421 sh_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
422 {
423  /* 0xc3c3 is trapa #c3, and it works in big and little endian modes. */
424  static unsigned char breakpoint[] = { 0xc3, 0xc3 };
425 
426  /* For remote stub targets, trapa #20 is used. */
427  if (strcmp (target_shortname, "remote") == 0)
428  {
429  static unsigned char big_remote_breakpoint[] = { 0xc3, 0x20 };
430  static unsigned char little_remote_breakpoint[] = { 0x20, 0xc3 };
431 
432  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
433  {
434  *lenptr = sizeof (big_remote_breakpoint);
435  return big_remote_breakpoint;
436  }
437  else
438  {
439  *lenptr = sizeof (little_remote_breakpoint);
440  return little_remote_breakpoint;
441  }
442  }
443 
444  *lenptr = sizeof (breakpoint);
445  return breakpoint;
446 }
447 
448 /* Prologue looks like
449  mov.l r14,@-r15
450  sts.l pr,@-r15
451  mov.l <regs>,@-r15
452  sub <room_for_loca_vars>,r15
453  mov r15,r14
454 
455  Actually it can be more complicated than this but that's it, basically. */
456 
457 #define GET_SOURCE_REG(x) (((x) >> 4) & 0xf)
458 #define GET_TARGET_REG(x) (((x) >> 8) & 0xf)
459 
460 /* JSR @Rm 0100mmmm00001011 */
461 #define IS_JSR(x) (((x) & 0xf0ff) == 0x400b)
462 
463 /* STS.L PR,@-r15 0100111100100010
464  r15-4-->r15, PR-->(r15) */
465 #define IS_STS(x) ((x) == 0x4f22)
466 
467 /* STS.L MACL,@-r15 0100111100010010
468  r15-4-->r15, MACL-->(r15) */
469 #define IS_MACL_STS(x) ((x) == 0x4f12)
470 
471 /* MOV.L Rm,@-r15 00101111mmmm0110
472  r15-4-->r15, Rm-->(R15) */
473 #define IS_PUSH(x) (((x) & 0xff0f) == 0x2f06)
474 
475 /* MOV r15,r14 0110111011110011
476  r15-->r14 */
477 #define IS_MOV_SP_FP(x) ((x) == 0x6ef3)
478 
479 /* ADD #imm,r15 01111111iiiiiiii
480  r15+imm-->r15 */
481 #define IS_ADD_IMM_SP(x) (((x) & 0xff00) == 0x7f00)
482 
483 #define IS_MOV_R3(x) (((x) & 0xff00) == 0x1a00)
484 #define IS_SHLL_R3(x) ((x) == 0x4300)
485 
486 /* ADD r3,r15 0011111100111100
487  r15+r3-->r15 */
488 #define IS_ADD_R3SP(x) ((x) == 0x3f3c)
489 
490 /* FMOV.S FRm,@-Rn Rn-4-->Rn, FRm-->(Rn) 1111nnnnmmmm1011
491  FMOV DRm,@-Rn Rn-8-->Rn, DRm-->(Rn) 1111nnnnmmm01011
492  FMOV XDm,@-Rn Rn-8-->Rn, XDm-->(Rn) 1111nnnnmmm11011 */
493 /* CV, 2003-08-28: Only suitable with Rn == SP, therefore name changed to
494  make this entirely clear. */
495 /* #define IS_FMOV(x) (((x) & 0xf00f) == 0xf00b) */
496 #define IS_FPUSH(x) (((x) & 0xff0f) == 0xff0b)
497 
498 /* MOV Rm,Rn Rm-->Rn 0110nnnnmmmm0011 4 <= m <= 7 */
499 #define IS_MOV_ARG_TO_REG(x) \
500  (((x) & 0xf00f) == 0x6003 && \
501  ((x) & 0x00f0) >= 0x0040 && \
502  ((x) & 0x00f0) <= 0x0070)
503 /* MOV.L Rm,@Rn 0010nnnnmmmm0010 n = 14, 4 <= m <= 7 */
504 #define IS_MOV_ARG_TO_IND_R14(x) \
505  (((x) & 0xff0f) == 0x2e02 && \
506  ((x) & 0x00f0) >= 0x0040 && \
507  ((x) & 0x00f0) <= 0x0070)
508 /* MOV.L Rm,@(disp*4,Rn) 00011110mmmmdddd n = 14, 4 <= m <= 7 */
509 #define IS_MOV_ARG_TO_IND_R14_WITH_DISP(x) \
510  (((x) & 0xff00) == 0x1e00 && \
511  ((x) & 0x00f0) >= 0x0040 && \
512  ((x) & 0x00f0) <= 0x0070)
513 
514 /* MOV.W @(disp*2,PC),Rn 1001nnnndddddddd */
515 #define IS_MOVW_PCREL_TO_REG(x) (((x) & 0xf000) == 0x9000)
516 /* MOV.L @(disp*4,PC),Rn 1101nnnndddddddd */
517 #define IS_MOVL_PCREL_TO_REG(x) (((x) & 0xf000) == 0xd000)
518 /* MOVI20 #imm20,Rn 0000nnnniiii0000 */
519 #define IS_MOVI20(x) (((x) & 0xf00f) == 0x0000)
520 /* SUB Rn,R15 00111111nnnn1000 */
521 #define IS_SUB_REG_FROM_SP(x) (((x) & 0xff0f) == 0x3f08)
522 
523 #define FPSCR_SZ (1 << 20)
524 
525 /* The following instructions are used for epilogue testing. */
526 #define IS_RESTORE_FP(x) ((x) == 0x6ef6)
527 #define IS_RTS(x) ((x) == 0x000b)
528 #define IS_LDS(x) ((x) == 0x4f26)
529 #define IS_MACL_LDS(x) ((x) == 0x4f16)
530 #define IS_MOV_FP_SP(x) ((x) == 0x6fe3)
531 #define IS_ADD_REG_TO_FP(x) (((x) & 0xff0f) == 0x3e0c)
532 #define IS_ADD_IMM_FP(x) (((x) & 0xff00) == 0x7e00)
533 
534 static CORE_ADDR
535 sh_analyze_prologue (struct gdbarch *gdbarch,
536  CORE_ADDR pc, CORE_ADDR limit_pc,
537  struct sh_frame_cache *cache, ULONGEST fpscr)
538 {
539  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
540  ULONGEST inst;
541  int offset;
542  int sav_offset = 0;
543  int r3_val = 0;
544  int reg, sav_reg = -1;
545 
546  cache->uses_fp = 0;
547  for (; pc < limit_pc; pc += 2)
548  {
549  inst = read_memory_unsigned_integer (pc, 2, byte_order);
550  /* See where the registers will be saved to. */
551  if (IS_PUSH (inst))
552  {
553  cache->saved_regs[GET_SOURCE_REG (inst)] = cache->sp_offset;
554  cache->sp_offset += 4;
555  }
556  else if (IS_STS (inst))
557  {
558  cache->saved_regs[PR_REGNUM] = cache->sp_offset;
559  cache->sp_offset += 4;
560  }
561  else if (IS_MACL_STS (inst))
562  {
563  cache->saved_regs[MACL_REGNUM] = cache->sp_offset;
564  cache->sp_offset += 4;
565  }
566  else if (IS_MOV_R3 (inst))
567  {
568  r3_val = ((inst & 0xff) ^ 0x80) - 0x80;
569  }
570  else if (IS_SHLL_R3 (inst))
571  {
572  r3_val <<= 1;
573  }
574  else if (IS_ADD_R3SP (inst))
575  {
576  cache->sp_offset += -r3_val;
577  }
578  else if (IS_ADD_IMM_SP (inst))
579  {
580  offset = ((inst & 0xff) ^ 0x80) - 0x80;
581  cache->sp_offset -= offset;
582  }
583  else if (IS_MOVW_PCREL_TO_REG (inst))
584  {
585  if (sav_reg < 0)
586  {
587  reg = GET_TARGET_REG (inst);
588  if (reg < 14)
589  {
590  sav_reg = reg;
591  offset = (inst & 0xff) << 1;
592  sav_offset =
593  read_memory_integer ((pc + 4) + offset, 2, byte_order);
594  }
595  }
596  }
597  else if (IS_MOVL_PCREL_TO_REG (inst))
598  {
599  if (sav_reg < 0)
600  {
601  reg = GET_TARGET_REG (inst);
602  if (reg < 14)
603  {
604  sav_reg = reg;
605  offset = (inst & 0xff) << 2;
606  sav_offset =
607  read_memory_integer (((pc & 0xfffffffc) + 4) + offset,
608  4, byte_order);
609  }
610  }
611  }
612  else if (IS_MOVI20 (inst)
613  && (pc + 2 < limit_pc))
614  {
615  if (sav_reg < 0)
616  {
617  reg = GET_TARGET_REG (inst);
618  if (reg < 14)
619  {
620  sav_reg = reg;
621  sav_offset = GET_SOURCE_REG (inst) << 16;
622  /* MOVI20 is a 32 bit instruction! */
623  pc += 2;
624  sav_offset
625  |= read_memory_unsigned_integer (pc, 2, byte_order);
626  /* Now sav_offset contains an unsigned 20 bit value.
627  It must still get sign extended. */
628  if (sav_offset & 0x00080000)
629  sav_offset |= 0xfff00000;
630  }
631  }
632  }
633  else if (IS_SUB_REG_FROM_SP (inst))
634  {
635  reg = GET_SOURCE_REG (inst);
636  if (sav_reg > 0 && reg == sav_reg)
637  {
638  sav_reg = -1;
639  }
640  cache->sp_offset += sav_offset;
641  }
642  else if (IS_FPUSH (inst))
643  {
644  if (fpscr & FPSCR_SZ)
645  {
646  cache->sp_offset += 8;
647  }
648  else
649  {
650  cache->sp_offset += 4;
651  }
652  }
653  else if (IS_MOV_SP_FP (inst))
654  {
655  pc += 2;
656  /* Don't go any further than six more instructions. */
657  limit_pc = min (limit_pc, pc + (2 * 6));
658 
659  cache->uses_fp = 1;
660  /* At this point, only allow argument register moves to other
661  registers or argument register moves to @(X,fp) which are
662  moving the register arguments onto the stack area allocated
663  by a former add somenumber to SP call. Don't allow moving
664  to an fp indirect address above fp + cache->sp_offset. */
665  for (; pc < limit_pc; pc += 2)
666  {
667  inst = read_memory_integer (pc, 2, byte_order);
668  if (IS_MOV_ARG_TO_IND_R14 (inst))
669  {
670  reg = GET_SOURCE_REG (inst);
671  if (cache->sp_offset > 0)
672  cache->saved_regs[reg] = cache->sp_offset;
673  }
674  else if (IS_MOV_ARG_TO_IND_R14_WITH_DISP (inst))
675  {
676  reg = GET_SOURCE_REG (inst);
677  offset = (inst & 0xf) * 4;
678  if (cache->sp_offset > offset)
679  cache->saved_regs[reg] = cache->sp_offset - offset;
680  }
681  else if (IS_MOV_ARG_TO_REG (inst))
682  continue;
683  else
684  break;
685  }
686  break;
687  }
688  else if (IS_JSR (inst))
689  {
690  /* We have found a jsr that has been scheduled into the prologue.
691  If we continue the scan and return a pc someplace after this,
692  then setting a breakpoint on this function will cause it to
693  appear to be called after the function it is calling via the
694  jsr, which will be very confusing. Most likely the next
695  instruction is going to be IS_MOV_SP_FP in the delay slot. If
696  so, note that before returning the current pc. */
697  if (pc + 2 < limit_pc)
698  {
699  inst = read_memory_integer (pc + 2, 2, byte_order);
700  if (IS_MOV_SP_FP (inst))
701  cache->uses_fp = 1;
702  }
703  break;
704  }
705 #if 0 /* This used to just stop when it found an instruction
706  that was not considered part of the prologue. Now,
707  we just keep going looking for likely
708  instructions. */
709  else
710  break;
711 #endif
712  }
713 
714  return pc;
715 }
716 
717 /* Skip any prologue before the guts of a function. */
718 static CORE_ADDR
719 sh_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
720 {
721  CORE_ADDR post_prologue_pc, func_addr, func_end_addr, limit_pc;
722  struct sh_frame_cache cache;
723 
724  /* See if we can determine the end of the prologue via the symbol table.
725  If so, then return either PC, or the PC after the prologue, whichever
726  is greater. */
727  if (find_pc_partial_function (pc, NULL, &func_addr, &func_end_addr))
728  {
729  post_prologue_pc = skip_prologue_using_sal (gdbarch, func_addr);
730  if (post_prologue_pc != 0)
731  return max (pc, post_prologue_pc);
732  }
733 
734  /* Can't determine prologue from the symbol table, need to examine
735  instructions. */
736 
737  /* Find an upper limit on the function prologue using the debug
738  information. If the debug information could not be used to provide
739  that bound, then use an arbitrary large number as the upper bound. */
740  limit_pc = skip_prologue_using_sal (gdbarch, pc);
741  if (limit_pc == 0)
742  /* Don't go any further than 28 instructions. */
743  limit_pc = pc + (2 * 28);
744 
745  /* Do not allow limit_pc to be past the function end, if we know
746  where that end is... */
747  if (func_end_addr != 0)
748  limit_pc = min (limit_pc, func_end_addr);
749 
750  cache.sp_offset = -4;
751  post_prologue_pc = sh_analyze_prologue (gdbarch, pc, limit_pc, &cache, 0);
752  if (cache.uses_fp)
753  pc = post_prologue_pc;
754 
755  return pc;
756 }
757 
758 /* The ABI says:
759 
760  Aggregate types not bigger than 8 bytes that have the same size and
761  alignment as one of the integer scalar types are returned in the
762  same registers as the integer type they match.
763 
764  For example, a 2-byte aligned structure with size 2 bytes has the
765  same size and alignment as a short int, and will be returned in R0.
766  A 4-byte aligned structure with size 8 bytes has the same size and
767  alignment as a long long int, and will be returned in R0 and R1.
768 
769  When an aggregate type is returned in R0 and R1, R0 contains the
770  first four bytes of the aggregate, and R1 contains the
771  remainder. If the size of the aggregate type is not a multiple of 4
772  bytes, the aggregate is tail-padded up to a multiple of 4
773  bytes. The value of the padding is undefined. For little-endian
774  targets the padding will appear at the most significant end of the
775  last element, for big-endian targets the padding appears at the
776  least significant end of the last element.
777 
778  All other aggregate types are returned by address. The caller
779  function passes the address of an area large enough to hold the
780  aggregate value in R2. The called function stores the result in
781  this location.
782 
783  To reiterate, structs smaller than 8 bytes could also be returned
784  in memory, if they don't pass the "same size and alignment as an
785  integer type" rule.
786 
787  For example, in
788 
789  struct s { char c[3]; } wibble;
790  struct s foo(void) { return wibble; }
791 
792  the return value from foo() will be in memory, not
793  in R0, because there is no 3-byte integer type.
794 
795  Similarly, in
796 
797  struct s { char c[2]; } wibble;
798  struct s foo(void) { return wibble; }
799 
800  because a struct containing two chars has alignment 1, that matches
801  type char, but size 2, that matches type short. There's no integer
802  type that has alignment 1 and size 2, so the struct is returned in
803  memory. */
804 
805 static int
806 sh_use_struct_convention (int renesas_abi, struct type *type)
807 {
808  int len = TYPE_LENGTH (type);
809  int nelem = TYPE_NFIELDS (type);
810 
811  /* The Renesas ABI returns aggregate types always on stack. */
812  if (renesas_abi && (TYPE_CODE (type) == TYPE_CODE_STRUCT
813  || TYPE_CODE (type) == TYPE_CODE_UNION))
814  return 1;
815 
816  /* Non-power of 2 length types and types bigger than 8 bytes (which don't
817  fit in two registers anyway) use struct convention. */
818  if (len != 1 && len != 2 && len != 4 && len != 8)
819  return 1;
820 
821  /* Scalar types and aggregate types with exactly one field are aligned
822  by definition. They are returned in registers. */
823  if (nelem <= 1)
824  return 0;
825 
826  /* If the first field in the aggregate has the same length as the entire
827  aggregate type, the type is returned in registers. */
828  if (TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)) == len)
829  return 0;
830 
831  /* If the size of the aggregate is 8 bytes and the first field is
832  of size 4 bytes its alignment is equal to long long's alignment,
833  so it's returned in registers. */
834  if (len == 8 && TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)) == 4)
835  return 0;
836 
837  /* Otherwise use struct convention. */
838  return 1;
839 }
840 
841 static int
842 sh_use_struct_convention_nofpu (int renesas_abi, struct type *type)
843 {
844  /* The Renesas ABI returns long longs/doubles etc. always on stack. */
845  if (renesas_abi && TYPE_NFIELDS (type) == 0 && TYPE_LENGTH (type) >= 8)
846  return 1;
847  return sh_use_struct_convention (renesas_abi, type);
848 }
849 
850 static CORE_ADDR
851 sh_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
852 {
853  return sp & ~3;
854 }
855 
856 /* Function: push_dummy_call (formerly push_arguments)
857  Setup the function arguments for calling a function in the inferior.
858 
859  On the Renesas SH architecture, there are four registers (R4 to R7)
860  which are dedicated for passing function arguments. Up to the first
861  four arguments (depending on size) may go into these registers.
862  The rest go on the stack.
863 
864  MVS: Except on SH variants that have floating point registers.
865  In that case, float and double arguments are passed in the same
866  manner, but using FP registers instead of GP registers.
867 
868  Arguments that are smaller than 4 bytes will still take up a whole
869  register or a whole 32-bit word on the stack, and will be
870  right-justified in the register or the stack word. This includes
871  chars, shorts, and small aggregate types.
872 
873  Arguments that are larger than 4 bytes may be split between two or
874  more registers. If there are not enough registers free, an argument
875  may be passed partly in a register (or registers), and partly on the
876  stack. This includes doubles, long longs, and larger aggregates.
877  As far as I know, there is no upper limit to the size of aggregates
878  that will be passed in this way; in other words, the convention of
879  passing a pointer to a large aggregate instead of a copy is not used.
880 
881  MVS: The above appears to be true for the SH variants that do not
882  have an FPU, however those that have an FPU appear to copy the
883  aggregate argument onto the stack (and not place it in registers)
884  if it is larger than 16 bytes (four GP registers).
885 
886  An exceptional case exists for struct arguments (and possibly other
887  aggregates such as arrays) if the size is larger than 4 bytes but
888  not a multiple of 4 bytes. In this case the argument is never split
889  between the registers and the stack, but instead is copied in its
890  entirety onto the stack, AND also copied into as many registers as
891  there is room for. In other words, space in registers permitting,
892  two copies of the same argument are passed in. As far as I can tell,
893  only the one on the stack is used, although that may be a function
894  of the level of compiler optimization. I suspect this is a compiler
895  bug. Arguments of these odd sizes are left-justified within the
896  word (as opposed to arguments smaller than 4 bytes, which are
897  right-justified).
898 
899  If the function is to return an aggregate type such as a struct, it
900  is either returned in the normal return value register R0 (if its
901  size is no greater than one byte), or else the caller must allocate
902  space into which the callee will copy the return value (if the size
903  is greater than one byte). In this case, a pointer to the return
904  value location is passed into the callee in register R2, which does
905  not displace any of the other arguments passed in via registers R4
906  to R7. */
907 
908 /* Helper function to justify value in register according to endianess. */
909 static const gdb_byte *
910 sh_justify_value_in_reg (struct gdbarch *gdbarch, struct value *val, int len)
911 {
912  static gdb_byte valbuf[4];
913 
914  memset (valbuf, 0, sizeof (valbuf));
915  if (len < 4)
916  {
917  /* value gets right-justified in the register or stack word. */
918  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
919  memcpy (valbuf + (4 - len), value_contents (val), len);
920  else
921  memcpy (valbuf, value_contents (val), len);
922  return valbuf;
923  }
924  return value_contents (val);
925 }
926 
927 /* Helper function to eval number of bytes to allocate on stack. */
928 static CORE_ADDR
929 sh_stack_allocsize (int nargs, struct value **args)
930 {
931  int stack_alloc = 0;
932  while (nargs-- > 0)
933  stack_alloc += ((TYPE_LENGTH (value_type (args[nargs])) + 3) & ~3);
934  return stack_alloc;
935 }
936 
937 /* Helper functions for getting the float arguments right. Registers usage
938  depends on the ABI and the endianess. The comments should enlighten how
939  it's intended to work. */
940 
941 /* This array stores which of the float arg registers are already in use. */
943 
944 /* This function just resets the above array to "no reg used so far". */
945 static void
947 {
948  memset (flt_argreg_array, 0, sizeof flt_argreg_array);
949 }
950 
951 /* This function returns the next register to use for float arg passing.
952  It returns either a valid value between FLOAT_ARG0_REGNUM and
953  FLOAT_ARGLAST_REGNUM if a register is available, otherwise it returns
954  FLOAT_ARGLAST_REGNUM + 1 to indicate that no register is available.
955 
956  Note that register number 0 in flt_argreg_array corresponds with the
957  real float register fr4. In contrast to FLOAT_ARG0_REGNUM (value is
958  29) the parity of the register number is preserved, which is important
959  for the double register passing test (see the "argreg & 1" test below). */
960 static int
961 sh_next_flt_argreg (struct gdbarch *gdbarch, int len, struct type *func_type)
962 {
963  int argreg;
964 
965  /* First search for the next free register. */
966  for (argreg = 0; argreg <= FLOAT_ARGLAST_REGNUM - FLOAT_ARG0_REGNUM;
967  ++argreg)
968  if (!flt_argreg_array[argreg])
969  break;
970 
971  /* No register left? */
972  if (argreg > FLOAT_ARGLAST_REGNUM - FLOAT_ARG0_REGNUM)
973  return FLOAT_ARGLAST_REGNUM + 1;
974 
975  if (len == 8)
976  {
977  /* Doubles are always starting in a even register number. */
978  if (argreg & 1)
979  {
980  /* In gcc ABI, the skipped register is lost for further argument
981  passing now. Not so in Renesas ABI. */
982  if (!sh_is_renesas_calling_convention (func_type))
983  flt_argreg_array[argreg] = 1;
984 
985  ++argreg;
986 
987  /* No register left? */
988  if (argreg > FLOAT_ARGLAST_REGNUM - FLOAT_ARG0_REGNUM)
989  return FLOAT_ARGLAST_REGNUM + 1;
990  }
991  /* Also mark the next register as used. */
992  flt_argreg_array[argreg + 1] = 1;
993  }
994  else if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE
995  && !sh_is_renesas_calling_convention (func_type))
996  {
997  /* In little endian, gcc passes floats like this: f5, f4, f7, f6, ... */
998  if (!flt_argreg_array[argreg + 1])
999  ++argreg;
1000  }
1001  flt_argreg_array[argreg] = 1;
1002  return FLOAT_ARG0_REGNUM + argreg;
1003 }
1004 
1005 /* Helper function which figures out, if a type is treated like a float type.
1006 
1007  The FPU ABIs have a special way how to treat types as float types.
1008  Structures with exactly one member, which is of type float or double, are
1009  treated exactly as the base types float or double:
1010 
1011  struct sf {
1012  float f;
1013  };
1014 
1015  struct sd {
1016  double d;
1017  };
1018 
1019  are handled the same way as just
1020 
1021  float f;
1022 
1023  double d;
1024 
1025  As a result, arguments of these struct types are pushed into floating point
1026  registers exactly as floats or doubles, using the same decision algorithm.
1027 
1028  The same is valid if these types are used as function return types. The
1029  above structs are returned in fr0 resp. fr0,fr1 instead of in r0, r0,r1
1030  or even using struct convention as it is for other structs. */
1031 
1032 static int
1034 {
1035  /* Ordinary float types are obviously treated as float. */
1036  if (TYPE_CODE (type) == TYPE_CODE_FLT)
1037  return 1;
1038  /* Otherwise non-struct types are not treated as float. */
1039  if (TYPE_CODE (type) != TYPE_CODE_STRUCT)
1040  return 0;
1041  /* Otherwise structs with more than one memeber are not treated as float. */
1042  if (TYPE_NFIELDS (type) != 1)
1043  return 0;
1044  /* Otherwise if the type of that member is float, the whole type is
1045  treated as float. */
1046  if (TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_FLT)
1047  return 1;
1048  /* Otherwise it's not treated as float. */
1049  return 0;
1050 }
1051 
1052 static CORE_ADDR
1053 sh_push_dummy_call_fpu (struct gdbarch *gdbarch,
1054  struct value *function,
1055  struct regcache *regcache,
1056  CORE_ADDR bp_addr, int nargs,
1057  struct value **args,
1058  CORE_ADDR sp, int struct_return,
1059  CORE_ADDR struct_addr)
1060 {
1061  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1062  int stack_offset = 0;
1063  int argreg = ARG0_REGNUM;
1064  int flt_argreg = 0;
1065  int argnum;
1066  struct type *func_type = value_type (function);
1067  struct type *type;
1068  CORE_ADDR regval;
1069  const gdb_byte *val;
1070  int len, reg_size = 0;
1071  int pass_on_stack = 0;
1072  int treat_as_flt;
1073  int last_reg_arg = INT_MAX;
1074 
1075  /* The Renesas ABI expects all varargs arguments, plus the last
1076  non-vararg argument to be on the stack, no matter how many
1077  registers have been used so far. */
1078  if (sh_is_renesas_calling_convention (func_type)
1079  && TYPE_VARARGS (func_type))
1080  last_reg_arg = TYPE_NFIELDS (func_type) - 2;
1081 
1082  /* First force sp to a 4-byte alignment. */
1083  sp = sh_frame_align (gdbarch, sp);
1084 
1085  /* Make room on stack for args. */
1086  sp -= sh_stack_allocsize (nargs, args);
1087 
1088  /* Initialize float argument mechanism. */
1089  sh_init_flt_argreg ();
1090 
1091  /* Now load as many as possible of the first arguments into
1092  registers, and push the rest onto the stack. There are 16 bytes
1093  in four registers available. Loop thru args from first to last. */
1094  for (argnum = 0; argnum < nargs; argnum++)
1095  {
1096  type = value_type (args[argnum]);
1097  len = TYPE_LENGTH (type);
1098  val = sh_justify_value_in_reg (gdbarch, args[argnum], len);
1099 
1100  /* Some decisions have to be made how various types are handled.
1101  This also differs in different ABIs. */
1102  pass_on_stack = 0;
1103 
1104  /* Find out the next register to use for a floating point value. */
1105  treat_as_flt = sh_treat_as_flt_p (type);
1106  if (treat_as_flt)
1107  flt_argreg = sh_next_flt_argreg (gdbarch, len, func_type);
1108  /* In Renesas ABI, long longs and aggregate types are always passed
1109  on stack. */
1110  else if (sh_is_renesas_calling_convention (func_type)
1111  && ((TYPE_CODE (type) == TYPE_CODE_INT && len == 8)
1112  || TYPE_CODE (type) == TYPE_CODE_STRUCT
1113  || TYPE_CODE (type) == TYPE_CODE_UNION))
1114  pass_on_stack = 1;
1115  /* In contrast to non-FPU CPUs, arguments are never split between
1116  registers and stack. If an argument doesn't fit in the remaining
1117  registers it's always pushed entirely on the stack. */
1118  else if (len > ((ARGLAST_REGNUM - argreg + 1) * 4))
1119  pass_on_stack = 1;
1120 
1121  while (len > 0)
1122  {
1123  if ((treat_as_flt && flt_argreg > FLOAT_ARGLAST_REGNUM)
1124  || (!treat_as_flt && (argreg > ARGLAST_REGNUM
1125  || pass_on_stack))
1126  || argnum > last_reg_arg)
1127  {
1128  /* The data goes entirely on the stack, 4-byte aligned. */
1129  reg_size = (len + 3) & ~3;
1130  write_memory (sp + stack_offset, val, reg_size);
1131  stack_offset += reg_size;
1132  }
1133  else if (treat_as_flt && flt_argreg <= FLOAT_ARGLAST_REGNUM)
1134  {
1135  /* Argument goes in a float argument register. */
1136  reg_size = register_size (gdbarch, flt_argreg);
1137  regval = extract_unsigned_integer (val, reg_size, byte_order);
1138  /* In little endian mode, float types taking two registers
1139  (doubles on sh4, long doubles on sh2e, sh3e and sh4) must
1140  be stored swapped in the argument registers. The below
1141  code first writes the first 32 bits in the next but one
1142  register, increments the val and len values accordingly
1143  and then proceeds as normal by writing the second 32 bits
1144  into the next register. */
1145  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE
1146  && TYPE_LENGTH (type) == 2 * reg_size)
1147  {
1148  regcache_cooked_write_unsigned (regcache, flt_argreg + 1,
1149  regval);
1150  val += reg_size;
1151  len -= reg_size;
1152  regval = extract_unsigned_integer (val, reg_size,
1153  byte_order);
1154  }
1155  regcache_cooked_write_unsigned (regcache, flt_argreg++, regval);
1156  }
1157  else if (!treat_as_flt && argreg <= ARGLAST_REGNUM)
1158  {
1159  /* there's room in a register */
1160  reg_size = register_size (gdbarch, argreg);
1161  regval = extract_unsigned_integer (val, reg_size, byte_order);
1162  regcache_cooked_write_unsigned (regcache, argreg++, regval);
1163  }
1164  /* Store the value one register at a time or in one step on
1165  stack. */
1166  len -= reg_size;
1167  val += reg_size;
1168  }
1169  }
1170 
1171  if (struct_return)
1172  {
1173  if (sh_is_renesas_calling_convention (func_type))
1174  /* If the function uses the Renesas ABI, subtract another 4 bytes from
1175  the stack and store the struct return address there. */
1176  write_memory_unsigned_integer (sp -= 4, 4, byte_order, struct_addr);
1177  else
1178  /* Using the gcc ABI, the "struct return pointer" pseudo-argument has
1179  its own dedicated register. */
1181  STRUCT_RETURN_REGNUM, struct_addr);
1182  }
1183 
1184  /* Store return address. */
1185  regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr);
1186 
1187  /* Update stack pointer. */
1189  gdbarch_sp_regnum (gdbarch), sp);
1190 
1191  return sp;
1192 }
1193 
1194 static CORE_ADDR
1195 sh_push_dummy_call_nofpu (struct gdbarch *gdbarch,
1196  struct value *function,
1197  struct regcache *regcache,
1198  CORE_ADDR bp_addr,
1199  int nargs, struct value **args,
1200  CORE_ADDR sp, int struct_return,
1201  CORE_ADDR struct_addr)
1202 {
1203  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1204  int stack_offset = 0;
1205  int argreg = ARG0_REGNUM;
1206  int argnum;
1207  struct type *func_type = value_type (function);
1208  struct type *type;
1209  CORE_ADDR regval;
1210  const gdb_byte *val;
1211  int len, reg_size = 0;
1212  int pass_on_stack = 0;
1213  int last_reg_arg = INT_MAX;
1214 
1215  /* The Renesas ABI expects all varargs arguments, plus the last
1216  non-vararg argument to be on the stack, no matter how many
1217  registers have been used so far. */
1218  if (sh_is_renesas_calling_convention (func_type)
1219  && TYPE_VARARGS (func_type))
1220  last_reg_arg = TYPE_NFIELDS (func_type) - 2;
1221 
1222  /* First force sp to a 4-byte alignment. */
1223  sp = sh_frame_align (gdbarch, sp);
1224 
1225  /* Make room on stack for args. */
1226  sp -= sh_stack_allocsize (nargs, args);
1227 
1228  /* Now load as many as possible of the first arguments into
1229  registers, and push the rest onto the stack. There are 16 bytes
1230  in four registers available. Loop thru args from first to last. */
1231  for (argnum = 0; argnum < nargs; argnum++)
1232  {
1233  type = value_type (args[argnum]);
1234  len = TYPE_LENGTH (type);
1235  val = sh_justify_value_in_reg (gdbarch, args[argnum], len);
1236 
1237  /* Some decisions have to be made how various types are handled.
1238  This also differs in different ABIs. */
1239  pass_on_stack = 0;
1240  /* Renesas ABI pushes doubles and long longs entirely on stack.
1241  Same goes for aggregate types. */
1242  if (sh_is_renesas_calling_convention (func_type)
1243  && ((TYPE_CODE (type) == TYPE_CODE_INT && len >= 8)
1244  || (TYPE_CODE (type) == TYPE_CODE_FLT && len >= 8)
1245  || TYPE_CODE (type) == TYPE_CODE_STRUCT
1246  || TYPE_CODE (type) == TYPE_CODE_UNION))
1247  pass_on_stack = 1;
1248  while (len > 0)
1249  {
1250  if (argreg > ARGLAST_REGNUM || pass_on_stack
1251  || argnum > last_reg_arg)
1252  {
1253  /* The remainder of the data goes entirely on the stack,
1254  4-byte aligned. */
1255  reg_size = (len + 3) & ~3;
1256  write_memory (sp + stack_offset, val, reg_size);
1257  stack_offset += reg_size;
1258  }
1259  else if (argreg <= ARGLAST_REGNUM)
1260  {
1261  /* There's room in a register. */
1262  reg_size = register_size (gdbarch, argreg);
1263  regval = extract_unsigned_integer (val, reg_size, byte_order);
1264  regcache_cooked_write_unsigned (regcache, argreg++, regval);
1265  }
1266  /* Store the value reg_size bytes at a time. This means that things
1267  larger than reg_size bytes may go partly in registers and partly
1268  on the stack. */
1269  len -= reg_size;
1270  val += reg_size;
1271  }
1272  }
1273 
1274  if (struct_return)
1275  {
1276  if (sh_is_renesas_calling_convention (func_type))
1277  /* If the function uses the Renesas ABI, subtract another 4 bytes from
1278  the stack and store the struct return address there. */
1279  write_memory_unsigned_integer (sp -= 4, 4, byte_order, struct_addr);
1280  else
1281  /* Using the gcc ABI, the "struct return pointer" pseudo-argument has
1282  its own dedicated register. */
1284  STRUCT_RETURN_REGNUM, struct_addr);
1285  }
1286 
1287  /* Store return address. */
1288  regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr);
1289 
1290  /* Update stack pointer. */
1292  gdbarch_sp_regnum (gdbarch), sp);
1293 
1294  return sp;
1295 }
1296 
1297 /* Find a function's return value in the appropriate registers (in
1298  regbuf), and copy it into valbuf. Extract from an array REGBUF
1299  containing the (raw) register state a function return value of type
1300  TYPE, and copy that, in virtual format, into VALBUF. */
1301 static void
1303  gdb_byte *valbuf)
1304 {
1305  struct gdbarch *gdbarch = get_regcache_arch (regcache);
1306  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1307  int len = TYPE_LENGTH (type);
1308  int return_register = R0_REGNUM;
1309  int offset;
1310 
1311  if (len <= 4)
1312  {
1313  ULONGEST c;
1314 
1315  regcache_cooked_read_unsigned (regcache, R0_REGNUM, &c);
1316  store_unsigned_integer (valbuf, len, byte_order, c);
1317  }
1318  else if (len == 8)
1319  {
1320  int i, regnum = R0_REGNUM;
1321  for (i = 0; i < len; i += 4)
1322  regcache_raw_read (regcache, regnum++, valbuf + i);
1323  }
1324  else
1325  error (_("bad size for return value"));
1326 }
1327 
1328 static void
1330  gdb_byte *valbuf)
1331 {
1332  struct gdbarch *gdbarch = get_regcache_arch (regcache);
1333  if (sh_treat_as_flt_p (type))
1334  {
1335  int len = TYPE_LENGTH (type);
1336  int i, regnum = gdbarch_fp0_regnum (gdbarch);
1337  for (i = 0; i < len; i += 4)
1338  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
1339  regcache_raw_read (regcache, regnum++,
1340  valbuf + len - 4 - i);
1341  else
1342  regcache_raw_read (regcache, regnum++, valbuf + i);
1343  }
1344  else
1345  sh_extract_return_value_nofpu (type, regcache, valbuf);
1346 }
1347 
1348 /* Write into appropriate registers a function return value
1349  of type TYPE, given in virtual format.
1350  If the architecture is sh4 or sh3e, store a function's return value
1351  in the R0 general register or in the FP0 floating point register,
1352  depending on the type of the return value. In all the other cases
1353  the result is stored in r0, left-justified. */
1354 static void
1356  const gdb_byte *valbuf)
1357 {
1358  struct gdbarch *gdbarch = get_regcache_arch (regcache);
1359  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1360  ULONGEST val;
1361  int len = TYPE_LENGTH (type);
1362 
1363  if (len <= 4)
1364  {
1365  val = extract_unsigned_integer (valbuf, len, byte_order);
1366  regcache_cooked_write_unsigned (regcache, R0_REGNUM, val);
1367  }
1368  else
1369  {
1370  int i, regnum = R0_REGNUM;
1371  for (i = 0; i < len; i += 4)
1372  regcache_raw_write (regcache, regnum++, valbuf + i);
1373  }
1374 }
1375 
1376 static void
1378  const gdb_byte *valbuf)
1379 {
1380  struct gdbarch *gdbarch = get_regcache_arch (regcache);
1381  if (sh_treat_as_flt_p (type))
1382  {
1383  int len = TYPE_LENGTH (type);
1384  int i, regnum = gdbarch_fp0_regnum (gdbarch);
1385  for (i = 0; i < len; i += 4)
1386  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
1387  regcache_raw_write (regcache, regnum++,
1388  valbuf + len - 4 - i);
1389  else
1390  regcache_raw_write (regcache, regnum++, valbuf + i);
1391  }
1392  else
1393  sh_store_return_value_nofpu (type, regcache, valbuf);
1394 }
1395 
1396 static enum return_value_convention
1397 sh_return_value_nofpu (struct gdbarch *gdbarch, struct value *function,
1398  struct type *type, struct regcache *regcache,
1399  gdb_byte *readbuf, const gdb_byte *writebuf)
1400 {
1401  struct type *func_type = function ? value_type (function) : NULL;
1402 
1404  sh_is_renesas_calling_convention (func_type), type))
1406  if (writebuf)
1407  sh_store_return_value_nofpu (type, regcache, writebuf);
1408  else if (readbuf)
1409  sh_extract_return_value_nofpu (type, regcache, readbuf);
1411 }
1412 
1413 static enum return_value_convention
1414 sh_return_value_fpu (struct gdbarch *gdbarch, struct value *function,
1415  struct type *type, struct regcache *regcache,
1416  gdb_byte *readbuf, const gdb_byte *writebuf)
1417 {
1418  struct type *func_type = function ? value_type (function) : NULL;
1419 
1421  sh_is_renesas_calling_convention (func_type), type))
1423  if (writebuf)
1424  sh_store_return_value_fpu (type, regcache, writebuf);
1425  else if (readbuf)
1426  sh_extract_return_value_fpu (type, regcache, readbuf);
1428 }
1429 
1430 static struct type *
1431 sh_sh2a_register_type (struct gdbarch *gdbarch, int reg_nr)
1432 {
1433  if ((reg_nr >= gdbarch_fp0_regnum (gdbarch)
1434  && (reg_nr <= FP_LAST_REGNUM)) || (reg_nr == FPUL_REGNUM))
1435  return builtin_type (gdbarch)->builtin_float;
1436  else if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM)
1437  return builtin_type (gdbarch)->builtin_double;
1438  else
1439  return builtin_type (gdbarch)->builtin_int;
1440 }
1441 
1442 /* Return the GDB type object for the "standard" data type
1443  of data in register N. */
1444 static struct type *
1445 sh_sh3e_register_type (struct gdbarch *gdbarch, int reg_nr)
1446 {
1447  if ((reg_nr >= gdbarch_fp0_regnum (gdbarch)
1448  && (reg_nr <= FP_LAST_REGNUM)) || (reg_nr == FPUL_REGNUM))
1449  return builtin_type (gdbarch)->builtin_float;
1450  else
1451  return builtin_type (gdbarch)->builtin_int;
1452 }
1453 
1454 static struct type *
1455 sh_sh4_build_float_register_type (struct gdbarch *gdbarch, int high)
1456 {
1457  return lookup_array_range_type (builtin_type (gdbarch)->builtin_float,
1458  0, high);
1459 }
1460 
1461 static struct type *
1462 sh_sh4_register_type (struct gdbarch *gdbarch, int reg_nr)
1463 {
1464  if ((reg_nr >= gdbarch_fp0_regnum (gdbarch)
1465  && (reg_nr <= FP_LAST_REGNUM)) || (reg_nr == FPUL_REGNUM))
1466  return builtin_type (gdbarch)->builtin_float;
1467  else if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM)
1468  return builtin_type (gdbarch)->builtin_double;
1469  else if (reg_nr >= FV0_REGNUM && reg_nr <= FV_LAST_REGNUM)
1470  return sh_sh4_build_float_register_type (gdbarch, 3);
1471  else
1472  return builtin_type (gdbarch)->builtin_int;
1473 }
1474 
1475 static struct type *
1476 sh_default_register_type (struct gdbarch *gdbarch, int reg_nr)
1477 {
1478  return builtin_type (gdbarch)->builtin_int;
1479 }
1480 
1481 /* Is a register in a reggroup?
1482  The default code in reggroup.c doesn't identify system registers, some
1483  float registers or any of the vector registers.
1484  TODO: sh2a and dsp registers. */
1485 static int
1486 sh_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
1487  struct reggroup *reggroup)
1488 {
1489  if (gdbarch_register_name (gdbarch, regnum) == NULL
1490  || *gdbarch_register_name (gdbarch, regnum) == '\0')
1491  return 0;
1492 
1493  if (reggroup == float_reggroup
1494  && (regnum == FPUL_REGNUM
1495  || regnum == FPSCR_REGNUM))
1496  return 1;
1497 
1498  if (regnum >= FV0_REGNUM && regnum <= FV_LAST_REGNUM)
1499  {
1500  if (reggroup == vector_reggroup || reggroup == float_reggroup)
1501  return 1;
1502  if (reggroup == general_reggroup)
1503  return 0;
1504  }
1505 
1506  if (regnum == VBR_REGNUM
1507  || regnum == SR_REGNUM
1508  || regnum == FPSCR_REGNUM
1509  || regnum == SSR_REGNUM
1510  || regnum == SPC_REGNUM)
1511  {
1512  if (reggroup == system_reggroup)
1513  return 1;
1514  if (reggroup == general_reggroup)
1515  return 0;
1516  }
1517 
1518  /* The default code can cope with any other registers. */
1519  return default_register_reggroup_p (gdbarch, regnum, reggroup);
1520 }
1521 
1522 /* On the sh4, the DRi pseudo registers are problematic if the target
1523  is little endian. When the user writes one of those registers, for
1524  instance with 'set var $dr0=1', we want the double to be stored
1525  like this:
1526  fr0 = 0x00 0x00 0xf0 0x3f
1527  fr1 = 0x00 0x00 0x00 0x00
1528 
1529  This corresponds to little endian byte order & big endian word
1530  order. However if we let gdb write the register w/o conversion, it
1531  will write fr0 and fr1 this way:
1532  fr0 = 0x00 0x00 0x00 0x00
1533  fr1 = 0x00 0x00 0xf0 0x3f
1534  because it will consider fr0 and fr1 as a single LE stretch of memory.
1535 
1536  To achieve what we want we must force gdb to store things in
1537  floatformat_ieee_double_littlebyte_bigword (which is defined in
1538  include/floatformat.h and libiberty/floatformat.c.
1539 
1540  In case the target is big endian, there is no problem, the
1541  raw bytes will look like:
1542  fr0 = 0x3f 0xf0 0x00 0x00
1543  fr1 = 0x00 0x00 0x00 0x00
1544 
1545  The other pseudo registers (the FVs) also don't pose a problem
1546  because they are stored as 4 individual FP elements. */
1547 
1548 static void
1549 sh_register_convert_to_virtual (struct gdbarch *gdbarch, int regnum,
1550  struct type *type, gdb_byte *from, gdb_byte *to)
1551 {
1552  if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_LITTLE)
1553  {
1554  /* It is a no-op. */
1555  memcpy (to, from, register_size (gdbarch, regnum));
1556  return;
1557  }
1558 
1559  if (regnum >= DR0_REGNUM && regnum <= DR_LAST_REGNUM)
1560  {
1561  DOUBLEST val;
1562  floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword,
1563  from, &val);
1564  store_typed_floating (to, type, val);
1565  }
1566  else
1567  error
1568  ("sh_register_convert_to_virtual called with non DR register number");
1569 }
1570 
1571 static void
1572 sh_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type,
1573  int regnum, const gdb_byte *from, gdb_byte *to)
1574 {
1575  if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_LITTLE)
1576  {
1577  /* It is a no-op. */
1578  memcpy (to, from, register_size (gdbarch, regnum));
1579  return;
1580  }
1581 
1582  if (regnum >= DR0_REGNUM && regnum <= DR_LAST_REGNUM)
1583  {
1584  DOUBLEST val = extract_typed_floating (from, type);
1585  floatformat_from_doublest (&floatformat_ieee_double_littlebyte_bigword,
1586  &val, to);
1587  }
1588  else
1589  error (_("sh_register_convert_to_raw called with non DR register number"));
1590 }
1591 
1592 /* For vectors of 4 floating point registers. */
1593 static int
1594 fv_reg_base_num (struct gdbarch *gdbarch, int fv_regnum)
1595 {
1596  int fp_regnum;
1597 
1598  fp_regnum = gdbarch_fp0_regnum (gdbarch)
1599  + (fv_regnum - FV0_REGNUM) * 4;
1600  return fp_regnum;
1601 }
1602 
1603 /* For double precision floating point registers, i.e 2 fp regs. */
1604 static int
1605 dr_reg_base_num (struct gdbarch *gdbarch, int dr_regnum)
1606 {
1607  int fp_regnum;
1608 
1609  fp_regnum = gdbarch_fp0_regnum (gdbarch)
1610  + (dr_regnum - DR0_REGNUM) * 2;
1611  return fp_regnum;
1612 }
1613 
1614 /* Concatenate PORTIONS contiguous raw registers starting at
1615  BASE_REGNUM into BUFFER. */
1616 
1617 static enum register_status
1618 pseudo_register_read_portions (struct gdbarch *gdbarch,
1619  struct regcache *regcache,
1620  int portions,
1621  int base_regnum, gdb_byte *buffer)
1622 {
1623  int portion;
1624 
1625  for (portion = 0; portion < portions; portion++)
1626  {
1627  enum register_status status;
1628  gdb_byte *b;
1629 
1630  b = buffer + register_size (gdbarch, base_regnum) * portion;
1631  status = regcache_raw_read (regcache, base_regnum + portion, b);
1632  if (status != REG_VALID)
1633  return status;
1634  }
1635 
1636  return REG_VALID;
1637 }
1638 
1639 static enum register_status
1640 sh_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
1641  int reg_nr, gdb_byte *buffer)
1642 {
1643  int base_regnum;
1644  gdb_byte temp_buffer[MAX_REGISTER_SIZE];
1645  enum register_status status;
1646 
1647  if (reg_nr == PSEUDO_BANK_REGNUM)
1648  return regcache_raw_read (regcache, BANK_REGNUM, buffer);
1649  else if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM)
1650  {
1651  base_regnum = dr_reg_base_num (gdbarch, reg_nr);
1652 
1653  /* Build the value in the provided buffer. */
1654  /* Read the real regs for which this one is an alias. */
1655  status = pseudo_register_read_portions (gdbarch, regcache,
1656  2, base_regnum, temp_buffer);
1657  if (status == REG_VALID)
1658  {
1659  /* We must pay attention to the endiannes. */
1660  sh_register_convert_to_virtual (gdbarch, reg_nr,
1661  register_type (gdbarch, reg_nr),
1662  temp_buffer, buffer);
1663  }
1664  return status;
1665  }
1666  else if (reg_nr >= FV0_REGNUM && reg_nr <= FV_LAST_REGNUM)
1667  {
1668  base_regnum = fv_reg_base_num (gdbarch, reg_nr);
1669 
1670  /* Read the real regs for which this one is an alias. */
1671  return pseudo_register_read_portions (gdbarch, regcache,
1672  4, base_regnum, buffer);
1673  }
1674  else
1675  gdb_assert_not_reached ("invalid pseudo register number");
1676 }
1677 
1678 static void
1679 sh_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
1680  int reg_nr, const gdb_byte *buffer)
1681 {
1682  int base_regnum, portion;
1683  gdb_byte temp_buffer[MAX_REGISTER_SIZE];
1684 
1685  if (reg_nr == PSEUDO_BANK_REGNUM)
1686  {
1687  /* When the bank register is written to, the whole register bank
1688  is switched and all values in the bank registers must be read
1689  from the target/sim again. We're just invalidating the regcache
1690  so that a re-read happens next time it's necessary. */
1691  int bregnum;
1692 
1693  regcache_raw_write (regcache, BANK_REGNUM, buffer);
1694  for (bregnum = R0_BANK0_REGNUM; bregnum < MACLB_REGNUM; ++bregnum)
1695  regcache_invalidate (regcache, bregnum);
1696  }
1697  else if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM)
1698  {
1699  base_regnum = dr_reg_base_num (gdbarch, reg_nr);
1700 
1701  /* We must pay attention to the endiannes. */
1702  sh_register_convert_to_raw (gdbarch, register_type (gdbarch, reg_nr),
1703  reg_nr, buffer, temp_buffer);
1704 
1705  /* Write the real regs for which this one is an alias. */
1706  for (portion = 0; portion < 2; portion++)
1707  regcache_raw_write (regcache, base_regnum + portion,
1708  (temp_buffer
1709  + register_size (gdbarch,
1710  base_regnum) * portion));
1711  }
1712  else if (reg_nr >= FV0_REGNUM && reg_nr <= FV_LAST_REGNUM)
1713  {
1714  base_regnum = fv_reg_base_num (gdbarch, reg_nr);
1715 
1716  /* Write the real regs for which this one is an alias. */
1717  for (portion = 0; portion < 4; portion++)
1718  regcache_raw_write (regcache, base_regnum + portion,
1719  (buffer
1720  + register_size (gdbarch,
1721  base_regnum) * portion));
1722  }
1723 }
1724 
1725 static int
1726 sh_dsp_register_sim_regno (struct gdbarch *gdbarch, int nr)
1727 {
1728  if (legacy_register_sim_regno (gdbarch, nr) < 0)
1729  return legacy_register_sim_regno (gdbarch, nr);
1730  if (nr >= DSR_REGNUM && nr <= Y1_REGNUM)
1731  return nr - DSR_REGNUM + SIM_SH_DSR_REGNUM;
1732  if (nr == MOD_REGNUM)
1733  return SIM_SH_MOD_REGNUM;
1734  if (nr == RS_REGNUM)
1735  return SIM_SH_RS_REGNUM;
1736  if (nr == RE_REGNUM)
1737  return SIM_SH_RE_REGNUM;
1738  if (nr >= DSP_R0_BANK_REGNUM && nr <= DSP_R7_BANK_REGNUM)
1739  return nr - DSP_R0_BANK_REGNUM + SIM_SH_R0_BANK_REGNUM;
1740  return nr;
1741 }
1742 
1743 static int
1744 sh_sh2a_register_sim_regno (struct gdbarch *gdbarch, int nr)
1745 {
1746  switch (nr)
1747  {
1748  case TBR_REGNUM:
1749  return SIM_SH_TBR_REGNUM;
1750  case IBNR_REGNUM:
1751  return SIM_SH_IBNR_REGNUM;
1752  case IBCR_REGNUM:
1753  return SIM_SH_IBCR_REGNUM;
1754  case BANK_REGNUM:
1755  return SIM_SH_BANK_REGNUM;
1756  case MACLB_REGNUM:
1757  return SIM_SH_BANK_MACL_REGNUM;
1758  case GBRB_REGNUM:
1759  return SIM_SH_BANK_GBR_REGNUM;
1760  case PRB_REGNUM:
1761  return SIM_SH_BANK_PR_REGNUM;
1762  case IVNB_REGNUM:
1763  return SIM_SH_BANK_IVN_REGNUM;
1764  case MACHB_REGNUM:
1765  return SIM_SH_BANK_MACH_REGNUM;
1766  default:
1767  break;
1768  }
1769  return legacy_register_sim_regno (gdbarch, nr);
1770 }
1771 
1772 /* Set up the register unwinding such that call-clobbered registers are
1773  not displayed in frames >0 because the true value is not certain.
1774  The 'undefined' registers will show up as 'not available' unless the
1775  CFI says otherwise.
1776 
1777  This function is currently set up for SH4 and compatible only. */
1778 
1779 static void
1780 sh_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
1781  struct dwarf2_frame_state_reg *reg,
1782  struct frame_info *this_frame)
1783 {
1784  /* Mark the PC as the destination for the return address. */
1785  if (regnum == gdbarch_pc_regnum (gdbarch))
1786  reg->how = DWARF2_FRAME_REG_RA;
1787 
1788  /* Mark the stack pointer as the call frame address. */
1789  else if (regnum == gdbarch_sp_regnum (gdbarch))
1790  reg->how = DWARF2_FRAME_REG_CFA;
1791 
1792  /* The above was taken from the default init_reg in dwarf2-frame.c
1793  while the below is SH specific. */
1794 
1795  /* Caller save registers. */
1796  else if ((regnum >= R0_REGNUM && regnum <= R0_REGNUM+7)
1797  || (regnum >= FR0_REGNUM && regnum <= FR0_REGNUM+11)
1798  || (regnum >= DR0_REGNUM && regnum <= DR0_REGNUM+5)
1799  || (regnum >= FV0_REGNUM && regnum <= FV0_REGNUM+2)
1800  || (regnum == MACH_REGNUM)
1801  || (regnum == MACL_REGNUM)
1802  || (regnum == FPUL_REGNUM)
1803  || (regnum == SR_REGNUM))
1805 
1806  /* Callee save registers. */
1807  else if ((regnum >= R0_REGNUM+8 && regnum <= R0_REGNUM+15)
1808  || (regnum >= FR0_REGNUM+12 && regnum <= FR0_REGNUM+15)
1809  || (regnum >= DR0_REGNUM+6 && regnum <= DR0_REGNUM+8)
1810  || (regnum == FV0_REGNUM+3))
1812 
1813  /* Other registers. These are not in the ABI and may or may not
1814  mean anything in frames >0 so don't show them. */
1815  else if ((regnum >= R0_BANK0_REGNUM && regnum <= R0_BANK0_REGNUM+15)
1816  || (regnum == GBR_REGNUM)
1817  || (regnum == VBR_REGNUM)
1818  || (regnum == FPSCR_REGNUM)
1819  || (regnum == SSR_REGNUM)
1820  || (regnum == SPC_REGNUM))
1822 }
1823 
1824 static struct sh_frame_cache *
1826 {
1827  struct sh_frame_cache *cache;
1828  int i;
1829 
1830  cache = FRAME_OBSTACK_ZALLOC (struct sh_frame_cache);
1831 
1832  /* Base address. */
1833  cache->base = 0;
1834  cache->saved_sp = 0;
1835  cache->sp_offset = 0;
1836  cache->pc = 0;
1837 
1838  /* Frameless until proven otherwise. */
1839  cache->uses_fp = 0;
1840 
1841  /* Saved registers. We initialize these to -1 since zero is a valid
1842  offset (that's where fp is supposed to be stored). */
1843  for (i = 0; i < SH_NUM_REGS; i++)
1844  {
1845  cache->saved_regs[i] = -1;
1846  }
1847 
1848  return cache;
1849 }
1850 
1851 static struct sh_frame_cache *
1852 sh_frame_cache (struct frame_info *this_frame, void **this_cache)
1853 {
1854  struct gdbarch *gdbarch = get_frame_arch (this_frame);
1855  struct sh_frame_cache *cache;
1856  CORE_ADDR current_pc;
1857  int i;
1858 
1859  if (*this_cache)
1860  return *this_cache;
1861 
1862  cache = sh_alloc_frame_cache ();
1863  *this_cache = cache;
1864 
1865  /* In principle, for normal frames, fp holds the frame pointer,
1866  which holds the base address for the current stack frame.
1867  However, for functions that don't need it, the frame pointer is
1868  optional. For these "frameless" functions the frame pointer is
1869  actually the frame pointer of the calling frame. */
1870  cache->base = get_frame_register_unsigned (this_frame, FP_REGNUM);
1871  if (cache->base == 0)
1872  return cache;
1873 
1874  cache->pc = get_frame_func (this_frame);
1875  current_pc = get_frame_pc (this_frame);
1876  if (cache->pc != 0)
1877  {
1878  ULONGEST fpscr;
1879 
1880  /* Check for the existence of the FPSCR register. If it exists,
1881  fetch its value for use in prologue analysis. Passing a zero
1882  value is the best choice for architecture variants upon which
1883  there's no FPSCR register. */
1885  fpscr = get_frame_register_unsigned (this_frame, FPSCR_REGNUM);
1886  else
1887  fpscr = 0;
1888 
1889  sh_analyze_prologue (gdbarch, cache->pc, current_pc, cache, fpscr);
1890  }
1891 
1892  if (!cache->uses_fp)
1893  {
1894  /* We didn't find a valid frame, which means that CACHE->base
1895  currently holds the frame pointer for our calling frame. If
1896  we're at the start of a function, or somewhere half-way its
1897  prologue, the function's frame probably hasn't been fully
1898  setup yet. Try to reconstruct the base address for the stack
1899  frame by looking at the stack pointer. For truly "frameless"
1900  functions this might work too. */
1902  (this_frame, gdbarch_sp_regnum (gdbarch));
1903  }
1904 
1905  /* Now that we have the base address for the stack frame we can
1906  calculate the value of sp in the calling frame. */
1907  cache->saved_sp = cache->base + cache->sp_offset;
1908 
1909  /* Adjust all the saved registers such that they contain addresses
1910  instead of offsets. */
1911  for (i = 0; i < SH_NUM_REGS; i++)
1912  if (cache->saved_regs[i] != -1)
1913  cache->saved_regs[i] = cache->saved_sp - cache->saved_regs[i] - 4;
1914 
1915  return cache;
1916 }
1917 
1918 static struct value *
1920  void **this_cache, int regnum)
1921 {
1922  struct gdbarch *gdbarch = get_frame_arch (this_frame);
1923  struct sh_frame_cache *cache = sh_frame_cache (this_frame, this_cache);
1924 
1925  gdb_assert (regnum >= 0);
1926 
1927  if (regnum == gdbarch_sp_regnum (gdbarch) && cache->saved_sp)
1928  return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
1929 
1930  /* The PC of the previous frame is stored in the PR register of
1931  the current frame. Frob regnum so that we pull the value from
1932  the correct place. */
1933  if (regnum == gdbarch_pc_regnum (gdbarch))
1934  regnum = PR_REGNUM;
1935 
1936  if (regnum < SH_NUM_REGS && cache->saved_regs[regnum] != -1)
1937  return frame_unwind_got_memory (this_frame, regnum,
1938  cache->saved_regs[regnum]);
1939 
1940  return frame_unwind_got_register (this_frame, regnum, regnum);
1941 }
1942 
1943 static void
1944 sh_frame_this_id (struct frame_info *this_frame, void **this_cache,
1945  struct frame_id *this_id)
1946 {
1947  struct sh_frame_cache *cache = sh_frame_cache (this_frame, this_cache);
1948 
1949  /* This marks the outermost frame. */
1950  if (cache->base == 0)
1951  return;
1952 
1953  *this_id = frame_id_build (cache->saved_sp, cache->pc);
1954 }
1955 
1956 static const struct frame_unwind sh_frame_unwind = {
1957  NORMAL_FRAME,
1961  NULL,
1963 };
1964 
1965 static CORE_ADDR
1966 sh_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
1967 {
1968  return frame_unwind_register_unsigned (next_frame,
1969  gdbarch_sp_regnum (gdbarch));
1970 }
1971 
1972 static CORE_ADDR
1973 sh_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1974 {
1975  return frame_unwind_register_unsigned (next_frame,
1976  gdbarch_pc_regnum (gdbarch));
1977 }
1978 
1979 static struct frame_id
1980 sh_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1981 {
1982  CORE_ADDR sp = get_frame_register_unsigned (this_frame,
1983  gdbarch_sp_regnum (gdbarch));
1984  return frame_id_build (sp, get_frame_pc (this_frame));
1985 }
1986 
1987 static CORE_ADDR
1988 sh_frame_base_address (struct frame_info *this_frame, void **this_cache)
1989 {
1990  struct sh_frame_cache *cache = sh_frame_cache (this_frame, this_cache);
1991 
1992  return cache->base;
1993 }
1994 
1995 static const struct frame_base sh_frame_base = {
1996  &sh_frame_unwind,
1999  sh_frame_base_address
2000 };
2001 
2002 static struct sh_frame_cache *
2003 sh_make_stub_cache (struct frame_info *this_frame)
2004 {
2005  struct gdbarch *gdbarch = get_frame_arch (this_frame);
2006  struct sh_frame_cache *cache;
2007 
2008  cache = sh_alloc_frame_cache ();
2009 
2010  cache->saved_sp
2011  = get_frame_register_unsigned (this_frame, gdbarch_sp_regnum (gdbarch));
2012 
2013  return cache;
2014 }
2015 
2016 static void
2017 sh_stub_this_id (struct frame_info *this_frame, void **this_cache,
2018  struct frame_id *this_id)
2019 {
2020  struct sh_frame_cache *cache;
2021 
2022  if (*this_cache == NULL)
2023  *this_cache = sh_make_stub_cache (this_frame);
2024  cache = *this_cache;
2025 
2026  *this_id = frame_id_build (cache->saved_sp, get_frame_pc (this_frame));
2027 }
2028 
2029 static int
2031  struct frame_info *this_frame,
2032  void **this_prologue_cache)
2033 {
2034  CORE_ADDR addr_in_block;
2035 
2036  addr_in_block = get_frame_address_in_block (this_frame);
2037  if (in_plt_section (addr_in_block))
2038  return 1;
2039 
2040  return 0;
2041 }
2042 
2043 static const struct frame_unwind sh_stub_unwind =
2044 {
2045  NORMAL_FRAME,
2049  NULL,
2051 };
2052 
2053 /* Implement the stack_frame_destroyed_p gdbarch method.
2054 
2055  The epilogue is defined here as the area at the end of a function,
2056  either on the `ret' instruction itself or after an instruction which
2057  destroys the function's stack frame. */
2058 
2059 static int
2060 sh_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
2061 {
2062  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2063  CORE_ADDR func_addr = 0, func_end = 0;
2064 
2065  if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
2066  {
2067  ULONGEST inst;
2068  /* The sh epilogue is max. 14 bytes long. Give another 14 bytes
2069  for a nop and some fixed data (e.g. big offsets) which are
2070  unfortunately also treated as part of the function (which
2071  means, they are below func_end. */
2072  CORE_ADDR addr = func_end - 28;
2073  if (addr < func_addr + 4)
2074  addr = func_addr + 4;
2075  if (pc < addr)
2076  return 0;
2077 
2078  /* First search forward until hitting an rts. */
2079  while (addr < func_end
2080  && !IS_RTS (read_memory_unsigned_integer (addr, 2, byte_order)))
2081  addr += 2;
2082  if (addr >= func_end)
2083  return 0;
2084 
2085  /* At this point we should find a mov.l @r15+,r14 instruction,
2086  either before or after the rts. If not, then the function has
2087  probably no "normal" epilogue and we bail out here. */
2088  inst = read_memory_unsigned_integer (addr - 2, 2, byte_order);
2089  if (IS_RESTORE_FP (read_memory_unsigned_integer (addr - 2, 2,
2090  byte_order)))
2091  addr -= 2;
2092  else if (!IS_RESTORE_FP (read_memory_unsigned_integer (addr + 2, 2,
2093  byte_order)))
2094  return 0;
2095 
2096  inst = read_memory_unsigned_integer (addr - 2, 2, byte_order);
2097 
2098  /* Step over possible lds.l @r15+,macl. */
2099  if (IS_MACL_LDS (inst))
2100  {
2101  addr -= 2;
2102  inst = read_memory_unsigned_integer (addr - 2, 2, byte_order);
2103  }
2104 
2105  /* Step over possible lds.l @r15+,pr. */
2106  if (IS_LDS (inst))
2107  {
2108  addr -= 2;
2109  inst = read_memory_unsigned_integer (addr - 2, 2, byte_order);
2110  }
2111 
2112  /* Step over possible mov r14,r15. */
2113  if (IS_MOV_FP_SP (inst))
2114  {
2115  addr -= 2;
2116  inst = read_memory_unsigned_integer (addr - 2, 2, byte_order);
2117  }
2118 
2119  /* Now check for FP adjustments, using add #imm,r14 or add rX, r14
2120  instructions. */
2121  while (addr > func_addr + 4
2122  && (IS_ADD_REG_TO_FP (inst) || IS_ADD_IMM_FP (inst)))
2123  {
2124  addr -= 2;
2125  inst = read_memory_unsigned_integer (addr - 2, 2, byte_order);
2126  }
2127 
2128  /* On SH2a check if the previous instruction was perhaps a MOVI20.
2129  That's allowed for the epilogue. */
2130  if ((gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_sh2a
2131  || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_sh2a_nofpu)
2132  && addr > func_addr + 6
2133  && IS_MOVI20 (read_memory_unsigned_integer (addr - 4, 2,
2134  byte_order)))
2135  addr -= 4;
2136 
2137  if (pc >= addr)
2138  return 1;
2139  }
2140  return 0;
2141 }
2142 
2143 
2144 /* Supply register REGNUM from the buffer specified by REGS and LEN
2145  in the register set REGSET to register cache REGCACHE.
2146  REGTABLE specifies where each register can be found in REGS.
2147  If REGNUM is -1, do this for all registers in REGSET. */
2148 
2149 void
2151  struct regcache *regcache,
2152  int regnum, const void *regs, size_t len)
2153 {
2154  struct gdbarch *gdbarch = get_regcache_arch (regcache);
2155  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2156  const struct sh_corefile_regmap *regmap = (regset == &sh_corefile_gregset
2157  ? tdep->core_gregmap
2158  : tdep->core_fpregmap);
2159  int i;
2160 
2161  for (i = 0; regmap[i].regnum != -1; i++)
2162  {
2163  if ((regnum == -1 || regnum == regmap[i].regnum)
2164  && regmap[i].offset + 4 <= len)
2165  regcache_raw_supply (regcache, regmap[i].regnum,
2166  (char *)regs + regmap[i].offset);
2167  }
2168 }
2169 
2170 /* Collect register REGNUM in the register set REGSET from register cache
2171  REGCACHE into the buffer specified by REGS and LEN.
2172  REGTABLE specifies where each register can be found in REGS.
2173  If REGNUM is -1, do this for all registers in REGSET. */
2174 
2175 void
2177  const struct regcache *regcache,
2178  int regnum, void *regs, size_t len)
2179 {
2180  struct gdbarch *gdbarch = get_regcache_arch (regcache);
2181  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2182  const struct sh_corefile_regmap *regmap = (regset == &sh_corefile_gregset
2183  ? tdep->core_gregmap
2184  : tdep->core_fpregmap);
2185  int i;
2186 
2187  for (i = 0; regmap[i].regnum != -1; i++)
2188  {
2189  if ((regnum == -1 || regnum == regmap[i].regnum)
2190  && regmap[i].offset + 4 <= len)
2191  regcache_raw_collect (regcache, regmap[i].regnum,
2192  (char *)regs + regmap[i].offset);
2193  }
2194 }
2195 
2196 /* The following two regsets have the same contents, so it is tempting to
2197  unify them, but they are distiguished by their address, so don't. */
2198 
2199 const struct regset sh_corefile_gregset =
2200 {
2201  NULL,
2204 };
2205 
2206 static const struct regset sh_corefile_fpregset =
2207 {
2208  NULL,
2211 };
2212 
2213 static void
2214 sh_iterate_over_regset_sections (struct gdbarch *gdbarch,
2216  void *cb_data,
2217  const struct regcache *regcache)
2218 {
2219  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2220 
2221  if (tdep->core_gregmap != NULL)
2222  cb (".reg", tdep->sizeof_gregset, &sh_corefile_gregset, NULL, cb_data);
2223 
2224  if (tdep->core_fpregmap != NULL)
2225  cb (".reg2", tdep->sizeof_fpregset, &sh_corefile_fpregset, NULL, cb_data);
2226 }
2227 
2228 /* This is the implementation of gdbarch method
2229  return_in_first_hidden_param_p. */
2230 
2231 static int
2232 sh_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
2233  struct type *type)
2234 {
2235  return 0;
2236 }
2237 
2238 
2239 
2240 static struct gdbarch *
2241 sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2242 {
2243  struct gdbarch *gdbarch;
2244  struct gdbarch_tdep *tdep;
2245 
2246  /* SH5 is handled entirely in sh64-tdep.c. */
2247  if (info.bfd_arch_info->mach == bfd_mach_sh5)
2248  return sh64_gdbarch_init (info, arches);
2249 
2250  /* If there is already a candidate, use it. */
2251  arches = gdbarch_list_lookup_by_info (arches, &info);
2252  if (arches != NULL)
2253  return arches->gdbarch;
2254 
2255  /* None found, create a new architecture from the information
2256  provided. */
2257  tdep = XCNEW (struct gdbarch_tdep);
2258  gdbarch = gdbarch_alloc (&info, tdep);
2259 
2260  set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
2261  set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2262  set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2264  set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2265  set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2267  set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2268 
2269  set_gdbarch_num_regs (gdbarch, SH_NUM_REGS);
2270  set_gdbarch_sp_regnum (gdbarch, 15);
2271  set_gdbarch_pc_regnum (gdbarch, 16);
2272  set_gdbarch_fp0_regnum (gdbarch, -1);
2273  set_gdbarch_num_pseudo_regs (gdbarch, 0);
2274 
2277 
2279 
2280  set_gdbarch_print_insn (gdbarch, print_insn_sh);
2282 
2284 
2287 
2291 
2292  set_gdbarch_believe_pcc_promotion (gdbarch, 1);
2293 
2297  set_gdbarch_dummy_id (gdbarch, sh_dummy_id);
2298  frame_base_set_default (gdbarch, &sh_frame_base);
2299 
2301 
2303 
2306 
2307  switch (info.bfd_arch_info->mach)
2308  {
2309  case bfd_mach_sh:
2311  break;
2312 
2313  case bfd_mach_sh2:
2315  break;
2316 
2317  case bfd_mach_sh2e:
2318  /* doubles on sh2e and sh3e are actually 4 byte. */
2319  set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2321 
2324  set_gdbarch_fp0_regnum (gdbarch, 25);
2327  break;
2328 
2329  case bfd_mach_sh2a:
2333 
2334  set_gdbarch_fp0_regnum (gdbarch, 25);
2335  set_gdbarch_num_pseudo_regs (gdbarch, 9);
2340  break;
2341 
2342  case bfd_mach_sh2a_nofpu:
2345 
2346  set_gdbarch_num_pseudo_regs (gdbarch, 1);
2349  break;
2350 
2351  case bfd_mach_sh_dsp:
2354  break;
2355 
2356  case bfd_mach_sh3:
2357  case bfd_mach_sh3_nommu:
2358  case bfd_mach_sh2a_nofpu_or_sh3_nommu:
2360  break;
2361 
2362  case bfd_mach_sh3e:
2363  case bfd_mach_sh2a_or_sh3e:
2364  /* doubles on sh2e and sh3e are actually 4 byte. */
2365  set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2367 
2370  set_gdbarch_fp0_regnum (gdbarch, 25);
2373  break;
2374 
2375  case bfd_mach_sh3_dsp:
2378  break;
2379 
2380  case bfd_mach_sh4:
2381  case bfd_mach_sh4a:
2382  case bfd_mach_sh2a_or_sh4:
2385  set_gdbarch_fp0_regnum (gdbarch, 25);
2386  set_gdbarch_num_pseudo_regs (gdbarch, 13);
2391  break;
2392 
2393  case bfd_mach_sh4_nofpu:
2394  case bfd_mach_sh4a_nofpu:
2395  case bfd_mach_sh4_nommu_nofpu:
2396  case bfd_mach_sh2a_nofpu_or_sh4_nommu_nofpu:
2398  break;
2399 
2400  case bfd_mach_sh4al_dsp:
2403  break;
2404 
2405  default:
2407  break;
2408  }
2409 
2410  /* Hook in ABI-specific overrides, if they have been registered. */
2411  gdbarch_init_osabi (info, gdbarch);
2412 
2413  dwarf2_append_unwinders (gdbarch);
2414  frame_unwind_append_unwinder (gdbarch, &sh_stub_unwind);
2415  frame_unwind_append_unwinder (gdbarch, &sh_frame_unwind);
2416 
2417  return gdbarch;
2418 }
2419 
2420 static void
2421 show_sh_command (char *args, int from_tty)
2422 {
2423  help_list (showshcmdlist, "show sh ", all_commands, gdb_stdout);
2424 }
2425 
2426 static void
2427 set_sh_command (char *args, int from_tty)
2428 {
2430  ("\"set sh\" must be followed by an appropriate subcommand.\n");
2431  help_list (setshcmdlist, "set sh ", all_commands, gdb_stdout);
2432 }
2433 
2434 extern initialize_file_ftype _initialize_sh_tdep; /* -Wmissing-prototypes */
2435 
2436 void
2438 {
2439  gdbarch_register (bfd_arch_sh, sh_gdbarch_init, NULL);
2440 
2441  add_prefix_cmd ("sh", no_class, set_sh_command, "SH specific commands.",
2442  &setshcmdlist, "set sh ", 0, &setlist);
2443  add_prefix_cmd ("sh", no_class, show_sh_command, "SH specific commands.",
2444  &showshcmdlist, "show sh ", 0, &showlist);
2445 
2446  add_setshow_enum_cmd ("calling-convention", class_vars, sh_cc_enum,
2448  _("Set calling convention used when calling target "
2449  "functions from GDB."),
2450  _("Show calling convention used when calling target "
2451  "functions from GDB."),
2452  _("gcc - Use GCC calling convention (default).\n"
2453  "renesas - Enforce Renesas calling convention."),
2454  NULL, NULL,
2455  &setshcmdlist, &showshcmdlist);
2456 }
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
#define IS_MOVI20(x)
Definition: sh-tdep.c:519
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:338
#define IS_MOVL_PCREL_TO_REG(x)
Definition: sh-tdep.c:517
#define IS_MOV_ARG_TO_IND_R14(x)
Definition: sh-tdep.c:504
static int sh_register_reggroup_p(struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
Definition: sh-tdep.c:1486
struct type * lookup_array_range_type(struct type *element_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:1128
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
static int sh_treat_as_flt_p(struct type *type)
Definition: sh-tdep.c:1033
CORE_ADDR get_frame_address_in_block(struct frame_info *this_frame)
Definition: frame.c:2248
static CORE_ADDR sh_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR limit_pc, struct sh_frame_cache *cache, ULONGEST fpscr)
Definition: sh-tdep.c:535
#define IS_MACL_STS(x)
Definition: sh-tdep.c:469
static struct type * sh_default_register_type(struct gdbarch *gdbarch, int reg_nr)
Definition: sh-tdep.c:1476
#define IS_LDS(x)
Definition: sh-tdep.c:528
void set_gdbarch_float_bit(struct gdbarch *gdbarch, int float_bit)
Definition: gdbarch.c:1601
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
static void pass_on_stack(struct aarch64_call_info *info, struct type *type, const bfd_byte *buf)
void set_gdbarch_fp0_regnum(struct gdbarch *gdbarch, int fp0_regnum)
Definition: gdbarch.c:2042
bfd_vma CORE_ADDR
Definition: common-types.h:41
void floatformat_from_doublest(const struct floatformat *fmt, const DOUBLEST *in, void *out)
Definition: doublest.c:727
#define IS_MOV_ARG_TO_IND_R14_WITH_DISP(x)
Definition: sh-tdep.c:509
#define IS_MOV_ARG_TO_REG(x)
Definition: sh-tdep.c:499
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: osabi.c:341
#define target_shortname
Definition: target.h:1242
#define IS_FPUSH(x)
Definition: sh-tdep.c:496
#define IS_MOVW_PCREL_TO_REG(x)
Definition: sh-tdep.c:515
static void sh_store_return_value_nofpu(struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
Definition: sh-tdep.c:1355
static int dr_reg_base_num(struct gdbarch *gdbarch, int dr_regnum)
Definition: sh-tdep.c:1605
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
struct value * frame_unwind_got_memory(struct frame_info *frame, int regnum, CORE_ADDR addr)
Definition: frame-unwind.c:228
void write_memory_unsigned_integer(CORE_ADDR addr, int len, enum bfd_endian byte_order, ULONGEST value)
Definition: corefile.c:412
void add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:487
void sh_corefile_supply_regset(const struct regset *regset, struct regcache *regcache, int regnum, const void *regs, size_t len)
Definition: sh-tdep.c:2150
#define INT_MAX
Definition: defs.h:509
static CORE_ADDR sh_push_dummy_call_fpu(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)
Definition: sh-tdep.c:1053
static enum register_status sh_pseudo_register_read(struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, gdb_byte *buffer)
Definition: sh-tdep.c:1640
struct sh_corefile_regmap * core_fpregmap
Definition: sh-tdep.h:102
struct sh_corefile_regmap * core_gregmap
Definition: sh-tdep.h:97
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
#define IS_ADD_REG_TO_FP(x)
Definition: sh-tdep.c:531
struct ui_file * gdb_stdout
Definition: main.c:71
#define IS_RESTORE_FP(x)
Definition: sh-tdep.c:526
static struct type * sh_sh4_build_float_register_type(struct gdbarch *gdbarch, int high)
Definition: sh-tdep.c:1455
static void sh_init_flt_argreg(void)
Definition: sh-tdep.c:946
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
unsigned int offset
Definition: sh-tdep.h:89
CORE_ADDR base
Definition: sh-tdep.c:75
return_value_convention
Definition: defs.h:206
static struct value * sh_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
Definition: sh-tdep.c:1919
static const char * sh_sh_dsp_register_name(struct gdbarch *gdbarch, int reg_nr)
Definition: sh-tdep.c:279
void set_gdbarch_register_reggroup_p(struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype register_reggroup_p)
Definition: gdbarch.c:3350
#define IS_SHLL_R3(x)
Definition: sh-tdep.c:484
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
Definition: gdbarch.c:4985
static CORE_ADDR sh_frame_base_address(struct frame_info *this_frame, void **this_cache)
Definition: sh-tdep.c:1988
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
Definition: symtab.c:3882
static CORE_ADDR sh_stack_allocsize(int nargs, struct value **args)
Definition: sh-tdep.c:929
CORE_ADDR saved_regs[SH_NUM_REGS]
Definition: sh-tdep.c:83
struct reggroup *const all_reggroup
Definition: reggroups.c:296
#define _(String)
Definition: gdb_locale.h:40
size_t sizeof_fpregset
Definition: i386-tdep.h:64
const struct bfd_arch_info * bfd_arch_info
Definition: gdbarch.h:1549
void set_gdbarch_return_in_first_hidden_param_p(struct gdbarch *gdbarch, gdbarch_return_in_first_hidden_param_p_ftype return_in_first_hidden_param_p)
Definition: gdbarch.c:2573
static void sh_register_convert_to_virtual(struct gdbarch *gdbarch, int regnum, struct type *type, gdb_byte *from, gdb_byte *to)
Definition: sh-tdep.c:1549
static int regmap[]
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
Definition: gdbarch.c:1402
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1368
static const gdb_byte * sh_justify_value_in_reg(struct gdbarch *gdbarch, struct value *val, int len)
Definition: sh-tdep.c:910
static CORE_ADDR sh_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: sh-tdep.c:719
DOUBLEST extract_typed_floating(const void *addr, const struct type *type)
Definition: doublest.c:817
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:78
void floatformat_to_doublest(const struct floatformat *fmt, const void *in, DOUBLEST *out)
Definition: doublest.c:697
static const char * sh_sh3_dsp_register_name(struct gdbarch *gdbarch, int reg_nr)
Definition: sh-tdep.c:301
#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
static CORE_ADDR sh_unwind_sp(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: sh-tdep.c:1966
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep)
Definition: gdbarch.c:4933
Definition: regset.h:34
static void sh_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
Definition: sh-tdep.c:1944
static void sh_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
Definition: sh-tdep.c:2214
initialize_file_ftype _initialize_sh_tdep
#define SH_NUM_REGS
Definition: sh-tdep.c:70
#define IS_SUB_REG_FROM_SP(x)
Definition: sh-tdep.c:521
static const char * sh_sh4al_dsp_register_name(struct gdbarch *gdbarch, int reg_nr)
Definition: sh-tdep.c:398
struct reggroup *const float_reggroup
Definition: reggroups.c:293
static CORE_ADDR sh_frame_align(struct gdbarch *ignore, CORE_ADDR sp)
Definition: sh-tdep.c:851
static void sh_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, const gdb_byte *buffer)
Definition: sh-tdep.c:1679
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
Definition: frame-base.c:94
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
static int sh_use_struct_convention(int renesas_abi, struct type *type)
Definition: sh-tdep.c:806
int * from
Definition: varobj.h:282
void set_gdbarch_pseudo_register_write(struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype pseudo_register_write)
Definition: gdbarch.c:1891
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype register_type)
Definition: gdbarch.c:2151
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
LONGEST read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:311
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1329
struct reggroup *const general_reggroup
Definition: reggroups.c:292
static const char * sh_sh2a_register_name(struct gdbarch *gdbarch, int reg_nr)
Definition: sh-tdep.c:199
static const char *const sh_cc_enum[]
Definition: sh-tdep.c:62
static struct type * sh_sh3e_register_type(struct gdbarch *gdbarch, int reg_nr)
Definition: sh-tdep.c:1445
void dwarf2_frame_set_init_reg(struct gdbarch *gdbarch, void(*init_reg)(struct gdbarch *, int, struct dwarf2_frame_state_reg *, struct frame_info *))
Definition: dwarf2-frame.c:780
void initialize_file_ftype(void)
Definition: defs.h:281
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:1981
register_status
Definition: regcache.h:50
void set_gdbarch_stack_frame_destroyed_p(struct gdbarch *gdbarch, gdbarch_stack_frame_destroyed_p_ftype stack_frame_destroyed_p)
Definition: gdbarch.c:3135
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:837
struct reggroup *const system_reggroup
Definition: reggroups.c:294
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
Definition: gdbarch.c:1991
static const char * sh_sh3_register_name(struct gdbarch *gdbarch, int reg_nr)
Definition: sh-tdep.c:133
static int fv_reg_base_num(struct gdbarch *gdbarch, int fv_regnum)
Definition: sh-tdep.c:1594
struct type * register_type(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:157
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype dummy_id)
Definition: gdbarch.c:2175
static int sh_dsp_register_sim_regno(struct gdbarch *gdbarch, int nr)
Definition: sh-tdep.c:1726
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
static void set_sh_command(char *args, int from_tty)
Definition: sh-tdep.c:2427
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
int legacy_register_sim_regno(struct gdbarch *gdbarch, int regnum)
Definition: arch-utils.c:95
struct_return
Definition: arm-tdep.h:148
void set_gdbarch_believe_pcc_promotion(struct gdbarch *gdbarch, int believe_pcc_promotion)
Definition: gdbarch.c:2406
double DOUBLEST
Definition: doublest.h:24
static struct type * sh_sh4_register_type(struct gdbarch *gdbarch, int reg_nr)
Definition: sh-tdep.c:1462
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:56
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
static int sh_is_renesas_calling_convention(struct type *func_type)
Definition: sh-tdep.c:88
#define IS_ADD_IMM_FP(x)
Definition: sh-tdep.c:532
void set_gdbarch_register_sim_regno(struct gdbarch *gdbarch, gdbarch_register_sim_regno_ftype register_sim_regno)
Definition: gdbarch.c:2332
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
static int flt_argreg_array[FLOAT_ARGLAST_REGNUM-FLOAT_ARG0_REGNUM+1]
Definition: sh-tdep.c:942
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
static CORE_ADDR sh_unwind_pc(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: sh-tdep.c:1973
int default_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
Definition: frame-unwind.c:170
static const char * type
Definition: language.c:103
#define gdb_assert(expr)
Definition: gdb_assert.h:33
static enum register_status pseudo_register_read_portions(struct gdbarch *gdbarch, struct regcache *regcache, int portions, int base_regnum, gdb_byte *buffer)
Definition: sh-tdep.c:1618
static struct sh_frame_cache * sh_make_stub_cache(struct frame_info *this_frame)
Definition: sh-tdep.c:2003
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition: gdbarch.c:2117
#define min(a, b)
Definition: defs.h:106
#define GET_SOURCE_REG(x)
Definition: sh-tdep.c:457
static const char * sh_sh2a_nofpu_register_name(struct gdbarch *gdbarch, int reg_nr)
Definition: sh-tdep.c:239
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
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
#define GET_TARGET_REG(x)
Definition: sh-tdep.c:458
void( iterate_over_regset_sections_cb)(const char *sect_name, int size, const struct regset *regset, const char *human_name, void *cb_data)
Definition: gdbarch.h:98
static const char sh_cc_gcc[]
Definition: sh-tdep.c:60
struct reggroup *const vector_reggroup
Definition: reggroups.c:295
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1194
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
Definition: gdbarch.c:1534
static int sh_sh2a_register_sim_regno(struct gdbarch *gdbarch, int nr)
Definition: sh-tdep.c:1744
Definition: regdef.h:22
#define IS_ADD_IMM_SP(x)
Definition: sh-tdep.c:481
Definition: value.c:172
CORE_ADDR saved_sp
Definition: sh-tdep.c:84
const struct floatformat * floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]
Definition: gdbtypes.c:70
void sh_corefile_collect_regset(const struct regset *regset, const struct regcache *regcache, int regnum, void *regs, size_t len)
Definition: sh-tdep.c:2176
void regcache_invalidate(struct regcache *regcache, int regnum)
Definition: regcache.c:459
static const char * sh_sh2e_register_name(struct gdbarch *gdbarch, int reg_nr)
Definition: sh-tdep.c:177
static int sh_use_struct_convention_nofpu(int renesas_abi, struct type *type)
Definition: sh-tdep.c:842
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
Definition: arch-utils.c:138
bfd_byte gdb_byte
Definition: common-types.h:38
static void show_sh_command(char *args, int from_tty)
Definition: sh-tdep.c:2421
LONGEST sp_offset
Definition: sh-tdep.c:76
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1023
static enum return_value_convention sh_return_value_fpu(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: sh-tdep.c:1414
static void sh_register_convert_to_raw(struct gdbarch *gdbarch, struct type *type, int regnum, const gdb_byte *from, gdb_byte *to)
Definition: sh-tdep.c:1572
void set_gdbarch_pseudo_register_read(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype pseudo_register_read)
Definition: gdbarch.c:1843
#define TYPE_VARARGS(t)
Definition: gdbtypes.h:282
static void sh_stub_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
Definition: sh-tdep.c:2017
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
struct type * builtin_double
Definition: gdbtypes.h:1491
#define max(a, b)
Definition: defs.h:109
int gdbarch_register_reggroup_p(struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
Definition: gdbarch.c:3340
static void sh_dwarf2_frame_init_reg(struct gdbarch *gdbarch, int regnum, struct dwarf2_frame_state_reg *reg, struct frame_info *this_frame)
Definition: sh-tdep.c:1780
static struct type * sh_sh2a_register_type(struct gdbarch *gdbarch, int reg_nr)
Definition: sh-tdep.c:1431
static void sh_store_return_value_fpu(struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
Definition: sh-tdep.c:1377
CORE_ADDR pc
Definition: sh-tdep.c:77
int gdbarch_fp0_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:2032
static struct gdbarch * sh_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
Definition: sh-tdep.c:2241
static int sh_next_flt_argreg(struct gdbarch *gdbarch, int len, struct type *func_type)
Definition: sh-tdep.c:961
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
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
#define IS_RTS(x)
Definition: sh-tdep.c:527
static int in_plt_section(CORE_ADDR pc)
Definition: objfiles.h:539
#define TYPE_CALLING_CONVENTION(thistype)
Definition: gdbtypes.h:1323
static const char * sh_sh_register_name(struct gdbarch *gdbarch, int reg_nr)
Definition: sh-tdep.c:111
void set_gdbarch_int_bit(struct gdbarch *gdbarch, int int_bit)
Definition: gdbarch.c:1500
int offset
Definition: agent.c:65
static void sh_extract_return_value_fpu(struct type *type, struct regcache *regcache, gdb_byte *valbuf)
Definition: sh-tdep.c:1329
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1241
Definition: buffer.h:23
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
Definition: gdbarch.c:1926
#define IS_MOV_SP_FP(x)
Definition: sh-tdep.c:477
static void sh_extract_return_value_nofpu(struct type *type, struct regcache *regcache, gdb_byte *valbuf)
Definition: sh-tdep.c:1302
static const char * sh_sh4_nofpu_register_name(struct gdbarch *gdbarch, int reg_nr)
Definition: sh-tdep.c:362
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
size_t sizeof_gregset
Definition: i386-tdep.h:61
#define IS_JSR(x)
Definition: sh-tdep.c:461
#define IS_PUSH(x)
Definition: sh-tdep.c:473
#define FPSCR_SZ
Definition: sh-tdep.c:523
void set_gdbarch_double_format(struct gdbarch *gdbarch, const struct floatformat **double_format)
Definition: gdbarch.c:1650
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1041
static const char * sh_active_calling_convention
Definition: sh-tdep.c:68
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
static const struct frame_unwind sh_frame_unwind
Definition: sh-tdep.c:1956
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:917
#define IS_MOV_R3(x)
Definition: sh-tdep.c:483
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:169
static struct sh_frame_cache * sh_alloc_frame_cache(void)
Definition: sh-tdep.c:1825
static struct frame_id sh_dummy_id(struct gdbarch *gdbarch, struct frame_info *this_frame)
Definition: sh-tdep.c:1980
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
Definition: gdbarch.c:1667
static const char sh_cc_renesas[]
Definition: sh-tdep.c:61
struct type * value_type(const struct value *value)
Definition: value.c:1021
#define IS_MOV_FP_SP(x)
Definition: sh-tdep.c:530
void set_gdbarch_long_bit(struct gdbarch *gdbarch, int long_bit)
Definition: gdbarch.c:1517
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
Definition: gdbarch.c:2556
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition: gdbarch.c:1411
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
Definition: regcache.c:1071
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:1998
static struct sh_frame_cache * sh_frame_cache(struct frame_info *this_frame, void **this_cache)
Definition: sh-tdep.c:1852
#define IS_ADD_R3SP(x)
Definition: sh-tdep.c:488
int default_register_reggroup_p(struct gdbarch *gdbarch, int regnum, struct reggroup *group)
Definition: reggroups.c:184
static const char * sh_sh3e_register_name(struct gdbarch *gdbarch, int reg_nr)
Definition: sh-tdep.c:155
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
int int * to
Definition: varobj.h:282
#define IS_STS(x)
Definition: sh-tdep.c:465
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
Definition: gdbarch.c:1700
static int sh_stub_unwind_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
Definition: sh-tdep.c:2030
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype push_dummy_call)
Definition: gdbarch.c:2216
gdbarch_init_ftype sh64_gdbarch_init
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:321
void set_gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype iterate_over_regset_sections)
Definition: gdbarch.c:3398
static int sh_return_in_first_hidden_param_p(struct gdbarch *gdbarch, struct type *type)
Definition: sh-tdep.c:2232
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
static CORE_ADDR sh_push_dummy_call_nofpu(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)
Definition: sh-tdep.c:1195
static const char * sh_sh4_register_name(struct gdbarch *gdbarch, int reg_nr)
Definition: sh-tdep.c:324
static int sh_stack_frame_destroyed_p(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: sh-tdep.c:2060
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
static enum return_value_convention sh_return_value_nofpu(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: sh-tdep.c:1397
CORE_ADDR get_frame_func(struct frame_info *this_frame)
Definition: frame.c:920
enum dwarf2_frame_reg_rule how
Definition: dwarf2-frame.h:82
void error(const char *fmt,...)
Definition: errors.c:38
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
void store_typed_floating(void *addr, const struct type *type, DOUBLEST val)
Definition: doublest.c:830
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
long long LONGEST
Definition: common-types.h:52
#define IS_MACL_LDS(x)
Definition: sh-tdep.c:529
static const unsigned char * sh_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
Definition: sh-tdep.c:421
void set_gdbarch_print_insn(struct gdbarch *gdbarch, gdbarch_print_insn_ftype print_insn)
Definition: gdbarch.c:3067
struct type * builtin_float
Definition: gdbtypes.h:1490
struct type * builtin_int
Definition: gdbtypes.h:1483
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