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     PersistentExpressionState *persistent_expression_state =
106         thread.CalculateTarget()->GetPersistentExpressionStateForLanguage(
107             ast_type.GetMinimumLanguage());
108 
109     if (!persistent_expression_state)
110       return ValueObjectSP();
111 
112     ConstString persistent_variable_name(
113         persistent_expression_state->GetNextPersistentVariableName());
114 
115     lldb::ValueObjectSP const_valobj_sp;
116 
117     // Check in case our value is already a constant value
118     if (return_valobj_sp->GetIsConstant()) {
119       const_valobj_sp = return_valobj_sp;
120       const_valobj_sp->SetName(persistent_variable_name);
121     } else
122       const_valobj_sp =
123           return_valobj_sp->CreateConstantValue(persistent_variable_name);
124 
125     lldb::ValueObjectSP live_valobj_sp = return_valobj_sp;
126 
127     return_valobj_sp = const_valobj_sp;
128 
129     ExpressionVariableSP clang_expr_variable_sp(
130         persistent_expression_state->CreatePersistentVariable(
131             return_valobj_sp));
132 
133     assert(clang_expr_variable_sp);
134 
135     // Set flags and live data as appropriate
136 
137     const Value &result_value = live_valobj_sp->GetValue();
138 
139     switch (result_value.GetValueType()) {
140     case Value::eValueTypeHostAddress:
141     case Value::eValueTypeFileAddress:
142       // we don't do anything with these for now
143       break;
144     case Value::eValueTypeScalar:
145     case Value::eValueTypeVector:
146       clang_expr_variable_sp->m_flags |=
147           ClangExpressionVariable::EVIsFreezeDried;
148       clang_expr_variable_sp->m_flags |=
149           ClangExpressionVariable::EVIsLLDBAllocated;
150       clang_expr_variable_sp->m_flags |=
151           ClangExpressionVariable::EVNeedsAllocation;
152       break;
153     case Value::eValueTypeLoadAddress:
154       clang_expr_variable_sp->m_live_sp = live_valobj_sp;
155       clang_expr_variable_sp->m_flags |=
156           ClangExpressionVariable::EVIsProgramReference;
157       break;
158     }
159 
160     return_valobj_sp = clang_expr_variable_sp->GetValueObject();
161   }
162   return return_valobj_sp;
163 }
164 
165 ValueObjectSP ABI::GetReturnValueObject(Thread &thread, llvm::Type &ast_type,
166                                         bool persistent) const {
167   ValueObjectSP return_valobj_sp;
168   return_valobj_sp = GetReturnValueObjectImpl(thread, ast_type);
169   return return_valobj_sp;
170 }
171 
172 // specialized to work with llvm IR types
173 //
174 // for now we will specify a default implementation so that we don't need to
175 // modify other ABIs
176 lldb::ValueObjectSP ABI::GetReturnValueObjectImpl(Thread &thread,
177                                                   llvm::Type &ir_type) const {
178   ValueObjectSP return_valobj_sp;
179 
180   /* this is a dummy and will only be called if an ABI does not override this */
181 
182   return return_valobj_sp;
183 }
184 
185 bool ABI::PrepareTrivialCall(Thread &thread, lldb::addr_t sp,
186                              lldb::addr_t functionAddress,
187                              lldb::addr_t returnAddress, llvm::Type &returntype,
188                              llvm::ArrayRef<ABI::CallArgument> args) const {
189   // dummy prepare trivial call
190   llvm_unreachable("Should never get here!");
191 }
192 
193 bool ABI::GetFallbackRegisterLocation(
194     const RegisterInfo *reg_info,
195     UnwindPlan::Row::RegisterLocation &unwind_regloc) {
196   // Did the UnwindPlan fail to give us the caller's stack pointer?
197   // The stack pointer is defined to be the same as THIS frame's CFA, so return
198   // the CFA value as
199   // the caller's stack pointer.  This is true on x86-32/x86-64 at least.
200   if (reg_info->kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_SP) {
201     unwind_regloc.SetIsCFAPlusOffset(0);
202     return true;
203   }
204 
205   // If a volatile register is being requested, we don't want to forward the
206   // next frame's register contents
207   // up the stack -- the register is not retrievable at this frame.
208   if (RegisterIsVolatile(reg_info)) {
209     unwind_regloc.SetUndefined();
210     return true;
211   }
212 
213   return false;
214 }
215