1 //===-- ABISysV_ppc64.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-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "ABISysV_ppc64.h" 10 11 #include "llvm/ADT/STLExtras.h" 12 #include "llvm/TargetParser/Triple.h" 13 14 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h" 15 #include "Utility/PPC64LE_DWARF_Registers.h" 16 #include "Utility/PPC64_DWARF_Registers.h" 17 #include "lldb/Core/Module.h" 18 #include "lldb/Core/PluginManager.h" 19 #include "lldb/Core/Value.h" 20 #include "lldb/Core/ValueObjectConstResult.h" 21 #include "lldb/Core/ValueObjectMemory.h" 22 #include "lldb/Core/ValueObjectRegister.h" 23 #include "lldb/Symbol/UnwindPlan.h" 24 #include "lldb/Target/Process.h" 25 #include "lldb/Target/RegisterContext.h" 26 #include "lldb/Target/StackFrame.h" 27 #include "lldb/Target/Target.h" 28 #include "lldb/Target/Thread.h" 29 #include "lldb/Utility/ConstString.h" 30 #include "lldb/Utility/DataExtractor.h" 31 #include "lldb/Utility/LLDBLog.h" 32 #include "lldb/Utility/Log.h" 33 #include "lldb/Utility/RegisterValue.h" 34 #include "lldb/Utility/Status.h" 35 36 #include "clang/AST/ASTContext.h" 37 #include "clang/AST/Attr.h" 38 #include "clang/AST/Decl.h" 39 40 #define DECLARE_REGISTER_INFOS_PPC64_STRUCT 41 #include "Plugins/Process/Utility/RegisterInfos_ppc64.h" 42 #undef DECLARE_REGISTER_INFOS_PPC64_STRUCT 43 44 #define DECLARE_REGISTER_INFOS_PPC64LE_STRUCT 45 #include "Plugins/Process/Utility/RegisterInfos_ppc64le.h" 46 #undef DECLARE_REGISTER_INFOS_PPC64LE_STRUCT 47 #include <optional> 48 49 using namespace lldb; 50 using namespace lldb_private; 51 52 LLDB_PLUGIN_DEFINE(ABISysV_ppc64) 53 54 const lldb_private::RegisterInfo * 55 ABISysV_ppc64::GetRegisterInfoArray(uint32_t &count) { 56 if (GetByteOrder() == lldb::eByteOrderLittle) { 57 count = std::size(g_register_infos_ppc64le); 58 return g_register_infos_ppc64le; 59 } else { 60 count = std::size(g_register_infos_ppc64); 61 return g_register_infos_ppc64; 62 } 63 } 64 65 size_t ABISysV_ppc64::GetRedZoneSize() const { return 224; } 66 67 lldb::ByteOrder ABISysV_ppc64::GetByteOrder() const { 68 return GetProcessSP()->GetByteOrder(); 69 } 70 71 // Static Functions 72 73 ABISP 74 ABISysV_ppc64::CreateInstance(lldb::ProcessSP process_sp, 75 const ArchSpec &arch) { 76 if (arch.GetTriple().isPPC64()) 77 return ABISP( 78 new ABISysV_ppc64(std::move(process_sp), MakeMCRegisterInfo(arch))); 79 return ABISP(); 80 } 81 82 bool ABISysV_ppc64::PrepareTrivialCall(Thread &thread, addr_t sp, 83 addr_t func_addr, addr_t return_addr, 84 llvm::ArrayRef<addr_t> args) const { 85 Log *log = GetLog(LLDBLog::Expressions); 86 87 if (log) { 88 StreamString s; 89 s.Printf("ABISysV_ppc64::PrepareTrivialCall (tid = 0x%" PRIx64 90 ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64 91 ", return_addr = 0x%" PRIx64, 92 thread.GetID(), (uint64_t)sp, (uint64_t)func_addr, 93 (uint64_t)return_addr); 94 95 for (size_t i = 0; i < args.size(); ++i) 96 s.Printf(", arg%" PRIu64 " = 0x%" PRIx64, static_cast<uint64_t>(i + 1), 97 args[i]); 98 s.PutCString(")"); 99 log->PutString(s.GetString()); 100 } 101 102 RegisterContext *reg_ctx = thread.GetRegisterContext().get(); 103 if (!reg_ctx) 104 return false; 105 106 const RegisterInfo *reg_info = nullptr; 107 108 if (args.size() > 8) // TODO handle more than 8 arguments 109 return false; 110 111 for (size_t i = 0; i < args.size(); ++i) { 112 reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, 113 LLDB_REGNUM_GENERIC_ARG1 + i); 114 LLDB_LOGF(log, "About to write arg%" PRIu64 " (0x%" PRIx64 ") into %s", 115 static_cast<uint64_t>(i + 1), args[i], reg_info->name); 116 if (!reg_ctx->WriteRegisterFromUnsigned(reg_info, args[i])) 117 return false; 118 } 119 120 // First, align the SP 121 122 LLDB_LOGF(log, "16-byte aligning SP: 0x%" PRIx64 " to 0x%" PRIx64, 123 (uint64_t)sp, (uint64_t)(sp & ~0xfull)); 124 125 sp &= ~(0xfull); // 16-byte alignment 126 127 sp -= 544; // allocate frame to save TOC, RA and SP. 128 129 Status error; 130 uint64_t reg_value; 131 const RegisterInfo *pc_reg_info = 132 reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); 133 const RegisterInfo *sp_reg_info = 134 reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP); 135 ProcessSP process_sp(thread.GetProcess()); 136 const RegisterInfo *lr_reg_info = 137 reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA); 138 const RegisterInfo *r2_reg_info = reg_ctx->GetRegisterInfoAtIndex(2); 139 const RegisterInfo *r12_reg_info = reg_ctx->GetRegisterInfoAtIndex(12); 140 141 // Save return address onto the stack. 142 LLDB_LOGF(log, 143 "Pushing the return address onto the stack: 0x%" PRIx64 144 "(+16): 0x%" PRIx64, 145 (uint64_t)sp, (uint64_t)return_addr); 146 if (!process_sp->WritePointerToMemory(sp + 16, return_addr, error)) 147 return false; 148 149 // Write the return address to link register. 150 LLDB_LOGF(log, "Writing LR: 0x%" PRIx64, (uint64_t)return_addr); 151 if (!reg_ctx->WriteRegisterFromUnsigned(lr_reg_info, return_addr)) 152 return false; 153 154 // Write target address to %r12 register. 155 LLDB_LOGF(log, "Writing R12: 0x%" PRIx64, (uint64_t)func_addr); 156 if (!reg_ctx->WriteRegisterFromUnsigned(r12_reg_info, func_addr)) 157 return false; 158 159 // Read TOC pointer value. 160 reg_value = reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0); 161 162 // Write TOC pointer onto the stack. 163 uint64_t stack_offset; 164 if (GetByteOrder() == lldb::eByteOrderLittle) 165 stack_offset = 24; 166 else 167 stack_offset = 40; 168 169 LLDB_LOGF(log, "Writing R2 (TOC) at SP(0x%" PRIx64 ")+%d: 0x%" PRIx64, 170 (uint64_t)(sp + stack_offset), (int)stack_offset, 171 (uint64_t)reg_value); 172 if (!process_sp->WritePointerToMemory(sp + stack_offset, reg_value, error)) 173 return false; 174 175 // Read the current SP value. 176 reg_value = reg_ctx->ReadRegisterAsUnsigned(sp_reg_info, 0); 177 178 // Save current SP onto the stack. 179 LLDB_LOGF(log, "Writing SP at SP(0x%" PRIx64 ")+0: 0x%" PRIx64, (uint64_t)sp, 180 (uint64_t)reg_value); 181 if (!process_sp->WritePointerToMemory(sp, reg_value, error)) 182 return false; 183 184 // %r1 is set to the actual stack value. 185 LLDB_LOGF(log, "Writing SP: 0x%" PRIx64, (uint64_t)sp); 186 187 if (!reg_ctx->WriteRegisterFromUnsigned(sp_reg_info, sp)) 188 return false; 189 190 // %pc is set to the address of the called function. 191 192 LLDB_LOGF(log, "Writing IP: 0x%" PRIx64, (uint64_t)func_addr); 193 194 if (!reg_ctx->WriteRegisterFromUnsigned(pc_reg_info, func_addr)) 195 return false; 196 197 return true; 198 } 199 200 static bool ReadIntegerArgument(Scalar &scalar, unsigned int bit_width, 201 bool is_signed, Thread &thread, 202 uint32_t *argument_register_ids, 203 unsigned int ¤t_argument_register, 204 addr_t ¤t_stack_argument) { 205 if (bit_width > 64) 206 return false; // Scalar can't hold large integer arguments 207 208 if (current_argument_register < 6) { 209 scalar = thread.GetRegisterContext()->ReadRegisterAsUnsigned( 210 argument_register_ids[current_argument_register], 0); 211 current_argument_register++; 212 if (is_signed) 213 scalar.SignExtend(bit_width); 214 } else { 215 uint32_t byte_size = (bit_width + (8 - 1)) / 8; 216 Status error; 217 if (thread.GetProcess()->ReadScalarIntegerFromMemory( 218 current_stack_argument, byte_size, is_signed, scalar, error)) { 219 current_stack_argument += byte_size; 220 return true; 221 } 222 return false; 223 } 224 return true; 225 } 226 227 bool ABISysV_ppc64::GetArgumentValues(Thread &thread, ValueList &values) const { 228 unsigned int num_values = values.GetSize(); 229 unsigned int value_index; 230 231 // Extract the register context so we can read arguments from registers 232 233 RegisterContext *reg_ctx = thread.GetRegisterContext().get(); 234 235 if (!reg_ctx) 236 return false; 237 238 // Get the pointer to the first stack argument so we have a place to start 239 // when reading data 240 241 addr_t sp = reg_ctx->GetSP(0); 242 243 if (!sp) 244 return false; 245 246 uint64_t stack_offset; 247 if (GetByteOrder() == lldb::eByteOrderLittle) 248 stack_offset = 32; 249 else 250 stack_offset = 48; 251 252 // jump over return address. 253 addr_t current_stack_argument = sp + stack_offset; 254 uint32_t argument_register_ids[8]; 255 256 for (size_t i = 0; i < 8; ++i) { 257 argument_register_ids[i] = 258 reg_ctx 259 ->GetRegisterInfo(eRegisterKindGeneric, 260 LLDB_REGNUM_GENERIC_ARG1 + i) 261 ->kinds[eRegisterKindLLDB]; 262 } 263 264 unsigned int current_argument_register = 0; 265 266 for (value_index = 0; value_index < num_values; ++value_index) { 267 Value *value = values.GetValueAtIndex(value_index); 268 269 if (!value) 270 return false; 271 272 // We currently only support extracting values with Clang QualTypes. Do we 273 // care about others? 274 CompilerType compiler_type = value->GetCompilerType(); 275 std::optional<uint64_t> bit_size = compiler_type.GetBitSize(&thread); 276 if (!bit_size) 277 return false; 278 bool is_signed; 279 280 if (compiler_type.IsIntegerOrEnumerationType(is_signed)) { 281 ReadIntegerArgument(value->GetScalar(), *bit_size, is_signed, thread, 282 argument_register_ids, current_argument_register, 283 current_stack_argument); 284 } else if (compiler_type.IsPointerType()) { 285 ReadIntegerArgument(value->GetScalar(), *bit_size, false, thread, 286 argument_register_ids, current_argument_register, 287 current_stack_argument); 288 } 289 } 290 291 return true; 292 } 293 294 Status ABISysV_ppc64::SetReturnValueObject(lldb::StackFrameSP &frame_sp, 295 lldb::ValueObjectSP &new_value_sp) { 296 Status error; 297 if (!new_value_sp) { 298 error.SetErrorString("Empty value object for return value."); 299 return error; 300 } 301 302 CompilerType compiler_type = new_value_sp->GetCompilerType(); 303 if (!compiler_type) { 304 error.SetErrorString("Null clang type for return value."); 305 return error; 306 } 307 308 Thread *thread = frame_sp->GetThread().get(); 309 310 bool is_signed; 311 uint32_t count; 312 bool is_complex; 313 314 RegisterContext *reg_ctx = thread->GetRegisterContext().get(); 315 316 bool set_it_simple = false; 317 if (compiler_type.IsIntegerOrEnumerationType(is_signed) || 318 compiler_type.IsPointerType()) { 319 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName("r3", 0); 320 321 DataExtractor data; 322 Status data_error; 323 size_t num_bytes = new_value_sp->GetData(data, data_error); 324 if (data_error.Fail()) { 325 error.SetErrorStringWithFormat( 326 "Couldn't convert return value to raw data: %s", 327 data_error.AsCString()); 328 return error; 329 } 330 lldb::offset_t offset = 0; 331 if (num_bytes <= 8) { 332 uint64_t raw_value = data.GetMaxU64(&offset, num_bytes); 333 334 if (reg_ctx->WriteRegisterFromUnsigned(reg_info, raw_value)) 335 set_it_simple = true; 336 } else { 337 error.SetErrorString("We don't support returning longer than 64 bit " 338 "integer values at present."); 339 } 340 } else if (compiler_type.IsFloatingPointType(count, is_complex)) { 341 if (is_complex) 342 error.SetErrorString( 343 "We don't support returning complex values at present"); 344 else { 345 std::optional<uint64_t> bit_width = 346 compiler_type.GetBitSize(frame_sp.get()); 347 if (!bit_width) { 348 error.SetErrorString("can't get size of type"); 349 return error; 350 } 351 if (*bit_width <= 64) { 352 DataExtractor data; 353 Status data_error; 354 size_t num_bytes = new_value_sp->GetData(data, data_error); 355 if (data_error.Fail()) { 356 error.SetErrorStringWithFormat( 357 "Couldn't convert return value to raw data: %s", 358 data_error.AsCString()); 359 return error; 360 } 361 362 unsigned char buffer[16]; 363 ByteOrder byte_order = data.GetByteOrder(); 364 365 data.CopyByteOrderedData(0, num_bytes, buffer, 16, byte_order); 366 set_it_simple = true; 367 } else { 368 // FIXME - don't know how to do 80 bit long doubles yet. 369 error.SetErrorString( 370 "We don't support returning float values > 64 bits at present"); 371 } 372 } 373 } 374 375 if (!set_it_simple) { 376 // Okay we've got a structure or something that doesn't fit in a simple 377 // register. We should figure out where it really goes, but we don't 378 // support this yet. 379 error.SetErrorString("We only support setting simple integer and float " 380 "return types at present."); 381 } 382 383 return error; 384 } 385 386 // 387 // ReturnValueExtractor 388 // 389 390 namespace { 391 392 #define LOG_PREFIX "ReturnValueExtractor: " 393 394 class ReturnValueExtractor { 395 // This class represents a register, from which data may be extracted. 396 // 397 // It may be constructed by directly specifying its index (where 0 is the 398 // first register used to return values) or by specifying the offset of a 399 // given struct field, in which case the appropriated register index will be 400 // calculated. 401 class Register { 402 public: 403 enum Type { 404 GPR, // General Purpose Register 405 FPR // Floating Point Register 406 }; 407 408 // main constructor 409 // 410 // offs - field offset in struct 411 Register(Type ty, uint32_t index, uint32_t offs, RegisterContext *reg_ctx, 412 ByteOrder byte_order) 413 : m_index(index), m_offs(offs % sizeof(uint64_t)), 414 m_avail(sizeof(uint64_t) - m_offs), m_type(ty), m_reg_ctx(reg_ctx), 415 m_byte_order(byte_order) {} 416 417 // explicit index, no offset 418 Register(Type ty, uint32_t index, RegisterContext *reg_ctx, 419 ByteOrder byte_order) 420 : Register(ty, index, 0, reg_ctx, byte_order) {} 421 422 // GPR, calculate index from offs 423 Register(uint32_t offs, RegisterContext *reg_ctx, ByteOrder byte_order) 424 : Register(GPR, offs / sizeof(uint64_t), offs, reg_ctx, byte_order) {} 425 426 uint32_t Index() const { return m_index; } 427 428 // register offset where data is located 429 uint32_t Offs() const { return m_offs; } 430 431 // available bytes in this register 432 uint32_t Avail() const { return m_avail; } 433 434 bool IsValid() const { 435 if (m_index > 7) { 436 LLDB_LOG(m_log, LOG_PREFIX 437 "No more than 8 registers should be used to return values"); 438 return false; 439 } 440 return true; 441 } 442 443 std::string GetName() const { 444 if (m_type == GPR) 445 return ("r" + llvm::Twine(m_index + 3)).str(); 446 else 447 return ("f" + llvm::Twine(m_index + 1)).str(); 448 } 449 450 // get raw register data 451 bool GetRawData(uint64_t &raw_data) { 452 const RegisterInfo *reg_info = 453 m_reg_ctx->GetRegisterInfoByName(GetName()); 454 if (!reg_info) { 455 LLDB_LOG(m_log, LOG_PREFIX "Failed to get RegisterInfo"); 456 return false; 457 } 458 459 RegisterValue reg_val; 460 if (!m_reg_ctx->ReadRegister(reg_info, reg_val)) { 461 LLDB_LOG(m_log, LOG_PREFIX "ReadRegister() failed"); 462 return false; 463 } 464 465 Status error; 466 uint32_t rc = reg_val.GetAsMemoryData( 467 *reg_info, &raw_data, sizeof(raw_data), m_byte_order, error); 468 if (rc != sizeof(raw_data)) { 469 LLDB_LOG(m_log, LOG_PREFIX "GetAsMemoryData() failed"); 470 return false; 471 } 472 473 return true; 474 } 475 476 private: 477 uint32_t m_index; 478 uint32_t m_offs; 479 uint32_t m_avail; 480 Type m_type; 481 RegisterContext *m_reg_ctx; 482 ByteOrder m_byte_order; 483 Log *m_log = GetLog(LLDBLog::Expressions); 484 }; 485 486 Register GetGPR(uint32_t index) const { 487 return Register(Register::GPR, index, m_reg_ctx, m_byte_order); 488 } 489 490 Register GetFPR(uint32_t index) const { 491 return Register(Register::FPR, index, m_reg_ctx, m_byte_order); 492 } 493 494 Register GetGPRByOffs(uint32_t offs) const { 495 return Register(offs, m_reg_ctx, m_byte_order); 496 } 497 498 public: 499 // factory 500 static llvm::Expected<ReturnValueExtractor> Create(Thread &thread, 501 CompilerType &type) { 502 RegisterContext *reg_ctx = thread.GetRegisterContext().get(); 503 if (!reg_ctx) 504 return llvm::make_error<llvm::StringError>( 505 LOG_PREFIX "Failed to get RegisterContext", 506 llvm::inconvertibleErrorCode()); 507 508 ProcessSP process_sp = thread.GetProcess(); 509 if (!process_sp) 510 return llvm::make_error<llvm::StringError>( 511 LOG_PREFIX "GetProcess() failed", llvm::inconvertibleErrorCode()); 512 513 return ReturnValueExtractor(thread, type, reg_ctx, process_sp); 514 } 515 516 // main method: get value of the type specified at construction time 517 ValueObjectSP GetValue() { 518 const uint32_t type_flags = m_type.GetTypeInfo(); 519 520 // call the appropriate type handler 521 ValueSP value_sp; 522 ValueObjectSP valobj_sp; 523 if (type_flags & eTypeIsScalar) { 524 if (type_flags & eTypeIsInteger) { 525 value_sp = GetIntegerValue(0); 526 } else if (type_flags & eTypeIsFloat) { 527 if (type_flags & eTypeIsComplex) { 528 LLDB_LOG(m_log, LOG_PREFIX "Complex numbers are not supported yet"); 529 return ValueObjectSP(); 530 } else { 531 value_sp = GetFloatValue(m_type, 0); 532 } 533 } 534 } else if (type_flags & eTypeIsPointer) { 535 value_sp = GetPointerValue(0); 536 } 537 538 if (value_sp) { 539 valobj_sp = ValueObjectConstResult::Create( 540 m_thread.GetStackFrameAtIndex(0).get(), *value_sp, ConstString("")); 541 } else if (type_flags & eTypeIsVector) { 542 valobj_sp = GetVectorValueObject(); 543 } else if (type_flags & eTypeIsStructUnion || type_flags & eTypeIsClass) { 544 valobj_sp = GetStructValueObject(); 545 } 546 547 return valobj_sp; 548 } 549 550 private: 551 // data 552 Thread &m_thread; 553 CompilerType &m_type; 554 uint64_t m_byte_size; 555 std::unique_ptr<DataBufferHeap> m_data_up; 556 int32_t m_src_offs = 0; 557 int32_t m_dst_offs = 0; 558 bool m_packed = false; 559 Log *m_log = GetLog(LLDBLog::Expressions); 560 RegisterContext *m_reg_ctx; 561 ProcessSP m_process_sp; 562 ByteOrder m_byte_order; 563 uint32_t m_addr_size; 564 565 // methods 566 567 // constructor 568 ReturnValueExtractor(Thread &thread, CompilerType &type, 569 RegisterContext *reg_ctx, ProcessSP process_sp) 570 : m_thread(thread), m_type(type), 571 m_byte_size(m_type.GetByteSize(&thread).value_or(0)), 572 m_data_up(new DataBufferHeap(m_byte_size, 0)), m_reg_ctx(reg_ctx), 573 m_process_sp(process_sp), m_byte_order(process_sp->GetByteOrder()), 574 m_addr_size( 575 process_sp->GetTarget().GetArchitecture().GetAddressByteSize()) {} 576 577 // build a new scalar value 578 ValueSP NewScalarValue(CompilerType &type) { 579 ValueSP value_sp(new Value); 580 value_sp->SetCompilerType(type); 581 value_sp->SetValueType(Value::ValueType::Scalar); 582 return value_sp; 583 } 584 585 // get an integer value in the specified register 586 ValueSP GetIntegerValue(uint32_t reg_index) { 587 uint64_t raw_value; 588 auto reg = GetGPR(reg_index); 589 if (!reg.GetRawData(raw_value)) 590 return ValueSP(); 591 592 // build value from data 593 ValueSP value_sp(NewScalarValue(m_type)); 594 595 uint32_t type_flags = m_type.GetTypeInfo(); 596 bool is_signed = (type_flags & eTypeIsSigned) != 0; 597 598 switch (m_byte_size) { 599 case sizeof(uint64_t): 600 if (is_signed) 601 value_sp->GetScalar() = (int64_t)(raw_value); 602 else 603 value_sp->GetScalar() = (uint64_t)(raw_value); 604 break; 605 606 case sizeof(uint32_t): 607 if (is_signed) 608 value_sp->GetScalar() = (int32_t)(raw_value & UINT32_MAX); 609 else 610 value_sp->GetScalar() = (uint32_t)(raw_value & UINT32_MAX); 611 break; 612 613 case sizeof(uint16_t): 614 if (is_signed) 615 value_sp->GetScalar() = (int16_t)(raw_value & UINT16_MAX); 616 else 617 value_sp->GetScalar() = (uint16_t)(raw_value & UINT16_MAX); 618 break; 619 620 case sizeof(uint8_t): 621 if (is_signed) 622 value_sp->GetScalar() = (int8_t)(raw_value & UINT8_MAX); 623 else 624 value_sp->GetScalar() = (uint8_t)(raw_value & UINT8_MAX); 625 break; 626 627 default: 628 llvm_unreachable("Invalid integer size"); 629 } 630 631 return value_sp; 632 } 633 634 // get a floating point value on the specified register 635 ValueSP GetFloatValue(CompilerType &type, uint32_t reg_index) { 636 uint64_t raw_data; 637 auto reg = GetFPR(reg_index); 638 if (!reg.GetRawData(raw_data)) 639 return {}; 640 641 // build value from data 642 ValueSP value_sp(NewScalarValue(type)); 643 644 DataExtractor de(&raw_data, sizeof(raw_data), m_byte_order, m_addr_size); 645 646 offset_t offset = 0; 647 std::optional<uint64_t> byte_size = type.GetByteSize(m_process_sp.get()); 648 if (!byte_size) 649 return {}; 650 switch (*byte_size) { 651 case sizeof(float): 652 value_sp->GetScalar() = (float)de.GetDouble(&offset); 653 break; 654 655 case sizeof(double): 656 value_sp->GetScalar() = de.GetDouble(&offset); 657 break; 658 659 default: 660 llvm_unreachable("Invalid floating point size"); 661 } 662 663 return value_sp; 664 } 665 666 // get pointer value from register 667 ValueSP GetPointerValue(uint32_t reg_index) { 668 uint64_t raw_data; 669 auto reg = GetGPR(reg_index); 670 if (!reg.GetRawData(raw_data)) 671 return ValueSP(); 672 673 // build value from raw data 674 ValueSP value_sp(NewScalarValue(m_type)); 675 value_sp->GetScalar() = raw_data; 676 return value_sp; 677 } 678 679 // build the ValueObject from our data buffer 680 ValueObjectSP BuildValueObject() { 681 DataExtractor de(DataBufferSP(m_data_up.release()), m_byte_order, 682 m_addr_size); 683 return ValueObjectConstResult::Create(&m_thread, m_type, ConstString(""), 684 de); 685 } 686 687 // get a vector return value 688 ValueObjectSP GetVectorValueObject() { 689 const uint32_t MAX_VRS = 2; 690 691 // get first V register used to return values 692 const RegisterInfo *vr[MAX_VRS]; 693 vr[0] = m_reg_ctx->GetRegisterInfoByName("vr2"); 694 if (!vr[0]) { 695 LLDB_LOG(m_log, LOG_PREFIX "Failed to get vr2 RegisterInfo"); 696 return ValueObjectSP(); 697 } 698 699 const uint32_t vr_size = vr[0]->byte_size; 700 size_t vrs = 1; 701 if (m_byte_size > 2 * vr_size) { 702 LLDB_LOG( 703 m_log, LOG_PREFIX 704 "Returning vectors that don't fit in 2 VR regs is not supported"); 705 return ValueObjectSP(); 706 } 707 708 // load vr3, if needed 709 if (m_byte_size > vr_size) { 710 vrs++; 711 vr[1] = m_reg_ctx->GetRegisterInfoByName("vr3"); 712 if (!vr[1]) { 713 LLDB_LOG(m_log, LOG_PREFIX "Failed to get vr3 RegisterInfo"); 714 return ValueObjectSP(); 715 } 716 } 717 718 // Get the whole contents of vector registers and let the logic here 719 // arrange the data properly. 720 721 RegisterValue vr_val[MAX_VRS]; 722 Status error; 723 std::unique_ptr<DataBufferHeap> vr_data( 724 new DataBufferHeap(vrs * vr_size, 0)); 725 726 for (uint32_t i = 0; i < vrs; i++) { 727 if (!m_reg_ctx->ReadRegister(vr[i], vr_val[i])) { 728 LLDB_LOG(m_log, LOG_PREFIX "Failed to read vector register contents"); 729 return ValueObjectSP(); 730 } 731 if (!vr_val[i].GetAsMemoryData(*vr[i], vr_data->GetBytes() + i * vr_size, 732 vr_size, m_byte_order, error)) { 733 LLDB_LOG(m_log, LOG_PREFIX "Failed to extract vector register bytes"); 734 return ValueObjectSP(); 735 } 736 } 737 738 // The compiler generated code seems to always put the vector elements at 739 // the end of the vector register, in case they don't occupy all of it. 740 // This offset variable handles this. 741 uint32_t offs = 0; 742 if (m_byte_size < vr_size) 743 offs = vr_size - m_byte_size; 744 745 // copy extracted data to our buffer 746 memcpy(m_data_up->GetBytes(), vr_data->GetBytes() + offs, m_byte_size); 747 return BuildValueObject(); 748 } 749 750 // get a struct return value 751 ValueObjectSP GetStructValueObject() { 752 // case 1: get from stack 753 if (m_byte_size > 2 * sizeof(uint64_t)) { 754 uint64_t addr; 755 auto reg = GetGPR(0); 756 if (!reg.GetRawData(addr)) 757 return {}; 758 759 Status error; 760 size_t rc = m_process_sp->ReadMemory(addr, m_data_up->GetBytes(), 761 m_byte_size, error); 762 if (rc != m_byte_size) { 763 LLDB_LOG(m_log, LOG_PREFIX "Failed to read memory pointed by r3"); 764 return ValueObjectSP(); 765 } 766 return BuildValueObject(); 767 } 768 769 // get number of children 770 const bool omit_empty_base_classes = true; 771 uint32_t n = m_type.GetNumChildren(omit_empty_base_classes, nullptr); 772 if (!n) { 773 LLDB_LOG(m_log, LOG_PREFIX "No children found in struct"); 774 return {}; 775 } 776 777 // case 2: homogeneous double or float aggregate 778 CompilerType elem_type; 779 if (m_type.IsHomogeneousAggregate(&elem_type)) { 780 uint32_t type_flags = elem_type.GetTypeInfo(); 781 std::optional<uint64_t> elem_size = 782 elem_type.GetByteSize(m_process_sp.get()); 783 if (!elem_size) 784 return {}; 785 if (type_flags & eTypeIsComplex || !(type_flags & eTypeIsFloat)) { 786 LLDB_LOG(m_log, 787 LOG_PREFIX "Unexpected type found in homogeneous aggregate"); 788 return {}; 789 } 790 791 for (uint32_t i = 0; i < n; i++) { 792 ValueSP val_sp = GetFloatValue(elem_type, i); 793 if (!val_sp) 794 return {}; 795 796 // copy to buffer 797 Status error; 798 size_t rc = val_sp->GetScalar().GetAsMemoryData( 799 m_data_up->GetBytes() + m_dst_offs, *elem_size, m_byte_order, 800 error); 801 if (rc != *elem_size) { 802 LLDB_LOG(m_log, LOG_PREFIX "Failed to get float data"); 803 return {}; 804 } 805 m_dst_offs += *elem_size; 806 } 807 return BuildValueObject(); 808 } 809 810 // case 3: get from GPRs 811 812 // first, check if this is a packed struct or not 813 auto ast = m_type.GetTypeSystem().dyn_cast_or_null<TypeSystemClang>(); 814 if (ast) { 815 clang::RecordDecl *record_decl = TypeSystemClang::GetAsRecordDecl(m_type); 816 817 if (record_decl) { 818 auto attrs = record_decl->attrs(); 819 for (const auto &attr : attrs) { 820 if (attr->getKind() == clang::attr::Packed) { 821 m_packed = true; 822 break; 823 } 824 } 825 } 826 } 827 828 LLDB_LOG(m_log, LOG_PREFIX "{0} struct", 829 m_packed ? "packed" : "not packed"); 830 831 for (uint32_t i = 0; i < n; i++) { 832 std::string name; 833 uint32_t size; 834 GetChildType(i, name, size); 835 // NOTE: the offset returned by GetChildCompilerTypeAtIndex() 836 // can't be used because it never considers alignment bytes 837 // between struct fields. 838 LLDB_LOG(m_log, LOG_PREFIX "field={0}, size={1}", name, size); 839 if (!ExtractField(size)) 840 return ValueObjectSP(); 841 } 842 843 return BuildValueObject(); 844 } 845 846 // extract 'size' bytes at 'offs' from GPRs 847 bool ExtractFromRegs(int32_t offs, uint32_t size, void *buf) { 848 while (size) { 849 auto reg = GetGPRByOffs(offs); 850 if (!reg.IsValid()) 851 return false; 852 853 uint32_t n = std::min(reg.Avail(), size); 854 uint64_t raw_data; 855 856 if (!reg.GetRawData(raw_data)) 857 return false; 858 859 memcpy(buf, (char *)&raw_data + reg.Offs(), n); 860 offs += n; 861 size -= n; 862 buf = (char *)buf + n; 863 } 864 return true; 865 } 866 867 // extract one field from GPRs and put it in our buffer 868 bool ExtractField(uint32_t size) { 869 auto reg = GetGPRByOffs(m_src_offs); 870 if (!reg.IsValid()) 871 return false; 872 873 // handle padding 874 if (!m_packed) { 875 uint32_t n = m_src_offs % size; 876 877 // not 'size' bytes aligned 878 if (n) { 879 LLDB_LOG(m_log, 880 LOG_PREFIX "Extracting {0} alignment bytes at offset {1}", n, 881 m_src_offs); 882 // get alignment bytes 883 if (!ExtractFromRegs(m_src_offs, n, m_data_up->GetBytes() + m_dst_offs)) 884 return false; 885 m_src_offs += n; 886 m_dst_offs += n; 887 } 888 } 889 890 // get field 891 LLDB_LOG(m_log, LOG_PREFIX "Extracting {0} field bytes at offset {1}", size, 892 m_src_offs); 893 if (!ExtractFromRegs(m_src_offs, size, m_data_up->GetBytes() + m_dst_offs)) 894 return false; 895 m_src_offs += size; 896 m_dst_offs += size; 897 return true; 898 } 899 900 // get child 901 CompilerType GetChildType(uint32_t i, std::string &name, uint32_t &size) { 902 // GetChild constant inputs 903 const bool transparent_pointers = false; 904 const bool omit_empty_base_classes = true; 905 const bool ignore_array_bounds = false; 906 // GetChild output params 907 int32_t child_offs; 908 uint32_t child_bitfield_bit_size; 909 uint32_t child_bitfield_bit_offset; 910 bool child_is_base_class; 911 bool child_is_deref_of_parent; 912 ValueObject *valobj = nullptr; 913 uint64_t language_flags; 914 ExecutionContext exe_ctx; 915 m_thread.CalculateExecutionContext(exe_ctx); 916 917 return m_type.GetChildCompilerTypeAtIndex( 918 &exe_ctx, i, transparent_pointers, omit_empty_base_classes, 919 ignore_array_bounds, name, size, child_offs, child_bitfield_bit_size, 920 child_bitfield_bit_offset, child_is_base_class, 921 child_is_deref_of_parent, valobj, language_flags); 922 } 923 }; 924 925 #undef LOG_PREFIX 926 927 } // anonymous namespace 928 929 ValueObjectSP 930 ABISysV_ppc64::GetReturnValueObjectSimple(Thread &thread, 931 CompilerType &type) const { 932 if (!type) 933 return ValueObjectSP(); 934 935 auto exp_extractor = ReturnValueExtractor::Create(thread, type); 936 if (!exp_extractor) { 937 Log *log = GetLog(LLDBLog::Expressions); 938 LLDB_LOG_ERROR(log, exp_extractor.takeError(), 939 "Extracting return value failed: {0}"); 940 return ValueObjectSP(); 941 } 942 943 return exp_extractor.get().GetValue(); 944 } 945 946 ValueObjectSP ABISysV_ppc64::GetReturnValueObjectImpl( 947 Thread &thread, CompilerType &return_compiler_type) const { 948 return GetReturnValueObjectSimple(thread, return_compiler_type); 949 } 950 951 bool ABISysV_ppc64::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) { 952 unwind_plan.Clear(); 953 unwind_plan.SetRegisterKind(eRegisterKindDWARF); 954 955 uint32_t lr_reg_num; 956 uint32_t sp_reg_num; 957 uint32_t pc_reg_num; 958 959 if (GetByteOrder() == lldb::eByteOrderLittle) { 960 lr_reg_num = ppc64le_dwarf::dwarf_lr_ppc64le; 961 sp_reg_num = ppc64le_dwarf::dwarf_r1_ppc64le; 962 pc_reg_num = ppc64le_dwarf::dwarf_pc_ppc64le; 963 } else { 964 lr_reg_num = ppc64_dwarf::dwarf_lr_ppc64; 965 sp_reg_num = ppc64_dwarf::dwarf_r1_ppc64; 966 pc_reg_num = ppc64_dwarf::dwarf_pc_ppc64; 967 } 968 969 UnwindPlan::RowSP row(new UnwindPlan::Row); 970 971 // Our Call Frame Address is the stack pointer value 972 row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0); 973 974 // The previous PC is in the LR 975 row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true); 976 unwind_plan.AppendRow(row); 977 978 // All other registers are the same. 979 980 unwind_plan.SetSourceName("ppc64 at-func-entry default"); 981 unwind_plan.SetSourcedFromCompiler(eLazyBoolNo); 982 983 return true; 984 } 985 986 bool ABISysV_ppc64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) { 987 unwind_plan.Clear(); 988 unwind_plan.SetRegisterKind(eRegisterKindDWARF); 989 990 uint32_t sp_reg_num; 991 uint32_t pc_reg_num; 992 uint32_t cr_reg_num; 993 994 if (GetByteOrder() == lldb::eByteOrderLittle) { 995 sp_reg_num = ppc64le_dwarf::dwarf_r1_ppc64le; 996 pc_reg_num = ppc64le_dwarf::dwarf_lr_ppc64le; 997 cr_reg_num = ppc64le_dwarf::dwarf_cr_ppc64le; 998 } else { 999 sp_reg_num = ppc64_dwarf::dwarf_r1_ppc64; 1000 pc_reg_num = ppc64_dwarf::dwarf_lr_ppc64; 1001 cr_reg_num = ppc64_dwarf::dwarf_cr_ppc64; 1002 } 1003 1004 UnwindPlan::RowSP row(new UnwindPlan::Row); 1005 const int32_t ptr_size = 8; 1006 row->SetUnspecifiedRegistersAreUndefined(true); 1007 row->GetCFAValue().SetIsRegisterDereferenced(sp_reg_num); 1008 1009 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * 2, true); 1010 row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true); 1011 row->SetRegisterLocationToAtCFAPlusOffset(cr_reg_num, ptr_size, true); 1012 1013 unwind_plan.AppendRow(row); 1014 unwind_plan.SetSourceName("ppc64 default unwind plan"); 1015 unwind_plan.SetSourcedFromCompiler(eLazyBoolNo); 1016 unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo); 1017 unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo); 1018 unwind_plan.SetReturnAddressRegister(pc_reg_num); 1019 return true; 1020 } 1021 1022 bool ABISysV_ppc64::RegisterIsVolatile(const RegisterInfo *reg_info) { 1023 return !RegisterIsCalleeSaved(reg_info); 1024 } 1025 1026 // See "Register Usage" in the 1027 // "System V Application Binary Interface" 1028 // "64-bit PowerPC ELF Application Binary Interface Supplement" current version 1029 // is 2 released 2015 at 1030 // https://members.openpowerfoundation.org/document/dl/576 1031 bool ABISysV_ppc64::RegisterIsCalleeSaved(const RegisterInfo *reg_info) { 1032 if (reg_info) { 1033 // Preserved registers are : 1034 // r1,r2,r13-r31 1035 // cr2-cr4 (partially preserved) 1036 // f14-f31 (not yet) 1037 // v20-v31 (not yet) 1038 // vrsave (not yet) 1039 1040 const char *name = reg_info->name; 1041 if (name[0] == 'r') { 1042 if ((name[1] == '1' || name[1] == '2') && name[2] == '\0') 1043 return true; 1044 if (name[1] == '1' && name[2] > '2') 1045 return true; 1046 if ((name[1] == '2' || name[1] == '3') && name[2] != '\0') 1047 return true; 1048 } 1049 1050 if (name[0] == 'f' && name[1] >= '0' && name[2] <= '9') { 1051 if (name[2] == '\0') 1052 return false; 1053 if (name[1] == '1' && name[2] >= '4') 1054 return true; 1055 if ((name[1] == '2' || name[1] == '3') && name[2] != '\0') 1056 return true; 1057 } 1058 1059 if (name[0] == 's' && name[1] == 'p' && name[2] == '\0') // sp 1060 return true; 1061 if (name[0] == 'f' && name[1] == 'p' && name[2] == '\0') // fp 1062 return false; 1063 if (name[0] == 'p' && name[1] == 'c' && name[2] == '\0') // pc 1064 return true; 1065 } 1066 return false; 1067 } 1068 1069 void ABISysV_ppc64::Initialize() { 1070 PluginManager::RegisterPlugin( 1071 GetPluginNameStatic(), "System V ABI for ppc64 targets", CreateInstance); 1072 } 1073 1074 void ABISysV_ppc64::Terminate() { 1075 PluginManager::UnregisterPlugin(CreateInstance); 1076 } 1077