10 #include "llvm/ADT/STLExtras.h"
11 #include "llvm/ADT/Triple.h"
74 if (arch.
GetTriple().getVendor() != llvm::Triple::Apple) {
75 if (arch.
GetTriple().getArch() == llvm::Triple::x86) {
77 new ABISysV_i386(std::move(process_sp), MakeMCRegisterInfo(arch)));
85 llvm::ArrayRef<addr_t> args)
const {
108 sp -= 4 * args.size();
111 sp &= ~(16ull - 1ull);
118 reg_info_32, arg_pos, reg_info_32->byte_size, reg_value);
128 reg_info_32,
sp, reg_info_32->byte_size, reg_value);
144 bool is_signed,
Process *process,
145 addr_t ¤t_stack_argument) {
146 uint32_t byte_size = (bit_width + (8 - 1)) / 8;
153 is_signed, scalar,
error)) {
154 current_stack_argument += byte_size;
161 unsigned int num_values = values.
GetSize();
162 unsigned int value_index;
174 addr_t current_stack_argument =
sp + 4;
176 for (value_index = 0; value_index < num_values; ++value_index) {
184 llvm::Optional<uint64_t> bit_size = compiler_type.
GetBitSize(&thread);
189 thread.
GetProcess().get(), current_stack_argument);
192 thread.
GetProcess().get(), current_stack_argument);
200 lldb::ValueObjectSP &new_value_sp) {
203 error.SetErrorString(
"Empty value object for return value.");
207 CompilerType compiler_type = new_value_sp->GetCompilerType();
208 if (!compiler_type) {
209 error.SetErrorString(
"Null clang type for return value.");
214 Thread *thread = frame_sp->GetThread().get();
218 size_t num_bytes = new_value_sp->GetData(data, data_error);
219 bool register_write_successful =
true;
221 if (data_error.
Fail()) {
222 error.SetErrorStringWithFormat(
223 "Couldn't convert return value to raw data: %s",
232 if (type_flags & eTypeIsPointer)
234 if (num_bytes !=
sizeof(
uint32_t)) {
235 error.SetErrorString(
"Pointer to be returned is not 4 bytes wide");
241 register_write_successful =
243 }
else if ((type_flags & eTypeIsScalar) ||
244 (type_flags & eTypeIsEnumeration))
249 if (type_flags & eTypeIsInteger)
262 register_write_successful =
271 register_write_successful =
276 }
else if (type_flags & eTypeIsEnumeration)
279 register_write_successful =
281 }
else if (type_flags & eTypeIsFloat)
285 const RegisterInfo *fstat_info =
300 uint32_t value_fstat_u32 = 0x00003800;
308 uint32_t value_ftag_u32 = 0x00000080;
312 long double value_long_dbl = 0.0;
314 value_long_dbl = data.
GetFloat(&offset);
315 else if (num_bytes == 8)
316 value_long_dbl = data.
GetDouble(&offset);
317 else if (num_bytes == 12)
320 error.SetErrorString(
"Invalid number of bytes for this return type");
326 register_write_successful =
330 }
else if (num_bytes == 16)
332 error.SetErrorString(
"Implementation is missing for this clang type.");
337 error.SetErrorString(
"Invalid clang type");
343 error.SetErrorString(
"Currently only Integral and Floating Point clang "
344 "types are supported.");
346 if (!register_write_successful)
347 error.SetErrorString(
"Register writing failed");
353 ValueObjectSP return_valobj_sp;
356 if (!return_compiler_type)
357 return return_valobj_sp;
363 return return_valobj_sp;
376 if (type_flags & eTypeIsPointer)
383 return_valobj_sp = ValueObjectConstResult::Create(
385 }
else if ((type_flags & eTypeIsScalar) ||
386 (type_flags & eTypeIsEnumeration))
389 llvm::Optional<uint64_t> byte_size =
392 return return_valobj_sp;
393 bool success =
false;
395 if (type_flags & eTypeIsInteger)
397 const bool is_signed = ((type_flags & eTypeIsSigned) != 0);
406 switch (*byte_size) {
417 value.
GetScalar() = (int64_t)(raw_value);
419 value.
GetScalar() = (uint64_t)(raw_value);
433 value.
GetScalar() = (int16_t)(raw_value & UINT16_MAX);
441 value.
GetScalar() = (int8_t)(raw_value & UINT8_MAX);
443 value.
GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
449 return_valobj_sp = ValueObjectConstResult::Create(
451 }
else if (type_flags & eTypeIsEnumeration)
458 return_valobj_sp = ValueObjectConstResult::Create(
460 }
else if (type_flags & eTypeIsFloat)
462 if (*byte_size <= 12)
474 if (*byte_size == 4) {
475 float value_float = (float)value_long_double;
478 }
else if (*byte_size == 8) {
482 double value_double = (double)value_long_double;
485 }
else if (*byte_size == 12) {
494 return_valobj_sp = ValueObjectConstResult::Create(
496 }
else if (*byte_size == 16)
501 return_valobj_sp = ValueObjectMemory::Create(
502 &thread,
"",
Address(storage_addr,
nullptr), return_compiler_type);
509 }
else if (type_flags & eTypeIsComplex)
512 }
else if (type_flags & eTypeIsVector)
514 llvm::Optional<uint64_t> byte_size =
516 if (byte_size && *byte_size > 0) {
518 if (vec_reg ==
nullptr)
522 if (*byte_size <= vec_reg->byte_size) {
525 std::unique_ptr<DataBufferHeap> heap_data_up(
527 const ByteOrder byte_order = process_sp->GetByteOrder();
532 heap_data_up->GetByteSize(),
533 byte_order,
error)) {
536 process_sp->GetTarget()
538 .GetAddressByteSize());
539 return_valobj_sp = ValueObjectConstResult::Create(
540 &thread, return_compiler_type,
ConstString(
""), data);
544 }
else if (*byte_size <= vec_reg->byte_size * 2) {
545 const RegisterInfo *vec_reg2 =
550 std::unique_ptr<DataBufferHeap> heap_data_up(
552 const ByteOrder byte_order = process_sp->GetByteOrder();
560 vec_reg->byte_size, byte_order,
563 vec_reg2, heap_data_up->GetBytes() + vec_reg->byte_size,
564 heap_data_up->GetByteSize() - vec_reg->byte_size,
565 byte_order,
error)) {
568 process_sp->GetTarget()
570 .GetAddressByteSize());
571 return_valobj_sp = ValueObjectConstResult::Create(
572 &thread, return_compiler_type,
ConstString(
""), data);
584 return return_valobj_sp;
589 ValueObjectSP return_valobj_sp;
591 if (!return_compiler_type)
592 return return_valobj_sp;
595 return_valobj_sp = GetReturnValueObjectSimple(thread, return_compiler_type);
596 if (return_valobj_sp)
597 return return_valobj_sp;
601 return return_valobj_sp;
609 return_valobj_sp = ValueObjectMemory::Create(
610 &thread,
"",
Address(storage_addr,
nullptr), return_compiler_type);
613 return return_valobj_sp;
628 row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 4);
629 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, -4,
false);
630 row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0,
true);
651 const int32_t ptr_size = 4;
653 row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
655 row->SetUnspecifiedRegistersAreUndefined(
true);
657 row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2,
true);
658 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1,
true);
659 row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0,
true);
677 const char *name = reg_info->name;
678 if (name[0] ==
'e') {
681 if (name[2] ==
'x' || name[2] ==
'p')
682 return name[3] ==
'\0';
686 return name[3] ==
'\0';
690 return name[3] ==
'\0';
693 if (name[2] ==
'i' || name[2] ==
'p')
694 return name[3] ==
'\0';
699 if (name[0] ==
's' && name[1] ==
'p' && name[2] ==
'\0')
701 if (name[0] ==
'f' && name[1] ==
'p' && name[2] ==
'\0')
703 if (name[0] ==
'p' && name[1] ==
'c' && name[2] ==
'\0')
710 PluginManager::RegisterPlugin(
711 GetPluginNameStatic(),
"System V ABI for i386 targets", CreateInstance);
715 PluginManager::UnregisterPlugin(CreateInstance);