lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc64.cpp

   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 &current_argument_register,
 204                                 addr_t &current_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 }