1 /* Target-dependent code for UltraSPARC.
3 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
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 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". */
109 sparc64_structure_or_union_p (const struct type
*type
)
111 switch (TYPE_CODE (type
))
113 case TYPE_CODE_STRUCT
:
114 case TYPE_CODE_UNION
:
124 /* Type for %pstate. */
125 struct type
*sparc64_pstate_type
;
128 struct type
*sparc64_fsr_type
;
130 /* Type for %fprs. */
131 struct type
*sparc64_fprs_type
;
133 /* Construct types for ISA-specific registers. */
136 sparc64_init_types (void)
140 type
= init_flags_type ("builtin_type_sparc64_pstate", 8);
141 append_flags_type_flag (type
, 0, "AG");
142 append_flags_type_flag (type
, 1, "IE");
143 append_flags_type_flag (type
, 2, "PRIV");
144 append_flags_type_flag (type
, 3, "AM");
145 append_flags_type_flag (type
, 4, "PEF");
146 append_flags_type_flag (type
, 5, "RED");
147 append_flags_type_flag (type
, 8, "TLE");
148 append_flags_type_flag (type
, 9, "CLE");
149 append_flags_type_flag (type
, 10, "PID0");
150 append_flags_type_flag (type
, 11, "PID1");
151 sparc64_pstate_type
= type
;
153 type
= init_flags_type ("builtin_type_sparc64_fsr", 8);
154 append_flags_type_flag (type
, 0, "NXA");
155 append_flags_type_flag (type
, 1, "DZA");
156 append_flags_type_flag (type
, 2, "UFA");
157 append_flags_type_flag (type
, 3, "OFA");
158 append_flags_type_flag (type
, 4, "NVA");
159 append_flags_type_flag (type
, 5, "NXC");
160 append_flags_type_flag (type
, 6, "DZC");
161 append_flags_type_flag (type
, 7, "UFC");
162 append_flags_type_flag (type
, 8, "OFC");
163 append_flags_type_flag (type
, 9, "NVC");
164 append_flags_type_flag (type
, 22, "NS");
165 append_flags_type_flag (type
, 23, "NXM");
166 append_flags_type_flag (type
, 24, "DZM");
167 append_flags_type_flag (type
, 25, "UFM");
168 append_flags_type_flag (type
, 26, "OFM");
169 append_flags_type_flag (type
, 27, "NVM");
170 sparc64_fsr_type
= type
;
172 type
= init_flags_type ("builtin_type_sparc64_fprs", 8);
173 append_flags_type_flag (type
, 0, "DL");
174 append_flags_type_flag (type
, 1, "DU");
175 append_flags_type_flag (type
, 2, "FEF");
176 sparc64_fprs_type
= type
;
179 /* Register information. */
181 static const char *sparc64_register_names
[] =
183 "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
184 "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
185 "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
186 "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
188 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
189 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
190 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
191 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
192 "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46",
193 "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62",
197 /* FIXME: Give "state" a name until we start using register groups. */
204 /* Total number of registers. */
205 #define SPARC64_NUM_REGS ARRAY_SIZE (sparc64_register_names)
207 /* We provide the aliases %d0..%d62 and %q0..%q60 for the floating
208 registers as "psuedo" registers. */
210 static const char *sparc64_pseudo_register_names
[] =
212 "cwp", "pstate", "asi", "ccr",
214 "d0", "d2", "d4", "d6", "d8", "d10", "d12", "d14",
215 "d16", "d18", "d20", "d22", "d24", "d26", "d28", "d30",
216 "d32", "d34", "d36", "d38", "d40", "d42", "d44", "d46",
217 "d48", "d50", "d52", "d54", "d56", "d58", "d60", "d62",
219 "q0", "q4", "q8", "q12", "q16", "q20", "q24", "q28",
220 "q32", "q36", "q40", "q44", "q48", "q52", "q56", "q60",
223 /* Total number of pseudo registers. */
224 #define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_names)
226 /* Return the name of register REGNUM. */
229 sparc64_register_name (struct gdbarch
*gdbarch
, int regnum
)
231 if (regnum
>= 0 && regnum
< SPARC64_NUM_REGS
)
232 return sparc64_register_names
[regnum
];
234 if (regnum
>= SPARC64_NUM_REGS
235 && regnum
< SPARC64_NUM_REGS
+ SPARC64_NUM_PSEUDO_REGS
)
236 return sparc64_pseudo_register_names
[regnum
- SPARC64_NUM_REGS
];
241 /* Return the GDB type object for the "standard" data type of data in
245 sparc64_register_type (struct gdbarch
*gdbarch
, int regnum
)
249 if (regnum
== SPARC_SP_REGNUM
|| regnum
== SPARC_FP_REGNUM
)
250 return builtin_type (gdbarch
)->builtin_data_ptr
;
251 if (regnum
>= SPARC_G0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
)
252 return builtin_type (gdbarch
)->builtin_int64
;
253 if (regnum
>= SPARC_F0_REGNUM
&& regnum
<= SPARC_F31_REGNUM
)
254 return builtin_type (gdbarch
)->builtin_float
;
255 if (regnum
>= SPARC64_F32_REGNUM
&& regnum
<= SPARC64_F62_REGNUM
)
256 return builtin_type (gdbarch
)->builtin_double
;
257 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== SPARC64_NPC_REGNUM
)
258 return builtin_type (gdbarch
)->builtin_func_ptr
;
259 /* This raw register contains the contents of %cwp, %pstate, %asi
260 and %ccr as laid out in a %tstate register. */
261 if (regnum
== SPARC64_STATE_REGNUM
)
262 return builtin_type (gdbarch
)->builtin_int64
;
263 if (regnum
== SPARC64_FSR_REGNUM
)
264 return sparc64_fsr_type
;
265 if (regnum
== SPARC64_FPRS_REGNUM
)
266 return sparc64_fprs_type
;
267 /* "Although Y is a 64-bit register, its high-order 32 bits are
268 reserved and always read as 0." */
269 if (regnum
== SPARC64_Y_REGNUM
)
270 return builtin_type (gdbarch
)->builtin_int64
;
272 /* Pseudo registers. */
274 if (regnum
== SPARC64_CWP_REGNUM
)
275 return builtin_type (gdbarch
)->builtin_int64
;
276 if (regnum
== SPARC64_PSTATE_REGNUM
)
277 return sparc64_pstate_type
;
278 if (regnum
== SPARC64_ASI_REGNUM
)
279 return builtin_type (gdbarch
)->builtin_int64
;
280 if (regnum
== SPARC64_CCR_REGNUM
)
281 return builtin_type (gdbarch
)->builtin_int64
;
282 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
283 return builtin_type (gdbarch
)->builtin_double
;
284 if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
285 return builtin_type (gdbarch
)->builtin_long_double
;
287 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
291 sparc64_pseudo_register_read (struct gdbarch
*gdbarch
,
292 struct regcache
*regcache
,
293 int regnum
, gdb_byte
*buf
)
295 gdb_assert (regnum
>= SPARC64_NUM_REGS
);
297 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D30_REGNUM
)
299 regnum
= SPARC_F0_REGNUM
+ 2 * (regnum
- SPARC64_D0_REGNUM
);
300 regcache_raw_read (regcache
, regnum
, buf
);
301 regcache_raw_read (regcache
, regnum
+ 1, buf
+ 4);
303 else if (regnum
>= SPARC64_D32_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
305 regnum
= SPARC64_F32_REGNUM
+ (regnum
- SPARC64_D32_REGNUM
);
306 regcache_raw_read (regcache
, regnum
, buf
);
308 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q28_REGNUM
)
310 regnum
= SPARC_F0_REGNUM
+ 4 * (regnum
- SPARC64_Q0_REGNUM
);
311 regcache_raw_read (regcache
, regnum
, buf
);
312 regcache_raw_read (regcache
, regnum
+ 1, buf
+ 4);
313 regcache_raw_read (regcache
, regnum
+ 2, buf
+ 8);
314 regcache_raw_read (regcache
, regnum
+ 3, buf
+ 12);
316 else if (regnum
>= SPARC64_Q32_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
318 regnum
= SPARC64_F32_REGNUM
+ 2 * (regnum
- SPARC64_Q32_REGNUM
);
319 regcache_raw_read (regcache
, regnum
, buf
);
320 regcache_raw_read (regcache
, regnum
+ 1, buf
+ 8);
322 else if (regnum
== SPARC64_CWP_REGNUM
323 || regnum
== SPARC64_PSTATE_REGNUM
324 || regnum
== SPARC64_ASI_REGNUM
325 || regnum
== SPARC64_CCR_REGNUM
)
329 regcache_raw_read_unsigned (regcache
, SPARC64_STATE_REGNUM
, &state
);
332 case SPARC64_CWP_REGNUM
:
333 state
= (state
>> 0) & ((1 << 5) - 1);
335 case SPARC64_PSTATE_REGNUM
:
336 state
= (state
>> 8) & ((1 << 12) - 1);
338 case SPARC64_ASI_REGNUM
:
339 state
= (state
>> 24) & ((1 << 8) - 1);
341 case SPARC64_CCR_REGNUM
:
342 state
= (state
>> 32) & ((1 << 8) - 1);
345 store_unsigned_integer (buf
, 8, state
);
350 sparc64_pseudo_register_write (struct gdbarch
*gdbarch
,
351 struct regcache
*regcache
,
352 int regnum
, const gdb_byte
*buf
)
354 gdb_assert (regnum
>= SPARC64_NUM_REGS
);
356 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D30_REGNUM
)
358 regnum
= SPARC_F0_REGNUM
+ 2 * (regnum
- SPARC64_D0_REGNUM
);
359 regcache_raw_write (regcache
, regnum
, buf
);
360 regcache_raw_write (regcache
, regnum
+ 1, buf
+ 4);
362 else if (regnum
>= SPARC64_D32_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
364 regnum
= SPARC64_F32_REGNUM
+ (regnum
- SPARC64_D32_REGNUM
);
365 regcache_raw_write (regcache
, regnum
, buf
);
367 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q28_REGNUM
)
369 regnum
= SPARC_F0_REGNUM
+ 4 * (regnum
- SPARC64_Q0_REGNUM
);
370 regcache_raw_write (regcache
, regnum
, buf
);
371 regcache_raw_write (regcache
, regnum
+ 1, buf
+ 4);
372 regcache_raw_write (regcache
, regnum
+ 2, buf
+ 8);
373 regcache_raw_write (regcache
, regnum
+ 3, buf
+ 12);
375 else if (regnum
>= SPARC64_Q32_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
377 regnum
= SPARC64_F32_REGNUM
+ 2 * (regnum
- SPARC64_Q32_REGNUM
);
378 regcache_raw_write (regcache
, regnum
, buf
);
379 regcache_raw_write (regcache
, regnum
+ 1, buf
+ 8);
381 else if (regnum
== SPARC64_CWP_REGNUM
382 || regnum
== SPARC64_PSTATE_REGNUM
383 || regnum
== SPARC64_ASI_REGNUM
384 || regnum
== SPARC64_CCR_REGNUM
)
386 ULONGEST state
, bits
;
388 regcache_raw_read_unsigned (regcache
, SPARC64_STATE_REGNUM
, &state
);
389 bits
= extract_unsigned_integer (buf
, 8);
392 case SPARC64_CWP_REGNUM
:
393 state
|= ((bits
& ((1 << 5) - 1)) << 0);
395 case SPARC64_PSTATE_REGNUM
:
396 state
|= ((bits
& ((1 << 12) - 1)) << 8);
398 case SPARC64_ASI_REGNUM
:
399 state
|= ((bits
& ((1 << 8) - 1)) << 24);
401 case SPARC64_CCR_REGNUM
:
402 state
|= ((bits
& ((1 << 8) - 1)) << 32);
405 regcache_raw_write_unsigned (regcache
, SPARC64_STATE_REGNUM
, state
);
410 /* Return PC of first real instruction of the function starting at
414 sparc64_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR start_pc
)
416 struct symtab_and_line sal
;
417 CORE_ADDR func_start
, func_end
;
418 struct sparc_frame_cache cache
;
420 /* This is the preferred method, find the end of the prologue by
421 using the debugging information. */
422 if (find_pc_partial_function (start_pc
, NULL
, &func_start
, &func_end
))
424 sal
= find_pc_line (func_start
, 0);
426 if (sal
.end
< func_end
427 && start_pc
<= sal
.end
)
431 return sparc_analyze_prologue (gdbarch
, start_pc
, 0xffffffffffffffffULL
,
437 static struct sparc_frame_cache
*
438 sparc64_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
440 return sparc_frame_cache (this_frame
, this_cache
);
444 sparc64_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
445 struct frame_id
*this_id
)
447 struct sparc_frame_cache
*cache
=
448 sparc64_frame_cache (this_frame
, this_cache
);
450 /* This marks the outermost frame. */
451 if (cache
->base
== 0)
454 (*this_id
) = frame_id_build (cache
->base
, cache
->pc
);
457 static struct value
*
458 sparc64_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
461 struct sparc_frame_cache
*cache
=
462 sparc64_frame_cache (this_frame
, this_cache
);
464 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== SPARC64_NPC_REGNUM
)
466 CORE_ADDR pc
= (regnum
== SPARC64_NPC_REGNUM
) ? 4 : 0;
468 regnum
= cache
->frameless_p
? SPARC_O7_REGNUM
: SPARC_I7_REGNUM
;
469 pc
+= get_frame_register_unsigned (this_frame
, regnum
) + 8;
470 return frame_unwind_got_constant (this_frame
, regnum
, pc
);
473 /* Handle StackGhost. */
475 ULONGEST wcookie
= sparc_fetch_wcookie ();
477 if (wcookie
!= 0 && !cache
->frameless_p
&& regnum
== SPARC_I7_REGNUM
)
479 CORE_ADDR addr
= cache
->base
+ (regnum
- SPARC_L0_REGNUM
) * 8;
482 /* Read the value in from memory. */
483 i7
= get_frame_memory_unsigned (this_frame
, addr
, 8);
484 return frame_unwind_got_constant (this_frame
, regnum
, i7
^ wcookie
);
488 /* The previous frame's `local' and `in' registers have been saved
489 in the register save area. */
490 if (!cache
->frameless_p
491 && regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
)
493 CORE_ADDR addr
= cache
->base
+ (regnum
- SPARC_L0_REGNUM
) * 8;
495 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
498 /* The previous frame's `out' registers are accessable as the
499 current frame's `in' registers. */
500 if (!cache
->frameless_p
501 && regnum
>= SPARC_O0_REGNUM
&& regnum
<= SPARC_O7_REGNUM
)
502 regnum
+= (SPARC_I0_REGNUM
- SPARC_O0_REGNUM
);
504 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
507 static const struct frame_unwind sparc64_frame_unwind
=
510 sparc64_frame_this_id
,
511 sparc64_frame_prev_register
,
513 default_frame_sniffer
518 sparc64_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
520 struct sparc_frame_cache
*cache
=
521 sparc64_frame_cache (this_frame
, this_cache
);
526 static const struct frame_base sparc64_frame_base
=
528 &sparc64_frame_unwind
,
529 sparc64_frame_base_address
,
530 sparc64_frame_base_address
,
531 sparc64_frame_base_address
534 /* Check whether TYPE must be 16-byte aligned. */
537 sparc64_16_byte_align_p (struct type
*type
)
539 if (sparc64_floating_p (type
) && TYPE_LENGTH (type
) == 16)
542 if (sparc64_structure_or_union_p (type
))
546 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
548 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
550 if (sparc64_16_byte_align_p (subtype
))
558 /* Store floating fields of element ELEMENT of an "parameter array"
559 that has type TYPE and is stored at BITPOS in VALBUF in the
560 apropriate registers of REGCACHE. This function can be called
561 recursively and therefore handles floating types in addition to
565 sparc64_store_floating_fields (struct regcache
*regcache
, struct type
*type
,
566 const gdb_byte
*valbuf
, int element
, int bitpos
)
568 gdb_assert (element
< 16);
570 if (sparc64_floating_p (type
))
572 int len
= TYPE_LENGTH (type
);
577 gdb_assert (bitpos
== 0);
578 gdb_assert ((element
% 2) == 0);
580 regnum
= SPARC64_Q0_REGNUM
+ element
/ 2;
581 regcache_cooked_write (regcache
, regnum
, valbuf
);
585 gdb_assert (bitpos
== 0 || bitpos
== 64);
587 regnum
= SPARC64_D0_REGNUM
+ element
+ bitpos
/ 64;
588 regcache_cooked_write (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
592 gdb_assert (len
== 4);
593 gdb_assert (bitpos
% 32 == 0 && bitpos
>= 0 && bitpos
< 128);
595 regnum
= SPARC_F0_REGNUM
+ element
* 2 + bitpos
/ 32;
596 regcache_cooked_write (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
599 else 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
));
606 int subpos
= bitpos
+ TYPE_FIELD_BITPOS (type
, i
);
608 sparc64_store_floating_fields (regcache
, subtype
, valbuf
,
612 /* GCC has an interesting bug. If TYPE is a structure that has
613 a single `float' member, GCC doesn't treat it as a structure
614 at all, but rather as an ordinary `float' argument. This
615 argument will be stored in %f1, as required by the psABI.
616 However, as a member of a structure the psABI requires it to
617 be stored in %f0. This bug is present in GCC 3.3.2, but
618 probably in older releases to. To appease GCC, if a
619 structure has only a single `float' member, we store its
620 value in %f1 too (we already have stored in %f0). */
621 if (TYPE_NFIELDS (type
) == 1)
623 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
625 if (sparc64_floating_p (subtype
) && TYPE_LENGTH (subtype
) == 4)
626 regcache_cooked_write (regcache
, SPARC_F1_REGNUM
, valbuf
);
631 /* Fetch floating fields from a variable of type TYPE from the
632 appropriate registers for BITPOS in REGCACHE and store it at BITPOS
633 in VALBUF. This function can be called recursively and therefore
634 handles floating types in addition to structures. */
637 sparc64_extract_floating_fields (struct regcache
*regcache
, struct type
*type
,
638 gdb_byte
*valbuf
, int bitpos
)
640 if (sparc64_floating_p (type
))
642 int len
= TYPE_LENGTH (type
);
647 gdb_assert (bitpos
== 0 || bitpos
== 128);
649 regnum
= SPARC64_Q0_REGNUM
+ bitpos
/ 128;
650 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
654 gdb_assert (bitpos
% 64 == 0 && bitpos
>= 0 && bitpos
< 256);
656 regnum
= SPARC64_D0_REGNUM
+ bitpos
/ 64;
657 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
661 gdb_assert (len
== 4);
662 gdb_assert (bitpos
% 32 == 0 && bitpos
>= 0 && bitpos
< 256);
664 regnum
= SPARC_F0_REGNUM
+ bitpos
/ 32;
665 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
668 else if (sparc64_structure_or_union_p (type
))
672 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
674 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
675 int subpos
= bitpos
+ TYPE_FIELD_BITPOS (type
, i
);
677 sparc64_extract_floating_fields (regcache
, subtype
, valbuf
, subpos
);
682 /* Store the NARGS arguments ARGS and STRUCT_ADDR (if STRUCT_RETURN is
683 non-zero) in REGCACHE and on the stack (starting from address SP). */
686 sparc64_store_arguments (struct regcache
*regcache
, int nargs
,
687 struct value
**args
, CORE_ADDR sp
,
688 int struct_return
, CORE_ADDR struct_addr
)
690 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
691 /* Number of extended words in the "parameter array". */
692 int num_elements
= 0;
696 /* Take BIAS into account. */
699 /* First we calculate the number of extended words in the "parameter
700 array". While doing so we also convert some of the arguments. */
705 for (i
= 0; i
< nargs
; i
++)
707 struct type
*type
= value_type (args
[i
]);
708 int len
= TYPE_LENGTH (type
);
710 if (sparc64_structure_or_union_p (type
))
712 /* Structure or Union arguments. */
715 if (num_elements
% 2 && sparc64_16_byte_align_p (type
))
717 num_elements
+= ((len
+ 7) / 8);
721 /* The psABI says that "Structures or unions larger than
722 sixteen bytes are copied by the caller and passed
723 indirectly; the caller will pass the address of a
724 correctly aligned structure value. This sixty-four
725 bit address will occupy one word in the parameter
726 array, and may be promoted to an %o register like any
727 other pointer value." Allocate memory for these
728 values on the stack. */
731 /* Use 16-byte alignment for these values. That's
732 always correct, and wasting a few bytes shouldn't be
736 write_memory (sp
, value_contents (args
[i
]), len
);
737 args
[i
] = value_from_pointer (lookup_pointer_type (type
), sp
);
741 else if (sparc64_floating_p (type
))
743 /* Floating arguments. */
747 /* The psABI says that "Each quad-precision parameter
748 value will be assigned to two extended words in the
752 /* The psABI says that "Long doubles must be
753 quad-aligned, and thus a hole might be introduced
754 into the parameter array to force alignment." Skip
755 an element if necessary. */
756 if (num_elements
% 2)
764 /* Integral and pointer arguments. */
765 gdb_assert (sparc64_integral_or_pointer_p (type
));
767 /* The psABI says that "Each argument value of integral type
768 smaller than an extended word will be widened by the
769 caller to an extended word according to the signed-ness
770 of the argument type." */
772 args
[i
] = value_cast (builtin_type (gdbarch
)->builtin_int64
,
778 /* Allocate the "parameter array". */
779 sp
-= num_elements
* 8;
781 /* The psABI says that "Every stack frame must be 16-byte aligned." */
784 /* Now we store the arguments in to the "paramater array". Some
785 Integer or Pointer arguments and Structure or Union arguments
786 will be passed in %o registers. Some Floating arguments and
787 floating members of structures are passed in floating-point
788 registers. However, for functions with variable arguments,
789 floating arguments are stored in an %0 register, and for
790 functions without a prototype floating arguments are stored in
791 both a floating-point and an %o registers, or a floating-point
792 register and memory. To simplify the logic here we always pass
793 arguments in memory, an %o register, and a floating-point
794 register if appropriate. This should be no problem since the
795 contents of any unused memory or registers in the "parameter
796 array" are undefined. */
800 regcache_cooked_write_unsigned (regcache
, SPARC_O0_REGNUM
, struct_addr
);
804 for (i
= 0; i
< nargs
; i
++)
806 const gdb_byte
*valbuf
= value_contents (args
[i
]);
807 struct type
*type
= value_type (args
[i
]);
808 int len
= TYPE_LENGTH (type
);
812 if (sparc64_structure_or_union_p (type
))
814 /* Structure or Union arguments. */
815 gdb_assert (len
<= 16);
816 memset (buf
, 0, sizeof (buf
));
817 valbuf
= memcpy (buf
, valbuf
, len
);
819 if (element
% 2 && sparc64_16_byte_align_p (type
))
824 regnum
= SPARC_O0_REGNUM
+ element
;
825 if (len
> 8 && element
< 5)
826 regcache_cooked_write (regcache
, regnum
+ 1, valbuf
+ 8);
830 sparc64_store_floating_fields (regcache
, type
, valbuf
, element
, 0);
832 else if (sparc64_floating_p (type
))
834 /* Floating arguments. */
840 regnum
= SPARC64_Q0_REGNUM
+ element
/ 2;
845 regnum
= SPARC64_D0_REGNUM
+ element
;
849 /* The psABI says "Each single-precision parameter value
850 will be assigned to one extended word in the
851 parameter array, and right-justified within that
852 word; the left half (even floatregister) is
853 undefined." Even though the psABI says that "the
854 left half is undefined", set it to zero here. */
856 memcpy (buf
+ 4, valbuf
, 4);
860 regnum
= SPARC64_D0_REGNUM
+ element
;
865 /* Integral and pointer arguments. */
866 gdb_assert (len
== 8);
868 regnum
= SPARC_O0_REGNUM
+ element
;
873 regcache_cooked_write (regcache
, regnum
, valbuf
);
875 /* If we're storing the value in a floating-point register,
876 also store it in the corresponding %0 register(s). */
877 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D10_REGNUM
)
879 gdb_assert (element
< 6);
880 regnum
= SPARC_O0_REGNUM
+ element
;
881 regcache_cooked_write (regcache
, regnum
, valbuf
);
883 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q8_REGNUM
)
885 gdb_assert (element
< 6);
886 regnum
= SPARC_O0_REGNUM
+ element
;
887 regcache_cooked_write (regcache
, regnum
, valbuf
);
888 regcache_cooked_write (regcache
, regnum
+ 1, valbuf
+ 8);
892 /* Always store the argument in memory. */
893 write_memory (sp
+ element
* 8, valbuf
, len
);
894 element
+= ((len
+ 7) / 8);
897 gdb_assert (element
== num_elements
);
899 /* Take BIAS into account. */
905 sparc64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
906 struct regcache
*regcache
, CORE_ADDR bp_addr
,
907 int nargs
, struct value
**args
, CORE_ADDR sp
,
908 int struct_return
, CORE_ADDR struct_addr
)
910 /* Set return address. */
911 regcache_cooked_write_unsigned (regcache
, SPARC_O7_REGNUM
, bp_addr
- 8);
913 /* Set up function arguments. */
914 sp
= sparc64_store_arguments (regcache
, nargs
, args
, sp
,
915 struct_return
, struct_addr
);
917 /* Allocate the register save area. */
920 /* Stack should be 16-byte aligned at this point. */
921 gdb_assert ((sp
+ BIAS
) % 16 == 0);
923 /* Finally, update the stack pointer. */
924 regcache_cooked_write_unsigned (regcache
, SPARC_SP_REGNUM
, sp
);
930 /* Extract from an array REGBUF containing the (raw) register state, a
931 function return value of TYPE, and copy that into VALBUF. */
934 sparc64_extract_return_value (struct type
*type
, struct regcache
*regcache
,
937 int len
= TYPE_LENGTH (type
);
941 if (sparc64_structure_or_union_p (type
))
943 /* Structure or Union return values. */
944 gdb_assert (len
<= 32);
946 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
947 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
948 if (TYPE_CODE (type
) != TYPE_CODE_UNION
)
949 sparc64_extract_floating_fields (regcache
, type
, buf
, 0);
950 memcpy (valbuf
, buf
, len
);
952 else if (sparc64_floating_p (type
))
954 /* Floating return values. */
955 for (i
= 0; i
< len
/ 4; i
++)
956 regcache_cooked_read (regcache
, SPARC_F0_REGNUM
+ i
, buf
+ i
* 4);
957 memcpy (valbuf
, buf
, len
);
959 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
961 /* Small arrays are returned the same way as small structures. */
962 gdb_assert (len
<= 32);
964 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
965 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
966 memcpy (valbuf
, buf
, len
);
970 /* Integral and pointer return values. */
971 gdb_assert (sparc64_integral_or_pointer_p (type
));
973 /* Just stripping off any unused bytes should preserve the
974 signed-ness just fine. */
975 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
, buf
);
976 memcpy (valbuf
, buf
+ 8 - len
, len
);
980 /* Write into the appropriate registers a function return value stored
981 in VALBUF of type TYPE. */
984 sparc64_store_return_value (struct type
*type
, struct regcache
*regcache
,
985 const gdb_byte
*valbuf
)
987 int len
= TYPE_LENGTH (type
);
991 if (sparc64_structure_or_union_p (type
))
993 /* Structure or Union return values. */
994 gdb_assert (len
<= 32);
996 /* Simplify matters by storing the complete value (including
997 floating members) into %o0 and %o1. Floating members are
998 also store in the appropriate floating-point registers. */
999 memset (buf
, 0, sizeof (buf
));
1000 memcpy (buf
, valbuf
, len
);
1001 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1002 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1003 if (TYPE_CODE (type
) != TYPE_CODE_UNION
)
1004 sparc64_store_floating_fields (regcache
, type
, buf
, 0, 0);
1006 else if (sparc64_floating_p (type
))
1008 /* Floating return values. */
1009 memcpy (buf
, valbuf
, len
);
1010 for (i
= 0; i
< len
/ 4; i
++)
1011 regcache_cooked_write (regcache
, SPARC_F0_REGNUM
+ i
, buf
+ i
* 4);
1013 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1015 /* Small arrays are returned the same way as small structures. */
1016 gdb_assert (len
<= 32);
1018 memset (buf
, 0, sizeof (buf
));
1019 memcpy (buf
, valbuf
, len
);
1020 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1021 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1025 /* Integral and pointer return values. */
1026 gdb_assert (sparc64_integral_or_pointer_p (type
));
1028 /* ??? Do we need to do any sign-extension here? */
1030 memcpy (buf
+ 8 - len
, valbuf
, len
);
1031 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
, buf
);
1035 static enum return_value_convention
1036 sparc64_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
1037 struct type
*type
, struct regcache
*regcache
,
1038 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1040 if (TYPE_LENGTH (type
) > 32)
1041 return RETURN_VALUE_STRUCT_CONVENTION
;
1044 sparc64_extract_return_value (type
, regcache
, readbuf
);
1046 sparc64_store_return_value (type
, regcache
, writebuf
);
1048 return RETURN_VALUE_REGISTER_CONVENTION
;
1053 sparc64_dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
1054 struct dwarf2_frame_state_reg
*reg
,
1055 struct frame_info
*this_frame
)
1059 case SPARC_G0_REGNUM
:
1060 /* Since %g0 is always zero, there is no point in saving it, and
1061 people will be inclined omit it from the CFI. Make sure we
1062 don't warn about that. */
1063 reg
->how
= DWARF2_FRAME_REG_SAME_VALUE
;
1065 case SPARC_SP_REGNUM
:
1066 reg
->how
= DWARF2_FRAME_REG_CFA
;
1068 case SPARC64_PC_REGNUM
:
1069 reg
->how
= DWARF2_FRAME_REG_RA_OFFSET
;
1070 reg
->loc
.offset
= 8;
1072 case SPARC64_NPC_REGNUM
:
1073 reg
->how
= DWARF2_FRAME_REG_RA_OFFSET
;
1074 reg
->loc
.offset
= 12;
1080 sparc64_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1082 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1084 tdep
->pc_regnum
= SPARC64_PC_REGNUM
;
1085 tdep
->npc_regnum
= SPARC64_NPC_REGNUM
;
1087 /* This is what all the fuss is about. */
1088 set_gdbarch_long_bit (gdbarch
, 64);
1089 set_gdbarch_long_long_bit (gdbarch
, 64);
1090 set_gdbarch_ptr_bit (gdbarch
, 64);
1092 set_gdbarch_num_regs (gdbarch
, SPARC64_NUM_REGS
);
1093 set_gdbarch_register_name (gdbarch
, sparc64_register_name
);
1094 set_gdbarch_register_type (gdbarch
, sparc64_register_type
);
1095 set_gdbarch_num_pseudo_regs (gdbarch
, SPARC64_NUM_PSEUDO_REGS
);
1096 set_gdbarch_pseudo_register_read (gdbarch
, sparc64_pseudo_register_read
);
1097 set_gdbarch_pseudo_register_write (gdbarch
, sparc64_pseudo_register_write
);
1099 /* Register numbers of various important registers. */
1100 set_gdbarch_pc_regnum (gdbarch
, SPARC64_PC_REGNUM
); /* %pc */
1102 /* Call dummy code. */
1103 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1104 set_gdbarch_push_dummy_code (gdbarch
, NULL
);
1105 set_gdbarch_push_dummy_call (gdbarch
, sparc64_push_dummy_call
);
1107 set_gdbarch_return_value (gdbarch
, sparc64_return_value
);
1108 set_gdbarch_stabs_argument_has_addr
1109 (gdbarch
, default_stabs_argument_has_addr
);
1111 set_gdbarch_skip_prologue (gdbarch
, sparc64_skip_prologue
);
1113 /* Hook in the DWARF CFI frame unwinder. */
1114 dwarf2_frame_set_init_reg (gdbarch
, sparc64_dwarf2_frame_init_reg
);
1115 /* FIXME: kettenis/20050423: Don't enable the unwinder until the
1116 StackGhost issues have been resolved. */
1118 frame_unwind_append_unwinder (gdbarch
, &sparc64_frame_unwind
);
1119 frame_base_set_default (gdbarch
, &sparc64_frame_base
);
1123 /* Helper functions for dealing with register sets. */
1125 #define TSTATE_CWP 0x000000000000001fULL
1126 #define TSTATE_ICC 0x0000000f00000000ULL
1127 #define TSTATE_XCC 0x000000f000000000ULL
1129 #define PSR_S 0x00000080
1130 #define PSR_ICC 0x00f00000
1131 #define PSR_VERS 0x0f000000
1132 #define PSR_IMPL 0xf0000000
1133 #define PSR_V8PLUS 0xff000000
1134 #define PSR_XCC 0x000f0000
1137 sparc64_supply_gregset (const struct sparc_gregset
*gregset
,
1138 struct regcache
*regcache
,
1139 int regnum
, const void *gregs
)
1141 int sparc32
= (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32);
1142 const gdb_byte
*regs
= gregs
;
1147 if (regnum
== SPARC32_PSR_REGNUM
|| regnum
== -1)
1149 int offset
= gregset
->r_tstate_offset
;
1150 ULONGEST tstate
, psr
;
1153 tstate
= extract_unsigned_integer (regs
+ offset
, 8);
1154 psr
= ((tstate
& TSTATE_CWP
) | PSR_S
| ((tstate
& TSTATE_ICC
) >> 12)
1155 | ((tstate
& TSTATE_XCC
) >> 20) | PSR_V8PLUS
);
1156 store_unsigned_integer (buf
, 4, psr
);
1157 regcache_raw_supply (regcache
, SPARC32_PSR_REGNUM
, buf
);
1160 if (regnum
== SPARC32_PC_REGNUM
|| regnum
== -1)
1161 regcache_raw_supply (regcache
, SPARC32_PC_REGNUM
,
1162 regs
+ gregset
->r_pc_offset
+ 4);
1164 if (regnum
== SPARC32_NPC_REGNUM
|| regnum
== -1)
1165 regcache_raw_supply (regcache
, SPARC32_NPC_REGNUM
,
1166 regs
+ gregset
->r_npc_offset
+ 4);
1168 if (regnum
== SPARC32_Y_REGNUM
|| regnum
== -1)
1170 int offset
= gregset
->r_y_offset
+ 8 - gregset
->r_y_size
;
1171 regcache_raw_supply (regcache
, SPARC32_Y_REGNUM
, regs
+ offset
);
1176 if (regnum
== SPARC64_STATE_REGNUM
|| regnum
== -1)
1177 regcache_raw_supply (regcache
, SPARC64_STATE_REGNUM
,
1178 regs
+ gregset
->r_tstate_offset
);
1180 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== -1)
1181 regcache_raw_supply (regcache
, SPARC64_PC_REGNUM
,
1182 regs
+ gregset
->r_pc_offset
);
1184 if (regnum
== SPARC64_NPC_REGNUM
|| regnum
== -1)
1185 regcache_raw_supply (regcache
, SPARC64_NPC_REGNUM
,
1186 regs
+ gregset
->r_npc_offset
);
1188 if (regnum
== SPARC64_Y_REGNUM
|| regnum
== -1)
1193 memcpy (buf
+ 8 - gregset
->r_y_size
,
1194 regs
+ gregset
->r_y_offset
, gregset
->r_y_size
);
1195 regcache_raw_supply (regcache
, SPARC64_Y_REGNUM
, buf
);
1198 if ((regnum
== SPARC64_FPRS_REGNUM
|| regnum
== -1)
1199 && gregset
->r_fprs_offset
!= -1)
1200 regcache_raw_supply (regcache
, SPARC64_FPRS_REGNUM
,
1201 regs
+ gregset
->r_fprs_offset
);
1204 if (regnum
== SPARC_G0_REGNUM
|| regnum
== -1)
1205 regcache_raw_supply (regcache
, SPARC_G0_REGNUM
, NULL
);
1207 if ((regnum
>= SPARC_G1_REGNUM
&& regnum
<= SPARC_O7_REGNUM
) || regnum
== -1)
1209 int offset
= gregset
->r_g1_offset
;
1214 for (i
= SPARC_G1_REGNUM
; i
<= SPARC_O7_REGNUM
; i
++)
1216 if (regnum
== i
|| regnum
== -1)
1217 regcache_raw_supply (regcache
, i
, regs
+ offset
);
1222 if ((regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
) || regnum
== -1)
1224 /* Not all of the register set variants include Locals and
1225 Inputs. For those that don't, we read them off the stack. */
1226 if (gregset
->r_l0_offset
== -1)
1230 regcache_cooked_read_unsigned (regcache
, SPARC_SP_REGNUM
, &sp
);
1231 sparc_supply_rwindow (regcache
, sp
, regnum
);
1235 int offset
= gregset
->r_l0_offset
;
1240 for (i
= SPARC_L0_REGNUM
; i
<= SPARC_I7_REGNUM
; i
++)
1242 if (regnum
== i
|| regnum
== -1)
1243 regcache_raw_supply (regcache
, i
, regs
+ offset
);
1251 sparc64_collect_gregset (const struct sparc_gregset
*gregset
,
1252 const struct regcache
*regcache
,
1253 int regnum
, void *gregs
)
1255 int sparc32
= (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32);
1256 gdb_byte
*regs
= gregs
;
1261 if (regnum
== SPARC32_PSR_REGNUM
|| regnum
== -1)
1263 int offset
= gregset
->r_tstate_offset
;
1264 ULONGEST tstate
, psr
;
1267 tstate
= extract_unsigned_integer (regs
+ offset
, 8);
1268 regcache_raw_collect (regcache
, SPARC32_PSR_REGNUM
, buf
);
1269 psr
= extract_unsigned_integer (buf
, 4);
1270 tstate
|= (psr
& PSR_ICC
) << 12;
1271 if ((psr
& (PSR_VERS
| PSR_IMPL
)) == PSR_V8PLUS
)
1272 tstate
|= (psr
& PSR_XCC
) << 20;
1273 store_unsigned_integer (buf
, 8, tstate
);
1274 memcpy (regs
+ offset
, buf
, 8);
1277 if (regnum
== SPARC32_PC_REGNUM
|| regnum
== -1)
1278 regcache_raw_collect (regcache
, SPARC32_PC_REGNUM
,
1279 regs
+ gregset
->r_pc_offset
+ 4);
1281 if (regnum
== SPARC32_NPC_REGNUM
|| regnum
== -1)
1282 regcache_raw_collect (regcache
, SPARC32_NPC_REGNUM
,
1283 regs
+ gregset
->r_npc_offset
+ 4);
1285 if (regnum
== SPARC32_Y_REGNUM
|| regnum
== -1)
1287 int offset
= gregset
->r_y_offset
+ 8 - gregset
->r_y_size
;
1288 regcache_raw_collect (regcache
, SPARC32_Y_REGNUM
, regs
+ offset
);
1293 if (regnum
== SPARC64_STATE_REGNUM
|| regnum
== -1)
1294 regcache_raw_collect (regcache
, SPARC64_STATE_REGNUM
,
1295 regs
+ gregset
->r_tstate_offset
);
1297 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== -1)
1298 regcache_raw_collect (regcache
, SPARC64_PC_REGNUM
,
1299 regs
+ gregset
->r_pc_offset
);
1301 if (regnum
== SPARC64_NPC_REGNUM
|| regnum
== -1)
1302 regcache_raw_collect (regcache
, SPARC64_NPC_REGNUM
,
1303 regs
+ gregset
->r_npc_offset
);
1305 if (regnum
== SPARC64_Y_REGNUM
|| regnum
== -1)
1309 regcache_raw_collect (regcache
, SPARC64_Y_REGNUM
, buf
);
1310 memcpy (regs
+ gregset
->r_y_offset
,
1311 buf
+ 8 - gregset
->r_y_size
, gregset
->r_y_size
);
1314 if ((regnum
== SPARC64_FPRS_REGNUM
|| regnum
== -1)
1315 && gregset
->r_fprs_offset
!= -1)
1316 regcache_raw_collect (regcache
, SPARC64_FPRS_REGNUM
,
1317 regs
+ gregset
->r_fprs_offset
);
1321 if ((regnum
>= SPARC_G1_REGNUM
&& regnum
<= SPARC_O7_REGNUM
) || regnum
== -1)
1323 int offset
= gregset
->r_g1_offset
;
1328 /* %g0 is always zero. */
1329 for (i
= SPARC_G1_REGNUM
; i
<= SPARC_O7_REGNUM
; i
++)
1331 if (regnum
== i
|| regnum
== -1)
1332 regcache_raw_collect (regcache
, i
, regs
+ offset
);
1337 if ((regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
) || regnum
== -1)
1339 /* Not all of the register set variants include Locals and
1340 Inputs. For those that don't, we read them off the stack. */
1341 if (gregset
->r_l0_offset
!= -1)
1343 int offset
= gregset
->r_l0_offset
;
1348 for (i
= SPARC_L0_REGNUM
; i
<= SPARC_I7_REGNUM
; i
++)
1350 if (regnum
== i
|| regnum
== -1)
1351 regcache_raw_collect (regcache
, i
, regs
+ offset
);
1359 sparc64_supply_fpregset (struct regcache
*regcache
,
1360 int regnum
, const void *fpregs
)
1362 int sparc32
= (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32);
1363 const gdb_byte
*regs
= fpregs
;
1366 for (i
= 0; i
< 32; i
++)
1368 if (regnum
== (SPARC_F0_REGNUM
+ i
) || regnum
== -1)
1369 regcache_raw_supply (regcache
, SPARC_F0_REGNUM
+ i
, regs
+ (i
* 4));
1374 if (regnum
== SPARC32_FSR_REGNUM
|| regnum
== -1)
1375 regcache_raw_supply (regcache
, SPARC32_FSR_REGNUM
,
1376 regs
+ (32 * 4) + (16 * 8) + 4);
1380 for (i
= 0; i
< 16; i
++)
1382 if (regnum
== (SPARC64_F32_REGNUM
+ i
) || regnum
== -1)
1383 regcache_raw_supply (regcache
, SPARC64_F32_REGNUM
+ i
,
1384 regs
+ (32 * 4) + (i
* 8));
1387 if (regnum
== SPARC64_FSR_REGNUM
|| regnum
== -1)
1388 regcache_raw_supply (regcache
, SPARC64_FSR_REGNUM
,
1389 regs
+ (32 * 4) + (16 * 8));
1394 sparc64_collect_fpregset (const struct regcache
*regcache
,
1395 int regnum
, void *fpregs
)
1397 int sparc32
= (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32);
1398 gdb_byte
*regs
= fpregs
;
1401 for (i
= 0; i
< 32; i
++)
1403 if (regnum
== (SPARC_F0_REGNUM
+ i
) || regnum
== -1)
1404 regcache_raw_collect (regcache
, SPARC_F0_REGNUM
+ i
, regs
+ (i
* 4));
1409 if (regnum
== SPARC32_FSR_REGNUM
|| regnum
== -1)
1410 regcache_raw_collect (regcache
, SPARC32_FSR_REGNUM
,
1411 regs
+ (32 * 4) + (16 * 8) + 4);
1415 for (i
= 0; i
< 16; i
++)
1417 if (regnum
== (SPARC64_F32_REGNUM
+ i
) || regnum
== -1)
1418 regcache_raw_collect (regcache
, SPARC64_F32_REGNUM
+ i
,
1419 regs
+ (32 * 4) + (i
* 8));
1422 if (regnum
== SPARC64_FSR_REGNUM
|| regnum
== -1)
1423 regcache_raw_collect (regcache
, SPARC64_FSR_REGNUM
,
1424 regs
+ (32 * 4) + (16 * 8));
1429 /* Provide a prototype to silence -Wmissing-prototypes. */
1430 void _initialize_sparc64_tdep (void);
1433 _initialize_sparc64_tdep (void)
1435 /* Initialize the UltraSPARC-specific register types. */
1436 sparc64_init_types();