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 (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
674 struct type
*t
= check_typedef (TYPE_TARGET_TYPE (type
));
676 if (sparc64_floating_p (t
))
679 if (sparc64_floating_p (type
) && TYPE_LENGTH (type
) == 16)
682 if (sparc64_structure_or_union_p (type
))
686 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
688 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
690 if (sparc64_16_byte_align_p (subtype
))
698 /* Store floating fields of element ELEMENT of an "parameter array"
699 that has type TYPE and is stored at BITPOS in VALBUF in the
700 apropriate registers of REGCACHE. This function can be called
701 recursively and therefore handles floating types in addition to
705 sparc64_store_floating_fields (struct regcache
*regcache
, struct type
*type
,
706 const gdb_byte
*valbuf
, int element
, int bitpos
)
708 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
709 int len
= TYPE_LENGTH (type
);
711 gdb_assert (element
< 16);
713 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
716 int regnum
= SPARC_F0_REGNUM
+ element
* 2 + bitpos
/ 32;
718 valbuf
+= bitpos
/ 8;
721 memset (buf
, 0, 8 - len
);
722 memcpy (buf
+ 8 - len
, valbuf
, len
);
726 for (int n
= 0; n
< (len
+ 3) / 4; n
++)
727 regcache_cooked_write (regcache
, regnum
+ n
, valbuf
+ n
* 4);
729 else if (sparc64_floating_p (type
)
730 || (sparc64_complex_floating_p (type
) && len
<= 16))
736 gdb_assert (bitpos
== 0);
737 gdb_assert ((element
% 2) == 0);
739 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_Q0_REGNUM
+ element
/ 2;
740 regcache_cooked_write (regcache
, regnum
, valbuf
);
744 gdb_assert (bitpos
== 0 || bitpos
== 64);
746 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_D0_REGNUM
747 + element
+ bitpos
/ 64;
748 regcache_cooked_write (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
752 gdb_assert (len
== 4);
753 gdb_assert (bitpos
% 32 == 0 && bitpos
>= 0 && bitpos
< 128);
755 regnum
= SPARC_F0_REGNUM
+ element
* 2 + bitpos
/ 32;
756 regcache_cooked_write (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
759 else if (sparc64_structure_or_union_p (type
))
763 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
765 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
766 int subpos
= bitpos
+ TYPE_FIELD_BITPOS (type
, i
);
768 sparc64_store_floating_fields (regcache
, subtype
, valbuf
,
772 /* GCC has an interesting bug. If TYPE is a structure that has
773 a single `float' member, GCC doesn't treat it as a structure
774 at all, but rather as an ordinary `float' argument. This
775 argument will be stored in %f1, as required by the psABI.
776 However, as a member of a structure the psABI requires it to
777 be stored in %f0. This bug is present in GCC 3.3.2, but
778 probably in older releases to. To appease GCC, if a
779 structure has only a single `float' member, we store its
780 value in %f1 too (we already have stored in %f0). */
781 if (TYPE_NFIELDS (type
) == 1)
783 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
785 if (sparc64_floating_p (subtype
) && TYPE_LENGTH (subtype
) == 4)
786 regcache_cooked_write (regcache
, SPARC_F1_REGNUM
, valbuf
);
791 /* Fetch floating fields from a variable of type TYPE from the
792 appropriate registers for BITPOS in REGCACHE and store it at BITPOS
793 in VALBUF. This function can be called recursively and therefore
794 handles floating types in addition to structures. */
797 sparc64_extract_floating_fields (struct regcache
*regcache
, struct type
*type
,
798 gdb_byte
*valbuf
, int bitpos
)
800 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
802 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
804 int len
= TYPE_LENGTH (type
);
805 int regnum
= SPARC_F0_REGNUM
+ bitpos
/ 32;
807 valbuf
+= bitpos
/ 8;
811 regcache_cooked_read (regcache
, regnum
, buf
);
812 memcpy (valbuf
, buf
+ 4 - len
, len
);
815 for (int i
= 0; i
< (len
+ 3) / 4; i
++)
816 regcache_cooked_read (regcache
, regnum
+ i
, valbuf
+ i
* 4);
818 else if (sparc64_floating_p (type
))
820 int len
= TYPE_LENGTH (type
);
825 gdb_assert (bitpos
== 0 || bitpos
== 128);
827 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_Q0_REGNUM
829 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
833 gdb_assert (bitpos
% 64 == 0 && bitpos
>= 0 && bitpos
< 256);
835 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_D0_REGNUM
+ bitpos
/ 64;
836 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
840 gdb_assert (len
== 4);
841 gdb_assert (bitpos
% 32 == 0 && bitpos
>= 0 && bitpos
< 256);
843 regnum
= SPARC_F0_REGNUM
+ bitpos
/ 32;
844 regcache_cooked_read (regcache
, regnum
, valbuf
+ (bitpos
/ 8));
847 else if (sparc64_structure_or_union_p (type
))
851 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
853 struct type
*subtype
= check_typedef (TYPE_FIELD_TYPE (type
, i
));
854 int subpos
= bitpos
+ TYPE_FIELD_BITPOS (type
, i
);
856 sparc64_extract_floating_fields (regcache
, subtype
, valbuf
, subpos
);
861 /* Store the NARGS arguments ARGS and STRUCT_ADDR (if STRUCT_RETURN is
862 non-zero) in REGCACHE and on the stack (starting from address SP). */
865 sparc64_store_arguments (struct regcache
*regcache
, int nargs
,
866 struct value
**args
, CORE_ADDR sp
,
867 int struct_return
, CORE_ADDR struct_addr
)
869 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
870 /* Number of extended words in the "parameter array". */
871 int num_elements
= 0;
875 /* Take BIAS into account. */
878 /* First we calculate the number of extended words in the "parameter
879 array". While doing so we also convert some of the arguments. */
884 for (i
= 0; i
< nargs
; i
++)
886 struct type
*type
= value_type (args
[i
]);
887 int len
= TYPE_LENGTH (type
);
889 if (sparc64_structure_or_union_p (type
)
890 || (sparc64_complex_floating_p (type
) && len
== 32))
892 /* Structure or Union arguments. */
895 if (num_elements
% 2 && sparc64_16_byte_align_p (type
))
897 num_elements
+= ((len
+ 7) / 8);
901 /* The psABI says that "Structures or unions larger than
902 sixteen bytes are copied by the caller and passed
903 indirectly; the caller will pass the address of a
904 correctly aligned structure value. This sixty-four
905 bit address will occupy one word in the parameter
906 array, and may be promoted to an %o register like any
907 other pointer value." Allocate memory for these
908 values on the stack. */
911 /* Use 16-byte alignment for these values. That's
912 always correct, and wasting a few bytes shouldn't be
916 write_memory (sp
, value_contents (args
[i
]), len
);
917 args
[i
] = value_from_pointer (lookup_pointer_type (type
), sp
);
921 else if (sparc64_floating_p (type
) || sparc64_complex_floating_p (type
))
923 /* Floating arguments. */
926 /* The psABI says that "Each quad-precision parameter
927 value will be assigned to two extended words in the
931 /* The psABI says that "Long doubles must be
932 quad-aligned, and thus a hole might be introduced
933 into the parameter array to force alignment." Skip
934 an element if necessary. */
935 if ((num_elements
% 2) && sparc64_16_byte_align_p (type
))
943 /* Integral and pointer arguments. */
944 gdb_assert (sparc64_integral_or_pointer_p (type
));
946 /* The psABI says that "Each argument value of integral type
947 smaller than an extended word will be widened by the
948 caller to an extended word according to the signed-ness
949 of the argument type." */
951 args
[i
] = value_cast (builtin_type (gdbarch
)->builtin_int64
,
957 /* Allocate the "parameter array". */
958 sp
-= num_elements
* 8;
960 /* The psABI says that "Every stack frame must be 16-byte aligned." */
963 /* Now we store the arguments in to the "paramater array". Some
964 Integer or Pointer arguments and Structure or Union arguments
965 will be passed in %o registers. Some Floating arguments and
966 floating members of structures are passed in floating-point
967 registers. However, for functions with variable arguments,
968 floating arguments are stored in an %0 register, and for
969 functions without a prototype floating arguments are stored in
970 both a floating-point and an %o registers, or a floating-point
971 register and memory. To simplify the logic here we always pass
972 arguments in memory, an %o register, and a floating-point
973 register if appropriate. This should be no problem since the
974 contents of any unused memory or registers in the "parameter
975 array" are undefined. */
979 regcache_cooked_write_unsigned (regcache
, SPARC_O0_REGNUM
, struct_addr
);
983 for (i
= 0; i
< nargs
; i
++)
985 const gdb_byte
*valbuf
= value_contents (args
[i
]);
986 struct type
*type
= value_type (args
[i
]);
987 int len
= TYPE_LENGTH (type
);
991 if (sparc64_structure_or_union_p (type
)
992 || (sparc64_complex_floating_p (type
) && len
== 32))
994 /* Structure, Union or long double Complex arguments. */
995 gdb_assert (len
<= 16);
996 memset (buf
, 0, sizeof (buf
));
997 memcpy (buf
, valbuf
, len
);
1000 if (element
% 2 && sparc64_16_byte_align_p (type
))
1005 regnum
= SPARC_O0_REGNUM
+ element
;
1006 if (len
> 8 && element
< 5)
1007 regcache_cooked_write (regcache
, regnum
+ 1, valbuf
+ 8);
1011 sparc64_store_floating_fields (regcache
, type
, valbuf
, element
, 0);
1013 else if (sparc64_complex_floating_p (type
))
1015 /* Float Complex or double Complex arguments. */
1018 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_D0_REGNUM
+ element
;
1022 if (regnum
< gdbarch_num_regs (gdbarch
) + SPARC64_D30_REGNUM
)
1023 regcache_cooked_write (regcache
, regnum
+ 1, valbuf
+ 8);
1024 if (regnum
< gdbarch_num_regs (gdbarch
) + SPARC64_D10_REGNUM
)
1025 regcache_cooked_write (regcache
,
1026 SPARC_O0_REGNUM
+ element
+ 1,
1031 else if (sparc64_floating_p (type
))
1033 /* Floating arguments. */
1039 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_Q0_REGNUM
1045 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_D0_REGNUM
1050 /* The psABI says "Each single-precision parameter value
1051 will be assigned to one extended word in the
1052 parameter array, and right-justified within that
1053 word; the left half (even float register) is
1054 undefined." Even though the psABI says that "the
1055 left half is undefined", set it to zero here. */
1057 memcpy (buf
+ 4, valbuf
, 4);
1061 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_D0_REGNUM
1067 /* Integral and pointer arguments. */
1068 gdb_assert (len
== 8);
1070 regnum
= SPARC_O0_REGNUM
+ element
;
1075 regcache_cooked_write (regcache
, regnum
, valbuf
);
1077 /* If we're storing the value in a floating-point register,
1078 also store it in the corresponding %0 register(s). */
1079 if (regnum
>= gdbarch_num_regs (gdbarch
))
1081 regnum
-= gdbarch_num_regs (gdbarch
);
1083 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D10_REGNUM
)
1085 gdb_assert (element
< 6);
1086 regnum
= SPARC_O0_REGNUM
+ element
;
1087 regcache_cooked_write (regcache
, regnum
, valbuf
);
1089 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q8_REGNUM
)
1091 gdb_assert (element
< 5);
1092 regnum
= SPARC_O0_REGNUM
+ element
;
1093 regcache_cooked_write (regcache
, regnum
, valbuf
);
1094 regcache_cooked_write (regcache
, regnum
+ 1, valbuf
+ 8);
1099 /* Always store the argument in memory. */
1100 write_memory (sp
+ element
* 8, valbuf
, len
);
1101 element
+= ((len
+ 7) / 8);
1104 gdb_assert (element
== num_elements
);
1106 /* Take BIAS into account. */
1112 sparc64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR address
)
1114 /* The ABI requires 16-byte alignment. */
1115 return address
& ~0xf;
1119 sparc64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
1120 struct regcache
*regcache
, CORE_ADDR bp_addr
,
1121 int nargs
, struct value
**args
, CORE_ADDR sp
,
1122 int struct_return
, CORE_ADDR struct_addr
)
1124 /* Set return address. */
1125 regcache_cooked_write_unsigned (regcache
, SPARC_O7_REGNUM
, bp_addr
- 8);
1127 /* Set up function arguments. */
1128 sp
= sparc64_store_arguments (regcache
, nargs
, args
, sp
,
1129 struct_return
, struct_addr
);
1131 /* Allocate the register save area. */
1134 /* Stack should be 16-byte aligned at this point. */
1135 gdb_assert ((sp
+ BIAS
) % 16 == 0);
1137 /* Finally, update the stack pointer. */
1138 regcache_cooked_write_unsigned (regcache
, SPARC_SP_REGNUM
, sp
);
1144 /* Extract from an array REGBUF containing the (raw) register state, a
1145 function return value of TYPE, and copy that into VALBUF. */
1148 sparc64_extract_return_value (struct type
*type
, struct regcache
*regcache
,
1151 int len
= TYPE_LENGTH (type
);
1155 if (sparc64_structure_or_union_p (type
))
1157 /* Structure or Union return values. */
1158 gdb_assert (len
<= 32);
1160 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1161 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1162 if (TYPE_CODE (type
) != TYPE_CODE_UNION
)
1163 sparc64_extract_floating_fields (regcache
, type
, buf
, 0);
1164 memcpy (valbuf
, buf
, len
);
1166 else if (sparc64_floating_p (type
) || sparc64_complex_floating_p (type
))
1168 /* Floating return values. */
1169 for (i
= 0; i
< len
/ 4; i
++)
1170 regcache_cooked_read (regcache
, SPARC_F0_REGNUM
+ i
, buf
+ i
* 4);
1171 memcpy (valbuf
, buf
, len
);
1173 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1175 /* Small arrays are returned the same way as small structures. */
1176 gdb_assert (len
<= 32);
1178 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1179 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1180 memcpy (valbuf
, buf
, len
);
1184 /* Integral and pointer return values. */
1185 gdb_assert (sparc64_integral_or_pointer_p (type
));
1187 /* Just stripping off any unused bytes should preserve the
1188 signed-ness just fine. */
1189 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
, buf
);
1190 memcpy (valbuf
, buf
+ 8 - len
, len
);
1194 /* Write into the appropriate registers a function return value stored
1195 in VALBUF of type TYPE. */
1198 sparc64_store_return_value (struct type
*type
, struct regcache
*regcache
,
1199 const gdb_byte
*valbuf
)
1201 int len
= TYPE_LENGTH (type
);
1205 if (sparc64_structure_or_union_p (type
))
1207 /* Structure or Union return values. */
1208 gdb_assert (len
<= 32);
1210 /* Simplify matters by storing the complete value (including
1211 floating members) into %o0 and %o1. Floating members are
1212 also store in the appropriate floating-point registers. */
1213 memset (buf
, 0, sizeof (buf
));
1214 memcpy (buf
, valbuf
, len
);
1215 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1216 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1217 if (TYPE_CODE (type
) != TYPE_CODE_UNION
)
1218 sparc64_store_floating_fields (regcache
, type
, buf
, 0, 0);
1220 else if (sparc64_floating_p (type
) || sparc64_complex_floating_p (type
))
1222 /* Floating return values. */
1223 memcpy (buf
, valbuf
, len
);
1224 for (i
= 0; i
< len
/ 4; i
++)
1225 regcache_cooked_write (regcache
, SPARC_F0_REGNUM
+ i
, buf
+ i
* 4);
1227 else if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1229 /* Small arrays are returned the same way as small structures. */
1230 gdb_assert (len
<= 32);
1232 memset (buf
, 0, sizeof (buf
));
1233 memcpy (buf
, valbuf
, len
);
1234 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1235 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1239 /* Integral and pointer return values. */
1240 gdb_assert (sparc64_integral_or_pointer_p (type
));
1242 /* ??? Do we need to do any sign-extension here? */
1244 memcpy (buf
+ 8 - len
, valbuf
, len
);
1245 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
, buf
);
1249 static enum return_value_convention
1250 sparc64_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
1251 struct type
*type
, struct regcache
*regcache
,
1252 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1254 if (TYPE_LENGTH (type
) > 32)
1255 return RETURN_VALUE_STRUCT_CONVENTION
;
1258 sparc64_extract_return_value (type
, regcache
, readbuf
);
1260 sparc64_store_return_value (type
, regcache
, writebuf
);
1262 return RETURN_VALUE_REGISTER_CONVENTION
;
1267 sparc64_dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
1268 struct dwarf2_frame_state_reg
*reg
,
1269 struct frame_info
*this_frame
)
1273 case SPARC_G0_REGNUM
:
1274 /* Since %g0 is always zero, there is no point in saving it, and
1275 people will be inclined omit it from the CFI. Make sure we
1276 don't warn about that. */
1277 reg
->how
= DWARF2_FRAME_REG_SAME_VALUE
;
1279 case SPARC_SP_REGNUM
:
1280 reg
->how
= DWARF2_FRAME_REG_CFA
;
1282 case SPARC64_PC_REGNUM
:
1283 reg
->how
= DWARF2_FRAME_REG_RA_OFFSET
;
1284 reg
->loc
.offset
= 8;
1286 case SPARC64_NPC_REGNUM
:
1287 reg
->how
= DWARF2_FRAME_REG_RA_OFFSET
;
1288 reg
->loc
.offset
= 12;
1294 sparc64_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1296 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1298 tdep
->pc_regnum
= SPARC64_PC_REGNUM
;
1299 tdep
->npc_regnum
= SPARC64_NPC_REGNUM
;
1300 tdep
->fpu_register_names
= sparc64_fpu_register_names
;
1301 tdep
->fpu_registers_num
= ARRAY_SIZE (sparc64_fpu_register_names
);
1302 tdep
->cp0_register_names
= sparc64_cp0_register_names
;
1303 tdep
->cp0_registers_num
= ARRAY_SIZE (sparc64_cp0_register_names
);
1305 /* This is what all the fuss is about. */
1306 set_gdbarch_long_bit (gdbarch
, 64);
1307 set_gdbarch_long_long_bit (gdbarch
, 64);
1308 set_gdbarch_ptr_bit (gdbarch
, 64);
1310 set_gdbarch_wchar_bit (gdbarch
, 16);
1311 set_gdbarch_wchar_signed (gdbarch
, 0);
1313 set_gdbarch_num_regs (gdbarch
, SPARC64_NUM_REGS
);
1314 set_gdbarch_register_name (gdbarch
, sparc64_register_name
);
1315 set_gdbarch_register_type (gdbarch
, sparc64_register_type
);
1316 set_gdbarch_num_pseudo_regs (gdbarch
, SPARC64_NUM_PSEUDO_REGS
);
1317 set_tdesc_pseudo_register_name (gdbarch
, sparc64_pseudo_register_name
);
1318 set_tdesc_pseudo_register_type (gdbarch
, sparc64_pseudo_register_type
);
1319 set_gdbarch_pseudo_register_read (gdbarch
, sparc64_pseudo_register_read
);
1320 set_gdbarch_pseudo_register_write (gdbarch
, sparc64_pseudo_register_write
);
1322 /* Register numbers of various important registers. */
1323 set_gdbarch_pc_regnum (gdbarch
, SPARC64_PC_REGNUM
); /* %pc */
1325 /* Call dummy code. */
1326 set_gdbarch_frame_align (gdbarch
, sparc64_frame_align
);
1327 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1328 set_gdbarch_push_dummy_code (gdbarch
, NULL
);
1329 set_gdbarch_push_dummy_call (gdbarch
, sparc64_push_dummy_call
);
1331 set_gdbarch_return_value (gdbarch
, sparc64_return_value
);
1332 set_gdbarch_stabs_argument_has_addr
1333 (gdbarch
, default_stabs_argument_has_addr
);
1335 set_gdbarch_skip_prologue (gdbarch
, sparc64_skip_prologue
);
1336 set_gdbarch_stack_frame_destroyed_p (gdbarch
, sparc_stack_frame_destroyed_p
);
1338 /* Hook in the DWARF CFI frame unwinder. */
1339 dwarf2_frame_set_init_reg (gdbarch
, sparc64_dwarf2_frame_init_reg
);
1340 /* FIXME: kettenis/20050423: Don't enable the unwinder until the
1341 StackGhost issues have been resolved. */
1343 frame_unwind_append_unwinder (gdbarch
, &sparc64_frame_unwind
);
1344 frame_base_set_default (gdbarch
, &sparc64_frame_base
);
1348 /* Helper functions for dealing with register sets. */
1350 #define TSTATE_CWP 0x000000000000001fULL
1351 #define TSTATE_ICC 0x0000000f00000000ULL
1352 #define TSTATE_XCC 0x000000f000000000ULL
1354 #define PSR_S 0x00000080
1355 #define PSR_ICC 0x00f00000
1356 #define PSR_VERS 0x0f000000
1357 #define PSR_IMPL 0xf0000000
1358 #define PSR_V8PLUS 0xff000000
1359 #define PSR_XCC 0x000f0000
1362 sparc64_supply_gregset (const struct sparc_gregmap
*gregmap
,
1363 struct regcache
*regcache
,
1364 int regnum
, const void *gregs
)
1366 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1367 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1368 int sparc32
= (gdbarch_ptr_bit (gdbarch
) == 32);
1369 const gdb_byte
*regs
= (const gdb_byte
*) gregs
;
1370 gdb_byte zero
[8] = { 0 };
1375 if (regnum
== SPARC32_PSR_REGNUM
|| regnum
== -1)
1377 int offset
= gregmap
->r_tstate_offset
;
1378 ULONGEST tstate
, psr
;
1381 tstate
= extract_unsigned_integer (regs
+ offset
, 8, byte_order
);
1382 psr
= ((tstate
& TSTATE_CWP
) | PSR_S
| ((tstate
& TSTATE_ICC
) >> 12)
1383 | ((tstate
& TSTATE_XCC
) >> 20) | PSR_V8PLUS
);
1384 store_unsigned_integer (buf
, 4, byte_order
, psr
);
1385 regcache_raw_supply (regcache
, SPARC32_PSR_REGNUM
, buf
);
1388 if (regnum
== SPARC32_PC_REGNUM
|| regnum
== -1)
1389 regcache_raw_supply (regcache
, SPARC32_PC_REGNUM
,
1390 regs
+ gregmap
->r_pc_offset
+ 4);
1392 if (regnum
== SPARC32_NPC_REGNUM
|| regnum
== -1)
1393 regcache_raw_supply (regcache
, SPARC32_NPC_REGNUM
,
1394 regs
+ gregmap
->r_npc_offset
+ 4);
1396 if (regnum
== SPARC32_Y_REGNUM
|| regnum
== -1)
1398 int offset
= gregmap
->r_y_offset
+ 8 - gregmap
->r_y_size
;
1399 regcache_raw_supply (regcache
, SPARC32_Y_REGNUM
, regs
+ offset
);
1404 if (regnum
== SPARC64_STATE_REGNUM
|| regnum
== -1)
1405 regcache_raw_supply (regcache
, SPARC64_STATE_REGNUM
,
1406 regs
+ gregmap
->r_tstate_offset
);
1408 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== -1)
1409 regcache_raw_supply (regcache
, SPARC64_PC_REGNUM
,
1410 regs
+ gregmap
->r_pc_offset
);
1412 if (regnum
== SPARC64_NPC_REGNUM
|| regnum
== -1)
1413 regcache_raw_supply (regcache
, SPARC64_NPC_REGNUM
,
1414 regs
+ gregmap
->r_npc_offset
);
1416 if (regnum
== SPARC64_Y_REGNUM
|| regnum
== -1)
1421 memcpy (buf
+ 8 - gregmap
->r_y_size
,
1422 regs
+ gregmap
->r_y_offset
, gregmap
->r_y_size
);
1423 regcache_raw_supply (regcache
, SPARC64_Y_REGNUM
, buf
);
1426 if ((regnum
== SPARC64_FPRS_REGNUM
|| regnum
== -1)
1427 && gregmap
->r_fprs_offset
!= -1)
1428 regcache_raw_supply (regcache
, SPARC64_FPRS_REGNUM
,
1429 regs
+ gregmap
->r_fprs_offset
);
1432 if (regnum
== SPARC_G0_REGNUM
|| regnum
== -1)
1433 regcache_raw_supply (regcache
, SPARC_G0_REGNUM
, &zero
);
1435 if ((regnum
>= SPARC_G1_REGNUM
&& regnum
<= SPARC_O7_REGNUM
) || regnum
== -1)
1437 int offset
= gregmap
->r_g1_offset
;
1442 for (i
= SPARC_G1_REGNUM
; i
<= SPARC_O7_REGNUM
; i
++)
1444 if (regnum
== i
|| regnum
== -1)
1445 regcache_raw_supply (regcache
, i
, regs
+ offset
);
1450 if ((regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
) || regnum
== -1)
1452 /* Not all of the register set variants include Locals and
1453 Inputs. For those that don't, we read them off the stack. */
1454 if (gregmap
->r_l0_offset
== -1)
1458 regcache_cooked_read_unsigned (regcache
, SPARC_SP_REGNUM
, &sp
);
1459 sparc_supply_rwindow (regcache
, sp
, regnum
);
1463 int offset
= gregmap
->r_l0_offset
;
1468 for (i
= SPARC_L0_REGNUM
; i
<= SPARC_I7_REGNUM
; i
++)
1470 if (regnum
== i
|| regnum
== -1)
1471 regcache_raw_supply (regcache
, i
, regs
+ offset
);
1479 sparc64_collect_gregset (const struct sparc_gregmap
*gregmap
,
1480 const struct regcache
*regcache
,
1481 int regnum
, void *gregs
)
1483 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1484 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1485 int sparc32
= (gdbarch_ptr_bit (gdbarch
) == 32);
1486 gdb_byte
*regs
= (gdb_byte
*) gregs
;
1491 if (regnum
== SPARC32_PSR_REGNUM
|| regnum
== -1)
1493 int offset
= gregmap
->r_tstate_offset
;
1494 ULONGEST tstate
, psr
;
1497 tstate
= extract_unsigned_integer (regs
+ offset
, 8, byte_order
);
1498 regcache_raw_collect (regcache
, SPARC32_PSR_REGNUM
, buf
);
1499 psr
= extract_unsigned_integer (buf
, 4, byte_order
);
1500 tstate
|= (psr
& PSR_ICC
) << 12;
1501 if ((psr
& (PSR_VERS
| PSR_IMPL
)) == PSR_V8PLUS
)
1502 tstate
|= (psr
& PSR_XCC
) << 20;
1503 store_unsigned_integer (buf
, 8, byte_order
, tstate
);
1504 memcpy (regs
+ offset
, buf
, 8);
1507 if (regnum
== SPARC32_PC_REGNUM
|| regnum
== -1)
1508 regcache_raw_collect (regcache
, SPARC32_PC_REGNUM
,
1509 regs
+ gregmap
->r_pc_offset
+ 4);
1511 if (regnum
== SPARC32_NPC_REGNUM
|| regnum
== -1)
1512 regcache_raw_collect (regcache
, SPARC32_NPC_REGNUM
,
1513 regs
+ gregmap
->r_npc_offset
+ 4);
1515 if (regnum
== SPARC32_Y_REGNUM
|| regnum
== -1)
1517 int offset
= gregmap
->r_y_offset
+ 8 - gregmap
->r_y_size
;
1518 regcache_raw_collect (regcache
, SPARC32_Y_REGNUM
, regs
+ offset
);
1523 if (regnum
== SPARC64_STATE_REGNUM
|| regnum
== -1)
1524 regcache_raw_collect (regcache
, SPARC64_STATE_REGNUM
,
1525 regs
+ gregmap
->r_tstate_offset
);
1527 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== -1)
1528 regcache_raw_collect (regcache
, SPARC64_PC_REGNUM
,
1529 regs
+ gregmap
->r_pc_offset
);
1531 if (regnum
== SPARC64_NPC_REGNUM
|| regnum
== -1)
1532 regcache_raw_collect (regcache
, SPARC64_NPC_REGNUM
,
1533 regs
+ gregmap
->r_npc_offset
);
1535 if (regnum
== SPARC64_Y_REGNUM
|| regnum
== -1)
1539 regcache_raw_collect (regcache
, SPARC64_Y_REGNUM
, buf
);
1540 memcpy (regs
+ gregmap
->r_y_offset
,
1541 buf
+ 8 - gregmap
->r_y_size
, gregmap
->r_y_size
);
1544 if ((regnum
== SPARC64_FPRS_REGNUM
|| regnum
== -1)
1545 && gregmap
->r_fprs_offset
!= -1)
1546 regcache_raw_collect (regcache
, SPARC64_FPRS_REGNUM
,
1547 regs
+ gregmap
->r_fprs_offset
);
1551 if ((regnum
>= SPARC_G1_REGNUM
&& regnum
<= SPARC_O7_REGNUM
) || regnum
== -1)
1553 int offset
= gregmap
->r_g1_offset
;
1558 /* %g0 is always zero. */
1559 for (i
= SPARC_G1_REGNUM
; i
<= SPARC_O7_REGNUM
; i
++)
1561 if (regnum
== i
|| regnum
== -1)
1562 regcache_raw_collect (regcache
, i
, regs
+ offset
);
1567 if ((regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
) || regnum
== -1)
1569 /* Not all of the register set variants include Locals and
1570 Inputs. For those that don't, we read them off the stack. */
1571 if (gregmap
->r_l0_offset
!= -1)
1573 int offset
= gregmap
->r_l0_offset
;
1578 for (i
= SPARC_L0_REGNUM
; i
<= SPARC_I7_REGNUM
; i
++)
1580 if (regnum
== i
|| regnum
== -1)
1581 regcache_raw_collect (regcache
, i
, regs
+ offset
);
1589 sparc64_supply_fpregset (const struct sparc_fpregmap
*fpregmap
,
1590 struct regcache
*regcache
,
1591 int regnum
, const void *fpregs
)
1593 int sparc32
= (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32);
1594 const gdb_byte
*regs
= (const gdb_byte
*) fpregs
;
1597 for (i
= 0; i
< 32; i
++)
1599 if (regnum
== (SPARC_F0_REGNUM
+ i
) || regnum
== -1)
1600 regcache_raw_supply (regcache
, SPARC_F0_REGNUM
+ i
,
1601 regs
+ fpregmap
->r_f0_offset
+ (i
* 4));
1606 if (regnum
== SPARC32_FSR_REGNUM
|| regnum
== -1)
1607 regcache_raw_supply (regcache
, SPARC32_FSR_REGNUM
,
1608 regs
+ fpregmap
->r_fsr_offset
);
1612 for (i
= 0; i
< 16; i
++)
1614 if (regnum
== (SPARC64_F32_REGNUM
+ i
) || regnum
== -1)
1615 regcache_raw_supply (regcache
, SPARC64_F32_REGNUM
+ i
,
1616 (regs
+ fpregmap
->r_f0_offset
1617 + (32 * 4) + (i
* 8)));
1620 if (regnum
== SPARC64_FSR_REGNUM
|| regnum
== -1)
1621 regcache_raw_supply (regcache
, SPARC64_FSR_REGNUM
,
1622 regs
+ fpregmap
->r_fsr_offset
);
1627 sparc64_collect_fpregset (const struct sparc_fpregmap
*fpregmap
,
1628 const struct regcache
*regcache
,
1629 int regnum
, void *fpregs
)
1631 int sparc32
= (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32);
1632 gdb_byte
*regs
= (gdb_byte
*) fpregs
;
1635 for (i
= 0; i
< 32; i
++)
1637 if (regnum
== (SPARC_F0_REGNUM
+ i
) || regnum
== -1)
1638 regcache_raw_collect (regcache
, SPARC_F0_REGNUM
+ i
,
1639 regs
+ fpregmap
->r_f0_offset
+ (i
* 4));
1644 if (regnum
== SPARC32_FSR_REGNUM
|| regnum
== -1)
1645 regcache_raw_collect (regcache
, SPARC32_FSR_REGNUM
,
1646 regs
+ fpregmap
->r_fsr_offset
);
1650 for (i
= 0; i
< 16; i
++)
1652 if (regnum
== (SPARC64_F32_REGNUM
+ i
) || regnum
== -1)
1653 regcache_raw_collect (regcache
, SPARC64_F32_REGNUM
+ i
,
1654 (regs
+ fpregmap
->r_f0_offset
1655 + (32 * 4) + (i
* 8)));
1658 if (regnum
== SPARC64_FSR_REGNUM
|| regnum
== -1)
1659 regcache_raw_collect (regcache
, SPARC64_FSR_REGNUM
,
1660 regs
+ fpregmap
->r_fsr_offset
);
1664 const struct sparc_fpregmap sparc64_bsd_fpregmap
=