11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/ADT/Triple.h"
113 #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4) \
115 #reg, alt, 8, 0, eEncodingUint, eFormatHex, {kind1, kind2, kind3, kind4 }, \
210 const lldb_private::RegisterInfo *
222 if (arch.
GetTriple().getArch() == llvm::Triple::ppc) {
224 new ABISysV_ppc(std::move(process_sp), MakeMCRegisterInfo(arch)));
231 llvm::ArrayRef<addr_t> args)
const {
236 s.
Printf(
"ABISysV_ppc::PrepareTrivialCall (tid = 0x%" PRIx64
237 ", sp = 0x%" PRIx64
", func_addr = 0x%" PRIx64
238 ", return_addr = 0x%" PRIx64,
239 thread.
GetID(), (uint64_t)
sp, (uint64_t)func_addr,
240 (uint64_t)return_addr);
242 for (
size_t i = 0; i < args.size(); ++i)
243 s.
Printf(
", arg%" PRIu64
" = 0x%" PRIx64,
static_cast<uint64_t
>(i + 1),
253 const RegisterInfo *reg_info =
nullptr;
258 for (
size_t i = 0; i < args.size(); ++i) {
261 LLDB_LOGF(log,
"About to write arg%" PRIu64
" (0x%" PRIx64
") into %s",
262 static_cast<uint64_t
>(i + 1), args[i], reg_info->name);
269 LLDB_LOGF(log,
"16-byte aligning SP: 0x%" PRIx64
" to 0x%" PRIx64,
270 (uint64_t)
sp, (uint64_t)(
sp & ~0xfull));
277 const RegisterInfo *pc_reg_info =
279 const RegisterInfo *sp_reg_info =
286 "Pushing the return address onto the stack: 0x%" PRIx64
288 (uint64_t)
sp, (uint64_t)return_addr);
291 if (!process_sp->WritePointerToMemory(
sp, return_addr,
error))
296 LLDB_LOGF(log,
"Writing SP: 0x%" PRIx64, (uint64_t)
sp);
303 LLDB_LOGF(log,
"Writing IP: 0x%" PRIx64, (uint64_t)func_addr);
312 bool is_signed,
Thread &thread,
314 unsigned int ¤t_argument_register,
315 addr_t ¤t_stack_argument) {
319 if (current_argument_register < 6) {
321 argument_register_ids[current_argument_register], 0);
322 current_argument_register++;
326 uint32_t byte_size = (bit_width + (8 - 1)) / 8;
328 if (thread.
GetProcess()->ReadScalarIntegerFromMemory(
329 current_stack_argument, byte_size, is_signed, scalar,
error)) {
330 current_stack_argument += byte_size;
339 unsigned int num_values = values.
GetSize();
340 unsigned int value_index;
357 addr_t current_stack_argument =
sp + 48;
361 argument_register_ids[0] =
364 argument_register_ids[1] =
367 argument_register_ids[2] =
370 argument_register_ids[3] =
373 argument_register_ids[4] =
376 argument_register_ids[5] =
379 argument_register_ids[6] =
382 argument_register_ids[7] =
386 unsigned int current_argument_register = 0;
388 for (value_index = 0; value_index < num_values; ++value_index) {
397 llvm::Optional<uint64_t> bit_size = compiler_type.
GetBitSize(&thread);
403 argument_register_ids, current_argument_register,
404 current_stack_argument);
407 argument_register_ids, current_argument_register,
408 current_stack_argument);
415 lldb::ValueObjectSP &new_value_sp) {
418 error.SetErrorString(
"Empty value object for return value.");
422 CompilerType compiler_type = new_value_sp->GetCompilerType();
423 if (!compiler_type) {
424 error.SetErrorString(
"Null clang type for return value.");
428 Thread *thread = frame_sp->GetThread().get();
436 bool set_it_simple =
false;
443 size_t num_bytes = new_value_sp->GetData(data, data_error);
444 if (data_error.
Fail()) {
445 error.SetErrorStringWithFormat(
446 "Couldn't convert return value to raw data: %s",
451 if (num_bytes <= 8) {
452 uint64_t raw_value = data.
GetMaxU64(&offset, num_bytes);
455 set_it_simple =
true;
457 error.SetErrorString(
"We don't support returning longer than 64 bit "
458 "integer values at present.");
462 error.SetErrorString(
463 "We don't support returning complex values at present");
465 llvm::Optional<uint64_t> bit_width =
468 error.SetErrorString(
"can't get type size");
471 if (*bit_width <= 64) {
474 size_t num_bytes = new_value_sp->GetData(data, data_error);
475 if (data_error.
Fail()) {
476 error.SetErrorStringWithFormat(
477 "Couldn't convert return value to raw data: %s",
482 unsigned char buffer[16];
486 set_it_simple =
true;
489 error.SetErrorString(
490 "We don't support returning float values > 64 bits at present");
495 if (!set_it_simple) {
499 error.SetErrorString(
"We only support setting simple integer and float "
500 "return types at present.");
508 ValueObjectSP return_valobj_sp;
511 if (!return_compiler_type)
512 return return_valobj_sp;
519 return return_valobj_sp;
522 if (type_flags & eTypeIsScalar) {
525 bool success =
false;
526 if (type_flags & eTypeIsInteger) {
529 llvm::Optional<uint64_t> byte_size =
532 return return_valobj_sp;
535 const bool is_signed = (type_flags & eTypeIsSigned) != 0;
536 switch (*byte_size) {
540 case sizeof(uint64_t):
542 value.
GetScalar() = (int64_t)(raw_value);
544 value.
GetScalar() = (uint64_t)(raw_value);
558 value.
GetScalar() = (int16_t)(raw_value & UINT16_MAX);
564 case sizeof(uint8_t):
566 value.
GetScalar() = (int8_t)(raw_value & UINT8_MAX);
568 value.
GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
572 }
else if (type_flags & eTypeIsFloat) {
573 if (type_flags & eTypeIsComplex) {
576 llvm::Optional<uint64_t> byte_size =
578 if (byte_size && *byte_size <=
sizeof(
long double)) {
585 if (*byte_size ==
sizeof(
float)) {
588 }
else if (*byte_size ==
sizeof(
double)) {
599 return_valobj_sp = ValueObjectConstResult::Create(
601 }
else if (type_flags & eTypeIsPointer) {
607 return_valobj_sp = ValueObjectConstResult::Create(
609 }
else if (type_flags & eTypeIsVector) {
610 llvm::Optional<uint64_t> byte_size =
612 if (byte_size && *byte_size > 0) {
615 if (*byte_size <= altivec_reg->byte_size) {
618 std::unique_ptr<DataBufferHeap> heap_data_up(
620 const ByteOrder byte_order = process_sp->GetByteOrder();
625 altivec_reg, heap_data_up->GetBytes(),
626 heap_data_up->GetByteSize(), byte_order,
error)) {
629 process_sp->GetTarget()
631 .GetAddressByteSize());
632 return_valobj_sp = ValueObjectConstResult::Create(
633 &thread, return_compiler_type,
ConstString(
""), data);
642 return return_valobj_sp;
647 ValueObjectSP return_valobj_sp;
649 if (!return_compiler_type)
650 return return_valobj_sp;
653 return_valobj_sp = GetReturnValueObjectSimple(thread, return_compiler_type);
654 if (return_valobj_sp)
655 return return_valobj_sp;
659 return return_valobj_sp;
661 llvm::Optional<uint64_t> bit_width = return_compiler_type.
GetBitSize(&thread);
663 return return_valobj_sp;
666 bool is_memory =
true;
667 if (*bit_width <= 128) {
673 const RegisterInfo *r3_info = reg_ctx_sp->GetRegisterInfoByName(
"r3", 0);
674 const RegisterInfo *rdx_info =
675 reg_ctx_sp->GetRegisterInfoByName(
"rdx", 0);
678 reg_ctx_sp->ReadRegister(r3_info, r3_value);
679 reg_ctx_sp->ReadRegister(rdx_info, rdx_value);
694 for (
uint32_t idx = 0; idx < num_children; idx++) {
696 uint64_t field_bit_offset = 0;
702 idx, name, &field_bit_offset,
nullptr,
nullptr);
703 llvm::Optional<uint64_t> field_bit_width =
705 if (!field_bit_width)
706 return return_valobj_sp;
709 if (field_bit_offset % *field_bit_width != 0) {
714 uint32_t field_byte_width = *field_bit_width / 8;
715 uint32_t field_byte_offset = field_bit_offset / 8;
722 if (integer_bytes < 8) {
723 if (integer_bytes + field_byte_width <= 8) {
725 copy_from_extractor = &r3_data;
726 copy_from_offset = integer_bytes;
727 integer_bytes += field_byte_width;
731 copy_from_extractor = &rdx_data;
732 copy_from_offset = 0;
733 integer_bytes = 8 + field_byte_width;
735 }
else if (integer_bytes + field_byte_width <= 16) {
736 copy_from_extractor = &rdx_data;
737 copy_from_offset = integer_bytes - 8;
738 integer_bytes += field_byte_width;
743 return return_valobj_sp;
747 if (*field_bit_width == 128) {
750 }
else if (*field_bit_width == 64) {
751 copy_from_offset = 0;
752 }
else if (*field_bit_width == 32) {
758 if (field_byte_offset % 8 == 0) {
761 if (idx == num_children - 1)
764 uint64_t next_field_bit_offset = 0;
767 &next_field_bit_offset,
773 copy_from_offset = 0;
777 }
else if (field_byte_offset % 4 == 0) {
784 uint64_t prev_field_bit_offset = 0;
787 &prev_field_bit_offset,
793 copy_from_offset = 4;
805 if (integer_bytes < 8) {
807 copy_from_extractor = &r3_data;
808 copy_from_offset = integer_bytes;
809 integer_bytes += field_byte_width;
811 copy_from_extractor = &rdx_data;
812 copy_from_offset = integer_bytes - 8;
813 integer_bytes += field_byte_width;
822 if (!copy_from_extractor)
823 return return_valobj_sp;
824 if (copy_from_offset + field_byte_width >
826 return return_valobj_sp;
829 copy_from_offset, field_byte_width,
830 data_sp->GetBytes() + field_byte_offset, field_byte_width,
837 return_valobj_sp = ValueObjectConstResult::Create(
838 &thread, return_compiler_type,
ConstString(
""), return_ext);
855 return_valobj_sp = ValueObjectMemory::Create(
856 &thread,
"",
Address(storage_addr,
nullptr), return_compiler_type);
860 return return_valobj_sp;
874 row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
877 row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num,
true);
897 const int32_t ptr_size = 4;
898 row->SetUnspecifiedRegistersAreUndefined(
true);
899 row->GetCFAValue().SetIsRegisterDereferenced(sp_reg_num);
901 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * 1,
true);
902 row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0,
true);
914 return !RegisterIsCalleeSaved(reg_info);
931 const char *name = reg_info->name;
932 if (name[0] ==
'r') {
933 if ((name[1] ==
'1' || name[1] ==
'2') && name[2] ==
'\0')
935 if (name[1] ==
'1' && name[2] >
'2')
937 if ((name[1] ==
'2' || name[1] ==
'3') && name[2] !=
'\0')
941 if (name[0] ==
'f' && name[1] >=
'0' && name[1] <=
'9') {
942 if (name[3] ==
'1' && name[4] >=
'4')
944 if ((name[3] ==
'2' || name[3] ==
'3') && name[4] !=
'\0')
948 if (name[0] ==
's' && name[1] ==
'p' && name[2] ==
'\0')
950 if (name[0] ==
'f' && name[1] ==
'p' && name[2] ==
'\0')
952 if (name[0] ==
'p' && name[1] ==
'c' && name[2] ==
'\0')
959 PluginManager::RegisterPlugin(GetPluginNameStatic(),
960 "System V ABI for ppc targets", CreateInstance);
964 PluginManager::UnregisterPlugin(CreateInstance);