[llvm] r361899 - [ORC] Track JIT symbol states more explicitly.
Lang Hames via llvm-commits
llvm-commits at lists.llvm.org
Thu May 30 19:22:32 PDT 2019
That warning seems unhelpful. Looks like there's already a bug filed for
it: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414
What's our policy on building warning clean on GCC? If we need to build
warning clean there I can work around this by declaring that field as a
uint8_t instead and casting.
-- Lang.
On Wed, May 29, 2019 at 3:42 PM Craig Topper <craig.topper at gmail.com> wrote:
> I'm getting this warning when compiled with gcc 5.5
>
> include/llvm/ExecutionEngine/Orc/Core.h:690:25: error:
> ‘llvm::orc::JITDylib::SymbolTableEntry::State’ is too small to hold all
> values of ‘enum class llvm::orc::JITDylib::SymbolState’ [-Werror]
> SymbolState State : 6;
>
> I think gcc uses the declared type of the enum class for this check. So it
> wants 8 bits here to match the uint8_t.
>
> ~Craig
>
>
> On Tue, May 28, 2019 at 4:32 PM Lang Hames via llvm-commits <
> llvm-commits at lists.llvm.org> wrote:
>
>> Author: lhames
>> Date: Tue May 28 16:35:44 2019
>> New Revision: 361899
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=361899&view=rev
>> Log:
>> [ORC] Track JIT symbol states more explicitly.
>>
>> Prior to this patch, JITDylibs inferred symbol states (whether a symbol
>> was
>> newly added, materializing, resolved, or ready to run) via a combination
>> of (1)
>> bits in the JITSymbolFlags member, and (2) the state of some internal
>> JITDylib
>> data structures. This patch explicitly tracks symbol states by adding a
>> new
>> SymbolState member to the symbol table entries, and removing the 'Lazy'
>> and
>> 'Materializing' bits from JITSymbolFlags. This is a first step towards
>> adding
>> additional states representing initialization phases (e.g. eh-frame
>> registration,
>> registration with the language runtime, and static initialization).
>>
>> Modified:
>> llvm/trunk/include/llvm/ExecutionEngine/JITSymbol.h
>> llvm/trunk/include/llvm/ExecutionEngine/Orc/Core.h
>> llvm/trunk/lib/ExecutionEngine/Orc/Core.cpp
>> llvm/trunk/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp
>>
>> Modified: llvm/trunk/include/llvm/ExecutionEngine/JITSymbol.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/JITSymbol.h?rev=361899&r1=361898&r2=361899&view=diff
>>
>> ==============================================================================
>> --- llvm/trunk/include/llvm/ExecutionEngine/JITSymbol.h (original)
>> +++ llvm/trunk/include/llvm/ExecutionEngine/JITSymbol.h Tue May 28
>> 16:35:44 2019
>> @@ -65,15 +65,9 @@ public:
>> Absolute = 1U << 3,
>> Exported = 1U << 4,
>> Callable = 1U << 5,
>> - Lazy = 1U << 6,
>> - Materializing = 1U << 7,
>> - LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ Materializing)
>> + LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ Callable)
>> };
>>
>> - static JITSymbolFlags stripTransientFlags(JITSymbolFlags Orig) {
>> - return static_cast<FlagNames>(Orig.Flags & ~Lazy & ~Materializing);
>> - }
>> -
>> /// Default-construct a JITSymbolFlags instance.
>> JITSymbolFlags() = default;
>>
>> @@ -110,19 +104,6 @@ public:
>> return (Flags & HasError) == HasError;
>> }
>>
>> - /// Returns true if this is a lazy symbol.
>> - /// This flag is used internally by the JIT APIs to track
>> - /// materialization states.
>> - bool isLazy() const { return Flags & Lazy; }
>> -
>> - /// Returns true if this symbol is in the process of being
>> - /// materialized.
>> - bool isMaterializing() const { return Flags & Materializing; }
>> -
>> - /// Returns true if this symbol is fully materialized.
>> - /// (i.e. neither lazy, nor materializing).
>> - bool isMaterialized() const { return !(Flags & (Lazy |
>> Materializing)); }
>> -
>> /// Returns true if the Weak flag is set.
>> bool isWeak() const {
>> return (Flags & Weak) == Weak;
>>
>> Modified: llvm/trunk/include/llvm/ExecutionEngine/Orc/Core.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/Core.h?rev=361899&r1=361898&r2=361899&view=diff
>>
>> ==============================================================================
>> --- llvm/trunk/include/llvm/ExecutionEngine/Orc/Core.h (original)
>> +++ llvm/trunk/include/llvm/ExecutionEngine/Orc/Core.h Tue May 28
>> 16:35:44 2019
>> @@ -641,6 +641,59 @@ private:
>> LLVM_MARK_AS_BITMASK_ENUM(NotifyFullyReady)
>> };
>>
>> + enum class SymbolState : uint8_t {
>> + Invalid, // No symbol should be in this state.
>> + NeverSearched, // Added to the symbol table, never queried.
>> + Materializing, // Queried, materialization begun.
>> + Resolved, // Assigned address, still materializing.
>> + Ready = 0x3f // Ready and safe for clients to access.
>> + };
>> +
>> + class SymbolTableEntry {
>> + public:
>> + SymbolTableEntry() = default;
>> + SymbolTableEntry(JITSymbolFlags Flags)
>> + : Flags(Flags), State(SymbolState::NeverSearched),
>> + MaterializerAttached(false), PendingRemoval(false) {}
>> +
>> + JITTargetAddress getAddress() const { return Addr; }
>> + JITSymbolFlags getFlags() const { return Flags; }
>> + SymbolState getState() const { return State; }
>> +
>> + bool isInMaterializationPhase() const {
>> + return State == SymbolState::Materializing ||
>> + State == SymbolState::Resolved;
>> + }
>> +
>> + bool hasMaterializerAttached() const { return MaterializerAttached; }
>> + bool isPendingRemoval() const { return PendingRemoval; }
>> +
>> + void setAddress(JITTargetAddress Addr) { this->Addr = Addr; }
>> + void setFlags(JITSymbolFlags Flags) { this->Flags = Flags; }
>> + void setState(SymbolState State) { this->State = State; }
>> +
>> + void setMaterializerAttached(bool MaterializerAttached) {
>> + this->MaterializerAttached = MaterializerAttached;
>> + }
>> +
>> + void setPendingRemoval(bool PendingRemoval) {
>> + this->PendingRemoval = PendingRemoval;
>> + }
>> +
>> + JITEvaluatedSymbol getSymbol() const {
>> + return JITEvaluatedSymbol(Addr, Flags);
>> + }
>> +
>> + private:
>> + JITTargetAddress Addr = 0;
>> + JITSymbolFlags Flags;
>> + SymbolState State : 6;
>> + bool MaterializerAttached : 1;
>> + bool PendingRemoval : 1;
>> + };
>> +
>> + using SymbolTable = DenseMap<SymbolStringPtr, SymbolTableEntry>;
>> +
>> JITDylib(ExecutionSession &ES, std::string Name);
>>
>> Error defineImpl(MaterializationUnit &MU);
>> @@ -685,7 +738,7 @@ private:
>>
>> ExecutionSession &ES;
>> std::string JITDylibName;
>> - SymbolMap Symbols;
>> + SymbolTable Symbols;
>> UnmaterializedInfosMap UnmaterializedInfos;
>> MaterializingInfosMap MaterializingInfos;
>> GeneratorFunction DefGenerator;
>>
>> Modified: llvm/trunk/lib/ExecutionEngine/Orc/Core.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/Core.cpp?rev=361899&r1=361898&r2=361899&view=diff
>>
>> ==============================================================================
>> --- llvm/trunk/lib/ExecutionEngine/Orc/Core.cpp (original)
>> +++ llvm/trunk/lib/ExecutionEngine/Orc/Core.cpp Tue May 28 16:35:44 2019
>> @@ -371,11 +371,6 @@ MaterializationResponsibility::Materiali
>> JITDylib &JD, SymbolFlagsMap SymbolFlags, VModuleKey K)
>> : JD(JD), SymbolFlags(std::move(SymbolFlags)), K(std::move(K)) {
>> assert(!this->SymbolFlags.empty() && "Materializing nothing?");
>> -
>> -#ifndef NDEBUG
>> - for (auto &KV : this->SymbolFlags)
>> - KV.second |= JITSymbolFlags::Materializing;
>> -#endif
>> }
>>
>> MaterializationResponsibility::~MaterializationResponsibility() {
>> @@ -395,8 +390,6 @@ void MaterializationResponsibility::reso
>> auto I = SymbolFlags.find(KV.first);
>> assert(I != SymbolFlags.end() &&
>> "Resolving symbol outside this responsibility set");
>> - assert(I->second.isMaterializing() && "Duplicate resolution");
>> - I->second &= ~JITSymbolFlags::Materializing;
>> if (I->second.isWeak())
>> assert(I->second == (KV.second.getFlags() | JITSymbolFlags::Weak)
>> &&
>> "Resolving symbol with incorrect flags");
>> @@ -415,12 +408,6 @@ void MaterializationResponsibility::emit
>> dbgs() << "In " << JD.getName() << " emitting " << SymbolFlags <<
>> "\n";
>> });
>>
>> -#ifndef NDEBUG
>> - for (auto &KV : SymbolFlags)
>> - assert(!KV.second.isMaterializing() &&
>> - "Failed to resolve symbol before emission");
>> -#endif // NDEBUG
>> -
>> JD.emit(SymbolFlags);
>> SymbolFlags.clear();
>> }
>> @@ -431,13 +418,8 @@ Error MaterializationResponsibility::def
>> // 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) {
>> - auto I = SymbolFlags.insert(KV).first;
>> - (void)I;
>> -#ifndef NDEBUG
>> - I->second |= JITSymbolFlags::Materializing;
>> -#endif
>> - }
>> + for (auto &KV : NewSymbolFlags)
>> + SymbolFlags.insert(KV);
>>
>> return JD.defineMaterializing(NewSymbolFlags);
>> }
>> @@ -744,21 +726,19 @@ ReexportsGenerator::operator()(JITDylib
>>
>> Error JITDylib::defineMaterializing(const SymbolFlagsMap &SymbolFlags) {
>> return ES.runSessionLocked([&]() -> Error {
>> - std::vector<SymbolMap::iterator> AddedSyms;
>> + std::vector<SymbolTable::iterator> AddedSyms;
>>
>> for (auto &KV : SymbolFlags) {
>> - SymbolMap::iterator EntryItr;
>> + SymbolTable::iterator EntryItr;
>> bool Added;
>>
>> - auto NewFlags = KV.second;
>> - NewFlags |= JITSymbolFlags::Materializing;
>> -
>> - std::tie(EntryItr, Added) = Symbols.insert(
>> - std::make_pair(KV.first, JITEvaluatedSymbol(0, NewFlags)));
>> + std::tie(EntryItr, Added) =
>> + Symbols.insert(std::make_pair(KV.first,
>> SymbolTableEntry(KV.second)));
>>
>> - if (Added)
>> + if (Added) {
>> AddedSyms.push_back(EntryItr);
>> - else {
>> + EntryItr->second.setState(SymbolState::Materializing);
>> + } else {
>> // Remove any symbols already added.
>> for (auto &SI : AddedSyms)
>> Symbols.erase(SI);
>> @@ -782,9 +762,10 @@ void JITDylib::replace(std::unique_ptr<M
>> for (auto &KV : MU->getSymbols()) {
>> auto SymI = Symbols.find(KV.first);
>> assert(SymI != Symbols.end() && "Replacing unknown symbol");
>> - assert(!SymI->second.getFlags().isLazy() &&
>> - SymI->second.getFlags().isMaterializing() &&
>> - "Can not replace symbol that is not materializing");
>> + assert(SymI->second.isInMaterializationPhase() &&
>> + "Can not call replace on a symbol that is not
>> materializing");
>> + assert(!SymI->second.hasMaterializerAttached() &&
>> + "Symbol should not have materializer attached already");
>> assert(UnmaterializedInfos.count(KV.first) == 0 &&
>> "Symbol being replaced should have no
>> UnmaterializedInfo");
>> }
>> @@ -803,16 +784,15 @@ void JITDylib::replace(std::unique_ptr<M
>> // Otherwise, make MU responsible for all the symbols.
>> auto UMI = std::make_shared<UnmaterializedInfo>(std::move(MU));
>> for (auto &KV : UMI->MU->getSymbols()) {
>> - assert(!KV.second.isLazy() &&
>> - "Lazy flag should be managed internally.");
>> - assert(!KV.second.isMaterializing() &&
>> - "Materializing flags should be managed internally.");
>> -
>> auto SymI = Symbols.find(KV.first);
>> - JITSymbolFlags ReplaceFlags = KV.second;
>> - ReplaceFlags |= JITSymbolFlags::Lazy;
>> - SymI->second = JITEvaluatedSymbol(SymI->second.getAddress(),
>> - std::move(ReplaceFlags));
>> + assert(SymI->second.getState() == SymbolState::Materializing &&
>> + "Can not replace a symbol that is not materializing");
>> + assert(!SymI->second.hasMaterializerAttached() &&
>> + "Can not replace a symbol that has a materializer
>> attached");
>> + assert(UnmaterializedInfos.count(KV.first) == 0 &&
>> + "Unexpected materializer entry in map");
>> + SymI->second.setAddress(SymI->second.getAddress());
>> + SymI->second.setMaterializerAttached(true);
>> UnmaterializedInfos[KV.first] = UMI;
>> }
>>
>> @@ -830,9 +810,9 @@ JITDylib::getRequestedSymbols(const Symb
>>
>> for (auto &KV : SymbolFlags) {
>> assert(Symbols.count(KV.first) && "JITDylib does not cover this
>> symbol?");
>> - assert(Symbols.find(KV.first)->second.getFlags().isMaterializing()
>> &&
>> - "getRequestedSymbols can only be called for materializing "
>> - "symbols");
>> + assert(Symbols.find(KV.first)->second.isInMaterializationPhase() &&
>> + "getRequestedSymbols can only be called for symbols that
>> have "
>> + "started materializing");
>> auto I = MaterializingInfos.find(KV.first);
>> if (I == MaterializingInfos.end())
>> continue;
>> @@ -848,9 +828,8 @@ JITDylib::getRequestedSymbols(const Symb
>> void JITDylib::addDependencies(const SymbolStringPtr &Name,
>> const SymbolDependenceMap &Dependencies) {
>> assert(Symbols.count(Name) && "Name not in symbol table");
>> - assert((Symbols[Name].getFlags().isLazy() ||
>> - Symbols[Name].getFlags().isMaterializing()) &&
>> - "Symbol is not lazy or materializing");
>> + assert(Symbols[Name].isInMaterializationPhase() &&
>> + "Can not add dependencies for a symbol that is not
>> materializing");
>>
>> auto &MI = MaterializingInfos[Name];
>> assert(!MI.IsEmitted && "Can not add dependencies to an emitted
>> symbol");
>> @@ -865,9 +844,8 @@ void JITDylib::addDependencies(const Sym
>> // Assert that this symbol exists and has not been emitted already.
>> auto SymI = OtherJITDylib.Symbols.find(OtherSymbol);
>> assert(SymI != OtherJITDylib.Symbols.end() &&
>> - (SymI->second.getFlags().isLazy() ||
>> - SymI->second.getFlags().isMaterializing()) &&
>> - "Dependency on emitted symbol");
>> + (SymI->second.getState() != SymbolState::Ready &&
>> + "Dependency on emitted symbol"));
>> #endif
>>
>> auto &OtherMI = OtherJITDylib.MaterializingInfos[OtherSymbol];
>> @@ -892,27 +870,25 @@ void JITDylib::resolve(const SymbolMap &
>> auto &Name = KV.first;
>> auto Sym = KV.second;
>>
>> - assert(!Sym.getFlags().isLazy() &&
>> !Sym.getFlags().isMaterializing() &&
>> - "Materializing flags should be managed internally");
>> -
>> auto I = Symbols.find(Name);
>>
>> assert(I != Symbols.end() && "Symbol not found");
>> - assert(!I->second.getFlags().isLazy() &&
>> - I->second.getFlags().isMaterializing() &&
>> + assert(!I->second.hasMaterializerAttached() &&
>> + "Resolving symbol with materializer attached?");
>> + assert(I->second.getState() == SymbolState::Materializing &&
>> "Symbol should be materializing");
>> assert(I->second.getAddress() == 0 && "Symbol has already been
>> resolved");
>>
>> assert((Sym.getFlags() & ~JITSymbolFlags::Weak) ==
>> -
>> (JITSymbolFlags::stripTransientFlags(I->second.getFlags()) &
>> - ~JITSymbolFlags::Weak) &&
>> + (I->second.getFlags() & ~JITSymbolFlags::Weak) &&
>> "Resolved flags should match the declared flags");
>>
>> // Once resolved, symbols can never be weak.
>> JITSymbolFlags ResolvedFlags = Sym.getFlags();
>> ResolvedFlags &= ~JITSymbolFlags::Weak;
>> - ResolvedFlags |= JITSymbolFlags::Materializing;
>> - I->second = JITEvaluatedSymbol(Sym.getAddress(), ResolvedFlags);
>> + I->second.setAddress(Sym.getAddress());
>> + I->second.setFlags(ResolvedFlags);
>> + I->second.setState(SymbolState::Resolved);
>>
>> auto &MI = MaterializingInfos[Name];
>> for (auto &Q : MI.PendingQueries) {
>> @@ -986,9 +962,7 @@ void JITDylib::emit(const SymbolFlagsMap
>> // and update its materializing state.
>> assert(DependantJD.Symbols.count(DependantName) &&
>> "Dependant has no entry in the Symbols table");
>> - auto &DependantSym = DependantJD.Symbols[DependantName];
>> - DependantSym.setFlags(DependantSym.getFlags() &
>> - ~JITSymbolFlags::Materializing);
>> +
>> DependantJD.Symbols[DependantName].setState(SymbolState::Ready);
>> DependantJD.MaterializingInfos.erase(DependantMII);
>> }
>> }
>> @@ -1005,8 +979,7 @@ void JITDylib::emit(const SymbolFlagsMap
>> }
>> assert(Symbols.count(Name) &&
>> "Symbol has no entry in the Symbols table");
>> - auto &Sym = Symbols[Name];
>> - Sym.setFlags(Sym.getFlags() & ~JITSymbolFlags::Materializing);
>> + Symbols[Name].setState(SymbolState::Ready);
>> MaterializingInfos.erase(MII);
>> }
>> }
>> @@ -1124,7 +1097,7 @@ void JITDylib::removeFromSearchOrder(JIT
>> Error JITDylib::remove(const SymbolNameSet &Names) {
>> return ES.runSessionLocked([&]() -> Error {
>> using SymbolMaterializerItrPair =
>> - std::pair<SymbolMap::iterator, UnmaterializedInfosMap::iterator>;
>> + std::pair<SymbolTable::iterator,
>> UnmaterializedInfosMap::iterator>;
>> std::vector<SymbolMaterializerItrPair> SymbolsToRemove;
>> SymbolNameSet Missing;
>> SymbolNameSet Materializing;
>> @@ -1139,13 +1112,14 @@ Error JITDylib::remove(const SymbolNameS
>> }
>>
>> // Note symbol materializing.
>> - if (I->second.getFlags().isMaterializing()) {
>> + if (I->second.isInMaterializationPhase()) {
>> Materializing.insert(Name);
>> continue;
>> }
>>
>> - auto UMII = I->second.getFlags().isLazy() ?
>> UnmaterializedInfos.find(Name)
>> - :
>> UnmaterializedInfos.end();
>> + auto UMII = I->second.hasMaterializerAttached()
>> + ? UnmaterializedInfos.find(Name)
>> + : UnmaterializedInfos.end();
>> SymbolsToRemove.push_back(std::make_pair(I, UMII));
>> }
>>
>> @@ -1205,14 +1179,11 @@ Expected<SymbolNameSet> JITDylib::lookup
>>
>> for (auto &Name : Names) {
>> auto I = Symbols.find(Name);
>> -
>> - if (I == Symbols.end()) {
>> + if (I != Symbols.end()) {
>> + assert(!Flags.count(Name) && "Symbol already present in Flags
>> map");
>> + Flags[Name] = I->second.getFlags();
>> + } else
>> Unresolved.insert(Name);
>> - continue;
>> - }
>> -
>> - assert(!Flags.count(Name) && "Symbol already present in Flags map");
>> - Flags[Name] =
>> JITSymbolFlags::stripTransientFlags(I->second.getFlags());
>> }
>>
>> return Unresolved;
>> @@ -1247,6 +1218,7 @@ void JITDylib::lodgeQueryImpl(
>>
>> std::vector<SymbolStringPtr> ToRemove;
>> for (auto Name : Unresolved) {
>> +
>> // Search for the name in Symbols. Skip it if not found.
>> auto SymI = Symbols.find(Name);
>> if (SymI == Symbols.end())
>> @@ -1260,16 +1232,17 @@ void JITDylib::lodgeQueryImpl(
>> // set.
>> ToRemove.push_back(Name);
>>
>> - // If the symbol has an address then resolve it.
>> - if (SymI->second.getAddress() != 0)
>> - Q->resolve(Name, SymI->second);
>> -
>> - // If the symbol is lazy, get the MaterialiaztionUnit for it.
>> - if (SymI->second.getFlags().isLazy()) {
>> + if (SymI->second.getState() >= SymbolState::Resolved) {
>> + assert(!SymI->second.hasMaterializerAttached() &&
>> + "Resolved symbols should not have materializers attached");
>> + Q->resolve(Name, SymI->second.getSymbol());
>> + if (SymI->second.getState() == SymbolState::Ready) {
>> + Q->notifySymbolReady();
>> + continue;
>> + }
>> + } else if (SymI->second.hasMaterializerAttached()) {
>> assert(SymI->second.getAddress() == 0 &&
>> - "Lazy symbol should not have a resolved address");
>> - assert(!SymI->second.getFlags().isMaterializing() &&
>> - "Materializing and lazy should not both be set");
>> + "Symbol not resolved but already has address?");
>> auto UMII = UnmaterializedInfos.find(Name);
>> assert(UMII != UnmaterializedInfos.end() &&
>> "Lazy symbol should have UnmaterializedInfo");
>> @@ -1280,24 +1253,17 @@ void JITDylib::lodgeQueryImpl(
>> // materializing state.
>> for (auto &KV : MU->getSymbols()) {
>> auto SymK = Symbols.find(KV.first);
>> - auto Flags = SymK->second.getFlags();
>> - Flags &= ~JITSymbolFlags::Lazy;
>> - Flags |= JITSymbolFlags::Materializing;
>> - SymK->second.setFlags(Flags);
>> + SymK->second.setMaterializerAttached(false);
>> + SymK->second.setState(SymbolState::Materializing);
>> UnmaterializedInfos.erase(KV.first);
>> }
>>
>> // Add MU to the list of MaterializationUnits to be materialized.
>> MUs.push_back(std::move(MU));
>> - } else if (!SymI->second.getFlags().isMaterializing()) {
>> - // The symbol is neither lazy nor materializing, so it must be
>> - // ready. Notify the query and continue.
>> - Q->notifySymbolReady();
>> - continue;
>> }
>>
>> // Add the query to the PendingQueries list.
>> - assert(SymI->second.getFlags().isMaterializing() &&
>> + assert(SymI->second.isInMaterializationPhase() &&
>> "By this line the symbol should be materializing");
>> auto &MI = MaterializingInfos[Name];
>> MI.PendingQueries.push_back(Q);
>> @@ -1387,17 +1353,15 @@ JITDylib::lookupImpl(std::shared_ptr<Asy
>>
>> // If the symbol has an address then resolve it.
>> if (SymI->second.getAddress() != 0) {
>> - Q->resolve(Name, SymI->second);
>> + Q->resolve(Name, SymI->second.getSymbol());
>> if (Q->isFullyResolved())
>> ActionFlags |= NotifyFullyResolved;
>> }
>>
>> // If the symbol is lazy, get the MaterialiaztionUnit for it.
>> - if (SymI->second.getFlags().isLazy()) {
>> + if (SymI->second.hasMaterializerAttached()) {
>> assert(SymI->second.getAddress() == 0 &&
>> "Lazy symbol should not have a resolved address");
>> - assert(!SymI->second.getFlags().isMaterializing() &&
>> - "Materializing and lazy should not both be set");
>> auto UMII = UnmaterializedInfos.find(Name);
>> assert(UMII != UnmaterializedInfos.end() &&
>> "Lazy symbol should have UnmaterializedInfo");
>> @@ -1408,18 +1372,15 @@ JITDylib::lookupImpl(std::shared_ptr<Asy
>> // materializing state.
>> for (auto &KV : MU->getSymbols()) {
>> auto SymK = Symbols.find(KV.first);
>> - auto Flags = SymK->second.getFlags();
>> - Flags &= ~JITSymbolFlags::Lazy;
>> - Flags |= JITSymbolFlags::Materializing;
>> - SymK->second.setFlags(Flags);
>> + assert(SymK != Symbols.end() && "Missing symbol table entry");
>> + SymK->second.setState(SymbolState::Materializing);
>> + SymK->second.setMaterializerAttached(false);
>> UnmaterializedInfos.erase(KV.first);
>> }
>>
>> // Add MU to the list of MaterializationUnits to be materialized.
>> MUs.push_back(std::move(MU));
>> - } else if (!SymI->second.getFlags().isMaterializing()) {
>> - // The symbol is neither lazy nor materializing, so it must be
>> ready.
>> - // Notify the query and continue.
>> + } else if (SymI->second.getState() == SymbolState::Ready) {
>> Q->notifySymbolReady();
>> if (Q->isFullyReady())
>> ActionFlags |= NotifyFullyReady;
>> @@ -1427,7 +1388,7 @@ JITDylib::lookupImpl(std::shared_ptr<Asy
>> }
>>
>> // Add the query to the PendingQueries list.
>> - assert(SymI->second.getFlags().isMaterializing() &&
>> + assert(SymI->second.isInMaterializationPhase() &&
>> "By this line the symbol should be materializing");
>> auto &MI = MaterializingInfos[Name];
>> MI.PendingQueries.push_back(Q);
>> @@ -1455,21 +1416,36 @@ void JITDylib::dump(raw_ostream &OS) {
>> for (auto &KV : Symbols) {
>> OS << " \"" << *KV.first << "\": ";
>> if (auto Addr = KV.second.getAddress())
>> - OS << format("0x%016" PRIx64, Addr) << ", " <<
>> KV.second.getFlags();
>> + OS << format("0x%016" PRIx64, Addr) << ", " <<
>> KV.second.getFlags()
>> + << " ";
>> else
>> - OS << "<not resolved>";
>> - if (KV.second.getFlags().isLazy() ||
>> - KV.second.getFlags().isMaterializing()) {
>> - OS << " (";
>> - if (KV.second.getFlags().isLazy()) {
>> - auto I = UnmaterializedInfos.find(KV.first);
>> - assert(I != UnmaterializedInfos.end() &&
>> - "Lazy symbol should have UnmaterializedInfo");
>> - OS << " Lazy (MU=" << I->second->MU.get() << ")";
>> - }
>> - if (KV.second.getFlags().isMaterializing())
>> - OS << " Materializing";
>> - OS << ", " << KV.second.getFlags() << " )\n";
>> + OS << "<not resolved> ";
>> +
>> + switch (KV.second.getState()) {
>> + case SymbolState::Invalid:
>> + OS << "Invalid";
>> + break;
>> + case SymbolState::NeverSearched:
>> + OS << "Never-Searched";
>> + break;
>> + case SymbolState::Materializing:
>> + OS << "Materializing";
>> + break;
>> + case SymbolState::Resolved:
>> + OS << "Resolved";
>> + break;
>> + case SymbolState::Ready:
>> + OS << "Ready";
>> + break;
>> + // default: llvm_unreachable("Invalid state"); break;
>> + }
>> +
>> + if (KV.second.hasMaterializerAttached()) {
>> + OS << " (Materializer ";
>> + auto I = UnmaterializedInfos.find(KV.first);
>> + assert(I != UnmaterializedInfos.end() &&
>> + "Lazy symbol should have UnmaterializedInfo");
>> + OS << I->second->MU.get() << ")\n";
>> } else
>> OS << "\n";
>> }
>> @@ -1505,21 +1481,17 @@ Error JITDylib::defineImpl(Materializati
>> std::vector<SymbolStringPtr> MUDefsOverridden;
>>
>> for (const auto &KV : MU.getSymbols()) {
>> - assert(!KV.second.isLazy() && "Lazy flag should be managed
>> internally.");
>> - assert(!KV.second.isMaterializing() &&
>> - "Materializing flags should be managed internally.");
>> -
>> auto I = Symbols.find(KV.first);
>>
>> if (I != Symbols.end()) {
>> if (KV.second.isStrong()) {
>> if (I->second.getFlags().isStrong() ||
>> - I->second.getFlags().isMaterializing())
>> + I->second.getState() > SymbolState::NeverSearched)
>> Duplicates.insert(KV.first);
>> else {
>> - assert(I->second.getFlags().isLazy() &&
>> - !I->second.getFlags().isMaterializing() &&
>> - "Overridden existing def should be in the Lazy state");
>> + assert(I->second.getState() == SymbolState::NeverSearched &&
>> + "Overridden existing def should be in the
>> never-searched "
>> + "state");
>> ExistingDefsOverridden.push_back(KV.first);
>> }
>> } else
>> @@ -1546,9 +1518,10 @@ Error JITDylib::defineImpl(Materializati
>>
>> // Finally, add the defs from this MU.
>> for (auto &KV : MU.getSymbols()) {
>> - auto NewFlags = KV.second;
>> - NewFlags |= JITSymbolFlags::Lazy;
>> - Symbols[KV.first] = JITEvaluatedSymbol(0, NewFlags);
>> + auto &SymEntry = Symbols[KV.first];
>> + SymEntry.setFlags(KV.second);
>> + SymEntry.setState(SymbolState::NeverSearched);
>> + SymEntry.setMaterializerAttached(true);
>> }
>>
>> return Error::success();
>>
>> Modified: llvm/trunk/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp?rev=361899&r1=361898&r2=361899&view=diff
>>
>> ==============================================================================
>> --- llvm/trunk/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp
>> (original)
>> +++ llvm/trunk/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp Tue
>> May 28 16:35:44 2019
>> @@ -175,7 +175,7 @@ Error RTDyldObjectLinkingLayer::onObjLoa
>> auto I = R.getSymbols().find(InternedName);
>>
>> if (OverrideObjectFlags && I != R.getSymbols().end())
>> - Flags = JITSymbolFlags::stripTransientFlags(I->second);
>> + Flags = I->second;
>> else if (AutoClaimObjectSymbols && I == R.getSymbols().end())
>> ExtraSymbolsToClaim[InternedName] = Flags;
>> }
>>
>>
>> _______________________________________________
>> llvm-commits mailing list
>> llvm-commits at lists.llvm.org
>> https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20190530/b80259d8/attachment.html>
More information about the llvm-commits
mailing list