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

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