1 /* Target-dependent code for UltraSPARC.
3 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 This file is part of GDB.
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.
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.
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/>. */
22 #include "arch-utils.h"
23 #include "dwarf2-frame.h"
24 #include "floatformat.h"
26 #include "frame-base.h"
27 #include "frame-unwind.h"
38 #include "gdb_assert.h"
39 #include "gdb_string.h"
41 #include "sparc64-tdep.h"
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
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. */
52 /* The functions on this page are intended to be used to classify
53 function arguments. */
55 /* Check whether TYPE is "Integral or Pointer". */
58 sparc64_integral_or_pointer_p (const struct type
*type
)
60 switch (TYPE_CODE (type
))
68 int len
= TYPE_LENGTH (type
);
69 gdb_assert (len
== 1 || len
== 2 || len
== 4 || len
== 8);
75 int len
= TYPE_LENGTH (type
);
76 gdb_assert (len
== 8);
86 /* Check whether TYPE is "Floating". */
89 sparc64_floating_p (const struct type
*type
)
91 switch (TYPE_CODE (type
))
95 int len
= TYPE_LENGTH (type
);
96 gdb_assert (len
== 4 || len
== 8 || len
== 16);
106 /* Check whether TYPE is "Structure or Union".
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
113 sparc64_structure_or_union_p (const struct type
*type
)
115 switch (TYPE_CODE (type
))
117 case TYPE_CODE_STRUCT
:
118 case TYPE_CODE_UNION
:
119 case TYPE_CODE_ARRAY
:
129 /* Construct types for ISA-specific registers. */
132 sparc64_pstate_type (struct gdbarch
*gdbarch
)
134 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
136 if (!tdep
->sparc64_pstate_type
)
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");
152 tdep
->sparc64_pstate_type
= type
;
155 return tdep
->sparc64_pstate_type
;
159 sparc64_fsr_type (struct gdbarch
*gdbarch
)
161 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
163 if (!tdep
->sparc64_fsr_type
)
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");
185 tdep
->sparc64_fsr_type
= type
;
188 return tdep
->sparc64_fsr_type
;
192 sparc64_fprs_type (struct gdbarch
*gdbarch
)
194 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
196 if (!tdep
->sparc64_fprs_type
)
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");
205 tdep
->sparc64_fprs_type
= type
;
208 return tdep
->sparc64_fprs_type
;
212 /* Register information. */
214 static const char *sparc64_register_names
[] =
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",
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",
230 /* FIXME: Give "state" a name until we start using register groups. */
237 /* Total number of registers. */
238 #define SPARC64_NUM_REGS ARRAY_SIZE (sparc64_register_names)
240 /* We provide the aliases %d0..%d62 and %q0..%q60 for the floating
241 registers as "psuedo" registers. */
243 static const char *sparc64_pseudo_register_names
[] =
245 "cwp", "pstate", "asi", "ccr",
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",
252 "q0", "q4", "q8", "q12", "q16", "q20", "q24", "q28",
253 "q32", "q36", "q40", "q44", "q48", "q52", "q56", "q60",
256 /* Total number of pseudo registers. */
257 #define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_names)
259 /* Return the name of register REGNUM. */
262 sparc64_register_name (struct gdbarch
*gdbarch
, int regnum
)
264 if (regnum
>= 0 && regnum
< SPARC64_NUM_REGS
)
265 return sparc64_register_names
[regnum
];
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
];
274 /* Return the GDB type object for the "standard" data type of data in
278 sparc64_register_type (struct gdbarch
*gdbarch
, int regnum
)
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
;
305 /* Pseudo registers. */
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
;
320 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
323 static enum register_status
324 sparc64_pseudo_register_read (struct gdbarch
*gdbarch
,
325 struct regcache
*regcache
,
326 int regnum
, gdb_byte
*buf
)
328 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
329 enum register_status status
;
331 gdb_assert (regnum
>= SPARC64_NUM_REGS
);
333 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D30_REGNUM
)
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);
341 else if (regnum
>= SPARC64_D32_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
343 regnum
= SPARC64_F32_REGNUM
+ (regnum
- SPARC64_D32_REGNUM
);
344 return regcache_raw_read (regcache
, regnum
, buf
);
346 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q28_REGNUM
)
348 regnum
= SPARC_F0_REGNUM
+ 4 * (regnum
- SPARC64_Q0_REGNUM
);
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);
360 else if (regnum
>= SPARC64_Q32_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
362 regnum
= SPARC64_F32_REGNUM
+ 2 * (regnum
- SPARC64_Q32_REGNUM
);
364 status
= regcache_raw_read (regcache
, regnum
, buf
);
365 if (status
== REG_VALID
)
366 status
= regcache_raw_read (regcache
, regnum
+ 1, buf
+ 8);
370 else if (regnum
== SPARC64_CWP_REGNUM
371 || regnum
== SPARC64_PSTATE_REGNUM
372 || regnum
== SPARC64_ASI_REGNUM
373 || regnum
== SPARC64_CCR_REGNUM
)
377 status
= regcache_raw_read_unsigned (regcache
, SPARC64_STATE_REGNUM
, &state
);
378 if (status
!= REG_VALID
)
383 case SPARC64_CWP_REGNUM
:
384 state
= (state
>> 0) & ((1 << 5) - 1);
386 case SPARC64_PSTATE_REGNUM
:
387 state
= (state
>> 8) & ((1 << 12) - 1);
389 case SPARC64_ASI_REGNUM
:
390 state
= (state
>> 24) & ((1 << 8) - 1);
392 case SPARC64_CCR_REGNUM
:
393 state
= (state
>> 32) & ((1 << 8) - 1);
396 store_unsigned_integer (buf
, 8, byte_order
, state
);
403 sparc64_pseudo_register_write (struct gdbarch
*gdbarch
,
404 struct regcache
*regcache
,
405 int regnum
, const gdb_byte
*buf
)
407 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
408 gdb_assert (regnum
>= SPARC64_NUM_REGS
);
410 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D30_REGNUM
)
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);
416 else if (regnum
>= SPARC64_D32_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
418 regnum
= SPARC64_F32_REGNUM
+ (regnum
- SPARC64_D32_REGNUM
);
419 regcache_raw_write (regcache
, regnum
, buf
);
421 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q28_REGNUM
)
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);
429 else if (regnum
>= SPARC64_Q32_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
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);
435 else if (regnum
== SPARC64_CWP_REGNUM
436 || regnum
== SPARC64_PSTATE_REGNUM
437 || regnum
== SPARC64_ASI_REGNUM
438 || regnum
== SPARC64_CCR_REGNUM
)
440 ULONGEST state
, bits
;
442 regcache_raw_read_unsigned (regcache
, SPARC64_STATE_REGNUM
, &state
);
443 bits
= extract_unsigned_integer (buf
, 8, byte_order
);
446 case SPARC64_CWP_REGNUM
:
447 state
|= ((bits
& ((1 << 5) - 1)) << 0);
449 case SPARC64_PSTATE_REGNUM
:
450 state
|= ((bits
& ((1 << 12) - 1)) << 8);
452 case SPARC64_ASI_REGNUM
:
453 state
|= ((bits
& ((1 << 8) - 1)) << 24);
455 case SPARC64_CCR_REGNUM
:
456 state
|= ((bits
& ((1 << 8) - 1)) << 32);
459 regcache_raw_write_unsigned (regcache
, SPARC64_STATE_REGNUM
, state
);
464 /* Return PC of first real instruction of the function starting at
468 sparc64_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR start_pc
)
470 struct symtab_and_line sal
;
471 CORE_ADDR func_start
, func_end
;
472 struct sparc_frame_cache cache
;
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
))
478 sal
= find_pc_line (func_start
, 0);
480 if (sal
.end
< func_end
481 && start_pc
<= sal
.end
)
485 return sparc_analyze_prologue (gdbarch
, start_pc
, 0xffffffffffffffffULL
,
491 static struct sparc_frame_cache
*
492 sparc64_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
494 return sparc_frame_cache (this_frame
, this_cache
);
498 sparc64_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
499 struct frame_id
*this_id
)
501 struct sparc_frame_cache
*cache
=
502 sparc64_frame_cache (this_frame
, this_cache
);
504 /* This marks the outermost frame. */
505 if (cache
->base
== 0)
508 (*this_id
) = frame_id_build (cache
->base
, cache
->pc
);
511 static struct value
*
512 sparc64_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
515 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
516 struct sparc_frame_cache
*cache
=
517 sparc64_frame_cache (this_frame
, this_cache
);
519 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== SPARC64_NPC_REGNUM
)
521 CORE_ADDR pc
= (regnum
== SPARC64_NPC_REGNUM
) ? 4 : 0;
524 (cache
->copied_regs_mask
& 0x80) ? SPARC_I7_REGNUM
: SPARC_O7_REGNUM
;
525 pc
+= get_frame_register_unsigned (this_frame
, regnum
) + 8;
526 return frame_unwind_got_constant (this_frame
, regnum
, pc
);
529 /* Handle StackGhost. */
531 ULONGEST wcookie
= sparc_fetch_wcookie (gdbarch
);
533 if (wcookie
!= 0 && !cache
->frameless_p
&& regnum
== SPARC_I7_REGNUM
)
535 CORE_ADDR addr
= cache
->base
+ (regnum
- SPARC_L0_REGNUM
) * 8;
538 /* Read the value in from memory. */
539 i7
= get_frame_memory_unsigned (this_frame
, addr
, 8);
540 return frame_unwind_got_constant (this_frame
, regnum
, i7
^ wcookie
);
544 /* The previous frame's `local' and `in' registers may have been saved
545 in the register save area. */
546 if (regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
547 && (cache
->saved_regs_mask
& (1 << (regnum
- SPARC_L0_REGNUM
))))
549 CORE_ADDR addr
= cache
->base
+ (regnum
- SPARC_L0_REGNUM
) * 8;
551 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
554 /* The previous frame's `out' registers may be accessible as the current
555 frame's `in' registers. */
556 if (regnum
>= SPARC_O0_REGNUM
&& regnum
<= SPARC_O7_REGNUM
557 && (cache
->copied_regs_mask
& (1 << (regnum
- SPARC_O0_REGNUM
))))
558 regnum
+= (SPARC_I0_REGNUM
- SPARC_O0_REGNUM
);
560 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
563 static const struct frame_unwind sparc64_frame_unwind
=
566 default_frame_unwind_stop_reason
,
567 sparc64_frame_this_id
,
568 sparc64_frame_prev_register
,
570 default_frame_sniffer
575 sparc64_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
577 struct sparc_frame_cache
*cache
=
578 sparc64_frame_cache (this_frame
, this_cache
);
583 static const struct frame_base sparc64_frame_base
=
585 &sparc64_frame_unwind
,
586 sparc64_frame_base_address
,
587 sparc64_frame_base_address
,
588 sparc64_frame_base_address
591 /* Check whether TYPE must be 16-byte aligned. */
594 sparc64_16_byte_align_p (struct type
*type
)
596 if (sparc64_floating_p (type
) && TYPE_LENGTH (type
) == 16)
599 if (sparc64_structure_or_union_p (type
))
603 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
605 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
607 if (sparc64_16_byte_align_p (subtype
))
615 /* Store floating fields of element ELEMENT of an "parameter array"
616 that has type TYPE and is stored at BITPOS in VALBUF in the
617 apropriate registers of REGCACHE. This function can be called
618 recursively and therefore handles floating types in addition to
622 sparc64_store_floating_fields (struct regcache
*regcache
, struct type
*type
,
623 const gdb_byte
*valbuf
, int element
, int bitpos
)
625 gdb_assert (element
< 16);
627 if (sparc64_floating_p (type
))
629 int len
= TYPE_LENGTH (type
);
634 gdb_assert (bitpos
== 0);
635 gdb_assert ((element
% 2) == 0);
637 regnum
= SPARC64_Q0_REGNUM
+ element
/ 2;
638 regcache_cooked_write (regcache
, regnum
, valbuf
);
642 gdb_assert (bitpos
== 0 || bitpos
== 64);
644 regnum
= SPARC64_D0_REGNUM
+ element
+ bitpos
/ 64;
645 regcache_cooked_write (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
649 gdb_assert (len
== 4);
650 gdb_assert (bitpos
% 32 == 0 && bitpos
>= 0 && bitpos
< 128);
652 regnum
= SPARC_F0_REGNUM
+ element
* 2 + bitpos
/ 32;
653 regcache_cooked_write (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
656 else if (sparc64_structure_or_union_p (type
))
660 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
662 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
663 int subpos
= bitpos
+ TYPE_FIELD_BITPOS (type
, i
);
665 sparc64_store_floating_fields (regcache
, subtype
, valbuf
,
669 /* GCC has an interesting bug. If TYPE is a structure that has
670 a single `float' member, GCC doesn't treat it as a structure
671 at all, but rather as an ordinary `float' argument. This
672 argument will be stored in %f1, as required by the psABI.
673 However, as a member of a structure the psABI requires it to
674 be stored in %f0. This bug is present in GCC 3.3.2, but
675 probably in older releases to. To appease GCC, if a
676 structure has only a single `float' member, we store its
677 value in %f1 too (we already have stored in %f0). */
678 if (TYPE_NFIELDS (type
) == 1)
680 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
682 if (sparc64_floating_p (subtype
) && TYPE_LENGTH (subtype
) == 4)
683 regcache_cooked_write (regcache
, SPARC_F1_REGNUM
, valbuf
);
688 /* Fetch floating fields from a variable of type TYPE from the
689 appropriate registers for BITPOS in REGCACHE and store it at BITPOS
690 in VALBUF. This function can be called recursively and therefore
691 handles floating types in addition to structures. */
694 sparc64_extract_floating_fields (struct regcache
*regcache
, struct type
*type
,
695 gdb_byte
*valbuf
, int bitpos
)
697 if (sparc64_floating_p (type
))
699 int len
= TYPE_LENGTH (type
);
704 gdb_assert (bitpos
== 0 || bitpos
== 128);
706 regnum
= SPARC64_Q0_REGNUM
+ bitpos
/ 128;
707 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
711 gdb_assert (bitpos
% 64 == 0 && bitpos
>= 0 && bitpos
< 256);
713 regnum
= SPARC64_D0_REGNUM
+ bitpos
/ 64;
714 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
718 gdb_assert (len
== 4);
719 gdb_assert (bitpos
% 32 == 0 && bitpos
>= 0 && bitpos
< 256);
721 regnum
= SPARC_F0_REGNUM
+ bitpos
/ 32;
722 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
725 else if (sparc64_structure_or_union_p (type
))
729 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
731 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
732 int subpos
= bitpos
+ TYPE_FIELD_BITPOS (type
, i
);
734 sparc64_extract_floating_fields (regcache
, subtype
, valbuf
, subpos
);
739 /* Store the NARGS arguments ARGS and STRUCT_ADDR (if STRUCT_RETURN is
740 non-zero) in REGCACHE and on the stack (starting from address SP). */
743 sparc64_store_arguments (struct regcache
*regcache
, int nargs
,
744 struct value
**args
, CORE_ADDR sp
,
745 int struct_return
, CORE_ADDR struct_addr
)
747 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
748 /* Number of extended words in the "parameter array". */
749 int num_elements
= 0;
753 /* Take BIAS into account. */
756 /* First we calculate the number of extended words in the "parameter
757 array". While doing so we also convert some of the arguments. */
762 for (i
= 0; i
< nargs
; i
++)
764 struct type
*type
= value_type (args
[i
]);
765 int len
= TYPE_LENGTH (type
);
767 if (sparc64_structure_or_union_p (type
))
769 /* Structure or Union arguments. */
772 if (num_elements
% 2 && sparc64_16_byte_align_p (type
))
774 num_elements
+= ((len
+ 7) / 8);
778 /* The psABI says that "Structures or unions larger than
779 sixteen bytes are copied by the caller and passed
780 indirectly; the caller will pass the address of a
781 correctly aligned structure value. This sixty-four
782 bit address will occupy one word in the parameter
783 array, and may be promoted to an %o register like any
784 other pointer value." Allocate memory for these
785 values on the stack. */
788 /* Use 16-byte alignment for these values. That's
789 always correct, and wasting a few bytes shouldn't be
793 write_memory (sp
, value_contents (args
[i
]), len
);
794 args
[i
] = value_from_pointer (lookup_pointer_type (type
), sp
);
798 else if (sparc64_floating_p (type
))
800 /* Floating arguments. */
804 /* The psABI says that "Each quad-precision parameter
805 value will be assigned to two extended words in the
809 /* The psABI says that "Long doubles must be
810 quad-aligned, and thus a hole might be introduced
811 into the parameter array to force alignment." Skip
812 an element if necessary. */
813 if (num_elements
% 2)
821 /* Integral and pointer arguments. */
822 gdb_assert (sparc64_integral_or_pointer_p (type
));
824 /* The psABI says that "Each argument value of integral type
825 smaller than an extended word will be widened by the
826 caller to an extended word according to the signed-ness
827 of the argument type." */
829 args
[i
] = value_cast (builtin_type (gdbarch
)->builtin_int64
,
835 /* Allocate the "parameter array". */
836 sp
-= num_elements
* 8;
838 /* The psABI says that "Every stack frame must be 16-byte aligned." */
841 /* Now we store the arguments in to the "paramater array". Some
842 Integer or Pointer arguments and Structure or Union arguments
843 will be passed in %o registers. Some Floating arguments and
844 floating members of structures are passed in floating-point
845 registers. However, for functions with variable arguments,
846 floating arguments are stored in an %0 register, and for
847 functions without a prototype floating arguments are stored in
848 both a floating-point and an %o registers, or a floating-point
849 register and memory. To simplify the logic here we always pass
850 arguments in memory, an %o register, and a floating-point
851 register if appropriate. This should be no problem since the
852 contents of any unused memory or registers in the "parameter
853 array" are undefined. */
857 regcache_cooked_write_unsigned (regcache
, SPARC_O0_REGNUM
, struct_addr
);
861 for (i
= 0; i
< nargs
; i
++)
863 const gdb_byte
*valbuf
= value_contents (args
[i
]);
864 struct type
*type
= value_type (args
[i
]);
865 int len
= TYPE_LENGTH (type
);
869 if (sparc64_structure_or_union_p (type
))
871 /* Structure or Union arguments. */
872 gdb_assert (len
<= 16);
873 memset (buf
, 0, sizeof (buf
));
874 valbuf
= memcpy (buf
, valbuf
, len
);
876 if (element
% 2 && sparc64_16_byte_align_p (type
))
881 regnum
= SPARC_O0_REGNUM
+ element
;
882 if (len
> 8 && element
< 5)
883 regcache_cooked_write (regcache
, regnum
+ 1, valbuf
+ 8);
887 sparc64_store_floating_fields (regcache
, type
, valbuf
, element
, 0);
889 else if (sparc64_floating_p (type
))
891 /* Floating arguments. */
897 regnum
= SPARC64_Q0_REGNUM
+ element
/ 2;
902 regnum
= SPARC64_D0_REGNUM
+ element
;
906 /* The psABI says "Each single-precision parameter value
907 will be assigned to one extended word in the
908 parameter array, and right-justified within that
909 word; the left half (even floatregister) is
910 undefined." Even though the psABI says that "the
911 left half is undefined", set it to zero here. */
913 memcpy (buf
+ 4, valbuf
, 4);
917 regnum
= SPARC64_D0_REGNUM
+ element
;
922 /* Integral and pointer arguments. */
923 gdb_assert (len
== 8);
925 regnum
= SPARC_O0_REGNUM
+ element
;
930 regcache_cooked_write (regcache
, regnum
, valbuf
);
932 /* If we're storing the value in a floating-point register,
933 also store it in the corresponding %0 register(s). */
934 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D10_REGNUM
)
936 gdb_assert (element
< 6);
937 regnum
= SPARC_O0_REGNUM
+ element
;
938 regcache_cooked_write (regcache
, regnum
, valbuf
);
940 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q8_REGNUM
)
942 gdb_assert (element
< 6);
943 regnum
= SPARC_O0_REGNUM
+ element
;
944 regcache_cooked_write (regcache
, regnum
, valbuf
);
945 regcache_cooked_write (regcache
, regnum
+ 1, valbuf
+ 8);
949 /* Always store the argument in memory. */
950 write_memory (sp
+ element
* 8, valbuf
, len
);
951 element
+= ((len
+ 7) / 8);
954 gdb_assert (element
== num_elements
);
956 /* Take BIAS into account. */
962 sparc64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR address
)
964 /* The ABI requires 16-byte alignment. */
965 return address
& ~0xf;
969 sparc64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
970 struct regcache
*regcache
, CORE_ADDR bp_addr
,
971 int nargs
, struct value
**args
, CORE_ADDR sp
,
972 int struct_return
, CORE_ADDR struct_addr
)
974 /* Set return address. */
975 regcache_cooked_write_unsigned (regcache
, SPARC_O7_REGNUM
, bp_addr
- 8);
977 /* Set up function arguments. */
978 sp
= sparc64_store_arguments (regcache
, nargs
, args
, sp
,
979 struct_return
, struct_addr
);
981 /* Allocate the register save area. */
984 /* Stack should be 16-byte aligned at this point. */
985 gdb_assert ((sp
+ BIAS
) % 16 == 0);
987 /* Finally, update the stack pointer. */
988 regcache_cooked_write_unsigned (regcache
, SPARC_SP_REGNUM
, sp
);
994 /* Extract from an array REGBUF containing the (raw) register state, a
995 function return value of TYPE, and copy that into VALBUF. */
998 sparc64_extract_return_value (struct type
*type
, struct regcache
*regcache
,
1001 int len
= TYPE_LENGTH (type
);
1005 if (sparc64_structure_or_union_p (type
))
1007 /* Structure or Union return values. */
1008 gdb_assert (len
<= 32);
1010 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1011 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1012 if (TYPE_CODE (type
) != TYPE_CODE_UNION
)
1013 sparc64_extract_floating_fields (regcache
, type
, buf
, 0);
1014 memcpy (valbuf
, buf
, len
);
1016 else if (sparc64_floating_p (type
))
1018 /* Floating return values. */
1019 for (i
= 0; i
< len
/ 4; i
++)
1020 regcache_cooked_read (regcache
, SPARC_F0_REGNUM
+ i
, buf
+ i
* 4);
1021 memcpy (valbuf
, buf
, len
);
1023 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1025 /* Small arrays are returned the same way as small structures. */
1026 gdb_assert (len
<= 32);
1028 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1029 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1030 memcpy (valbuf
, buf
, len
);
1034 /* Integral and pointer return values. */
1035 gdb_assert (sparc64_integral_or_pointer_p (type
));
1037 /* Just stripping off any unused bytes should preserve the
1038 signed-ness just fine. */
1039 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
, buf
);
1040 memcpy (valbuf
, buf
+ 8 - len
, len
);
1044 /* Write into the appropriate registers a function return value stored
1045 in VALBUF of type TYPE. */
1048 sparc64_store_return_value (struct type
*type
, struct regcache
*regcache
,
1049 const gdb_byte
*valbuf
)
1051 int len
= TYPE_LENGTH (type
);
1055 if (sparc64_structure_or_union_p (type
))
1057 /* Structure or Union return values. */
1058 gdb_assert (len
<= 32);
1060 /* Simplify matters by storing the complete value (including
1061 floating members) into %o0 and %o1. Floating members are
1062 also store in the appropriate floating-point registers. */
1063 memset (buf
, 0, sizeof (buf
));
1064 memcpy (buf
, valbuf
, len
);
1065 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1066 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1067 if (TYPE_CODE (type
) != TYPE_CODE_UNION
)
1068 sparc64_store_floating_fields (regcache
, type
, buf
, 0, 0);
1070 else if (sparc64_floating_p (type
))
1072 /* Floating return values. */
1073 memcpy (buf
, valbuf
, len
);
1074 for (i
= 0; i
< len
/ 4; i
++)
1075 regcache_cooked_write (regcache
, SPARC_F0_REGNUM
+ i
, buf
+ i
* 4);
1077 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1079 /* Small arrays are returned the same way as small structures. */
1080 gdb_assert (len
<= 32);
1082 memset (buf
, 0, sizeof (buf
));
1083 memcpy (buf
, valbuf
, len
);
1084 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1085 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1089 /* Integral and pointer return values. */
1090 gdb_assert (sparc64_integral_or_pointer_p (type
));
1092 /* ??? Do we need to do any sign-extension here? */
1094 memcpy (buf
+ 8 - len
, valbuf
, len
);
1095 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
, buf
);
1099 static enum return_value_convention
1100 sparc64_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
1101 struct type
*type
, struct regcache
*regcache
,
1102 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1104 if (TYPE_LENGTH (type
) > 32)
1105 return RETURN_VALUE_STRUCT_CONVENTION
;
1108 sparc64_extract_return_value (type
, regcache
, readbuf
);
1110 sparc64_store_return_value (type
, regcache
, writebuf
);
1112 return RETURN_VALUE_REGISTER_CONVENTION
;
1117 sparc64_dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
1118 struct dwarf2_frame_state_reg
*reg
,
1119 struct frame_info
*this_frame
)
1123 case SPARC_G0_REGNUM
:
1124 /* Since %g0 is always zero, there is no point in saving it, and
1125 people will be inclined omit it from the CFI. Make sure we
1126 don't warn about that. */
1127 reg
->how
= DWARF2_FRAME_REG_SAME_VALUE
;
1129 case SPARC_SP_REGNUM
:
1130 reg
->how
= DWARF2_FRAME_REG_CFA
;
1132 case SPARC64_PC_REGNUM
:
1133 reg
->how
= DWARF2_FRAME_REG_RA_OFFSET
;
1134 reg
->loc
.offset
= 8;
1136 case SPARC64_NPC_REGNUM
:
1137 reg
->how
= DWARF2_FRAME_REG_RA_OFFSET
;
1138 reg
->loc
.offset
= 12;
1144 sparc64_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1146 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1148 tdep
->pc_regnum
= SPARC64_PC_REGNUM
;
1149 tdep
->npc_regnum
= SPARC64_NPC_REGNUM
;
1151 /* This is what all the fuss is about. */
1152 set_gdbarch_long_bit (gdbarch
, 64);
1153 set_gdbarch_long_long_bit (gdbarch
, 64);
1154 set_gdbarch_ptr_bit (gdbarch
, 64);
1156 set_gdbarch_num_regs (gdbarch
, SPARC64_NUM_REGS
);
1157 set_gdbarch_register_name (gdbarch
, sparc64_register_name
);
1158 set_gdbarch_register_type (gdbarch
, sparc64_register_type
);
1159 set_gdbarch_num_pseudo_regs (gdbarch
, SPARC64_NUM_PSEUDO_REGS
);
1160 set_gdbarch_pseudo_register_read (gdbarch
, sparc64_pseudo_register_read
);
1161 set_gdbarch_pseudo_register_write (gdbarch
, sparc64_pseudo_register_write
);
1163 /* Register numbers of various important registers. */
1164 set_gdbarch_pc_regnum (gdbarch
, SPARC64_PC_REGNUM
); /* %pc */
1166 /* Call dummy code. */
1167 set_gdbarch_frame_align (gdbarch
, sparc64_frame_align
);
1168 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1169 set_gdbarch_push_dummy_code (gdbarch
, NULL
);
1170 set_gdbarch_push_dummy_call (gdbarch
, sparc64_push_dummy_call
);
1172 set_gdbarch_return_value (gdbarch
, sparc64_return_value
);
1173 set_gdbarch_stabs_argument_has_addr
1174 (gdbarch
, default_stabs_argument_has_addr
);
1176 set_gdbarch_skip_prologue (gdbarch
, sparc64_skip_prologue
);
1178 /* Hook in the DWARF CFI frame unwinder. */
1179 dwarf2_frame_set_init_reg (gdbarch
, sparc64_dwarf2_frame_init_reg
);
1180 /* FIXME: kettenis/20050423: Don't enable the unwinder until the
1181 StackGhost issues have been resolved. */
1183 frame_unwind_append_unwinder (gdbarch
, &sparc64_frame_unwind
);
1184 frame_base_set_default (gdbarch
, &sparc64_frame_base
);
1188 /* Helper functions for dealing with register sets. */
1190 #define TSTATE_CWP 0x000000000000001fULL
1191 #define TSTATE_ICC 0x0000000f00000000ULL
1192 #define TSTATE_XCC 0x000000f000000000ULL
1194 #define PSR_S 0x00000080
1195 #define PSR_ICC 0x00f00000
1196 #define PSR_VERS 0x0f000000
1197 #define PSR_IMPL 0xf0000000
1198 #define PSR_V8PLUS 0xff000000
1199 #define PSR_XCC 0x000f0000
1202 sparc64_supply_gregset (const struct sparc_gregset
*gregset
,
1203 struct regcache
*regcache
,
1204 int regnum
, const void *gregs
)
1206 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1207 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1208 int sparc32
= (gdbarch_ptr_bit (gdbarch
) == 32);
1209 const gdb_byte
*regs
= gregs
;
1210 gdb_byte zero
[8] = { 0 };
1215 if (regnum
== SPARC32_PSR_REGNUM
|| regnum
== -1)
1217 int offset
= gregset
->r_tstate_offset
;
1218 ULONGEST tstate
, psr
;
1221 tstate
= extract_unsigned_integer (regs
+ offset
, 8, byte_order
);
1222 psr
= ((tstate
& TSTATE_CWP
) | PSR_S
| ((tstate
& TSTATE_ICC
) >> 12)
1223 | ((tstate
& TSTATE_XCC
) >> 20) | PSR_V8PLUS
);
1224 store_unsigned_integer (buf
, 4, byte_order
, psr
);
1225 regcache_raw_supply (regcache
, SPARC32_PSR_REGNUM
, buf
);
1228 if (regnum
== SPARC32_PC_REGNUM
|| regnum
== -1)
1229 regcache_raw_supply (regcache
, SPARC32_PC_REGNUM
,
1230 regs
+ gregset
->r_pc_offset
+ 4);
1232 if (regnum
== SPARC32_NPC_REGNUM
|| regnum
== -1)
1233 regcache_raw_supply (regcache
, SPARC32_NPC_REGNUM
,
1234 regs
+ gregset
->r_npc_offset
+ 4);
1236 if (regnum
== SPARC32_Y_REGNUM
|| regnum
== -1)
1238 int offset
= gregset
->r_y_offset
+ 8 - gregset
->r_y_size
;
1239 regcache_raw_supply (regcache
, SPARC32_Y_REGNUM
, regs
+ offset
);
1244 if (regnum
== SPARC64_STATE_REGNUM
|| regnum
== -1)
1245 regcache_raw_supply (regcache
, SPARC64_STATE_REGNUM
,
1246 regs
+ gregset
->r_tstate_offset
);
1248 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== -1)
1249 regcache_raw_supply (regcache
, SPARC64_PC_REGNUM
,
1250 regs
+ gregset
->r_pc_offset
);
1252 if (regnum
== SPARC64_NPC_REGNUM
|| regnum
== -1)
1253 regcache_raw_supply (regcache
, SPARC64_NPC_REGNUM
,
1254 regs
+ gregset
->r_npc_offset
);
1256 if (regnum
== SPARC64_Y_REGNUM
|| regnum
== -1)
1261 memcpy (buf
+ 8 - gregset
->r_y_size
,
1262 regs
+ gregset
->r_y_offset
, gregset
->r_y_size
);
1263 regcache_raw_supply (regcache
, SPARC64_Y_REGNUM
, buf
);
1266 if ((regnum
== SPARC64_FPRS_REGNUM
|| regnum
== -1)
1267 && gregset
->r_fprs_offset
!= -1)
1268 regcache_raw_supply (regcache
, SPARC64_FPRS_REGNUM
,
1269 regs
+ gregset
->r_fprs_offset
);
1272 if (regnum
== SPARC_G0_REGNUM
|| regnum
== -1)
1273 regcache_raw_supply (regcache
, SPARC_G0_REGNUM
, &zero
);
1275 if ((regnum
>= SPARC_G1_REGNUM
&& regnum
<= SPARC_O7_REGNUM
) || regnum
== -1)
1277 int offset
= gregset
->r_g1_offset
;
1282 for (i
= SPARC_G1_REGNUM
; i
<= SPARC_O7_REGNUM
; i
++)
1284 if (regnum
== i
|| regnum
== -1)
1285 regcache_raw_supply (regcache
, i
, regs
+ offset
);
1290 if ((regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
) || regnum
== -1)
1292 /* Not all of the register set variants include Locals and
1293 Inputs. For those that don't, we read them off the stack. */
1294 if (gregset
->r_l0_offset
== -1)
1298 regcache_cooked_read_unsigned (regcache
, SPARC_SP_REGNUM
, &sp
);
1299 sparc_supply_rwindow (regcache
, sp
, regnum
);
1303 int offset
= gregset
->r_l0_offset
;
1308 for (i
= SPARC_L0_REGNUM
; i
<= SPARC_I7_REGNUM
; i
++)
1310 if (regnum
== i
|| regnum
== -1)
1311 regcache_raw_supply (regcache
, i
, regs
+ offset
);
1319 sparc64_collect_gregset (const struct sparc_gregset
*gregset
,
1320 const struct regcache
*regcache
,
1321 int regnum
, void *gregs
)
1323 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1324 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1325 int sparc32
= (gdbarch_ptr_bit (gdbarch
) == 32);
1326 gdb_byte
*regs
= gregs
;
1331 if (regnum
== SPARC32_PSR_REGNUM
|| regnum
== -1)
1333 int offset
= gregset
->r_tstate_offset
;
1334 ULONGEST tstate
, psr
;
1337 tstate
= extract_unsigned_integer (regs
+ offset
, 8, byte_order
);
1338 regcache_raw_collect (regcache
, SPARC32_PSR_REGNUM
, buf
);
1339 psr
= extract_unsigned_integer (buf
, 4, byte_order
);
1340 tstate
|= (psr
& PSR_ICC
) << 12;
1341 if ((psr
& (PSR_VERS
| PSR_IMPL
)) == PSR_V8PLUS
)
1342 tstate
|= (psr
& PSR_XCC
) << 20;
1343 store_unsigned_integer (buf
, 8, byte_order
, tstate
);
1344 memcpy (regs
+ offset
, buf
, 8);
1347 if (regnum
== SPARC32_PC_REGNUM
|| regnum
== -1)
1348 regcache_raw_collect (regcache
, SPARC32_PC_REGNUM
,
1349 regs
+ gregset
->r_pc_offset
+ 4);
1351 if (regnum
== SPARC32_NPC_REGNUM
|| regnum
== -1)
1352 regcache_raw_collect (regcache
, SPARC32_NPC_REGNUM
,
1353 regs
+ gregset
->r_npc_offset
+ 4);
1355 if (regnum
== SPARC32_Y_REGNUM
|| regnum
== -1)
1357 int offset
= gregset
->r_y_offset
+ 8 - gregset
->r_y_size
;
1358 regcache_raw_collect (regcache
, SPARC32_Y_REGNUM
, regs
+ offset
);
1363 if (regnum
== SPARC64_STATE_REGNUM
|| regnum
== -1)
1364 regcache_raw_collect (regcache
, SPARC64_STATE_REGNUM
,
1365 regs
+ gregset
->r_tstate_offset
);
1367 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== -1)
1368 regcache_raw_collect (regcache
, SPARC64_PC_REGNUM
,
1369 regs
+ gregset
->r_pc_offset
);
1371 if (regnum
== SPARC64_NPC_REGNUM
|| regnum
== -1)
1372 regcache_raw_collect (regcache
, SPARC64_NPC_REGNUM
,
1373 regs
+ gregset
->r_npc_offset
);
1375 if (regnum
== SPARC64_Y_REGNUM
|| regnum
== -1)
1379 regcache_raw_collect (regcache
, SPARC64_Y_REGNUM
, buf
);
1380 memcpy (regs
+ gregset
->r_y_offset
,
1381 buf
+ 8 - gregset
->r_y_size
, gregset
->r_y_size
);
1384 if ((regnum
== SPARC64_FPRS_REGNUM
|| regnum
== -1)
1385 && gregset
->r_fprs_offset
!= -1)
1386 regcache_raw_collect (regcache
, SPARC64_FPRS_REGNUM
,
1387 regs
+ gregset
->r_fprs_offset
);
1391 if ((regnum
>= SPARC_G1_REGNUM
&& regnum
<= SPARC_O7_REGNUM
) || regnum
== -1)
1393 int offset
= gregset
->r_g1_offset
;
1398 /* %g0 is always zero. */
1399 for (i
= SPARC_G1_REGNUM
; i
<= SPARC_O7_REGNUM
; i
++)
1401 if (regnum
== i
|| regnum
== -1)
1402 regcache_raw_collect (regcache
, i
, regs
+ offset
);
1407 if ((regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
) || regnum
== -1)
1409 /* Not all of the register set variants include Locals and
1410 Inputs. For those that don't, we read them off the stack. */
1411 if (gregset
->r_l0_offset
!= -1)
1413 int offset
= gregset
->r_l0_offset
;
1418 for (i
= SPARC_L0_REGNUM
; i
<= SPARC_I7_REGNUM
; i
++)
1420 if (regnum
== i
|| regnum
== -1)
1421 regcache_raw_collect (regcache
, i
, regs
+ offset
);
1429 sparc64_supply_fpregset (struct regcache
*regcache
,
1430 int regnum
, const void *fpregs
)
1432 int sparc32
= (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32);
1433 const gdb_byte
*regs
= fpregs
;
1436 for (i
= 0; i
< 32; i
++)
1438 if (regnum
== (SPARC_F0_REGNUM
+ i
) || regnum
== -1)
1439 regcache_raw_supply (regcache
, SPARC_F0_REGNUM
+ i
, regs
+ (i
* 4));
1444 if (regnum
== SPARC32_FSR_REGNUM
|| regnum
== -1)
1445 regcache_raw_supply (regcache
, SPARC32_FSR_REGNUM
,
1446 regs
+ (32 * 4) + (16 * 8) + 4);
1450 for (i
= 0; i
< 16; i
++)
1452 if (regnum
== (SPARC64_F32_REGNUM
+ i
) || regnum
== -1)
1453 regcache_raw_supply (regcache
, SPARC64_F32_REGNUM
+ i
,
1454 regs
+ (32 * 4) + (i
* 8));
1457 if (regnum
== SPARC64_FSR_REGNUM
|| regnum
== -1)
1458 regcache_raw_supply (regcache
, SPARC64_FSR_REGNUM
,
1459 regs
+ (32 * 4) + (16 * 8));
1464 sparc64_collect_fpregset (const struct regcache
*regcache
,
1465 int regnum
, void *fpregs
)
1467 int sparc32
= (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32);
1468 gdb_byte
*regs
= fpregs
;
1471 for (i
= 0; i
< 32; i
++)
1473 if (regnum
== (SPARC_F0_REGNUM
+ i
) || regnum
== -1)
1474 regcache_raw_collect (regcache
, SPARC_F0_REGNUM
+ i
, regs
+ (i
* 4));
1479 if (regnum
== SPARC32_FSR_REGNUM
|| regnum
== -1)
1480 regcache_raw_collect (regcache
, SPARC32_FSR_REGNUM
,
1481 regs
+ (32 * 4) + (16 * 8) + 4);
1485 for (i
= 0; i
< 16; i
++)
1487 if (regnum
== (SPARC64_F32_REGNUM
+ i
) || regnum
== -1)
1488 regcache_raw_collect (regcache
, SPARC64_F32_REGNUM
+ i
,
1489 regs
+ (32 * 4) + (i
* 8));
1492 if (regnum
== SPARC64_FSR_REGNUM
|| regnum
== -1)
1493 regcache_raw_collect (regcache
, SPARC64_FSR_REGNUM
,
1494 regs
+ (32 * 4) + (16 * 8));