contrib/llvm/tools/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp

   1 //===-- ABIMacOSX_arm.cpp ---------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "ABIMacOSX_arm.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/Status.h"
  34
  35 #include "Plugins/Process/Utility/ARMDefines.h"
  36 #include "Utility/ARM_DWARF_Registers.h"
  37 #include "Utility/ARM_ehframe_Registers.h"
  38
  39 using namespace lldb;
  40 using namespace lldb_private;
  41
  42 static RegisterInfo g_register_infos[] = {
  43     //  NAME       ALT       SZ OFF ENCODING         FORMAT          EH_FRAME
  44     //  DWARF               GENERIC                     PROCESS PLUGIN
  45     //  LLDB NATIVE
  46     //  ========== =======   == === =============    ============
  47     //  ======================= =================== ===========================
  48     //  ======================= ======================
  49     {"r0",
  50      "arg1",
  51      4,
  52      0,
  53      eEncodingUint,
  54      eFormatHex,
  55      {ehframe_r0, dwarf_r0, LLDB_REGNUM_GENERIC_ARG1, LLDB_INVALID_REGNUM,
  56       LLDB_INVALID_REGNUM},
  57      nullptr,
  58      nullptr,
  59      nullptr,
  60      0},
  61     {"r1",
  62      "arg2",
  63      4,
  64      0,
  65      eEncodingUint,
  66      eFormatHex,
  67      {ehframe_r1, dwarf_r1, LLDB_REGNUM_GENERIC_ARG2, LLDB_INVALID_REGNUM,
  68       LLDB_INVALID_REGNUM},
  69      nullptr,
  70      nullptr,
  71      nullptr,
  72      0},
  73     {"r2",
  74      "arg3",
  75      4,
  76      0,
  77      eEncodingUint,
  78      eFormatHex,
  79      {ehframe_r2, dwarf_r2, LLDB_REGNUM_GENERIC_ARG3, LLDB_INVALID_REGNUM,
  80       LLDB_INVALID_REGNUM},
  81      nullptr,
  82      nullptr,
  83      nullptr,
  84      0},
  85     {"r3",
  86      "arg4",
  87      4,
  88      0,
  89      eEncodingUint,
  90      eFormatHex,
  91      {ehframe_r3, dwarf_r3, LLDB_REGNUM_GENERIC_ARG4, LLDB_INVALID_REGNUM,
  92       LLDB_INVALID_REGNUM},
  93      nullptr,
  94      nullptr,
  95      nullptr,
  96      0},
  97     {"r4",
  98      nullptr,
  99      4,
 100      0,
 101      eEncodingUint,
 102      eFormatHex,
 103      {ehframe_r4, dwarf_r4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 104       LLDB_INVALID_REGNUM},
 105      nullptr,
 106      nullptr,
 107      nullptr,
 108      0},
 109     {"r5",
 110      nullptr,
 111      4,
 112      0,
 113      eEncodingUint,
 114      eFormatHex,
 115      {ehframe_r5, dwarf_r5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 116       LLDB_INVALID_REGNUM},
 117      nullptr,
 118      nullptr,
 119      nullptr,
 120      0},
 121     {"r6",
 122      nullptr,
 123      4,
 124      0,
 125      eEncodingUint,
 126      eFormatHex,
 127      {ehframe_r6, dwarf_r6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 128       LLDB_INVALID_REGNUM},
 129      nullptr,
 130      nullptr,
 131      nullptr,
 132      0},
 133     {"r7",
 134      nullptr,
 135      4,
 136      0,
 137      eEncodingUint,
 138      eFormatHex,
 139      {ehframe_r7, dwarf_r7, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM,
 140       LLDB_INVALID_REGNUM},
 141      nullptr,
 142      nullptr,
 143      nullptr,
 144      0},
 145     {"r8",
 146      nullptr,
 147      4,
 148      0,
 149      eEncodingUint,
 150      eFormatHex,
 151      {ehframe_r8, dwarf_r8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 152       LLDB_INVALID_REGNUM},
 153      nullptr,
 154      nullptr,
 155      nullptr,
 156      0},
 157     {"r9",
 158      nullptr,
 159      4,
 160      0,
 161      eEncodingUint,
 162      eFormatHex,
 163      {ehframe_r9, dwarf_r9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 164       LLDB_INVALID_REGNUM},
 165      nullptr,
 166      nullptr,
 167      nullptr,
 168      0},
 169     {"r10",
 170      nullptr,
 171      4,
 172      0,
 173      eEncodingUint,
 174      eFormatHex,
 175      {ehframe_r10, dwarf_r10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 176       LLDB_INVALID_REGNUM},
 177      nullptr,
 178      nullptr,
 179      nullptr,
 180      0},
 181     {"r11",
 182      nullptr,
 183      4,
 184      0,
 185      eEncodingUint,
 186      eFormatHex,
 187      {ehframe_r11, dwarf_r11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 188       LLDB_INVALID_REGNUM},
 189      nullptr,
 190      nullptr,
 191      nullptr,
 192      0},
 193     {"r12",
 194      nullptr,
 195      4,
 196      0,
 197      eEncodingUint,
 198      eFormatHex,
 199      {ehframe_r12, dwarf_r12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 200       LLDB_INVALID_REGNUM},
 201      nullptr,
 202      nullptr,
 203      nullptr,
 204      0},
 205     {"sp",
 206      "r13",
 207      4,
 208      0,
 209      eEncodingUint,
 210      eFormatHex,
 211      {ehframe_sp, dwarf_sp, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM,
 212       LLDB_INVALID_REGNUM},
 213      nullptr,
 214      nullptr,
 215      nullptr,
 216      0},
 217     {"lr",
 218      "r14",
 219      4,
 220      0,
 221      eEncodingUint,
 222      eFormatHex,
 223      {ehframe_lr, dwarf_lr, LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM,
 224       LLDB_INVALID_REGNUM},
 225      nullptr,
 226      nullptr,
 227      nullptr,
 228      0},
 229     {"pc",
 230      "r15",
 231      4,
 232      0,
 233      eEncodingUint,
 234      eFormatHex,
 235      {ehframe_pc, dwarf_pc, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
 236       LLDB_INVALID_REGNUM},
 237      nullptr,
 238      nullptr,
 239      nullptr,
 240      0},
 241     {"cpsr",
 242      "psr",
 243      4,
 244      0,
 245      eEncodingUint,
 246      eFormatHex,
 247      {ehframe_cpsr, dwarf_cpsr, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM,
 248       LLDB_INVALID_REGNUM},
 249      nullptr,
 250      nullptr,
 251      nullptr,
 252      0},
 253     {"s0",
 254      nullptr,
 255      4,
 256      0,
 257      eEncodingIEEE754,
 258      eFormatFloat,
 259      {LLDB_INVALID_REGNUM, dwarf_s0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 260       LLDB_INVALID_REGNUM},
 261      nullptr,
 262      nullptr,
 263      nullptr,
 264      0},
 265     {"s1",
 266      nullptr,
 267      4,
 268      0,
 269      eEncodingIEEE754,
 270      eFormatFloat,
 271      {LLDB_INVALID_REGNUM, dwarf_s1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 272       LLDB_INVALID_REGNUM},
 273      nullptr,
 274      nullptr,
 275      nullptr,
 276      0},
 277     {"s2",
 278      nullptr,
 279      4,
 280      0,
 281      eEncodingIEEE754,
 282      eFormatFloat,
 283      {LLDB_INVALID_REGNUM, dwarf_s2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 284       LLDB_INVALID_REGNUM},
 285      nullptr,
 286      nullptr,
 287      nullptr,
 288      0},
 289     {"s3",
 290      nullptr,
 291      4,
 292      0,
 293      eEncodingIEEE754,
 294      eFormatFloat,
 295      {LLDB_INVALID_REGNUM, dwarf_s3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 296       LLDB_INVALID_REGNUM},
 297      nullptr,
 298      nullptr,
 299      nullptr,
 300      0},
 301     {"s4",
 302      nullptr,
 303      4,
 304      0,
 305      eEncodingIEEE754,
 306      eFormatFloat,
 307      {LLDB_INVALID_REGNUM, dwarf_s4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 308       LLDB_INVALID_REGNUM},
 309      nullptr,
 310      nullptr,
 311      nullptr,
 312      0},
 313     {"s5",
 314      nullptr,
 315      4,
 316      0,
 317      eEncodingIEEE754,
 318      eFormatFloat,
 319      {LLDB_INVALID_REGNUM, dwarf_s5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 320       LLDB_INVALID_REGNUM},
 321      nullptr,
 322      nullptr,
 323      nullptr,
 324      0},
 325     {"s6",
 326      nullptr,
 327      4,
 328      0,
 329      eEncodingIEEE754,
 330      eFormatFloat,
 331      {LLDB_INVALID_REGNUM, dwarf_s6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 332       LLDB_INVALID_REGNUM},
 333      nullptr,
 334      nullptr,
 335      nullptr,
 336      0},
 337     {"s7",
 338      nullptr,
 339      4,
 340      0,
 341      eEncodingIEEE754,
 342      eFormatFloat,
 343      {LLDB_INVALID_REGNUM, dwarf_s7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 344       LLDB_INVALID_REGNUM},
 345      nullptr,
 346      nullptr,
 347      nullptr,
 348      0},
 349     {"s8",
 350      nullptr,
 351      4,
 352      0,
 353      eEncodingIEEE754,
 354      eFormatFloat,
 355      {LLDB_INVALID_REGNUM, dwarf_s8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 356       LLDB_INVALID_REGNUM},
 357      nullptr,
 358      nullptr,
 359      nullptr,
 360      0},
 361     {"s9",
 362      nullptr,
 363      4,
 364      0,
 365      eEncodingIEEE754,
 366      eFormatFloat,
 367      {LLDB_INVALID_REGNUM, dwarf_s9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 368       LLDB_INVALID_REGNUM},
 369      nullptr,
 370      nullptr,
 371      nullptr,
 372      0},
 373     {"s10",
 374      nullptr,
 375      4,
 376      0,
 377      eEncodingIEEE754,
 378      eFormatFloat,
 379      {LLDB_INVALID_REGNUM, dwarf_s10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 380       LLDB_INVALID_REGNUM},
 381      nullptr,
 382      nullptr,
 383      nullptr,
 384      0},
 385     {"s11",
 386      nullptr,
 387      4,
 388      0,
 389      eEncodingIEEE754,
 390      eFormatFloat,
 391      {LLDB_INVALID_REGNUM, dwarf_s11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 392       LLDB_INVALID_REGNUM},
 393      nullptr,
 394      nullptr,
 395      nullptr,
 396      0},
 397     {"s12",
 398      nullptr,
 399      4,
 400      0,
 401      eEncodingIEEE754,
 402      eFormatFloat,
 403      {LLDB_INVALID_REGNUM, dwarf_s12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 404       LLDB_INVALID_REGNUM},
 405      nullptr,
 406      nullptr,
 407      nullptr,
 408      0},
 409     {"s13",
 410      nullptr,
 411      4,
 412      0,
 413      eEncodingIEEE754,
 414      eFormatFloat,
 415      {LLDB_INVALID_REGNUM, dwarf_s13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 416       LLDB_INVALID_REGNUM},
 417      nullptr,
 418      nullptr,
 419      nullptr,
 420      0},
 421     {"s14",
 422      nullptr,
 423      4,
 424      0,
 425      eEncodingIEEE754,
 426      eFormatFloat,
 427      {LLDB_INVALID_REGNUM, dwarf_s14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 428       LLDB_INVALID_REGNUM},
 429      nullptr,
 430      nullptr,
 431      nullptr,
 432      0},
 433     {"s15",
 434      nullptr,
 435      4,
 436      0,
 437      eEncodingIEEE754,
 438      eFormatFloat,
 439      {LLDB_INVALID_REGNUM, dwarf_s15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 440       LLDB_INVALID_REGNUM},
 441      nullptr,
 442      nullptr,
 443      nullptr,
 444      0},
 445     {"s16",
 446      nullptr,
 447      4,
 448      0,
 449      eEncodingIEEE754,
 450      eFormatFloat,
 451      {LLDB_INVALID_REGNUM, dwarf_s16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 452       LLDB_INVALID_REGNUM},
 453      nullptr,
 454      nullptr,
 455      nullptr,
 456      0},
 457     {"s17",
 458      nullptr,
 459      4,
 460      0,
 461      eEncodingIEEE754,
 462      eFormatFloat,
 463      {LLDB_INVALID_REGNUM, dwarf_s17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 464       LLDB_INVALID_REGNUM},
 465      nullptr,
 466      nullptr,
 467      nullptr,
 468      0},
 469     {"s18",
 470      nullptr,
 471      4,
 472      0,
 473      eEncodingIEEE754,
 474      eFormatFloat,
 475      {LLDB_INVALID_REGNUM, dwarf_s18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 476       LLDB_INVALID_REGNUM},
 477      nullptr,
 478      nullptr,
 479      nullptr,
 480      0},
 481     {"s19",
 482      nullptr,
 483      4,
 484      0,
 485      eEncodingIEEE754,
 486      eFormatFloat,
 487      {LLDB_INVALID_REGNUM, dwarf_s19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 488       LLDB_INVALID_REGNUM},
 489      nullptr,
 490      nullptr,
 491      nullptr,
 492      0},
 493     {"s20",
 494      nullptr,
 495      4,
 496      0,
 497      eEncodingIEEE754,
 498      eFormatFloat,
 499      {LLDB_INVALID_REGNUM, dwarf_s20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 500       LLDB_INVALID_REGNUM},
 501      nullptr,
 502      nullptr,
 503      nullptr,
 504      0},
 505     {"s21",
 506      nullptr,
 507      4,
 508      0,
 509      eEncodingIEEE754,
 510      eFormatFloat,
 511      {LLDB_INVALID_REGNUM, dwarf_s21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 512       LLDB_INVALID_REGNUM},
 513      nullptr,
 514      nullptr,
 515      nullptr,
 516      0},
 517     {"s22",
 518      nullptr,
 519      4,
 520      0,
 521      eEncodingIEEE754,
 522      eFormatFloat,
 523      {LLDB_INVALID_REGNUM, dwarf_s22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 524       LLDB_INVALID_REGNUM},
 525      nullptr,
 526      nullptr,
 527      nullptr,
 528      0},
 529     {"s23",
 530      nullptr,
 531      4,
 532      0,
 533      eEncodingIEEE754,
 534      eFormatFloat,
 535      {LLDB_INVALID_REGNUM, dwarf_s23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 536       LLDB_INVALID_REGNUM},
 537      nullptr,
 538      nullptr,
 539      nullptr,
 540      0},
 541     {"s24",
 542      nullptr,
 543      4,
 544      0,
 545      eEncodingIEEE754,
 546      eFormatFloat,
 547      {LLDB_INVALID_REGNUM, dwarf_s24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 548       LLDB_INVALID_REGNUM},
 549      nullptr,
 550      nullptr,
 551      nullptr,
 552      0},
 553     {"s25",
 554      nullptr,
 555      4,
 556      0,
 557      eEncodingIEEE754,
 558      eFormatFloat,
 559      {LLDB_INVALID_REGNUM, dwarf_s25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 560       LLDB_INVALID_REGNUM},
 561      nullptr,
 562      nullptr,
 563      nullptr,
 564      0},
 565     {"s26",
 566      nullptr,
 567      4,
 568      0,
 569      eEncodingIEEE754,
 570      eFormatFloat,
 571      {LLDB_INVALID_REGNUM, dwarf_s26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 572       LLDB_INVALID_REGNUM},
 573      nullptr,
 574      nullptr,
 575      nullptr,
 576      0},
 577     {"s27",
 578      nullptr,
 579      4,
 580      0,
 581      eEncodingIEEE754,
 582      eFormatFloat,
 583      {LLDB_INVALID_REGNUM, dwarf_s27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 584       LLDB_INVALID_REGNUM},
 585      nullptr,
 586      nullptr,
 587      nullptr,
 588      0},
 589     {"s28",
 590      nullptr,
 591      4,
 592      0,
 593      eEncodingIEEE754,
 594      eFormatFloat,
 595      {LLDB_INVALID_REGNUM, dwarf_s28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 596       LLDB_INVALID_REGNUM},
 597      nullptr,
 598      nullptr,
 599      nullptr,
 600      0},
 601     {"s29",
 602      nullptr,
 603      4,
 604      0,
 605      eEncodingIEEE754,
 606      eFormatFloat,
 607      {LLDB_INVALID_REGNUM, dwarf_s29, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 608       LLDB_INVALID_REGNUM},
 609      nullptr,
 610      nullptr,
 611      nullptr,
 612      0},
 613     {"s30",
 614      nullptr,
 615      4,
 616      0,
 617      eEncodingIEEE754,
 618      eFormatFloat,
 619      {LLDB_INVALID_REGNUM, dwarf_s30, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 620       LLDB_INVALID_REGNUM},
 621      nullptr,
 622      nullptr,
 623      nullptr,
 624      0},
 625     {"s31",
 626      nullptr,
 627      4,
 628      0,
 629      eEncodingIEEE754,
 630      eFormatFloat,
 631      {LLDB_INVALID_REGNUM, dwarf_s31, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 632       LLDB_INVALID_REGNUM},
 633      nullptr,
 634      nullptr,
 635      nullptr,
 636      0},
 637     {"fpscr",
 638      nullptr,
 639      4,
 640      0,
 641      eEncodingUint,
 642      eFormatHex,
 643      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 644       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
 645      nullptr,
 646      nullptr,
 647      nullptr,
 648      0},
 649     {"d0",
 650      nullptr,
 651      8,
 652      0,
 653      eEncodingIEEE754,
 654      eFormatFloat,
 655      {LLDB_INVALID_REGNUM, dwarf_d0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 656       LLDB_INVALID_REGNUM},
 657      nullptr,
 658      nullptr,
 659      nullptr,
 660      0},
 661     {"d1",
 662      nullptr,
 663      8,
 664      0,
 665      eEncodingIEEE754,
 666      eFormatFloat,
 667      {LLDB_INVALID_REGNUM, dwarf_d1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 668       LLDB_INVALID_REGNUM},
 669      nullptr,
 670      nullptr,
 671      nullptr,
 672      0},
 673     {"d2",
 674      nullptr,
 675      8,
 676      0,
 677      eEncodingIEEE754,
 678      eFormatFloat,
 679      {LLDB_INVALID_REGNUM, dwarf_d2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 680       LLDB_INVALID_REGNUM},
 681      nullptr,
 682      nullptr,
 683      nullptr,
 684      0},
 685     {"d3",
 686      nullptr,
 687      8,
 688      0,
 689      eEncodingIEEE754,
 690      eFormatFloat,
 691      {LLDB_INVALID_REGNUM, dwarf_d3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 692       LLDB_INVALID_REGNUM},
 693      nullptr,
 694      nullptr,
 695      nullptr,
 696      0},
 697     {"d4",
 698      nullptr,
 699      8,
 700      0,
 701      eEncodingIEEE754,
 702      eFormatFloat,
 703      {LLDB_INVALID_REGNUM, dwarf_d4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 704       LLDB_INVALID_REGNUM},
 705      nullptr,
 706      nullptr,
 707      nullptr,
 708      0},
 709     {"d5",
 710      nullptr,
 711      8,
 712      0,
 713      eEncodingIEEE754,
 714      eFormatFloat,
 715      {LLDB_INVALID_REGNUM, dwarf_d5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 716       LLDB_INVALID_REGNUM},
 717      nullptr,
 718      nullptr,
 719      nullptr,
 720      0},
 721     {"d6",
 722      nullptr,
 723      8,
 724      0,
 725      eEncodingIEEE754,
 726      eFormatFloat,
 727      {LLDB_INVALID_REGNUM, dwarf_d6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 728       LLDB_INVALID_REGNUM},
 729      nullptr,
 730      nullptr,
 731      nullptr,
 732      0},
 733     {"d7",
 734      nullptr,
 735      8,
 736      0,
 737      eEncodingIEEE754,
 738      eFormatFloat,
 739      {LLDB_INVALID_REGNUM, dwarf_d7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 740       LLDB_INVALID_REGNUM},
 741      nullptr,
 742      nullptr,
 743      nullptr,
 744      0},
 745     {"d8",
 746      nullptr,
 747      8,
 748      0,
 749      eEncodingIEEE754,
 750      eFormatFloat,
 751      {LLDB_INVALID_REGNUM, dwarf_d8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 752       LLDB_INVALID_REGNUM},
 753      nullptr,
 754      nullptr,
 755      nullptr,
 756      0},
 757     {"d9",
 758      nullptr,
 759      8,
 760      0,
 761      eEncodingIEEE754,
 762      eFormatFloat,
 763      {LLDB_INVALID_REGNUM, dwarf_d9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 764       LLDB_INVALID_REGNUM},
 765      nullptr,
 766      nullptr,
 767      nullptr,
 768      0},
 769     {"d10",
 770      nullptr,
 771      8,
 772      0,
 773      eEncodingIEEE754,
 774      eFormatFloat,
 775      {LLDB_INVALID_REGNUM, dwarf_d10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 776       LLDB_INVALID_REGNUM},
 777      nullptr,
 778      nullptr,
 779      nullptr,
 780      0},
 781     {"d11",
 782      nullptr,
 783      8,
 784      0,
 785      eEncodingIEEE754,
 786      eFormatFloat,
 787      {LLDB_INVALID_REGNUM, dwarf_d11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 788       LLDB_INVALID_REGNUM},
 789      nullptr,
 790      nullptr,
 791      nullptr,
 792      0},
 793     {"d12",
 794      nullptr,
 795      8,
 796      0,
 797      eEncodingIEEE754,
 798      eFormatFloat,
 799      {LLDB_INVALID_REGNUM, dwarf_d12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 800       LLDB_INVALID_REGNUM},
 801      nullptr,
 802      nullptr,
 803      nullptr,
 804      0},
 805     {"d13",
 806      nullptr,
 807      8,
 808      0,
 809      eEncodingIEEE754,
 810      eFormatFloat,
 811      {LLDB_INVALID_REGNUM, dwarf_d13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 812       LLDB_INVALID_REGNUM},
 813      nullptr,
 814      nullptr,
 815      nullptr,
 816      0},
 817     {"d14",
 818      nullptr,
 819      8,
 820      0,
 821      eEncodingIEEE754,
 822      eFormatFloat,
 823      {LLDB_INVALID_REGNUM, dwarf_d14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 824       LLDB_INVALID_REGNUM},
 825      nullptr,
 826      nullptr,
 827      nullptr,
 828      0},
 829     {"d15",
 830      nullptr,
 831      8,
 832      0,
 833      eEncodingIEEE754,
 834      eFormatFloat,
 835      {LLDB_INVALID_REGNUM, dwarf_d15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 836       LLDB_INVALID_REGNUM},
 837      nullptr,
 838      nullptr,
 839      nullptr,
 840      0},
 841     {"d16",
 842      nullptr,
 843      8,
 844      0,
 845      eEncodingIEEE754,
 846      eFormatFloat,
 847      {LLDB_INVALID_REGNUM, dwarf_d16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 848       LLDB_INVALID_REGNUM},
 849      nullptr,
 850      nullptr,
 851      nullptr,
 852      0},
 853     {"d17",
 854      nullptr,
 855      8,
 856      0,
 857      eEncodingIEEE754,
 858      eFormatFloat,
 859      {LLDB_INVALID_REGNUM, dwarf_d17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 860       LLDB_INVALID_REGNUM},
 861      nullptr,
 862      nullptr,
 863      nullptr,
 864      0},
 865     {"d18",
 866      nullptr,
 867      8,
 868      0,
 869      eEncodingIEEE754,
 870      eFormatFloat,
 871      {LLDB_INVALID_REGNUM, dwarf_d18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 872       LLDB_INVALID_REGNUM},
 873      nullptr,
 874      nullptr,
 875      nullptr,
 876      0},
 877     {"d19",
 878      nullptr,
 879      8,
 880      0,
 881      eEncodingIEEE754,
 882      eFormatFloat,
 883      {LLDB_INVALID_REGNUM, dwarf_d19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 884       LLDB_INVALID_REGNUM},
 885      nullptr,
 886      nullptr,
 887      nullptr,
 888      0},
 889     {"d20",
 890      nullptr,
 891      8,
 892      0,
 893      eEncodingIEEE754,
 894      eFormatFloat,
 895      {LLDB_INVALID_REGNUM, dwarf_d20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 896       LLDB_INVALID_REGNUM},
 897      nullptr,
 898      nullptr,
 899      nullptr,
 900      0},
 901     {"d21",
 902      nullptr,
 903      8,
 904      0,
 905      eEncodingIEEE754,
 906      eFormatFloat,
 907      {LLDB_INVALID_REGNUM, dwarf_d21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 908       LLDB_INVALID_REGNUM},
 909      nullptr,
 910      nullptr,
 911      nullptr,
 912      0},
 913     {"d22",
 914      nullptr,
 915      8,
 916      0,
 917      eEncodingIEEE754,
 918      eFormatFloat,
 919      {LLDB_INVALID_REGNUM, dwarf_d22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 920       LLDB_INVALID_REGNUM},
 921      nullptr,
 922      nullptr,
 923      nullptr,
 924      0},
 925     {"d23",
 926      nullptr,
 927      8,
 928      0,
 929      eEncodingIEEE754,
 930      eFormatFloat,
 931      {LLDB_INVALID_REGNUM, dwarf_d23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 932       LLDB_INVALID_REGNUM},
 933      nullptr,
 934      nullptr,
 935      nullptr,
 936      0},
 937     {"d24",
 938      nullptr,
 939      8,
 940      0,
 941      eEncodingIEEE754,
 942      eFormatFloat,
 943      {LLDB_INVALID_REGNUM, dwarf_d24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 944       LLDB_INVALID_REGNUM},
 945      nullptr,
 946      nullptr,
 947      nullptr,
 948      0},
 949     {"d25",
 950      nullptr,
 951      8,
 952      0,
 953      eEncodingIEEE754,
 954      eFormatFloat,
 955      {LLDB_INVALID_REGNUM, dwarf_d25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 956       LLDB_INVALID_REGNUM},
 957      nullptr,
 958      nullptr,
 959      nullptr,
 960      0},
 961     {"d26",
 962      nullptr,
 963      8,
 964      0,
 965      eEncodingIEEE754,
 966      eFormatFloat,
 967      {LLDB_INVALID_REGNUM, dwarf_d26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 968       LLDB_INVALID_REGNUM},
 969      nullptr,
 970      nullptr,
 971      nullptr,
 972      0},
 973     {"d27",
 974      nullptr,
 975      8,
 976      0,
 977      eEncodingIEEE754,
 978      eFormatFloat,
 979      {LLDB_INVALID_REGNUM, dwarf_d27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 980       LLDB_INVALID_REGNUM},
 981      nullptr,
 982      nullptr,
 983      nullptr,
 984      0},
 985     {"d28",
 986      nullptr,
 987      8,
 988      0,
 989      eEncodingIEEE754,
 990      eFormatFloat,
 991      {LLDB_INVALID_REGNUM, dwarf_d28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 992       LLDB_INVALID_REGNUM},
 993      nullptr,
 994      nullptr,
 995      nullptr,
 996      0},
 997     {"d29",
 998      nullptr,
 999      8,
1000      0,
1001      eEncodingIEEE754,
1002      eFormatFloat,
1003      {LLDB_INVALID_REGNUM, dwarf_d29, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1004       LLDB_INVALID_REGNUM},
1005      nullptr,
1006      nullptr,
1007      nullptr,
1008      0},
1009     {"d30",
1010      nullptr,
1011      8,
1012      0,
1013      eEncodingIEEE754,
1014      eFormatFloat,
1015      {LLDB_INVALID_REGNUM, dwarf_d30, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1016       LLDB_INVALID_REGNUM},
1017      nullptr,
1018      nullptr,
1019      nullptr,
1020      0},
1021     {"d31",
1022      nullptr,
1023      8,
1024      0,
1025      eEncodingIEEE754,
1026      eFormatFloat,
1027      {LLDB_INVALID_REGNUM, dwarf_d31, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1028       LLDB_INVALID_REGNUM},
1029      nullptr,
1030      nullptr,
1031      nullptr,
1032      0},
1033     {"r8_usr",
1034      nullptr,
1035      4,
1036      0,
1037      eEncodingUint,
1038      eFormatHex,
1039      {LLDB_INVALID_REGNUM, dwarf_r8_usr, LLDB_INVALID_REGNUM,
1040       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1041      nullptr,
1042      nullptr,
1043      nullptr,
1044      0},
1045     {"r9_usr",
1046      nullptr,
1047      4,
1048      0,
1049      eEncodingUint,
1050      eFormatHex,
1051      {LLDB_INVALID_REGNUM, dwarf_r9_usr, LLDB_INVALID_REGNUM,
1052       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1053      nullptr,
1054      nullptr,
1055      nullptr,
1056      0},
1057     {"r10_usr",
1058      nullptr,
1059      4,
1060      0,
1061      eEncodingUint,
1062      eFormatHex,
1063      {LLDB_INVALID_REGNUM, dwarf_r10_usr, LLDB_INVALID_REGNUM,
1064       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1065      nullptr,
1066      nullptr,
1067      nullptr,
1068      0},
1069     {"r11_usr",
1070      nullptr,
1071      4,
1072      0,
1073      eEncodingUint,
1074      eFormatHex,
1075      {LLDB_INVALID_REGNUM, dwarf_r11_usr, LLDB_INVALID_REGNUM,
1076       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1077      nullptr,
1078      nullptr,
1079      nullptr,
1080      0},
1081     {"r12_usr",
1082      nullptr,
1083      4,
1084      0,
1085      eEncodingUint,
1086      eFormatHex,
1087      {LLDB_INVALID_REGNUM, dwarf_r12_usr, LLDB_INVALID_REGNUM,
1088       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1089      nullptr,
1090      nullptr,
1091      nullptr,
1092      0},
1093     {"r13_usr",
1094      "sp_usr",
1095      4,
1096      0,
1097      eEncodingUint,
1098      eFormatHex,
1099      {LLDB_INVALID_REGNUM, dwarf_r13_usr, LLDB_INVALID_REGNUM,
1100       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1101      nullptr,
1102      nullptr,
1103      nullptr,
1104      0},
1105     {"r14_usr",
1106      "lr_usr",
1107      4,
1108      0,
1109      eEncodingUint,
1110      eFormatHex,
1111      {LLDB_INVALID_REGNUM, dwarf_r14_usr, LLDB_INVALID_REGNUM,
1112       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1113      nullptr,
1114      nullptr,
1115      nullptr,
1116      0},
1117     {"r8_fiq",
1118      nullptr,
1119      4,
1120      0,
1121      eEncodingUint,
1122      eFormatHex,
1123      {LLDB_INVALID_REGNUM, dwarf_r8_fiq, LLDB_INVALID_REGNUM,
1124       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1125      nullptr,
1126      nullptr,
1127      nullptr,
1128      0},
1129     {"r9_fiq",
1130      nullptr,
1131      4,
1132      0,
1133      eEncodingUint,
1134      eFormatHex,
1135      {LLDB_INVALID_REGNUM, dwarf_r9_fiq, LLDB_INVALID_REGNUM,
1136       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1137      nullptr,
1138      nullptr,
1139      nullptr,
1140      0},
1141     {"r10_fiq",
1142      nullptr,
1143      4,
1144      0,
1145      eEncodingUint,
1146      eFormatHex,
1147      {LLDB_INVALID_REGNUM, dwarf_r10_fiq, LLDB_INVALID_REGNUM,
1148       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1149      nullptr,
1150      nullptr,
1151      nullptr,
1152      0},
1153     {"r11_fiq",
1154      nullptr,
1155      4,
1156      0,
1157      eEncodingUint,
1158      eFormatHex,
1159      {LLDB_INVALID_REGNUM, dwarf_r11_fiq, LLDB_INVALID_REGNUM,
1160       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1161      nullptr,
1162      nullptr,
1163      nullptr,
1164      0},
1165     {"r12_fiq",
1166      nullptr,
1167      4,
1168      0,
1169      eEncodingUint,
1170      eFormatHex,
1171      {LLDB_INVALID_REGNUM, dwarf_r12_fiq, LLDB_INVALID_REGNUM,
1172       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1173      nullptr,
1174      nullptr,
1175      nullptr,
1176      0},
1177     {"r13_fiq",
1178      "sp_fiq",
1179      4,
1180      0,
1181      eEncodingUint,
1182      eFormatHex,
1183      {LLDB_INVALID_REGNUM, dwarf_r13_fiq, LLDB_INVALID_REGNUM,
1184       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1185      nullptr,
1186      nullptr,
1187      nullptr,
1188      0},
1189     {"r14_fiq",
1190      "lr_fiq",
1191      4,
1192      0,
1193      eEncodingUint,
1194      eFormatHex,
1195      {LLDB_INVALID_REGNUM, dwarf_r14_fiq, LLDB_INVALID_REGNUM,
1196       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1197      nullptr,
1198      nullptr,
1199      nullptr,
1200      0},
1201     {"r13_irq",
1202      "sp_irq",
1203      4,
1204      0,
1205      eEncodingUint,
1206      eFormatHex,
1207      {LLDB_INVALID_REGNUM, dwarf_r13_irq, LLDB_INVALID_REGNUM,
1208       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1209      nullptr,
1210      nullptr,
1211      nullptr,
1212      0},
1213     {"r14_irq",
1214      "lr_irq",
1215      4,
1216      0,
1217      eEncodingUint,
1218      eFormatHex,
1219      {LLDB_INVALID_REGNUM, dwarf_r14_irq, LLDB_INVALID_REGNUM,
1220       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1221      nullptr,
1222      nullptr,
1223      nullptr,
1224      0},
1225     {"r13_abt",
1226      "sp_abt",
1227      4,
1228      0,
1229      eEncodingUint,
1230      eFormatHex,
1231      {LLDB_INVALID_REGNUM, dwarf_r13_abt, LLDB_INVALID_REGNUM,
1232       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1233      nullptr,
1234      nullptr,
1235      nullptr,
1236      0},
1237     {"r14_abt",
1238      "lr_abt",
1239      4,
1240      0,
1241      eEncodingUint,
1242      eFormatHex,
1243      {LLDB_INVALID_REGNUM, dwarf_r14_abt, LLDB_INVALID_REGNUM,
1244       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1245      nullptr,
1246      nullptr,
1247      nullptr,
1248      0},
1249     {"r13_und",
1250      "sp_und",
1251      4,
1252      0,
1253      eEncodingUint,
1254      eFormatHex,
1255      {LLDB_INVALID_REGNUM, dwarf_r13_und, LLDB_INVALID_REGNUM,
1256       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1257      nullptr,
1258      nullptr,
1259      nullptr,
1260      0},
1261     {"r14_und",
1262      "lr_und",
1263      4,
1264      0,
1265      eEncodingUint,
1266      eFormatHex,
1267      {LLDB_INVALID_REGNUM, dwarf_r14_und, LLDB_INVALID_REGNUM,
1268       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1269      nullptr,
1270      nullptr,
1271      nullptr,
1272      0},
1273     {"r13_svc",
1274      "sp_svc",
1275      4,
1276      0,
1277      eEncodingUint,
1278      eFormatHex,
1279      {LLDB_INVALID_REGNUM, dwarf_r13_svc, LLDB_INVALID_REGNUM,
1280       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1281      nullptr,
1282      nullptr,
1283      nullptr,
1284      0},
1285     {"r14_svc",
1286      "lr_svc",
1287      4,
1288      0,
1289      eEncodingUint,
1290      eFormatHex,
1291      {LLDB_INVALID_REGNUM, dwarf_r14_svc, LLDB_INVALID_REGNUM,
1292       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1293      nullptr,
1294      nullptr,
1295      nullptr,
1296      0}};
1297
1298 static const uint32_t k_num_register_infos =
1299     llvm::array_lengthof(g_register_infos);
1300 static bool g_register_info_names_constified = false;
1301
1302 const lldb_private::RegisterInfo *
1303 ABIMacOSX_arm::GetRegisterInfoArray(uint32_t &count) {
1304   // Make the C-string names and alt_names for the register infos into const
1305   // C-string values by having the ConstString unique the names in the global
1306   // constant C-string pool.
1307   if (!g_register_info_names_constified) {
1308     g_register_info_names_constified = true;
1309     for (uint32_t i = 0; i < k_num_register_infos; ++i) {
1310       if (g_register_infos[i].name)
1311         g_register_infos[i].name =
1312             ConstString(g_register_infos[i].name).GetCString();
1313       if (g_register_infos[i].alt_name)
1314         g_register_infos[i].alt_name =
1315             ConstString(g_register_infos[i].alt_name).GetCString();
1316     }
1317   }
1318   count = k_num_register_infos;
1319   return g_register_infos;
1320 }
1321
1322 size_t ABIMacOSX_arm::GetRedZoneSize() const { return 0; }
1323
1324 //------------------------------------------------------------------
1325 // Static Functions
1326 //------------------------------------------------------------------
1327
1328 ABISP
1329 ABIMacOSX_arm::CreateInstance(ProcessSP process_sp, const ArchSpec &arch) {
1330   static ABISP g_abi_sp;
1331   const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch();
1332   const llvm::Triple::VendorType vendor_type = arch.GetTriple().getVendor();
1333
1334   if (vendor_type == llvm::Triple::Apple) {
1335     if ((arch_type == llvm::Triple::arm) ||
1336         (arch_type == llvm::Triple::thumb)) {
1337       if (!g_abi_sp)
1338         g_abi_sp.reset(new ABIMacOSX_arm(process_sp));
1339       return g_abi_sp;
1340     }
1341   }
1342
1343   return ABISP();
1344 }
1345
1346 bool ABIMacOSX_arm::PrepareTrivialCall(Thread &thread, addr_t sp,
1347                                        addr_t function_addr, addr_t return_addr,
1348                                        llvm::ArrayRef<addr_t> args) const {
1349   RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1350   if (!reg_ctx)
1351     return false;
1352
1353   const uint32_t pc_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1354       eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
1355   const uint32_t sp_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1356       eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
1357   const uint32_t ra_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1358       eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA);
1359
1360   RegisterValue reg_value;
1361
1362   const char *reg_names[] = {"r0", "r1", "r2", "r3"};
1363
1364   llvm::ArrayRef<addr_t>::iterator ai = args.begin(), ae = args.end();
1365
1366   for (size_t i = 0; i < llvm::array_lengthof(reg_names); ++i) {
1367     if (ai == ae)
1368       break;
1369
1370     reg_value.SetUInt32(*ai);
1371     if (!reg_ctx->WriteRegister(reg_ctx->GetRegisterInfoByName(reg_names[i]),
1372                                 reg_value))
1373       return false;
1374
1375     ++ai;
1376   }
1377
1378   if (ai != ae) {
1379     // Spill onto the stack
1380     size_t num_stack_regs = ae - ai;
1381
1382     sp -= (num_stack_regs * 4);
1383     // Keep the stack 16 byte aligned
1384     sp &= ~(16ull - 1ull);
1385
1386     // just using arg1 to get the right size
1387     const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
1388         eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
1389
1390     addr_t arg_pos = sp;
1391
1392     for (; ai != ae; ++ai) {
1393       reg_value.SetUInt32(*ai);
1394       if (reg_ctx
1395               ->WriteRegisterValueToMemory(reg_info, arg_pos,
1396                                            reg_info->byte_size, reg_value)
1397               .Fail())
1398         return false;
1399       arg_pos += reg_info->byte_size;
1400     }
1401   }
1402
1403   TargetSP target_sp(thread.CalculateTarget());
1404   Address so_addr;
1405
1406   // Figure out if our return address is ARM or Thumb by using the
1407   // Address::GetCallableLoadAddress(Target*) which will figure out the ARM
1408   // thumb-ness and set the correct address bits for us.
1409   so_addr.SetLoadAddress(return_addr, target_sp.get());
1410   return_addr = so_addr.GetCallableLoadAddress(target_sp.get());
1411
1412   // Set "lr" to the return address
1413   if (!reg_ctx->WriteRegisterFromUnsigned(ra_reg_num, return_addr))
1414     return false;
1415
1416   // If bit zero or 1 is set, this must be a thumb function, no need to figure
1417   // this out from the symbols.
1418   so_addr.SetLoadAddress(function_addr, target_sp.get());
1419   function_addr = so_addr.GetCallableLoadAddress(target_sp.get());
1420
1421   const RegisterInfo *cpsr_reg_info = reg_ctx->GetRegisterInfoByName("cpsr");
1422   const uint32_t curr_cpsr = reg_ctx->ReadRegisterAsUnsigned(cpsr_reg_info, 0);
1423
1424   // Make a new CPSR and mask out any Thumb IT (if/then) bits
1425   uint32_t new_cpsr = curr_cpsr & ~MASK_CPSR_IT_MASK;
1426   // If bit zero or 1 is set, this must be thumb...
1427   if (function_addr & 1ull)
1428     new_cpsr |= MASK_CPSR_T; // Set T bit in CPSR
1429   else
1430     new_cpsr &= ~MASK_CPSR_T; // Clear T bit in CPSR
1431
1432   if (new_cpsr != curr_cpsr) {
1433     if (!reg_ctx->WriteRegisterFromUnsigned(cpsr_reg_info, new_cpsr))
1434       return false;
1435   }
1436
1437   function_addr &=
1438       ~1ull; // clear bit zero since the CPSR will take care of the mode for us
1439
1440   // Update the sp - stack pointer - to be aligned to 16-bytes
1441   sp &= ~(0xfull);
1442   if (!reg_ctx->WriteRegisterFromUnsigned(sp_reg_num, sp))
1443     return false;
1444
1445   // Set "pc" to the address requested
1446   if (!reg_ctx->WriteRegisterFromUnsigned(pc_reg_num, function_addr))
1447     return false;
1448
1449   return true;
1450 }
1451
1452 bool ABIMacOSX_arm::GetArgumentValues(Thread &thread, ValueList &values) const {
1453   uint32_t num_values = values.GetSize();
1454
1455   ExecutionContext exe_ctx(thread.shared_from_this());
1456   // For now, assume that the types in the AST values come from the Target's
1457   // scratch AST.
1458
1459   // Extract the register context so we can read arguments from registers
1460
1461   RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1462
1463   if (!reg_ctx)
1464     return false;
1465
1466   addr_t sp = 0;
1467
1468   for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) {
1469     // We currently only support extracting values with Clang QualTypes. Do we
1470     // care about others?
1471     Value *value = values.GetValueAtIndex(value_idx);
1472
1473     if (!value)
1474       return false;
1475
1476     CompilerType compiler_type = value->GetCompilerType();
1477     if (compiler_type) {
1478       bool is_signed = false;
1479       size_t bit_width = 0;
1480       if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
1481         bit_width = compiler_type.GetBitSize(&thread);
1482       } else if (compiler_type.IsPointerOrReferenceType()) {
1483         bit_width = compiler_type.GetBitSize(&thread);
1484       } else {
1485         // We only handle integer, pointer and reference types currently...
1486         return false;
1487       }
1488
1489       if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) {
1490         if (value_idx < 4) {
1491           // Arguments 1-4 are in r0-r3...
1492           const RegisterInfo *arg_reg_info = nullptr;
1493           // Search by generic ID first, then fall back to by name
1494           uint32_t arg_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1495               eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + value_idx);
1496           if (arg_reg_num != LLDB_INVALID_REGNUM) {
1497             arg_reg_info = reg_ctx->GetRegisterInfoAtIndex(arg_reg_num);
1498           } else {
1499             switch (value_idx) {
1500             case 0:
1501               arg_reg_info = reg_ctx->GetRegisterInfoByName("r0");
1502               break;
1503             case 1:
1504               arg_reg_info = reg_ctx->GetRegisterInfoByName("r1");
1505               break;
1506             case 2:
1507               arg_reg_info = reg_ctx->GetRegisterInfoByName("r2");
1508               break;
1509             case 3:
1510               arg_reg_info = reg_ctx->GetRegisterInfoByName("r3");
1511               break;
1512             }
1513           }
1514
1515           if (arg_reg_info) {
1516             RegisterValue reg_value;
1517
1518             if (reg_ctx->ReadRegister(arg_reg_info, reg_value)) {
1519               if (is_signed)
1520                 reg_value.SignExtend(bit_width);
1521               if (!reg_value.GetScalarValue(value->GetScalar()))
1522                 return false;
1523               continue;
1524             }
1525           }
1526           return false;
1527         } else {
1528           if (sp == 0) {
1529             // Read the stack pointer if it already hasn't been read
1530             sp = reg_ctx->GetSP(0);
1531             if (sp == 0)
1532               return false;
1533           }
1534
1535           // Arguments 5 on up are on the stack
1536           const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8;
1537           Status error;
1538           if (!exe_ctx.GetProcessRef().ReadScalarIntegerFromMemory(
1539                   sp, arg_byte_size, is_signed, value->GetScalar(), error))
1540             return false;
1541
1542           sp += arg_byte_size;
1543         }
1544       }
1545     }
1546   }
1547   return true;
1548 }
1549
1550 bool ABIMacOSX_arm::IsArmv7kProcess() const {
1551   bool is_armv7k = false;
1552   ProcessSP process_sp(GetProcessSP());
1553   if (process_sp) {
1554     const ArchSpec &arch(process_sp->GetTarget().GetArchitecture());
1555     const ArchSpec::Core system_core = arch.GetCore();
1556     if (system_core == ArchSpec::eCore_arm_armv7k) {
1557       is_armv7k = true;
1558     }
1559   }
1560   return is_armv7k;
1561 }
1562
1563 ValueObjectSP ABIMacOSX_arm::GetReturnValueObjectImpl(
1564     Thread &thread, lldb_private::CompilerType &compiler_type) const {
1565   Value value;
1566   ValueObjectSP return_valobj_sp;
1567
1568   if (!compiler_type)
1569     return return_valobj_sp;
1570
1571   value.SetCompilerType(compiler_type);
1572
1573   RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1574   if (!reg_ctx)
1575     return return_valobj_sp;
1576
1577   bool is_signed;
1578
1579   // Get the pointer to the first stack argument so we have a place to start
1580   // when reading data
1581
1582   const RegisterInfo *r0_reg_info = reg_ctx->GetRegisterInfoByName("r0", 0);
1583   if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
1584     size_t bit_width = compiler_type.GetBitSize(&thread);
1585
1586     switch (bit_width) {
1587     default:
1588       return return_valobj_sp;
1589     case 128:
1590       if (IsArmv7kProcess()) {
1591         // "A composite type not larger than 16 bytes is returned in r0-r3. The
1592         // format is as if the result had been stored in memory at a word-
1593         // aligned address and then loaded into r0-r3 with an ldm instruction"
1594         {
1595           const RegisterInfo *r1_reg_info =
1596               reg_ctx->GetRegisterInfoByName("r1", 0);
1597           const RegisterInfo *r2_reg_info =
1598               reg_ctx->GetRegisterInfoByName("r2", 0);
1599           const RegisterInfo *r3_reg_info =
1600               reg_ctx->GetRegisterInfoByName("r3", 0);
1601           if (r1_reg_info && r2_reg_info && r3_reg_info) {
1602             const size_t byte_size = compiler_type.GetByteSize(&thread);
1603             ProcessSP process_sp(thread.GetProcess());
1604             if (byte_size <= r0_reg_info->byte_size + r1_reg_info->byte_size +
1605                                  r2_reg_info->byte_size +
1606                                  r3_reg_info->byte_size &&
1607                 process_sp) {
1608               std::unique_ptr<DataBufferHeap> heap_data_ap(
1609                   new DataBufferHeap(byte_size, 0));
1610               const ByteOrder byte_order = process_sp->GetByteOrder();
1611               RegisterValue r0_reg_value;
1612               RegisterValue r1_reg_value;
1613               RegisterValue r2_reg_value;
1614               RegisterValue r3_reg_value;
1615               if (reg_ctx->ReadRegister(r0_reg_info, r0_reg_value) &&
1616                   reg_ctx->ReadRegister(r1_reg_info, r1_reg_value) &&
1617                   reg_ctx->ReadRegister(r2_reg_info, r2_reg_value) &&
1618                   reg_ctx->ReadRegister(r3_reg_info, r3_reg_value)) {
1619                 Status error;
1620                 if (r0_reg_value.GetAsMemoryData(r0_reg_info,
1621                                                  heap_data_ap->GetBytes() + 0,
1622                                                  4, byte_order, error) &&
1623                     r1_reg_value.GetAsMemoryData(r1_reg_info,
1624                                                  heap_data_ap->GetBytes() + 4,
1625                                                  4, byte_order, error) &&
1626                     r2_reg_value.GetAsMemoryData(r2_reg_info,
1627                                                  heap_data_ap->GetBytes() + 8,
1628                                                  4, byte_order, error) &&
1629                     r3_reg_value.GetAsMemoryData(r3_reg_info,
1630                                                  heap_data_ap->GetBytes() + 12,
1631                                                  4, byte_order, error)) {
1632                   DataExtractor data(DataBufferSP(heap_data_ap.release()),
1633                                      byte_order,
1634                                      process_sp->GetAddressByteSize());
1635
1636                   return_valobj_sp = ValueObjectConstResult::Create(
1637                       &thread, compiler_type, ConstString(""), data);
1638                   return return_valobj_sp;
1639                 }
1640               }
1641             }
1642           }
1643         }
1644       } else {
1645         return return_valobj_sp;
1646       }
1647       break;
1648     case 64: {
1649       const RegisterInfo *r1_reg_info = reg_ctx->GetRegisterInfoByName("r1", 0);
1650       uint64_t raw_value;
1651       raw_value = reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX;
1652       raw_value |= ((uint64_t)(reg_ctx->ReadRegisterAsUnsigned(r1_reg_info, 0) &
1653                                UINT32_MAX))
1654                    << 32;
1655       if (is_signed)
1656         value.GetScalar() = (int64_t)raw_value;
1657       else
1658         value.GetScalar() = (uint64_t)raw_value;
1659     } break;
1660     case 32:
1661       if (is_signed)
1662         value.GetScalar() = (int32_t)(
1663             reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX);
1664       else
1665         value.GetScalar() = (uint32_t)(
1666             reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX);
1667       break;
1668     case 16:
1669       if (is_signed)
1670         value.GetScalar() = (int16_t)(
1671             reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT16_MAX);
1672       else
1673         value.GetScalar() = (uint16_t)(
1674             reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT16_MAX);
1675       break;
1676     case 8:
1677       if (is_signed)
1678         value.GetScalar() = (int8_t)(
1679             reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX);
1680       else
1681         value.GetScalar() = (uint8_t)(
1682             reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX);
1683       break;
1684     }
1685   } else if (compiler_type.IsPointerType()) {
1686     uint32_t ptr =
1687         thread.GetRegisterContext()->ReadRegisterAsUnsigned(r0_reg_info, 0) &
1688         UINT32_MAX;
1689     value.GetScalar() = ptr;
1690   } else {
1691     // not handled yet
1692     return return_valobj_sp;
1693   }
1694
1695   // If we get here, we have a valid Value, so make our ValueObject out of it:
1696
1697   return_valobj_sp = ValueObjectConstResult::Create(
1698       thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
1699   return return_valobj_sp;
1700 }
1701
1702 Status ABIMacOSX_arm::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
1703                                            lldb::ValueObjectSP &new_value_sp) {
1704   Status error;
1705   if (!new_value_sp) {
1706     error.SetErrorString("Empty value object for return value.");
1707     return error;
1708   }
1709
1710   CompilerType compiler_type = new_value_sp->GetCompilerType();
1711   if (!compiler_type) {
1712     error.SetErrorString("Null clang type for return value.");
1713     return error;
1714   }
1715
1716   Thread *thread = frame_sp->GetThread().get();
1717
1718   bool is_signed;
1719   uint32_t count;
1720   bool is_complex;
1721
1722   RegisterContext *reg_ctx = thread->GetRegisterContext().get();
1723
1724   bool set_it_simple = false;
1725   if (compiler_type.IsIntegerOrEnumerationType(is_signed) ||
1726       compiler_type.IsPointerType()) {
1727     DataExtractor data;
1728     Status data_error;
1729     size_t num_bytes = new_value_sp->GetData(data, data_error);
1730     if (data_error.Fail()) {
1731       error.SetErrorStringWithFormat(
1732           "Couldn't convert return value to raw data: %s",
1733           data_error.AsCString());
1734       return error;
1735     }
1736     lldb::offset_t offset = 0;
1737     if (num_bytes <= 8) {
1738       const RegisterInfo *r0_info = reg_ctx->GetRegisterInfoByName("r0", 0);
1739       if (num_bytes <= 4) {
1740         uint32_t raw_value = data.GetMaxU32(&offset, num_bytes);
1741
1742         if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value))
1743           set_it_simple = true;
1744       } else {
1745         uint32_t raw_value = data.GetMaxU32(&offset, 4);
1746
1747         if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value)) {
1748           const RegisterInfo *r1_info = reg_ctx->GetRegisterInfoByName("r1", 0);
1749           uint32_t raw_value = data.GetMaxU32(&offset, num_bytes - offset);
1750
1751           if (reg_ctx->WriteRegisterFromUnsigned(r1_info, raw_value))
1752             set_it_simple = true;
1753         }
1754       }
1755     } else if (num_bytes <= 16 && IsArmv7kProcess()) {
1756       // "A composite type not larger than 16 bytes is returned in r0-r3. The
1757       // format is as if the result had been stored in memory at a word-aligned
1758       // address and then loaded into r0-r3 with an ldm instruction"
1759
1760       const RegisterInfo *r0_info = reg_ctx->GetRegisterInfoByName("r0", 0);
1761       const RegisterInfo *r1_info = reg_ctx->GetRegisterInfoByName("r1", 0);
1762       const RegisterInfo *r2_info = reg_ctx->GetRegisterInfoByName("r2", 0);
1763       const RegisterInfo *r3_info = reg_ctx->GetRegisterInfoByName("r3", 0);
1764       lldb::offset_t offset = 0;
1765       uint32_t bytes_written = 4;
1766       uint32_t raw_value = data.GetMaxU64(&offset, 4);
1767       if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value) &&
1768           bytes_written <= num_bytes) {
1769         bytes_written += 4;
1770         raw_value = data.GetMaxU64(&offset, 4);
1771         if (bytes_written <= num_bytes &&
1772             reg_ctx->WriteRegisterFromUnsigned(r1_info, raw_value)) {
1773           bytes_written += 4;
1774           raw_value = data.GetMaxU64(&offset, 4);
1775           if (bytes_written <= num_bytes &&
1776               reg_ctx->WriteRegisterFromUnsigned(r2_info, raw_value)) {
1777             bytes_written += 4;
1778             raw_value = data.GetMaxU64(&offset, 4);
1779             if (bytes_written <= num_bytes &&
1780                 reg_ctx->WriteRegisterFromUnsigned(r3_info, raw_value)) {
1781               set_it_simple = true;
1782             }
1783           }
1784         }
1785       }
1786     } else {
1787       error.SetErrorString("We don't support returning longer than 64 bit "
1788                            "integer values at present.");
1789     }
1790   } else if (compiler_type.IsFloatingPointType(count, is_complex)) {
1791     if (is_complex)
1792       error.SetErrorString(
1793           "We don't support returning complex values at present");
1794     else
1795       error.SetErrorString(
1796           "We don't support returning float values at present");
1797   }
1798
1799   if (!set_it_simple)
1800     error.SetErrorString(
1801         "We only support setting simple integer return types at present.");
1802
1803   return error;
1804 }
1805
1806 bool ABIMacOSX_arm::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) {
1807   unwind_plan.Clear();
1808   unwind_plan.SetRegisterKind(eRegisterKindDWARF);
1809
1810   uint32_t lr_reg_num = dwarf_lr;
1811   uint32_t sp_reg_num = dwarf_sp;
1812   uint32_t pc_reg_num = dwarf_pc;
1813
1814   UnwindPlan::RowSP row(new UnwindPlan::Row);
1815
1816   // Our Call Frame Address is the stack pointer value
1817   row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
1818
1819   // The previous PC is in the LR
1820   row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
1821   unwind_plan.AppendRow(row);
1822
1823   // All other registers are the same.
1824
1825   unwind_plan.SetSourceName("arm at-func-entry default");
1826   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
1827
1828   return true;
1829 }
1830
1831 bool ABIMacOSX_arm::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
1832   unwind_plan.Clear();
1833   unwind_plan.SetRegisterKind(eRegisterKindDWARF);
1834
1835   uint32_t fp_reg_num =
1836       dwarf_r7; // apple uses r7 for all frames. Normal arm uses r11
1837   uint32_t pc_reg_num = dwarf_pc;
1838
1839   UnwindPlan::RowSP row(new UnwindPlan::Row);
1840   const int32_t ptr_size = 4;
1841
1842   row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
1843   row->SetOffset(0);
1844
1845   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
1846   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
1847
1848   unwind_plan.AppendRow(row);
1849   unwind_plan.SetSourceName("arm-apple-ios default unwind plan");
1850   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
1851   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
1852
1853   return true;
1854 }
1855
1856 // cf. "ARMv6 Function Calling Conventions"
1857 // https://developer.apple.com/library/ios/documentation/Xcode/Conceptual/iPhoneOSABIReference/Articles/ARMv6FunctionCallingConventions.html
1858 // and "ARMv7 Function Calling Conventions"
1859 // https://developer.apple.com/library/ios/documentation/Xcode/Conceptual/iPhoneOSABIReference/Articles/ARMv7FunctionCallingConventions.html
1860
1861 // ARMv7 on iOS general purpose reg rules:
1862 //    r0-r3 not preserved  (used for argument passing)
1863 //    r4-r6 preserved
1864 //    r7    preserved (frame pointer)
1865 //    r8    preserved
1866 //    r9    not preserved (usable as volatile scratch register with iOS 3.x and
1867 //    later)
1868 //    r10-r11 preserved
1869 //    r12   not presrved
1870 //    r13   preserved (stack pointer)
1871 //    r14   not preserved (link register)
1872 //    r15   preserved (pc)
1873 //    cpsr  not preserved (different rules for different bits)
1874
1875 // ARMv7 on iOS floating point rules:
1876 //    d0-d7   not preserved   (aka s0-s15, q0-q3)
1877 //    d8-d15  preserved       (aka s16-s31, q4-q7)
1878 //    d16-d31 not preserved   (aka q8-q15)
1879
1880 bool ABIMacOSX_arm::RegisterIsVolatile(const RegisterInfo *reg_info) {
1881   if (reg_info) {
1882     // Volatile registers are: r0, r1, r2, r3, r9, r12, r13 (aka sp)
1883     const char *name = reg_info->name;
1884     if (name[0] == 'r') {
1885       switch (name[1]) {
1886       case '0':
1887         return name[2] == '\0'; // r0
1888       case '1':
1889         switch (name[2]) {
1890         case '\0':
1891           return true; // r1
1892         case '2':
1893         case '3':
1894           return name[3] == '\0'; // r12, r13 (sp)
1895         default:
1896           break;
1897         }
1898         break;
1899
1900       case '2':
1901         return name[2] == '\0'; // r2
1902       case '3':
1903         return name[2] == '\0'; // r3
1904       case '9':
1905         return name[2] == '\0'; // r9 (apple-ios only...)
1906
1907         break;
1908       }
1909     } else if (name[0] == 'd') {
1910       switch (name[1]) {
1911       case '0':
1912         return name[2] == '\0'; // d0 is volatile
1913
1914       case '1':
1915         switch (name[2]) {
1916         case '\0':
1917           return true; // d1 is volatile
1918         case '6':
1919         case '7':
1920         case '8':
1921         case '9':
1922           return name[3] == '\0'; // d16 - d19 are volatile
1923         default:
1924           break;
1925         }
1926         break;
1927
1928       case '2':
1929         switch (name[2]) {
1930         case '\0':
1931           return true; // d2 is volatile
1932         case '0':
1933         case '1':
1934         case '2':
1935         case '3':
1936         case '4':
1937         case '5':
1938         case '6':
1939         case '7':
1940         case '8':
1941         case '9':
1942           return name[3] == '\0'; // d20 - d29 are volatile
1943         default:
1944           break;
1945         }
1946         break;
1947
1948       case '3':
1949         switch (name[2]) {
1950         case '\0':
1951           return true; // d3 is volatile
1952         case '0':
1953         case '1':
1954           return name[3] == '\0'; // d30 - d31 are volatile
1955         default:
1956           break;
1957         }
1958         break;
1959       case '4':
1960       case '5':
1961       case '6':
1962       case '7':
1963         return name[2] == '\0'; // d4 - d7 are volatile
1964
1965       default:
1966         break;
1967       }
1968     } else if (name[0] == 's') {
1969       switch (name[1]) {
1970       case '0':
1971         return name[2] == '\0'; // s0 is volatile
1972
1973       case '1':
1974         switch (name[2]) {
1975         case '\0':
1976           return true; // s1 is volatile
1977         case '0':
1978         case '1':
1979         case '2':
1980         case '3':
1981         case '4':
1982         case '5':
1983           return name[3] == '\0'; // s10 - s15 are volatile
1984         default:
1985           break;
1986         }
1987         break;
1988
1989       case '2':
1990       case '3':
1991       case '4':
1992       case '5':
1993       case '6':
1994       case '7':
1995       case '8':
1996       case '9':
1997         return name[2] == '\0'; // s2 - s9 are volatile
1998
1999       default:
2000         break;
2001       }
2002     } else if (name[0] == 'q') {
2003       switch (name[1]) {
2004       case '1':
2005         switch (name[2]) {
2006         case '\0':
2007           return true; // q1 is volatile
2008         case '0':
2009         case '1':
2010         case '2':
2011         case '3':
2012         case '4':
2013         case '5':
2014           return true; // q10-q15 are volatile
2015         default:
2016           break;
2017         };
2018         break;
2019       case '0':
2020       case '2':
2021       case '3':
2022         return name[2] == '\0'; // q0-q3 are volatile
2023       case '8':
2024       case '9':
2025         return name[2] == '\0'; // q8-q9 are volatile
2026       default:
2027         break;
2028       }
2029     } else if (name[0] == 's' && name[1] == 'p' && name[2] == '\0')
2030       return true;
2031   }
2032   return false;
2033 }
2034
2035 void ABIMacOSX_arm::Initialize() {
2036   PluginManager::RegisterPlugin(GetPluginNameStatic(),
2037                                 "Mac OS X ABI for arm targets", CreateInstance);
2038 }
2039
2040 void ABIMacOSX_arm::Terminate() {
2041   PluginManager::UnregisterPlugin(CreateInstance);
2042 }
2043
2044 lldb_private::ConstString ABIMacOSX_arm::GetPluginNameStatic() {
2045   static ConstString g_name("macosx-arm");
2046   return g_name;
2047 }
2048
2049 //------------------------------------------------------------------
2050 // PluginInterface protocol
2051 //------------------------------------------------------------------
2052
2053 lldb_private::ConstString ABIMacOSX_arm::GetPluginName() {
2054   return GetPluginNameStatic();
2055 }
2056
2057 uint32_t ABIMacOSX_arm::GetPluginVersion() { return 1; }