1//===-- ABIMacOSX_arm64.cpp -------------------------------------*- C++ -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8 9#include "ABIMacOSX_arm64.h" 10 11#include <vector> 12 13#include "llvm/ADT/STLExtras.h" 14#include "llvm/ADT/Triple.h" 15 16#include "lldb/Core/Module.h" 17#include "lldb/Core/PluginManager.h" 18#include "lldb/Core/Value.h" 19#include "lldb/Core/ValueObjectConstResult.h" 20#include "lldb/Symbol/UnwindPlan.h" 21#include "lldb/Target/Process.h" 22#include "lldb/Target/RegisterContext.h" 23#include "lldb/Target/Target.h" 24#include "lldb/Target/Thread.h" 25#include "lldb/Utility/ConstString.h" 26#include "lldb/Utility/Log.h" 27#include "lldb/Utility/RegisterValue.h" 28#include "lldb/Utility/Scalar.h" 29#include "lldb/Utility/Status.h" 30 31#include "Utility/ARM64_DWARF_Registers.h" 32 33using namespace lldb; 34using namespace lldb_private; 35 36static const char *pluginDesc = "Mac OS X ABI for arm64 targets"; 37 38static RegisterInfo g_register_infos[] = { 39 // NAME ALT SZ OFF ENCODING FORMAT 40 // EH_FRAME DWARF GENERIC 41 // PROCESS PLUGIN LLDB NATIVE 42 // ========== ======= == === ============= =================== 43 // =================== ====================== =========================== 44 // ======================= ====================== 45 {"x0", 46 nullptr, 47 8, 48 0, 49 eEncodingUint, 50 eFormatHex, 51 {LLDB_INVALID_REGNUM, arm64_dwarf::x0, LLDB_REGNUM_GENERIC_ARG1, 52 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 53 nullptr, 54 nullptr, 55 nullptr, 56 0}, 57 {"x1", 58 nullptr, 59 8, 60 0, 61 eEncodingUint, 62 eFormatHex, 63 {LLDB_INVALID_REGNUM, arm64_dwarf::x1, LLDB_REGNUM_GENERIC_ARG2, 64 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 65 nullptr, 66 nullptr, 67 nullptr, 68 0}, 69 {"x2", 70 nullptr, 71 8, 72 0, 73 eEncodingUint, 74 eFormatHex, 75 {LLDB_INVALID_REGNUM, arm64_dwarf::x2, LLDB_REGNUM_GENERIC_ARG3, 76 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 77 nullptr, 78 nullptr, 79 nullptr, 80 0}, 81 {"x3", 82 nullptr, 83 8, 84 0, 85 eEncodingUint, 86 eFormatHex, 87 {LLDB_INVALID_REGNUM, arm64_dwarf::x3, LLDB_REGNUM_GENERIC_ARG4, 88 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 89 nullptr, 90 nullptr, 91 nullptr, 92 0}, 93 {"x4", 94 nullptr, 95 8, 96 0, 97 eEncodingUint, 98 eFormatHex, 99 {LLDB_INVALID_REGNUM, arm64_dwarf::x4, LLDB_REGNUM_GENERIC_ARG5, 100 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 101 nullptr, 102 nullptr, 103 nullptr, 104 0}, 105 {"x5", 106 nullptr, 107 8, 108 0, 109 eEncodingUint, 110 eFormatHex, 111 {LLDB_INVALID_REGNUM, arm64_dwarf::x5, LLDB_REGNUM_GENERIC_ARG6, 112 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 113 nullptr, 114 nullptr, 115 nullptr, 116 0}, 117 {"x6", 118 nullptr, 119 8, 120 0, 121 eEncodingUint, 122 eFormatHex, 123 {LLDB_INVALID_REGNUM, arm64_dwarf::x6, LLDB_REGNUM_GENERIC_ARG7, 124 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 125 nullptr, 126 nullptr, 127 nullptr, 128 0}, 129 {"x7", 130 nullptr, 131 8, 132 0, 133 eEncodingUint, 134 eFormatHex, 135 {LLDB_INVALID_REGNUM, arm64_dwarf::x7, LLDB_REGNUM_GENERIC_ARG8, 136 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 137 nullptr, 138 nullptr, 139 nullptr, 140 0}, 141 {"x8", 142 nullptr, 143 8, 144 0, 145 eEncodingUint, 146 eFormatHex, 147 {LLDB_INVALID_REGNUM, arm64_dwarf::x8, LLDB_INVALID_REGNUM, 148 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 149 nullptr, 150 nullptr, 151 nullptr, 152 0}, 153 {"x9", 154 nullptr, 155 8, 156 0, 157 eEncodingUint, 158 eFormatHex, 159 {LLDB_INVALID_REGNUM, arm64_dwarf::x9, LLDB_INVALID_REGNUM, 160 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 161 nullptr, 162 nullptr, 163 nullptr, 164 0}, 165 {"x10", 166 nullptr, 167 8, 168 0, 169 eEncodingUint, 170 eFormatHex, 171 {LLDB_INVALID_REGNUM, arm64_dwarf::x10, LLDB_INVALID_REGNUM, 172 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 173 nullptr, 174 nullptr, 175 nullptr, 176 0}, 177 {"x11", 178 nullptr, 179 8, 180 0, 181 eEncodingUint, 182 eFormatHex, 183 {LLDB_INVALID_REGNUM, arm64_dwarf::x11, LLDB_INVALID_REGNUM, 184 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 185 nullptr, 186 nullptr, 187 nullptr, 188 0}, 189 {"x12", 190 nullptr, 191 8, 192 0, 193 eEncodingUint, 194 eFormatHex, 195 {LLDB_INVALID_REGNUM, arm64_dwarf::x12, LLDB_INVALID_REGNUM, 196 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 197 nullptr, 198 nullptr, 199 nullptr, 200 0}, 201 {"x13", 202 nullptr, 203 8, 204 0, 205 eEncodingUint, 206 eFormatHex, 207 {LLDB_INVALID_REGNUM, arm64_dwarf::x13, LLDB_INVALID_REGNUM, 208 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 209 nullptr, 210 nullptr, 211 nullptr, 212 0}, 213 {"x14", 214 nullptr, 215 8, 216 0, 217 eEncodingUint, 218 eFormatHex, 219 {LLDB_INVALID_REGNUM, arm64_dwarf::x14, LLDB_INVALID_REGNUM, 220 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 221 nullptr, 222 nullptr, 223 nullptr, 224 0}, 225 {"x15", 226 nullptr, 227 8, 228 0, 229 eEncodingUint, 230 eFormatHex, 231 {LLDB_INVALID_REGNUM, arm64_dwarf::x15, LLDB_INVALID_REGNUM, 232 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 233 nullptr, 234 nullptr, 235 nullptr, 236 0}, 237 {"x16", 238 nullptr, 239 8, 240 0, 241 eEncodingUint, 242 eFormatHex, 243 {LLDB_INVALID_REGNUM, arm64_dwarf::x16, LLDB_INVALID_REGNUM, 244 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 245 nullptr, 246 nullptr, 247 nullptr, 248 0}, 249 {"x17", 250 nullptr, 251 8, 252 0, 253 eEncodingUint, 254 eFormatHex, 255 {LLDB_INVALID_REGNUM, arm64_dwarf::x17, LLDB_INVALID_REGNUM, 256 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 257 nullptr, 258 nullptr, 259 nullptr, 260 0}, 261 {"x18", 262 nullptr, 263 8, 264 0, 265 eEncodingUint, 266 eFormatHex, 267 {LLDB_INVALID_REGNUM, arm64_dwarf::x18, LLDB_INVALID_REGNUM, 268 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 269 nullptr, 270 nullptr, 271 nullptr, 272 0}, 273 {"x19", 274 nullptr, 275 8, 276 0, 277 eEncodingUint, 278 eFormatHex, 279 {LLDB_INVALID_REGNUM, arm64_dwarf::x19, LLDB_INVALID_REGNUM, 280 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 281 nullptr, 282 nullptr, 283 nullptr, 284 0}, 285 {"x20", 286 nullptr, 287 8, 288 0, 289 eEncodingUint, 290 eFormatHex, 291 {LLDB_INVALID_REGNUM, arm64_dwarf::x20, LLDB_INVALID_REGNUM, 292 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 293 nullptr, 294 nullptr, 295 nullptr, 296 0}, 297 {"x21", 298 nullptr, 299 8, 300 0, 301 eEncodingUint, 302 eFormatHex, 303 {LLDB_INVALID_REGNUM, arm64_dwarf::x21, LLDB_INVALID_REGNUM, 304 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 305 nullptr, 306 nullptr, 307 nullptr, 308 0}, 309 {"x22", 310 nullptr, 311 8, 312 0, 313 eEncodingUint, 314 eFormatHex, 315 {LLDB_INVALID_REGNUM, arm64_dwarf::x22, LLDB_INVALID_REGNUM, 316 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 317 nullptr, 318 nullptr, 319 nullptr, 320 0}, 321 {"x23", 322 nullptr, 323 8, 324 0, 325 eEncodingUint, 326 eFormatHex, 327 {LLDB_INVALID_REGNUM, arm64_dwarf::x23, LLDB_INVALID_REGNUM, 328 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 329 nullptr, 330 nullptr, 331 nullptr, 332 0}, 333 {"x24", 334 nullptr, 335 8, 336 0, 337 eEncodingUint, 338 eFormatHex, 339 {LLDB_INVALID_REGNUM, arm64_dwarf::x24, LLDB_INVALID_REGNUM, 340 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 341 nullptr, 342 nullptr, 343 nullptr, 344 0}, 345 {"x25", 346 nullptr, 347 8, 348 0, 349 eEncodingUint, 350 eFormatHex, 351 {LLDB_INVALID_REGNUM, arm64_dwarf::x25, LLDB_INVALID_REGNUM, 352 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 353 nullptr, 354 nullptr, 355 nullptr, 356 0}, 357 {"x26", 358 nullptr, 359 8, 360 0, 361 eEncodingUint, 362 eFormatHex, 363 {LLDB_INVALID_REGNUM, arm64_dwarf::x26, LLDB_INVALID_REGNUM, 364 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 365 nullptr, 366 nullptr, 367 nullptr, 368 0}, 369 {"x27", 370 nullptr, 371 8, 372 0, 373 eEncodingUint, 374 eFormatHex, 375 {LLDB_INVALID_REGNUM, arm64_dwarf::x27, LLDB_INVALID_REGNUM, 376 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 377 nullptr, 378 nullptr, 379 nullptr, 380 0}, 381 {"x28", 382 nullptr, 383 8, 384 0, 385 eEncodingUint, 386 eFormatHex, 387 {LLDB_INVALID_REGNUM, arm64_dwarf::x28, LLDB_INVALID_REGNUM, 388 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 389 nullptr, 390 nullptr, 391 nullptr, 392 0}, 393 {"fp", 394 "x29", 395 8, 396 0, 397 eEncodingUint, 398 eFormatHex, 399 {LLDB_INVALID_REGNUM, arm64_dwarf::x29, LLDB_REGNUM_GENERIC_FP, 400 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 401 nullptr, 402 nullptr, 403 nullptr, 404 0}, 405 {"lr", 406 "x30", 407 8, 408 0, 409 eEncodingUint, 410 eFormatHex, 411 {LLDB_INVALID_REGNUM, arm64_dwarf::x30, LLDB_REGNUM_GENERIC_RA, 412 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 413 nullptr, 414 nullptr, 415 nullptr, 416 0}, 417 {"sp", 418 "x31", 419 8, 420 0, 421 eEncodingUint, 422 eFormatHex, 423 {LLDB_INVALID_REGNUM, arm64_dwarf::x31, LLDB_REGNUM_GENERIC_SP, 424 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 425 nullptr, 426 nullptr, 427 nullptr, 428 0}, 429 {"pc", 430 nullptr, 431 8, 432 0, 433 eEncodingUint, 434 eFormatHex, 435 {LLDB_INVALID_REGNUM, arm64_dwarf::pc, LLDB_REGNUM_GENERIC_PC, 436 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 437 nullptr, 438 nullptr, 439 nullptr, 440 0}, 441 {"cpsr", 442 "psr", 443 4, 444 0, 445 eEncodingUint, 446 eFormatHex, 447 {LLDB_INVALID_REGNUM, arm64_dwarf::cpsr, LLDB_REGNUM_GENERIC_FLAGS, 448 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 449 nullptr, 450 nullptr, 451 nullptr, 452 0}, 453 454 {"v0", 455 nullptr, 456 16, 457 0, 458 eEncodingVector, 459 eFormatVectorOfUInt8, 460 {LLDB_INVALID_REGNUM, arm64_dwarf::v0, LLDB_INVALID_REGNUM, 461 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 462 nullptr, 463 nullptr, 464 nullptr, 465 0}, 466 {"v1", 467 nullptr, 468 16, 469 0, 470 eEncodingVector, 471 eFormatVectorOfUInt8, 472 {LLDB_INVALID_REGNUM, arm64_dwarf::v1, LLDB_INVALID_REGNUM, 473 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 474 nullptr, 475 nullptr, 476 nullptr, 477 0}, 478 {"v2", 479 nullptr, 480 16, 481 0, 482 eEncodingVector, 483 eFormatVectorOfUInt8, 484 {LLDB_INVALID_REGNUM, arm64_dwarf::v2, LLDB_INVALID_REGNUM, 485 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 486 nullptr, 487 nullptr, 488 nullptr, 489 0}, 490 {"v3", 491 nullptr, 492 16, 493 0, 494 eEncodingVector, 495 eFormatVectorOfUInt8, 496 {LLDB_INVALID_REGNUM, arm64_dwarf::v3, LLDB_INVALID_REGNUM, 497 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 498 nullptr, 499 nullptr, 500 nullptr, 501 0}, 502 {"v4", 503 nullptr, 504 16, 505 0, 506 eEncodingVector, 507 eFormatVectorOfUInt8, 508 {LLDB_INVALID_REGNUM, arm64_dwarf::v4, LLDB_INVALID_REGNUM, 509 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 510 nullptr, 511 nullptr, 512 nullptr, 513 0}, 514 {"v5", 515 nullptr, 516 16, 517 0, 518 eEncodingVector, 519 eFormatVectorOfUInt8, 520 {LLDB_INVALID_REGNUM, arm64_dwarf::v5, LLDB_INVALID_REGNUM, 521 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 522 nullptr, 523 nullptr, 524 nullptr, 525 0}, 526 {"v6", 527 nullptr, 528 16, 529 0, 530 eEncodingVector, 531 eFormatVectorOfUInt8, 532 {LLDB_INVALID_REGNUM, arm64_dwarf::v6, LLDB_INVALID_REGNUM, 533 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 534 nullptr, 535 nullptr, 536 nullptr, 537 0}, 538 {"v7", 539 nullptr, 540 16, 541 0, 542 eEncodingVector, 543 eFormatVectorOfUInt8, 544 {LLDB_INVALID_REGNUM, arm64_dwarf::v7, LLDB_INVALID_REGNUM, 545 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 546 nullptr, 547 nullptr, 548 nullptr, 549 0}, 550 {"v8", 551 nullptr, 552 16, 553 0, 554 eEncodingVector, 555 eFormatVectorOfUInt8, 556 {LLDB_INVALID_REGNUM, arm64_dwarf::v8, LLDB_INVALID_REGNUM, 557 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 558 nullptr, 559 nullptr, 560 nullptr, 561 0}, 562 {"v9", 563 nullptr, 564 16, 565 0, 566 eEncodingVector, 567 eFormatVectorOfUInt8, 568 {LLDB_INVALID_REGNUM, arm64_dwarf::v9, LLDB_INVALID_REGNUM, 569 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 570 nullptr, 571 nullptr, 572 nullptr, 573 0}, 574 {"v10", 575 nullptr, 576 16, 577 0, 578 eEncodingVector, 579 eFormatVectorOfUInt8, 580 {LLDB_INVALID_REGNUM, arm64_dwarf::v10, LLDB_INVALID_REGNUM, 581 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 582 nullptr, 583 nullptr, 584 nullptr, 585 0}, 586 {"v11", 587 nullptr, 588 16, 589 0, 590 eEncodingVector, 591 eFormatVectorOfUInt8, 592 {LLDB_INVALID_REGNUM, arm64_dwarf::v11, LLDB_INVALID_REGNUM, 593 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 594 nullptr, 595 nullptr, 596 nullptr, 597 0}, 598 {"v12", 599 nullptr, 600 16, 601 0, 602 eEncodingVector, 603 eFormatVectorOfUInt8, 604 {LLDB_INVALID_REGNUM, arm64_dwarf::v12, LLDB_INVALID_REGNUM, 605 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 606 nullptr, 607 nullptr, 608 nullptr, 609 0}, 610 {"v13", 611 nullptr, 612 16, 613 0, 614 eEncodingVector, 615 eFormatVectorOfUInt8, 616 {LLDB_INVALID_REGNUM, arm64_dwarf::v13, LLDB_INVALID_REGNUM, 617 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 618 nullptr, 619 nullptr, 620 nullptr, 621 0}, 622 {"v14", 623 nullptr, 624 16, 625 0, 626 eEncodingVector, 627 eFormatVectorOfUInt8, 628 {LLDB_INVALID_REGNUM, arm64_dwarf::v14, LLDB_INVALID_REGNUM, 629 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 630 nullptr, 631 nullptr, 632 nullptr, 633 0}, 634 {"v15", 635 nullptr, 636 16, 637 0, 638 eEncodingVector, 639 eFormatVectorOfUInt8, 640 {LLDB_INVALID_REGNUM, arm64_dwarf::v15, LLDB_INVALID_REGNUM, 641 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 642 nullptr, 643 nullptr, 644 nullptr, 645 0}, 646 {"v16", 647 nullptr, 648 16, 649 0, 650 eEncodingVector, 651 eFormatVectorOfUInt8, 652 {LLDB_INVALID_REGNUM, arm64_dwarf::v16, LLDB_INVALID_REGNUM, 653 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 654 nullptr, 655 nullptr, 656 nullptr, 657 0}, 658 {"v17", 659 nullptr, 660 16, 661 0, 662 eEncodingVector, 663 eFormatVectorOfUInt8, 664 {LLDB_INVALID_REGNUM, arm64_dwarf::v17, LLDB_INVALID_REGNUM, 665 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 666 nullptr, 667 nullptr, 668 nullptr, 669 0}, 670 {"v18", 671 nullptr, 672 16, 673 0, 674 eEncodingVector, 675 eFormatVectorOfUInt8, 676 {LLDB_INVALID_REGNUM, arm64_dwarf::v18, LLDB_INVALID_REGNUM, 677 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 678 nullptr, 679 nullptr, 680 nullptr, 681 0}, 682 {"v19", 683 nullptr, 684 16, 685 0, 686 eEncodingVector, 687 eFormatVectorOfUInt8, 688 {LLDB_INVALID_REGNUM, arm64_dwarf::v19, LLDB_INVALID_REGNUM, 689 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 690 nullptr, 691 nullptr, 692 nullptr, 693 0}, 694 {"v20", 695 nullptr, 696 16, 697 0, 698 eEncodingVector, 699 eFormatVectorOfUInt8, 700 {LLDB_INVALID_REGNUM, arm64_dwarf::v20, LLDB_INVALID_REGNUM, 701 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 702 nullptr, 703 nullptr, 704 nullptr, 705 0}, 706 {"v21", 707 nullptr, 708 16, 709 0, 710 eEncodingVector, 711 eFormatVectorOfUInt8, 712 {LLDB_INVALID_REGNUM, arm64_dwarf::v21, LLDB_INVALID_REGNUM, 713 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 714 nullptr, 715 nullptr, 716 nullptr, 717 0}, 718 {"v22", 719 nullptr, 720 16, 721 0, 722 eEncodingVector, 723 eFormatVectorOfUInt8, 724 {LLDB_INVALID_REGNUM, arm64_dwarf::v22, LLDB_INVALID_REGNUM, 725 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 726 nullptr, 727 nullptr, 728 nullptr, 729 0}, 730 {"v23", 731 nullptr, 732 16, 733 0, 734 eEncodingVector, 735 eFormatVectorOfUInt8, 736 {LLDB_INVALID_REGNUM, arm64_dwarf::v23, LLDB_INVALID_REGNUM, 737 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 738 nullptr, 739 nullptr, 740 nullptr, 741 0}, 742 {"v24", 743 nullptr, 744 16, 745 0, 746 eEncodingVector, 747 eFormatVectorOfUInt8, 748 {LLDB_INVALID_REGNUM, arm64_dwarf::v24, LLDB_INVALID_REGNUM, 749 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 750 nullptr, 751 nullptr, 752 nullptr, 753 0}, 754 {"v25", 755 nullptr, 756 16, 757 0, 758 eEncodingVector, 759 eFormatVectorOfUInt8, 760 {LLDB_INVALID_REGNUM, arm64_dwarf::v25, LLDB_INVALID_REGNUM, 761 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 762 nullptr, 763 nullptr, 764 nullptr, 765 0}, 766 {"v26", 767 nullptr, 768 16, 769 0, 770 eEncodingVector, 771 eFormatVectorOfUInt8, 772 {LLDB_INVALID_REGNUM, arm64_dwarf::v26, LLDB_INVALID_REGNUM, 773 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 774 nullptr, 775 nullptr, 776 nullptr, 777 0}, 778 {"v27", 779 nullptr, 780 16, 781 0, 782 eEncodingVector, 783 eFormatVectorOfUInt8, 784 {LLDB_INVALID_REGNUM, arm64_dwarf::v27, LLDB_INVALID_REGNUM, 785 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 786 nullptr, 787 nullptr, 788 nullptr, 789 0}, 790 {"v28", 791 nullptr, 792 16, 793 0, 794 eEncodingVector, 795 eFormatVectorOfUInt8, 796 {LLDB_INVALID_REGNUM, arm64_dwarf::v28, LLDB_INVALID_REGNUM, 797 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 798 nullptr, 799 nullptr, 800 nullptr, 801 0}, 802 {"v29", 803 nullptr, 804 16, 805 0, 806 eEncodingVector, 807 eFormatVectorOfUInt8, 808 {LLDB_INVALID_REGNUM, arm64_dwarf::v29, LLDB_INVALID_REGNUM, 809 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 810 nullptr, 811 nullptr, 812 nullptr, 813 0}, 814 {"v30", 815 nullptr, 816 16, 817 0, 818 eEncodingVector, 819 eFormatVectorOfUInt8, 820 {LLDB_INVALID_REGNUM, arm64_dwarf::v30, LLDB_INVALID_REGNUM, 821 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 822 nullptr, 823 nullptr, 824 nullptr, 825 0}, 826 {"v31", 827 nullptr, 828 16, 829 0, 830 eEncodingVector, 831 eFormatVectorOfUInt8, 832 {LLDB_INVALID_REGNUM, arm64_dwarf::v31, LLDB_INVALID_REGNUM, 833 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 834 nullptr, 835 nullptr, 836 nullptr, 837 0}, 838 839 {"fpsr", 840 nullptr, 841 4, 842 0, 843 eEncodingUint, 844 eFormatHex, 845 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 846 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 847 nullptr, 848 nullptr, 849 nullptr, 850 0}, 851 {"fpcr", 852 nullptr, 853 4, 854 0, 855 eEncodingUint, 856 eFormatHex, 857 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 858 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 859 nullptr, 860 nullptr, 861 nullptr, 862 0}, 863 864 {"s0", 865 nullptr, 866 4, 867 0, 868 eEncodingIEEE754, 869 eFormatFloat, 870 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 871 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 872 nullptr, 873 nullptr, 874 nullptr, 875 0}, 876 {"s1", 877 nullptr, 878 4, 879 0, 880 eEncodingIEEE754, 881 eFormatFloat, 882 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 883 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 884 nullptr, 885 nullptr, 886 nullptr, 887 0}, 888 {"s2", 889 nullptr, 890 4, 891 0, 892 eEncodingIEEE754, 893 eFormatFloat, 894 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 895 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 896 nullptr, 897 nullptr, 898 nullptr, 899 0}, 900 {"s3", 901 nullptr, 902 4, 903 0, 904 eEncodingIEEE754, 905 eFormatFloat, 906 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 907 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 908 nullptr, 909 nullptr, 910 nullptr, 911 0}, 912 {"s4", 913 nullptr, 914 4, 915 0, 916 eEncodingIEEE754, 917 eFormatFloat, 918 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 919 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 920 nullptr, 921 nullptr, 922 nullptr, 923 0}, 924 {"s5", 925 nullptr, 926 4, 927 0, 928 eEncodingIEEE754, 929 eFormatFloat, 930 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 931 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 932 nullptr, 933 nullptr, 934 nullptr, 935 0}, 936 {"s6", 937 nullptr, 938 4, 939 0, 940 eEncodingIEEE754, 941 eFormatFloat, 942 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 943 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 944 nullptr, 945 nullptr, 946 nullptr, 947 0}, 948 {"s7", 949 nullptr, 950 4, 951 0, 952 eEncodingIEEE754, 953 eFormatFloat, 954 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 955 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 956 nullptr, 957 nullptr, 958 nullptr, 959 0}, 960 {"s8", 961 nullptr, 962 4, 963 0, 964 eEncodingIEEE754, 965 eFormatFloat, 966 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 967 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 968 nullptr, 969 nullptr, 970 nullptr, 971 0}, 972 {"s9", 973 nullptr, 974 4, 975 0, 976 eEncodingIEEE754, 977 eFormatFloat, 978 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 979 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 980 nullptr, 981 nullptr, 982 nullptr, 983 0}, 984 {"s10", 985 nullptr, 986 4, 987 0, 988 eEncodingIEEE754, 989 eFormatFloat, 990 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 991 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 992 nullptr, 993 nullptr, 994 nullptr, 995 0}, 996 {"s11", 997 nullptr, 998 4, 999 0, 1000 eEncodingIEEE754, 1001 eFormatFloat, 1002 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1003 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1004 nullptr, 1005 nullptr, 1006 nullptr, 1007 0}, 1008 {"s12", 1009 nullptr, 1010 4, 1011 0, 1012 eEncodingIEEE754, 1013 eFormatFloat, 1014 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1015 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1016 nullptr, 1017 nullptr, 1018 nullptr, 1019 0}, 1020 {"s13", 1021 nullptr, 1022 4, 1023 0, 1024 eEncodingIEEE754, 1025 eFormatFloat, 1026 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1027 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1028 nullptr, 1029 nullptr, 1030 nullptr, 1031 0}, 1032 {"s14", 1033 nullptr, 1034 4, 1035 0, 1036 eEncodingIEEE754, 1037 eFormatFloat, 1038 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1039 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1040 nullptr, 1041 nullptr, 1042 nullptr, 1043 0}, 1044 {"s15", 1045 nullptr, 1046 4, 1047 0, 1048 eEncodingIEEE754, 1049 eFormatFloat, 1050 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1051 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1052 nullptr, 1053 nullptr, 1054 nullptr, 1055 0}, 1056 {"s16", 1057 nullptr, 1058 4, 1059 0, 1060 eEncodingIEEE754, 1061 eFormatFloat, 1062 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1063 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1064 nullptr, 1065 nullptr, 1066 nullptr, 1067 0}, 1068 {"s17", 1069 nullptr, 1070 4, 1071 0, 1072 eEncodingIEEE754, 1073 eFormatFloat, 1074 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1075 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1076 nullptr, 1077 nullptr, 1078 nullptr, 1079 0}, 1080 {"s18", 1081 nullptr, 1082 4, 1083 0, 1084 eEncodingIEEE754, 1085 eFormatFloat, 1086 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1087 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1088 nullptr, 1089 nullptr, 1090 nullptr, 1091 0}, 1092 {"s19", 1093 nullptr, 1094 4, 1095 0, 1096 eEncodingIEEE754, 1097 eFormatFloat, 1098 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1099 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1100 nullptr, 1101 nullptr, 1102 nullptr, 1103 0}, 1104 {"s20", 1105 nullptr, 1106 4, 1107 0, 1108 eEncodingIEEE754, 1109 eFormatFloat, 1110 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1111 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1112 nullptr, 1113 nullptr, 1114 nullptr, 1115 0}, 1116 {"s21", 1117 nullptr, 1118 4, 1119 0, 1120 eEncodingIEEE754, 1121 eFormatFloat, 1122 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1123 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1124 nullptr, 1125 nullptr, 1126 nullptr, 1127 0}, 1128 {"s22", 1129 nullptr, 1130 4, 1131 0, 1132 eEncodingIEEE754, 1133 eFormatFloat, 1134 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1135 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1136 nullptr, 1137 nullptr, 1138 nullptr, 1139 0}, 1140 {"s23", 1141 nullptr, 1142 4, 1143 0, 1144 eEncodingIEEE754, 1145 eFormatFloat, 1146 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1147 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1148 nullptr, 1149 nullptr, 1150 nullptr, 1151 0}, 1152 {"s24", 1153 nullptr, 1154 4, 1155 0, 1156 eEncodingIEEE754, 1157 eFormatFloat, 1158 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1159 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1160 nullptr, 1161 nullptr, 1162 nullptr, 1163 0}, 1164 {"s25", 1165 nullptr, 1166 4, 1167 0, 1168 eEncodingIEEE754, 1169 eFormatFloat, 1170 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1171 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1172 nullptr, 1173 nullptr, 1174 nullptr, 1175 0}, 1176 {"s26", 1177 nullptr, 1178 4, 1179 0, 1180 eEncodingIEEE754, 1181 eFormatFloat, 1182 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1183 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1184 nullptr, 1185 nullptr, 1186 nullptr, 1187 0}, 1188 {"s27", 1189 nullptr, 1190 4, 1191 0, 1192 eEncodingIEEE754, 1193 eFormatFloat, 1194 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1195 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1196 nullptr, 1197 nullptr, 1198 nullptr, 1199 0}, 1200 {"s28", 1201 nullptr, 1202 4, 1203 0, 1204 eEncodingIEEE754, 1205 eFormatFloat, 1206 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1207 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1208 nullptr, 1209 nullptr, 1210 nullptr, 1211 0}, 1212 {"s29", 1213 nullptr, 1214 4, 1215 0, 1216 eEncodingIEEE754, 1217 eFormatFloat, 1218 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1219 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1220 nullptr, 1221 nullptr, 1222 nullptr, 1223 0}, 1224 {"s30", 1225 nullptr, 1226 4, 1227 0, 1228 eEncodingIEEE754, 1229 eFormatFloat, 1230 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1231 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1232 nullptr, 1233 nullptr, 1234 nullptr, 1235 0}, 1236 {"s31", 1237 nullptr, 1238 4, 1239 0, 1240 eEncodingIEEE754, 1241 eFormatFloat, 1242 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1243 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1244 nullptr, 1245 nullptr, 1246 nullptr, 1247 0}, 1248 1249 {"d0", 1250 nullptr, 1251 8, 1252 0, 1253 eEncodingIEEE754, 1254 eFormatFloat, 1255 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1256 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1257 nullptr, 1258 nullptr, 1259 nullptr, 1260 0}, 1261 {"d1", 1262 nullptr, 1263 8, 1264 0, 1265 eEncodingIEEE754, 1266 eFormatFloat, 1267 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1268 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1269 nullptr, 1270 nullptr, 1271 nullptr, 1272 0}, 1273 {"d2", 1274 nullptr, 1275 8, 1276 0, 1277 eEncodingIEEE754, 1278 eFormatFloat, 1279 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1280 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1281 nullptr, 1282 nullptr, 1283 nullptr, 1284 0}, 1285 {"d3", 1286 nullptr, 1287 8, 1288 0, 1289 eEncodingIEEE754, 1290 eFormatFloat, 1291 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1292 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1293 nullptr, 1294 nullptr, 1295 nullptr, 1296 0}, 1297 {"d4", 1298 nullptr, 1299 8, 1300 0, 1301 eEncodingIEEE754, 1302 eFormatFloat, 1303 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1304 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1305 nullptr, 1306 nullptr, 1307 nullptr, 1308 0}, 1309 {"d5", 1310 nullptr, 1311 8, 1312 0, 1313 eEncodingIEEE754, 1314 eFormatFloat, 1315 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1316 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1317 nullptr, 1318 nullptr, 1319 nullptr, 1320 0}, 1321 {"d6", 1322 nullptr, 1323 8, 1324 0, 1325 eEncodingIEEE754, 1326 eFormatFloat, 1327 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1328 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1329 nullptr, 1330 nullptr, 1331 nullptr, 1332 0}, 1333 {"d7", 1334 nullptr, 1335 8, 1336 0, 1337 eEncodingIEEE754, 1338 eFormatFloat, 1339 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1340 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1341 nullptr, 1342 nullptr, 1343 nullptr, 1344 0}, 1345 {"d8", 1346 nullptr, 1347 8, 1348 0, 1349 eEncodingIEEE754, 1350 eFormatFloat, 1351 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1352 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1353 nullptr, 1354 nullptr, 1355 nullptr, 1356 0}, 1357 {"d9", 1358 nullptr, 1359 8, 1360 0, 1361 eEncodingIEEE754, 1362 eFormatFloat, 1363 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1364 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1365 nullptr, 1366 nullptr, 1367 nullptr, 1368 0}, 1369 {"d10", 1370 nullptr, 1371 8, 1372 0, 1373 eEncodingIEEE754, 1374 eFormatFloat, 1375 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1376 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1377 nullptr, 1378 nullptr, 1379 nullptr, 1380 0}, 1381 {"d11", 1382 nullptr, 1383 8, 1384 0, 1385 eEncodingIEEE754, 1386 eFormatFloat, 1387 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1388 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1389 nullptr, 1390 nullptr, 1391 nullptr, 1392 0}, 1393 {"d12", 1394 nullptr, 1395 8, 1396 0, 1397 eEncodingIEEE754, 1398 eFormatFloat, 1399 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1400 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1401 nullptr, 1402 nullptr, 1403 nullptr, 1404 0}, 1405 {"d13", 1406 nullptr, 1407 8, 1408 0, 1409 eEncodingIEEE754, 1410 eFormatFloat, 1411 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1412 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1413 nullptr, 1414 nullptr, 1415 nullptr, 1416 0}, 1417 {"d14", 1418 nullptr, 1419 8, 1420 0, 1421 eEncodingIEEE754, 1422 eFormatFloat, 1423 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1424 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1425 nullptr, 1426 nullptr, 1427 nullptr, 1428 0}, 1429 {"d15", 1430 nullptr, 1431 8, 1432 0, 1433 eEncodingIEEE754, 1434 eFormatFloat, 1435 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1436 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1437 nullptr, 1438 nullptr, 1439 nullptr, 1440 0}, 1441 {"d16", 1442 nullptr, 1443 8, 1444 0, 1445 eEncodingIEEE754, 1446 eFormatFloat, 1447 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1448 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1449 nullptr, 1450 nullptr, 1451 nullptr, 1452 0}, 1453 {"d17", 1454 nullptr, 1455 8, 1456 0, 1457 eEncodingIEEE754, 1458 eFormatFloat, 1459 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1460 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1461 nullptr, 1462 nullptr, 1463 nullptr, 1464 0}, 1465 {"d18", 1466 nullptr, 1467 8, 1468 0, 1469 eEncodingIEEE754, 1470 eFormatFloat, 1471 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1472 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1473 nullptr, 1474 nullptr, 1475 nullptr, 1476 0}, 1477 {"d19", 1478 nullptr, 1479 8, 1480 0, 1481 eEncodingIEEE754, 1482 eFormatFloat, 1483 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1484 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1485 nullptr, 1486 nullptr, 1487 nullptr, 1488 0}, 1489 {"d20", 1490 nullptr, 1491 8, 1492 0, 1493 eEncodingIEEE754, 1494 eFormatFloat, 1495 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1496 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1497 nullptr, 1498 nullptr, 1499 nullptr, 1500 0}, 1501 {"d21", 1502 nullptr, 1503 8, 1504 0, 1505 eEncodingIEEE754, 1506 eFormatFloat, 1507 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1508 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1509 nullptr, 1510 nullptr, 1511 nullptr, 1512 0}, 1513 {"d22", 1514 nullptr, 1515 8, 1516 0, 1517 eEncodingIEEE754, 1518 eFormatFloat, 1519 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1520 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1521 nullptr, 1522 nullptr, 1523 nullptr, 1524 0}, 1525 {"d23", 1526 nullptr, 1527 8, 1528 0, 1529 eEncodingIEEE754, 1530 eFormatFloat, 1531 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1532 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1533 nullptr, 1534 nullptr, 1535 nullptr, 1536 0}, 1537 {"d24", 1538 nullptr, 1539 8, 1540 0, 1541 eEncodingIEEE754, 1542 eFormatFloat, 1543 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1544 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1545 nullptr, 1546 nullptr, 1547 nullptr, 1548 0}, 1549 {"d25", 1550 nullptr, 1551 8, 1552 0, 1553 eEncodingIEEE754, 1554 eFormatFloat, 1555 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1556 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1557 nullptr, 1558 nullptr, 1559 nullptr, 1560 0}, 1561 {"d26", 1562 nullptr, 1563 8, 1564 0, 1565 eEncodingIEEE754, 1566 eFormatFloat, 1567 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1568 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1569 nullptr, 1570 nullptr, 1571 nullptr, 1572 0}, 1573 {"d27", 1574 nullptr, 1575 8, 1576 0, 1577 eEncodingIEEE754, 1578 eFormatFloat, 1579 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1580 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1581 nullptr, 1582 nullptr, 1583 nullptr, 1584 0}, 1585 {"d28", 1586 nullptr, 1587 8, 1588 0, 1589 eEncodingIEEE754, 1590 eFormatFloat, 1591 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1592 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1593 nullptr, 1594 nullptr, 1595 nullptr, 1596 0}, 1597 {"d29", 1598 nullptr, 1599 8, 1600 0, 1601 eEncodingIEEE754, 1602 eFormatFloat, 1603 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1604 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1605 nullptr, 1606 nullptr, 1607 nullptr, 1608 0}, 1609 {"d30", 1610 nullptr, 1611 8, 1612 0, 1613 eEncodingIEEE754, 1614 eFormatFloat, 1615 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1616 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1617 nullptr, 1618 nullptr, 1619 nullptr, 1620 0}, 1621 {"d31", 1622 nullptr, 1623 8, 1624 0, 1625 eEncodingIEEE754, 1626 eFormatFloat, 1627 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, 1628 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, 1629 nullptr, 1630 nullptr, 1631 nullptr, 1632 0}}; 1633 1634static const uint32_t k_num_register_infos = 1635 llvm::array_lengthof(g_register_infos); 1636static bool g_register_info_names_constified = false; 1637 1638const lldb_private::RegisterInfo * 1639ABIMacOSX_arm64::GetRegisterInfoArray(uint32_t &count) { 1640 // Make the C-string names and alt_names for the register infos into const 1641 // C-string values by having the ConstString unique the names in the global 1642 // constant C-string pool. 1643 if (!g_register_info_names_constified) { 1644 g_register_info_names_constified = true; 1645 for (uint32_t i = 0; i < k_num_register_infos; ++i) { 1646 if (g_register_infos[i].name) 1647 g_register_infos[i].name = 1648 ConstString(g_register_infos[i].name).GetCString(); 1649 if (g_register_infos[i].alt_name) 1650 g_register_infos[i].alt_name = 1651 ConstString(g_register_infos[i].alt_name).GetCString(); 1652 } 1653 } 1654 count = k_num_register_infos; 1655 return g_register_infos; 1656} 1657 1658size_t ABIMacOSX_arm64::GetRedZoneSize() const { return 128; } 1659 1660// Static Functions 1661 1662ABISP 1663ABIMacOSX_arm64::CreateInstance(ProcessSP process_sp, const ArchSpec &arch) { 1664 const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch(); 1665 const llvm::Triple::VendorType vendor_type = arch.GetTriple().getVendor(); 1666 1667 if (vendor_type == llvm::Triple::Apple) { 1668 if (arch_type == llvm::Triple::aarch64 || 1669 arch_type == llvm::Triple::aarch64_32) { 1670 return ABISP( 1671 new ABIMacOSX_arm64(std::move(process_sp), MakeMCRegisterInfo(arch))); 1672 } 1673 } 1674 1675 return ABISP(); 1676} 1677 1678bool ABIMacOSX_arm64::PrepareTrivialCall( 1679 Thread &thread, lldb::addr_t sp, lldb::addr_t func_addr, 1680 lldb::addr_t return_addr, llvm::ArrayRef<lldb::addr_t> args) const { 1681 RegisterContext *reg_ctx = thread.GetRegisterContext().get(); 1682 if (!reg_ctx) 1683 return false; 1684 1685 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 1686 1687 if (log) { 1688 StreamString s; 1689 s.Printf("ABISysV_x86_64::PrepareTrivialCall (tid = 0x%" PRIx64 1690 ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64 1691 ", return_addr = 0x%" PRIx64, 1692 thread.GetID(), (uint64_t)sp, (uint64_t)func_addr, 1693 (uint64_t)return_addr); 1694 1695 for (size_t i = 0; i < args.size(); ++i) 1696 s.Printf(", arg%d = 0x%" PRIx64, static_cast<int>(i + 1), args[i]); 1697 s.PutCString(")"); 1698 log->PutString(s.GetString()); 1699 } 1700 1701 const uint32_t pc_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber( 1702 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); 1703 const uint32_t sp_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber( 1704 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP); 1705 const uint32_t ra_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber( 1706 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA); 1707 1708 // x0 - x7 contain first 8 simple args 1709 if (args.size() > 8) // TODO handle more than 6 arguments 1710 return false; 1711 1712 for (size_t i = 0; i < args.size(); ++i) { 1713 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo( 1714 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + i); 1715 LLDB_LOGF(log, "About to write arg%d (0x%" PRIx64 ") into %s", 1716 static_cast<int>(i + 1), args[i], reg_info->name); 1717 if (!reg_ctx->WriteRegisterFromUnsigned(reg_info, args[i])) 1718 return false; 1719 } 1720 1721 // Set "lr" to the return address 1722 if (!reg_ctx->WriteRegisterFromUnsigned( 1723 reg_ctx->GetRegisterInfoAtIndex(ra_reg_num), return_addr)) 1724 return false; 1725 1726 // Set "sp" to the requested value 1727 if (!reg_ctx->WriteRegisterFromUnsigned( 1728 reg_ctx->GetRegisterInfoAtIndex(sp_reg_num), sp)) 1729 return false; 1730 1731 // Set "pc" to the address requested 1732 if (!reg_ctx->WriteRegisterFromUnsigned( 1733 reg_ctx->GetRegisterInfoAtIndex(pc_reg_num), func_addr)) 1734 return false; 1735 1736 return true; 1737} 1738 1739bool ABIMacOSX_arm64::GetArgumentValues(Thread &thread, 1740 ValueList &values) const { 1741 uint32_t num_values = values.GetSize(); 1742 1743 ExecutionContext exe_ctx(thread.shared_from_this()); 1744 1745 // Extract the register context so we can read arguments from registers 1746 1747 RegisterContext *reg_ctx = thread.GetRegisterContext().get(); 1748 1749 if (!reg_ctx) 1750 return false; 1751 1752 addr_t sp = 0; 1753 1754 for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) { 1755 // We currently only support extracting values with Clang QualTypes. Do we 1756 // care about others? 1757 Value *value = values.GetValueAtIndex(value_idx); 1758 1759 if (!value) 1760 return false; 1761 1762 CompilerType value_type = value->GetCompilerType(); 1763 llvm::Optional<uint64_t> bit_size = value_type.GetBitSize(&thread); 1764 if (!bit_size) 1765 return false; 1766 1767 bool is_signed = false; 1768 size_t bit_width = 0; 1769 if (value_type.IsIntegerOrEnumerationType(is_signed)) { 1770 bit_width = *bit_size; 1771 } else if (value_type.IsPointerOrReferenceType()) { 1772 bit_width = *bit_size; 1773 } else { 1774 // We only handle integer, pointer and reference types currently... 1775 return false; 1776 } 1777 1778 if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) { 1779 if (value_idx < 8) { 1780 // Arguments 1-6 are in x0-x5... 1781 const RegisterInfo *reg_info = nullptr; 1782 // Search by generic ID first, then fall back to by name 1783 uint32_t arg_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber( 1784 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + value_idx); 1785 if (arg_reg_num != LLDB_INVALID_REGNUM) { 1786 reg_info = reg_ctx->GetRegisterInfoAtIndex(arg_reg_num); 1787 } else { 1788 switch (value_idx) { 1789 case 0: 1790 reg_info = reg_ctx->GetRegisterInfoByName("x0"); 1791 break; 1792 case 1: 1793 reg_info = reg_ctx->GetRegisterInfoByName("x1"); 1794 break; 1795 case 2: 1796 reg_info = reg_ctx->GetRegisterInfoByName("x2"); 1797 break; 1798 case 3: 1799 reg_info = reg_ctx->GetRegisterInfoByName("x3"); 1800 break; 1801 case 4: 1802 reg_info = reg_ctx->GetRegisterInfoByName("x4"); 1803 break; 1804 case 5: 1805 reg_info = reg_ctx->GetRegisterInfoByName("x5"); 1806 break; 1807 case 6: 1808 reg_info = reg_ctx->GetRegisterInfoByName("x6"); 1809 break; 1810 case 7: 1811 reg_info = reg_ctx->GetRegisterInfoByName("x7"); 1812 break; 1813 } 1814 } 1815 1816 if (reg_info) { 1817 RegisterValue reg_value; 1818 1819 if (reg_ctx->ReadRegister(reg_info, reg_value)) { 1820 if (is_signed) 1821 reg_value.SignExtend(bit_width); 1822 if (!reg_value.GetScalarValue(value->GetScalar())) 1823 return false; 1824 continue; 1825 } 1826 } 1827 return false; 1828 } else { 1829 if (sp == 0) { 1830 // Read the stack pointer if we already haven't read it 1831 sp = reg_ctx->GetSP(0); 1832 if (sp == 0) 1833 return false; 1834 } 1835 1836 // Arguments 5 on up are on the stack 1837 const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8; 1838 Status error; 1839 if (!exe_ctx.GetProcessRef().ReadScalarIntegerFromMemory( 1840 sp, arg_byte_size, is_signed, value->GetScalar(), error)) 1841 return false; 1842 1843 sp += arg_byte_size; 1844 // Align up to the next 8 byte boundary if needed 1845 if (sp % 8) { 1846 sp >>= 3; 1847 sp += 1; 1848 sp <<= 3; 1849 } 1850 } 1851 } 1852 } 1853 return true; 1854} 1855 1856Status 1857ABIMacOSX_arm64::SetReturnValueObject(lldb::StackFrameSP &frame_sp, 1858 lldb::ValueObjectSP &new_value_sp) { 1859 Status error; 1860 if (!new_value_sp) { 1861 error.SetErrorString("Empty value object for return value."); 1862 return error; 1863 } 1864 1865 CompilerType return_value_type = new_value_sp->GetCompilerType(); 1866 if (!return_value_type) { 1867 error.SetErrorString("Null clang type for return value."); 1868 return error; 1869 } 1870 1871 Thread *thread = frame_sp->GetThread().get(); 1872 1873 RegisterContext *reg_ctx = thread->GetRegisterContext().get(); 1874 1875 if (reg_ctx) { 1876 DataExtractor data; 1877 Status data_error; 1878 const uint64_t byte_size = new_value_sp->GetData(data, data_error); 1879 if (data_error.Fail()) { 1880 error.SetErrorStringWithFormat( 1881 "Couldn't convert return value to raw data: %s", 1882 data_error.AsCString()); 1883 return error; 1884 } 1885 1886 const uint32_t type_flags = return_value_type.GetTypeInfo(nullptr); 1887 if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) { 1888 if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) { 1889 // Extract the register context so we can read arguments from registers 1890 lldb::offset_t offset = 0; 1891 if (byte_size <= 16) { 1892 const RegisterInfo *x0_info = reg_ctx->GetRegisterInfoByName("x0", 0); 1893 if (byte_size <= 8) { 1894 uint64_t raw_value = data.GetMaxU64(&offset, byte_size); 1895 1896 if (!reg_ctx->WriteRegisterFromUnsigned(x0_info, raw_value)) 1897 error.SetErrorString("failed to write register x0"); 1898 } else { 1899 uint64_t raw_value = data.GetMaxU64(&offset, 8); 1900 1901 if (reg_ctx->WriteRegisterFromUnsigned(x0_info, raw_value)) { 1902 const RegisterInfo *x1_info = 1903 reg_ctx->GetRegisterInfoByName("x1", 0); 1904 raw_value = data.GetMaxU64(&offset, byte_size - offset); 1905 1906 if (!reg_ctx->WriteRegisterFromUnsigned(x1_info, raw_value)) 1907 error.SetErrorString("failed to write register x1"); 1908 } 1909 } 1910 } else { 1911 error.SetErrorString("We don't support returning longer than 128 bit " 1912 "integer values at present."); 1913 } 1914 } else if (type_flags & eTypeIsFloat) { 1915 if (type_flags & eTypeIsComplex) { 1916 // Don't handle complex yet. 1917 error.SetErrorString( 1918 "returning complex float values are not supported"); 1919 } else { 1920 const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0); 1921 1922 if (v0_info) { 1923 if (byte_size <= 16) { 1924 if (byte_size <= RegisterValue::GetMaxByteSize()) { 1925 RegisterValue reg_value; 1926 error = reg_value.SetValueFromData(v0_info, data, 0, true); 1927 if (error.Success()) { 1928 if (!reg_ctx->WriteRegister(v0_info, reg_value)) 1929 error.SetErrorString("failed to write register v0"); 1930 } 1931 } else { 1932 error.SetErrorStringWithFormat( 1933 "returning float values with a byte size of %" PRIu64 1934 " are not supported", 1935 byte_size); 1936 } 1937 } else { 1938 error.SetErrorString("returning float values longer than 128 " 1939 "bits are not supported"); 1940 } 1941 } else { 1942 error.SetErrorString("v0 register is not available on this target"); 1943 } 1944 } 1945 } 1946 } else if (type_flags & eTypeIsVector) { 1947 if (byte_size > 0) { 1948 const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0); 1949 1950 if (v0_info) { 1951 if (byte_size <= v0_info->byte_size) { 1952 RegisterValue reg_value; 1953 error = reg_value.SetValueFromData(v0_info, data, 0, true); 1954 if (error.Success()) { 1955 if (!reg_ctx->WriteRegister(v0_info, reg_value)) 1956 error.SetErrorString("failed to write register v0"); 1957 } 1958 } 1959 } 1960 } 1961 } 1962 } else { 1963 error.SetErrorString("no registers are available"); 1964 } 1965 1966 return error; 1967} 1968 1969bool ABIMacOSX_arm64::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) { 1970 unwind_plan.Clear(); 1971 unwind_plan.SetRegisterKind(eRegisterKindDWARF); 1972 1973 uint32_t lr_reg_num = arm64_dwarf::lr; 1974 uint32_t sp_reg_num = arm64_dwarf::sp; 1975 uint32_t pc_reg_num = arm64_dwarf::pc; 1976 1977 UnwindPlan::RowSP row(new UnwindPlan::Row); 1978 1979 // Our previous Call Frame Address is the stack pointer 1980 row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0); 1981 1982 // Our previous PC is in the LR 1983 row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true); 1984 1985 unwind_plan.AppendRow(row); 1986 1987 // All other registers are the same. 1988 1989 unwind_plan.SetSourceName("arm64 at-func-entry default"); 1990 unwind_plan.SetSourcedFromCompiler(eLazyBoolNo); 1991 1992 return true; 1993} 1994 1995bool ABIMacOSX_arm64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) { 1996 unwind_plan.Clear(); 1997 unwind_plan.SetRegisterKind(eRegisterKindDWARF); 1998 1999 uint32_t fp_reg_num = arm64_dwarf::fp; 2000 uint32_t pc_reg_num = arm64_dwarf::pc; 2001 2002 UnwindPlan::RowSP row(new UnwindPlan::Row); 2003 const int32_t ptr_size = 8; 2004 2005 row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size); 2006 row->SetOffset(0); 2007 2008 row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true); 2009 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true); 2010 2011 unwind_plan.AppendRow(row); 2012 unwind_plan.SetSourceName("arm64-apple-darwin default unwind plan"); 2013 unwind_plan.SetSourcedFromCompiler(eLazyBoolNo); 2014 unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo); 2015 unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo); 2016 return true; 2017} 2018 2019// AAPCS64 (Procedure Call Standard for the ARM 64-bit Architecture) says 2020// registers x19 through x28 and sp are callee preserved. v8-v15 are non- 2021// volatile (and specifically only the lower 8 bytes of these regs), the rest 2022// of the fp/SIMD registers are volatile. 2023// 2024// v. https://github.com/ARM-software/software-standards/blob/master/abi/aapcs64/ 2025 2026// We treat x29 as callee preserved also, else the unwinder won't try to 2027// retrieve fp saves. 2028 2029bool ABIMacOSX_arm64::RegisterIsVolatile(const RegisterInfo *reg_info) { 2030 if (reg_info) { 2031 const char *name = reg_info->name; 2032 2033 // Sometimes we'll be called with the "alternate" name for these registers; 2034 // recognize them as non-volatile. 2035 2036 if (name[0] == 'p' && name[1] == 'c') // pc 2037 return false; 2038 if (name[0] == 'f' && name[1] == 'p') // fp 2039 return false; 2040 if (name[0] == 's' && name[1] == 'p') // sp 2041 return false; 2042 if (name[0] == 'l' && name[1] == 'r') // lr 2043 return false; 2044 2045 if (name[0] == 'x') { 2046 // Volatile registers: x0-x18, x30 (lr) 2047 // Return false for the non-volatile gpr regs, true for everything else 2048 switch (name[1]) { 2049 case '1': 2050 switch (name[2]) { 2051 case '9': 2052 return false; // x19 is non-volatile 2053 default: 2054 return true; 2055 } 2056 break; 2057 case '2': 2058 switch (name[2]) { 2059 case '0': 2060 case '1': 2061 case '2': 2062 case '3': 2063 case '4': 2064 case '5': 2065 case '6': 2066 case '7': 2067 case '8': 2068 return false; // x20 - 28 are non-volatile 2069 case '9': 2070 return false; // x29 aka fp treat as non-volatile on Darwin 2071 default: 2072 return true; 2073 } 2074 case '3': // x30 aka lr treat as non-volatile 2075 if (name[2] == '0') 2076 return false; 2077 break; 2078 default: 2079 return true; 2080 } 2081 } else if (name[0] == 'v' || name[0] == 's' || name[0] == 'd') { 2082 // Volatile registers: v0-7, v16-v31 2083 // Return false for non-volatile fp/SIMD regs, true for everything else 2084 switch (name[1]) { 2085 case '8': 2086 case '9': 2087 return false; // v8-v9 are non-volatile 2088 case '1': 2089 switch (name[2]) { 2090 case '0': 2091 case '1': 2092 case '2': 2093 case '3': 2094 case '4': 2095 case '5': 2096 return false; // v10-v15 are non-volatile 2097 default: 2098 return true; 2099 } 2100 default: 2101 return true; 2102 } 2103 } 2104 } 2105 return true; 2106} 2107 2108static bool LoadValueFromConsecutiveGPRRegisters( 2109 ExecutionContext &exe_ctx, RegisterContext *reg_ctx, 2110 const CompilerType &value_type, 2111 bool is_return_value, // false => parameter, true => return value 2112 uint32_t &NGRN, // NGRN (see ABI documentation) 2113 uint32_t &NSRN, // NSRN (see ABI documentation) 2114 DataExtractor &data) { 2115 llvm::Optional<uint64_t> byte_size = value_type.GetByteSize(nullptr); 2116 if (!byte_size || *byte_size == 0) 2117 return false; 2118 2119 std::unique_ptr<DataBufferHeap> heap_data_up( 2120 new DataBufferHeap(*byte_size, 0)); 2121 const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder(); 2122 Status error; 2123 2124 CompilerType base_type; 2125 const uint32_t homogeneous_count = 2126 value_type.IsHomogeneousAggregate(&base_type); 2127 if (homogeneous_count > 0 && homogeneous_count <= 8) { 2128 // Make sure we have enough registers 2129 if (NSRN < 8 && (8 - NSRN) >= homogeneous_count) { 2130 if (!base_type) 2131 return false; 2132 llvm::Optional<uint64_t> base_byte_size = base_type.GetByteSize(nullptr); 2133 if (!base_byte_size) 2134 return false; 2135 uint32_t data_offset = 0; 2136 2137 for (uint32_t i = 0; i < homogeneous_count; ++i) { 2138 char v_name[8]; 2139 ::snprintf(v_name, sizeof(v_name), "v%u", NSRN); 2140 const RegisterInfo *reg_info = 2141 reg_ctx->GetRegisterInfoByName(v_name, 0); 2142 if (reg_info == nullptr) 2143 return false; 2144 2145 if (*base_byte_size > reg_info->byte_size) 2146 return false; 2147 2148 RegisterValue reg_value; 2149 2150 if (!reg_ctx->ReadRegister(reg_info, reg_value)) 2151 return false; 2152 2153 // Make sure we have enough room in "heap_data_up" 2154 if ((data_offset + *base_byte_size) <= heap_data_up->GetByteSize()) { 2155 const size_t bytes_copied = reg_value.GetAsMemoryData( 2156 reg_info, heap_data_up->GetBytes() + data_offset, *base_byte_size, 2157 byte_order, error); 2158 if (bytes_copied != *base_byte_size) 2159 return false; 2160 data_offset += bytes_copied; 2161 ++NSRN; 2162 } else 2163 return false; 2164 } 2165 data.SetByteOrder(byte_order); 2166 data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize()); 2167 data.SetData(DataBufferSP(heap_data_up.release())); 2168 return true; 2169 } 2170 } 2171 2172 const size_t max_reg_byte_size = 16; 2173 if (*byte_size <= max_reg_byte_size) { 2174 size_t bytes_left = *byte_size; 2175 uint32_t data_offset = 0; 2176 while (data_offset < *byte_size) { 2177 if (NGRN >= 8) 2178 return false; 2179 2180 uint32_t reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber( 2181 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + NGRN); 2182 if (reg_num == LLDB_INVALID_REGNUM) 2183 return false; 2184 2185 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_num); 2186 if (reg_info == nullptr) 2187 return false; 2188 2189 RegisterValue reg_value; 2190 2191 if (!reg_ctx->ReadRegister(reg_info, reg_value)) 2192 return false; 2193 2194 const size_t curr_byte_size = std::min<size_t>(8, bytes_left); 2195 const size_t bytes_copied = reg_value.GetAsMemoryData( 2196 reg_info, heap_data_up->GetBytes() + data_offset, curr_byte_size, 2197 byte_order, error); 2198 if (bytes_copied == 0) 2199 return false; 2200 if (bytes_copied >= bytes_left) 2201 break; 2202 data_offset += bytes_copied; 2203 bytes_left -= bytes_copied; 2204 ++NGRN; 2205 } 2206 } else { 2207 const RegisterInfo *reg_info = nullptr; 2208 if (is_return_value) { 2209 // We are assuming we are decoding this immediately after returning from 2210 // a function call and that the address of the structure is in x8 2211 reg_info = reg_ctx->GetRegisterInfoByName("x8", 0); 2212 } else { 2213 // We are assuming we are stopped at the first instruction in a function 2214 // and that the ABI is being respected so all parameters appear where 2215 // they should be (functions with no external linkage can legally violate 2216 // the ABI). 2217 if (NGRN >= 8) 2218 return false; 2219 2220 uint32_t reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber( 2221 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + NGRN); 2222 if (reg_num == LLDB_INVALID_REGNUM) 2223 return false; 2224 reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_num); 2225 if (reg_info == nullptr) 2226 return false; 2227 ++NGRN; 2228 } 2229 2230 if (reg_info == nullptr) 2231 return false; 2232 2233 const lldb::addr_t value_addr = 2234 reg_ctx->ReadRegisterAsUnsigned(reg_info, LLDB_INVALID_ADDRESS); 2235 2236 if (value_addr == LLDB_INVALID_ADDRESS) 2237 return false; 2238 2239 if (exe_ctx.GetProcessRef().ReadMemory( 2240 value_addr, heap_data_up->GetBytes(), heap_data_up->GetByteSize(), 2241 error) != heap_data_up->GetByteSize()) { 2242 return false; 2243 } 2244 } 2245 2246 data.SetByteOrder(byte_order); 2247 data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize()); 2248 data.SetData(DataBufferSP(heap_data_up.release())); 2249 return true; 2250} 2251 2252ValueObjectSP ABIMacOSX_arm64::GetReturnValueObjectImpl( 2253 Thread &thread, CompilerType &return_compiler_type) const { 2254 ValueObjectSP return_valobj_sp; 2255 Value value; 2256 2257 ExecutionContext exe_ctx(thread.shared_from_this()); 2258 if (exe_ctx.GetTargetPtr() == nullptr || exe_ctx.GetProcessPtr() == nullptr) 2259 return return_valobj_sp; 2260 2261 // value.SetContext (Value::eContextTypeClangType, return_compiler_type); 2262 value.SetCompilerType(return_compiler_type); 2263 2264 RegisterContext *reg_ctx = thread.GetRegisterContext().get(); 2265 if (!reg_ctx) 2266 return return_valobj_sp; 2267 2268 llvm::Optional<uint64_t> byte_size = 2269 return_compiler_type.GetByteSize(nullptr); 2270 if (!byte_size) 2271 return return_valobj_sp; 2272 2273 const uint32_t type_flags = return_compiler_type.GetTypeInfo(nullptr); 2274 if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) { 2275 value.SetValueType(Value::eValueTypeScalar); 2276 2277 bool success = false; 2278 if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) { 2279 // Extract the register context so we can read arguments from registers 2280 if (*byte_size <= 8) { 2281 const RegisterInfo *x0_reg_info = 2282 reg_ctx->GetRegisterInfoByName("x0", 0); 2283 if (x0_reg_info) { 2284 uint64_t raw_value = 2285 thread.GetRegisterContext()->ReadRegisterAsUnsigned(x0_reg_info, 2286 0); 2287 const bool is_signed = (type_flags & eTypeIsSigned) != 0; 2288 switch (*byte_size) { 2289 default: 2290 break; 2291 case 16: // uint128_t 2292 // In register x0 and x1 2293 { 2294 const RegisterInfo *x1_reg_info = 2295 reg_ctx->GetRegisterInfoByName("x1", 0); 2296 2297 if (x1_reg_info) { 2298 if (*byte_size <= 2299 x0_reg_info->byte_size + x1_reg_info->byte_size) { 2300 std::unique_ptr<DataBufferHeap> heap_data_up( 2301 new DataBufferHeap(*byte_size, 0)); 2302 const ByteOrder byte_order = 2303 exe_ctx.GetProcessRef().GetByteOrder(); 2304 RegisterValue x0_reg_value; 2305 RegisterValue x1_reg_value; 2306 if (reg_ctx->ReadRegister(x0_reg_info, x0_reg_value) && 2307 reg_ctx->ReadRegister(x1_reg_info, x1_reg_value)) { 2308 Status error; 2309 if (x0_reg_value.GetAsMemoryData( 2310 x0_reg_info, heap_data_up->GetBytes() + 0, 8, 2311 byte_order, error) && 2312 x1_reg_value.GetAsMemoryData( 2313 x1_reg_info, heap_data_up->GetBytes() + 8, 8, 2314 byte_order, error)) { 2315 DataExtractor data( 2316 DataBufferSP(heap_data_up.release()), byte_order, 2317 exe_ctx.GetProcessRef().GetAddressByteSize()); 2318 2319 return_valobj_sp = ValueObjectConstResult::Create( 2320 &thread, return_compiler_type, ConstString(""), data); 2321 return return_valobj_sp; 2322 } 2323 } 2324 } 2325 } 2326 } 2327 break; 2328 case sizeof(uint64_t): 2329 if (is_signed) 2330 value.GetScalar() = (int64_t)(raw_value); 2331 else 2332 value.GetScalar() = (uint64_t)(raw_value); 2333 success = true; 2334 break; 2335 2336 case sizeof(uint32_t): 2337 if (is_signed) 2338 value.GetScalar() = (int32_t)(raw_value & UINT32_MAX); 2339 else 2340 value.GetScalar() = (uint32_t)(raw_value & UINT32_MAX); 2341 success = true; 2342 break; 2343 2344 case sizeof(uint16_t): 2345 if (is_signed) 2346 value.GetScalar() = (int16_t)(raw_value & UINT16_MAX); 2347 else 2348 value.GetScalar() = (uint16_t)(raw_value & UINT16_MAX); 2349 success = true; 2350 break; 2351 2352 case sizeof(uint8_t): 2353 if (is_signed) 2354 value.GetScalar() = (int8_t)(raw_value & UINT8_MAX); 2355 else 2356 value.GetScalar() = (uint8_t)(raw_value & UINT8_MAX); 2357 success = true; 2358 break; 2359 } 2360 } 2361 } 2362 } else if (type_flags & eTypeIsFloat) { 2363 if (type_flags & eTypeIsComplex) { 2364 // Don't handle complex yet. 2365 } else { 2366 if (*byte_size <= sizeof(long double)) { 2367 const RegisterInfo *v0_reg_info = 2368 reg_ctx->GetRegisterInfoByName("v0", 0); 2369 RegisterValue v0_value; 2370 if (reg_ctx->ReadRegister(v0_reg_info, v0_value)) { 2371 DataExtractor data; 2372 if (v0_value.GetData(data)) { 2373 lldb::offset_t offset = 0; 2374 if (*byte_size == sizeof(float)) { 2375 value.GetScalar() = data.GetFloat(&offset); 2376 success = true; 2377 } else if (*byte_size == sizeof(double)) { 2378 value.GetScalar() = data.GetDouble(&offset); 2379 success = true; 2380 } else if (*byte_size == sizeof(long double)) { 2381 value.GetScalar() = data.GetLongDouble(&offset); 2382 success = true; 2383 } 2384 } 2385 } 2386 } 2387 } 2388 } 2389 2390 if (success) 2391 return_valobj_sp = ValueObjectConstResult::Create( 2392 thread.GetStackFrameAtIndex(0).get(), value, ConstString("")); 2393 } else if (type_flags & eTypeIsVector) { 2394 if (*byte_size > 0) { 2395 2396 const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0); 2397 2398 if (v0_info) { 2399 if (*byte_size <= v0_info->byte_size) { 2400 std::unique_ptr<DataBufferHeap> heap_data_up( 2401 new DataBufferHeap(*byte_size, 0)); 2402 const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder(); 2403 RegisterValue reg_value; 2404 if (reg_ctx->ReadRegister(v0_info, reg_value)) { 2405 Status error; 2406 if (reg_value.GetAsMemoryData(v0_info, heap_data_up->GetBytes(), 2407 heap_data_up->GetByteSize(), 2408 byte_order, error)) { 2409 DataExtractor data(DataBufferSP(heap_data_up.release()), 2410 byte_order, 2411 exe_ctx.GetProcessRef().GetAddressByteSize()); 2412 return_valobj_sp = ValueObjectConstResult::Create( 2413 &thread, return_compiler_type, ConstString(""), data); 2414 } 2415 } 2416 } 2417 } 2418 } 2419 } else if (type_flags & eTypeIsStructUnion || type_flags & eTypeIsClass) { 2420 DataExtractor data; 2421 2422 uint32_t NGRN = 0; // Search ABI docs for NGRN 2423 uint32_t NSRN = 0; // Search ABI docs for NSRN 2424 const bool is_return_value = true; 2425 if (LoadValueFromConsecutiveGPRRegisters( 2426 exe_ctx, reg_ctx, return_compiler_type, is_return_value, NGRN, NSRN, 2427 data)) { 2428 return_valobj_sp = ValueObjectConstResult::Create( 2429 &thread, return_compiler_type, ConstString(""), data); 2430 } 2431 } 2432 return return_valobj_sp; 2433} 2434 2435void ABIMacOSX_arm64::Initialize() { 2436 PluginManager::RegisterPlugin(GetPluginNameStatic(), pluginDesc, 2437 CreateInstance); 2438} 2439 2440void ABIMacOSX_arm64::Terminate() { 2441 PluginManager::UnregisterPlugin(CreateInstance); 2442} 2443 2444// PluginInterface protocol 2445 2446ConstString ABIMacOSX_arm64::GetPluginNameStatic() { 2447 static ConstString g_plugin_name("ABIMacOSX_arm64"); 2448 return g_plugin_name; 2449} 2450 2451uint32_t ABIMacOSX_arm64::GetPluginVersion() { return 1; } 2452