10 #include "llvm/ADT/STLExtras.h"
11 #include "llvm/ADT/Triple.h"
75 if (arch.
GetTriple().getVendor() != llvm::Triple::Apple) {
76 if (arch.
GetTriple().getArch() == llvm::Triple::x86) {
78 new ABISysV_i386(std::move(process_sp), MakeMCRegisterInfo(arch)));
86 llvm::ArrayRef<addr_t> args)
const {
109 sp -= 4 * args.size();
112 sp &= ~(16ull - 1ull);
119 reg_info_32, arg_pos, reg_info_32->byte_size, reg_value);
129 reg_info_32,
sp, reg_info_32->byte_size, reg_value);
145 bool is_signed,
Process *process,
146 addr_t ¤t_stack_argument) {
147 uint32_t byte_size = (bit_width + (8 - 1)) / 8;
154 is_signed, scalar,
error)) {
155 current_stack_argument += byte_size;
162 unsigned int num_values = values.
GetSize();
163 unsigned int value_index;
175 addr_t current_stack_argument =
sp + 4;
177 for (value_index = 0; value_index < num_values; ++value_index) {
185 std::optional<uint64_t> bit_size = compiler_type.
GetBitSize(&thread);
190 thread.
GetProcess().get(), current_stack_argument);
193 thread.
GetProcess().get(), current_stack_argument);
201 lldb::ValueObjectSP &new_value_sp) {
204 error.SetErrorString(
"Empty value object for return value.");
208 CompilerType compiler_type = new_value_sp->GetCompilerType();
209 if (!compiler_type) {
210 error.SetErrorString(
"Null clang type for return value.");
215 Thread *thread = frame_sp->GetThread().get();
219 size_t num_bytes = new_value_sp->GetData(data, data_error);
220 bool register_write_successful =
true;
222 if (data_error.
Fail()) {
223 error.SetErrorStringWithFormat(
224 "Couldn't convert return value to raw data: %s",
233 if (type_flags & eTypeIsPointer)
235 if (num_bytes !=
sizeof(
uint32_t)) {
236 error.SetErrorString(
"Pointer to be returned is not 4 bytes wide");
242 register_write_successful =
244 }
else if ((type_flags & eTypeIsScalar) ||
245 (type_flags & eTypeIsEnumeration))
250 if (type_flags & eTypeIsInteger)
263 register_write_successful =
272 register_write_successful =
277 }
else if (type_flags & eTypeIsEnumeration)
280 register_write_successful =
282 }
else if (type_flags & eTypeIsFloat)
286 const RegisterInfo *fstat_info =
301 uint32_t value_fstat_u32 = 0x00003800;
309 uint32_t value_ftag_u32 = 0x00000080;
313 long double value_long_dbl = 0.0;
315 value_long_dbl = data.
GetFloat(&offset);
316 else if (num_bytes == 8)
317 value_long_dbl = data.
GetDouble(&offset);
318 else if (num_bytes == 12)
321 error.SetErrorString(
"Invalid number of bytes for this return type");
327 register_write_successful =
331 }
else if (num_bytes == 16)
333 error.SetErrorString(
"Implementation is missing for this clang type.");
338 error.SetErrorString(
"Invalid clang type");
344 error.SetErrorString(
"Currently only Integral and Floating Point clang "
345 "types are supported.");
347 if (!register_write_successful)
348 error.SetErrorString(
"Register writing failed");
354 ValueObjectSP return_valobj_sp;
357 if (!return_compiler_type)
358 return return_valobj_sp;
364 return return_valobj_sp;
377 if (type_flags & eTypeIsPointer)
384 return_valobj_sp = ValueObjectConstResult::Create(
386 }
else if ((type_flags & eTypeIsScalar) ||
387 (type_flags & eTypeIsEnumeration))
390 std::optional<uint64_t> byte_size =
393 return return_valobj_sp;
394 bool success =
false;
396 if (type_flags & eTypeIsInteger)
398 const bool is_signed = ((type_flags & eTypeIsSigned) != 0);
407 switch (*byte_size) {
418 value.
GetScalar() = (int64_t)(raw_value);
420 value.
GetScalar() = (uint64_t)(raw_value);
434 value.
GetScalar() = (int16_t)(raw_value & UINT16_MAX);
442 value.
GetScalar() = (int8_t)(raw_value & UINT8_MAX);
444 value.
GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
450 return_valobj_sp = ValueObjectConstResult::Create(
452 }
else if (type_flags & eTypeIsEnumeration)
459 return_valobj_sp = ValueObjectConstResult::Create(
461 }
else if (type_flags & eTypeIsFloat)
463 if (*byte_size <= 12)
475 if (*byte_size == 4) {
476 float value_float = (float)value_long_double;
479 }
else if (*byte_size == 8) {
483 double value_double = (double)value_long_double;
486 }
else if (*byte_size == 12) {
495 return_valobj_sp = ValueObjectConstResult::Create(
497 }
else if (*byte_size == 16)
502 return_valobj_sp = ValueObjectMemory::Create(
503 &thread,
"",
Address(storage_addr,
nullptr), return_compiler_type);
510 }
else if (type_flags & eTypeIsComplex)
513 }
else if (type_flags & eTypeIsVector)
515 std::optional<uint64_t> byte_size =
517 if (byte_size && *byte_size > 0) {
519 if (vec_reg ==
nullptr)
523 if (*byte_size <= vec_reg->byte_size) {
526 std::unique_ptr<DataBufferHeap> heap_data_up(
528 const ByteOrder byte_order = process_sp->GetByteOrder();
533 heap_data_up->GetByteSize(),
534 byte_order,
error)) {
537 process_sp->GetTarget()
539 .GetAddressByteSize());
540 return_valobj_sp = ValueObjectConstResult::Create(
541 &thread, return_compiler_type,
ConstString(
""), data);
545 }
else if (*byte_size <= vec_reg->byte_size * 2) {
546 const RegisterInfo *vec_reg2 =
551 std::unique_ptr<DataBufferHeap> heap_data_up(
553 const ByteOrder byte_order = process_sp->GetByteOrder();
561 *vec_reg, heap_data_up->GetBytes(), vec_reg->byte_size,
562 byte_order,
error) &&
565 heap_data_up->GetBytes() + vec_reg->byte_size,
566 heap_data_up->GetByteSize() - vec_reg->byte_size,
567 byte_order,
error)) {
570 process_sp->GetTarget()
572 .GetAddressByteSize());
573 return_valobj_sp = ValueObjectConstResult::Create(
574 &thread, return_compiler_type,
ConstString(
""), data);
586 return return_valobj_sp;
591 ValueObjectSP return_valobj_sp;
593 if (!return_compiler_type)
594 return return_valobj_sp;
597 return_valobj_sp = GetReturnValueObjectSimple(thread, return_compiler_type);
598 if (return_valobj_sp)
599 return return_valobj_sp;
603 return return_valobj_sp;
611 return_valobj_sp = ValueObjectMemory::Create(
612 &thread,
"",
Address(storage_addr,
nullptr), return_compiler_type);
615 return return_valobj_sp;
630 row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 4);
631 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, -4,
false);
632 row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0,
true);
653 const int32_t ptr_size = 4;
655 row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
657 row->SetUnspecifiedRegistersAreUndefined(
true);
659 row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2,
true);
660 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1,
true);
661 row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0,
true);
679 const char *name = reg_info->name;
680 if (name[0] ==
'e') {
683 if (name[2] ==
'x' || name[2] ==
'p')
684 return name[3] ==
'\0';
688 return name[3] ==
'\0';
692 return name[3] ==
'\0';
695 if (name[2] ==
'i' || name[2] ==
'p')
696 return name[3] ==
'\0';
701 if (name[0] ==
's' && name[1] ==
'p' && name[2] ==
'\0')
703 if (name[0] ==
'f' && name[1] ==
'p' && name[2] ==
'\0')
705 if (name[0] ==
'p' && name[1] ==
'c' && name[2] ==
'\0')
712 PluginManager::RegisterPlugin(
713 GetPluginNameStatic(),
"System V ABI for i386 targets", CreateInstance);
717 PluginManager::UnregisterPlugin(CreateInstance);