uint32_t Flags = I->getFlags();
bool IsCommon = Flags & SymbolRef::SF_Common;
+ bool IsWeak = Flags & SymbolRef::SF_Weak;
if (IsCommon)
CommonSymbols.push_back(*I);
else {
continue;
StringRef SectionData;
Check(SI->getContents(SectionData));
+ // TODO: It make make sense to delay emitting the section for weak
+ // symbols until they are actually required, but that's not possible
+ // currently, because we only know whether we will need the symbol
+ // in resolveRelocations, which happens after we have already finalized
+ // the Load.
bool IsCode = SI->isText();
unsigned SectionID =
findOrEmitSection(Obj, *SI, IsCode, LocalSections);
SymbolInfo::Visibility Vis =
(Flags & SymbolRef::SF_Exported) ?
SymbolInfo::Default : SymbolInfo::Hidden;
- GlobalSymbolTable[Name] = SymbolInfo(SectionID, SectOffset, Vis);
+ if (!IsWeak) {
+ GlobalSymbolTable[Name] = SymbolInfo(SectionID, SectOffset, Vis);
+ } else {
+ WeakSymbolTable[Name] = SymbolInfo(SectionID, SectOffset, Vis);
+ }
}
}
}
SymInfo.getOffset();
}
+ // If we didn't find the symbol yet, and it is present in the weak symbol
+ // table, the definition from this object file needs to be used, so emit
+ // it now
+ if (!Addr) {
+ RTDyldSymbolTable::const_iterator Loc = WeakSymbolTable.find(Name);
+ if (Loc != WeakSymbolTable.end()) {
+ SymbolInfo SymInfo = Loc->second;
+ Addr = getSectionLoadAddress(SymInfo.getSectionID()) + SymInfo.getOffset();
+ // Since the weak symbol is now, materialized, add it to the
+ // GlobalSymbolTable. If somebody later asks the ExecutionEngine
+ // for the address of this symbol that's where it'll look
+ GlobalSymbolTable[Name] = SymInfo;
+ }
+ }
+
// FIXME: Implement error handling that doesn't kill the host program!
if (!Addr)
report_fatal_error("Program used external function '" + Name +
ExternalSymbolRelocations.erase(i);
}
+ WeakSymbolTable.clear();
}
//===----------------------------------------------------------------------===//
break;
}
case SymbolRef::ST_Data:
+ case SymbolRef::ST_Function:
case SymbolRef::ST_Unknown: {
Value.SymbolName = TargetName.data();
Value.Addend = Addend;
// A global symbol table for symbols from all loaded modules.
RTDyldSymbolTable GlobalSymbolTable;
+ // Like the global symbol table but for weak symbols
+ RTDyldSymbolTable WeakSymbolTable;
+
// Keep a map of common symbols to their info pairs
typedef std::vector<SymbolRef> CommonSymbolList;
set(LLVM_LINK_COMPONENTS
Analysis
+ AsmParser
Core
ExecutionEngine
IPO
//===----------------------------------------------------------------------===//
#include "llvm/ExecutionEngine/MCJIT.h"
+#include "llvm/Support/DynamicLibrary.h"
#include "MCJITTestBase.h"
#include "gtest/gtest.h"
EXPECT_EQ(A, B) << "Repeat calls to getPointerToFunction fail.";
}
+// Test weak symbol linking when the weak symbol is present in a shared
+// library
+TEST_F(MCJITTest, weak_symbol_present) {
+ SKIP_UNSUPPORTED_PLATFORM;
+
+ int FakeWeakSymbol;
+ llvm::sys::DynamicLibrary::AddSymbol("FakeWeakSymbol", &FakeWeakSymbol);
+ createJITFromAssembly(
+ "$FakeWeakSymbol = comdat any\n"
+ "@FakeWeakSymbol = linkonce_odr global i32 42, comdat, align 4\n"
+ "define i32 @weak_test(i32* %arg) {\n"
+ " %r = icmp eq i32* %arg, @FakeWeakSymbol\n"
+ " %ret = zext i1 %r to i32\n"
+ " ret i32 %ret\n"
+ " }");
+
+ uint64_t Addr = TheJIT->getFunctionAddress("weak_test");;
+ EXPECT_TRUE(Addr != 0);
+ int32_t(*FuncPtr)(int32_t *) = (int32_t(*)(int32_t *))Addr;
+ EXPECT_EQ(FuncPtr(&FakeWeakSymbol),1);
+ EXPECT_TRUE(TheJIT->getGlobalValueAddress("FakeWeakSymbol") == 0);
+}
+
+// Test weak symbol linking when the weak symbol is not present in a
+// shared library
+TEST_F(MCJITTest, weak_symbol_absent) {
+ SKIP_UNSUPPORTED_PLATFORM;
+
+ SMDiagnostic Error;
+ createJITFromAssembly(
+ " $FakeWeakSymbol2 = comdat any\n"
+ " @FakeWeakSymbol2 = linkonce_odr global i32 42, comdat, align 4\n"
+ " define i32* @get_weak() {\n"
+ " ret i32* @FakeWeakSymbol2\n"
+ " }\n");
+ void*(*FuncPtr)() =
+ (void*(*)(void))TheJIT->getFunctionAddress("get_weak");
+ EXPECT_EQ(FuncPtr(),(void*)TheJIT->getGlobalValueAddress("FakeWeakSymbol2"));
+}
+
+
}
#define LLVM_UNITTESTS_EXECUTIONENGINE_MCJIT_MCJITTESTBASE_H
#include "MCJITTestAPICommon.h"
+#include "llvm/AsmParser/Parser.h"
#include "llvm/Config/config.h"
#include "llvm/ExecutionEngine/ExecutionEngine.h"
#include "llvm/ExecutionEngine/SectionMemoryManager.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/TypeBuilder.h"
#include "llvm/Support/CodeGen.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/raw_ostream.h"
namespace llvm {
assert(TheJIT.get() != NULL && "error creating MCJIT with EngineBuilder");
}
+ void createJITFromAssembly(const char *Test) {
+ SMDiagnostic Error;
+ M = parseAssemblyString(Test, Error, Context);
+
+ std::string errMsg;
+ raw_string_ostream os(errMsg);
+ Error.print("", os);
+
+ // A failure here means that the test itself is buggy.
+ if (!M)
+ report_fatal_error(os.str().c_str());
+
+ createJIT(std::move(M));
+ }
+
CodeGenOpt::Level OptLevel;
Reloc::Model RelocModel;
CodeModel::Model CodeModel;
LEVEL = ../../..
TESTNAME = MCJIT
-LINK_COMPONENTS := core ipo mcjit native support
+LINK_COMPONENTS := core asmparser ipo mcjit native support
include $(LEVEL)/Makefile.config
include $(LLVM_SRC_ROOT)/unittests/Makefile.unittest