1 /* Target-dependent code for UltraSPARC.
3 Copyright (C) 2003-2023 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"
24 #include "frame-base.h"
25 #include "frame-unwind.h"
33 #include "target-descriptions.h"
36 #include "sparc64-tdep.h"
37 #include <forward_list>
39 /* This file implements the SPARC 64-bit ABI as defined by the
40 section "Low-Level System Information" of the SPARC Compliance
41 Definition (SCD) 2.4.1, which is the 64-bit System V psABI for
44 /* Please use the sparc32_-prefix for 32-bit specific code, the
45 sparc64_-prefix for 64-bit specific code and the sparc_-prefix for
46 code can handle both. */
48 /* The M7 processor supports an Application Data Integrity (ADI) feature
49 that detects invalid data accesses. When software allocates memory and
50 enables ADI on the allocated memory, it chooses a 4-bit version number,
51 sets the version in the upper 4 bits of the 64-bit pointer to that data,
52 and stores the 4-bit version in every cacheline of the object. Hardware
53 saves the latter in spare bits in the cache and memory hierarchy. On each
54 load and store, the processor compares the upper 4 VA (virtual address) bits
55 to the cacheline's version. If there is a mismatch, the processor generates
56 a version mismatch trap which can be either precise or disrupting.
57 The trap is an error condition which the kernel delivers to the process
60 The upper 4 bits of the VA represent a version and are not part of the
61 true address. The processor clears these bits and sign extends bit 59
62 to generate the true address.
64 Note that 32-bit applications cannot use ADI. */
68 #include "cli/cli-utils.h"
72 #define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/9999/adi/lstatus")
74 /* ELF Auxiliary vectors */
76 #define AT_ADI_BLKSZ 34
79 #define AT_ADI_NBITS 35
81 #ifndef AT_ADI_UEONADI
82 #define AT_ADI_UEONADI 36
85 /* ADI command list. */
86 static struct cmd_list_element
*sparc64adilist
= NULL
;
88 /* ADI stat settings. */
91 /* The ADI block size. */
92 unsigned long blksize
;
94 /* Number of bits used for an ADI version tag which can be
95 used together with the shift value for an ADI version tag
96 to encode or extract the ADI version value in a pointer. */
99 /* The maximum ADI version tag value supported. */
102 /* ADI version tag file. */
105 /* ADI availability check has been done. */
106 bool checked_avail
= false;
108 /* ADI is available. */
109 bool is_avail
= false;
113 /* Per-process ADI stat info. */
115 struct sparc64_adi_info
117 sparc64_adi_info (pid_t pid_
)
121 /* The process identifier. */
125 adi_stat_t stat
= {};
129 static std::forward_list
<sparc64_adi_info
> adi_proc_list
;
132 /* Get ADI info for process PID, creating one if it doesn't exist. */
134 static sparc64_adi_info
*
135 get_adi_info_proc (pid_t pid
)
137 auto found
= std::find_if (adi_proc_list
.begin (), adi_proc_list
.end (),
138 [&pid
] (const sparc64_adi_info
&info
)
140 return info
.pid
== pid
;
143 if (found
== adi_proc_list
.end ())
145 adi_proc_list
.emplace_front (pid
);
146 return &adi_proc_list
.front ();
155 get_adi_info (pid_t pid
)
157 sparc64_adi_info
*proc
;
159 proc
= get_adi_info_proc (pid
);
163 /* Is called when GDB is no longer debugging process PID. It
164 deletes data structure that keeps track of the ADI stat. */
167 sparc64_forget_process (pid_t pid
)
169 fileio_error target_errno
;
171 for (auto pit
= adi_proc_list
.before_begin (),
172 it
= std::next (pit
);
173 it
!= adi_proc_list
.end ();
176 if ((*it
).pid
== pid
)
178 if ((*it
).stat
.tag_fd
> 0)
179 target_fileio_close ((*it
).stat
.tag_fd
, &target_errno
);
180 adi_proc_list
.erase_after (pit
);
189 /* Read attributes of a maps entry in /proc/[pid]/adi/maps. */
192 read_maps_entry (const char *line
,
193 ULONGEST
*addr
, ULONGEST
*endaddr
)
195 const char *p
= line
;
197 *addr
= strtoulst (p
, &p
, 16);
201 *endaddr
= strtoulst (p
, &p
, 16);
204 /* Check if ADI is available. */
209 pid_t pid
= inferior_ptid
.pid ();
210 sparc64_adi_info
*proc
= get_adi_info_proc (pid
);
213 if (proc
->stat
.checked_avail
)
214 return proc
->stat
.is_avail
;
216 proc
->stat
.checked_avail
= true;
217 if (target_auxv_search (AT_ADI_BLKSZ
, &value
) <= 0)
219 proc
->stat
.blksize
= value
;
220 target_auxv_search (AT_ADI_NBITS
, &value
);
221 proc
->stat
.nbits
= value
;
222 proc
->stat
.max_version
= (1 << proc
->stat
.nbits
) - 2;
223 proc
->stat
.is_avail
= true;
225 return proc
->stat
.is_avail
;
228 /* Normalize a versioned address - a VA with ADI bits (63-60) set. */
231 adi_normalize_address (CORE_ADDR addr
)
233 adi_stat_t ast
= get_adi_info (inferior_ptid
.pid ());
237 /* Clear upper bits. */
238 addr
&= ((uint64_t) -1) >> ast
.nbits
;
241 CORE_ADDR signbit
= (uint64_t) 1 << (64 - ast
.nbits
- 1);
242 return (addr
^ signbit
) - signbit
;
247 /* Align a normalized address - a VA with bit 59 sign extended into
251 adi_align_address (CORE_ADDR naddr
)
253 adi_stat_t ast
= get_adi_info (inferior_ptid
.pid ());
255 return (naddr
- (naddr
% ast
.blksize
)) / ast
.blksize
;
258 /* Convert a byte count to count at a ratio of 1:adi_blksz. */
261 adi_convert_byte_count (CORE_ADDR naddr
, int nbytes
, CORE_ADDR locl
)
263 adi_stat_t ast
= get_adi_info (inferior_ptid
.pid ());
265 return ((naddr
+ nbytes
+ ast
.blksize
- 1) / ast
.blksize
) - locl
;
268 /* The /proc/[pid]/adi/tags file, which allows gdb to get/set ADI
269 version in a target process, maps linearly to the address space
270 of the target process at a ratio of 1:adi_blksz.
272 A read (or write) at offset K in the file returns (or modifies)
273 the ADI version tag stored in the cacheline containing address
274 K * adi_blksz, encoded as 1 version tag per byte. The allowed
275 version tag values are between 0 and adi_stat.max_version. */
280 pid_t pid
= inferior_ptid
.pid ();
281 sparc64_adi_info
*proc
= get_adi_info_proc (pid
);
283 if (proc
->stat
.tag_fd
!= 0)
284 return proc
->stat
.tag_fd
;
286 char cl_name
[MAX_PROC_NAME_SIZE
];
287 snprintf (cl_name
, sizeof(cl_name
), "/proc/%ld/adi/tags", (long) pid
);
288 fileio_error target_errno
;
289 proc
->stat
.tag_fd
= target_fileio_open (NULL
, cl_name
, O_RDWR
|O_EXCL
,
290 false, 0, &target_errno
);
291 return proc
->stat
.tag_fd
;
294 /* Check if an address set is ADI enabled, using /proc/[pid]/adi/maps
295 which was exported by the kernel and contains the currently ADI
296 mapped memory regions and their access permissions. */
299 adi_is_addr_mapped (CORE_ADDR vaddr
, size_t cnt
)
301 char filename
[MAX_PROC_NAME_SIZE
];
304 pid_t pid
= inferior_ptid
.pid ();
305 snprintf (filename
, sizeof filename
, "/proc/%ld/adi/maps", (long) pid
);
306 gdb::unique_xmalloc_ptr
<char> data
307 = target_fileio_read_stralloc (NULL
, filename
);
310 adi_stat_t adi_stat
= get_adi_info (pid
);
312 for (char *line
= strtok_r (data
.get (), "\n", &saveptr
);
314 line
= strtok_r (NULL
, "\n", &saveptr
))
316 ULONGEST addr
, endaddr
;
318 read_maps_entry (line
, &addr
, &endaddr
);
320 while (((vaddr
+ i
) * adi_stat
.blksize
) >= addr
321 && ((vaddr
+ i
) * adi_stat
.blksize
) < endaddr
)
329 warning (_("unable to open /proc file '%s'"), filename
);
334 /* Read ADI version tag value for memory locations starting at "VADDR"
335 for "SIZE" number of bytes. */
338 adi_read_versions (CORE_ADDR vaddr
, size_t size
, gdb_byte
*tags
)
340 int fd
= adi_tag_fd ();
344 if (!adi_is_addr_mapped (vaddr
, size
))
346 adi_stat_t ast
= get_adi_info (inferior_ptid
.pid ());
347 error(_("Address at %s is not in ADI maps"),
348 paddress (target_gdbarch (), vaddr
* ast
.blksize
));
351 fileio_error target_errno
;
352 return target_fileio_pread (fd
, tags
, size
, vaddr
, &target_errno
);
355 /* Write ADI version tag for memory locations starting at "VADDR" for
356 "SIZE" number of bytes to "TAGS". */
359 adi_write_versions (CORE_ADDR vaddr
, size_t size
, unsigned char *tags
)
361 int fd
= adi_tag_fd ();
365 if (!adi_is_addr_mapped (vaddr
, size
))
367 adi_stat_t ast
= get_adi_info (inferior_ptid
.pid ());
368 error(_("Address at %s is not in ADI maps"),
369 paddress (target_gdbarch (), vaddr
* ast
.blksize
));
372 fileio_error target_errno
;
373 return target_fileio_pwrite (fd
, tags
, size
, vaddr
, &target_errno
);
376 /* Print ADI version tag value in "TAGS" for memory locations starting
377 at "VADDR" with number of "CNT". */
380 adi_print_versions (CORE_ADDR vaddr
, size_t cnt
, gdb_byte
*tags
)
383 const int maxelts
= 8; /* # of elements per line */
385 adi_stat_t adi_stat
= get_adi_info (inferior_ptid
.pid ());
391 paddress (target_gdbarch (), vaddr
* adi_stat
.blksize
));
392 for (int i
= maxelts
; i
> 0 && cnt
> 0; i
--, cnt
--)
394 if (tags
[v_idx
] == 0xff) /* no version tag */
397 gdb_printf ("%1X", tags
[v_idx
]);
408 do_examine (CORE_ADDR start
, int bcnt
)
410 CORE_ADDR vaddr
= adi_normalize_address (start
);
412 CORE_ADDR vstart
= adi_align_address (vaddr
);
413 int cnt
= adi_convert_byte_count (vaddr
, bcnt
, vstart
);
414 gdb::def_vector
<gdb_byte
> buf (cnt
);
415 int read_cnt
= adi_read_versions (vstart
, cnt
, buf
.data ());
417 error (_("No ADI information"));
418 else if (read_cnt
< cnt
)
419 error(_("No ADI information at %s"), paddress (target_gdbarch (), vaddr
));
421 adi_print_versions (vstart
, cnt
, buf
.data ());
425 do_assign (CORE_ADDR start
, size_t bcnt
, int version
)
427 CORE_ADDR vaddr
= adi_normalize_address (start
);
429 CORE_ADDR vstart
= adi_align_address (vaddr
);
430 int cnt
= adi_convert_byte_count (vaddr
, bcnt
, vstart
);
431 std::vector
<unsigned char> buf (cnt
, version
);
432 int set_cnt
= adi_write_versions (vstart
, cnt
, buf
.data ());
435 error (_("No ADI information"));
436 else if (set_cnt
< cnt
)
437 error(_("No ADI information at %s"), paddress (target_gdbarch (), vaddr
));
441 /* ADI examine version tag command.
445 adi (examine|x)[/COUNT] [ADDR] */
448 adi_examine_command (const char *args
, int from_tty
)
450 /* make sure program is active and adi is available */
451 if (!target_has_execution ())
452 error (_("ADI command requires a live process/thread"));
454 if (!adi_available ())
455 error (_("No ADI information"));
458 const char *p
= args
;
462 cnt
= get_number (&p
);
465 CORE_ADDR next_address
= 0;
466 if (p
!= 0 && *p
!= 0)
467 next_address
= parse_and_eval_address (p
);
468 if (!cnt
|| !next_address
)
469 error (_("Usage: adi examine|x[/COUNT] [ADDR]"));
471 do_examine (next_address
, cnt
);
474 /* ADI assign version tag command.
478 adi (assign|a)[/COUNT] ADDR = VERSION */
481 adi_assign_command (const char *args
, int from_tty
)
483 static const char *adi_usage
484 = N_("Usage: adi assign|a[/COUNT] ADDR = VERSION");
486 /* make sure program is active and adi is available */
487 if (!target_has_execution ())
488 error (_("ADI command requires a live process/thread"));
490 if (!adi_available ())
491 error (_("No ADI information"));
493 const char *exp
= args
;
495 error_no_arg (_(adi_usage
));
497 char *q
= (char *) strchr (exp
, '=');
501 error ("%s", _(adi_usage
));
504 const char *p
= args
;
505 if (exp
&& *exp
== '/')
508 cnt
= get_number (&p
);
511 CORE_ADDR next_address
= 0;
512 if (p
!= 0 && *p
!= 0)
513 next_address
= parse_and_eval_address (p
);
515 error ("%s", _(adi_usage
));
518 if (q
!= NULL
) /* parse version tag */
520 adi_stat_t ast
= get_adi_info (inferior_ptid
.pid ());
521 version
= parse_and_eval_long (q
);
522 if (version
< 0 || version
> ast
.max_version
)
523 error (_("Invalid ADI version tag %d"), version
);
526 do_assign (next_address
, cnt
, version
);
529 void _initialize_sparc64_adi_tdep ();
531 _initialize_sparc64_adi_tdep ()
533 add_basic_prefix_cmd ("adi", class_support
,
534 _("ADI version related commands."),
535 &sparc64adilist
, 0, &cmdlist
);
536 cmd_list_element
*adi_examine_cmd
537 = add_cmd ("examine", class_support
, adi_examine_command
,
538 _("Examine ADI versions."), &sparc64adilist
);
539 add_alias_cmd ("x", adi_examine_cmd
, no_class
, 1, &sparc64adilist
);
540 add_cmd ("assign", class_support
, adi_assign_command
,
541 _("Assign ADI versions."), &sparc64adilist
);
546 /* The functions on this page are intended to be used to classify
547 function arguments. */
549 /* Check whether TYPE is "Integral or Pointer". */
552 sparc64_integral_or_pointer_p (const struct type
*type
)
554 switch (type
->code ())
560 case TYPE_CODE_RANGE
:
562 int len
= type
->length ();
563 gdb_assert (len
== 1 || len
== 2 || len
== 4 || len
== 8);
568 case TYPE_CODE_RVALUE_REF
:
570 int len
= type
->length ();
571 gdb_assert (len
== 8);
581 /* Check whether TYPE is "Floating". */
584 sparc64_floating_p (const struct type
*type
)
586 switch (type
->code ())
590 int len
= type
->length ();
591 gdb_assert (len
== 4 || len
== 8 || len
== 16);
601 /* Check whether TYPE is "Complex Floating". */
604 sparc64_complex_floating_p (const struct type
*type
)
606 switch (type
->code ())
608 case TYPE_CODE_COMPLEX
:
610 int len
= type
->length ();
611 gdb_assert (len
== 8 || len
== 16 || len
== 32);
621 /* Check whether TYPE is "Structure or Union".
623 In terms of Ada subprogram calls, arrays are treated the same as
624 struct and union types. So this function also returns non-zero
628 sparc64_structure_or_union_p (const struct type
*type
)
630 switch (type
->code ())
632 case TYPE_CODE_STRUCT
:
633 case TYPE_CODE_UNION
:
634 case TYPE_CODE_ARRAY
:
644 /* Construct types for ISA-specific registers. */
647 sparc64_pstate_type (struct gdbarch
*gdbarch
)
649 sparc_gdbarch_tdep
*tdep
= gdbarch_tdep
<sparc_gdbarch_tdep
> (gdbarch
);
651 if (!tdep
->sparc64_pstate_type
)
655 type
= arch_flags_type (gdbarch
, "builtin_type_sparc64_pstate", 64);
656 append_flags_type_flag (type
, 0, "AG");
657 append_flags_type_flag (type
, 1, "IE");
658 append_flags_type_flag (type
, 2, "PRIV");
659 append_flags_type_flag (type
, 3, "AM");
660 append_flags_type_flag (type
, 4, "PEF");
661 append_flags_type_flag (type
, 5, "RED");
662 append_flags_type_flag (type
, 8, "TLE");
663 append_flags_type_flag (type
, 9, "CLE");
664 append_flags_type_flag (type
, 10, "PID0");
665 append_flags_type_flag (type
, 11, "PID1");
667 tdep
->sparc64_pstate_type
= type
;
670 return tdep
->sparc64_pstate_type
;
674 sparc64_ccr_type (struct gdbarch
*gdbarch
)
676 sparc_gdbarch_tdep
*tdep
= gdbarch_tdep
<sparc_gdbarch_tdep
> (gdbarch
);
678 if (tdep
->sparc64_ccr_type
== NULL
)
682 type
= arch_flags_type (gdbarch
, "builtin_type_sparc64_ccr", 64);
683 append_flags_type_flag (type
, 0, "icc.c");
684 append_flags_type_flag (type
, 1, "icc.v");
685 append_flags_type_flag (type
, 2, "icc.z");
686 append_flags_type_flag (type
, 3, "icc.n");
687 append_flags_type_flag (type
, 4, "xcc.c");
688 append_flags_type_flag (type
, 5, "xcc.v");
689 append_flags_type_flag (type
, 6, "xcc.z");
690 append_flags_type_flag (type
, 7, "xcc.n");
692 tdep
->sparc64_ccr_type
= type
;
695 return tdep
->sparc64_ccr_type
;
699 sparc64_fsr_type (struct gdbarch
*gdbarch
)
701 sparc_gdbarch_tdep
*tdep
= gdbarch_tdep
<sparc_gdbarch_tdep
> (gdbarch
);
703 if (!tdep
->sparc64_fsr_type
)
707 type
= arch_flags_type (gdbarch
, "builtin_type_sparc64_fsr", 64);
708 append_flags_type_flag (type
, 0, "NXC");
709 append_flags_type_flag (type
, 1, "DZC");
710 append_flags_type_flag (type
, 2, "UFC");
711 append_flags_type_flag (type
, 3, "OFC");
712 append_flags_type_flag (type
, 4, "NVC");
713 append_flags_type_flag (type
, 5, "NXA");
714 append_flags_type_flag (type
, 6, "DZA");
715 append_flags_type_flag (type
, 7, "UFA");
716 append_flags_type_flag (type
, 8, "OFA");
717 append_flags_type_flag (type
, 9, "NVA");
718 append_flags_type_flag (type
, 22, "NS");
719 append_flags_type_flag (type
, 23, "NXM");
720 append_flags_type_flag (type
, 24, "DZM");
721 append_flags_type_flag (type
, 25, "UFM");
722 append_flags_type_flag (type
, 26, "OFM");
723 append_flags_type_flag (type
, 27, "NVM");
725 tdep
->sparc64_fsr_type
= type
;
728 return tdep
->sparc64_fsr_type
;
732 sparc64_fprs_type (struct gdbarch
*gdbarch
)
734 sparc_gdbarch_tdep
*tdep
= gdbarch_tdep
<sparc_gdbarch_tdep
> (gdbarch
);
736 if (!tdep
->sparc64_fprs_type
)
740 type
= arch_flags_type (gdbarch
, "builtin_type_sparc64_fprs", 64);
741 append_flags_type_flag (type
, 0, "DL");
742 append_flags_type_flag (type
, 1, "DU");
743 append_flags_type_flag (type
, 2, "FEF");
745 tdep
->sparc64_fprs_type
= type
;
748 return tdep
->sparc64_fprs_type
;
752 /* Register information. */
753 #define SPARC64_FPU_REGISTERS \
754 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \
755 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \
756 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", \
757 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", \
758 "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46", \
759 "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62"
760 #define SPARC64_CP0_REGISTERS \
762 /* FIXME: Give "state" a name until we start using register groups. */ \
768 static const char * const sparc64_fpu_register_names
[] = {
769 SPARC64_FPU_REGISTERS
771 static const char * const sparc64_cp0_register_names
[] = {
772 SPARC64_CP0_REGISTERS
775 static const char * const sparc64_register_names
[] =
777 SPARC_CORE_REGISTERS
,
778 SPARC64_FPU_REGISTERS
,
779 SPARC64_CP0_REGISTERS
782 /* Total number of registers. */
783 #define SPARC64_NUM_REGS ARRAY_SIZE (sparc64_register_names)
785 /* We provide the aliases %d0..%d62 and %q0..%q60 for the floating
786 registers as "psuedo" registers. */
788 static const char * const sparc64_pseudo_register_names
[] =
790 "cwp", "pstate", "asi", "ccr",
792 "d0", "d2", "d4", "d6", "d8", "d10", "d12", "d14",
793 "d16", "d18", "d20", "d22", "d24", "d26", "d28", "d30",
794 "d32", "d34", "d36", "d38", "d40", "d42", "d44", "d46",
795 "d48", "d50", "d52", "d54", "d56", "d58", "d60", "d62",
797 "q0", "q4", "q8", "q12", "q16", "q20", "q24", "q28",
798 "q32", "q36", "q40", "q44", "q48", "q52", "q56", "q60",
801 /* Total number of pseudo registers. */
802 #define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_names)
804 /* Return the name of pseudo register REGNUM. */
807 sparc64_pseudo_register_name (struct gdbarch
*gdbarch
, int regnum
)
809 regnum
-= gdbarch_num_regs (gdbarch
);
811 gdb_assert (regnum
< SPARC64_NUM_PSEUDO_REGS
);
812 return sparc64_pseudo_register_names
[regnum
];
815 /* Return the name of register REGNUM. */
818 sparc64_register_name (struct gdbarch
*gdbarch
, int regnum
)
820 if (tdesc_has_registers (gdbarch_target_desc (gdbarch
)))
821 return tdesc_register_name (gdbarch
, regnum
);
823 if (regnum
>= 0 && regnum
< gdbarch_num_regs (gdbarch
))
824 return sparc64_register_names
[regnum
];
826 return sparc64_pseudo_register_name (gdbarch
, regnum
);
829 /* Return the GDB type object for the "standard" data type of data in
830 pseudo register REGNUM. */
833 sparc64_pseudo_register_type (struct gdbarch
*gdbarch
, int regnum
)
835 regnum
-= gdbarch_num_regs (gdbarch
);
837 if (regnum
== SPARC64_CWP_REGNUM
)
838 return builtin_type (gdbarch
)->builtin_int64
;
839 if (regnum
== SPARC64_PSTATE_REGNUM
)
840 return sparc64_pstate_type (gdbarch
);
841 if (regnum
== SPARC64_ASI_REGNUM
)
842 return builtin_type (gdbarch
)->builtin_int64
;
843 if (regnum
== SPARC64_CCR_REGNUM
)
844 return sparc64_ccr_type (gdbarch
);
845 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
846 return builtin_type (gdbarch
)->builtin_double
;
847 if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
848 return builtin_type (gdbarch
)->builtin_long_double
;
850 internal_error (_("sparc64_pseudo_register_type: bad register number %d"),
854 /* Return the GDB type object for the "standard" data type of data in
858 sparc64_register_type (struct gdbarch
*gdbarch
, int regnum
)
860 if (tdesc_has_registers (gdbarch_target_desc (gdbarch
)))
861 return tdesc_register_type (gdbarch
, regnum
);
864 if (regnum
== SPARC_SP_REGNUM
|| regnum
== SPARC_FP_REGNUM
)
865 return builtin_type (gdbarch
)->builtin_data_ptr
;
866 if (regnum
>= SPARC_G0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
)
867 return builtin_type (gdbarch
)->builtin_int64
;
868 if (regnum
>= SPARC_F0_REGNUM
&& regnum
<= SPARC_F31_REGNUM
)
869 return builtin_type (gdbarch
)->builtin_float
;
870 if (regnum
>= SPARC64_F32_REGNUM
&& regnum
<= SPARC64_F62_REGNUM
)
871 return builtin_type (gdbarch
)->builtin_double
;
872 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== SPARC64_NPC_REGNUM
)
873 return builtin_type (gdbarch
)->builtin_func_ptr
;
874 /* This raw register contains the contents of %cwp, %pstate, %asi
875 and %ccr as laid out in a %tstate register. */
876 if (regnum
== SPARC64_STATE_REGNUM
)
877 return builtin_type (gdbarch
)->builtin_int64
;
878 if (regnum
== SPARC64_FSR_REGNUM
)
879 return sparc64_fsr_type (gdbarch
);
880 if (regnum
== SPARC64_FPRS_REGNUM
)
881 return sparc64_fprs_type (gdbarch
);
882 /* "Although Y is a 64-bit register, its high-order 32 bits are
883 reserved and always read as 0." */
884 if (regnum
== SPARC64_Y_REGNUM
)
885 return builtin_type (gdbarch
)->builtin_int64
;
887 /* Pseudo registers. */
888 if (regnum
>= gdbarch_num_regs (gdbarch
))
889 return sparc64_pseudo_register_type (gdbarch
, regnum
);
891 internal_error (_("invalid regnum"));
894 static enum register_status
895 sparc64_pseudo_register_read (struct gdbarch
*gdbarch
,
896 readable_regcache
*regcache
,
897 int regnum
, gdb_byte
*buf
)
899 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
900 enum register_status status
;
902 regnum
-= gdbarch_num_regs (gdbarch
);
904 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D30_REGNUM
)
906 regnum
= SPARC_F0_REGNUM
+ 2 * (regnum
- SPARC64_D0_REGNUM
);
907 status
= regcache
->raw_read (regnum
, buf
);
908 if (status
== REG_VALID
)
909 status
= regcache
->raw_read (regnum
+ 1, buf
+ 4);
912 else if (regnum
>= SPARC64_D32_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
914 regnum
= SPARC64_F32_REGNUM
+ (regnum
- SPARC64_D32_REGNUM
);
915 return regcache
->raw_read (regnum
, buf
);
917 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q28_REGNUM
)
919 regnum
= SPARC_F0_REGNUM
+ 4 * (regnum
- SPARC64_Q0_REGNUM
);
921 status
= regcache
->raw_read (regnum
, buf
);
922 if (status
== REG_VALID
)
923 status
= regcache
->raw_read (regnum
+ 1, buf
+ 4);
924 if (status
== REG_VALID
)
925 status
= regcache
->raw_read (regnum
+ 2, buf
+ 8);
926 if (status
== REG_VALID
)
927 status
= regcache
->raw_read (regnum
+ 3, buf
+ 12);
931 else if (regnum
>= SPARC64_Q32_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
933 regnum
= SPARC64_F32_REGNUM
+ 2 * (regnum
- SPARC64_Q32_REGNUM
);
935 status
= regcache
->raw_read (regnum
, buf
);
936 if (status
== REG_VALID
)
937 status
= regcache
->raw_read (regnum
+ 1, buf
+ 8);
941 else if (regnum
== SPARC64_CWP_REGNUM
942 || regnum
== SPARC64_PSTATE_REGNUM
943 || regnum
== SPARC64_ASI_REGNUM
944 || regnum
== SPARC64_CCR_REGNUM
)
948 status
= regcache
->raw_read (SPARC64_STATE_REGNUM
, &state
);
949 if (status
!= REG_VALID
)
954 case SPARC64_CWP_REGNUM
:
955 state
= (state
>> 0) & ((1 << 5) - 1);
957 case SPARC64_PSTATE_REGNUM
:
958 state
= (state
>> 8) & ((1 << 12) - 1);
960 case SPARC64_ASI_REGNUM
:
961 state
= (state
>> 24) & ((1 << 8) - 1);
963 case SPARC64_CCR_REGNUM
:
964 state
= (state
>> 32) & ((1 << 8) - 1);
967 store_unsigned_integer (buf
, 8, byte_order
, state
);
974 sparc64_pseudo_register_write (struct gdbarch
*gdbarch
,
975 struct regcache
*regcache
,
976 int regnum
, const gdb_byte
*buf
)
978 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
980 regnum
-= gdbarch_num_regs (gdbarch
);
982 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D30_REGNUM
)
984 regnum
= SPARC_F0_REGNUM
+ 2 * (regnum
- SPARC64_D0_REGNUM
);
985 regcache
->raw_write (regnum
, buf
);
986 regcache
->raw_write (regnum
+ 1, buf
+ 4);
988 else if (regnum
>= SPARC64_D32_REGNUM
&& regnum
<= SPARC64_D62_REGNUM
)
990 regnum
= SPARC64_F32_REGNUM
+ (regnum
- SPARC64_D32_REGNUM
);
991 regcache
->raw_write (regnum
, buf
);
993 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q28_REGNUM
)
995 regnum
= SPARC_F0_REGNUM
+ 4 * (regnum
- SPARC64_Q0_REGNUM
);
996 regcache
->raw_write (regnum
, buf
);
997 regcache
->raw_write (regnum
+ 1, buf
+ 4);
998 regcache
->raw_write (regnum
+ 2, buf
+ 8);
999 regcache
->raw_write (regnum
+ 3, buf
+ 12);
1001 else if (regnum
>= SPARC64_Q32_REGNUM
&& regnum
<= SPARC64_Q60_REGNUM
)
1003 regnum
= SPARC64_F32_REGNUM
+ 2 * (regnum
- SPARC64_Q32_REGNUM
);
1004 regcache
->raw_write (regnum
, buf
);
1005 regcache
->raw_write (regnum
+ 1, buf
+ 8);
1007 else if (regnum
== SPARC64_CWP_REGNUM
1008 || regnum
== SPARC64_PSTATE_REGNUM
1009 || regnum
== SPARC64_ASI_REGNUM
1010 || regnum
== SPARC64_CCR_REGNUM
)
1012 ULONGEST state
, bits
;
1014 regcache_raw_read_unsigned (regcache
, SPARC64_STATE_REGNUM
, &state
);
1015 bits
= extract_unsigned_integer (buf
, 8, byte_order
);
1018 case SPARC64_CWP_REGNUM
:
1019 state
|= ((bits
& ((1 << 5) - 1)) << 0);
1021 case SPARC64_PSTATE_REGNUM
:
1022 state
|= ((bits
& ((1 << 12) - 1)) << 8);
1024 case SPARC64_ASI_REGNUM
:
1025 state
|= ((bits
& ((1 << 8) - 1)) << 24);
1027 case SPARC64_CCR_REGNUM
:
1028 state
|= ((bits
& ((1 << 8) - 1)) << 32);
1031 regcache_raw_write_unsigned (regcache
, SPARC64_STATE_REGNUM
, state
);
1036 /* Return PC of first real instruction of the function starting at
1040 sparc64_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR start_pc
)
1042 struct symtab_and_line sal
;
1043 CORE_ADDR func_start
, func_end
;
1044 struct sparc_frame_cache cache
;
1046 /* This is the preferred method, find the end of the prologue by
1047 using the debugging information. */
1048 if (find_pc_partial_function (start_pc
, NULL
, &func_start
, &func_end
))
1050 sal
= find_pc_line (func_start
, 0);
1052 if (sal
.end
< func_end
1053 && start_pc
<= sal
.end
)
1057 return sparc_analyze_prologue (gdbarch
, start_pc
, 0xffffffffffffffffULL
,
1061 /* Normal frames. */
1063 static struct sparc_frame_cache
*
1064 sparc64_frame_cache (frame_info_ptr this_frame
, void **this_cache
)
1066 return sparc_frame_cache (this_frame
, this_cache
);
1070 sparc64_frame_this_id (frame_info_ptr this_frame
, void **this_cache
,
1071 struct frame_id
*this_id
)
1073 struct sparc_frame_cache
*cache
=
1074 sparc64_frame_cache (this_frame
, this_cache
);
1076 /* This marks the outermost frame. */
1077 if (cache
->base
== 0)
1080 (*this_id
) = frame_id_build (cache
->base
, cache
->pc
);
1083 static struct value
*
1084 sparc64_frame_prev_register (frame_info_ptr this_frame
, void **this_cache
,
1087 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1088 struct sparc_frame_cache
*cache
=
1089 sparc64_frame_cache (this_frame
, this_cache
);
1091 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== SPARC64_NPC_REGNUM
)
1093 CORE_ADDR pc
= (regnum
== SPARC64_NPC_REGNUM
) ? 4 : 0;
1096 (cache
->copied_regs_mask
& 0x80) ? SPARC_I7_REGNUM
: SPARC_O7_REGNUM
;
1097 pc
+= get_frame_register_unsigned (this_frame
, regnum
) + 8;
1098 return frame_unwind_got_constant (this_frame
, regnum
, pc
);
1101 /* Handle StackGhost. */
1103 ULONGEST wcookie
= sparc_fetch_wcookie (gdbarch
);
1105 if (wcookie
!= 0 && !cache
->frameless_p
&& regnum
== SPARC_I7_REGNUM
)
1107 CORE_ADDR addr
= cache
->base
+ (regnum
- SPARC_L0_REGNUM
) * 8;
1110 /* Read the value in from memory. */
1111 i7
= get_frame_memory_unsigned (this_frame
, addr
, 8);
1112 return frame_unwind_got_constant (this_frame
, regnum
, i7
^ wcookie
);
1116 /* The previous frame's `local' and `in' registers may have been saved
1117 in the register save area. */
1118 if (regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
1119 && (cache
->saved_regs_mask
& (1 << (regnum
- SPARC_L0_REGNUM
))))
1121 CORE_ADDR addr
= cache
->base
+ (regnum
- SPARC_L0_REGNUM
) * 8;
1123 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1126 /* The previous frame's `out' registers may be accessible as the current
1127 frame's `in' registers. */
1128 if (regnum
>= SPARC_O0_REGNUM
&& regnum
<= SPARC_O7_REGNUM
1129 && (cache
->copied_regs_mask
& (1 << (regnum
- SPARC_O0_REGNUM
))))
1130 regnum
+= (SPARC_I0_REGNUM
- SPARC_O0_REGNUM
);
1132 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1135 static const struct frame_unwind sparc64_frame_unwind
=
1139 default_frame_unwind_stop_reason
,
1140 sparc64_frame_this_id
,
1141 sparc64_frame_prev_register
,
1143 default_frame_sniffer
1148 sparc64_frame_base_address (frame_info_ptr this_frame
, void **this_cache
)
1150 struct sparc_frame_cache
*cache
=
1151 sparc64_frame_cache (this_frame
, this_cache
);
1156 static const struct frame_base sparc64_frame_base
=
1158 &sparc64_frame_unwind
,
1159 sparc64_frame_base_address
,
1160 sparc64_frame_base_address
,
1161 sparc64_frame_base_address
1164 /* Check whether TYPE must be 16-byte aligned. */
1167 sparc64_16_byte_align_p (struct type
*type
)
1169 if (type
->code () == TYPE_CODE_ARRAY
)
1171 struct type
*t
= check_typedef (type
->target_type ());
1173 if (sparc64_floating_p (t
))
1176 if (sparc64_floating_p (type
) && type
->length () == 16)
1179 if (sparc64_structure_or_union_p (type
))
1183 for (i
= 0; i
< type
->num_fields (); i
++)
1185 struct type
*subtype
= check_typedef (type
->field (i
).type ());
1187 if (sparc64_16_byte_align_p (subtype
))
1195 /* Store floating fields of element ELEMENT of an "parameter array"
1196 that has type TYPE and is stored at BITPOS in VALBUF in the
1197 appropriate registers of REGCACHE. This function can be called
1198 recursively and therefore handles floating types in addition to
1202 sparc64_store_floating_fields (struct regcache
*regcache
, struct type
*type
,
1203 const gdb_byte
*valbuf
, int element
, int bitpos
)
1205 struct gdbarch
*gdbarch
= regcache
->arch ();
1206 int len
= type
->length ();
1208 gdb_assert (element
< 16);
1210 if (type
->code () == TYPE_CODE_ARRAY
)
1213 int regnum
= SPARC_F0_REGNUM
+ element
* 2 + bitpos
/ 32;
1215 valbuf
+= bitpos
/ 8;
1218 memset (buf
, 0, 8 - len
);
1219 memcpy (buf
+ 8 - len
, valbuf
, len
);
1223 for (int n
= 0; n
< (len
+ 3) / 4; n
++)
1224 regcache
->cooked_write (regnum
+ n
, valbuf
+ n
* 4);
1226 else if (sparc64_floating_p (type
)
1227 || (sparc64_complex_floating_p (type
) && len
<= 16))
1233 gdb_assert (bitpos
== 0);
1234 gdb_assert ((element
% 2) == 0);
1236 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_Q0_REGNUM
+ element
/ 2;
1237 regcache
->cooked_write (regnum
, valbuf
);
1241 gdb_assert (bitpos
== 0 || bitpos
== 64);
1243 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_D0_REGNUM
1244 + element
+ bitpos
/ 64;
1245 regcache
->cooked_write (regnum
, valbuf
+ (bitpos
/ 8));
1249 gdb_assert (len
== 4);
1250 gdb_assert (bitpos
% 32 == 0 && bitpos
>= 0 && bitpos
< 128);
1252 regnum
= SPARC_F0_REGNUM
+ element
* 2 + bitpos
/ 32;
1253 regcache
->cooked_write (regnum
, valbuf
+ (bitpos
/ 8));
1256 else if (sparc64_structure_or_union_p (type
))
1260 for (i
= 0; i
< type
->num_fields (); i
++)
1262 struct type
*subtype
= check_typedef (type
->field (i
).type ());
1263 int subpos
= bitpos
+ type
->field (i
).loc_bitpos ();
1265 sparc64_store_floating_fields (regcache
, subtype
, valbuf
,
1269 /* GCC has an interesting bug. If TYPE is a structure that has
1270 a single `float' member, GCC doesn't treat it as a structure
1271 at all, but rather as an ordinary `float' argument. This
1272 argument will be stored in %f1, as required by the psABI.
1273 However, as a member of a structure the psABI requires it to
1274 be stored in %f0. This bug is present in GCC 3.3.2, but
1275 probably in older releases to. To appease GCC, if a
1276 structure has only a single `float' member, we store its
1277 value in %f1 too (we already have stored in %f0). */
1278 if (type
->num_fields () == 1)
1280 struct type
*subtype
= check_typedef (type
->field (0).type ());
1282 if (sparc64_floating_p (subtype
) && subtype
->length () == 4)
1283 regcache
->cooked_write (SPARC_F1_REGNUM
, valbuf
);
1288 /* Fetch floating fields from a variable of type TYPE from the
1289 appropriate registers for BITPOS in REGCACHE and store it at BITPOS
1290 in VALBUF. This function can be called recursively and therefore
1291 handles floating types in addition to structures. */
1294 sparc64_extract_floating_fields (struct regcache
*regcache
, struct type
*type
,
1295 gdb_byte
*valbuf
, int bitpos
)
1297 struct gdbarch
*gdbarch
= regcache
->arch ();
1299 if (type
->code () == TYPE_CODE_ARRAY
)
1301 int len
= type
->length ();
1302 int regnum
= SPARC_F0_REGNUM
+ bitpos
/ 32;
1304 valbuf
+= bitpos
/ 8;
1308 regcache
->cooked_read (regnum
, buf
);
1309 memcpy (valbuf
, buf
+ 4 - len
, len
);
1312 for (int i
= 0; i
< (len
+ 3) / 4; i
++)
1313 regcache
->cooked_read (regnum
+ i
, valbuf
+ i
* 4);
1315 else if (sparc64_floating_p (type
))
1317 int len
= type
->length ();
1322 gdb_assert (bitpos
== 0 || bitpos
== 128);
1324 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_Q0_REGNUM
1326 regcache
->cooked_read (regnum
, valbuf
+ (bitpos
/ 8));
1330 gdb_assert (bitpos
% 64 == 0 && bitpos
>= 0 && bitpos
< 256);
1332 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_D0_REGNUM
+ bitpos
/ 64;
1333 regcache
->cooked_read (regnum
, valbuf
+ (bitpos
/ 8));
1337 gdb_assert (len
== 4);
1338 gdb_assert (bitpos
% 32 == 0 && bitpos
>= 0 && bitpos
< 256);
1340 regnum
= SPARC_F0_REGNUM
+ bitpos
/ 32;
1341 regcache
->cooked_read (regnum
, valbuf
+ (bitpos
/ 8));
1344 else if (sparc64_structure_or_union_p (type
))
1348 for (i
= 0; i
< type
->num_fields (); i
++)
1350 struct type
*subtype
= check_typedef (type
->field (i
).type ());
1351 int subpos
= bitpos
+ type
->field (i
).loc_bitpos ();
1353 sparc64_extract_floating_fields (regcache
, subtype
, valbuf
, subpos
);
1358 /* Store the NARGS arguments ARGS and STRUCT_ADDR (if STRUCT_RETURN is
1359 non-zero) in REGCACHE and on the stack (starting from address SP). */
1362 sparc64_store_arguments (struct regcache
*regcache
, int nargs
,
1363 struct value
**args
, CORE_ADDR sp
,
1364 function_call_return_method return_method
,
1365 CORE_ADDR struct_addr
)
1367 struct gdbarch
*gdbarch
= regcache
->arch ();
1368 /* Number of extended words in the "parameter array". */
1369 int num_elements
= 0;
1373 /* Take BIAS into account. */
1376 /* First we calculate the number of extended words in the "parameter
1377 array". While doing so we also convert some of the arguments. */
1379 if (return_method
== return_method_struct
)
1382 for (i
= 0; i
< nargs
; i
++)
1384 struct type
*type
= value_type (args
[i
]);
1385 int len
= type
->length ();
1387 if (sparc64_structure_or_union_p (type
)
1388 || (sparc64_complex_floating_p (type
) && len
== 32))
1390 /* Structure or Union arguments. */
1393 if (num_elements
% 2 && sparc64_16_byte_align_p (type
))
1395 num_elements
+= ((len
+ 7) / 8);
1399 /* The psABI says that "Structures or unions larger than
1400 sixteen bytes are copied by the caller and passed
1401 indirectly; the caller will pass the address of a
1402 correctly aligned structure value. This sixty-four
1403 bit address will occupy one word in the parameter
1404 array, and may be promoted to an %o register like any
1405 other pointer value." Allocate memory for these
1406 values on the stack. */
1409 /* Use 16-byte alignment for these values. That's
1410 always correct, and wasting a few bytes shouldn't be
1414 write_memory (sp
, value_contents (args
[i
]).data (), len
);
1415 args
[i
] = value_from_pointer (lookup_pointer_type (type
), sp
);
1419 else if (sparc64_floating_p (type
) || sparc64_complex_floating_p (type
))
1421 /* Floating arguments. */
1424 /* The psABI says that "Each quad-precision parameter
1425 value will be assigned to two extended words in the
1429 /* The psABI says that "Long doubles must be
1430 quad-aligned, and thus a hole might be introduced
1431 into the parameter array to force alignment." Skip
1432 an element if necessary. */
1433 if ((num_elements
% 2) && sparc64_16_byte_align_p (type
))
1441 /* Integral and pointer arguments. */
1442 gdb_assert (sparc64_integral_or_pointer_p (type
));
1444 /* The psABI says that "Each argument value of integral type
1445 smaller than an extended word will be widened by the
1446 caller to an extended word according to the signed-ness
1447 of the argument type." */
1449 args
[i
] = value_cast (builtin_type (gdbarch
)->builtin_int64
,
1455 /* Allocate the "parameter array". */
1456 sp
-= num_elements
* 8;
1458 /* The psABI says that "Every stack frame must be 16-byte aligned." */
1461 /* Now we store the arguments in to the "parameter array". Some
1462 Integer or Pointer arguments and Structure or Union arguments
1463 will be passed in %o registers. Some Floating arguments and
1464 floating members of structures are passed in floating-point
1465 registers. However, for functions with variable arguments,
1466 floating arguments are stored in an %0 register, and for
1467 functions without a prototype floating arguments are stored in
1468 both a floating-point and an %o registers, or a floating-point
1469 register and memory. To simplify the logic here we always pass
1470 arguments in memory, an %o register, and a floating-point
1471 register if appropriate. This should be no problem since the
1472 contents of any unused memory or registers in the "parameter
1473 array" are undefined. */
1475 if (return_method
== return_method_struct
)
1477 regcache_cooked_write_unsigned (regcache
, SPARC_O0_REGNUM
, struct_addr
);
1481 for (i
= 0; i
< nargs
; i
++)
1483 const gdb_byte
*valbuf
= value_contents (args
[i
]).data ();
1484 struct type
*type
= value_type (args
[i
]);
1485 int len
= type
->length ();
1489 if (sparc64_structure_or_union_p (type
)
1490 || (sparc64_complex_floating_p (type
) && len
== 32))
1492 /* Structure, Union or long double Complex arguments. */
1493 gdb_assert (len
<= 16);
1494 memset (buf
, 0, sizeof (buf
));
1495 memcpy (buf
, valbuf
, len
);
1498 if (element
% 2 && sparc64_16_byte_align_p (type
))
1503 regnum
= SPARC_O0_REGNUM
+ element
;
1504 if (len
> 8 && element
< 5)
1505 regcache
->cooked_write (regnum
+ 1, valbuf
+ 8);
1509 sparc64_store_floating_fields (regcache
, type
, valbuf
, element
, 0);
1511 else if (sparc64_complex_floating_p (type
))
1513 /* Float Complex or double Complex arguments. */
1516 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_D0_REGNUM
+ element
;
1520 if (regnum
< gdbarch_num_regs (gdbarch
) + SPARC64_D30_REGNUM
)
1521 regcache
->cooked_write (regnum
+ 1, valbuf
+ 8);
1522 if (regnum
< gdbarch_num_regs (gdbarch
) + SPARC64_D10_REGNUM
)
1523 regcache
->cooked_write (SPARC_O0_REGNUM
+ element
+ 1,
1528 else if (sparc64_floating_p (type
))
1530 /* Floating arguments. */
1536 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_Q0_REGNUM
1542 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_D0_REGNUM
1547 /* The psABI says "Each single-precision parameter value
1548 will be assigned to one extended word in the
1549 parameter array, and right-justified within that
1550 word; the left half (even float register) is
1551 undefined." Even though the psABI says that "the
1552 left half is undefined", set it to zero here. */
1554 memcpy (buf
+ 4, valbuf
, 4);
1558 regnum
= gdbarch_num_regs (gdbarch
) + SPARC64_D0_REGNUM
1564 /* Integral and pointer arguments. */
1565 gdb_assert (len
== 8);
1567 regnum
= SPARC_O0_REGNUM
+ element
;
1572 regcache
->cooked_write (regnum
, valbuf
);
1574 /* If we're storing the value in a floating-point register,
1575 also store it in the corresponding %0 register(s). */
1576 if (regnum
>= gdbarch_num_regs (gdbarch
))
1578 regnum
-= gdbarch_num_regs (gdbarch
);
1580 if (regnum
>= SPARC64_D0_REGNUM
&& regnum
<= SPARC64_D10_REGNUM
)
1582 gdb_assert (element
< 6);
1583 regnum
= SPARC_O0_REGNUM
+ element
;
1584 regcache
->cooked_write (regnum
, valbuf
);
1586 else if (regnum
>= SPARC64_Q0_REGNUM
&& regnum
<= SPARC64_Q8_REGNUM
)
1588 gdb_assert (element
< 5);
1589 regnum
= SPARC_O0_REGNUM
+ element
;
1590 regcache
->cooked_write (regnum
, valbuf
);
1591 regcache
->cooked_write (regnum
+ 1, valbuf
+ 8);
1596 /* Always store the argument in memory. */
1597 write_memory (sp
+ element
* 8, valbuf
, len
);
1598 element
+= ((len
+ 7) / 8);
1601 gdb_assert (element
== num_elements
);
1603 /* Take BIAS into account. */
1609 sparc64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR address
)
1611 /* The ABI requires 16-byte alignment. */
1612 return address
& ~0xf;
1616 sparc64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
1617 struct regcache
*regcache
, CORE_ADDR bp_addr
,
1618 int nargs
, struct value
**args
, CORE_ADDR sp
,
1619 function_call_return_method return_method
,
1620 CORE_ADDR struct_addr
)
1622 /* Set return address. */
1623 regcache_cooked_write_unsigned (regcache
, SPARC_O7_REGNUM
, bp_addr
- 8);
1625 /* Set up function arguments. */
1626 sp
= sparc64_store_arguments (regcache
, nargs
, args
, sp
, return_method
,
1629 /* Allocate the register save area. */
1632 /* Stack should be 16-byte aligned at this point. */
1633 gdb_assert ((sp
+ BIAS
) % 16 == 0);
1635 /* Finally, update the stack pointer. */
1636 regcache_cooked_write_unsigned (regcache
, SPARC_SP_REGNUM
, sp
);
1642 /* Extract from an array REGBUF containing the (raw) register state, a
1643 function return value of TYPE, and copy that into VALBUF. */
1646 sparc64_extract_return_value (struct type
*type
, struct regcache
*regcache
,
1649 int len
= type
->length ();
1653 if (sparc64_structure_or_union_p (type
))
1655 /* Structure or Union return values. */
1656 gdb_assert (len
<= 32);
1658 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1659 regcache
->cooked_read (SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1660 if (type
->code () != TYPE_CODE_UNION
)
1661 sparc64_extract_floating_fields (regcache
, type
, buf
, 0);
1662 memcpy (valbuf
, buf
, len
);
1664 else if (sparc64_floating_p (type
) || sparc64_complex_floating_p (type
))
1666 /* Floating return values. */
1667 for (i
= 0; i
< len
/ 4; i
++)
1668 regcache
->cooked_read (SPARC_F0_REGNUM
+ i
, buf
+ i
* 4);
1669 memcpy (valbuf
, buf
, len
);
1671 else if (type
->code () == TYPE_CODE_ARRAY
)
1673 /* Small arrays are returned the same way as small structures. */
1674 gdb_assert (len
<= 32);
1676 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1677 regcache
->cooked_read (SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1678 memcpy (valbuf
, buf
, len
);
1682 /* Integral and pointer return values. */
1683 gdb_assert (sparc64_integral_or_pointer_p (type
));
1685 /* Just stripping off any unused bytes should preserve the
1686 signed-ness just fine. */
1687 regcache
->cooked_read (SPARC_O0_REGNUM
, buf
);
1688 memcpy (valbuf
, buf
+ 8 - len
, len
);
1692 /* Write into the appropriate registers a function return value stored
1693 in VALBUF of type TYPE. */
1696 sparc64_store_return_value (struct type
*type
, struct regcache
*regcache
,
1697 const gdb_byte
*valbuf
)
1699 int len
= type
->length ();
1703 if (sparc64_structure_or_union_p (type
))
1705 /* Structure or Union return values. */
1706 gdb_assert (len
<= 32);
1708 /* Simplify matters by storing the complete value (including
1709 floating members) into %o0 and %o1. Floating members are
1710 also store in the appropriate floating-point registers. */
1711 memset (buf
, 0, sizeof (buf
));
1712 memcpy (buf
, valbuf
, len
);
1713 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1714 regcache
->cooked_write (SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1715 if (type
->code () != TYPE_CODE_UNION
)
1716 sparc64_store_floating_fields (regcache
, type
, buf
, 0, 0);
1718 else if (sparc64_floating_p (type
) || sparc64_complex_floating_p (type
))
1720 /* Floating return values. */
1721 memcpy (buf
, valbuf
, len
);
1722 for (i
= 0; i
< len
/ 4; i
++)
1723 regcache
->cooked_write (SPARC_F0_REGNUM
+ i
, buf
+ i
* 4);
1725 else if (type
->code () == TYPE_CODE_ARRAY
)
1727 /* Small arrays are returned the same way as small structures. */
1728 gdb_assert (len
<= 32);
1730 memset (buf
, 0, sizeof (buf
));
1731 memcpy (buf
, valbuf
, len
);
1732 for (i
= 0; i
< ((len
+ 7) / 8); i
++)
1733 regcache
->cooked_write (SPARC_O0_REGNUM
+ i
, buf
+ i
* 8);
1737 /* Integral and pointer return values. */
1738 gdb_assert (sparc64_integral_or_pointer_p (type
));
1740 /* ??? Do we need to do any sign-extension here? */
1742 memcpy (buf
+ 8 - len
, valbuf
, len
);
1743 regcache
->cooked_write (SPARC_O0_REGNUM
, buf
);
1747 static enum return_value_convention
1748 sparc64_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
1749 struct type
*type
, struct regcache
*regcache
,
1750 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1752 if (type
->length () > 32)
1753 return RETURN_VALUE_STRUCT_CONVENTION
;
1756 sparc64_extract_return_value (type
, regcache
, readbuf
);
1758 sparc64_store_return_value (type
, regcache
, writebuf
);
1760 return RETURN_VALUE_REGISTER_CONVENTION
;
1765 sparc64_dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
1766 struct dwarf2_frame_state_reg
*reg
,
1767 frame_info_ptr this_frame
)
1771 case SPARC_G0_REGNUM
:
1772 /* Since %g0 is always zero, there is no point in saving it, and
1773 people will be inclined omit it from the CFI. Make sure we
1774 don't warn about that. */
1775 reg
->how
= DWARF2_FRAME_REG_SAME_VALUE
;
1777 case SPARC_SP_REGNUM
:
1778 reg
->how
= DWARF2_FRAME_REG_CFA
;
1780 case SPARC64_PC_REGNUM
:
1781 reg
->how
= DWARF2_FRAME_REG_RA_OFFSET
;
1782 reg
->loc
.offset
= 8;
1784 case SPARC64_NPC_REGNUM
:
1785 reg
->how
= DWARF2_FRAME_REG_RA_OFFSET
;
1786 reg
->loc
.offset
= 12;
1791 /* sparc64_addr_bits_remove - remove useless address bits */
1794 sparc64_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1796 return adi_normalize_address (addr
);
1800 sparc64_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1802 sparc_gdbarch_tdep
*tdep
= gdbarch_tdep
<sparc_gdbarch_tdep
> (gdbarch
);
1804 tdep
->pc_regnum
= SPARC64_PC_REGNUM
;
1805 tdep
->npc_regnum
= SPARC64_NPC_REGNUM
;
1806 tdep
->fpu_register_names
= sparc64_fpu_register_names
;
1807 tdep
->fpu_registers_num
= ARRAY_SIZE (sparc64_fpu_register_names
);
1808 tdep
->cp0_register_names
= sparc64_cp0_register_names
;
1809 tdep
->cp0_registers_num
= ARRAY_SIZE (sparc64_cp0_register_names
);
1811 /* This is what all the fuss is about. */
1812 set_gdbarch_long_bit (gdbarch
, 64);
1813 set_gdbarch_long_long_bit (gdbarch
, 64);
1814 set_gdbarch_ptr_bit (gdbarch
, 64);
1816 set_gdbarch_wchar_bit (gdbarch
, 16);
1817 set_gdbarch_wchar_signed (gdbarch
, 0);
1819 set_gdbarch_num_regs (gdbarch
, SPARC64_NUM_REGS
);
1820 set_gdbarch_register_name (gdbarch
, sparc64_register_name
);
1821 set_gdbarch_register_type (gdbarch
, sparc64_register_type
);
1822 set_gdbarch_num_pseudo_regs (gdbarch
, SPARC64_NUM_PSEUDO_REGS
);
1823 set_tdesc_pseudo_register_name (gdbarch
, sparc64_pseudo_register_name
);
1824 set_tdesc_pseudo_register_type (gdbarch
, sparc64_pseudo_register_type
);
1825 set_gdbarch_pseudo_register_read (gdbarch
, sparc64_pseudo_register_read
);
1826 set_gdbarch_pseudo_register_write (gdbarch
, sparc64_pseudo_register_write
);
1828 /* Register numbers of various important registers. */
1829 set_gdbarch_pc_regnum (gdbarch
, SPARC64_PC_REGNUM
); /* %pc */
1831 /* Call dummy code. */
1832 set_gdbarch_frame_align (gdbarch
, sparc64_frame_align
);
1833 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1834 set_gdbarch_push_dummy_code (gdbarch
, NULL
);
1835 set_gdbarch_push_dummy_call (gdbarch
, sparc64_push_dummy_call
);
1837 set_gdbarch_return_value (gdbarch
, sparc64_return_value
);
1838 set_gdbarch_stabs_argument_has_addr
1839 (gdbarch
, default_stabs_argument_has_addr
);
1841 set_gdbarch_skip_prologue (gdbarch
, sparc64_skip_prologue
);
1842 set_gdbarch_stack_frame_destroyed_p (gdbarch
, sparc_stack_frame_destroyed_p
);
1844 /* Hook in the DWARF CFI frame unwinder. */
1845 dwarf2_frame_set_init_reg (gdbarch
, sparc64_dwarf2_frame_init_reg
);
1846 /* FIXME: kettenis/20050423: Don't enable the unwinder until the
1847 StackGhost issues have been resolved. */
1849 frame_unwind_append_unwinder (gdbarch
, &sparc64_frame_unwind
);
1850 frame_base_set_default (gdbarch
, &sparc64_frame_base
);
1852 set_gdbarch_addr_bits_remove (gdbarch
, sparc64_addr_bits_remove
);
1856 /* Helper functions for dealing with register sets. */
1858 #define TSTATE_CWP 0x000000000000001fULL
1859 #define TSTATE_ICC 0x0000000f00000000ULL
1860 #define TSTATE_XCC 0x000000f000000000ULL
1862 #define PSR_S 0x00000080
1864 #define PSR_ICC 0x00f00000
1866 #define PSR_VERS 0x0f000000
1868 #define PSR_IMPL 0xf0000000
1870 #define PSR_V8PLUS 0xff000000
1871 #define PSR_XCC 0x000f0000
1874 sparc64_supply_gregset (const struct sparc_gregmap
*gregmap
,
1875 struct regcache
*regcache
,
1876 int regnum
, const void *gregs
)
1878 struct gdbarch
*gdbarch
= regcache
->arch ();
1879 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1880 int sparc32
= (gdbarch_ptr_bit (gdbarch
) == 32);
1881 const gdb_byte
*regs
= (const gdb_byte
*) gregs
;
1882 gdb_byte zero
[8] = { 0 };
1887 if (regnum
== SPARC32_PSR_REGNUM
|| regnum
== -1)
1889 int offset
= gregmap
->r_tstate_offset
;
1890 ULONGEST tstate
, psr
;
1893 tstate
= extract_unsigned_integer (regs
+ offset
, 8, byte_order
);
1894 psr
= ((tstate
& TSTATE_CWP
) | PSR_S
| ((tstate
& TSTATE_ICC
) >> 12)
1895 | ((tstate
& TSTATE_XCC
) >> 20) | PSR_V8PLUS
);
1896 store_unsigned_integer (buf
, 4, byte_order
, psr
);
1897 regcache
->raw_supply (SPARC32_PSR_REGNUM
, buf
);
1900 if (regnum
== SPARC32_PC_REGNUM
|| regnum
== -1)
1901 regcache
->raw_supply (SPARC32_PC_REGNUM
,
1902 regs
+ gregmap
->r_pc_offset
+ 4);
1904 if (regnum
== SPARC32_NPC_REGNUM
|| regnum
== -1)
1905 regcache
->raw_supply (SPARC32_NPC_REGNUM
,
1906 regs
+ gregmap
->r_npc_offset
+ 4);
1908 if (regnum
== SPARC32_Y_REGNUM
|| regnum
== -1)
1910 int offset
= gregmap
->r_y_offset
+ 8 - gregmap
->r_y_size
;
1911 regcache
->raw_supply (SPARC32_Y_REGNUM
, regs
+ offset
);
1916 if (regnum
== SPARC64_STATE_REGNUM
|| regnum
== -1)
1917 regcache
->raw_supply (SPARC64_STATE_REGNUM
,
1918 regs
+ gregmap
->r_tstate_offset
);
1920 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== -1)
1921 regcache
->raw_supply (SPARC64_PC_REGNUM
,
1922 regs
+ gregmap
->r_pc_offset
);
1924 if (regnum
== SPARC64_NPC_REGNUM
|| regnum
== -1)
1925 regcache
->raw_supply (SPARC64_NPC_REGNUM
,
1926 regs
+ gregmap
->r_npc_offset
);
1928 if (regnum
== SPARC64_Y_REGNUM
|| regnum
== -1)
1933 memcpy (buf
+ 8 - gregmap
->r_y_size
,
1934 regs
+ gregmap
->r_y_offset
, gregmap
->r_y_size
);
1935 regcache
->raw_supply (SPARC64_Y_REGNUM
, buf
);
1938 if ((regnum
== SPARC64_FPRS_REGNUM
|| regnum
== -1)
1939 && gregmap
->r_fprs_offset
!= -1)
1940 regcache
->raw_supply (SPARC64_FPRS_REGNUM
,
1941 regs
+ gregmap
->r_fprs_offset
);
1944 if (regnum
== SPARC_G0_REGNUM
|| regnum
== -1)
1945 regcache
->raw_supply (SPARC_G0_REGNUM
, &zero
);
1947 if ((regnum
>= SPARC_G1_REGNUM
&& regnum
<= SPARC_O7_REGNUM
) || regnum
== -1)
1949 int offset
= gregmap
->r_g1_offset
;
1954 for (i
= SPARC_G1_REGNUM
; i
<= SPARC_O7_REGNUM
; i
++)
1956 if (regnum
== i
|| regnum
== -1)
1957 regcache
->raw_supply (i
, regs
+ offset
);
1962 if ((regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
) || regnum
== -1)
1964 /* Not all of the register set variants include Locals and
1965 Inputs. For those that don't, we read them off the stack. */
1966 if (gregmap
->r_l0_offset
== -1)
1970 regcache_cooked_read_unsigned (regcache
, SPARC_SP_REGNUM
, &sp
);
1971 sparc_supply_rwindow (regcache
, sp
, regnum
);
1975 int offset
= gregmap
->r_l0_offset
;
1980 for (i
= SPARC_L0_REGNUM
; i
<= SPARC_I7_REGNUM
; i
++)
1982 if (regnum
== i
|| regnum
== -1)
1983 regcache
->raw_supply (i
, regs
+ offset
);
1991 sparc64_collect_gregset (const struct sparc_gregmap
*gregmap
,
1992 const struct regcache
*regcache
,
1993 int regnum
, void *gregs
)
1995 struct gdbarch
*gdbarch
= regcache
->arch ();
1996 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1997 int sparc32
= (gdbarch_ptr_bit (gdbarch
) == 32);
1998 gdb_byte
*regs
= (gdb_byte
*) gregs
;
2003 if (regnum
== SPARC32_PSR_REGNUM
|| regnum
== -1)
2005 int offset
= gregmap
->r_tstate_offset
;
2006 ULONGEST tstate
, psr
;
2009 tstate
= extract_unsigned_integer (regs
+ offset
, 8, byte_order
);
2010 regcache
->raw_collect (SPARC32_PSR_REGNUM
, buf
);
2011 psr
= extract_unsigned_integer (buf
, 4, byte_order
);
2012 tstate
|= (psr
& PSR_ICC
) << 12;
2013 if ((psr
& (PSR_VERS
| PSR_IMPL
)) == PSR_V8PLUS
)
2014 tstate
|= (psr
& PSR_XCC
) << 20;
2015 store_unsigned_integer (buf
, 8, byte_order
, tstate
);
2016 memcpy (regs
+ offset
, buf
, 8);
2019 if (regnum
== SPARC32_PC_REGNUM
|| regnum
== -1)
2020 regcache
->raw_collect (SPARC32_PC_REGNUM
,
2021 regs
+ gregmap
->r_pc_offset
+ 4);
2023 if (regnum
== SPARC32_NPC_REGNUM
|| regnum
== -1)
2024 regcache
->raw_collect (SPARC32_NPC_REGNUM
,
2025 regs
+ gregmap
->r_npc_offset
+ 4);
2027 if (regnum
== SPARC32_Y_REGNUM
|| regnum
== -1)
2029 int offset
= gregmap
->r_y_offset
+ 8 - gregmap
->r_y_size
;
2030 regcache
->raw_collect (SPARC32_Y_REGNUM
, regs
+ offset
);
2035 if (regnum
== SPARC64_STATE_REGNUM
|| regnum
== -1)
2036 regcache
->raw_collect (SPARC64_STATE_REGNUM
,
2037 regs
+ gregmap
->r_tstate_offset
);
2039 if (regnum
== SPARC64_PC_REGNUM
|| regnum
== -1)
2040 regcache
->raw_collect (SPARC64_PC_REGNUM
,
2041 regs
+ gregmap
->r_pc_offset
);
2043 if (regnum
== SPARC64_NPC_REGNUM
|| regnum
== -1)
2044 regcache
->raw_collect (SPARC64_NPC_REGNUM
,
2045 regs
+ gregmap
->r_npc_offset
);
2047 if (regnum
== SPARC64_Y_REGNUM
|| regnum
== -1)
2051 regcache
->raw_collect (SPARC64_Y_REGNUM
, buf
);
2052 memcpy (regs
+ gregmap
->r_y_offset
,
2053 buf
+ 8 - gregmap
->r_y_size
, gregmap
->r_y_size
);
2056 if ((regnum
== SPARC64_FPRS_REGNUM
|| regnum
== -1)
2057 && gregmap
->r_fprs_offset
!= -1)
2058 regcache
->raw_collect (SPARC64_FPRS_REGNUM
,
2059 regs
+ gregmap
->r_fprs_offset
);
2063 if ((regnum
>= SPARC_G1_REGNUM
&& regnum
<= SPARC_O7_REGNUM
) || regnum
== -1)
2065 int offset
= gregmap
->r_g1_offset
;
2070 /* %g0 is always zero. */
2071 for (i
= SPARC_G1_REGNUM
; i
<= SPARC_O7_REGNUM
; i
++)
2073 if (regnum
== i
|| regnum
== -1)
2074 regcache
->raw_collect (i
, regs
+ offset
);
2079 if ((regnum
>= SPARC_L0_REGNUM
&& regnum
<= SPARC_I7_REGNUM
) || regnum
== -1)
2081 /* Not all of the register set variants include Locals and
2082 Inputs. For those that don't, we read them off the stack. */
2083 if (gregmap
->r_l0_offset
!= -1)
2085 int offset
= gregmap
->r_l0_offset
;
2090 for (i
= SPARC_L0_REGNUM
; i
<= SPARC_I7_REGNUM
; i
++)
2092 if (regnum
== i
|| regnum
== -1)
2093 regcache
->raw_collect (i
, regs
+ offset
);
2101 sparc64_supply_fpregset (const struct sparc_fpregmap
*fpregmap
,
2102 struct regcache
*regcache
,
2103 int regnum
, const void *fpregs
)
2105 int sparc32
= (gdbarch_ptr_bit (regcache
->arch ()) == 32);
2106 const gdb_byte
*regs
= (const gdb_byte
*) fpregs
;
2109 for (i
= 0; i
< 32; i
++)
2111 if (regnum
== (SPARC_F0_REGNUM
+ i
) || regnum
== -1)
2112 regcache
->raw_supply (SPARC_F0_REGNUM
+ i
,
2113 regs
+ fpregmap
->r_f0_offset
+ (i
* 4));
2118 if (regnum
== SPARC32_FSR_REGNUM
|| regnum
== -1)
2119 regcache
->raw_supply (SPARC32_FSR_REGNUM
,
2120 regs
+ fpregmap
->r_fsr_offset
);
2124 for (i
= 0; i
< 16; i
++)
2126 if (regnum
== (SPARC64_F32_REGNUM
+ i
) || regnum
== -1)
2127 regcache
->raw_supply
2128 (SPARC64_F32_REGNUM
+ i
,
2129 regs
+ fpregmap
->r_f0_offset
+ (32 * 4) + (i
* 8));
2132 if (regnum
== SPARC64_FSR_REGNUM
|| regnum
== -1)
2133 regcache
->raw_supply (SPARC64_FSR_REGNUM
,
2134 regs
+ fpregmap
->r_fsr_offset
);
2139 sparc64_collect_fpregset (const struct sparc_fpregmap
*fpregmap
,
2140 const struct regcache
*regcache
,
2141 int regnum
, void *fpregs
)
2143 int sparc32
= (gdbarch_ptr_bit (regcache
->arch ()) == 32);
2144 gdb_byte
*regs
= (gdb_byte
*) fpregs
;
2147 for (i
= 0; i
< 32; i
++)
2149 if (regnum
== (SPARC_F0_REGNUM
+ i
) || regnum
== -1)
2150 regcache
->raw_collect (SPARC_F0_REGNUM
+ i
,
2151 regs
+ fpregmap
->r_f0_offset
+ (i
* 4));
2156 if (regnum
== SPARC32_FSR_REGNUM
|| regnum
== -1)
2157 regcache
->raw_collect (SPARC32_FSR_REGNUM
,
2158 regs
+ fpregmap
->r_fsr_offset
);
2162 for (i
= 0; i
< 16; i
++)
2164 if (regnum
== (SPARC64_F32_REGNUM
+ i
) || regnum
== -1)
2165 regcache
->raw_collect (SPARC64_F32_REGNUM
+ i
,
2166 (regs
+ fpregmap
->r_f0_offset
2167 + (32 * 4) + (i
* 8)));
2170 if (regnum
== SPARC64_FSR_REGNUM
|| regnum
== -1)
2171 regcache
->raw_collect (SPARC64_FSR_REGNUM
,
2172 regs
+ fpregmap
->r_fsr_offset
);
2176 const struct sparc_fpregmap sparc64_bsd_fpregmap
=