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