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 #include "lldb/Target/ABI.h"
11 #include "lldb/Core/PluginManager.h"
12 #include "lldb/Core/Value.h"
13 #include "lldb/Core/ValueObjectConstResult.h"
14 #include "lldb/Expression/ClangPersistentVariables.h"
15 #include "lldb/Symbol/ClangASTType.h"
16 #include "lldb/Target/Target.h"
17 #include "lldb/Target/Thread.h"
18
19 using namespace lldb;
20 using namespace lldb_private;
21
22 ABISP
FindPlugin(const ArchSpec & arch)23 ABI::FindPlugin (const ArchSpec &arch)
24 {
25 ABISP abi_sp;
26 ABICreateInstance create_callback;
27
28 for (uint32_t idx = 0;
29 (create_callback = PluginManager::GetABICreateCallbackAtIndex(idx)) != NULL;
30 ++idx)
31 {
32 abi_sp = create_callback(arch);
33
34 if (abi_sp)
35 return abi_sp;
36 }
37 abi_sp.reset();
38 return abi_sp;
39 }
40
41 //----------------------------------------------------------------------
42 // Constructor
43 //----------------------------------------------------------------------
ABI()44 ABI::ABI()
45 {
46 }
47
48 //----------------------------------------------------------------------
49 // Destructor
50 //----------------------------------------------------------------------
~ABI()51 ABI::~ABI()
52 {
53 }
54
55 bool
GetRegisterInfoByName(const ConstString & name,RegisterInfo & info)56 ABI::GetRegisterInfoByName (const ConstString &name, RegisterInfo &info)
57 {
58 uint32_t count = 0;
59 const RegisterInfo *register_info_array = GetRegisterInfoArray (count);
60 if (register_info_array)
61 {
62 const char *unique_name_cstr = name.GetCString();
63 uint32_t i;
64 for (i=0; i<count; ++i)
65 {
66 if (register_info_array[i].name == unique_name_cstr)
67 {
68 info = register_info_array[i];
69 return true;
70 }
71 }
72 for (i=0; i<count; ++i)
73 {
74 if (register_info_array[i].alt_name == unique_name_cstr)
75 {
76 info = register_info_array[i];
77 return true;
78 }
79 }
80 }
81 return false;
82 }
83
84 bool
GetRegisterInfoByKind(RegisterKind reg_kind,uint32_t reg_num,RegisterInfo & info)85 ABI::GetRegisterInfoByKind (RegisterKind reg_kind, uint32_t reg_num, RegisterInfo &info)
86 {
87 if (reg_kind < eRegisterKindGCC || reg_kind >= kNumRegisterKinds)
88 return false;
89
90 uint32_t count = 0;
91 const RegisterInfo *register_info_array = GetRegisterInfoArray (count);
92 if (register_info_array)
93 {
94 for (uint32_t i=0; i<count; ++i)
95 {
96 if (register_info_array[i].kinds[reg_kind] == reg_num)
97 {
98 info = register_info_array[i];
99 return true;
100 }
101 }
102 }
103 return false;
104 }
105
106 ValueObjectSP
GetReturnValueObject(Thread & thread,ClangASTType & ast_type,bool persistent) const107 ABI::GetReturnValueObject (Thread &thread,
108 ClangASTType &ast_type,
109 bool persistent) const
110 {
111 if (!ast_type.IsValid())
112 return ValueObjectSP();
113
114 ValueObjectSP return_valobj_sp;
115
116 return_valobj_sp = GetReturnValueObjectImpl(thread, ast_type);
117 if (!return_valobj_sp)
118 return return_valobj_sp;
119
120 // Now turn this into a persistent variable.
121 // FIXME: This code is duplicated from Target::EvaluateExpression, and it is used in similar form in a couple
122 // of other places. Figure out the correct Create function to do all this work.
123
124 if (persistent)
125 {
126 ClangPersistentVariables& persistent_variables = thread.CalculateTarget()->GetPersistentVariables();
127 ConstString persistent_variable_name (persistent_variables.GetNextPersistentVariableName());
128
129 lldb::ValueObjectSP const_valobj_sp;
130
131 // Check in case our value is already a constant value
132 if (return_valobj_sp->GetIsConstant())
133 {
134 const_valobj_sp = return_valobj_sp;
135 const_valobj_sp->SetName (persistent_variable_name);
136 }
137 else
138 const_valobj_sp = return_valobj_sp->CreateConstantValue (persistent_variable_name);
139
140 lldb::ValueObjectSP live_valobj_sp = return_valobj_sp;
141
142 return_valobj_sp = const_valobj_sp;
143
144 ClangExpressionVariableSP clang_expr_variable_sp(persistent_variables.CreatePersistentVariable(return_valobj_sp));
145
146 assert (clang_expr_variable_sp.get());
147
148 // Set flags and live data as appropriate
149
150 const Value &result_value = live_valobj_sp->GetValue();
151
152 switch (result_value.GetValueType())
153 {
154 case Value::eValueTypeHostAddress:
155 case Value::eValueTypeFileAddress:
156 // we don't do anything with these for now
157 break;
158 case Value::eValueTypeScalar:
159 case Value::eValueTypeVector:
160 clang_expr_variable_sp->m_flags |= ClangExpressionVariable::EVIsFreezeDried;
161 clang_expr_variable_sp->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
162 clang_expr_variable_sp->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
163 break;
164 case Value::eValueTypeLoadAddress:
165 clang_expr_variable_sp->m_live_sp = live_valobj_sp;
166 clang_expr_variable_sp->m_flags |= ClangExpressionVariable::EVIsProgramReference;
167 break;
168 }
169
170 return_valobj_sp = clang_expr_variable_sp->GetValueObject();
171 }
172 return return_valobj_sp;
173 }
174
175 ValueObjectSP
GetReturnValueObject(Thread & thread,llvm::Type & ast_type,bool persistent) const176 ABI::GetReturnValueObject(Thread &thread, llvm::Type &ast_type, bool persistent) const
177 {
178 ValueObjectSP return_valobj_sp;
179 return_valobj_sp = GetReturnValueObjectImpl( thread, ast_type );
180 return return_valobj_sp;
181 }
182
183 // specialized to work with llvm IR types
184 //
185 // for now we will specify a default implementation so that we don't need to
186 // modify other ABIs
187 lldb::ValueObjectSP
GetReturnValueObjectImpl(Thread & thread,llvm::Type & ir_type) const188 ABI::GetReturnValueObjectImpl( Thread &thread, llvm::Type &ir_type ) const
189 {
190 ValueObjectSP return_valobj_sp;
191
192 /* this is a dummy and will only be called if an ABI does not override this */
193
194 return return_valobj_sp;
195 }
196
197 bool
PrepareTrivialCall(Thread & thread,lldb::addr_t sp,lldb::addr_t functionAddress,lldb::addr_t returnAddress,llvm::Type & returntype,llvm::ArrayRef<ABI::CallArgument> args) const198 ABI::PrepareTrivialCall (Thread &thread,
199 lldb::addr_t sp,
200 lldb::addr_t functionAddress,
201 lldb::addr_t returnAddress,
202 llvm::Type &returntype,
203 llvm::ArrayRef<ABI::CallArgument> args) const
204 {
205 // dummy prepare trivial call
206 assert( !"Should never get here!" );
207 return false;
208 }
209