1 //===-- ABI.cpp -------------------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 // C Includes
11 // C++ Includes
12 // Other libraries and framework includes
13 // Project 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"
23 
24 using namespace lldb;
25 using namespace lldb_private;
26 
27 ABISP
28 ABI::FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch) {
29   ABISP abi_sp;
30   ABICreateInstance create_callback;
31 
32   for (uint32_t idx = 0;
33        (create_callback = PluginManager::GetABICreateCallbackAtIndex(idx)) !=
34        nullptr;
35        ++idx) {
36     abi_sp = create_callback(process_sp, arch);
37 
38     if (abi_sp)
39       return abi_sp;
40   }
41   abi_sp.reset();
42   return abi_sp;
43 }
44 
45 ABI::~ABI() = default;
46 
47 bool ABI::GetRegisterInfoByName(const ConstString &name, RegisterInfo &info) {
48   uint32_t count = 0;
49   const RegisterInfo *register_info_array = GetRegisterInfoArray(count);
50   if (register_info_array) {
51     const char *unique_name_cstr = name.GetCString();
52     uint32_t i;
53     for (i = 0; i < count; ++i) {
54       if (register_info_array[i].name == unique_name_cstr) {
55         info = register_info_array[i];
56         return true;
57       }
58     }
59     for (i = 0; i < count; ++i) {
60       if (register_info_array[i].alt_name == unique_name_cstr) {
61         info = register_info_array[i];
62         return true;
63       }
64     }
65   }
66   return false;
67 }
68 
69 bool ABI::GetRegisterInfoByKind(RegisterKind reg_kind, uint32_t reg_num,
70                                 RegisterInfo &info) {
71   if (reg_kind < eRegisterKindEHFrame || reg_kind >= kNumRegisterKinds)
72     return false;
73 
74   uint32_t count = 0;
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];
80         return true;
81       }
82     }
83   }
84   return false;
85 }
86 
87 ValueObjectSP ABI::GetReturnValueObject(Thread &thread, CompilerType &ast_type,
88                                         bool persistent) const {
89   if (!ast_type.IsValid())
90     return ValueObjectSP();
91 
92   ValueObjectSP return_valobj_sp;
93 
94   return_valobj_sp = GetReturnValueObjectImpl(thread, ast_type);
95   if (!return_valobj_sp)
96     return return_valobj_sp;
97 
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
102   // work.
103 
104   if (persistent) {
105     Target &target = *thread.CalculateTarget();
106     PersistentExpressionState *persistent_expression_state =
107         target.GetPersistentExpressionStateForLanguage(
108             ast_type.GetMinimumLanguage());
109 
110     if (!persistent_expression_state)
111       return ValueObjectSP();
112 
113     auto prefix = persistent_expression_state->GetPersistentVariablePrefix();
114     ConstString persistent_variable_name =
115         persistent_expression_state->GetNextPersistentVariableName(target,
116                                                                    prefix);
117 
118     lldb::ValueObjectSP const_valobj_sp;
119 
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);
124     } else
125       const_valobj_sp =
126           return_valobj_sp->CreateConstantValue(persistent_variable_name);
127 
128     lldb::ValueObjectSP live_valobj_sp = return_valobj_sp;
129 
130     return_valobj_sp = const_valobj_sp;
131 
132     ExpressionVariableSP clang_expr_variable_sp(
133         persistent_expression_state->CreatePersistentVariable(
134             return_valobj_sp));
135 
136     assert(clang_expr_variable_sp);
137 
138     // Set flags and live data as appropriate
139 
140     const Value &result_value = live_valobj_sp->GetValue();
141 
142     switch (result_value.GetValueType()) {
143     case Value::eValueTypeHostAddress:
144     case Value::eValueTypeFileAddress:
145       // we don't do anything with these for now
146       break;
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;
155       break;
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;
160       break;
161     }
162 
163     return_valobj_sp = clang_expr_variable_sp->GetValueObject();
164   }
165   return return_valobj_sp;
166 }
167 
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;
173 }
174 
175 // specialized to work with llvm IR types
176 //
177 // for now we will specify a default implementation so that we don't need to
178 // modify other ABIs
179 lldb::ValueObjectSP ABI::GetReturnValueObjectImpl(Thread &thread,
180                                                   llvm::Type &ir_type) const {
181   ValueObjectSP return_valobj_sp;
182 
183   /* this is a dummy and will only be called if an ABI does not override this */
184 
185   return return_valobj_sp;
186 }
187 
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!");
194 }
195 
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
202   // least.
203   if (reg_info->kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_SP) {
204     unwind_regloc.SetIsCFAPlusOffset(0);
205     return true;
206   }
207 
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();
213     return true;
214   }
215 
216   return false;
217 }
218