11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/ADT/Triple.h"
36 #include "clang/AST/ASTContext.h"
37 #include "clang/AST/Attr.h"
38 #include "clang/AST/Decl.h"
40 #define DECLARE_REGISTER_INFOS_PPC64_STRUCT
42 #undef DECLARE_REGISTER_INFOS_PPC64_STRUCT
44 #define DECLARE_REGISTER_INFOS_PPC64LE_STRUCT
46 #undef DECLARE_REGISTER_INFOS_PPC64LE_STRUCT
53 const lldb_private::RegisterInfo *
56 count = llvm::array_lengthof(g_register_infos_ppc64le);
57 return g_register_infos_ppc64le;
59 count = llvm::array_lengthof(g_register_infos_ppc64);
60 return g_register_infos_ppc64;
67 return GetProcessSP()->GetByteOrder();
77 new ABISysV_ppc64(std::move(process_sp), MakeMCRegisterInfo(arch)));
83 llvm::ArrayRef<addr_t> args)
const {
88 s.
Printf(
"ABISysV_ppc64::PrepareTrivialCall (tid = 0x%" PRIx64
89 ", sp = 0x%" PRIx64
", func_addr = 0x%" PRIx64
90 ", return_addr = 0x%" PRIx64,
91 thread.
GetID(), (uint64_t)
sp, (uint64_t)func_addr,
92 (uint64_t)return_addr);
94 for (
size_t i = 0; i < args.size(); ++i)
95 s.
Printf(
", arg%" PRIu64
" = 0x%" PRIx64,
static_cast<uint64_t
>(i + 1),
105 const RegisterInfo *reg_info =
nullptr;
110 for (
size_t i = 0; i < args.size(); ++i) {
113 LLDB_LOGF(log,
"About to write arg%" PRIu64
" (0x%" PRIx64
") into %s",
114 static_cast<uint64_t
>(i + 1), args[i], reg_info->name);
121 LLDB_LOGF(log,
"16-byte aligning SP: 0x%" PRIx64
" to 0x%" PRIx64,
122 (uint64_t)
sp, (uint64_t)(
sp & ~0xfull));
130 const RegisterInfo *pc_reg_info =
132 const RegisterInfo *sp_reg_info =
135 const RegisterInfo *lr_reg_info =
142 "Pushing the return address onto the stack: 0x%" PRIx64
144 (uint64_t)
sp, (uint64_t)return_addr);
145 if (!process_sp->WritePointerToMemory(
sp + 16, return_addr,
error))
149 LLDB_LOGF(log,
"Writing LR: 0x%" PRIx64, (uint64_t)return_addr);
154 LLDB_LOGF(log,
"Writing R12: 0x%" PRIx64, (uint64_t)func_addr);
162 uint64_t stack_offset;
168 LLDB_LOGF(log,
"Writing R2 (TOC) at SP(0x%" PRIx64
")+%d: 0x%" PRIx64,
169 (uint64_t)(
sp + stack_offset), (
int)stack_offset,
170 (uint64_t)reg_value);
171 if (!process_sp->WritePointerToMemory(
sp + stack_offset, reg_value,
error))
178 LLDB_LOGF(log,
"Writing SP at SP(0x%" PRIx64
")+0: 0x%" PRIx64, (uint64_t)
sp,
179 (uint64_t)reg_value);
180 if (!process_sp->WritePointerToMemory(
sp, reg_value,
error))
184 LLDB_LOGF(log,
"Writing SP: 0x%" PRIx64, (uint64_t)
sp);
191 LLDB_LOGF(log,
"Writing IP: 0x%" PRIx64, (uint64_t)func_addr);
200 bool is_signed,
Thread &thread,
202 unsigned int ¤t_argument_register,
203 addr_t ¤t_stack_argument) {
207 if (current_argument_register < 6) {
209 argument_register_ids[current_argument_register], 0);
210 current_argument_register++;
214 uint32_t byte_size = (bit_width + (8 - 1)) / 8;
216 if (thread.
GetProcess()->ReadScalarIntegerFromMemory(
217 current_stack_argument, byte_size, is_signed, scalar,
error)) {
218 current_stack_argument += byte_size;
227 unsigned int num_values = values.
GetSize();
228 unsigned int value_index;
245 uint64_t stack_offset;
252 addr_t current_stack_argument =
sp + stack_offset;
255 for (
size_t i = 0; i < 8; ++i) {
256 argument_register_ids[i] =
263 unsigned int current_argument_register = 0;
265 for (value_index = 0; value_index < num_values; ++value_index) {
274 llvm::Optional<uint64_t> bit_size = compiler_type.
GetBitSize(&thread);
281 argument_register_ids, current_argument_register,
282 current_stack_argument);
285 argument_register_ids, current_argument_register,
286 current_stack_argument);
294 lldb::ValueObjectSP &new_value_sp) {
297 error.SetErrorString(
"Empty value object for return value.");
301 CompilerType compiler_type = new_value_sp->GetCompilerType();
302 if (!compiler_type) {
303 error.SetErrorString(
"Null clang type for return value.");
307 Thread *thread = frame_sp->GetThread().get();
315 bool set_it_simple =
false;
322 size_t num_bytes = new_value_sp->GetData(data, data_error);
323 if (data_error.
Fail()) {
324 error.SetErrorStringWithFormat(
325 "Couldn't convert return value to raw data: %s",
330 if (num_bytes <= 8) {
331 uint64_t raw_value = data.
GetMaxU64(&offset, num_bytes);
334 set_it_simple =
true;
336 error.SetErrorString(
"We don't support returning longer than 64 bit "
337 "integer values at present.");
341 error.SetErrorString(
342 "We don't support returning complex values at present");
344 llvm::Optional<uint64_t> bit_width =
347 error.SetErrorString(
"can't get size of type");
350 if (*bit_width <= 64) {
353 size_t num_bytes = new_value_sp->GetData(data, data_error);
354 if (data_error.
Fail()) {
355 error.SetErrorStringWithFormat(
356 "Couldn't convert return value to raw data: %s",
361 unsigned char buffer[16];
365 set_it_simple =
true;
368 error.SetErrorString(
369 "We don't support returning float values > 64 bits at present");
374 if (!set_it_simple) {
378 error.SetErrorString(
"We only support setting simple integer and float "
379 "return types at present.");
391 #define LOG_PREFIX "ReturnValueExtractor: "
393 class ReturnValueExtractor {
412 : m_index(index), m_offs(offs %
sizeof(uint64_t)),
413 m_avail(
sizeof(uint64_t) - m_offs), m_type(ty), m_reg_ctx(reg_ctx),
414 m_byte_order(byte_order) {}
419 : Register(ty, index, 0, reg_ctx, byte_order) {}
423 : Register(
GPR, offs /
sizeof(uint64_t), offs, reg_ctx, byte_order) {}
425 uint32_t Index()
const {
return m_index; }
428 uint32_t Offs()
const {
return m_offs; }
431 uint32_t Avail()
const {
return m_avail; }
433 bool IsValid()
const {
436 "No more than 8 registers should be used to return values");
444 return (
"r" + llvm::Twine(m_index + 3)).str();
446 return (
"f" + llvm::Twine(m_index + 1)).str();
450 bool GetRawData(uint64_t &raw_data) {
451 const RegisterInfo *reg_info =
452 m_reg_ctx->GetRegisterInfoByName(
GetName());
459 if (!m_reg_ctx->ReadRegister(reg_info, reg_val)) {
466 reg_info, &raw_data,
sizeof(raw_data), m_byte_order,
error);
467 if (rc !=
sizeof(raw_data)) {
482 Log *m_log =
GetLog(LLDBLog::Expressions);
485 Register GetGPR(
uint32_t index)
const {
486 return Register(
Register::GPR, index, m_reg_ctx, m_byte_order);
489 Register GetFPR(
uint32_t index)
const {
490 return Register(
Register::FPR, index, m_reg_ctx, m_byte_order);
493 Register GetGPRByOffs(
uint32_t offs)
const {
494 return Register(offs, m_reg_ctx, m_byte_order);
499 static llvm::Expected<ReturnValueExtractor> Create(
Thread &thread,
503 return llvm::make_error<llvm::StringError>(
505 llvm::inconvertibleErrorCode());
509 return llvm::make_error<llvm::StringError>(
510 LOG_PREFIX "GetProcess() failed", llvm::inconvertibleErrorCode());
512 return ReturnValueExtractor(thread, type, reg_ctx, process_sp);
516 ValueObjectSP GetValue() {
517 const uint32_t type_flags = m_type.GetTypeInfo();
521 ValueObjectSP valobj_sp;
522 if (type_flags & eTypeIsScalar) {
523 if (type_flags & eTypeIsInteger) {
524 value_sp = GetIntegerValue(0);
525 }
else if (type_flags & eTypeIsFloat) {
526 if (type_flags & eTypeIsComplex) {
528 return ValueObjectSP();
530 value_sp = GetFloatValue(m_type, 0);
533 }
else if (type_flags & eTypeIsPointer) {
534 value_sp = GetPointerValue(0);
538 valobj_sp = ValueObjectConstResult::Create(
539 m_thread.GetStackFrameAtIndex(0).get(), *value_sp,
ConstString(
""));
540 }
else if (type_flags & eTypeIsVector) {
541 valobj_sp = GetVectorValueObject();
542 }
else if (type_flags & eTypeIsStructUnion || type_flags & eTypeIsClass) {
543 valobj_sp = GetStructValueObject();
553 uint64_t m_byte_size;
554 std::unique_ptr<DataBufferHeap> m_data_up;
555 int32_t m_src_offs = 0;
556 int32_t m_dst_offs = 0;
557 bool m_packed =
false;
558 Log *m_log =
GetLog(LLDBLog::Expressions);
560 ProcessSP m_process_sp;
569 : m_thread(thread), m_type(type),
570 m_byte_size(m_type.
GetByteSize(&thread).value_or(0)),
571 m_data_up(
new DataBufferHeap(m_byte_size, 0)), m_reg_ctx(reg_ctx),
572 m_process_sp(process_sp), m_byte_order(process_sp->GetByteOrder()),
574 process_sp->GetTarget().GetArchitecture().GetAddressByteSize()) {}
578 ValueSP value_sp(
new Value);
579 value_sp->SetCompilerType(type);
580 value_sp->SetValueType(Value::ValueType::Scalar);
585 ValueSP GetIntegerValue(
uint32_t reg_index) {
587 auto reg = GetGPR(reg_index);
588 if (!reg.GetRawData(raw_value))
592 ValueSP value_sp(NewScalarValue(m_type));
595 bool is_signed = (type_flags & eTypeIsSigned) != 0;
597 switch (m_byte_size) {
598 case sizeof(uint64_t):
600 value_sp->GetScalar() = (int64_t)(raw_value);
602 value_sp->GetScalar() = (uint64_t)(raw_value);
607 value_sp->GetScalar() = (int32_t)(raw_value &
UINT32_MAX);
614 value_sp->GetScalar() = (int16_t)(raw_value & UINT16_MAX);
616 value_sp->GetScalar() = (
uint16_t)(raw_value & UINT16_MAX);
619 case sizeof(uint8_t):
621 value_sp->GetScalar() = (int8_t)(raw_value & UINT8_MAX);
623 value_sp->GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
627 llvm_unreachable(
"Invalid integer size");
636 auto reg = GetFPR(reg_index);
637 if (!reg.GetRawData(raw_data))
641 ValueSP value_sp(NewScalarValue(type));
643 DataExtractor de(&raw_data,
sizeof(raw_data), m_byte_order, m_addr_size);
646 llvm::Optional<uint64_t> byte_size = type.
GetByteSize(m_process_sp.get());
649 switch (*byte_size) {
651 value_sp->GetScalar() = (float)de.
GetDouble(&offset);
655 value_sp->GetScalar() = de.
GetDouble(&offset);
659 llvm_unreachable(
"Invalid floating point size");
666 ValueSP GetPointerValue(
uint32_t reg_index) {
668 auto reg = GetGPR(reg_index);
669 if (!reg.GetRawData(raw_data))
673 ValueSP value_sp(NewScalarValue(m_type));
674 value_sp->GetScalar() = raw_data;
679 ValueObjectSP BuildValueObject() {
680 DataExtractor de(DataBufferSP(m_data_up.release()), m_byte_order,
682 return ValueObjectConstResult::Create(&m_thread, m_type,
ConstString(
""),
687 ValueObjectSP GetVectorValueObject() {
691 const RegisterInfo *vr[MAX_VRS];
695 return ValueObjectSP();
698 const uint32_t vr_size = vr[0]->byte_size;
700 if (m_byte_size > 2 * vr_size) {
703 "Returning vectors that don't fit in 2 VR regs is not supported");
704 return ValueObjectSP();
708 if (m_byte_size > vr_size) {
713 return ValueObjectSP();
722 std::unique_ptr<DataBufferHeap> vr_data(
725 for (
uint32_t i = 0; i < vrs; i++) {
728 return ValueObjectSP();
730 if (!vr_val[i].GetAsMemoryData(vr[i], vr_data->GetBytes() + i * vr_size,
731 vr_size, m_byte_order,
error)) {
733 return ValueObjectSP();
741 if (m_byte_size < vr_size)
742 offs = vr_size - m_byte_size;
745 memcpy(m_data_up->GetBytes(), vr_data->GetBytes() + offs, m_byte_size);
746 return BuildValueObject();
750 ValueObjectSP GetStructValueObject() {
752 if (m_byte_size > 2 *
sizeof(uint64_t)) {
754 auto reg = GetGPR(0);
755 if (!reg.GetRawData(addr))
759 size_t rc = m_process_sp->ReadMemory(addr, m_data_up->GetBytes(),
761 if (rc != m_byte_size) {
763 return ValueObjectSP();
765 return BuildValueObject();
769 const bool omit_empty_base_classes =
true;
780 llvm::Optional<uint64_t> elem_size =
784 if (type_flags & eTypeIsComplex || !(type_flags & eTypeIsFloat)) {
786 LOG_PREFIX "Unexpected type found in homogeneous aggregate");
791 ValueSP val_sp = GetFloatValue(elem_type, i);
797 size_t rc = val_sp->GetScalar().GetAsMemoryData(
798 m_data_up->GetBytes() + m_dst_offs, *elem_size, m_byte_order,
800 if (rc != *elem_size) {
804 m_dst_offs += *elem_size;
806 return BuildValueObject();
815 clang::RecordDecl *record_decl = TypeSystemClang::GetAsRecordDecl(m_type);
818 auto attrs = record_decl->attrs();
819 for (
const auto &attr : attrs) {
820 if (attr->getKind() == clang::attr::Packed) {
829 m_packed ?
"packed" :
"not packed");
834 GetChildType(i, name, size);
839 if (!ExtractField(size))
840 return ValueObjectSP();
843 return BuildValueObject();
847 bool ExtractFromRegs(int32_t offs,
uint32_t size,
void *buf) {
849 auto reg = GetGPRByOffs(offs);
853 uint32_t n = std::min(reg.Avail(), size);
856 if (!reg.GetRawData(raw_data))
859 memcpy(buf, (
char *)&raw_data + reg.Offs(), n);
862 buf = (
char *)buf + n;
869 auto reg = GetGPRByOffs(m_src_offs);
880 LOG_PREFIX "Extracting {0} alignment bytes at offset {1}", n,
883 if (!ExtractFromRegs(m_src_offs, n, m_data_up->GetBytes() + m_dst_offs))
893 if (!ExtractFromRegs(m_src_offs, size, m_data_up->GetBytes() + m_dst_offs))
903 const bool transparent_pointers =
false;
904 const bool omit_empty_base_classes =
true;
905 const bool ignore_array_bounds =
false;
910 bool child_is_base_class;
911 bool child_is_deref_of_parent;
913 uint64_t language_flags;
918 &exe_ctx, i, transparent_pointers, omit_empty_base_classes,
919 ignore_array_bounds, name, size, child_offs, child_bitfield_bit_size,
920 child_bitfield_bit_offset, child_is_base_class,
921 child_is_deref_of_parent, valobj, language_flags);
933 return ValueObjectSP();
935 auto exp_extractor = ReturnValueExtractor::Create(thread, type);
936 if (!exp_extractor) {
939 "Extracting return value failed: {0}");
940 return ValueObjectSP();
943 return exp_extractor.get().GetValue();
948 return GetReturnValueObjectSimple(thread, return_compiler_type);
972 row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
975 row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num,
true);
1005 const int32_t ptr_size = 8;
1006 row->SetUnspecifiedRegistersAreUndefined(
true);
1007 row->GetCFAValue().SetIsRegisterDereferenced(sp_reg_num);
1009 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * 2,
true);
1010 row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0,
true);
1011 row->SetRegisterLocationToAtCFAPlusOffset(cr_reg_num, ptr_size,
true);
1023 return !RegisterIsCalleeSaved(reg_info);
1040 const char *name = reg_info->name;
1041 if (name[0] ==
'r') {
1042 if ((name[1] ==
'1' || name[1] ==
'2') && name[2] ==
'\0')
1044 if (name[1] ==
'1' && name[2] >
'2')
1046 if ((name[1] ==
'2' || name[1] ==
'3') && name[2] !=
'\0')
1050 if (name[0] ==
'f' && name[1] >=
'0' && name[2] <=
'9') {
1051 if (name[2] ==
'\0')
1053 if (name[1] ==
'1' && name[2] >=
'4')
1055 if ((name[1] ==
'2' || name[1] ==
'3') && name[2] !=
'\0')
1059 if (name[0] ==
's' && name[1] ==
'p' && name[2] ==
'\0')
1061 if (name[0] ==
'f' && name[1] ==
'p' && name[2] ==
'\0')
1063 if (name[0] ==
'p' && name[1] ==
'c' && name[2] ==
'\0')
1070 PluginManager::RegisterPlugin(
1071 GetPluginNameStatic(),
"System V ABI for ppc64 targets", CreateInstance);
1075 PluginManager::UnregisterPlugin(CreateInstance);