gdb/sparc64-tdep.c

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