720 lines · cpp
1//===-- ABISysV_s390x.cpp -------------------------------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#include "ABISysV_s390x.h"10 11#include "llvm/ADT/STLExtras.h"12#include "llvm/TargetParser/Triple.h"13 14#include "lldb/Core/Module.h"15#include "lldb/Core/PluginManager.h"16#include "lldb/Core/Value.h"17#include "lldb/Symbol/UnwindPlan.h"18#include "lldb/Target/Process.h"19#include "lldb/Target/RegisterContext.h"20#include "lldb/Target/StackFrame.h"21#include "lldb/Target/Target.h"22#include "lldb/Target/Thread.h"23#include "lldb/Utility/ConstString.h"24#include "lldb/Utility/DataExtractor.h"25#include "lldb/Utility/LLDBLog.h"26#include "lldb/Utility/Log.h"27#include "lldb/Utility/RegisterValue.h"28#include "lldb/Utility/Status.h"29#include "lldb/ValueObject/ValueObjectConstResult.h"30#include "lldb/ValueObject/ValueObjectMemory.h"31#include "lldb/ValueObject/ValueObjectRegister.h"32#include <optional>33 34using namespace lldb;35using namespace lldb_private;36 37LLDB_PLUGIN_DEFINE_ADV(ABISysV_s390x, ABISystemZ)38 39enum dwarf_regnums {40 // General Purpose Registers41 dwarf_r0_s390x = 0,42 dwarf_r1_s390x,43 dwarf_r2_s390x,44 dwarf_r3_s390x,45 dwarf_r4_s390x,46 dwarf_r5_s390x,47 dwarf_r6_s390x,48 dwarf_r7_s390x,49 dwarf_r8_s390x,50 dwarf_r9_s390x,51 dwarf_r10_s390x,52 dwarf_r11_s390x,53 dwarf_r12_s390x,54 dwarf_r13_s390x,55 dwarf_r14_s390x,56 dwarf_r15_s390x,57 // Floating Point Registers / Vector Registers 0-1558 dwarf_f0_s390x = 16,59 dwarf_f2_s390x,60 dwarf_f4_s390x,61 dwarf_f6_s390x,62 dwarf_f1_s390x,63 dwarf_f3_s390x,64 dwarf_f5_s390x,65 dwarf_f7_s390x,66 dwarf_f8_s390x,67 dwarf_f10_s390x,68 dwarf_f12_s390x,69 dwarf_f14_s390x,70 dwarf_f9_s390x,71 dwarf_f11_s390x,72 dwarf_f13_s390x,73 dwarf_f15_s390x,74 // Access Registers75 dwarf_acr0_s390x = 48,76 dwarf_acr1_s390x,77 dwarf_acr2_s390x,78 dwarf_acr3_s390x,79 dwarf_acr4_s390x,80 dwarf_acr5_s390x,81 dwarf_acr6_s390x,82 dwarf_acr7_s390x,83 dwarf_acr8_s390x,84 dwarf_acr9_s390x,85 dwarf_acr10_s390x,86 dwarf_acr11_s390x,87 dwarf_acr12_s390x,88 dwarf_acr13_s390x,89 dwarf_acr14_s390x,90 dwarf_acr15_s390x,91 // Program Status Word92 dwarf_pswm_s390x = 64,93 dwarf_pswa_s390x,94 // Vector Registers 16-3195 dwarf_v16_s390x = 68,96 dwarf_v18_s390x,97 dwarf_v20_s390x,98 dwarf_v22_s390x,99 dwarf_v17_s390x,100 dwarf_v19_s390x,101 dwarf_v21_s390x,102 dwarf_v23_s390x,103 dwarf_v24_s390x,104 dwarf_v26_s390x,105 dwarf_v28_s390x,106 dwarf_v30_s390x,107 dwarf_v25_s390x,108 dwarf_v27_s390x,109 dwarf_v29_s390x,110 dwarf_v31_s390x,111};112 113// RegisterKind: EHFrame, DWARF, Generic, Process Plugin, LLDB114 115#define DEFINE_REG(name, size, alt, generic) \116 { \117 #name, alt, size, 0, eEncodingUint, eFormatHex, \118 {dwarf_##name##_s390x, dwarf_##name##_s390x, generic, \119 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM }, \120 nullptr, nullptr, nullptr, \121 }122 123static const RegisterInfo g_register_infos[] = {124 DEFINE_REG(r0, 8, nullptr, LLDB_INVALID_REGNUM),125 DEFINE_REG(r1, 8, nullptr, LLDB_INVALID_REGNUM),126 DEFINE_REG(r2, 8, nullptr, LLDB_REGNUM_GENERIC_ARG1),127 DEFINE_REG(r3, 8, nullptr, LLDB_REGNUM_GENERIC_ARG2),128 DEFINE_REG(r4, 8, nullptr, LLDB_REGNUM_GENERIC_ARG3),129 DEFINE_REG(r5, 8, nullptr, LLDB_REGNUM_GENERIC_ARG4),130 DEFINE_REG(r6, 8, nullptr, LLDB_REGNUM_GENERIC_ARG5),131 DEFINE_REG(r7, 8, nullptr, LLDB_INVALID_REGNUM),132 DEFINE_REG(r8, 8, nullptr, LLDB_INVALID_REGNUM),133 DEFINE_REG(r9, 8, nullptr, LLDB_INVALID_REGNUM),134 DEFINE_REG(r10, 8, nullptr, LLDB_INVALID_REGNUM),135 DEFINE_REG(r11, 8, nullptr, LLDB_REGNUM_GENERIC_FP),136 DEFINE_REG(r12, 8, nullptr, LLDB_INVALID_REGNUM),137 DEFINE_REG(r13, 8, nullptr, LLDB_INVALID_REGNUM),138 DEFINE_REG(r14, 8, nullptr, LLDB_INVALID_REGNUM),139 DEFINE_REG(r15, 8, "sp", LLDB_REGNUM_GENERIC_SP),140 DEFINE_REG(acr0, 4, nullptr, LLDB_INVALID_REGNUM),141 DEFINE_REG(acr1, 4, nullptr, LLDB_INVALID_REGNUM),142 DEFINE_REG(acr2, 4, nullptr, LLDB_INVALID_REGNUM),143 DEFINE_REG(acr3, 4, nullptr, LLDB_INVALID_REGNUM),144 DEFINE_REG(acr4, 4, nullptr, LLDB_INVALID_REGNUM),145 DEFINE_REG(acr5, 4, nullptr, LLDB_INVALID_REGNUM),146 DEFINE_REG(acr6, 4, nullptr, LLDB_INVALID_REGNUM),147 DEFINE_REG(acr7, 4, nullptr, LLDB_INVALID_REGNUM),148 DEFINE_REG(acr8, 4, nullptr, LLDB_INVALID_REGNUM),149 DEFINE_REG(acr9, 4, nullptr, LLDB_INVALID_REGNUM),150 DEFINE_REG(acr10, 4, nullptr, LLDB_INVALID_REGNUM),151 DEFINE_REG(acr11, 4, nullptr, LLDB_INVALID_REGNUM),152 DEFINE_REG(acr12, 4, nullptr, LLDB_INVALID_REGNUM),153 DEFINE_REG(acr13, 4, nullptr, LLDB_INVALID_REGNUM),154 DEFINE_REG(acr14, 4, nullptr, LLDB_INVALID_REGNUM),155 DEFINE_REG(acr15, 4, nullptr, LLDB_INVALID_REGNUM),156 DEFINE_REG(pswm, 8, nullptr, LLDB_REGNUM_GENERIC_FLAGS),157 DEFINE_REG(pswa, 8, nullptr, LLDB_REGNUM_GENERIC_PC),158 DEFINE_REG(f0, 8, nullptr, LLDB_INVALID_REGNUM),159 DEFINE_REG(f1, 8, nullptr, LLDB_INVALID_REGNUM),160 DEFINE_REG(f2, 8, nullptr, LLDB_INVALID_REGNUM),161 DEFINE_REG(f3, 8, nullptr, LLDB_INVALID_REGNUM),162 DEFINE_REG(f4, 8, nullptr, LLDB_INVALID_REGNUM),163 DEFINE_REG(f5, 8, nullptr, LLDB_INVALID_REGNUM),164 DEFINE_REG(f6, 8, nullptr, LLDB_INVALID_REGNUM),165 DEFINE_REG(f7, 8, nullptr, LLDB_INVALID_REGNUM),166 DEFINE_REG(f8, 8, nullptr, LLDB_INVALID_REGNUM),167 DEFINE_REG(f9, 8, nullptr, LLDB_INVALID_REGNUM),168 DEFINE_REG(f10, 8, nullptr, LLDB_INVALID_REGNUM),169 DEFINE_REG(f11, 8, nullptr, LLDB_INVALID_REGNUM),170 DEFINE_REG(f12, 8, nullptr, LLDB_INVALID_REGNUM),171 DEFINE_REG(f13, 8, nullptr, LLDB_INVALID_REGNUM),172 DEFINE_REG(f14, 8, nullptr, LLDB_INVALID_REGNUM),173 DEFINE_REG(f15, 8, nullptr, LLDB_INVALID_REGNUM),174};175 176static const uint32_t k_num_register_infos = std::size(g_register_infos);177 178const lldb_private::RegisterInfo *179ABISysV_s390x::GetRegisterInfoArray(uint32_t &count) {180 count = k_num_register_infos;181 return g_register_infos;182}183 184size_t ABISysV_s390x::GetRedZoneSize() const { return 0; }185 186// Static Functions187 188ABISP189ABISysV_s390x::CreateInstance(lldb::ProcessSP process_sp, const ArchSpec &arch) {190 if (arch.GetTriple().getArch() == llvm::Triple::systemz) {191 return ABISP(new ABISysV_s390x(std::move(process_sp), MakeMCRegisterInfo(arch)));192 }193 return ABISP();194}195 196bool ABISysV_s390x::PrepareTrivialCall(Thread &thread, addr_t sp,197 addr_t func_addr, addr_t return_addr,198 llvm::ArrayRef<addr_t> args) const {199 Log *log = GetLog(LLDBLog::Expressions);200 201 if (log) {202 StreamString s;203 s.Printf("ABISysV_s390x::PrepareTrivialCall (tid = 0x%" PRIx64204 ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64205 ", return_addr = 0x%" PRIx64,206 thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,207 (uint64_t)return_addr);208 209 for (size_t i = 0; i < args.size(); ++i)210 s.Printf(", arg%" PRIu64 " = 0x%" PRIx64, static_cast<uint64_t>(i + 1),211 args[i]);212 s.PutCString(")");213 log->PutString(s.GetString());214 }215 216 RegisterContext *reg_ctx = thread.GetRegisterContext().get();217 if (!reg_ctx)218 return false;219 220 const RegisterInfo *pc_reg_info =221 reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);222 const RegisterInfo *sp_reg_info =223 reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);224 const RegisterInfo *ra_reg_info = reg_ctx->GetRegisterInfoByName("r14", 0);225 ProcessSP process_sp(thread.GetProcess());226 227 // Allocate a new stack frame and space for stack arguments if necessary228 229 addr_t arg_pos = 0;230 if (args.size() > 5) {231 sp -= 8 * (args.size() - 5);232 arg_pos = sp;233 }234 235 sp -= 160;236 237 // Process arguments238 239 for (size_t i = 0; i < args.size(); ++i) {240 if (i < 5) {241 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(242 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + i);243 LLDB_LOGF(log, "About to write arg%" PRIu64 " (0x%" PRIx64 ") into %s",244 static_cast<uint64_t>(i + 1), args[i], reg_info->name);245 if (!reg_ctx->WriteRegisterFromUnsigned(reg_info, args[i]))246 return false;247 } else {248 Status error;249 LLDB_LOGF(log, "About to write arg%" PRIu64 " (0x%" PRIx64 ") onto stack",250 static_cast<uint64_t>(i + 1), args[i]);251 if (!process_sp->WritePointerToMemory(arg_pos, args[i], error))252 return false;253 arg_pos += 8;254 }255 }256 257 // %r14 is set to the return address258 259 LLDB_LOGF(log, "Writing RA: 0x%" PRIx64, (uint64_t)return_addr);260 261 if (!reg_ctx->WriteRegisterFromUnsigned(ra_reg_info, return_addr))262 return false;263 264 // %r15 is set to the actual stack value.265 266 LLDB_LOGF(log, "Writing SP: 0x%" PRIx64, (uint64_t)sp);267 268 if (!reg_ctx->WriteRegisterFromUnsigned(sp_reg_info, sp))269 return false;270 271 // %pc is set to the address of the called function.272 273 LLDB_LOGF(log, "Writing PC: 0x%" PRIx64, (uint64_t)func_addr);274 275 if (!reg_ctx->WriteRegisterFromUnsigned(pc_reg_info, func_addr))276 return false;277 278 return true;279}280 281static bool ReadIntegerArgument(Scalar &scalar, unsigned int bit_width,282 bool is_signed, Thread &thread,283 uint32_t *argument_register_ids,284 unsigned int ¤t_argument_register,285 addr_t ¤t_stack_argument) {286 if (bit_width > 64)287 return false; // Scalar can't hold large integer arguments288 289 if (current_argument_register < 5) {290 scalar = thread.GetRegisterContext()->ReadRegisterAsUnsigned(291 argument_register_ids[current_argument_register], 0);292 current_argument_register++;293 if (is_signed)294 scalar.SignExtend(bit_width);295 } else {296 uint32_t byte_size = (bit_width + (8 - 1)) / 8;297 Status error;298 if (thread.GetProcess()->ReadScalarIntegerFromMemory(299 current_stack_argument + 8 - byte_size, byte_size, is_signed,300 scalar, error)) {301 current_stack_argument += 8;302 return true;303 }304 return false;305 }306 return true;307}308 309bool ABISysV_s390x::GetArgumentValues(Thread &thread, ValueList &values) const {310 unsigned int num_values = values.GetSize();311 unsigned int value_index;312 313 // Extract the register context so we can read arguments from registers314 315 RegisterContext *reg_ctx = thread.GetRegisterContext().get();316 317 if (!reg_ctx)318 return false;319 320 // Get the pointer to the first stack argument so we have a place to start321 // when reading data322 323 addr_t sp = reg_ctx->GetSP(0);324 325 if (!sp)326 return false;327 328 addr_t current_stack_argument = sp + 160;329 330 uint32_t argument_register_ids[5];331 332 argument_register_ids[0] =333 reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1)334 ->kinds[eRegisterKindLLDB];335 argument_register_ids[1] =336 reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG2)337 ->kinds[eRegisterKindLLDB];338 argument_register_ids[2] =339 reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG3)340 ->kinds[eRegisterKindLLDB];341 argument_register_ids[3] =342 reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG4)343 ->kinds[eRegisterKindLLDB];344 argument_register_ids[4] =345 reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG5)346 ->kinds[eRegisterKindLLDB];347 348 unsigned int current_argument_register = 0;349 350 for (value_index = 0; value_index < num_values; ++value_index) {351 Value *value = values.GetValueAtIndex(value_index);352 353 if (!value)354 return false;355 356 // We currently only support extracting values with Clang QualTypes. Do we357 // care about others?358 CompilerType compiler_type = value->GetCompilerType();359 std::optional<uint64_t> bit_size =360 llvm::expectedToOptional(compiler_type.GetBitSize(&thread));361 if (!bit_size)362 return false;363 bool is_signed;364 365 if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {366 ReadIntegerArgument(value->GetScalar(), *bit_size, is_signed, thread,367 argument_register_ids, current_argument_register,368 current_stack_argument);369 } else if (compiler_type.IsPointerType()) {370 ReadIntegerArgument(value->GetScalar(), *bit_size, false, thread,371 argument_register_ids, current_argument_register,372 current_stack_argument);373 }374 }375 376 return true;377}378 379Status ABISysV_s390x::SetReturnValueObject(lldb::StackFrameSP &frame_sp,380 lldb::ValueObjectSP &new_value_sp) {381 Status error;382 if (!new_value_sp) {383 error = Status::FromErrorString("Empty value object for return value.");384 return error;385 }386 387 CompilerType compiler_type = new_value_sp->GetCompilerType();388 if (!compiler_type) {389 error = Status::FromErrorString("Null clang type for return value.");390 return error;391 }392 393 Thread *thread = frame_sp->GetThread().get();394 395 bool is_signed;396 bool is_complex;397 398 RegisterContext *reg_ctx = thread->GetRegisterContext().get();399 400 bool set_it_simple = false;401 if (compiler_type.IsIntegerOrEnumerationType(is_signed) ||402 compiler_type.IsPointerType()) {403 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName("r2", 0);404 405 DataExtractor data;406 Status data_error;407 size_t num_bytes = new_value_sp->GetData(data, data_error);408 if (data_error.Fail()) {409 error = Status::FromErrorStringWithFormat(410 "Couldn't convert return value to raw data: %s",411 data_error.AsCString());412 return error;413 }414 lldb::offset_t offset = 0;415 if (num_bytes <= 8) {416 uint64_t raw_value = data.GetMaxU64(&offset, num_bytes);417 418 if (reg_ctx->WriteRegisterFromUnsigned(reg_info, raw_value))419 set_it_simple = true;420 } else {421 error = Status::FromErrorString(422 "We don't support returning longer than 64 bit "423 "integer values at present.");424 }425 } else if (compiler_type.IsFloatingPointType(is_complex)) {426 if (is_complex)427 error = Status::FromErrorString(428 "We don't support returning complex values at present");429 else {430 std::optional<uint64_t> bit_width =431 llvm::expectedToOptional(compiler_type.GetBitSize(frame_sp.get()));432 if (!bit_width) {433 error = Status::FromErrorString("can't get type size");434 return error;435 }436 if (*bit_width <= 64) {437 const RegisterInfo *f0_info = reg_ctx->GetRegisterInfoByName("f0", 0);438 RegisterValue f0_value;439 DataExtractor data;440 Status data_error;441 size_t num_bytes = new_value_sp->GetData(data, data_error);442 if (data_error.Fail()) {443 error = Status::FromErrorStringWithFormat(444 "Couldn't convert return value to raw data: %s",445 data_error.AsCString());446 return error;447 }448 449 unsigned char buffer[8];450 ByteOrder byte_order = data.GetByteOrder();451 452 data.CopyByteOrderedData(0, num_bytes, buffer, 8, byte_order);453 f0_value.SetBytes(buffer, 8, byte_order);454 reg_ctx->WriteRegister(f0_info, f0_value);455 set_it_simple = true;456 } else {457 // FIXME - don't know how to do long doubles yet.458 error = Status::FromErrorString(459 "We don't support returning float values > 64 bits at present");460 }461 }462 }463 464 if (!set_it_simple) {465 // Okay we've got a structure or something that doesn't fit in a simple466 // register. We should figure out where it really goes, but we don't467 // support this yet.468 error = Status::FromErrorString(469 "We only support setting simple integer and float "470 "return types at present.");471 }472 473 return error;474}475 476ValueObjectSP ABISysV_s390x::GetReturnValueObjectSimple(477 Thread &thread, CompilerType &return_compiler_type) const {478 ValueObjectSP return_valobj_sp;479 Value value;480 481 if (!return_compiler_type)482 return return_valobj_sp;483 484 // value.SetContext (Value::eContextTypeClangType, return_value_type);485 value.SetCompilerType(return_compiler_type);486 487 RegisterContext *reg_ctx = thread.GetRegisterContext().get();488 if (!reg_ctx)489 return return_valobj_sp;490 491 const uint32_t type_flags = return_compiler_type.GetTypeInfo();492 if (type_flags & eTypeIsScalar) {493 value.SetValueType(Value::ValueType::Scalar);494 495 bool success = false;496 if (type_flags & eTypeIsInteger) {497 // Extract the register context so we can read arguments from registers.498 std::optional<uint64_t> byte_size =499 llvm::expectedToOptional(return_compiler_type.GetByteSize(&thread));500 if (!byte_size)501 return return_valobj_sp;502 uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(503 reg_ctx->GetRegisterInfoByName("r2", 0), 0);504 const bool is_signed = (type_flags & eTypeIsSigned) != 0;505 switch (*byte_size) {506 default:507 break;508 509 case sizeof(uint64_t):510 if (is_signed)511 value.GetScalar() = (int64_t)(raw_value);512 else513 value.GetScalar() = (uint64_t)(raw_value);514 success = true;515 break;516 517 case sizeof(uint32_t):518 if (is_signed)519 value.GetScalar() = (int32_t)(raw_value & UINT32_MAX);520 else521 value.GetScalar() = (uint32_t)(raw_value & UINT32_MAX);522 success = true;523 break;524 525 case sizeof(uint16_t):526 if (is_signed)527 value.GetScalar() = (int16_t)(raw_value & UINT16_MAX);528 else529 value.GetScalar() = (uint16_t)(raw_value & UINT16_MAX);530 success = true;531 break;532 533 case sizeof(uint8_t):534 if (is_signed)535 value.GetScalar() = (int8_t)(raw_value & UINT8_MAX);536 else537 value.GetScalar() = (uint8_t)(raw_value & UINT8_MAX);538 success = true;539 break;540 }541 } else if (type_flags & eTypeIsFloat) {542 if (type_flags & eTypeIsComplex) {543 // Don't handle complex yet.544 } else {545 std::optional<uint64_t> byte_size =546 llvm::expectedToOptional(return_compiler_type.GetByteSize(&thread));547 if (byte_size && *byte_size <= sizeof(long double)) {548 const RegisterInfo *f0_info = reg_ctx->GetRegisterInfoByName("f0", 0);549 RegisterValue f0_value;550 if (reg_ctx->ReadRegister(f0_info, f0_value)) {551 DataExtractor data;552 if (f0_value.GetData(data)) {553 lldb::offset_t offset = 0;554 if (*byte_size == sizeof(float)) {555 value.GetScalar() = (float)data.GetFloat(&offset);556 success = true;557 } else if (*byte_size == sizeof(double)) {558 value.GetScalar() = (double)data.GetDouble(&offset);559 success = true;560 } else if (*byte_size == sizeof(long double)) {561 // Don't handle long double yet.562 }563 }564 }565 }566 }567 }568 569 if (success)570 return_valobj_sp = ValueObjectConstResult::Create(571 thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));572 } else if (type_flags & eTypeIsPointer) {573 unsigned r2_id =574 reg_ctx->GetRegisterInfoByName("r2", 0)->kinds[eRegisterKindLLDB];575 value.GetScalar() =576 (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r2_id, 0);577 value.SetValueType(Value::ValueType::Scalar);578 return_valobj_sp = ValueObjectConstResult::Create(579 thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));580 }581 582 return return_valobj_sp;583}584 585ValueObjectSP ABISysV_s390x::GetReturnValueObjectImpl(586 Thread &thread, CompilerType &return_compiler_type) const {587 ValueObjectSP return_valobj_sp;588 589 if (!return_compiler_type)590 return return_valobj_sp;591 592 ExecutionContext exe_ctx(thread.shared_from_this());593 return_valobj_sp = GetReturnValueObjectSimple(thread, return_compiler_type);594 if (return_valobj_sp)595 return return_valobj_sp;596 597 RegisterContextSP reg_ctx_sp = thread.GetRegisterContext();598 if (!reg_ctx_sp)599 return return_valobj_sp;600 601 if (return_compiler_type.IsAggregateType()) {602 // FIXME: This is just taking a guess, r2 may very well no longer hold the603 // return storage location.604 // If we are going to do this right, when we make a new frame we should605 // check to see if it uses a memory return, and if we are at the first606 // instruction and if so stash away the return location. Then we would607 // only return the memory return value if we know it is valid.608 609 unsigned r2_id =610 reg_ctx_sp->GetRegisterInfoByName("r2", 0)->kinds[eRegisterKindLLDB];611 lldb::addr_t storage_addr =612 (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r2_id, 0);613 return_valobj_sp = ValueObjectMemory::Create(614 &thread, "", Address(storage_addr, nullptr), return_compiler_type);615 }616 617 return return_valobj_sp;618}619 620UnwindPlanSP ABISysV_s390x::CreateFunctionEntryUnwindPlan() {621 UnwindPlan::Row row;622 623 // Our Call Frame Address is the stack pointer value + 160624 row.GetCFAValue().SetIsRegisterPlusOffset(dwarf_r15_s390x, 160);625 626 // The previous PC is in r14627 row.SetRegisterLocationToRegister(dwarf_pswa_s390x, dwarf_r14_s390x, true);628 629 // All other registers are the same.630 auto plan_sp = std::make_shared<UnwindPlan>(eRegisterKindDWARF);631 plan_sp->AppendRow(std::move(row));632 plan_sp->SetSourceName("s390x at-func-entry default");633 plan_sp->SetSourcedFromCompiler(eLazyBoolNo);634 return plan_sp;635}636 637UnwindPlanSP ABISysV_s390x::CreateDefaultUnwindPlan() {638 // There's really no default way to unwind on s390x. Trust the .eh_frame CFI,639 // which should always be good.640 return nullptr;641}642 643bool ABISysV_s390x::GetFallbackRegisterLocation(644 const RegisterInfo *reg_info,645 UnwindPlan::Row::AbstractRegisterLocation &unwind_regloc) {646 // If a volatile register is being requested, we don't want to forward the647 // next frame's register contents up the stack -- the register is not648 // retrievable at this frame.649 if (RegisterIsVolatile(reg_info)) {650 unwind_regloc.SetUndefined();651 return true;652 }653 654 return false;655}656 657bool ABISysV_s390x::RegisterIsVolatile(const RegisterInfo *reg_info) {658 return !RegisterIsCalleeSaved(reg_info);659}660 661bool ABISysV_s390x::RegisterIsCalleeSaved(const RegisterInfo *reg_info) {662 if (reg_info) {663 // Preserved registers are :664 // r6-r13, r15665 // f8-f15666 667 const char *name = reg_info->name;668 if (name[0] == 'r') {669 switch (name[1]) {670 case '6': // r6671 case '7': // r7672 case '8': // r8673 case '9': // r9674 return name[2] == '\0';675 676 case '1': // r10, r11, r12, r13, r15677 if ((name[2] >= '0' && name[2] <= '3') || name[2] == '5')678 return name[3] == '\0';679 break;680 681 default:682 break;683 }684 }685 if (name[0] == 'f') {686 switch (name[1]) {687 case '8': // r8688 case '9': // r9689 return name[2] == '\0';690 691 case '1': // r10, r11, r12, r13, r14, r15692 if (name[2] >= '0' && name[2] <= '5')693 return name[3] == '\0';694 break;695 696 default:697 break;698 }699 }700 701 // Accept shorter-variant versions702 if (name[0] == 's' && name[1] == 'p' && name[2] == '\0') // sp703 return true;704 if (name[0] == 'f' && name[1] == 'p' && name[2] == '\0') // fp705 return true;706 if (name[0] == 'p' && name[1] == 'c' && name[2] == '\0') // pc707 return true;708 }709 return false;710}711 712void ABISysV_s390x::Initialize() {713 PluginManager::RegisterPlugin(714 GetPluginNameStatic(), "System V ABI for s390x targets", CreateInstance);715}716 717void ABISysV_s390x::Terminate() {718 PluginManager::UnregisterPlugin(CreateInstance);719}720