Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 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" |
Jim Ingham | 1586d97 | 2011-12-17 01:35:57 +0000 | [diff] [blame] | 12 | #include "lldb/Core/Value.h" |
| 13 | #include "lldb/Core/ValueObjectConstResult.h" |
| 14 | #include "lldb/Symbol/ClangASTType.h" |
Jim Ingham | 016ef88 | 2011-12-22 19:12:40 +0000 | [diff] [blame] | 15 | #include "lldb/Target/Target.h" |
Jim Ingham | 1586d97 | 2011-12-17 01:35:57 +0000 | [diff] [blame] | 16 | #include "lldb/Target/Thread.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 17 | |
| 18 | using namespace lldb; |
| 19 | using namespace lldb_private; |
| 20 | |
Greg Clayton | 75906e4 | 2011-05-11 18:39:18 +0000 | [diff] [blame] | 21 | ABISP |
Greg Clayton | 395fc33 | 2011-02-15 21:59:32 +0000 | [diff] [blame] | 22 | ABI::FindPlugin (const ArchSpec &arch) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 23 | { |
Greg Clayton | 75906e4 | 2011-05-11 18:39:18 +0000 | [diff] [blame] | 24 | ABISP abi_sp; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 25 | ABICreateInstance create_callback; |
| 26 | |
| 27 | for (uint32_t idx = 0; |
| 28 | (create_callback = PluginManager::GetABICreateCallbackAtIndex(idx)) != NULL; |
| 29 | ++idx) |
| 30 | { |
Greg Clayton | 75906e4 | 2011-05-11 18:39:18 +0000 | [diff] [blame] | 31 | abi_sp = create_callback(arch); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 32 | |
Greg Clayton | 75906e4 | 2011-05-11 18:39:18 +0000 | [diff] [blame] | 33 | if (abi_sp) |
| 34 | return abi_sp; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 35 | } |
Greg Clayton | 75906e4 | 2011-05-11 18:39:18 +0000 | [diff] [blame] | 36 | abi_sp.reset(); |
| 37 | return abi_sp; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 38 | } |
| 39 | |
| 40 | //---------------------------------------------------------------------- |
| 41 | // Constructor |
| 42 | //---------------------------------------------------------------------- |
| 43 | ABI::ABI() |
| 44 | { |
| 45 | } |
| 46 | |
| 47 | //---------------------------------------------------------------------- |
| 48 | // Destructor |
| 49 | //---------------------------------------------------------------------- |
| 50 | ABI::~ABI() |
| 51 | { |
| 52 | } |
Greg Clayton | 37f962e | 2011-08-22 02:49:39 +0000 | [diff] [blame] | 53 | |
| 54 | |
| 55 | bool |
| 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 |
| 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 | } |
Jim Ingham | 1586d97 | 2011-12-17 01:35:57 +0000 | [diff] [blame] | 105 | |
| 106 | ValueObjectSP |
| 107 | ABI::GetReturnValueObject (Thread &thread, |
Greg Clayton | f4124de | 2012-02-21 00:09:25 +0000 | [diff] [blame] | 108 | ClangASTType &ast_type, |
| 109 | bool persistent) const |
Jim Ingham | 1586d97 | 2011-12-17 01:35:57 +0000 | [diff] [blame] | 110 | { |
| 111 | if (!ast_type.IsValid()) |
| 112 | return ValueObjectSP(); |
| 113 | |
Jim Ingham | 016ef88 | 2011-12-22 19:12:40 +0000 | [diff] [blame] | 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) |
Jim Ingham | 1586d97 | 2011-12-17 01:35:57 +0000 | [diff] [blame] | 125 | { |
Greg Clayton | f4124de | 2012-02-21 00:09:25 +0000 | [diff] [blame] | 126 | ClangPersistentVariables& persistent_variables = thread.CalculateTarget()->GetPersistentVariables(); |
Jim Ingham | 016ef88 | 2011-12-22 19:12:40 +0000 | [diff] [blame] | 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: |
Greg Clayton | f0fab4f | 2012-10-30 23:56:14 +0000 | [diff] [blame^] | 159 | case Value::eValueTypeVector: |
Sean Callanan | 9ac3d8b | 2012-01-05 01:11:09 +0000 | [diff] [blame] | 160 | clang_expr_variable_sp->m_flags |= ClangExpressionVariable::EVIsFreezeDried; |
Jim Ingham | 016ef88 | 2011-12-22 19:12:40 +0000 | [diff] [blame] | 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 | } |
Sean Callanan | 9ac3d8b | 2012-01-05 01:11:09 +0000 | [diff] [blame] | 169 | |
Jim Ingham | 016ef88 | 2011-12-22 19:12:40 +0000 | [diff] [blame] | 170 | return_valobj_sp = clang_expr_variable_sp->GetValueObject(); |
Jim Ingham | 1586d97 | 2011-12-17 01:35:57 +0000 | [diff] [blame] | 171 | } |
Jim Ingham | 016ef88 | 2011-12-22 19:12:40 +0000 | [diff] [blame] | 172 | return return_valobj_sp; |
Jim Ingham | 1586d97 | 2011-12-17 01:35:57 +0000 | [diff] [blame] | 173 | } |
| 174 | |
| 175 | |