contrib/llvm/tools/lldb/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp

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