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