Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===-- Speculation.h - Speculative Compilation --*- C++ -*-===//

//

// 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

//

//===----------------------------------------------------------------------===//

//

// Contains the definition to support speculative compilation when laziness is

// enabled.

//===----------------------------------------------------------------------===//

#ifndef LLVM_EXECUTIONENGINE_ORC_SPECULATION_H

#define LLVM_EXECUTIONENGINE_ORC_SPECULATION_H

#include "llvm/ADT/DenseMap.h"

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

#include "llvm/ExecutionEngine/Orc/DebugUtils.h"

#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"

#include "llvm/Support/Debug.h"

#include <mutex>

#include <type_traits>

#include <utility>

namespace llvm {

namespace orc {

class Speculator;

// Track the Impls (JITDylib,Symbols) of Symbols while lazy call through

// trampolines are created. Operations are guarded by locks tp ensure that Imap

// stays in consistent state after read/write

class ImplSymbolMap {

  friend class Speculator;

public:

  using AliaseeDetails = std::pair<SymbolStringPtr, JITDylib *>;

  using Alias = SymbolStringPtr;

  using ImapTy = DenseMap<Alias, AliaseeDetails>;

  void trackImpls(SymbolAliasMap ImplMaps, JITDylib *SrcJD);

private:

  // FIX ME: find a right way to distinguish the pre-compile Symbols, and update

  // the callsite

  std::optional<AliaseeDetails> getImplFor(const SymbolStringPtr &StubSymbol) {

    std::lock_guard<std::mutex> Lockit(ConcurrentAccess);

    auto Position = Maps.find(StubSymbol);

    if (Position != Maps.end())

      return Position->getSecond();

    else

      return std::nullopt;

  }

  std::mutex ConcurrentAccess;

  ImapTy Maps;

};

// Defines Speculator Concept,

class Speculator {

public:

  using TargetFAddr = JITTargetAddress;

  using FunctionCandidatesMap = DenseMap<SymbolStringPtr, SymbolNameSet>;

  using StubAddrLikelies = DenseMap<TargetFAddr, SymbolNameSet>;

private:

  void registerSymbolsWithAddr(TargetFAddr ImplAddr,

                               SymbolNameSet likelySymbols) {

    std::lock_guard<std::mutex> Lockit(ConcurrentAccess);

    GlobalSpecMap.insert({ImplAddr, std::move(likelySymbols)});

  }

  void launchCompile(JITTargetAddress FAddr) {

    SymbolNameSet CandidateSet;

    // Copy CandidateSet is necessary, to avoid unsynchronized access to

    // the datastructure.

    {

      std::lock_guard<std::mutex> Lockit(ConcurrentAccess);

      auto It = GlobalSpecMap.find(FAddr);

      if (It == GlobalSpecMap.end())

        return;

      CandidateSet = It->getSecond();

    }

    SymbolDependenceMap SpeculativeLookUpImpls;

    for (auto &Callee : CandidateSet) {

      auto ImplSymbol = AliaseeImplTable.getImplFor(Callee);

      // try to distinguish already compiled & library symbols

      if (!ImplSymbol)

        continue;

      const auto &ImplSymbolName = ImplSymbol->first;

      JITDylib *ImplJD = ImplSymbol->second;

      auto &SymbolsInJD = SpeculativeLookUpImpls[ImplJD];

      SymbolsInJD.insert(ImplSymbolName);

    }

    DEBUG_WITH_TYPE("orc", {

      for (auto &I : SpeculativeLookUpImpls) {

        llvm::dbgs() << "\n In " << I.first->getName() << " JITDylib ";

        for (auto &N : I.second)

          llvm::dbgs() << "\n Likely Symbol : " << N;

      }

    });

    // for a given symbol, there may be no symbol qualified for speculatively

    // compile try to fix this before jumping to this code if possible.

    for (auto &LookupPair : SpeculativeLookUpImpls)

      ES.lookup(

          LookupKind::Static,

          makeJITDylibSearchOrder(LookupPair.first,

                                  JITDylibLookupFlags::MatchAllSymbols),

          SymbolLookupSet(LookupPair.second), SymbolState::Ready,

          [this](Expected<SymbolMap> Result) {

            if (auto Err = Result.takeError())

              ES.reportError(std::move(Err));

          },

          NoDependenciesToRegister);

  }

public:

