1 /* Target-dependent code for UltraSPARC.
3 Copyright (C) 2003-2018 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"
37 #include "sparc64-tdep.h"
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 typedef 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)
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);
190 info_adi_command (const char *args, int from_tty)
192 printf_unfiltered ("\"adi\" must be followed by \"examine\" "
194 help_list (sparc64adilist, "adi ", all_commands, gdb_stdout);
197 /* Read attributes of a maps entry in /proc/[pid]/adi/maps. */
200 read_maps_entry (const char *line,
201 ULONGEST *addr, ULONGEST *endaddr)
203 const char *p = line;
205 *addr = strtoulst (p, &p, 16);
209 *endaddr = strtoulst (p, &p, 16);
212 /* Check if ADI is available. */
217 pid_t pid = inferior_ptid.pid ();
218 sparc64_adi_info *proc = get_adi_info_proc (pid);
221 if (proc->stat.checked_avail)
222 return proc->stat.is_avail;
224 proc->stat.checked_avail = true;
225 if (target_auxv_search (current_top_target (), AT_ADI_BLKSZ, &value) <= 0)
227 proc->stat.blksize = value;
228 target_auxv_search (current_top_target (), AT_ADI_NBITS, &value);
229 proc->stat.nbits = value;
230 proc->stat.max_version = (1 << proc->stat.nbits) - 2;
231 proc->stat.is_avail = true;
233 return proc->stat.is_avail;
236 /* Normalize a versioned address - a VA with ADI bits (63-60) set. */
239 adi_normalize_address (CORE_ADDR addr)
241 adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
245 /* Clear upper bits. */
246 addr &= ((uint64_t) -1) >> ast.nbits;
249 CORE_ADDR signbit = (uint64_t) 1 << (64 - ast.nbits - 1);
250 return (addr ^ signbit) - signbit;
255 /* Align a normalized address - a VA with bit 59 sign extended into
259 adi_align_address (CORE_ADDR naddr)
261 adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
263 return (naddr - (naddr % ast.blksize)) / ast.blksize;
266 /* Convert a byte count to count at a ratio of 1:adi_blksz. */
269 adi_convert_byte_count (CORE_ADDR naddr, int nbytes, CORE_ADDR locl)
271 adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
273 return ((naddr + nbytes + ast.blksize - 1) / ast.blksize) - locl;
276 /* The /proc/[pid]/adi/tags file, which allows gdb to get/set ADI
277 version in a target process, maps linearly to the address space
278 of the target process at a ratio of 1:adi_blksz.
280 A read (or write) at offset K in the file returns (or modifies)
281 the ADI version tag stored in the cacheline containing address
282 K * adi_blksz, encoded as 1 version tag per byte. The allowed
283 version tag values are between 0 and adi_stat.max_version. */
288 pid_t pid = inferior_ptid.pid ();
289 sparc64_adi_info *proc = get_adi_info_proc (pid);
291 if (proc->stat.tag_fd != 0)
292 return proc->stat.tag_fd;
294 char cl_name[MAX_PROC_NAME_SIZE];
295 snprintf (cl_name, sizeof(cl_name), "/proc/%ld/adi/tags", (long) pid);
297 proc->stat.tag_fd = target_fileio_open (NULL, cl_name, O_RDWR|O_EXCL,
299 return proc->stat.tag_fd;
302 /* Check if an address set is ADI enabled, using /proc/[pid]/adi/maps
303 which was exported by the kernel and contains the currently ADI
304 mapped memory regions and their access permissions. */
307 adi_is_addr_mapped (CORE_ADDR vaddr, size_t cnt)
309 char filename[MAX_PROC_NAME_SIZE];
312 pid_t pid = inferior_ptid.pid ();
313 snprintf (filename, sizeof filename, "/proc/%ld/adi/maps", (long) pid);
314 gdb::unique_xmalloc_ptr<char> data
315 = target_fileio_read_stralloc (NULL, filename);
318 adi_stat_t adi_stat = get_adi_info (pid);
320 for (line = strtok (data.get (), "\n"); line; line = strtok (NULL, "\n"))
322 ULONGEST addr, endaddr;
324 read_maps_entry (line, &addr, &endaddr);
326 while (((vaddr + i) * adi_stat.blksize) >= addr
327 && ((vaddr + i) * adi_stat.blksize) < endaddr)
335 warning (_("unable to open /proc file '%s'"), filename);
340 /* Read ADI version tag value for memory locations starting at "VADDR"
341 for "SIZE" number of bytes. */
344 adi_read_versions (CORE_ADDR vaddr, size_t size, gdb_byte *tags)
346 int fd = adi_tag_fd ();
350 if (!adi_is_addr_mapped (vaddr, size))
352 adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
353 error(_("Address at %s is not in ADI maps"),
354 paddress (target_gdbarch (), vaddr * ast.blksize));
358 return target_fileio_pread (fd, tags, size, vaddr, &target_errno);
361 /* Write ADI version tag for memory locations starting at "VADDR" for
362 "SIZE" number of bytes to "TAGS". */
365 adi_write_versions (CORE_ADDR vaddr, size_t size, unsigned char *tags)
367 int fd = adi_tag_fd ();
371 if (!adi_is_addr_mapped (vaddr, size))
373 adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
374 error(_("Address at %s is not in ADI maps"),
375 paddress (target_gdbarch (), vaddr * ast.blksize));
379 return target_fileio_pwrite (fd, tags, size, vaddr, &target_errno);
382 /* Print ADI version tag value in "TAGS" for memory locations starting
383 at "VADDR" with number of "CNT". */
386 adi_print_versions (CORE_ADDR vaddr, size_t cnt, gdb_byte *tags)
389 const int maxelts = 8; /* # of elements per line */
391 adi_stat_t adi_stat = get_adi_info (inferior_ptid.pid ());
396 printf_filtered ("%s:\t",
397 paddress (target_gdbarch (), vaddr * adi_stat.blksize));
398 for (int i = maxelts; i > 0 && cnt > 0; i--, cnt--)
400 if (tags[v_idx] == 0xff) /* no version tag */
401 printf_filtered ("-");
403 printf_filtered ("%1X", tags[v_idx]);
405 printf_filtered (" ");
408 printf_filtered ("\n");
409 gdb_flush (gdb_stdout);
415 do_examine (CORE_ADDR start, int bcnt)
417 CORE_ADDR vaddr = adi_normalize_address (start);
419 CORE_ADDR vstart = adi_align_address (vaddr);
420 int cnt = adi_convert_byte_count (vaddr, bcnt, vstart);
421 gdb::def_vector<gdb_byte> buf (cnt);
422 int read_cnt = adi_read_versions (vstart, cnt, buf.data ());
424 error (_("No ADI information"));
425 else if (read_cnt < cnt)
426 error(_("No ADI information at %s"), paddress (target_gdbarch (), vaddr));
428 adi_print_versions (vstart, cnt, buf.data ());
432 do_assign (CORE_ADDR start, size_t bcnt, int version)
434 CORE_ADDR vaddr = adi_normalize_address (start);
436 CORE_ADDR vstart = adi_align_address (vaddr);
437 int cnt = adi_convert_byte_count (vaddr, bcnt, vstart);
438 std::vector<unsigned char> buf (cnt, version);
439 int set_cnt = adi_write_versions (vstart, cnt, buf.data ());
442 error (_("No ADI information"));
443 else if (set_cnt < cnt)
444 error(_("No ADI information at %s"), paddress (target_gdbarch (), vaddr));
448 /* ADI examine version tag command.
452 adi (examine|x)/count <addr> */
455 adi_examine_command (const char *args, int from_tty)
457 /* make sure program is active and adi is available */
458 if (!target_has_execution)
459 error (_("ADI command requires a live process/thread"));
461 if (!adi_available ())
462 error (_("No ADI information"));
464 pid_t pid = inferior_ptid.pid ();
465 sparc64_adi_info *proc = get_adi_info_proc (pid);
467 const char *p = args;
471 cnt = get_number (&p);
474 CORE_ADDR next_address = 0;
475 if (p != 0 && *p != 0)
476 next_address = parse_and_eval_address (p);
477 if (!cnt || !next_address)
478 error (_("Usage: adi examine|x[/count] <addr>"));
480 do_examine (next_address, cnt);
483 /* ADI assign version tag command.
487 adi (assign|a)/count <addr> = <version> */
490 adi_assign_command (const char *args, int from_tty)
492 /* make sure program is active and adi is available */
493 if (!target_has_execution)
494 error (_("ADI command requires a live process/thread"));
496 if (!adi_available ())
497 error (_("No ADI information"));
499 const char *exp = args;
501 error_no_arg (_("Usage: adi assign|a[/count] <addr> = <version>"));
503 char *q = (char *) strchr (exp, '=');
507 error (_("Usage: adi assign|a[/count] <addr> = <version>"));
510 const char *p = args;
511 if (exp && *exp == '/')
514 cnt = get_number (&p);
517 CORE_ADDR next_address = 0;
518 if (p != 0 && *p != 0)
519 next_address = parse_and_eval_address (p);
521 error (_("Usage: adi assign|a[/count] <addr> = <version>"));
524 if (q != NULL) /* parse version tag */
526 adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
527 version = parse_and_eval_long (q);
528 if (version < 0 || version > ast.max_version)
529 error (_("Invalid ADI version tag %d"), version);
532 do_assign (next_address, cnt, version);
536 _initialize_sparc64_adi_tdep (void)
539 add_prefix_cmd ("adi", class_support, info_adi_command,
540 _("ADI version related commands."),
541 &sparc64adilist, "adi ", 0, &cmdlist);
542 add_cmd ("examine", class_support, adi_examine_command,
543 _("Examine ADI versions."), &sparc64adilist);
544 add_alias_cmd ("x", "examine", no_class, 1, &sparc64adilist);
545 add_cmd ("assign", class_support, adi_assign_command,
546 _("Assign ADI versions."), &sparc64adilist);
551 /* The functions on this page are intended to be used to classify
552 function arguments. */
554 /* Check whether TYPE is "Integral or Pointer". */
557 sparc64_integral_or_pointer_p (const struct type *type)
559 switch (TYPE_CODE (type))
565 case TYPE_CODE_RANGE:
567 int len = TYPE_LENGTH (type);
568 gdb_assert (len == 1 || len == 2 || len == 4 || len == 8);
573 case TYPE_CODE_RVALUE_REF:
575 int len = TYPE_LENGTH (type);
576 gdb_assert (len == 8);
586 /* Check whether TYPE is "Floating". */
589 sparc64_floating_p (const struct type *type)
591 switch (TYPE_CODE (type))
595 int len = TYPE_LENGTH (type);
596 gdb_assert (len == 4 || len == 8 || len == 16);
606 /* Check whether TYPE is "Complex Floating". */
609 sparc64_complex_floating_p (const struct type *type)
611 switch (TYPE_CODE (type))
613 case TYPE_CODE_COMPLEX:
615 int len = TYPE_LENGTH (type);
616 gdb_assert (len == 8 || len == 16 || len == 32);
626 /* Check whether TYPE is "Structure or Union".
628 In terms of Ada subprogram calls, arrays are treated the same as
629 struct and union types. So this function also returns non-zero
633 sparc64_structure_or_union_p (const struct type *type)
635 switch (TYPE_CODE (type))
637 case TYPE_CODE_STRUCT:
638 case TYPE_CODE_UNION:
639 case TYPE_CODE_ARRAY:
649 /* Construct types for ISA-specific registers. */
652 sparc64_pstate_type (struct gdbarch *gdbarch)
654 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
656 if (!tdep->sparc64_pstate_type)
660 type = arch_flags_type (gdbarch, "builtin_type_sparc64_pstate", 64);
661 append_flags_type_flag (type, 0, "AG");
662 append_flags_type_flag (type, 1, "IE");
663 append_flags_type_flag (type, 2, "PRIV");
664 append_flags_type_flag (type, 3, "AM");
665 append_flags_type_flag (type, 4, "PEF");
666 append_flags_type_flag (type, 5, "RED");
667 append_flags_type_flag (type, 8, "TLE");
668 append_flags_type_flag (type, 9, "CLE");
669 append_flags_type_flag (type, 10, "PID0");
670 append_flags_type_flag (type, 11, "PID1");
672 tdep->sparc64_pstate_type = type;
675 return tdep->sparc64_pstate_type;
679 sparc64_ccr_type (struct gdbarch *gdbarch)
681 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
683 if (tdep->sparc64_ccr_type == NULL)
687 type = arch_flags_type (gdbarch, "builtin_type_sparc64_ccr", 64);
688 append_flags_type_flag (type, 0, "icc.c");
689 append_flags_type_flag (type, 1, "icc.v");
690 append_flags_type_flag (type, 2, "icc.z");
691 append_flags_type_flag (type, 3, "icc.n");
692 append_flags_type_flag (type, 4, "xcc.c");
693 append_flags_type_flag (type, 5, "xcc.v");
694 append_flags_type_flag (type, 6, "xcc.z");
695 append_flags_type_flag (type, 7, "xcc.n");
697 tdep->sparc64_ccr_type = type;
700 return tdep->sparc64_ccr_type;
704 sparc64_fsr_type (struct gdbarch *gdbarch)
706 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
708 if (!tdep->sparc64_fsr_type)
712 type = arch_flags_type (gdbarch, "builtin_type_sparc64_fsr", 64);
713 append_flags_type_flag (type, 0, "NXC");
714 append_flags_type_flag (type, 1, "DZC");
715 append_flags_type_flag (type, 2, "UFC");
716 append_flags_type_flag (type, 3, "OFC");
717 append_flags_type_flag (type, 4, "NVC");
718 append_flags_type_flag (type, 5, "NXA");
719 append_flags_type_flag (type, 6, "DZA");
720 append_flags_type_flag (type, 7, "UFA");
721 append_flags_type_flag (type, 8, "OFA");
722 append_flags_type_flag (type, 9, "NVA");
723 append_flags_type_flag (type, 22, "NS");
724 append_flags_type_flag (type, 23, "NXM");
725 append_flags_type_flag (type, 24, "DZM");
726 append_flags_type_flag (type, 25, "UFM");
727 append_flags_type_flag (type, 26, "OFM");
728 append_flags_type_flag (type, 27, "NVM");
730 tdep->sparc64_fsr_type = type;
733 return tdep->sparc64_fsr_type;
737 sparc64_fprs_type (struct gdbarch *gdbarch)
739 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
741 if (!tdep->sparc64_fprs_type)
745 type = arch_flags_type (gdbarch, "builtin_type_sparc64_fprs", 64);
746 append_flags_type_flag (type, 0, "DL");
747 append_flags_type_flag (type, 1, "DU");
748 append_flags_type_flag (type, 2, "FEF");
750 tdep->sparc64_fprs_type = type;
753 return tdep->sparc64_fprs_type;
757 /* Register information. */
758 #define SPARC64_FPU_REGISTERS \
759 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \
760 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \
761 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", \
762 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", \
763 "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46", \
764 "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62"
765 #define SPARC64_CP0_REGISTERS \
767 /* FIXME: Give "state" a name until we start using register groups. */ \
773 static const char *sparc64_fpu_register_names[] = { SPARC64_FPU_REGISTERS };
774 static const char *sparc64_cp0_register_names[] = { SPARC64_CP0_REGISTERS };
776 static const char *sparc64_register_names[] =
778 SPARC_CORE_REGISTERS,
779 SPARC64_FPU_REGISTERS,
780 SPARC64_CP0_REGISTERS
783 /* Total number of registers. */
784 #define SPARC64_NUM_REGS ARRAY_SIZE (sparc64_register_names)
786 /* We provide the aliases %d0..%d62 and %q0..%q60 for the floating
787 registers as "psuedo" registers. */
789 static const char *sparc64_pseudo_register_names[] =
791 "cwp", "pstate", "asi", "ccr",
793 "d0", "d2", "d4", "d6", "d8", "d10", "d12", "d14",
794 "d16", "d18", "d20", "d22", "d24", "d26", "d28", "d30",
795 "d32", "d34", "d36", "d38", "d40", "d42", "d44", "d46",
796 "d48", "d50", "d52", "d54", "d56", "d58", "d60", "d62",
798 "q0", "q4", "q8", "q12", "q16", "q20", "q24", "q28",
799 "q32", "q36", "q40", "q44", "q48", "q52", "q56", "q60",
802 /* Total number of pseudo registers. */
803 #define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_names)
805 /* Return the name of pseudo register REGNUM. */
808 sparc64_pseudo_register_name (struct gdbarch *gdbarch, int regnum)
810 regnum -= gdbarch_num_regs (gdbarch);
812 if (regnum < SPARC64_NUM_PSEUDO_REGS)
813 return sparc64_pseudo_register_names[regnum];
815 internal_error (__FILE__, __LINE__,
816 _("sparc64_pseudo_register_name: bad register number %d"),
820 /* Return the name of register REGNUM. */
823 sparc64_register_name (struct gdbarch *gdbarch, int regnum)
825 if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
826 return tdesc_register_name (gdbarch, regnum);
828 if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch))
829 return sparc64_register_names[regnum];
831 return sparc64_pseudo_register_name (gdbarch, regnum);
834 /* Return the GDB type object for the "standard" data type of data in
835 pseudo register REGNUM. */
838 sparc64_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
840 regnum -= gdbarch_num_regs (gdbarch);
842 if (regnum == SPARC64_CWP_REGNUM)
843 return builtin_type (gdbarch)->builtin_int64;
844 if (regnum == SPARC64_PSTATE_REGNUM)
845 return sparc64_pstate_type (gdbarch);
846 if (regnum == SPARC64_ASI_REGNUM)
847 return builtin_type (gdbarch)->builtin_int64;
848 if (regnum == SPARC64_CCR_REGNUM)
849 return sparc64_ccr_type (gdbarch);
850 if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D62_REGNUM)
851 return builtin_type (gdbarch)->builtin_double;
852 if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q60_REGNUM)
853 return builtin_type (gdbarch)->builtin_long_double;
855 internal_error (__FILE__, __LINE__,
856 _("sparc64_pseudo_register_type: bad register number %d"),
860 /* Return the GDB type object for the "standard" data type of data in
864 sparc64_register_type (struct gdbarch *gdbarch, int regnum)
866 if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
867 return tdesc_register_type (gdbarch, regnum);
870 if (regnum == SPARC_SP_REGNUM || regnum == SPARC_FP_REGNUM)
871 return builtin_type (gdbarch)->builtin_data_ptr;
872 if (regnum >= SPARC_G0_REGNUM && regnum <= SPARC_I7_REGNUM)
873 return builtin_type (gdbarch)->builtin_int64;
874 if (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F31_REGNUM)
875 return builtin_type (gdbarch)->builtin_float;
876 if (regnum >= SPARC64_F32_REGNUM && regnum <= SPARC64_F62_REGNUM)
877 return builtin_type (gdbarch)->builtin_double;
878 if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
879 return builtin_type (gdbarch)->builtin_func_ptr;
880 /* This raw register contains the contents of %cwp, %pstate, %asi
881 and %ccr as laid out in a %tstate register. */
882 if (regnum == SPARC64_STATE_REGNUM)
883 return builtin_type (gdbarch)->builtin_int64;
884 if (regnum == SPARC64_FSR_REGNUM)
885 return sparc64_fsr_type (gdbarch);
886 if (regnum == SPARC64_FPRS_REGNUM)
887 return sparc64_fprs_type (gdbarch);
888 /* "Although Y is a 64-bit register, its high-order 32 bits are
889 reserved and always read as 0." */
890 if (regnum == SPARC64_Y_REGNUM)
891 return builtin_type (gdbarch)->builtin_int64;
893 /* Pseudo registers. */
894 if (regnum >= gdbarch_num_regs (gdbarch))
895 return sparc64_pseudo_register_type (gdbarch, regnum);
897 internal_error (__FILE__, __LINE__, _("invalid regnum"));
900 static enum register_status
901 sparc64_pseudo_register_read (struct gdbarch *gdbarch,
902 readable_regcache *regcache,
903 int regnum, gdb_byte *buf)
905 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
906 enum register_status status;
908 regnum -= gdbarch_num_regs (gdbarch);
910 if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)
912 regnum = SPARC_F0_REGNUM + 2 * (regnum - SPARC64_D0_REGNUM);
913 status = regcache->raw_read (regnum, buf);
914 if (status == REG_VALID)
915 status = regcache->raw_read (regnum + 1, buf + 4);
918 else if (regnum >= SPARC64_D32_REGNUM && regnum <= SPARC64_D62_REGNUM)
920 regnum = SPARC64_F32_REGNUM + (regnum - SPARC64_D32_REGNUM);
921 return regcache->raw_read (regnum, buf);
923 else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q28_REGNUM)
925 regnum = SPARC_F0_REGNUM + 4 * (regnum - SPARC64_Q0_REGNUM);
927 status = regcache->raw_read (regnum, buf);
928 if (status == REG_VALID)
929 status = regcache->raw_read (regnum + 1, buf + 4);
930 if (status == REG_VALID)
931 status = regcache->raw_read (regnum + 2, buf + 8);
932 if (status == REG_VALID)
933 status = regcache->raw_read (regnum + 3, buf + 12);
937 else if (regnum >= SPARC64_Q32_REGNUM && regnum <= SPARC64_Q60_REGNUM)
939 regnum = SPARC64_F32_REGNUM + 2 * (regnum - SPARC64_Q32_REGNUM);
941 status = regcache->raw_read (regnum, buf);
942 if (status == REG_VALID)
943 status = regcache->raw_read (regnum + 1, buf + 8);
947 else if (regnum == SPARC64_CWP_REGNUM
948 || regnum == SPARC64_PSTATE_REGNUM
949 || regnum == SPARC64_ASI_REGNUM
950 || regnum == SPARC64_CCR_REGNUM)
954 status = regcache->raw_read (SPARC64_STATE_REGNUM, &state);
955 if (status != REG_VALID)
960 case SPARC64_CWP_REGNUM:
961 state = (state >> 0) & ((1 << 5) - 1);
963 case SPARC64_PSTATE_REGNUM:
964 state = (state >> 8) & ((1 << 12) - 1);
966 case SPARC64_ASI_REGNUM:
967 state = (state >> 24) & ((1 << 8) - 1);
969 case SPARC64_CCR_REGNUM:
970 state = (state >> 32) & ((1 << 8) - 1);
973 store_unsigned_integer (buf, 8, byte_order, state);
980 sparc64_pseudo_register_write (struct gdbarch *gdbarch,
981 struct regcache *regcache,
982 int regnum, const gdb_byte *buf)
984 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
986 regnum -= gdbarch_num_regs (gdbarch);
988 if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)
990 regnum = SPARC_F0_REGNUM + 2 * (regnum - SPARC64_D0_REGNUM);
991 regcache->raw_write (regnum, buf);
992 regcache->raw_write (regnum + 1, buf + 4);
994 else if (regnum >= SPARC64_D32_REGNUM && regnum <= SPARC64_D62_REGNUM)
996 regnum = SPARC64_F32_REGNUM + (regnum - SPARC64_D32_REGNUM);
997 regcache->raw_write (regnum, buf);
999 else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q28_REGNUM)
1001 regnum = SPARC_F0_REGNUM + 4 * (regnum - SPARC64_Q0_REGNUM);
1002 regcache->raw_write (regnum, buf);
1003 regcache->raw_write (regnum + 1, buf + 4);
1004 regcache->raw_write (regnum + 2, buf + 8);
1005 regcache->raw_write (regnum + 3, buf + 12);
1007 else if (regnum >= SPARC64_Q32_REGNUM && regnum <= SPARC64_Q60_REGNUM)
1009 regnum = SPARC64_F32_REGNUM + 2 * (regnum - SPARC64_Q32_REGNUM);
1010 regcache->raw_write (regnum, buf);
1011 regcache->raw_write (regnum + 1, buf + 8);
1013 else if (regnum == SPARC64_CWP_REGNUM
1014 || regnum == SPARC64_PSTATE_REGNUM
1015 || regnum == SPARC64_ASI_REGNUM
1016 || regnum == SPARC64_CCR_REGNUM)
1018 ULONGEST state, bits;
1020 regcache_raw_read_unsigned (regcache, SPARC64_STATE_REGNUM, &state);
1021 bits = extract_unsigned_integer (buf, 8, byte_order);
1024 case SPARC64_CWP_REGNUM:
1025 state |= ((bits & ((1 << 5) - 1)) << 0);
1027 case SPARC64_PSTATE_REGNUM:
1028 state |= ((bits & ((1 << 12) - 1)) << 8);
1030 case SPARC64_ASI_REGNUM:
1031 state |= ((bits & ((1 << 8) - 1)) << 24);
1033 case SPARC64_CCR_REGNUM:
1034 state |= ((bits & ((1 << 8) - 1)) << 32);
1037 regcache_raw_write_unsigned (regcache, SPARC64_STATE_REGNUM, state);
1042 /* Return PC of first real instruction of the function starting at
1046 sparc64_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
1048 struct symtab_and_line sal;
1049 CORE_ADDR func_start, func_end;
1050 struct sparc_frame_cache cache;
1052 /* This is the preferred method, find the end of the prologue by
1053 using the debugging information. */
1054 if (find_pc_partial_function (start_pc, NULL, &func_start, &func_end))
1056 sal = find_pc_line (func_start, 0);
1058 if (sal.end < func_end
1059 && start_pc <= sal.end)
1063 return sparc_analyze_prologue (gdbarch, start_pc, 0xffffffffffffffffULL,
1067 /* Normal frames. */
1069 static struct sparc_frame_cache *
1070 sparc64_frame_cache (struct frame_info *this_frame, void **this_cache)
1072 return sparc_frame_cache (this_frame, this_cache);
1076 sparc64_frame_this_id (struct frame_info *this_frame, void **this_cache,
1077 struct frame_id *this_id)
1079 struct sparc_frame_cache *cache =
1080 sparc64_frame_cache (this_frame, this_cache);
1082 /* This marks the outermost frame. */
1083 if (cache->base == 0)
1086 (*this_id) = frame_id_build (cache->base, cache->pc);
1089 static struct value *
1090 sparc64_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1093 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1094 struct sparc_frame_cache *cache =
1095 sparc64_frame_cache (this_frame, this_cache);
1097 if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
1099 CORE_ADDR pc = (regnum == SPARC64_NPC_REGNUM) ? 4 : 0;
1102 (cache->copied_regs_mask & 0x80) ? SPARC_I7_REGNUM : SPARC_O7_REGNUM;
1103 pc += get_frame_register_unsigned (this_frame, regnum) + 8;
1104 return frame_unwind_got_constant (this_frame, regnum, pc);
1107 /* Handle StackGhost. */
1109 ULONGEST wcookie = sparc_fetch_wcookie (gdbarch);
1111 if (wcookie != 0 && !cache->frameless_p && regnum == SPARC_I7_REGNUM)
1113 CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 8;
1116 /* Read the value in from memory. */
1117 i7 = get_frame_memory_unsigned (this_frame, addr, 8);
1118 return frame_unwind_got_constant (this_frame, regnum, i7 ^ wcookie);
1122 /* The previous frame's `local' and `in' registers may have been saved
1123 in the register save area. */
1124 if (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM
1125 && (cache->saved_regs_mask & (1 << (regnum - SPARC_L0_REGNUM))))
1127 CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 8;
1129 return frame_unwind_got_memory (this_frame, regnum, addr);
1132 /* The previous frame's `out' registers may be accessible as the current
1133 frame's `in' registers. */
1134 if (regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM
1135 && (cache->copied_regs_mask & (1 << (regnum - SPARC_O0_REGNUM))))
1136 regnum += (SPARC_I0_REGNUM - SPARC_O0_REGNUM);
1138 return frame_unwind_got_register (this_frame, regnum, regnum);
1141 static const struct frame_unwind sparc64_frame_unwind =
1144 default_frame_unwind_stop_reason,
1145 sparc64_frame_this_id,
1146 sparc64_frame_prev_register,
1148 default_frame_sniffer
1153 sparc64_frame_base_address (struct frame_info *this_frame, void **this_cache)
1155 struct sparc_frame_cache *cache =
1156 sparc64_frame_cache (this_frame, this_cache);
1161 static const struct frame_base sparc64_frame_base =
1163 &sparc64_frame_unwind,
1164 sparc64_frame_base_address,
1165 sparc64_frame_base_address,
1166 sparc64_frame_base_address
1169 /* Check whether TYPE must be 16-byte aligned. */
1172 sparc64_16_byte_align_p (struct type *type)
1174 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1176 struct type *t = check_typedef (TYPE_TARGET_TYPE (type));
1178 if (sparc64_floating_p (t))
1181 if (sparc64_floating_p (type) && TYPE_LENGTH (type) == 16)
1184 if (sparc64_structure_or_union_p (type))
1188 for (i = 0; i < TYPE_NFIELDS (type); i++)
1190 struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
1192 if (sparc64_16_byte_align_p (subtype))
1200 /* Store floating fields of element ELEMENT of an "parameter array"
1201 that has type TYPE and is stored at BITPOS in VALBUF in the
1202 apropriate registers of REGCACHE. This function can be called
1203 recursively and therefore handles floating types in addition to
1207 sparc64_store_floating_fields (struct regcache *regcache, struct type *type,
1208 const gdb_byte *valbuf, int element, int bitpos)
1210 struct gdbarch *gdbarch = regcache->arch ();
1211 int len = TYPE_LENGTH (type);
1213 gdb_assert (element < 16);
1215 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1218 int regnum = SPARC_F0_REGNUM + element * 2 + bitpos / 32;
1220 valbuf += bitpos / 8;
1223 memset (buf, 0, 8 - len);
1224 memcpy (buf + 8 - len, valbuf, len);
1228 for (int n = 0; n < (len + 3) / 4; n++)
1229 regcache->cooked_write (regnum + n, valbuf + n * 4);
1231 else if (sparc64_floating_p (type)
1232 || (sparc64_complex_floating_p (type) && len <= 16))
1238 gdb_assert (bitpos == 0);
1239 gdb_assert ((element % 2) == 0);
1241 regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM + element / 2;
1242 regcache->cooked_write (regnum, valbuf);
1246 gdb_assert (bitpos == 0 || bitpos == 64);
1248 regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
1249 + element + bitpos / 64;
1250 regcache->cooked_write (regnum, valbuf + (bitpos / 8));
1254 gdb_assert (len == 4);
1255 gdb_assert (bitpos % 32 == 0 && bitpos >= 0 && bitpos < 128);
1257 regnum = SPARC_F0_REGNUM + element * 2 + bitpos / 32;
1258 regcache->cooked_write (regnum, valbuf + (bitpos / 8));
1261 else if (sparc64_structure_or_union_p (type))
1265 for (i = 0; i < TYPE_NFIELDS (type); i++)
1267 struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
1268 int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
1270 sparc64_store_floating_fields (regcache, subtype, valbuf,
1274 /* GCC has an interesting bug. If TYPE is a structure that has
1275 a single `float' member, GCC doesn't treat it as a structure
1276 at all, but rather as an ordinary `float' argument. This
1277 argument will be stored in %f1, as required by the psABI.
1278 However, as a member of a structure the psABI requires it to
1279 be stored in %f0. This bug is present in GCC 3.3.2, but
1280 probably in older releases to. To appease GCC, if a
1281 structure has only a single `float' member, we store its
1282 value in %f1 too (we already have stored in %f0). */
1283 if (TYPE_NFIELDS (type) == 1)
1285 struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, 0));
1287 if (sparc64_floating_p (subtype) && TYPE_LENGTH (subtype) == 4)
1288 regcache->cooked_write (SPARC_F1_REGNUM, valbuf);
1293 /* Fetch floating fields from a variable of type TYPE from the
1294 appropriate registers for BITPOS in REGCACHE and store it at BITPOS
1295 in VALBUF. This function can be called recursively and therefore
1296 handles floating types in addition to structures. */
1299 sparc64_extract_floating_fields (struct regcache *regcache, struct type *type,
1300 gdb_byte *valbuf, int bitpos)
1302 struct gdbarch *gdbarch = regcache->arch ();
1304 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1306 int len = TYPE_LENGTH (type);
1307 int regnum = SPARC_F0_REGNUM + bitpos / 32;
1309 valbuf += bitpos / 8;
1313 regcache->cooked_read (regnum, buf);
1314 memcpy (valbuf, buf + 4 - len, len);
1317 for (int i = 0; i < (len + 3) / 4; i++)
1318 regcache->cooked_read (regnum + i, valbuf + i * 4);
1320 else if (sparc64_floating_p (type))
1322 int len = TYPE_LENGTH (type);
1327 gdb_assert (bitpos == 0 || bitpos == 128);
1329 regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM
1331 regcache->cooked_read (regnum, valbuf + (bitpos / 8));
1335 gdb_assert (bitpos % 64 == 0 && bitpos >= 0 && bitpos < 256);
1337 regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + bitpos / 64;
1338 regcache->cooked_read (regnum, valbuf + (bitpos / 8));
1342 gdb_assert (len == 4);
1343 gdb_assert (bitpos % 32 == 0 && bitpos >= 0 && bitpos < 256);
1345 regnum = SPARC_F0_REGNUM + bitpos / 32;
1346 regcache->cooked_read (regnum, valbuf + (bitpos / 8));
1349 else if (sparc64_structure_or_union_p (type))
1353 for (i = 0; i < TYPE_NFIELDS (type); i++)
1355 struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
1356 int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
1358 sparc64_extract_floating_fields (regcache, subtype, valbuf, subpos);
1363 /* Store the NARGS arguments ARGS and STRUCT_ADDR (if STRUCT_RETURN is
1364 non-zero) in REGCACHE and on the stack (starting from address SP). */
1367 sparc64_store_arguments (struct regcache *regcache, int nargs,
1368 struct value **args, CORE_ADDR sp,
1369 int struct_return, CORE_ADDR struct_addr)
1371 struct gdbarch *gdbarch = regcache->arch ();
1372 /* Number of extended words in the "parameter array". */
1373 int num_elements = 0;
1377 /* Take BIAS into account. */
1380 /* First we calculate the number of extended words in the "parameter
1381 array". While doing so we also convert some of the arguments. */
1386 for (i = 0; i < nargs; i++)
1388 struct type *type = value_type (args[i]);
1389 int len = TYPE_LENGTH (type);
1391 if (sparc64_structure_or_union_p (type)
1392 || (sparc64_complex_floating_p (type) && len == 32))
1394 /* Structure or Union arguments. */
1397 if (num_elements % 2 && sparc64_16_byte_align_p (type))
1399 num_elements += ((len + 7) / 8);
1403 /* The psABI says that "Structures or unions larger than
1404 sixteen bytes are copied by the caller and passed
1405 indirectly; the caller will pass the address of a
1406 correctly aligned structure value. This sixty-four
1407 bit address will occupy one word in the parameter
1408 array, and may be promoted to an %o register like any
1409 other pointer value." Allocate memory for these
1410 values on the stack. */
1413 /* Use 16-byte alignment for these values. That's
1414 always correct, and wasting a few bytes shouldn't be
1418 write_memory (sp, value_contents (args[i]), len);
1419 args[i] = value_from_pointer (lookup_pointer_type (type), sp);
1423 else if (sparc64_floating_p (type) || sparc64_complex_floating_p (type))
1425 /* Floating arguments. */
1428 /* The psABI says that "Each quad-precision parameter
1429 value will be assigned to two extended words in the
1433 /* The psABI says that "Long doubles must be
1434 quad-aligned, and thus a hole might be introduced
1435 into the parameter array to force alignment." Skip
1436 an element if necessary. */
1437 if ((num_elements % 2) && sparc64_16_byte_align_p (type))
1445 /* Integral and pointer arguments. */
1446 gdb_assert (sparc64_integral_or_pointer_p (type));
1448 /* The psABI says that "Each argument value of integral type
1449 smaller than an extended word will be widened by the
1450 caller to an extended word according to the signed-ness
1451 of the argument type." */
1453 args[i] = value_cast (builtin_type (gdbarch)->builtin_int64,
1459 /* Allocate the "parameter array". */
1460 sp -= num_elements * 8;
1462 /* The psABI says that "Every stack frame must be 16-byte aligned." */
1465 /* Now we store the arguments in to the "paramater array". Some
1466 Integer or Pointer arguments and Structure or Union arguments
1467 will be passed in %o registers. Some Floating arguments and
1468 floating members of structures are passed in floating-point
1469 registers. However, for functions with variable arguments,
1470 floating arguments are stored in an %0 register, and for
1471 functions without a prototype floating arguments are stored in
1472 both a floating-point and an %o registers, or a floating-point
1473 register and memory. To simplify the logic here we always pass
1474 arguments in memory, an %o register, and a floating-point
1475 register if appropriate. This should be no problem since the
1476 contents of any unused memory or registers in the "parameter
1477 array" are undefined. */
1481 regcache_cooked_write_unsigned (regcache, SPARC_O0_REGNUM, struct_addr);
1485 for (i = 0; i < nargs; i++)
1487 const gdb_byte *valbuf = value_contents (args[i]);
1488 struct type *type = value_type (args[i]);
1489 int len = TYPE_LENGTH (type);
1493 if (sparc64_structure_or_union_p (type)
1494 || (sparc64_complex_floating_p (type) && len == 32))
1496 /* Structure, Union or long double Complex arguments. */
1497 gdb_assert (len <= 16);
1498 memset (buf, 0, sizeof (buf));
1499 memcpy (buf, valbuf, len);
1502 if (element % 2 && sparc64_16_byte_align_p (type))
1507 regnum = SPARC_O0_REGNUM + element;
1508 if (len > 8 && element < 5)
1509 regcache->cooked_write (regnum + 1, valbuf + 8);
1513 sparc64_store_floating_fields (regcache, type, valbuf, element, 0);
1515 else if (sparc64_complex_floating_p (type))
1517 /* Float Complex or double Complex arguments. */
1520 regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + element;
1524 if (regnum < gdbarch_num_regs (gdbarch) + SPARC64_D30_REGNUM)
1525 regcache->cooked_write (regnum + 1, valbuf + 8);
1526 if (regnum < gdbarch_num_regs (gdbarch) + SPARC64_D10_REGNUM)
1527 regcache->cooked_write (SPARC_O0_REGNUM + element + 1,
1532 else if (sparc64_floating_p (type))
1534 /* Floating arguments. */
1540 regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM
1546 regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
1551 /* The psABI says "Each single-precision parameter value
1552 will be assigned to one extended word in the
1553 parameter array, and right-justified within that
1554 word; the left half (even float register) is
1555 undefined." Even though the psABI says that "the
1556 left half is undefined", set it to zero here. */
1558 memcpy (buf + 4, valbuf, 4);
1562 regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
1568 /* Integral and pointer arguments. */
1569 gdb_assert (len == 8);
1571 regnum = SPARC_O0_REGNUM + element;
1576 regcache->cooked_write (regnum, valbuf);
1578 /* If we're storing the value in a floating-point register,
1579 also store it in the corresponding %0 register(s). */
1580 if (regnum >= gdbarch_num_regs (gdbarch))
1582 regnum -= gdbarch_num_regs (gdbarch);
1584 if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D10_REGNUM)
1586 gdb_assert (element < 6);
1587 regnum = SPARC_O0_REGNUM + element;
1588 regcache->cooked_write (regnum, valbuf);
1590 else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q8_REGNUM)
1592 gdb_assert (element < 5);
1593 regnum = SPARC_O0_REGNUM + element;
1594 regcache->cooked_write (regnum, valbuf);
1595 regcache->cooked_write (regnum + 1, valbuf + 8);
1600 /* Always store the argument in memory. */
1601 write_memory (sp + element * 8, valbuf, len);
1602 element += ((len + 7) / 8);
1605 gdb_assert (element == num_elements);
1607 /* Take BIAS into account. */
1613 sparc64_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
1615 /* The ABI requires 16-byte alignment. */
1616 return address & ~0xf;
1620 sparc64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1621 struct regcache *regcache, CORE_ADDR bp_addr,
1622 int nargs, struct value **args, CORE_ADDR sp,
1623 int struct_return, CORE_ADDR struct_addr)
1625 /* Set return address. */
1626 regcache_cooked_write_unsigned (regcache, SPARC_O7_REGNUM, bp_addr - 8);
1628 /* Set up function arguments. */
1629 sp = sparc64_store_arguments (regcache, nargs, args, sp,
1630 struct_return, struct_addr);
1632 /* Allocate the register save area. */
1635 /* Stack should be 16-byte aligned at this point. */
1636 gdb_assert ((sp + BIAS) % 16 == 0);
1638 /* Finally, update the stack pointer. */
1639 regcache_cooked_write_unsigned (regcache, SPARC_SP_REGNUM, sp);
1645 /* Extract from an array REGBUF containing the (raw) register state, a
1646 function return value of TYPE, and copy that into VALBUF. */
1649 sparc64_extract_return_value (struct type *type, struct regcache *regcache,
1652 int len = TYPE_LENGTH (type);
1656 if (sparc64_structure_or_union_p (type))
1658 /* Structure or Union return values. */
1659 gdb_assert (len <= 32);
1661 for (i = 0; i < ((len + 7) / 8); i++)
1662 regcache->cooked_read (SPARC_O0_REGNUM + i, buf + i * 8);
1663 if (TYPE_CODE (type) != TYPE_CODE_UNION)
1664 sparc64_extract_floating_fields (regcache, type, buf, 0);
1665 memcpy (valbuf, buf, len);
1667 else if (sparc64_floating_p (type) || sparc64_complex_floating_p (type))
1669 /* Floating return values. */
1670 for (i = 0; i < len / 4; i++)
1671 regcache->cooked_read (SPARC_F0_REGNUM + i, buf + i * 4);
1672 memcpy (valbuf, buf, len);
1674 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1676 /* Small arrays are returned the same way as small structures. */
1677 gdb_assert (len <= 32);
1679 for (i = 0; i < ((len + 7) / 8); i++)
1680 regcache->cooked_read (SPARC_O0_REGNUM + i, buf + i * 8);
1681 memcpy (valbuf, buf, len);
1685 /* Integral and pointer return values. */
1686 gdb_assert (sparc64_integral_or_pointer_p (type));
1688 /* Just stripping off any unused bytes should preserve the
1689 signed-ness just fine. */
1690 regcache->cooked_read (SPARC_O0_REGNUM, buf);
1691 memcpy (valbuf, buf + 8 - len, len);
1695 /* Write into the appropriate registers a function return value stored
1696 in VALBUF of type TYPE. */
1699 sparc64_store_return_value (struct type *type, struct regcache *regcache,
1700 const gdb_byte *valbuf)
1702 int len = TYPE_LENGTH (type);
1706 if (sparc64_structure_or_union_p (type))
1708 /* Structure or Union return values. */
1709 gdb_assert (len <= 32);
1711 /* Simplify matters by storing the complete value (including
1712 floating members) into %o0 and %o1. Floating members are
1713 also store in the appropriate floating-point registers. */
1714 memset (buf, 0, sizeof (buf));
1715 memcpy (buf, valbuf, len);
1716 for (i = 0; i < ((len + 7) / 8); i++)
1717 regcache->cooked_write (SPARC_O0_REGNUM + i, buf + i * 8);
1718 if (TYPE_CODE (type) != TYPE_CODE_UNION)
1719 sparc64_store_floating_fields (regcache, type, buf, 0, 0);
1721 else if (sparc64_floating_p (type) || sparc64_complex_floating_p (type))
1723 /* Floating return values. */
1724 memcpy (buf, valbuf, len);
1725 for (i = 0; i < len / 4; i++)
1726 regcache->cooked_write (SPARC_F0_REGNUM + i, buf + i * 4);
1728 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1730 /* Small arrays are returned the same way as small structures. */
1731 gdb_assert (len <= 32);
1733 memset (buf, 0, sizeof (buf));
1734 memcpy (buf, valbuf, len);
1735 for (i = 0; i < ((len + 7) / 8); i++)
1736 regcache->cooked_write (SPARC_O0_REGNUM + i, buf + i * 8);
1740 /* Integral and pointer return values. */
1741 gdb_assert (sparc64_integral_or_pointer_p (type));
1743 /* ??? Do we need to do any sign-extension here? */
1745 memcpy (buf + 8 - len, valbuf, len);
1746 regcache->cooked_write (SPARC_O0_REGNUM, buf);
1750 static enum return_value_convention
1751 sparc64_return_value (struct gdbarch *gdbarch, struct value *function,
1752 struct type *type, struct regcache *regcache,
1753 gdb_byte *readbuf, const gdb_byte *writebuf)
1755 if (TYPE_LENGTH (type) > 32)
1756 return RETURN_VALUE_STRUCT_CONVENTION;
1759 sparc64_extract_return_value (type, regcache, readbuf);
1761 sparc64_store_return_value (type, regcache, writebuf);
1763 return RETURN_VALUE_REGISTER_CONVENTION;
1768 sparc64_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
1769 struct dwarf2_frame_state_reg *reg,
1770 struct frame_info *this_frame)
1774 case SPARC_G0_REGNUM:
1775 /* Since %g0 is always zero, there is no point in saving it, and
1776 people will be inclined omit it from the CFI. Make sure we
1777 don't warn about that. */
1778 reg->how = DWARF2_FRAME_REG_SAME_VALUE;
1780 case SPARC_SP_REGNUM:
1781 reg->how = DWARF2_FRAME_REG_CFA;
1783 case SPARC64_PC_REGNUM:
1784 reg->how = DWARF2_FRAME_REG_RA_OFFSET;
1785 reg->loc.offset = 8;
1787 case SPARC64_NPC_REGNUM:
1788 reg->how = DWARF2_FRAME_REG_RA_OFFSET;
1789 reg->loc.offset = 12;
1794 /* sparc64_addr_bits_remove - remove useless address bits */
1797 sparc64_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
1799 return adi_normalize_address (addr);
1803 sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1805 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1807 tdep->pc_regnum = SPARC64_PC_REGNUM;
1808 tdep->npc_regnum = SPARC64_NPC_REGNUM;
1809 tdep->fpu_register_names = sparc64_fpu_register_names;
1810 tdep->fpu_registers_num = ARRAY_SIZE (sparc64_fpu_register_names);
1811 tdep->cp0_register_names = sparc64_cp0_register_names;
1812 tdep->cp0_registers_num = ARRAY_SIZE (sparc64_cp0_register_names);
1814 /* This is what all the fuss is about. */
1815 set_gdbarch_long_bit (gdbarch, 64);
1816 set_gdbarch_long_long_bit (gdbarch, 64);
1817 set_gdbarch_ptr_bit (gdbarch, 64);
1819 set_gdbarch_wchar_bit (gdbarch, 16);
1820 set_gdbarch_wchar_signed (gdbarch, 0);
1822 set_gdbarch_num_regs (gdbarch, SPARC64_NUM_REGS);
1823 set_gdbarch_register_name (gdbarch, sparc64_register_name);
1824 set_gdbarch_register_type (gdbarch, sparc64_register_type);
1825 set_gdbarch_num_pseudo_regs (gdbarch, SPARC64_NUM_PSEUDO_REGS);
1826 set_tdesc_pseudo_register_name (gdbarch, sparc64_pseudo_register_name);
1827 set_tdesc_pseudo_register_type (gdbarch, sparc64_pseudo_register_type);
1828 set_gdbarch_pseudo_register_read (gdbarch, sparc64_pseudo_register_read);
1829 set_gdbarch_pseudo_register_write (gdbarch, sparc64_pseudo_register_write);
1831 /* Register numbers of various important registers. */
1832 set_gdbarch_pc_regnum (gdbarch, SPARC64_PC_REGNUM); /* %pc */
1834 /* Call dummy code. */
1835 set_gdbarch_frame_align (gdbarch, sparc64_frame_align);
1836 set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
1837 set_gdbarch_push_dummy_code (gdbarch, NULL);
1838 set_gdbarch_push_dummy_call (gdbarch, sparc64_push_dummy_call);
1840 set_gdbarch_return_value (gdbarch, sparc64_return_value);
1841 set_gdbarch_stabs_argument_has_addr
1842 (gdbarch, default_stabs_argument_has_addr);
1844 set_gdbarch_skip_prologue (gdbarch, sparc64_skip_prologue);
1845 set_gdbarch_stack_frame_destroyed_p (gdbarch, sparc_stack_frame_destroyed_p);
1847 /* Hook in the DWARF CFI frame unwinder. */
1848 dwarf2_frame_set_init_reg (gdbarch, sparc64_dwarf2_frame_init_reg);
1849 /* FIXME: kettenis/20050423: Don't enable the unwinder until the
1850 StackGhost issues have been resolved. */
1852 frame_unwind_append_unwinder (gdbarch, &sparc64_frame_unwind);
1853 frame_base_set_default (gdbarch, &sparc64_frame_base);
1855 set_gdbarch_addr_bits_remove (gdbarch, sparc64_addr_bits_remove);
1859 /* Helper functions for dealing with register sets. */
1861 #define TSTATE_CWP 0x000000000000001fULL
1862 #define TSTATE_ICC 0x0000000f00000000ULL
1863 #define TSTATE_XCC 0x000000f000000000ULL
1865 #define PSR_S 0x00000080
1867 #define PSR_ICC 0x00f00000
1869 #define PSR_VERS 0x0f000000
1871 #define PSR_IMPL 0xf0000000
1873 #define PSR_V8PLUS 0xff000000
1874 #define PSR_XCC 0x000f0000
1877 sparc64_supply_gregset (const struct sparc_gregmap *gregmap,
1878 struct regcache *regcache,
1879 int regnum, const void *gregs)
1881 struct gdbarch *gdbarch = regcache->arch ();
1882 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1883 int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32);
1884 const gdb_byte *regs = (const gdb_byte *) gregs;
1885 gdb_byte zero[8] = { 0 };
1890 if (regnum == SPARC32_PSR_REGNUM || regnum == -1)
1892 int offset = gregmap->r_tstate_offset;
1893 ULONGEST tstate, psr;
1896 tstate = extract_unsigned_integer (regs + offset, 8, byte_order);
1897 psr = ((tstate & TSTATE_CWP) | PSR_S | ((tstate & TSTATE_ICC) >> 12)
1898 | ((tstate & TSTATE_XCC) >> 20) | PSR_V8PLUS);
1899 store_unsigned_integer (buf, 4, byte_order, psr);
1900 regcache->raw_supply (SPARC32_PSR_REGNUM, buf);
1903 if (regnum == SPARC32_PC_REGNUM || regnum == -1)
1904 regcache->raw_supply (SPARC32_PC_REGNUM,
1905 regs + gregmap->r_pc_offset + 4);
1907 if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
1908 regcache->raw_supply (SPARC32_NPC_REGNUM,
1909 regs + gregmap->r_npc_offset + 4);
1911 if (regnum == SPARC32_Y_REGNUM || regnum == -1)
1913 int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size;
1914 regcache->raw_supply (SPARC32_Y_REGNUM, regs + offset);
1919 if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
1920 regcache->raw_supply (SPARC64_STATE_REGNUM,
1921 regs + gregmap->r_tstate_offset);
1923 if (regnum == SPARC64_PC_REGNUM || regnum == -1)
1924 regcache->raw_supply (SPARC64_PC_REGNUM,
1925 regs + gregmap->r_pc_offset);
1927 if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
1928 regcache->raw_supply (SPARC64_NPC_REGNUM,
1929 regs + gregmap->r_npc_offset);
1931 if (regnum == SPARC64_Y_REGNUM || regnum == -1)
1936 memcpy (buf + 8 - gregmap->r_y_size,
1937 regs + gregmap->r_y_offset, gregmap->r_y_size);
1938 regcache->raw_supply (SPARC64_Y_REGNUM, buf);
1941 if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
1942 && gregmap->r_fprs_offset != -1)
1943 regcache->raw_supply (SPARC64_FPRS_REGNUM,
1944 regs + gregmap->r_fprs_offset);
1947 if (regnum == SPARC_G0_REGNUM || regnum == -1)
1948 regcache->raw_supply (SPARC_G0_REGNUM, &zero);
1950 if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
1952 int offset = gregmap->r_g1_offset;
1957 for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
1959 if (regnum == i || regnum == -1)
1960 regcache->raw_supply (i, regs + offset);
1965 if ((regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM) || regnum == -1)
1967 /* Not all of the register set variants include Locals and
1968 Inputs. For those that don't, we read them off the stack. */
1969 if (gregmap->r_l0_offset == -1)
1973 regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp);
1974 sparc_supply_rwindow (regcache, sp, regnum);
1978 int offset = gregmap->r_l0_offset;
1983 for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
1985 if (regnum == i || regnum == -1)
1986 regcache->raw_supply (i, regs + offset);
1994 sparc64_collect_gregset (const struct sparc_gregmap *gregmap,
1995 const struct regcache *regcache,
1996 int regnum, void *gregs)
1998 struct gdbarch *gdbarch = regcache->arch ();
1999 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2000 int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32);
2001 gdb_byte *regs = (gdb_byte *) gregs;
2006 if (regnum == SPARC32_PSR_REGNUM || regnum == -1)
2008 int offset = gregmap->r_tstate_offset;
2009 ULONGEST tstate, psr;
2012 tstate = extract_unsigned_integer (regs + offset, 8, byte_order);
2013 regcache->raw_collect (SPARC32_PSR_REGNUM, buf);
2014 psr = extract_unsigned_integer (buf, 4, byte_order);
2015 tstate |= (psr & PSR_ICC) << 12;
2016 if ((psr & (PSR_VERS | PSR_IMPL)) == PSR_V8PLUS)
2017 tstate |= (psr & PSR_XCC) << 20;
2018 store_unsigned_integer (buf, 8, byte_order, tstate);
2019 memcpy (regs + offset, buf, 8);
2022 if (regnum == SPARC32_PC_REGNUM || regnum == -1)
2023 regcache->raw_collect (SPARC32_PC_REGNUM,
2024 regs + gregmap->r_pc_offset + 4);
2026 if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
2027 regcache->raw_collect (SPARC32_NPC_REGNUM,
2028 regs + gregmap->r_npc_offset + 4);
2030 if (regnum == SPARC32_Y_REGNUM || regnum == -1)
2032 int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size;
2033 regcache->raw_collect (SPARC32_Y_REGNUM, regs + offset);
2038 if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
2039 regcache->raw_collect (SPARC64_STATE_REGNUM,
2040 regs + gregmap->r_tstate_offset);
2042 if (regnum == SPARC64_PC_REGNUM || regnum == -1)
2043 regcache->raw_collect (SPARC64_PC_REGNUM,
2044 regs + gregmap->r_pc_offset);
2046 if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
2047 regcache->raw_collect (SPARC64_NPC_REGNUM,
2048 regs + gregmap->r_npc_offset);
2050 if (regnum == SPARC64_Y_REGNUM || regnum == -1)
2054 regcache->raw_collect (SPARC64_Y_REGNUM, buf);
2055 memcpy (regs + gregmap->r_y_offset,
2056 buf + 8 - gregmap->r_y_size, gregmap->r_y_size);
2059 if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
2060 && gregmap->r_fprs_offset != -1)
2061 regcache->raw_collect (SPARC64_FPRS_REGNUM,
2062 regs + gregmap->r_fprs_offset);
2066 if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
2068 int offset = gregmap->r_g1_offset;
2073 /* %g0 is always zero. */
2074 for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
2076 if (regnum == i || regnum == -1)
2077 regcache->raw_collect (i, regs + offset);
2082 if ((regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM) || regnum == -1)
2084 /* Not all of the register set variants include Locals and
2085 Inputs. For those that don't, we read them off the stack. */
2086 if (gregmap->r_l0_offset != -1)
2088 int offset = gregmap->r_l0_offset;
2093 for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
2095 if (regnum == i || regnum == -1)
2096 regcache->raw_collect (i, regs + offset);
2104 sparc64_supply_fpregset (const struct sparc_fpregmap *fpregmap,
2105 struct regcache *regcache,
2106 int regnum, const void *fpregs)
2108 int sparc32 = (gdbarch_ptr_bit (regcache->arch ()) == 32);
2109 const gdb_byte *regs = (const gdb_byte *) fpregs;
2112 for (i = 0; i < 32; i++)
2114 if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
2115 regcache->raw_supply (SPARC_F0_REGNUM + i,
2116 regs + fpregmap->r_f0_offset + (i * 4));
2121 if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
2122 regcache->raw_supply (SPARC32_FSR_REGNUM,
2123 regs + fpregmap->r_fsr_offset);
2127 for (i = 0; i < 16; i++)
2129 if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
2130 regcache->raw_supply
2131 (SPARC64_F32_REGNUM + i,
2132 regs + fpregmap->r_f0_offset + (32 * 4) + (i * 8));
2135 if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
2136 regcache->raw_supply (SPARC64_FSR_REGNUM,
2137 regs + fpregmap->r_fsr_offset);
2142 sparc64_collect_fpregset (const struct sparc_fpregmap *fpregmap,
2143 const struct regcache *regcache,
2144 int regnum, void *fpregs)
2146 int sparc32 = (gdbarch_ptr_bit (regcache->arch ()) == 32);
2147 gdb_byte *regs = (gdb_byte *) fpregs;
2150 for (i = 0; i < 32; i++)
2152 if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
2153 regcache->raw_collect (SPARC_F0_REGNUM + i,
2154 regs + fpregmap->r_f0_offset + (i * 4));
2159 if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
2160 regcache->raw_collect (SPARC32_FSR_REGNUM,
2161 regs + fpregmap->r_fsr_offset);
2165 for (i = 0; i < 16; i++)
2167 if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
2168 regcache->raw_collect (SPARC64_F32_REGNUM + i,
2169 (regs + fpregmap->r_f0_offset
2170 + (32 * 4) + (i * 8)));
2173 if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
2174 regcache->raw_collect (SPARC64_FSR_REGNUM,
2175 regs + fpregmap->r_fsr_offset);
2179 const struct sparc_fpregmap sparc64_bsd_fpregmap =