contrib/llvm/tools/lldb/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp

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