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