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