13 #include "llvm/ADT/STLExtras.h"
14 #include "llvm/ADT/Triple.h"
48 const llvm::Triple::ArchType arch_type = arch.
GetTriple().getArch();
49 const llvm::Triple::VendorType vendor_type = arch.
GetTriple().getVendor();
51 if (vendor_type != llvm::Triple::Apple) {
52 if (arch_type == llvm::Triple::aarch64 ||
53 arch_type == llvm::Triple::aarch64_32) {
55 new ABISysV_arm64(std::move(process_sp), MakeMCRegisterInfo(arch)));
64 llvm::ArrayRef<addr_t> args)
const {
73 s.
Printf(
"ABISysV_arm64::PrepareTrivialCall (tid = 0x%" PRIx64
74 ", sp = 0x%" PRIx64
", func_addr = 0x%" PRIx64
75 ", return_addr = 0x%" PRIx64,
76 thread.
GetID(), (uint64_t)
sp, (uint64_t)func_addr,
77 (uint64_t)return_addr);
79 for (
size_t i = 0; i < args.size(); ++i)
80 s.
Printf(
", arg%d = 0x%" PRIx64,
static_cast<int>(i + 1), args[i]);
89 for (
size_t i = 0; i < args.size(); ++i) {
92 LLDB_LOGF(log,
"About to write arg%d (0x%" PRIx64
") into %s",
93 static_cast<int>(i + 1), args[i], reg_info->name);
137 for (
uint32_t value_idx = 0; value_idx < num_values; ++value_idx) {
147 bool is_signed =
false;
148 size_t bit_width = 0;
149 llvm::Optional<uint64_t> bit_size = value_type.
GetBitSize(&thread);
153 bit_width = *bit_size;
155 bit_width = *bit_size;
164 const RegisterInfo *reg_info =
nullptr;
190 const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8;
211 lldb::ValueObjectSP &new_value_sp) {
214 error.SetErrorString(
"Empty value object for return value.");
218 CompilerType return_value_type = new_value_sp->GetCompilerType();
219 if (!return_value_type) {
220 error.SetErrorString(
"Null clang type for return value.");
224 Thread *thread = frame_sp->GetThread().get();
231 const uint64_t byte_size = new_value_sp->GetData(data, data_error);
232 if (data_error.
Fail()) {
233 error.SetErrorStringWithFormat(
234 "Couldn't convert return value to raw data: %s",
240 if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
241 if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
244 if (byte_size <= 16) {
247 if (byte_size <= 8) {
248 uint64_t raw_value = data.
GetMaxU64(&offset, byte_size);
251 error.SetErrorString(
"failed to write register x0");
253 uint64_t raw_value = data.
GetMaxU64(&offset, 8);
258 raw_value = data.
GetMaxU64(&offset, byte_size - offset);
261 error.SetErrorString(
"failed to write register x1");
265 error.SetErrorString(
"We don't support returning longer than 128 bit "
266 "integer values at present.");
268 }
else if (type_flags & eTypeIsFloat) {
269 if (type_flags & eTypeIsComplex) {
271 error.SetErrorString(
272 "returning complex float values are not supported");
277 if (byte_size <= 16) {
278 if (byte_size <= RegisterValue::GetMaxByteSize()) {
281 if (
error.Success()) {
283 error.SetErrorString(
"failed to write register v0");
286 error.SetErrorStringWithFormat(
287 "returning float values with a byte size of %" PRIu64
288 " are not supported",
292 error.SetErrorString(
"returning float values longer than 128 "
293 "bits are not supported");
296 error.SetErrorString(
"v0 register is not available on this target");
300 }
else if (type_flags & eTypeIsVector) {
305 if (byte_size <= v0_info->byte_size) {
308 if (
error.Success()) {
310 error.SetErrorString(
"failed to write register v0");
317 error.SetErrorString(
"no registers are available");
333 row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
356 const int32_t ptr_size = 8;
358 row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
360 row->SetUnspecifiedRegistersAreUndefined(
true);
362 row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2,
true);
363 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1,
true);
384 const char *name = reg_info->name;
389 if (name[0] ==
'p' && name[1] ==
'c')
391 if (name[0] ==
'f' && name[1] ==
'p')
393 if (name[0] ==
's' && name[1] ==
'p')
395 if (name[0] ==
'l' && name[1] ==
'r')
398 if (name[0] ==
'x' || name[0] ==
'r') {
431 if (name[2] ==
'0' || name[2] ==
'1')
437 }
else if (name[0] ==
'v' || name[0] ==
's' || name[0] ==
'd') {
467 bool is_return_value,
471 llvm::Optional<uint64_t> byte_size =
474 if (byte_size || *byte_size == 0)
477 std::unique_ptr<DataBufferHeap> heap_data_up(
485 if (homogeneous_count > 0 && homogeneous_count <= 8) {
487 if (NSRN < 8 && (8 - NSRN) >= homogeneous_count) {
490 llvm::Optional<uint64_t> base_byte_size =
496 for (
uint32_t i = 0; i < homogeneous_count; ++i) {
498 ::snprintf(v_name,
sizeof(v_name),
"v%u", NSRN);
499 const RegisterInfo *reg_info =
501 if (reg_info ==
nullptr)
504 if (*base_byte_size > reg_info->byte_size)
513 if ((data_offset + *base_byte_size) <= heap_data_up->GetByteSize()) {
515 reg_info, heap_data_up->GetBytes() + data_offset, *base_byte_size,
517 if (bytes_copied != *base_byte_size)
519 data_offset += bytes_copied;
526 data.
SetData(DataBufferSP(heap_data_up.release()));
531 const size_t max_reg_byte_size = 16;
532 if (*byte_size <= max_reg_byte_size) {
533 size_t bytes_left = *byte_size;
535 while (data_offset < *byte_size) {
541 if (reg_info ==
nullptr)
549 const size_t curr_byte_size = std::min<size_t>(8, bytes_left);
551 reg_info, heap_data_up->GetBytes() + data_offset, curr_byte_size,
553 if (bytes_copied == 0)
555 if (bytes_copied >= bytes_left)
557 data_offset += bytes_copied;
558 bytes_left -= bytes_copied;
562 const RegisterInfo *reg_info =
nullptr;
563 if (is_return_value) {
580 if (reg_info ==
nullptr)
585 if (reg_info ==
nullptr)
595 value_addr, heap_data_up->GetBytes(), heap_data_up->GetByteSize(),
596 error) != heap_data_up->GetByteSize()) {
603 data.
SetData(DataBufferSP(heap_data_up.release()));
609 ValueObjectSP return_valobj_sp;
614 return return_valobj_sp;
621 return return_valobj_sp;
623 llvm::Optional<uint64_t> byte_size =
626 return return_valobj_sp;
629 if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
632 bool success =
false;
633 if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
635 if (*byte_size <= 8) {
636 const RegisterInfo *x0_reg_info =
nullptr;
643 const bool is_signed = (type_flags & eTypeIsSigned) != 0;
644 switch (*byte_size) {
650 const RegisterInfo *x1_reg_info =
nullptr;
656 x0_reg_info->byte_size + x1_reg_info->byte_size) {
657 std::unique_ptr<DataBufferHeap> heap_data_up(
667 x0_reg_info, heap_data_up->GetBytes() + 0, 8,
668 byte_order,
error) &&
670 x1_reg_info, heap_data_up->GetBytes() + 8, 8,
671 byte_order,
error)) {
673 DataBufferSP(heap_data_up.release()), byte_order,
676 return_valobj_sp = ValueObjectConstResult::Create(
677 &thread, return_compiler_type,
ConstString(
""), data);
678 return return_valobj_sp;
685 case sizeof(uint64_t):
687 value.
GetScalar() = (int64_t)(raw_value);
689 value.
GetScalar() = (uint64_t)(raw_value);
703 value.
GetScalar() = (int16_t)(raw_value & UINT16_MAX);
709 case sizeof(uint8_t):
711 value.
GetScalar() = (int8_t)(raw_value & UINT8_MAX);
713 value.
GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
719 }
else if (type_flags & eTypeIsFloat) {
720 if (type_flags & eTypeIsComplex) {
723 if (*byte_size <=
sizeof(
long double)) {
724 const RegisterInfo *v0_reg_info =
731 if (*byte_size ==
sizeof(
float)) {
734 }
else if (*byte_size ==
sizeof(
double)) {
737 }
else if (*byte_size ==
sizeof(
long double)) {
748 return_valobj_sp = ValueObjectConstResult::Create(
750 }
else if (type_flags & eTypeIsVector && *byte_size <= 16) {
751 if (*byte_size > 0) {
755 std::unique_ptr<DataBufferHeap> heap_data_up(
762 heap_data_up->GetByteSize(), byte_order,
764 DataExtractor data(DataBufferSP(heap_data_up.release()), byte_order,
766 return_valobj_sp = ValueObjectConstResult::Create(
767 &thread, return_compiler_type,
ConstString(
""), data);
772 }
else if (type_flags & eTypeIsStructUnion || type_flags & eTypeIsClass ||
773 (type_flags & eTypeIsVector && *byte_size > 16)) {
778 const bool is_return_value =
true;
780 exe_ctx, reg_ctx, return_compiler_type, is_return_value, NGRN, NSRN,
782 return_valobj_sp = ValueObjectConstResult::Create(
783 &thread, return_compiler_type,
ConstString(
""), data);
786 return return_valobj_sp;
790 lldb::addr_t pac_sign_extension = 0x0080000000000000ULL;
791 return (
pc & pac_sign_extension) ?
pc | mask :
pc & (~mask);
796 llvm::StringRef reg_name) {
802 uint64_t address_mask = 0;
803 lldb::ThreadSP thread_sp = process_sp->GetThreadList().GetSelectedThread();
807 address_mask = ~((1ULL << 56) - 1);
811 lldb::RegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext();
813 const RegisterInfo *reg_info =
814 reg_ctx_sp->GetRegisterInfoByName(reg_name, 0);
816 lldb::addr_t mask_reg_val = reg_ctx_sp->ReadRegisterAsUnsigned(
819 address_mask |= mask_reg_val;
827 if (lldb::ProcessSP process_sp = GetProcessSP()) {
828 if (process_sp->GetTarget().GetArchitecture().GetTriple().isOSLinux() &&
829 !process_sp->GetCodeAddressMask())
830 process_sp->SetCodeAddressMask(
833 return FixAddress(
pc, process_sp->GetCodeAddressMask());
839 if (lldb::ProcessSP process_sp = GetProcessSP()) {
840 if (process_sp->GetTarget().GetArchitecture().GetTriple().isOSLinux() &&
841 !process_sp->GetDataAddressMask())
842 process_sp->SetDataAddressMask(
845 return FixAddress(
pc, process_sp->GetDataAddressMask());
851 PluginManager::RegisterPlugin(GetPluginNameStatic(),
852 "SysV ABI for AArch64 targets", CreateInstance);
856 PluginManager::UnregisterPlugin(CreateInstance);