1 /* Target-dependent code for UltraSPARC.
3 Copyright (C) 2003-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
22 #include "dwarf2-frame.h"
23 #include "floatformat.h"
25 #include "frame-base.h"
26 #include "frame-unwind.h"
37 #include "sparc64-tdep.h"
39 /* This file implements the SPARC 64-bit ABI as defined by the
40 section "Low-Level System Information" of the SPARC Compliance
41 Definition (SCD) 2.4.1, which is the 64-bit System V psABI for
44 /* Please use the sparc32_-prefix for 32-bit specific code, the
45 sparc64_-prefix for 64-bit specific code and the sparc_-prefix for
46 code can handle both. */
48 /* The functions on this page are intended to be used to classify
49 function arguments. */
51 /* Check whether TYPE is "Integral or Pointer". */
54 sparc64_integral_or_pointer_p (const struct type
*type
)
56 switch (TYPE_CODE (type
))
64 int len
= TYPE_LENGTH (type
);
65 gdb_assert (len
== 1 || len
== 2 || len
== 4 || len
== 8);
71 int len
= TYPE_LENGTH (type
);
72 gdb_assert (len
== 8);
82 /* Check whether TYPE is "Floating". */
85 sparc64_floating_p (const struct type
*type
)
87 switch (TYPE_CODE (type
))
91 int len
= TYPE_LENGTH (type
);
92 gdb_assert (len
== 4 || len
== 8 || len
== 16);
102 /* Check whether TYPE is "Complex Floating". */
105 sparc64_complex_floating_p (const struct type
*type
)
107 switch (TYPE_CODE (type
))
109 case TYPE_CODE_COMPLEX
:
111 int len
= TYPE_LENGTH (type
);
112 gdb_assert (len
== 8 || len
== 16 || len
== 32);
122 /* Check whether TYPE is "Structure or Union".
124 In terms of Ada subprogram calls, arrays are treated the same as
125 struct and union types. So this function also returns non-zero
129 sparc64_structure_or_union_p (const struct type
*type
)
131 switch (TYPE_CODE (type
))
133 case TYPE_CODE_STRUCT
:
134 case TYPE_CODE_UNION
:
135 case TYPE_CODE_ARRAY
:
145 /* Construct types for ISA-specific registers. */
148 sparc64_pstate_type (struct gdbarch
*gdbarch
)
150 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
152 if (!tdep
->sparc64_pstate_type
)
156 type
= arch_flags_type (gdbarch
, "builtin_type_sparc64_pstate", 8);
157 append_flags_type_flag (type
, 0, "AG");
158 append_flags_type_flag (type
, 1, "IE");
159 append_flags_type_flag (type
, 2, "PRIV");
160 append_flags_type_flag (type
, 3, "AM");
161 append_flags_type_flag (type
, 4, "PEF");
162 append_flags_type_flag (type
, 5, "RED");
163 append_flags_type_flag (type
, 8, "TLE");
164 append_flags_type_flag (type
, 9, "CLE");
165 append_flags_type_flag (type
, 10, "PID0");
166 append_flags_type_flag (type
, 11, "PID1");
168 tdep
->sparc64_pstate_type
= type
;
171 return tdep
->sparc64_pstate_type
;
175 sparc64_fsr_type (struct gdbarch
*gdbarch
)
177 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
179 if (!tdep
->sparc64_fsr_type
)
183 type
= arch_flags_type (gdbarch
, "builtin_type_sparc64_fsr", 8);
184 append_flags_type_flag (type
, 0, "NXA");
185 append_flags_type_flag (type
, 1, "DZA");
186 append_flags_type_flag (type
, 2, "UFA");
187 append_flags_type_flag (type
, 3, "OFA");
188 append_flags_type_flag (type
, 4, "NVA");
189 append_flags_type_flag (type
, 5, "NXC");
190 append_flags_type_flag (type
, 6, "DZC");
191 append_flags_type_flag (type
, 7, "UFC");
192 append_flags_type_flag (type
, 8, "OFC");
193 append_flags_type_flag (type
, 9, "NVC");
194 append_flags_type_flag (type
, 22, "NS");
195 append_flags_type_flag (type
, 23, "NXM");
196 append_flags_type_flag (type
, 24, "DZM");
197 append_flags_type_flag (type
, 25, "UFM");
198 append_flags_type_flag (type
, 26, "OFM");
199 append_flags_type_flag (type
, 27, "NVM");
201 tdep
->sparc64_fsr_type
= type
;
204 return tdep
->sparc64_fsr_type
;
208 sparc64_fprs_type (struct gdbarch
*gdbarch
)
210 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
212 if (!tdep
->sparc64_fprs_type
)
216 type
= arch_flags_type (gdbarch
, "builtin_type_sparc64_fprs", 8);
217 append_flags_type_flag (type
, 0, "DL");
218 append_flags_type_flag (type
, 1, "DU");
219 append_flags_type_flag (type
, 2, "FEF");
221 tdep
->sparc64_fprs_type
= type
;
224 return tdep
->sparc64_fprs_type
;
228 /* Register information. */
230 static const char *sparc64_register_names
[] =
232 "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
233 "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
234 "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
235 "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
237 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
238 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
239 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
240 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
241 "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46",
242 "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62",
246 /* FIXME: Give "state" a name until we start using register groups. */
253 /* Total number of registers. */
254 #define SPARC64_NUM_REGS ARRAY_SIZE (sparc64_register_names)
256 /* We provide the aliases %d0..%d62 and %q0..%q60 for the floating
257 registers as "psuedo" registers. */
259 static const char *sparc64_pseudo_register_names
[] =
261 "cwp", "pstate", "asi", "ccr",
263 "d0", "d2", "d4", "d6", "d8", "d10", "d12", "d14",
264 "d16", "d18", "d20", "d22", "d24", "d26", "d28", "d30",
265 "d32", "d34", "d36", "d38", "d40", "d42", "d44", "d46",
266 "d48", "d50", "d52", "d54", "d56", "d58", "d60", "d62",
268 "q0", "q4", "q8", "q12", "q16", "q20", "q24", "q28",
269 "q32", "q36", "q40", "q44", "q48", "q52", "q56", "q60",
272 /* Total number of pseudo registers. */
273 #define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_names)
275 /* Return the name of register REGNUM. */
278 sparc64_register_name (struct gdbarch
*gdbarch
, int regnum
)
280 if (regnum
>= 0 && regnum
< SPARC64_NUM_REGS
)
281 return sparc64_register_names
[regnum
];
283 if (regnum
>= SPARC64_NUM_REGS
284 && regnum
< SPARC64_NUM_REGS
+ SPARC64_NUM_PSEUDO_REGS
)
285 return sparc64_pseudo_register_names
[regnum
- SPARC64_NUM_REGS
];
290 /* Return the GDB type object for the "standard" data type of data in
294 sparc64_register_type (struct gdbarch
*gdbarch
, int regnum
)
298 if (regnum
== SPARC_SP_REGNUM
|| regnum
== SPARC_FP_REGNUM
)
299 return builtin_type (gdbarch
)->builtin_data_ptr
;
300 if (regnum
>= SPARC_G0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
)
301 return builtin_type (gdbarch
)->builtin_int64
;
302 if (regnum
>= SPARC_F0_REGNUM
&& regnum
<= SPARC_F31_REGNUM
)
303 return builtin_type (gdbarch
)->builtin_float
;
304 if (regnum
>= SPARC64_F32_REGNUM
&& regnum
<= SPARC64_F62_REGNUM
)
305 return builtin_type (gdbarch
)->builtin_double
;
306 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== SPARC64_NPC_REGNUM
)
307 return builtin_type (gdbarch
)->builtin_func_ptr
;
308 /* This raw register contains the contents of %cwp, %pstate, %asi
309 and %ccr as laid out in a %tstate register. */
310 if (regnum
== SPARC64_STATE_REGNUM
)
311 return builtin_type (gdbarch
)->builtin_int64
;
312 if (regnum
== SPARC64_FSR_REGNUM
)
313 return sparc64_fsr_type (gdbarch
);
314 if (regnum
== SPARC64_FPRS_REGNUM
)
315 return sparc64_fprs_type (gdbarch
);
316 /* "Although Y is a 64-bit register, its high-order 32 bits are
317 reserved and always read as 0." */
318 if (regnum
== SPARC64_Y_REGNUM
)
319 return builtin_type (gdbarch
)->builtin_int64
;
321 /* Pseudo registers. */
323 if (regnum
== SPARC64_CWP_REGNUM
)
324 return builtin_type (gdbarch
)->builtin_int64
;
325 if (regnum
== SPARC64_PSTATE_REGNUM
)
326 return sparc64_pstate_type (gdbarch
);
327 if (regnum
== SPARC64_ASI_REGNUM
)
328 return builtin_type (gdbarch
)->builtin_int64
;
329 if (regnum
== SPARC64_CCR_REGNUM
)
330 return builtin_type (gdbarch
)->builtin_int64
;
331 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
332 return builtin_type (gdbarch
)->builtin_double
;
333 if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
334 return builtin_type (gdbarch
)->builtin_long_double
;
336 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
339 static enum register_status
340 sparc64_pseudo_register_read (struct gdbarch
*gdbarch
,
341 struct regcache
*regcache
,
342 int regnum
, gdb_byte
*buf
)
344 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
345 enum register_status status
;
347 gdb_assert (regnum
>= SPARC64_NUM_REGS
);
349 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D30_REGNUM
)
351 regnum
= SPARC_F0_REGNUM
+ 2 * (regnum
- SPARC64_D0_REGNUM
);
352 status
= regcache_raw_read (regcache
, regnum
, buf
);
353 if (status
== REG_VALID
)
354 status
= regcache_raw_read (regcache
, regnum
+ 1, buf
+ 4);
357 else if (regnum
>= SPARC64_D32_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
359 regnum
= SPARC64_F32_REGNUM
+ (regnum
- SPARC64_D32_REGNUM
);
360 return regcache_raw_read (regcache
, regnum
, buf
);
362 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q28_REGNUM
)
364 regnum
= SPARC_F0_REGNUM
+ 4 * (regnum
- SPARC64_Q0_REGNUM
);
366 status
= regcache_raw_read (regcache
, regnum
, buf
);
367 if (status
== REG_VALID
)
368 status
= regcache_raw_read (regcache
, regnum
+ 1, buf
+ 4);
369 if (status
== REG_VALID
)
370 status
= regcache_raw_read (regcache
, regnum
+ 2, buf
+ 8);
371 if (status
== REG_VALID
)
372 status
= regcache_raw_read (regcache
, regnum
+ 3, buf
+ 12);
376 else if (regnum
>= SPARC64_Q32_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
378 regnum
= SPARC64_F32_REGNUM
+ 2 * (regnum
- SPARC64_Q32_REGNUM
);
380 status
= regcache_raw_read (regcache
, regnum
, buf
);
381 if (status
== REG_VALID
)
382 status
= regcache_raw_read (regcache
, regnum
+ 1, buf
+ 8);
386 else if (regnum
== SPARC64_CWP_REGNUM
387 || regnum
== SPARC64_PSTATE_REGNUM
388 || regnum
== SPARC64_ASI_REGNUM
389 || regnum
== SPARC64_CCR_REGNUM
)
393 status
= regcache_raw_read_unsigned (regcache
, SPARC64_STATE_REGNUM
, &state
);
394 if (status
!= REG_VALID
)
399 case SPARC64_CWP_REGNUM
:
400 state
= (state
>> 0) & ((1 << 5) - 1);
402 case SPARC64_PSTATE_REGNUM
:
403 state
= (state
>> 8) & ((1 << 12) - 1);
405 case SPARC64_ASI_REGNUM
:
406 state
= (state
>> 24) & ((1 << 8) - 1);
408 case SPARC64_CCR_REGNUM
:
409 state
= (state
>> 32) & ((1 << 8) - 1);
412 store_unsigned_integer (buf
, 8, byte_order
, state
);
419 sparc64_pseudo_register_write (struct gdbarch
*gdbarch
,
420 struct regcache
*regcache
,
421 int regnum
, const gdb_byte
*buf
)
423 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
424 gdb_assert (regnum
>= SPARC64_NUM_REGS
);
426 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D30_REGNUM
)
428 regnum
= SPARC_F0_REGNUM
+ 2 * (regnum
- SPARC64_D0_REGNUM
);
429 regcache_raw_write (regcache
, regnum
, buf
);
430 regcache_raw_write (regcache
, regnum
+ 1, buf
+ 4);
432 else if (regnum
>= SPARC64_D32_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
434 regnum
= SPARC64_F32_REGNUM
+ (regnum
- SPARC64_D32_REGNUM
);
435 regcache_raw_write (regcache
, regnum
, buf
);
437 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q28_REGNUM
)
439 regnum
= SPARC_F0_REGNUM
+ 4 * (regnum
- SPARC64_Q0_REGNUM
);
440 regcache_raw_write (regcache
, regnum
, buf
);
441 regcache_raw_write (regcache
, regnum
+ 1, buf
+ 4);
442 regcache_raw_write (regcache
, regnum
+ 2, buf
+ 8);
443 regcache_raw_write (regcache
, regnum
+ 3, buf
+ 12);
445 else if (regnum
>= SPARC64_Q32_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
447 regnum
= SPARC64_F32_REGNUM
+ 2 * (regnum
- SPARC64_Q32_REGNUM
);
448 regcache_raw_write (regcache
, regnum
, buf
);
449 regcache_raw_write (regcache
, regnum
+ 1, buf
+ 8);
451 else if (regnum
== SPARC64_CWP_REGNUM
452 || regnum
== SPARC64_PSTATE_REGNUM
453 || regnum
== SPARC64_ASI_REGNUM
454 || regnum
== SPARC64_CCR_REGNUM
)
456 ULONGEST state
, bits
;
458 regcache_raw_read_unsigned (regcache
, SPARC64_STATE_REGNUM
, &state
);
459 bits
= extract_unsigned_integer (buf
, 8, byte_order
);
462 case SPARC64_CWP_REGNUM
:
463 state
|= ((bits
& ((1 << 5) - 1)) << 0);
465 case SPARC64_PSTATE_REGNUM
:
466 state
|= ((bits
& ((1 << 12) - 1)) << 8);
468 case SPARC64_ASI_REGNUM
:
469 state
|= ((bits
& ((1 << 8) - 1)) << 24);
471 case SPARC64_CCR_REGNUM
:
472 state
|= ((bits
& ((1 << 8) - 1)) << 32);
475 regcache_raw_write_unsigned (regcache
, SPARC64_STATE_REGNUM
, state
);
480 /* Return PC of first real instruction of the function starting at
484 sparc64_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR start_pc
)
486 struct symtab_and_line sal
;
487 CORE_ADDR func_start
, func_end
;
488 struct sparc_frame_cache cache
;
490 /* This is the preferred method, find the end of the prologue by
491 using the debugging information. */
492 if (find_pc_partial_function (start_pc
, NULL
, &func_start
, &func_end
))
494 sal
= find_pc_line (func_start
, 0);
496 if (sal
.end
< func_end
497 && start_pc
<= sal
.end
)
501 return sparc_analyze_prologue (gdbarch
, start_pc
, 0xffffffffffffffffULL
,
507 static struct sparc_frame_cache
*
508 sparc64_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
510 return sparc_frame_cache (this_frame
, this_cache
);
514 sparc64_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
515 struct frame_id
*this_id
)
517 struct sparc_frame_cache
*cache
=
518 sparc64_frame_cache (this_frame
, this_cache
);
520 /* This marks the outermost frame. */
521 if (cache
->base
== 0)
524 (*this_id
) = frame_id_build (cache
->base
, cache
->pc
);
527 static struct value
*
528 sparc64_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
531 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
532 struct sparc_frame_cache
*cache
=
533 sparc64_frame_cache (this_frame
, this_cache
);
535 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== SPARC64_NPC_REGNUM
)
537 CORE_ADDR pc
= (regnum
== SPARC64_NPC_REGNUM
) ? 4 : 0;
540 (cache
->copied_regs_mask
& 0x80) ? SPARC_I7_REGNUM
: SPARC_O7_REGNUM
;
541 pc
+= get_frame_register_unsigned (this_frame
, regnum
) + 8;
542 return frame_unwind_got_constant (this_frame
, regnum
, pc
);
545 /* Handle StackGhost. */
547 ULONGEST wcookie
= sparc_fetch_wcookie (gdbarch
);
549 if (wcookie
!= 0 && !cache
->frameless_p
&& regnum
== SPARC_I7_REGNUM
)
551 CORE_ADDR addr
= cache
->base
+ (regnum
- SPARC_L0_REGNUM
) * 8;
554 /* Read the value in from memory. */
555 i7
= get_frame_memory_unsigned (this_frame
, addr
, 8);
556 return frame_unwind_got_constant (this_frame
, regnum
, i7
^ wcookie
);
560 /* The previous frame's `local' and `in' registers may have been saved
561 in the register save area. */
562 if (regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
563 && (cache
->saved_regs_mask
& (1 << (regnum
- SPARC_L0_REGNUM
))))
565 CORE_ADDR addr
= cache
->base
+ (regnum
- SPARC_L0_REGNUM
) * 8;
567 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
570 /* The previous frame's `out' registers may be accessible as the current
571 frame's `in' registers. */
572 if (regnum
>= SPARC_O0_REGNUM
&& regnum
<= SPARC_O7_REGNUM
573 && (cache
->copied_regs_mask
& (1 << (regnum
- SPARC_O0_REGNUM
))))
574 regnum
+= (SPARC_I0_REGNUM
- SPARC_O0_REGNUM
);
576 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
579 static const struct frame_unwind sparc64_frame_unwind
=
582 default_frame_unwind_stop_reason
,
583 sparc64_frame_this_id
,
584 sparc64_frame_prev_register
,
586 default_frame_sniffer
591 sparc64_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
593 struct sparc_frame_cache
*cache
=
594 sparc64_frame_cache (this_frame
, this_cache
);
599 static const struct frame_base sparc64_frame_base
=
601 &sparc64_frame_unwind
,
602 sparc64_frame_base_address
,
603 sparc64_frame_base_address
,
604 sparc64_frame_base_address
607 /* Check whether TYPE must be 16-byte aligned. */
610 sparc64_16_byte_align_p (struct type
*type
)
612 if (sparc64_floating_p (type
) && TYPE_LENGTH (type
) == 16)
615 if (sparc64_structure_or_union_p (type
))
619 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
621 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
623 if (sparc64_16_byte_align_p (subtype
))
631 /* Store floating fields of element ELEMENT of an "parameter array"
632 that has type TYPE and is stored at BITPOS in VALBUF in the
633 apropriate registers of REGCACHE. This function can be called
634 recursively and therefore handles floating types in addition to
638 sparc64_store_floating_fields (struct regcache
*regcache
, struct type
*type
,
639 const gdb_byte
*valbuf
, int element
, int bitpos
)
641 int len
= TYPE_LENGTH (type
);
643 gdb_assert (element
< 16);
645 if (sparc64_floating_p (type
)
646 || (sparc64_complex_floating_p (type
) && len
<= 16))
652 gdb_assert (bitpos
== 0);
653 gdb_assert ((element
% 2) == 0);
655 regnum
= SPARC64_Q0_REGNUM
+ element
/ 2;
656 regcache_cooked_write (regcache
, regnum
, valbuf
);
660 gdb_assert (bitpos
== 0 || bitpos
== 64);
662 regnum
= SPARC64_D0_REGNUM
+ element
+ bitpos
/ 64;
663 regcache_cooked_write (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
667 gdb_assert (len
== 4);
668 gdb_assert (bitpos
% 32 == 0 && bitpos
>= 0 && bitpos
< 128);
670 regnum
= SPARC_F0_REGNUM
+ element
* 2 + bitpos
/ 32;
671 regcache_cooked_write (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
674 else if (sparc64_structure_or_union_p (type
))
678 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
680 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
681 int subpos
= bitpos
+ TYPE_FIELD_BITPOS (type
, i
);
683 sparc64_store_floating_fields (regcache
, subtype
, valbuf
,
687 /* GCC has an interesting bug. If TYPE is a structure that has
688 a single `float' member, GCC doesn't treat it as a structure
689 at all, but rather as an ordinary `float' argument. This
690 argument will be stored in %f1, as required by the psABI.
691 However, as a member of a structure the psABI requires it to
692 be stored in %f0. This bug is present in GCC 3.3.2, but
693 probably in older releases to. To appease GCC, if a
694 structure has only a single `float' member, we store its
695 value in %f1 too (we already have stored in %f0). */
696 if (TYPE_NFIELDS (type
) == 1)
698 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
700 if (sparc64_floating_p (subtype
) && TYPE_LENGTH (subtype
) == 4)
701 regcache_cooked_write (regcache
, SPARC_F1_REGNUM
, valbuf
);
706 /* Fetch floating fields from a variable of type TYPE from the
707 appropriate registers for BITPOS in REGCACHE and store it at BITPOS
708 in VALBUF. This function can be called recursively and therefore
709 handles floating types in addition to structures. */
712 sparc64_extract_floating_fields (struct regcache
*regcache
, struct type
*type
,
713 gdb_byte
*valbuf
, int bitpos
)
715 if (sparc64_floating_p (type
))
717 int len
= TYPE_LENGTH (type
);
722 gdb_assert (bitpos
== 0 || bitpos
== 128);
724 regnum
= SPARC64_Q0_REGNUM
+ bitpos
/ 128;
725 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
729 gdb_assert (bitpos
% 64 == 0 && bitpos
>= 0 && bitpos
< 256);
731 regnum
= SPARC64_D0_REGNUM
+ bitpos
/ 64;
732 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
736 gdb_assert (len
== 4);
737 gdb_assert (bitpos
% 32 == 0 && bitpos
>= 0 && bitpos
< 256);
739 regnum
= SPARC_F0_REGNUM
+ bitpos
/ 32;
740 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
743 else if (sparc64_structure_or_union_p (type
))
747 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
749 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
750 int subpos
= bitpos
+ TYPE_FIELD_BITPOS (type
, i
);
752 sparc64_extract_floating_fields (regcache
, subtype
, valbuf
, subpos
);
757 /* Store the NARGS arguments ARGS and STRUCT_ADDR (if STRUCT_RETURN is
758 non-zero) in REGCACHE and on the stack (starting from address SP). */
761 sparc64_store_arguments (struct regcache
*regcache
, int nargs
,
762 struct value
**args
, CORE_ADDR sp
,
763 int struct_return
, CORE_ADDR struct_addr
)
765 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
766 /* Number of extended words in the "parameter array". */
767 int num_elements
= 0;
771 /* Take BIAS into account. */
774 /* First we calculate the number of extended words in the "parameter
775 array". While doing so we also convert some of the arguments. */
780 for (i
= 0; i
< nargs
; i
++)
782 struct type
*type
= value_type (args
[i
]);
783 int len
= TYPE_LENGTH (type
);
785 if (sparc64_structure_or_union_p (type
)
786 || (sparc64_complex_floating_p (type
) && len
== 32))
788 /* Structure or Union arguments. */
791 if (num_elements
% 2 && sparc64_16_byte_align_p (type
))
793 num_elements
+= ((len
+ 7) / 8);
797 /* The psABI says that "Structures or unions larger than
798 sixteen bytes are copied by the caller and passed
799 indirectly; the caller will pass the address of a
800 correctly aligned structure value. This sixty-four
801 bit address will occupy one word in the parameter
802 array, and may be promoted to an %o register like any
803 other pointer value." Allocate memory for these
804 values on the stack. */
807 /* Use 16-byte alignment for these values. That's
808 always correct, and wasting a few bytes shouldn't be
812 write_memory (sp
, value_contents (args
[i
]), len
);
813 args
[i
] = value_from_pointer (lookup_pointer_type (type
), sp
);
817 else if (sparc64_floating_p (type
) || sparc64_complex_floating_p (type
))
819 /* Floating arguments. */
822 /* The psABI says that "Each quad-precision parameter
823 value will be assigned to two extended words in the
827 /* The psABI says that "Long doubles must be
828 quad-aligned, and thus a hole might be introduced
829 into the parameter array to force alignment." Skip
830 an element if necessary. */
831 if ((num_elements
% 2) && sparc64_16_byte_align_p (type
))
839 /* Integral and pointer arguments. */
840 gdb_assert (sparc64_integral_or_pointer_p (type
));
842 /* The psABI says that "Each argument value of integral type
843 smaller than an extended word will be widened by the
844 caller to an extended word according to the signed-ness
845 of the argument type." */
847 args
[i
] = value_cast (builtin_type (gdbarch
)->builtin_int64
,
853 /* Allocate the "parameter array". */
854 sp
-= num_elements
* 8;
856 /* The psABI says that "Every stack frame must be 16-byte aligned." */
859 /* Now we store the arguments in to the "paramater array". Some
860 Integer or Pointer arguments and Structure or Union arguments
861 will be passed in %o registers. Some Floating arguments and
862 floating members of structures are passed in floating-point
863 registers. However, for functions with variable arguments,
864 floating arguments are stored in an %0 register, and for
865 functions without a prototype floating arguments are stored in
866 both a floating-point and an %o registers, or a floating-point
867 register and memory. To simplify the logic here we always pass
868 arguments in memory, an %o register, and a floating-point
869 register if appropriate. This should be no problem since the
870 contents of any unused memory or registers in the "parameter
871 array" are undefined. */
875 regcache_cooked_write_unsigned (regcache
, SPARC_O0_REGNUM
, struct_addr
);
879 for (i
= 0; i
< nargs
; i
++)
881 const gdb_byte
*valbuf
= value_contents (args
[i
]);
882 struct type
*type
= value_type (args
[i
]);
883 int len
= TYPE_LENGTH (type
);
887 if (sparc64_structure_or_union_p (type
)
888 || (sparc64_complex_floating_p (type
) && len
== 32))
890 /* Structure, Union or long double Complex arguments. */
891 gdb_assert (len
<= 16);
892 memset (buf
, 0, sizeof (buf
));
893 valbuf
= memcpy (buf
, valbuf
, len
);
895 if (element
% 2 && sparc64_16_byte_align_p (type
))
900 regnum
= SPARC_O0_REGNUM
+ element
;
901 if (len
> 8 && element
< 5)
902 regcache_cooked_write (regcache
, regnum
+ 1, valbuf
+ 8);
906 sparc64_store_floating_fields (regcache
, type
, valbuf
, element
, 0);
908 else if (sparc64_complex_floating_p (type
))
910 /* Float Complex or double Complex arguments. */
913 regnum
= SPARC64_D0_REGNUM
+ element
;
917 if (regnum
< SPARC64_D30_REGNUM
)
918 regcache_cooked_write (regcache
, regnum
+ 1, valbuf
+ 8);
919 if (regnum
< SPARC64_D10_REGNUM
)
920 regcache_cooked_write (regcache
,
921 SPARC_O0_REGNUM
+ element
+ 1,
926 else if (sparc64_floating_p (type
))
928 /* Floating arguments. */
934 regnum
= SPARC64_Q0_REGNUM
+ element
/ 2;
939 regnum
= SPARC64_D0_REGNUM
+ element
;
943 /* The psABI says "Each single-precision parameter value
944 will be assigned to one extended word in the
945 parameter array, and right-justified within that
946 word; the left half (even float register) is
947 undefined." Even though the psABI says that "the
948 left half is undefined", set it to zero here. */
950 memcpy (buf
+ 4, valbuf
, 4);
954 regnum
= SPARC64_D0_REGNUM
+ element
;
959 /* Integral and pointer arguments. */
960 gdb_assert (len
== 8);
962 regnum
= SPARC_O0_REGNUM
+ element
;
967 regcache_cooked_write (regcache
, regnum
, valbuf
);
969 /* If we're storing the value in a floating-point register,
970 also store it in the corresponding %0 register(s). */
971 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D10_REGNUM
)
973 gdb_assert (element
< 6);
974 regnum
= SPARC_O0_REGNUM
+ element
;
975 regcache_cooked_write (regcache
, regnum
, valbuf
);
977 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q8_REGNUM
)
979 gdb_assert (element
< 5);
980 regnum
= SPARC_O0_REGNUM
+ element
;
981 regcache_cooked_write (regcache
, regnum
, valbuf
);
982 regcache_cooked_write (regcache
, regnum
+ 1, valbuf
+ 8);
986 /* Always store the argument in memory. */
987 write_memory (sp
+ element
* 8, valbuf
, len
);
988 element
+= ((len
+ 7) / 8);
991 gdb_assert (element
== num_elements
);
993 /* Take BIAS into account. */
999 sparc64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR address
)
1001 /* The ABI requires 16-byte alignment. */
1002 return address
& ~0xf;
1006 sparc64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
1007 struct regcache
*regcache
, CORE_ADDR bp_addr
,
1008 int nargs
, struct value
**args
, CORE_ADDR sp
,
1009 int struct_return
, CORE_ADDR struct_addr
)
1011 /* Set return address. */
1012 regcache_cooked_write_unsigned (regcache
, SPARC_O7_REGNUM
, bp_addr
- 8);
1014 /* Set up function arguments. */
1015 sp
= sparc64_store_arguments (regcache
, nargs
, args
, sp
,
1016 struct_return
, struct_addr
);
1018 /* Allocate the register save area. */
1021 /* Stack should be 16-byte aligned at this point. */
1022 gdb_assert ((sp
+ BIAS
) % 16 == 0);
1024 /* Finally, update the stack pointer. */
1025 regcache_cooked_write_unsigned (regcache
, SPARC_SP_REGNUM
, sp
);
1031 /* Extract from an array REGBUF containing the (raw) register state, a
1032 function return value of TYPE, and copy that into VALBUF. */
1035 sparc64_extract_return_value (struct type
*type
, struct regcache
*regcache
,
1038 int len
= TYPE_LENGTH (type
);
1042 if (sparc64_structure_or_union_p (type
))
1044 /* Structure or Union return values. */
1045 gdb_assert (len
<= 32);
1047 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1048 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1049 if (TYPE_CODE (type
) != TYPE_CODE_UNION
)
1050 sparc64_extract_floating_fields (regcache
, type
, buf
, 0);
1051 memcpy (valbuf
, buf
, len
);
1053 else if (sparc64_floating_p (type
) || sparc64_complex_floating_p (type
))
1055 /* Floating return values. */
1056 for (i
= 0; i
< len
/ 4; i
++)
1057 regcache_cooked_read (regcache
, SPARC_F0_REGNUM
+ i
, buf
+ i
* 4);
1058 memcpy (valbuf
, buf
, len
);
1060 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1062 /* Small arrays are returned the same way as small structures. */
1063 gdb_assert (len
<= 32);
1065 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1066 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1067 memcpy (valbuf
, buf
, len
);
1071 /* Integral and pointer return values. */
1072 gdb_assert (sparc64_integral_or_pointer_p (type
));
1074 /* Just stripping off any unused bytes should preserve the
1075 signed-ness just fine. */
1076 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
, buf
);
1077 memcpy (valbuf
, buf
+ 8 - len
, len
);
1081 /* Write into the appropriate registers a function return value stored
1082 in VALBUF of type TYPE. */
1085 sparc64_store_return_value (struct type
*type
, struct regcache
*regcache
,
1086 const gdb_byte
*valbuf
)
1088 int len
= TYPE_LENGTH (type
);
1092 if (sparc64_structure_or_union_p (type
))
1094 /* Structure or Union return values. */
1095 gdb_assert (len
<= 32);
1097 /* Simplify matters by storing the complete value (including
1098 floating members) into %o0 and %o1. Floating members are
1099 also store in the appropriate floating-point registers. */
1100 memset (buf
, 0, sizeof (buf
));
1101 memcpy (buf
, valbuf
, len
);
1102 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1103 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1104 if (TYPE_CODE (type
) != TYPE_CODE_UNION
)
1105 sparc64_store_floating_fields (regcache
, type
, buf
, 0, 0);
1107 else if (sparc64_floating_p (type
) || sparc64_complex_floating_p (type
))
1109 /* Floating return values. */
1110 memcpy (buf
, valbuf
, len
);
1111 for (i
= 0; i
< len
/ 4; i
++)
1112 regcache_cooked_write (regcache
, SPARC_F0_REGNUM
+ i
, buf
+ i
* 4);
1114 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1116 /* Small arrays are returned the same way as small structures. */
1117 gdb_assert (len
<= 32);
1119 memset (buf
, 0, sizeof (buf
));
1120 memcpy (buf
, valbuf
, len
);
1121 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1122 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1126 /* Integral and pointer return values. */
1127 gdb_assert (sparc64_integral_or_pointer_p (type
));
1129 /* ??? Do we need to do any sign-extension here? */
1131 memcpy (buf
+ 8 - len
, valbuf
, len
);
1132 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
, buf
);
1136 static enum return_value_convention
1137 sparc64_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
1138 struct type
*type
, struct regcache
*regcache
,
1139 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1141 if (TYPE_LENGTH (type
) > 32)
1142 return RETURN_VALUE_STRUCT_CONVENTION
;
1145 sparc64_extract_return_value (type
, regcache
, readbuf
);
1147 sparc64_store_return_value (type
, regcache
, writebuf
);
1149 return RETURN_VALUE_REGISTER_CONVENTION
;
1154 sparc64_dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
1155 struct dwarf2_frame_state_reg
*reg
,
1156 struct frame_info
*this_frame
)
1160 case SPARC_G0_REGNUM
:
1161 /* Since %g0 is always zero, there is no point in saving it, and
1162 people will be inclined omit it from the CFI. Make sure we
1163 don't warn about that. */
1164 reg
->how
= DWARF2_FRAME_REG_SAME_VALUE
;
1166 case SPARC_SP_REGNUM
:
1167 reg
->how
= DWARF2_FRAME_REG_CFA
;
1169 case SPARC64_PC_REGNUM
:
1170 reg
->how
= DWARF2_FRAME_REG_RA_OFFSET
;
1171 reg
->loc
.offset
= 8;
1173 case SPARC64_NPC_REGNUM
:
1174 reg
->how
= DWARF2_FRAME_REG_RA_OFFSET
;
1175 reg
->loc
.offset
= 12;
1181 sparc64_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1183 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1185 tdep
->pc_regnum
= SPARC64_PC_REGNUM
;
1186 tdep
->npc_regnum
= SPARC64_NPC_REGNUM
;
1188 /* This is what all the fuss is about. */
1189 set_gdbarch_long_bit (gdbarch
, 64);
1190 set_gdbarch_long_long_bit (gdbarch
, 64);
1191 set_gdbarch_ptr_bit (gdbarch
, 64);
1193 set_gdbarch_num_regs (gdbarch
, SPARC64_NUM_REGS
);
1194 set_gdbarch_register_name (gdbarch
, sparc64_register_name
);
1195 set_gdbarch_register_type (gdbarch
, sparc64_register_type
);
1196 set_gdbarch_num_pseudo_regs (gdbarch
, SPARC64_NUM_PSEUDO_REGS
);
1197 set_gdbarch_pseudo_register_read (gdbarch
, sparc64_pseudo_register_read
);
1198 set_gdbarch_pseudo_register_write (gdbarch
, sparc64_pseudo_register_write
);
1200 /* Register numbers of various important registers. */
1201 set_gdbarch_pc_regnum (gdbarch
, SPARC64_PC_REGNUM
); /* %pc */
1203 /* Call dummy code. */
1204 set_gdbarch_frame_align (gdbarch
, sparc64_frame_align
);
1205 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1206 set_gdbarch_push_dummy_code (gdbarch
, NULL
);
1207 set_gdbarch_push_dummy_call (gdbarch
, sparc64_push_dummy_call
);
1209 set_gdbarch_return_value (gdbarch
, sparc64_return_value
);
1210 set_gdbarch_stabs_argument_has_addr
1211 (gdbarch
, default_stabs_argument_has_addr
);
1213 set_gdbarch_skip_prologue (gdbarch
, sparc64_skip_prologue
);
1214 set_gdbarch_in_function_epilogue_p (gdbarch
, sparc_in_function_epilogue_p
);
1216 /* Hook in the DWARF CFI frame unwinder. */
1217 dwarf2_frame_set_init_reg (gdbarch
, sparc64_dwarf2_frame_init_reg
);
1218 /* FIXME: kettenis/20050423: Don't enable the unwinder until the
1219 StackGhost issues have been resolved. */
1221 frame_unwind_append_unwinder (gdbarch
, &sparc64_frame_unwind
);
1222 frame_base_set_default (gdbarch
, &sparc64_frame_base
);
1226 /* Helper functions for dealing with register sets. */
1228 #define TSTATE_CWP 0x000000000000001fULL
1229 #define TSTATE_ICC 0x0000000f00000000ULL
1230 #define TSTATE_XCC 0x000000f000000000ULL
1232 #define PSR_S 0x00000080
1233 #define PSR_ICC 0x00f00000
1234 #define PSR_VERS 0x0f000000
1235 #define PSR_IMPL 0xf0000000
1236 #define PSR_V8PLUS 0xff000000
1237 #define PSR_XCC 0x000f0000
1240 sparc64_supply_gregset (const struct sparc_gregmap
*gregmap
,
1241 struct regcache
*regcache
,
1242 int regnum
, const void *gregs
)
1244 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1245 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1246 int sparc32
= (gdbarch_ptr_bit (gdbarch
) == 32);
1247 const gdb_byte
*regs
= gregs
;
1248 gdb_byte zero
[8] = { 0 };
1253 if (regnum
== SPARC32_PSR_REGNUM
|| regnum
== -1)
1255 int offset
= gregmap
->r_tstate_offset
;
1256 ULONGEST tstate
, psr
;
1259 tstate
= extract_unsigned_integer (regs
+ offset
, 8, byte_order
);
1260 psr
= ((tstate
& TSTATE_CWP
) | PSR_S
| ((tstate
& TSTATE_ICC
) >> 12)
1261 | ((tstate
& TSTATE_XCC
) >> 20) | PSR_V8PLUS
);
1262 store_unsigned_integer (buf
, 4, byte_order
, psr
);
1263 regcache_raw_supply (regcache
, SPARC32_PSR_REGNUM
, buf
);
1266 if (regnum
== SPARC32_PC_REGNUM
|| regnum
== -1)
1267 regcache_raw_supply (regcache
, SPARC32_PC_REGNUM
,
1268 regs
+ gregmap
->r_pc_offset
+ 4);
1270 if (regnum
== SPARC32_NPC_REGNUM
|| regnum
== -1)
1271 regcache_raw_supply (regcache
, SPARC32_NPC_REGNUM
,
1272 regs
+ gregmap
->r_npc_offset
+ 4);
1274 if (regnum
== SPARC32_Y_REGNUM
|| regnum
== -1)
1276 int offset
= gregmap
->r_y_offset
+ 8 - gregmap
->r_y_size
;
1277 regcache_raw_supply (regcache
, SPARC32_Y_REGNUM
, regs
+ offset
);
1282 if (regnum
== SPARC64_STATE_REGNUM
|| regnum
== -1)
1283 regcache_raw_supply (regcache
, SPARC64_STATE_REGNUM
,
1284 regs
+ gregmap
->r_tstate_offset
);
1286 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== -1)
1287 regcache_raw_supply (regcache
, SPARC64_PC_REGNUM
,
1288 regs
+ gregmap
->r_pc_offset
);
1290 if (regnum
== SPARC64_NPC_REGNUM
|| regnum
== -1)
1291 regcache_raw_supply (regcache
, SPARC64_NPC_REGNUM
,
1292 regs
+ gregmap
->r_npc_offset
);
1294 if (regnum
== SPARC64_Y_REGNUM
|| regnum
== -1)
1299 memcpy (buf
+ 8 - gregmap
->r_y_size
,
1300 regs
+ gregmap
->r_y_offset
, gregmap
->r_y_size
);
1301 regcache_raw_supply (regcache
, SPARC64_Y_REGNUM
, buf
);
1304 if ((regnum
== SPARC64_FPRS_REGNUM
|| regnum
== -1)
1305 && gregmap
->r_fprs_offset
!= -1)
1306 regcache_raw_supply (regcache
, SPARC64_FPRS_REGNUM
,
1307 regs
+ gregmap
->r_fprs_offset
);
1310 if (regnum
== SPARC_G0_REGNUM
|| regnum
== -1)
1311 regcache_raw_supply (regcache
, SPARC_G0_REGNUM
, &zero
);
1313 if ((regnum
>= SPARC_G1_REGNUM
&& regnum
<= SPARC_O7_REGNUM
) || regnum
== -1)
1315 int offset
= gregmap
->r_g1_offset
;
1320 for (i
= SPARC_G1_REGNUM
; i
<= SPARC_O7_REGNUM
; i
++)
1322 if (regnum
== i
|| regnum
== -1)
1323 regcache_raw_supply (regcache
, i
, regs
+ offset
);
1328 if ((regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
) || regnum
== -1)
1330 /* Not all of the register set variants include Locals and
1331 Inputs. For those that don't, we read them off the stack. */
1332 if (gregmap
->r_l0_offset
== -1)
1336 regcache_cooked_read_unsigned (regcache
, SPARC_SP_REGNUM
, &sp
);
1337 sparc_supply_rwindow (regcache
, sp
, regnum
);
1341 int offset
= gregmap
->r_l0_offset
;
1346 for (i
= SPARC_L0_REGNUM
; i
<= SPARC_I7_REGNUM
; i
++)
1348 if (regnum
== i
|| regnum
== -1)
1349 regcache_raw_supply (regcache
, i
, regs
+ offset
);
1357 sparc64_collect_gregset (const struct sparc_gregmap
*gregmap
,
1358 const struct regcache
*regcache
,
1359 int regnum
, void *gregs
)
1361 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1362 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1363 int sparc32
= (gdbarch_ptr_bit (gdbarch
) == 32);
1364 gdb_byte
*regs
= gregs
;
1369 if (regnum
== SPARC32_PSR_REGNUM
|| regnum
== -1)
1371 int offset
= gregmap
->r_tstate_offset
;
1372 ULONGEST tstate
, psr
;
1375 tstate
= extract_unsigned_integer (regs
+ offset
, 8, byte_order
);
1376 regcache_raw_collect (regcache
, SPARC32_PSR_REGNUM
, buf
);
1377 psr
= extract_unsigned_integer (buf
, 4, byte_order
);
1378 tstate
|= (psr
& PSR_ICC
) << 12;
1379 if ((psr
& (PSR_VERS
| PSR_IMPL
)) == PSR_V8PLUS
)
1380 tstate
|= (psr
& PSR_XCC
) << 20;
1381 store_unsigned_integer (buf
, 8, byte_order
, tstate
);
1382 memcpy (regs
+ offset
, buf
, 8);
1385 if (regnum
== SPARC32_PC_REGNUM
|| regnum
== -1)
1386 regcache_raw_collect (regcache
, SPARC32_PC_REGNUM
,
1387 regs
+ gregmap
->r_pc_offset
+ 4);
1389 if (regnum
== SPARC32_NPC_REGNUM
|| regnum
== -1)
1390 regcache_raw_collect (regcache
, SPARC32_NPC_REGNUM
,
1391 regs
+ gregmap
->r_npc_offset
+ 4);
1393 if (regnum
== SPARC32_Y_REGNUM
|| regnum
== -1)
1395 int offset
= gregmap
->r_y_offset
+ 8 - gregmap
->r_y_size
;
1396 regcache_raw_collect (regcache
, SPARC32_Y_REGNUM
, regs
+ offset
);
1401 if (regnum
== SPARC64_STATE_REGNUM
|| regnum
== -1)
1402 regcache_raw_collect (regcache
, SPARC64_STATE_REGNUM
,
1403 regs
+ gregmap
->r_tstate_offset
);
1405 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== -1)
1406 regcache_raw_collect (regcache
, SPARC64_PC_REGNUM
,
1407 regs
+ gregmap
->r_pc_offset
);
1409 if (regnum
== SPARC64_NPC_REGNUM
|| regnum
== -1)
1410 regcache_raw_collect (regcache
, SPARC64_NPC_REGNUM
,
1411 regs
+ gregmap
->r_npc_offset
);
1413 if (regnum
== SPARC64_Y_REGNUM
|| regnum
== -1)
1417 regcache_raw_collect (regcache
, SPARC64_Y_REGNUM
, buf
);
1418 memcpy (regs
+ gregmap
->r_y_offset
,
1419 buf
+ 8 - gregmap
->r_y_size
, gregmap
->r_y_size
);
1422 if ((regnum
== SPARC64_FPRS_REGNUM
|| regnum
== -1)
1423 && gregmap
->r_fprs_offset
!= -1)
1424 regcache_raw_collect (regcache
, SPARC64_FPRS_REGNUM
,
1425 regs
+ gregmap
->r_fprs_offset
);
1429 if ((regnum
>= SPARC_G1_REGNUM
&& regnum
<= SPARC_O7_REGNUM
) || regnum
== -1)
1431 int offset
= gregmap
->r_g1_offset
;
1436 /* %g0 is always zero. */
1437 for (i
= SPARC_G1_REGNUM
; i
<= SPARC_O7_REGNUM
; i
++)
1439 if (regnum
== i
|| regnum
== -1)
1440 regcache_raw_collect (regcache
, i
, regs
+ offset
);
1445 if ((regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
) || regnum
== -1)
1447 /* Not all of the register set variants include Locals and
1448 Inputs. For those that don't, we read them off the stack. */
1449 if (gregmap
->r_l0_offset
!= -1)
1451 int offset
= gregmap
->r_l0_offset
;
1456 for (i
= SPARC_L0_REGNUM
; i
<= SPARC_I7_REGNUM
; i
++)
1458 if (regnum
== i
|| regnum
== -1)
1459 regcache_raw_collect (regcache
, i
, regs
+ offset
);
1467 sparc64_supply_fpregset (const struct sparc_fpregmap
*fpregmap
,
1468 struct regcache
*regcache
,
1469 int regnum
, const void *fpregs
)
1471 int sparc32
= (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32);
1472 const gdb_byte
*regs
= fpregs
;
1475 for (i
= 0; i
< 32; i
++)
1477 if (regnum
== (SPARC_F0_REGNUM
+ i
) || regnum
== -1)
1478 regcache_raw_supply (regcache
, SPARC_F0_REGNUM
+ i
,
1479 regs
+ fpregmap
->r_f0_offset
+ (i
* 4));
1484 if (regnum
== SPARC32_FSR_REGNUM
|| regnum
== -1)
1485 regcache_raw_supply (regcache
, SPARC32_FSR_REGNUM
,
1486 regs
+ fpregmap
->r_fsr_offset
);
1490 for (i
= 0; i
< 16; i
++)
1492 if (regnum
== (SPARC64_F32_REGNUM
+ i
) || regnum
== -1)
1493 regcache_raw_supply (regcache
, SPARC64_F32_REGNUM
+ i
,
1494 (regs
+ fpregmap
->r_f0_offset
1495 + (32 * 4) + (i
* 8)));
1498 if (regnum
== SPARC64_FSR_REGNUM
|| regnum
== -1)
1499 regcache_raw_supply (regcache
, SPARC64_FSR_REGNUM
,
1500 regs
+ fpregmap
->r_fsr_offset
);
1505 sparc64_collect_fpregset (const struct sparc_fpregmap
*fpregmap
,
1506 const struct regcache
*regcache
,
1507 int regnum
, void *fpregs
)
1509 int sparc32
= (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32);
1510 gdb_byte
*regs
= fpregs
;
1513 for (i
= 0; i
< 32; i
++)
1515 if (regnum
== (SPARC_F0_REGNUM
+ i
) || regnum
== -1)
1516 regcache_raw_collect (regcache
, SPARC_F0_REGNUM
+ i
,
1517 regs
+ fpregmap
->r_f0_offset
+ (i
* 4));
1522 if (regnum
== SPARC32_FSR_REGNUM
|| regnum
== -1)
1523 regcache_raw_collect (regcache
, SPARC32_FSR_REGNUM
,
1524 regs
+ fpregmap
->r_fsr_offset
);
1528 for (i
= 0; i
< 16; i
++)
1530 if (regnum
== (SPARC64_F32_REGNUM
+ i
) || regnum
== -1)
1531 regcache_raw_collect (regcache
, SPARC64_F32_REGNUM
+ i
,
1532 (regs
+ fpregmap
->r_f0_offset
1533 + (32 * 4) + (i
* 8)));
1536 if (regnum
== SPARC64_FSR_REGNUM
|| regnum
== -1)
1537 regcache_raw_collect (regcache
, SPARC64_FSR_REGNUM
,
1538 regs
+ fpregmap
->r_fsr_offset
);
1542 const struct sparc_fpregmap sparc64_bsd_fpregmap
=