15 #include <type_traits>
18 #include "llvm/ADT/Triple.h"
19 #include "llvm/IR/DerivedTypes.h"
20 #include "llvm/Support/MathExtras.h"
38 #define DEFINE_REG_NAME(reg_num) ConstString(#reg_num).GetCString()
39 #define DEFINE_REG_NAME_STR(reg_name) ConstString(reg_name).GetCString()
44 #define DEFINE_GENERIC_REGISTER_STUB(dwarf_num, str_name, generic_num) \
46 DEFINE_REG_NAME(dwarf_num), DEFINE_REG_NAME_STR(str_name), \
47 0, 0, eEncodingInvalid, eFormatDefault, \
48 { dwarf_num, dwarf_num, generic_num, LLDB_INVALID_REGNUM, dwarf_num }, \
52 #define DEFINE_REGISTER_STUB(dwarf_num, str_name) \
53 DEFINE_GENERIC_REGISTER_STUB(dwarf_num, str_name, LLDB_INVALID_REGNUM)
63 r0, r1, r2, r3, r4, r5, r6, r7,
r8,
r9,
r10,
r11,
r12,
r13,
r14,
r15, r16,
64 r17, r18, r19, r20, r21, r22, r23, r24, r25, r26,
65 r27,
fp = r27, r28,
sp = r28, r29, r30, r31, blink = r31,
66 r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46,
67 r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60,
68 r63 = 63,
pc = 70, status32 = 74
147 if (!m_is_reg_file_reduced) {
153 const uint32_t rf_entries_bit = 1U << 9U;
154 m_is_reg_file_reduced = (reg_value | rf_entries_bit) != 0;
157 return m_is_reg_file_reduced.value_or(
false);
165 return llvm::Triple::arc == arch.
GetTriple().getArch() ?
166 ABISP(
new ABISysV_arc(std::move(process_sp), MakeMCRegisterInfo(arch))) :
174 return llvm::alignTo(size_in_bytes,
word_size);
179 size_t total_size = 0;
180 for (
const auto &arg : args)
182 (ABI::CallArgument::TargetValue == arg.type ?
AugmentArgSize(arg.size)
191 llvm::ArrayRef<addr_t> args)
const {
198 llvm::ArrayRef<ABI::CallArgument> args)
const {
203 uint32_t pc_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(
208 uint32_t ra_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(
213 uint32_t sp_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(
224 for (
const auto &arg : args) {
226 if (arg.type == ABI::CallArgument::TargetValue)
232 if (process->WriteMemory(
sp, arg.data_up.get(), arg.size,
error) < arg.size
237 *
const_cast<addr_t *
>(&arg.value) =
sp;
241 assert(!prototype.isFunctionVarArg());
242 assert(prototype.getFunctionNumParams() == args.size());
244 const size_t regs_for_args_count = IsRegisterFileReduced(*reg_ctx) ? 4U : 8U;
249 args_size <= regs_for_args_count ? 0 : args_size - regs_for_args_count;
255 for (
const auto &arg : args) {
256 auto value =
reinterpret_cast<const uint8_t *
>(&arg.value);
258 ABI::CallArgument::TargetValue == arg.type ? arg.size :
reg_size;
261 while (size > 0 && reg_index < regs_for_args_count) {
262 size_t byte_index = 0;
265 while (byte_index < end) {
266 reg_value[byte_index++] = *(value++);
271 reg_value[byte_index++] = 0;
276 if (!reg_ctx->WriteRegister(
285 if (reg_index < regs_for_args_count || size == 0)
289 if (process->WriteMemory(
sp - offset, value, size,
error) < size ||
300 reg_ctx->WriteRegisterFromUnsigned(pc_reg,
pc);
301 reg_ctx->WriteRegisterFromUnsigned(ra_reg,
ra);
302 reg_ctx->WriteRegisterFromUnsigned(sp_reg,
sp);
312 ValueObjectSP &new_value_sp) {
319 CompilerType compiler_type = new_value_sp->GetCompilerType();
320 if (!compiler_type) {
325 auto ®_ctx = *frame_sp->GetThread()->GetRegisterContext();
327 bool is_signed =
false;
330 result.
SetErrorString(
"We don't support returning other types at present");
335 size_t num_bytes = new_value_sp->
GetData(data, result);
339 "Couldn't convert return value to raw data: %s", result.
AsCString());
345 uint64_t raw_value = data.
GetMaxU64(&offset, num_bytes);
349 if (!reg_ctx.WriteRegisterFromUnsigned(reg_info, raw_value)) {
361 if (!reg_ctx.WriteRegisterFromUnsigned(reg_info, raw_value)) {
370 "We don't support returning large integer values at present.");
374 template <
typename T>
376 raw_value &= std::numeric_limits<T>::max();
378 scalar =
static_cast<typename std::make_signed<T>::type
>(raw_value);
380 scalar =
static_cast<T
>(raw_value);
384 uint8_t size_in_bytes,
bool is_signed) {
385 switch (size_in_bytes) {
389 case sizeof(uint64_t):
390 SetInteger<uint64_t>(scalar, raw_value, is_signed);
394 SetInteger<uint32_t>(scalar, raw_value, is_signed);
398 SetInteger<uint16_t>(scalar, raw_value, is_signed);
401 case sizeof(uint8_t):
402 SetInteger<uint8_t>(scalar, raw_value, is_signed);
410 uint8_t size_in_bytes) {
411 switch (size_in_bytes) {
415 case sizeof(uint64_t):
416 scalar = *
reinterpret_cast<double *
>(&raw_value);
420 scalar = *
reinterpret_cast<float *
>(&raw_value);
428 uint8_t size_in_bytes) {
434 reg_ctx->ReadRegisterAsUnsigned(reg_info_r0, 0) &
UINT32_MAX;
436 if (
sizeof(uint64_t) == size_in_bytes)
437 raw_value |= (reg_ctx->ReadRegisterAsUnsigned(
449 return ValueObjectSP();
453 return ValueObjectSP();
460 if (type_flags & eTypeIsInteger) {
461 const size_t byte_size = compiler_type.
GetByteSize(&thread).value_or(0);
464 const bool is_signed = (type_flags & eTypeIsSigned) != 0;
466 return ValueObjectSP();
471 else if (type_flags & eTypeIsPointer) {
474 value.
GetScalar() = reg_ctx->ReadRegisterAsUnsigned(reg_info_r0, 0);
479 else if (type_flags & eTypeIsFloat) {
481 bool is_complex =
false;
484 1 == float_count && !is_complex) {
485 const size_t byte_size = compiler_type.
GetByteSize(&thread).value_or(0);
489 return ValueObjectSP();
494 return ValueObjectSP();
502 ValueObjectSP return_valobj_sp;
504 if (!return_compiler_type)
505 return return_valobj_sp;
508 return GetReturnValueObjectSimple(thread, return_compiler_type);
512 llvm::Type &retType)
const {
515 return ValueObjectSP();
519 if (retType.isVoidTy()) {
523 else if (retType.isIntegerTy()) {
524 size_t byte_size = retType.getPrimitiveSizeInBits();
526 byte_size /= CHAR_BIT;
530 const bool is_signed =
false;
532 return ValueObjectSP();
535 else if (retType.isPointerTy()) {
538 value.
GetScalar() = reg_ctx->ReadRegisterAsUnsigned(reg_info_r0, 0);
542 else if (retType.isFloatingPointTy()) {
543 const size_t byte_size = retType.getPrimitiveSizeInBits() / CHAR_BIT;
547 return ValueObjectSP();
551 return ValueObjectSP();
564 row->GetCFAValue().SetIsRegisterPlusOffset(
dwarf::sp, 0);
567 row->SetRegisterLocationToRegister(
dwarf::pc, dwarf::blink,
true);
582 if (
nullptr == reg_info)
591 return ra_reg_name == reg_info->name;
595 PluginManager::RegisterPlugin(GetPluginNameStatic(),
596 "System V ABI for ARC targets", CreateInstance);
600 PluginManager::UnregisterPlugin(CreateInstance);