contrib/llvm/tools/lldb/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp

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