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"
10 #include "lldb/Core/PluginManager.h"
11 #include "lldb/Core/Value.h"
12 #include "lldb/Core/ValueObjectConstResult.h"
13 #include "lldb/Expression/ExpressionVariable.h"
14 #include "lldb/Symbol/CompilerType.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
FindPlugin(lldb::ProcessSP process_sp,const ArchSpec & arch)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
GetRegisterInfoByName(llvm::StringRef name,RegisterInfo & info)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
GetReturnValueObject(Thread & thread,CompilerType & ast_type,bool persistent) const69 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 =
89 target.GetPersistentExpressionStateForLanguage(
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
GetReturnValueObject(Thread & thread,llvm::Type & ast_type,bool persistent) const149 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
GetReturnValueObjectImpl(Thread & thread,llvm::Type & ir_type) const160 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
PrepareTrivialCall(Thread & thread,lldb::addr_t sp,lldb::addr_t functionAddress,lldb::addr_t returnAddress,llvm::Type & returntype,llvm::ArrayRef<ABI::CallArgument> args) const169 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
GetFallbackRegisterLocation(const RegisterInfo * reg_info,UnwindPlan::Row::RegisterLocation & unwind_regloc)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
MakeMCRegisterInfo(const ArchSpec & arch)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) {
206 LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS),
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
AugmentRegisterInfo(RegisterInfo & info)217 void RegInfoBasedABI::AugmentRegisterInfo(RegisterInfo &info) {
218 if (info.kinds[eRegisterKindEHFrame] != LLDB_INVALID_REGNUM &&
219 info.kinds[eRegisterKindDWARF] != 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
AugmentRegisterInfo(RegisterInfo & info)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>
GetEHAndDWARFNums(llvm::StringRef name)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
MapRegisterName(std::string & name,llvm::StringRef from_prefix,llvm::StringRef to_prefix)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 }
274