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, nullptr, 0 \
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.getValueOr(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 namespace {
171 const size_t word_size = 4U;
172 const size_t reg_size = word_size;
173 
174 inline size_t AugmentArgSize(size_t size_in_bytes) {
175  return llvm::alignTo(size_in_bytes, word_size);
176 }
177 
178 size_t 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 } // namespace
189 
191  addr_t func_addr, addr_t return_addr,
192  llvm::ArrayRef<addr_t> args) const {
193  // We don't use the traditional trivial call specialized for jit.
194  return false;
195 }
196 
198  addr_t ra, llvm::Type &prototype,
199  llvm::ArrayRef<ABI::CallArgument> args) const {
200  auto reg_ctx = thread.GetRegisterContext();
201  if (!reg_ctx)
202  return false;
203 
204  uint32_t pc_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(
206  if (pc_reg == LLDB_INVALID_REGNUM)
207  return false;
208 
209  uint32_t ra_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(
211  if (ra_reg == LLDB_INVALID_REGNUM)
212  return false;
213 
214  uint32_t sp_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(
216  if (sp_reg == LLDB_INVALID_REGNUM)
217  return false;
218 
219  Status error;
220  ProcessSP process = thread.GetProcess();
221  if (!process)
222  return false;
223 
224  // Push host data onto target.
225  for (const auto &arg : args) {
226  // Skip over target values.
227  if (arg.type == ABI::CallArgument::TargetValue)
228  continue;
229 
230  // Create space on the stack for this data 4-byte aligned.
231  sp -= AugmentArgSize(arg.size);
232 
233  if (process->WriteMemory(sp, arg.data_up.get(), arg.size, error) < arg.size
234  || error.Fail())
235  return false;
236 
237  // Update the argument with the target pointer.
238  *const_cast<addr_t *>(&arg.value) = sp;
239  }
240 
241  // Make sure number of parameters matches prototype.
242  assert(!prototype.isFunctionVarArg());
243  assert(prototype.getFunctionNumParams() == args.size());
244 
245  const size_t regs_for_args_count = IsRegisterFileReduced(*reg_ctx) ? 4U : 8U;
246 
247  // Number of arguments passed on stack.
248  auto args_size = TotalArgsSizeInWords(args);
249  auto on_stack =
250  args_size <= regs_for_args_count ? 0 : args_size - regs_for_args_count;
251  auto offset = on_stack * word_size;
252 
253  uint8_t reg_value[reg_size];
254  size_t reg_index = LLDB_REGNUM_GENERIC_ARG1;
255 
256  for (const auto &arg : args) {
257  auto value = reinterpret_cast<const uint8_t *>(&arg.value);
258  auto size =
259  ABI::CallArgument::TargetValue == arg.type ? arg.size : reg_size;
260 
261  // Pass arguments via registers.
262  while (size > 0 && reg_index < regs_for_args_count) {
263  size_t byte_index = 0;
264  auto end = size < reg_size ? size : reg_size;
265 
266  while (byte_index < end) {
267  reg_value[byte_index++] = *(value++);
268  --size;
269  }
270 
271  while (byte_index < reg_size) {
272  reg_value[byte_index++] = 0;
273  }
274 
275  RegisterValue reg_val_obj(reg_value, reg_size, eByteOrderLittle);
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 namespace {
375 template <typename T>
376 void SetInteger(Scalar &scalar, uint64_t raw_value, bool is_signed) {
377  raw_value &= std::numeric_limits<T>::max();
378  if (is_signed)
379  scalar = static_cast<typename std::make_signed<T>::type>(raw_value);
380  else
381  scalar = static_cast<T>(raw_value);
382 }
383 
384 bool SetSizedInteger(Scalar &scalar, uint64_t raw_value, uint8_t size_in_bytes,
385  bool is_signed) {
386  switch (size_in_bytes) {
387  default:
388  return false;
389 
390  case sizeof(uint64_t):
391  SetInteger<uint64_t>(scalar, raw_value, is_signed);
392  break;
393 
394  case sizeof(uint32_t):
395  SetInteger<uint32_t>(scalar, raw_value, is_signed);
396  break;
397 
398  case sizeof(uint16_t):
399  SetInteger<uint16_t>(scalar, raw_value, is_signed);
400  break;
401 
402  case sizeof(uint8_t):
403  SetInteger<uint8_t>(scalar, raw_value, is_signed);
404  break;
405  }
406 
407  return true;
408 }
409 
410 bool SetSizedFloat(Scalar &scalar, uint64_t raw_value, 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 uint64_t ReadRawValue(const RegisterContextSP &reg_ctx, uint8_t size_in_bytes) {
428  auto reg_info_r0 =
429  reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
430 
431  // Extract the register context so we can read arguments from registers.
432  uint64_t raw_value =
433  reg_ctx->ReadRegisterAsUnsigned(reg_info_r0, 0) & UINT32_MAX;
434 
435  if (sizeof(uint64_t) == size_in_bytes)
436  raw_value |= (reg_ctx->ReadRegisterAsUnsigned(
437  reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
439  UINT64_MAX) << 32U;
440 
441  return raw_value;
442 }
443 } // namespace
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(nullptr).getValueOr(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::eValueTypeScalar);
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::eValueTypeScalar);
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(nullptr).getValueOr(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::eValueTypeScalar);
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 }
602 
604  static ConstString g_name("sysv-arc");
605  return g_name;
606 }
607 
608 //------------------------------------------------------------------
609 // PluginInterface protocol
610 //------------------------------------------------------------------
611 
613  return GetPluginNameStatic();
614 }
615 
#define LLDB_REGNUM_GENERIC_PC
Definition: lldb-defines.h:63
An data extractor class.
Definition: DataExtractor.h:48
#define LLDB_REGNUM_GENERIC_ARG6
Definition: lldb-defines.h:78
size_t GetRedZoneSize() const override
bool CreateDefaultUnwindPlan(lldb_private::UnwindPlan &unwind_plan) override
bool IsRegisterFileReduced(lldb_private::RegisterContext &reg_ctx) const
bool RegisterIsVolatile(const lldb_private::RegisterInfo *reg_info) override
void SetSourceName(const char *)
Definition: UnwindPlan.cpp:546
A class that represents a running process on the host machine.
lldb::ValueObjectSP GetReturnValueObjectImpl(lldb_private::Thread &thread, lldb_private::CompilerType &type) const override
const void * GetData(lldb::offset_t *offset_ptr, lldb::offset_t length) const
Extract length bytes from *offset_ptr.
insn ptr reg, stack ptr reg, etc not specific to any particular target
#define LLDB_REGNUM_GENERIC_RA
Definition: lldb-defines.h:66
uint64_t ReadRegisterAsUnsigned(uint32_t reg, uint64_t fail_value)
static lldb_private::ConstString GetPluginNameStatic()
regnums
Definition: ABISysV_arc.cpp:62
#define LLDB_REGNUM_GENERIC_ARG4
Definition: lldb-defines.h:74
the register numbers seen DWARF
bool IsIntegerOrEnumerationType(bool &is_signed) const
bool CreateFunctionEntryUnwindPlan(lldb_private::UnwindPlan &unwind_plan) override
An architecture specification class.
Definition: ArchSpec.h:33
#define LLDB_REGNUM_GENERIC_ARG2
Definition: lldb-defines.h:70
uint32_t GetTypeInfo(CompilerType *pointee_or_element_compiler_type=nullptr) const
void SetValueType(ValueType value_type)
Definition: Value.h:144
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
#define LLDB_REGNUM_GENERIC_SP
Definition: lldb-defines.h:64
#define DEFINE_REGISTER_STUB(dwarf_num, str_name)
Definition: ABISysV_arc.cpp:52
#define DEFINE_GENERIC_REGISTER_STUB(dwarf_num, str_name, generic_num)
Definition: ABISysV_arc.cpp:44
#define LLDB_REGNUM_GENERIC_ARG7
Definition: lldb-defines.h:80
static void Terminate()
llvm::Optional< uint64_t > GetByteSize(ExecutionContextScope *exe_scope) const
Return the size of the type in bytes.
#define LLDB_REGNUM_GENERIC_ARG5
Definition: lldb-defines.h:76
#define LLDB_REGNUM_GENERIC_ARG1
Definition: lldb-defines.h:68
bool IsPointerType(CompilerType *pointee_type=nullptr) const
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:434
#define LLDB_REGNUM_GENERIC_FP
Definition: lldb-defines.h:65
#define UINT32_MAX
Definition: lldb-defines.h:31
bool IsFloatingPointType(uint32_t &count, bool &is_complex) const
uint64_t offset_t
Definition: lldb-types.h:87
static llvm::raw_ostream & error(Stream &strm)
std::shared_ptr< Row > RowSP
Definition: UnwindPlan.h:377
void AppendRow(const RowSP &row_sp)
Definition: UnwindPlan.cpp:357
virtual lldb::RegisterContextSP GetRegisterContext()=0
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:242
#define LLDB_REGNUM_GENERIC_FLAGS
Definition: lldb-defines.h:67
const RegisterInfo * GetRegisterInfoByName(llvm::StringRef reg_name, uint32_t start_idx=0)
bool Success() const
Test for success condition.
Definition: Status.cpp:288
void SetRegisterKind(lldb::RegisterKind kind)
Definition: UnwindPlan.h:420
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
lldb::ProcessSP GetProcess() const
Definition: Thread.h:153
const lldb_private::RegisterInfo * GetRegisterInfoArray(uint32_t &count) override
uint64_t GetMaxU64(lldb::offset_t *offset_ptr, size_t byte_size) const
Extract an unsigned integer of size byte_size from *offset_ptr.
static RegisterInfo g_register_infos[]
uint64_t addr_t
Definition: lldb-types.h:83
lldb::ValueObjectSP GetReturnValueObjectSimple(lldb_private::Thread &thread, lldb_private::CompilerType &ast_type) const
A uniqued constant string class.
Definition: ConstString.h:40
bool Fail() const
Test for error condition.
Definition: Status.cpp:182
#define LLDB_REGNUM_GENERIC_ARG8
Definition: lldb-defines.h:82
#define LLDB_REGNUM_GENERIC_ARG3
Definition: lldb-defines.h:72
Definition: SBAddress.h:15
uint32_t GetPluginVersion() override
Represents a generic type in a programming language.
Definition: CompilerType.h:33
static void Initialize()
lldb_private::Status SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value) override
static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch)
lldb_private::ConstString GetPluginName() override
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:256
void SetCompilerType(const CompilerType &compiler_type)
Definition: Value.cpp:268
const Scalar & GetScalar() const
Definition: Value.h:168
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:131
virtual lldb::StackFrameSP GetStackFrameAtIndex(uint32_t idx)
Definition: Thread.h:398
#define UINT64_MAX
Definition: lldb-defines.h:35
bool GetArgumentValues(lldb_private::Thread &thread, lldb_private::ValueList &values) const override
void SetSourcedFromCompiler(lldb_private::LazyBool from_compiler)
Definition: UnwindPlan.h:461
An error handling class.
Definition: Status.h:44
#define LLDB_INVALID_REGNUM
Definition: lldb-defines.h:90
LLDB_PLUGIN_DEFINE_ADV(ObjectContainerUniversalMachO, ObjectContainerMachOArchive) void ObjectContainerUniversalMachO