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
LLDB_PLUGIN_DEFINE(ABISysV_ppc64) const50 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
GetRedZoneSize() const63 size_t ABISysV_ppc64::GetRedZoneSize() const { return 224; }
64
GetByteOrder() const65 lldb::ByteOrder ABISysV_ppc64::GetByteOrder() const {
66 return GetProcessSP()->GetByteOrder();
67 }
68
69 // Static Functions
70
71 ABISP
CreateInstance(lldb::ProcessSP process_sp,const ArchSpec & arch)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
PrepareTrivialCall(Thread & thread,addr_t sp,addr_t func_addr,addr_t return_addr,llvm::ArrayRef<addr_t> args) const80 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
ReadIntegerArgument(Scalar & scalar,unsigned int bit_width,bool is_signed,Thread & thread,uint32_t * argument_register_ids,unsigned int & current_argument_register,addr_t & current_stack_argument)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 ¤t_argument_register,
202 addr_t ¤t_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
GetArgumentValues(Thread & thread,ValueList & values) const225 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
SetReturnValueObject(lldb::StackFrameSP & frame_sp,lldb::ValueObjectSP & new_value_sp)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
Register(Type ty,uint32_t index,uint32_t offs,RegisterContext * reg_ctx,ByteOrder byte_order)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
Register(Type ty,uint32_t index,RegisterContext * reg_ctx,ByteOrder byte_order)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
Register(uint32_t offs,RegisterContext * reg_ctx,ByteOrder byte_order)421 Register(uint32_t offs, RegisterContext *reg_ctx, ByteOrder byte_order)
422 : Register(GPR, offs / sizeof(uint64_t), offs, reg_ctx, byte_order) {}
423
Index() const424 uint32_t Index() const { return m_index; }
425
426 // register offset where data is located
Offs() const427 uint32_t Offs() const { return m_offs; }
428
429 // available bytes in this register
Avail() const430 uint32_t Avail() const { return m_avail; }
431
IsValid() const432 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
GetName() const441 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
GetRawData(uint64_t & raw_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
GetGPR(uint32_t index) const485 Register GetGPR(uint32_t index) const {
486 return Register(Register::GPR, index, m_reg_ctx, m_byte_order);
487 }
488
GetFPR(uint32_t index) const489 Register GetFPR(uint32_t index) const {
490 return Register(Register::FPR, index, m_reg_ctx, m_byte_order);
491 }
492
GetGPRByOffs(uint32_t offs) const493 Register GetGPRByOffs(uint32_t offs) const {
494 return Register(offs, m_reg_ctx, m_byte_order);
495 }
496
497 public:
498 // factory
Create(Thread & thread,CompilerType & type)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
GetValue()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
ReturnValueExtractor(Thread & thread,CompilerType & type,RegisterContext * reg_ctx,ProcessSP process_sp)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(&thread).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
NewScalarValue(CompilerType & type)577 ValueSP NewScalarValue(CompilerType &type) {
578 ValueSP value_sp(new Value);
579 value_sp->SetCompilerType(type);
580 value_sp->SetValueType(Value::ValueType::Scalar);
581 return value_sp;
582 }
583
584 // get an integer value in the specified register
GetIntegerValue(uint32_t reg_index)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
GetFloatValue(CompilerType & type,uint32_t reg_index)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(m_process_sp.get());
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
GetPointerValue(uint32_t reg_index)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
BuildValueObject()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
GetVectorValueObject()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
GetStructValueObject()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 =
781 elem_type.GetByteSize(m_process_sp.get());
782 if (!elem_size)
783 return {};
784 if (type_flags & eTypeIsComplex || !(type_flags & eTypeIsFloat)) {
785 LLDB_LOG(m_log,
786 LOG_PREFIX "Unexpected type found in homogeneous aggregate");
787 return {};
788 }
789
790 for (uint32_t i = 0; i < n; i++) {
791 ValueSP val_sp = GetFloatValue(elem_type, i);
792 if (!val_sp)
793 return {};
794
795 // copy to buffer
796 Status error;
797 size_t rc = val_sp->GetScalar().GetAsMemoryData(
798 m_data_up->GetBytes() + m_dst_offs, *elem_size, m_byte_order,
799 error);
800 if (rc != *elem_size) {
801 LLDB_LOG(m_log, LOG_PREFIX "Failed to get float data");
802 return {};
803 }
804 m_dst_offs += *elem_size;
805 }
806 return BuildValueObject();
807 }
808
809 // case 3: get from GPRs
810
811 // first, check if this is a packed struct or not
812 TypeSystemClang *ast =
813 llvm::dyn_cast<TypeSystemClang>(m_type.GetTypeSystem());
814 if (ast) {
815 clang::RecordDecl *record_decl = TypeSystemClang::GetAsRecordDecl(m_type);
816
817 if (record_decl) {
818 auto attrs = record_decl->attrs();
819 for (const auto &attr : attrs) {
820 if (attr->getKind() == clang::attr::Packed) {
821 m_packed = true;
822 break;
823 }
824 }
825 }
826 }
827
828 LLDB_LOG(m_log, LOG_PREFIX "{0} struct",
829 m_packed ? "packed" : "not packed");
830
831 for (uint32_t i = 0; i < n; i++) {
832 std::string name;
833 uint32_t size;
834 GetChildType(i, name, size);
835 // NOTE: the offset returned by GetChildCompilerTypeAtIndex()
836 // can't be used because it never considers alignment bytes
837 // between struct fields.
838 LLDB_LOG(m_log, LOG_PREFIX "field={0}, size={1}", name, size);
839 if (!ExtractField(size))
840 return ValueObjectSP();
841 }
842
843 return BuildValueObject();
844 }
845
846 // extract 'size' bytes at 'offs' from GPRs
ExtractFromRegs(int32_t offs,uint32_t size,void * buf)847 bool ExtractFromRegs(int32_t offs, uint32_t size, void *buf) {
848 while (size) {
849 auto reg = GetGPRByOffs(offs);
850 if (!reg.IsValid())
851 return false;
852
853 uint32_t n = std::min(reg.Avail(), size);
854 uint64_t raw_data;
855
856 if (!reg.GetRawData(raw_data))
857 return false;
858
859 memcpy(buf, (char *)&raw_data + reg.Offs(), n);
860 offs += n;
861 size -= n;
862 buf = (char *)buf + n;
863 }
864 return true;
865 }
866
867 // extract one field from GPRs and put it in our buffer
ExtractField(uint32_t size)868 bool ExtractField(uint32_t size) {
869 auto reg = GetGPRByOffs(m_src_offs);
870 if (!reg.IsValid())
871 return false;
872
873 // handle padding
874 if (!m_packed) {
875 uint32_t n = m_src_offs % size;
876
877 // not 'size' bytes aligned
878 if (n) {
879 LLDB_LOG(m_log,
880 LOG_PREFIX "Extracting {0} alignment bytes at offset {1}", n,
881 m_src_offs);
882 // get alignment bytes
883 if (!ExtractFromRegs(m_src_offs, n, m_data_up->GetBytes() + m_dst_offs))
884 return false;
885 m_src_offs += n;
886 m_dst_offs += n;
887 }
888 }
889
890 // get field
891 LLDB_LOG(m_log, LOG_PREFIX "Extracting {0} field bytes at offset {1}", size,
892 m_src_offs);
893 if (!ExtractFromRegs(m_src_offs, size, m_data_up->GetBytes() + m_dst_offs))
894 return false;
895 m_src_offs += size;
896 m_dst_offs += size;
897 return true;
898 }
899
900 // get child
GetChildType(uint32_t i,std::string & name,uint32_t & size)901 CompilerType GetChildType(uint32_t i, std::string &name, uint32_t &size) {
902 // GetChild constant inputs
903 const bool transparent_pointers = false;
904 const bool omit_empty_base_classes = true;
905 const bool ignore_array_bounds = false;
906 // GetChild output params
907 int32_t child_offs;
908 uint32_t child_bitfield_bit_size;
909 uint32_t child_bitfield_bit_offset;
910 bool child_is_base_class;
911 bool child_is_deref_of_parent;
912 ValueObject *valobj = nullptr;
913 uint64_t language_flags;
914 ExecutionContext exe_ctx;
915 m_thread.CalculateExecutionContext(exe_ctx);
916
917 return m_type.GetChildCompilerTypeAtIndex(
918 &exe_ctx, i, transparent_pointers, omit_empty_base_classes,
919 ignore_array_bounds, name, size, child_offs, child_bitfield_bit_size,
920 child_bitfield_bit_offset, child_is_base_class,
921 child_is_deref_of_parent, valobj, language_flags);
922 }
923 };
924
925 #undef LOG_PREFIX
926
927 } // anonymous namespace
928
929 ValueObjectSP
GetReturnValueObjectSimple(Thread & thread,CompilerType & type) const930 ABISysV_ppc64::GetReturnValueObjectSimple(Thread &thread,
931 CompilerType &type) const {
932 if (!type)
933 return ValueObjectSP();
934
935 auto exp_extractor = ReturnValueExtractor::Create(thread, type);
936 if (!exp_extractor) {
937 Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS);
938 LLDB_LOG_ERROR(log, exp_extractor.takeError(),
939 "Extracting return value failed: {0}");
940 return ValueObjectSP();
941 }
942
943 return exp_extractor.get().GetValue();
944 }
945
GetReturnValueObjectImpl(Thread & thread,CompilerType & return_compiler_type) const946 ValueObjectSP ABISysV_ppc64::GetReturnValueObjectImpl(
947 Thread &thread, CompilerType &return_compiler_type) const {
948 return GetReturnValueObjectSimple(thread, return_compiler_type);
949 }
950
CreateFunctionEntryUnwindPlan(UnwindPlan & unwind_plan)951 bool ABISysV_ppc64::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) {
952 unwind_plan.Clear();
953 unwind_plan.SetRegisterKind(eRegisterKindDWARF);
954
955 uint32_t lr_reg_num;
956 uint32_t sp_reg_num;
957 uint32_t pc_reg_num;
958
959 if (GetByteOrder() == lldb::eByteOrderLittle) {
960 lr_reg_num = ppc64le_dwarf::dwarf_lr_ppc64le;
961 sp_reg_num = ppc64le_dwarf::dwarf_r1_ppc64le;
962 pc_reg_num = ppc64le_dwarf::dwarf_pc_ppc64le;
963 } else {
964 lr_reg_num = ppc64_dwarf::dwarf_lr_ppc64;
965 sp_reg_num = ppc64_dwarf::dwarf_r1_ppc64;
966 pc_reg_num = ppc64_dwarf::dwarf_pc_ppc64;
967 }
968
969 UnwindPlan::RowSP row(new UnwindPlan::Row);
970
971 // Our Call Frame Address is the stack pointer value
972 row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
973
974 // The previous PC is in the LR
975 row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
976 unwind_plan.AppendRow(row);
977
978 // All other registers are the same.
979
980 unwind_plan.SetSourceName("ppc64 at-func-entry default");
981 unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
982
983 return true;
984 }
985
CreateDefaultUnwindPlan(UnwindPlan & unwind_plan)986 bool ABISysV_ppc64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
987 unwind_plan.Clear();
988 unwind_plan.SetRegisterKind(eRegisterKindDWARF);
989
990 uint32_t sp_reg_num;
991 uint32_t pc_reg_num;
992 uint32_t cr_reg_num;
993
994 if (GetByteOrder() == lldb::eByteOrderLittle) {
995 sp_reg_num = ppc64le_dwarf::dwarf_r1_ppc64le;
996 pc_reg_num = ppc64le_dwarf::dwarf_lr_ppc64le;
997 cr_reg_num = ppc64le_dwarf::dwarf_cr_ppc64le;
998 } else {
999 sp_reg_num = ppc64_dwarf::dwarf_r1_ppc64;
1000 pc_reg_num = ppc64_dwarf::dwarf_lr_ppc64;
1001 cr_reg_num = ppc64_dwarf::dwarf_cr_ppc64;
1002 }
1003
1004 UnwindPlan::RowSP row(new UnwindPlan::Row);
1005 const int32_t ptr_size = 8;
1006 row->SetUnspecifiedRegistersAreUndefined(true);
1007 row->GetCFAValue().SetIsRegisterDereferenced(sp_reg_num);
1008
1009 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * 2, true);
1010 row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
1011 row->SetRegisterLocationToAtCFAPlusOffset(cr_reg_num, ptr_size, true);
1012
1013 unwind_plan.AppendRow(row);
1014 unwind_plan.SetSourceName("ppc64 default unwind plan");
1015 unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
1016 unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
1017 unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
1018 unwind_plan.SetReturnAddressRegister(pc_reg_num);
1019 return true;
1020 }
1021
RegisterIsVolatile(const RegisterInfo * reg_info)1022 bool ABISysV_ppc64::RegisterIsVolatile(const RegisterInfo *reg_info) {
1023 return !RegisterIsCalleeSaved(reg_info);
1024 }
1025
1026 // See "Register Usage" in the
1027 // "System V Application Binary Interface"
1028 // "64-bit PowerPC ELF Application Binary Interface Supplement" current version
1029 // is 2 released 2015 at
1030 // https://members.openpowerfoundation.org/document/dl/576
RegisterIsCalleeSaved(const RegisterInfo * reg_info)1031 bool ABISysV_ppc64::RegisterIsCalleeSaved(const RegisterInfo *reg_info) {
1032 if (reg_info) {
1033 // Preserved registers are :
1034 // r1,r2,r13-r31
1035 // cr2-cr4 (partially preserved)
1036 // f14-f31 (not yet)
1037 // v20-v31 (not yet)
1038 // vrsave (not yet)
1039
1040 const char *name = reg_info->name;
1041 if (name[0] == 'r') {
1042 if ((name[1] == '1' || name[1] == '2') && name[2] == '\0')
1043 return true;
1044 if (name[1] == '1' && name[2] > '2')
1045 return true;
1046 if ((name[1] == '2' || name[1] == '3') && name[2] != '\0')
1047 return true;
1048 }
1049
1050 if (name[0] == 'f' && name[1] >= '0' && name[2] <= '9') {
1051 if (name[2] == '\0')
1052 return false;
1053 if (name[1] == '1' && name[2] >= '4')
1054 return true;
1055 if ((name[1] == '2' || name[1] == '3') && name[2] != '\0')
1056 return true;
1057 }
1058
1059 if (name[0] == 's' && name[1] == 'p' && name[2] == '\0') // sp
1060 return true;
1061 if (name[0] == 'f' && name[1] == 'p' && name[2] == '\0') // fp
1062 return false;
1063 if (name[0] == 'p' && name[1] == 'c' && name[2] == '\0') // pc
1064 return true;
1065 }
1066 return false;
1067 }
1068
Initialize()1069 void ABISysV_ppc64::Initialize() {
1070 PluginManager::RegisterPlugin(
1071 GetPluginNameStatic(), "System V ABI for ppc64 targets", CreateInstance);
1072 }
1073
Terminate()1074 void ABISysV_ppc64::Terminate() {
1075 PluginManager::UnregisterPlugin(CreateInstance);
1076 }
1077
GetPluginNameStatic()1078 lldb_private::ConstString ABISysV_ppc64::GetPluginNameStatic() {
1079 static ConstString g_name("sysv-ppc64");
1080 return g_name;
1081 }
1082
1083 // PluginInterface protocol
1084
GetPluginName()1085 lldb_private::ConstString ABISysV_ppc64::GetPluginName() {
1086 return GetPluginNameStatic();
1087 }
1088
GetPluginVersion()1089 uint32_t ABISysV_ppc64::GetPluginVersion() { return 1; }
1090