projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Remove regcache_descr fields sizeof_raw_register_status and sizeof_cooked_register_status
[deliverable/binutils-gdb.git] / gdb / sparc64-tdep.c
CommitLineData
8b39fe56
MK		 1/* Target-dependent code for UltraSPARC.
2
61baf725 3 Copyright (C) 2003-2017 Free Software Foundation, Inc.
8b39fe56
MK		 4
5 This file is part of GDB.
6
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
a9762ec7 9 the Free Software Foundation; either version 3 of the License, or
8b39fe56
MK		 10 (at your option) any later version.
11
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.
16
17 You should have received a copy of the GNU General Public License
a9762ec7 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
8b39fe56
MK		 19
20#include "defs.h"
21#include "arch-utils.h"
02a71ae8 22#include "dwarf2-frame.h"
8b39fe56
MK		 23#include "frame.h"
24#include "frame-base.h"
25#include "frame-unwind.h"
26#include "gdbcore.h"
27#include "gdbtypes.h"
386c036b
MK		 28#include "inferior.h"
29#include "symtab.h"
30#include "objfiles.h"
8b39fe56
MK		 31#include "osabi.h"
32#include "regcache.h"
3f7b46f2 33#include "target-descriptions.h"
8b39fe56
MK		 34#include "target.h"
35#include "value.h"
36
8b39fe56
MK		 37#include "sparc64-tdep.h"
38
b021a221 39/* This file implements the SPARC 64-bit ABI as defined by the
8b39fe56
MK		 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. */
43
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. */
8b39fe56 47\f
58afddc6
WP		 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.
59
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.
63
64 Note that 32-bit applications cannot use ADI. */
65
66
67#include <algorithm>
68#include "cli/cli-utils.h"
69#include "gdbcmd.h"
70#include "auxv.h"
71
72#define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/9999/adi/lstatus")
73
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
84
85/* ADI command list. */
86static struct cmd_list_element *sparc64adilist = NULL;
87
88/* ADI stat settings. */
89typedef struct
90{
91 /* The ADI block size. */
92 unsigned long blksize;
93
94 /* Number of bits used for an ADI version tag which can be
654670a4
WP		 95 used together with the shift value for an ADI version tag
96 to encode or extract the ADI version value in a pointer. */
58afddc6
WP		 97 unsigned long nbits;
98
99 /* The maximum ADI version tag value supported. */
100 int max_version;
101
102 /* ADI version tag file. */
103 int tag_fd = 0;
104
105 /* ADI availability check has been done. */
106 bool checked_avail = false;
107
108 /* ADI is available. */
109 bool is_avail = false;
110
111} adi_stat_t;
112
113/* Per-process ADI stat info. */
114
115typedef struct sparc64_adi_info
116{
117 sparc64_adi_info (pid_t pid_)
118 : pid (pid_)
119 {}
120
121 /* The process identifier. */
122 pid_t pid;
123
124 /* The ADI stat. */
125 adi_stat_t stat = {};
126
127} sparc64_adi_info;
128
129static std::forward_list<sparc64_adi_info> adi_proc_list;
130
131
132/* Get ADI info for process PID, creating one if it doesn't exist. */
133
134static sparc64_adi_info *
135get_adi_info_proc (pid_t pid)
136{
137 auto found = std::find_if (adi_proc_list.begin (), adi_proc_list.end (),
138 [&pid] (const sparc64_adi_info &info)
139 {
140 return info.pid == pid;
141 });
142
143 if (found == adi_proc_list.end ())
144 {
145 adi_proc_list.emplace_front (pid);
146 return &adi_proc_list.front ();
147 }
148 else
149 {
150 return &(*found);
151 }
152}
153
154static adi_stat_t
155get_adi_info (pid_t pid)
156{
157 sparc64_adi_info *proc;
158
159 proc = get_adi_info_proc (pid);
160 return proc->stat;
161}
162
163/* Is called when GDB is no longer debugging process PID. It
164 deletes data structure that keeps track of the ADI stat. */
165
166void
167sparc64_forget_process (pid_t pid)
168{
169 int target_errno;
170
171 for (auto pit = adi_proc_list.before_begin (),
172 it = std::next (pit);
173 it != adi_proc_list.end ();
174 )
175 {
176 if ((*it).pid == pid)
177 {
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;
182 }
183 else
184 pit = it++;
185 }
186
187}
188
189static void
981a3fb3 190info_adi_command (const char *args, int from_tty)
58afddc6
WP		 191{
192 printf_unfiltered ("\"adi\" must be followed by \"examine\" "
193 "or \"assign\".\n");
194 help_list (sparc64adilist, "adi ", all_commands, gdb_stdout);
195}
196
197/* Read attributes of a maps entry in /proc/[pid]/adi/maps. */
198
199static void
200read_maps_entry (const char *line,
201 ULONGEST *addr, ULONGEST *endaddr)
202{
203 const char *p = line;
204
205 *addr = strtoulst (p, &p, 16);
206 if (*p == '-')
207 p++;
208
209 *endaddr = strtoulst (p, &p, 16);
210}
211
212/* Check if ADI is available. */
213
214static bool
215adi_available (void)
216{
217 pid_t pid = ptid_get_pid (inferior_ptid);
218 sparc64_adi_info *proc = get_adi_info_proc (pid);
654670a4 219 CORE_ADDR value;
58afddc6
WP		 220
221 if (proc->stat.checked_avail)
222 return proc->stat.is_avail;
223
224 proc->stat.checked_avail = true;
654670a4 225 if (target_auxv_search (&current_target, AT_ADI_BLKSZ, &value) <= 0)
58afddc6 226 return false;
654670a4
WP		 227 proc->stat.blksize = value;
228 target_auxv_search (&current_target, AT_ADI_NBITS, &value);
229 proc->stat.nbits = value;
58afddc6
WP		 230 proc->stat.max_version = (1 << proc->stat.nbits) - 2;
231 proc->stat.is_avail = true;
232
233 return proc->stat.is_avail;
234}
235
236/* Normalize a versioned address - a VA with ADI bits (63-60) set. */
237
238static CORE_ADDR
239adi_normalize_address (CORE_ADDR addr)
240{
241 adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
242
243 if (ast.nbits)
654670a4
WP		 244 {
245 /* Clear upper bits. */
246 addr &= ((uint64_t) -1) >> ast.nbits;
247
248 /* Sign extend. */
249 CORE_ADDR signbit = (uint64_t) 1 << (64 - ast.nbits - 1);
250 return (addr ^ signbit) - signbit;
251 }
58afddc6
WP		 252 return addr;
253}
254
255/* Align a normalized address - a VA with bit 59 sign extended into
256 ADI bits. */
257
258static CORE_ADDR
259adi_align_address (CORE_ADDR naddr)
260{
261 adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
262
263 return (naddr - (naddr % ast.blksize)) / ast.blksize;
264}
265
266/* Convert a byte count to count at a ratio of 1:adi_blksz. */
267
268static int
269adi_convert_byte_count (CORE_ADDR naddr, int nbytes, CORE_ADDR locl)
270{
271 adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
272
273 return ((naddr + nbytes + ast.blksize - 1) / ast.blksize) - locl;
274}
275
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.
279
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. */
284
285static int
286adi_tag_fd (void)
287{
288 pid_t pid = ptid_get_pid (inferior_ptid);
289 sparc64_adi_info *proc = get_adi_info_proc (pid);
290
291 if (proc->stat.tag_fd != 0)
292 return proc->stat.tag_fd;
293
294 char cl_name[MAX_PROC_NAME_SIZE];
39b06c20 295 snprintf (cl_name, sizeof(cl_name), "/proc/%ld/adi/tags", (long) pid);
58afddc6
WP		 296 int target_errno;
297 proc->stat.tag_fd = target_fileio_open (NULL, cl_name, O_RDWR|O_EXCL,
298 0, &target_errno);
299 return proc->stat.tag_fd;
300}
301
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. */
305
306static bool
307adi_is_addr_mapped (CORE_ADDR vaddr, size_t cnt)
308{
309 char filename[MAX_PROC_NAME_SIZE];
310 size_t i = 0;
311
312 pid_t pid = ptid_get_pid (inferior_ptid);
39b06c20 313 snprintf (filename, sizeof filename, "/proc/%ld/adi/maps", (long) pid);
87028b87
TT		 314 gdb::unique_xmalloc_ptr<char> data
315 = target_fileio_read_stralloc (NULL, filename);
58afddc6
WP		 316 if (data)
317 {
58afddc6
WP		 318 adi_stat_t adi_stat = get_adi_info (pid);
319 char *line;
87028b87 320 for (line = strtok (data.get (), "\n"); line; line = strtok (NULL, "\n"))
58afddc6
WP		 321 {
322 ULONGEST addr, endaddr;
323
324 read_maps_entry (line, &addr, &endaddr);
325
326 while (((vaddr + i) * adi_stat.blksize) >= addr
327 && ((vaddr + i) * adi_stat.blksize) < endaddr)
328 {
329 if (++i == cnt)
87028b87 330 return true;
58afddc6
WP		 331 }
332 }
58afddc6
WP		 333 }
334 else
335 warning (_("unable to open /proc file '%s'"), filename);
336
337 return false;
338}
339
340/* Read ADI version tag value for memory locations starting at "VADDR"
341 for "SIZE" number of bytes. */
342
343static int
344adi_read_versions (CORE_ADDR vaddr, size_t size, unsigned char *tags)
345{
346 int fd = adi_tag_fd ();
347 if (fd == -1)
348 return -1;
349
350 if (!adi_is_addr_mapped (vaddr, size))
351 {
352 adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
654670a4
WP		 353 error(_("Address at %s is not in ADI maps"),
354 paddress (target_gdbarch (), vaddr * ast.blksize));
58afddc6
WP		 355 }
356
357 int target_errno;
358 return target_fileio_pread (fd, tags, size, vaddr, &target_errno);
359}
360
361/* Write ADI version tag for memory locations starting at "VADDR" for
362 "SIZE" number of bytes to "TAGS". */
363
364static int
365adi_write_versions (CORE_ADDR vaddr, size_t size, unsigned char *tags)
366{
367 int fd = adi_tag_fd ();
368 if (fd == -1)
369 return -1;
370
371 if (!adi_is_addr_mapped (vaddr, size))
372 {
373 adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
654670a4
WP		 374 error(_("Address at %s is not in ADI maps"),
375 paddress (target_gdbarch (), vaddr * ast.blksize));
58afddc6
WP		 376 }
377
378 int target_errno;
379 return target_fileio_pwrite (fd, tags, size, vaddr, &target_errno);
380}
381
382/* Print ADI version tag value in "TAGS" for memory locations starting
383 at "VADDR" with number of "CNT". */
384
385static void
386adi_print_versions (CORE_ADDR vaddr, size_t cnt, unsigned char *tags)
387{
388 int v_idx = 0;
389 const int maxelts = 8; /* # of elements per line */
390
391 adi_stat_t adi_stat = get_adi_info (ptid_get_pid (inferior_ptid));
392
393 while (cnt > 0)
394 {
395 QUIT;
654670a4
WP		 396 printf_filtered ("%s:\t",
397 paddress (target_gdbarch (), vaddr * adi_stat.blksize));
58afddc6
WP		 398 for (int i = maxelts; i > 0 && cnt > 0; i--, cnt--)
399 {
400 if (tags[v_idx] == 0xff) /* no version tag */
401 printf_filtered ("-");
402 else
403 printf_filtered ("%1X", tags[v_idx]);
404 if (cnt > 1)
405 printf_filtered (" ");
406 ++v_idx;
407 }
408 printf_filtered ("\n");
409 gdb_flush (gdb_stdout);
410 vaddr += maxelts;
411 }
412}
413
414static void
415do_examine (CORE_ADDR start, int bcnt)
416{
417 CORE_ADDR vaddr = adi_normalize_address (start);
418 struct cleanup *cleanup;
419
420 CORE_ADDR vstart = adi_align_address (vaddr);
421 int cnt = adi_convert_byte_count (vaddr, bcnt, vstart);
422 unsigned char *buf = (unsigned char *) xmalloc (cnt);
423 cleanup = make_cleanup (xfree, buf);
424 int read_cnt = adi_read_versions (vstart, cnt, buf);
425 if (read_cnt == -1)
426 error (_("No ADI information"));
427 else if (read_cnt < cnt)
654670a4 428 error(_("No ADI information at %s"), paddress (target_gdbarch (), vaddr));
58afddc6
WP		 429
430 adi_print_versions (vstart, cnt, buf);
431
432 do_cleanups (cleanup);
433}
434
435static void
436do_assign (CORE_ADDR start, size_t bcnt, int version)
437{
438 CORE_ADDR vaddr = adi_normalize_address (start);
439
440 CORE_ADDR vstart = adi_align_address (vaddr);
441 int cnt = adi_convert_byte_count (vaddr, bcnt, vstart);
442 std::vector<unsigned char> buf (cnt, version);
443 int set_cnt = adi_write_versions (vstart, cnt, buf.data ());
444
445 if (set_cnt == -1)
446 error (_("No ADI information"));
447 else if (set_cnt < cnt)
654670a4 448 error(_("No ADI information at %s"), paddress (target_gdbarch (), vaddr));
58afddc6
WP		 449
450}
451
452/* ADI examine version tag command.
453
454 Command syntax:
455
456 adi (examine|x)/count <addr> */
457
458static void
459adi_examine_command (char *args, int from_tty)
460{
461 /* make sure program is active and adi is available */
462 if (!target_has_execution)
463 error (_("ADI command requires a live process/thread"));
464
465 if (!adi_available ())
466 error (_("No ADI information"));
467
468 pid_t pid = ptid_get_pid (inferior_ptid);
469 sparc64_adi_info *proc = get_adi_info_proc (pid);
470 int cnt = 1;
471 char *p = args;
472 if (p && *p == '/')
473 {
474 p++;
475 cnt = get_number (&p);
476 }
477
478 CORE_ADDR next_address = 0;
479 if (p != 0 && *p != 0)
480 next_address = parse_and_eval_address (p);
481 if (!cnt || !next_address)
482 error (_("Usage: adi examine|x[/count] <addr>"));
483
484 do_examine (next_address, cnt);
485}
486
487/* ADI assign version tag command.
488
489 Command syntax:
490
491 adi (assign|a)/count <addr> = <version> */
492
493static void
494adi_assign_command (char *args, int from_tty)
495{
496 /* make sure program is active and adi is available */
497 if (!target_has_execution)
498 error (_("ADI command requires a live process/thread"));
499
500 if (!adi_available ())
501 error (_("No ADI information"));
502
503 char *exp = args;
504 if (exp == 0)
505 error_no_arg (_("Usage: adi assign|a[/count] <addr> = <version>"));
506
507 char *q = (char *) strchr (exp, '=');
508 if (q)
509 *q++ = 0;
510 else
511 error (_("Usage: adi assign|a[/count] <addr> = <version>"));
512
513 size_t cnt = 1;
514 char *p = args;
515 if (exp && *exp == '/')
516 {
517 p = exp + 1;
518 cnt = get_number (&p);
519 }
520
521 CORE_ADDR next_address = 0;
522 if (p != 0 && *p != 0)
523 next_address = parse_and_eval_address (p);
524 else
525 error (_("Usage: adi assign|a[/count] <addr> = <version>"));
526
527 int version = 0;
528 if (q != NULL) /* parse version tag */
529 {
530 adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
531 version = parse_and_eval_long (q);
532 if (version < 0 || version > ast.max_version)
533 error (_("Invalid ADI version tag %d"), version);
534 }
535
536 do_assign (next_address, cnt, version);
537}
538
539void
540_initialize_sparc64_adi_tdep (void)
541{
542
543 add_prefix_cmd ("adi", class_support, info_adi_command,
544 _("ADI version related commands."),
545 &sparc64adilist, "adi ", 0, &cmdlist);
546 add_cmd ("examine", class_support, adi_examine_command,
547 _("Examine ADI versions."), &sparc64adilist);
548 add_alias_cmd ("x", "examine", no_class, 1, &sparc64adilist);
549 add_cmd ("assign", class_support, adi_assign_command,
550 _("Assign ADI versions."), &sparc64adilist);
551
552}
553\f
554
8b39fe56
MK		 555/* The functions on this page are intended to be used to classify
556 function arguments. */
557
8b39fe56
MK		 558/* Check whether TYPE is "Integral or Pointer". */
559
560static int
561sparc64_integral_or_pointer_p (const struct type *type)
562{
563 switch (TYPE_CODE (type))
564 {
565 case TYPE_CODE_INT:
566 case TYPE_CODE_BOOL:
567 case TYPE_CODE_CHAR:
568 case TYPE_CODE_ENUM:
569 case TYPE_CODE_RANGE:
570 {
571 int len = TYPE_LENGTH (type);
572 gdb_assert (len == 1 || len == 2 || len == 4 || len == 8);
573 }
574 return 1;
575 case TYPE_CODE_PTR:
576 case TYPE_CODE_REF:
aa006118 577 case TYPE_CODE_RVALUE_REF:
8b39fe56
MK		 578 {
579 int len = TYPE_LENGTH (type);
580 gdb_assert (len == 8);
581 }
582 return 1;
583 default:
584 break;
585 }
586
587 return 0;
588}
589
590/* Check whether TYPE is "Floating". */
591
592static int
593sparc64_floating_p (const struct type *type)
594{
595 switch (TYPE_CODE (type))
596 {
597 case TYPE_CODE_FLT:
598 {
599 int len = TYPE_LENGTH (type);
600 gdb_assert (len == 4 || len == 8 || len == 16);
601 }
602 return 1;
603 default:
604 break;
605 }
606
607 return 0;
608}
609
fe10a582
DM		 610/* Check whether TYPE is "Complex Floating". */
611
612static int
613sparc64_complex_floating_p (const struct type *type)
614{
615 switch (TYPE_CODE (type))
616 {
617 case TYPE_CODE_COMPLEX:
618 {
619 int len = TYPE_LENGTH (type);
620 gdb_assert (len == 8 || len == 16 || len == 32);
621 }
622 return 1;
623 default:
624 break;
625 }
626
627 return 0;
628}
629
0497f5b0
JB		 630/* Check whether TYPE is "Structure or Union".
631
632 In terms of Ada subprogram calls, arrays are treated the same as
633 struct and union types. So this function also returns non-zero
634 for array types. */
8b39fe56
MK		 635
636static int
637sparc64_structure_or_union_p (const struct type *type)
638{
639 switch (TYPE_CODE (type))
640 {
641 case TYPE_CODE_STRUCT:
642 case TYPE_CODE_UNION:
0497f5b0 643 case TYPE_CODE_ARRAY:
8b39fe56
MK		 644 return 1;
645 default:
646 break;
647 }
648
649 return 0;
650}
fd936806
MK		 651\f
652
209bd28e 653/* Construct types for ISA-specific registers. */
fd936806 654
209bd28e
UW		 655static struct type *
656sparc64_pstate_type (struct gdbarch *gdbarch)
657{
658 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
fd936806 659
209bd28e
UW		 660 if (!tdep->sparc64_pstate_type)
661 {
662 struct type *type;
663
77b7c781 664 type = arch_flags_type (gdbarch, "builtin_type_sparc64_pstate", 64);
209bd28e
UW		 665 append_flags_type_flag (type, 0, "AG");
666 append_flags_type_flag (type, 1, "IE");
667 append_flags_type_flag (type, 2, "PRIV");
668 append_flags_type_flag (type, 3, "AM");
669 append_flags_type_flag (type, 4, "PEF");
670 append_flags_type_flag (type, 5, "RED");
671 append_flags_type_flag (type, 8, "TLE");
672 append_flags_type_flag (type, 9, "CLE");
673 append_flags_type_flag (type, 10, "PID0");
674 append_flags_type_flag (type, 11, "PID1");
675
676 tdep->sparc64_pstate_type = type;
677 }
fd936806 678
209bd28e
UW		 679 return tdep->sparc64_pstate_type;
680}
fd936806 681
5badf10a
IR		 682static struct type *
683sparc64_ccr_type (struct gdbarch *gdbarch)
684{
685 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
686
687 if (tdep->sparc64_ccr_type == NULL)
688 {
689 struct type *type;
690
77b7c781 691 type = arch_flags_type (gdbarch, "builtin_type_sparc64_ccr", 64);
5badf10a
IR		 692 append_flags_type_flag (type, 0, "icc.c");
693 append_flags_type_flag (type, 1, "icc.v");
694 append_flags_type_flag (type, 2, "icc.z");
695 append_flags_type_flag (type, 3, "icc.n");
696 append_flags_type_flag (type, 4, "xcc.c");
697 append_flags_type_flag (type, 5, "xcc.v");
698 append_flags_type_flag (type, 6, "xcc.z");
699 append_flags_type_flag (type, 7, "xcc.n");
700
701 tdep->sparc64_ccr_type = type;
702 }
703
704 return tdep->sparc64_ccr_type;
705}
706
209bd28e
UW		 707static struct type *
708sparc64_fsr_type (struct gdbarch *gdbarch)
709{
710 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
711
712 if (!tdep->sparc64_fsr_type)
713 {
714 struct type *type;
715
77b7c781 716 type = arch_flags_type (gdbarch, "builtin_type_sparc64_fsr", 64);
5badf10a
IR		 717 append_flags_type_flag (type, 0, "NXC");
718 append_flags_type_flag (type, 1, "DZC");
719 append_flags_type_flag (type, 2, "UFC");
720 append_flags_type_flag (type, 3, "OFC");
721 append_flags_type_flag (type, 4, "NVC");
722 append_flags_type_flag (type, 5, "NXA");
723 append_flags_type_flag (type, 6, "DZA");
724 append_flags_type_flag (type, 7, "UFA");
725 append_flags_type_flag (type, 8, "OFA");
726 append_flags_type_flag (type, 9, "NVA");
209bd28e
UW		 727 append_flags_type_flag (type, 22, "NS");
728 append_flags_type_flag (type, 23, "NXM");
729 append_flags_type_flag (type, 24, "DZM");
730 append_flags_type_flag (type, 25, "UFM");
731 append_flags_type_flag (type, 26, "OFM");
732 append_flags_type_flag (type, 27, "NVM");
733
734 tdep->sparc64_fsr_type = type;
735 }
736
737 return tdep->sparc64_fsr_type;
738}
739
740static struct type *
741sparc64_fprs_type (struct gdbarch *gdbarch)
fd936806 742{
209bd28e
UW		 743 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
744
745 if (!tdep->sparc64_fprs_type)
746 {
747 struct type *type;
748
77b7c781 749 type = arch_flags_type (gdbarch, "builtin_type_sparc64_fprs", 64);
209bd28e
UW		 750 append_flags_type_flag (type, 0, "DL");
751 append_flags_type_flag (type, 1, "DU");
752 append_flags_type_flag (type, 2, "FEF");
753
754 tdep->sparc64_fprs_type = type;
755 }
756
757 return tdep->sparc64_fprs_type;
fd936806 758}
8b39fe56 759
209bd28e 760
8b39fe56 761/* Register information. */
7a36499a
IR		 762#define SPARC64_FPU_REGISTERS \
763 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \
764 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \
765 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", \
766 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", \
767 "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46", \
768 "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62"
769#define SPARC64_CP0_REGISTERS \
770 "pc", "npc", \
771 /* FIXME: Give "state" a name until we start using register groups. */ \
772 "state", \
773 "fsr", \
774 "fprs", \
775 "y"
8b39fe56 776
3f7b46f2
IR		 777static const char *sparc64_fpu_register_names[] = { SPARC64_FPU_REGISTERS };
778static const char *sparc64_cp0_register_names[] = { SPARC64_CP0_REGISTERS };
779
6707b003 780static const char *sparc64_register_names[] =
8b39fe56 781{
7a36499a
IR		 782 SPARC_CORE_REGISTERS,
783 SPARC64_FPU_REGISTERS,
784 SPARC64_CP0_REGISTERS
8b39fe56
MK		 785};
786
787/* Total number of registers. */
6707b003 788#define SPARC64_NUM_REGS ARRAY_SIZE (sparc64_register_names)
8b39fe56
MK		 789
790/* We provide the aliases %d0..%d62 and %q0..%q60 for the floating
791 registers as "psuedo" registers. */
792
6707b003 793static const char *sparc64_pseudo_register_names[] =
8b39fe56 794{
6707b003
UW		 795 "cwp", "pstate", "asi", "ccr",
796
797 "d0", "d2", "d4", "d6", "d8", "d10", "d12", "d14",
798 "d16", "d18", "d20", "d22", "d24", "d26", "d28", "d30",
799 "d32", "d34", "d36", "d38", "d40", "d42", "d44", "d46",
800 "d48", "d50", "d52", "d54", "d56", "d58", "d60", "d62",
801
802 "q0", "q4", "q8", "q12", "q16", "q20", "q24", "q28",
803 "q32", "q36", "q40", "q44", "q48", "q52", "q56", "q60",
8b39fe56
MK		 804};
805
806/* Total number of pseudo registers. */
6707b003 807#define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_names)
8b39fe56 808
7a36499a
IR		 809/* Return the name of pseudo register REGNUM. */
810
811static const char *
812sparc64_pseudo_register_name (struct gdbarch *gdbarch, int regnum)
813{
814 regnum -= gdbarch_num_regs (gdbarch);
815
816 if (regnum < SPARC64_NUM_PSEUDO_REGS)
817 return sparc64_pseudo_register_names[regnum];
818
819 internal_error (__FILE__, __LINE__,
820 _("sparc64_pseudo_register_name: bad register number %d"),
821 regnum);
822}
823
8b39fe56
MK		 824/* Return the name of register REGNUM. */
825
826static const char *
d93859e2 827sparc64_register_name (struct gdbarch *gdbarch, int regnum)
8b39fe56 828{
3f7b46f2
IR		 829 if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
830 return tdesc_register_name (gdbarch, regnum);
831
7a36499a 832 if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch))
6707b003 833 return sparc64_register_names[regnum];
8b39fe56 834
7a36499a
IR		 835 return sparc64_pseudo_register_name (gdbarch, regnum);
836}
837
838/* Return the GDB type object for the "standard" data type of data in
839 pseudo register REGNUM. */
840
841static struct type *
842sparc64_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
843{
844 regnum -= gdbarch_num_regs (gdbarch);
845
846 if (regnum == SPARC64_CWP_REGNUM)
847 return builtin_type (gdbarch)->builtin_int64;
848 if (regnum == SPARC64_PSTATE_REGNUM)
849 return sparc64_pstate_type (gdbarch);
850 if (regnum == SPARC64_ASI_REGNUM)
851 return builtin_type (gdbarch)->builtin_int64;
852 if (regnum == SPARC64_CCR_REGNUM)
5badf10a 853 return sparc64_ccr_type (gdbarch);
7a36499a
IR		 854 if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D62_REGNUM)
855 return builtin_type (gdbarch)->builtin_double;
856 if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q60_REGNUM)
857 return builtin_type (gdbarch)->builtin_long_double;
8b39fe56 858
7a36499a
IR		 859 internal_error (__FILE__, __LINE__,
860 _("sparc64_pseudo_register_type: bad register number %d"),
861 regnum);
8b39fe56
MK		 862}
863
864/* Return the GDB type object for the "standard" data type of data in
c378eb4e 865 register REGNUM. */
8b39fe56
MK		 866
867static struct type *
868sparc64_register_type (struct gdbarch *gdbarch, int regnum)
869{
3f7b46f2
IR		 870 if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
871 return tdesc_register_type (gdbarch, regnum);
872
6707b003 873 /* Raw registers. */
6707b003 874 if (regnum == SPARC_SP_REGNUM || regnum == SPARC_FP_REGNUM)
0dfff4cb 875 return builtin_type (gdbarch)->builtin_data_ptr;
6707b003 876 if (regnum >= SPARC_G0_REGNUM && regnum <= SPARC_I7_REGNUM)
df4df182 877 return builtin_type (gdbarch)->builtin_int64;
6707b003 878 if (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F31_REGNUM)
0dfff4cb 879 return builtin_type (gdbarch)->builtin_float;
6707b003 880 if (regnum >= SPARC64_F32_REGNUM && regnum <= SPARC64_F62_REGNUM)
0dfff4cb 881 return builtin_type (gdbarch)->builtin_double;
6707b003 882 if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
0dfff4cb 883 return builtin_type (gdbarch)->builtin_func_ptr;
6707b003
UW		 884 /* This raw register contains the contents of %cwp, %pstate, %asi
885 and %ccr as laid out in a %tstate register. */
886 if (regnum == SPARC64_STATE_REGNUM)
df4df182 887 return builtin_type (gdbarch)->builtin_int64;
6707b003 888 if (regnum == SPARC64_FSR_REGNUM)
209bd28e 889 return sparc64_fsr_type (gdbarch);
6707b003 890 if (regnum == SPARC64_FPRS_REGNUM)
209bd28e 891 return sparc64_fprs_type (gdbarch);
6707b003
UW		 892 /* "Although Y is a 64-bit register, its high-order 32 bits are
893 reserved and always read as 0." */
894 if (regnum == SPARC64_Y_REGNUM)
df4df182 895 return builtin_type (gdbarch)->builtin_int64;
6707b003
UW		 896
897 /* Pseudo registers. */
7a36499a
IR		 898 if (regnum >= gdbarch_num_regs (gdbarch))
899 return sparc64_pseudo_register_type (gdbarch, regnum);
6707b003
UW		 900
901 internal_error (__FILE__, __LINE__, _("invalid regnum"));
8b39fe56
MK		 902}
903
05d1431c 904static enum register_status
8b39fe56
MK		 905sparc64_pseudo_register_read (struct gdbarch *gdbarch,
906 struct regcache *regcache,
e1613aba 907 int regnum, gdb_byte *buf)
8b39fe56 908{
e17a4113 909 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
05d1431c
PA		 910 enum register_status status;
911
7a36499a 912 regnum -= gdbarch_num_regs (gdbarch);
8b39fe56
MK		 913
914 if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)
915 {
916 regnum = SPARC_F0_REGNUM + 2 * (regnum - SPARC64_D0_REGNUM);
05d1431c
PA		 917 status = regcache_raw_read (regcache, regnum, buf);
918 if (status == REG_VALID)
919 status = regcache_raw_read (regcache, regnum + 1, buf + 4);
920 return status;
8b39fe56
MK		 921 }
922 else if (regnum >= SPARC64_D32_REGNUM && regnum <= SPARC64_D62_REGNUM)
923 {
924 regnum = SPARC64_F32_REGNUM + (regnum - SPARC64_D32_REGNUM);
05d1431c 925 return regcache_raw_read (regcache, regnum, buf);
8b39fe56
MK		 926 }
927 else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q28_REGNUM)
928 {
929 regnum = SPARC_F0_REGNUM + 4 * (regnum - SPARC64_Q0_REGNUM);
05d1431c
PA		 930
931 status = regcache_raw_read (regcache, regnum, buf);
932 if (status == REG_VALID)
933 status = regcache_raw_read (regcache, regnum + 1, buf + 4);
934 if (status == REG_VALID)
935 status = regcache_raw_read (regcache, regnum + 2, buf + 8);
936 if (status == REG_VALID)
937 status = regcache_raw_read (regcache, regnum + 3, buf + 12);
938
939 return status;
8b39fe56
MK		 940 }
941 else if (regnum >= SPARC64_Q32_REGNUM && regnum <= SPARC64_Q60_REGNUM)
942 {
943 regnum = SPARC64_F32_REGNUM + 2 * (regnum - SPARC64_Q32_REGNUM);
05d1431c
PA		 944
945 status = regcache_raw_read (regcache, regnum, buf);
946 if (status == REG_VALID)
947 status = regcache_raw_read (regcache, regnum + 1, buf + 8);
948
949 return status;
8b39fe56
MK		 950 }
951 else if (regnum == SPARC64_CWP_REGNUM
952 || regnum == SPARC64_PSTATE_REGNUM
953 || regnum == SPARC64_ASI_REGNUM
954 || regnum == SPARC64_CCR_REGNUM)
955 {
956 ULONGEST state;
957
05d1431c
PA		 958 status = regcache_raw_read_unsigned (regcache, SPARC64_STATE_REGNUM, &state);
959 if (status != REG_VALID)
960 return status;
961
8b39fe56
MK		 962 switch (regnum)
963 {
3567a8ea 964 case SPARC64_CWP_REGNUM:
8b39fe56
MK		 965 state = (state >> 0) & ((1 << 5) - 1);
966 break;
3567a8ea 967 case SPARC64_PSTATE_REGNUM:
8b39fe56
MK		 968 state = (state >> 8) & ((1 << 12) - 1);
969 break;
3567a8ea 970 case SPARC64_ASI_REGNUM:
8b39fe56
MK		 971 state = (state >> 24) & ((1 << 8) - 1);
972 break;
3567a8ea 973 case SPARC64_CCR_REGNUM:
8b39fe56
MK		 974 state = (state >> 32) & ((1 << 8) - 1);
975 break;
976 }
e17a4113 977 store_unsigned_integer (buf, 8, byte_order, state);
8b39fe56 978 }
05d1431c
PA		 979
980 return REG_VALID;
8b39fe56
MK		 981}
982
983static void
984sparc64_pseudo_register_write (struct gdbarch *gdbarch,
985 struct regcache *regcache,
e1613aba 986 int regnum, const gdb_byte *buf)
8b39fe56 987{
e17a4113 988 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
7a36499a
IR		 989
990 regnum -= gdbarch_num_regs (gdbarch);
8b39fe56
MK		 991
992 if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)
993 {
994 regnum = SPARC_F0_REGNUM + 2 * (regnum - SPARC64_D0_REGNUM);
995 regcache_raw_write (regcache, regnum, buf);
e1613aba 996 regcache_raw_write (regcache, regnum + 1, buf + 4);
8b39fe56
MK		 997 }
998 else if (regnum >= SPARC64_D32_REGNUM && regnum <= SPARC64_D62_REGNUM)
999 {
1000 regnum = SPARC64_F32_REGNUM + (regnum - SPARC64_D32_REGNUM);
1001 regcache_raw_write (regcache, regnum, buf);
1002 }
1003 else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q28_REGNUM)
1004 {
1005 regnum = SPARC_F0_REGNUM + 4 * (regnum - SPARC64_Q0_REGNUM);
1006 regcache_raw_write (regcache, regnum, buf);
e1613aba
MK		 1007 regcache_raw_write (regcache, regnum + 1, buf + 4);
1008 regcache_raw_write (regcache, regnum + 2, buf + 8);
1009 regcache_raw_write (regcache, regnum + 3, buf + 12);
8b39fe56
MK		 1010 }
1011 else if (regnum >= SPARC64_Q32_REGNUM && regnum <= SPARC64_Q60_REGNUM)
1012 {
1013 regnum = SPARC64_F32_REGNUM + 2 * (regnum - SPARC64_Q32_REGNUM);
1014 regcache_raw_write (regcache, regnum, buf);
e1613aba 1015 regcache_raw_write (regcache, regnum + 1, buf + 8);
8b39fe56 1016 }
3567a8ea
MK		 1017 else if (regnum == SPARC64_CWP_REGNUM
1018 || regnum == SPARC64_PSTATE_REGNUM
1019 || regnum == SPARC64_ASI_REGNUM
1020 || regnum == SPARC64_CCR_REGNUM)
1021 {
1022 ULONGEST state, bits;
1023
1024 regcache_raw_read_unsigned (regcache, SPARC64_STATE_REGNUM, &state);
e17a4113 1025 bits = extract_unsigned_integer (buf, 8, byte_order);
3567a8ea
MK		 1026 switch (regnum)
1027 {
1028 case SPARC64_CWP_REGNUM:
1029 state |= ((bits & ((1 << 5) - 1)) << 0);
1030 break;
1031 case SPARC64_PSTATE_REGNUM:
1032 state |= ((bits & ((1 << 12) - 1)) << 8);
1033 break;
1034 case SPARC64_ASI_REGNUM:
1035 state |= ((bits & ((1 << 8) - 1)) << 24);
1036 break;
1037 case SPARC64_CCR_REGNUM:
1038 state |= ((bits & ((1 << 8) - 1)) << 32);
1039 break;
1040 }
1041 regcache_raw_write_unsigned (regcache, SPARC64_STATE_REGNUM, state);
1042 }
8b39fe56 1043}
8b39fe56
MK		 1044\f
1045
8b39fe56
MK		 1046/* Return PC of first real instruction of the function starting at
1047 START_PC. */
1048
1049static CORE_ADDR
6093d2eb 1050sparc64_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
8b39fe56
MK		 1051{
1052 struct symtab_and_line sal;
1053 CORE_ADDR func_start, func_end;
386c036b 1054 struct sparc_frame_cache cache;
8b39fe56
MK		 1055
1056 /* This is the preferred method, find the end of the prologue by
1057 using the debugging information. */
1058 if (find_pc_partial_function (start_pc, NULL, &func_start, &func_end))
1059 {
1060 sal = find_pc_line (func_start, 0);
1061
1062 if (sal.end < func_end
1063 && start_pc <= sal.end)
1064 return sal.end;
1065 }
1066
be8626e0
MD		 1067 return sparc_analyze_prologue (gdbarch, start_pc, 0xffffffffffffffffULL,
1068 &cache);
8b39fe56
MK		 1069}
1070
1071/* Normal frames. */
1072
386c036b 1073static struct sparc_frame_cache *
236369e7 1074sparc64_frame_cache (struct frame_info *this_frame, void **this_cache)
8b39fe56 1075{
236369e7 1076 return sparc_frame_cache (this_frame, this_cache);
8b39fe56
MK		 1077}
1078
1079static void
236369e7 1080sparc64_frame_this_id (struct frame_info *this_frame, void **this_cache,
8b39fe56
MK		 1081 struct frame_id *this_id)
1082{
386c036b 1083 struct sparc_frame_cache *cache =
236369e7 1084 sparc64_frame_cache (this_frame, this_cache);
8b39fe56
MK		 1085
1086 /* This marks the outermost frame. */
1087 if (cache->base == 0)
1088 return;
1089
1090 (*this_id) = frame_id_build (cache->base, cache->pc);
1091}
1092
236369e7
JB		 1093static struct value *
1094sparc64_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1095 int regnum)
8b39fe56 1096{
e17a4113 1097 struct gdbarch *gdbarch = get_frame_arch (this_frame);
386c036b 1098 struct sparc_frame_cache *cache =
236369e7 1099 sparc64_frame_cache (this_frame, this_cache);
8b39fe56
MK		 1100
1101 if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
1102 {
236369e7 1103 CORE_ADDR pc = (regnum == SPARC64_NPC_REGNUM) ? 4 : 0;
8b39fe56 1104
369c397b
JB		 1105 regnum =
1106 (cache->copied_regs_mask & 0x80) ? SPARC_I7_REGNUM : SPARC_O7_REGNUM;
236369e7
JB		 1107 pc += get_frame_register_unsigned (this_frame, regnum) + 8;
1108 return frame_unwind_got_constant (this_frame, regnum, pc);
8b39fe56
MK		 1109 }
1110
f700a364
MK		 1111 /* Handle StackGhost. */
1112 {
e17a4113 1113 ULONGEST wcookie = sparc_fetch_wcookie (gdbarch);
f700a364
MK		 1114
1115 if (wcookie != 0 && !cache->frameless_p && regnum == SPARC_I7_REGNUM)
1116 {
236369e7
JB		 1117 CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 8;
1118 ULONGEST i7;
1119
1120 /* Read the value in from memory. */
1121 i7 = get_frame_memory_unsigned (this_frame, addr, 8);
1122 return frame_unwind_got_constant (this_frame, regnum, i7 ^ wcookie);
f700a364
MK		 1123 }
1124 }
1125
369c397b 1126 /* The previous frame's `local' and `in' registers may have been saved
8b39fe56 1127 in the register save area. */
369c397b
JB		 1128 if (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM
1129 && (cache->saved_regs_mask & (1 << (regnum - SPARC_L0_REGNUM))))
8b39fe56 1130 {
236369e7 1131 CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 8;
8b39fe56 1132
236369e7 1133 return frame_unwind_got_memory (this_frame, regnum, addr);
8b39fe56
MK		 1134 }
1135
369c397b
JB		 1136 /* The previous frame's `out' registers may be accessible as the current
1137 frame's `in' registers. */
1138 if (regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM
1139 && (cache->copied_regs_mask & (1 << (regnum - SPARC_O0_REGNUM))))
8b39fe56
MK		 1140 regnum += (SPARC_I0_REGNUM - SPARC_O0_REGNUM);
1141
236369e7 1142 return frame_unwind_got_register (this_frame, regnum, regnum);
8b39fe56
MK		 1143}
1144
1145static const struct frame_unwind sparc64_frame_unwind =
1146{
1147 NORMAL_FRAME,
8fbca658 1148 default_frame_unwind_stop_reason,
8b39fe56 1149 sparc64_frame_this_id,
236369e7
JB		 1150 sparc64_frame_prev_register,
1151 NULL,
1152 default_frame_sniffer
8b39fe56 1153};
8b39fe56
MK		 1154\f
1155
1156static CORE_ADDR
236369e7 1157sparc64_frame_base_address (struct frame_info *this_frame, void **this_cache)
8b39fe56 1158{
386c036b 1159 struct sparc_frame_cache *cache =
236369e7 1160 sparc64_frame_cache (this_frame, this_cache);
8b39fe56 1161
5b2d44a0 1162 return cache->base;
8b39fe56
MK		 1163}
1164
1165static const struct frame_base sparc64_frame_base =
1166{
1167 &sparc64_frame_unwind,
1168 sparc64_frame_base_address,
1169 sparc64_frame_base_address,
1170 sparc64_frame_base_address
1171};
8b39fe56
MK		 1172\f
1173/* Check whether TYPE must be 16-byte aligned. */
1174
1175static int
1176sparc64_16_byte_align_p (struct type *type)
1177{
1933fd8e
VM		 1178 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1179 {
1180 struct type *t = check_typedef (TYPE_TARGET_TYPE (type));
1181
1182 if (sparc64_floating_p (t))
1183 return 1;
1184 }
8b39fe56
MK		 1185 if (sparc64_floating_p (type) && TYPE_LENGTH (type) == 16)
1186 return 1;
1187
1188 if (sparc64_structure_or_union_p (type))
1189 {
1190 int i;
1191
1192 for (i = 0; i < TYPE_NFIELDS (type); i++)
60af1db2
MK		 1193 {
1194 struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
1195
1196 if (sparc64_16_byte_align_p (subtype))
1197 return 1;
1198 }
8b39fe56
MK		 1199 }
1200
1201 return 0;
1202}
1203
1204/* Store floating fields of element ELEMENT of an "parameter array"
1205 that has type TYPE and is stored at BITPOS in VALBUF in the
1206 apropriate registers of REGCACHE. This function can be called
1207 recursively and therefore handles floating types in addition to
1208 structures. */
1209
1210static void
1211sparc64_store_floating_fields (struct regcache *regcache, struct type *type,
e1613aba 1212 const gdb_byte *valbuf, int element, int bitpos)
8b39fe56 1213{
ac7936df 1214 struct gdbarch *gdbarch = regcache->arch ();
fe10a582
DM		 1215 int len = TYPE_LENGTH (type);
1216
8b39fe56
MK		 1217 gdb_assert (element < 16);
1218
1933fd8e
VM		 1219 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1220 {
1221 gdb_byte buf[8];
1222 int regnum = SPARC_F0_REGNUM + element * 2 + bitpos / 32;
1223
1224 valbuf += bitpos / 8;
1225 if (len < 8)
1226 {
1227 memset (buf, 0, 8 - len);
1228 memcpy (buf + 8 - len, valbuf, len);
1229 valbuf = buf;
1230 len = 8;
1231 }
1232 for (int n = 0; n < (len + 3) / 4; n++)
1233 regcache_cooked_write (regcache, regnum + n, valbuf + n * 4);
1234 }
1235 else if (sparc64_floating_p (type)
fe10a582 1236 || (sparc64_complex_floating_p (type) && len <= 16))
8b39fe56 1237 {
8b39fe56
MK		 1238 int regnum;
1239
1240 if (len == 16)
1241 {
1242 gdb_assert (bitpos == 0);
1243 gdb_assert ((element % 2) == 0);
1244
7a36499a 1245 regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM + element / 2;
8b39fe56
MK		 1246 regcache_cooked_write (regcache, regnum, valbuf);
1247 }
1248 else if (len == 8)
1249 {
1250 gdb_assert (bitpos == 0 || bitpos == 64);
1251
7a36499a
IR		 1252 regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
1253 + element + bitpos / 64;
8b39fe56
MK		 1254 regcache_cooked_write (regcache, regnum, valbuf + (bitpos / 8));
1255 }
1256 else
1257 {
1258 gdb_assert (len == 4);
1259 gdb_assert (bitpos % 32 == 0 && bitpos >= 0 && bitpos < 128);
1260
1261 regnum = SPARC_F0_REGNUM + element * 2 + bitpos / 32;
1262 regcache_cooked_write (regcache, regnum, valbuf + (bitpos / 8));
1263 }
1264 }
1265 else if (sparc64_structure_or_union_p (type))
1266 {
1267 int i;
1268
1269 for (i = 0; i < TYPE_NFIELDS (type); i++)
60af1db2
MK		 1270 {
1271 struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
1272 int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
1273
1274 sparc64_store_floating_fields (regcache, subtype, valbuf,
1275 element, subpos);
1276 }
200cc553
MK		 1277
1278 /* GCC has an interesting bug. If TYPE is a structure that has
1279 a single `float' member, GCC doesn't treat it as a structure
1280 at all, but rather as an ordinary `float' argument. This
1281 argument will be stored in %f1, as required by the psABI.
1282 However, as a member of a structure the psABI requires it to
5154b0cd
MK		 1283 be stored in %f0. This bug is present in GCC 3.3.2, but
1284 probably in older releases to. To appease GCC, if a
1285 structure has only a single `float' member, we store its
1286 value in %f1 too (we already have stored in %f0). */
200cc553
MK		 1287 if (TYPE_NFIELDS (type) == 1)
1288 {
1289 struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, 0));
1290
1291 if (sparc64_floating_p (subtype) && TYPE_LENGTH (subtype) == 4)
1292 regcache_cooked_write (regcache, SPARC_F1_REGNUM, valbuf);
1293 }
8b39fe56
MK		 1294 }
1295}
1296
1297/* Fetch floating fields from a variable of type TYPE from the
1298 appropriate registers for BITPOS in REGCACHE and store it at BITPOS
1299 in VALBUF. This function can be called recursively and therefore
1300 handles floating types in addition to structures. */
1301
1302static void
1303sparc64_extract_floating_fields (struct regcache *regcache, struct type *type,
e1613aba 1304 gdb_byte *valbuf, int bitpos)
8b39fe56 1305{
ac7936df 1306 struct gdbarch *gdbarch = regcache->arch ();
7a36499a 1307
1933fd8e
VM		 1308 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1309 {
1310 int len = TYPE_LENGTH (type);
1311 int regnum = SPARC_F0_REGNUM + bitpos / 32;
1312
1313 valbuf += bitpos / 8;
1314 if (len < 4)
1315 {
1316 gdb_byte buf[4];
1317 regcache_cooked_read (regcache, regnum, buf);
1318 memcpy (valbuf, buf + 4 - len, len);
1319 }
1320 else
1321 for (int i = 0; i < (len + 3) / 4; i++)
1322 regcache_cooked_read (regcache, regnum + i, valbuf + i * 4);
1323 }
1324 else if (sparc64_floating_p (type))
8b39fe56
MK		 1325 {
1326 int len = TYPE_LENGTH (type);
1327 int regnum;
1328
1329 if (len == 16)
1330 {
1331 gdb_assert (bitpos == 0 || bitpos == 128);
1332
7a36499a
IR		 1333 regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM
1334 + bitpos / 128;
8b39fe56
MK		 1335 regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8));
1336 }
1337 else if (len == 8)
1338 {
1339 gdb_assert (bitpos % 64 == 0 && bitpos >= 0 && bitpos < 256);
1340
7a36499a 1341 regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + bitpos / 64;
8b39fe56
MK		 1342 regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8));
1343 }
1344 else
1345 {
1346 gdb_assert (len == 4);
1347 gdb_assert (bitpos % 32 == 0 && bitpos >= 0 && bitpos < 256);
1348
1349 regnum = SPARC_F0_REGNUM + bitpos / 32;
1350 regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8));
1351 }
1352 }
1353 else if (sparc64_structure_or_union_p (type))
1354 {
1355 int i;
1356
1357 for (i = 0; i < TYPE_NFIELDS (type); i++)
60af1db2
MK		 1358 {
1359 struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
1360 int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
1361
1362 sparc64_extract_floating_fields (regcache, subtype, valbuf, subpos);
1363 }
8b39fe56
MK		 1364 }
1365}
1366
1367/* Store the NARGS arguments ARGS and STRUCT_ADDR (if STRUCT_RETURN is
1368 non-zero) in REGCACHE and on the stack (starting from address SP). */
1369
1370static CORE_ADDR
1371sparc64_store_arguments (struct regcache *regcache, int nargs,
1372 struct value **args, CORE_ADDR sp,
1373 int struct_return, CORE_ADDR struct_addr)
1374{
ac7936df 1375 struct gdbarch *gdbarch = regcache->arch ();
8b39fe56
MK		 1376 /* Number of extended words in the "parameter array". */
1377 int num_elements = 0;
1378 int element = 0;
1379 int i;
1380
1381 /* Take BIAS into account. */
1382 sp += BIAS;
1383
1384 /* First we calculate the number of extended words in the "parameter
1385 array". While doing so we also convert some of the arguments. */
1386
1387 if (struct_return)
1388 num_elements++;
1389
1390 for (i = 0; i < nargs; i++)
1391 {
4991999e 1392 struct type *type = value_type (args[i]);
8b39fe56
MK		 1393 int len = TYPE_LENGTH (type);
1394
fb57d452
MK		 1395 if (sparc64_structure_or_union_p (type)
1396 || (sparc64_complex_floating_p (type) && len == 32))
8b39fe56
MK		 1397 {
1398 /* Structure or Union arguments. */
1399 if (len <= 16)
1400 {
1401 if (num_elements % 2 && sparc64_16_byte_align_p (type))
1402 num_elements++;
1403 num_elements += ((len + 7) / 8);
1404 }
1405 else
1406 {
1407 /* The psABI says that "Structures or unions larger than
1408 sixteen bytes are copied by the caller and passed
1409 indirectly; the caller will pass the address of a
1410 correctly aligned structure value. This sixty-four
1411 bit address will occupy one word in the parameter
1412 array, and may be promoted to an %o register like any
1413 other pointer value." Allocate memory for these
1414 values on the stack. */
1415 sp -= len;
1416
1417 /* Use 16-byte alignment for these values. That's
1418 always correct, and wasting a few bytes shouldn't be
1419 a problem. */
1420 sp &= ~0xf;
1421
0fd88904 1422 write_memory (sp, value_contents (args[i]), len);
8b39fe56
MK		 1423 args[i] = value_from_pointer (lookup_pointer_type (type), sp);
1424 num_elements++;
1425 }
1426 }
cdc7b32f 1427 else if (sparc64_floating_p (type) || sparc64_complex_floating_p (type))
8b39fe56
MK		 1428 {
1429 /* Floating arguments. */
8b39fe56
MK		 1430 if (len == 16)
1431 {
1432 /* The psABI says that "Each quad-precision parameter
1433 value will be assigned to two extended words in the
1434 parameter array. */
1435 num_elements += 2;
1436
1437 /* The psABI says that "Long doubles must be
1438 quad-aligned, and thus a hole might be introduced
1439 into the parameter array to force alignment." Skip
1440 an element if necessary. */
49caec94 1441 if ((num_elements % 2) && sparc64_16_byte_align_p (type))
8b39fe56
MK		 1442 num_elements++;
1443 }
1444 else
1445 num_elements++;
1446 }
1447 else
1448 {
1449 /* Integral and pointer arguments. */
1450 gdb_assert (sparc64_integral_or_pointer_p (type));
1451
1452 /* The psABI says that "Each argument value of integral type
1453 smaller than an extended word will be widened by the
1454 caller to an extended word according to the signed-ness
1455 of the argument type." */
1456 if (len < 8)
df4df182
UW		 1457 args[i] = value_cast (builtin_type (gdbarch)->builtin_int64,
1458 args[i]);
8b39fe56
MK		 1459 num_elements++;
1460 }
1461 }
1462
1463 /* Allocate the "parameter array". */
1464 sp -= num_elements * 8;
1465
1466 /* The psABI says that "Every stack frame must be 16-byte aligned." */
1467 sp &= ~0xf;
1468
1469 /* Now we store the arguments in to the "paramater array". Some
1470 Integer or Pointer arguments and Structure or Union arguments
1471 will be passed in %o registers. Some Floating arguments and
1472 floating members of structures are passed in floating-point
1473 registers. However, for functions with variable arguments,
1474 floating arguments are stored in an %0 register, and for
1475 functions without a prototype floating arguments are stored in
1476 both a floating-point and an %o registers, or a floating-point
1477 register and memory. To simplify the logic here we always pass
1478 arguments in memory, an %o register, and a floating-point
1479 register if appropriate. This should be no problem since the
1480 contents of any unused memory or registers in the "parameter
1481 array" are undefined. */
1482
1483 if (struct_return)
1484 {
1485 regcache_cooked_write_unsigned (regcache, SPARC_O0_REGNUM, struct_addr);
1486 element++;
1487 }
1488
1489 for (i = 0; i < nargs; i++)
1490 {
e1613aba 1491 const gdb_byte *valbuf = value_contents (args[i]);
4991999e 1492 struct type *type = value_type (args[i]);
8b39fe56
MK		 1493 int len = TYPE_LENGTH (type);
1494 int regnum = -1;
e1613aba 1495 gdb_byte buf[16];
8b39fe56 1496
fb57d452
MK		 1497 if (sparc64_structure_or_union_p (type)
1498 || (sparc64_complex_floating_p (type) && len == 32))
8b39fe56 1499 {
49caec94 1500 /* Structure, Union or long double Complex arguments. */
8b39fe56
MK		 1501 gdb_assert (len <= 16);
1502 memset (buf, 0, sizeof (buf));
cfcb22a5
SM		 1503 memcpy (buf, valbuf, len);
1504 valbuf = buf;
8b39fe56
MK		 1505
1506 if (element % 2 && sparc64_16_byte_align_p (type))
1507 element++;
1508
1509 if (element < 6)
1510 {
1511 regnum = SPARC_O0_REGNUM + element;
1512 if (len > 8 && element < 5)
1513 regcache_cooked_write (regcache, regnum + 1, valbuf + 8);
1514 }
1515
1516 if (element < 16)
1517 sparc64_store_floating_fields (regcache, type, valbuf, element, 0);
1518 }
49caec94
JM		 1519 else if (sparc64_complex_floating_p (type))
1520 {
1521 /* Float Complex or double Complex arguments. */
1522 if (element < 16)
1523 {
7a36499a 1524 regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + element;
49caec94
JM		 1525
1526 if (len == 16)
1527 {
7a36499a 1528 if (regnum < gdbarch_num_regs (gdbarch) + SPARC64_D30_REGNUM)
49caec94 1529 regcache_cooked_write (regcache, regnum + 1, valbuf + 8);
7a36499a 1530 if (regnum < gdbarch_num_regs (gdbarch) + SPARC64_D10_REGNUM)
49caec94
JM		 1531 regcache_cooked_write (regcache,
1532 SPARC_O0_REGNUM + element + 1,
1533 valbuf + 8);
1534 }
1535 }
1536 }
1537 else if (sparc64_floating_p (type))
8b39fe56
MK		 1538 {
1539 /* Floating arguments. */
1540 if (len == 16)
1541 {
1542 if (element % 2)
1543 element++;
1544 if (element < 16)
7a36499a
IR		 1545 regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM
1546 + element / 2;
8b39fe56
MK		 1547 }
1548 else if (len == 8)
1549 {
1550 if (element < 16)
7a36499a
IR		 1551 regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
1552 + element;
8b39fe56 1553 }
fe10a582 1554 else if (len == 4)
8b39fe56
MK		 1555 {
1556 /* The psABI says "Each single-precision parameter value
1557 will be assigned to one extended word in the
1558 parameter array, and right-justified within that
cdc7b32f 1559 word; the left half (even float register) is
8b39fe56
MK		 1560 undefined." Even though the psABI says that "the
1561 left half is undefined", set it to zero here. */
1562 memset (buf, 0, 4);
8ada74e3
MK		 1563 memcpy (buf + 4, valbuf, 4);
1564 valbuf = buf;
8b39fe56
MK		 1565 len = 8;
1566 if (element < 16)
7a36499a
IR		 1567 regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
1568 + element;
8b39fe56
MK		 1569 }
1570 }
1571 else
1572 {
1573 /* Integral and pointer arguments. */
1574 gdb_assert (len == 8);
1575 if (element < 6)
1576 regnum = SPARC_O0_REGNUM + element;
1577 }
1578
1579 if (regnum != -1)
1580 {
1581 regcache_cooked_write (regcache, regnum, valbuf);
1582
1583 /* If we're storing the value in a floating-point register,
1584 also store it in the corresponding %0 register(s). */
7a36499a
IR		 1585 if (regnum >= gdbarch_num_regs (gdbarch))
1586 {
1587 regnum -= gdbarch_num_regs (gdbarch);
1588
1589 if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D10_REGNUM)
1590 {
1591 gdb_assert (element < 6);
1592 regnum = SPARC_O0_REGNUM + element;
1593 regcache_cooked_write (regcache, regnum, valbuf);
1594 }
1595 else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q8_REGNUM)
1596 {
1597 gdb_assert (element < 5);
1598 regnum = SPARC_O0_REGNUM + element;
1599 regcache_cooked_write (regcache, regnum, valbuf);
1600 regcache_cooked_write (regcache, regnum + 1, valbuf + 8);
1601 }
1602 }
8b39fe56
MK		 1603 }
1604
c4f2d4d7 1605 /* Always store the argument in memory. */
8b39fe56
MK		 1606 write_memory (sp + element * 8, valbuf, len);
1607 element += ((len + 7) / 8);
1608 }
1609
1610 gdb_assert (element == num_elements);
1611
1612 /* Take BIAS into account. */
1613 sp -= BIAS;
1614 return sp;
1615}
1616
49a45ecf
JB		 1617static CORE_ADDR
1618sparc64_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
1619{
1620 /* The ABI requires 16-byte alignment. */
1621 return address & ~0xf;
1622}
1623
8b39fe56 1624static CORE_ADDR
7d9b040b 1625sparc64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
8b39fe56
MK		 1626 struct regcache *regcache, CORE_ADDR bp_addr,
1627 int nargs, struct value **args, CORE_ADDR sp,
1628 int struct_return, CORE_ADDR struct_addr)
1629{
1630 /* Set return address. */
1631 regcache_cooked_write_unsigned (regcache, SPARC_O7_REGNUM, bp_addr - 8);
1632
1633 /* Set up function arguments. */
1634 sp = sparc64_store_arguments (regcache, nargs, args, sp,
1635 struct_return, struct_addr);
1636
1637 /* Allocate the register save area. */
1638 sp -= 16 * 8;
1639
1640 /* Stack should be 16-byte aligned at this point. */
3567a8ea 1641 gdb_assert ((sp + BIAS) % 16 == 0);
8b39fe56
MK		 1642
1643 /* Finally, update the stack pointer. */
1644 regcache_cooked_write_unsigned (regcache, SPARC_SP_REGNUM, sp);
1645
5b2d44a0 1646 return sp + BIAS;
8b39fe56
MK		 1647}
1648\f
1649
1650/* Extract from an array REGBUF containing the (raw) register state, a
1651 function return value of TYPE, and copy that into VALBUF. */
1652
1653static void
1654sparc64_extract_return_value (struct type *type, struct regcache *regcache,
e1613aba 1655 gdb_byte *valbuf)
8b39fe56
MK		 1656{
1657 int len = TYPE_LENGTH (type);
e1613aba 1658 gdb_byte buf[32];
8b39fe56
MK		 1659 int i;
1660
1661 if (sparc64_structure_or_union_p (type))
1662 {
1663 /* Structure or Union return values. */
1664 gdb_assert (len <= 32);
1665
1666 for (i = 0; i < ((len + 7) / 8); i++)
1667 regcache_cooked_read (regcache, SPARC_O0_REGNUM + i, buf + i * 8);
1668 if (TYPE_CODE (type) != TYPE_CODE_UNION)
1669 sparc64_extract_floating_fields (regcache, type, buf, 0);
1670 memcpy (valbuf, buf, len);
1671 }
cdc7b32f 1672 else if (sparc64_floating_p (type) || sparc64_complex_floating_p (type))
8b39fe56
MK		 1673 {
1674 /* Floating return values. */
1675 for (i = 0; i < len / 4; i++)
1676 regcache_cooked_read (regcache, SPARC_F0_REGNUM + i, buf + i * 4);
1677 memcpy (valbuf, buf, len);
1678 }
4bd87714
JB		 1679 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1680 {
1681 /* Small arrays are returned the same way as small structures. */
1682 gdb_assert (len <= 32);
1683
1684 for (i = 0; i < ((len + 7) / 8); i++)
1685 regcache_cooked_read (regcache, SPARC_O0_REGNUM + i, buf + i * 8);
1686 memcpy (valbuf, buf, len);
1687 }
8b39fe56
MK		 1688 else
1689 {
1690 /* Integral and pointer return values. */
1691 gdb_assert (sparc64_integral_or_pointer_p (type));
1692
1693 /* Just stripping off any unused bytes should preserve the
1694 signed-ness just fine. */
1695 regcache_cooked_read (regcache, SPARC_O0_REGNUM, buf);
1696 memcpy (valbuf, buf + 8 - len, len);
1697 }
1698}
1699
1700/* Write into the appropriate registers a function return value stored
1701 in VALBUF of type TYPE. */
1702
1703static void
1704sparc64_store_return_value (struct type *type, struct regcache *regcache,
e1613aba 1705 const gdb_byte *valbuf)
8b39fe56
MK		 1706{
1707 int len = TYPE_LENGTH (type);
e1613aba 1708 gdb_byte buf[16];
8b39fe56
MK		 1709 int i;
1710
1711 if (sparc64_structure_or_union_p (type))
1712 {
1713 /* Structure or Union return values. */
1714 gdb_assert (len <= 32);
1715
1716 /* Simplify matters by storing the complete value (including
1717 floating members) into %o0 and %o1. Floating members are
1718 also store in the appropriate floating-point registers. */
1719 memset (buf, 0, sizeof (buf));
1720 memcpy (buf, valbuf, len);
1721 for (i = 0; i < ((len + 7) / 8); i++)
60af1db2 1722 regcache_cooked_write (regcache, SPARC_O0_REGNUM + i, buf + i * 8);
8b39fe56
MK		 1723 if (TYPE_CODE (type) != TYPE_CODE_UNION)
1724 sparc64_store_floating_fields (regcache, type, buf, 0, 0);
1725 }
fe10a582 1726 else if (sparc64_floating_p (type) || sparc64_complex_floating_p (type))
8b39fe56
MK		 1727 {
1728 /* Floating return values. */
1729 memcpy (buf, valbuf, len);
1730 for (i = 0; i < len / 4; i++)
1731 regcache_cooked_write (regcache, SPARC_F0_REGNUM + i, buf + i * 4);
1732 }
4bd87714
JB		 1733 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1734 {
1735 /* Small arrays are returned the same way as small structures. */
1736 gdb_assert (len <= 32);
1737
1738 memset (buf, 0, sizeof (buf));
1739 memcpy (buf, valbuf, len);
1740 for (i = 0; i < ((len + 7) / 8); i++)
1741 regcache_cooked_write (regcache, SPARC_O0_REGNUM + i, buf + i * 8);
1742 }
8b39fe56
MK		 1743 else
1744 {
1745 /* Integral and pointer return values. */
1746 gdb_assert (sparc64_integral_or_pointer_p (type));
1747
1748 /* ??? Do we need to do any sign-extension here? */
1749 memset (buf, 0, 8);
1750 memcpy (buf + 8 - len, valbuf, len);
1751 regcache_cooked_write (regcache, SPARC_O0_REGNUM, buf);
1752 }
1753}
1754
60af1db2 1755static enum return_value_convention
6a3a010b 1756sparc64_return_value (struct gdbarch *gdbarch, struct value *function,
c055b101
CV		 1757 struct type *type, struct regcache *regcache,
1758 gdb_byte *readbuf, const gdb_byte *writebuf)
8b39fe56 1759{
60af1db2
MK		 1760 if (TYPE_LENGTH (type) > 32)
1761 return RETURN_VALUE_STRUCT_CONVENTION;
1762
1763 if (readbuf)
1764 sparc64_extract_return_value (type, regcache, readbuf);
1765 if (writebuf)
1766 sparc64_store_return_value (type, regcache, writebuf);
1767
1768 return RETURN_VALUE_REGISTER_CONVENTION;
8b39fe56 1769}
8b39fe56 1770\f
8b39fe56 1771
02a71ae8
MK		 1772static void
1773sparc64_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
aff37fc1 1774 struct dwarf2_frame_state_reg *reg,
4a4e5149 1775 struct frame_info *this_frame)
02a71ae8
MK		 1776{
1777 switch (regnum)
1778 {
1779 case SPARC_G0_REGNUM:
1780 /* Since %g0 is always zero, there is no point in saving it, and
1781 people will be inclined omit it from the CFI. Make sure we
1782 don't warn about that. */
1783 reg->how = DWARF2_FRAME_REG_SAME_VALUE;
1784 break;
1785 case SPARC_SP_REGNUM:
1786 reg->how = DWARF2_FRAME_REG_CFA;
1787 break;
1788 case SPARC64_PC_REGNUM:
1789 reg->how = DWARF2_FRAME_REG_RA_OFFSET;
1790 reg->loc.offset = 8;
1791 break;
1792 case SPARC64_NPC_REGNUM:
1793 reg->how = DWARF2_FRAME_REG_RA_OFFSET;
1794 reg->loc.offset = 12;
1795 break;
1796 }
1797}
1798
58afddc6
WP		 1799/* sparc64_addr_bits_remove - remove useless address bits */
1800
1801static CORE_ADDR
1802sparc64_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
1803{
1804 return adi_normalize_address (addr);
1805}
1806
8b39fe56 1807void
386c036b 1808sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
8b39fe56 1809{
386c036b 1810 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
8b39fe56 1811
386c036b
MK		 1812 tdep->pc_regnum = SPARC64_PC_REGNUM;
1813 tdep->npc_regnum = SPARC64_NPC_REGNUM;
3f7b46f2
IR		 1814 tdep->fpu_register_names = sparc64_fpu_register_names;
1815 tdep->fpu_registers_num = ARRAY_SIZE (sparc64_fpu_register_names);
1816 tdep->cp0_register_names = sparc64_cp0_register_names;
1817 tdep->cp0_registers_num = ARRAY_SIZE (sparc64_cp0_register_names);
8b39fe56 1818
386c036b 1819 /* This is what all the fuss is about. */
8b39fe56
MK		 1820 set_gdbarch_long_bit (gdbarch, 64);
1821 set_gdbarch_long_long_bit (gdbarch, 64);
1822 set_gdbarch_ptr_bit (gdbarch, 64);
8b39fe56 1823
53375380
PA		 1824 set_gdbarch_wchar_bit (gdbarch, 16);
1825 set_gdbarch_wchar_signed (gdbarch, 0);
1826
8b39fe56
MK		 1827 set_gdbarch_num_regs (gdbarch, SPARC64_NUM_REGS);
1828 set_gdbarch_register_name (gdbarch, sparc64_register_name);
1829 set_gdbarch_register_type (gdbarch, sparc64_register_type);
1830 set_gdbarch_num_pseudo_regs (gdbarch, SPARC64_NUM_PSEUDO_REGS);
3f7b46f2
IR		 1831 set_tdesc_pseudo_register_name (gdbarch, sparc64_pseudo_register_name);
1832 set_tdesc_pseudo_register_type (gdbarch, sparc64_pseudo_register_type);
8b39fe56
MK		 1833 set_gdbarch_pseudo_register_read (gdbarch, sparc64_pseudo_register_read);
1834 set_gdbarch_pseudo_register_write (gdbarch, sparc64_pseudo_register_write);
1835
1836 /* Register numbers of various important registers. */
8b39fe56 1837 set_gdbarch_pc_regnum (gdbarch, SPARC64_PC_REGNUM); /* %pc */
8b39fe56
MK		 1838
1839 /* Call dummy code. */
49a45ecf 1840 set_gdbarch_frame_align (gdbarch, sparc64_frame_align);
386c036b
MK		 1841 set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
1842 set_gdbarch_push_dummy_code (gdbarch, NULL);
8b39fe56
MK		 1843 set_gdbarch_push_dummy_call (gdbarch, sparc64_push_dummy_call);
1844
60af1db2 1845 set_gdbarch_return_value (gdbarch, sparc64_return_value);
386c036b
MK		 1846 set_gdbarch_stabs_argument_has_addr
1847 (gdbarch, default_stabs_argument_has_addr);
8b39fe56
MK		 1848
1849 set_gdbarch_skip_prologue (gdbarch, sparc64_skip_prologue);
c9cf6e20 1850 set_gdbarch_stack_frame_destroyed_p (gdbarch, sparc_stack_frame_destroyed_p);
8b39fe56 1851
02a71ae8
MK		 1852 /* Hook in the DWARF CFI frame unwinder. */
1853 dwarf2_frame_set_init_reg (gdbarch, sparc64_dwarf2_frame_init_reg);
1854 /* FIXME: kettenis/20050423: Don't enable the unwinder until the
1855 StackGhost issues have been resolved. */
1856
236369e7 1857 frame_unwind_append_unwinder (gdbarch, &sparc64_frame_unwind);
8b39fe56 1858 frame_base_set_default (gdbarch, &sparc64_frame_base);
58afddc6
WP		 1859
1860 set_gdbarch_addr_bits_remove (gdbarch, sparc64_addr_bits_remove);
386c036b
MK		 1861}
1862\f
8b39fe56 1863
386c036b 1864/* Helper functions for dealing with register sets. */
8b39fe56 1865
386c036b
MK		 1866#define TSTATE_CWP 0x000000000000001fULL
1867#define TSTATE_ICC 0x0000000f00000000ULL
1868#define TSTATE_XCC 0x000000f000000000ULL
8b39fe56 1869
386c036b 1870#define PSR_S 0x00000080
39b06c20 1871#ifndef PSR_ICC
386c036b 1872#define PSR_ICC 0x00f00000
39b06c20 1873#endif
386c036b 1874#define PSR_VERS 0x0f000000
39b06c20 1875#ifndef PSR_IMPL
386c036b 1876#define PSR_IMPL 0xf0000000
39b06c20 1877#endif
386c036b
MK		 1878#define PSR_V8PLUS 0xff000000
1879#define PSR_XCC 0x000f0000
8b39fe56 1880
3567a8ea 1881void
b4fd25c9 1882sparc64_supply_gregset (const struct sparc_gregmap *gregmap,
386c036b
MK		 1883 struct regcache *regcache,
1884 int regnum, const void *gregs)
8b39fe56 1885{
ac7936df 1886 struct gdbarch *gdbarch = regcache->arch ();
e17a4113
UW		 1887 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1888 int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32);
19ba03f4 1889 const gdb_byte *regs = (const gdb_byte *) gregs;
22e74ef9 1890 gdb_byte zero[8] = { 0 };
8b39fe56
MK		 1891 int i;
1892
386c036b 1893 if (sparc32)
8b39fe56 1894 {
386c036b
MK		 1895 if (regnum == SPARC32_PSR_REGNUM || regnum == -1)
1896 {
b4fd25c9 1897 int offset = gregmap->r_tstate_offset;
386c036b 1898 ULONGEST tstate, psr;
e1613aba 1899 gdb_byte buf[4];
386c036b 1900
e17a4113 1901 tstate = extract_unsigned_integer (regs + offset, 8, byte_order);
386c036b
MK		 1902 psr = ((tstate & TSTATE_CWP) | PSR_S | ((tstate & TSTATE_ICC) >> 12)
1903 | ((tstate & TSTATE_XCC) >> 20) | PSR_V8PLUS);
e17a4113 1904 store_unsigned_integer (buf, 4, byte_order, psr);
386c036b
MK		 1905 regcache_raw_supply (regcache, SPARC32_PSR_REGNUM, buf);
1906 }
1907
1908 if (regnum == SPARC32_PC_REGNUM || regnum == -1)
1909 regcache_raw_supply (regcache, SPARC32_PC_REGNUM,
b4fd25c9 1910 regs + gregmap->r_pc_offset + 4);
386c036b
MK		 1911
1912 if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
1913 regcache_raw_supply (regcache, SPARC32_NPC_REGNUM,
b4fd25c9 1914 regs + gregmap->r_npc_offset + 4);
8b39fe56 1915
386c036b 1916 if (regnum == SPARC32_Y_REGNUM || regnum == -1)
8b39fe56 1917 {
b4fd25c9 1918 int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size;
386c036b 1919 regcache_raw_supply (regcache, SPARC32_Y_REGNUM, regs + offset);
8b39fe56
MK		 1920 }
1921 }
1922 else
1923 {
386c036b
MK		 1924 if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
1925 regcache_raw_supply (regcache, SPARC64_STATE_REGNUM,
b4fd25c9 1926 regs + gregmap->r_tstate_offset);
8b39fe56 1927
386c036b
MK		 1928 if (regnum == SPARC64_PC_REGNUM || regnum == -1)
1929 regcache_raw_supply (regcache, SPARC64_PC_REGNUM,
b4fd25c9 1930 regs + gregmap->r_pc_offset);
386c036b
MK		 1931
1932 if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
1933 regcache_raw_supply (regcache, SPARC64_NPC_REGNUM,
b4fd25c9 1934 regs + gregmap->r_npc_offset);
386c036b
MK		 1935
1936 if (regnum == SPARC64_Y_REGNUM || regnum == -1)
3567a8ea 1937 {
e1613aba 1938 gdb_byte buf[8];
386c036b
MK		 1939
1940 memset (buf, 0, 8);
b4fd25c9
AA		 1941 memcpy (buf + 8 - gregmap->r_y_size,
1942 regs + gregmap->r_y_offset, gregmap->r_y_size);
386c036b 1943 regcache_raw_supply (regcache, SPARC64_Y_REGNUM, buf);
3567a8ea 1944 }
8b39fe56 1945
386c036b 1946 if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
b4fd25c9 1947 && gregmap->r_fprs_offset != -1)
386c036b 1948 regcache_raw_supply (regcache, SPARC64_FPRS_REGNUM,
b4fd25c9 1949 regs + gregmap->r_fprs_offset);
386c036b
MK		 1950 }
1951
1952 if (regnum == SPARC_G0_REGNUM || regnum == -1)
22e74ef9 1953 regcache_raw_supply (regcache, SPARC_G0_REGNUM, &zero);
386c036b
MK		 1954
1955 if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
1956 {
b4fd25c9 1957 int offset = gregmap->r_g1_offset;
386c036b
MK		 1958
1959 if (sparc32)
1960 offset += 4;
1961
1962 for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
8b39fe56 1963 {
3567a8ea 1964 if (regnum == i || regnum == -1)
386c036b
MK		 1965 regcache_raw_supply (regcache, i, regs + offset);
1966 offset += 8;
1967 }
1968 }
1969
1970 if ((regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM) || regnum == -1)
1971 {
1972 /* Not all of the register set variants include Locals and
1973 Inputs. For those that don't, we read them off the stack. */
b4fd25c9 1974 if (gregmap->r_l0_offset == -1)
386c036b
MK		 1975 {
1976 ULONGEST sp;
1977
1978 regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp);
1979 sparc_supply_rwindow (regcache, sp, regnum);
1980 }
1981 else
1982 {
b4fd25c9 1983 int offset = gregmap->r_l0_offset;
386c036b
MK		 1984
1985 if (sparc32)
1986 offset += 4;
1987
1988 for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
3567a8ea 1989 {
386c036b
MK		 1990 if (regnum == i || regnum == -1)
1991 regcache_raw_supply (regcache, i, regs + offset);
1992 offset += 8;
3567a8ea 1993 }
8b39fe56
MK		 1994 }
1995 }
1996}
1997
1998void
b4fd25c9 1999sparc64_collect_gregset (const struct sparc_gregmap *gregmap,
386c036b
MK		 2000 const struct regcache *regcache,
2001 int regnum, void *gregs)
8b39fe56 2002{
ac7936df 2003 struct gdbarch *gdbarch = regcache->arch ();
e17a4113
UW		 2004 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2005 int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32);
19ba03f4 2006 gdb_byte *regs = (gdb_byte *) gregs;
3567a8ea
MK		 2007 int i;
2008
386c036b 2009 if (sparc32)
8b39fe56 2010 {
386c036b
MK		 2011 if (regnum == SPARC32_PSR_REGNUM || regnum == -1)
2012 {
b4fd25c9 2013 int offset = gregmap->r_tstate_offset;
386c036b 2014 ULONGEST tstate, psr;
e1613aba 2015 gdb_byte buf[8];
386c036b 2016
e17a4113 2017 tstate = extract_unsigned_integer (regs + offset, 8, byte_order);
386c036b 2018 regcache_raw_collect (regcache, SPARC32_PSR_REGNUM, buf);
e17a4113 2019 psr = extract_unsigned_integer (buf, 4, byte_order);
386c036b
MK		 2020 tstate |= (psr & PSR_ICC) << 12;
2021 if ((psr & (PSR_VERS | PSR_IMPL)) == PSR_V8PLUS)
2022 tstate |= (psr & PSR_XCC) << 20;
e17a4113 2023 store_unsigned_integer (buf, 8, byte_order, tstate);
386c036b
MK		 2024 memcpy (regs + offset, buf, 8);
2025 }
8b39fe56 2026
386c036b
MK		 2027 if (regnum == SPARC32_PC_REGNUM || regnum == -1)
2028 regcache_raw_collect (regcache, SPARC32_PC_REGNUM,
b4fd25c9 2029 regs + gregmap->r_pc_offset + 4);
386c036b
MK		 2030
2031 if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
2032 regcache_raw_collect (regcache, SPARC32_NPC_REGNUM,
b4fd25c9 2033 regs + gregmap->r_npc_offset + 4);
386c036b
MK		 2034
2035 if (regnum == SPARC32_Y_REGNUM || regnum == -1)
8b39fe56 2036 {
b4fd25c9 2037 int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size;
386c036b 2038 regcache_raw_collect (regcache, SPARC32_Y_REGNUM, regs + offset);
8b39fe56
MK		 2039 }
2040 }
2041 else
2042 {
386c036b
MK		 2043 if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
2044 regcache_raw_collect (regcache, SPARC64_STATE_REGNUM,
b4fd25c9 2045 regs + gregmap->r_tstate_offset);
386c036b
MK		 2046
2047 if (regnum == SPARC64_PC_REGNUM || regnum == -1)
2048 regcache_raw_collect (regcache, SPARC64_PC_REGNUM,
b4fd25c9 2049 regs + gregmap->r_pc_offset);
3567a8ea 2050
386c036b
MK		 2051 if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
2052 regcache_raw_collect (regcache, SPARC64_NPC_REGNUM,
b4fd25c9 2053 regs + gregmap->r_npc_offset);
3567a8ea 2054
386c036b 2055 if (regnum == SPARC64_Y_REGNUM || regnum == -1)
3567a8ea 2056 {
e1613aba 2057 gdb_byte buf[8];
386c036b
MK		 2058
2059 regcache_raw_collect (regcache, SPARC64_Y_REGNUM, buf);
b4fd25c9
AA		 2060 memcpy (regs + gregmap->r_y_offset,
2061 buf + 8 - gregmap->r_y_size, gregmap->r_y_size);
386c036b
MK		 2062 }
2063
2064 if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
b4fd25c9 2065 && gregmap->r_fprs_offset != -1)
386c036b 2066 regcache_raw_collect (regcache, SPARC64_FPRS_REGNUM,
b4fd25c9 2067 regs + gregmap->r_fprs_offset);
386c036b
MK		 2068
2069 }
2070
2071 if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
2072 {
b4fd25c9 2073 int offset = gregmap->r_g1_offset;
386c036b
MK		 2074
2075 if (sparc32)
2076 offset += 4;
2077
2078 /* %g0 is always zero. */
2079 for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
2080 {
2081 if (regnum == i || regnum == -1)
2082 regcache_raw_collect (regcache, i, regs + offset);
2083 offset += 8;
2084 }
2085 }
2086
2087 if ((regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM) || regnum == -1)
2088 {
2089 /* Not all of the register set variants include Locals and
2090 Inputs. For those that don't, we read them off the stack. */
b4fd25c9 2091 if (gregmap->r_l0_offset != -1)
386c036b 2092 {
b4fd25c9 2093 int offset = gregmap->r_l0_offset;
386c036b
MK		 2094
2095 if (sparc32)
2096 offset += 4;
2097
2098 for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
3567a8ea 2099 {
386c036b
MK		 2100 if (regnum == i || regnum == -1)
2101 regcache_raw_collect (regcache, i, regs + offset);
2102 offset += 8;
3567a8ea
MK		 2103 }
2104 }
8b39fe56
MK		 2105 }
2106}
8b39fe56 2107
386c036b 2108void
b4fd25c9 2109sparc64_supply_fpregset (const struct sparc_fpregmap *fpregmap,
db75c717 2110 struct regcache *regcache,
386c036b
MK		 2111 int regnum, const void *fpregs)
2112{
ac7936df 2113 int sparc32 = (gdbarch_ptr_bit (regcache->arch ()) == 32);
19ba03f4 2114 const gdb_byte *regs = (const gdb_byte *) fpregs;
386c036b
MK		 2115 int i;
2116
2117 for (i = 0; i < 32; i++)
2118 {
2119 if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
db75c717 2120 regcache_raw_supply (regcache, SPARC_F0_REGNUM + i,
b4fd25c9 2121 regs + fpregmap->r_f0_offset + (i * 4));
386c036b
MK		 2122 }
2123
2124 if (sparc32)
2125 {
2126 if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
2127 regcache_raw_supply (regcache, SPARC32_FSR_REGNUM,
b4fd25c9 2128 regs + fpregmap->r_fsr_offset);
386c036b
MK		 2129 }
2130 else
2131 {
2132 for (i = 0; i < 16; i++)
2133 {
2134 if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
2135 regcache_raw_supply (regcache, SPARC64_F32_REGNUM + i,
b4fd25c9 2136 (regs + fpregmap->r_f0_offset
db75c717 2137 + (32 * 4) + (i * 8)));
386c036b
MK		 2138 }
2139
2140 if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
2141 regcache_raw_supply (regcache, SPARC64_FSR_REGNUM,
b4fd25c9 2142 regs + fpregmap->r_fsr_offset);
386c036b
MK		 2143 }
2144}
8b39fe56
MK		 2145
2146void
b4fd25c9 2147sparc64_collect_fpregset (const struct sparc_fpregmap *fpregmap,
db75c717 2148 const struct regcache *regcache,
386c036b 2149 int regnum, void *fpregs)
8b39fe56 2150{
ac7936df 2151 int sparc32 = (gdbarch_ptr_bit (regcache->arch ()) == 32);
19ba03f4 2152 gdb_byte *regs = (gdb_byte *) fpregs;
386c036b
MK		 2153 int i;
2154
2155 for (i = 0; i < 32; i++)
2156 {
2157 if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
db75c717 2158 regcache_raw_collect (regcache, SPARC_F0_REGNUM + i,
b4fd25c9 2159 regs + fpregmap->r_f0_offset + (i * 4));
386c036b
MK		 2160 }
2161
2162 if (sparc32)
2163 {
2164 if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
2165 regcache_raw_collect (regcache, SPARC32_FSR_REGNUM,
b4fd25c9 2166 regs + fpregmap->r_fsr_offset);
386c036b
MK		 2167 }
2168 else
2169 {
2170 for (i = 0; i < 16; i++)
2171 {
2172 if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
2173 regcache_raw_collect (regcache, SPARC64_F32_REGNUM + i,
b4fd25c9 2174 (regs + fpregmap->r_f0_offset
db75c717 2175 + (32 * 4) + (i * 8)));
386c036b
MK		 2176 }
2177
2178 if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
2179 regcache_raw_collect (regcache, SPARC64_FSR_REGNUM,
b4fd25c9 2180 regs + fpregmap->r_fsr_offset);
386c036b 2181 }
8b39fe56 2182}
fd936806 2183
b4fd25c9 2184const struct sparc_fpregmap sparc64_bsd_fpregmap =
db75c717
DM		 2185{
2186 0 * 8, /* %f0 */
2187 32 * 8, /* %fsr */
2188};
GDB Binutils - Deliverables
This page took 1.572267 seconds and 4 git commands to generate.