Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- PassManagerImpl.h - Pass management infrastructure -------*- 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

//

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

/// \file

/// Provides implementations for PassManager and AnalysisManager template

/// methods. These classes should be explicitly instantiated for any IR unit,

/// and files doing the explicit instantiation should include this header.

///

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

#ifndef LLVM_IR_PASSMANAGERIMPL_H

#define LLVM_IR_PASSMANAGERIMPL_H

#include "llvm/IR/PassManager.h"

namespace llvm {

template <typename IRUnitT, typename... ExtraArgTs>

inline AnalysisManager<IRUnitT, ExtraArgTs...>::AnalysisManager() = default;

template <typename IRUnitT, typename... ExtraArgTs>

inline AnalysisManager<IRUnitT, ExtraArgTs...>::AnalysisManager(

    AnalysisManager &&) = default;

template <typename IRUnitT, typename... ExtraArgTs>

inline AnalysisManager<IRUnitT, ExtraArgTs...> &

AnalysisManager<IRUnitT, ExtraArgTs...>::operator=(AnalysisManager &&) =

    default;

template <typename IRUnitT, typename... ExtraArgTs>

inline void

AnalysisManager<IRUnitT, ExtraArgTs...>::clear(IRUnitT &IR,

                                               llvm::StringRef Name) {

  if (auto *PI = getCachedResult<PassInstrumentationAnalysis>(IR))

    PI->runAnalysesCleared(Name);

  auto ResultsListI = AnalysisResultLists.find(&IR);

  if (ResultsListI == AnalysisResultLists.end())

    return;

  // Delete the map entries that point into the results list.

  for (auto &IDAndResult : ResultsListI->second)

    AnalysisResults.erase({IDAndResult.first, &IR});

  // And actually destroy and erase the results associated with this IR.

  AnalysisResultLists.erase(ResultsListI);

}

template <typename IRUnitT, typename... ExtraArgTs>

inline typename AnalysisManager<IRUnitT, ExtraArgTs...>::ResultConceptT &

AnalysisManager<IRUnitT, ExtraArgTs...>::getResultImpl(

    AnalysisKey *ID, IRUnitT &IR, ExtraArgTs... ExtraArgs) {

  typename AnalysisResultMapT::iterator RI;

  bool Inserted;

  std::tie(RI, Inserted) = AnalysisResults.insert(std::make_pair(

      std::make_pair(ID, &IR), typename AnalysisResultListT::iterator()));

  // If we don't have a cached result for this function, look up the pass and

  // run it to produce a result, which we then add to the cache.

  if (Inserted) {

    auto &P = this->lookUpPass(ID);

    PassInstrumentation PI;

    if (ID != PassInstrumentationAnalysis::ID()) {

      PI = getResult<PassInstrumentationAnalysis>(IR, ExtraArgs...);

      PI.runBeforeAnalysis(P, IR);

    }

    AnalysisResultListT &ResultList = AnalysisResultLists[&IR];

    ResultList.emplace_back(ID, P.run(IR, *this, ExtraArgs...));

    PI.runAfterAnalysis(P, IR);

    // P.run may have inserted elements into AnalysisResults and invalidated

    // RI.

    RI = AnalysisResults.find({ID, &IR});

    assert(RI != AnalysisResults.end() && "we just inserted it!");

    RI->second = std::prev(ResultList.end());

  }

  return *RI->second->second;

}

template <typename IRUnitT, typename... ExtraArgTs>

inline void AnalysisManager<IRUnitT, ExtraArgTs...>::invalidate(

    IRUnitT &IR, const PreservedAnalyses &PA) {

  // We're done if all analyses on this IR unit are preserved.

  if (PA.allAnalysesInSetPreserved<AllAnalysesOn<IRUnitT>>())

    return;

  // Track whether each analysis's result is invalidated in

  // IsResultInvalidated.

  SmallDenseMap<AnalysisKey *, bool, 8> IsResultInvalidated;

  Invalidator Inv(IsResultInvalidated, AnalysisResults);

  AnalysisResultListT &ResultsList = AnalysisResultLists[&IR];

  for (auto &AnalysisResultPair : ResultsList) {

    // This is basically the same thing as Invalidator::invalidate, but we

    // can't call it here because we're operating on the type-erased result.

    // Moreover if we instead called invalidate() directly, it would do an

    // unnecessary look up in ResultsList.

    AnalysisKey *ID = AnalysisResultPair.first;

    auto &Result = *AnalysisResultPair.second;

    auto IMapI = IsResultInvalidated.find(ID);

    if (IMapI != IsResultInvalidated.end())

      // This result was already handled via the Invalidator.

      continue;

    // Try to invalidate the result, giving it the Invalidator so it can

    // recursively query for any dependencies it has and record the result.

    // Note that we cannot reuse 'IMapI' here or pre-insert the ID, as

    // Result.invalidate may insert things into the map, invalidating our

    // iterator.

    bool Inserted =

        IsResultInvalidated.insert({ID, Result.invalidate(IR, PA, Inv)}).second;

    (void)Inserted;

    assert(Inserted && "Should never have already inserted this ID, likely "

                       "indicates a cycle!");

  }

  // Now erase the results that were marked above as invalidated.

  if (!IsResultInvalidated.empty()) {

    for (auto I = ResultsList.begin(), E = ResultsList.end(); I != E;) {

      AnalysisKey *ID = I->first;

      if (!IsResultInvalidated.lookup(ID)) {

        ++I;

        continue;

      }

      if (auto *PI = getCachedResult<PassInstrumentationAnalysis>(IR))

        PI->runAnalysisInvalidated(this->lookUpPass(ID), IR);

      I = ResultsList.erase(I);

      AnalysisResults.erase({ID, &IR});

    }

  }

  if (ResultsList.empty())

    AnalysisResultLists.erase(&IR);

}

} // end namespace llvm

#endif // LLVM_IR_PASSMANAGERIMPL_H