1 //===-- ABIMacOSX_arm.cpp -------------------------------------------------===// 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 const 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 1296 const lldb_private::RegisterInfo * 1297 ABIMacOSX_arm::GetRegisterInfoArray(uint32_t &count) { 1298 count = k_num_register_infos; 1299 return g_register_infos; 1300 } 1301 1302 size_t ABIMacOSX_arm::GetRedZoneSize() const { return 0; } 1303 1304 // Static Functions 1305 1306 ABISP 1307 ABIMacOSX_arm::CreateInstance(ProcessSP process_sp, const ArchSpec &arch) { 1308 const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch(); 1309 const llvm::Triple::VendorType vendor_type = arch.GetTriple().getVendor(); 1310 1311 if (vendor_type == llvm::Triple::Apple) { 1312 if ((arch_type == llvm::Triple::arm) || 1313 (arch_type == llvm::Triple::thumb)) { 1314 return ABISP( 1315 new ABIMacOSX_arm(std::move(process_sp), MakeMCRegisterInfo(arch))); 1316 } 1317 } 1318 1319 return ABISP(); 1320 } 1321 1322 bool ABIMacOSX_arm::PrepareTrivialCall(Thread &thread, addr_t sp, 1323 addr_t function_addr, addr_t return_addr, 1324 llvm::ArrayRef<addr_t> args) const { 1325 RegisterContext *reg_ctx = thread.GetRegisterContext().get(); 1326 if (!reg_ctx) 1327 return false; 1328 1329 const uint32_t pc_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber( 1330 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); 1331 const uint32_t sp_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber( 1332 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP); 1333 const uint32_t ra_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber( 1334 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA); 1335 1336 RegisterValue reg_value; 1337 1338 const char *reg_names[] = {"r0", "r1", "r2", "r3"}; 1339 1340 llvm::ArrayRef<addr_t>::iterator ai = args.begin(), ae = args.end(); 1341 1342 for (size_t i = 0; i < llvm::array_lengthof(reg_names); ++i) { 1343 if (ai == ae) 1344 break; 1345 1346 reg_value.SetUInt32(*ai); 1347 if (!reg_ctx->WriteRegister(reg_ctx->GetRegisterInfoByName(reg_names[i]), 1348 reg_value)) 1349 return false; 1350 1351 ++ai; 1352 } 1353 1354 if (ai != ae) { 1355 // Spill onto the stack 1356 size_t num_stack_regs = ae - ai; 1357 1358 sp -= (num_stack_regs * 4); 1359 // Keep the stack 16 byte aligned 1360 sp &= ~(16ull - 1ull); 1361 1362 // just using arg1 to get the right size 1363 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo( 1364 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1); 1365 1366 addr_t arg_pos = sp; 1367 1368 for (; ai != ae; ++ai) { 1369 reg_value.SetUInt32(*ai); 1370 if (reg_ctx 1371 ->WriteRegisterValueToMemory(reg_info, arg_pos, 1372 reg_info->byte_size, reg_value) 1373 .Fail()) 1374 return false; 1375 arg_pos += reg_info->byte_size; 1376 } 1377 } 1378 1379 TargetSP target_sp(thread.CalculateTarget()); 1380 Address so_addr; 1381 1382 // Figure out if our return address is ARM or Thumb by using the 1383 // Address::GetCallableLoadAddress(Target*) which will figure out the ARM 1384 // thumb-ness and set the correct address bits for us. 1385 so_addr.SetLoadAddress(return_addr, target_sp.get()); 1386 return_addr = so_addr.GetCallableLoadAddress(target_sp.get()); 1387 1388 // Set "lr" to the return address 1389 if (!reg_ctx->WriteRegisterFromUnsigned(ra_reg_num, return_addr)) 1390 return false; 1391 1392 // If bit zero or 1 is set, this must be a thumb function, no need to figure 1393 // this out from the symbols. 1394 so_addr.SetLoadAddress(function_addr, target_sp.get()); 1395 function_addr = so_addr.GetCallableLoadAddress(target_sp.get()); 1396 1397 const RegisterInfo *cpsr_reg_info = reg_ctx->GetRegisterInfoByName("cpsr"); 1398 const uint32_t curr_cpsr = reg_ctx->ReadRegisterAsUnsigned(cpsr_reg_info, 0); 1399 1400 // Make a new CPSR and mask out any Thumb IT (if/then) bits 1401 uint32_t new_cpsr = curr_cpsr & ~MASK_CPSR_IT_MASK; 1402 // If bit zero or 1 is set, this must be thumb... 1403 if (function_addr & 1ull) 1404 new_cpsr |= MASK_CPSR_T; // Set T bit in CPSR 1405 else 1406 new_cpsr &= ~MASK_CPSR_T; // Clear T bit in CPSR 1407 1408 if (new_cpsr != curr_cpsr) { 1409 if (!reg_ctx->WriteRegisterFromUnsigned(cpsr_reg_info, new_cpsr)) 1410 return false; 1411 } 1412 1413 function_addr &= 1414 ~1ull; // clear bit zero since the CPSR will take care of the mode for us 1415 1416 // Update the sp - stack pointer - to be aligned to 16-bytes 1417 sp &= ~(0xfull); 1418 if (!reg_ctx->WriteRegisterFromUnsigned(sp_reg_num, sp)) 1419 return false; 1420 1421 // Set "pc" to the address requested 1422 if (!reg_ctx->WriteRegisterFromUnsigned(pc_reg_num, function_addr)) 1423 return false; 1424 1425 return true; 1426 } 1427 1428 bool ABIMacOSX_arm::GetArgumentValues(Thread &thread, ValueList &values) const { 1429 uint32_t num_values = values.GetSize(); 1430 1431 ExecutionContext exe_ctx(thread.shared_from_this()); 1432 // For now, assume that the types in the AST values come from the Target's 1433 // scratch AST. 1434 1435 // Extract the register context so we can read arguments from registers 1436 1437 RegisterContext *reg_ctx = thread.GetRegisterContext().get(); 1438 1439 if (!reg_ctx) 1440 return false; 1441 1442 addr_t sp = 0; 1443 1444 for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) { 1445 // We currently only support extracting values with Clang QualTypes. Do we 1446 // care about others? 1447 Value *value = values.GetValueAtIndex(value_idx); 1448 1449 if (!value) 1450 return false; 1451 1452 CompilerType compiler_type = value->GetCompilerType(); 1453 if (compiler_type) { 1454 bool is_signed = false; 1455 size_t bit_width = 0; 1456 llvm::Optional<uint64_t> bit_size = compiler_type.GetBitSize(&thread); 1457 if (!bit_size) 1458 return false; 1459 if (compiler_type.IsIntegerOrEnumerationType(is_signed)) 1460 bit_width = *bit_size; 1461 else if (compiler_type.IsPointerOrReferenceType()) 1462 bit_width = *bit_size; 1463 else 1464 // We only handle integer, pointer and reference types currently... 1465 return false; 1466 1467 if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) { 1468 if (value_idx < 4) { 1469 // Arguments 1-4 are in r0-r3... 1470 const RegisterInfo *arg_reg_info = nullptr; 1471 // Search by generic ID first, then fall back to by name 1472 uint32_t arg_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber( 1473 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + value_idx); 1474 if (arg_reg_num != LLDB_INVALID_REGNUM) { 1475 arg_reg_info = reg_ctx->GetRegisterInfoAtIndex(arg_reg_num); 1476 } else { 1477 switch (value_idx) { 1478 case 0: 1479 arg_reg_info = reg_ctx->GetRegisterInfoByName("r0"); 1480 break; 1481 case 1: 1482 arg_reg_info = reg_ctx->GetRegisterInfoByName("r1"); 1483 break; 1484 case 2: 1485 arg_reg_info = reg_ctx->GetRegisterInfoByName("r2"); 1486 break; 1487 case 3: 1488 arg_reg_info = reg_ctx->GetRegisterInfoByName("r3"); 1489 break; 1490 } 1491 } 1492 1493 if (arg_reg_info) { 1494 RegisterValue reg_value; 1495 1496 if (reg_ctx->ReadRegister(arg_reg_info, reg_value)) { 1497 if (is_signed) 1498 reg_value.SignExtend(bit_width); 1499 if (!reg_value.GetScalarValue(value->GetScalar())) 1500 return false; 1501 continue; 1502 } 1503 } 1504 return false; 1505 } else { 1506 if (sp == 0) { 1507 // Read the stack pointer if it already hasn't been read 1508 sp = reg_ctx->GetSP(0); 1509 if (sp == 0) 1510 return false; 1511 } 1512 1513 // Arguments 5 on up are on the stack 1514 const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8; 1515 Status error; 1516 if (!exe_ctx.GetProcessRef().ReadScalarIntegerFromMemory( 1517 sp, arg_byte_size, is_signed, value->GetScalar(), error)) 1518 return false; 1519 1520 sp += arg_byte_size; 1521 } 1522 } 1523 } 1524 } 1525 return true; 1526 } 1527 1528 bool ABIMacOSX_arm::IsArmv7kProcess() const { 1529 bool is_armv7k = false; 1530 ProcessSP process_sp(GetProcessSP()); 1531 if (process_sp) { 1532 const ArchSpec &arch(process_sp->GetTarget().GetArchitecture()); 1533 const ArchSpec::Core system_core = arch.GetCore(); 1534 if (system_core == ArchSpec::eCore_arm_armv7k) { 1535 is_armv7k = true; 1536 } 1537 } 1538 return is_armv7k; 1539 } 1540 1541 ValueObjectSP ABIMacOSX_arm::GetReturnValueObjectImpl( 1542 Thread &thread, lldb_private::CompilerType &compiler_type) const { 1543 Value value; 1544 ValueObjectSP return_valobj_sp; 1545 1546 if (!compiler_type) 1547 return return_valobj_sp; 1548 1549 value.SetCompilerType(compiler_type); 1550 1551 RegisterContext *reg_ctx = thread.GetRegisterContext().get(); 1552 if (!reg_ctx) 1553 return return_valobj_sp; 1554 1555 bool is_signed; 1556 1557 // Get the pointer to the first stack argument so we have a place to start 1558 // when reading data 1559 1560 const RegisterInfo *r0_reg_info = reg_ctx->GetRegisterInfoByName("r0", 0); 1561 if (compiler_type.IsIntegerOrEnumerationType(is_signed)) { 1562 llvm::Optional<uint64_t> bit_width = compiler_type.GetBitSize(&thread); 1563 if (!bit_width) 1564 return return_valobj_sp; 1565 1566 switch (*bit_width) { 1567 default: 1568 return return_valobj_sp; 1569 case 128: 1570 if (IsArmv7kProcess()) { 1571 // "A composite type not larger than 16 bytes is returned in r0-r3. The 1572 // format is as if the result had been stored in memory at a word- 1573 // aligned address and then loaded into r0-r3 with an ldm instruction" 1574 { 1575 const RegisterInfo *r1_reg_info = 1576 reg_ctx->GetRegisterInfoByName("r1", 0); 1577 const RegisterInfo *r2_reg_info = 1578 reg_ctx->GetRegisterInfoByName("r2", 0); 1579 const RegisterInfo *r3_reg_info = 1580 reg_ctx->GetRegisterInfoByName("r3", 0); 1581 if (r1_reg_info && r2_reg_info && r3_reg_info) { 1582 llvm::Optional<uint64_t> byte_size = 1583 compiler_type.GetByteSize(&thread); 1584 if (!byte_size) 1585 return return_valobj_sp; 1586 ProcessSP process_sp(thread.GetProcess()); 1587 if (*byte_size <= r0_reg_info->byte_size + r1_reg_info->byte_size + 1588 r2_reg_info->byte_size + 1589 r3_reg_info->byte_size && 1590 process_sp) { 1591 std::unique_ptr<DataBufferHeap> heap_data_up( 1592 new DataBufferHeap(*byte_size, 0)); 1593 const ByteOrder byte_order = process_sp->GetByteOrder(); 1594 RegisterValue r0_reg_value; 1595 RegisterValue r1_reg_value; 1596 RegisterValue r2_reg_value; 1597 RegisterValue r3_reg_value; 1598 if (reg_ctx->ReadRegister(r0_reg_info, r0_reg_value) && 1599 reg_ctx->ReadRegister(r1_reg_info, r1_reg_value) && 1600 reg_ctx->ReadRegister(r2_reg_info, r2_reg_value) && 1601 reg_ctx->ReadRegister(r3_reg_info, r3_reg_value)) { 1602 Status error; 1603 if (r0_reg_value.GetAsMemoryData(r0_reg_info, 1604 heap_data_up->GetBytes() + 0, 1605 4, byte_order, error) && 1606 r1_reg_value.GetAsMemoryData(r1_reg_info, 1607 heap_data_up->GetBytes() + 4, 1608 4, byte_order, error) && 1609 r2_reg_value.GetAsMemoryData(r2_reg_info, 1610 heap_data_up->GetBytes() + 8, 1611 4, byte_order, error) && 1612 r3_reg_value.GetAsMemoryData(r3_reg_info, 1613 heap_data_up->GetBytes() + 12, 1614 4, byte_order, error)) { 1615 DataExtractor data(DataBufferSP(heap_data_up.release()), 1616 byte_order, 1617 process_sp->GetAddressByteSize()); 1618 1619 return_valobj_sp = ValueObjectConstResult::Create( 1620 &thread, compiler_type, ConstString(""), data); 1621 return return_valobj_sp; 1622 } 1623 } 1624 } 1625 } 1626 } 1627 } else { 1628 return return_valobj_sp; 1629 } 1630 break; 1631 case 64: { 1632 const RegisterInfo *r1_reg_info = reg_ctx->GetRegisterInfoByName("r1", 0); 1633 uint64_t raw_value; 1634 raw_value = reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX; 1635 raw_value |= ((uint64_t)(reg_ctx->ReadRegisterAsUnsigned(r1_reg_info, 0) & 1636 UINT32_MAX)) 1637 << 32; 1638 if (is_signed) 1639 value.GetScalar() = (int64_t)raw_value; 1640 else 1641 value.GetScalar() = (uint64_t)raw_value; 1642 } break; 1643 case 32: 1644 if (is_signed) 1645 value.GetScalar() = (int32_t)( 1646 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX); 1647 else 1648 value.GetScalar() = (uint32_t)( 1649 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX); 1650 break; 1651 case 16: 1652 if (is_signed) 1653 value.GetScalar() = (int16_t)( 1654 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT16_MAX); 1655 else 1656 value.GetScalar() = (uint16_t)( 1657 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT16_MAX); 1658 break; 1659 case 8: 1660 if (is_signed) 1661 value.GetScalar() = (int8_t)( 1662 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX); 1663 else 1664 value.GetScalar() = (uint8_t)( 1665 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX); 1666 break; 1667 } 1668 } else if (compiler_type.IsPointerType()) { 1669 uint32_t ptr = 1670 thread.GetRegisterContext()->ReadRegisterAsUnsigned(r0_reg_info, 0) & 1671 UINT32_MAX; 1672 value.GetScalar() = ptr; 1673 } else { 1674 // not handled yet 1675 return return_valobj_sp; 1676 } 1677 1678 // If we get here, we have a valid Value, so make our ValueObject out of it: 1679 1680 return_valobj_sp = ValueObjectConstResult::Create( 1681 thread.GetStackFrameAtIndex(0).get(), value, ConstString("")); 1682 return return_valobj_sp; 1683 } 1684 1685 Status ABIMacOSX_arm::SetReturnValueObject(lldb::StackFrameSP &frame_sp, 1686 lldb::ValueObjectSP &new_value_sp) { 1687 Status error; 1688 if (!new_value_sp) { 1689 error.SetErrorString("Empty value object for return value."); 1690 return error; 1691 } 1692 1693 CompilerType compiler_type = new_value_sp->GetCompilerType(); 1694 if (!compiler_type) { 1695 error.SetErrorString("Null clang type for return value."); 1696 return error; 1697 } 1698 1699 Thread *thread = frame_sp->GetThread().get(); 1700 1701 bool is_signed; 1702 uint32_t count; 1703 bool is_complex; 1704 1705 RegisterContext *reg_ctx = thread->GetRegisterContext().get(); 1706 1707 bool set_it_simple = false; 1708 if (compiler_type.IsIntegerOrEnumerationType(is_signed) || 1709 compiler_type.IsPointerType()) { 1710 DataExtractor data; 1711 Status data_error; 1712 size_t num_bytes = new_value_sp->GetData(data, data_error); 1713 if (data_error.Fail()) { 1714 error.SetErrorStringWithFormat( 1715 "Couldn't convert return value to raw data: %s", 1716 data_error.AsCString()); 1717 return error; 1718 } 1719 lldb::offset_t offset = 0; 1720 if (num_bytes <= 8) { 1721 const RegisterInfo *r0_info = reg_ctx->GetRegisterInfoByName("r0", 0); 1722 if (num_bytes <= 4) { 1723 uint32_t raw_value = data.GetMaxU32(&offset, num_bytes); 1724 1725 if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value)) 1726 set_it_simple = true; 1727 } else { 1728 uint32_t raw_value = data.GetMaxU32(&offset, 4); 1729 1730 if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value)) { 1731 const RegisterInfo *r1_info = reg_ctx->GetRegisterInfoByName("r1", 0); 1732 uint32_t raw_value = data.GetMaxU32(&offset, num_bytes - offset); 1733 1734 if (reg_ctx->WriteRegisterFromUnsigned(r1_info, raw_value)) 1735 set_it_simple = true; 1736 } 1737 } 1738 } else if (num_bytes <= 16 && IsArmv7kProcess()) { 1739 // "A composite type not larger than 16 bytes is returned in r0-r3. The 1740 // format is as if the result had been stored in memory at a word-aligned 1741 // address and then loaded into r0-r3 with an ldm instruction" 1742 1743 const RegisterInfo *r0_info = reg_ctx->GetRegisterInfoByName("r0", 0); 1744 const RegisterInfo *r1_info = reg_ctx->GetRegisterInfoByName("r1", 0); 1745 const RegisterInfo *r2_info = reg_ctx->GetRegisterInfoByName("r2", 0); 1746 const RegisterInfo *r3_info = reg_ctx->GetRegisterInfoByName("r3", 0); 1747 lldb::offset_t offset = 0; 1748 uint32_t bytes_written = 4; 1749 uint32_t raw_value = data.GetMaxU64(&offset, 4); 1750 if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value) && 1751 bytes_written <= num_bytes) { 1752 bytes_written += 4; 1753 raw_value = data.GetMaxU64(&offset, 4); 1754 if (bytes_written <= num_bytes && 1755 reg_ctx->WriteRegisterFromUnsigned(r1_info, raw_value)) { 1756 bytes_written += 4; 1757 raw_value = data.GetMaxU64(&offset, 4); 1758 if (bytes_written <= num_bytes && 1759 reg_ctx->WriteRegisterFromUnsigned(r2_info, raw_value)) { 1760 bytes_written += 4; 1761 raw_value = data.GetMaxU64(&offset, 4); 1762 if (bytes_written <= num_bytes && 1763 reg_ctx->WriteRegisterFromUnsigned(r3_info, raw_value)) { 1764 set_it_simple = true; 1765 } 1766 } 1767 } 1768 } 1769 } else { 1770 error.SetErrorString("We don't support returning longer than 64 bit " 1771 "integer values at present."); 1772 } 1773 } else if (compiler_type.IsFloatingPointType(count, is_complex)) { 1774 if (is_complex) 1775 error.SetErrorString( 1776 "We don't support returning complex values at present"); 1777 else 1778 error.SetErrorString( 1779 "We don't support returning float values at present"); 1780 } 1781 1782 if (!set_it_simple) 1783 error.SetErrorString( 1784 "We only support setting simple integer return types at present."); 1785 1786 return error; 1787 } 1788 1789 bool ABIMacOSX_arm::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) { 1790 unwind_plan.Clear(); 1791 unwind_plan.SetRegisterKind(eRegisterKindDWARF); 1792 1793 uint32_t lr_reg_num = dwarf_lr; 1794 uint32_t sp_reg_num = dwarf_sp; 1795 uint32_t pc_reg_num = dwarf_pc; 1796 1797 UnwindPlan::RowSP row(new UnwindPlan::Row); 1798 1799 // Our Call Frame Address is the stack pointer value 1800 row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0); 1801 1802 // The previous PC is in the LR 1803 row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true); 1804 unwind_plan.AppendRow(row); 1805 1806 // All other registers are the same. 1807 1808 unwind_plan.SetSourceName("arm at-func-entry default"); 1809 unwind_plan.SetSourcedFromCompiler(eLazyBoolNo); 1810 1811 return true; 1812 } 1813 1814 bool ABIMacOSX_arm::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) { 1815 unwind_plan.Clear(); 1816 unwind_plan.SetRegisterKind(eRegisterKindDWARF); 1817 1818 uint32_t fp_reg_num = 1819 dwarf_r7; // apple uses r7 for all frames. Normal arm uses r11 1820 uint32_t pc_reg_num = dwarf_pc; 1821 1822 UnwindPlan::RowSP row(new UnwindPlan::Row); 1823 const int32_t ptr_size = 4; 1824 1825 row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size); 1826 row->SetOffset(0); 1827 1828 row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true); 1829 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true); 1830 1831 unwind_plan.AppendRow(row); 1832 unwind_plan.SetSourceName("arm-apple-ios default unwind plan"); 1833 unwind_plan.SetSourcedFromCompiler(eLazyBoolNo); 1834 unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo); 1835 unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo); 1836 1837 return true; 1838 } 1839 1840 // cf. "ARMv6 Function Calling Conventions" 1841 // https://developer.apple.com/library/ios/documentation/Xcode/Conceptual/iPhoneOSABIReference/Articles/ARMv6FunctionCallingConventions.html 1842 // and "ARMv7 Function Calling Conventions" 1843 // https://developer.apple.com/library/ios/documentation/Xcode/Conceptual/iPhoneOSABIReference/Articles/ARMv7FunctionCallingConventions.html 1844 1845 // ARMv7 on iOS general purpose reg rules: 1846 // r0-r3 not preserved (used for argument passing) 1847 // r4-r6 preserved 1848 // r7 preserved (frame pointer) 1849 // r8 preserved 1850 // r9 not preserved (usable as volatile scratch register with iOS 3.x and 1851 // later) 1852 // r10-r11 preserved 1853 // r12 not presrved 1854 // r13 preserved (stack pointer) 1855 // r14 not preserved (link register) 1856 // r15 preserved (pc) 1857 // cpsr not preserved (different rules for different bits) 1858 1859 // ARMv7 on iOS floating point rules: 1860 // d0-d7 not preserved (aka s0-s15, q0-q3) 1861 // d8-d15 preserved (aka s16-s31, q4-q7) 1862 // d16-d31 not preserved (aka q8-q15) 1863 1864 bool ABIMacOSX_arm::RegisterIsVolatile(const RegisterInfo *reg_info) { 1865 if (reg_info) { 1866 // Volatile registers are: r0, r1, r2, r3, r9, r12, r13 (aka sp) 1867 const char *name = reg_info->name; 1868 if (name[0] == 'r') { 1869 switch (name[1]) { 1870 case '0': 1871 return name[2] == '\0'; // r0 1872 case '1': 1873 switch (name[2]) { 1874 case '\0': 1875 return true; // r1 1876 case '2': 1877 case '3': 1878 return name[3] == '\0'; // r12, r13 (sp) 1879 default: 1880 break; 1881 } 1882 break; 1883 1884 case '2': 1885 return name[2] == '\0'; // r2 1886 case '3': 1887 return name[2] == '\0'; // r3 1888 case '9': 1889 return name[2] == '\0'; // r9 (apple-ios only...) 1890 1891 break; 1892 } 1893 } else if (name[0] == 'd') { 1894 switch (name[1]) { 1895 case '0': 1896 return name[2] == '\0'; // d0 is volatile 1897 1898 case '1': 1899 switch (name[2]) { 1900 case '\0': 1901 return true; // d1 is volatile 1902 case '6': 1903 case '7': 1904 case '8': 1905 case '9': 1906 return name[3] == '\0'; // d16 - d19 are volatile 1907 default: 1908 break; 1909 } 1910 break; 1911 1912 case '2': 1913 switch (name[2]) { 1914 case '\0': 1915 return true; // d2 is volatile 1916 case '0': 1917 case '1': 1918 case '2': 1919 case '3': 1920 case '4': 1921 case '5': 1922 case '6': 1923 case '7': 1924 case '8': 1925 case '9': 1926 return name[3] == '\0'; // d20 - d29 are volatile 1927 default: 1928 break; 1929 } 1930 break; 1931 1932 case '3': 1933 switch (name[2]) { 1934 case '\0': 1935 return true; // d3 is volatile 1936 case '0': 1937 case '1': 1938 return name[3] == '\0'; // d30 - d31 are volatile 1939 default: 1940 break; 1941 } 1942 break; 1943 case '4': 1944 case '5': 1945 case '6': 1946 case '7': 1947 return name[2] == '\0'; // d4 - d7 are volatile 1948 1949 default: 1950 break; 1951 } 1952 } else if (name[0] == 's') { 1953 switch (name[1]) { 1954 case '0': 1955 return name[2] == '\0'; // s0 is volatile 1956 1957 case '1': 1958 switch (name[2]) { 1959 case '\0': 1960 return true; // s1 is volatile 1961 case '0': 1962 case '1': 1963 case '2': 1964 case '3': 1965 case '4': 1966 case '5': 1967 return name[3] == '\0'; // s10 - s15 are volatile 1968 default: 1969 break; 1970 } 1971 break; 1972 1973 case '2': 1974 case '3': 1975 case '4': 1976 case '5': 1977 case '6': 1978 case '7': 1979 case '8': 1980 case '9': 1981 return name[2] == '\0'; // s2 - s9 are volatile 1982 1983 default: 1984 break; 1985 } 1986 } else if (name[0] == 'q') { 1987 switch (name[1]) { 1988 case '1': 1989 switch (name[2]) { 1990 case '\0': 1991 return true; // q1 is volatile 1992 case '0': 1993 case '1': 1994 case '2': 1995 case '3': 1996 case '4': 1997 case '5': 1998 return true; // q10-q15 are volatile 1999 default: 2000 break; 2001 }; 2002 break; 2003 case '0': 2004 case '2': 2005 case '3': 2006 return name[2] == '\0'; // q0-q3 are volatile 2007 case '8': 2008 case '9': 2009 return name[2] == '\0'; // q8-q9 are volatile 2010 default: 2011 break; 2012 } 2013 } else if (name[0] == 's' && name[1] == 'p' && name[2] == '\0') 2014 return true; 2015 } 2016 return false; 2017 } 2018 2019 void ABIMacOSX_arm::Initialize() { 2020 PluginManager::RegisterPlugin(GetPluginNameStatic(), 2021 "Mac OS X ABI for arm targets", CreateInstance); 2022 } 2023 2024 void ABIMacOSX_arm::Terminate() { 2025 PluginManager::UnregisterPlugin(CreateInstance); 2026 } 2027 2028 lldb_private::ConstString ABIMacOSX_arm::GetPluginNameStatic() { 2029 static ConstString g_name("macosx-arm"); 2030 return g_name; 2031 } 2032 2033 // PluginInterface protocol 2034 2035 lldb_private::ConstString ABIMacOSX_arm::GetPluginName() { 2036 return GetPluginNameStatic(); 2037 } 2038 2039 uint32_t ABIMacOSX_arm::GetPluginVersion() { return 1; } 2040