  Speculator(ImplSymbolMap &Impl, ExecutionSession &ref)

      : AliaseeImplTable(Impl), ES(ref), GlobalSpecMap(0) {}

  Speculator(const Speculator &) = delete;

  Speculator(Speculator &&) = delete;

  Speculator &operator=(const Speculator &) = delete;

  Speculator &operator=(Speculator &&) = delete;

  /// Define symbols for this Speculator object (__orc_speculator) and the

  /// speculation runtime entry point symbol (__orc_speculate_for) in the

  /// given JITDylib.

  Error addSpeculationRuntime(JITDylib &JD, MangleAndInterner &Mangle);

  // Speculatively compile likely functions for the given Stub Address.

  // destination of __orc_speculate_for jump

  void speculateFor(TargetFAddr StubAddr) { launchCompile(StubAddr); }

  // FIXME : Register with Stub Address, after JITLink Fix.

  void registerSymbols(FunctionCandidatesMap Candidates, JITDylib *JD) {

    for (auto &SymPair : Candidates) {

      auto Target = SymPair.first;

      auto Likely = SymPair.second;

      auto OnReadyFixUp = [Likely, Target,

                           this](Expected<SymbolMap> ReadySymbol) {

        if (ReadySymbol) {

          auto RAddr = (*ReadySymbol)[Target].getAddress();

          registerSymbolsWithAddr(RAddr, std::move(Likely));

        } else

          this->getES().reportError(ReadySymbol.takeError());

      };

      // Include non-exported symbols also.

      ES.lookup(

          LookupKind::Static,

          makeJITDylibSearchOrder(JD, JITDylibLookupFlags::MatchAllSymbols),

          SymbolLookupSet(Target, SymbolLookupFlags::WeaklyReferencedSymbol),

          SymbolState::Ready, OnReadyFixUp, NoDependenciesToRegister);

    }

  }

  ExecutionSession &getES() { return ES; }

private:

  static void speculateForEntryPoint(Speculator *Ptr, uint64_t StubId);

  std::mutex ConcurrentAccess;

  ImplSymbolMap &AliaseeImplTable;

  ExecutionSession &ES;

  StubAddrLikelies GlobalSpecMap;

};

class IRSpeculationLayer : public IRLayer {

public:

  using IRlikiesStrRef =

      std::optional<DenseMap<StringRef, DenseSet<StringRef>>>;

  using ResultEval = std::function<IRlikiesStrRef(Function &)>;

  using TargetAndLikelies = DenseMap<SymbolStringPtr, SymbolNameSet>;

  IRSpeculationLayer(ExecutionSession &ES, IRLayer &BaseLayer, Speculator &Spec,

                     MangleAndInterner &Mangle, ResultEval Interpreter)

      : IRLayer(ES, BaseLayer.getManglingOptions()), NextLayer(BaseLayer),

        S(Spec), Mangle(Mangle), QueryAnalysis(Interpreter) {}

  void emit(std::unique_ptr<MaterializationResponsibility> R,

            ThreadSafeModule TSM) override;

private:

  TargetAndLikelies

  internToJITSymbols(DenseMap<StringRef, DenseSet<StringRef>> IRNames) {

    assert(!IRNames.empty() && "No IRNames received to Intern?");

    TargetAndLikelies InternedNames;

    for (auto &NamePair : IRNames) {

      DenseSet<SymbolStringPtr> TargetJITNames;

      for (auto &TargetNames : NamePair.second)

        TargetJITNames.insert(Mangle(TargetNames));

      InternedNames[Mangle(NamePair.first)] = std::move(TargetJITNames);

    }

    return InternedNames;

  }

  IRLayer &NextLayer;

  Speculator &S;

  MangleAndInterner &Mangle;

  ResultEval QueryAnalysis;

};

} // namespace orc

} // namespace llvm

#endif // LLVM_EXECUTIONENGINE_ORC_SPECULATION_H