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/Symbol/UnwindPlan.h" 21 #include "lldb/Target/Process.h" 22 #include "lldb/Target/RegisterContext.h" 23 #include "lldb/Target/StackFrame.h" 24 #include "lldb/Target/Target.h" 25 #include "lldb/Target/Thread.h" 26 #include "lldb/Utility/ConstString.h" 27 #include "lldb/Utility/DataExtractor.h" 28 #include "lldb/Utility/LLDBLog.h" 29 #include "lldb/Utility/Log.h" 30 #include "lldb/Utility/RegisterValue.h" 31 #include "lldb/Utility/Status.h" 32 #include "lldb/ValueObject/ValueObjectConstResult.h" 33 #include "lldb/ValueObject/ValueObjectMemory.h" 34 #include "lldb/ValueObject/ValueObjectRegister.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 = Status::FromErrorString("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 = Status::FromErrorString("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 = Status::FromErrorStringWithFormat( 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 = Status::FromErrorString( 338 "We don't support returning longer than 64 bit " 339 "integer values at present."); 340 } 341 } else if (compiler_type.IsFloatingPointType(count, is_complex)) { 342 if (is_complex) 343 error = Status::FromErrorString( 344 "We don't support returning complex values at present"); 345 else { 346 std::optional<uint64_t> bit_width = 347 compiler_type.GetBitSize(frame_sp.get()); 348 if (!bit_width) { 349 error = Status::FromErrorString("can't get size of type"); 350 return error; 351 } 352 if (*bit_width <= 64) { 353 DataExtractor data; 354 Status data_error; 355 size_t num_bytes = new_value_sp->GetData(data, data_error); 356 if (data_error.Fail()) { 357 error = Status::FromErrorStringWithFormat( 358 "Couldn't convert return value to raw data: %s", 359 data_error.AsCString()); 360 return error; 361 } 362 363 unsigned char buffer[16]; 364 ByteOrder byte_order = data.GetByteOrder(); 365 366 data.CopyByteOrderedData(0, num_bytes, buffer, 16, byte_order); 367 set_it_simple = true; 368 } else { 369 // FIXME - don't know how to do 80 bit long doubles yet. 370 error = Status::FromErrorString( 371 "We don't support returning float values > 64 bits at present"); 372 } 373 } 374 } 375 376 if (!set_it_simple) { 377 // Okay we've got a structure or something that doesn't fit in a simple 378 // register. We should figure out where it really goes, but we don't 379 // support this yet. 380 error = Status::FromErrorString( 381 "We only support setting simple integer and float " 382 "return types at present."); 383 } 384 385 return error; 386 } 387 388 // 389 // ReturnValueExtractor 390 // 391 392 namespace { 393 394 #define LOG_PREFIX "ReturnValueExtractor: " 395 396 class ReturnValueExtractor { 397 // This class represents a register, from which data may be extracted. 398 // 399 // It may be constructed by directly specifying its index (where 0 is the 400 // first register used to return values) or by specifying the offset of a 401 // given struct field, in which case the appropriated register index will be 402 // calculated. 403 class Register { 404 public: 405 enum Type { 406 GPR, // General Purpose Register 407 FPR // Floating Point Register 408 }; 409 410 // main constructor 411 // 412 // offs - field offset in struct 413 Register(Type ty, uint32_t index, uint32_t offs, RegisterContext *reg_ctx, 414 ByteOrder byte_order) 415 : m_index(index), m_offs(offs % sizeof(uint64_t)), 416 m_avail(sizeof(uint64_t) - m_offs), m_type(ty), m_reg_ctx(reg_ctx), 417 m_byte_order(byte_order) {} 418 419 // explicit index, no offset 420 Register(Type ty, uint32_t index, RegisterContext *reg_ctx, 421 ByteOrder byte_order) 422 : Register(ty, index, 0, reg_ctx, byte_order) {} 423 424 // GPR, calculate index from offs 425 Register(uint32_t offs, RegisterContext *reg_ctx, ByteOrder byte_order) 426 : Register(GPR, offs / sizeof(uint64_t), offs, reg_ctx, byte_order) {} 427 428 uint32_t Index() const { return m_index; } 429 430 // register offset where data is located 431 uint32_t Offs() const { return m_offs; } 432 433 // available bytes in this register 434 uint32_t Avail() const { return m_avail; } 435 436 bool IsValid() const { 437 if (m_index > 7) { 438 LLDB_LOG(m_log, LOG_PREFIX 439 "No more than 8 registers should be used to return values"); 440 return false; 441 } 442 return true; 443 } 444 445 std::string GetName() const { 446 if (m_type == GPR) 447 return ("r" + llvm::Twine(m_index + 3)).str(); 448 else 449 return ("f" + llvm::Twine(m_index + 1)).str(); 450 } 451 452 // get raw register data 453 bool GetRawData(uint64_t &raw_data) { 454 const RegisterInfo *reg_info = 455 m_reg_ctx->GetRegisterInfoByName(GetName()); 456 if (!reg_info) { 457 LLDB_LOG(m_log, LOG_PREFIX "Failed to get RegisterInfo"); 458 return false; 459 } 460 461 RegisterValue reg_val; 462 if (!m_reg_ctx->ReadRegister(reg_info, reg_val)) { 463 LLDB_LOG(m_log, LOG_PREFIX "ReadRegister() failed"); 464 return false; 465 } 466 467 Status error; 468 uint32_t rc = reg_val.GetAsMemoryData( 469 *reg_info, &raw_data, sizeof(raw_data), m_byte_order, error); 470 if (rc != sizeof(raw_data)) { 471 LLDB_LOG(m_log, LOG_PREFIX "GetAsMemoryData() failed"); 472 return false; 473 } 474 475 return true; 476 } 477 478 private: 479 uint32_t m_index; 480 uint32_t m_offs; 481 uint32_t m_avail; 482 Type m_type; 483 RegisterContext *m_reg_ctx; 484 ByteOrder m_byte_order; 485 Log *m_log = GetLog(LLDBLog::Expressions); 486 }; 487 488 Register GetGPR(uint32_t index) const { 489 return Register(Register::GPR, index, m_reg_ctx, m_byte_order); 490 } 491 492 Register GetFPR(uint32_t index) const { 493 return Register(Register::FPR, index, m_reg_ctx, m_byte_order); 494 } 495 496 Register GetGPRByOffs(uint32_t offs) const { 497 return Register(offs, m_reg_ctx, m_byte_order); 498 } 499 500 public: 501 // factory 502 static llvm::Expected<ReturnValueExtractor> Create(Thread &thread, 503 CompilerType &type) { 504 RegisterContext *reg_ctx = thread.GetRegisterContext().get(); 505 if (!reg_ctx) 506 return llvm::createStringError(LOG_PREFIX 507 "Failed to get RegisterContext"); 508 509 ProcessSP process_sp = thread.GetProcess(); 510 if (!process_sp) 511 return llvm::createStringError(LOG_PREFIX "GetProcess() failed"); 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 lldb::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 auto n_or_err = m_type.GetNumChildren(omit_empty_base_classes, nullptr); 772 if (!n_or_err) { 773 LLDB_LOG_ERROR(m_log, n_or_err.takeError(), LOG_PREFIX "{0}"); 774 return {}; 775 } 776 uint32_t n = *n_or_err; 777 if (!n) { 778 LLDB_LOG(m_log, LOG_PREFIX "No children found in struct"); 779 return {}; 780 } 781 782 // case 2: homogeneous double or float aggregate 783 CompilerType elem_type; 784 if (m_type.IsHomogeneousAggregate(&elem_type)) { 785 uint32_t type_flags = elem_type.GetTypeInfo(); 786 std::optional<uint64_t> elem_size = 787 elem_type.GetByteSize(m_process_sp.get()); 788 if (!elem_size) 789 return {}; 790 if (type_flags & eTypeIsComplex || !(type_flags & eTypeIsFloat)) { 791 LLDB_LOG(m_log, 792 LOG_PREFIX "Unexpected type found in homogeneous aggregate"); 793 return {}; 794 } 795 796 for (uint32_t i = 0; i < n; i++) { 797 ValueSP val_sp = GetFloatValue(elem_type, i); 798 if (!val_sp) 799 return {}; 800 801 // copy to buffer 802 Status error; 803 size_t rc = val_sp->GetScalar().GetAsMemoryData( 804 m_data_up->GetBytes() + m_dst_offs, *elem_size, m_byte_order, 805 error); 806 if (rc != *elem_size) { 807 LLDB_LOG(m_log, LOG_PREFIX "Failed to get float data"); 808 return {}; 809 } 810 m_dst_offs += *elem_size; 811 } 812 return BuildValueObject(); 813 } 814 815 // case 3: get from GPRs 816 817 // first, check if this is a packed struct or not 818 auto ast = m_type.GetTypeSystem().dyn_cast_or_null<TypeSystemClang>(); 819 if (ast) { 820 clang::RecordDecl *record_decl = TypeSystemClang::GetAsRecordDecl(m_type); 821 822 if (record_decl) { 823 auto attrs = record_decl->attrs(); 824 for (const auto &attr : attrs) { 825 if (attr->getKind() == clang::attr::Packed) { 826 m_packed = true; 827 break; 828 } 829 } 830 } 831 } 832 833 LLDB_LOG(m_log, LOG_PREFIX "{0} struct", 834 m_packed ? "packed" : "not packed"); 835 836 for (uint32_t i = 0; i < n; i++) { 837 std::string name; 838 uint32_t size; 839 (void)GetChildType(i, name, size); 840 // NOTE: the offset returned by GetChildCompilerTypeAtIndex() 841 // can't be used because it never considers alignment bytes 842 // between struct fields. 843 LLDB_LOG(m_log, LOG_PREFIX "field={0}, size={1}", name, size); 844 if (!ExtractField(size)) 845 return ValueObjectSP(); 846 } 847 848 return BuildValueObject(); 849 } 850 851 // extract 'size' bytes at 'offs' from GPRs 852 bool ExtractFromRegs(int32_t offs, uint32_t size, void *buf) { 853 while (size) { 854 auto reg = GetGPRByOffs(offs); 855 if (!reg.IsValid()) 856 return false; 857 858 uint32_t n = std::min(reg.Avail(), size); 859 uint64_t raw_data; 860 861 if (!reg.GetRawData(raw_data)) 862 return false; 863 864 memcpy(buf, (char *)&raw_data + reg.Offs(), n); 865 offs += n; 866 size -= n; 867 buf = (char *)buf + n; 868 } 869 return true; 870 } 871 872 // extract one field from GPRs and put it in our buffer 873 bool ExtractField(uint32_t size) { 874 auto reg = GetGPRByOffs(m_src_offs); 875 if (!reg.IsValid()) 876 return false; 877 878 // handle padding 879 if (!m_packed) { 880 uint32_t n = m_src_offs % size; 881 882 // not 'size' bytes aligned 883 if (n) { 884 LLDB_LOG(m_log, 885 LOG_PREFIX "Extracting {0} alignment bytes at offset {1}", n, 886 m_src_offs); 887 // get alignment bytes 888 if (!ExtractFromRegs(m_src_offs, n, m_data_up->GetBytes() + m_dst_offs)) 889 return false; 890 m_src_offs += n; 891 m_dst_offs += n; 892 } 893 } 894 895 // get field 896 LLDB_LOG(m_log, LOG_PREFIX "Extracting {0} field bytes at offset {1}", size, 897 m_src_offs); 898 if (!ExtractFromRegs(m_src_offs, size, m_data_up->GetBytes() + m_dst_offs)) 899 return false; 900 m_src_offs += size; 901 m_dst_offs += size; 902 return true; 903 } 904 905 // get child 906 llvm::Expected<CompilerType> GetChildType(uint32_t i, std::string &name, 907 uint32_t &size) { 908 // GetChild constant inputs 909 const bool transparent_pointers = false; 910 const bool omit_empty_base_classes = true; 911 const bool ignore_array_bounds = false; 912 // GetChild output params 913 int32_t child_offs; 914 uint32_t child_bitfield_bit_size; 915 uint32_t child_bitfield_bit_offset; 916 bool child_is_base_class; 917 bool child_is_deref_of_parent; 918 ValueObject *valobj = nullptr; 919 uint64_t language_flags; 920 ExecutionContext exe_ctx; 921 m_thread.CalculateExecutionContext(exe_ctx); 922 923 return m_type.GetChildCompilerTypeAtIndex( 924 &exe_ctx, i, transparent_pointers, omit_empty_base_classes, 925 ignore_array_bounds, name, size, child_offs, child_bitfield_bit_size, 926 child_bitfield_bit_offset, child_is_base_class, 927 child_is_deref_of_parent, valobj, language_flags); 928 } 929 }; 930 931 #undef LOG_PREFIX 932 933 } // anonymous namespace 934 935 ValueObjectSP 936 ABISysV_ppc64::GetReturnValueObjectSimple(Thread &thread, 937 CompilerType &type) const { 938 if (!type) 939 return ValueObjectSP(); 940 941 auto exp_extractor = ReturnValueExtractor::Create(thread, type); 942 if (!exp_extractor) { 943 Log *log = GetLog(LLDBLog::Expressions); 944 LLDB_LOG_ERROR(log, exp_extractor.takeError(), 945 "Extracting return value failed: {0}"); 946 return ValueObjectSP(); 947 } 948 949 return exp_extractor.get().GetValue(); 950 } 951 952 ValueObjectSP ABISysV_ppc64::GetReturnValueObjectImpl( 953 Thread &thread, CompilerType &return_compiler_type) const { 954 return GetReturnValueObjectSimple(thread, return_compiler_type); 955 } 956 957 bool ABISysV_ppc64::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) { 958 unwind_plan.Clear(); 959 unwind_plan.SetRegisterKind(eRegisterKindDWARF); 960 961 uint32_t lr_reg_num; 962 uint32_t sp_reg_num; 963 uint32_t pc_reg_num; 964 965 if (GetByteOrder() == lldb::eByteOrderLittle) { 966 lr_reg_num = ppc64le_dwarf::dwarf_lr_ppc64le; 967 sp_reg_num = ppc64le_dwarf::dwarf_r1_ppc64le; 968 pc_reg_num = ppc64le_dwarf::dwarf_pc_ppc64le; 969 } else { 970 lr_reg_num = ppc64_dwarf::dwarf_lr_ppc64; 971 sp_reg_num = ppc64_dwarf::dwarf_r1_ppc64; 972 pc_reg_num = ppc64_dwarf::dwarf_pc_ppc64; 973 } 974 975 UnwindPlan::RowSP row(new UnwindPlan::Row); 976 977 // Our Call Frame Address is the stack pointer value 978 row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0); 979 980 // The previous PC is in the LR 981 row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true); 982 unwind_plan.AppendRow(row); 983 984 // All other registers are the same. 985 986 unwind_plan.SetSourceName("ppc64 at-func-entry default"); 987 unwind_plan.SetSourcedFromCompiler(eLazyBoolNo); 988 989 return true; 990 } 991 992 bool ABISysV_ppc64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) { 993 unwind_plan.Clear(); 994 unwind_plan.SetRegisterKind(eRegisterKindDWARF); 995 996 uint32_t sp_reg_num; 997 uint32_t pc_reg_num; 998 uint32_t cr_reg_num; 999 1000 if (GetByteOrder() == lldb::eByteOrderLittle) { 1001 sp_reg_num = ppc64le_dwarf::dwarf_r1_ppc64le; 1002 pc_reg_num = ppc64le_dwarf::dwarf_lr_ppc64le; 1003 cr_reg_num = ppc64le_dwarf::dwarf_cr_ppc64le; 1004 } else { 1005 sp_reg_num = ppc64_dwarf::dwarf_r1_ppc64; 1006 pc_reg_num = ppc64_dwarf::dwarf_lr_ppc64; 1007 cr_reg_num = ppc64_dwarf::dwarf_cr_ppc64; 1008 } 1009 1010 UnwindPlan::RowSP row(new UnwindPlan::Row); 1011 const int32_t ptr_size = 8; 1012 row->SetUnspecifiedRegistersAreUndefined(true); 1013 row->GetCFAValue().SetIsRegisterDereferenced(sp_reg_num); 1014 1015 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * 2, true); 1016 row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true); 1017 row->SetRegisterLocationToAtCFAPlusOffset(cr_reg_num, ptr_size, true); 1018 1019 unwind_plan.AppendRow(row); 1020 unwind_plan.SetSourceName("ppc64 default unwind plan"); 1021 unwind_plan.SetSourcedFromCompiler(eLazyBoolNo); 1022 unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo); 1023 unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo); 1024 unwind_plan.SetReturnAddressRegister(pc_reg_num); 1025 return true; 1026 } 1027 1028 bool ABISysV_ppc64::RegisterIsVolatile(const RegisterInfo *reg_info) { 1029 return !RegisterIsCalleeSaved(reg_info); 1030 } 1031 1032 // See "Register Usage" in the 1033 // "System V Application Binary Interface" 1034 // "64-bit PowerPC ELF Application Binary Interface Supplement" current version 1035 // is 2 released 2015 at 1036 // https://members.openpowerfoundation.org/document/dl/576 1037 bool ABISysV_ppc64::RegisterIsCalleeSaved(const RegisterInfo *reg_info) { 1038 if (reg_info) { 1039 // Preserved registers are : 1040 // r1,r2,r13-r31 1041 // cr2-cr4 (partially preserved) 1042 // f14-f31 (not yet) 1043 // v20-v31 (not yet) 1044 // vrsave (not yet) 1045 1046 const char *name = reg_info->name; 1047 if (name[0] == 'r') { 1048 if ((name[1] == '1' || name[1] == '2') && name[2] == '\0') 1049 return true; 1050 if (name[1] == '1' && name[2] > '2') 1051 return true; 1052 if ((name[1] == '2' || name[1] == '3') && name[2] != '\0') 1053 return true; 1054 } 1055 1056 if (name[0] == 'f' && name[1] >= '0' && name[2] <= '9') { 1057 if (name[2] == '\0') 1058 return false; 1059 if (name[1] == '1' && name[2] >= '4') 1060 return true; 1061 if ((name[1] == '2' || name[1] == '3') && name[2] != '\0') 1062 return true; 1063 } 1064 1065 if (name[0] == 's' && name[1] == 'p' && name[2] == '\0') // sp 1066 return true; 1067 if (name[0] == 'f' && name[1] == 'p' && name[2] == '\0') // fp 1068 return false; 1069 if (name[0] == 'p' && name[1] == 'c' && name[2] == '\0') // pc 1070 return true; 1071 } 1072 return false; 1073 } 1074 1075 void ABISysV_ppc64::Initialize() { 1076 PluginManager::RegisterPlugin( 1077 GetPluginNameStatic(), "System V ABI for ppc64 targets", CreateInstance); 1078 } 1079 1080 void ABISysV_ppc64::Terminate() { 1081 PluginManager::UnregisterPlugin(CreateInstance); 1082 } 1083