gdb/sh-tdep.c

   1 /* Target-dependent code for Hitachi Super-H, for GDB.
   2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 2000 Free Software
   3    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 2 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, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 /*
  23    Contributed by Steve Chamberlain
  24    sac@cygnus.com
  25  */
  26
  27 #include "defs.h"
  28 #include "frame.h"
  29 #include "obstack.h"
  30 #include "symtab.h"
  31 #include "symfile.h"
  32 #include "gdbtypes.h"
  33 #include "gdbcmd.h"
  34 #include "gdbcore.h"
  35 #include "value.h"
  36 #include "dis-asm.h"
  37 #include "inferior.h"           /* for BEFORE_TEXT_END etc. */
  38 #include "gdb_string.h"
  39 #include "arch-utils.h"
  40 #include "floatformat.h"
  41
  42 #include "solib-svr4.h"
  43
  44 #undef XMALLOC
  45 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
  46
  47
  48 /* Frame interpretation related functions. */
  49 static gdbarch_breakpoint_from_pc_ftype sh_breakpoint_from_pc;
  50 static gdbarch_frame_chain_ftype sh_frame_chain;
  51 static gdbarch_frame_saved_pc_ftype sh_frame_saved_pc;
  52 static gdbarch_skip_prologue_ftype sh_skip_prologue;
  53
  54 static gdbarch_frame_init_saved_regs_ftype sh_nofp_frame_init_saved_regs;
  55 static gdbarch_frame_init_saved_regs_ftype sh_fp_frame_init_saved_regs;
  56 static gdbarch_init_extra_frame_info_ftype sh_init_extra_frame_info;
  57 static gdbarch_pop_frame_ftype sh_pop_frame;
  58 static gdbarch_saved_pc_after_call_ftype sh_saved_pc_after_call;
  59
  60 /* Function call related functions. */
  61 static gdbarch_extract_return_value_ftype sh_extract_return_value;
  62 static gdbarch_extract_struct_value_address_ftype sh_extract_struct_value_address;
  63 static gdbarch_use_struct_convention_ftype sh_use_struct_convention;
  64 static gdbarch_store_struct_return_ftype sh_store_struct_return;
  65 static gdbarch_push_arguments_ftype sh_push_arguments;
  66 static gdbarch_push_return_address_ftype sh_push_return_address;
  67 static gdbarch_coerce_float_to_double_ftype sh_coerce_float_to_double;
  68 static gdbarch_store_return_value_ftype sh_default_store_return_value;
  69 static gdbarch_store_return_value_ftype sh3e_sh4_store_return_value;
  70
  71 static gdbarch_register_name_ftype sh_generic_register_name;
  72 static gdbarch_register_name_ftype sh_sh_register_name;
  73 static gdbarch_register_name_ftype sh_sh3_register_name;
  74 static gdbarch_register_name_ftype sh_sh3e_register_name;
  75 static gdbarch_register_name_ftype sh_sh_dsp_register_name;
  76 static gdbarch_register_name_ftype sh_sh3_dsp_register_name;
  77
  78 /* Registers display related functions */
  79 static gdbarch_register_raw_size_ftype sh_default_register_raw_size;
  80 static gdbarch_register_raw_size_ftype sh_sh4_register_raw_size;
  81
  82 static gdbarch_register_virtual_size_ftype sh_register_virtual_size;
  83
  84 static gdbarch_register_byte_ftype sh_default_register_byte;
  85 static gdbarch_register_byte_ftype sh_sh4_register_byte;
  86
  87 static gdbarch_register_virtual_type_ftype sh_sh3e_register_virtual_type;
  88 static gdbarch_register_virtual_type_ftype sh_sh4_register_virtual_type;
  89 static gdbarch_register_virtual_type_ftype sh_default_register_virtual_type;
  90
  91 static void sh_generic_show_regs (void);
  92 static void sh3_show_regs (void);
  93 static void sh3e_show_regs (void);
  94 static void sh3_dsp_show_regs (void);
  95 static void sh_dsp_show_regs (void);
  96 static void sh4_show_regs (void);
  97 static void sh_show_regs_command (char *, int);
  98
  99 static struct type *sh_sh4_build_float_register_type (int high);
 100
 101 static gdbarch_fetch_pseudo_register_ftype sh_fetch_pseudo_register;
 102 static gdbarch_store_pseudo_register_ftype sh_store_pseudo_register;
 103 static int fv_reg_base_num (int);
 104 static int dr_reg_base_num (int);
 105 static gdbarch_do_registers_info_ftype sh_do_registers_info;
 106 static void do_fv_register_info (int fv_regnum);
 107 static void do_dr_register_info (int dr_regnum);
 108 static void sh_do_pseudo_register (int regnum);
 109 static void sh_do_fp_register (int regnum);
 110 static void sh_do_register (int regnum);
 111 static void sh_print_register (int regnum);
 112
 113 void (*sh_show_regs) (void);
 114 int (*print_sh_insn) (bfd_vma, disassemble_info*);
 115
 116 /* Define other aspects of the stack frame.
 117    we keep a copy of the worked out return pc lying around, since it
 118    is a useful bit of info */
 119
 120 struct frame_extra_info
 121 {
 122   CORE_ADDR return_pc;
 123   int leaf_function;
 124   int f_offset;
 125 };
 126
 127 #if 0
 128 #ifdef _WIN32_WCE
 129 char **sh_register_names = sh3_reg_names;
 130 #else
 131 char **sh_register_names = sh_generic_reg_names;
 132 #endif
 133 #endif
 134
 135 static char *
 136 sh_generic_register_name (int reg_nr)
 137 {
 138   static char *register_names[] =
 139   {
 140     "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 141     "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 142     "pc",   "pr",   "gbr",  "vbr",  "mach", "macl", "sr",
 143     "fpul", "fpscr",
 144     "fr0",  "fr1",  "fr2",  "fr3",  "fr4",  "fr5",  "fr6",  "fr7",
 145     "fr8",  "fr9",  "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
 146     "ssr",  "spc",
 147     "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
 148     "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
 149   };
 150   if (reg_nr < 0)
 151     return NULL;
 152   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 153     return NULL;
 154   return register_names[reg_nr];
 155 }
 156
 157 static char *
 158 sh_sh_register_name (int reg_nr)
 159 {
 160   static char *register_names[] =
 161   {
 162     "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 163     "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 164     "pc",   "pr",   "gbr",  "vbr",  "mach", "macl", "sr",
 165     "",     "",
 166     "",     "",     "",     "",     "",     "",     "",     "",
 167     "",     "",     "",     "",     "",     "",     "",     "",
 168     "",     "",
 169     "",     "",     "",     "",     "",     "",     "",     "",
 170     "",     "",     "",     "",     "",     "",     "",     "",
 171   };
 172   if (reg_nr < 0)
 173     return NULL;
 174   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 175     return NULL;
 176   return register_names[reg_nr];
 177 }
 178
 179 static char *
 180 sh_sh3_register_name (int reg_nr)
 181 {
 182   static char *register_names[] =
 183   {
 184     "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 185     "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 186     "pc",   "pr",   "gbr",  "vbr",  "mach", "macl", "sr",
 187     "",     "",
 188     "",     "",     "",     "",     "",     "",     "",     "",
 189     "",     "",     "",     "",     "",     "",     "",     "",
 190     "ssr",  "spc",
 191     "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
 192     "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1"
 193   };
 194   if (reg_nr < 0)
 195     return NULL;
 196   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 197     return NULL;
 198   return register_names[reg_nr];
 199 }
 200
 201 static char *
 202 sh_sh3e_register_name (int reg_nr)
 203 {
 204   static char *register_names[] =
 205   {
 206     "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 207     "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 208     "pc",   "pr",   "gbr",  "vbr",  "mach", "macl", "sr",
 209     "fpul", "fpscr",
 210     "fr0",  "fr1",  "fr2",  "fr3",  "fr4",  "fr5",  "fr6",  "fr7",
 211     "fr8",  "fr9",  "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
 212     "ssr",  "spc",
 213     "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
 214     "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
 215   };
 216   if (reg_nr < 0)
 217     return NULL;
 218   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 219     return NULL;
 220   return register_names[reg_nr];
 221 }
 222
 223 static char *
 224 sh_sh_dsp_register_name (int reg_nr)
 225 {
 226   static char *register_names[] =
 227   {
 228     "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 229     "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 230     "pc",   "pr",   "gbr",  "vbr",  "mach", "macl", "sr",
 231     "",     "dsr",
 232     "a0g",  "a0",   "a1g",  "a1",   "m0",   "m1",   "x0",   "x1",
 233     "y0",   "y1",   "",     "",     "",     "",     "",     "mod",
 234     "",     "",
 235     "rs",   "re",   "",     "",     "",     "",     "",     "",
 236     "",     "",     "",     "",     "",     "",     "",     "",
 237   };
 238   if (reg_nr < 0)
 239     return NULL;
 240   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 241     return NULL;
 242   return register_names[reg_nr];
 243 }
 244
 245 static char *
 246 sh_sh3_dsp_register_name (int reg_nr)
 247 {
 248   static char *register_names[] =
 249   {
 250     "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 251     "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 252     "pc",   "pr",   "gbr",  "vbr",  "mach", "macl", "sr",
 253     "",     "dsr",
 254     "a0g",  "a0",   "a1g",  "a1",   "m0",   "m1",   "x0",   "x1",
 255     "y0",   "y1",   "",     "",     "",     "",     "",     "mod",
 256     "ssr",  "spc",
 257     "rs",   "re",   "",     "",     "",     "",     "",     "",
 258     "r0b",  "r1b",  "r2b",  "r3b",  "r4b",  "r5b",  "r6b",  "r7b"
 259     "",     "",     "",     "",     "",     "",     "",     "",
 260   };
 261   if (reg_nr < 0)
 262     return NULL;
 263   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 264     return NULL;
 265   return register_names[reg_nr];
 266 }
 267
 268 static char *
 269 sh_sh4_register_name (int reg_nr)
 270 {
 271   static char *register_names[] =
 272   {
 273     /* general registers 0-15 */
 274     "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 275     "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 276     /* 16 - 22 */
 277     "pc",   "pr",   "gbr",  "vbr",  "mach", "macl", "sr",
 278     /* 23, 24 */
 279     "fpul", "fpscr",
 280     /* floating point registers 25 - 40 */
 281     "fr0",  "fr1",  "fr2",  "fr3",  "fr4",  "fr5",  "fr6",  "fr7",
 282     "fr8",  "fr9",  "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
 283     /* 41, 42 */
 284     "ssr",  "spc",
 285     /* bank 0 43 - 50 */
 286     "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
 287     /* bank 1 51 - 58 */
 288     "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
 289     /* double precision (pseudo) 59 - 66 */
 290     "dr0",  "dr2",  "dr4",  "dr6",  "dr8",  "dr10", "dr12", "dr14",
 291     /* vectors (pseudo) 67 - 70 */
 292     "fv0",  "fv4",  "fv8",  "fv12",
 293     /* FIXME: missing XF 71 - 86 */
 294     /* FIXME: missing XD 87 - 94 */
 295   };
 296   if (reg_nr < 0)
 297     return NULL;
 298   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 299     return NULL;
 300   return register_names[reg_nr];
 301 }
 302
 303 static unsigned char *
 304 sh_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 305 {
 306   /* 0xc3c3 is trapa #c3, and it works in big and little endian modes */
 307   static unsigned char breakpoint[] =  {0xc3, 0xc3};
 308
 309   *lenptr = sizeof (breakpoint);
 310   return breakpoint;
 311 }
 312
 313 /* Prologue looks like
 314    [mov.l       <regs>,@-r15]...
 315    [sts.l       pr,@-r15]
 316    [mov.l       r14,@-r15]
 317    [mov         r15,r14]
 318
 319    Actually it can be more complicated than this.  For instance, with
 320    newer gcc's:
 321
 322    mov.l   r14,@-r15
 323    add     #-12,r15
 324    mov     r15,r14
 325    mov     r4,r1
 326    mov     r5,r2
 327    mov.l   r6,@(4,r14)
 328    mov.l   r7,@(8,r14)
 329    mov.b   r1,@r14
 330    mov     r14,r1
 331    mov     r14,r1
 332    add     #2,r1
 333    mov.w   r2,@r1
 334
 335  */
 336
 337 /* STS.L PR,@-r15  0100111100100010
 338    r15-4-->r15, PR-->(r15) */
 339 #define IS_STS(x)               ((x) == 0x4f22)
 340
 341 /* MOV.L Rm,@-r15  00101111mmmm0110
 342    r15-4-->r15, Rm-->(R15) */
 343 #define IS_PUSH(x)              (((x) & 0xff0f) == 0x2f06)
 344
 345 #define GET_PUSHED_REG(x)       (((x) >> 4) & 0xf)
 346
 347 /* MOV r15,r14     0110111011110011
 348    r15-->r14  */
 349 #define IS_MOV_SP_FP(x)         ((x) == 0x6ef3)
 350
 351 /* ADD #imm,r15    01111111iiiiiiii
 352    r15+imm-->r15 */
 353 #define IS_ADD_SP(x)            (((x) & 0xff00) == 0x7f00)
 354
 355 #define IS_MOV_R3(x)            (((x) & 0xff00) == 0x1a00)
 356 #define IS_SHLL_R3(x)           ((x) == 0x4300)
 357
 358 /* ADD r3,r15      0011111100111100
 359    r15+r3-->r15 */
 360 #define IS_ADD_R3SP(x)          ((x) == 0x3f3c)
 361
 362 /* FMOV.S FRm,@-Rn  Rn-4-->Rn, FRm-->(Rn)     1111nnnnmmmm1011
 363    FMOV DRm,@-Rn    Rn-8-->Rn, DRm-->(Rn)     1111nnnnmmm01011
 364    FMOV XDm,@-Rn    Rn-8-->Rn, XDm-->(Rn)     1111nnnnmmm11011 */
 365 #define IS_FMOV(x)              (((x) & 0xf00f) == 0xf00b)
 366
 367 /* MOV Rm,Rn            Rm-->Rn          0110nnnnmmmm0011
 368    MOV.L Rm,@(disp,Rn)  Rm-->(dispx4+Rn) 0001nnnnmmmmdddd
 369    MOV.L Rm,@Rn         Rm-->(Rn)        0010nnnnmmmm0010
 370    where Rm is one of r4,r5,r6,r7 which are the argument registers. */
 371 #define IS_ARG_MOV(x) \
 372 (((((x) & 0xf00f) == 0x6003) && (((x) & 0x00f0) >= 0x0040 && ((x) & 0x00f0) <= 0x0070)) \
 373  || ((((x) & 0xf000) == 0x1000) && (((x) & 0x00f0) >= 0x0040 && ((x) & 0x00f0) <= 0x0070)) \
 374  || ((((x) & 0xf00f) == 0x2002) && (((x) & 0x00f0) >= 0x0040 && ((x) & 0x00f0) <= 0x0070)))
 375
 376 /* MOV.L Rm,@(disp,r14)  00011110mmmmdddd
 377    Rm-->(dispx4+r14) where Rm is one of r4,r5,r6,r7 */
 378 #define IS_MOV_R14(x) \
 379      ((((x) & 0xff00) == 0x1e) && (((x) & 0x00f0) >= 0x0040 && ((x) & 0x00f0) <= 0x0070))
 380
 381 #define FPSCR_SZ                (1 << 20)
 382
 383 /* Skip any prologue before the guts of a function */
 384
 385 /* Skip the prologue using the debug information. If this fails we'll
 386    fall back on the 'guess' method below. */
 387 static CORE_ADDR
 388 after_prologue (CORE_ADDR pc)
 389 {
 390   struct symtab_and_line sal;
 391   CORE_ADDR func_addr, func_end;
 392
 393   /* If we can not find the symbol in the partial symbol table, then
 394      there is no hope we can determine the function's start address
 395      with this code.  */
 396   if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 397     return 0;
 398
 399   /* Get the line associated with FUNC_ADDR.  */
 400   sal = find_pc_line (func_addr, 0);
 401
 402   /* There are only two cases to consider.  First, the end of the source line
 403      is within the function bounds.  In that case we return the end of the
 404      source line.  Second is the end of the source line extends beyond the
 405      bounds of the current function.  We need to use the slow code to
 406      examine instructions in that case.  */
 407   if (sal.end < func_end)
 408     return sal.end;
 409   else
 410     return 0;
 411 }
 412
 413 /* Here we look at each instruction in the function, and try to guess
 414    where the prologue ends. Unfortunately this is not always
 415    accurate. */
 416 static CORE_ADDR
 417 skip_prologue_hard_way (CORE_ADDR start_pc)
 418 {
 419   CORE_ADDR here, end;
 420   int updated_fp = 0;
 421
 422   if (!start_pc)
 423     return 0;
 424
 425   for (here = start_pc, end = start_pc + (2 * 28); here < end;)
 426     {
 427       int w = read_memory_integer (here, 2);
 428       here += 2;
 429       if (IS_FMOV (w) || IS_PUSH (w) || IS_STS (w) || IS_MOV_R3 (w)
 430           || IS_ADD_R3SP (w) || IS_ADD_SP (w) || IS_SHLL_R3 (w)
 431           || IS_ARG_MOV (w) || IS_MOV_R14 (w))
 432         {
 433           start_pc = here;
 434         }
 435       else if (IS_MOV_SP_FP (w))
 436         {
 437           start_pc = here;
 438           updated_fp = 1;
 439         }
 440       else
 441         /* Don't bail out yet, if we are before the copy of sp. */
 442         if (updated_fp)
 443           break;
 444     }
 445
 446   return start_pc;
 447 }
 448
 449 static CORE_ADDR
 450 sh_skip_prologue (CORE_ADDR pc)
 451 {
 452   CORE_ADDR post_prologue_pc;
 453
 454   /* See if we can determine the end of the prologue via the symbol table.
 455      If so, then return either PC, or the PC after the prologue, whichever
 456      is greater.  */
 457
 458   post_prologue_pc = after_prologue (pc);
 459
 460   /* If after_prologue returned a useful address, then use it.  Else
 461      fall back on the instruction skipping code. */
 462   if (post_prologue_pc != 0)
 463     return max (pc, post_prologue_pc);
 464   else
 465     return (skip_prologue_hard_way (pc));
 466 }
 467
 468 /* Immediately after a function call, return the saved pc.
 469    Can't always go through the frames for this because on some machines
 470    the new frame is not set up until the new function executes
 471    some instructions.
 472
 473    The return address is the value saved in the PR register + 4  */
 474 static CORE_ADDR
 475 sh_saved_pc_after_call (struct frame_info *frame)
 476 {
 477   return (ADDR_BITS_REMOVE(read_register(PR_REGNUM)));
 478 }
 479
 480 /* Should call_function allocate stack space for a struct return?  */
 481 static int
 482 sh_use_struct_convention (int gcc_p, struct type *type)
 483 {
 484   return (TYPE_LENGTH (type) > 1);
 485 }
 486
 487 /* Store the address of the place in which to copy the structure the
 488    subroutine will return.  This is called from call_function.
 489
 490    We store structs through a pointer passed in R0 */
 491 static void
 492 sh_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
 493 {
 494   write_register (STRUCT_RETURN_REGNUM, (addr));
 495 }
 496
 497 /* Disassemble an instruction.  */
 498 static int
 499 gdb_print_insn_sh (bfd_vma memaddr, disassemble_info *info)
 500 {
 501   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 502     return print_insn_sh (memaddr, info);
 503   else
 504     return print_insn_shl (memaddr, info);
 505 }
 506
 507 /* Given a GDB frame, determine the address of the calling function's frame.
 508    This will be used to create a new GDB frame struct, and then
 509    INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
 510
 511    For us, the frame address is its stack pointer value, so we look up
 512    the function prologue to determine the caller's sp value, and return it.  */
 513 static CORE_ADDR
 514 sh_frame_chain (struct frame_info *frame)
 515 {
 516   if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
 517     return frame->frame;        /* dummy frame same as caller's frame */
 518   if (frame->pc && !inside_entry_file (frame->pc))
 519     return read_memory_integer (FRAME_FP (frame) + frame->extra_info->f_offset, 4);
 520   else
 521     return 0;
 522 }
 523
 524 /* Find REGNUM on the stack.  Otherwise, it's in an active register.  One thing
 525    we might want to do here is to check REGNUM against the clobber mask, and
 526    somehow flag it as invalid if it isn't saved on the stack somewhere.  This
 527    would provide a graceful failure mode when trying to get the value of
 528    caller-saves registers for an inner frame.  */
 529
 530 static CORE_ADDR
 531 sh_find_callers_reg (struct frame_info *fi, int regnum)
 532 {
 533   for (; fi; fi = fi->next)
 534     if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
 535       /* When the caller requests PR from the dummy frame, we return PC because
 536          that's where the previous routine appears to have done a call from. */
 537       return generic_read_register_dummy (fi->pc, fi->frame, regnum);
 538     else
 539       {
 540         FRAME_INIT_SAVED_REGS (fi);
 541         if (!fi->pc)
 542           return 0;
 543         if (fi->saved_regs[regnum] != 0)
 544           return read_memory_integer (fi->saved_regs[regnum],
 545                                       REGISTER_RAW_SIZE (regnum));
 546       }
 547   return read_register (regnum);
 548 }
 549
 550 /* Put here the code to store, into a struct frame_saved_regs, the
 551    addresses of the saved registers of frame described by FRAME_INFO.
 552    This includes special registers such as pc and fp saved in special
 553    ways in the stack frame.  sp is even more special: the address we
 554    return for it IS the sp for the next frame. */
 555 static void
 556 sh_nofp_frame_init_saved_regs (struct frame_info *fi)
 557 {
 558   int where[NUM_REGS];
 559   int rn;
 560   int have_fp = 0;
 561   int depth;
 562   int pc;
 563   int opc;
 564   int insn;
 565   int r3_val = 0;
 566   char *dummy_regs = generic_find_dummy_frame (fi->pc, fi->frame);
 567
 568   if (fi->saved_regs == NULL)
 569     frame_saved_regs_zalloc (fi);
 570   else
 571     memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
 572
 573   if (dummy_regs)
 574     {
 575       /* DANGER!  This is ONLY going to work if the char buffer format of
 576          the saved registers is byte-for-byte identical to the
 577          CORE_ADDR regs[NUM_REGS] format used by struct frame_saved_regs! */
 578       memcpy (fi->saved_regs, dummy_regs, sizeof (fi->saved_regs));
 579       return;
 580     }
 581
 582   fi->extra_info->leaf_function = 1;
 583   fi->extra_info->f_offset = 0;
 584
 585   for (rn = 0; rn < NUM_REGS; rn++)
 586     where[rn] = -1;
 587
 588   depth = 0;
 589
 590   /* Loop around examining the prologue insns until we find something
 591      that does not appear to be part of the prologue.  But give up
 592      after 20 of them, since we're getting silly then. */
 593
 594   pc = get_pc_function_start (fi->pc);
 595   if (!pc)
 596     {
 597       fi->pc = 0;
 598       return;
 599     }
 600
 601   for (opc = pc + (2 * 28); pc < opc; pc += 2)
 602     {
 603       insn = read_memory_integer (pc, 2);
 604       /* See where the registers will be saved to */
 605       if (IS_PUSH (insn))
 606         {
 607           rn = GET_PUSHED_REG (insn);
 608           where[rn] = depth;
 609           depth += 4;
 610         }
 611       else if (IS_STS (insn))
 612         {
 613           where[PR_REGNUM] = depth;
 614           /* If we're storing the pr then this isn't a leaf */
 615           fi->extra_info->leaf_function = 0;
 616           depth += 4;
 617         }
 618       else if (IS_MOV_R3 (insn))
 619         {
 620           r3_val = ((insn & 0xff) ^ 0x80) - 0x80;
 621         }
 622       else if (IS_SHLL_R3 (insn))
 623         {
 624           r3_val <<= 1;
 625         }
 626       else if (IS_ADD_R3SP (insn))
 627         {
 628           depth += -r3_val;
 629         }
 630       else if (IS_ADD_SP (insn))
 631         {
 632           depth -= ((insn & 0xff) ^ 0x80) - 0x80;
 633         }
 634       else if (IS_MOV_SP_FP (insn))
 635         break;
 636 #if 0 /* This used to just stop when it found an instruction that
 637          was not considered part of the prologue.  Now, we just
 638          keep going looking for likely instructions. */
 639       else
 640         break;
 641 #endif
 642     }
 643
 644   /* Now we know how deep things are, we can work out their addresses */
 645
 646   for (rn = 0; rn < NUM_REGS; rn++)
 647     {
 648       if (where[rn] >= 0)
 649         {
 650           if (rn == FP_REGNUM)
 651             have_fp = 1;
 652
 653           fi->saved_regs[rn] = fi->frame - where[rn] + depth - 4;
 654         }
 655       else
 656         {
 657           fi->saved_regs[rn] = 0;
 658         }
 659     }
 660
 661   if (have_fp)
 662     {
 663       fi->saved_regs[SP_REGNUM] = read_memory_integer (fi->saved_regs[FP_REGNUM], 4);
 664     }
 665   else
 666     {
 667       fi->saved_regs[SP_REGNUM] = fi->frame - 4;
 668     }
 669
 670   fi->extra_info->f_offset = depth - where[FP_REGNUM] - 4;
 671   /* Work out the return pc - either from the saved pr or the pr
 672      value */
 673 }
 674
 675 static void
 676 sh_fp_frame_init_saved_regs (struct frame_info *fi)
 677 {
 678   int where[NUM_REGS];
 679   int rn;
 680   int have_fp = 0;
 681   int depth;
 682   int pc;
 683   int opc;
 684   int insn;
 685   int r3_val = 0;
 686   char *dummy_regs = generic_find_dummy_frame (fi->pc, fi->frame);
 687
 688   if (fi->saved_regs == NULL)
 689     frame_saved_regs_zalloc (fi);
 690   else
 691     memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
 692
 693   if (dummy_regs)
 694     {
 695       /* DANGER!  This is ONLY going to work if the char buffer format of
 696          the saved registers is byte-for-byte identical to the
 697          CORE_ADDR regs[NUM_REGS] format used by struct frame_saved_regs! */
 698       memcpy (fi->saved_regs, dummy_regs, sizeof (fi->saved_regs));
 699       return;
 700     }
 701
 702   fi->extra_info->leaf_function = 1;
 703   fi->extra_info->f_offset = 0;
 704
 705   for (rn = 0; rn < NUM_REGS; rn++)
 706     where[rn] = -1;
 707
 708   depth = 0;
 709
 710   /* Loop around examining the prologue insns until we find something
 711      that does not appear to be part of the prologue.  But give up
 712      after 20 of them, since we're getting silly then. */
 713
 714   pc = get_pc_function_start (fi->pc);
 715   if (!pc)
 716     {
 717       fi->pc = 0;
 718       return;
 719     }
 720
 721   for (opc = pc + (2 * 28); pc < opc; pc += 2)
 722     {
 723       insn = read_memory_integer (pc, 2);
 724       /* See where the registers will be saved to */
 725       if (IS_PUSH (insn))
 726         {
 727           rn = GET_PUSHED_REG (insn);
 728           where[rn] = depth;
 729           depth += 4;
 730         }
 731       else if (IS_STS (insn))
 732         {
 733           where[PR_REGNUM] = depth;
 734           /* If we're storing the pr then this isn't a leaf */
 735           fi->extra_info->leaf_function = 0;
 736           depth += 4;
 737         }
 738       else if (IS_MOV_R3 (insn))
 739         {
 740           r3_val = ((insn & 0xff) ^ 0x80) - 0x80;
 741         }
 742       else if (IS_SHLL_R3 (insn))
 743         {
 744           r3_val <<= 1;
 745         }
 746       else if (IS_ADD_R3SP (insn))
 747         {
 748           depth += -r3_val;
 749         }
 750       else if (IS_ADD_SP (insn))
 751         {
 752           depth -= ((insn & 0xff) ^ 0x80) - 0x80;
 753         }
 754       else if (IS_FMOV (insn))
 755         {
 756           if (read_register (gdbarch_tdep (current_gdbarch)->FPSCR_REGNUM) & FPSCR_SZ)
 757             {
 758               depth += 8;
 759             }
 760           else
 761             {
 762               depth += 4;
 763             }
 764         }
 765       else if (IS_MOV_SP_FP (insn))
 766         break;
 767 #if 0 /* This used to just stop when it found an instruction that
 768          was not considered part of the prologue.  Now, we just
 769          keep going looking for likely instructions. */
 770       else
 771         break;
 772 #endif
 773     }
 774
 775   /* Now we know how deep things are, we can work out their addresses */
 776
 777   for (rn = 0; rn < NUM_REGS; rn++)
 778     {
 779       if (where[rn] >= 0)
 780         {
 781           if (rn == FP_REGNUM)
 782             have_fp = 1;
 783
 784           fi->saved_regs[rn] = fi->frame - where[rn] + depth - 4;
 785         }
 786       else
 787         {
 788           fi->saved_regs[rn] = 0;
 789         }
 790     }
 791
 792   if (have_fp)
 793     {
 794       fi->saved_regs[SP_REGNUM] = read_memory_integer (fi->saved_regs[FP_REGNUM], 4);
 795     }
 796   else
 797     {
 798       fi->saved_regs[SP_REGNUM] = fi->frame - 4;
 799     }
 800
 801   fi->extra_info->f_offset = depth - where[FP_REGNUM] - 4;
 802   /* Work out the return pc - either from the saved pr or the pr
 803      value */
 804 }
 805
 806 /* Initialize the extra info saved in a FRAME */
 807 static void
 808 sh_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 809 {
 810
 811   fi->extra_info = (struct frame_extra_info *)
 812     frame_obstack_alloc (sizeof (struct frame_extra_info));
 813
 814   if (fi->next)
 815     fi->pc = FRAME_SAVED_PC (fi->next);
 816
 817   if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
 818     {
 819       /* We need to setup fi->frame here because run_stack_dummy gets it wrong
 820          by assuming it's always FP.  */
 821       fi->frame = generic_read_register_dummy (fi->pc, fi->frame,
 822                                                SP_REGNUM);
 823       fi->extra_info->return_pc = generic_read_register_dummy (fi->pc, fi->frame,
 824                                                                PC_REGNUM);
 825       fi->extra_info->f_offset = -(CALL_DUMMY_LENGTH + 4);
 826       fi->extra_info->leaf_function = 0;
 827       return;
 828     }
 829   else
 830     {
 831       FRAME_INIT_SAVED_REGS (fi);
 832       fi->extra_info->return_pc = sh_find_callers_reg (fi, PR_REGNUM);
 833     }
 834 }
 835
 836 /* Extract from an array REGBUF containing the (raw) register state
 837    the address in which a function should return its structure value,
 838    as a CORE_ADDR (or an expression that can be used as one).  */
 839 static CORE_ADDR
 840 sh_extract_struct_value_address (char *regbuf)
 841 {
 842   return (extract_address ((regbuf), REGISTER_RAW_SIZE (0)));
 843 }
 844
 845 static CORE_ADDR
 846 sh_frame_saved_pc (struct frame_info *frame)
 847 {
 848   return ((frame)->extra_info->return_pc);
 849 }
 850
 851 /* Discard from the stack the innermost frame,
 852    restoring all saved registers.  */
 853 static void
 854 sh_pop_frame (void)
 855 {
 856   register struct frame_info *frame = get_current_frame ();
 857   register CORE_ADDR fp;
 858   register int regnum;
 859
 860   if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
 861     generic_pop_dummy_frame ();
 862   else
 863     {
 864       fp = FRAME_FP (frame);
 865       FRAME_INIT_SAVED_REGS (frame);
 866
 867       /* Copy regs from where they were saved in the frame */
 868       for (regnum = 0; regnum < NUM_REGS; regnum++)
 869         if (frame->saved_regs[regnum])
 870           write_register (regnum, read_memory_integer (frame->saved_regs[regnum], 4));
 871
 872       write_register (PC_REGNUM, frame->extra_info->return_pc);
 873       write_register (SP_REGNUM, fp + 4);
 874     }
 875   flush_cached_frames ();
 876 }
 877
 878 /* Function: push_arguments
 879    Setup the function arguments for calling a function in the inferior.
 880
 881    On the Hitachi SH architecture, there are four registers (R4 to R7)
 882    which are dedicated for passing function arguments.  Up to the first
 883    four arguments (depending on size) may go into these registers.
 884    The rest go on the stack.
 885
 886    Arguments that are smaller than 4 bytes will still take up a whole
 887    register or a whole 32-bit word on the stack, and will be
 888    right-justified in the register or the stack word.  This includes
 889    chars, shorts, and small aggregate types.
 890
 891    Arguments that are larger than 4 bytes may be split between two or
 892    more registers.  If there are not enough registers free, an argument
 893    may be passed partly in a register (or registers), and partly on the
 894    stack.  This includes doubles, long longs, and larger aggregates.
 895    As far as I know, there is no upper limit to the size of aggregates
 896    that will be passed in this way; in other words, the convention of
 897    passing a pointer to a large aggregate instead of a copy is not used.
 898
 899    An exceptional case exists for struct arguments (and possibly other
 900    aggregates such as arrays) if the size is larger than 4 bytes but
 901    not a multiple of 4 bytes.  In this case the argument is never split
 902    between the registers and the stack, but instead is copied in its
 903    entirety onto the stack, AND also copied into as many registers as
 904    there is room for.  In other words, space in registers permitting,
 905    two copies of the same argument are passed in.  As far as I can tell,
 906    only the one on the stack is used, although that may be a function
 907    of the level of compiler optimization.  I suspect this is a compiler
 908    bug.  Arguments of these odd sizes are left-justified within the
 909    word (as opposed to arguments smaller than 4 bytes, which are
 910    right-justified).
 911
 912    If the function is to return an aggregate type such as a struct, it
 913    is either returned in the normal return value register R0 (if its
 914    size is no greater than one byte), or else the caller must allocate
 915    space into which the callee will copy the return value (if the size
 916    is greater than one byte).  In this case, a pointer to the return
 917    value location is passed into the callee in register R2, which does
 918    not displace any of the other arguments passed in via registers R4
 919    to R7.   */
 920
 921 static CORE_ADDR
 922 sh_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 923                    int struct_return, CORE_ADDR struct_addr)
 924 {
 925   int stack_offset, stack_alloc;
 926   int argreg;
 927   int argnum;
 928   struct type *type;
 929   CORE_ADDR regval;
 930   char *val;
 931   char valbuf[4];
 932   int len;
 933   int odd_sized_struct;
 934
 935   /* first force sp to a 4-byte alignment */
 936   sp = sp & ~3;
 937
 938   /* The "struct return pointer" pseudo-argument has its own dedicated
 939      register */
 940   if (struct_return)
 941     write_register (STRUCT_RETURN_REGNUM, struct_addr);
 942
 943   /* Now make sure there's space on the stack */
 944   for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)
 945     stack_alloc += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3);
 946   sp -= stack_alloc;            /* make room on stack for args */
 947
 948   /* Now load as many as possible of the first arguments into
 949      registers, and push the rest onto the stack.  There are 16 bytes
 950      in four registers available.  Loop thru args from first to last.  */
 951
 952   argreg = ARG0_REGNUM;
 953   for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
 954     {
 955       type = VALUE_TYPE (args[argnum]);
 956       len = TYPE_LENGTH (type);
 957       memset (valbuf, 0, sizeof (valbuf));
 958       if (len < 4)
 959         {
 960           /* value gets right-justified in the register or stack word */
 961           memcpy (valbuf + (4 - len),
 962                   (char *) VALUE_CONTENTS (args[argnum]), len);
 963           val = valbuf;
 964         }
 965       else
 966         val = (char *) VALUE_CONTENTS (args[argnum]);
 967
 968       if (len > 4 && (len & 3) != 0)
 969         odd_sized_struct = 1;   /* such structs go entirely on stack */
 970       else
 971         odd_sized_struct = 0;
 972       while (len > 0)
 973         {
 974           if (argreg > ARGLAST_REGNUM || odd_sized_struct)
 975             {                   /* must go on the stack */
 976               write_memory (sp + stack_offset, val, 4);
 977               stack_offset += 4;
 978             }
 979           /* NOTE WELL!!!!!  This is not an "else if" clause!!!
 980              That's because some *&^%$ things get passed on the stack
 981              AND in the registers!   */
 982           if (argreg <= ARGLAST_REGNUM)
 983             {                   /* there's room in a register */
 984               regval = extract_address (val, REGISTER_RAW_SIZE (argreg));
 985               write_register (argreg++, regval);
 986             }
 987           /* Store the value 4 bytes at a time.  This means that things
 988              larger than 4 bytes may go partly in registers and partly
 989              on the stack.  */
 990           len -= REGISTER_RAW_SIZE (argreg);
 991           val += REGISTER_RAW_SIZE (argreg);
 992         }
 993     }
 994   return sp;
 995 }
 996
 997 /* Function: push_return_address (pc)
 998    Set up the return address for the inferior function call.
 999    Needed for targets where we don't actually execute a JSR/BSR instruction */
