[ORC] Add a 'Callable' flag to JITSymbolFlags.
The callable flag can be used to indicate that a symbol is callable. If present,
the symbol is callable. If absent, the symbol may or may not be callable (the
client must determine this by context, for example by examining the program
representation that will provide the symbol definition).
This flag will be used in the near future to enable creation of lazy compilation
stubs based on SymbolFlagsMap instances only (without having to provide
additional information to determine which symbols need stubs).
llvm-svn: 338649
diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp b/llvm/lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp
index 18eb0e4..88b0cd0 100644
--- a/llvm/lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp
+++ b/llvm/lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp
@@ -12,8 +12,9 @@
//===----------------------------------------------------------------------===//
#include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/IR/Function.h"
#include "llvm/IR/GlobalValue.h"
-#include "llvm/Object/SymbolicFile.h"
+#include "llvm/Object/ObjectFile.h"
using namespace llvm;
@@ -25,11 +26,13 @@
Flags |= JITSymbolFlags::Common;
if (!GV.hasLocalLinkage() && !GV.hasHiddenVisibility())
Flags |= JITSymbolFlags::Exported;
+ if (isa<Function>(GV))
+ Flags |= JITSymbolFlags::Callable;
return Flags;
}
-JITSymbolFlags
-llvm::JITSymbolFlags::fromObjectSymbol(const object::BasicSymbolRef &Symbol) {
+Expected<JITSymbolFlags>
+llvm::JITSymbolFlags::fromObjectSymbol(const object::SymbolRef &Symbol) {
JITSymbolFlags Flags = JITSymbolFlags::None;
if (Symbol.getFlags() & object::BasicSymbolRef::SF_Weak)
Flags |= JITSymbolFlags::Weak;
@@ -37,11 +40,19 @@
Flags |= JITSymbolFlags::Common;
if (Symbol.getFlags() & 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::BasicSymbolRef &Symbol) {
+ARMJITSymbolFlags
+llvm::ARMJITSymbolFlags::fromObjectSymbol(const object::SymbolRef &Symbol) {
ARMJITSymbolFlags Flags;
if (Symbol.getFlags() & object::BasicSymbolRef::SF_Thumb)
Flags |= ARMJITSymbolFlags::Thumb;
diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
index 1189be5..af5427e 100644
--- a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
+++ b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
@@ -249,13 +249,15 @@
return NameOrErr.takeError();
// Compute JIT symbol flags.
- JITSymbolFlags JITSymFlags = getJITSymbolFlags(*I);
+ auto JITSymFlags = getJITSymbolFlags(*I);
+ if (!JITSymFlags)
+ return JITSymFlags.takeError();
// If this is a weak definition, check to see if there's a strong one.
// If there is, skip this symbol (we won't be providing it: the strong
// definition will). If there's no strong definition, make this definition
// strong.
- if (JITSymFlags.isWeak() || JITSymFlags.isCommon()) {
+ if (JITSymFlags->isWeak() || JITSymFlags->isCommon()) {
// First check whether there's already a definition in this instance.
// FIXME: Override existing weak definitions with strong ones.
if (GlobalSymbolTable.count(Name))
@@ -265,12 +267,12 @@
// flags lookup earlier.
auto FlagsI = SymbolFlags.find(Name);
if (FlagsI == SymbolFlags.end() ||
- (JITSymFlags.isWeak() && !FlagsI->second.isStrong()) ||
- (JITSymFlags.isCommon() && FlagsI->second.isCommon())) {
- if (JITSymFlags.isWeak())
- JITSymFlags &= ~JITSymbolFlags::Weak;
- if (JITSymFlags.isCommon()) {
- JITSymFlags &= ~JITSymbolFlags::Common;
+ (JITSymFlags->isWeak() && !FlagsI->second.isStrong()) ||
+ (JITSymFlags->isCommon() && FlagsI->second.isCommon())) {
+ if (JITSymFlags->isWeak())
+ *JITSymFlags &= ~JITSymbolFlags::Weak;
+ if (JITSymFlags->isCommon()) {
+ *JITSymFlags &= ~JITSymbolFlags::Common;
uint32_t Align = I->getAlignment();
uint64_t Size = I->getCommonSize();
if (!CommonAlign)
@@ -296,7 +298,7 @@
<< " SID: " << SectionID
<< " Offset: " << format("%p", (uintptr_t)Addr)
<< " flags: " << Flags << "\n");
- GlobalSymbolTable[Name] = SymbolTableEntry(SectionID, Addr, JITSymFlags);
+ GlobalSymbolTable[Name] = SymbolTableEntry(SectionID, Addr, *JITSymFlags);
} else if (SymType == object::SymbolRef::ST_Function ||
SymType == object::SymbolRef::ST_Data ||
SymType == object::SymbolRef::ST_Unknown ||
@@ -329,7 +331,7 @@
<< " Offset: " << format("%p", (uintptr_t)SectOffset)
<< " flags: " << Flags << "\n");
GlobalSymbolTable[Name] =
- SymbolTableEntry(SectionID, SectOffset, JITSymFlags);
+ SymbolTableEntry(SectionID, SectOffset, *JITSymFlags);
}
}
@@ -642,7 +644,8 @@
}
}
-JITSymbolFlags RuntimeDyldImpl::getJITSymbolFlags(const BasicSymbolRef &SR) {
+Expected<JITSymbolFlags>
+RuntimeDyldImpl::getJITSymbolFlags(const SymbolRef &SR) {
return JITSymbolFlags::fromObjectSymbol(SR);
}
@@ -683,11 +686,15 @@
Addr += AlignOffset;
Offset += AlignOffset;
}
- JITSymbolFlags JITSymFlags = getJITSymbolFlags(Sym);
+ auto JITSymFlags = getJITSymbolFlags(Sym);
+
+ if (!JITSymFlags)
+ return JITSymFlags.takeError();
+
LLVM_DEBUG(dbgs() << "Allocating common symbol " << Name << " address "
<< format("%p", Addr) << "\n");
GlobalSymbolTable[Name] =
- SymbolTableEntry(SectionID, Offset, JITSymFlags);
+ SymbolTableEntry(SectionID, Offset, std::move(*JITSymFlags));
Offset += Size;
Addr += Size;
}
diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
index 4d7cc36..9b33952 100644
--- a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
+++ b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
@@ -370,7 +370,7 @@
void writeBytesUnaligned(uint64_t Value, uint8_t *Dst, unsigned Size) const;
/// Generate JITSymbolFlags from a libObject symbol.
- virtual JITSymbolFlags getJITSymbolFlags(const BasicSymbolRef &Sym);
+ virtual Expected<JITSymbolFlags> getJITSymbolFlags(const SymbolRef &Sym);
/// Modify the given target address based on the given symbol flags.
/// This can be used by subclasses to tweak addresses based on symbol flags,
diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOARM.h b/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOARM.h
index 64a6b29..ab7cd2b 100644
--- a/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOARM.h
+++ b/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOARM.h
@@ -34,9 +34,11 @@
unsigned getStubAlignment() override { return 4; }
- JITSymbolFlags getJITSymbolFlags(const BasicSymbolRef &SR) override {
+ Expected<JITSymbolFlags> getJITSymbolFlags(const SymbolRef &SR) override {
auto Flags = RuntimeDyldImpl::getJITSymbolFlags(SR);
- Flags.getTargetFlags() = ARMJITSymbolFlags::fromObjectSymbol(SR);
+ if (!Flags)
+ return Flags.takeError();
+ Flags->getTargetFlags() = ARMJITSymbolFlags::fromObjectSymbol(SR);
return Flags;
}