//===- llvm/Analysis/MemoryDependenceAnalysis.h - Memory Deps ---*- 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 // //===----------------------------------------------------------------------===// // // This file defines the MemoryDependenceAnalysis analysis pass. // //===----------------------------------------------------------------------===// #ifndef LLVM_ANALYSIS_MEMORYDEPENDENCEANALYSIS_H #define LLVM_ANALYSIS_MEMORYDEPENDENCEANALYSIS_H #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/PointerEmbeddedInt.h" #include "llvm/ADT/PointerIntPair.h" #include "llvm/ADT/PointerSumType.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/Analysis/AliasAnalysis.h" #include "llvm/Analysis/MemoryLocation.h" #include "llvm/IR/PassManager.h" #include "llvm/IR/PredIteratorCache.h" #include "llvm/IR/ValueHandle.h" #include "llvm/Pass.h" #include <optional> namespace llvm { class AssumptionCache; class DominatorTree; class PHITransAddr; /// A memory dependence query can return one of three different answers. class MemDepResult { … }; /// This is an entry in the NonLocalDepInfo cache. /// /// For each BasicBlock (the BB entry) it keeps a MemDepResult. class NonLocalDepEntry { … }; /// This is a result from a NonLocal dependence query. /// /// For each BasicBlock (the BB entry) it keeps a MemDepResult and the /// (potentially phi translated) address that was live in the block. class NonLocalDepResult { … }; /// Provides a lazy, caching interface for making common memory aliasing /// information queries, backed by LLVM's alias analysis passes. /// /// The dependency information returned is somewhat unusual, but is pragmatic. /// If queried about a store or call that might modify memory, the analysis /// will return the instruction[s] that may either load from that memory or /// store to it. If queried with a load or call that can never modify memory, /// the analysis will return calls and stores that might modify the pointer, /// but generally does not return loads unless a) they are volatile, or /// b) they load from *must-aliased* pointers. Returning a dependence on /// must-alias'd pointers instead of all pointers interacts well with the /// internal caching mechanism. class MemoryDependenceResults { … }; /// An analysis that produces \c MemoryDependenceResults for a function. /// /// This is essentially a no-op because the results are computed entirely /// lazily. class MemoryDependenceAnalysis : public AnalysisInfoMixin<MemoryDependenceAnalysis> { … }; /// A wrapper analysis pass for the legacy pass manager that exposes a \c /// MemoryDepnedenceResults instance. class MemoryDependenceWrapperPass : public FunctionPass { … }; } // end namespace llvm #endif // LLVM_ANALYSIS_MEMORYDEPENDENCEANALYSIS_H