LLDB  mainline
ABI.cpp
Go to the documentation of this file.
1 //===-- ABI.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 "lldb/Target/ABI.h"
11 #include "lldb/Core/Value.h"
15 #include "lldb/Symbol/TypeSystem.h"
16 #include "lldb/Target/Target.h"
17 #include "lldb/Target/Thread.h"
18 #include "lldb/Utility/Log.h"
19 #include "llvm/Support/TargetRegistry.h"
20 #include <cctype>
21 
22 using namespace lldb;
23 using namespace lldb_private;
24 
25 ABISP
26 ABI::FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch) {
27  ABISP abi_sp;
28  ABICreateInstance create_callback;
29 
30  for (uint32_t idx = 0;
31  (create_callback = PluginManager::GetABICreateCallbackAtIndex(idx)) !=
32  nullptr;
33  ++idx) {
34  abi_sp = create_callback(process_sp, arch);
35 
36  if (abi_sp)
37  return abi_sp;
38  }
39  abi_sp.reset();
40  return abi_sp;
41 }
42 
43 ABI::~ABI() = default;
44 
45 bool RegInfoBasedABI::GetRegisterInfoByName(llvm::StringRef name,
46  RegisterInfo &info) {
47  uint32_t count = 0;
48  const RegisterInfo *register_info_array = GetRegisterInfoArray(count);
49  if (register_info_array) {
50  uint32_t i;
51  for (i = 0; i < count; ++i) {
52  const char *reg_name = register_info_array[i].name;
53  if (reg_name == name) {
54  info = register_info_array[i];
55  return true;
56  }
57  }
58  for (i = 0; i < count; ++i) {
59  const char *reg_alt_name = register_info_array[i].alt_name;
60  if (reg_alt_name == name) {
61  info = register_info_array[i];
62  return true;
63  }
64  }
65  }
66  return false;
67 }
68 
69 ValueObjectSP ABI::GetReturnValueObject(Thread &thread, CompilerType &ast_type,
70  bool persistent) const {
71  if (!ast_type.IsValid())
72  return ValueObjectSP();
73 
74  ValueObjectSP return_valobj_sp;
75 
76  return_valobj_sp = GetReturnValueObjectImpl(thread, ast_type);
77  if (!return_valobj_sp)
78  return return_valobj_sp;
79 
80  // Now turn this into a persistent variable.
81  // FIXME: This code is duplicated from Target::EvaluateExpression, and it is
82  // used in similar form in a couple
83  // of other places. Figure out the correct Create function to do all this
84  // work.
85 
86  if (persistent) {
87  Target &target = *thread.CalculateTarget();
88  PersistentExpressionState *persistent_expression_state =
90  ast_type.GetMinimumLanguage());
91 
92  if (!persistent_expression_state)
93  return {};
94 
95  ConstString persistent_variable_name =
96  persistent_expression_state->GetNextPersistentVariableName();
97 
98  lldb::ValueObjectSP const_valobj_sp;
99 
100  // Check in case our value is already a constant value
101  if (return_valobj_sp->GetIsConstant()) {
102  const_valobj_sp = return_valobj_sp;
103  const_valobj_sp->SetName(persistent_variable_name);
104  } else
105  const_valobj_sp =
106  return_valobj_sp->CreateConstantValue(persistent_variable_name);
107 
108  lldb::ValueObjectSP live_valobj_sp = return_valobj_sp;
109 
110  return_valobj_sp = const_valobj_sp;
111 
112  ExpressionVariableSP expr_variable_sp(
113  persistent_expression_state->CreatePersistentVariable(
114  return_valobj_sp));
115 
116  assert(expr_variable_sp);
117 
118  // Set flags and live data as appropriate
119 
120  const Value &result_value = live_valobj_sp->GetValue();
121 
122  switch (result_value.GetValueType()) {
123  case Value::ValueType::Invalid:
124  return {};
125  case Value::ValueType::HostAddress:
126  case Value::ValueType::FileAddress:
127  // we odon't do anything with these for now
128  break;
129  case Value::ValueType::Scalar:
130  expr_variable_sp->m_flags |=
131  ExpressionVariable::EVIsFreezeDried;
132  expr_variable_sp->m_flags |=
133  ExpressionVariable::EVIsLLDBAllocated;
134  expr_variable_sp->m_flags |=
135  ExpressionVariable::EVNeedsAllocation;
136  break;
137  case Value::ValueType::LoadAddress:
138  expr_variable_sp->m_live_sp = live_valobj_sp;
139  expr_variable_sp->m_flags |=
140  ExpressionVariable::EVIsProgramReference;
141  break;
142  }
143 
144  return_valobj_sp = expr_variable_sp->GetValueObject();
145  }
146  return return_valobj_sp;
147 }
148 
149 ValueObjectSP ABI::GetReturnValueObject(Thread &thread, llvm::Type &ast_type,
150  bool persistent) const {
151  ValueObjectSP return_valobj_sp;
152  return_valobj_sp = GetReturnValueObjectImpl(thread, ast_type);
153  return return_valobj_sp;
154 }
155 
156 // specialized to work with llvm IR types
157 //
158 // for now we will specify a default implementation so that we don't need to
159 // modify other ABIs
160 lldb::ValueObjectSP ABI::GetReturnValueObjectImpl(Thread &thread,
161  llvm::Type &ir_type) const {
162  ValueObjectSP return_valobj_sp;
163 
164  /* this is a dummy and will only be called if an ABI does not override this */
165 
166  return return_valobj_sp;
167 }
168 
169 bool ABI::PrepareTrivialCall(Thread &thread, lldb::addr_t sp,
170  lldb::addr_t functionAddress,
171  lldb::addr_t returnAddress, llvm::Type &returntype,
172  llvm::ArrayRef<ABI::CallArgument> args) const {
173  // dummy prepare trivial call
174  llvm_unreachable("Should never get here!");
175 }
176 
177 bool ABI::GetFallbackRegisterLocation(
178  const RegisterInfo *reg_info,
179  UnwindPlan::Row::RegisterLocation &unwind_regloc) {
180  // Did the UnwindPlan fail to give us the caller's stack pointer? The stack
181  // pointer is defined to be the same as THIS frame's CFA, so return the CFA
182  // value as the caller's stack pointer. This is true on x86-32/x86-64 at
183  // least.
184  if (reg_info->kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_SP) {
185  unwind_regloc.SetIsCFAPlusOffset(0);
186  return true;
187  }
188 
189  // If a volatile register is being requested, we don't want to forward the
190  // next frame's register contents up the stack -- the register is not
191  // retrievable at this frame.
192  if (RegisterIsVolatile(reg_info)) {
193  unwind_regloc.SetUndefined();
194  return true;
195  }
196 
197  return false;
198 }
199 
200 std::unique_ptr<llvm::MCRegisterInfo> ABI::MakeMCRegisterInfo(const ArchSpec &arch) {
201  std::string triple = arch.GetTriple().getTriple();
202  std::string lookup_error;
203  const llvm::Target *target =
204  llvm::TargetRegistry::lookupTarget(triple, lookup_error);
205  if (!target) {
207  "Failed to create an llvm target for {0}: {1}", triple,
208  lookup_error);
209  return nullptr;
210  }
211  std::unique_ptr<llvm::MCRegisterInfo> info_up(
212  target->createMCRegInfo(triple));
213  assert(info_up);
214  return info_up;
215 }
216 
217 void RegInfoBasedABI::AugmentRegisterInfo(RegisterInfo &info) {
218  if (info.kinds[eRegisterKindEHFrame] != LLDB_INVALID_REGNUM &&
220  return;
221 
222  RegisterInfo abi_info;
223  if (!GetRegisterInfoByName(info.name, abi_info))
224  return;
225 
226  if (info.kinds[eRegisterKindEHFrame] == LLDB_INVALID_REGNUM)
227  info.kinds[eRegisterKindEHFrame] = abi_info.kinds[eRegisterKindEHFrame];
228  if (info.kinds[eRegisterKindDWARF] == LLDB_INVALID_REGNUM)
229  info.kinds[eRegisterKindDWARF] = abi_info.kinds[eRegisterKindDWARF];
230  if (info.kinds[eRegisterKindGeneric] == LLDB_INVALID_REGNUM)
231  info.kinds[eRegisterKindGeneric] = abi_info.kinds[eRegisterKindGeneric];
232 }
233 
234 void MCBasedABI::AugmentRegisterInfo(RegisterInfo &info) {
235  uint32_t eh, dwarf;
236  std::tie(eh, dwarf) = GetEHAndDWARFNums(info.name);
237 
238  if (info.kinds[eRegisterKindEHFrame] == LLDB_INVALID_REGNUM)
239  info.kinds[eRegisterKindEHFrame] = eh;
240  if (info.kinds[eRegisterKindDWARF] == LLDB_INVALID_REGNUM)
241  info.kinds[eRegisterKindDWARF] = dwarf;
242  if (info.kinds[eRegisterKindGeneric] == LLDB_INVALID_REGNUM)
243  info.kinds[eRegisterKindGeneric] = GetGenericNum(info.name);
244 }
245 
246 std::pair<uint32_t, uint32_t>
247 MCBasedABI::GetEHAndDWARFNums(llvm::StringRef name) {
248  std::string mc_name = GetMCName(name.str());
249  for (char &c : mc_name)
250  c = std::toupper(c);
251  int eh = -1;
252  int dwarf = -1;
253  for (unsigned reg = 0; reg < m_mc_register_info_up->getNumRegs(); ++reg) {
254  if (m_mc_register_info_up->getName(reg) == mc_name) {
255  eh = m_mc_register_info_up->getDwarfRegNum(reg, /*isEH=*/true);
256  dwarf = m_mc_register_info_up->getDwarfRegNum(reg, /*isEH=*/false);
257  break;
258  }
259  }
260  return std::pair<uint32_t, uint32_t>(eh == -1 ? LLDB_INVALID_REGNUM : eh,
261  dwarf == -1 ? LLDB_INVALID_REGNUM
262  : dwarf);
263 }
264 
265 void MCBasedABI::MapRegisterName(std::string &name, llvm::StringRef from_prefix,
266  llvm::StringRef to_prefix) {
267  llvm::StringRef name_ref = name;
268  if (!name_ref.consume_front(from_prefix))
269  return;
270  uint64_t _;
271  if (name_ref.empty() || to_integer(name_ref, _, 10))
272  name = (to_prefix + name_ref).str();
273 }
ExpressionVariable.h
lldb_private::ArchSpec
Definition: ArchSpec.h:33
LLDB_INVALID_REGNUM
#define LLDB_INVALID_REGNUM
Definition: lldb-defines.h:90
lldb::eRegisterKindDWARF
@ eRegisterKindDWARF
the register numbers seen DWARF
Definition: lldb-enumerations.h:229
lldb_private::Value
Definition: Value.h:38
lldb::eRegisterKindGeneric
@ eRegisterKindGeneric
insn ptr reg, stack ptr reg, etc not specific to any particular target
Definition: lldb-enumerations.h:230
lldb_private::Value::GetValueType
ValueType GetValueType() const
Definition: Value.cpp:112
lldb_private::Thread::CalculateTarget
lldb::TargetSP CalculateTarget() override
Definition: Thread.cpp:1390
lldb_private::UnwindPlan::Row::RegisterLocation::SetUndefined
void SetUndefined()
Definition: UnwindPlan.h:84
lldb_private::ArchSpec::GetTriple
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:444
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::Target
Definition: Target.h:447
ABI.h
Target.h
lldb::eRegisterKindEHFrame
@ eRegisterKindEHFrame
the register numbers seen in eh_frame
Definition: lldb-enumerations.h:228
lldb_private::PersistentExpressionState::GetNextPersistentVariableName
virtual ConstString GetNextPersistentVariableName(bool is_error=false)=0
Return a new persistent variable name with the specified prefix.
dwarf
Definition: ABISysV_arc.cpp:61
Log.h
lldb_private::Thread
Definition: Thread.h:62
lldb_private::ConstString
Definition: ConstString.h:40
lldb_private::GetLogIfAllCategoriesSet
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:58
sp
@ sp
Definition: CompactUnwindInfo.cpp:1249
lldb_private::Target::GetPersistentExpressionStateForLanguage
PersistentExpressionState * GetPersistentExpressionStateForLanguage(lldb::LanguageType language)
Definition: Target.cpp:2261
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:38
Thread.h
TypeSystem.h
CompilerType.h
lldb_private::CompilerType::IsValid
bool IsValid() const
Definition: CompilerType.h:72
lldb_private::UnwindPlan::Row::RegisterLocation
Definition: UnwindPlan.h:57
ValueObjectConstResult.h
uint32_t
LLDB_REGNUM_GENERIC_SP
#define LLDB_REGNUM_GENERIC_SP
Definition: lldb-defines.h:64
PluginManager.h
LLDB_LOG
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:242
lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition: CompilerType.h:33
lldb_private::PersistentExpressionState
Definition: ExpressionVariable.h:203
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::CompilerType::GetMinimumLanguage
lldb::LanguageType GetMinimumLanguage()
Definition: CompilerType.cpp:298
lldb_private::UnwindPlan::Row::RegisterLocation::SetIsCFAPlusOffset
void SetIsCFAPlusOffset(int32_t offset)
Definition: UnwindPlan.h:113
lldb_private::PersistentExpressionState::CreatePersistentVariable
virtual lldb::ExpressionVariableSP CreatePersistentVariable(const lldb::ValueObjectSP &valobj_sp)=0
lldb
Definition: SBAddress.h:15
LIBLLDB_LOG_PROCESS
#define LIBLLDB_LOG_PROCESS
Definition: Logging.h:15
Value.h