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