LLDB  mainline
ABISysV_arc.cpp
Go to the documentation of this file.
1 //===-- ABISysV_arc.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_arc.h"
10 
11 // C Includes
12 // C++ Includes
13 #include <array>
14 #include <limits>
15 #include <type_traits>
16 
17 // Other libraries and framework includes
18 #include "llvm/ADT/Triple.h"
19 #include "llvm/IR/DerivedTypes.h"
20 #include "llvm/Support/MathExtras.h"
21 
22 #include "lldb/Core/Module.h"
24 #include "lldb/Core/Value.h"
28 #include "lldb/Symbol/UnwindPlan.h"
29 #include "lldb/Target/Process.h"
31 #include "lldb/Target/StackFrame.h"
32 #include "lldb/Target/Target.h"
33 #include "lldb/Target/Thread.h"
36 #include "lldb/Utility/Status.h"
37 
38 #define DEFINE_REG_NAME(reg_num) ConstString(#reg_num).GetCString()
39 #define DEFINE_REG_NAME_STR(reg_name) ConstString(reg_name).GetCString()
40 
41 // The ABI is not a source of such information as size, offset, encoding, etc.
42 // of a register. Just provides correct dwarf and eh_frame numbers.
43 
44 #define DEFINE_GENERIC_REGISTER_STUB(dwarf_num, str_name, generic_num) \
45  { \
46  DEFINE_REG_NAME(dwarf_num), DEFINE_REG_NAME_STR(str_name), \
47  0, 0, eEncodingInvalid, eFormatDefault, \
48  { dwarf_num, dwarf_num, generic_num, LLDB_INVALID_REGNUM, dwarf_num }, \
49  nullptr, nullptr \
50  }
51 
52 #define DEFINE_REGISTER_STUB(dwarf_num, str_name) \
53  DEFINE_GENERIC_REGISTER_STUB(dwarf_num, str_name, LLDB_INVALID_REGNUM)
54 
55 using namespace lldb;
56 using namespace lldb_private;
57 
59 
60 namespace {
61 namespace dwarf {
62 enum regnums {
63  r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16,
64  r17, r18, r19, r20, r21, r22, r23, r24, r25, r26,
65  r27, fp = r27, r28, sp = r28, r29, r30, r31, blink = r31,
66  r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46,
67  r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60,
68  /*reserved,*/ /*limm indicator,*/ r63 = 63, pc = 70, status32 = 74
69 };
70 
71 static const std::array<RegisterInfo, 64> g_register_infos = { {
80  DEFINE_REGISTER_STUB(r8, nullptr),
81  DEFINE_REGISTER_STUB(r9, nullptr),
82  DEFINE_REGISTER_STUB(r10, nullptr),
83  DEFINE_REGISTER_STUB(r11, nullptr),
84  DEFINE_REGISTER_STUB(r12, nullptr),
85  DEFINE_REGISTER_STUB(r13, nullptr),
86  DEFINE_REGISTER_STUB(r14, nullptr),
87  DEFINE_REGISTER_STUB(r15, nullptr),
88  DEFINE_REGISTER_STUB(r16, nullptr),
89  DEFINE_REGISTER_STUB(r17, nullptr),
90  DEFINE_REGISTER_STUB(r18, nullptr),
91  DEFINE_REGISTER_STUB(r19, nullptr),
92  DEFINE_REGISTER_STUB(r20, nullptr),
93  DEFINE_REGISTER_STUB(r21, nullptr),
94  DEFINE_REGISTER_STUB(r22, nullptr),
95  DEFINE_REGISTER_STUB(r23, nullptr),
96  DEFINE_REGISTER_STUB(r24, nullptr),
97  DEFINE_REGISTER_STUB(r25, nullptr),
98  DEFINE_REGISTER_STUB(r26, "gp"),
101  DEFINE_REGISTER_STUB(r29, "ilink"),
102  DEFINE_REGISTER_STUB(r30, nullptr),
104  DEFINE_REGISTER_STUB(r32, nullptr),
105  DEFINE_REGISTER_STUB(r33, nullptr),
106  DEFINE_REGISTER_STUB(r34, nullptr),
107  DEFINE_REGISTER_STUB(r35, nullptr),
108  DEFINE_REGISTER_STUB(r36, nullptr),
109  DEFINE_REGISTER_STUB(r37, nullptr),
110  DEFINE_REGISTER_STUB(r38, nullptr),
111  DEFINE_REGISTER_STUB(r39, nullptr),
112  DEFINE_REGISTER_STUB(r40, nullptr),
113  DEFINE_REGISTER_STUB(r41, nullptr),
114  DEFINE_REGISTER_STUB(r42, nullptr),
115  DEFINE_REGISTER_STUB(r43, nullptr),
116  DEFINE_REGISTER_STUB(r44, nullptr),
117  DEFINE_REGISTER_STUB(r45, nullptr),
118  DEFINE_REGISTER_STUB(r46, nullptr),
119  DEFINE_REGISTER_STUB(r47, nullptr),
120  DEFINE_REGISTER_STUB(r48, nullptr),
121  DEFINE_REGISTER_STUB(r49, nullptr),
122  DEFINE_REGISTER_STUB(r50, nullptr),
123  DEFINE_REGISTER_STUB(r51, nullptr),
124  DEFINE_REGISTER_STUB(r52, nullptr),
125  DEFINE_REGISTER_STUB(r53, nullptr),
126  DEFINE_REGISTER_STUB(r54, nullptr),
127  DEFINE_REGISTER_STUB(r55, nullptr),
128  DEFINE_REGISTER_STUB(r56, nullptr),
129  DEFINE_REGISTER_STUB(r57, nullptr),
130  DEFINE_REGISTER_STUB(r58, "accl"),
131  DEFINE_REGISTER_STUB(r59, "acch"),
132  DEFINE_REGISTER_STUB(r60, "lp_count"),
133  DEFINE_REGISTER_STUB(r63, "pcl"),
136 } // namespace dwarf
137 } // namespace
138 
139 const RegisterInfo *ABISysV_arc::GetRegisterInfoArray(uint32_t &count) {
140  count = dwarf::g_register_infos.size();
141  return dwarf::g_register_infos.data();
142 }
143 
144 size_t ABISysV_arc::GetRedZoneSize() const { return 0; }
145 
147  if (!m_is_reg_file_reduced) {
148  const auto *const rf_build_reg = reg_ctx.GetRegisterInfoByName("rf_build");
149 
150  const auto reg_value = reg_ctx.ReadRegisterAsUnsigned(rf_build_reg,
151  /*fail_value*/ 0);
152  // RF_BUILD "Number of Entries" bit.
153  const uint32_t rf_entries_bit = 1U << 9U;
154  m_is_reg_file_reduced = (reg_value & rf_entries_bit) != 0;
155  }
156 
157  return m_is_reg_file_reduced.value_or(false);
158 }
159 
160 //------------------------------------------------------------------
161 // Static Functions
162 //------------------------------------------------------------------
163 
164 ABISP ABISysV_arc::CreateInstance(ProcessSP process_sp, const ArchSpec &arch) {
165  return llvm::Triple::arc == arch.GetTriple().getArch() ?
166  ABISP(new ABISysV_arc(std::move(process_sp), MakeMCRegisterInfo(arch))) :
167  ABISP();
168 }
169 
170 static const size_t word_size = 4U;
171 static const size_t reg_size = word_size;
172 
173 static inline size_t AugmentArgSize(size_t size_in_bytes) {
174  return llvm::alignTo(size_in_bytes, word_size);
175 }
176 
177 static size_t
178 TotalArgsSizeInWords(const llvm::ArrayRef<ABI::CallArgument> &args) {
179  size_t total_size = 0;
180  for (const auto &arg : args)
181  total_size +=
182  (ABI::CallArgument::TargetValue == arg.type ? AugmentArgSize(arg.size)
183  : reg_size) /
184  word_size;
185 
186  return total_size;
187 }
188 
190  addr_t func_addr, addr_t return_addr,
191  llvm::ArrayRef<addr_t> args) const {
192  // We don't use the traditional trivial call specialized for jit.
193  return false;
194 }
195 
197  addr_t ra, llvm::Type &prototype,
198  llvm::ArrayRef<ABI::CallArgument> args) const {
199  auto reg_ctx = thread.GetRegisterContext();
200  if (!reg_ctx)
201  return false;
202 
203  uint32_t pc_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(
205  if (pc_reg == LLDB_INVALID_REGNUM)
206  return false;
207 
208  uint32_t ra_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(
210  if (ra_reg == LLDB_INVALID_REGNUM)
211  return false;
212 
213  uint32_t sp_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(
215  if (sp_reg == LLDB_INVALID_REGNUM)
216  return false;
217 
218  Status error;
219  ProcessSP process = thread.GetProcess();
220  if (!process)
221  return false;
222 
223  // Push host data onto target.
224  for (const auto &arg : args) {
225  // Skip over target values.
226  if (arg.type == ABI::CallArgument::TargetValue)
227  continue;
228 
229  // Create space on the stack for this data 4-byte aligned.
230  sp -= AugmentArgSize(arg.size);
231 
232  if (process->WriteMemory(sp, arg.data_up.get(), arg.size, error) < arg.size
233  || error.Fail())
234  return false;
235 
236  // Update the argument with the target pointer.
237  *const_cast<addr_t *>(&arg.value) = sp;
238  }
239 
240  // Make sure number of parameters matches prototype.
241  assert(!prototype.isFunctionVarArg());
242  assert(prototype.getFunctionNumParams() == args.size());
243 
244  const size_t regs_for_args_count = IsRegisterFileReduced(*reg_ctx) ? 4U : 8U;
245 
246  // Number of arguments passed on stack.
247  auto args_size = TotalArgsSizeInWords(args);
248  auto on_stack =
249  args_size <= regs_for_args_count ? 0 : args_size - regs_for_args_count;
250  auto offset = on_stack * word_size;
251 
252  uint8_t reg_value[reg_size];
253  size_t reg_index = LLDB_REGNUM_GENERIC_ARG1;
254 
255  for (const auto &arg : args) {
256  auto value = reinterpret_cast<const uint8_t *>(&arg.value);
257  auto size =
258  ABI::CallArgument::TargetValue == arg.type ? arg.size : reg_size;
259 
260  // Pass arguments via registers.
261  while (size > 0 && reg_index < regs_for_args_count) {
262  size_t byte_index = 0;
263  auto end = size < reg_size ? size : reg_size;
264 
265  while (byte_index < end) {
266  reg_value[byte_index++] = *(value++);
267  --size;
268  }
269 
270  while (byte_index < reg_size) {
271  reg_value[byte_index++] = 0;
272  }
273 
274  RegisterValue reg_val_obj(llvm::makeArrayRef(reg_value, reg_size),
276  if (!reg_ctx->WriteRegister(
277  reg_ctx->GetRegisterInfo(eRegisterKindGeneric, reg_index),
278  reg_val_obj))
279  return false;
280 
281  // NOTE: It's unsafe to iterate through LLDB_REGNUM_GENERICs.
282  ++reg_index;
283  }
284 
285  if (reg_index < regs_for_args_count || size == 0)
286  continue;
287 
288  // Remaining arguments are passed on the stack.
289  if (process->WriteMemory(sp - offset, value, size, error) < size ||
290  !error.Success())
291  return false;
292 
293  offset -= AugmentArgSize(size);
294  }
295 
296  // Set stack pointer immediately below arguments.
297  sp -= on_stack * word_size;
298 
299  // Update registers with current function call state.
300  reg_ctx->WriteRegisterFromUnsigned(pc_reg, pc);
301  reg_ctx->WriteRegisterFromUnsigned(ra_reg, ra);
302  reg_ctx->WriteRegisterFromUnsigned(sp_reg, sp);
303 
304  return true;
305 }
306 
307 bool ABISysV_arc::GetArgumentValues(Thread &thread, ValueList &values) const {
308  return false;
309 }
310 
312  ValueObjectSP &new_value_sp) {
313  Status result;
314  if (!new_value_sp) {
315  result.SetErrorString("Empty value object for return value.");
316  return result;
317  }
318 
319  CompilerType compiler_type = new_value_sp->GetCompilerType();
320  if (!compiler_type) {
321  result.SetErrorString("Null clang type for return value.");
322  return result;
323  }
324 
325  auto &reg_ctx = *frame_sp->GetThread()->GetRegisterContext();
326 
327  bool is_signed = false;
328  if (!compiler_type.IsIntegerOrEnumerationType(is_signed) &&
329  !compiler_type.IsPointerType()) {
330  result.SetErrorString("We don't support returning other types at present");
331  return result;
332  }
333 
334  DataExtractor data;
335  size_t num_bytes = new_value_sp->GetData(data, result);
336 
337  if (result.Fail()) {
339  "Couldn't convert return value to raw data: %s", result.AsCString());
340  return result;
341  }
342 
343  if (num_bytes <= 2 * reg_size) {
344  offset_t offset = 0;
345  uint64_t raw_value = data.GetMaxU64(&offset, num_bytes);
346 
347  auto reg_info =
348  reg_ctx.GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
349  if (!reg_ctx.WriteRegisterFromUnsigned(reg_info, raw_value)) {
350  result.SetErrorStringWithFormat("Couldn't write value to register %s",
351  reg_info->name);
352  return result;
353  }
354 
355  if (num_bytes <= reg_size)
356  return result; // Successfully written.
357 
358  raw_value >>= 32;
359  reg_info =
360  reg_ctx.GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG2);
361  if (!reg_ctx.WriteRegisterFromUnsigned(reg_info, raw_value)) {
362  result.SetErrorStringWithFormat("Couldn't write value to register %s",
363  reg_info->name);
364  }
365 
366  return result;
367  }
368 
369  result.SetErrorString(
370  "We don't support returning large integer values at present.");
371  return result;
372 }
373 
374 template <typename T>
375 static void SetInteger(Scalar &scalar, uint64_t raw_value, bool is_signed) {
376  raw_value &= std::numeric_limits<T>::max();
377  if (is_signed)
378  scalar = static_cast<typename std::make_signed<T>::type>(raw_value);
379  else
380  scalar = static_cast<T>(raw_value);
381 }
382 
383 static bool SetSizedInteger(Scalar &scalar, uint64_t raw_value,
384  uint8_t size_in_bytes, bool is_signed) {
385  switch (size_in_bytes) {
386  default:
387  return false;
388 
389  case sizeof(uint64_t):
390  SetInteger<uint64_t>(scalar, raw_value, is_signed);
391  break;
392 
393  case sizeof(uint32_t):
394  SetInteger<uint32_t>(scalar, raw_value, is_signed);
395  break;
396 
397  case sizeof(uint16_t):
398  SetInteger<uint16_t>(scalar, raw_value, is_signed);
399  break;
400 
401  case sizeof(uint8_t):
402  SetInteger<uint8_t>(scalar, raw_value, is_signed);
403  break;
404  }
405 
406  return true;
407 }
408 
409 static bool SetSizedFloat(Scalar &scalar, uint64_t raw_value,
410  uint8_t size_in_bytes) {
411  switch (size_in_bytes) {
412  default:
413  return false;
414 
415  case sizeof(uint64_t):
416  scalar = *reinterpret_cast<double *>(&raw_value);
417  break;
418 
419  case sizeof(uint32_t):
420  scalar = *reinterpret_cast<float *>(&raw_value);
421  break;
422  }
423 
424  return true;
425 }
426 
427 static uint64_t ReadRawValue(const RegisterContextSP &reg_ctx,
428  uint8_t size_in_bytes) {
429  auto reg_info_r0 =
430  reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
431 
432  // Extract the register context so we can read arguments from registers.
433  uint64_t raw_value =
434  reg_ctx->ReadRegisterAsUnsigned(reg_info_r0, 0) & UINT32_MAX;
435 
436  if (sizeof(uint64_t) == size_in_bytes)
437  raw_value |= (reg_ctx->ReadRegisterAsUnsigned(
438  reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
440  UINT64_MAX) << 32U;
441 
442  return raw_value;
443 }
444 
445 ValueObjectSP
447  CompilerType &compiler_type) const {
448  if (!compiler_type)
449  return ValueObjectSP();
450 
451  auto reg_ctx = thread.GetRegisterContext();
452  if (!reg_ctx)
453  return ValueObjectSP();
454 
455  Value value;
456  value.SetCompilerType(compiler_type);
457 
458  const uint32_t type_flags = compiler_type.GetTypeInfo();
459  // Integer return type.
460  if (type_flags & eTypeIsInteger) {
461  const size_t byte_size = compiler_type.GetByteSize(&thread).value_or(0);
462  auto raw_value = ReadRawValue(reg_ctx, byte_size);
463 
464  const bool is_signed = (type_flags & eTypeIsSigned) != 0;
465  if (!SetSizedInteger(value.GetScalar(), raw_value, byte_size, is_signed))
466  return ValueObjectSP();
467 
468  value.SetValueType(Value::ValueType::Scalar);
469  }
470  // Pointer return type.
471  else if (type_flags & eTypeIsPointer) {
472  auto reg_info_r0 = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
474  value.GetScalar() = reg_ctx->ReadRegisterAsUnsigned(reg_info_r0, 0);
475 
476  value.SetValueType(Value::ValueType::Scalar);
477  }
478  // Floating point return type.
479  else if (type_flags & eTypeIsFloat) {
480  uint32_t float_count = 0;
481  bool is_complex = false;
482 
483  if (compiler_type.IsFloatingPointType(float_count, is_complex) &&
484  1 == float_count && !is_complex) {
485  const size_t byte_size = compiler_type.GetByteSize(&thread).value_or(0);
486  auto raw_value = ReadRawValue(reg_ctx, byte_size);
487 
488  if (!SetSizedFloat(value.GetScalar(), raw_value, byte_size))
489  return ValueObjectSP();
490  }
491  }
492  // Unsupported return type.
493  else
494  return ValueObjectSP();
495 
496  return ValueObjectConstResult::Create(thread.GetStackFrameAtIndex(0).get(),
497  value, ConstString(""));
498 }
499 
501  Thread &thread, CompilerType &return_compiler_type) const {
502  ValueObjectSP return_valobj_sp;
503 
504  if (!return_compiler_type)
505  return return_valobj_sp;
506 
507  ExecutionContext exe_ctx(thread.shared_from_this());
508  return GetReturnValueObjectSimple(thread, return_compiler_type);
509 }
510 
512  llvm::Type &retType) const {
513  auto reg_ctx = thread.GetRegisterContext();
514  if (!reg_ctx)
515  return ValueObjectSP();
516 
517  Value value;
518  // Void return type.
519  if (retType.isVoidTy()) {
520  value.GetScalar() = 0;
521  }
522  // Integer return type.
523  else if (retType.isIntegerTy()) {
524  size_t byte_size = retType.getPrimitiveSizeInBits();
525  if (1 != byte_size) // For boolean type.
526  byte_size /= CHAR_BIT;
527 
528  auto raw_value = ReadRawValue(reg_ctx, byte_size);
529 
530  const bool is_signed = false; // IR Type doesn't provide this info.
531  if (!SetSizedInteger(value.GetScalar(), raw_value, byte_size, is_signed))
532  return ValueObjectSP();
533  }
534  // Pointer return type.
535  else if (retType.isPointerTy()) {
536  auto reg_info_r0 = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
538  value.GetScalar() = reg_ctx->ReadRegisterAsUnsigned(reg_info_r0, 0);
539  value.SetValueType(Value::ValueType::Scalar);
540  }
541  // Floating point return type.
542  else if (retType.isFloatingPointTy()) {
543  const size_t byte_size = retType.getPrimitiveSizeInBits() / CHAR_BIT;
544  auto raw_value = ReadRawValue(reg_ctx, byte_size);
545 
546  if (!SetSizedFloat(value.GetScalar(), raw_value, byte_size))
547  return ValueObjectSP();
548  }
549  // Unsupported return type.
550  else
551  return ValueObjectSP();
552 
553  return ValueObjectConstResult::Create(thread.GetStackFrameAtIndex(0).get(),
554  value, ConstString(""));
555 }
556 
558  unwind_plan.Clear();
559  unwind_plan.SetRegisterKind(eRegisterKindDWARF);
560 
562 
563  // Our Call Frame Address is the stack pointer value.
564  row->GetCFAValue().SetIsRegisterPlusOffset(dwarf::sp, 0);
565 
566  // The previous PC is in the BLINK.
567  row->SetRegisterLocationToRegister(dwarf::pc, dwarf::blink, true);
568  unwind_plan.AppendRow(row);
569 
570  // All other registers are the same.
571  unwind_plan.SetSourceName("arc at-func-entry default");
572  unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
573 
574  return true;
575 }
576 
578  return false;
579 }
580 
581 bool ABISysV_arc::RegisterIsVolatile(const RegisterInfo *reg_info) {
582  if (nullptr == reg_info)
583  return false;
584 
585  // Volatile registers are: r0..r12.
586  uint32_t regnum = reg_info->kinds[eRegisterKindDWARF];
587  if (regnum <= 12)
588  return true;
589 
590  static const std::string ra_reg_name = "blink";
591  return ra_reg_name == reg_info->name;
592 }
593 
595  PluginManager::RegisterPlugin(GetPluginNameStatic(),
596  "System V ABI for ARC targets", CreateInstance);
597 }
598 
600  PluginManager::UnregisterPlugin(CreateInstance);
601 }
LLDB_REGNUM_GENERIC_ARG2
#define LLDB_REGNUM_GENERIC_ARG2
Definition: lldb-defines.h:58
ABISysV_arc::IsRegisterFileReduced
bool IsRegisterFileReduced(lldb_private::RegisterContext &reg_ctx) const
Definition: ABISysV_arc.cpp:146
LLDB_REGNUM_GENERIC_ARG3
#define LLDB_REGNUM_GENERIC_ARG3
Definition: lldb-defines.h:60
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
r12
@ r12
Definition: CompactUnwindInfo.cpp:706
lldb_private::UnwindPlan::AppendRow
void AppendRow(const RowSP &row_sp)
Definition: UnwindPlan.cpp:362
DEFINE_REGISTER_STUB
#define DEFINE_REGISTER_STUB(dwarf_num, str_name)
Definition: ABISysV_arc.cpp:52
lldb_private::ArchSpec
Definition: ArchSpec.h:32
LLDB_REGNUM_GENERIC_ARG1
#define LLDB_REGNUM_GENERIC_ARG1
Definition: lldb-defines.h:56
LLDB_INVALID_REGNUM
#define LLDB_INVALID_REGNUM
Definition: lldb-defines.h:79
lldb_private::RegisterValue
Definition: RegisterValue.h:28
lldb_private::UnwindPlan::SetRegisterKind
void SetRegisterKind(lldb::RegisterKind kind)
Definition: UnwindPlan.h:437
lldb::eRegisterKindDWARF
@ eRegisterKindDWARF
the register numbers seen DWARF
Definition: lldb-enumerations.h:230
lldb_private::Value
Definition: Value.h:38
lldb_private::Value::SetValueType
void SetValueType(ValueType value_type)
Definition: Value.h:89
lldb::eRegisterKindGeneric
@ eRegisterKindGeneric
insn ptr reg, stack ptr reg, etc not specific to any particular target
Definition: lldb-enumerations.h:231
LLDB_REGNUM_GENERIC_ARG5
#define LLDB_REGNUM_GENERIC_ARG5
Definition: lldb-defines.h:64
ABISysV_arc::PrepareTrivialCall
bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp, lldb::addr_t functionAddress, lldb::addr_t returnAddress, llvm::ArrayRef< lldb::addr_t > args) const override
r10
@ r10
Definition: CompactUnwindInfo.cpp:704
lldb_private::Scalar
Definition: Scalar.h:34
Module.h
word_size
static const size_t word_size
Definition: ABISysV_arc.cpp:170
lldb_private::RegisterContext::ReadRegisterAsUnsigned
uint64_t ReadRegisterAsUnsigned(uint32_t reg, uint64_t fail_value)
Definition: RegisterContext.cpp:188
ABISysV_arc::CreateFunctionEntryUnwindPlan
bool CreateFunctionEntryUnwindPlan(lldb_private::UnwindPlan &unwind_plan) override
Definition: ABISysV_arc.cpp:557
reg_size
static const size_t reg_size
Definition: ABISysV_arc.cpp:171
g_register_infos
static const RegisterInfo g_register_infos[]
Definition: ABIMacOSX_arm.cpp:37
ABISysV_arc::RegisterIsVolatile
bool RegisterIsVolatile(const lldb_private::RegisterInfo *reg_info) override
Definition: ABISysV_arc.cpp:581
lldb_private::CompilerType::GetByteSize
llvm::Optional< uint64_t > GetByteSize(ExecutionContextScope *exe_scope) const
Return the size of the type in bytes.
Definition: CompilerType.cpp:552
lldb::offset_t
uint64_t offset_t
Definition: lldb-types.h:87
RegisterValue.h
lldb_private::ValueList
Definition: Value.h:157
StackFrame.h
ValueObjectMemory.h
ra
@ ra
Definition: CompactUnwindInfo.cpp:1249
lldb_private::ArchSpec::GetTriple
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:463
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::CompilerType::IsFloatingPointType
bool IsFloatingPointType(uint32_t &count, bool &is_complex) const
Definition: CompilerType.cpp:220
pc
@ pc
Definition: CompactUnwindInfo.cpp:1251
lldb_private::UnwindPlan::SetSourceName
void SetSourceName(const char *)
Definition: UnwindPlan.cpp:564
LLDB_PLUGIN_DEFINE_ADV
LLDB_PLUGIN_DEFINE_ADV(ObjectContainerUniversalMachO, ObjectContainerMachOArchive) void ObjectContainerUniversalMachO
Definition: ObjectContainerUniversalMachO.cpp:23
LLDB_REGNUM_GENERIC_ARG6
#define LLDB_REGNUM_GENERIC_ARG6
Definition: lldb-defines.h:66
ABISysV_arc::SetReturnValueObject
lldb_private::Status SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value) override
Definition: ABISysV_arc.cpp:311
Process.h
regnums
regnums
Definition: ABISysV_arc.cpp:62
lldb_private::CompilerType::IsIntegerOrEnumerationType
bool IsIntegerOrEnumerationType(bool &is_signed) const
Definition: CompilerType.cpp:178
lldb_private::Value::SetCompilerType
void SetCompilerType(const CompilerType &compiler_type)
Definition: Value.cpp:251
ABISysV_arc::Initialize
static void Initialize()
Definition: ABISysV_arc.cpp:594
Target.h
lldb_private::Value::GetScalar
const Scalar & GetScalar() const
Definition: Value.h:112
lldb_private::Thread::GetProcess
lldb::ProcessSP GetProcess() const
Definition: Thread.h:153
LLDB_REGNUM_GENERIC_FLAGS
#define LLDB_REGNUM_GENERIC_FLAGS
Definition: lldb-defines.h:55
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
r8
@ r8
Definition: CompactUnwindInfo.cpp:702
dwarf
Definition: ABISysV_arc.cpp:61
lldb_private::DataExtractor
Definition: DataExtractor.h:48
ABISysV_arc::GetArgumentValues
bool GetArgumentValues(lldb_private::Thread &thread, lldb_private::ValueList &values) const override
Definition: ABISysV_arc.cpp:307
lldb_private::Thread
Definition: Thread.h:61
DEFINE_GENERIC_REGISTER_STUB
#define DEFINE_GENERIC_REGISTER_STUB(dwarf_num, str_name, generic_num)
Definition: ABISysV_arc.cpp:44
lldb_private::Status::Fail
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
lldb_private::Status::SetErrorStringWithFormat
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:255
r11
@ r11
Definition: CompactUnwindInfo.cpp:705
r14
@ r14
Definition: CompactUnwindInfo.cpp:708
lldb_private::UnwindPlan::SetSourcedFromCompiler
void SetSourcedFromCompiler(lldb_private::LazyBool from_compiler)
Definition: UnwindPlan.h:478
ValueObjectRegister.h
lldb_private::ConstString
Definition: ConstString.h:39
ABISysV_arc
Definition: ABISysV_arc.h:19
SetInteger
static void SetInteger(Scalar &scalar, uint64_t raw_value, bool is_signed)
Definition: ABISysV_arc.cpp:375
ABISysV_arc::CreateDefaultUnwindPlan
bool CreateDefaultUnwindPlan(lldb_private::UnwindPlan &unwind_plan) override
Definition: ABISysV_arc.cpp:577
ABISysV_arc::GetReturnValueObjectImpl
lldb::ValueObjectSP GetReturnValueObjectImpl(lldb_private::Thread &thread, lldb_private::CompilerType &type) const override
Definition: ABISysV_arc.cpp:500
sp
@ sp
Definition: CompactUnwindInfo.cpp:1250
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
Thread.h
UnwindPlan.h
lldb_private::RegisterContext
Definition: RegisterContext.h:17
ValueObjectConstResult.h
ABISysV_arc::GetRegisterInfoArray
const lldb_private::RegisterInfo * GetRegisterInfoArray(uint32_t &count) override
Definition: ABISysV_arc.cpp:139
lldb_private::UnwindPlan::RowSP
std::shared_ptr< Row > RowSP
Definition: UnwindPlan.h:395
ABISysV_arc::CreateInstance
static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch)
Definition: ABISysV_arc.cpp:164
lldb_private::UnwindPlan::Clear
void Clear()
Definition: UnwindPlan.h:508
lldb_private::Status
Definition: Status.h:44
TotalArgsSizeInWords
static size_t TotalArgsSizeInWords(const llvm::ArrayRef< ABI::CallArgument > &args)
Definition: ABISysV_arc.cpp:178
ABISysV_arc.h
lldb_private::UnwindPlan::Row
Definition: UnwindPlan.h:55
uint32_t
lldb_private::eLazyBoolNo
@ eLazyBoolNo
Definition: lldb-private-enumerations.h:115
LLDB_REGNUM_GENERIC_SP
#define LLDB_REGNUM_GENERIC_SP
Definition: lldb-defines.h:52
ABISysV_arc::GetReturnValueObjectSimple
lldb::ValueObjectSP GetReturnValueObjectSimple(lldb_private::Thread &thread, lldb_private::CompilerType &ast_type) const
Definition: ABISysV_arc.cpp:446
lldb_private::DataExtractor::GetMaxU64
uint64_t GetMaxU64(lldb::offset_t *offset_ptr, size_t byte_size) const
Extract an unsigned integer of size byte_size from *offset_ptr.
Definition: DataExtractor.cpp:524
lldb_private::CompilerType::IsPointerType
bool IsPointerType(CompilerType *pointee_type=nullptr) const
Definition: CompilerType.cpp:182
ABISysV_arc::Terminate
static void Terminate()
Definition: ABISysV_arc.cpp:599
lldb_private::CompilerType::GetTypeInfo
uint32_t GetTypeInfo(CompilerType *pointee_or_element_compiler_type=nullptr) const
Definition: CompilerType.cpp:329
lldb_private::Status::SetErrorString
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:241
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:19
SetSizedInteger
static bool SetSizedInteger(Scalar &scalar, uint64_t raw_value, uint8_t size_in_bytes, bool is_signed)
Definition: ABISysV_arc.cpp:383
uint16_t
PluginManager.h
lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition: CompilerType.h:35
Status.h
LLDB_REGNUM_GENERIC_ARG4
#define LLDB_REGNUM_GENERIC_ARG4
Definition: lldb-defines.h:62
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
LLDB_REGNUM_GENERIC_FP
#define LLDB_REGNUM_GENERIC_FP
Definition: lldb-defines.h:53
r15
@ r15
Definition: CompactUnwindInfo.cpp:709
LLDB_REGNUM_GENERIC_PC
#define LLDB_REGNUM_GENERIC_PC
Definition: lldb-defines.h:51
ConstString.h
lldb_private::DataExtractor::GetData
const void * GetData(lldb::offset_t *offset_ptr, lldb::offset_t length) const
Extract length bytes from *offset_ptr.
Definition: DataExtractor.h:337
SetSizedFloat
static bool SetSizedFloat(Scalar &scalar, uint64_t raw_value, uint8_t size_in_bytes)
Definition: ABISysV_arc.cpp:409
lldb_private::Thread::GetStackFrameAtIndex
virtual lldb::StackFrameSP GetStackFrameAtIndex(uint32_t idx)
Definition: Thread.h:399
LLDB_REGNUM_GENERIC_ARG8
#define LLDB_REGNUM_GENERIC_ARG8
Definition: lldb-defines.h:70
lldb_private::Thread::GetRegisterContext
virtual lldb::RegisterContextSP GetRegisterContext()=0
LLDB_REGNUM_GENERIC_ARG7
#define LLDB_REGNUM_GENERIC_ARG7
Definition: lldb-defines.h:68
ABISysV_arc::GetRedZoneSize
size_t GetRedZoneSize() const override
Definition: ABISysV_arc.cpp:144
fp
@ fp
Definition: CompactUnwindInfo.cpp:1248
lldb::eByteOrderLittle
@ eByteOrderLittle
Definition: lldb-enumerations.h:143
AugmentArgSize
static size_t AugmentArgSize(size_t size_in_bytes)
Definition: ABISysV_arc.cpp:173
r9
@ r9
Definition: CompactUnwindInfo.cpp:703
lldb_private::UnwindPlan
Definition: UnwindPlan.h:53
lldb
Definition: SBAddress.h:15
ReadRawValue
static uint64_t ReadRawValue(const RegisterContextSP &reg_ctx, uint8_t size_in_bytes)
Definition: ABISysV_arc.cpp:427
RegisterContext.h
Value.h
UINT64_MAX
#define UINT64_MAX
Definition: lldb-defines.h:23
lldb_private::RegisterContext::GetRegisterInfoByName
const RegisterInfo * GetRegisterInfoByName(llvm::StringRef reg_name, uint32_t start_idx=0)
Definition: RegisterContext.cpp:52
lldb_private::Status::AsCString
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:130
r13
@ r13
Definition: CompactUnwindInfo.cpp:707
LLDB_REGNUM_GENERIC_RA
#define LLDB_REGNUM_GENERIC_RA
Definition: lldb-defines.h:54