1 /* Target-dependent code for UltraSPARC.
3 Copyright 2003, 2004, 2005 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 2 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, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 #include "arch-utils.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
:
123 /* Register information. */
125 struct sparc64_register_info
131 static struct sparc64_register_info sparc64_register_info
[] =
133 { "g0", &builtin_type_int64
},
134 { "g1", &builtin_type_int64
},
135 { "g2", &builtin_type_int64
},
136 { "g3", &builtin_type_int64
},
137 { "g4", &builtin_type_int64
},
138 { "g5", &builtin_type_int64
},
139 { "g6", &builtin_type_int64
},
140 { "g7", &builtin_type_int64
},
142 { "o0", &builtin_type_int64
},
143 { "o1", &builtin_type_int64
},
144 { "o2", &builtin_type_int64
},
145 { "o3", &builtin_type_int64
},
146 { "o4", &builtin_type_int64
},
147 { "o5", &builtin_type_int64
},
148 { "sp", &builtin_type_void_data_ptr
},
149 { "o7", &builtin_type_int64
},
151 { "l0", &builtin_type_int64
},
152 { "l1", &builtin_type_int64
},
153 { "l2", &builtin_type_int64
},
154 { "l3", &builtin_type_int64
},
155 { "l4", &builtin_type_int64
},
156 { "l5", &builtin_type_int64
},
157 { "l6", &builtin_type_int64
},
158 { "l7", &builtin_type_int64
},
160 { "i0", &builtin_type_int64
},
161 { "i1", &builtin_type_int64
},
162 { "i2", &builtin_type_int64
},
163 { "i3", &builtin_type_int64
},
164 { "i4", &builtin_type_int64
},
165 { "i5", &builtin_type_int64
},
166 { "fp", &builtin_type_void_data_ptr
},
167 { "i7", &builtin_type_int64
},
169 { "f0", &builtin_type_float
},
170 { "f1", &builtin_type_float
},
171 { "f2", &builtin_type_float
},
172 { "f3", &builtin_type_float
},
173 { "f4", &builtin_type_float
},
174 { "f5", &builtin_type_float
},
175 { "f6", &builtin_type_float
},
176 { "f7", &builtin_type_float
},
177 { "f8", &builtin_type_float
},
178 { "f9", &builtin_type_float
},
179 { "f10", &builtin_type_float
},
180 { "f11", &builtin_type_float
},
181 { "f12", &builtin_type_float
},
182 { "f13", &builtin_type_float
},
183 { "f14", &builtin_type_float
},
184 { "f15", &builtin_type_float
},
185 { "f16", &builtin_type_float
},
186 { "f17", &builtin_type_float
},
187 { "f18", &builtin_type_float
},
188 { "f19", &builtin_type_float
},
189 { "f20", &builtin_type_float
},
190 { "f21", &builtin_type_float
},
191 { "f22", &builtin_type_float
},
192 { "f23", &builtin_type_float
},
193 { "f24", &builtin_type_float
},
194 { "f25", &builtin_type_float
},
195 { "f26", &builtin_type_float
},
196 { "f27", &builtin_type_float
},
197 { "f28", &builtin_type_float
},
198 { "f29", &builtin_type_float
},
199 { "f30", &builtin_type_float
},
200 { "f31", &builtin_type_float
},
201 { "f32", &builtin_type_double
},
202 { "f34", &builtin_type_double
},
203 { "f36", &builtin_type_double
},
204 { "f38", &builtin_type_double
},
205 { "f40", &builtin_type_double
},
206 { "f42", &builtin_type_double
},
207 { "f44", &builtin_type_double
},
208 { "f46", &builtin_type_double
},
209 { "f48", &builtin_type_double
},
210 { "f50", &builtin_type_double
},
211 { "f52", &builtin_type_double
},
212 { "f54", &builtin_type_double
},
213 { "f56", &builtin_type_double
},
214 { "f58", &builtin_type_double
},
215 { "f60", &builtin_type_double
},
216 { "f62", &builtin_type_double
},
218 { "pc", &builtin_type_void_func_ptr
},
219 { "npc", &builtin_type_void_func_ptr
},
221 /* This raw register contains the contents of %cwp, %pstate, %asi
222 and %ccr as laid out in a %tstate register. */
223 /* FIXME: Give it a name until we start using register groups. */
224 { "state", &builtin_type_int64
},
226 { "fsr", &builtin_type_int64
},
227 { "fprs", &builtin_type_int64
},
229 /* "Although Y is a 64-bit register, its high-order 32 bits are
230 reserved and always read as 0." */
231 { "y", &builtin_type_int64
}
234 /* Total number of registers. */
235 #define SPARC64_NUM_REGS ARRAY_SIZE (sparc64_register_info)
237 /* We provide the aliases %d0..%d62 and %q0..%q60 for the floating
238 registers as "psuedo" registers. */
240 static struct sparc64_register_info sparc64_pseudo_register_info
[] =
242 { "cwp", &builtin_type_int64
},
243 { "pstate", &builtin_type_int64
},
244 { "asi", &builtin_type_int64
},
245 { "ccr", &builtin_type_int64
},
247 { "d0", &builtin_type_double
},
248 { "d2", &builtin_type_double
},
249 { "d4", &builtin_type_double
},
250 { "d6", &builtin_type_double
},
251 { "d8", &builtin_type_double
},
252 { "d10", &builtin_type_double
},
253 { "d12", &builtin_type_double
},
254 { "d14", &builtin_type_double
},
255 { "d16", &builtin_type_double
},
256 { "d18", &builtin_type_double
},
257 { "d20", &builtin_type_double
},
258 { "d22", &builtin_type_double
},
259 { "d24", &builtin_type_double
},
260 { "d26", &builtin_type_double
},
261 { "d28", &builtin_type_double
},
262 { "d30", &builtin_type_double
},
263 { "d32", &builtin_type_double
},
264 { "d34", &builtin_type_double
},
265 { "d36", &builtin_type_double
},
266 { "d38", &builtin_type_double
},
267 { "d40", &builtin_type_double
},
268 { "d42", &builtin_type_double
},
269 { "d44", &builtin_type_double
},
270 { "d46", &builtin_type_double
},
271 { "d48", &builtin_type_double
},
272 { "d50", &builtin_type_double
},
273 { "d52", &builtin_type_double
},
274 { "d54", &builtin_type_double
},
275 { "d56", &builtin_type_double
},
276 { "d58", &builtin_type_double
},
277 { "d60", &builtin_type_double
},
278 { "d62", &builtin_type_double
},
280 { "q0", &builtin_type_long_double
},
281 { "q4", &builtin_type_long_double
},
282 { "q8", &builtin_type_long_double
},
283 { "q12", &builtin_type_long_double
},
284 { "q16", &builtin_type_long_double
},
285 { "q20", &builtin_type_long_double
},
286 { "q24", &builtin_type_long_double
},
287 { "q28", &builtin_type_long_double
},
288 { "q32", &builtin_type_long_double
},
289 { "q36", &builtin_type_long_double
},
290 { "q40", &builtin_type_long_double
},
291 { "q44", &builtin_type_long_double
},
292 { "q48", &builtin_type_long_double
},
293 { "q52", &builtin_type_long_double
},
294 { "q56", &builtin_type_long_double
},
295 { "q60", &builtin_type_long_double
}
298 /* Total number of pseudo registers. */
299 #define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_info)
301 /* Return the name of register REGNUM. */
304 sparc64_register_name (int regnum
)
306 if (regnum
>= 0 && regnum
< SPARC64_NUM_REGS
)
307 return sparc64_register_info
[regnum
].name
;
309 if (regnum
>= SPARC64_NUM_REGS
310 && regnum
< SPARC64_NUM_REGS
+ SPARC64_NUM_PSEUDO_REGS
)
311 return sparc64_pseudo_register_info
[regnum
- SPARC64_NUM_REGS
].name
;
316 /* Return the GDB type object for the "standard" data type of data in
320 sparc64_register_type (struct gdbarch
*gdbarch
, int regnum
)
322 if (regnum
>= SPARC64_NUM_REGS
323 && regnum
< SPARC64_NUM_REGS
+ SPARC64_NUM_PSEUDO_REGS
)
324 return *sparc64_pseudo_register_info
[regnum
- SPARC64_NUM_REGS
].type
;
326 gdb_assert (regnum
>= 0 && regnum
< SPARC64_NUM_REGS
);
327 return *sparc64_register_info
[regnum
].type
;
331 sparc64_pseudo_register_read (struct gdbarch
*gdbarch
,
332 struct regcache
*regcache
,
333 int regnum
, void *buf
)
335 gdb_assert (regnum
>= SPARC64_NUM_REGS
);
337 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D30_REGNUM
)
339 regnum
= SPARC_F0_REGNUM
+ 2 * (regnum
- SPARC64_D0_REGNUM
);
340 regcache_raw_read (regcache
, regnum
, buf
);
341 regcache_raw_read (regcache
, regnum
+ 1, ((char *)buf
) + 4);
343 else if (regnum
>= SPARC64_D32_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
345 regnum
= SPARC64_F32_REGNUM
+ (regnum
- SPARC64_D32_REGNUM
);
346 regcache_raw_read (regcache
, regnum
, buf
);
348 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q28_REGNUM
)
350 regnum
= SPARC_F0_REGNUM
+ 4 * (regnum
- SPARC64_Q0_REGNUM
);
351 regcache_raw_read (regcache
, regnum
, buf
);
352 regcache_raw_read (regcache
, regnum
+ 1, ((char *)buf
) + 4);
353 regcache_raw_read (regcache
, regnum
+ 2, ((char *)buf
) + 8);
354 regcache_raw_read (regcache
, regnum
+ 3, ((char *)buf
) + 12);
356 else if (regnum
>= SPARC64_Q32_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
358 regnum
= SPARC64_F32_REGNUM
+ 2 * (regnum
- SPARC64_Q32_REGNUM
);
359 regcache_raw_read (regcache
, regnum
, buf
);
360 regcache_raw_read (regcache
, regnum
+ 1, ((char *)buf
) + 8);
362 else if (regnum
== SPARC64_CWP_REGNUM
363 || regnum
== SPARC64_PSTATE_REGNUM
364 || regnum
== SPARC64_ASI_REGNUM
365 || regnum
== SPARC64_CCR_REGNUM
)
369 regcache_raw_read_unsigned (regcache
, SPARC64_STATE_REGNUM
, &state
);
372 case SPARC64_CWP_REGNUM
:
373 state
= (state
>> 0) & ((1 << 5) - 1);
375 case SPARC64_PSTATE_REGNUM
:
376 state
= (state
>> 8) & ((1 << 12) - 1);
378 case SPARC64_ASI_REGNUM
:
379 state
= (state
>> 24) & ((1 << 8) - 1);
381 case SPARC64_CCR_REGNUM
:
382 state
= (state
>> 32) & ((1 << 8) - 1);
385 store_unsigned_integer (buf
, 8, state
);
390 sparc64_pseudo_register_write (struct gdbarch
*gdbarch
,
391 struct regcache
*regcache
,
392 int regnum
, const void *buf
)
394 gdb_assert (regnum
>= SPARC64_NUM_REGS
);
396 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D30_REGNUM
)
398 regnum
= SPARC_F0_REGNUM
+ 2 * (regnum
- SPARC64_D0_REGNUM
);
399 regcache_raw_write (regcache
, regnum
, buf
);
400 regcache_raw_write (regcache
, regnum
+ 1, ((const char *)buf
) + 4);
402 else if (regnum
>= SPARC64_D32_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
404 regnum
= SPARC64_F32_REGNUM
+ (regnum
- SPARC64_D32_REGNUM
);
405 regcache_raw_write (regcache
, regnum
, buf
);
407 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q28_REGNUM
)
409 regnum
= SPARC_F0_REGNUM
+ 4 * (regnum
- SPARC64_Q0_REGNUM
);
410 regcache_raw_write (regcache
, regnum
, buf
);
411 regcache_raw_write (regcache
, regnum
+ 1, ((const char *)buf
) + 4);
412 regcache_raw_write (regcache
, regnum
+ 2, ((const char *)buf
) + 8);
413 regcache_raw_write (regcache
, regnum
+ 3, ((const char *)buf
) + 12);
415 else if (regnum
>= SPARC64_Q32_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
417 regnum
= SPARC64_F32_REGNUM
+ 2 * (regnum
- SPARC64_Q32_REGNUM
);
418 regcache_raw_write (regcache
, regnum
, buf
);
419 regcache_raw_write (regcache
, regnum
+ 1, ((const char *)buf
) + 8);
421 else if (regnum
== SPARC64_CWP_REGNUM
422 || regnum
== SPARC64_PSTATE_REGNUM
423 || regnum
== SPARC64_ASI_REGNUM
424 || regnum
== SPARC64_CCR_REGNUM
)
426 ULONGEST state
, bits
;
428 regcache_raw_read_unsigned (regcache
, SPARC64_STATE_REGNUM
, &state
);
429 bits
= extract_unsigned_integer (buf
, 8);
432 case SPARC64_CWP_REGNUM
:
433 state
|= ((bits
& ((1 << 5) - 1)) << 0);
435 case SPARC64_PSTATE_REGNUM
:
436 state
|= ((bits
& ((1 << 12) - 1)) << 8);
438 case SPARC64_ASI_REGNUM
:
439 state
|= ((bits
& ((1 << 8) - 1)) << 24);
441 case SPARC64_CCR_REGNUM
:
442 state
|= ((bits
& ((1 << 8) - 1)) << 32);
445 regcache_raw_write_unsigned (regcache
, SPARC64_STATE_REGNUM
, state
);
450 /* Return PC of first real instruction of the function starting at
454 sparc64_skip_prologue (CORE_ADDR start_pc
)
456 struct symtab_and_line sal
;
457 CORE_ADDR func_start
, func_end
;
458 struct sparc_frame_cache cache
;
460 /* This is the preferred method, find the end of the prologue by
461 using the debugging information. */
462 if (find_pc_partial_function (start_pc
, NULL
, &func_start
, &func_end
))
464 sal
= find_pc_line (func_start
, 0);
466 if (sal
.end
< func_end
467 && start_pc
<= sal
.end
)
471 return sparc_analyze_prologue (start_pc
, 0xffffffffffffffffULL
, &cache
);
476 static struct sparc_frame_cache
*
477 sparc64_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
479 return sparc_frame_cache (next_frame
, this_cache
);
483 sparc64_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
484 struct frame_id
*this_id
)
486 struct sparc_frame_cache
*cache
=
487 sparc64_frame_cache (next_frame
, this_cache
);
489 /* This marks the outermost frame. */
490 if (cache
->base
== 0)
493 (*this_id
) = frame_id_build (cache
->base
, cache
->pc
);
497 sparc64_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
498 int regnum
, int *optimizedp
,
499 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
500 int *realnump
, void *valuep
)
502 struct sparc_frame_cache
*cache
=
503 sparc64_frame_cache (next_frame
, this_cache
);
505 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== SPARC64_NPC_REGNUM
)
513 CORE_ADDR pc
= (regnum
== SPARC64_NPC_REGNUM
) ? 4 : 0;
515 regnum
= cache
->frameless_p
? SPARC_O7_REGNUM
: SPARC_I7_REGNUM
;
516 pc
+= frame_unwind_register_unsigned (next_frame
, regnum
) + 8;
517 store_unsigned_integer (valuep
, 8, pc
);
522 /* Handle StackGhost. */
524 ULONGEST wcookie
= sparc_fetch_wcookie ();
526 if (wcookie
!= 0 && !cache
->frameless_p
&& regnum
== SPARC_I7_REGNUM
)
534 CORE_ADDR addr
= cache
->base
+ (regnum
- SPARC_L0_REGNUM
) * 8;
537 /* Read the value in from memory. */
538 i7
= get_frame_memory_unsigned (next_frame
, addr
, 8);
539 store_unsigned_integer (valuep
, 8, i7
^ wcookie
);
545 /* The previous frame's `local' and `in' registers have been saved
546 in the register save area. */
547 if (!cache
->frameless_p
548 && regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
)
551 *lvalp
= lval_memory
;
552 *addrp
= cache
->base
+ (regnum
- SPARC_L0_REGNUM
) * 8;
556 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
558 /* Read the value in from memory. */
559 read_memory (*addrp
, valuep
, register_size (gdbarch
, regnum
));
564 /* The previous frame's `out' registers are accessable as the
565 current frame's `in' registers. */
566 if (!cache
->frameless_p
567 && regnum
>= SPARC_O0_REGNUM
&& regnum
<= SPARC_O7_REGNUM
)
568 regnum
+= (SPARC_I0_REGNUM
- SPARC_O0_REGNUM
);
571 *lvalp
= lval_register
;
575 frame_unwind_register (next_frame
, regnum
, valuep
);
578 static const struct frame_unwind sparc64_frame_unwind
=
581 sparc64_frame_this_id
,
582 sparc64_frame_prev_register
585 static const struct frame_unwind
*
586 sparc64_frame_sniffer (struct frame_info
*next_frame
)
588 return &sparc64_frame_unwind
;
593 sparc64_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
595 struct sparc_frame_cache
*cache
=
596 sparc64_frame_cache (next_frame
, this_cache
);
601 static const struct frame_base sparc64_frame_base
=
603 &sparc64_frame_unwind
,
604 sparc64_frame_base_address
,
605 sparc64_frame_base_address
,
606 sparc64_frame_base_address
609 /* Check whether TYPE must be 16-byte aligned. */
612 sparc64_16_byte_align_p (struct type
*type
)
614 if (sparc64_floating_p (type
) && TYPE_LENGTH (type
) == 16)
617 if (sparc64_structure_or_union_p (type
))
621 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
623 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
625 if (sparc64_16_byte_align_p (subtype
))
633 /* Store floating fields of element ELEMENT of an "parameter array"
634 that has type TYPE and is stored at BITPOS in VALBUF in the
635 apropriate registers of REGCACHE. This function can be called
636 recursively and therefore handles floating types in addition to
640 sparc64_store_floating_fields (struct regcache
*regcache
, struct type
*type
,
641 const char *valbuf
, int element
, int bitpos
)
643 gdb_assert (element
< 16);
645 if (sparc64_floating_p (type
))
647 int len
= TYPE_LENGTH (type
);
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 char *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 /* Number of extended words in the "parameter array". */
766 int num_elements
= 0;
770 /* Take BIAS into account. */
773 /* First we calculate the number of extended words in the "parameter
774 array". While doing so we also convert some of the arguments. */
779 for (i
= 0; i
< nargs
; i
++)
781 struct type
*type
= value_type (args
[i
]);
782 int len
= TYPE_LENGTH (type
);
784 if (sparc64_structure_or_union_p (type
))
786 /* Structure or Union arguments. */
789 if (num_elements
% 2 && sparc64_16_byte_align_p (type
))
791 num_elements
+= ((len
+ 7) / 8);
795 /* The psABI says that "Structures or unions larger than
796 sixteen bytes are copied by the caller and passed
797 indirectly; the caller will pass the address of a
798 correctly aligned structure value. This sixty-four
799 bit address will occupy one word in the parameter
800 array, and may be promoted to an %o register like any
801 other pointer value." Allocate memory for these
802 values on the stack. */
805 /* Use 16-byte alignment for these values. That's
806 always correct, and wasting a few bytes shouldn't be
810 write_memory (sp
, value_contents (args
[i
]), len
);
811 args
[i
] = value_from_pointer (lookup_pointer_type (type
), sp
);
815 else if (sparc64_floating_p (type
))
817 /* Floating arguments. */
821 /* The psABI says that "Each quad-precision parameter
822 value will be assigned to two extended words in the
826 /* The psABI says that "Long doubles must be
827 quad-aligned, and thus a hole might be introduced
828 into the parameter array to force alignment." Skip
829 an element if necessary. */
830 if (num_elements
% 2)
838 /* Integral and pointer arguments. */
839 gdb_assert (sparc64_integral_or_pointer_p (type
));
841 /* The psABI says that "Each argument value of integral type
842 smaller than an extended word will be widened by the
843 caller to an extended word according to the signed-ness
844 of the argument type." */
846 args
[i
] = value_cast (builtin_type_int64
, args
[i
]);
851 /* Allocate the "parameter array". */
852 sp
-= num_elements
* 8;
854 /* The psABI says that "Every stack frame must be 16-byte aligned." */
857 /* Now we store the arguments in to the "paramater array". Some
858 Integer or Pointer arguments and Structure or Union arguments
859 will be passed in %o registers. Some Floating arguments and
860 floating members of structures are passed in floating-point
861 registers. However, for functions with variable arguments,
862 floating arguments are stored in an %0 register, and for
863 functions without a prototype floating arguments are stored in
864 both a floating-point and an %o registers, or a floating-point
865 register and memory. To simplify the logic here we always pass
866 arguments in memory, an %o register, and a floating-point
867 register if appropriate. This should be no problem since the
868 contents of any unused memory or registers in the "parameter
869 array" are undefined. */
873 regcache_cooked_write_unsigned (regcache
, SPARC_O0_REGNUM
, struct_addr
);
877 for (i
= 0; i
< nargs
; i
++)
879 const char *valbuf
= value_contents (args
[i
]);
880 struct type
*type
= value_type (args
[i
]);
881 int len
= TYPE_LENGTH (type
);
885 if (sparc64_structure_or_union_p (type
))
887 /* Structure or Union arguments. */
888 gdb_assert (len
<= 16);
889 memset (buf
, 0, sizeof (buf
));
890 valbuf
= memcpy (buf
, valbuf
, len
);
892 if (element
% 2 && sparc64_16_byte_align_p (type
))
897 regnum
= SPARC_O0_REGNUM
+ element
;
898 if (len
> 8 && element
< 5)
899 regcache_cooked_write (regcache
, regnum
+ 1, valbuf
+ 8);
903 sparc64_store_floating_fields (regcache
, type
, valbuf
, element
, 0);
905 else if (sparc64_floating_p (type
))
907 /* Floating arguments. */
913 regnum
= SPARC64_Q0_REGNUM
+ element
/ 2;
918 regnum
= SPARC64_D0_REGNUM
+ element
;
922 /* The psABI says "Each single-precision parameter value
923 will be assigned to one extended word in the
924 parameter array, and right-justified within that
925 word; the left half (even floatregister) is
926 undefined." Even though the psABI says that "the
927 left half is undefined", set it to zero here. */
929 memcpy (buf
+ 4, valbuf
, 4);
933 regnum
= SPARC64_D0_REGNUM
+ element
;
938 /* Integral and pointer arguments. */
939 gdb_assert (len
== 8);
941 regnum
= SPARC_O0_REGNUM
+ element
;
946 regcache_cooked_write (regcache
, regnum
, valbuf
);
948 /* If we're storing the value in a floating-point register,
949 also store it in the corresponding %0 register(s). */
950 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D10_REGNUM
)
952 gdb_assert (element
< 6);
953 regnum
= SPARC_O0_REGNUM
+ element
;
954 regcache_cooked_write (regcache
, regnum
, valbuf
);
956 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q8_REGNUM
)
958 gdb_assert (element
< 6);
959 regnum
= SPARC_O0_REGNUM
+ element
;
960 regcache_cooked_write (regcache
, regnum
, valbuf
);
961 regcache_cooked_write (regcache
, regnum
+ 1, valbuf
+ 8);
965 /* Always store the argument in memory. */
966 write_memory (sp
+ element
* 8, valbuf
, len
);
967 element
+= ((len
+ 7) / 8);
970 gdb_assert (element
== num_elements
);
972 /* Take BIAS into account. */
978 sparc64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
979 struct regcache
*regcache
, CORE_ADDR bp_addr
,
980 int nargs
, struct value
**args
, CORE_ADDR sp
,
981 int struct_return
, CORE_ADDR struct_addr
)
983 /* Set return address. */
984 regcache_cooked_write_unsigned (regcache
, SPARC_O7_REGNUM
, bp_addr
- 8);
986 /* Set up function arguments. */
987 sp
= sparc64_store_arguments (regcache
, nargs
, args
, sp
,
988 struct_return
, struct_addr
);
990 /* Allocate the register save area. */
993 /* Stack should be 16-byte aligned at this point. */
994 gdb_assert ((sp
+ BIAS
) % 16 == 0);
996 /* Finally, update the stack pointer. */
997 regcache_cooked_write_unsigned (regcache
, SPARC_SP_REGNUM
, sp
);
1003 /* Extract from an array REGBUF containing the (raw) register state, a
1004 function return value of TYPE, and copy that into VALBUF. */
1007 sparc64_extract_return_value (struct type
*type
, struct regcache
*regcache
,
1010 int len
= TYPE_LENGTH (type
);
1014 if (sparc64_structure_or_union_p (type
))
1016 /* Structure or Union return values. */
1017 gdb_assert (len
<= 32);
1019 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1020 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1021 if (TYPE_CODE (type
) != TYPE_CODE_UNION
)
1022 sparc64_extract_floating_fields (regcache
, type
, buf
, 0);
1023 memcpy (valbuf
, buf
, len
);
1025 else if (sparc64_floating_p (type
))
1027 /* Floating return values. */
1028 for (i
= 0; i
< len
/ 4; i
++)
1029 regcache_cooked_read (regcache
, SPARC_F0_REGNUM
+ i
, buf
+ i
* 4);
1030 memcpy (valbuf
, buf
, len
);
1034 /* Integral and pointer return values. */
1035 gdb_assert (sparc64_integral_or_pointer_p (type
));
1037 /* Just stripping off any unused bytes should preserve the
1038 signed-ness just fine. */
1039 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
, buf
);
1040 memcpy (valbuf
, buf
+ 8 - len
, len
);
1044 /* Write into the appropriate registers a function return value stored
1045 in VALBUF of type TYPE. */
1048 sparc64_store_return_value (struct type
*type
, struct regcache
*regcache
,
1051 int len
= TYPE_LENGTH (type
);
1055 if (sparc64_structure_or_union_p (type
))
1057 /* Structure or Union return values. */
1058 gdb_assert (len
<= 32);
1060 /* Simplify matters by storing the complete value (including
1061 floating members) into %o0 and %o1. Floating members are
1062 also store in the appropriate floating-point registers. */
1063 memset (buf
, 0, sizeof (buf
));
1064 memcpy (buf
, valbuf
, len
);
1065 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1066 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1067 if (TYPE_CODE (type
) != TYPE_CODE_UNION
)
1068 sparc64_store_floating_fields (regcache
, type
, buf
, 0, 0);
1070 else if (sparc64_floating_p (type
))
1072 /* Floating return values. */
1073 memcpy (buf
, valbuf
, len
);
1074 for (i
= 0; i
< len
/ 4; i
++)
1075 regcache_cooked_write (regcache
, SPARC_F0_REGNUM
+ i
, buf
+ i
* 4);
1079 /* Integral and pointer return values. */
1080 gdb_assert (sparc64_integral_or_pointer_p (type
));
1082 /* ??? Do we need to do any sign-extension here? */
1084 memcpy (buf
+ 8 - len
, valbuf
, len
);
1085 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
, buf
);
1089 static enum return_value_convention
1090 sparc64_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
1091 struct regcache
*regcache
, void *readbuf
,
1092 const void *writebuf
)
1094 if (TYPE_LENGTH (type
) > 32)
1095 return RETURN_VALUE_STRUCT_CONVENTION
;
1098 sparc64_extract_return_value (type
, regcache
, readbuf
);
1100 sparc64_store_return_value (type
, regcache
, writebuf
);
1102 return RETURN_VALUE_REGISTER_CONVENTION
;
1107 sparc64_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1109 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1111 tdep
->pc_regnum
= SPARC64_PC_REGNUM
;
1112 tdep
->npc_regnum
= SPARC64_NPC_REGNUM
;
1114 /* This is what all the fuss is about. */
1115 set_gdbarch_long_bit (gdbarch
, 64);
1116 set_gdbarch_long_long_bit (gdbarch
, 64);
1117 set_gdbarch_ptr_bit (gdbarch
, 64);
1119 set_gdbarch_num_regs (gdbarch
, SPARC64_NUM_REGS
);
1120 set_gdbarch_register_name (gdbarch
, sparc64_register_name
);
1121 set_gdbarch_register_type (gdbarch
, sparc64_register_type
);
1122 set_gdbarch_num_pseudo_regs (gdbarch
, SPARC64_NUM_PSEUDO_REGS
);
1123 set_gdbarch_pseudo_register_read (gdbarch
, sparc64_pseudo_register_read
);
1124 set_gdbarch_pseudo_register_write (gdbarch
, sparc64_pseudo_register_write
);
1126 /* Register numbers of various important registers. */
1127 set_gdbarch_pc_regnum (gdbarch
, SPARC64_PC_REGNUM
); /* %pc */
1129 /* Call dummy code. */
1130 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1131 set_gdbarch_push_dummy_code (gdbarch
, NULL
);
1132 set_gdbarch_push_dummy_call (gdbarch
, sparc64_push_dummy_call
);
1134 set_gdbarch_return_value (gdbarch
, sparc64_return_value
);
1135 set_gdbarch_stabs_argument_has_addr
1136 (gdbarch
, default_stabs_argument_has_addr
);
1138 set_gdbarch_skip_prologue (gdbarch
, sparc64_skip_prologue
);
1140 frame_unwind_append_sniffer (gdbarch
, sparc64_frame_sniffer
);
1141 frame_base_set_default (gdbarch
, &sparc64_frame_base
);
1145 /* Helper functions for dealing with register sets. */
1147 #define TSTATE_CWP 0x000000000000001fULL
1148 #define TSTATE_ICC 0x0000000f00000000ULL
1149 #define TSTATE_XCC 0x000000f000000000ULL
1151 #define PSR_S 0x00000080
1152 #define PSR_ICC 0x00f00000
1153 #define PSR_VERS 0x0f000000
1154 #define PSR_IMPL 0xf0000000
1155 #define PSR_V8PLUS 0xff000000
1156 #define PSR_XCC 0x000f0000
1159 sparc64_supply_gregset (const struct sparc_gregset
*gregset
,
1160 struct regcache
*regcache
,
1161 int regnum
, const void *gregs
)
1163 int sparc32
= (gdbarch_ptr_bit (current_gdbarch
) == 32);
1164 const char *regs
= gregs
;
1169 if (regnum
== SPARC32_PSR_REGNUM
|| regnum
== -1)
1171 int offset
= gregset
->r_tstate_offset
;
1172 ULONGEST tstate
, psr
;
1175 tstate
= extract_unsigned_integer (regs
+ offset
, 8);
1176 psr
= ((tstate
& TSTATE_CWP
) | PSR_S
| ((tstate
& TSTATE_ICC
) >> 12)
1177 | ((tstate
& TSTATE_XCC
) >> 20) | PSR_V8PLUS
);
1178 store_unsigned_integer (buf
, 4, psr
);
1179 regcache_raw_supply (regcache
, SPARC32_PSR_REGNUM
, buf
);
1182 if (regnum
== SPARC32_PC_REGNUM
|| regnum
== -1)
1183 regcache_raw_supply (regcache
, SPARC32_PC_REGNUM
,
1184 regs
+ gregset
->r_pc_offset
+ 4);
1186 if (regnum
== SPARC32_NPC_REGNUM
|| regnum
== -1)
1187 regcache_raw_supply (regcache
, SPARC32_NPC_REGNUM
,
1188 regs
+ gregset
->r_npc_offset
+ 4);
1190 if (regnum
== SPARC32_Y_REGNUM
|| regnum
== -1)
1192 int offset
= gregset
->r_y_offset
+ 8 - gregset
->r_y_size
;
1193 regcache_raw_supply (regcache
, SPARC32_Y_REGNUM
, regs
+ offset
);
1198 if (regnum
== SPARC64_STATE_REGNUM
|| regnum
== -1)
1199 regcache_raw_supply (regcache
, SPARC64_STATE_REGNUM
,
1200 regs
+ gregset
->r_tstate_offset
);
1202 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== -1)
1203 regcache_raw_supply (regcache
, SPARC64_PC_REGNUM
,
1204 regs
+ gregset
->r_pc_offset
);
1206 if (regnum
== SPARC64_NPC_REGNUM
|| regnum
== -1)
1207 regcache_raw_supply (regcache
, SPARC64_NPC_REGNUM
,
1208 regs
+ gregset
->r_npc_offset
);
1210 if (regnum
== SPARC64_Y_REGNUM
|| regnum
== -1)
1215 memcpy (buf
+ 8 - gregset
->r_y_size
,
1216 regs
+ gregset
->r_y_offset
, gregset
->r_y_size
);
1217 regcache_raw_supply (regcache
, SPARC64_Y_REGNUM
, buf
);
1220 if ((regnum
== SPARC64_FPRS_REGNUM
|| regnum
== -1)
1221 && gregset
->r_fprs_offset
!= -1)
1222 regcache_raw_supply (regcache
, SPARC64_FPRS_REGNUM
,
1223 regs
+ gregset
->r_fprs_offset
);
1226 if (regnum
== SPARC_G0_REGNUM
|| regnum
== -1)
1227 regcache_raw_supply (regcache
, SPARC_G0_REGNUM
, NULL
);
1229 if ((regnum
>= SPARC_G1_REGNUM
&& regnum
<= SPARC_O7_REGNUM
) || regnum
== -1)
1231 int offset
= gregset
->r_g1_offset
;
1236 for (i
= SPARC_G1_REGNUM
; i
<= SPARC_O7_REGNUM
; i
++)
1238 if (regnum
== i
|| regnum
== -1)
1239 regcache_raw_supply (regcache
, i
, regs
+ offset
);
1244 if ((regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
) || regnum
== -1)
1246 /* Not all of the register set variants include Locals and
1247 Inputs. For those that don't, we read them off the stack. */
1248 if (gregset
->r_l0_offset
== -1)
1252 regcache_cooked_read_unsigned (regcache
, SPARC_SP_REGNUM
, &sp
);
1253 sparc_supply_rwindow (regcache
, sp
, regnum
);
1257 int offset
= gregset
->r_l0_offset
;
1262 for (i
= SPARC_L0_REGNUM
; i
<= SPARC_I7_REGNUM
; i
++)
1264 if (regnum
== i
|| regnum
== -1)
1265 regcache_raw_supply (regcache
, i
, regs
+ offset
);
1273 sparc64_collect_gregset (const struct sparc_gregset
*gregset
,
1274 const struct regcache
*regcache
,
1275 int regnum
, void *gregs
)
1277 int sparc32
= (gdbarch_ptr_bit (current_gdbarch
) == 32);
1283 if (regnum
== SPARC32_PSR_REGNUM
|| regnum
== -1)
1285 int offset
= gregset
->r_tstate_offset
;
1286 ULONGEST tstate
, psr
;
1289 tstate
= extract_unsigned_integer (regs
+ offset
, 8);
1290 regcache_raw_collect (regcache
, SPARC32_PSR_REGNUM
, buf
);
1291 psr
= extract_unsigned_integer (buf
, 4);
1292 tstate
|= (psr
& PSR_ICC
) << 12;
1293 if ((psr
& (PSR_VERS
| PSR_IMPL
)) == PSR_V8PLUS
)
1294 tstate
|= (psr
& PSR_XCC
) << 20;
1295 store_unsigned_integer (buf
, 8, tstate
);
1296 memcpy (regs
+ offset
, buf
, 8);
1299 if (regnum
== SPARC32_PC_REGNUM
|| regnum
== -1)
1300 regcache_raw_collect (regcache
, SPARC32_PC_REGNUM
,
1301 regs
+ gregset
->r_pc_offset
+ 4);
1303 if (regnum
== SPARC32_NPC_REGNUM
|| regnum
== -1)
1304 regcache_raw_collect (regcache
, SPARC32_NPC_REGNUM
,
1305 regs
+ gregset
->r_npc_offset
+ 4);
1307 if (regnum
== SPARC32_Y_REGNUM
|| regnum
== -1)
1309 int offset
= gregset
->r_y_offset
+ 8 - gregset
->r_y_size
;
1310 regcache_raw_collect (regcache
, SPARC32_Y_REGNUM
, regs
+ offset
);
1315 if (regnum
== SPARC64_STATE_REGNUM
|| regnum
== -1)
1316 regcache_raw_collect (regcache
, SPARC64_STATE_REGNUM
,
1317 regs
+ gregset
->r_tstate_offset
);
1319 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== -1)
1320 regcache_raw_collect (regcache
, SPARC64_PC_REGNUM
,
1321 regs
+ gregset
->r_pc_offset
);
1323 if (regnum
== SPARC64_NPC_REGNUM
|| regnum
== -1)
1324 regcache_raw_collect (regcache
, SPARC64_NPC_REGNUM
,
1325 regs
+ gregset
->r_npc_offset
);
1327 if (regnum
== SPARC64_Y_REGNUM
|| regnum
== -1)
1331 regcache_raw_collect (regcache
, SPARC64_Y_REGNUM
, buf
);
1332 memcpy (regs
+ gregset
->r_y_offset
,
1333 buf
+ 8 - gregset
->r_y_size
, gregset
->r_y_size
);
1336 if ((regnum
== SPARC64_FPRS_REGNUM
|| regnum
== -1)
1337 && gregset
->r_fprs_offset
!= -1)
1338 regcache_raw_collect (regcache
, SPARC64_FPRS_REGNUM
,
1339 regs
+ gregset
->r_fprs_offset
);
1343 if ((regnum
>= SPARC_G1_REGNUM
&& regnum
<= SPARC_O7_REGNUM
) || regnum
== -1)
1345 int offset
= gregset
->r_g1_offset
;
1350 /* %g0 is always zero. */
1351 for (i
= SPARC_G1_REGNUM
; i
<= SPARC_O7_REGNUM
; i
++)
1353 if (regnum
== i
|| regnum
== -1)
1354 regcache_raw_collect (regcache
, i
, regs
+ offset
);
1359 if ((regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
) || regnum
== -1)
1361 /* Not all of the register set variants include Locals and
1362 Inputs. For those that don't, we read them off the stack. */
1363 if (gregset
->r_l0_offset
!= -1)
1365 int offset
= gregset
->r_l0_offset
;
1370 for (i
= SPARC_L0_REGNUM
; i
<= SPARC_I7_REGNUM
; i
++)
1372 if (regnum
== i
|| regnum
== -1)
1373 regcache_raw_collect (regcache
, i
, regs
+ offset
);
1381 sparc64_supply_fpregset (struct regcache
*regcache
,
1382 int regnum
, const void *fpregs
)
1384 int sparc32
= (gdbarch_ptr_bit (current_gdbarch
) == 32);
1385 const char *regs
= fpregs
;
1388 for (i
= 0; i
< 32; i
++)
1390 if (regnum
== (SPARC_F0_REGNUM
+ i
) || regnum
== -1)
1391 regcache_raw_supply (regcache
, SPARC_F0_REGNUM
+ i
, regs
+ (i
* 4));
1396 if (regnum
== SPARC32_FSR_REGNUM
|| regnum
== -1)
1397 regcache_raw_supply (regcache
, SPARC32_FSR_REGNUM
,
1398 regs
+ (32 * 4) + (16 * 8) + 4);
1402 for (i
= 0; i
< 16; i
++)
1404 if (regnum
== (SPARC64_F32_REGNUM
+ i
) || regnum
== -1)
1405 regcache_raw_supply (regcache
, SPARC64_F32_REGNUM
+ i
,
1406 regs
+ (32 * 4) + (i
* 8));
1409 if (regnum
== SPARC64_FSR_REGNUM
|| regnum
== -1)
1410 regcache_raw_supply (regcache
, SPARC64_FSR_REGNUM
,
1411 regs
+ (32 * 4) + (16 * 8));
1416 sparc64_collect_fpregset (const struct regcache
*regcache
,
1417 int regnum
, void *fpregs
)
1419 int sparc32
= (gdbarch_ptr_bit (current_gdbarch
) == 32);
1420 char *regs
= fpregs
;
1423 for (i
= 0; i
< 32; i
++)
1425 if (regnum
== (SPARC_F0_REGNUM
+ i
) || regnum
== -1)
1426 regcache_raw_collect (regcache
, SPARC_F0_REGNUM
+ i
, regs
+ (i
* 4));
1431 if (regnum
== SPARC32_FSR_REGNUM
|| regnum
== -1)
1432 regcache_raw_collect (regcache
, SPARC32_FSR_REGNUM
,
1433 regs
+ (32 * 4) + (16 * 8) + 4);
1437 for (i
= 0; i
< 16; i
++)
1439 if (regnum
== (SPARC64_F32_REGNUM
+ i
) || regnum
== -1)
1440 regcache_raw_collect (regcache
, SPARC64_F32_REGNUM
+ i
,
1441 regs
+ (32 * 4) + (i
* 8));
1444 if (regnum
== SPARC64_FSR_REGNUM
|| regnum
== -1)
1445 regcache_raw_collect (regcache
, SPARC64_FSR_REGNUM
,
1446 regs
+ (32 * 4) + (16 * 8));