11#include "llvm/ADT/STLExtras.h"
12#include "llvm/ADT/StringSwitch.h"
13#include "llvm/TargetParser/Triple.h"
73 const llvm::Triple::ArchType arch_type = arch.
GetTriple().getArch();
74 const llvm::Triple::OSType os_type = arch.
GetTriple().getOS();
75 const llvm::Triple::EnvironmentType os_env =
77 if (arch_type == llvm::Triple::x86_64) {
79 case llvm::Triple::OSType::IOS:
80 case llvm::Triple::OSType::TvOS:
81 case llvm::Triple::OSType::WatchOS:
83 case llvm::Triple::EnvironmentType::MacABI:
84 case llvm::Triple::EnvironmentType::Simulator:
85 case llvm::Triple::EnvironmentType::UnknownEnvironment:
93 case llvm::Triple::OSType::Darwin:
94 case llvm::Triple::OSType::FreeBSD:
95 case llvm::Triple::OSType::Linux:
96 case llvm::Triple::OSType::MacOSX:
97 case llvm::Triple::OSType::NetBSD:
98 case llvm::Triple::OSType::OpenBSD:
99 case llvm::Triple::OSType::Solaris:
100 case llvm::Triple::OSType::UnknownOS:
112 llvm::ArrayRef<addr_t> args)
const {
117 s.
Printf(
"ABISysV_x86_64::PrepareTrivialCall (tid = 0x%" PRIx64
118 ", sp = 0x%" PRIx64
", func_addr = 0x%" PRIx64
119 ", return_addr = 0x%" PRIx64,
120 thread.
GetID(), (uint64_t)
sp, (uint64_t)func_addr,
121 (uint64_t)return_addr);
123 for (
size_t i = 0; i < args.size(); ++i)
124 s.
Printf(
", arg%" PRIu64
" = 0x%" PRIx64,
static_cast<uint64_t
>(i + 1),
139 for (
size_t i = 0; i < args.size(); ++i) {
142 LLDB_LOGF(log,
"About to write arg%" PRIu64
" (0x%" PRIx64
") into %s",
143 static_cast<uint64_t
>(i + 1), args[i], reg_info->
name);
150 LLDB_LOGF(log,
"16-byte aligning SP: 0x%" PRIx64
" to 0x%" PRIx64,
151 (uint64_t)
sp, (uint64_t)(
sp & ~0xfull));
166 "Pushing the return address onto the stack: 0x%" PRIx64
168 (uint64_t)
sp, (uint64_t)return_addr);
171 if (!process_sp->WritePointerToMemory(
sp, return_addr,
error))
176 LLDB_LOGF(log,
"Writing SP: 0x%" PRIx64, (uint64_t)
sp);
183 LLDB_LOGF(log,
"Writing IP: 0x%" PRIx64, (uint64_t)func_addr);
192 bool is_signed,
Thread &thread,
193 uint32_t *argument_register_ids,
194 unsigned int ¤t_argument_register,
195 addr_t ¤t_stack_argument) {
199 if (current_argument_register < 6) {
201 argument_register_ids[current_argument_register], 0);
202 current_argument_register++;
206 uint32_t byte_size = (bit_width + (8 - 1)) / 8;
208 if (thread.
GetProcess()->ReadScalarIntegerFromMemory(
209 current_stack_argument, byte_size, is_signed, scalar,
error)) {
210 current_stack_argument += byte_size;
220 unsigned int num_values = values.
GetSize();
221 unsigned int value_index;
238 addr_t current_stack_argument =
sp + 8;
240 uint32_t argument_register_ids[6];
242 argument_register_ids[0] =
245 argument_register_ids[1] =
248 argument_register_ids[2] =
251 argument_register_ids[3] =
254 argument_register_ids[4] =
257 argument_register_ids[5] =
261 unsigned int current_argument_register = 0;
263 for (value_index = 0; value_index < num_values; ++value_index) {
272 std::optional<uint64_t> bit_size = compiler_type.
GetBitSize(&thread);
279 argument_register_ids, current_argument_register,
280 current_stack_argument);
283 argument_register_ids, current_argument_register,
284 current_stack_argument);
299 CompilerType compiler_type = new_value_sp->GetCompilerType();
300 if (!compiler_type) {
305 Thread *thread = frame_sp->GetThread().get();
313 bool set_it_simple =
false;
320 size_t num_bytes = new_value_sp->GetData(data, data_error);
321 if (data_error.
Fail()) {
323 "Couldn't convert return value to raw data: %s",
328 if (num_bytes <= 8) {
329 uint64_t raw_value = data.
GetMaxU64(&offset, num_bytes);
332 set_it_simple =
true;
335 "We don't support returning longer than 64 bit "
336 "integer values at present.");
341 "We don't support returning complex values at present");
343 std::optional<uint64_t> bit_width =
349 if (*bit_width <= 64) {
355 size_t num_bytes = new_value_sp->GetData(data, data_error);
356 if (data_error.
Fail()) {
358 "Couldn't convert return value to raw data: %s",
363 unsigned char buffer[16];
367 xmm0_value.
SetBytes(buffer, 16, byte_order);
369 set_it_simple =
true;
373 "We don't support returning float values > 64 bits at present");
378 if (!set_it_simple) {
383 "We only support setting simple integer and float "
384 "return types at present.");
395 if (!return_compiler_type)
396 return return_valobj_sp;
403 return return_valobj_sp;
405 const uint32_t type_flags = return_compiler_type.
GetTypeInfo();
406 if (type_flags & eTypeIsScalar) {
409 bool success =
false;
410 if (type_flags & eTypeIsInteger) {
413 std::optional<uint64_t> byte_size =
416 return return_valobj_sp;
419 const bool is_signed = (type_flags & eTypeIsSigned) != 0;
420 switch (*byte_size) {
424 case sizeof(uint64_t):
426 value.
GetScalar() = (int64_t)(raw_value);
428 value.
GetScalar() = (uint64_t)(raw_value);
432 case sizeof(uint32_t):
440 case sizeof(uint16_t):
442 value.
GetScalar() = (int16_t)(raw_value & UINT16_MAX);
444 value.
GetScalar() = (uint16_t)(raw_value & UINT16_MAX);
448 case sizeof(uint8_t):
450 value.
GetScalar() = (int8_t)(raw_value & UINT8_MAX);
452 value.
GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
456 }
else if (type_flags & eTypeIsFloat) {
457 if (type_flags & eTypeIsComplex) {
460 std::optional<uint64_t> byte_size =
462 if (byte_size && *byte_size <=
sizeof(
long double)) {
468 if (xmm0_value.
GetData(data)) {
470 if (*byte_size ==
sizeof(
float)) {
473 }
else if (*byte_size ==
sizeof(
double)) {
476 }
else if (*byte_size ==
sizeof(
long double)) {
489 }
else if (type_flags & eTypeIsPointer) {
498 }
else if (type_flags & eTypeIsVector) {
499 std::optional<uint64_t> byte_size =
501 if (byte_size && *byte_size > 0) {
504 if (altivec_reg ==
nullptr)
508 if (*byte_size <= altivec_reg->byte_size) {
511 std::unique_ptr<DataBufferHeap> heap_data_up(
513 const ByteOrder byte_order = process_sp->GetByteOrder();
518 *altivec_reg, heap_data_up->GetBytes(),
519 heap_data_up->GetByteSize(), byte_order,
error)) {
522 process_sp->GetTarget()
524 .GetAddressByteSize());
526 &thread, return_compiler_type,
ConstString(
""), data);
530 }
else if (*byte_size <= altivec_reg->byte_size * 2) {
536 std::unique_ptr<DataBufferHeap> heap_data_up(
538 const ByteOrder byte_order = process_sp->GetByteOrder();
546 *altivec_reg, heap_data_up->GetBytes(),
550 heap_data_up->GetBytes() + altivec_reg->
byte_size,
551 heap_data_up->GetByteSize() - altivec_reg->
byte_size,
552 byte_order,
error)) {
555 process_sp->GetTarget()
557 .GetAddressByteSize());
559 &thread, return_compiler_type,
ConstString(
""), data);
569 return return_valobj_sp;
580 uint32_t data_byte_offset,
581 std::vector<uint32_t> &aggregate_field_offsets,
582 std::vector<CompilerType> &aggregate_compiler_types) {
584 const uint32_t num_children = return_compiler_type.
GetNumFields();
585 for (uint32_t idx = 0; idx < num_children; ++idx) {
591 uint64_t field_bit_offset = 0;
593 idx, name, &field_bit_offset,
nullptr,
nullptr);
594 std::optional<uint64_t> field_bit_width =
598 if (!field_bit_width || *field_bit_width == 0) {
602 uint32_t field_byte_offset = field_bit_offset / 8 + data_byte_offset;
604 const uint32_t field_type_flags = field_compiler_type.
GetTypeInfo();
608 aggregate_field_offsets.push_back(field_byte_offset);
609 aggregate_compiler_types.push_back(field_compiler_type);
610 }
else if (field_type_flags & eTypeHasChildren) {
612 field_byte_offset, aggregate_field_offsets,
613 aggregate_compiler_types)) {
625 if (!return_compiler_type)
626 return return_valobj_sp;
630 if (return_valobj_sp)
631 return return_valobj_sp;
635 return return_valobj_sp;
637 std::optional<uint64_t> bit_width = return_compiler_type.
GetBitSize(&thread);
639 return return_valobj_sp;
642 bool is_memory =
true;
643 std::vector<uint32_t> aggregate_field_offsets;
644 std::vector<CompilerType> aggregate_compiler_types;
646 if (ts && ts->CanPassInRegisters(return_compiler_type) &&
649 aggregate_field_offsets,
650 aggregate_compiler_types)) {
657 reg_ctx_sp->GetRegisterInfoByName(
"rax", 0);
659 reg_ctx_sp->GetRegisterInfoByName(
"rdx", 0);
661 reg_ctx_sp->GetRegisterInfoByName(
"xmm0", 0);
663 reg_ctx_sp->GetRegisterInfoByName(
"xmm1", 0);
666 reg_ctx_sp->ReadRegister(rax_info, rax_value);
667 reg_ctx_sp->ReadRegister(rdx_info, rdx_value);
668 reg_ctx_sp->ReadRegister(xmm0_info, xmm0_value);
669 reg_ctx_sp->ReadRegister(xmm1_info, xmm1_value);
680 uint32_t integer_bytes =
685 if (aggregate_field_offsets.size()) {
686 fp_bytes = aggregate_field_offsets[0];
687 integer_bytes = aggregate_field_offsets[0];
690 const uint32_t num_children = aggregate_compiler_types.size();
694 for (uint32_t idx = 0; idx < num_children; idx++) {
699 CompilerType field_compiler_type = aggregate_compiler_types[idx];
700 uint32_t field_byte_width = (uint32_t) (*field_compiler_type.
GetByteSize(&thread));
701 uint32_t field_byte_offset = aggregate_field_offsets[idx];
703 uint32_t field_bit_width = field_byte_width * 8;
706 uint32_t copy_from_offset = 0;
710 if (integer_bytes < 8) {
711 if (integer_bytes + field_byte_width <= 8) {
713 copy_from_extractor = &rax_data;
714 copy_from_offset = integer_bytes;
715 integer_bytes += field_byte_width;
719 copy_from_extractor = &rdx_data;
720 copy_from_offset = 0;
721 integer_bytes = 8 + field_byte_width;
723 }
else if (integer_bytes + field_byte_width <= 16) {
724 copy_from_extractor = &rdx_data;
725 copy_from_offset = integer_bytes - 8;
726 integer_bytes += field_byte_width;
731 return return_valobj_sp;
735 if (field_bit_width == 128) {
738 }
else if (field_bit_width == 64) {
741 copy_from_extractor = &xmm0_data;
743 copy_from_extractor = &xmm1_data;
745 copy_from_offset = 0;
746 fp_bytes += field_byte_width;
747 }
else if (field_bit_width == 32) {
753 if (field_byte_offset % 8 == 0) {
756 if (idx == num_children - 1) {
760 aggregate_compiler_types[idx + 1];
765 copy_from_offset = 0;
769 }
else if (field_byte_offset % 4 == 0) {
777 aggregate_compiler_types[idx - 1];
782 copy_from_offset = 4;
794 if (integer_bytes < 8) {
796 copy_from_extractor = &rax_data;
797 copy_from_offset = integer_bytes;
798 integer_bytes += field_byte_width;
800 copy_from_extractor = &rdx_data;
801 copy_from_offset = integer_bytes - 8;
802 integer_bytes += field_byte_width;
806 copy_from_extractor = &xmm0_data;
808 copy_from_extractor = &xmm1_data;
810 fp_bytes += field_byte_width;
817 if (!copy_from_extractor)
818 return return_valobj_sp;
819 if (copy_from_offset + field_byte_width >
821 return return_valobj_sp;
823 copy_from_offset, field_byte_width,
824 data_sp->GetBytes() + field_byte_offset, field_byte_width,
831 &thread, return_compiler_type,
ConstString(
""), return_ext);
849 &thread,
"",
Address(storage_addr,
nullptr), return_compiler_type);
853 return return_valobj_sp;
868 row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 8);
869 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, -8,
false);
870 row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0,
true);
892 const int32_t ptr_size = 8;
893 row->GetCFAValue().SetIsRegisterPlusOffset(
dwarf_rbp, 2 * ptr_size);
895 row->SetUnspecifiedRegistersAreUndefined(
true);
897 row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2,
true);
898 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1,
true);
899 row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0,
true);
925 assert(reg_info->
name !=
nullptr &&
"unnamed register?");
926 std::string Name = std::string(reg_info->
name);
928 llvm::StringSwitch<bool>(Name)
929 .Cases(
"r12",
"r13",
"r14",
"r15",
"rbp",
"ebp",
"rbx",
"ebx",
true)
930 .Cases(
"rip",
"eip",
"rsp",
"esp",
"sp",
"fp",
"pc",
true)
932 return IsCalleeSaved;
936 return llvm::StringSwitch<uint32_t>(name)
static bool ReadIntegerArgument(Scalar &scalar, unsigned int bit_width, bool is_signed, Thread &thread, uint32_t *argument_register_ids, unsigned int ¤t_argument_register, addr_t ¤t_stack_argument)
static bool FlattenAggregateType(Thread &thread, ExecutionContext &exe_ctx, CompilerType &return_compiler_type, uint32_t data_byte_offset, std::vector< uint32_t > &aggregate_field_offsets, std::vector< CompilerType > &aggregate_compiler_types)
static bool ReadIntegerArgument(Scalar &scalar, unsigned int bit_width, bool is_signed, Thread &thread, uint32_t *argument_register_ids, unsigned int ¤t_argument_register, addr_t ¤t_stack_argument)
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOGF(log,...)
#define LLDB_PLUGIN_DEFINE(PluginName)
bool GetArgumentValues(lldb_private::Thread &thread, lldb_private::ValueList &values) const override
bool CreateDefaultUnwindPlan(lldb_private::UnwindPlan &unwind_plan) override
static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch)
bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info)
bool GetPointerReturnRegister(const char *&name) override
lldb_private::Status SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value) override
uint32_t GetGenericNum(llvm::StringRef reg) override
Return the generic number of the given register.
lldb::ValueObjectSP GetReturnValueObjectImpl(lldb_private::Thread &thread, lldb_private::CompilerType &type) const override
size_t GetRedZoneSize() const override
lldb::ValueObjectSP GetReturnValueObjectSimple(lldb_private::Thread &thread, lldb_private::CompilerType &ast_type) const
static llvm::StringRef GetPluginNameStatic()
bool CreateFunctionEntryUnwindPlan(lldb_private::UnwindPlan &unwind_plan) override
bool RegisterIsVolatile(const lldb_private::RegisterInfo *reg_info) override
bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp, lldb::addr_t functionAddress, lldb::addr_t returnAddress, llvm::ArrayRef< lldb::addr_t > args) const override
static std::unique_ptr< llvm::MCRegisterInfo > MakeMCRegisterInfo(const ArchSpec &arch)
Utility function to construct a MCRegisterInfo using the ArchSpec triple.
A section + offset based address class.
An architecture specification class.
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
llvm::Triple & GetTriple()
Architecture triple accessor.
lldb::ByteOrder GetByteOrder() const
Returns the byte order for the architecture specification.
Generic representation of a type in a programming language.
TypeSystemSPWrapper GetTypeSystem() const
Accessors.
std::optional< uint64_t > GetByteSize(ExecutionContextScope *exe_scope) const
Return the size of the type in bytes.
CompilerType GetFieldAtIndex(size_t idx, std::string &name, uint64_t *bit_offset_ptr, uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr) const
bool IsFloatingPointType(uint32_t &count, bool &is_complex) const
uint32_t GetNumFields() const
bool IsIntegerOrEnumerationType(bool &is_signed) const
bool IsAggregateType() const
uint32_t GetTypeInfo(CompilerType *pointee_or_element_compiler_type=nullptr) const
std::optional< uint64_t > GetBitSize(ExecutionContextScope *exe_scope) const
Return the size of the type in bits.
bool IsPointerType(CompilerType *pointee_type=nullptr) const
A uniqued constant string class.
A subclass of DataBuffer that stores a data buffer on the heap.
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
Target * GetTargetPtr() const
Returns a pointer to the target object.
void PutString(llvm::StringRef str)
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
static bool UnregisterPlugin(ABICreateInstance create_callback)
uint64_t GetSP(uint64_t fail_value=LLDB_INVALID_ADDRESS)
virtual bool WriteRegister(const RegisterInfo *reg_info, const RegisterValue ®_value)=0
const RegisterInfo * GetRegisterInfo(lldb::RegisterKind reg_kind, uint32_t reg_num)
bool WriteRegisterFromUnsigned(uint32_t reg, uint64_t uval)
const RegisterInfo * GetRegisterInfoByName(llvm::StringRef reg_name, uint32_t start_idx=0)
virtual bool ReadRegister(const RegisterInfo *reg_info, RegisterValue ®_value)=0
bool GetData(DataExtractor &data) const
uint32_t GetAsMemoryData(const RegisterInfo ®_info, void *dst, uint32_t dst_len, lldb::ByteOrder dst_byte_order, Status &error) const
void SetBytes(const void *bytes, size_t length, lldb::ByteOrder byte_order)
bool SignExtend(uint32_t bit_pos)
static Status FromErrorStringWithFormat(const char *format,...) __attribute__((format(printf
static Status FromErrorString(const char *str)
bool Fail() const
Test for error condition.
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
llvm::StringRef GetString() const
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
const ArchSpec & GetArchitecture() const
virtual lldb::StackFrameSP GetStackFrameAtIndex(uint32_t idx)
virtual lldb::RegisterContextSP GetRegisterContext()=0
lldb::ProcessSP GetProcess() const
void SetUnwindPlanForSignalTrap(lldb_private::LazyBool is_for_signal_trap)
void SetRegisterKind(lldb::RegisterKind kind)
void AppendRow(const RowSP &row_sp)
std::shared_ptr< Row > RowSP
void SetSourcedFromCompiler(lldb_private::LazyBool from_compiler)
void SetSourceName(const char *)
void SetUnwindPlanValidAtAllInstructions(lldb_private::LazyBool valid_at_all_insn)
Value * GetValueAtIndex(size_t idx)
static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope, lldb::ByteOrder byte_order, uint32_t addr_byte_size, lldb::addr_t address=LLDB_INVALID_ADDRESS)
static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope, llvm::StringRef name, const Address &address, lldb::TypeSP &type_sp)
const Scalar & GetScalar() const
void SetCompilerType(const CompilerType &compiler_type)
void SetValueType(ValueType value_type)
const CompilerType & GetCompilerType()
#define LLDB_REGNUM_GENERIC_ARG6
#define LLDB_REGNUM_GENERIC_SP
#define LLDB_REGNUM_GENERIC_ARG4
#define LLDB_REGNUM_GENERIC_ARG3
#define LLDB_REGNUM_GENERIC_ARG1
#define LLDB_REGNUM_GENERIC_FLAGS
#define LLDB_INVALID_REGNUM
#define LLDB_REGNUM_GENERIC_ARG2
#define LLDB_REGNUM_GENERIC_PC
#define LLDB_REGNUM_GENERIC_FP
#define LLDB_REGNUM_GENERIC_ARG5
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
std::shared_ptr< lldb_private::ABI > ABISP
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
std::shared_ptr< lldb_private::Process > ProcessSP
ByteOrder
Byte ordering definitions.
std::shared_ptr< lldb_private::DataBuffer > DataBufferSP
std::shared_ptr< lldb_private::WritableDataBuffer > WritableDataBufferSP
std::shared_ptr< lldb_private::RegisterContext > RegisterContextSP
@ eRegisterKindGeneric
insn ptr reg, stack ptr reg, etc not specific to any particular target
@ eRegisterKindLLDB
lldb's internal register numbers
@ eRegisterKindDWARF
the register numbers seen DWARF
Every register is described in detail including its name, alternate name (optional),...
uint32_t byte_size
Size in bytes of the register.
uint32_t kinds[lldb::kNumRegisterKinds]
Holds all of the various register numbers for all register kinds.
const char * name
Name of this register, can't be NULL.
lldb::user_id_t GetID() const
Get accessor for the user ID.