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

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