gdb/sh-tdep.c

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