LLVM 20.0.0git
Classes | Namespaces | Macros | Functions | Variables
MemorySSA.cpp File Reference
#include "llvm/Analysis/MemorySSA.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DenseMapInfo.h"
#include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/DepthFirstIterator.h"
#include "llvm/ADT/Hashing.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/iterator.h"
#include "llvm/ADT/iterator_range.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/CFGPrinter.h"
#include "llvm/Analysis/IteratedDominanceFrontier.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Analysis/MemoryLocation.h"
#include "llvm/Config/llvm-config.h"
#include "llvm/IR/AssemblyAnnotationWriter.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Dominators.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Operator.h"
#include "llvm/IR/PassManager.h"
#include "llvm/IR/Use.h"
#include "llvm/InitializePasses.h"
#include "llvm/Pass.h"
#include "llvm/Support/AtomicOrdering.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FormattedStream.h"
#include "llvm/Support/GraphWriter.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cassert>
#include <iterator>
#include <memory>
#include <utility>

Go to the source code of this file.

Classes

struct  llvm::DenseMapInfo< MemoryLocOrCall >
 
class  llvm::MemorySSA::ClobberWalkerBase
 
class  llvm::MemorySSA::CachingWalker
 A MemorySSAWalker that does AA walks to disambiguate accesses. More...
 
class  llvm::MemorySSA::SkipSelfWalker
 
class  llvm::MemorySSA::OptimizeUses
 This class is a batch walker of all MemoryUse's in the program, and points their defining access at the thing that actually clobbers them. More...
 
class  DOTFuncMSSAInfo
 
struct  llvm::GraphTraits< DOTFuncMSSAInfo * >
 
struct  llvm::DOTGraphTraits< DOTFuncMSSAInfo * >
 

Namespaces

namespace  llvm
 This is an optimization pass for GlobalISel generic memory operations.
 

Macros

#define DEBUG_TYPE   "memoryssa"
 

