forked from OSchip/llvm-project
281 lines
9.1 KiB
C++
281 lines
9.1 KiB
C++
//===-- ABI.cpp -----------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Target/ABI.h"
|
|
#include "lldb/Core/PluginManager.h"
|
|
#include "lldb/Core/Value.h"
|
|
#include "lldb/Core/ValueObjectConstResult.h"
|
|
#include "lldb/Expression/ExpressionVariable.h"
|
|
#include "lldb/Symbol/CompilerType.h"
|
|
#include "lldb/Symbol/TypeSystem.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Target/Thread.h"
|
|
#include "lldb/Utility/LLDBLog.h"
|
|
#include "lldb/Utility/Log.h"
|
|
#include "llvm/MC/TargetRegistry.h"
|
|
#include <cctype>
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
ABISP
|
|
ABI::FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch) {
|
|
ABISP abi_sp;
|
|
ABICreateInstance create_callback;
|
|
|
|
for (uint32_t idx = 0;
|
|
(create_callback = PluginManager::GetABICreateCallbackAtIndex(idx)) !=
|
|
nullptr;
|
|
++idx) {
|
|
abi_sp = create_callback(process_sp, arch);
|
|
|
|
if (abi_sp)
|
|
return abi_sp;
|
|
}
|
|
abi_sp.reset();
|
|
return abi_sp;
|
|
}
|
|
|
|
ABI::~ABI() = default;
|
|
|
|
bool RegInfoBasedABI::GetRegisterInfoByName(llvm::StringRef name,
|
|
RegisterInfo &info) {
|
|
uint32_t count = 0;
|
|
const RegisterInfo *register_info_array = GetRegisterInfoArray(count);
|
|
if (register_info_array) {
|
|
uint32_t i;
|
|
for (i = 0; i < count; ++i) {
|
|
const char *reg_name = register_info_array[i].name;
|
|
if (reg_name == name) {
|
|
info = register_info_array[i];
|
|
return true;
|
|
}
|
|
}
|
|
for (i = 0; i < count; ++i) {
|
|
const char *reg_alt_name = register_info_array[i].alt_name;
|
|
if (reg_alt_name == name) {
|
|
info = register_info_array[i];
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
ValueObjectSP ABI::GetReturnValueObject(Thread &thread, CompilerType &ast_type,
|
|
bool persistent) const {
|
|
if (!ast_type.IsValid())
|
|
return ValueObjectSP();
|
|
|
|
ValueObjectSP return_valobj_sp;
|
|
|
|
return_valobj_sp = GetReturnValueObjectImpl(thread, ast_type);
|
|
if (!return_valobj_sp)
|
|
return return_valobj_sp;
|
|
|
|
// Now turn this into a persistent variable.
|
|
// FIXME: This code is duplicated from Target::EvaluateExpression, and it is
|
|
// used in similar form in a couple
|
|
// of other places. Figure out the correct Create function to do all this
|
|
// work.
|
|
|
|
if (persistent) {
|
|
Target &target = *thread.CalculateTarget();
|
|
PersistentExpressionState *persistent_expression_state =
|
|
target.GetPersistentExpressionStateForLanguage(
|
|
ast_type.GetMinimumLanguage());
|
|
|
|
if (!persistent_expression_state)
|
|
return {};
|
|
|
|
ConstString persistent_variable_name =
|
|
persistent_expression_state->GetNextPersistentVariableName();
|
|
|
|
lldb::ValueObjectSP const_valobj_sp;
|
|
|
|
// Check in case our value is already a constant value
|
|
if (return_valobj_sp->GetIsConstant()) {
|
|
const_valobj_sp = return_valobj_sp;
|
|
const_valobj_sp->SetName(persistent_variable_name);
|
|
} else
|
|
const_valobj_sp =
|
|
return_valobj_sp->CreateConstantValue(persistent_variable_name);
|
|
|
|
lldb::ValueObjectSP live_valobj_sp = return_valobj_sp;
|
|
|
|
return_valobj_sp = const_valobj_sp;
|
|
|
|
ExpressionVariableSP expr_variable_sp(
|
|
persistent_expression_state->CreatePersistentVariable(
|
|
return_valobj_sp));
|
|
|
|
assert(expr_variable_sp);
|
|
|
|
// Set flags and live data as appropriate
|
|
|
|
const Value &result_value = live_valobj_sp->GetValue();
|
|
|
|
switch (result_value.GetValueType()) {
|
|
case Value::ValueType::Invalid:
|
|
return {};
|
|
case Value::ValueType::HostAddress:
|
|
case Value::ValueType::FileAddress:
|
|
// we odon't do anything with these for now
|
|
break;
|
|
case Value::ValueType::Scalar:
|
|
expr_variable_sp->m_flags |=
|
|
ExpressionVariable::EVIsFreezeDried;
|
|
expr_variable_sp->m_flags |=
|
|
ExpressionVariable::EVIsLLDBAllocated;
|
|
expr_variable_sp->m_flags |=
|
|
ExpressionVariable::EVNeedsAllocation;
|
|
break;
|
|
case Value::ValueType::LoadAddress:
|
|
expr_variable_sp->m_live_sp = live_valobj_sp;
|
|
expr_variable_sp->m_flags |=
|
|
ExpressionVariable::EVIsProgramReference;
|
|
break;
|
|
}
|
|
|
|
return_valobj_sp = expr_variable_sp->GetValueObject();
|
|
}
|
|
return return_valobj_sp;
|
|
}
|
|
|
|
ValueObjectSP ABI::GetReturnValueObject(Thread &thread, llvm::Type &ast_type,
|
|
bool persistent) const {
|
|
ValueObjectSP return_valobj_sp;
|
|
return_valobj_sp = GetReturnValueObjectImpl(thread, ast_type);
|
|
return return_valobj_sp;
|
|
}
|
|
|
|
// specialized to work with llvm IR types
|
|
//
|
|
// for now we will specify a default implementation so that we don't need to
|
|
// modify other ABIs
|
|
lldb::ValueObjectSP ABI::GetReturnValueObjectImpl(Thread &thread,
|
|
llvm::Type &ir_type) const {
|
|
ValueObjectSP return_valobj_sp;
|
|
|
|
/* this is a dummy and will only be called if an ABI does not override this */
|
|
|
|
return return_valobj_sp;
|
|
}
|
|
|
|
bool ABI::PrepareTrivialCall(Thread &thread, lldb::addr_t sp,
|
|
lldb::addr_t functionAddress,
|
|
lldb::addr_t returnAddress, llvm::Type &returntype,
|
|
llvm::ArrayRef<ABI::CallArgument> args) const {
|
|
// dummy prepare trivial call
|
|
llvm_unreachable("Should never get here!");
|
|
}
|
|
|
|
bool ABI::GetFallbackRegisterLocation(
|
|
const RegisterInfo *reg_info,
|
|
UnwindPlan::Row::RegisterLocation &unwind_regloc) {
|
|
// Did the UnwindPlan fail to give us the caller's stack pointer? The stack
|
|
// pointer is defined to be the same as THIS frame's CFA, so return the CFA
|
|
// value as the caller's stack pointer. This is true on x86-32/x86-64 at
|
|
// least.
|
|
if (reg_info->kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_SP) {
|
|
unwind_regloc.SetIsCFAPlusOffset(0);
|
|
return true;
|
|
}
|
|
|
|
// If a volatile register is being requested, we don't want to forward the
|
|
// next frame's register contents up the stack -- the register is not
|
|
// retrievable at this frame.
|
|
if (RegisterIsVolatile(reg_info)) {
|
|
unwind_regloc.SetUndefined();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
std::unique_ptr<llvm::MCRegisterInfo> ABI::MakeMCRegisterInfo(const ArchSpec &arch) {
|
|
std::string triple = arch.GetTriple().getTriple();
|
|
std::string lookup_error;
|
|
const llvm::Target *target =
|
|
llvm::TargetRegistry::lookupTarget(triple, lookup_error);
|
|
if (!target) {
|
|
LLDB_LOG(GetLog(LLDBLog::Process),
|
|
"Failed to create an llvm target for {0}: {1}", triple,
|
|
lookup_error);
|
|
return nullptr;
|
|
}
|
|
std::unique_ptr<llvm::MCRegisterInfo> info_up(
|
|
target->createMCRegInfo(triple));
|
|
assert(info_up);
|
|
return info_up;
|
|
}
|
|
|
|
void RegInfoBasedABI::AugmentRegisterInfo(
|
|
std::vector<DynamicRegisterInfo::Register> ®s) {
|
|
for (DynamicRegisterInfo::Register &info : regs) {
|
|
if (info.regnum_ehframe != LLDB_INVALID_REGNUM &&
|
|
info.regnum_dwarf != LLDB_INVALID_REGNUM)
|
|
continue;
|
|
|
|
RegisterInfo abi_info;
|
|
if (!GetRegisterInfoByName(info.name.GetStringRef(), abi_info))
|
|
continue;
|
|
|
|
if (info.regnum_ehframe == LLDB_INVALID_REGNUM)
|
|
info.regnum_ehframe = abi_info.kinds[eRegisterKindEHFrame];
|
|
if (info.regnum_dwarf == LLDB_INVALID_REGNUM)
|
|
info.regnum_dwarf = abi_info.kinds[eRegisterKindDWARF];
|
|
if (info.regnum_generic == LLDB_INVALID_REGNUM)
|
|
info.regnum_generic = abi_info.kinds[eRegisterKindGeneric];
|
|
}
|
|
}
|
|
|
|
void MCBasedABI::AugmentRegisterInfo(
|
|
std::vector<DynamicRegisterInfo::Register> ®s) {
|
|
for (DynamicRegisterInfo::Register &info : regs) {
|
|
uint32_t eh, dwarf;
|
|
std::tie(eh, dwarf) = GetEHAndDWARFNums(info.name.GetStringRef());
|
|
|
|
if (info.regnum_ehframe == LLDB_INVALID_REGNUM)
|
|
info.regnum_ehframe = eh;
|
|
if (info.regnum_dwarf == LLDB_INVALID_REGNUM)
|
|
info.regnum_dwarf = dwarf;
|
|
if (info.regnum_generic == LLDB_INVALID_REGNUM)
|
|
info.regnum_generic = GetGenericNum(info.name.GetStringRef());
|
|
}
|
|
}
|
|
|
|
std::pair<uint32_t, uint32_t>
|
|
MCBasedABI::GetEHAndDWARFNums(llvm::StringRef name) {
|
|
std::string mc_name = GetMCName(name.str());
|
|
for (char &c : mc_name)
|
|
c = std::toupper(c);
|
|
int eh = -1;
|
|
int dwarf = -1;
|
|
for (unsigned reg = 0; reg < m_mc_register_info_up->getNumRegs(); ++reg) {
|
|
if (m_mc_register_info_up->getName(reg) == mc_name) {
|
|
eh = m_mc_register_info_up->getDwarfRegNum(reg, /*isEH=*/true);
|
|
dwarf = m_mc_register_info_up->getDwarfRegNum(reg, /*isEH=*/false);
|
|
break;
|
|
}
|
|
}
|
|
return std::pair<uint32_t, uint32_t>(eh == -1 ? LLDB_INVALID_REGNUM : eh,
|
|
dwarf == -1 ? LLDB_INVALID_REGNUM
|
|
: dwarf);
|
|
}
|
|
|
|
void MCBasedABI::MapRegisterName(std::string &name, llvm::StringRef from_prefix,
|
|
llvm::StringRef to_prefix) {
|
|
llvm::StringRef name_ref = name;
|
|
if (!name_ref.consume_front(from_prefix))
|
|
return;
|
|
uint64_t _;
|
|
if (name_ref.empty() || to_integer(name_ref, _, 10))
|
|
name = (to_prefix + name_ref).str();
|
|
}
|