[ORC] Add weak symbol support to defineMaterializing, fix for PR40074. (f7f0fd4a) · Commits · llvm-doe / llvm-project

llvm/include/llvm/ExecutionEngine/Orc/Core.h

+9 −4

Original line number	Diff line number	Diff line
		@@ -489,13 +489,18 @@ public:
		/// is guaranteed to return Error::success() and can be wrapped with cantFail.
		Error notifyEmitted();

		/// Adds new symbols to the JITDylib and this responsibility instance.
		/// JITDylib entries start out in the materializing state.
		/// Attempt to claim responsibility for new definitions. This method can be
		/// used to claim responsibility for symbols that are added to a
		/// materialization unit during the compilation process (e.g. literal pool
		/// symbols). Symbol linkage rules are the same as for symbols that are
		/// defined up front: duplicate strong definitions will result in errors.
		/// Duplicate weak definitions will be discarded (in which case they will
		/// not be added to this responsibility instance).
		///
		/// This method can be used by materialization units that want to add
		/// additional symbols at materialization time (e.g. stubs, compile
		/// callbacks, metadata).
		Error defineMaterializing(const SymbolFlagsMap &SymbolFlags);
		Error defineMaterializing(SymbolFlagsMap SymbolFlags);

		/// Notify all not-yet-emitted covered by this MaterializationResponsibility
		/// instance that an error has occurred.
		@@ -1023,7 +1028,7 @@ private:
		const SymbolStringPtr &DependantName,
		MaterializingInfo &EmittedMI);

		Error defineMaterializing(const SymbolFlagsMap &SymbolFlags);
		Expected<SymbolFlagsMap> defineMaterializing(SymbolFlagsMap SymbolFlags);

		void replace(std::unique_ptr<MaterializationUnit> MU);

llvm/lib/ExecutionEngine/Orc/Core.cpp

+51 −26