Functions

 INITIALIZE_PASS_BEGIN (MemorySSAWrapperPass, "memoryssa", "Memory SSA", false, true) INITIALIZE_PASS_END(MemorySSAWrapperPass
 
Memory static true cl::opt< unsignedMaxCheckLimit ("memssa-check-limit", cl::Hidden, cl::init(100), cl::desc("The maximum number of stores/phis MemorySSA" "will consider trying to walk past (default = 100)"))
 
static bool areLoadsReorderable (const LoadInst *Use, const LoadInst *MayClobber)
 This does one-way checks to see if Use could theoretically be hoisted above MayClobber.
 
template<typename AliasAnalysisType >
static bool instructionClobbersQuery (const MemoryDef *MD, const MemoryLocation &UseLoc, const Instruction *UseInst, AliasAnalysisType &AA)
 
template<typename AliasAnalysisType >
static bool instructionClobbersQuery (MemoryDef *MD, const MemoryUseOrDef *MU, const MemoryLocOrCall &UseMLOC, AliasAnalysisType &AA)
 
template<typename AliasAnalysisType >
static bool isUseTriviallyOptimizableToLiveOnEntry (AliasAnalysisType &AA, const Instruction *I)
 
static LLVM_ATTRIBUTE_UNUSED void checkClobberSanity (const MemoryAccess *Start, MemoryAccess *ClobberAt, const MemoryLocation &StartLoc, const MemorySSA &MSSA, const UpwardsMemoryQuery &Query, BatchAAResults &AA, bool AllowImpreciseClobber=false)
 Verifies that Start is clobbered by ClobberAt, and that nothing inbetween Start and ClobberAt can clobbers Start.
 
static bool isOrdered (const Instruction *I)
 
static const InstructiongetInvariantGroupClobberingInstruction (Instruction &I, DominatorTree &DT)
 

Variables

static cl::opt< std::string > DotCFGMSSA ("dot-cfg-mssa", cl::value_desc("file name for generated dot file"), cl::desc("file name for generated dot file"), cl::init(""))
 
 memoryssa
 
Memory SSA
 
Memory false
 
static cl::opt< bool, trueVerifyMemorySSAX ("verify-memoryssa", cl::location(VerifyMemorySSA), cl::Hidden, cl::desc("Enable verification of MemorySSA."))
 
static const char LiveOnEntryStr [] = "liveOnEntry"
 

Macro Definition Documentation

◆ DEBUG_TYPE

#define DEBUG_TYPE   "memoryssa"

Definition at line 61 of file MemorySSA.cpp.

Function Documentation

◆ areLoadsReorderable()

static bool areLoadsReorderable ( const LoadInst Use,
const LoadInst MayClobber 
)
static

This does one-way checks to see if Use could theoretically be hoisted above MayClobber.

This will not check the other way around.

This assumes that, for the purposes of MemorySSA, Use comes directly after MayClobber, with no potentially clobbering operations in between them. (Where potentially clobbering ops are memory barriers, aliased stores, etc.)

Definition at line 256 of file MemorySSA.cpp.

References llvm::LoadInst::getOrdering(), llvm::isAtLeastOrStrongerThan(), and llvm::LoadInst::isVolatile().

Referenced by instructionClobbersQuery().

◆ checkClobberSanity()

static LLVM_ATTRIBUTE_UNUSED void checkClobberSanity ( const MemoryAccess Start,
MemoryAccess ClobberAt,
const MemoryLocation StartLoc,
const MemorySSA MSSA,
const UpwardsMemoryQuery &  Query,
BatchAAResults AA,
bool  AllowImpreciseClobber = false 
)
static

Verifies that Start is clobbered by ClobberAt, and that nothing inbetween Start and ClobberAt can clobbers Start.

This is meant to be as simple and self-contained as possible. Because it uses no cache, etc., it can be relatively expensive.

Parameters
StartThe MemoryAccess that we want to walk from.
ClobberAtA clobber for Start.
StartLocThe MemoryLocation for Start.
MSSAThe MemorySSA instance that Start and ClobberAt belong to.
QueryThe UpwardsMemoryQuery we used for our search.
AAThe AliasAnalysis we used for our search.
AllowImpreciseClobberAlways false, unless we do relaxed verify.

Definition at line 397 of file MemorySSA.cpp.

References assert(), llvm::def_chain(), llvm::MemorySSA::dominates(), llvm::SmallVectorImpl< T >::emplace_back(), llvm::SmallVectorBase< Size_T >::empty(), llvm::MemorySSA::getDomTree(), llvm::detail::DenseSetImpl< ValueT, MapTy, ValueInfoT >::insert(), instructionClobbersQuery(), llvm::MemorySSA::isLiveOnEntryDef(), llvm::DominatorTree::isReachableFromEntry(), MAP, llvm::SmallVectorImpl< T >::pop_back_val(), llvm::upward_defs_begin(), and llvm::upward_defs_end().

◆ getInvariantGroupClobberingInstruction()

static const Instruction * getInvariantGroupClobberingInstruction ( Instruction I,
DominatorTree DT 
)
static

◆ INITIALIZE_PASS_BEGIN()

INITIALIZE_PASS_BEGIN ( MemorySSAWrapperPass  ,
"memoryssa"  ,
"Memory SSA"  ,
false  ,
true   
)

◆ instructionClobbersQuery() [1/2]

template<typename AliasAnalysisType >
static bool instructionClobbersQuery ( const MemoryDef MD,
const MemoryLocation UseLoc,
const Instruction UseInst,
AliasAnalysisType &  AA 
)
static

◆ instructionClobbersQuery() [2/2]

template<typename AliasAnalysisType >
static bool instructionClobbersQuery ( MemoryDef MD,
const MemoryUseOrDef MU,
const MemoryLocOrCall &  UseMLOC,
AliasAnalysisType &  AA 
)
static

◆ isOrdered()

static bool isOrdered ( const Instruction I)
inlinestatic

Definition at line 1745 of file MemorySSA.cpp.

References I.

Referenced by llvm::MemoryDependenceResults::getNonLocalPointerDependency().

◆ isUseTriviallyOptimizableToLiveOnEntry()

template<typename AliasAnalysisType >
static bool isUseTriviallyOptimizableToLiveOnEntry ( AliasAnalysisType &  AA,
const Instruction I 
)
static

◆ MaxCheckLimit()

Memory static true cl::opt< unsigned > MaxCheckLimit ( "memssa-check-limit"  ,
cl::Hidden  ,
cl::init(100)  ,
cl::desc("The maximum number of stores/phis MemorySSA" "will consider trying to walk past (default = 100)")   
)
static

Variable Documentation

◆ DotCFGMSSA

cl::opt< std::string > DotCFGMSSA("dot-cfg-mssa", cl::value_desc("file name for generated dot file"), cl::desc("file name for generated dot file"), cl::init("")) ( "dot-cfg-mssa"  ,
cl::value_desc("file name for generated dot file")  ,
cl::desc("file name for generated dot file")  ,
cl::init("")   
)
static

◆ false

Memory false

Definition at line 72 of file MemorySSA.cpp.

◆ LiveOnEntryStr

const char LiveOnEntryStr[] = "liveOnEntry"
static

◆ memoryssa

memoryssa

Definition at line 72 of file MemorySSA.cpp.

◆ SSA

Memory SSA

◆ VerifyMemorySSAX

cl::opt< bool, true > VerifyMemorySSAX("verify-memoryssa", cl::location(VerifyMemorySSA), cl::Hidden, cl::desc("Enable verification of MemorySSA.")) ( "verify-memoryssa"  ,
cl::location(VerifyMemorySSA)  ,
cl::Hidden  ,
cl::desc("Enable verification of MemorySSA.")   
)
static