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