Original line number	Diff line number	Diff line
		@@ -468,15 +468,19 @@ Error MaterializationResponsibility::notifyEmitted() {
		}

		Error MaterializationResponsibility::defineMaterializing(
		const SymbolFlagsMap &NewSymbolFlags) {
		// Add the given symbols to this responsibility object.
		// It's ok if we hit a duplicate here: In that case the new version will be
		// discarded, and the JITDylib::defineMaterializing method will return a
		// duplicate symbol error.
		for (auto &KV : NewSymbolFlags)
		SymbolFlags.insert(KV);
		SymbolFlagsMap NewSymbolFlags) {

		return JD.defineMaterializing(NewSymbolFlags);
		LLVM_DEBUG({
		dbgs() << "In " << JD.getName() << " defining materializing symbols "
		<< NewSymbolFlags << "\n";
		});
		if (auto AcceptedDefs = JD.defineMaterializing(std::move(NewSymbolFlags))) {
		// Add all newly accepted symbols to this responsibility object.
		for (auto &KV : *AcceptedDefs)
		SymbolFlags.insert(KV);
		return Error::success();
		} else
		return AcceptedDefs.takeError();
		}

		void MaterializationResponsibility::failMaterialization() {
		@@ -809,31 +813,52 @@ void JITDylib::removeGenerator(DefinitionGenerator &G) {
		});
		}

		Error JITDylib::defineMaterializing(const SymbolFlagsMap &SymbolFlags) {
		return ES.runSessionLocked([&]() -> Error {
		Expected<SymbolFlagsMap>
		JITDylib::defineMaterializing(SymbolFlagsMap SymbolFlags) {

		return ES.runSessionLocked([&]() -> Expected<SymbolFlagsMap> {
		std::vector<SymbolTable::iterator> AddedSyms;
		std::vector<SymbolFlagsMap::iterator> RejectedWeakDefs;

		for (auto &KV : SymbolFlags) {
		SymbolTable::iterator EntryItr;
		bool Added;
		for (auto SFItr = SymbolFlags.begin(), SFEnd = SymbolFlags.end();
		SFItr != SFEnd; ++SFItr) {

		std::tie(EntryItr, Added) =
		Symbols.insert(std::make_pair(KV.first, SymbolTableEntry(KV.second)));
		auto &Name = SFItr->first;
		auto &Flags = SFItr->second;

		if (Added) {
		AddedSyms.push_back(EntryItr);
		EntryItr->second.setState(SymbolState::Materializing);
		} else {
		auto EntryItr = Symbols.find(Name);

		// If the entry already exists...
		if (EntryItr != Symbols.end()) {

		// If this is a strong definition then error out.
		if (!Flags.isWeak()) {
		// Remove any symbols already added.
		for (auto &SI : AddedSyms)
		Symbols.erase(SI);

		// FIXME: Return all duplicates.
		return make_error<DuplicateDefinition>(*KV.first);
		return make_error<DuplicateDefinition>(*Name);
		}

		// Otherwise just make a note to discard this symbol after the loop.
		RejectedWeakDefs.push_back(SFItr);
		continue;
		} else
		EntryItr =
		Symbols.insert(std::make_pair(Name, SymbolTableEntry(Flags))).first;

		AddedSyms.push_back(EntryItr);
		EntryItr->second.setState(SymbolState::Materializing);
		}

		// Remove any rejected weak definitions from the SymbolFlags map.
		while (!RejectedWeakDefs.empty()) {
		SymbolFlags.erase(RejectedWeakDefs.back());
		RejectedWeakDefs.pop_back();
		}

		return Error::success();
		return SymbolFlags;
		});
		}

llvm/lib/ExecutionEngine/Orc/LLJIT.cpp

+3 −1

Original line number	Diff line number	Diff line
		@@ -96,8 +96,10 @@ LLJIT::createObjectLinkingLayer(LLJITBuilderState &S, ExecutionSession &ES) {
		auto ObjLinkingLayer =
		std::make_unique<RTDyldObjectLinkingLayer>(ES, std::move(GetMemMgr));

		if (S.JTMB->getTargetTriple().isOSBinFormatCOFF())
		if (S.JTMB->getTargetTriple().isOSBinFormatCOFF()) {
		ObjLinkingLayer->setOverrideObjectFlagsWithResponsibilityFlags(true);
		ObjLinkingLayer->setAutoClaimResponsibilityForObjectSymbols(true);
		}

		// FIXME: Explicit conversion to std::unique_ptr<ObjectLayer> added to silence
		// errors from some GCC / libstdc++ bots. Remove this conversion (i.e.

llvm/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp

+42 −1

Original line number	Diff line number	Diff line
		@@ -7,6 +7,7 @@
		//===----------------------------------------------------------------------===//

		#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
		#include "llvm/Object/COFF.h"

		namespace {

		@@ -160,6 +161,39 @@ Error RTDyldObjectLinkingLayer::onObjLoad(
		std::set<StringRef> &InternalSymbols) {
		SymbolFlagsMap ExtraSymbolsToClaim;
		SymbolMap Symbols;

		// Hack to support COFF constant pool comdats introduced during compilation:
		// (See http://llvm.org/PR40074)
		if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(&Obj)) {
		auto &ES = getExecutionSession();

		// For all resolved symbols that are not already in the responsibilty set:
		// check whether the symbol is in a comdat section and if so mark it as
		// weak.
		for (auto &Sym : COFFObj->symbols()) {
		if (Sym.getFlags() & object::BasicSymbolRef::SF_Undefined)
		continue;
		auto Name = Sym.getName();
		if (!Name)
		return Name.takeError();
		auto I = Resolved.find(*Name);

		// Skip unresolved symbols, internal symbols, and symbols that are
		// already in the responsibility set.
		if (I == Resolved.end() \|\| InternalSymbols.count(*Name) \|\|
		R.getSymbols().count(ES.intern(*Name)))
		continue;
		auto Sec = Sym.getSection();
		if (!Sec)
		return Sec.takeError();
		if (*Sec == COFFObj->section_end())
		continue;
		auto &COFFSec = COFFObj->getCOFFSection(*Sec);
		if (COFFSec.Characteristics & COFF::IMAGE_SCN_LNK_COMDAT)
		I->second.setFlags(I->second.getFlags() \| JITSymbolFlags::Weak);
		}
		}

		for (auto &KV : Resolved) {
		// Scan the symbols and add them to the Symbols map for resolution.

		@@ -184,10 +218,17 @@ Error RTDyldObjectLinkingLayer::onObjLoad(
		Symbols[InternedName] = JITEvaluatedSymbol(KV.second.getAddress(), Flags);
		}

		if (!ExtraSymbolsToClaim.empty())
		if (!ExtraSymbolsToClaim.empty()) {
		if (auto Err = R.defineMaterializing(ExtraSymbolsToClaim))
		return Err;

		// If we claimed responsibility for any weak symbols but were rejected then
		// we need to remove them from the resolved set.
		for (auto &KV : ExtraSymbolsToClaim)
		if (KV.second.isWeak() && !R.getSymbols().count(KV.first))
		Symbols.erase(KV.first);
		}

		if (auto Err = R.notifyResolved(Symbols)) {
		R.failMaterialization();
		return Err;