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 #include <vector>
  13
  14 #include "llvm/ADT/STLExtras.h"
  15 #include "llvm/ADT/Triple.h"
  16
  17 #include "lldb/Core/Module.h"
  18 #include "lldb/Core/PluginManager.h"
  19 #include "lldb/Core/Value.h"
  20 #include "lldb/Core/ValueObjectConstResult.h"
  21 #include "lldb/Symbol/UnwindPlan.h"
  22 #include "lldb/Target/Process.h"
  23 #include "lldb/Target/RegisterContext.h"
  24 #include "lldb/Target/Target.h"
  25 #include "lldb/Target/Thread.h"
  26 #include "lldb/Utility/ConstString.h"
  27 #include "lldb/Utility/RegisterValue.h"
  28 #include "lldb/Utility/Scalar.h"
  29 #include "lldb/Utility/Status.h"
  30
  31 #include "Plugins/Process/Utility/ARMDefines.h"
  32 #include "Utility/ARM_DWARF_Registers.h"
  33 #include "Utility/ARM_ehframe_Registers.h"
  34
  35 using namespace lldb;
  36 using namespace lldb_private;
  37
  38 static RegisterInfo g_register_infos[] = {
  39     //  NAME       ALT       SZ OFF ENCODING         FORMAT          EH_FRAME
  40     //  DWARF               GENERIC                     PROCESS PLUGIN
  41     //  LLDB NATIVE
  42     //  ========== =======   == === =============    ============
  43     //  ======================= =================== ===========================
  44     //  ======================= ======================
  45     {"r0",
  46      "arg1",
  47      4,
  48      0,
  49      eEncodingUint,
  50      eFormatHex,
  51      {ehframe_r0, dwarf_r0, LLDB_REGNUM_GENERIC_ARG1, LLDB_INVALID_REGNUM,
  52       LLDB_INVALID_REGNUM},
  53      nullptr,
  54      nullptr,
  55      nullptr,
  56      0},
  57     {"r1",
  58      "arg2",
  59      4,
  60      0,
  61      eEncodingUint,
  62      eFormatHex,
  63      {ehframe_r1, dwarf_r1, LLDB_REGNUM_GENERIC_ARG2, LLDB_INVALID_REGNUM,
  64       LLDB_INVALID_REGNUM},
  65      nullptr,
  66      nullptr,
  67      nullptr,
  68      0},
  69     {"r2",
  70      "arg3",
  71      4,
  72      0,
  73      eEncodingUint,
  74      eFormatHex,
  75      {ehframe_r2, dwarf_r2, LLDB_REGNUM_GENERIC_ARG3, LLDB_INVALID_REGNUM,
  76       LLDB_INVALID_REGNUM},
  77      nullptr,
  78      nullptr,
  79      nullptr,
  80      0},
  81     {"r3",
  82      "arg4",
  83      4,
  84      0,
  85      eEncodingUint,
  86      eFormatHex,
  87      {ehframe_r3, dwarf_r3, LLDB_REGNUM_GENERIC_ARG4, LLDB_INVALID_REGNUM,
  88       LLDB_INVALID_REGNUM},
  89      nullptr,
  90      nullptr,
  91      nullptr,
  92      0},
  93     {"r4",
  94      nullptr,
  95      4,
  96      0,
  97      eEncodingUint,
  98      eFormatHex,
  99      {ehframe_r4, dwarf_r4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 100       LLDB_INVALID_REGNUM},
 101      nullptr,
 102      nullptr,
 103      nullptr,
 104      0},
 105     {"r5",
 106      nullptr,
 107      4,
 108      0,
 109      eEncodingUint,
 110      eFormatHex,
 111      {ehframe_r5, dwarf_r5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 112       LLDB_INVALID_REGNUM},
 113      nullptr,
 114      nullptr,
 115      nullptr,
 116      0},
 117     {"r6",
 118      nullptr,
 119      4,
 120      0,
 121      eEncodingUint,
 122      eFormatHex,
 123      {ehframe_r6, dwarf_r6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 124       LLDB_INVALID_REGNUM},
 125      nullptr,
 126      nullptr,
 127      nullptr,
 128      0},
 129     {"r7",
 130      nullptr,
 131      4,
 132      0,
 133      eEncodingUint,
 134      eFormatHex,
 135      {ehframe_r7, dwarf_r7, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM,
 136       LLDB_INVALID_REGNUM},
 137      nullptr,
 138      nullptr,
 139      nullptr,
 140      0},
 141     {"r8",
 142      nullptr,
 143      4,
 144      0,
 145      eEncodingUint,
 146      eFormatHex,
 147      {ehframe_r8, dwarf_r8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 148       LLDB_INVALID_REGNUM},
 149      nullptr,
 150      nullptr,
 151      nullptr,
 152      0},
 153     {"r9",
 154      nullptr,
 155      4,
 156      0,
 157      eEncodingUint,
 158      eFormatHex,
 159      {ehframe_r9, dwarf_r9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 160       LLDB_INVALID_REGNUM},
 161      nullptr,
 162      nullptr,
 163      nullptr,
 164      0},
 165     {"r10",
 166      nullptr,
 167      4,
 168      0,
 169      eEncodingUint,
 170      eFormatHex,
 171      {ehframe_r10, dwarf_r10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 172       LLDB_INVALID_REGNUM},
 173      nullptr,
 174      nullptr,
 175      nullptr,
 176      0},
 177     {"r11",
 178      nullptr,
 179      4,
 180      0,
 181      eEncodingUint,
 182      eFormatHex,
 183      {ehframe_r11, dwarf_r11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 184       LLDB_INVALID_REGNUM},
 185      nullptr,
 186      nullptr,
 187      nullptr,
 188      0},
 189     {"r12",
 190      nullptr,
 191      4,
 192      0,
 193      eEncodingUint,
 194      eFormatHex,
 195      {ehframe_r12, dwarf_r12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 196       LLDB_INVALID_REGNUM},
 197      nullptr,
 198      nullptr,
 199      nullptr,
 200      0},
 201     {"sp",
 202      "r13",
 203      4,
 204      0,
 205      eEncodingUint,
 206      eFormatHex,
 207      {ehframe_sp, dwarf_sp, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM,
 208       LLDB_INVALID_REGNUM},
 209      nullptr,
 210      nullptr,
 211      nullptr,
 212      0},
 213     {"lr",
 214      "r14",
 215      4,
 216      0,
 217      eEncodingUint,
 218      eFormatHex,
 219      {ehframe_lr, dwarf_lr, LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM,
 220       LLDB_INVALID_REGNUM},
 221      nullptr,
 222      nullptr,
 223      nullptr,
 224      0},
 225     {"pc",
 226      "r15",
 227      4,
 228      0,
 229      eEncodingUint,
 230      eFormatHex,
 231      {ehframe_pc, dwarf_pc, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
 232       LLDB_INVALID_REGNUM},
 233      nullptr,
 234      nullptr,
 235      nullptr,
 236      0},
 237     {"cpsr",
 238      "psr",
 239      4,
 240      0,
 241      eEncodingUint,
 242      eFormatHex,
 243      {ehframe_cpsr, dwarf_cpsr, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM,
 244       LLDB_INVALID_REGNUM},
 245      nullptr,
 246      nullptr,
 247      nullptr,
 248      0},
 249     {"s0",
 250      nullptr,
 251      4,
 252      0,
 253      eEncodingIEEE754,
 254      eFormatFloat,
 255      {LLDB_INVALID_REGNUM, dwarf_s0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 256       LLDB_INVALID_REGNUM},
 257      nullptr,
 258      nullptr,
 259      nullptr,
 260      0},
 261     {"s1",
 262      nullptr,
 263      4,
 264      0,
 265      eEncodingIEEE754,
 266      eFormatFloat,
 267      {LLDB_INVALID_REGNUM, dwarf_s1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 268       LLDB_INVALID_REGNUM},
 269      nullptr,
 270      nullptr,
 271      nullptr,
 272      0},
 273     {"s2",
 274      nullptr,
 275      4,
 276      0,
 277      eEncodingIEEE754,
 278      eFormatFloat,
 279      {LLDB_INVALID_REGNUM, dwarf_s2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 280       LLDB_INVALID_REGNUM},
 281      nullptr,
 282      nullptr,
 283      nullptr,
 284      0},
 285     {"s3",
 286      nullptr,
 287      4,
 288      0,
 289      eEncodingIEEE754,
 290      eFormatFloat,
 291      {LLDB_INVALID_REGNUM, dwarf_s3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 292       LLDB_INVALID_REGNUM},
 293      nullptr,
 294      nullptr,
 295      nullptr,
 296      0},
 297     {"s4",
 298      nullptr,
 299      4,
 300      0,
 301      eEncodingIEEE754,
 302      eFormatFloat,
 303      {LLDB_INVALID_REGNUM, dwarf_s4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 304       LLDB_INVALID_REGNUM},
 305      nullptr,
 306      nullptr,
 307      nullptr,
 308      0},
 309     {"s5",
 310      nullptr,
 311      4,
 312      0,
 313      eEncodingIEEE754,
 314      eFormatFloat,
 315      {LLDB_INVALID_REGNUM, dwarf_s5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 316       LLDB_INVALID_REGNUM},
 317      nullptr,
 318      nullptr,
 319      nullptr,
 320      0},
 321     {"s6",
 322      nullptr,
 323      4,
 324      0,
 325      eEncodingIEEE754,
 326      eFormatFloat,
 327      {LLDB_INVALID_REGNUM, dwarf_s6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 328       LLDB_INVALID_REGNUM},
 329      nullptr,
 330      nullptr,
 331      nullptr,
 332      0},
 333     {"s7",
 334      nullptr,
 335      4,
 336      0,
 337      eEncodingIEEE754,
 338      eFormatFloat,
 339      {LLDB_INVALID_REGNUM, dwarf_s7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 340       LLDB_INVALID_REGNUM},
 341      nullptr,
 342      nullptr,
 343      nullptr,
 344      0},
 345     {"s8",
 346      nullptr,
 347      4,
 348      0,
 349      eEncodingIEEE754,
 350      eFormatFloat,
 351      {LLDB_INVALID_REGNUM, dwarf_s8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 352       LLDB_INVALID_REGNUM},
 353      nullptr,
 354      nullptr,
 355      nullptr,
 356      0},
 357     {"s9",
 358      nullptr,
 359      4,
 360      0,
 361      eEncodingIEEE754,
 362      eFormatFloat,
 363      {LLDB_INVALID_REGNUM, dwarf_s9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 364       LLDB_INVALID_REGNUM},
 365      nullptr,
 366      nullptr,
 367      nullptr,
 368      0},
 369     {"s10",
 370      nullptr,
 371      4,
 372      0,
 373      eEncodingIEEE754,
 374      eFormatFloat,
 375      {LLDB_INVALID_REGNUM, dwarf_s10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 376       LLDB_INVALID_REGNUM},
 377      nullptr,
 378      nullptr,
 379      nullptr,
 380      0},
 381     {"s11",
 382      nullptr,
 383      4,
 384      0,
 385      eEncodingIEEE754,
 386      eFormatFloat,
 387      {LLDB_INVALID_REGNUM, dwarf_s11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 388       LLDB_INVALID_REGNUM},
 389      nullptr,
 390      nullptr,
 391      nullptr,
 392      0},
 393     {"s12",
 394      nullptr,
 395      4,
 396      0,
 397      eEncodingIEEE754,
 398      eFormatFloat,
 399      {LLDB_INVALID_REGNUM, dwarf_s12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 400       LLDB_INVALID_REGNUM},
 401      nullptr,
 402      nullptr,
 403      nullptr,
 404      0},
 405     {"s13",
 406      nullptr,
 407      4,
 408      0,
 409      eEncodingIEEE754,
 410      eFormatFloat,
 411      {LLDB_INVALID_REGNUM, dwarf_s13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 412       LLDB_INVALID_REGNUM},
 413      nullptr,
 414      nullptr,
 415      nullptr,
 416      0},
 417     {"s14",
 418      nullptr,
 419      4,
 420      0,
 421      eEncodingIEEE754,
 422      eFormatFloat,
 423      {LLDB_INVALID_REGNUM, dwarf_s14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 424       LLDB_INVALID_REGNUM},
 425      nullptr,
 426      nullptr,
 427      nullptr,
 428      0},
 429     {"s15",
 430      nullptr,
 431      4,
 432      0,
 433      eEncodingIEEE754,
 434      eFormatFloat,
 435      {LLDB_INVALID_REGNUM, dwarf_s15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 436       LLDB_INVALID_REGNUM},
 437      nullptr,
 438      nullptr,
 439      nullptr,
 440      0},
 441     {"s16",
 442      nullptr,
 443      4,
 444      0,
 445      eEncodingIEEE754,
 446      eFormatFloat,
 447      {LLDB_INVALID_REGNUM, dwarf_s16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 448       LLDB_INVALID_REGNUM},
 449      nullptr,
 450      nullptr,
 451      nullptr,
 452      0},
 453     {"s17",
 454      nullptr,
 455      4,
 456      0,
 457      eEncodingIEEE754,
 458      eFormatFloat,
 459      {LLDB_INVALID_REGNUM, dwarf_s17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 460       LLDB_INVALID_REGNUM},
 461      nullptr,
 462      nullptr,
 463      nullptr,
 464      0},
 465     {"s18",
 466      nullptr,
 467      4,
 468      0,
 469      eEncodingIEEE754,
 470      eFormatFloat,
 471      {LLDB_INVALID_REGNUM, dwarf_s18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 472       LLDB_INVALID_REGNUM},
 473      nullptr,
 474      nullptr,
 475      nullptr,
 476      0},
 477     {"s19",
 478      nullptr,
 479      4,
 480      0,
 481      eEncodingIEEE754,
 482      eFormatFloat,
 483      {LLDB_INVALID_REGNUM, dwarf_s19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 484       LLDB_INVALID_REGNUM},
 485      nullptr,
 486      nullptr,
 487      nullptr,
 488      0},
 489     {"s20",
 490      nullptr,
 491      4,
 492      0,
 493      eEncodingIEEE754,
 494      eFormatFloat,
 495      {LLDB_INVALID_REGNUM, dwarf_s20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 496       LLDB_INVALID_REGNUM},
 497      nullptr,
 498      nullptr,
 499      nullptr,
 500      0},
 501     {"s21",
 502      nullptr,
 503      4,
 504      0,
 505      eEncodingIEEE754,
 506      eFormatFloat,
 507      {LLDB_INVALID_REGNUM, dwarf_s21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 508       LLDB_INVALID_REGNUM},
 509      nullptr,
 510      nullptr,
 511      nullptr,
 512      0},
 513     {"s22",
 514      nullptr,
 515      4,
 516      0,
 517      eEncodingIEEE754,
 518      eFormatFloat,
 519      {LLDB_INVALID_REGNUM, dwarf_s22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 520       LLDB_INVALID_REGNUM},
 521      nullptr,
 522      nullptr,
 523      nullptr,
 524      0},
 525     {"s23",
 526      nullptr,
 527      4,
 528      0,
 529      eEncodingIEEE754,
 530      eFormatFloat,
 531      {LLDB_INVALID_REGNUM, dwarf_s23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 532       LLDB_INVALID_REGNUM},
 533      nullptr,
 534      nullptr,
 535      nullptr,
 536      0},
 537     {"s24",
 538      nullptr,
 539      4,
 540      0,
 541      eEncodingIEEE754,
 542      eFormatFloat,
 543      {LLDB_INVALID_REGNUM, dwarf_s24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 544       LLDB_INVALID_REGNUM},
 545      nullptr,
 546      nullptr,
 547      nullptr,
 548      0},
 549     {"s25",
 550      nullptr,
 551      4,
 552      0,
 553      eEncodingIEEE754,
 554      eFormatFloat,
 555      {LLDB_INVALID_REGNUM, dwarf_s25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 556       LLDB_INVALID_REGNUM},
 557      nullptr,
 558      nullptr,
 559      nullptr,
 560      0},
 561     {"s26",
 562      nullptr,
 563      4,
 564      0,
 565      eEncodingIEEE754,
 566      eFormatFloat,
 567      {LLDB_INVALID_REGNUM, dwarf_s26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 568       LLDB_INVALID_REGNUM},
 569      nullptr,
 570      nullptr,
 571      nullptr,
 572      0},
 573     {"s27",
 574      nullptr,
 575      4,
 576      0,
 577      eEncodingIEEE754,
 578      eFormatFloat,
 579      {LLDB_INVALID_REGNUM, dwarf_s27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 580       LLDB_INVALID_REGNUM},
 581      nullptr,
 582      nullptr,
 583      nullptr,
 584      0},
 585     {"s28",
 586      nullptr,
 587      4,
 588      0,
 589      eEncodingIEEE754,
 590      eFormatFloat,
 591      {LLDB_INVALID_REGNUM, dwarf_s28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 592       LLDB_INVALID_REGNUM},
 593      nullptr,
 594      nullptr,
 595      nullptr,
 596      0},
 597     {"s29",
 598      nullptr,
 599      4,
 600      0,
 601      eEncodingIEEE754,
 602      eFormatFloat,
 603      {LLDB_INVALID_REGNUM, dwarf_s29, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 604       LLDB_INVALID_REGNUM},
 605      nullptr,
 606      nullptr,
 607      nullptr,
 608      0},
 609     {"s30",
 610      nullptr,
 611      4,
 612      0,
 613      eEncodingIEEE754,
 614      eFormatFloat,
 615      {LLDB_INVALID_REGNUM, dwarf_s30, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 616       LLDB_INVALID_REGNUM},
 617      nullptr,
 618      nullptr,
 619      nullptr,
 620      0},
 621     {"s31",
 622      nullptr,
 623      4,
 624      0,
 625      eEncodingIEEE754,
 626      eFormatFloat,
 627      {LLDB_INVALID_REGNUM, dwarf_s31, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 628       LLDB_INVALID_REGNUM},
 629      nullptr,
 630      nullptr,
 631      nullptr,
 632      0},
 633     {"fpscr",
 634      nullptr,
 635      4,
 636      0,
 637      eEncodingUint,
 638      eFormatHex,
 639      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 640       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
 641      nullptr,
 642      nullptr,
 643      nullptr,
 644      0},
 645     {"d0",
 646      nullptr,
 647      8,
 648      0,
 649      eEncodingIEEE754,
 650      eFormatFloat,
 651      {LLDB_INVALID_REGNUM, dwarf_d0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 652       LLDB_INVALID_REGNUM},
 653      nullptr,
 654      nullptr,
 655      nullptr,
 656      0},
 657     {"d1",
 658      nullptr,
 659      8,
 660      0,
 661      eEncodingIEEE754,
 662      eFormatFloat,
 663      {LLDB_INVALID_REGNUM, dwarf_d1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 664       LLDB_INVALID_REGNUM},
 665      nullptr,
 666      nullptr,
 667      nullptr,
 668      0},
 669     {"d2",
 670      nullptr,
 671      8,
 672      0,
 673      eEncodingIEEE754,
 674      eFormatFloat,
 675      {LLDB_INVALID_REGNUM, dwarf_d2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 676       LLDB_INVALID_REGNUM},
 677      nullptr,
 678      nullptr,
 679      nullptr,
 680      0},
 681     {"d3",
 682      nullptr,
 683      8,
 684      0,
 685      eEncodingIEEE754,
 686      eFormatFloat,
 687      {LLDB_INVALID_REGNUM, dwarf_d3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 688       LLDB_INVALID_REGNUM},
 689      nullptr,
 690      nullptr,
 691      nullptr,
 692      0},
 693     {"d4",
 694      nullptr,
 695      8,
 696      0,
 697      eEncodingIEEE754,
 698      eFormatFloat,
 699      {LLDB_INVALID_REGNUM, dwarf_d4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 700       LLDB_INVALID_REGNUM},
 701      nullptr,
 702      nullptr,
 703      nullptr,
 704      0},
 705     {"d5",
 706      nullptr,
 707      8,
 708      0,
 709      eEncodingIEEE754,
 710      eFormatFloat,
 711      {LLDB_INVALID_REGNUM, dwarf_d5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 712       LLDB_INVALID_REGNUM},
 713      nullptr,
 714      nullptr,
 715      nullptr,
 716      0},
 717     {"d6",
 718      nullptr,
 719      8,
 720      0,
 721      eEncodingIEEE754,
 722      eFormatFloat,
 723      {LLDB_INVALID_REGNUM, dwarf_d6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 724       LLDB_INVALID_REGNUM},
 725      nullptr,
 726      nullptr,
 727      nullptr,
 728      0},
 729     {"d7",
 730      nullptr,
 731      8,
 732      0,
 733      eEncodingIEEE754,
 734      eFormatFloat,
 735      {LLDB_INVALID_REGNUM, dwarf_d7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 736       LLDB_INVALID_REGNUM},
 737      nullptr,
 738      nullptr,
 739      nullptr,
 740      0},
 741     {"d8",
 742      nullptr,
 743      8,
 744      0,
 745      eEncodingIEEE754,
 746      eFormatFloat,
 747      {LLDB_INVALID_REGNUM, dwarf_d8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 748       LLDB_INVALID_REGNUM},
 749      nullptr,
 750      nullptr,
 751      nullptr,
 752      0},
 753     {"d9",
 754      nullptr,
 755      8,
 756      0,
 757      eEncodingIEEE754,
 758      eFormatFloat,
 759      {LLDB_INVALID_REGNUM, dwarf_d9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 760       LLDB_INVALID_REGNUM},
 761      nullptr,
 762      nullptr,
 763      nullptr,
 764      0},
 765     {"d10",
 766      nullptr,
 767      8,
 768      0,
 769      eEncodingIEEE754,
 770      eFormatFloat,
 771      {LLDB_INVALID_REGNUM, dwarf_d10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 772       LLDB_INVALID_REGNUM},
 773      nullptr,
 774      nullptr,
 775      nullptr,
 776      0},
 777     {"d11",
 778      nullptr,
 779      8,
 780      0,
 781      eEncodingIEEE754,
 782      eFormatFloat,
 783      {LLDB_INVALID_REGNUM, dwarf_d11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 784       LLDB_INVALID_REGNUM},
 785      nullptr,
 786      nullptr,
 787      nullptr,
 788      0},
 789     {"d12",
 790      nullptr,
 791      8,
 792      0,
 793      eEncodingIEEE754,
 794      eFormatFloat,
 795      {LLDB_INVALID_REGNUM, dwarf_d12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 796       LLDB_INVALID_REGNUM},
 797      nullptr,
 798      nullptr,
 799      nullptr,
 800      0},
 801     {"d13",
 802      nullptr,
 803      8,
 804      0,
 805      eEncodingIEEE754,
 806      eFormatFloat,
 807      {LLDB_INVALID_REGNUM, dwarf_d13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 808       LLDB_INVALID_REGNUM},
 809      nullptr,
 810      nullptr,
 811      nullptr,
 812      0},
 813     {"d14",
 814      nullptr,
 815      8,
 816      0,
 817      eEncodingIEEE754,
 818      eFormatFloat,
 819      {LLDB_INVALID_REGNUM, dwarf_d14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 820       LLDB_INVALID_REGNUM},
 821      nullptr,
 822      nullptr,
 823      nullptr,
 824      0},
 825     {"d15",
 826      nullptr,
 827      8,
 828      0,
 829      eEncodingIEEE754,
 830      eFormatFloat,
 831      {LLDB_INVALID_REGNUM, dwarf_d15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 832       LLDB_INVALID_REGNUM},
 833      nullptr,
 834      nullptr,
 835      nullptr,
 836      0},
 837     {"d16",
 838      nullptr,
 839      8,
 840      0,
 841      eEncodingIEEE754,
 842      eFormatFloat,
 843      {LLDB_INVALID_REGNUM, dwarf_d16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 844       LLDB_INVALID_REGNUM},
 845      nullptr,
 846      nullptr,
 847      nullptr,
 848      0},
 849     {"d17",
 850      nullptr,
 851      8,
 852      0,
 853      eEncodingIEEE754,
 854      eFormatFloat,
 855      {LLDB_INVALID_REGNUM, dwarf_d17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 856       LLDB_INVALID_REGNUM},
 857      nullptr,
 858      nullptr,
 859      nullptr,
 860      0},
 861     {"d18",
 862      nullptr,
 863      8,
 864      0,
 865      eEncodingIEEE754,
 866      eFormatFloat,
 867      {LLDB_INVALID_REGNUM, dwarf_d18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 868       LLDB_INVALID_REGNUM},
 869      nullptr,
 870      nullptr,
 871      nullptr,
 872      0},
 873     {"d19",
 874      nullptr,
 875      8,
 876      0,
 877      eEncodingIEEE754,
 878      eFormatFloat,
 879      {LLDB_INVALID_REGNUM, dwarf_d19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 880       LLDB_INVALID_REGNUM},
 881      nullptr,
 882      nullptr,
 883      nullptr,
 884      0},
 885     {"d20",
 886      nullptr,
 887      8,
 888      0,
 889      eEncodingIEEE754,
 890      eFormatFloat,
 891      {LLDB_INVALID_REGNUM, dwarf_d20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 892       LLDB_INVALID_REGNUM},
 893      nullptr,
 894      nullptr,
 895      nullptr,
 896      0},
 897     {"d21",
 898      nullptr,
 899      8,
 900      0,
 901      eEncodingIEEE754,
 902      eFormatFloat,
 903      {LLDB_INVALID_REGNUM, dwarf_d21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 904       LLDB_INVALID_REGNUM},
 905      nullptr,
 906      nullptr,
 907      nullptr,
 908      0},
 909     {"d22",
 910      nullptr,
 911      8,
 912      0,
 913      eEncodingIEEE754,
 914      eFormatFloat,
 915      {LLDB_INVALID_REGNUM, dwarf_d22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 916       LLDB_INVALID_REGNUM},
 917      nullptr,
 918      nullptr,
 919      nullptr,
 920      0},
 921     {"d23",
 922      nullptr,
 923      8,
 924      0,
 925      eEncodingIEEE754,
 926      eFormatFloat,
 927      {LLDB_INVALID_REGNUM, dwarf_d23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 928       LLDB_INVALID_REGNUM},
 929      nullptr,
 930      nullptr,
 931      nullptr,
 932      0},
 933     {"d24",
 934      nullptr,
 935      8,
 936      0,
 937      eEncodingIEEE754,
 938      eFormatFloat,
 939      {LLDB_INVALID_REGNUM, dwarf_d24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 940       LLDB_INVALID_REGNUM},
 941      nullptr,
 942      nullptr,
 943      nullptr,
 944      0},
 945     {"d25",
 946      nullptr,
 947      8,
 948      0,
 949      eEncodingIEEE754,
 950      eFormatFloat,
 951      {LLDB_INVALID_REGNUM, dwarf_d25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 952       LLDB_INVALID_REGNUM},
 953      nullptr,
 954      nullptr,
 955      nullptr,
 956      0},
 957     {"d26",
 958      nullptr,
 959      8,
 960      0,
 961      eEncodingIEEE754,
 962      eFormatFloat,
 963      {LLDB_INVALID_REGNUM, dwarf_d26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 964       LLDB_INVALID_REGNUM},
 965      nullptr,
 966      nullptr,
 967      nullptr,
 968      0},
 969     {"d27",
 970      nullptr,
 971      8,
 972      0,
 973      eEncodingIEEE754,
 974      eFormatFloat,
 975      {LLDB_INVALID_REGNUM, dwarf_d27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 976       LLDB_INVALID_REGNUM},
 977      nullptr,
 978      nullptr,
 979      nullptr,
 980      0},
 981     {"d28",
 982      nullptr,
 983      8,
 984      0,
 985      eEncodingIEEE754,
 986      eFormatFloat,
 987      {LLDB_INVALID_REGNUM, dwarf_d28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
 988       LLDB_INVALID_REGNUM},
 989      nullptr,
 990      nullptr,
 991      nullptr,
 992      0},
 993     {"d29",
 994      nullptr,
 995      8,
 996      0,
 997      eEncodingIEEE754,
 998      eFormatFloat,
 999      {LLDB_INVALID_REGNUM, dwarf_d29, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1000       LLDB_INVALID_REGNUM},
1001      nullptr,
1002      nullptr,
1003      nullptr,
1004      0},
1005     {"d30",
1006      nullptr,
1007      8,
1008      0,
1009      eEncodingIEEE754,
1010      eFormatFloat,
1011      {LLDB_INVALID_REGNUM, dwarf_d30, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1012       LLDB_INVALID_REGNUM},
1013      nullptr,
1014      nullptr,
1015      nullptr,
1016      0},
1017     {"d31",
1018      nullptr,
1019      8,
1020      0,
1021      eEncodingIEEE754,
1022      eFormatFloat,
1023      {LLDB_INVALID_REGNUM, dwarf_d31, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1024       LLDB_INVALID_REGNUM},
1025      nullptr,
1026      nullptr,
1027      nullptr,
1028      0},
1029     {"r8_usr",
1030      nullptr,
1031      4,
1032      0,
1033      eEncodingUint,
1034      eFormatHex,
1035      {LLDB_INVALID_REGNUM, dwarf_r8_usr, LLDB_INVALID_REGNUM,
1036       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1037      nullptr,
1038      nullptr,
1039      nullptr,
1040      0},
1041     {"r9_usr",
1042      nullptr,
1043      4,
1044      0,
1045      eEncodingUint,
1046      eFormatHex,
1047      {LLDB_INVALID_REGNUM, dwarf_r9_usr, LLDB_INVALID_REGNUM,
1048       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1049      nullptr,
1050      nullptr,
1051      nullptr,
1052      0},
1053     {"r10_usr",
1054      nullptr,
1055      4,
1056      0,
1057      eEncodingUint,
1058      eFormatHex,
1059      {LLDB_INVALID_REGNUM, dwarf_r10_usr, LLDB_INVALID_REGNUM,
1060       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1061      nullptr,
1062      nullptr,
1063      nullptr,
1064      0},
1065     {"r11_usr",
1066      nullptr,
1067      4,
1068      0,
1069      eEncodingUint,
1070      eFormatHex,
1071      {LLDB_INVALID_REGNUM, dwarf_r11_usr, LLDB_INVALID_REGNUM,
1072       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1073      nullptr,
1074      nullptr,
1075      nullptr,
1076      0},
1077     {"r12_usr",
1078      nullptr,
1079      4,
1080      0,
1081      eEncodingUint,
1082      eFormatHex,
1083      {LLDB_INVALID_REGNUM, dwarf_r12_usr, LLDB_INVALID_REGNUM,
1084       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1085      nullptr,
1086      nullptr,
1087      nullptr,
1088      0},
1089     {"r13_usr",
1090      "sp_usr",
1091      4,
1092      0,
1093      eEncodingUint,
1094      eFormatHex,
1095      {LLDB_INVALID_REGNUM, dwarf_r13_usr, LLDB_INVALID_REGNUM,
1096       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1097      nullptr,
1098      nullptr,
1099      nullptr,
1100      0},
1101     {"r14_usr",
1102      "lr_usr",
1103      4,
1104      0,
1105      eEncodingUint,
1106      eFormatHex,
1107      {LLDB_INVALID_REGNUM, dwarf_r14_usr, LLDB_INVALID_REGNUM,
1108       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1109      nullptr,
1110      nullptr,
1111      nullptr,
1112      0},
1113     {"r8_fiq",
1114      nullptr,
1115      4,
1116      0,
1117      eEncodingUint,
1118      eFormatHex,
1119      {LLDB_INVALID_REGNUM, dwarf_r8_fiq, LLDB_INVALID_REGNUM,
1120       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1121      nullptr,
1122      nullptr,
1123      nullptr,
1124      0},
1125     {"r9_fiq",
1126      nullptr,
1127      4,
1128      0,
1129      eEncodingUint,
1130      eFormatHex,
1131      {LLDB_INVALID_REGNUM, dwarf_r9_fiq, LLDB_INVALID_REGNUM,
1132       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1133      nullptr,
1134      nullptr,
1135      nullptr,
1136      0},
1137     {"r10_fiq",
1138      nullptr,
1139      4,
1140      0,
1141      eEncodingUint,
1142      eFormatHex,
1143      {LLDB_INVALID_REGNUM, dwarf_r10_fiq, LLDB_INVALID_REGNUM,
1144       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1145      nullptr,
1146      nullptr,
1147      nullptr,
1148      0},
1149     {"r11_fiq",
1150      nullptr,
1151      4,
1152      0,
1153      eEncodingUint,
1154      eFormatHex,
1155      {LLDB_INVALID_REGNUM, dwarf_r11_fiq, LLDB_INVALID_REGNUM,
1156       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1157      nullptr,
1158      nullptr,
1159      nullptr,
1160      0},
1161     {"r12_fiq",
1162      nullptr,
1163      4,
1164      0,
1165      eEncodingUint,
1166      eFormatHex,
1167      {LLDB_INVALID_REGNUM, dwarf_r12_fiq, LLDB_INVALID_REGNUM,
1168       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1169      nullptr,
1170      nullptr,
1171      nullptr,
1172      0},
1173     {"r13_fiq",
1174      "sp_fiq",
1175      4,
1176      0,
1177      eEncodingUint,
1178      eFormatHex,
1179      {LLDB_INVALID_REGNUM, dwarf_r13_fiq, LLDB_INVALID_REGNUM,
1180       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1181      nullptr,
1182      nullptr,
1183      nullptr,
1184      0},
1185     {"r14_fiq",
1186      "lr_fiq",
1187      4,
1188      0,
1189      eEncodingUint,
1190      eFormatHex,
1191      {LLDB_INVALID_REGNUM, dwarf_r14_fiq, LLDB_INVALID_REGNUM,
1192       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1193      nullptr,
1194      nullptr,
1195      nullptr,
1196      0},
1197     {"r13_irq",
1198      "sp_irq",
1199      4,
1200      0,
1201      eEncodingUint,
1202      eFormatHex,
1203      {LLDB_INVALID_REGNUM, dwarf_r13_irq, LLDB_INVALID_REGNUM,
1204       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1205      nullptr,
1206      nullptr,
1207      nullptr,
1208      0},
1209     {"r14_irq",
1210      "lr_irq",
1211      4,
1212      0,
1213      eEncodingUint,
1214      eFormatHex,
1215      {LLDB_INVALID_REGNUM, dwarf_r14_irq, LLDB_INVALID_REGNUM,
1216       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1217      nullptr,
1218      nullptr,
1219      nullptr,
1220      0},
1221     {"r13_abt",
1222      "sp_abt",
1223      4,
1224      0,
1225      eEncodingUint,
1226      eFormatHex,
1227      {LLDB_INVALID_REGNUM, dwarf_r13_abt, LLDB_INVALID_REGNUM,
1228       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1229      nullptr,
1230      nullptr,
1231      nullptr,
1232      0},
1233     {"r14_abt",
1234      "lr_abt",
1235      4,
1236      0,
1237      eEncodingUint,
1238      eFormatHex,
1239      {LLDB_INVALID_REGNUM, dwarf_r14_abt, LLDB_INVALID_REGNUM,
1240       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1241      nullptr,
1242      nullptr,
1243      nullptr,
1244      0},
1245     {"r13_und",
1246      "sp_und",
1247      4,
1248      0,
1249      eEncodingUint,
1250      eFormatHex,
1251      {LLDB_INVALID_REGNUM, dwarf_r13_und, LLDB_INVALID_REGNUM,
1252       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1253      nullptr,
1254      nullptr,
1255      nullptr,
1256      0},
1257     {"r14_und",
1258      "lr_und",
1259      4,
1260      0,
1261      eEncodingUint,
1262      eFormatHex,
1263      {LLDB_INVALID_REGNUM, dwarf_r14_und, LLDB_INVALID_REGNUM,
1264       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1265      nullptr,
1266      nullptr,
1267      nullptr,
1268      0},
1269     {"r13_svc",
1270      "sp_svc",
1271      4,
1272      0,
1273      eEncodingUint,
1274      eFormatHex,
1275      {LLDB_INVALID_REGNUM, dwarf_r13_svc, LLDB_INVALID_REGNUM,
1276       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1277      nullptr,
1278      nullptr,
1279      nullptr,
1280      0},
1281     {"r14_svc",
1282      "lr_svc",
1283      4,
1284      0,
1285      eEncodingUint,
1286      eFormatHex,
1287      {LLDB_INVALID_REGNUM, dwarf_r14_svc, LLDB_INVALID_REGNUM,
1288       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1289      nullptr,
1290      nullptr,
1291      nullptr,
1292      0}};
1293
1294 static const uint32_t k_num_register_infos =
1295     llvm::array_lengthof(g_register_infos);
1296 static bool g_register_info_names_constified = false;
1297
1298 const lldb_private::RegisterInfo *
1299 ABIMacOSX_arm::GetRegisterInfoArray(uint32_t &count) {
1300   // Make the C-string names and alt_names for the register infos into const
1301   // C-string values by having the ConstString unique the names in the global
1302   // constant C-string pool.
1303   if (!g_register_info_names_constified) {
1304     g_register_info_names_constified = true;
1305     for (uint32_t i = 0; i < k_num_register_infos; ++i) {
1306       if (g_register_infos[i].name)
1307         g_register_infos[i].name =
1308             ConstString(g_register_infos[i].name).GetCString();
1309       if (g_register_infos[i].alt_name)
1310         g_register_infos[i].alt_name =
1311             ConstString(g_register_infos[i].alt_name).GetCString();
1312     }
1313   }
1314   count = k_num_register_infos;
1315   return g_register_infos;
1316 }
1317
1318 size_t ABIMacOSX_arm::GetRedZoneSize() const { return 0; }
1319
1320 //------------------------------------------------------------------
1321 // Static Functions
1322 //------------------------------------------------------------------
1323
1324 ABISP
1325 ABIMacOSX_arm::CreateInstance(ProcessSP process_sp, const ArchSpec &arch) {
1326   const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch();
1327   const llvm::Triple::VendorType vendor_type = arch.GetTriple().getVendor();
1328
1329   if (vendor_type == llvm::Triple::Apple) {
1330     if ((arch_type == llvm::Triple::arm) ||
1331         (arch_type == llvm::Triple::thumb)) {
1332       return ABISP(new ABIMacOSX_arm(process_sp));
1333     }
1334   }
1335
1336   return ABISP();
1337 }
1338
1339 bool ABIMacOSX_arm::PrepareTrivialCall(Thread &thread, addr_t sp,
1340                                        addr_t function_addr, addr_t return_addr,
1341                                        llvm::ArrayRef<addr_t> args) const {
1342   RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1343   if (!reg_ctx)
1344     return false;
1345
1346   const uint32_t pc_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1347       eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
1348   const uint32_t sp_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1349       eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
1350   const uint32_t ra_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1351       eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA);
1352
1353   RegisterValue reg_value;
1354
1355   const char *reg_names[] = {"r0", "r1", "r2", "r3"};
1356
1357   llvm::ArrayRef<addr_t>::iterator ai = args.begin(), ae = args.end();
1358
1359   for (size_t i = 0; i < llvm::array_lengthof(reg_names); ++i) {
1360     if (ai == ae)
1361       break;
1362
1363     reg_value.SetUInt32(*ai);
1364     if (!reg_ctx->WriteRegister(reg_ctx->GetRegisterInfoByName(reg_names[i]),
1365                                 reg_value))
1366       return false;
1367
1368     ++ai;
1369   }
1370
1371   if (ai != ae) {
1372     // Spill onto the stack
1373     size_t num_stack_regs = ae - ai;
1374
1375     sp -= (num_stack_regs * 4);
1376     // Keep the stack 16 byte aligned
1377     sp &= ~(16ull - 1ull);
1378
1379     // just using arg1 to get the right size
1380     const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
1381         eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
1382
1383     addr_t arg_pos = sp;
1384
1385     for (; ai != ae; ++ai) {
1386       reg_value.SetUInt32(*ai);
1387       if (reg_ctx
1388               ->WriteRegisterValueToMemory(reg_info, arg_pos,
1389                                            reg_info->byte_size, reg_value)
1390               .Fail())
1391         return false;
1392       arg_pos += reg_info->byte_size;
1393     }
1394   }
1395
1396   TargetSP target_sp(thread.CalculateTarget());
1397   Address so_addr;
1398
1399   // Figure out if our return address is ARM or Thumb by using the
1400   // Address::GetCallableLoadAddress(Target*) which will figure out the ARM
1401   // thumb-ness and set the correct address bits for us.
1402   so_addr.SetLoadAddress(return_addr, target_sp.get());
1403   return_addr = so_addr.GetCallableLoadAddress(target_sp.get());
1404
1405   // Set "lr" to the return address
1406   if (!reg_ctx->WriteRegisterFromUnsigned(ra_reg_num, return_addr))
1407     return false;
1408
1409   // If bit zero or 1 is set, this must be a thumb function, no need to figure
1410   // this out from the symbols.
1411   so_addr.SetLoadAddress(function_addr, target_sp.get());
1412   function_addr = so_addr.GetCallableLoadAddress(target_sp.get());
1413
1414   const RegisterInfo *cpsr_reg_info = reg_ctx->GetRegisterInfoByName("cpsr");
1415   const uint32_t curr_cpsr = reg_ctx->ReadRegisterAsUnsigned(cpsr_reg_info, 0);
1416
1417   // Make a new CPSR and mask out any Thumb IT (if/then) bits
1418   uint32_t new_cpsr = curr_cpsr & ~MASK_CPSR_IT_MASK;
1419   // If bit zero or 1 is set, this must be thumb...
1420   if (function_addr & 1ull)
1421     new_cpsr |= MASK_CPSR_T; // Set T bit in CPSR
1422   else
1423     new_cpsr &= ~MASK_CPSR_T; // Clear T bit in CPSR
1424
1425   if (new_cpsr != curr_cpsr) {
1426     if (!reg_ctx->WriteRegisterFromUnsigned(cpsr_reg_info, new_cpsr))
1427       return false;
1428   }
1429
1430   function_addr &=
1431       ~1ull; // clear bit zero since the CPSR will take care of the mode for us
1432
1433   // Update the sp - stack pointer - to be aligned to 16-bytes
1434   sp &= ~(0xfull);
1435   if (!reg_ctx->WriteRegisterFromUnsigned(sp_reg_num, sp))
1436     return false;
1437
1438   // Set "pc" to the address requested
1439   if (!reg_ctx->WriteRegisterFromUnsigned(pc_reg_num, function_addr))
1440     return false;
1441
1442   return true;
1443 }
1444
1445 bool ABIMacOSX_arm::GetArgumentValues(Thread &thread, ValueList &values) const {
1446   uint32_t num_values = values.GetSize();
1447
1448   ExecutionContext exe_ctx(thread.shared_from_this());
1449   // For now, assume that the types in the AST values come from the Target's
1450   // scratch AST.
1451
1452   // Extract the register context so we can read arguments from registers
1453
1454   RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1455
1456   if (!reg_ctx)
1457     return false;
1458
1459   addr_t sp = 0;
1460
1461   for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) {
1462     // We currently only support extracting values with Clang QualTypes. Do we
1463     // care about others?
1464     Value *value = values.GetValueAtIndex(value_idx);
1465
1466     if (!value)
1467       return false;
1468
1469     CompilerType compiler_type = value->GetCompilerType();
1470     if (compiler_type) {
1471       bool is_signed = false;
1472       size_t bit_width = 0;
1473       llvm::Optional<uint64_t> bit_size = compiler_type.GetBitSize(&thread);
1474       if (!bit_size)
1475         return false;
1476       if (compiler_type.IsIntegerOrEnumerationType(is_signed))
1477         bit_width = *bit_size;
1478       else if (compiler_type.IsPointerOrReferenceType())
1479         bit_width = *bit_size;
1480       else
1481         // We only handle integer, pointer and reference types currently...
1482         return false;
1483
1484       if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) {
1485         if (value_idx < 4) {
1486           // Arguments 1-4 are in r0-r3...
1487           const RegisterInfo *arg_reg_info = nullptr;
1488           // Search by generic ID first, then fall back to by name
1489           uint32_t arg_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1490               eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + value_idx);
1491           if (arg_reg_num != LLDB_INVALID_REGNUM) {
1492             arg_reg_info = reg_ctx->GetRegisterInfoAtIndex(arg_reg_num);
1493           } else {
1494             switch (value_idx) {
1495             case 0:
1496               arg_reg_info = reg_ctx->GetRegisterInfoByName("r0");
1497               break;
1498             case 1:
1499               arg_reg_info = reg_ctx->GetRegisterInfoByName("r1");
1500               break;
1501             case 2:
1502               arg_reg_info = reg_ctx->GetRegisterInfoByName("r2");
1503               break;
1504             case 3:
1505               arg_reg_info = reg_ctx->GetRegisterInfoByName("r3");
1506               break;
1507             }
1508           }
1509
1510           if (arg_reg_info) {
1511             RegisterValue reg_value;
1512
1513             if (reg_ctx->ReadRegister(arg_reg_info, reg_value)) {
1514               if (is_signed)
1515                 reg_value.SignExtend(bit_width);
1516               if (!reg_value.GetScalarValue(value->GetScalar()))
1517                 return false;
1518               continue;
1519             }
1520           }
1521           return false;
1522         } else {
1523           if (sp == 0) {
1524             // Read the stack pointer if it already hasn't been read
1525             sp = reg_ctx->GetSP(0);
1526             if (sp == 0)
1527               return false;
1528           }
1529
1530           // Arguments 5 on up are on the stack
1531           const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8;
1532           Status error;
1533           if (!exe_ctx.GetProcessRef().ReadScalarIntegerFromMemory(
1534                   sp, arg_byte_size, is_signed, value->GetScalar(), error))
1535             return false;
1536
1537           sp += arg_byte_size;
1538         }
1539       }
1540     }
1541   }
1542   return true;
1543 }
1544
1545 bool ABIMacOSX_arm::IsArmv7kProcess() const {
1546   bool is_armv7k = false;
1547   ProcessSP process_sp(GetProcessSP());
1548   if (process_sp) {
1549     const ArchSpec &arch(process_sp->GetTarget().GetArchitecture());
1550     const ArchSpec::Core system_core = arch.GetCore();
1551     if (system_core == ArchSpec::eCore_arm_armv7k) {
1552       is_armv7k = true;
1553     }
1554   }
1555   return is_armv7k;
1556 }
1557
1558 ValueObjectSP ABIMacOSX_arm::GetReturnValueObjectImpl(
1559     Thread &thread, lldb_private::CompilerType &compiler_type) const {
1560   Value value;
1561   ValueObjectSP return_valobj_sp;
1562
1563   if (!compiler_type)
1564     return return_valobj_sp;
1565
1566   value.SetCompilerType(compiler_type);
1567
1568   RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1569   if (!reg_ctx)
1570     return return_valobj_sp;
1571
1572   bool is_signed;
1573
1574   // Get the pointer to the first stack argument so we have a place to start
1575   // when reading data
1576
1577   const RegisterInfo *r0_reg_info = reg_ctx->GetRegisterInfoByName("r0", 0);
1578   if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
1579     llvm::Optional<uint64_t> bit_width = compiler_type.GetBitSize(&thread);
1580     if (!bit_width)
1581       return return_valobj_sp;
1582
1583     switch (*bit_width) {
1584     default:
1585       return return_valobj_sp;
1586     case 128:
1587       if (IsArmv7kProcess()) {
1588         // "A composite type not larger than 16 bytes is returned in r0-r3. The
1589         // format is as if the result had been stored in memory at a word-
1590         // aligned address and then loaded into r0-r3 with an ldm instruction"
1591         {
1592           const RegisterInfo *r1_reg_info =
1593               reg_ctx->GetRegisterInfoByName("r1", 0);
1594           const RegisterInfo *r2_reg_info =
1595               reg_ctx->GetRegisterInfoByName("r2", 0);
1596           const RegisterInfo *r3_reg_info =
1597               reg_ctx->GetRegisterInfoByName("r3", 0);
1598           if (r1_reg_info && r2_reg_info && r3_reg_info) {
1599             llvm::Optional<uint64_t> byte_size =
1600                 compiler_type.GetByteSize(&thread);
1601             if (!byte_size)
1602               return return_valobj_sp;
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; }