Automatic date update in version.in
[binutils-gdb.git] / gdb / sparc64-tdep.c
blob5ca5f2dca8c71c0b4e69781d02001b1864d71ced
1 /* Target-dependent code for UltraSPARC.
3 Copyright (C) 2003-2022 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/>. */
20 #include "defs.h"
21 #include "arch-utils.h"
22 #include "dwarf2/frame.h"
23 #include "frame.h"
24 #include "frame-base.h"
25 #include "frame-unwind.h"
26 #include "gdbcore.h"
27 #include "gdbtypes.h"
28 #include "inferior.h"
29 #include "symtab.h"
30 #include "objfiles.h"
31 #include "osabi.h"
32 #include "regcache.h"
33 #include "target-descriptions.h"
34 #include "target.h"
35 #include "value.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
42 SPARC. */
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
58 as a SIGSEGV signal.
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. */
67 #include <algorithm>
68 #include "cli/cli-utils.h"
69 #include "gdbcmd.h"
70 #include "auxv.h"
72 #define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/9999/adi/lstatus")
74 /* ELF Auxiliary vectors */
75 #ifndef AT_ADI_BLKSZ
76 #define AT_ADI_BLKSZ 34
77 #endif
78 #ifndef AT_ADI_NBITS
79 #define AT_ADI_NBITS 35
80 #endif
81 #ifndef AT_ADI_UEONADI
82 #define AT_ADI_UEONADI 36
83 #endif
85 /* ADI command list. */
86 static struct cmd_list_element *sparc64adilist = NULL;
88 /* ADI stat settings. */
89 struct adi_stat_t
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. */
97 unsigned long nbits;
99 /* The maximum ADI version tag value supported. */
100 int max_version;
102 /* ADI version tag file. */
103 int tag_fd = 0;
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_)
118 : pid (pid_)
121 /* The process identifier. */
122 pid_t pid;
124 /* The ADI stat. */
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 ();
148 else
150 return &(*found);
154 static adi_stat_t
155 get_adi_info (pid_t pid)
157 sparc64_adi_info *proc;
159 proc = get_adi_info_proc (pid);
160 return proc->stat;
163 /* Is called when GDB is no longer debugging process PID. It
164 deletes data structure that keeps track of the ADI stat. */
166 void
167 sparc64_forget_process (pid_t pid)
169 int 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);
181 break;
183 else
184 pit = it++;
189 /* Read attributes of a maps entry in /proc/[pid]/adi/maps. */
191 static void
192 read_maps_entry (const char *line,
193 ULONGEST *addr, ULONGEST *endaddr)
195 const char *p = line;
197 *addr = strtoulst (p, &p, 16);
198 if (*p == '-')
199 p++;
201 *endaddr = strtoulst (p, &p, 16);
204 /* Check if ADI is available. */
206 static bool
207 adi_available (void)
209 pid_t pid = inferior_ptid.pid ();
210 sparc64_adi_info *proc = get_adi_info_proc (pid);
211 CORE_ADDR value;
213 if (proc->stat.checked_avail)
214 return proc->stat.is_avail;
216 proc->stat.checked_avail = true;
217 if (target_auxv_search (current_inferior ()->top_target (),
218 AT_ADI_BLKSZ, &value) <= 0)
219 return false;
220 proc->stat.blksize = value;
221 target_auxv_search (current_inferior ()->top_target (),
222 AT_ADI_NBITS, &value);
223 proc->stat.nbits = value;
224 proc->stat.max_version = (1 << proc->stat.nbits) - 2;
225 proc->stat.is_avail = true;
227 return proc->stat.is_avail;
230 /* Normalize a versioned address - a VA with ADI bits (63-60) set. */
232 static CORE_ADDR
233 adi_normalize_address (CORE_ADDR addr)
235 adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
237 if (ast.nbits)
239 /* Clear upper bits. */
240 addr &= ((uint64_t) -1) >> ast.nbits;
242 /* Sign extend. */
243 CORE_ADDR signbit = (uint64_t) 1 << (64 - ast.nbits - 1);
244 return (addr ^ signbit) - signbit;
246 return addr;
249 /* Align a normalized address - a VA with bit 59 sign extended into
250 ADI bits. */
252 static CORE_ADDR
253 adi_align_address (CORE_ADDR naddr)
255 adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
257 return (naddr - (naddr % ast.blksize)) / ast.blksize;
260 /* Convert a byte count to count at a ratio of 1:adi_blksz. */
262 static int
263 adi_convert_byte_count (CORE_ADDR naddr, int nbytes, CORE_ADDR locl)
265 adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
267 return ((naddr + nbytes + ast.blksize - 1) / ast.blksize) - locl;
270 /* The /proc/[pid]/adi/tags file, which allows gdb to get/set ADI
271 version in a target process, maps linearly to the address space
272 of the target process at a ratio of 1:adi_blksz.
274 A read (or write) at offset K in the file returns (or modifies)
275 the ADI version tag stored in the cacheline containing address
276 K * adi_blksz, encoded as 1 version tag per byte. The allowed
277 version tag values are between 0 and adi_stat.max_version. */
279 static int
280 adi_tag_fd (void)
282 pid_t pid = inferior_ptid.pid ();
283 sparc64_adi_info *proc = get_adi_info_proc (pid);
285 if (proc->stat.tag_fd != 0)
286 return proc->stat.tag_fd;
288 char cl_name[MAX_PROC_NAME_SIZE];
289 snprintf (cl_name, sizeof(cl_name), "/proc/%ld/adi/tags", (long) pid);
290 int target_errno;
291 proc->stat.tag_fd = target_fileio_open (NULL, cl_name, O_RDWR|O_EXCL,
292 false, 0, &target_errno);
293 return proc->stat.tag_fd;
296 /* Check if an address set is ADI enabled, using /proc/[pid]/adi/maps
297 which was exported by the kernel and contains the currently ADI
298 mapped memory regions and their access permissions. */
300 static bool
301 adi_is_addr_mapped (CORE_ADDR vaddr, size_t cnt)
303 char filename[MAX_PROC_NAME_SIZE];
304 size_t i = 0;
306 pid_t pid = inferior_ptid.pid ();
307 snprintf (filename, sizeof filename, "/proc/%ld/adi/maps", (long) pid);
308 gdb::unique_xmalloc_ptr<char> data
309 = target_fileio_read_stralloc (NULL, filename);
310 if (data)
312 adi_stat_t adi_stat = get_adi_info (pid);
313 char *saveptr;
314 for (char *line = strtok_r (data.get (), "\n", &saveptr);
315 line;
316 line = strtok_r (NULL, "\n", &saveptr))
318 ULONGEST addr, endaddr;
320 read_maps_entry (line, &addr, &endaddr);
322 while (((vaddr + i) * adi_stat.blksize) >= addr
323 && ((vaddr + i) * adi_stat.blksize) < endaddr)
325 if (++i == cnt)
326 return true;
330 else
331 warning (_("unable to open /proc file '%s'"), filename);
333 return false;
336 /* Read ADI version tag value for memory locations starting at "VADDR"
337 for "SIZE" number of bytes. */
339 static int
340 adi_read_versions (CORE_ADDR vaddr, size_t size, gdb_byte *tags)
342 int fd = adi_tag_fd ();
343 if (fd == -1)
344 return -1;
346 if (!adi_is_addr_mapped (vaddr, size))
348 adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
349 error(_("Address at %s is not in ADI maps"),
350 paddress (target_gdbarch (), vaddr * ast.blksize));
353 int target_errno;
354 return target_fileio_pread (fd, tags, size, vaddr, &target_errno);
357 /* Write ADI version tag for memory locations starting at "VADDR" for
358 "SIZE" number of bytes to "TAGS". */
360 static int
361 adi_write_versions (CORE_ADDR vaddr, size_t size, unsigned char *tags)
363 int fd = adi_tag_fd ();
364 if (fd == -1)
365 return -1;
367 if (!adi_is_addr_mapped (vaddr, size))
369 adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
370 error(_("Address at %s is not in ADI maps"),
371 paddress (target_gdbarch (), vaddr * ast.blksize));
374 int target_errno;
375 return target_fileio_pwrite (fd, tags, size, vaddr, &target_errno);
378 /* Print ADI version tag value in "TAGS" for memory locations starting
379 at "VADDR" with number of "CNT". */
381 static void
382 adi_print_versions (CORE_ADDR vaddr, size_t cnt, gdb_byte *tags)
384 int v_idx = 0;
385 const int maxelts = 8; /* # of elements per line */
387 adi_stat_t adi_stat = get_adi_info (inferior_ptid.pid ());
389 while (cnt > 0)
391 QUIT;
392 gdb_printf ("%s:\t",
393 paddress (target_gdbarch (), vaddr * adi_stat.blksize));
394 for (int i = maxelts; i > 0 && cnt > 0; i--, cnt--)
396 if (tags[v_idx] == 0xff) /* no version tag */
397 gdb_printf ("-");
398 else
399 gdb_printf ("%1X", tags[v_idx]);
400 if (cnt > 1)
401 gdb_printf (" ");
402 ++v_idx;
404 gdb_printf ("\n");
405 vaddr += maxelts;
409 static void
410 do_examine (CORE_ADDR start, int bcnt)
412 CORE_ADDR vaddr = adi_normalize_address (start);
414 CORE_ADDR vstart = adi_align_address (vaddr);
415 int cnt = adi_convert_byte_count (vaddr, bcnt, vstart);
416 gdb::def_vector<gdb_byte> buf (cnt);
417 int read_cnt = adi_read_versions (vstart, cnt, buf.data ());
418 if (read_cnt == -1)
419 error (_("No ADI information"));
420 else if (read_cnt < cnt)
421 error(_("No ADI information at %s"), paddress (target_gdbarch (), vaddr));
423 adi_print_versions (vstart, cnt, buf.data ());
426 static void
427 do_assign (CORE_ADDR start, size_t bcnt, int version)
429 CORE_ADDR vaddr = adi_normalize_address (start);
431 CORE_ADDR vstart = adi_align_address (vaddr);
432 int cnt = adi_convert_byte_count (vaddr, bcnt, vstart);
433 std::vector<unsigned char> buf (cnt, version);
434 int set_cnt = adi_write_versions (vstart, cnt, buf.data ());
436 if (set_cnt == -1)
437 error (_("No ADI information"));
438 else if (set_cnt < cnt)
439 error(_("No ADI information at %s"), paddress (target_gdbarch (), vaddr));
443 /* ADI examine version tag command.
445 Command syntax:
447 adi (examine|x)[/COUNT] [ADDR] */
449 static void
450 adi_examine_command (const char *args, int from_tty)
452 /* make sure program is active and adi is available */
453 if (!target_has_execution ())
454 error (_("ADI command requires a live process/thread"));
456 if (!adi_available ())
457 error (_("No ADI information"));
459 int cnt = 1;
460 const char *p = args;
461 if (p && *p == '/')
463 p++;
464 cnt = get_number (&p);
467 CORE_ADDR next_address = 0;
468 if (p != 0 && *p != 0)
469 next_address = parse_and_eval_address (p);
470 if (!cnt || !next_address)
471 error (_("Usage: adi examine|x[/COUNT] [ADDR]"));
473 do_examine (next_address, cnt);
476 /* ADI assign version tag command.
478 Command syntax:
480 adi (assign|a)[/COUNT] ADDR = VERSION */
482 static void
483 adi_assign_command (const char *args, int from_tty)
485 static const char *adi_usage
486 = N_("Usage: adi assign|a[/COUNT] ADDR = VERSION");
488 /* make sure program is active and adi is available */
489 if (!target_has_execution ())
490 error (_("ADI command requires a live process/thread"));
492 if (!adi_available ())
493 error (_("No ADI information"));
495 const char *exp = args;
496 if (exp == 0)
497 error_no_arg (_(adi_usage));
499 char *q = (char *) strchr (exp, '=');
500 if (q)
501 *q++ = 0;
502 else
503 error ("%s", _(adi_usage));
505 size_t cnt = 1;
506 const char *p = args;
507 if (exp && *exp == '/')
509 p = exp + 1;
510 cnt = get_number (&p);
513 CORE_ADDR next_address = 0;
514 if (p != 0 && *p != 0)
515 next_address = parse_and_eval_address (p);
516 else
517 error ("%s", _(adi_usage));
519 int version = 0;
520 if (q != NULL) /* parse version tag */
522 adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
523 version = parse_and_eval_long (q);
524 if (version < 0 || version > ast.max_version)
525 error (_("Invalid ADI version tag %d"), version);
528 do_assign (next_address, cnt, version);
531 void _initialize_sparc64_adi_tdep ();
532 void
533 _initialize_sparc64_adi_tdep ()
535 add_basic_prefix_cmd ("adi", class_support,
536 _("ADI version related commands."),
537 &sparc64adilist, 0, &cmdlist);
538 cmd_list_element *adi_examine_cmd
539 = add_cmd ("examine", class_support, adi_examine_command,
540 _("Examine ADI versions."), &sparc64adilist);
541 add_alias_cmd ("x", adi_examine_cmd, no_class, 1, &sparc64adilist);
542 add_cmd ("assign", class_support, adi_assign_command,
543 _("Assign ADI versions."), &sparc64adilist);
548 /* The functions on this page are intended to be used to classify
549 function arguments. */
551 /* Check whether TYPE is "Integral or Pointer". */
553 static int
554 sparc64_integral_or_pointer_p (const struct type *type)
556 switch (type->code ())
558 case TYPE_CODE_INT:
559 case TYPE_CODE_BOOL:
560 case TYPE_CODE_CHAR:
561 case TYPE_CODE_ENUM:
562 case TYPE_CODE_RANGE:
564 int len = TYPE_LENGTH (type);
565 gdb_assert (len == 1 || len == 2 || len == 4 || len == 8);
567 return 1;
568 case TYPE_CODE_PTR:
569 case TYPE_CODE_REF:
570 case TYPE_CODE_RVALUE_REF:
572 int len = TYPE_LENGTH (type);
573 gdb_assert (len == 8);
575 return 1;
576 default:
577 break;
580 return 0;
583 /* Check whether TYPE is "Floating". */
585 static int
586 sparc64_floating_p (const struct type *type)
588 switch (type->code ())
590 case TYPE_CODE_FLT:
592 int len = TYPE_LENGTH (type);
593 gdb_assert (len == 4 || len == 8 || len == 16);
595 return 1;
596 default:
597 break;
600 return 0;
603 /* Check whether TYPE is "Complex Floating". */
605 static int
606 sparc64_complex_floating_p (const struct type *type)
608 switch (type->code ())
610 case TYPE_CODE_COMPLEX:
612 int len = TYPE_LENGTH (type);
613 gdb_assert (len == 8 || len == 16 || len == 32);
615 return 1;
616 default:
617 break;
620 return 0;
623 /* Check whether TYPE is "Structure or Union".
625 In terms of Ada subprogram calls, arrays are treated the same as
626 struct and union types. So this function also returns non-zero
627 for array types. */
629 static int
630 sparc64_structure_or_union_p (const struct type *type)
632 switch (type->code ())
634 case TYPE_CODE_STRUCT:
635 case TYPE_CODE_UNION:
636 case TYPE_CODE_ARRAY:
637 return 1;
638 default:
639 break;
642 return 0;
646 /* Construct types for ISA-specific registers. */
648 static struct type *
649 sparc64_pstate_type (struct gdbarch *gdbarch)
651 sparc_gdbarch_tdep *tdep = gdbarch_tdep<sparc_gdbarch_tdep> (gdbarch);
653 if (!tdep->sparc64_pstate_type)
655 struct type *type;
657 type = arch_flags_type (gdbarch, "builtin_type_sparc64_pstate", 64);
658 append_flags_type_flag (type, 0, "AG");
659 append_flags_type_flag (type, 1, "IE");
660 append_flags_type_flag (type, 2, "PRIV");
661 append_flags_type_flag (type, 3, "AM");
662 append_flags_type_flag (type, 4, "PEF");
663 append_flags_type_flag (type, 5, "RED");
664 append_flags_type_flag (type, 8, "TLE");
665 append_flags_type_flag (type, 9, "CLE");
666 append_flags_type_flag (type, 10, "PID0");
667 append_flags_type_flag (type, 11, "PID1");
669 tdep->sparc64_pstate_type = type;
672 return tdep->sparc64_pstate_type;
675 static struct type *
676 sparc64_ccr_type (struct gdbarch *gdbarch)
678 sparc_gdbarch_tdep *tdep = gdbarch_tdep<sparc_gdbarch_tdep> (gdbarch);
680 if (tdep->sparc64_ccr_type == NULL)
682 struct type *type;
684 type = arch_flags_type (gdbarch, "builtin_type_sparc64_ccr", 64);
685 append_flags_type_flag (type, 0, "icc.c");
686 append_flags_type_flag (type, 1, "icc.v");
687 append_flags_type_flag (type, 2, "icc.z");
688 append_flags_type_flag (type, 3, "icc.n");
689 append_flags_type_flag (type, 4, "xcc.c");
690 append_flags_type_flag (type, 5, "xcc.v");
691 append_flags_type_flag (type, 6, "xcc.z");
692 append_flags_type_flag (type, 7, "xcc.n");
694 tdep->sparc64_ccr_type = type;
697 return tdep->sparc64_ccr_type;
700 static struct type *
701 sparc64_fsr_type (struct gdbarch *gdbarch)
703 sparc_gdbarch_tdep *tdep = gdbarch_tdep<sparc_gdbarch_tdep> (gdbarch);
705 if (!tdep->sparc64_fsr_type)
707 struct type *type;
709 type = arch_flags_type (gdbarch, "builtin_type_sparc64_fsr", 64);
710 append_flags_type_flag (type, 0, "NXC");
711 append_flags_type_flag (type, 1, "DZC");
712 append_flags_type_flag (type, 2, "UFC");
713 append_flags_type_flag (type, 3, "OFC");
714 append_flags_type_flag (type, 4, "NVC");
715 append_flags_type_flag (type, 5, "NXA");
716 append_flags_type_flag (type, 6, "DZA");
717 append_flags_type_flag (type, 7, "UFA");
718 append_flags_type_flag (type, 8, "OFA");
719 append_flags_type_flag (type, 9, "NVA");
720 append_flags_type_flag (type, 22, "NS");
721 append_flags_type_flag (type, 23, "NXM");
722 append_flags_type_flag (type, 24, "DZM");
723 append_flags_type_flag (type, 25, "UFM");
724 append_flags_type_flag (type, 26, "OFM");
725 append_flags_type_flag (type, 27, "NVM");
727 tdep->sparc64_fsr_type = type;
730 return tdep->sparc64_fsr_type;
733 static struct type *
734 sparc64_fprs_type (struct gdbarch *gdbarch)
736 sparc_gdbarch_tdep *tdep = gdbarch_tdep<sparc_gdbarch_tdep> (gdbarch);
738 if (!tdep->sparc64_fprs_type)
740 struct type *type;
742 type = arch_flags_type (gdbarch, "builtin_type_sparc64_fprs", 64);
743 append_flags_type_flag (type, 0, "DL");
744 append_flags_type_flag (type, 1, "DU");
745 append_flags_type_flag (type, 2, "FEF");
747 tdep->sparc64_fprs_type = type;
750 return tdep->sparc64_fprs_type;
754 /* Register information. */
755 #define SPARC64_FPU_REGISTERS \
756 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \
757 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \
758 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", \
759 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", \
760 "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46", \
761 "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62"
762 #define SPARC64_CP0_REGISTERS \
763 "pc", "npc", \
764 /* FIXME: Give "state" a name until we start using register groups. */ \
765 "state", \
766 "fsr", \
767 "fprs", \
770 static const char * const sparc64_fpu_register_names[] = {
771 SPARC64_FPU_REGISTERS
773 static const char * const sparc64_cp0_register_names[] = {
774 SPARC64_CP0_REGISTERS
777 static const char * const sparc64_register_names[] =
779 SPARC_CORE_REGISTERS,
780 SPARC64_FPU_REGISTERS,
781 SPARC64_CP0_REGISTERS
784 /* Total number of registers. */
785 #define SPARC64_NUM_REGS ARRAY_SIZE (sparc64_register_names)
787 /* We provide the aliases %d0..%d62 and %q0..%q60 for the floating
788 registers as "psuedo" registers. */
790 static const char * const sparc64_pseudo_register_names[] =
792 "cwp", "pstate", "asi", "ccr",
794 "d0", "d2", "d4", "d6", "d8", "d10", "d12", "d14",
795 "d16", "d18", "d20", "d22", "d24", "d26", "d28", "d30",
796 "d32", "d34", "d36", "d38", "d40", "d42", "d44", "d46",
797 "d48", "d50", "d52", "d54", "d56", "d58", "d60", "d62",
799 "q0", "q4", "q8", "q12", "q16", "q20", "q24", "q28",
800 "q32", "q36", "q40", "q44", "q48", "q52", "q56", "q60",
803 /* Total number of pseudo registers. */
804 #define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_names)
806 /* Return the name of pseudo register REGNUM. */
808 static const char *
809 sparc64_pseudo_register_name (struct gdbarch *gdbarch, int regnum)
811 regnum -= gdbarch_num_regs (gdbarch);
813 if (regnum < SPARC64_NUM_PSEUDO_REGS)
814 return sparc64_pseudo_register_names[regnum];
816 internal_error (__FILE__, __LINE__,
817 _("sparc64_pseudo_register_name: bad register number %d"),
818 regnum);
821 /* Return the name of register REGNUM. */
823 static const char *
824 sparc64_register_name (struct gdbarch *gdbarch, int regnum)
826 if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
827 return tdesc_register_name (gdbarch, regnum);
829 if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch))
830 return sparc64_register_names[regnum];
832 return sparc64_pseudo_register_name (gdbarch, regnum);
835 /* Return the GDB type object for the "standard" data type of data in
836 pseudo register REGNUM. */
838 static struct type *
839 sparc64_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
841 regnum -= gdbarch_num_regs (gdbarch);
843 if (regnum == SPARC64_CWP_REGNUM)
844 return builtin_type (gdbarch)->builtin_int64;
845 if (regnum == SPARC64_PSTATE_REGNUM)
846 return sparc64_pstate_type (gdbarch);
847 if (regnum == SPARC64_ASI_REGNUM)
848 return builtin_type (gdbarch)->builtin_int64;
849 if (regnum == SPARC64_CCR_REGNUM)
850 return sparc64_ccr_type (gdbarch);
851 if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D62_REGNUM)
852 return builtin_type (gdbarch)->builtin_double;
853 if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q60_REGNUM)
854 return builtin_type (gdbarch)->builtin_long_double;
856 internal_error (__FILE__, __LINE__,
857 _("sparc64_pseudo_register_type: bad register number %d"),
858 regnum);
861 /* Return the GDB type object for the "standard" data type of data in
862 register REGNUM. */
864 static struct type *
865 sparc64_register_type (struct gdbarch *gdbarch, int regnum)
867 if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
868 return tdesc_register_type (gdbarch, regnum);
870 /* Raw registers. */
871 if (regnum == SPARC_SP_REGNUM || regnum == SPARC_FP_REGNUM)
872 return builtin_type (gdbarch)->builtin_data_ptr;
873 if (regnum >= SPARC_G0_REGNUM && regnum <= SPARC_I7_REGNUM)
874 return builtin_type (gdbarch)->builtin_int64;
875 if (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F31_REGNUM)
876 return builtin_type (gdbarch)->builtin_float;
877 if (regnum >= SPARC64_F32_REGNUM && regnum <= SPARC64_F62_REGNUM)
878 return builtin_type (gdbarch)->builtin_double;
879 if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
880 return builtin_type (gdbarch)->builtin_func_ptr;
881 /* This raw register contains the contents of %cwp, %pstate, %asi
882 and %ccr as laid out in a %tstate register. */
883 if (regnum == SPARC64_STATE_REGNUM)
884 return builtin_type (gdbarch)->builtin_int64;
885 if (regnum == SPARC64_FSR_REGNUM)
886 return sparc64_fsr_type (gdbarch);
887 if (regnum == SPARC64_FPRS_REGNUM)
888 return sparc64_fprs_type (gdbarch);
889 /* "Although Y is a 64-bit register, its high-order 32 bits are
890 reserved and always read as 0." */
891 if (regnum == SPARC64_Y_REGNUM)
892 return builtin_type (gdbarch)->builtin_int64;
894 /* Pseudo registers. */
895 if (regnum >= gdbarch_num_regs (gdbarch))
896 return sparc64_pseudo_register_type (gdbarch, regnum);
898 internal_error (__FILE__, __LINE__, _("invalid regnum"));
901 static enum register_status
902 sparc64_pseudo_register_read (struct gdbarch *gdbarch,
903 readable_regcache *regcache,
904 int regnum, gdb_byte *buf)
906 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
907 enum register_status status;
909 regnum -= gdbarch_num_regs (gdbarch);
911 if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)
913 regnum = SPARC_F0_REGNUM + 2 * (regnum - SPARC64_D0_REGNUM);
914 status = regcache->raw_read (regnum, buf);
915 if (status == REG_VALID)
916 status = regcache->raw_read (regnum + 1, buf + 4);
917 return status;
919 else if (regnum >= SPARC64_D32_REGNUM && regnum <= SPARC64_D62_REGNUM)
921 regnum = SPARC64_F32_REGNUM + (regnum - SPARC64_D32_REGNUM);
922 return regcache->raw_read (regnum, buf);
924 else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q28_REGNUM)
926 regnum = SPARC_F0_REGNUM + 4 * (regnum - SPARC64_Q0_REGNUM);
928 status = regcache->raw_read (regnum, buf);
929 if (status == REG_VALID)
930 status = regcache->raw_read (regnum + 1, buf + 4);
931 if (status == REG_VALID)
932 status = regcache->raw_read (regnum + 2, buf + 8);
933 if (status == REG_VALID)
934 status = regcache->raw_read (regnum + 3, buf + 12);
936 return status;
938 else if (regnum >= SPARC64_Q32_REGNUM && regnum <= SPARC64_Q60_REGNUM)
940 regnum = SPARC64_F32_REGNUM + 2 * (regnum - SPARC64_Q32_REGNUM);
942 status = regcache->raw_read (regnum, buf);
943 if (status == REG_VALID)
944 status = regcache->raw_read (regnum + 1, buf + 8);
946 return status;
948 else if (regnum == SPARC64_CWP_REGNUM
949 || regnum == SPARC64_PSTATE_REGNUM
950 || regnum == SPARC64_ASI_REGNUM
951 || regnum == SPARC64_CCR_REGNUM)
953 ULONGEST state;
955 status = regcache->raw_read (SPARC64_STATE_REGNUM, &state);
956 if (status != REG_VALID)
957 return status;
959 switch (regnum)
961 case SPARC64_CWP_REGNUM:
962 state = (state >> 0) & ((1 << 5) - 1);
963 break;
964 case SPARC64_PSTATE_REGNUM:
965 state = (state >> 8) & ((1 << 12) - 1);
966 break;
967 case SPARC64_ASI_REGNUM:
968 state = (state >> 24) & ((1 << 8) - 1);
969 break;
970 case SPARC64_CCR_REGNUM:
971 state = (state >> 32) & ((1 << 8) - 1);
972 break;
974 store_unsigned_integer (buf, 8, byte_order, state);
977 return REG_VALID;
980 static void
981 sparc64_pseudo_register_write (struct gdbarch *gdbarch,
982 struct regcache *regcache,
983 int regnum, const gdb_byte *buf)
985 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
987 regnum -= gdbarch_num_regs (gdbarch);
989 if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)
991 regnum = SPARC_F0_REGNUM + 2 * (regnum - SPARC64_D0_REGNUM);
992 regcache->raw_write (regnum, buf);
993 regcache->raw_write (regnum + 1, buf + 4);
995 else if (regnum >= SPARC64_D32_REGNUM && regnum <= SPARC64_D62_REGNUM)
997 regnum = SPARC64_F32_REGNUM + (regnum - SPARC64_D32_REGNUM);
998 regcache->raw_write (regnum, buf);
1000 else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q28_REGNUM)
1002 regnum = SPARC_F0_REGNUM + 4 * (regnum - SPARC64_Q0_REGNUM);
1003 regcache->raw_write (regnum, buf);
1004 regcache->raw_write (regnum + 1, buf + 4);
1005 regcache->raw_write (regnum + 2, buf + 8);
1006 regcache->raw_write (regnum + 3, buf + 12);
1008 else if (regnum >= SPARC64_Q32_REGNUM && regnum <= SPARC64_Q60_REGNUM)
1010 regnum = SPARC64_F32_REGNUM + 2 * (regnum - SPARC64_Q32_REGNUM);
1011 regcache->raw_write (regnum, buf);
1012 regcache->raw_write (regnum + 1, buf + 8);
1014 else if (regnum == SPARC64_CWP_REGNUM
1015 || regnum == SPARC64_PSTATE_REGNUM
1016 || regnum == SPARC64_ASI_REGNUM
1017 || regnum == SPARC64_CCR_REGNUM)
1019 ULONGEST state, bits;
1021 regcache_raw_read_unsigned (regcache, SPARC64_STATE_REGNUM, &state);
1022 bits = extract_unsigned_integer (buf, 8, byte_order);
1023 switch (regnum)
1025 case SPARC64_CWP_REGNUM:
1026 state |= ((bits & ((1 << 5) - 1)) << 0);
1027 break;
1028 case SPARC64_PSTATE_REGNUM:
1029 state |= ((bits & ((1 << 12) - 1)) << 8);
1030 break;
1031 case SPARC64_ASI_REGNUM:
1032 state |= ((bits & ((1 << 8) - 1)) << 24);
1033 break;
1034 case SPARC64_CCR_REGNUM:
1035 state |= ((bits & ((1 << 8) - 1)) << 32);
1036 break;
1038 regcache_raw_write_unsigned (regcache, SPARC64_STATE_REGNUM, state);
1043 /* Return PC of first real instruction of the function starting at
1044 START_PC. */
1046 static CORE_ADDR
1047 sparc64_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
1049 struct symtab_and_line sal;
1050 CORE_ADDR func_start, func_end;
1051 struct sparc_frame_cache cache;
1053 /* This is the preferred method, find the end of the prologue by
1054 using the debugging information. */
1055 if (find_pc_partial_function (start_pc, NULL, &func_start, &func_end))
1057 sal = find_pc_line (func_start, 0);
1059 if (sal.end < func_end
1060 && start_pc <= sal.end)
1061 return sal.end;
1064 return sparc_analyze_prologue (gdbarch, start_pc, 0xffffffffffffffffULL,
1065 &cache);
1068 /* Normal frames. */
1070 static struct sparc_frame_cache *
1071 sparc64_frame_cache (struct frame_info *this_frame, void **this_cache)
1073 return sparc_frame_cache (this_frame, this_cache);
1076 static void
1077 sparc64_frame_this_id (struct frame_info *this_frame, void **this_cache,
1078 struct frame_id *this_id)
1080 struct sparc_frame_cache *cache =
1081 sparc64_frame_cache (this_frame, this_cache);
1083 /* This marks the outermost frame. */
1084 if (cache->base == 0)
1085 return;
1087 (*this_id) = frame_id_build (cache->base, cache->pc);
1090 static struct value *
1091 sparc64_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1092 int regnum)
1094 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1095 struct sparc_frame_cache *cache =
1096 sparc64_frame_cache (this_frame, this_cache);
1098 if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
1100 CORE_ADDR pc = (regnum == SPARC64_NPC_REGNUM) ? 4 : 0;
1102 regnum =
1103 (cache->copied_regs_mask & 0x80) ? SPARC_I7_REGNUM : SPARC_O7_REGNUM;
1104 pc += get_frame_register_unsigned (this_frame, regnum) + 8;
1105 return frame_unwind_got_constant (this_frame, regnum, pc);
1108 /* Handle StackGhost. */
1110 ULONGEST wcookie = sparc_fetch_wcookie (gdbarch);
1112 if (wcookie != 0 && !cache->frameless_p && regnum == SPARC_I7_REGNUM)
1114 CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 8;
1115 ULONGEST i7;
1117 /* Read the value in from memory. */
1118 i7 = get_frame_memory_unsigned (this_frame, addr, 8);
1119 return frame_unwind_got_constant (this_frame, regnum, i7 ^ wcookie);
1123 /* The previous frame's `local' and `in' registers may have been saved
1124 in the register save area. */
1125 if (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM
1126 && (cache->saved_regs_mask & (1 << (regnum - SPARC_L0_REGNUM))))
1128 CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 8;
1130 return frame_unwind_got_memory (this_frame, regnum, addr);
1133 /* The previous frame's `out' registers may be accessible as the current
1134 frame's `in' registers. */
1135 if (regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM
1136 && (cache->copied_regs_mask & (1 << (regnum - SPARC_O0_REGNUM))))
1137 regnum += (SPARC_I0_REGNUM - SPARC_O0_REGNUM);
1139 return frame_unwind_got_register (this_frame, regnum, regnum);
1142 static const struct frame_unwind sparc64_frame_unwind =
1144 "sparc64 prologue",
1145 NORMAL_FRAME,
1146 default_frame_unwind_stop_reason,
1147 sparc64_frame_this_id,
1148 sparc64_frame_prev_register,
1149 NULL,
1150 default_frame_sniffer
1154 static CORE_ADDR
1155 sparc64_frame_base_address (struct frame_info *this_frame, void **this_cache)
1157 struct sparc_frame_cache *cache =
1158 sparc64_frame_cache (this_frame, this_cache);
1160 return cache->base;
1163 static const struct frame_base sparc64_frame_base =
1165 &sparc64_frame_unwind,
1166 sparc64_frame_base_address,
1167 sparc64_frame_base_address,
1168 sparc64_frame_base_address
1171 /* Check whether TYPE must be 16-byte aligned. */
1173 static int
1174 sparc64_16_byte_align_p (struct type *type)
1176 if (type->code () == TYPE_CODE_ARRAY)
1178 struct type *t = check_typedef (TYPE_TARGET_TYPE (type));
1180 if (sparc64_floating_p (t))
1181 return 1;
1183 if (sparc64_floating_p (type) && TYPE_LENGTH (type) == 16)
1184 return 1;
1186 if (sparc64_structure_or_union_p (type))
1188 int i;
1190 for (i = 0; i < type->num_fields (); i++)
1192 struct type *subtype = check_typedef (type->field (i).type ());
1194 if (sparc64_16_byte_align_p (subtype))
1195 return 1;
1199 return 0;
1202 /* Store floating fields of element ELEMENT of an "parameter array"
1203 that has type TYPE and is stored at BITPOS in VALBUF in the
1204 appropriate registers of REGCACHE. This function can be called
1205 recursively and therefore handles floating types in addition to
1206 structures. */
1208 static void
1209 sparc64_store_floating_fields (struct regcache *regcache, struct type *type,
1210 const gdb_byte *valbuf, int element, int bitpos)
1212 struct gdbarch *gdbarch = regcache->arch ();
1213 int len = TYPE_LENGTH (type);
1215 gdb_assert (element < 16);
1217 if (type->code () == TYPE_CODE_ARRAY)
1219 gdb_byte buf[8];
1220 int regnum = SPARC_F0_REGNUM + element * 2 + bitpos / 32;
1222 valbuf += bitpos / 8;
1223 if (len < 8)
1225 memset (buf, 0, 8 - len);
1226 memcpy (buf + 8 - len, valbuf, len);
1227 valbuf = buf;
1228 len = 8;
1230 for (int n = 0; n < (len + 3) / 4; n++)
1231 regcache->cooked_write (regnum + n, valbuf + n * 4);
1233 else if (sparc64_floating_p (type)
1234 || (sparc64_complex_floating_p (type) && len <= 16))
1236 int regnum;
1238 if (len == 16)
1240 gdb_assert (bitpos == 0);
1241 gdb_assert ((element % 2) == 0);
1243 regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM + element / 2;
1244 regcache->cooked_write (regnum, valbuf);
1246 else if (len == 8)
1248 gdb_assert (bitpos == 0 || bitpos == 64);
1250 regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
1251 + element + bitpos / 64;
1252 regcache->cooked_write (regnum, valbuf + (bitpos / 8));
1254 else
1256 gdb_assert (len == 4);
1257 gdb_assert (bitpos % 32 == 0 && bitpos >= 0 && bitpos < 128);
1259 regnum = SPARC_F0_REGNUM + element * 2 + bitpos / 32;
1260 regcache->cooked_write (regnum, valbuf + (bitpos / 8));
1263 else if (sparc64_structure_or_union_p (type))
1265 int i;
1267 for (i = 0; i < type->num_fields (); i++)
1269 struct type *subtype = check_typedef (type->field (i).type ());
1270 int subpos = bitpos + type->field (i).loc_bitpos ();
1272 sparc64_store_floating_fields (regcache, subtype, valbuf,
1273 element, subpos);
1276 /* GCC has an interesting bug. If TYPE is a structure that has
1277 a single `float' member, GCC doesn't treat it as a structure
1278 at all, but rather as an ordinary `float' argument. This
1279 argument will be stored in %f1, as required by the psABI.
1280 However, as a member of a structure the psABI requires it to
1281 be stored in %f0. This bug is present in GCC 3.3.2, but
1282 probably in older releases to. To appease GCC, if a
1283 structure has only a single `float' member, we store its
1284 value in %f1 too (we already have stored in %f0). */
1285 if (type->num_fields () == 1)
1287 struct type *subtype = check_typedef (type->field (0).type ());
1289 if (sparc64_floating_p (subtype) && TYPE_LENGTH (subtype) == 4)
1290 regcache->cooked_write (SPARC_F1_REGNUM, valbuf);
1295 /* Fetch floating fields from a variable of type TYPE from the
1296 appropriate registers for BITPOS in REGCACHE and store it at BITPOS
1297 in VALBUF. This function can be called recursively and therefore
1298 handles floating types in addition to structures. */
1300 static void
1301 sparc64_extract_floating_fields (struct regcache *regcache, struct type *type,
1302 gdb_byte *valbuf, int bitpos)
1304 struct gdbarch *gdbarch = regcache->arch ();
1306 if (type->code () == TYPE_CODE_ARRAY)
1308 int len = TYPE_LENGTH (type);
1309 int regnum = SPARC_F0_REGNUM + bitpos / 32;
1311 valbuf += bitpos / 8;
1312 if (len < 4)
1314 gdb_byte buf[4];
1315 regcache->cooked_read (regnum, buf);
1316 memcpy (valbuf, buf + 4 - len, len);
1318 else
1319 for (int i = 0; i < (len + 3) / 4; i++)
1320 regcache->cooked_read (regnum + i, valbuf + i * 4);
1322 else if (sparc64_floating_p (type))
1324 int len = TYPE_LENGTH (type);
1325 int regnum;
1327 if (len == 16)
1329 gdb_assert (bitpos == 0 || bitpos == 128);
1331 regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM
1332 + bitpos / 128;
1333 regcache->cooked_read (regnum, valbuf + (bitpos / 8));
1335 else if (len == 8)
1337 gdb_assert (bitpos % 64 == 0 && bitpos >= 0 && bitpos < 256);
1339 regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + bitpos / 64;
1340 regcache->cooked_read (regnum, valbuf + (bitpos / 8));
1342 else
1344 gdb_assert (len == 4);
1345 gdb_assert (bitpos % 32 == 0 && bitpos >= 0 && bitpos < 256);
1347 regnum = SPARC_F0_REGNUM + bitpos / 32;
1348 regcache->cooked_read (regnum, valbuf + (bitpos / 8));
1351 else if (sparc64_structure_or_union_p (type))
1353 int i;
1355 for (i = 0; i < type->num_fields (); i++)
1357 struct type *subtype = check_typedef (type->field (i).type ());
1358 int subpos = bitpos + type->field (i).loc_bitpos ();
1360 sparc64_extract_floating_fields (regcache, subtype, valbuf, subpos);
1365 /* Store the NARGS arguments ARGS and STRUCT_ADDR (if STRUCT_RETURN is
1366 non-zero) in REGCACHE and on the stack (starting from address SP). */
1368 static CORE_ADDR
1369 sparc64_store_arguments (struct regcache *regcache, int nargs,
1370 struct value **args, CORE_ADDR sp,
1371 function_call_return_method return_method,
1372 CORE_ADDR struct_addr)
1374 struct gdbarch *gdbarch = regcache->arch ();
1375 /* Number of extended words in the "parameter array". */
1376 int num_elements = 0;
1377 int element = 0;
1378 int i;
1380 /* Take BIAS into account. */
1381 sp += BIAS;
1383 /* First we calculate the number of extended words in the "parameter
1384 array". While doing so we also convert some of the arguments. */
1386 if (return_method == return_method_struct)
1387 num_elements++;
1389 for (i = 0; i < nargs; i++)
1391 struct type *type = value_type (args[i]);
1392 int len = TYPE_LENGTH (type);
1394 if (sparc64_structure_or_union_p (type)
1395 || (sparc64_complex_floating_p (type) && len == 32))
1397 /* Structure or Union arguments. */
1398 if (len <= 16)
1400 if (num_elements % 2 && sparc64_16_byte_align_p (type))
1401 num_elements++;
1402 num_elements += ((len + 7) / 8);
1404 else
1406 /* The psABI says that "Structures or unions larger than
1407 sixteen bytes are copied by the caller and passed
1408 indirectly; the caller will pass the address of a
1409 correctly aligned structure value. This sixty-four
1410 bit address will occupy one word in the parameter
1411 array, and may be promoted to an %o register like any
1412 other pointer value." Allocate memory for these
1413 values on the stack. */
1414 sp -= len;
1416 /* Use 16-byte alignment for these values. That's
1417 always correct, and wasting a few bytes shouldn't be
1418 a problem. */
1419 sp &= ~0xf;
1421 write_memory (sp, value_contents (args[i]).data (), len);
1422 args[i] = value_from_pointer (lookup_pointer_type (type), sp);
1423 num_elements++;
1426 else if (sparc64_floating_p (type) || sparc64_complex_floating_p (type))
1428 /* Floating arguments. */
1429 if (len == 16)
1431 /* The psABI says that "Each quad-precision parameter
1432 value will be assigned to two extended words in the
1433 parameter array. */
1434 num_elements += 2;
1436 /* The psABI says that "Long doubles must be
1437 quad-aligned, and thus a hole might be introduced
1438 into the parameter array to force alignment." Skip
1439 an element if necessary. */
1440 if ((num_elements % 2) && sparc64_16_byte_align_p (type))
1441 num_elements++;
1443 else
1444 num_elements++;
1446 else
1448 /* Integral and pointer arguments. */
1449 gdb_assert (sparc64_integral_or_pointer_p (type));
1451 /* The psABI says that "Each argument value of integral type
1452 smaller than an extended word will be widened by the
1453 caller to an extended word according to the signed-ness
1454 of the argument type." */
1455 if (len < 8)
1456 args[i] = value_cast (builtin_type (gdbarch)->builtin_int64,
1457 args[i]);
1458 num_elements++;
1462 /* Allocate the "parameter array". */
1463 sp -= num_elements * 8;
1465 /* The psABI says that "Every stack frame must be 16-byte aligned." */
1466 sp &= ~0xf;
1468 /* Now we store the arguments in to the "parameter array". Some
1469 Integer or Pointer arguments and Structure or Union arguments
1470 will be passed in %o registers. Some Floating arguments and
1471 floating members of structures are passed in floating-point
1472 registers. However, for functions with variable arguments,
1473 floating arguments are stored in an %0 register, and for
1474 functions without a prototype floating arguments are stored in
1475 both a floating-point and an %o registers, or a floating-point
1476 register and memory. To simplify the logic here we always pass
1477 arguments in memory, an %o register, and a floating-point
1478 register if appropriate. This should be no problem since the
1479 contents of any unused memory or registers in the "parameter
1480 array" are undefined. */
1482 if (return_method == return_method_struct)
1484 regcache_cooked_write_unsigned (regcache, SPARC_O0_REGNUM, struct_addr);
1485 element++;
1488 for (i = 0; i < nargs; i++)
1490 const gdb_byte *valbuf = value_contents (args[i]).data ();
1491 struct type *type = value_type (args[i]);
1492 int len = TYPE_LENGTH (type);
1493 int regnum = -1;
1494 gdb_byte buf[16];
1496 if (sparc64_structure_or_union_p (type)
1497 || (sparc64_complex_floating_p (type) && len == 32))
1499 /* Structure, Union or long double Complex arguments. */
1500 gdb_assert (len <= 16);
1501 memset (buf, 0, sizeof (buf));
1502 memcpy (buf, valbuf, len);
1503 valbuf = buf;
1505 if (element % 2 && sparc64_16_byte_align_p (type))
1506 element++;
1508 if (element < 6)
1510 regnum = SPARC_O0_REGNUM + element;
1511 if (len > 8 && element < 5)
1512 regcache->cooked_write (regnum + 1, valbuf + 8);
1515 if (element < 16)
1516 sparc64_store_floating_fields (regcache, type, valbuf, element, 0);
1518 else if (sparc64_complex_floating_p (type))
1520 /* Float Complex or double Complex arguments. */
1521 if (element < 16)
1523 regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + element;
1525 if (len == 16)
1527 if (regnum < gdbarch_num_regs (gdbarch) + SPARC64_D30_REGNUM)
1528 regcache->cooked_write (regnum + 1, valbuf + 8);
1529 if (regnum < gdbarch_num_regs (gdbarch) + SPARC64_D10_REGNUM)
1530 regcache->cooked_write (SPARC_O0_REGNUM + element + 1,
1531 valbuf + 8);
1535 else if (sparc64_floating_p (type))
1537 /* Floating arguments. */
1538 if (len == 16)
1540 if (element % 2)
1541 element++;
1542 if (element < 16)
1543 regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM
1544 + element / 2;
1546 else if (len == 8)
1548 if (element < 16)
1549 regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
1550 + element;
1552 else if (len == 4)
1554 /* The psABI says "Each single-precision parameter value
1555 will be assigned to one extended word in the
1556 parameter array, and right-justified within that
1557 word; the left half (even float register) is
1558 undefined." Even though the psABI says that "the
1559 left half is undefined", set it to zero here. */
1560 memset (buf, 0, 4);
1561 memcpy (buf + 4, valbuf, 4);
1562 valbuf = buf;
1563 len = 8;
1564 if (element < 16)
1565 regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
1566 + element;
1569 else
1571 /* Integral and pointer arguments. */
1572 gdb_assert (len == 8);
1573 if (element < 6)
1574 regnum = SPARC_O0_REGNUM + element;
1577 if (regnum != -1)
1579 regcache->cooked_write (regnum, valbuf);
1581 /* If we're storing the value in a floating-point register,
1582 also store it in the corresponding %0 register(s). */
1583 if (regnum >= gdbarch_num_regs (gdbarch))
1585 regnum -= gdbarch_num_regs (gdbarch);
1587 if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D10_REGNUM)
1589 gdb_assert (element < 6);
1590 regnum = SPARC_O0_REGNUM + element;
1591 regcache->cooked_write (regnum, valbuf);
1593 else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q8_REGNUM)
1595 gdb_assert (element < 5);
1596 regnum = SPARC_O0_REGNUM + element;
1597 regcache->cooked_write (regnum, valbuf);
1598 regcache->cooked_write (regnum + 1, valbuf + 8);
1603 /* Always store the argument in memory. */
1604 write_memory (sp + element * 8, valbuf, len);
1605 element += ((len + 7) / 8);
1608 gdb_assert (element == num_elements);
1610 /* Take BIAS into account. */
1611 sp -= BIAS;
1612 return sp;
1615 static CORE_ADDR
1616 sparc64_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
1618 /* The ABI requires 16-byte alignment. */
1619 return address & ~0xf;
1622 static CORE_ADDR
1623 sparc64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1624 struct regcache *regcache, CORE_ADDR bp_addr,
1625 int nargs, struct value **args, CORE_ADDR sp,
1626 function_call_return_method return_method,
1627 CORE_ADDR struct_addr)
1629 /* Set return address. */
1630 regcache_cooked_write_unsigned (regcache, SPARC_O7_REGNUM, bp_addr - 8);
1632 /* Set up function arguments. */
1633 sp = sparc64_store_arguments (regcache, nargs, args, sp, return_method,
1634 struct_addr);
1636 /* Allocate the register save area. */
1637 sp -= 16 * 8;
1639 /* Stack should be 16-byte aligned at this point. */
1640 gdb_assert ((sp + BIAS) % 16 == 0);
1642 /* Finally, update the stack pointer. */
1643 regcache_cooked_write_unsigned (regcache, SPARC_SP_REGNUM, sp);
1645 return sp + BIAS;
1649 /* Extract from an array REGBUF containing the (raw) register state, a
1650 function return value of TYPE, and copy that into VALBUF. */
1652 static void
1653 sparc64_extract_return_value (struct type *type, struct regcache *regcache,
1654 gdb_byte *valbuf)
1656 int len = TYPE_LENGTH (type);
1657 gdb_byte buf[32];
1658 int i;
1660 if (sparc64_structure_or_union_p (type))
1662 /* Structure or Union return values. */
1663 gdb_assert (len <= 32);
1665 for (i = 0; i < ((len + 7) / 8); i++)
1666 regcache->cooked_read (SPARC_O0_REGNUM + i, buf + i * 8);
1667 if (type->code () != TYPE_CODE_UNION)
1668 sparc64_extract_floating_fields (regcache, type, buf, 0);
1669 memcpy (valbuf, buf, len);
1671 else if (sparc64_floating_p (type) || sparc64_complex_floating_p (type))
1673 /* Floating return values. */
1674 for (i = 0; i < len / 4; i++)
1675 regcache->cooked_read (SPARC_F0_REGNUM + i, buf + i * 4);
1676 memcpy (valbuf, buf, len);
1678 else if (type->code () == TYPE_CODE_ARRAY)
1680 /* Small arrays are returned the same way as small structures. */
1681 gdb_assert (len <= 32);
1683 for (i = 0; i < ((len + 7) / 8); i++)
1684 regcache->cooked_read (SPARC_O0_REGNUM + i, buf + i * 8);
1685 memcpy (valbuf, buf, len);
1687 else
1689 /* Integral and pointer return values. */
1690 gdb_assert (sparc64_integral_or_pointer_p (type));
1692 /* Just stripping off any unused bytes should preserve the
1693 signed-ness just fine. */
1694 regcache->cooked_read (SPARC_O0_REGNUM, buf);
1695 memcpy (valbuf, buf + 8 - len, len);
1699 /* Write into the appropriate registers a function return value stored
1700 in VALBUF of type TYPE. */
1702 static void
1703 sparc64_store_return_value (struct type *type, struct regcache *regcache,
1704 const gdb_byte *valbuf)
1706 int len = TYPE_LENGTH (type);
1707 gdb_byte buf[16];
1708 int i;
1710 if (sparc64_structure_or_union_p (type))
1712 /* Structure or Union return values. */
1713 gdb_assert (len <= 32);
1715 /* Simplify matters by storing the complete value (including
1716 floating members) into %o0 and %o1. Floating members are
1717 also store in the appropriate floating-point registers. */
1718 memset (buf, 0, sizeof (buf));
1719 memcpy (buf, valbuf, len);
1720 for (i = 0; i < ((len + 7) / 8); i++)
1721 regcache->cooked_write (SPARC_O0_REGNUM + i, buf + i * 8);
1722 if (type->code () != TYPE_CODE_UNION)
1723 sparc64_store_floating_fields (regcache, type, buf, 0, 0);
1725 else if (sparc64_floating_p (type) || sparc64_complex_floating_p (type))
1727 /* Floating return values. */
1728 memcpy (buf, valbuf, len);
1729 for (i = 0; i < len / 4; i++)
1730 regcache->cooked_write (SPARC_F0_REGNUM + i, buf + i * 4);
1732 else if (type->code () == TYPE_CODE_ARRAY)
1734 /* Small arrays are returned the same way as small structures. */
1735 gdb_assert (len <= 32);
1737 memset (buf, 0, sizeof (buf));
1738 memcpy (buf, valbuf, len);
1739 for (i = 0; i < ((len + 7) / 8); i++)
1740 regcache->cooked_write (SPARC_O0_REGNUM + i, buf + i * 8);
1742 else
1744 /* Integral and pointer return values. */
1745 gdb_assert (sparc64_integral_or_pointer_p (type));
1747 /* ??? Do we need to do any sign-extension here? */
1748 memset (buf, 0, 8);
1749 memcpy (buf + 8 - len, valbuf, len);
1750 regcache->cooked_write (SPARC_O0_REGNUM, buf);
1754 static enum return_value_convention
1755 sparc64_return_value (struct gdbarch *gdbarch, struct value *function,
1756 struct type *type, struct regcache *regcache,
1757 gdb_byte *readbuf, const gdb_byte *writebuf)
1759 if (TYPE_LENGTH (type) > 32)
1760 return RETURN_VALUE_STRUCT_CONVENTION;
1762 if (readbuf)
1763 sparc64_extract_return_value (type, regcache, readbuf);
1764 if (writebuf)
1765 sparc64_store_return_value (type, regcache, writebuf);
1767 return RETURN_VALUE_REGISTER_CONVENTION;
1771 static void
1772 sparc64_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
1773 struct dwarf2_frame_state_reg *reg,
1774 struct frame_info *this_frame)
1776 switch (regnum)
1778 case SPARC_G0_REGNUM:
1779 /* Since %g0 is always zero, there is no point in saving it, and
1780 people will be inclined omit it from the CFI. Make sure we
1781 don't warn about that. */
1782 reg->how = DWARF2_FRAME_REG_SAME_VALUE;
1783 break;
1784 case SPARC_SP_REGNUM:
1785 reg->how = DWARF2_FRAME_REG_CFA;
1786 break;
1787 case SPARC64_PC_REGNUM:
1788 reg->how = DWARF2_FRAME_REG_RA_OFFSET;
1789 reg->loc.offset = 8;
1790 break;
1791 case SPARC64_NPC_REGNUM:
1792 reg->how = DWARF2_FRAME_REG_RA_OFFSET;
1793 reg->loc.offset = 12;
1794 break;
1798 /* sparc64_addr_bits_remove - remove useless address bits */
1800 static CORE_ADDR
1801 sparc64_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
1803 return adi_normalize_address (addr);
1806 void
1807 sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1809 sparc_gdbarch_tdep *tdep = gdbarch_tdep<sparc_gdbarch_tdep> (gdbarch);
1811 tdep->pc_regnum = SPARC64_PC_REGNUM;
1812 tdep->npc_regnum = SPARC64_NPC_REGNUM;
1813 tdep->fpu_register_names = sparc64_fpu_register_names;
1814 tdep->fpu_registers_num = ARRAY_SIZE (sparc64_fpu_register_names);
1815 tdep->cp0_register_names = sparc64_cp0_register_names;
1816 tdep->cp0_registers_num = ARRAY_SIZE (sparc64_cp0_register_names);
1818 /* This is what all the fuss is about. */
1819 set_gdbarch_long_bit (gdbarch, 64);
1820 set_gdbarch_long_long_bit (gdbarch, 64);
1821 set_gdbarch_ptr_bit (gdbarch, 64);
1823 set_gdbarch_wchar_bit (gdbarch, 16);
1824 set_gdbarch_wchar_signed (gdbarch, 0);
1826 set_gdbarch_num_regs (gdbarch, SPARC64_NUM_REGS);
1827 set_gdbarch_register_name (gdbarch, sparc64_register_name);
1828 set_gdbarch_register_type (gdbarch, sparc64_register_type);
1829 set_gdbarch_num_pseudo_regs (gdbarch, SPARC64_NUM_PSEUDO_REGS);
1830 set_tdesc_pseudo_register_name (gdbarch, sparc64_pseudo_register_name);
1831 set_tdesc_pseudo_register_type (gdbarch, sparc64_pseudo_register_type);
1832 set_gdbarch_pseudo_register_read (gdbarch, sparc64_pseudo_register_read);
1833 set_gdbarch_pseudo_register_write (gdbarch, sparc64_pseudo_register_write);
1835 /* Register numbers of various important registers. */
1836 set_gdbarch_pc_regnum (gdbarch, SPARC64_PC_REGNUM); /* %pc */
1838 /* Call dummy code. */
1839 set_gdbarch_frame_align (gdbarch, sparc64_frame_align);
1840 set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
1841 set_gdbarch_push_dummy_code (gdbarch, NULL);
1842 set_gdbarch_push_dummy_call (gdbarch, sparc64_push_dummy_call);
1844 set_gdbarch_return_value (gdbarch, sparc64_return_value);
1845 set_gdbarch_stabs_argument_has_addr
1846 (gdbarch, default_stabs_argument_has_addr);
1848 set_gdbarch_skip_prologue (gdbarch, sparc64_skip_prologue);
1849 set_gdbarch_stack_frame_destroyed_p (gdbarch, sparc_stack_frame_destroyed_p);
1851 /* Hook in the DWARF CFI frame unwinder. */
1852 dwarf2_frame_set_init_reg (gdbarch, sparc64_dwarf2_frame_init_reg);
1853 /* FIXME: kettenis/20050423: Don't enable the unwinder until the
1854 StackGhost issues have been resolved. */
1856 frame_unwind_append_unwinder (gdbarch, &sparc64_frame_unwind);
1857 frame_base_set_default (gdbarch, &sparc64_frame_base);
1859 set_gdbarch_addr_bits_remove (gdbarch, sparc64_addr_bits_remove);
1863 /* Helper functions for dealing with register sets. */
1865 #define TSTATE_CWP 0x000000000000001fULL
1866 #define TSTATE_ICC 0x0000000f00000000ULL
1867 #define TSTATE_XCC 0x000000f000000000ULL
1869 #define PSR_S 0x00000080
1870 #ifndef PSR_ICC
1871 #define PSR_ICC 0x00f00000
1872 #endif
1873 #define PSR_VERS 0x0f000000
1874 #ifndef PSR_IMPL
1875 #define PSR_IMPL 0xf0000000
1876 #endif
1877 #define PSR_V8PLUS 0xff000000
1878 #define PSR_XCC 0x000f0000
1880 void
1881 sparc64_supply_gregset (const struct sparc_gregmap *gregmap,
1882 struct regcache *regcache,
1883 int regnum, const void *gregs)
1885 struct gdbarch *gdbarch = regcache->arch ();
1886 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1887 int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32);
1888 const gdb_byte *regs = (const gdb_byte *) gregs;
1889 gdb_byte zero[8] = { 0 };
1890 int i;
1892 if (sparc32)
1894 if (regnum == SPARC32_PSR_REGNUM || regnum == -1)
1896 int offset = gregmap->r_tstate_offset;
1897 ULONGEST tstate, psr;
1898 gdb_byte buf[4];
1900 tstate = extract_unsigned_integer (regs + offset, 8, byte_order);
1901 psr = ((tstate & TSTATE_CWP) | PSR_S | ((tstate & TSTATE_ICC) >> 12)
1902 | ((tstate & TSTATE_XCC) >> 20) | PSR_V8PLUS);
1903 store_unsigned_integer (buf, 4, byte_order, psr);
1904 regcache->raw_supply (SPARC32_PSR_REGNUM, buf);
1907 if (regnum == SPARC32_PC_REGNUM || regnum == -1)
1908 regcache->raw_supply (SPARC32_PC_REGNUM,
1909 regs + gregmap->r_pc_offset + 4);
1911 if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
1912 regcache->raw_supply (SPARC32_NPC_REGNUM,
1913 regs + gregmap->r_npc_offset + 4);
1915 if (regnum == SPARC32_Y_REGNUM || regnum == -1)
1917 int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size;
1918 regcache->raw_supply (SPARC32_Y_REGNUM, regs + offset);
1921 else
1923 if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
1924 regcache->raw_supply (SPARC64_STATE_REGNUM,
1925 regs + gregmap->r_tstate_offset);
1927 if (regnum == SPARC64_PC_REGNUM || regnum == -1)
1928 regcache->raw_supply (SPARC64_PC_REGNUM,
1929 regs + gregmap->r_pc_offset);
1931 if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
1932 regcache->raw_supply (SPARC64_NPC_REGNUM,
1933 regs + gregmap->r_npc_offset);
1935 if (regnum == SPARC64_Y_REGNUM || regnum == -1)
1937 gdb_byte buf[8];
1939 memset (buf, 0, 8);
1940 memcpy (buf + 8 - gregmap->r_y_size,
1941 regs + gregmap->r_y_offset, gregmap->r_y_size);
1942 regcache->raw_supply (SPARC64_Y_REGNUM, buf);
1945 if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
1946 && gregmap->r_fprs_offset != -1)
1947 regcache->raw_supply (SPARC64_FPRS_REGNUM,
1948 regs + gregmap->r_fprs_offset);
1951 if (regnum == SPARC_G0_REGNUM || regnum == -1)
1952 regcache->raw_supply (SPARC_G0_REGNUM, &zero);
1954 if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
1956 int offset = gregmap->r_g1_offset;
1958 if (sparc32)
1959 offset += 4;
1961 for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
1963 if (regnum == i || regnum == -1)
1964 regcache->raw_supply (i, regs + offset);
1965 offset += 8;
1969 if ((regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM) || regnum == -1)
1971 /* Not all of the register set variants include Locals and
1972 Inputs. For those that don't, we read them off the stack. */
1973 if (gregmap->r_l0_offset == -1)
1975 ULONGEST sp;
1977 regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp);
1978 sparc_supply_rwindow (regcache, sp, regnum);
1980 else
1982 int offset = gregmap->r_l0_offset;
1984 if (sparc32)
1985 offset += 4;
1987 for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
1989 if (regnum == i || regnum == -1)
1990 regcache->raw_supply (i, regs + offset);
1991 offset += 8;
1997 void
1998 sparc64_collect_gregset (const struct sparc_gregmap *gregmap,
1999 const struct regcache *regcache,
2000 int regnum, void *gregs)
2002 struct gdbarch *gdbarch = regcache->arch ();
2003 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2004 int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32);
2005 gdb_byte *regs = (gdb_byte *) gregs;
2006 int i;
2008 if (sparc32)
2010 if (regnum == SPARC32_PSR_REGNUM || regnum == -1)
2012 int offset = gregmap->r_tstate_offset;
2013 ULONGEST tstate, psr;
2014 gdb_byte buf[8];
2016 tstate = extract_unsigned_integer (regs + offset, 8, byte_order);
2017 regcache->raw_collect (SPARC32_PSR_REGNUM, buf);
2018 psr = extract_unsigned_integer (buf, 4, byte_order);
2019 tstate |= (psr & PSR_ICC) << 12;
2020 if ((psr & (PSR_VERS | PSR_IMPL)) == PSR_V8PLUS)
2021 tstate |= (psr & PSR_XCC) << 20;
2022 store_unsigned_integer (buf, 8, byte_order, tstate);
2023 memcpy (regs + offset, buf, 8);
2026 if (regnum == SPARC32_PC_REGNUM || regnum == -1)
2027 regcache->raw_collect (SPARC32_PC_REGNUM,
2028 regs + gregmap->r_pc_offset + 4);
2030 if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
2031 regcache->raw_collect (SPARC32_NPC_REGNUM,
2032 regs + gregmap->r_npc_offset + 4);
2034 if (regnum == SPARC32_Y_REGNUM || regnum == -1)
2036 int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size;
2037 regcache->raw_collect (SPARC32_Y_REGNUM, regs + offset);
2040 else
2042 if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
2043 regcache->raw_collect (SPARC64_STATE_REGNUM,
2044 regs + gregmap->r_tstate_offset);
2046 if (regnum == SPARC64_PC_REGNUM || regnum == -1)
2047 regcache->raw_collect (SPARC64_PC_REGNUM,
2048 regs + gregmap->r_pc_offset);
2050 if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
2051 regcache->raw_collect (SPARC64_NPC_REGNUM,
2052 regs + gregmap->r_npc_offset);
2054 if (regnum == SPARC64_Y_REGNUM || regnum == -1)
2056 gdb_byte buf[8];
2058 regcache->raw_collect (SPARC64_Y_REGNUM, buf);
2059 memcpy (regs + gregmap->r_y_offset,
2060 buf + 8 - gregmap->r_y_size, gregmap->r_y_size);
2063 if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
2064 && gregmap->r_fprs_offset != -1)
2065 regcache->raw_collect (SPARC64_FPRS_REGNUM,
2066 regs + gregmap->r_fprs_offset);
2070 if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
2072 int offset = gregmap->r_g1_offset;
2074 if (sparc32)
2075 offset += 4;
2077 /* %g0 is always zero. */
2078 for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
2080 if (regnum == i || regnum == -1)
2081 regcache->raw_collect (i, regs + offset);
2082 offset += 8;
2086 if ((regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM) || regnum == -1)
2088 /* Not all of the register set variants include Locals and
2089 Inputs. For those that don't, we read them off the stack. */
2090 if (gregmap->r_l0_offset != -1)
2092 int offset = gregmap->r_l0_offset;
2094 if (sparc32)
2095 offset += 4;
2097 for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
2099 if (regnum == i || regnum == -1)
2100 regcache->raw_collect (i, regs + offset);
2101 offset += 8;
2107 void
2108 sparc64_supply_fpregset (const struct sparc_fpregmap *fpregmap,
2109 struct regcache *regcache,
2110 int regnum, const void *fpregs)
2112 int sparc32 = (gdbarch_ptr_bit (regcache->arch ()) == 32);
2113 const gdb_byte *regs = (const gdb_byte *) fpregs;
2114 int i;
2116 for (i = 0; i < 32; i++)
2118 if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
2119 regcache->raw_supply (SPARC_F0_REGNUM + i,
2120 regs + fpregmap->r_f0_offset + (i * 4));
2123 if (sparc32)
2125 if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
2126 regcache->raw_supply (SPARC32_FSR_REGNUM,
2127 regs + fpregmap->r_fsr_offset);
2129 else
2131 for (i = 0; i < 16; i++)
2133 if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
2134 regcache->raw_supply
2135 (SPARC64_F32_REGNUM + i,
2136 regs + fpregmap->r_f0_offset + (32 * 4) + (i * 8));
2139 if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
2140 regcache->raw_supply (SPARC64_FSR_REGNUM,
2141 regs + fpregmap->r_fsr_offset);
2145 void
2146 sparc64_collect_fpregset (const struct sparc_fpregmap *fpregmap,
2147 const struct regcache *regcache,
2148 int regnum, void *fpregs)
2150 int sparc32 = (gdbarch_ptr_bit (regcache->arch ()) == 32);
2151 gdb_byte *regs = (gdb_byte *) fpregs;
2152 int i;
2154 for (i = 0; i < 32; i++)
2156 if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
2157 regcache->raw_collect (SPARC_F0_REGNUM + i,
2158 regs + fpregmap->r_f0_offset + (i * 4));
2161 if (sparc32)
2163 if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
2164 regcache->raw_collect (SPARC32_FSR_REGNUM,
2165 regs + fpregmap->r_fsr_offset);
2167 else
2169 for (i = 0; i < 16; i++)
2171 if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
2172 regcache->raw_collect (SPARC64_F32_REGNUM + i,
2173 (regs + fpregmap->r_f0_offset
2174 + (32 * 4) + (i * 8)));
2177 if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
2178 regcache->raw_collect (SPARC64_FSR_REGNUM,
2179 regs + fpregmap->r_fsr_offset);
2183 const struct sparc_fpregmap sparc64_bsd_fpregmap =
2185 0 * 8, /* %f0 */
2186 32 * 8, /* %fsr */