blob: 210fbf6e43e350428f1806c08f6eacf37a2b1e13 [file] [log] [blame]
//===----------- JITSymbol.cpp - JITSymbol class implementation -----------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// JITSymbol class implementation plus helper functions.
//
//===----------------------------------------------------------------------===//
#include "llvm/ExecutionEngine/JITSymbol.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/GlobalAlias.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/ModuleSummaryIndex.h"
#include "llvm/Object/ObjectFile.h"
using namespace llvm;
JITSymbolFlags llvm::JITSymbolFlags::fromGlobalValue(const GlobalValue &GV) {
assert(GV.hasName() && "Can't get flags for anonymous symbol");
JITSymbolFlags Flags = JITSymbolFlags::None;
if (GV.hasWeakLinkage() || GV.hasLinkOnceLinkage())
Flags |= JITSymbolFlags::Weak;
if (GV.hasCommonLinkage())
Flags |= JITSymbolFlags::Common;
if (!GV.hasLocalLinkage() && !GV.hasHiddenVisibility())
Flags |= JITSymbolFlags::Exported;
if (isa<Function>(GV))
Flags |= JITSymbolFlags::Callable;
else if (isa<GlobalAlias>(GV) &&
isa<Function>(cast<GlobalAlias>(GV).getAliasee()))
Flags |= JITSymbolFlags::Callable;
// Check for a linker-private-global-prefix on the symbol name, in which
// case it must be marked as non-exported.
if (auto *M = GV.getParent()) {
const auto &DL = M->getDataLayout();
StringRef LPGP = DL.getLinkerPrivateGlobalPrefix();
if (!LPGP.empty() && GV.getName().front() == '\01' &&
GV.getName().substr(1).startswith(LPGP))
Flags &= ~JITSymbolFlags::Exported;
}
return Flags;
}
JITSymbolFlags llvm::JITSymbolFlags::fromSummary(GlobalValueSummary *S) {
JITSymbolFlags Flags = JITSymbolFlags::None;
auto L = S->linkage();
if (GlobalValue::isWeakLinkage(L) || GlobalValue::isLinkOnceLinkage(L))
Flags |= JITSymbolFlags::Weak;
if (GlobalValue::isCommonLinkage(L))
Flags |= JITSymbolFlags::Common;
if (GlobalValue::isExternalLinkage(L) || GlobalValue::isExternalWeakLinkage(L))
Flags |= JITSymbolFlags::Exported;
if (isa<FunctionSummary>(S))
Flags |= JITSymbolFlags::Callable;
return Flags;
}
Expected<JITSymbolFlags>
llvm::JITSymbolFlags::fromObjectSymbol(const object::SymbolRef &Symbol) {
Expected<uint32_t> SymbolFlagsOrErr = Symbol.getFlags();
if (!SymbolFlagsOrErr)
// TODO: Test this error.
return SymbolFlagsOrErr.takeError();
JITSymbolFlags Flags = JITSymbolFlags::None;
if (*SymbolFlagsOrErr & object::BasicSymbolRef::SF_Weak)
Flags |= JITSymbolFlags::Weak;
if (*SymbolFlagsOrErr & object::BasicSymbolRef::SF_Common)
Flags |= JITSymbolFlags::Common;
if (*SymbolFlagsOrErr & object::BasicSymbolRef::SF_Exported)
Flags |= JITSymbolFlags::Exported;
auto SymbolType = Symbol.getType();
if (!SymbolType)
return SymbolType.takeError();
if (*SymbolType == object::SymbolRef::ST_Function)
Flags |= JITSymbolFlags::Callable;
return Flags;
}
ARMJITSymbolFlags
llvm::ARMJITSymbolFlags::fromObjectSymbol(const object::SymbolRef &Symbol) {
Expected<uint32_t> SymbolFlagsOrErr = Symbol.getFlags();
if (!SymbolFlagsOrErr)
// TODO: Actually report errors helpfully.
report_fatal_error(SymbolFlagsOrErr.takeError());
ARMJITSymbolFlags Flags;
if (*SymbolFlagsOrErr & object::BasicSymbolRef::SF_Thumb)
Flags |= ARMJITSymbolFlags::Thumb;
return Flags;
}
/// Performs lookup by, for each symbol, first calling
/// findSymbolInLogicalDylib and if that fails calling
/// findSymbol.
void LegacyJITSymbolResolver::lookup(const LookupSet &Symbols,
OnResolvedFunction OnResolved) {
JITSymbolResolver::LookupResult Result;
for (auto &Symbol : Symbols) {
std::string SymName = Symbol.str();
if (auto Sym = findSymbolInLogicalDylib(SymName)) {
if (auto AddrOrErr = Sym.getAddress())
Result[Symbol] = JITEvaluatedSymbol(*AddrOrErr, Sym.getFlags());
else {
OnResolved(AddrOrErr.takeError());
return;
}
} else if (auto Err = Sym.takeError()) {
OnResolved(std::move(Err));
return;
} else {
// findSymbolInLogicalDylib failed. Lets try findSymbol.
if (auto Sym = findSymbol(SymName)) {
if (auto AddrOrErr = Sym.getAddress())
Result[Symbol] = JITEvaluatedSymbol(*AddrOrErr, Sym.getFlags());
else {
OnResolved(AddrOrErr.takeError());
return;
}
} else if (auto Err = Sym.takeError()) {
OnResolved(std::move(Err));
return;
} else {
OnResolved(make_error<StringError>("Symbol not found: " + Symbol,
inconvertibleErrorCode()));
return;
}
}
}
OnResolved(std::move(Result));
}
/// Performs flags lookup by calling findSymbolInLogicalDylib and
/// returning the flags value for that symbol.
Expected<JITSymbolResolver::LookupSet>
LegacyJITSymbolResolver::getResponsibilitySet(const LookupSet &Symbols) {
JITSymbolResolver::LookupSet Result;
for (auto &Symbol : Symbols) {
std::string SymName = Symbol.str();
if (auto Sym = findSymbolInLogicalDylib(SymName)) {
// If there's an existing def but it is not strong, then the caller is
// responsible for it.
if (!Sym.getFlags().isStrong())
Result.insert(Symbol);
} else if (auto Err = Sym.takeError())
return std::move(Err);
else {
// If there is no existing definition then the caller is responsible for
// it.
Result.insert(Symbol);
}
}
return std::move(Result);
}