1 /* Target-dependent code for UltraSPARC.
3 Copyright (C) 2003-2017 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"
34 #include "target-descriptions.h"
38 #include "sparc64-tdep.h"
40 /* This file implements the SPARC 64-bit ABI as defined by the
41 section "Low-Level System Information" of the SPARC Compliance
42 Definition (SCD) 2.4.1, which is the 64-bit System V psABI for
45 /* Please use the sparc32_-prefix for 32-bit specific code, the
46 sparc64_-prefix for 64-bit specific code and the sparc_-prefix for
47 code can handle both. */
49 /* The functions on this page are intended to be used to classify
50 function arguments. */
52 /* Check whether TYPE is "Integral or Pointer". */
55 sparc64_integral_or_pointer_p (const struct type
*type
)
57 switch (TYPE_CODE (type
))
65 int len
= TYPE_LENGTH (type
);
66 gdb_assert (len
== 1 || len
== 2 || len
== 4 || len
== 8);
71 case TYPE_CODE_RVALUE_REF
:
73 int len
= TYPE_LENGTH (type
);
74 gdb_assert (len
== 8);
84 /* Check whether TYPE is "Floating". */
87 sparc64_floating_p (const struct type
*type
)
89 switch (TYPE_CODE (type
))
93 int len
= TYPE_LENGTH (type
);
94 gdb_assert (len
== 4 || len
== 8 || len
== 16);
104 /* Check whether TYPE is "Complex Floating". */
107 sparc64_complex_floating_p (const struct type
*type
)
109 switch (TYPE_CODE (type
))
111 case TYPE_CODE_COMPLEX
:
113 int len
= TYPE_LENGTH (type
);
114 gdb_assert (len
== 8 || len
== 16 || len
== 32);
124 /* Check whether TYPE is "Structure or Union".
126 In terms of Ada subprogram calls, arrays are treated the same as
127 struct and union types. So this function also returns non-zero
131 sparc64_structure_or_union_p (const struct type
*type
)
133 switch (TYPE_CODE (type
))
135 case TYPE_CODE_STRUCT
:
136 case TYPE_CODE_UNION
:
137 case TYPE_CODE_ARRAY
:
147 /* Construct types for ISA-specific registers. */
150 sparc64_pstate_type (struct gdbarch
*gdbarch
)
152 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
154 if (!tdep
->sparc64_pstate_type
)
158 type
= arch_flags_type (gdbarch
, "builtin_type_sparc64_pstate", 8);
159 append_flags_type_flag (type
, 0, "AG");
160 append_flags_type_flag (type
, 1, "IE");
161 append_flags_type_flag (type
, 2, "PRIV");
162 append_flags_type_flag (type
, 3, "AM");
163 append_flags_type_flag (type
, 4, "PEF");
164 append_flags_type_flag (type
, 5, "RED");
165 append_flags_type_flag (type
, 8, "TLE");
166 append_flags_type_flag (type
, 9, "CLE");
167 append_flags_type_flag (type
, 10, "PID0");
168 append_flags_type_flag (type
, 11, "PID1");
170 tdep
->sparc64_pstate_type
= type
;
173 return tdep
->sparc64_pstate_type
;
177 sparc64_ccr_type (struct gdbarch
*gdbarch
)
179 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
181 if (tdep
->sparc64_ccr_type
== NULL
)
185 type
= arch_flags_type (gdbarch
, "builtin_type_sparc64_ccr", 8);
186 append_flags_type_flag (type
, 0, "icc.c");
187 append_flags_type_flag (type
, 1, "icc.v");
188 append_flags_type_flag (type
, 2, "icc.z");
189 append_flags_type_flag (type
, 3, "icc.n");
190 append_flags_type_flag (type
, 4, "xcc.c");
191 append_flags_type_flag (type
, 5, "xcc.v");
192 append_flags_type_flag (type
, 6, "xcc.z");
193 append_flags_type_flag (type
, 7, "xcc.n");
195 tdep
->sparc64_ccr_type
= type
;
198 return tdep
->sparc64_ccr_type
;
202 sparc64_fsr_type (struct gdbarch
*gdbarch
)
204 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
206 if (!tdep
->sparc64_fsr_type
)
210 type
= arch_flags_type (gdbarch
, "builtin_type_sparc64_fsr", 8);
211 append_flags_type_flag (type
, 0, "NXC");
212 append_flags_type_flag (type
, 1, "DZC");
213 append_flags_type_flag (type
, 2, "UFC");
214 append_flags_type_flag (type
, 3, "OFC");
215 append_flags_type_flag (type
, 4, "NVC");
216 append_flags_type_flag (type
, 5, "NXA");
217 append_flags_type_flag (type
, 6, "DZA");
218 append_flags_type_flag (type
, 7, "UFA");
219 append_flags_type_flag (type
, 8, "OFA");
220 append_flags_type_flag (type
, 9, "NVA");
221 append_flags_type_flag (type
, 22, "NS");
222 append_flags_type_flag (type
, 23, "NXM");
223 append_flags_type_flag (type
, 24, "DZM");
224 append_flags_type_flag (type
, 25, "UFM");
225 append_flags_type_flag (type
, 26, "OFM");
226 append_flags_type_flag (type
, 27, "NVM");
228 tdep
->sparc64_fsr_type
= type
;
231 return tdep
->sparc64_fsr_type
;
235 sparc64_fprs_type (struct gdbarch
*gdbarch
)
237 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
239 if (!tdep
->sparc64_fprs_type
)
243 type
= arch_flags_type (gdbarch
, "builtin_type_sparc64_fprs", 8);
244 append_flags_type_flag (type
, 0, "DL");
245 append_flags_type_flag (type
, 1, "DU");
246 append_flags_type_flag (type
, 2, "FEF");
248 tdep
->sparc64_fprs_type
= type
;
251 return tdep
->sparc64_fprs_type
;
255 /* Register information. */
256 #define SPARC64_FPU_REGISTERS \
257 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \
258 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \
259 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", \
260 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", \
261 "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46", \
262 "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62"
263 #define SPARC64_CP0_REGISTERS \
265 /* FIXME: Give "state" a name until we start using register groups. */ \
271 static const char *sparc64_fpu_register_names
[] = { SPARC64_FPU_REGISTERS
};
272 static const char *sparc64_cp0_register_names
[] = { SPARC64_CP0_REGISTERS
};
274 static const char *sparc64_register_names
[] =
276 SPARC_CORE_REGISTERS
,
277 SPARC64_FPU_REGISTERS
,
278 SPARC64_CP0_REGISTERS
281 /* Total number of registers. */
282 #define SPARC64_NUM_REGS ARRAY_SIZE (sparc64_register_names)
284 /* We provide the aliases %d0..%d62 and %q0..%q60 for the floating
285 registers as "psuedo" registers. */
287 static const char *sparc64_pseudo_register_names
[] =
289 "cwp", "pstate", "asi", "ccr",
291 "d0", "d2", "d4", "d6", "d8", "d10", "d12", "d14",
292 "d16", "d18", "d20", "d22", "d24", "d26", "d28", "d30",
293 "d32", "d34", "d36", "d38", "d40", "d42", "d44", "d46",
294 "d48", "d50", "d52", "d54", "d56", "d58", "d60", "d62",
296 "q0", "q4", "q8", "q12", "q16", "q20", "q24", "q28",
297 "q32", "q36", "q40", "q44", "q48", "q52", "q56", "q60",
300 /* Total number of pseudo registers. */
301 #define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_names)
303 /* Return the name of pseudo register REGNUM. */
306 sparc64_pseudo_register_name (struct gdbarch
*gdbarch
, int regnum
)
308 regnum
-= gdbarch_num_regs (gdbarch
);
310 if (regnum
< SPARC64_NUM_PSEUDO_REGS
)
311 return sparc64_pseudo_register_names
[regnum
];
313 internal_error (__FILE__
, __LINE__
,
314 _("sparc64_pseudo_register_name: bad register number %d"),
318 /* Return the name of register REGNUM. */
321 sparc64_register_name (struct gdbarch
*gdbarch
, int regnum
)
323 if (tdesc_has_registers (gdbarch_target_desc (gdbarch
)))
324 return tdesc_register_name (gdbarch
, regnum
);
326 if (regnum
>= 0 && regnum
< gdbarch_num_regs (gdbarch
))
327 return sparc64_register_names
[regnum
];
329 return sparc64_pseudo_register_name (gdbarch
, regnum
);
332 /* Return the GDB type object for the "standard" data type of data in
333 pseudo register REGNUM. */
336 sparc64_pseudo_register_type (struct gdbarch
*gdbarch
, int regnum
)
338 regnum
-= gdbarch_num_regs (gdbarch
);
340 if (regnum
== SPARC64_CWP_REGNUM
)
341 return builtin_type (gdbarch
)->builtin_int64
;
342 if (regnum
== SPARC64_PSTATE_REGNUM
)
343 return sparc64_pstate_type (gdbarch
);
344 if (regnum
== SPARC64_ASI_REGNUM
)
345 return builtin_type (gdbarch
)->builtin_int64
;
346 if (regnum
== SPARC64_CCR_REGNUM
)
347 return sparc64_ccr_type (gdbarch
);
348 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
349 return builtin_type (gdbarch
)->builtin_double
;
350 if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
351 return builtin_type (gdbarch
)->builtin_long_double
;
353 internal_error (__FILE__
, __LINE__
,
354 _("sparc64_pseudo_register_type: bad register number %d"),
358 /* Return the GDB type object for the "standard" data type of data in
362 sparc64_register_type (struct gdbarch
*gdbarch
, int regnum
)
364 if (tdesc_has_registers (gdbarch_target_desc (gdbarch
)))
365 return tdesc_register_type (gdbarch
, regnum
);
368 if (regnum
== SPARC_SP_REGNUM
|| regnum
== SPARC_FP_REGNUM
)
369 return builtin_type (gdbarch
)->builtin_data_ptr
;
370 if (regnum
>= SPARC_G0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
)
371 return builtin_type (gdbarch
)->builtin_int64
;
372 if (regnum
>= SPARC_F0_REGNUM
&& regnum
<= SPARC_F31_REGNUM
)
373 return builtin_type (gdbarch
)->builtin_float
;
374 if (regnum
>= SPARC64_F32_REGNUM
&& regnum
<= SPARC64_F62_REGNUM
)
375 return builtin_type (gdbarch
)->builtin_double
;
376 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== SPARC64_NPC_REGNUM
)
377 return builtin_type (gdbarch
)->builtin_func_ptr
;
378 /* This raw register contains the contents of %cwp, %pstate, %asi
379 and %ccr as laid out in a %tstate register. */
380 if (regnum
== SPARC64_STATE_REGNUM
)
381 return builtin_type (gdbarch
)->builtin_int64
;
382 if (regnum
== SPARC64_FSR_REGNUM
)
383 return sparc64_fsr_type (gdbarch
);
384 if (regnum
== SPARC64_FPRS_REGNUM
)
385 return sparc64_fprs_type (gdbarch
);
386 /* "Although Y is a 64-bit register, its high-order 32 bits are
387 reserved and always read as 0." */
388 if (regnum
== SPARC64_Y_REGNUM
)
389 return builtin_type (gdbarch
)->builtin_int64
;
391 /* Pseudo registers. */
392 if (regnum
>= gdbarch_num_regs (gdbarch
))
393 return sparc64_pseudo_register_type (gdbarch
, regnum
);
395 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
398 static enum register_status
399 sparc64_pseudo_register_read (struct gdbarch
*gdbarch
,
400 struct regcache
*regcache
,
401 int regnum
, gdb_byte
*buf
)
403 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
404 enum register_status status
;
406 regnum
-= gdbarch_num_regs (gdbarch
);
408 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D30_REGNUM
)
410 regnum
= SPARC_F0_REGNUM
+ 2 * (regnum
- SPARC64_D0_REGNUM
);
411 status
= regcache_raw_read (regcache
, regnum
, buf
);
412 if (status
== REG_VALID
)
413 status
= regcache_raw_read (regcache
, regnum
+ 1, buf
+ 4);
416 else if (regnum
>= SPARC64_D32_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
418 regnum
= SPARC64_F32_REGNUM
+ (regnum
- SPARC64_D32_REGNUM
);
419 return regcache_raw_read (regcache
, regnum
, buf
);
421 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q28_REGNUM
)
423 regnum
= SPARC_F0_REGNUM
+ 4 * (regnum
- SPARC64_Q0_REGNUM
);
425 status
= regcache_raw_read (regcache
, regnum
, buf
);
426 if (status
== REG_VALID
)
427 status
= regcache_raw_read (regcache
, regnum
+ 1, buf
+ 4);
428 if (status
== REG_VALID
)
429 status
= regcache_raw_read (regcache
, regnum
+ 2, buf
+ 8);
430 if (status
== REG_VALID
)
431 status
= regcache_raw_read (regcache
, regnum
+ 3, buf
+ 12);
435 else if (regnum
>= SPARC64_Q32_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
437 regnum
= SPARC64_F32_REGNUM
+ 2 * (regnum
- SPARC64_Q32_REGNUM
);
439 status
= regcache_raw_read (regcache
, regnum
, buf
);
440 if (status
== REG_VALID
)
441 status
= regcache_raw_read (regcache
, regnum
+ 1, buf
+ 8);
445 else if (regnum
== SPARC64_CWP_REGNUM
446 || regnum
== SPARC64_PSTATE_REGNUM
447 || regnum
== SPARC64_ASI_REGNUM
448 || regnum
== SPARC64_CCR_REGNUM
)
452 status
= regcache_raw_read_unsigned (regcache
, SPARC64_STATE_REGNUM
, &state
);
453 if (status
!= REG_VALID
)
458 case SPARC64_CWP_REGNUM
:
459 state
= (state
>> 0) & ((1 << 5) - 1);
461 case SPARC64_PSTATE_REGNUM
:
462 state
= (state
>> 8) & ((1 << 12) - 1);
464 case SPARC64_ASI_REGNUM
:
465 state
= (state
>> 24) & ((1 << 8) - 1);
467 case SPARC64_CCR_REGNUM
:
468 state
= (state
>> 32) & ((1 << 8) - 1);
471 store_unsigned_integer (buf
, 8, byte_order
, state
);
478 sparc64_pseudo_register_write (struct gdbarch
*gdbarch
,
479 struct regcache
*regcache
,
480 int regnum
, const gdb_byte
*buf
)
482 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
484 regnum
-= gdbarch_num_regs (gdbarch
);
486 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D30_REGNUM
)
488 regnum
= SPARC_F0_REGNUM
+ 2 * (regnum
- SPARC64_D0_REGNUM
);
489 regcache_raw_write (regcache
, regnum
, buf
);
490 regcache_raw_write (regcache
, regnum
+ 1, buf
+ 4);
492 else if (regnum
>= SPARC64_D32_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
494 regnum
= SPARC64_F32_REGNUM
+ (regnum
- SPARC64_D32_REGNUM
);
495 regcache_raw_write (regcache
, regnum
, buf
);
497 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q28_REGNUM
)
499 regnum
= SPARC_F0_REGNUM
+ 4 * (regnum
- SPARC64_Q0_REGNUM
);
500 regcache_raw_write (regcache
, regnum
, buf
);
501 regcache_raw_write (regcache
, regnum
+ 1, buf
+ 4);
502 regcache_raw_write (regcache
, regnum
+ 2, buf
+ 8);
503 regcache_raw_write (regcache
, regnum
+ 3, buf
+ 12);
505 else if (regnum
>= SPARC64_Q32_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
507 regnum
= SPARC64_F32_REGNUM
+ 2 * (regnum
- SPARC64_Q32_REGNUM
);
508 regcache_raw_write (regcache
, regnum
, buf
);
509 regcache_raw_write (regcache
, regnum
+ 1, buf
+ 8);
511 else if (regnum
== SPARC64_CWP_REGNUM
512 || regnum
== SPARC64_PSTATE_REGNUM
513 || regnum
== SPARC64_ASI_REGNUM
514 || regnum
== SPARC64_CCR_REGNUM
)
516 ULONGEST state
, bits
;
518 regcache_raw_read_unsigned (regcache
, SPARC64_STATE_REGNUM
, &state
);
519 bits
= extract_unsigned_integer (buf
, 8, byte_order
);
522 case SPARC64_CWP_REGNUM
:
523 state
|= ((bits
& ((1 << 5) - 1)) << 0);
525 case SPARC64_PSTATE_REGNUM
:
526 state
|= ((bits
& ((1 << 12) - 1)) << 8);
528 case SPARC64_ASI_REGNUM
:
529 state
|= ((bits
& ((1 << 8) - 1)) << 24);
531 case SPARC64_CCR_REGNUM
:
532 state
|= ((bits
& ((1 << 8) - 1)) << 32);
535 regcache_raw_write_unsigned (regcache
, SPARC64_STATE_REGNUM
, state
);
540 /* Return PC of first real instruction of the function starting at
544 sparc64_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR start_pc
)
546 struct symtab_and_line sal
;
547 CORE_ADDR func_start
, func_end
;
548 struct sparc_frame_cache cache
;
550 /* This is the preferred method, find the end of the prologue by
551 using the debugging information. */
552 if (find_pc_partial_function (start_pc
, NULL
, &func_start
, &func_end
))
554 sal
= find_pc_line (func_start
, 0);
556 if (sal
.end
< func_end
557 && start_pc
<= sal
.end
)
561 return sparc_analyze_prologue (gdbarch
, start_pc
, 0xffffffffffffffffULL
,
567 static struct sparc_frame_cache
*
568 sparc64_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
570 return sparc_frame_cache (this_frame
, this_cache
);
574 sparc64_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
575 struct frame_id
*this_id
)
577 struct sparc_frame_cache
*cache
=
578 sparc64_frame_cache (this_frame
, this_cache
);
580 /* This marks the outermost frame. */
581 if (cache
->base
== 0)
584 (*this_id
) = frame_id_build (cache
->base
, cache
->pc
);
587 static struct value
*
588 sparc64_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
591 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
592 struct sparc_frame_cache
*cache
=
593 sparc64_frame_cache (this_frame
, this_cache
);
595 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== SPARC64_NPC_REGNUM
)
597 CORE_ADDR pc
= (regnum
== SPARC64_NPC_REGNUM
) ? 4 : 0;
600 (cache
->copied_regs_mask
& 0x80) ? SPARC_I7_REGNUM
: SPARC_O7_REGNUM
;
601 pc
+= get_frame_register_unsigned (this_frame
, regnum
) + 8;
602 return frame_unwind_got_constant (this_frame
, regnum
, pc
);
605 /* Handle StackGhost. */
607 ULONGEST wcookie
= sparc_fetch_wcookie (gdbarch
);
609 if (wcookie
!= 0 && !cache
->frameless_p
&& regnum
== SPARC_I7_REGNUM
)
611 CORE_ADDR addr
= cache
->base
+ (regnum
- SPARC_L0_REGNUM
) * 8;
614 /* Read the value in from memory. */
615 i7
= get_frame_memory_unsigned (this_frame
, addr
, 8);
616 return frame_unwind_got_constant (this_frame
, regnum
, i7
^ wcookie
);
620 /* The previous frame's `local' and `in' registers may have been saved
621 in the register save area. */
622 if (regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
623 && (cache
->saved_regs_mask
& (1 << (regnum
- SPARC_L0_REGNUM
))))
625 CORE_ADDR addr
= cache
->base
+ (regnum
- SPARC_L0_REGNUM
) * 8;
627 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
630 /* The previous frame's `out' registers may be accessible as the current
631 frame's `in' registers. */
632 if (regnum
>= SPARC_O0_REGNUM
&& regnum
<= SPARC_O7_REGNUM
633 && (cache
->copied_regs_mask
& (1 << (regnum
- SPARC_O0_REGNUM
))))
634 regnum
+= (SPARC_I0_REGNUM
- SPARC_O0_REGNUM
);
636 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
639 static const struct frame_unwind sparc64_frame_unwind
=
642 default_frame_unwind_stop_reason
,
643 sparc64_frame_this_id
,
644 sparc64_frame_prev_register
,
646 default_frame_sniffer
651 sparc64_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
653 struct sparc_frame_cache
*cache
=
654 sparc64_frame_cache (this_frame
, this_cache
);
659 static const struct frame_base sparc64_frame_base
=
661 &sparc64_frame_unwind
,
662 sparc64_frame_base_address
,
663 sparc64_frame_base_address
,
664 sparc64_frame_base_address
667 /* Check whether TYPE must be 16-byte aligned. */
670 sparc64_16_byte_align_p (struct type
*type
)
672 if (sparc64_floating_p (type
) && TYPE_LENGTH (type
) == 16)
675 if (sparc64_structure_or_union_p (type
))
679 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
681 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
683 if (sparc64_16_byte_align_p (subtype
))
691 /* Store floating fields of element ELEMENT of an "parameter array"
692 that has type TYPE and is stored at BITPOS in VALBUF in the
693 apropriate registers of REGCACHE. This function can be called
694 recursively and therefore handles floating types in addition to
698 sparc64_store_floating_fields (struct regcache
*regcache
, struct type
*type
,
699 const gdb_byte
*valbuf
, int element
, int bitpos
)
701 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
702 int len
= TYPE_LENGTH (type
);
704 gdb_assert (element
< 16);
706 if (sparc64_floating_p (type
)
707 || (sparc64_complex_floating_p (type
) && len
<= 16))
713 gdb_assert (bitpos
== 0);
714 gdb_assert ((element
% 2) == 0);
716 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_Q0_REGNUM
+ element
/ 2;
717 regcache_cooked_write (regcache
, regnum
, valbuf
);
721 gdb_assert (bitpos
== 0 || bitpos
== 64);
723 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_D0_REGNUM
724 + element
+ bitpos
/ 64;
725 regcache_cooked_write (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
729 gdb_assert (len
== 4);
730 gdb_assert (bitpos
% 32 == 0 && bitpos
>= 0 && bitpos
< 128);
732 regnum
= SPARC_F0_REGNUM
+ element
* 2 + bitpos
/ 32;
733 regcache_cooked_write (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
736 else if (sparc64_structure_or_union_p (type
))
740 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
742 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
743 int subpos
= bitpos
+ TYPE_FIELD_BITPOS (type
, i
);
745 sparc64_store_floating_fields (regcache
, subtype
, valbuf
,
749 /* GCC has an interesting bug. If TYPE is a structure that has
750 a single `float' member, GCC doesn't treat it as a structure
751 at all, but rather as an ordinary `float' argument. This
752 argument will be stored in %f1, as required by the psABI.
753 However, as a member of a structure the psABI requires it to
754 be stored in %f0. This bug is present in GCC 3.3.2, but
755 probably in older releases to. To appease GCC, if a
756 structure has only a single `float' member, we store its
757 value in %f1 too (we already have stored in %f0). */
758 if (TYPE_NFIELDS (type
) == 1)
760 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
762 if (sparc64_floating_p (subtype
) && TYPE_LENGTH (subtype
) == 4)
763 regcache_cooked_write (regcache
, SPARC_F1_REGNUM
, valbuf
);
768 /* Fetch floating fields from a variable of type TYPE from the
769 appropriate registers for BITPOS in REGCACHE and store it at BITPOS
770 in VALBUF. This function can be called recursively and therefore
771 handles floating types in addition to structures. */
774 sparc64_extract_floating_fields (struct regcache
*regcache
, struct type
*type
,
775 gdb_byte
*valbuf
, int bitpos
)
777 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
779 if (sparc64_floating_p (type
))
781 int len
= TYPE_LENGTH (type
);
786 gdb_assert (bitpos
== 0 || bitpos
== 128);
788 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_Q0_REGNUM
790 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
794 gdb_assert (bitpos
% 64 == 0 && bitpos
>= 0 && bitpos
< 256);
796 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_D0_REGNUM
+ bitpos
/ 64;
797 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
801 gdb_assert (len
== 4);
802 gdb_assert (bitpos
% 32 == 0 && bitpos
>= 0 && bitpos
< 256);
804 regnum
= SPARC_F0_REGNUM
+ bitpos
/ 32;
805 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
808 else if (sparc64_structure_or_union_p (type
))
812 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
814 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
815 int subpos
= bitpos
+ TYPE_FIELD_BITPOS (type
, i
);
817 sparc64_extract_floating_fields (regcache
, subtype
, valbuf
, subpos
);
822 /* Store the NARGS arguments ARGS and STRUCT_ADDR (if STRUCT_RETURN is
823 non-zero) in REGCACHE and on the stack (starting from address SP). */
826 sparc64_store_arguments (struct regcache
*regcache
, int nargs
,
827 struct value
**args
, CORE_ADDR sp
,
828 int struct_return
, CORE_ADDR struct_addr
)
830 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
831 /* Number of extended words in the "parameter array". */
832 int num_elements
= 0;
836 /* Take BIAS into account. */
839 /* First we calculate the number of extended words in the "parameter
840 array". While doing so we also convert some of the arguments. */
845 for (i
= 0; i
< nargs
; i
++)
847 struct type
*type
= value_type (args
[i
]);
848 int len
= TYPE_LENGTH (type
);
850 if (sparc64_structure_or_union_p (type
)
851 || (sparc64_complex_floating_p (type
) && len
== 32))
853 /* Structure or Union arguments. */
856 if (num_elements
% 2 && sparc64_16_byte_align_p (type
))
858 num_elements
+= ((len
+ 7) / 8);
862 /* The psABI says that "Structures or unions larger than
863 sixteen bytes are copied by the caller and passed
864 indirectly; the caller will pass the address of a
865 correctly aligned structure value. This sixty-four
866 bit address will occupy one word in the parameter
867 array, and may be promoted to an %o register like any
868 other pointer value." Allocate memory for these
869 values on the stack. */
872 /* Use 16-byte alignment for these values. That's
873 always correct, and wasting a few bytes shouldn't be
877 write_memory (sp
, value_contents (args
[i
]), len
);
878 args
[i
] = value_from_pointer (lookup_pointer_type (type
), sp
);
882 else if (sparc64_floating_p (type
) || sparc64_complex_floating_p (type
))
884 /* Floating arguments. */
887 /* The psABI says that "Each quad-precision parameter
888 value will be assigned to two extended words in the
892 /* The psABI says that "Long doubles must be
893 quad-aligned, and thus a hole might be introduced
894 into the parameter array to force alignment." Skip
895 an element if necessary. */
896 if ((num_elements
% 2) && sparc64_16_byte_align_p (type
))
904 /* Integral and pointer arguments. */
905 gdb_assert (sparc64_integral_or_pointer_p (type
));
907 /* The psABI says that "Each argument value of integral type
908 smaller than an extended word will be widened by the
909 caller to an extended word according to the signed-ness
910 of the argument type." */
912 args
[i
] = value_cast (builtin_type (gdbarch
)->builtin_int64
,
918 /* Allocate the "parameter array". */
919 sp
-= num_elements
* 8;
921 /* The psABI says that "Every stack frame must be 16-byte aligned." */
924 /* Now we store the arguments in to the "paramater array". Some
925 Integer or Pointer arguments and Structure or Union arguments
926 will be passed in %o registers. Some Floating arguments and
927 floating members of structures are passed in floating-point
928 registers. However, for functions with variable arguments,
929 floating arguments are stored in an %0 register, and for
930 functions without a prototype floating arguments are stored in
931 both a floating-point and an %o registers, or a floating-point
932 register and memory. To simplify the logic here we always pass
933 arguments in memory, an %o register, and a floating-point
934 register if appropriate. This should be no problem since the
935 contents of any unused memory or registers in the "parameter
936 array" are undefined. */
940 regcache_cooked_write_unsigned (regcache
, SPARC_O0_REGNUM
, struct_addr
);
944 for (i
= 0; i
< nargs
; i
++)
946 const gdb_byte
*valbuf
= value_contents (args
[i
]);
947 struct type
*type
= value_type (args
[i
]);
948 int len
= TYPE_LENGTH (type
);
952 if (sparc64_structure_or_union_p (type
)
953 || (sparc64_complex_floating_p (type
) && len
== 32))
955 /* Structure, Union or long double Complex arguments. */
956 gdb_assert (len
<= 16);
957 memset (buf
, 0, sizeof (buf
));
958 memcpy (buf
, valbuf
, len
);
961 if (element
% 2 && sparc64_16_byte_align_p (type
))
966 regnum
= SPARC_O0_REGNUM
+ element
;
967 if (len
> 8 && element
< 5)
968 regcache_cooked_write (regcache
, regnum
+ 1, valbuf
+ 8);
972 sparc64_store_floating_fields (regcache
, type
, valbuf
, element
, 0);
974 else if (sparc64_complex_floating_p (type
))
976 /* Float Complex or double Complex arguments. */
979 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_D0_REGNUM
+ element
;
983 if (regnum
< gdbarch_num_regs (gdbarch
) + SPARC64_D30_REGNUM
)
984 regcache_cooked_write (regcache
, regnum
+ 1, valbuf
+ 8);
985 if (regnum
< gdbarch_num_regs (gdbarch
) + SPARC64_D10_REGNUM
)
986 regcache_cooked_write (regcache
,
987 SPARC_O0_REGNUM
+ element
+ 1,
992 else if (sparc64_floating_p (type
))
994 /* Floating arguments. */
1000 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_Q0_REGNUM
1006 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_D0_REGNUM
1011 /* The psABI says "Each single-precision parameter value
1012 will be assigned to one extended word in the
1013 parameter array, and right-justified within that
1014 word; the left half (even float register) is
1015 undefined." Even though the psABI says that "the
1016 left half is undefined", set it to zero here. */
1018 memcpy (buf
+ 4, valbuf
, 4);
1022 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_D0_REGNUM
1028 /* Integral and pointer arguments. */
1029 gdb_assert (len
== 8);
1031 regnum
= SPARC_O0_REGNUM
+ element
;
1036 regcache_cooked_write (regcache
, regnum
, valbuf
);
1038 /* If we're storing the value in a floating-point register,
1039 also store it in the corresponding %0 register(s). */
1040 if (regnum
>= gdbarch_num_regs (gdbarch
))
1042 regnum
-= gdbarch_num_regs (gdbarch
);
1044 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D10_REGNUM
)
1046 gdb_assert (element
< 6);
1047 regnum
= SPARC_O0_REGNUM
+ element
;
1048 regcache_cooked_write (regcache
, regnum
, valbuf
);
1050 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q8_REGNUM
)
1052 gdb_assert (element
< 5);
1053 regnum
= SPARC_O0_REGNUM
+ element
;
1054 regcache_cooked_write (regcache
, regnum
, valbuf
);
1055 regcache_cooked_write (regcache
, regnum
+ 1, valbuf
+ 8);
1060 /* Always store the argument in memory. */
1061 write_memory (sp
+ element
* 8, valbuf
, len
);
1062 element
+= ((len
+ 7) / 8);
1065 gdb_assert (element
== num_elements
);
1067 /* Take BIAS into account. */
1073 sparc64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR address
)
1075 /* The ABI requires 16-byte alignment. */
1076 return address
& ~0xf;
1080 sparc64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
1081 struct regcache
*regcache
, CORE_ADDR bp_addr
,
1082 int nargs
, struct value
**args
, CORE_ADDR sp
,
1083 int struct_return
, CORE_ADDR struct_addr
)
1085 /* Set return address. */
1086 regcache_cooked_write_unsigned (regcache
, SPARC_O7_REGNUM
, bp_addr
- 8);
1088 /* Set up function arguments. */
1089 sp
= sparc64_store_arguments (regcache
, nargs
, args
, sp
,
1090 struct_return
, struct_addr
);
1092 /* Allocate the register save area. */
1095 /* Stack should be 16-byte aligned at this point. */
1096 gdb_assert ((sp
+ BIAS
) % 16 == 0);
1098 /* Finally, update the stack pointer. */
1099 regcache_cooked_write_unsigned (regcache
, SPARC_SP_REGNUM
, sp
);
1105 /* Extract from an array REGBUF containing the (raw) register state, a
1106 function return value of TYPE, and copy that into VALBUF. */
1109 sparc64_extract_return_value (struct type
*type
, struct regcache
*regcache
,
1112 int len
= TYPE_LENGTH (type
);
1116 if (sparc64_structure_or_union_p (type
))
1118 /* Structure or Union return values. */
1119 gdb_assert (len
<= 32);
1121 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1122 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1123 if (TYPE_CODE (type
) != TYPE_CODE_UNION
)
1124 sparc64_extract_floating_fields (regcache
, type
, buf
, 0);
1125 memcpy (valbuf
, buf
, len
);
1127 else if (sparc64_floating_p (type
) || sparc64_complex_floating_p (type
))
1129 /* Floating return values. */
1130 for (i
= 0; i
< len
/ 4; i
++)
1131 regcache_cooked_read (regcache
, SPARC_F0_REGNUM
+ i
, buf
+ i
* 4);
1132 memcpy (valbuf
, buf
, len
);
1134 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1136 /* Small arrays are returned the same way as small structures. */
1137 gdb_assert (len
<= 32);
1139 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1140 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1141 memcpy (valbuf
, buf
, len
);
1145 /* Integral and pointer return values. */
1146 gdb_assert (sparc64_integral_or_pointer_p (type
));
1148 /* Just stripping off any unused bytes should preserve the
1149 signed-ness just fine. */
1150 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
, buf
);
1151 memcpy (valbuf
, buf
+ 8 - len
, len
);
1155 /* Write into the appropriate registers a function return value stored
1156 in VALBUF of type TYPE. */
1159 sparc64_store_return_value (struct type
*type
, struct regcache
*regcache
,
1160 const gdb_byte
*valbuf
)
1162 int len
= TYPE_LENGTH (type
);
1166 if (sparc64_structure_or_union_p (type
))
1168 /* Structure or Union return values. */
1169 gdb_assert (len
<= 32);
1171 /* Simplify matters by storing the complete value (including
1172 floating members) into %o0 and %o1. Floating members are
1173 also store in the appropriate floating-point registers. */
1174 memset (buf
, 0, sizeof (buf
));
1175 memcpy (buf
, valbuf
, len
);
1176 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1177 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1178 if (TYPE_CODE (type
) != TYPE_CODE_UNION
)
1179 sparc64_store_floating_fields (regcache
, type
, buf
, 0, 0);
1181 else if (sparc64_floating_p (type
) || sparc64_complex_floating_p (type
))
1183 /* Floating return values. */
1184 memcpy (buf
, valbuf
, len
);
1185 for (i
= 0; i
< len
/ 4; i
++)
1186 regcache_cooked_write (regcache
, SPARC_F0_REGNUM
+ i
, buf
+ i
* 4);
1188 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1190 /* Small arrays are returned the same way as small structures. */
1191 gdb_assert (len
<= 32);
1193 memset (buf
, 0, sizeof (buf
));
1194 memcpy (buf
, valbuf
, len
);
1195 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1196 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1200 /* Integral and pointer return values. */
1201 gdb_assert (sparc64_integral_or_pointer_p (type
));
1203 /* ??? Do we need to do any sign-extension here? */
1205 memcpy (buf
+ 8 - len
, valbuf
, len
);
1206 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
, buf
);
1210 static enum return_value_convention
1211 sparc64_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
1212 struct type
*type
, struct regcache
*regcache
,
1213 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1215 if (TYPE_LENGTH (type
) > 32)
1216 return RETURN_VALUE_STRUCT_CONVENTION
;
1219 sparc64_extract_return_value (type
, regcache
, readbuf
);
1221 sparc64_store_return_value (type
, regcache
, writebuf
);
1223 return RETURN_VALUE_REGISTER_CONVENTION
;
1228 sparc64_dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
1229 struct dwarf2_frame_state_reg
*reg
,
1230 struct frame_info
*this_frame
)
1234 case SPARC_G0_REGNUM
:
1235 /* Since %g0 is always zero, there is no point in saving it, and
1236 people will be inclined omit it from the CFI. Make sure we
1237 don't warn about that. */
1238 reg
->how
= DWARF2_FRAME_REG_SAME_VALUE
;
1240 case SPARC_SP_REGNUM
:
1241 reg
->how
= DWARF2_FRAME_REG_CFA
;
1243 case SPARC64_PC_REGNUM
:
1244 reg
->how
= DWARF2_FRAME_REG_RA_OFFSET
;
1245 reg
->loc
.offset
= 8;
1247 case SPARC64_NPC_REGNUM
:
1248 reg
->how
= DWARF2_FRAME_REG_RA_OFFSET
;
1249 reg
->loc
.offset
= 12;
1255 sparc64_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1257 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1259 tdep
->pc_regnum
= SPARC64_PC_REGNUM
;
1260 tdep
->npc_regnum
= SPARC64_NPC_REGNUM
;
1261 tdep
->fpu_register_names
= sparc64_fpu_register_names
;
1262 tdep
->fpu_registers_num
= ARRAY_SIZE (sparc64_fpu_register_names
);
1263 tdep
->cp0_register_names
= sparc64_cp0_register_names
;
1264 tdep
->cp0_registers_num
= ARRAY_SIZE (sparc64_cp0_register_names
);
1266 /* This is what all the fuss is about. */
1267 set_gdbarch_long_bit (gdbarch
, 64);
1268 set_gdbarch_long_long_bit (gdbarch
, 64);
1269 set_gdbarch_ptr_bit (gdbarch
, 64);
1271 set_gdbarch_num_regs (gdbarch
, SPARC64_NUM_REGS
);
1272 set_gdbarch_register_name (gdbarch
, sparc64_register_name
);
1273 set_gdbarch_register_type (gdbarch
, sparc64_register_type
);
1274 set_gdbarch_num_pseudo_regs (gdbarch
, SPARC64_NUM_PSEUDO_REGS
);
1275 set_tdesc_pseudo_register_name (gdbarch
, sparc64_pseudo_register_name
);
1276 set_tdesc_pseudo_register_type (gdbarch
, sparc64_pseudo_register_type
);
1277 set_gdbarch_pseudo_register_read (gdbarch
, sparc64_pseudo_register_read
);
1278 set_gdbarch_pseudo_register_write (gdbarch
, sparc64_pseudo_register_write
);
1280 /* Register numbers of various important registers. */
1281 set_gdbarch_pc_regnum (gdbarch
, SPARC64_PC_REGNUM
); /* %pc */
1283 /* Call dummy code. */
1284 set_gdbarch_frame_align (gdbarch
, sparc64_frame_align
);
1285 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1286 set_gdbarch_push_dummy_code (gdbarch
, NULL
);
1287 set_gdbarch_push_dummy_call (gdbarch
, sparc64_push_dummy_call
);
1289 set_gdbarch_return_value (gdbarch
, sparc64_return_value
);
1290 set_gdbarch_stabs_argument_has_addr
1291 (gdbarch
, default_stabs_argument_has_addr
);
1293 set_gdbarch_skip_prologue (gdbarch
, sparc64_skip_prologue
);
1294 set_gdbarch_stack_frame_destroyed_p (gdbarch
, sparc_stack_frame_destroyed_p
);
1296 /* Hook in the DWARF CFI frame unwinder. */
1297 dwarf2_frame_set_init_reg (gdbarch
, sparc64_dwarf2_frame_init_reg
);
1298 /* FIXME: kettenis/20050423: Don't enable the unwinder until the
1299 StackGhost issues have been resolved. */
1301 frame_unwind_append_unwinder (gdbarch
, &sparc64_frame_unwind
);
1302 frame_base_set_default (gdbarch
, &sparc64_frame_base
);
1306 /* Helper functions for dealing with register sets. */
1308 #define TSTATE_CWP 0x000000000000001fULL
1309 #define TSTATE_ICC 0x0000000f00000000ULL
1310 #define TSTATE_XCC 0x000000f000000000ULL
1312 #define PSR_S 0x00000080
1313 #define PSR_ICC 0x00f00000
1314 #define PSR_VERS 0x0f000000
1315 #define PSR_IMPL 0xf0000000
1316 #define PSR_V8PLUS 0xff000000
1317 #define PSR_XCC 0x000f0000
1320 sparc64_supply_gregset (const struct sparc_gregmap
*gregmap
,
1321 struct regcache
*regcache
,
1322 int regnum
, const void *gregs
)
1324 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1325 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1326 int sparc32
= (gdbarch_ptr_bit (gdbarch
) == 32);
1327 const gdb_byte
*regs
= (const gdb_byte
*) gregs
;
1328 gdb_byte zero
[8] = { 0 };
1333 if (regnum
== SPARC32_PSR_REGNUM
|| regnum
== -1)
1335 int offset
= gregmap
->r_tstate_offset
;
1336 ULONGEST tstate
, psr
;
1339 tstate
= extract_unsigned_integer (regs
+ offset
, 8, byte_order
);
1340 psr
= ((tstate
& TSTATE_CWP
) | PSR_S
| ((tstate
& TSTATE_ICC
) >> 12)
1341 | ((tstate
& TSTATE_XCC
) >> 20) | PSR_V8PLUS
);
1342 store_unsigned_integer (buf
, 4, byte_order
, psr
);
1343 regcache_raw_supply (regcache
, SPARC32_PSR_REGNUM
, buf
);
1346 if (regnum
== SPARC32_PC_REGNUM
|| regnum
== -1)
1347 regcache_raw_supply (regcache
, SPARC32_PC_REGNUM
,
1348 regs
+ gregmap
->r_pc_offset
+ 4);
1350 if (regnum
== SPARC32_NPC_REGNUM
|| regnum
== -1)
1351 regcache_raw_supply (regcache
, SPARC32_NPC_REGNUM
,
1352 regs
+ gregmap
->r_npc_offset
+ 4);
1354 if (regnum
== SPARC32_Y_REGNUM
|| regnum
== -1)
1356 int offset
= gregmap
->r_y_offset
+ 8 - gregmap
->r_y_size
;
1357 regcache_raw_supply (regcache
, SPARC32_Y_REGNUM
, regs
+ offset
);
1362 if (regnum
== SPARC64_STATE_REGNUM
|| regnum
== -1)
1363 regcache_raw_supply (regcache
, SPARC64_STATE_REGNUM
,
1364 regs
+ gregmap
->r_tstate_offset
);
1366 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== -1)
1367 regcache_raw_supply (regcache
, SPARC64_PC_REGNUM
,
1368 regs
+ gregmap
->r_pc_offset
);
1370 if (regnum
== SPARC64_NPC_REGNUM
|| regnum
== -1)
1371 regcache_raw_supply (regcache
, SPARC64_NPC_REGNUM
,
1372 regs
+ gregmap
->r_npc_offset
);
1374 if (regnum
== SPARC64_Y_REGNUM
|| regnum
== -1)
1379 memcpy (buf
+ 8 - gregmap
->r_y_size
,
1380 regs
+ gregmap
->r_y_offset
, gregmap
->r_y_size
);
1381 regcache_raw_supply (regcache
, SPARC64_Y_REGNUM
, buf
);
1384 if ((regnum
== SPARC64_FPRS_REGNUM
|| regnum
== -1)
1385 && gregmap
->r_fprs_offset
!= -1)
1386 regcache_raw_supply (regcache
, SPARC64_FPRS_REGNUM
,
1387 regs
+ gregmap
->r_fprs_offset
);
1390 if (regnum
== SPARC_G0_REGNUM
|| regnum
== -1)
1391 regcache_raw_supply (regcache
, SPARC_G0_REGNUM
, &zero
);
1393 if ((regnum
>= SPARC_G1_REGNUM
&& regnum
<= SPARC_O7_REGNUM
) || regnum
== -1)
1395 int offset
= gregmap
->r_g1_offset
;
1400 for (i
= SPARC_G1_REGNUM
; i
<= SPARC_O7_REGNUM
; i
++)
1402 if (regnum
== i
|| regnum
== -1)
1403 regcache_raw_supply (regcache
, i
, regs
+ offset
);
1408 if ((regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
) || regnum
== -1)
1410 /* Not all of the register set variants include Locals and
1411 Inputs. For those that don't, we read them off the stack. */
1412 if (gregmap
->r_l0_offset
== -1)
1416 regcache_cooked_read_unsigned (regcache
, SPARC_SP_REGNUM
, &sp
);
1417 sparc_supply_rwindow (regcache
, sp
, regnum
);
1421 int offset
= gregmap
->r_l0_offset
;
1426 for (i
= SPARC_L0_REGNUM
; i
<= SPARC_I7_REGNUM
; i
++)
1428 if (regnum
== i
|| regnum
== -1)
1429 regcache_raw_supply (regcache
, i
, regs
+ offset
);
1437 sparc64_collect_gregset (const struct sparc_gregmap
*gregmap
,
1438 const struct regcache
*regcache
,
1439 int regnum
, void *gregs
)
1441 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1442 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1443 int sparc32
= (gdbarch_ptr_bit (gdbarch
) == 32);
1444 gdb_byte
*regs
= (gdb_byte
*) gregs
;
1449 if (regnum
== SPARC32_PSR_REGNUM
|| regnum
== -1)
1451 int offset
= gregmap
->r_tstate_offset
;
1452 ULONGEST tstate
, psr
;
1455 tstate
= extract_unsigned_integer (regs
+ offset
, 8, byte_order
);
1456 regcache_raw_collect (regcache
, SPARC32_PSR_REGNUM
, buf
);
1457 psr
= extract_unsigned_integer (buf
, 4, byte_order
);
1458 tstate
|= (psr
& PSR_ICC
) << 12;
1459 if ((psr
& (PSR_VERS
| PSR_IMPL
)) == PSR_V8PLUS
)
1460 tstate
|= (psr
& PSR_XCC
) << 20;
1461 store_unsigned_integer (buf
, 8, byte_order
, tstate
);
1462 memcpy (regs
+ offset
, buf
, 8);
1465 if (regnum
== SPARC32_PC_REGNUM
|| regnum
== -1)
1466 regcache_raw_collect (regcache
, SPARC32_PC_REGNUM
,
1467 regs
+ gregmap
->r_pc_offset
+ 4);
1469 if (regnum
== SPARC32_NPC_REGNUM
|| regnum
== -1)
1470 regcache_raw_collect (regcache
, SPARC32_NPC_REGNUM
,
1471 regs
+ gregmap
->r_npc_offset
+ 4);
1473 if (regnum
== SPARC32_Y_REGNUM
|| regnum
== -1)
1475 int offset
= gregmap
->r_y_offset
+ 8 - gregmap
->r_y_size
;
1476 regcache_raw_collect (regcache
, SPARC32_Y_REGNUM
, regs
+ offset
);
1481 if (regnum
== SPARC64_STATE_REGNUM
|| regnum
== -1)
1482 regcache_raw_collect (regcache
, SPARC64_STATE_REGNUM
,
1483 regs
+ gregmap
->r_tstate_offset
);
1485 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== -1)
1486 regcache_raw_collect (regcache
, SPARC64_PC_REGNUM
,
1487 regs
+ gregmap
->r_pc_offset
);
1489 if (regnum
== SPARC64_NPC_REGNUM
|| regnum
== -1)
1490 regcache_raw_collect (regcache
, SPARC64_NPC_REGNUM
,
1491 regs
+ gregmap
->r_npc_offset
);
1493 if (regnum
== SPARC64_Y_REGNUM
|| regnum
== -1)
1497 regcache_raw_collect (regcache
, SPARC64_Y_REGNUM
, buf
);
1498 memcpy (regs
+ gregmap
->r_y_offset
,
1499 buf
+ 8 - gregmap
->r_y_size
, gregmap
->r_y_size
);
1502 if ((regnum
== SPARC64_FPRS_REGNUM
|| regnum
== -1)
1503 && gregmap
->r_fprs_offset
!= -1)
1504 regcache_raw_collect (regcache
, SPARC64_FPRS_REGNUM
,
1505 regs
+ gregmap
->r_fprs_offset
);
1509 if ((regnum
>= SPARC_G1_REGNUM
&& regnum
<= SPARC_O7_REGNUM
) || regnum
== -1)
1511 int offset
= gregmap
->r_g1_offset
;
1516 /* %g0 is always zero. */
1517 for (i
= SPARC_G1_REGNUM
; i
<= SPARC_O7_REGNUM
; i
++)
1519 if (regnum
== i
|| regnum
== -1)
1520 regcache_raw_collect (regcache
, i
, regs
+ offset
);
1525 if ((regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
) || regnum
== -1)
1527 /* Not all of the register set variants include Locals and
1528 Inputs. For those that don't, we read them off the stack. */
1529 if (gregmap
->r_l0_offset
!= -1)
1531 int offset
= gregmap
->r_l0_offset
;
1536 for (i
= SPARC_L0_REGNUM
; i
<= SPARC_I7_REGNUM
; i
++)
1538 if (regnum
== i
|| regnum
== -1)
1539 regcache_raw_collect (regcache
, i
, regs
+ offset
);
1547 sparc64_supply_fpregset (const struct sparc_fpregmap
*fpregmap
,
1548 struct regcache
*regcache
,
1549 int regnum
, const void *fpregs
)
1551 int sparc32
= (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32);
1552 const gdb_byte
*regs
= (const gdb_byte
*) fpregs
;
1555 for (i
= 0; i
< 32; i
++)
1557 if (regnum
== (SPARC_F0_REGNUM
+ i
) || regnum
== -1)
1558 regcache_raw_supply (regcache
, SPARC_F0_REGNUM
+ i
,
1559 regs
+ fpregmap
->r_f0_offset
+ (i
* 4));
1564 if (regnum
== SPARC32_FSR_REGNUM
|| regnum
== -1)
1565 regcache_raw_supply (regcache
, SPARC32_FSR_REGNUM
,
1566 regs
+ fpregmap
->r_fsr_offset
);
1570 for (i
= 0; i
< 16; i
++)
1572 if (regnum
== (SPARC64_F32_REGNUM
+ i
) || regnum
== -1)
1573 regcache_raw_supply (regcache
, SPARC64_F32_REGNUM
+ i
,
1574 (regs
+ fpregmap
->r_f0_offset
1575 + (32 * 4) + (i
* 8)));
1578 if (regnum
== SPARC64_FSR_REGNUM
|| regnum
== -1)
1579 regcache_raw_supply (regcache
, SPARC64_FSR_REGNUM
,
1580 regs
+ fpregmap
->r_fsr_offset
);
1585 sparc64_collect_fpregset (const struct sparc_fpregmap
*fpregmap
,
1586 const struct regcache
*regcache
,
1587 int regnum
, void *fpregs
)
1589 int sparc32
= (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32);
1590 gdb_byte
*regs
= (gdb_byte
*) fpregs
;
1593 for (i
= 0; i
< 32; i
++)
1595 if (regnum
== (SPARC_F0_REGNUM
+ i
) || regnum
== -1)
1596 regcache_raw_collect (regcache
, SPARC_F0_REGNUM
+ i
,
1597 regs
+ fpregmap
->r_f0_offset
+ (i
* 4));
1602 if (regnum
== SPARC32_FSR_REGNUM
|| regnum
== -1)
1603 regcache_raw_collect (regcache
, SPARC32_FSR_REGNUM
,
1604 regs
+ fpregmap
->r_fsr_offset
);
1608 for (i
= 0; i
< 16; i
++)
1610 if (regnum
== (SPARC64_F32_REGNUM
+ i
) || regnum
== -1)
1611 regcache_raw_collect (regcache
, SPARC64_F32_REGNUM
+ i
,
1612 (regs
+ fpregmap
->r_f0_offset
1613 + (32 * 4) + (i
* 8)));
1616 if (regnum
== SPARC64_FSR_REGNUM
|| regnum
== -1)
1617 regcache_raw_collect (regcache
, SPARC64_FSR_REGNUM
,
1618 regs
+ fpregmap
->r_fsr_offset
);
1622 const struct sparc_fpregmap sparc64_bsd_fpregmap
=