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 "Complex Floating". */
109 sparc64_complex_floating_p (const struct type
*type
)
111 switch (TYPE_CODE (type
))
113 case TYPE_CODE_COMPLEX
:
115 int len
= TYPE_LENGTH (type
);
116 gdb_assert (len
== 8 || len
== 16 || len
== 32);
126 /* Check whether TYPE is "Structure or Union".
128 In terms of Ada subprogram calls, arrays are treated the same as
129 struct and union types. So this function also returns non-zero
133 sparc64_structure_or_union_p (const struct type
*type
)
135 switch (TYPE_CODE (type
))
137 case TYPE_CODE_STRUCT
:
138 case TYPE_CODE_UNION
:
139 case TYPE_CODE_ARRAY
:
149 /* Construct types for ISA-specific registers. */
152 sparc64_pstate_type (struct gdbarch
*gdbarch
)
154 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
156 if (!tdep
->sparc64_pstate_type
)
160 type
= arch_flags_type (gdbarch
, "builtin_type_sparc64_pstate", 8);
161 append_flags_type_flag (type
, 0, "AG");
162 append_flags_type_flag (type
, 1, "IE");
163 append_flags_type_flag (type
, 2, "PRIV");
164 append_flags_type_flag (type
, 3, "AM");
165 append_flags_type_flag (type
, 4, "PEF");
166 append_flags_type_flag (type
, 5, "RED");
167 append_flags_type_flag (type
, 8, "TLE");
168 append_flags_type_flag (type
, 9, "CLE");
169 append_flags_type_flag (type
, 10, "PID0");
170 append_flags_type_flag (type
, 11, "PID1");
172 tdep
->sparc64_pstate_type
= type
;
175 return tdep
->sparc64_pstate_type
;
179 sparc64_fsr_type (struct gdbarch
*gdbarch
)
181 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
183 if (!tdep
->sparc64_fsr_type
)
187 type
= arch_flags_type (gdbarch
, "builtin_type_sparc64_fsr", 8);
188 append_flags_type_flag (type
, 0, "NXA");
189 append_flags_type_flag (type
, 1, "DZA");
190 append_flags_type_flag (type
, 2, "UFA");
191 append_flags_type_flag (type
, 3, "OFA");
192 append_flags_type_flag (type
, 4, "NVA");
193 append_flags_type_flag (type
, 5, "NXC");
194 append_flags_type_flag (type
, 6, "DZC");
195 append_flags_type_flag (type
, 7, "UFC");
196 append_flags_type_flag (type
, 8, "OFC");
197 append_flags_type_flag (type
, 9, "NVC");
198 append_flags_type_flag (type
, 22, "NS");
199 append_flags_type_flag (type
, 23, "NXM");
200 append_flags_type_flag (type
, 24, "DZM");
201 append_flags_type_flag (type
, 25, "UFM");
202 append_flags_type_flag (type
, 26, "OFM");
203 append_flags_type_flag (type
, 27, "NVM");
205 tdep
->sparc64_fsr_type
= type
;
208 return tdep
->sparc64_fsr_type
;
212 sparc64_fprs_type (struct gdbarch
*gdbarch
)
214 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
216 if (!tdep
->sparc64_fprs_type
)
220 type
= arch_flags_type (gdbarch
, "builtin_type_sparc64_fprs", 8);
221 append_flags_type_flag (type
, 0, "DL");
222 append_flags_type_flag (type
, 1, "DU");
223 append_flags_type_flag (type
, 2, "FEF");
225 tdep
->sparc64_fprs_type
= type
;
228 return tdep
->sparc64_fprs_type
;
232 /* Register information. */
234 static const char *sparc64_register_names
[] =
236 "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
237 "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
238 "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
239 "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
241 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
242 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
243 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
244 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
245 "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46",
246 "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62",
250 /* FIXME: Give "state" a name until we start using register groups. */
257 /* Total number of registers. */
258 #define SPARC64_NUM_REGS ARRAY_SIZE (sparc64_register_names)
260 /* We provide the aliases %d0..%d62 and %q0..%q60 for the floating
261 registers as "psuedo" registers. */
263 static const char *sparc64_pseudo_register_names
[] =
265 "cwp", "pstate", "asi", "ccr",
267 "d0", "d2", "d4", "d6", "d8", "d10", "d12", "d14",
268 "d16", "d18", "d20", "d22", "d24", "d26", "d28", "d30",
269 "d32", "d34", "d36", "d38", "d40", "d42", "d44", "d46",
270 "d48", "d50", "d52", "d54", "d56", "d58", "d60", "d62",
272 "q0", "q4", "q8", "q12", "q16", "q20", "q24", "q28",
273 "q32", "q36", "q40", "q44", "q48", "q52", "q56", "q60",
276 /* Total number of pseudo registers. */
277 #define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_names)
279 /* Return the name of register REGNUM. */
282 sparc64_register_name (struct gdbarch
*gdbarch
, int regnum
)
284 if (regnum
>= 0 && regnum
< SPARC64_NUM_REGS
)
285 return sparc64_register_names
[regnum
];
287 if (regnum
>= SPARC64_NUM_REGS
288 && regnum
< SPARC64_NUM_REGS
+ SPARC64_NUM_PSEUDO_REGS
)
289 return sparc64_pseudo_register_names
[regnum
- SPARC64_NUM_REGS
];
294 /* Return the GDB type object for the "standard" data type of data in
298 sparc64_register_type (struct gdbarch
*gdbarch
, int regnum
)
302 if (regnum
== SPARC_SP_REGNUM
|| regnum
== SPARC_FP_REGNUM
)
303 return builtin_type (gdbarch
)->builtin_data_ptr
;
304 if (regnum
>= SPARC_G0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
)
305 return builtin_type (gdbarch
)->builtin_int64
;
306 if (regnum
>= SPARC_F0_REGNUM
&& regnum
<= SPARC_F31_REGNUM
)
307 return builtin_type (gdbarch
)->builtin_float
;
308 if (regnum
>= SPARC64_F32_REGNUM
&& regnum
<= SPARC64_F62_REGNUM
)
309 return builtin_type (gdbarch
)->builtin_double
;
310 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== SPARC64_NPC_REGNUM
)
311 return builtin_type (gdbarch
)->builtin_func_ptr
;
312 /* This raw register contains the contents of %cwp, %pstate, %asi
313 and %ccr as laid out in a %tstate register. */
314 if (regnum
== SPARC64_STATE_REGNUM
)
315 return builtin_type (gdbarch
)->builtin_int64
;
316 if (regnum
== SPARC64_FSR_REGNUM
)
317 return sparc64_fsr_type (gdbarch
);
318 if (regnum
== SPARC64_FPRS_REGNUM
)
319 return sparc64_fprs_type (gdbarch
);
320 /* "Although Y is a 64-bit register, its high-order 32 bits are
321 reserved and always read as 0." */
322 if (regnum
== SPARC64_Y_REGNUM
)
323 return builtin_type (gdbarch
)->builtin_int64
;
325 /* Pseudo registers. */
327 if (regnum
== SPARC64_CWP_REGNUM
)
328 return builtin_type (gdbarch
)->builtin_int64
;
329 if (regnum
== SPARC64_PSTATE_REGNUM
)
330 return sparc64_pstate_type (gdbarch
);
331 if (regnum
== SPARC64_ASI_REGNUM
)
332 return builtin_type (gdbarch
)->builtin_int64
;
333 if (regnum
== SPARC64_CCR_REGNUM
)
334 return builtin_type (gdbarch
)->builtin_int64
;
335 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
336 return builtin_type (gdbarch
)->builtin_double
;
337 if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
338 return builtin_type (gdbarch
)->builtin_long_double
;
340 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
343 static enum register_status
344 sparc64_pseudo_register_read (struct gdbarch
*gdbarch
,
345 struct regcache
*regcache
,
346 int regnum
, gdb_byte
*buf
)
348 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
349 enum register_status status
;
351 gdb_assert (regnum
>= SPARC64_NUM_REGS
);
353 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D30_REGNUM
)
355 regnum
= SPARC_F0_REGNUM
+ 2 * (regnum
- SPARC64_D0_REGNUM
);
356 status
= regcache_raw_read (regcache
, regnum
, buf
);
357 if (status
== REG_VALID
)
358 status
= regcache_raw_read (regcache
, regnum
+ 1, buf
+ 4);
361 else if (regnum
>= SPARC64_D32_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
363 regnum
= SPARC64_F32_REGNUM
+ (regnum
- SPARC64_D32_REGNUM
);
364 return regcache_raw_read (regcache
, regnum
, buf
);
366 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q28_REGNUM
)
368 regnum
= SPARC_F0_REGNUM
+ 4 * (regnum
- SPARC64_Q0_REGNUM
);
370 status
= regcache_raw_read (regcache
, regnum
, buf
);
371 if (status
== REG_VALID
)
372 status
= regcache_raw_read (regcache
, regnum
+ 1, buf
+ 4);
373 if (status
== REG_VALID
)
374 status
= regcache_raw_read (regcache
, regnum
+ 2, buf
+ 8);
375 if (status
== REG_VALID
)
376 status
= regcache_raw_read (regcache
, regnum
+ 3, buf
+ 12);
380 else if (regnum
>= SPARC64_Q32_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
382 regnum
= SPARC64_F32_REGNUM
+ 2 * (regnum
- SPARC64_Q32_REGNUM
);
384 status
= regcache_raw_read (regcache
, regnum
, buf
);
385 if (status
== REG_VALID
)
386 status
= regcache_raw_read (regcache
, regnum
+ 1, buf
+ 8);
390 else if (regnum
== SPARC64_CWP_REGNUM
391 || regnum
== SPARC64_PSTATE_REGNUM
392 || regnum
== SPARC64_ASI_REGNUM
393 || regnum
== SPARC64_CCR_REGNUM
)
397 status
= regcache_raw_read_unsigned (regcache
, SPARC64_STATE_REGNUM
, &state
);
398 if (status
!= REG_VALID
)
403 case SPARC64_CWP_REGNUM
:
404 state
= (state
>> 0) & ((1 << 5) - 1);
406 case SPARC64_PSTATE_REGNUM
:
407 state
= (state
>> 8) & ((1 << 12) - 1);
409 case SPARC64_ASI_REGNUM
:
410 state
= (state
>> 24) & ((1 << 8) - 1);
412 case SPARC64_CCR_REGNUM
:
413 state
= (state
>> 32) & ((1 << 8) - 1);
416 store_unsigned_integer (buf
, 8, byte_order
, state
);
423 sparc64_pseudo_register_write (struct gdbarch
*gdbarch
,
424 struct regcache
*regcache
,
425 int regnum
, const gdb_byte
*buf
)
427 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
428 gdb_assert (regnum
>= SPARC64_NUM_REGS
);
430 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D30_REGNUM
)
432 regnum
= SPARC_F0_REGNUM
+ 2 * (regnum
- SPARC64_D0_REGNUM
);
433 regcache_raw_write (regcache
, regnum
, buf
);
434 regcache_raw_write (regcache
, regnum
+ 1, buf
+ 4);
436 else if (regnum
>= SPARC64_D32_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
438 regnum
= SPARC64_F32_REGNUM
+ (regnum
- SPARC64_D32_REGNUM
);
439 regcache_raw_write (regcache
, regnum
, buf
);
441 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q28_REGNUM
)
443 regnum
= SPARC_F0_REGNUM
+ 4 * (regnum
- SPARC64_Q0_REGNUM
);
444 regcache_raw_write (regcache
, regnum
, buf
);
445 regcache_raw_write (regcache
, regnum
+ 1, buf
+ 4);
446 regcache_raw_write (regcache
, regnum
+ 2, buf
+ 8);
447 regcache_raw_write (regcache
, regnum
+ 3, buf
+ 12);
449 else if (regnum
>= SPARC64_Q32_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
451 regnum
= SPARC64_F32_REGNUM
+ 2 * (regnum
- SPARC64_Q32_REGNUM
);
452 regcache_raw_write (regcache
, regnum
, buf
);
453 regcache_raw_write (regcache
, regnum
+ 1, buf
+ 8);
455 else if (regnum
== SPARC64_CWP_REGNUM
456 || regnum
== SPARC64_PSTATE_REGNUM
457 || regnum
== SPARC64_ASI_REGNUM
458 || regnum
== SPARC64_CCR_REGNUM
)
460 ULONGEST state
, bits
;
462 regcache_raw_read_unsigned (regcache
, SPARC64_STATE_REGNUM
, &state
);
463 bits
= extract_unsigned_integer (buf
, 8, byte_order
);
466 case SPARC64_CWP_REGNUM
:
467 state
|= ((bits
& ((1 << 5) - 1)) << 0);
469 case SPARC64_PSTATE_REGNUM
:
470 state
|= ((bits
& ((1 << 12) - 1)) << 8);
472 case SPARC64_ASI_REGNUM
:
473 state
|= ((bits
& ((1 << 8) - 1)) << 24);
475 case SPARC64_CCR_REGNUM
:
476 state
|= ((bits
& ((1 << 8) - 1)) << 32);
479 regcache_raw_write_unsigned (regcache
, SPARC64_STATE_REGNUM
, state
);
484 /* Return PC of first real instruction of the function starting at
488 sparc64_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR start_pc
)
490 struct symtab_and_line sal
;
491 CORE_ADDR func_start
, func_end
;
492 struct sparc_frame_cache cache
;
494 /* This is the preferred method, find the end of the prologue by
495 using the debugging information. */
496 if (find_pc_partial_function (start_pc
, NULL
, &func_start
, &func_end
))
498 sal
= find_pc_line (func_start
, 0);
500 if (sal
.end
< func_end
501 && start_pc
<= sal
.end
)
505 return sparc_analyze_prologue (gdbarch
, start_pc
, 0xffffffffffffffffULL
,
511 static struct sparc_frame_cache
*
512 sparc64_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
514 return sparc_frame_cache (this_frame
, this_cache
);
518 sparc64_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
519 struct frame_id
*this_id
)
521 struct sparc_frame_cache
*cache
=
522 sparc64_frame_cache (this_frame
, this_cache
);
524 /* This marks the outermost frame. */
525 if (cache
->base
== 0)
528 (*this_id
) = frame_id_build (cache
->base
, cache
->pc
);
531 static struct value
*
532 sparc64_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
535 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
536 struct sparc_frame_cache
*cache
=
537 sparc64_frame_cache (this_frame
, this_cache
);
539 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== SPARC64_NPC_REGNUM
)
541 CORE_ADDR pc
= (regnum
== SPARC64_NPC_REGNUM
) ? 4 : 0;
544 (cache
->copied_regs_mask
& 0x80) ? SPARC_I7_REGNUM
: SPARC_O7_REGNUM
;
545 pc
+= get_frame_register_unsigned (this_frame
, regnum
) + 8;
546 return frame_unwind_got_constant (this_frame
, regnum
, pc
);
549 /* Handle StackGhost. */
551 ULONGEST wcookie
= sparc_fetch_wcookie (gdbarch
);
553 if (wcookie
!= 0 && !cache
->frameless_p
&& regnum
== SPARC_I7_REGNUM
)
555 CORE_ADDR addr
= cache
->base
+ (regnum
- SPARC_L0_REGNUM
) * 8;
558 /* Read the value in from memory. */
559 i7
= get_frame_memory_unsigned (this_frame
, addr
, 8);
560 return frame_unwind_got_constant (this_frame
, regnum
, i7
^ wcookie
);
564 /* The previous frame's `local' and `in' registers may have been saved
565 in the register save area. */
566 if (regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
567 && (cache
->saved_regs_mask
& (1 << (regnum
- SPARC_L0_REGNUM
))))
569 CORE_ADDR addr
= cache
->base
+ (regnum
- SPARC_L0_REGNUM
) * 8;
571 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
574 /* The previous frame's `out' registers may be accessible as the current
575 frame's `in' registers. */
576 if (regnum
>= SPARC_O0_REGNUM
&& regnum
<= SPARC_O7_REGNUM
577 && (cache
->copied_regs_mask
& (1 << (regnum
- SPARC_O0_REGNUM
))))
578 regnum
+= (SPARC_I0_REGNUM
- SPARC_O0_REGNUM
);
580 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
583 static const struct frame_unwind sparc64_frame_unwind
=
586 default_frame_unwind_stop_reason
,
587 sparc64_frame_this_id
,
588 sparc64_frame_prev_register
,
590 default_frame_sniffer
595 sparc64_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
597 struct sparc_frame_cache
*cache
=
598 sparc64_frame_cache (this_frame
, this_cache
);
603 static const struct frame_base sparc64_frame_base
=
605 &sparc64_frame_unwind
,
606 sparc64_frame_base_address
,
607 sparc64_frame_base_address
,
608 sparc64_frame_base_address
611 /* Check whether TYPE must be 16-byte aligned. */
614 sparc64_16_byte_align_p (struct type
*type
)
616 if (sparc64_floating_p (type
) && TYPE_LENGTH (type
) == 16)
619 if (sparc64_structure_or_union_p (type
))
623 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
625 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
627 if (sparc64_16_byte_align_p (subtype
))
635 /* Store floating fields of element ELEMENT of an "parameter array"
636 that has type TYPE and is stored at BITPOS in VALBUF in the
637 apropriate registers of REGCACHE. This function can be called
638 recursively and therefore handles floating types in addition to
642 sparc64_store_floating_fields (struct regcache
*regcache
, struct type
*type
,
643 const gdb_byte
*valbuf
, int element
, int bitpos
)
645 int len
= TYPE_LENGTH (type
);
647 gdb_assert (element
< 16);
649 if (sparc64_floating_p (type
)
650 || (sparc64_complex_floating_p (type
) && len
<= 16))
656 gdb_assert (bitpos
== 0);
657 gdb_assert ((element
% 2) == 0);
659 regnum
= SPARC64_Q0_REGNUM
+ element
/ 2;
660 regcache_cooked_write (regcache
, regnum
, valbuf
);
664 gdb_assert (bitpos
== 0 || bitpos
== 64);
666 regnum
= SPARC64_D0_REGNUM
+ element
+ bitpos
/ 64;
667 regcache_cooked_write (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
671 gdb_assert (len
== 4);
672 gdb_assert (bitpos
% 32 == 0 && bitpos
>= 0 && bitpos
< 128);
674 regnum
= SPARC_F0_REGNUM
+ element
* 2 + bitpos
/ 32;
675 regcache_cooked_write (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
678 else if (sparc64_structure_or_union_p (type
))
682 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
684 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
685 int subpos
= bitpos
+ TYPE_FIELD_BITPOS (type
, i
);
687 sparc64_store_floating_fields (regcache
, subtype
, valbuf
,
691 /* GCC has an interesting bug. If TYPE is a structure that has
692 a single `float' member, GCC doesn't treat it as a structure
693 at all, but rather as an ordinary `float' argument. This
694 argument will be stored in %f1, as required by the psABI.
695 However, as a member of a structure the psABI requires it to
696 be stored in %f0. This bug is present in GCC 3.3.2, but
697 probably in older releases to. To appease GCC, if a
698 structure has only a single `float' member, we store its
699 value in %f1 too (we already have stored in %f0). */
700 if (TYPE_NFIELDS (type
) == 1)
702 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
704 if (sparc64_floating_p (subtype
) && TYPE_LENGTH (subtype
) == 4)
705 regcache_cooked_write (regcache
, SPARC_F1_REGNUM
, valbuf
);
710 /* Fetch floating fields from a variable of type TYPE from the
711 appropriate registers for BITPOS in REGCACHE and store it at BITPOS
712 in VALBUF. This function can be called recursively and therefore
713 handles floating types in addition to structures. */
716 sparc64_extract_floating_fields (struct regcache
*regcache
, struct type
*type
,
717 gdb_byte
*valbuf
, int bitpos
)
719 if (sparc64_floating_p (type
))
721 int len
= TYPE_LENGTH (type
);
726 gdb_assert (bitpos
== 0 || bitpos
== 128);
728 regnum
= SPARC64_Q0_REGNUM
+ bitpos
/ 128;
729 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
733 gdb_assert (bitpos
% 64 == 0 && bitpos
>= 0 && bitpos
< 256);
735 regnum
= SPARC64_D0_REGNUM
+ bitpos
/ 64;
736 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
740 gdb_assert (len
== 4);
741 gdb_assert (bitpos
% 32 == 0 && bitpos
>= 0 && bitpos
< 256);
743 regnum
= SPARC_F0_REGNUM
+ bitpos
/ 32;
744 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
747 else if (sparc64_structure_or_union_p (type
))
751 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
753 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
754 int subpos
= bitpos
+ TYPE_FIELD_BITPOS (type
, i
);
756 sparc64_extract_floating_fields (regcache
, subtype
, valbuf
, subpos
);
761 /* Store the NARGS arguments ARGS and STRUCT_ADDR (if STRUCT_RETURN is
762 non-zero) in REGCACHE and on the stack (starting from address SP). */
765 sparc64_store_arguments (struct regcache
*regcache
, int nargs
,
766 struct value
**args
, CORE_ADDR sp
,
767 int struct_return
, CORE_ADDR struct_addr
)
769 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
770 /* Number of extended words in the "parameter array". */
771 int num_elements
= 0;
775 /* Take BIAS into account. */
778 /* First we calculate the number of extended words in the "parameter
779 array". While doing so we also convert some of the arguments. */
784 for (i
= 0; i
< nargs
; i
++)
786 struct type
*type
= value_type (args
[i
]);
787 int len
= TYPE_LENGTH (type
);
789 if (sparc64_structure_or_union_p (type
))
791 /* Structure or Union arguments. */
794 if (num_elements
% 2 && sparc64_16_byte_align_p (type
))
796 num_elements
+= ((len
+ 7) / 8);
800 /* The psABI says that "Structures or unions larger than
801 sixteen bytes are copied by the caller and passed
802 indirectly; the caller will pass the address of a
803 correctly aligned structure value. This sixty-four
804 bit address will occupy one word in the parameter
805 array, and may be promoted to an %o register like any
806 other pointer value." Allocate memory for these
807 values on the stack. */
810 /* Use 16-byte alignment for these values. That's
811 always correct, and wasting a few bytes shouldn't be
815 write_memory (sp
, value_contents (args
[i
]), len
);
816 args
[i
] = value_from_pointer (lookup_pointer_type (type
), sp
);
820 else if (sparc64_floating_p (type
))
822 /* Floating arguments. */
826 /* The psABI says that "Each quad-precision parameter
827 value will be assigned to two extended words in the
831 /* The psABI says that "Long doubles must be
832 quad-aligned, and thus a hole might be introduced
833 into the parameter array to force alignment." Skip
834 an element if necessary. */
835 if (num_elements
% 2)
843 /* Integral and pointer arguments. */
844 gdb_assert (sparc64_integral_or_pointer_p (type
));
846 /* The psABI says that "Each argument value of integral type
847 smaller than an extended word will be widened by the
848 caller to an extended word according to the signed-ness
849 of the argument type." */
851 args
[i
] = value_cast (builtin_type (gdbarch
)->builtin_int64
,
857 /* Allocate the "parameter array". */
858 sp
-= num_elements
* 8;
860 /* The psABI says that "Every stack frame must be 16-byte aligned." */
863 /* Now we store the arguments in to the "paramater array". Some
864 Integer or Pointer arguments and Structure or Union arguments
865 will be passed in %o registers. Some Floating arguments and
866 floating members of structures are passed in floating-point
867 registers. However, for functions with variable arguments,
868 floating arguments are stored in an %0 register, and for
869 functions without a prototype floating arguments are stored in
870 both a floating-point and an %o registers, or a floating-point
871 register and memory. To simplify the logic here we always pass
872 arguments in memory, an %o register, and a floating-point
873 register if appropriate. This should be no problem since the
874 contents of any unused memory or registers in the "parameter
875 array" are undefined. */
879 regcache_cooked_write_unsigned (regcache
, SPARC_O0_REGNUM
, struct_addr
);
883 for (i
= 0; i
< nargs
; i
++)
885 const gdb_byte
*valbuf
= value_contents (args
[i
]);
886 struct type
*type
= value_type (args
[i
]);
887 int len
= TYPE_LENGTH (type
);
891 if (sparc64_structure_or_union_p (type
))
893 /* Structure or Union arguments. */
894 gdb_assert (len
<= 16);
895 memset (buf
, 0, sizeof (buf
));
896 valbuf
= memcpy (buf
, valbuf
, len
);
898 if (element
% 2 && sparc64_16_byte_align_p (type
))
903 regnum
= SPARC_O0_REGNUM
+ element
;
904 if (len
> 8 && element
< 5)
905 regcache_cooked_write (regcache
, regnum
+ 1, valbuf
+ 8);
909 sparc64_store_floating_fields (regcache
, type
, valbuf
, element
, 0);
911 else if (sparc64_floating_p (type
) || sparc64_complex_floating_p (type
))
913 /* Floating arguments. */
919 regnum
= SPARC64_Q0_REGNUM
+ element
/ 2;
924 regnum
= SPARC64_D0_REGNUM
+ element
;
928 /* The psABI says "Each single-precision parameter value
929 will be assigned to one extended word in the
930 parameter array, and right-justified within that
931 word; the left half (even floatregister) is
932 undefined." Even though the psABI says that "the
933 left half is undefined", set it to zero here. */
935 memcpy (buf
+ 4, valbuf
, 4);
939 regnum
= SPARC64_D0_REGNUM
+ element
;
944 /* Integral and pointer arguments. */
945 gdb_assert (len
== 8);
947 regnum
= SPARC_O0_REGNUM
+ element
;
952 regcache_cooked_write (regcache
, regnum
, valbuf
);
954 /* If we're storing the value in a floating-point register,
955 also store it in the corresponding %0 register(s). */
956 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D10_REGNUM
)
958 gdb_assert (element
< 6);
959 regnum
= SPARC_O0_REGNUM
+ element
;
960 regcache_cooked_write (regcache
, regnum
, valbuf
);
962 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q8_REGNUM
)
964 gdb_assert (element
< 6);
965 regnum
= SPARC_O0_REGNUM
+ element
;
966 regcache_cooked_write (regcache
, regnum
, valbuf
);
967 regcache_cooked_write (regcache
, regnum
+ 1, valbuf
+ 8);
971 /* Always store the argument in memory. */
972 write_memory (sp
+ element
* 8, valbuf
, len
);
973 element
+= ((len
+ 7) / 8);
976 gdb_assert (element
== num_elements
);
978 /* Take BIAS into account. */
984 sparc64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR address
)
986 /* The ABI requires 16-byte alignment. */
987 return address
& ~0xf;
991 sparc64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
992 struct regcache
*regcache
, CORE_ADDR bp_addr
,
993 int nargs
, struct value
**args
, CORE_ADDR sp
,
994 int struct_return
, CORE_ADDR struct_addr
)
996 /* Set return address. */
997 regcache_cooked_write_unsigned (regcache
, SPARC_O7_REGNUM
, bp_addr
- 8);
999 /* Set up function arguments. */
1000 sp
= sparc64_store_arguments (regcache
, nargs
, args
, sp
,
1001 struct_return
, struct_addr
);
1003 /* Allocate the register save area. */
1006 /* Stack should be 16-byte aligned at this point. */
1007 gdb_assert ((sp
+ BIAS
) % 16 == 0);
1009 /* Finally, update the stack pointer. */
1010 regcache_cooked_write_unsigned (regcache
, SPARC_SP_REGNUM
, sp
);
1016 /* Extract from an array REGBUF containing the (raw) register state, a
1017 function return value of TYPE, and copy that into VALBUF. */
1020 sparc64_extract_return_value (struct type
*type
, struct regcache
*regcache
,
1023 int len
= TYPE_LENGTH (type
);
1027 if (sparc64_structure_or_union_p (type
))
1029 /* Structure or Union return values. */
1030 gdb_assert (len
<= 32);
1032 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1033 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1034 if (TYPE_CODE (type
) != TYPE_CODE_UNION
)
1035 sparc64_extract_floating_fields (regcache
, type
, buf
, 0);
1036 memcpy (valbuf
, buf
, len
);
1038 else if (sparc64_floating_p (type
))
1040 /* Floating return values. */
1041 for (i
= 0; i
< len
/ 4; i
++)
1042 regcache_cooked_read (regcache
, SPARC_F0_REGNUM
+ i
, buf
+ i
* 4);
1043 memcpy (valbuf
, buf
, len
);
1045 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1047 /* Small arrays are returned the same way as small structures. */
1048 gdb_assert (len
<= 32);
1050 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1051 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1052 memcpy (valbuf
, buf
, len
);
1056 /* Integral and pointer return values. */
1057 gdb_assert (sparc64_integral_or_pointer_p (type
));
1059 /* Just stripping off any unused bytes should preserve the
1060 signed-ness just fine. */
1061 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
, buf
);
1062 memcpy (valbuf
, buf
+ 8 - len
, len
);
1066 /* Write into the appropriate registers a function return value stored
1067 in VALBUF of type TYPE. */
1070 sparc64_store_return_value (struct type
*type
, struct regcache
*regcache
,
1071 const gdb_byte
*valbuf
)
1073 int len
= TYPE_LENGTH (type
);
1077 if (sparc64_structure_or_union_p (type
))
1079 /* Structure or Union return values. */
1080 gdb_assert (len
<= 32);
1082 /* Simplify matters by storing the complete value (including
1083 floating members) into %o0 and %o1. Floating members are
1084 also store in the appropriate floating-point registers. */
1085 memset (buf
, 0, sizeof (buf
));
1086 memcpy (buf
, valbuf
, len
);
1087 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1088 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1089 if (TYPE_CODE (type
) != TYPE_CODE_UNION
)
1090 sparc64_store_floating_fields (regcache
, type
, buf
, 0, 0);
1092 else if (sparc64_floating_p (type
) || sparc64_complex_floating_p (type
))
1094 /* Floating return values. */
1095 memcpy (buf
, valbuf
, len
);
1096 for (i
= 0; i
< len
/ 4; i
++)
1097 regcache_cooked_write (regcache
, SPARC_F0_REGNUM
+ i
, buf
+ i
* 4);
1099 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1101 /* Small arrays are returned the same way as small structures. */
1102 gdb_assert (len
<= 32);
1104 memset (buf
, 0, sizeof (buf
));
1105 memcpy (buf
, valbuf
, len
);
1106 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1107 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1111 /* Integral and pointer return values. */
1112 gdb_assert (sparc64_integral_or_pointer_p (type
));
1114 /* ??? Do we need to do any sign-extension here? */
1116 memcpy (buf
+ 8 - len
, valbuf
, len
);
1117 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
, buf
);
1121 static enum return_value_convention
1122 sparc64_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
1123 struct type
*type
, struct regcache
*regcache
,
1124 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1126 if (TYPE_LENGTH (type
) > 32)
1127 return RETURN_VALUE_STRUCT_CONVENTION
;
1130 sparc64_extract_return_value (type
, regcache
, readbuf
);
1132 sparc64_store_return_value (type
, regcache
, writebuf
);
1134 return RETURN_VALUE_REGISTER_CONVENTION
;
1139 sparc64_dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
1140 struct dwarf2_frame_state_reg
*reg
,
1141 struct frame_info
*this_frame
)
1145 case SPARC_G0_REGNUM
:
1146 /* Since %g0 is always zero, there is no point in saving it, and
1147 people will be inclined omit it from the CFI. Make sure we
1148 don't warn about that. */
1149 reg
->how
= DWARF2_FRAME_REG_SAME_VALUE
;
1151 case SPARC_SP_REGNUM
:
1152 reg
->how
= DWARF2_FRAME_REG_CFA
;
1154 case SPARC64_PC_REGNUM
:
1155 reg
->how
= DWARF2_FRAME_REG_RA_OFFSET
;
1156 reg
->loc
.offset
= 8;
1158 case SPARC64_NPC_REGNUM
:
1159 reg
->how
= DWARF2_FRAME_REG_RA_OFFSET
;
1160 reg
->loc
.offset
= 12;
1166 sparc64_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1168 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1170 tdep
->pc_regnum
= SPARC64_PC_REGNUM
;
1171 tdep
->npc_regnum
= SPARC64_NPC_REGNUM
;
1173 /* This is what all the fuss is about. */
1174 set_gdbarch_long_bit (gdbarch
, 64);
1175 set_gdbarch_long_long_bit (gdbarch
, 64);
1176 set_gdbarch_ptr_bit (gdbarch
, 64);
1178 set_gdbarch_num_regs (gdbarch
, SPARC64_NUM_REGS
);
1179 set_gdbarch_register_name (gdbarch
, sparc64_register_name
);
1180 set_gdbarch_register_type (gdbarch
, sparc64_register_type
);
1181 set_gdbarch_num_pseudo_regs (gdbarch
, SPARC64_NUM_PSEUDO_REGS
);
1182 set_gdbarch_pseudo_register_read (gdbarch
, sparc64_pseudo_register_read
);
1183 set_gdbarch_pseudo_register_write (gdbarch
, sparc64_pseudo_register_write
);
1185 /* Register numbers of various important registers. */
1186 set_gdbarch_pc_regnum (gdbarch
, SPARC64_PC_REGNUM
); /* %pc */
1188 /* Call dummy code. */
1189 set_gdbarch_frame_align (gdbarch
, sparc64_frame_align
);
1190 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1191 set_gdbarch_push_dummy_code (gdbarch
, NULL
);
1192 set_gdbarch_push_dummy_call (gdbarch
, sparc64_push_dummy_call
);
1194 set_gdbarch_return_value (gdbarch
, sparc64_return_value
);
1195 set_gdbarch_stabs_argument_has_addr
1196 (gdbarch
, default_stabs_argument_has_addr
);
1198 set_gdbarch_skip_prologue (gdbarch
, sparc64_skip_prologue
);
1200 /* Hook in the DWARF CFI frame unwinder. */
1201 dwarf2_frame_set_init_reg (gdbarch
, sparc64_dwarf2_frame_init_reg
);
1202 /* FIXME: kettenis/20050423: Don't enable the unwinder until the
1203 StackGhost issues have been resolved. */
1205 frame_unwind_append_unwinder (gdbarch
, &sparc64_frame_unwind
);
1206 frame_base_set_default (gdbarch
, &sparc64_frame_base
);
1210 /* Helper functions for dealing with register sets. */
1212 #define TSTATE_CWP 0x000000000000001fULL
1213 #define TSTATE_ICC 0x0000000f00000000ULL
1214 #define TSTATE_XCC 0x000000f000000000ULL
1216 #define PSR_S 0x00000080
1217 #define PSR_ICC 0x00f00000
1218 #define PSR_VERS 0x0f000000
1219 #define PSR_IMPL 0xf0000000
1220 #define PSR_V8PLUS 0xff000000
1221 #define PSR_XCC 0x000f0000
1224 sparc64_supply_gregset (const struct sparc_gregset
*gregset
,
1225 struct regcache
*regcache
,
1226 int regnum
, const void *gregs
)
1228 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1229 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1230 int sparc32
= (gdbarch_ptr_bit (gdbarch
) == 32);
1231 const gdb_byte
*regs
= gregs
;
1232 gdb_byte zero
[8] = { 0 };
1237 if (regnum
== SPARC32_PSR_REGNUM
|| regnum
== -1)
1239 int offset
= gregset
->r_tstate_offset
;
1240 ULONGEST tstate
, psr
;
1243 tstate
= extract_unsigned_integer (regs
+ offset
, 8, byte_order
);
1244 psr
= ((tstate
& TSTATE_CWP
) | PSR_S
| ((tstate
& TSTATE_ICC
) >> 12)
1245 | ((tstate
& TSTATE_XCC
) >> 20) | PSR_V8PLUS
);
1246 store_unsigned_integer (buf
, 4, byte_order
, psr
);
1247 regcache_raw_supply (regcache
, SPARC32_PSR_REGNUM
, buf
);
1250 if (regnum
== SPARC32_PC_REGNUM
|| regnum
== -1)
1251 regcache_raw_supply (regcache
, SPARC32_PC_REGNUM
,
1252 regs
+ gregset
->r_pc_offset
+ 4);
1254 if (regnum
== SPARC32_NPC_REGNUM
|| regnum
== -1)
1255 regcache_raw_supply (regcache
, SPARC32_NPC_REGNUM
,
1256 regs
+ gregset
->r_npc_offset
+ 4);
1258 if (regnum
== SPARC32_Y_REGNUM
|| regnum
== -1)
1260 int offset
= gregset
->r_y_offset
+ 8 - gregset
->r_y_size
;
1261 regcache_raw_supply (regcache
, SPARC32_Y_REGNUM
, regs
+ offset
);
1266 if (regnum
== SPARC64_STATE_REGNUM
|| regnum
== -1)
1267 regcache_raw_supply (regcache
, SPARC64_STATE_REGNUM
,
1268 regs
+ gregset
->r_tstate_offset
);
1270 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== -1)
1271 regcache_raw_supply (regcache
, SPARC64_PC_REGNUM
,
1272 regs
+ gregset
->r_pc_offset
);
1274 if (regnum
== SPARC64_NPC_REGNUM
|| regnum
== -1)
1275 regcache_raw_supply (regcache
, SPARC64_NPC_REGNUM
,
1276 regs
+ gregset
->r_npc_offset
);
1278 if (regnum
== SPARC64_Y_REGNUM
|| regnum
== -1)
1283 memcpy (buf
+ 8 - gregset
->r_y_size
,
1284 regs
+ gregset
->r_y_offset
, gregset
->r_y_size
);
1285 regcache_raw_supply (regcache
, SPARC64_Y_REGNUM
, buf
);
1288 if ((regnum
== SPARC64_FPRS_REGNUM
|| regnum
== -1)
1289 && gregset
->r_fprs_offset
!= -1)
1290 regcache_raw_supply (regcache
, SPARC64_FPRS_REGNUM
,
1291 regs
+ gregset
->r_fprs_offset
);
1294 if (regnum
== SPARC_G0_REGNUM
|| regnum
== -1)
1295 regcache_raw_supply (regcache
, SPARC_G0_REGNUM
, &zero
);
1297 if ((regnum
>= SPARC_G1_REGNUM
&& regnum
<= SPARC_O7_REGNUM
) || regnum
== -1)
1299 int offset
= gregset
->r_g1_offset
;
1304 for (i
= SPARC_G1_REGNUM
; i
<= SPARC_O7_REGNUM
; i
++)
1306 if (regnum
== i
|| regnum
== -1)
1307 regcache_raw_supply (regcache
, i
, regs
+ offset
);
1312 if ((regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
) || regnum
== -1)
1314 /* Not all of the register set variants include Locals and
1315 Inputs. For those that don't, we read them off the stack. */
1316 if (gregset
->r_l0_offset
== -1)
1320 regcache_cooked_read_unsigned (regcache
, SPARC_SP_REGNUM
, &sp
);
1321 sparc_supply_rwindow (regcache
, sp
, regnum
);
1325 int offset
= gregset
->r_l0_offset
;
1330 for (i
= SPARC_L0_REGNUM
; i
<= SPARC_I7_REGNUM
; i
++)
1332 if (regnum
== i
|| regnum
== -1)
1333 regcache_raw_supply (regcache
, i
, regs
+ offset
);
1341 sparc64_collect_gregset (const struct sparc_gregset
*gregset
,
1342 const struct regcache
*regcache
,
1343 int regnum
, void *gregs
)
1345 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1346 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1347 int sparc32
= (gdbarch_ptr_bit (gdbarch
) == 32);
1348 gdb_byte
*regs
= gregs
;
1353 if (regnum
== SPARC32_PSR_REGNUM
|| regnum
== -1)
1355 int offset
= gregset
->r_tstate_offset
;
1356 ULONGEST tstate
, psr
;
1359 tstate
= extract_unsigned_integer (regs
+ offset
, 8, byte_order
);
1360 regcache_raw_collect (regcache
, SPARC32_PSR_REGNUM
, buf
);
1361 psr
= extract_unsigned_integer (buf
, 4, byte_order
);
1362 tstate
|= (psr
& PSR_ICC
) << 12;
1363 if ((psr
& (PSR_VERS
| PSR_IMPL
)) == PSR_V8PLUS
)
1364 tstate
|= (psr
& PSR_XCC
) << 20;
1365 store_unsigned_integer (buf
, 8, byte_order
, tstate
);
1366 memcpy (regs
+ offset
, buf
, 8);
1369 if (regnum
== SPARC32_PC_REGNUM
|| regnum
== -1)
1370 regcache_raw_collect (regcache
, SPARC32_PC_REGNUM
,
1371 regs
+ gregset
->r_pc_offset
+ 4);
1373 if (regnum
== SPARC32_NPC_REGNUM
|| regnum
== -1)
1374 regcache_raw_collect (regcache
, SPARC32_NPC_REGNUM
,
1375 regs
+ gregset
->r_npc_offset
+ 4);
1377 if (regnum
== SPARC32_Y_REGNUM
|| regnum
== -1)
1379 int offset
= gregset
->r_y_offset
+ 8 - gregset
->r_y_size
;
1380 regcache_raw_collect (regcache
, SPARC32_Y_REGNUM
, regs
+ offset
);
1385 if (regnum
== SPARC64_STATE_REGNUM
|| regnum
== -1)
1386 regcache_raw_collect (regcache
, SPARC64_STATE_REGNUM
,
1387 regs
+ gregset
->r_tstate_offset
);
1389 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== -1)
1390 regcache_raw_collect (regcache
, SPARC64_PC_REGNUM
,
1391 regs
+ gregset
->r_pc_offset
);
1393 if (regnum
== SPARC64_NPC_REGNUM
|| regnum
== -1)
1394 regcache_raw_collect (regcache
, SPARC64_NPC_REGNUM
,
1395 regs
+ gregset
->r_npc_offset
);
1397 if (regnum
== SPARC64_Y_REGNUM
|| regnum
== -1)
1401 regcache_raw_collect (regcache
, SPARC64_Y_REGNUM
, buf
);
1402 memcpy (regs
+ gregset
->r_y_offset
,
1403 buf
+ 8 - gregset
->r_y_size
, gregset
->r_y_size
);
1406 if ((regnum
== SPARC64_FPRS_REGNUM
|| regnum
== -1)
1407 && gregset
->r_fprs_offset
!= -1)
1408 regcache_raw_collect (regcache
, SPARC64_FPRS_REGNUM
,
1409 regs
+ gregset
->r_fprs_offset
);
1413 if ((regnum
>= SPARC_G1_REGNUM
&& regnum
<= SPARC_O7_REGNUM
) || regnum
== -1)
1415 int offset
= gregset
->r_g1_offset
;
1420 /* %g0 is always zero. */
1421 for (i
= SPARC_G1_REGNUM
; i
<= SPARC_O7_REGNUM
; i
++)
1423 if (regnum
== i
|| regnum
== -1)
1424 regcache_raw_collect (regcache
, i
, regs
+ offset
);
1429 if ((regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
) || regnum
== -1)
1431 /* Not all of the register set variants include Locals and
1432 Inputs. For those that don't, we read them off the stack. */
1433 if (gregset
->r_l0_offset
!= -1)
1435 int offset
= gregset
->r_l0_offset
;
1440 for (i
= SPARC_L0_REGNUM
; i
<= SPARC_I7_REGNUM
; i
++)
1442 if (regnum
== i
|| regnum
== -1)
1443 regcache_raw_collect (regcache
, i
, regs
+ offset
);
1451 sparc64_supply_fpregset (struct regcache
*regcache
,
1452 int regnum
, const void *fpregs
)
1454 int sparc32
= (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32);
1455 const gdb_byte
*regs
= fpregs
;
1458 for (i
= 0; i
< 32; i
++)
1460 if (regnum
== (SPARC_F0_REGNUM
+ i
) || regnum
== -1)
1461 regcache_raw_supply (regcache
, SPARC_F0_REGNUM
+ i
, regs
+ (i
* 4));
1466 if (regnum
== SPARC32_FSR_REGNUM
|| regnum
== -1)
1467 regcache_raw_supply (regcache
, SPARC32_FSR_REGNUM
,
1468 regs
+ (32 * 4) + (16 * 8) + 4);
1472 for (i
= 0; i
< 16; i
++)
1474 if (regnum
== (SPARC64_F32_REGNUM
+ i
) || regnum
== -1)
1475 regcache_raw_supply (regcache
, SPARC64_F32_REGNUM
+ i
,
1476 regs
+ (32 * 4) + (i
* 8));
1479 if (regnum
== SPARC64_FSR_REGNUM
|| regnum
== -1)
1480 regcache_raw_supply (regcache
, SPARC64_FSR_REGNUM
,
1481 regs
+ (32 * 4) + (16 * 8));
1486 sparc64_collect_fpregset (const struct regcache
*regcache
,
1487 int regnum
, void *fpregs
)
1489 int sparc32
= (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32);
1490 gdb_byte
*regs
= fpregs
;
1493 for (i
= 0; i
< 32; i
++)
1495 if (regnum
== (SPARC_F0_REGNUM
+ i
) || regnum
== -1)
1496 regcache_raw_collect (regcache
, SPARC_F0_REGNUM
+ i
, regs
+ (i
* 4));
1501 if (regnum
== SPARC32_FSR_REGNUM
|| regnum
== -1)
1502 regcache_raw_collect (regcache
, SPARC32_FSR_REGNUM
,
1503 regs
+ (32 * 4) + (16 * 8) + 4);
1507 for (i
= 0; i
< 16; i
++)
1509 if (regnum
== (SPARC64_F32_REGNUM
+ i
) || regnum
== -1)
1510 regcache_raw_collect (regcache
, SPARC64_F32_REGNUM
+ i
,
1511 regs
+ (32 * 4) + (i
* 8));
1514 if (regnum
== SPARC64_FSR_REGNUM
|| regnum
== -1)
1515 regcache_raw_collect (regcache
, SPARC64_FSR_REGNUM
,
1516 regs
+ (32 * 4) + (16 * 8));