contrib/llvm/tools/lldb/source/Target/ABI.cpp

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