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