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

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