11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/ADT/StringSwitch.h"
13 #include "llvm/ADT/Triple.h"
116 if (arch.
GetTriple().getArch() == llvm::Triple::x86_64 &&
126 llvm::ArrayRef<addr_t> args)
const {
131 s.
Printf(
"ABIWindows_x86_64::PrepareTrivialCall (tid = 0x%" PRIx64
132 ", sp = 0x%" PRIx64
", func_addr = 0x%" PRIx64
133 ", return_addr = 0x%" PRIx64,
134 thread.
GetID(), (uint64_t)
sp, (uint64_t)func_addr,
135 (uint64_t)return_addr);
137 for (
size_t i = 0; i < args.size(); ++i)
138 s.
Printf(
", arg%" PRIu64
" = 0x%" PRIx64,
static_cast<uint64_t
>(i + 1),
148 const RegisterInfo *reg_info =
nullptr;
153 for (
size_t i = 0; i < args.size(); ++i) {
156 LLDB_LOGF(log,
"About to write arg%" PRIu64
" (0x%" PRIx64
") into %s",
157 static_cast<uint64_t
>(i + 1), args[i], reg_info->name);
164 LLDB_LOGF(log,
"16-byte aligning SP: 0x%" PRIx64
" to 0x%" PRIx64,
165 (uint64_t)
sp, (uint64_t)(
sp & ~0xfull));
172 const RegisterInfo *pc_reg_info =
174 const RegisterInfo *sp_reg_info =
180 "Pushing the return address onto the stack: 0x%" PRIx64
182 (uint64_t)
sp, (uint64_t)return_addr);
185 if (!process_sp->WritePointerToMemory(
sp, return_addr,
error))
190 LLDB_LOGF(log,
"Writing SP: 0x%" PRIx64, (uint64_t)
sp);
197 LLDB_LOGF(log,
"Writing IP: 0x%" PRIx64, (uint64_t)func_addr);
206 bool is_signed,
Thread &thread,
208 unsigned int ¤t_argument_register,
209 addr_t ¤t_stack_argument) {
213 if (current_argument_register < 4) {
215 argument_register_ids[current_argument_register], 0);
216 current_argument_register++;
221 uint32_t byte_size = (bit_width + (CHAR_BIT - 1)) / CHAR_BIT;
223 if (thread.
GetProcess()->ReadScalarIntegerFromMemory(
224 current_stack_argument, byte_size, is_signed, scalar,
error)) {
225 current_stack_argument += byte_size;
233 unsigned int num_values = values.
GetSize();
234 unsigned int value_index;
251 addr_t current_stack_argument =
sp + 8;
255 argument_register_ids[0] =
258 argument_register_ids[1] =
261 argument_register_ids[2] =
264 argument_register_ids[3] =
268 unsigned int current_argument_register = 0;
270 for (value_index = 0; value_index < num_values; ++value_index) {
277 llvm::Optional<uint64_t> bit_size = compiler_type.
GetBitSize(&thread);
284 argument_register_ids, current_argument_register,
285 current_stack_argument);
288 argument_register_ids, current_argument_register,
289 current_stack_argument);
297 lldb::ValueObjectSP &new_value_sp) {
300 error.SetErrorString(
"Empty value object for return value.");
304 CompilerType compiler_type = new_value_sp->GetCompilerType();
305 if (!compiler_type) {
306 error.SetErrorString(
"Null clang type for return value.");
310 Thread *thread = frame_sp->GetThread().get();
318 bool set_it_simple =
false;
325 size_t num_bytes = new_value_sp->GetData(data, data_error);
326 if (data_error.
Fail()) {
327 error.SetErrorStringWithFormat(
328 "Couldn't convert return value to raw data: %s",
333 if (num_bytes <= 8) {
334 uint64_t raw_value = data.
GetMaxU64(&offset, num_bytes);
337 set_it_simple =
true;
339 error.SetErrorString(
"We don't support returning longer than 64 bit "
340 "integer values at present.");
344 error.SetErrorString(
345 "We don't support returning complex values at present");
347 llvm::Optional<uint64_t> bit_width =
350 error.SetErrorString(
"can't get type size");
353 if (*bit_width <= 64) {
354 const RegisterInfo *xmm0_info =
359 size_t num_bytes = new_value_sp->GetData(data, data_error);
360 if (data_error.
Fail()) {
361 error.SetErrorStringWithFormat(
362 "Couldn't convert return value to raw data: %s",
367 unsigned char buffer[16];
371 xmm0_value.
SetBytes(buffer, 16, byte_order);
373 set_it_simple =
true;
376 error.SetErrorString(
377 "Windows-x86_64 doesn't allow FP larger than 64 bits.");
382 if (!set_it_simple) {
389 error.SetErrorString(
"We only support setting simple integer and float "
390 "return types at present.");
398 ValueObjectSP return_valobj_sp;
401 if (!return_compiler_type)
402 return return_valobj_sp;
408 return return_valobj_sp;
411 if (type_flags & eTypeIsScalar) {
414 bool success =
false;
415 if (type_flags & eTypeIsInteger) {
417 llvm::Optional<uint64_t> byte_size =
420 return return_valobj_sp;
423 const bool is_signed = (type_flags & eTypeIsSigned) != 0;
424 switch (*byte_size) {
428 case sizeof(uint64_t):
430 value.
GetScalar() = (int64_t)(raw_value);
432 value.
GetScalar() = (uint64_t)(raw_value);
446 value.
GetScalar() = (int16_t)(raw_value & UINT16_MAX);
452 case sizeof(uint8_t):
454 value.
GetScalar() = (int8_t)(raw_value & UINT8_MAX);
456 value.
GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
460 }
else if (type_flags & eTypeIsFloat) {
461 if (type_flags & eTypeIsComplex) {
464 llvm::Optional<uint64_t> byte_size =
466 if (byte_size && *byte_size <=
sizeof(
long double)) {
467 const RegisterInfo *xmm0_info =
472 if (xmm0_value.
GetData(data)) {
474 if (*byte_size ==
sizeof(
float)) {
477 }
else if (*byte_size ==
sizeof(
double)) {
489 return_valobj_sp = ValueObjectConstResult::Create(
491 }
else if ((type_flags & eTypeIsPointer) ||
492 (type_flags & eTypeInstanceIsPointer)) {
499 return_valobj_sp = ValueObjectConstResult::Create(
501 }
else if (type_flags & eTypeIsVector) {
502 llvm::Optional<uint64_t> byte_size =
504 if (byte_size && *byte_size > 0) {
505 const RegisterInfo *xmm_reg =
507 if (xmm_reg ==
nullptr)
511 if (*byte_size <= xmm_reg->byte_size) {
514 std::unique_ptr<DataBufferHeap> heap_data_up(
516 const ByteOrder byte_order = process_sp->GetByteOrder();
521 xmm_reg, heap_data_up->GetBytes(),
522 heap_data_up->GetByteSize(), byte_order,
error)) {
525 process_sp->GetTarget()
527 .GetAddressByteSize());
528 return_valobj_sp = ValueObjectConstResult::Create(
529 &thread, return_compiler_type,
ConstString(
""), data);
538 return return_valobj_sp;
550 std::vector<uint32_t> &aggregate_field_offsets,
551 std::vector<CompilerType> &aggregate_compiler_types) {
554 for (
uint32_t idx = 0; idx < num_children; ++idx) {
560 uint64_t field_bit_offset = 0;
562 idx, name, &field_bit_offset,
nullptr,
nullptr);
563 llvm::Optional<uint64_t> field_bit_width =
567 if (!field_bit_width || *field_bit_width == 0) {
571 if (field_bit_offset % *field_bit_width != 0) {
576 uint32_t field_byte_offset = field_bit_offset / 8 + data_byte_offset;
582 aggregate_field_offsets.push_back(field_byte_offset);
583 aggregate_compiler_types.push_back(field_compiler_type);
584 }
else if (field_type_flags & eTypeHasChildren) {
586 field_byte_offset, aggregate_field_offsets,
587 aggregate_compiler_types)) {
597 ValueObjectSP return_valobj_sp;
599 if (!return_compiler_type) {
600 return return_valobj_sp;
604 return_valobj_sp = GetReturnValueObjectSimple(thread, return_compiler_type);
605 if (return_valobj_sp) {
606 return return_valobj_sp;
611 return return_valobj_sp;
614 llvm::Optional<uint64_t> bit_width = return_compiler_type.
GetBitSize(&thread);
616 return return_valobj_sp;
621 return return_valobj_sp;
626 uint32_t max_register_value_bit_width = 64;
636 bool is_memory = *bit_width > max_register_value_bit_width ||
637 *bit_width & (*bit_width - 1);
638 std::vector<uint32_t> aggregate_field_offsets;
639 std::vector<CompilerType> aggregate_compiler_types;
642 0, aggregate_field_offsets,
643 aggregate_compiler_types)) {
645 WritableDataBufferSP data_sp(
651 const RegisterInfo *rax_info =
652 reg_ctx_sp->GetRegisterInfoByName(
"rax", 0);
654 reg_ctx_sp->ReadRegister(rax_info, rax_value);
663 if (aggregate_field_offsets.size())
664 used_bytes = aggregate_field_offsets[0];
666 const uint32_t num_children = aggregate_compiler_types.size();
667 for (
uint32_t idx = 0; idx < num_children; idx++) {
672 CompilerType field_compiler_type = aggregate_compiler_types[idx];
674 uint32_t field_byte_offset = aggregate_field_offsets[idx];
678 if (used_bytes >= 8 || used_bytes + field_byte_width > 8) {
679 return return_valobj_sp;
687 copy_from_extractor = &rax_data;
688 copy_from_offset = used_bytes;
689 used_bytes += field_byte_width;
694 if (!copy_from_extractor) {
695 return return_valobj_sp;
697 if (copy_from_offset + field_byte_width >
699 return return_valobj_sp;
702 field_byte_width, data_sp->GetBytes() + field_byte_offset,
703 field_byte_width, byte_order);
708 return_valobj_sp = ValueObjectConstResult::Create(
709 &thread, return_compiler_type,
ConstString(
""), return_ext);
728 return_valobj_sp = ValueObjectMemory::Create(
729 &thread,
"",
Address(storage_addr,
nullptr), return_compiler_type);
731 return return_valobj_sp;
746 row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 8);
747 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, -8,
false);
748 row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0,
true);
768 const int32_t ptr_size = 8;
769 row->GetCFAValue().SetIsRegisterPlusOffset(
dwarf_rbp, 2 * ptr_size);
771 row->SetUnspecifiedRegistersAreUndefined(
true);
773 row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2,
true);
774 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1,
true);
775 row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0,
true);
786 return !RegisterIsCalleeSaved(reg_info);
792 assert(reg_info->name !=
nullptr &&
"unnamed register?");
795 llvm::StringSwitch<bool>(Name)
796 .Cases(
"rbx",
"ebx",
"rbp",
"ebp",
"rdi",
"edi",
"rsi",
"esi",
true)
797 .Cases(
"rsp",
"esp",
"r12",
"r13",
"r14",
"r15",
"sp",
"fp",
true)
798 .Cases(
"xmm6",
"xmm7",
"xmm8",
"xmm9",
"xmm10",
"xmm11",
"xmm12",
799 "xmm13",
"xmm14",
"xmm15",
true)
801 return IsCalleeSaved;
805 return llvm::StringSwitch<uint32_t>(reg)
820 PluginManager::RegisterPlugin(
821 GetPluginNameStatic(),
"Windows ABI for x86_64 targets", CreateInstance);
825 PluginManager::UnregisterPlugin(CreateInstance);