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