1 //===-- ABI.cpp -------------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
12 // Other libraries and framework includes
14 #include "lldb/Target/ABI.h"
15 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
16 #include "lldb/Core/PluginManager.h"
17 #include "lldb/Core/Value.h"
18 #include "lldb/Core/ValueObjectConstResult.h"
19 #include "lldb/Symbol/CompilerType.h"
20 #include "lldb/Symbol/TypeSystem.h"
21 #include "lldb/Target/Target.h"
22 #include "lldb/Target/Thread.h"
25 using namespace lldb_private;
28 ABI::FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch) {
30 ABICreateInstance create_callback;
32 for (uint32_t idx = 0;
33 (create_callback = PluginManager::GetABICreateCallbackAtIndex(idx)) !=
36 abi_sp = create_callback(process_sp, arch);
45 ABI::~ABI() = default;
47 bool ABI::GetRegisterInfoByName(const ConstString &name, RegisterInfo &info) {
49 const RegisterInfo *register_info_array = GetRegisterInfoArray(count);
50 if (register_info_array) {
51 const char *unique_name_cstr = name.GetCString();
53 for (i = 0; i < count; ++i) {
54 if (register_info_array[i].name == unique_name_cstr) {
55 info = register_info_array[i];
59 for (i = 0; i < count; ++i) {
60 if (register_info_array[i].alt_name == unique_name_cstr) {
61 info = register_info_array[i];
69 bool ABI::GetRegisterInfoByKind(RegisterKind reg_kind, uint32_t reg_num,
71 if (reg_kind < eRegisterKindEHFrame || reg_kind >= kNumRegisterKinds)
75 const RegisterInfo *register_info_array = GetRegisterInfoArray(count);
76 if (register_info_array) {
77 for (uint32_t i = 0; i < count; ++i) {
78 if (register_info_array[i].kinds[reg_kind] == reg_num) {
79 info = register_info_array[i];
87 ValueObjectSP ABI::GetReturnValueObject(Thread &thread, CompilerType &ast_type,
88 bool persistent) const {
89 if (!ast_type.IsValid())
90 return ValueObjectSP();
92 ValueObjectSP return_valobj_sp;
94 return_valobj_sp = GetReturnValueObjectImpl(thread, ast_type);
95 if (!return_valobj_sp)
96 return return_valobj_sp;
98 // Now turn this into a persistent variable.
99 // FIXME: This code is duplicated from Target::EvaluateExpression, and it is
100 // used in similar form in a couple
101 // of other places. Figure out the correct Create function to do all this
105 Target &target = *thread.CalculateTarget();
106 PersistentExpressionState *persistent_expression_state =
107 target.GetPersistentExpressionStateForLanguage(
108 ast_type.GetMinimumLanguage());
110 if (!persistent_expression_state)
111 return ValueObjectSP();
113 auto prefix = persistent_expression_state->GetPersistentVariablePrefix();
114 ConstString persistent_variable_name =
115 persistent_expression_state->GetNextPersistentVariableName(target,
118 lldb::ValueObjectSP const_valobj_sp;
120 // Check in case our value is already a constant value
121 if (return_valobj_sp->GetIsConstant()) {
122 const_valobj_sp = return_valobj_sp;
123 const_valobj_sp->SetName(persistent_variable_name);
126 return_valobj_sp->CreateConstantValue(persistent_variable_name);
128 lldb::ValueObjectSP live_valobj_sp = return_valobj_sp;
130 return_valobj_sp = const_valobj_sp;
132 ExpressionVariableSP clang_expr_variable_sp(
133 persistent_expression_state->CreatePersistentVariable(
136 assert(clang_expr_variable_sp);
138 // Set flags and live data as appropriate
140 const Value &result_value = live_valobj_sp->GetValue();
142 switch (result_value.GetValueType()) {
143 case Value::eValueTypeHostAddress:
144 case Value::eValueTypeFileAddress:
145 // we don't do anything with these for now
147 case Value::eValueTypeScalar:
148 case Value::eValueTypeVector:
149 clang_expr_variable_sp->m_flags |=
150 ClangExpressionVariable::EVIsFreezeDried;
151 clang_expr_variable_sp->m_flags |=
152 ClangExpressionVariable::EVIsLLDBAllocated;
153 clang_expr_variable_sp->m_flags |=
154 ClangExpressionVariable::EVNeedsAllocation;
156 case Value::eValueTypeLoadAddress:
157 clang_expr_variable_sp->m_live_sp = live_valobj_sp;
158 clang_expr_variable_sp->m_flags |=
159 ClangExpressionVariable::EVIsProgramReference;
163 return_valobj_sp = clang_expr_variable_sp->GetValueObject();
165 return return_valobj_sp;
168 ValueObjectSP ABI::GetReturnValueObject(Thread &thread, llvm::Type &ast_type,
169 bool persistent) const {
170 ValueObjectSP return_valobj_sp;
171 return_valobj_sp = GetReturnValueObjectImpl(thread, ast_type);
172 return return_valobj_sp;
175 // specialized to work with llvm IR types
177 // for now we will specify a default implementation so that we don't need to
179 lldb::ValueObjectSP ABI::GetReturnValueObjectImpl(Thread &thread,
180 llvm::Type &ir_type) const {
181 ValueObjectSP return_valobj_sp;
183 /* this is a dummy and will only be called if an ABI does not override this */
185 return return_valobj_sp;
188 bool ABI::PrepareTrivialCall(Thread &thread, lldb::addr_t sp,
189 lldb::addr_t functionAddress,
190 lldb::addr_t returnAddress, llvm::Type &returntype,
191 llvm::ArrayRef<ABI::CallArgument> args) const {
192 // dummy prepare trivial call
193 llvm_unreachable("Should never get here!");
196 bool ABI::GetFallbackRegisterLocation(
197 const RegisterInfo *reg_info,
198 UnwindPlan::Row::RegisterLocation &unwind_regloc) {
199 // Did the UnwindPlan fail to give us the caller's stack pointer? The stack
200 // pointer is defined to be the same as THIS frame's CFA, so return the CFA
201 // value as the caller's stack pointer. This is true on x86-32/x86-64 at
203 if (reg_info->kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_SP) {
204 unwind_regloc.SetIsCFAPlusOffset(0);
208 // If a volatile register is being requested, we don't want to forward the
209 // next frame's register contents up the stack -- the register is not
210 // retrievable at this frame.
211 if (RegisterIsVolatile(reg_info)) {
212 unwind_regloc.SetUndefined();