gdb/sparc64-tdep.c

   1 /* Target-dependent code for UltraSPARC.
   2
   3    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "arch-utils.h"
  23 #include "dwarf2-frame.h"
  24 #include "floatformat.h"
  25 #include "frame.h"
  26 #include "frame-base.h"
  27 #include "frame-unwind.h"
  28 #include "gdbcore.h"
  29 #include "gdbtypes.h"
  30 #include "inferior.h"
  31 #include "symtab.h"
  32 #include "objfiles.h"
  33 #include "osabi.h"
  34 #include "regcache.h"
  35 #include "target.h"
  36 #include "value.h"
  37
  38 #include "gdb_assert.h"
  39 #include "gdb_string.h"
  40
  41 #include "sparc64-tdep.h"
  42
  43 /* This file implements the SPARC 64-bit ABI as defined by the
  44    section "Low-Level System Information" of the SPARC Compliance
  45    Definition (SCD) 2.4.1, which is the 64-bit System V psABI for
  46    SPARC.  */
  47
  48 /* Please use the sparc32_-prefix for 32-bit specific code, the
  49    sparc64_-prefix for 64-bit specific code and the sparc_-prefix for
  50    code can handle both.  */
  51 \f
  52 /* The functions on this page are intended to be used to classify
  53    function arguments.  */
  54
  55 /* Check whether TYPE is "Integral or Pointer".  */
  56
  57 static int
  58 sparc64_integral_or_pointer_p (const struct type *type)
  59 {
  60   switch (TYPE_CODE (type))
  61     {
  62     case TYPE_CODE_INT:
  63     case TYPE_CODE_BOOL:
  64     case TYPE_CODE_CHAR:
  65     case TYPE_CODE_ENUM:
  66     case TYPE_CODE_RANGE:
  67       {
  68         int len = TYPE_LENGTH (type);
  69         gdb_assert (len == 1 || len == 2 || len == 4 || len == 8);
  70       }
  71       return 1;
  72     case TYPE_CODE_PTR:
  73     case TYPE_CODE_REF:
  74       {
  75         int len = TYPE_LENGTH (type);
  76         gdb_assert (len == 8);
  77       }
  78       return 1;
  79     default:
  80       break;
  81     }
  82
  83   return 0;
  84 }
  85
  86 /* Check whether TYPE is "Floating".  */
  87
  88 static int
  89 sparc64_floating_p (const struct type *type)
  90 {
  91   switch (TYPE_CODE (type))
  92     {
  93     case TYPE_CODE_FLT:
  94       {
  95         int len = TYPE_LENGTH (type);
  96         gdb_assert (len == 4 || len == 8 || len == 16);
  97       }
  98       return 1;
  99     default:
 100       break;
 101     }
 102
 103   return 0;
 104 }
 105
 106 /* Check whether TYPE is "Structure or Union".
 107
 108    In terms of Ada subprogram calls, arrays are treated the same as
 109    struct and union types.  So this function also returns non-zero
 110    for array types.  */
 111
 112 static int
 113 sparc64_structure_or_union_p (const struct type *type)
 114 {
 115   switch (TYPE_CODE (type))
 116     {
 117     case TYPE_CODE_STRUCT:
 118     case TYPE_CODE_UNION:
 119     case TYPE_CODE_ARRAY:
 120       return 1;
 121     default:
 122       break;
 123     }
 124
 125   return 0;
 126 }
 127 \f
 128
 129 /* Construct types for ISA-specific registers.  */
 130
 131 static struct type *
 132 sparc64_pstate_type (struct gdbarch *gdbarch)
 133 {
 134   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 135
 136   if (!tdep->sparc64_pstate_type)
 137     {
 138       struct type *type;
 139
 140       type = arch_flags_type (gdbarch, "builtin_type_sparc64_pstate", 8);
 141       append_flags_type_flag (type, 0, "AG");
 142       append_flags_type_flag (type, 1, "IE");
 143       append_flags_type_flag (type, 2, "PRIV");
 144       append_flags_type_flag (type, 3, "AM");
 145       append_flags_type_flag (type, 4, "PEF");
 146       append_flags_type_flag (type, 5, "RED");
 147       append_flags_type_flag (type, 8, "TLE");
 148       append_flags_type_flag (type, 9, "CLE");
 149       append_flags_type_flag (type, 10, "PID0");
 150       append_flags_type_flag (type, 11, "PID1");
 151
 152       tdep->sparc64_pstate_type = type;
 153     }
 154
 155   return tdep->sparc64_pstate_type;
 156 }
 157
 158 static struct type *
 159 sparc64_fsr_type (struct gdbarch *gdbarch)
 160 {
 161   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 162
 163   if (!tdep->sparc64_fsr_type)
 164     {
 165       struct type *type;
 166
 167       type = arch_flags_type (gdbarch, "builtin_type_sparc64_fsr", 8);
 168       append_flags_type_flag (type, 0, "NXA");
 169       append_flags_type_flag (type, 1, "DZA");
 170       append_flags_type_flag (type, 2, "UFA");
 171       append_flags_type_flag (type, 3, "OFA");
 172       append_flags_type_flag (type, 4, "NVA");
 173       append_flags_type_flag (type, 5, "NXC");
 174       append_flags_type_flag (type, 6, "DZC");
 175       append_flags_type_flag (type, 7, "UFC");
 176       append_flags_type_flag (type, 8, "OFC");
 177       append_flags_type_flag (type, 9, "NVC");
 178       append_flags_type_flag (type, 22, "NS");
 179       append_flags_type_flag (type, 23, "NXM");
 180       append_flags_type_flag (type, 24, "DZM");
 181       append_flags_type_flag (type, 25, "UFM");
 182       append_flags_type_flag (type, 26, "OFM");
 183       append_flags_type_flag (type, 27, "NVM");
 184
 185       tdep->sparc64_fsr_type = type;
 186     }
 187
 188   return tdep->sparc64_fsr_type;
 189 }
 190
 191 static struct type *
 192 sparc64_fprs_type (struct gdbarch *gdbarch)
 193 {
 194   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 195
 196   if (!tdep->sparc64_fprs_type)
 197     {
 198       struct type *type;
 199
 200       type = arch_flags_type (gdbarch, "builtin_type_sparc64_fprs", 8);
 201       append_flags_type_flag (type, 0, "DL");
 202       append_flags_type_flag (type, 1, "DU");
 203       append_flags_type_flag (type, 2, "FEF");
 204
 205       tdep->sparc64_fprs_type = type;
 206     }
 207
 208   return tdep->sparc64_fprs_type;
 209 }
 210
 211
 212 /* Register information.  */
 213
 214 static const char *sparc64_register_names[] =
 215 {
 216   "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
 217   "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
 218   "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
 219   "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
 220
 221   "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
 222   "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
 223   "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
 224   "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
 225   "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46",
 226   "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62",
 227
 228   "pc", "npc",
 229
 230   /* FIXME: Give "state" a name until we start using register groups.  */
 231   "state",
 232   "fsr",
 233   "fprs",
 234   "y",
 235 };
 236
 237 /* Total number of registers.  */
 238 #define SPARC64_NUM_REGS ARRAY_SIZE (sparc64_register_names)
 239
 240 /* We provide the aliases %d0..%d62 and %q0..%q60 for the floating
 241    registers as "psuedo" registers.  */
 242
 243 static const char *sparc64_pseudo_register_names[] =
 244 {
 245   "cwp", "pstate", "asi", "ccr",
 246
 247   "d0", "d2", "d4", "d6", "d8", "d10", "d12", "d14",
 248   "d16", "d18", "d20", "d22", "d24", "d26", "d28", "d30",
 249   "d32", "d34", "d36", "d38", "d40", "d42", "d44", "d46",
 250   "d48", "d50", "d52", "d54", "d56", "d58", "d60", "d62",
 251
 252   "q0", "q4", "q8", "q12", "q16", "q20", "q24", "q28",
 253   "q32", "q36", "q40", "q44", "q48", "q52", "q56", "q60",
 254 };
 255
 256 /* Total number of pseudo registers.  */
 257 #define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_names)
 258
 259 /* Return the name of register REGNUM.  */
 260
 261 static const char *
 262 sparc64_register_name (struct gdbarch *gdbarch, int regnum)
 263 {
 264   if (regnum >= 0 && regnum < SPARC64_NUM_REGS)
 265     return sparc64_register_names[regnum];
 266
 267   if (regnum >= SPARC64_NUM_REGS
 268       && regnum < SPARC64_NUM_REGS + SPARC64_NUM_PSEUDO_REGS)
 269     return sparc64_pseudo_register_names[regnum - SPARC64_NUM_REGS];
 270
 271   return NULL;
 272 }
 273
 274 /* Return the GDB type object for the "standard" data type of data in
 275    register REGNUM.  */
 276
 277 static struct type *
 278 sparc64_register_type (struct gdbarch *gdbarch, int regnum)
 279 {
 280   /* Raw registers.  */
 281
 282   if (regnum == SPARC_SP_REGNUM || regnum == SPARC_FP_REGNUM)
 283     return builtin_type (gdbarch)->builtin_data_ptr;
 284   if (regnum >= SPARC_G0_REGNUM && regnum <= SPARC_I7_REGNUM)
 285     return builtin_type (gdbarch)->builtin_int64;
 286   if (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F31_REGNUM)
 287     return builtin_type (gdbarch)->builtin_float;
 288   if (regnum >= SPARC64_F32_REGNUM && regnum <= SPARC64_F62_REGNUM)
 289     return builtin_type (gdbarch)->builtin_double;
 290   if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
 291     return builtin_type (gdbarch)->builtin_func_ptr;
 292   /* This raw register contains the contents of %cwp, %pstate, %asi
 293      and %ccr as laid out in a %tstate register.  */
 294   if (regnum == SPARC64_STATE_REGNUM)
 295     return builtin_type (gdbarch)->builtin_int64;
 296   if (regnum == SPARC64_FSR_REGNUM)
 297     return sparc64_fsr_type (gdbarch);
 298   if (regnum == SPARC64_FPRS_REGNUM)
 299     return sparc64_fprs_type (gdbarch);
 300   /* "Although Y is a 64-bit register, its high-order 32 bits are
 301      reserved and always read as 0."  */
 302   if (regnum == SPARC64_Y_REGNUM)
 303     return builtin_type (gdbarch)->builtin_int64;
 304
 305   /* Pseudo registers.  */
 306
 307   if (regnum == SPARC64_CWP_REGNUM)
 308     return builtin_type (gdbarch)->builtin_int64;
 309   if (regnum == SPARC64_PSTATE_REGNUM)
 310     return sparc64_pstate_type (gdbarch);
 311   if (regnum == SPARC64_ASI_REGNUM)
 312     return builtin_type (gdbarch)->builtin_int64;
 313   if (regnum == SPARC64_CCR_REGNUM)
 314     return builtin_type (gdbarch)->builtin_int64;
 315   if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D62_REGNUM)
 316     return builtin_type (gdbarch)->builtin_double;
 317   if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q60_REGNUM)
 318     return builtin_type (gdbarch)->builtin_long_double;
 319
 320   internal_error (__FILE__, __LINE__, _("invalid regnum"));
 321 }
 322
 323 static enum register_status
 324 sparc64_pseudo_register_read (struct gdbarch *gdbarch,
 325                               struct regcache *regcache,
 326                               int regnum, gdb_byte *buf)
 327 {
 328   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 329   enum register_status status;
 330
 331   gdb_assert (regnum >= SPARC64_NUM_REGS);
 332
 333   if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)
 334     {
 335       regnum = SPARC_F0_REGNUM + 2 * (regnum - SPARC64_D0_REGNUM);
 336       status = regcache_raw_read (regcache, regnum, buf);
 337       if (status == REG_VALID)
 338         status = regcache_raw_read (regcache, regnum + 1, buf + 4);
 339       return status;
 340     }
 341   else if (regnum >= SPARC64_D32_REGNUM && regnum <= SPARC64_D62_REGNUM)
 342     {
 343       regnum = SPARC64_F32_REGNUM + (regnum - SPARC64_D32_REGNUM);
 344       return regcache_raw_read (regcache, regnum, buf);
 345     }
 346   else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q28_REGNUM)
 347     {
 348       regnum = SPARC_F0_REGNUM + 4 * (regnum - SPARC64_Q0_REGNUM);
 349
 350       status = regcache_raw_read (regcache, regnum, buf);
 351       if (status == REG_VALID)
 352         status = regcache_raw_read (regcache, regnum + 1, buf + 4);
 353       if (status == REG_VALID)
 354         status = regcache_raw_read (regcache, regnum + 2, buf + 8);
 355       if (status == REG_VALID)
 356         status = regcache_raw_read (regcache, regnum + 3, buf + 12);
 357
 358       return status;
 359     }
 360   else if (regnum >= SPARC64_Q32_REGNUM && regnum <= SPARC64_Q60_REGNUM)
 361     {
 362       regnum = SPARC64_F32_REGNUM + 2 * (regnum - SPARC64_Q32_REGNUM);
 363
 364       status = regcache_raw_read (regcache, regnum, buf);
 365       if (status == REG_VALID)
 366         status = regcache_raw_read (regcache, regnum + 1, buf + 8);
 367
 368       return status;
 369     }
 370   else if (regnum == SPARC64_CWP_REGNUM
 371            || regnum == SPARC64_PSTATE_REGNUM
 372            || regnum == SPARC64_ASI_REGNUM
 373            || regnum == SPARC64_CCR_REGNUM)
 374     {
 375       ULONGEST state;
 376
 377       status = regcache_raw_read_unsigned (regcache, SPARC64_STATE_REGNUM, &state);
 378       if (status != REG_VALID)
 379         return status;
 380
 381       switch (regnum)
 382         {
 383         case SPARC64_CWP_REGNUM:
 384           state = (state >> 0) & ((1 << 5) - 1);
 385           break;
 386         case SPARC64_PSTATE_REGNUM:
 387           state = (state >> 8) & ((1 << 12) - 1);
 388           break;
 389         case SPARC64_ASI_REGNUM:
 390           state = (state >> 24) & ((1 << 8) - 1);
 391           break;
 392         case SPARC64_CCR_REGNUM:
 393           state = (state >> 32) & ((1 << 8) - 1);
 394           break;
 395         }
 396       store_unsigned_integer (buf, 8, byte_order, state);
 397     }
 398
 399   return REG_VALID;
 400 }
 401
 402 static void
 403 sparc64_pseudo_register_write (struct gdbarch *gdbarch,
 404                                struct regcache *regcache,
 405                                int regnum, const gdb_byte *buf)
 406 {
 407   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 408   gdb_assert (regnum >= SPARC64_NUM_REGS);
 409
 410   if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)
 411     {
 412       regnum = SPARC_F0_REGNUM + 2 * (regnum - SPARC64_D0_REGNUM);
 413       regcache_raw_write (regcache, regnum, buf);
 414       regcache_raw_write (regcache, regnum + 1, buf + 4);
 415     }
 416   else if (regnum >= SPARC64_D32_REGNUM && regnum <= SPARC64_D62_REGNUM)
 417     {
 418       regnum = SPARC64_F32_REGNUM + (regnum - SPARC64_D32_REGNUM);
 419       regcache_raw_write (regcache, regnum, buf);
 420     }
 421   else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q28_REGNUM)
 422     {
 423       regnum = SPARC_F0_REGNUM + 4 * (regnum - SPARC64_Q0_REGNUM);
 424       regcache_raw_write (regcache, regnum, buf);
 425       regcache_raw_write (regcache, regnum + 1, buf + 4);
 426       regcache_raw_write (regcache, regnum + 2, buf + 8);
 427       regcache_raw_write (regcache, regnum + 3, buf + 12);
 428     }
 429   else if (regnum >= SPARC64_Q32_REGNUM && regnum <= SPARC64_Q60_REGNUM)
 430     {
 431       regnum = SPARC64_F32_REGNUM + 2 * (regnum - SPARC64_Q32_REGNUM);
 432       regcache_raw_write (regcache, regnum, buf);
 433       regcache_raw_write (regcache, regnum + 1, buf + 8);
 434     }
 435   else if (regnum == SPARC64_CWP_REGNUM
 436            || regnum == SPARC64_PSTATE_REGNUM
 437            || regnum == SPARC64_ASI_REGNUM
 438            || regnum == SPARC64_CCR_REGNUM)
 439     {
 440       ULONGEST state, bits;
 441
 442       regcache_raw_read_unsigned (regcache, SPARC64_STATE_REGNUM, &state);
 443       bits = extract_unsigned_integer (buf, 8, byte_order);
 444       switch (regnum)
 445         {
 446         case SPARC64_CWP_REGNUM:
 447           state |= ((bits & ((1 << 5) - 1)) << 0);
 448           break;
 449         case SPARC64_PSTATE_REGNUM:
 450           state |= ((bits & ((1 << 12) - 1)) << 8);
 451           break;
 452         case SPARC64_ASI_REGNUM:
 453           state |= ((bits & ((1 << 8) - 1)) << 24);
 454           break;
 455         case SPARC64_CCR_REGNUM:
 456           state |= ((bits & ((1 << 8) - 1)) << 32);
 457           break;
 458         }
 459       regcache_raw_write_unsigned (regcache, SPARC64_STATE_REGNUM, state);
 460     }
 461 }
 462 \f
 463
 464 /* Return PC of first real instruction of the function starting at
 465    START_PC.  */
 466
 467 static CORE_ADDR
 468 sparc64_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
 469 {
 470   struct symtab_and_line sal;
 471   CORE_ADDR func_start, func_end;
 472   struct sparc_frame_cache cache;
 473
 474   /* This is the preferred method, find the end of the prologue by
 475      using the debugging information.  */
 476   if (find_pc_partial_function (start_pc, NULL, &func_start, &func_end))
 477     {
 478       sal = find_pc_line (func_start, 0);
 479
 480       if (sal.end < func_end
 481           && start_pc <= sal.end)
 482         return sal.end;
 483     }
 484
 485   return sparc_analyze_prologue (gdbarch, start_pc, 0xffffffffffffffffULL,
 486                                  &cache);
 487 }
 488
 489 /* Normal frames.  */
 490
 491 static struct sparc_frame_cache *
 492 sparc64_frame_cache (struct frame_info *this_frame, void **this_cache)
 493 {
 494   return sparc_frame_cache (this_frame, this_cache);
 495 }
 496
 497 static void
 498 sparc64_frame_this_id (struct frame_info *this_frame, void **this_cache,
 499                        struct frame_id *this_id)
 500 {
 501   struct sparc_frame_cache *cache =
 502     sparc64_frame_cache (this_frame, this_cache);
 503
 504   /* This marks the outermost frame.  */
 505   if (cache->base == 0)
 506     return;
 507
 508   (*this_id) = frame_id_build (cache->base, cache->pc);
 509 }
 510
 511 static struct value *
 512 sparc64_frame_prev_register (struct frame_info *this_frame, void **this_cache,
 513                              int regnum)
 514 {
 515   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 516   struct sparc_frame_cache *cache =
 517     sparc64_frame_cache (this_frame, this_cache);
 518
 519   if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
 520     {
 521       CORE_ADDR pc = (regnum == SPARC64_NPC_REGNUM) ? 4 : 0;
 522
 523       regnum = cache->frameless_p ? SPARC_O7_REGNUM : SPARC_I7_REGNUM;
 524       pc += get_frame_register_unsigned (this_frame, regnum) + 8;
 525       return frame_unwind_got_constant (this_frame, regnum, pc);
 526     }
 527
 528   /* Handle StackGhost.  */
 529   {
 530     ULONGEST wcookie = sparc_fetch_wcookie (gdbarch);
 531
 532     if (wcookie != 0 && !cache->frameless_p && regnum == SPARC_I7_REGNUM)
 533       {
 534         CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 8;
 535         ULONGEST i7;
 536
 537         /* Read the value in from memory.  */
 538         i7 = get_frame_memory_unsigned (this_frame, addr, 8);
 539         return frame_unwind_got_constant (this_frame, regnum, i7 ^ wcookie);
 540       }
 541   }
 542
 543   /* The previous frame's `local' and `in' registers have been saved
 544      in the register save area.  */
 545   if (!cache->frameless_p
 546       && regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM)
 547     {
 548       CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 8;
 549
 550       return frame_unwind_got_memory (this_frame, regnum, addr);
 551     }
 552
 553   /* The previous frame's `out' registers are accessable as the
 554      current frame's `in' registers.  */
 555   if (!cache->frameless_p
 556       && regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM)
 557     regnum += (SPARC_I0_REGNUM - SPARC_O0_REGNUM);
 558
 559   return frame_unwind_got_register (this_frame, regnum, regnum);
 560 }
 561
 562 static const struct frame_unwind sparc64_frame_unwind =
 563 {
 564   NORMAL_FRAME,
 565   default_frame_unwind_stop_reason,
 566   sparc64_frame_this_id,
 567   sparc64_frame_prev_register,
 568   NULL,
 569   default_frame_sniffer
 570 };
 571 \f
 572
 573 static CORE_ADDR
 574 sparc64_frame_base_address (struct frame_info *this_frame, void **this_cache)
 575 {
 576   struct sparc_frame_cache *cache =
 577     sparc64_frame_cache (this_frame, this_cache);
 578
 579   return cache->base;
 580 }
 581
 582 static const struct frame_base sparc64_frame_base =
 583 {
 584   &sparc64_frame_unwind,
 585   sparc64_frame_base_address,
 586   sparc64_frame_base_address,
 587   sparc64_frame_base_address
 588 };
 589 \f
 590 /* Check whether TYPE must be 16-byte aligned.  */
 591
 592 static int
 593 sparc64_16_byte_align_p (struct type *type)
 594 {
 595   if (sparc64_floating_p (type) && TYPE_LENGTH (type) == 16)
 596     return 1;
 597
 598   if (sparc64_structure_or_union_p (type))
 599     {
 600       int i;
 601
 602       for (i = 0; i < TYPE_NFIELDS (type); i++)
 603         {
 604           struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
 605
 606           if (sparc64_16_byte_align_p (subtype))
 607             return 1;
 608         }
 609     }
 610
 611   return 0;
 612 }
 613
 614 /* Store floating fields of element ELEMENT of an "parameter array"
 615    that has type TYPE and is stored at BITPOS in VALBUF in the
 616    apropriate registers of REGCACHE.  This function can be called
 617    recursively and therefore handles floating types in addition to
 618    structures.  */
 619
 620 static void
 621 sparc64_store_floating_fields (struct regcache *regcache, struct type *type,
 622                                const gdb_byte *valbuf, int element, int bitpos)
 623 {
 624   gdb_assert (element < 16);
 625
 626   if (sparc64_floating_p (type))
 627     {
 628       int len = TYPE_LENGTH (type);
 629       int regnum;
 630
 631       if (len == 16)
 632         {
 633           gdb_assert (bitpos == 0);
 634           gdb_assert ((element % 2) == 0);
 635
 636           regnum = SPARC64_Q0_REGNUM + element / 2;
 637           regcache_cooked_write (regcache, regnum, valbuf);
 638         }
 639       else if (len == 8)
 640         {
 641           gdb_assert (bitpos == 0 || bitpos == 64);
 642
 643           regnum = SPARC64_D0_REGNUM + element + bitpos / 64;
 644           regcache_cooked_write (regcache, regnum, valbuf + (bitpos / 8));
 645         }
 646       else
 647         {
 648           gdb_assert (len == 4);
 649           gdb_assert (bitpos % 32 == 0 && bitpos >= 0 && bitpos < 128);
 650
 651           regnum = SPARC_F0_REGNUM + element * 2 + bitpos / 32;
 652           regcache_cooked_write (regcache, regnum, valbuf + (bitpos / 8));
 653         }
 654     }
 655   else if (sparc64_structure_or_union_p (type))
 656     {
 657       int i;
 658
 659       for (i = 0; i < TYPE_NFIELDS (type); i++)
 660         {
 661           struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
 662           int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
 663
 664           sparc64_store_floating_fields (regcache, subtype, valbuf,
 665                                          element, subpos);
 666         }
 667
 668       /* GCC has an interesting bug.  If TYPE is a structure that has
 669          a single `float' member, GCC doesn't treat it as a structure
 670          at all, but rather as an ordinary `float' argument.  This
 671          argument will be stored in %f1, as required by the psABI.
 672          However, as a member of a structure the psABI requires it to
 673          be stored in %f0.  This bug is present in GCC 3.3.2, but
 674          probably in older releases to.  To appease GCC, if a
 675          structure has only a single `float' member, we store its
 676          value in %f1 too (we already have stored in %f0).  */
 677       if (TYPE_NFIELDS (type) == 1)
 678         {
 679           struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, 0));
 680
 681           if (sparc64_floating_p (subtype) && TYPE_LENGTH (subtype) == 4)
 682             regcache_cooked_write (regcache, SPARC_F1_REGNUM, valbuf);
 683         }
 684     }
 685 }
 686
 687 /* Fetch floating fields from a variable of type TYPE from the
 688    appropriate registers for BITPOS in REGCACHE and store it at BITPOS
 689    in VALBUF.  This function can be called recursively and therefore
 690    handles floating types in addition to structures.  */
 691
 692 static void
 693 sparc64_extract_floating_fields (struct regcache *regcache, struct type *type,
 694                                  gdb_byte *valbuf, int bitpos)
 695 {
 696   if (sparc64_floating_p (type))
 697     {
 698       int len = TYPE_LENGTH (type);
 699       int regnum;
 700
 701       if (len == 16)
 702         {
 703           gdb_assert (bitpos == 0 || bitpos == 128);
 704
 705           regnum = SPARC64_Q0_REGNUM + bitpos / 128;
 706           regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8));
 707         }
 708       else if (len == 8)
 709         {
 710           gdb_assert (bitpos % 64 == 0 && bitpos >= 0 && bitpos < 256);
 711
 712           regnum = SPARC64_D0_REGNUM + bitpos / 64;
 713           regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8));
 714         }
 715       else
 716         {
 717           gdb_assert (len == 4);
 718           gdb_assert (bitpos % 32 == 0 && bitpos >= 0 && bitpos < 256);
 719
 720           regnum = SPARC_F0_REGNUM + bitpos / 32;
 721           regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8));
 722         }
 723     }
 724   else if (sparc64_structure_or_union_p (type))
 725     {
 726       int i;
 727
 728       for (i = 0; i < TYPE_NFIELDS (type); i++)
 729         {
 730           struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
 731           int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
 732
 733           sparc64_extract_floating_fields (regcache, subtype, valbuf, subpos);
 734         }
 735     }
 736 }
 737
 738 /* Store the NARGS arguments ARGS and STRUCT_ADDR (if STRUCT_RETURN is
 739    non-zero) in REGCACHE and on the stack (starting from address SP).  */
 740
 741 static CORE_ADDR
 742 sparc64_store_arguments (struct regcache *regcache, int nargs,
 743                          struct value **args, CORE_ADDR sp,
 744                          int struct_return, CORE_ADDR struct_addr)
 745 {
 746   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 747   /* Number of extended words in the "parameter array".  */
 748   int num_elements = 0;
 749   int element = 0;
 750   int i;
 751
 752   /* Take BIAS into account.  */
 753   sp += BIAS;
 754
 755   /* First we calculate the number of extended words in the "parameter
 756      array".  While doing so we also convert some of the arguments.  */
 757
 758   if (struct_return)
 759     num_elements++;
 760
 761   for (i = 0; i < nargs; i++)
 762     {
 763       struct type *type = value_type (args[i]);
 764       int len = TYPE_LENGTH (type);
 765
 766       if (sparc64_structure_or_union_p (type))
 767         {
 768           /* Structure or Union arguments.  */
 769           if (len <= 16)
 770             {
 771               if (num_elements % 2 && sparc64_16_byte_align_p (type))
 772                 num_elements++;
 773               num_elements += ((len + 7) / 8);
 774             }
 775           else
 776             {
 777               /* The psABI says that "Structures or unions larger than
 778                  sixteen bytes are copied by the caller and passed
 779                  indirectly; the caller will pass the address of a
 780                  correctly aligned structure value.  This sixty-four
 781                  bit address will occupy one word in the parameter
 782                  array, and may be promoted to an %o register like any
 783                  other pointer value."  Allocate memory for these
 784                  values on the stack.  */
 785               sp -= len;
 786
 787               /* Use 16-byte alignment for these values.  That's
 788                  always correct, and wasting a few bytes shouldn't be
 789                  a problem.  */
 790               sp &= ~0xf;
 791
 792               write_memory (sp, value_contents (args[i]), len);
 793               args[i] = value_from_pointer (lookup_pointer_type (type), sp);
 794               num_elements++;
 795             }
 796         }
 797       else if (sparc64_floating_p (type))
 798         {
 799           /* Floating arguments.  */
 800
 801           if (len == 16)
 802             {
 803               /* The psABI says that "Each quad-precision parameter
 804                  value will be assigned to two extended words in the
 805                  parameter array.  */
 806               num_elements += 2;
 807
 808               /* The psABI says that "Long doubles must be
 809                  quad-aligned, and thus a hole might be introduced
 810                  into the parameter array to force alignment."  Skip
 811                  an element if necessary.  */
 812               if (num_elements % 2)
 813                 num_elements++;
 814             }
 815           else
 816             num_elements++;
 817         }
 818       else
 819         {
 820           /* Integral and pointer arguments.  */
 821           gdb_assert (sparc64_integral_or_pointer_p (type));
 822
 823           /* The psABI says that "Each argument value of integral type
 824              smaller than an extended word will be widened by the
 825              caller to an extended word according to the signed-ness
 826              of the argument type."  */
 827           if (len < 8)
 828             args[i] = value_cast (builtin_type (gdbarch)->builtin_int64,
 829                                   args[i]);
 830           num_elements++;
 831         }
 832     }
 833
 834   /* Allocate the "parameter array".  */
 835   sp -= num_elements * 8;
 836
 837   /* The psABI says that "Every stack frame must be 16-byte aligned."  */
 838   sp &= ~0xf;
 839
 840   /* Now we store the arguments in to the "paramater array".  Some
 841      Integer or Pointer arguments and Structure or Union arguments
 842      will be passed in %o registers.  Some Floating arguments and
 843      floating members of structures are passed in floating-point
 844      registers.  However, for functions with variable arguments,
 845      floating arguments are stored in an %0 register, and for
 846      functions without a prototype floating arguments are stored in
 847      both a floating-point and an %o registers, or a floating-point
 848      register and memory.  To simplify the logic here we always pass
 849      arguments in memory, an %o register, and a floating-point
 850      register if appropriate.  This should be no problem since the
 851      contents of any unused memory or registers in the "parameter
 852      array" are undefined.  */
 853
 854   if (struct_return)
 855     {
 856       regcache_cooked_write_unsigned (regcache, SPARC_O0_REGNUM, struct_addr);
 857       element++;
 858     }
 859
 860   for (i = 0; i < nargs; i++)
 861     {
 862       const gdb_byte *valbuf = value_contents (args[i]);
 863       struct type *type = value_type (args[i]);
 864       int len = TYPE_LENGTH (type);
 865       int regnum = -1;
 866       gdb_byte buf[16];
 867
 868       if (sparc64_structure_or_union_p (type))
 869         {
 870           /* Structure or Union arguments.  */
 871           gdb_assert (len <= 16);
 872           memset (buf, 0, sizeof (buf));
 873           valbuf = memcpy (buf, valbuf, len);
 874
 875           if (element % 2 && sparc64_16_byte_align_p (type))
 876             element++;
 877
 878           if (element < 6)
 879             {
 880               regnum = SPARC_O0_REGNUM + element;
 881               if (len > 8 && element < 5)
 882                 regcache_cooked_write (regcache, regnum + 1, valbuf + 8);
 883             }
 884
 885           if (element < 16)
 886             sparc64_store_floating_fields (regcache, type, valbuf, element, 0);
 887         }
 888       else if (sparc64_floating_p (type))
 889         {
 890           /* Floating arguments.  */
 891           if (len == 16)
 892             {
 893               if (element % 2)
 894                 element++;
 895               if (element < 16)
 896                 regnum = SPARC64_Q0_REGNUM + element / 2;
 897             }
 898           else if (len == 8)
 899             {
 900               if (element < 16)
 901                 regnum = SPARC64_D0_REGNUM + element;
 902             }
 903           else
 904             {
 905               /* The psABI says "Each single-precision parameter value
 906                  will be assigned to one extended word in the
 907                  parameter array, and right-justified within that
 908                  word; the left half (even floatregister) is
 909                  undefined."  Even though the psABI says that "the
 910                  left half is undefined", set it to zero here.  */
 911               memset (buf, 0, 4);
 912               memcpy (buf + 4, valbuf, 4);
 913               valbuf = buf;
 914               len = 8;
 915               if (element < 16)
 916                 regnum = SPARC64_D0_REGNUM + element;
 917             }
 918         }
 919       else
 920         {
 921           /* Integral and pointer arguments.  */
 922           gdb_assert (len == 8);
 923           if (element < 6)
 924             regnum = SPARC_O0_REGNUM + element;
 925         }
 926
 927       if (regnum != -1)
 928         {
 929           regcache_cooked_write (regcache, regnum, valbuf);
 930
 931           /* If we're storing the value in a floating-point register,
 932              also store it in the corresponding %0 register(s).  */
 933           if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D10_REGNUM)
 934             {
 935               gdb_assert (element < 6);
 936               regnum = SPARC_O0_REGNUM + element;
 937               regcache_cooked_write (regcache, regnum, valbuf);
 938             }
 939           else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q8_REGNUM)
 940             {
 941               gdb_assert (element < 6);
 942               regnum = SPARC_O0_REGNUM + element;
 943               regcache_cooked_write (regcache, regnum, valbuf);
 944               regcache_cooked_write (regcache, regnum + 1, valbuf + 8);
 945             }
 946         }
 947
 948       /* Always store the argument in memory.  */
 949       write_memory (sp + element * 8, valbuf, len);
 950       element += ((len + 7) / 8);
 951     }
 952
 953   gdb_assert (element == num_elements);
 954
 955   /* Take BIAS into account.  */
 956   sp -= BIAS;
 957   return sp;
 958 }
 959
 960 static CORE_ADDR
 961 sparc64_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
 962 {
 963   /* The ABI requires 16-byte alignment.  */
 964   return address & ~0xf;
 965 }
 966
 967 static CORE_ADDR
 968 sparc64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 969                          struct regcache *regcache, CORE_ADDR bp_addr,
 970                          int nargs, struct value **args, CORE_ADDR sp,
 971                          int struct_return, CORE_ADDR struct_addr)
 972 {
 973   /* Set return address.  */
 974   regcache_cooked_write_unsigned (regcache, SPARC_O7_REGNUM, bp_addr - 8);
 975
 976   /* Set up function arguments.  */
 977   sp = sparc64_store_arguments (regcache, nargs, args, sp,
 978                                 struct_return, struct_addr);
 979
 980   /* Allocate the register save area.  */
 981   sp -= 16 * 8;
 982
 983   /* Stack should be 16-byte aligned at this point.  */
 984   gdb_assert ((sp + BIAS) % 16 == 0);
 985
 986   /* Finally, update the stack pointer.  */
 987   regcache_cooked_write_unsigned (regcache, SPARC_SP_REGNUM, sp);
 988
 989   return sp + BIAS;
 990 }
 991 \f
 992
 993 /* Extract from an array REGBUF containing the (raw) register state, a
 994    function return value of TYPE, and copy that into VALBUF.  */
 995
 996 static void
 997 sparc64_extract_return_value (struct type *type, struct regcache *regcache,
 998                               gdb_byte *valbuf)
 999 {
1000   int len = TYPE_LENGTH (type);
1001   gdb_byte buf[32];
1002   int i;
1003
1004   if (sparc64_structure_or_union_p (type))
1005     {
1006       /* Structure or Union return values.  */
1007       gdb_assert (len <= 32);
1008
1009       for (i = 0; i < ((len + 7) / 8); i++)
1010         regcache_cooked_read (regcache, SPARC_O0_REGNUM + i, buf + i * 8);
1011       if (TYPE_CODE (type) != TYPE_CODE_UNION)
1012         sparc64_extract_floating_fields (regcache, type, buf, 0);
1013       memcpy (valbuf, buf, len);
1014     }
1015   else if (sparc64_floating_p (type))
1016     {
1017       /* Floating return values.  */
1018       for (i = 0; i < len / 4; i++)
1019         regcache_cooked_read (regcache, SPARC_F0_REGNUM + i, buf + i * 4);
1020       memcpy (valbuf, buf, len);
1021     }
1022   else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1023     {
1024       /* Small arrays are returned the same way as small structures.  */
1025       gdb_assert (len <= 32);
1026
1027       for (i = 0; i < ((len + 7) / 8); i++)
1028         regcache_cooked_read (regcache, SPARC_O0_REGNUM + i, buf + i * 8);
1029       memcpy (valbuf, buf, len);
1030     }
1031   else
1032     {
1033       /* Integral and pointer return values.  */
1034       gdb_assert (sparc64_integral_or_pointer_p (type));
1035
1036       /* Just stripping off any unused bytes should preserve the
1037          signed-ness just fine.  */
1038       regcache_cooked_read (regcache, SPARC_O0_REGNUM, buf);
1039       memcpy (valbuf, buf + 8 - len, len);
1040     }
1041 }
1042
1043 /* Write into the appropriate registers a function return value stored
1044    in VALBUF of type TYPE.  */
1045
1046 static void
1047 sparc64_store_return_value (struct type *type, struct regcache *regcache,
1048                             const gdb_byte *valbuf)
1049 {
1050   int len = TYPE_LENGTH (type);
1051   gdb_byte buf[16];
1052   int i;
1053
1054   if (sparc64_structure_or_union_p (type))
1055     {
1056       /* Structure or Union return values.  */
1057       gdb_assert (len <= 32);
1058
1059       /* Simplify matters by storing the complete value (including
1060          floating members) into %o0 and %o1.  Floating members are
1061          also store in the appropriate floating-point registers.  */
1062       memset (buf, 0, sizeof (buf));
1063       memcpy (buf, valbuf, len);
1064       for (i = 0; i < ((len + 7) / 8); i++)
1065         regcache_cooked_write (regcache, SPARC_O0_REGNUM + i, buf + i * 8);
1066       if (TYPE_CODE (type) != TYPE_CODE_UNION)
1067         sparc64_store_floating_fields (regcache, type, buf, 0, 0);
1068     }
1069   else if (sparc64_floating_p (type))
1070     {
1071       /* Floating return values.  */
1072       memcpy (buf, valbuf, len);
1073       for (i = 0; i < len / 4; i++)
1074         regcache_cooked_write (regcache, SPARC_F0_REGNUM + i, buf + i * 4);
1075     }
1076   else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1077     {
1078       /* Small arrays are returned the same way as small structures.  */
1079       gdb_assert (len <= 32);
1080
1081       memset (buf, 0, sizeof (buf));
1082       memcpy (buf, valbuf, len);
1083       for (i = 0; i < ((len + 7) / 8); i++)
1084         regcache_cooked_write (regcache, SPARC_O0_REGNUM + i, buf + i * 8);
1085     }
1086   else
1087     {
1088       /* Integral and pointer return values.  */
1089       gdb_assert (sparc64_integral_or_pointer_p (type));
1090
1091       /* ??? Do we need to do any sign-extension here?  */
1092       memset (buf, 0, 8);
1093       memcpy (buf + 8 - len, valbuf, len);
1094       regcache_cooked_write (regcache, SPARC_O0_REGNUM, buf);
1095     }
1096 }
1097
1098 static enum return_value_convention
1099 sparc64_return_value (struct gdbarch *gdbarch, struct type *func_type,
1100                       struct type *type, struct regcache *regcache,
1101                       gdb_byte *readbuf, const gdb_byte *writebuf)
1102 {
1103   if (TYPE_LENGTH (type) > 32)
1104     return RETURN_VALUE_STRUCT_CONVENTION;
1105
1106   if (readbuf)
1107     sparc64_extract_return_value (type, regcache, readbuf);
1108   if (writebuf)
1109     sparc64_store_return_value (type, regcache, writebuf);
1110
1111   return RETURN_VALUE_REGISTER_CONVENTION;
1112 }
1113 \f
1114
1115 static void
1116 sparc64_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
1117                                struct dwarf2_frame_state_reg *reg,
1118                                struct frame_info *this_frame)
1119 {
1120   switch (regnum)
1121     {
1122     case SPARC_G0_REGNUM:
1123       /* Since %g0 is always zero, there is no point in saving it, and
1124          people will be inclined omit it from the CFI.  Make sure we
1125          don't warn about that.  */
1126       reg->how = DWARF2_FRAME_REG_SAME_VALUE;
1127       break;
1128     case SPARC_SP_REGNUM:
1129       reg->how = DWARF2_FRAME_REG_CFA;
1130       break;
1131     case SPARC64_PC_REGNUM:
1132       reg->how = DWARF2_FRAME_REG_RA_OFFSET;
1133       reg->loc.offset = 8;
1134       break;
1135     case SPARC64_NPC_REGNUM:
1136       reg->how = DWARF2_FRAME_REG_RA_OFFSET;
1137       reg->loc.offset = 12;
1138       break;
1139     }
1140 }
1141
1142 void
1143 sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1144 {
1145   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1146
1147   tdep->pc_regnum = SPARC64_PC_REGNUM;
1148   tdep->npc_regnum = SPARC64_NPC_REGNUM;
1149
1150   /* This is what all the fuss is about.  */
1151   set_gdbarch_long_bit (gdbarch, 64);
1152   set_gdbarch_long_long_bit (gdbarch, 64);
1153   set_gdbarch_ptr_bit (gdbarch, 64);
1154
1155   set_gdbarch_num_regs (gdbarch, SPARC64_NUM_REGS);
1156   set_gdbarch_register_name (gdbarch, sparc64_register_name);
1157   set_gdbarch_register_type (gdbarch, sparc64_register_type);
1158   set_gdbarch_num_pseudo_regs (gdbarch, SPARC64_NUM_PSEUDO_REGS);
1159   set_gdbarch_pseudo_register_read (gdbarch, sparc64_pseudo_register_read);
1160   set_gdbarch_pseudo_register_write (gdbarch, sparc64_pseudo_register_write);
1161
1162   /* Register numbers of various important registers.  */
1163   set_gdbarch_pc_regnum (gdbarch, SPARC64_PC_REGNUM); /* %pc */
1164
1165   /* Call dummy code.  */
1166   set_gdbarch_frame_align (gdbarch, sparc64_frame_align);
1167   set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
1168   set_gdbarch_push_dummy_code (gdbarch, NULL);
1169   set_gdbarch_push_dummy_call (gdbarch, sparc64_push_dummy_call);
1170
1171   set_gdbarch_return_value (gdbarch, sparc64_return_value);
1172   set_gdbarch_stabs_argument_has_addr
1173     (gdbarch, default_stabs_argument_has_addr);
1174
1175   set_gdbarch_skip_prologue (gdbarch, sparc64_skip_prologue);
1176
1177   /* Hook in the DWARF CFI frame unwinder.  */
1178   dwarf2_frame_set_init_reg (gdbarch, sparc64_dwarf2_frame_init_reg);
1179   /* FIXME: kettenis/20050423: Don't enable the unwinder until the
1180      StackGhost issues have been resolved.  */
1181
1182   frame_unwind_append_unwinder (gdbarch, &sparc64_frame_unwind);
1183   frame_base_set_default (gdbarch, &sparc64_frame_base);
1184 }
1185 \f
1186
1187 /* Helper functions for dealing with register sets.  */
1188
1189 #define TSTATE_CWP      0x000000000000001fULL
1190 #define TSTATE_ICC      0x0000000f00000000ULL
1191 #define TSTATE_XCC      0x000000f000000000ULL
1192
1193 #define PSR_S           0x00000080
1194 #define PSR_ICC         0x00f00000
1195 #define PSR_VERS        0x0f000000
1196 #define PSR_IMPL        0xf0000000
1197 #define PSR_V8PLUS      0xff000000
1198 #define PSR_XCC         0x000f0000
1199
1200 void
1201 sparc64_supply_gregset (const struct sparc_gregset *gregset,
1202                         struct regcache *regcache,
1203                         int regnum, const void *gregs)
1204 {
1205   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1206   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1207   int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32);
1208   const gdb_byte *regs = gregs;
1209   gdb_byte zero[8] = { 0 };
1210   int i;
1211
1212   if (sparc32)
1213     {
1214       if (regnum == SPARC32_PSR_REGNUM || regnum == -1)
1215         {
1216           int offset = gregset->r_tstate_offset;
1217           ULONGEST tstate, psr;
1218           gdb_byte buf[4];
1219
1220           tstate = extract_unsigned_integer (regs + offset, 8, byte_order);
1221           psr = ((tstate & TSTATE_CWP) | PSR_S | ((tstate & TSTATE_ICC) >> 12)
1222                  | ((tstate & TSTATE_XCC) >> 20) | PSR_V8PLUS);
1223           store_unsigned_integer (buf, 4, byte_order, psr);
1224           regcache_raw_supply (regcache, SPARC32_PSR_REGNUM, buf);
1225         }
1226
1227       if (regnum == SPARC32_PC_REGNUM || regnum == -1)
1228         regcache_raw_supply (regcache, SPARC32_PC_REGNUM,
1229                              regs + gregset->r_pc_offset + 4);
1230
1231       if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
1232         regcache_raw_supply (regcache, SPARC32_NPC_REGNUM,
1233                              regs + gregset->r_npc_offset + 4);
1234
1235       if (regnum == SPARC32_Y_REGNUM || regnum == -1)
1236         {
1237           int offset = gregset->r_y_offset + 8 - gregset->r_y_size;
1238           regcache_raw_supply (regcache, SPARC32_Y_REGNUM, regs + offset);
1239         }
1240     }
1241   else
1242     {
1243       if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
1244         regcache_raw_supply (regcache, SPARC64_STATE_REGNUM,
1245                              regs + gregset->r_tstate_offset);
1246
1247       if (regnum == SPARC64_PC_REGNUM || regnum == -1)
1248         regcache_raw_supply (regcache, SPARC64_PC_REGNUM,
1249                              regs + gregset->r_pc_offset);
1250
1251       if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
1252         regcache_raw_supply (regcache, SPARC64_NPC_REGNUM,
1253                              regs + gregset->r_npc_offset);
1254
1255       if (regnum == SPARC64_Y_REGNUM || regnum == -1)
1256         {
1257           gdb_byte buf[8];
1258
1259           memset (buf, 0, 8);
1260           memcpy (buf + 8 - gregset->r_y_size,
1261                   regs + gregset->r_y_offset, gregset->r_y_size);
1262           regcache_raw_supply (regcache, SPARC64_Y_REGNUM, buf);
1263         }
1264
1265       if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
1266           && gregset->r_fprs_offset != -1)
1267         regcache_raw_supply (regcache, SPARC64_FPRS_REGNUM,
1268                              regs + gregset->r_fprs_offset);
1269     }
1270
1271   if (regnum == SPARC_G0_REGNUM || regnum == -1)
1272     regcache_raw_supply (regcache, SPARC_G0_REGNUM, &zero);
1273
1274   if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
1275     {
1276       int offset = gregset->r_g1_offset;
1277
1278       if (sparc32)
1279         offset += 4;
1280
1281       for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
1282         {
1283           if (regnum == i || regnum == -1)
1284             regcache_raw_supply (regcache, i, regs + offset);
1285           offset += 8;
1286         }
1287     }
1288
1289   if ((regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM) || regnum == -1)
1290     {
1291       /* Not all of the register set variants include Locals and
1292          Inputs.  For those that don't, we read them off the stack.  */
1293       if (gregset->r_l0_offset == -1)
1294         {
1295           ULONGEST sp;
1296
1297           regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp);
1298           sparc_supply_rwindow (regcache, sp, regnum);
1299         }
1300       else
1301         {
1302           int offset = gregset->r_l0_offset;
1303
1304           if (sparc32)
1305             offset += 4;
1306
1307           for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
1308             {
1309               if (regnum == i || regnum == -1)
1310                 regcache_raw_supply (regcache, i, regs + offset);
1311               offset += 8;
1312             }
1313         }
1314     }
1315 }
1316
1317 void
1318 sparc64_collect_gregset (const struct sparc_gregset *gregset,
1319                          const struct regcache *regcache,
1320                          int regnum, void *gregs)
1321 {
1322   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1323   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1324   int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32);
1325   gdb_byte *regs = gregs;
1326   int i;
1327
1328   if (sparc32)
1329     {
1330       if (regnum == SPARC32_PSR_REGNUM || regnum == -1)
1331         {
1332           int offset = gregset->r_tstate_offset;
1333           ULONGEST tstate, psr;
1334           gdb_byte buf[8];
1335
1336           tstate = extract_unsigned_integer (regs + offset, 8, byte_order);
1337           regcache_raw_collect (regcache, SPARC32_PSR_REGNUM, buf);
1338           psr = extract_unsigned_integer (buf, 4, byte_order);
1339           tstate |= (psr & PSR_ICC) << 12;
1340           if ((psr & (PSR_VERS | PSR_IMPL)) == PSR_V8PLUS)
1341             tstate |= (psr & PSR_XCC) << 20;
1342           store_unsigned_integer (buf, 8, byte_order, tstate);
1343           memcpy (regs + offset, buf, 8);
1344         }
1345
1346       if (regnum == SPARC32_PC_REGNUM || regnum == -1)
1347         regcache_raw_collect (regcache, SPARC32_PC_REGNUM,
1348                               regs + gregset->r_pc_offset + 4);
1349
1350       if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
1351         regcache_raw_collect (regcache, SPARC32_NPC_REGNUM,
1352                               regs + gregset->r_npc_offset + 4);
1353
1354       if (regnum == SPARC32_Y_REGNUM || regnum == -1)
1355         {
1356           int offset = gregset->r_y_offset + 8 - gregset->r_y_size;
1357           regcache_raw_collect (regcache, SPARC32_Y_REGNUM, regs + offset);
1358         }
1359     }
1360   else
1361     {
1362       if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
1363         regcache_raw_collect (regcache, SPARC64_STATE_REGNUM,
1364                               regs + gregset->r_tstate_offset);
1365
1366       if (regnum == SPARC64_PC_REGNUM || regnum == -1)
1367         regcache_raw_collect (regcache, SPARC64_PC_REGNUM,
1368                               regs + gregset->r_pc_offset);
1369
1370       if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
1371         regcache_raw_collect (regcache, SPARC64_NPC_REGNUM,
1372                               regs + gregset->r_npc_offset);
1373
1374       if (regnum == SPARC64_Y_REGNUM || regnum == -1)
1375         {
1376           gdb_byte buf[8];
1377
1378           regcache_raw_collect (regcache, SPARC64_Y_REGNUM, buf);
1379           memcpy (regs + gregset->r_y_offset,
1380                   buf + 8 - gregset->r_y_size, gregset->r_y_size);
1381         }
1382
1383       if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
1384           && gregset->r_fprs_offset != -1)
1385         regcache_raw_collect (regcache, SPARC64_FPRS_REGNUM,
1386                               regs + gregset->r_fprs_offset);
1387
1388     }
1389
1390   if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
1391     {
1392       int offset = gregset->r_g1_offset;
1393
1394       if (sparc32)
1395         offset += 4;
1396
1397       /* %g0 is always zero.  */
1398       for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
1399         {
1400           if (regnum == i || regnum == -1)
1401             regcache_raw_collect (regcache, i, regs + offset);
1402           offset += 8;
1403         }
1404     }
1405
1406   if ((regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM) || regnum == -1)
1407     {
1408       /* Not all of the register set variants include Locals and
1409          Inputs.  For those that don't, we read them off the stack.  */
1410       if (gregset->r_l0_offset != -1)
1411         {
1412           int offset = gregset->r_l0_offset;
1413
1414           if (sparc32)
1415             offset += 4;
1416
1417           for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
1418             {
1419               if (regnum == i || regnum == -1)
1420                 regcache_raw_collect (regcache, i, regs + offset);
1421               offset += 8;
1422             }
1423         }
1424     }
1425 }
1426
1427 void
1428 sparc64_supply_fpregset (struct regcache *regcache,
1429                          int regnum, const void *fpregs)
1430 {
1431   int sparc32 = (gdbarch_ptr_bit (get_regcache_arch (regcache)) == 32);
1432   const gdb_byte *regs = fpregs;
1433   int i;
1434
1435   for (i = 0; i < 32; i++)
1436     {
1437       if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
1438         regcache_raw_supply (regcache, SPARC_F0_REGNUM + i, regs + (i * 4));
1439     }
1440
1441   if (sparc32)
1442     {
1443       if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
1444         regcache_raw_supply (regcache, SPARC32_FSR_REGNUM,
1445                              regs + (32 * 4) + (16 * 8) + 4);
1446     }
1447   else
1448     {
1449       for (i = 0; i < 16; i++)
1450         {
1451           if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
1452             regcache_raw_supply (regcache, SPARC64_F32_REGNUM + i,
1453                                  regs + (32 * 4) + (i * 8));
1454         }
1455
1456       if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
1457         regcache_raw_supply (regcache, SPARC64_FSR_REGNUM,
1458                              regs + (32 * 4) + (16 * 8));
1459     }
1460 }
1461
1462 void
1463 sparc64_collect_fpregset (const struct regcache *regcache,
1464                           int regnum, void *fpregs)
1465 {
1466   int sparc32 = (gdbarch_ptr_bit (get_regcache_arch (regcache)) == 32);
1467   gdb_byte *regs = fpregs;
1468   int i;
1469
1470   for (i = 0; i < 32; i++)
1471     {
1472       if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
1473         regcache_raw_collect (regcache, SPARC_F0_REGNUM + i, regs + (i * 4));
1474     }
1475
1476   if (sparc32)
1477     {
1478       if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
1479         regcache_raw_collect (regcache, SPARC32_FSR_REGNUM,
1480                               regs + (32 * 4) + (16 * 8) + 4);
1481     }
1482   else
1483     {
1484       for (i = 0; i < 16; i++)
1485         {
1486           if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
1487             regcache_raw_collect (regcache, SPARC64_F32_REGNUM + i,
1488                                   regs + (32 * 4) + (i * 8));
1489         }
1490
1491       if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
1492         regcache_raw_collect (regcache, SPARC64_FSR_REGNUM,
1493                               regs + (32 * 4) + (16 * 8));
1494     }
1495 }
1496