1000
1001 static CORE_ADDR
1002 sh_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
1003 {
1004   write_register (PR_REGNUM, CALL_DUMMY_ADDRESS ());
1005   return sp;
1006 }
1007
1008 /* Function: fix_call_dummy
1009    Poke the callee function's address into the destination part of
1010    the CALL_DUMMY.  The address is actually stored in a data word
1011    following the actualy CALL_DUMMY instructions, which will load
1012    it into a register using PC-relative addressing.  This function
1013    expects the CALL_DUMMY to look like this:
1014
1015    mov.w @(2,PC), R8
1016    jsr   @R8
1017    nop
1018    trap
1019    <destination>
1020  */
1021
1022 #if 0
1023 void
1024 sh_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
1025                    value_ptr *args, struct type *type, int gcc_p)
1026 {
1027   *(unsigned long *) (dummy + 8) = fun;
1028 }
1029 #endif
1030
1031 static int
1032 sh_coerce_float_to_double (struct type *formal, struct type *actual)
1033 {
1034   return 1;
1035 }
1036
1037 /* Find a function's return value in the appropriate registers (in
1038    regbuf), and copy it into valbuf.  Extract from an array REGBUF
1039    containing the (raw) register state a function return value of type
1040    TYPE, and copy that, in virtual format, into VALBUF.  */
1041 static void
1042 sh_extract_return_value (struct type *type, char *regbuf, char *valbuf)
1043 {
1044   int len = TYPE_LENGTH (type);
1045
1046   if (len <= 4)
1047     memcpy (valbuf, ((char *) regbuf) + 4 - len, len);
1048   else if (len <= 8)
1049     memcpy (valbuf, ((char *) regbuf) + 8 - len, len);
1050   else
1051     error ("bad size for return value");
1052 }
1053
1054 /* Write into appropriate registers a function return value
1055    of type TYPE, given in virtual format.
1056    If the architecture is sh4 or sh3e, store a function's return value
1057    in the R0 general register or in the FP0 floating point register,
1058    depending on the type of the return value. In all the other cases
1059    the result is stored in r0. */
1060 static void
1061 sh_default_store_return_value (struct type *type, char *valbuf)
1062 {
1063   char buf[32]; /* more than enough... */
1064
1065   if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (R0_REGNUM))
1066     {
1067       /* Add leading zeros to the value. */
1068       memset (buf, 0, REGISTER_RAW_SIZE (R0_REGNUM));
1069       memcpy (buf + REGISTER_RAW_SIZE (R0_REGNUM) - TYPE_LENGTH (type),
1070               valbuf, TYPE_LENGTH (type));
1071       write_register_bytes (REGISTER_BYTE (R0_REGNUM), buf,
1072                             REGISTER_RAW_SIZE (R0_REGNUM));
1073     }
1074   else
1075     write_register_bytes (REGISTER_BYTE (R0_REGNUM), valbuf,
1076                           TYPE_LENGTH (type));
1077 }
1078
1079 static void
1080 sh3e_sh4_store_return_value (struct type *type, char *valbuf)
1081 {
1082   if (TYPE_CODE (type) == TYPE_CODE_FLT)
1083     write_register_bytes (REGISTER_BYTE (FP0_REGNUM),
1084                           valbuf, TYPE_LENGTH (type));
1085   else
1086     sh_default_store_return_value (type, valbuf);
1087 }
1088
1089
1090 /* Print the registers in a form similar to the E7000 */
1091
1092 static void
1093 sh_generic_show_regs (void)
1094 {
1095   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1096                    paddr (read_register (PC_REGNUM)),
1097                    (long) read_register (gdbarch_tdep (current_gdbarch)->SR_REGNUM),
1098                    (long) read_register (PR_REGNUM),
1099                    (long) read_register (MACH_REGNUM),
1100                    (long) read_register (MACL_REGNUM));
1101
1102   printf_filtered ("GBR=%08lx VBR=%08lx",
1103                    (long) read_register (GBR_REGNUM),
1104                    (long) read_register (VBR_REGNUM));
1105
1106   printf_filtered ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1107                    (long) read_register (0),
1108                    (long) read_register (1),
1109                    (long) read_register (2),
1110                    (long) read_register (3),
1111                    (long) read_register (4),
1112                    (long) read_register (5),
1113                    (long) read_register (6),
1114                    (long) read_register (7));
1115   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1116                    (long) read_register (8),
1117                    (long) read_register (9),
1118                    (long) read_register (10),
1119                    (long) read_register (11),
1120                    (long) read_register (12),
1121                    (long) read_register (13),
1122                    (long) read_register (14),
1123                    (long) read_register (15));
1124 }
1125
1126 static void
1127 sh3_show_regs (void)
1128 {
1129   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1130                    paddr (read_register (PC_REGNUM)),
1131                    (long) read_register (gdbarch_tdep (current_gdbarch)->SR_REGNUM),
1132                    (long) read_register (PR_REGNUM),
1133                    (long) read_register (MACH_REGNUM),
1134                    (long) read_register (MACL_REGNUM));
1135
1136   printf_filtered ("GBR=%08lx VBR=%08lx",
1137                    (long) read_register (GBR_REGNUM),
1138                    (long) read_register (VBR_REGNUM));
1139   printf_filtered (" SSR=%08lx SPC=%08lx",
1140                    (long) read_register (gdbarch_tdep (current_gdbarch)->SSR_REGNUM),
1141                    (long) read_register (gdbarch_tdep (current_gdbarch)->SPC_REGNUM));
1142
1143   printf_filtered ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1144                    (long) read_register (0),
1145                    (long) read_register (1),
1146                    (long) read_register (2),
1147                    (long) read_register (3),
1148                    (long) read_register (4),
1149                    (long) read_register (5),
1150                    (long) read_register (6),
1151                    (long) read_register (7));
1152   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1153                    (long) read_register (8),
1154                    (long) read_register (9),
1155                    (long) read_register (10),
1156                    (long) read_register (11),
1157                    (long) read_register (12),
1158                    (long) read_register (13),
1159                    (long) read_register (14),
1160                    (long) read_register (15));
1161 }
1162
1163
1164 static void
1165 sh3e_show_regs (void)
1166 {
1167   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1168                    paddr (read_register (PC_REGNUM)),
1169                    (long) read_register (gdbarch_tdep (current_gdbarch)->SR_REGNUM),
1170                    (long) read_register (PR_REGNUM),
1171                    (long) read_register (MACH_REGNUM),
1172                    (long) read_register (MACL_REGNUM));
1173
1174   printf_filtered ("GBR=%08lx VBR=%08lx",
1175                    (long) read_register (GBR_REGNUM),
1176                    (long) read_register (VBR_REGNUM));
1177   printf_filtered (" SSR=%08lx SPC=%08lx",
1178                    (long) read_register (gdbarch_tdep (current_gdbarch)->SSR_REGNUM),
1179                    (long) read_register (gdbarch_tdep (current_gdbarch)->SPC_REGNUM));
1180   printf_filtered (" FPUL=%08lx FPSCR=%08lx",
1181                    (long) read_register (gdbarch_tdep (current_gdbarch)->FPUL_REGNUM),
1182                    (long) read_register (gdbarch_tdep (current_gdbarch)->FPSCR_REGNUM));
1183
1184   printf_filtered ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1185                    (long) read_register (0),
1186                    (long) read_register (1),
1187                    (long) read_register (2),
1188                    (long) read_register (3),
1189                    (long) read_register (4),
1190                    (long) read_register (5),
1191                    (long) read_register (6),
1192                    (long) read_register (7));
1193   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1194                    (long) read_register (8),
1195                    (long) read_register (9),
1196                    (long) read_register (10),
1197                    (long) read_register (11),
1198                    (long) read_register (12),
1199                    (long) read_register (13),
1200                    (long) read_register (14),
1201                    (long) read_register (15));
1202
1203   printf_filtered (("FP0-FP7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
1204                    (long) read_register (FP0_REGNUM + 0),
1205                    (long) read_register (FP0_REGNUM + 1),
1206                    (long) read_register (FP0_REGNUM + 2),
1207                    (long) read_register (FP0_REGNUM + 3),
1208                    (long) read_register (FP0_REGNUM + 4),
1209                    (long) read_register (FP0_REGNUM + 5),
1210                    (long) read_register (FP0_REGNUM + 6),
1211                    (long) read_register (FP0_REGNUM + 7));
1212   printf_filtered (("FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
1213                    (long) read_register (FP0_REGNUM + 8),
1214                    (long) read_register (FP0_REGNUM + 9),
1215                    (long) read_register (FP0_REGNUM + 10),
1216                    (long) read_register (FP0_REGNUM + 11),
1217                    (long) read_register (FP0_REGNUM + 12),
1218                    (long) read_register (FP0_REGNUM + 13),
1219                    (long) read_register (FP0_REGNUM + 14),
1220                    (long) read_register (FP0_REGNUM + 15));
1221 }
1222
1223 static void
1224 sh3_dsp_show_regs (void)
1225 {
1226   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1227                    paddr (read_register (PC_REGNUM)),
1228                    (long) read_register (gdbarch_tdep (current_gdbarch)->SR_REGNUM),
1229                    (long) read_register (PR_REGNUM),
1230                    (long) read_register (MACH_REGNUM),
1231                    (long) read_register (MACL_REGNUM));
1232
1233   printf_filtered ("GBR=%08lx VBR=%08lx",
1234                    (long) read_register (GBR_REGNUM),
1235                    (long) read_register (VBR_REGNUM));
1236
1237   printf_filtered (" SSR=%08lx SPC=%08lx",
1238                    (long) read_register (gdbarch_tdep (current_gdbarch)->SSR_REGNUM),
1239                    (long) read_register (gdbarch_tdep (current_gdbarch)->SPC_REGNUM));
1240
1241   printf_filtered (" DSR=%08lx",
1242                    (long) read_register (gdbarch_tdep (current_gdbarch)->DSR_REGNUM));
1243
1244   printf_filtered ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1245                    (long) read_register (0),
1246                    (long) read_register (1),
1247                    (long) read_register (2),
1248                    (long) read_register (3),
1249                    (long) read_register (4),
1250                    (long) read_register (5),
1251                    (long) read_register (6),
1252                    (long) read_register (7));
1253   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1254                    (long) read_register (8),
1255                    (long) read_register (9),
1256                    (long) read_register (10),
1257                    (long) read_register (11),
1258                    (long) read_register (12),
1259                    (long) read_register (13),
1260                    (long) read_register (14),
1261                    (long) read_register (15));
1262
1263   printf_filtered ("A0G=%02lx A0=%08lx M0=%08lx X0=%08lx Y0=%08lx RS=%08lx MOD=%08lx\n",
1264                    (long) read_register (gdbarch_tdep (current_gdbarch)->A0G_REGNUM) & 0xff,
1265                    (long) read_register (gdbarch_tdep (current_gdbarch)->A0_REGNUM),
1266                    (long) read_register (gdbarch_tdep (current_gdbarch)->M0_REGNUM),
1267                    (long) read_register (gdbarch_tdep (current_gdbarch)->X0_REGNUM),
1268                    (long) read_register (gdbarch_tdep (current_gdbarch)->Y0_REGNUM),
1269                    (long) read_register (gdbarch_tdep (current_gdbarch)->RS_REGNUM),
1270                    (long) read_register (gdbarch_tdep (current_gdbarch)->MOD_REGNUM));
1271   printf_filtered ("A1G=%02lx A1=%08lx M1=%08lx X1=%08lx Y1=%08lx RE=%08lx\n",
1272                    (long) read_register (gdbarch_tdep (current_gdbarch)->A1G_REGNUM) & 0xff,
1273                    (long) read_register (gdbarch_tdep (current_gdbarch)->A1_REGNUM),
1274                    (long) read_register (gdbarch_tdep (current_gdbarch)->M1_REGNUM),
1275                    (long) read_register (gdbarch_tdep (current_gdbarch)->X1_REGNUM),
1276                    (long) read_register (gdbarch_tdep (current_gdbarch)->Y1_REGNUM),
1277                    (long) read_register (gdbarch_tdep (current_gdbarch)->RE_REGNUM));
1278 }
1279
1280 static void
1281 sh4_show_regs (void)
1282 {
1283   int pr = read_register (gdbarch_tdep (current_gdbarch)->FPSCR_REGNUM) & 0x80000;
1284   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1285                    paddr (read_register (PC_REGNUM)),
1286                    (long) read_register (gdbarch_tdep (current_gdbarch)->SR_REGNUM),
1287                    (long) read_register (PR_REGNUM),
1288                    (long) read_register (MACH_REGNUM),
1289                    (long) read_register (MACL_REGNUM));
1290
1291   printf_filtered ("GBR=%08lx VBR=%08lx",
1292                    (long) read_register (GBR_REGNUM),
1293                    (long) read_register (VBR_REGNUM));
1294   printf_filtered (" SSR=%08lx SPC=%08lx",
1295                    (long) read_register (gdbarch_tdep (current_gdbarch)->SSR_REGNUM),
1296                    (long) read_register (gdbarch_tdep (current_gdbarch)->SPC_REGNUM));
1297   printf_filtered (" FPUL=%08lx FPSCR=%08lx",
1298                    (long) read_register (gdbarch_tdep (current_gdbarch)->FPUL_REGNUM),
1299                    (long) read_register (gdbarch_tdep (current_gdbarch)->FPSCR_REGNUM));
1300
1301   printf_filtered ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1302                    (long) read_register (0),
1303                    (long) read_register (1),
1304                    (long) read_register (2),
1305                    (long) read_register (3),
1306                    (long) read_register (4),
1307                    (long) read_register (5),
1308                    (long) read_register (6),
1309                    (long) read_register (7));
1310   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1311                    (long) read_register (8),
1312                    (long) read_register (9),
1313                    (long) read_register (10),
1314                    (long) read_register (11),
1315                    (long) read_register (12),
1316                    (long) read_register (13),
1317                    (long) read_register (14),
1318                    (long) read_register (15));
1319
1320   printf_filtered ((pr
1321                     ? "DR0-DR6  %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
1322                     : "FP0-FP7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
1323                    (long) read_register (FP0_REGNUM + 0),
1324                    (long) read_register (FP0_REGNUM + 1),
1325                    (long) read_register (FP0_REGNUM + 2),
1326                    (long) read_register (FP0_REGNUM + 3),
1327                    (long) read_register (FP0_REGNUM + 4),
1328                    (long) read_register (FP0_REGNUM + 5),
1329                    (long) read_register (FP0_REGNUM + 6),
1330                    (long) read_register (FP0_REGNUM + 7));
1331   printf_filtered ((pr
1332                     ? "DR8-DR14 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
1333                     : "FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
1334                    (long) read_register (FP0_REGNUM + 8),
1335                    (long) read_register (FP0_REGNUM + 9),
1336                    (long) read_register (FP0_REGNUM + 10),
1337                    (long) read_register (FP0_REGNUM + 11),
1338                    (long) read_register (FP0_REGNUM + 12),
1339                    (long) read_register (FP0_REGNUM + 13),
1340                    (long) read_register (FP0_REGNUM + 14),
1341                    (long) read_register (FP0_REGNUM + 15));
1342 }
1343
1344 static void
1345 sh_dsp_show_regs (void)
1346 {
1347   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1348                    paddr (read_register (PC_REGNUM)),
1349                    (long) read_register (gdbarch_tdep (current_gdbarch)->SR_REGNUM),
1350                    (long) read_register (PR_REGNUM),
1351                    (long) read_register (MACH_REGNUM),
1352                    (long) read_register (MACL_REGNUM));
1353
1354   printf_filtered ("GBR=%08lx VBR=%08lx",
1355                    (long) read_register (GBR_REGNUM),
1356                    (long) read_register (VBR_REGNUM));
1357
1358   printf_filtered (" DSR=%08lx",
1359                    (long) read_register (gdbarch_tdep (current_gdbarch)->DSR_REGNUM));
1360
1361   printf_filtered ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1362                    (long) read_register (0),
1363                    (long) read_register (1),
1364                    (long) read_register (2),
1365                    (long) read_register (3),
1366                    (long) read_register (4),
1367                    (long) read_register (5),
1368                    (long) read_register (6),
1369                    (long) read_register (7));
1370   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1371                    (long) read_register (8),
1372                    (long) read_register (9),
1373                    (long) read_register (10),
1374                    (long) read_register (11),
1375                    (long) read_register (12),
1376                    (long) read_register (13),
1377                    (long) read_register (14),
1378                    (long) read_register (15));
1379
1380   printf_filtered ("A0G=%02lx A0=%08lx M0=%08lx X0=%08lx Y0=%08lx RS=%08lx MOD=%08lx\n",
1381                    (long) read_register (gdbarch_tdep (current_gdbarch)->A0G_REGNUM) & 0xff,
1382                    (long) read_register (gdbarch_tdep (current_gdbarch)->A0_REGNUM),
1383                    (long) read_register (gdbarch_tdep (current_gdbarch)->M0_REGNUM),
1384                    (long) read_register (gdbarch_tdep (current_gdbarch)->X0_REGNUM),
1385                    (long) read_register (gdbarch_tdep (current_gdbarch)->Y0_REGNUM),
1386                    (long) read_register (gdbarch_tdep (current_gdbarch)->RS_REGNUM),
1387                    (long) read_register (gdbarch_tdep (current_gdbarch)->MOD_REGNUM));
1388   printf_filtered ("A1G=%02lx A1=%08lx M1=%08lx X1=%08lx Y1=%08lx RE=%08lx\n",
1389                    (long) read_register (gdbarch_tdep (current_gdbarch)->A1G_REGNUM) & 0xff,
1390                    (long) read_register (gdbarch_tdep (current_gdbarch)->A1_REGNUM),
1391                    (long) read_register (gdbarch_tdep (current_gdbarch)->M1_REGNUM),
1392                    (long) read_register (gdbarch_tdep (current_gdbarch)->X1_REGNUM),
1393                    (long) read_register (gdbarch_tdep (current_gdbarch)->Y1_REGNUM),
1394                    (long) read_register (gdbarch_tdep (current_gdbarch)->RE_REGNUM));
1395 }
1396
1397 void sh_show_regs_command (char *args, int from_tty)
1398 {
1399   if (sh_show_regs)
1400     (*sh_show_regs)();
1401 }
1402
1403 /* Index within `registers' of the first byte of the space for
1404    register N.  */
1405 static int
1406 sh_default_register_byte (int reg_nr)
1407 {
1408   return (reg_nr * 4);
1409 }
1410
1411 static int
1412 sh_sh4_register_byte (int reg_nr)
1413 {
1414   if (reg_nr >= gdbarch_tdep (current_gdbarch)->DR0_REGNUM
1415       && reg_nr <= gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM)
1416     return (dr_reg_base_num (reg_nr) * 4);
1417   else if  (reg_nr >= gdbarch_tdep (current_gdbarch)->FV0_REGNUM
1418             && reg_nr <= gdbarch_tdep (current_gdbarch)->FV_LAST_REGNUM)
1419     return (fv_reg_base_num (reg_nr) * 4);
1420   else
1421     return (reg_nr * 4);
1422 }
1423
1424 /* Number of bytes of storage in the actual machine representation for
1425    register REG_NR.  */
1426 static int
1427 sh_default_register_raw_size (int reg_nr)
1428 {
1429   return 4;
1430 }
1431
1432 static int
1433 sh_sh4_register_raw_size (int reg_nr)
1434 {
1435   if (reg_nr >= gdbarch_tdep (current_gdbarch)->DR0_REGNUM
1436       && reg_nr <= gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM)
1437     return 8;
1438   else if  (reg_nr >= gdbarch_tdep (current_gdbarch)->FV0_REGNUM
1439             && reg_nr <= gdbarch_tdep (current_gdbarch)->FV_LAST_REGNUM)
1440     return 16;
1441   else
1442     return 4;
1443 }
1444
1445 /* Number of bytes of storage in the program's representation
1446    for register N.  */
1447 static int
1448 sh_register_virtual_size (int reg_nr)
1449 {
1450   return 4;
1451 }
1452
1453 /* Return the GDB type object for the "standard" data type
1454    of data in register N.  */
1455
1456 static struct type *
1457 sh_sh3e_register_virtual_type (int reg_nr)
1458 {
1459   if ((reg_nr >= FP0_REGNUM
1460        && (reg_nr <= gdbarch_tdep (current_gdbarch)->FP_LAST_REGNUM))
1461       || (reg_nr == gdbarch_tdep (current_gdbarch)->FPUL_REGNUM))
1462     return builtin_type_float;
1463   else
1464     return builtin_type_int;
1465 }
1466
1467 static struct type *
1468 sh_sh4_register_virtual_type (int reg_nr)
1469 {
1470   if ((reg_nr >= FP0_REGNUM
1471        && (reg_nr <= gdbarch_tdep (current_gdbarch)->FP_LAST_REGNUM))
1472       || (reg_nr == gdbarch_tdep (current_gdbarch)->FPUL_REGNUM))
1473     return builtin_type_float;
1474   else if (reg_nr >= gdbarch_tdep (current_gdbarch)->DR0_REGNUM
1475            && reg_nr <= gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM)
1476     return builtin_type_double;
1477   else if  (reg_nr >= gdbarch_tdep (current_gdbarch)->FV0_REGNUM
1478            && reg_nr <= gdbarch_tdep (current_gdbarch)->FV_LAST_REGNUM)
1479     return sh_sh4_build_float_register_type (3);
1480   else
1481     return builtin_type_int;
1482 }
1483
1484 static struct type *
1485 sh_sh4_build_float_register_type (int high)
1486 {
1487   struct type *temp;
1488
1489   temp = create_range_type (NULL, builtin_type_int, 0, high);
1490   return create_array_type (NULL, builtin_type_float, temp);
1491 }
1492
1493 static struct type *
1494 sh_default_register_virtual_type (int reg_nr)
1495 {
1496   return builtin_type_int;
1497 }
1498
1499 /* On the sh4, the DRi pseudo registers are problematic if the target
1500    is little endian. When the user writes one of those registers, for
1501    instance with 'ser var $dr0=1', we want the double to be stored
1502    like this:
1503    fr0 = 0x00 0x00 0x00 0x00 0x00 0xf0 0x3f
1504    fr1 = 0x00 0x00 0x00 0x00 0x00 0x00 0x00
1505
1506    This corresponds to little endian byte order & big endian word
1507    order.  However if we let gdb write the register w/o conversion, it
1508    will write fr0 and fr1 this way:
1509    fr0 = 0x00 0x00 0x00 0x00 0x00 0x00 0x00
1510    fr1 = 0x00 0x00 0x00 0x00 0x00 0xf0 0x3f
1511    because it will consider fr0 and fr1 as a single LE stretch of memory.
1512
1513    To achieve what we want we must force gdb to store things in
1514    floatformat_ieee_double_littlebyte_bigword (which is defined in
1515    include/floatformat.h and libiberty/floatformat.c.
1516
1517    In case the target is big endian, there is no problem, the
1518    raw bytes will look like:
1519    fr0 = 0x3f 0xf0 0x00 0x00 0x00 0x00 0x00
1520    fr1 = 0x00 0x00 0x00 0x00 0x00 0x00 0x00
1521
1522    The other pseudo registers (the FVs) also don't pose a problem
1523    because they are stored as 4 individual FP elements. */
1524
1525 int
1526 sh_sh4_register_convertible (int nr)
1527 {
1528   if (TARGET_BYTE_ORDER == LITTLE_ENDIAN)
1529     return (gdbarch_tdep (current_gdbarch)->DR0_REGNUM <= nr
1530             && nr <= gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM);
1531   else
1532     return 0;
1533 }
1534
1535 void
1536 sh_sh4_register_convert_to_virtual (int regnum, struct type *type,
1537                                   char *from, char *to)
1538 {
1539   if (regnum >= gdbarch_tdep (current_gdbarch)->DR0_REGNUM
1540       && regnum <= gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM)
1541     {
1542       DOUBLEST val;
1543       floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword, from, &val);
1544       store_floating(to, TYPE_LENGTH(type), val);
1545     }
1546   else
1547     error("sh_register_convert_to_virtual called with non DR register number");
1548 }
1549
1550 void
1551 sh_sh4_register_convert_to_raw (struct type *type, int regnum,
1552                               char *from, char *to)
1553 {
1554   if (regnum >= gdbarch_tdep (current_gdbarch)->DR0_REGNUM
1555       && regnum <= gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM)
1556     {
1557       DOUBLEST val = extract_floating (from, TYPE_LENGTH(type));
1558       floatformat_from_doublest (&floatformat_ieee_double_littlebyte_bigword, &val, to);
1559     }
1560   else
1561     error("sh_register_convert_to_raw called with non DR register number");
1562 }
1563
1564 void
1565 sh_fetch_pseudo_register (int reg_nr)
1566 {
1567   int base_regnum, portion;
1568
1569   if (!register_cached (reg_nr))
1570     {
1571       if (reg_nr >= gdbarch_tdep (current_gdbarch)->DR0_REGNUM
1572           && reg_nr <= gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM)
1573         {
1574           base_regnum = dr_reg_base_num (reg_nr);
1575
1576           /* Read the real regs for which this one is an alias.  */
1577           for (portion = 0; portion < 2; portion++)
1578             if (!register_cached (base_regnum + portion))
1579               target_fetch_registers (base_regnum + portion);
1580         }
1581       else if (reg_nr >= gdbarch_tdep (current_gdbarch)->FV0_REGNUM
1582                && reg_nr <= gdbarch_tdep (current_gdbarch)->FV_LAST_REGNUM)
1583         {
1584           base_regnum = fv_reg_base_num (reg_nr);
1585
1586           /* Read the real regs for which this one is an alias.  */
1587           for (portion = 0; portion < 4; portion++)
1588             if (!register_cached (base_regnum + portion))
1589               target_fetch_registers (base_regnum + portion);
1590
1591         }
1592       register_valid [reg_nr] = 1;
1593     }
1594 }
1595
1596 void
1597 sh_store_pseudo_register (int reg_nr)
1598 {
1599   int base_regnum, portion;
1600
1601   if (reg_nr >= gdbarch_tdep (current_gdbarch)->DR0_REGNUM
1602       && reg_nr <= gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM)
1603     {
1604       base_regnum = dr_reg_base_num (reg_nr);
1605
1606       /* Write the real regs for which this one is an alias.  */
1607       for (portion = 0; portion < 2; portion++)
1608         {
1609           register_valid[base_regnum + portion] = 1;
1610           target_store_registers (base_regnum + portion);
1611         }
1612     }
1613   else if (reg_nr >= gdbarch_tdep (current_gdbarch)->FV0_REGNUM
1614            && reg_nr <= gdbarch_tdep (current_gdbarch)->FV_LAST_REGNUM)
1615     {
1616       base_regnum = fv_reg_base_num (reg_nr);
1617
1618       /* Write the real regs for which this one is an alias.  */
1619       for (portion = 0; portion < 4; portion++)
1620         {
1621           register_valid[base_regnum + portion] = 1;
1622           target_store_registers (base_regnum + portion);
1623         }
1624     }
1625 }
1626
1627 static int
1628 fv_reg_base_num (int fv_regnum)
1629 {
1630   int fp_regnum;
1631
1632   fp_regnum = FP0_REGNUM +
1633     (fv_regnum - gdbarch_tdep (current_gdbarch)->FV0_REGNUM) * 4;
1634   return fp_regnum;
1635 }
1636
1637 static int
1638 dr_reg_base_num (int dr_regnum)
1639 {
1640   int fp_regnum;
1641
1642   fp_regnum = FP0_REGNUM +
1643     (dr_regnum - gdbarch_tdep (current_gdbarch)->DR0_REGNUM) * 2;
1644   return fp_regnum;
1645 }
1646
1647 static void
1648 do_fv_register_info (int fv_regnum)
1649 {
1650   int first_fp_reg_num = fv_reg_base_num (fv_regnum);
1651   printf_filtered ("fv%d\t0x%08x\t0x%08x\t0x%08x\t0x%08x\n",
1652                      fv_regnum - gdbarch_tdep (current_gdbarch)->FV0_REGNUM,
1653                      (int) read_register (first_fp_reg_num),
1654                      (int) read_register (first_fp_reg_num + 1),
1655                      (int) read_register (first_fp_reg_num + 2),
1656                      (int) read_register (first_fp_reg_num + 3));
1657 }
1658
1659 static void
1660 do_dr_register_info (int dr_regnum)
1661 {
1662   int first_fp_reg_num = dr_reg_base_num (dr_regnum);
1663
1664   printf_filtered ("dr%d\t0x%08x%08x\n",
1665                     dr_regnum - gdbarch_tdep (current_gdbarch)->DR0_REGNUM,
1666                     (int) read_register (first_fp_reg_num),
1667                     (int) read_register (first_fp_reg_num + 1));
1668 }
1669
1670 static void
1671 sh_do_pseudo_register (int regnum)
1672 {
1673   if (regnum < NUM_REGS || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
1674     internal_error ("Invalid pseudo register number %d\n", regnum);
1675   else if (regnum >= gdbarch_tdep (current_gdbarch)->DR0_REGNUM
1676            && regnum < gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM)
1677     do_dr_register_info (regnum);
1678   else if (regnum >= gdbarch_tdep (current_gdbarch)->FV0_REGNUM
1679            && regnum <= gdbarch_tdep (current_gdbarch)->FV_LAST_REGNUM)
1680     do_fv_register_info (regnum);
1681 }
1682
1683
1684 static void
1685 sh_do_fp_register (int regnum)
1686 {                               /* do values for FP (float) regs */
1687   char *raw_buffer;
1688   double flt;   /* double extracted from raw hex data */
1689   int inv;
1690   int j;
1691
1692   /* Allocate space for the float. */
1693   raw_buffer = (char *) alloca (REGISTER_RAW_SIZE (FP0_REGNUM));
1694
1695   /* Get the data in raw format.  */
1696   if (read_relative_register_raw_bytes (regnum, raw_buffer))
1697     error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum));
1698
1699   /* Get the register as a number */
1700   flt = unpack_double (builtin_type_float, raw_buffer, &inv);
1701
1702   /* Print the name and some spaces. */
1703   fputs_filtered (REGISTER_NAME (regnum), gdb_stdout);
1704   print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), gdb_stdout);
1705
1706   /* Print the value. */
1707   printf_filtered (inv ? "<invalid float>" : "%-10.9g", flt);
1708
1709   /* Print the fp register as hex. */
1710   printf_filtered ("\t(raw 0x");
1711   for (j = 0; j < REGISTER_RAW_SIZE (regnum); j++)
1712     {
1713       register int idx = TARGET_BYTE_ORDER == BIG_ENDIAN ? j
1714         : REGISTER_RAW_SIZE (regnum) - 1 - j;
1715       printf_filtered ("%02x", (unsigned char) raw_buffer[idx]);
1716     }
1717   printf_filtered (")");
1718   printf_filtered ("\n");
1719 }
1720
1721 static void
1722 sh_do_register (int regnum)
1723 {
1724   char raw_buffer[MAX_REGISTER_RAW_SIZE];
1725
1726   fputs_filtered (REGISTER_NAME (regnum), gdb_stdout);
1727   print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), gdb_stdout);
1728
1729   /* Get the data in raw format.  */
1730   if (read_relative_register_raw_bytes (regnum, raw_buffer))
1731     printf_filtered ("*value not available*\n");
1732
1733   val_print (REGISTER_VIRTUAL_TYPE (regnum), raw_buffer, 0, 0,
1734              gdb_stdout, 'x', 1, 0, Val_pretty_default);
1735   printf_filtered ("\t");
1736   val_print (REGISTER_VIRTUAL_TYPE (regnum), raw_buffer, 0, 0,
1737              gdb_stdout, 0, 1, 0, Val_pretty_default);
1738   printf_filtered ("\n");
1739 }
1740
1741 static void
1742 sh_print_register (int regnum)
1743 {
1744   if (regnum < 0 || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
1745     internal_error ("Invalid register number %d\n", regnum);
1746
1747   else if (regnum >= 0 && regnum < NUM_REGS)
1748     {
1749       if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
1750         sh_do_fp_register (regnum);     /* FP regs */
1751       else
1752         sh_do_register (regnum);        /* All other regs */
1753     }
1754
1755   else if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
1756     sh_do_pseudo_register (regnum);
1757 }
1758
1759 void
1760 sh_do_registers_info (int regnum, int fpregs)
1761 {
1762   if (regnum != -1)             /* do one specified register */
1763     {
1764       if (*(REGISTER_NAME (regnum)) == '\0')
1765         error ("Not a valid register for the current processor type");
1766
1767       sh_print_register (regnum);
1768     }
1769   else
1770     /* do all (or most) registers */
1771     {
1772       regnum = 0;
1773       while (regnum < NUM_REGS)
1774         {
1775           /* If the register name is empty, it is undefined for this
1776              processor, so don't display anything.  */
1777           if (REGISTER_NAME (regnum) == NULL
1778               || *(REGISTER_NAME (regnum)) == '\0')
1779             {
1780               regnum++;
1781               continue;
1782             }
1783
1784           if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
1785             {
1786               if (fpregs)
1787                 {
1788                   /* true for "INFO ALL-REGISTERS" command */
1789                   sh_do_fp_register (regnum);   /* FP regs */
1790                   regnum ++;
1791                 }
1792               else
1793                 regnum += (gdbarch_tdep (current_gdbarch)->FP_LAST_REGNUM - FP0_REGNUM);        /* skip FP regs */
1794             }
1795           else
1796             {
1797               sh_do_register (regnum);  /* All other regs */
1798               regnum++;
1799             }
1800         }
1801
1802       if (fpregs)
1803         while (regnum < NUM_REGS + NUM_PSEUDO_REGS)
1804           {
1805             sh_do_pseudo_register (regnum);
1806             regnum++;
1807           }
1808     }
1809 }
1810
1811 #ifdef SVR4_SHARED_LIBS
1812
1813 /* Fetch (and possibly build) an appropriate link_map_offsets structure
1814    for native i386 linux targets using the struct offsets defined in
1815    link.h (but without actual reference to that file).
1816
1817    This makes it possible to access i386-linux shared libraries from
1818    a gdb that was not built on an i386-linux host (for cross debugging).
1819    */
1820
1821 struct link_map_offsets *
1822 sh_linux_svr4_fetch_link_map_offsets (void)
1823 {
1824   static struct link_map_offsets lmo;
1825   static struct link_map_offsets *lmp = 0;
1826
1827   if (lmp == 0)
1828     {
1829       lmp = &lmo;
1830
1831       lmo.r_debug_size = 8;     /* 20 not actual size but all we need */
1832
1833       lmo.r_map_offset = 4;
1834       lmo.r_map_size   = 4;
1835
1836       lmo.link_map_size = 20;   /* 552 not actual size but all we need */
1837
1838       lmo.l_addr_offset = 0;
1839       lmo.l_addr_size   = 4;
1840
1841       lmo.l_name_offset = 4;
1842       lmo.l_name_size   = 4;
1843
1844       lmo.l_next_offset = 12;
1845       lmo.l_next_size   = 4;
1846
1847       lmo.l_prev_offset = 16;
1848       lmo.l_prev_size   = 4;
1849     }
1850
1851     return lmp;
1852 }
1853 #endif /* SVR4_SHARED_LIBS */
1854
1855 static gdbarch_init_ftype sh_gdbarch_init;
1856
1857 static struct gdbarch *
1858 sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1859 {
1860   static LONGEST sh_call_dummy_words[] = {0};
1861   struct gdbarch *gdbarch;
1862   struct gdbarch_tdep *tdep;
1863   gdbarch_register_name_ftype *sh_register_name;
1864   gdbarch_store_return_value_ftype *sh_store_return_value;
1865   gdbarch_register_virtual_type_ftype *sh_register_virtual_type;
1866
1867   /* Find a candidate among the list of pre-declared architectures. */
1868   arches = gdbarch_list_lookup_by_info (arches, &info);
1869   if (arches != NULL)
1870     return arches->gdbarch;
1871
1872   /* None found, create a new architecture from the information
1873      provided. */
1874   tdep = XMALLOC (struct gdbarch_tdep);
1875   gdbarch = gdbarch_alloc (&info, tdep);
1876
1877   /* Initialize the register numbers that are not common to all the
1878      variants to -1, if necessary thse will be overwritten in the case
1879      statement below. */
1880   tdep->FPUL_REGNUM = -1;
1881   tdep->FPSCR_REGNUM = -1;
1882   tdep->SR_REGNUM = 22;
1883   tdep->DSR_REGNUM = -1;
1884   tdep->FP_LAST_REGNUM = -1;
1885   tdep->A0G_REGNUM = -1;
1886   tdep->A0_REGNUM = -1;
1887   tdep->A1G_REGNUM = -1;
1888   tdep->A1_REGNUM = -1;
1889   tdep->M0_REGNUM = -1;
1890   tdep->M1_REGNUM = -1;
1891   tdep->X0_REGNUM = -1;
1892   tdep->X1_REGNUM = -1;
1893   tdep->Y0_REGNUM = -1;
1894   tdep->Y1_REGNUM = -1;
1895   tdep->MOD_REGNUM = -1;
1896   tdep->RS_REGNUM = -1;
1897   tdep->RE_REGNUM = -1;
1898   tdep->SSR_REGNUM = -1;
1899   tdep->SPC_REGNUM = -1;
1900   tdep->DR0_REGNUM = -1;
1901   tdep->DR_LAST_REGNUM = -1;
1902   tdep->FV0_REGNUM = -1;
1903   tdep->FV_LAST_REGNUM = -1;
1904
1905   set_gdbarch_fp0_regnum (gdbarch, -1);
1906   set_gdbarch_num_pseudo_regs (gdbarch, 0);
1907   set_gdbarch_max_register_raw_size (gdbarch, 4);
1908   set_gdbarch_max_register_virtual_size (gdbarch, 4);
1909   set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1910   set_gdbarch_num_regs (gdbarch, 59);
1911   set_gdbarch_sp_regnum (gdbarch, 15);
1912   set_gdbarch_fp_regnum (gdbarch, 14);
1913   set_gdbarch_pc_regnum (gdbarch, 16);
1914   set_gdbarch_register_size (gdbarch, 4);
1915   set_gdbarch_register_bytes (gdbarch, NUM_REGS * 4);
1916   set_gdbarch_fetch_pseudo_register (gdbarch, sh_fetch_pseudo_register);
1917   set_gdbarch_store_pseudo_register (gdbarch, sh_store_pseudo_register);
1918   set_gdbarch_do_registers_info (gdbarch, sh_do_registers_info);
1919   set_gdbarch_breakpoint_from_pc (gdbarch, sh_breakpoint_from_pc);
1920   print_sh_insn = gdb_print_insn_sh;
1921
1922   switch (info.bfd_arch_info->mach)
1923     {
1924     case bfd_mach_sh:
1925       sh_register_name = sh_sh_register_name;
1926       sh_show_regs = sh_generic_show_regs;
1927       sh_store_return_value = sh_default_store_return_value;
1928       sh_register_virtual_type = sh_default_register_virtual_type;
1929       set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
1930       set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
1931       set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
1932       set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
1933       break;
1934     case bfd_mach_sh2:
1935       sh_register_name = sh_sh_register_name;
1936       sh_show_regs = sh_generic_show_regs;
1937       sh_store_return_value = sh_default_store_return_value;
1938       sh_register_virtual_type = sh_default_register_virtual_type;
1939       set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
1940       set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
1941       set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
1942       set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
1943       break;
1944     case bfd_mach_sh_dsp:
1945       sh_register_name = sh_sh_dsp_register_name;
1946       sh_show_regs = sh_dsp_show_regs;
1947       sh_store_return_value = sh_default_store_return_value;
1948       sh_register_virtual_type = sh_default_register_virtual_type;
1949       set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
1950       set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
1951       set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
1952       set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
1953       tdep->DSR_REGNUM = 24;
1954       tdep->A0G_REGNUM = 25;
1955       tdep->A0_REGNUM = 26;
1956       tdep->A1G_REGNUM = 27;
1957       tdep->A1_REGNUM = 28;
1958       tdep->M0_REGNUM = 29;
1959       tdep->M1_REGNUM = 30;
1960       tdep->X0_REGNUM = 31;
1961       tdep->X1_REGNUM = 32;
1962       tdep->Y0_REGNUM = 33;
1963       tdep->Y1_REGNUM = 34;
1964       tdep->MOD_REGNUM = 40;
1965       tdep->RS_REGNUM = 43;
1966       tdep->RE_REGNUM = 44;
1967       break;
1968     case bfd_mach_sh3:
1969       sh_register_name = sh_sh3_register_name;
1970       sh_show_regs = sh3_show_regs;
1971       sh_store_return_value = sh_default_store_return_value;
1972       sh_register_virtual_type = sh_default_register_virtual_type;
1973       set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
1974       set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
1975       set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
1976       set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
1977       tdep->SSR_REGNUM = 41;
1978       tdep->SPC_REGNUM = 42;
1979       break;
1980     case bfd_mach_sh3e:
1981       sh_register_name = sh_sh3e_register_name;
1982       sh_show_regs = sh3e_show_regs;
1983       sh_store_return_value = sh3e_sh4_store_return_value;
1984       sh_register_virtual_type = sh_sh3e_register_virtual_type;
1985       set_gdbarch_frame_init_saved_regs (gdbarch, sh_fp_frame_init_saved_regs);
1986       set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
1987       set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
1988       set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
1989       set_gdbarch_fp0_regnum (gdbarch, 25);
1990       tdep->FPUL_REGNUM = 23;
1991       tdep->FPSCR_REGNUM = 24;
1992       tdep->FP_LAST_REGNUM = 40;
1993       tdep->SSR_REGNUM = 41;
1994       tdep->SPC_REGNUM = 42;
1995       break;
1996     case bfd_mach_sh3_dsp:
1997       sh_register_name = sh_sh3_dsp_register_name;
1998       sh_show_regs = sh3_dsp_show_regs;
1999       sh_store_return_value = sh_default_store_return_value;
2000       sh_register_virtual_type = sh_default_register_virtual_type;
2001       set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
2002       set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
2003       set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
2004       set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
2005       tdep->DSR_REGNUM = 24;
2006       tdep->A0G_REGNUM = 25;
2007       tdep->A0_REGNUM = 26;
2008       tdep->A1G_REGNUM = 27;
2009       tdep->A1_REGNUM = 28;
2010       tdep->M0_REGNUM = 29;
2011       tdep->M1_REGNUM = 30;
2012       tdep->X0_REGNUM = 31;
2013       tdep->X1_REGNUM = 32;
2014       tdep->Y0_REGNUM = 33;
2015       tdep->Y1_REGNUM = 34;
2016       tdep->MOD_REGNUM = 40;
2017       tdep->RS_REGNUM = 43;
2018       tdep->RE_REGNUM = 44;
2019       tdep->SSR_REGNUM = 41;
2020       tdep->SPC_REGNUM = 42;
2021       break;
2022     case bfd_mach_sh4:
2023       sh_register_name = sh_sh4_register_name;
2024       sh_show_regs = sh4_show_regs;
2025       sh_store_return_value = sh3e_sh4_store_return_value;
2026       sh_register_virtual_type = sh_sh4_register_virtual_type;
2027       set_gdbarch_frame_init_saved_regs (gdbarch, sh_fp_frame_init_saved_regs);
2028       set_gdbarch_fp0_regnum (gdbarch, 25);
2029       set_gdbarch_register_raw_size (gdbarch, sh_sh4_register_raw_size);
2030       set_gdbarch_register_virtual_size (gdbarch, sh_sh4_register_raw_size);
2031       set_gdbarch_register_byte (gdbarch, sh_sh4_register_byte);
2032       set_gdbarch_num_pseudo_regs (gdbarch, 12);
2033       set_gdbarch_max_register_raw_size (gdbarch, 4 * 4);
2034       set_gdbarch_max_register_virtual_size (gdbarch, 4 * 4);
2035       set_gdbarch_register_convert_to_raw (gdbarch, sh_sh4_register_convert_to_raw);
2036       set_gdbarch_register_convert_to_virtual (gdbarch, sh_sh4_register_convert_to_virtual);
2037       set_gdbarch_register_convertible (gdbarch, sh_sh4_register_convertible);
2038       tdep->FPUL_REGNUM = 23;
2039       tdep->FPSCR_REGNUM = 24;
2040       tdep->FP_LAST_REGNUM = 40;
2041       tdep->SSR_REGNUM = 41;
2042       tdep->SPC_REGNUM = 42;
2043       tdep->DR0_REGNUM = 59;
2044       tdep->DR_LAST_REGNUM = 66;
2045       tdep->FV0_REGNUM = 67;
2046       tdep->FV_LAST_REGNUM = 70;
2047       break;
2048     default:
2049       sh_register_name = sh_generic_register_name;
2050       sh_show_regs = sh_generic_show_regs;
2051       sh_store_return_value = sh_default_store_return_value;
2052       sh_register_virtual_type = sh_default_register_virtual_type;
2053       set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
2054       set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
2055       set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
2056       set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
2057       break;
2058     }
2059
2060   set_gdbarch_read_pc (gdbarch, generic_target_read_pc);
2061   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
2062   set_gdbarch_read_fp (gdbarch, generic_target_read_fp);
2063   set_gdbarch_write_fp (gdbarch, generic_target_write_fp);
2064   set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
2065   set_gdbarch_write_sp (gdbarch, generic_target_write_sp);
2066
2067   set_gdbarch_register_name (gdbarch, sh_register_name);
2068   set_gdbarch_register_virtual_type (gdbarch, sh_register_virtual_type);
2069
2070   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
2071   set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2072   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2073   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2074   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2075   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2076   set_gdbarch_long_double_bit (gdbarch, 16 * TARGET_CHAR_BIT);/*??should be 8?*/
2077
2078   set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
2079   set_gdbarch_call_dummy_length (gdbarch, 0);
2080   set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
2081   set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
2082   set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1); /*???*/
2083   set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
2084   set_gdbarch_call_dummy_start_offset (gdbarch, 0);
2085   set_gdbarch_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy);
2086   set_gdbarch_call_dummy_words (gdbarch, sh_call_dummy_words);
2087   set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (sh_call_dummy_words));
2088   set_gdbarch_call_dummy_p (gdbarch, 1);
2089   set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
2090   set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register);
2091   set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
2092   set_gdbarch_coerce_float_to_double (gdbarch,
2093                                       sh_coerce_float_to_double);
2094
2095   set_gdbarch_extract_return_value (gdbarch, sh_extract_return_value);
2096   set_gdbarch_push_arguments (gdbarch, sh_push_arguments);
2097   set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
2098   set_gdbarch_push_return_address (gdbarch, sh_push_return_address);
2099
2100   set_gdbarch_store_struct_return (gdbarch, sh_store_struct_return);
2101   set_gdbarch_store_return_value (gdbarch, sh_store_return_value);
2102   set_gdbarch_extract_struct_value_address (gdbarch, sh_extract_struct_value_address);
2103   set_gdbarch_use_struct_convention (gdbarch, sh_use_struct_convention);
2104   set_gdbarch_init_extra_frame_info (gdbarch, sh_init_extra_frame_info);
2105   set_gdbarch_pop_frame (gdbarch, sh_pop_frame);
2106   set_gdbarch_skip_prologue (gdbarch, sh_skip_prologue);
2107   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2108   set_gdbarch_decr_pc_after_break (gdbarch, 0);
2109   set_gdbarch_function_start_offset (gdbarch, 0);
2110
2111   set_gdbarch_frame_args_skip (gdbarch, 0);
2112   set_gdbarch_frameless_function_invocation (gdbarch, frameless_look_for_prologue);
2113   set_gdbarch_frame_chain (gdbarch, sh_frame_chain);
2114   set_gdbarch_frame_chain_valid (gdbarch, generic_file_frame_chain_valid);
2115   set_gdbarch_frame_saved_pc (gdbarch, sh_frame_saved_pc);
2116   set_gdbarch_frame_args_address (gdbarch, default_frame_address);
2117   set_gdbarch_frame_locals_address (gdbarch, default_frame_address);
2118   set_gdbarch_saved_pc_after_call (gdbarch, sh_saved_pc_after_call);
2119   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
2120   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
2121   set_gdbarch_ieee_float (gdbarch, 1);
2122   tm_print_insn = print_sh_insn;
2123
2124   return gdbarch;
2125 }
2126
2127 void
2128 _initialize_sh_tdep (void)
2129 {
2130   struct cmd_list_element *c;
2131
2132   register_gdbarch_init (bfd_arch_sh, sh_gdbarch_init);
2133
2134   add_com ("regs", class_vars, sh_show_regs_command, "Print all registers");
2135 }