| //===- LocalAliasAnalysis.cpp - Local stateless alias Analysis for MLIR ---===// | |
| // | |
| // 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 | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "mlir/Analysis/AliasAnalysis/LocalAliasAnalysis.h" | |
| #include "mlir/Analysis/AliasAnalysis.h" | |
| #include "mlir/IR/Attributes.h" | |
| #include "mlir/IR/Block.h" | |
| #include "mlir/IR/Matchers.h" | |
| #include "mlir/IR/OpDefinition.h" | |
| #include "mlir/IR/Operation.h" | |
| #include "mlir/IR/Region.h" | |
| #include "mlir/IR/Value.h" | |
| #include "mlir/Interfaces/ControlFlowInterfaces.h" | |
| #include "mlir/Interfaces/FunctionInterfaces.h" | |
| #include "mlir/Interfaces/SideEffectInterfaces.h" | |
| #include "mlir/Interfaces/ViewLikeInterface.h" | |
| #include "mlir/Support/LLVM.h" | |
| #include "llvm/Support/Casting.h" | |
| #include "llvm/Support/DebugLog.h" | |
| #include <cassert> | |
| #include <optional> | |
| #include <utility> | |
| using namespace mlir; | |
| #define DEBUG_TYPE "local-alias-analysis" | |
| //===----------------------------------------------------------------------===// | |
| // Underlying Address Computation | |
| //===----------------------------------------------------------------------===// | |
| /// The maximum depth that will be searched when trying to find an underlying | |
| /// value. | |
| static constexpr unsigned maxUnderlyingValueSearchDepth = 10; | |
| /// Given a value, collect all of the underlying values being addressed. | |
| static void collectUnderlyingAddressValues(Value value, unsigned maxDepth, | |
| DenseSet<Value> &visited, | |
| SmallVectorImpl<Value> &output); | |
| /// Given a RegionBranchOpInterface operation (`branch`), a Value`inputValue` | |
| /// which is an input for the provided successor (`initialSuccessor`), try to | |
| /// find the possible sources for the value along the control flow edges. | |
| static void collectUnderlyingAddressValues2( | |
| RegionBranchOpInterface branch, RegionSuccessor initialSuccessor, | |
| Value inputValue, unsigned inputIndex, unsigned maxDepth, | |
| DenseSet<Value> &visited, SmallVectorImpl<Value> &output) { | |
| LDBG() << "collectUnderlyingAddressValues2: " | |
| << OpWithFlags(branch.getOperation(), OpPrintingFlags().skipRegions()); | |
| LDBG() << " with initialSuccessor " << initialSuccessor; | |
| LDBG() << " inputValue: " << inputValue; | |
| LDBG() << " inputIndex: " << inputIndex; | |
| LDBG() << " maxDepth: " << maxDepth; | |
| ValueRange inputs = branch.getSuccessorInputs(initialSuccessor); | |
| if (inputs.empty()) { | |
| LDBG() << " input is empty, enqueue value"; | |
| output.push_back(inputValue); | |
| return; | |
| } | |
| unsigned firstInputIndex, lastInputIndex; | |
| if (isa<BlockArgument>(inputs[0])) { | |
| firstInputIndex = cast<BlockArgument>(inputs[0]).getArgNumber(); | |
| lastInputIndex = cast<BlockArgument>(inputs.back()).getArgNumber(); | |
| } else { | |
| firstInputIndex = cast<OpResult>(inputs[0]).getResultNumber(); | |
| lastInputIndex = cast<OpResult>(inputs.back()).getResultNumber(); | |
| } | |
| if (firstInputIndex > inputIndex || lastInputIndex < inputIndex) { | |
| LDBG() << " !! Input index " << inputIndex << " out of range " | |
| << firstInputIndex << " to " << lastInputIndex | |
| << ", adding input value to output"; | |
| output.push_back(inputValue); | |
| return; | |
| } | |
| SmallVector<Value> predecessorValues; | |
| branch.getPredecessorValues(initialSuccessor, inputIndex - firstInputIndex, | |
| predecessorValues); | |
| LDBG() << " Found " << predecessorValues.size() << " predecessor values"; | |
| for (Value predecessorValue : predecessorValues) { | |
| LDBG() << " Processing predecessor value: " << predecessorValue; | |
| collectUnderlyingAddressValues(predecessorValue, maxDepth, visited, output); | |
| } | |
| } | |
| /// Given a result, collect all of the underlying values being addressed. | |
| static void collectUnderlyingAddressValues(OpResult result, unsigned maxDepth, | |
| DenseSet<Value> &visited, | |
| SmallVectorImpl<Value> &output) { | |
| LDBG() << "collectUnderlyingAddressValues (OpResult): " << result; | |
| LDBG() << " maxDepth: " << maxDepth; | |
| Operation *op = result.getOwner(); | |
| // If this is a view, unwrap to the source. | |
| if (ViewLikeOpInterface view = dyn_cast<ViewLikeOpInterface>(op)) { | |
| if (result == view.getViewDest()) { | |
| LDBG() << " Unwrapping view to source: " << view.getViewSource(); | |
| return collectUnderlyingAddressValues(view.getViewSource(), maxDepth, | |
| visited, output); | |
| } | |
| } | |
| // Check to see if we can reason about the control flow of this op. | |
| if (auto branch = dyn_cast<RegionBranchOpInterface>(op)) { | |
| LDBG() << " Processing region branch operation"; | |
| return collectUnderlyingAddressValues2( | |
| branch, RegionSuccessor(branch.getOperation()), result, | |
| result.getResultNumber(), maxDepth, visited, output); | |
| } | |
| LDBG() << " Adding result to output: " << result; | |
| output.push_back(result); | |
| } | |
| /// Given a block argument, collect all of the underlying values being | |
| /// addressed. | |
| static void collectUnderlyingAddressValues(BlockArgument arg, unsigned maxDepth, | |
| DenseSet<Value> &visited, | |
| SmallVectorImpl<Value> &output) { | |
| LDBG() << "collectUnderlyingAddressValues (BlockArgument): " << arg; | |
| LDBG() << " maxDepth: " << maxDepth; | |
| LDBG() << " argNumber: " << arg.getArgNumber(); | |
| LDBG() << " isEntryBlock: " << arg.getOwner()->isEntryBlock(); | |
| Block *block = arg.getOwner(); | |
| unsigned argNumber = arg.getArgNumber(); | |
| // Handle the case of a non-entry block. | |
| if (!block->isEntryBlock()) { | |
| LDBG() << " Processing non-entry block with " | |
| << std::distance(block->pred_begin(), block->pred_end()) | |
| << " predecessors"; | |
| for (auto it = block->pred_begin(), e = block->pred_end(); it != e; ++it) { | |
| auto branch = dyn_cast<BranchOpInterface>((*it)->getTerminator()); | |
| if (!branch) { | |
| LDBG() << " Cannot analyze control flow, adding argument to output"; | |
| // We can't analyze the control flow, so bail out early. | |
| output.push_back(arg); | |
| return; | |
| } | |
| // Try to get the operand passed for this argument. | |
| unsigned index = it.getSuccessorIndex(); | |
| Value operand = branch.getSuccessorOperands(index)[argNumber]; | |
| if (!operand) { | |
| LDBG() << " No operand found for argument, adding to output"; | |
| // We can't analyze the control flow, so bail out early. | |
| output.push_back(arg); | |
| return; | |
| } | |
| LDBG() << " Processing operand from predecessor: " << operand; | |
| collectUnderlyingAddressValues(operand, maxDepth, visited, output); | |
| } | |
| return; | |
| } | |
| // Otherwise, check to see if we can reason about the control flow of this op. | |
| Region *region = block->getParent(); | |
| Operation *op = region->getParentOp(); | |
| if (auto branch = dyn_cast<RegionBranchOpInterface>(op)) { | |
| LDBG() << " Processing region branch operation for entry block"; | |
| // We have to find the successor matching the region, so that the input | |
| // arguments are correctly set. | |
| // TODO: this isn't comprehensive: the successor may not be reachable from | |
| // the entry block. | |
| SmallVector<RegionSuccessor> successors; | |
| branch.getSuccessorRegions(RegionBranchPoint::parent(), successors); | |
| for (RegionSuccessor &successor : successors) { | |
| if (successor.getSuccessor() == region) { | |
| LDBG() << " Found matching region successor: " << successor; | |
| return collectUnderlyingAddressValues2( | |
| branch, successor, arg, argNumber, maxDepth, visited, output); | |
| } | |
| } | |
| LDBG() << " No matching region successor found, adding argument to output"; | |
| output.push_back(arg); | |
| return; | |
| } | |
| LDBG() | |
| << " Cannot reason about underlying address, adding argument to output"; | |
| // We can't reason about the underlying address of this argument. | |
| output.push_back(arg); | |
| } | |
| /// Given a value, collect all of the underlying values being addressed. | |
| static void collectUnderlyingAddressValues(Value value, unsigned maxDepth, | |
| DenseSet<Value> &visited, | |
| SmallVectorImpl<Value> &output) { | |
| LDBG() << "collectUnderlyingAddressValues: " << value; | |
| LDBG() << " maxDepth: " << maxDepth; | |
| // Check that we don't infinitely recurse. | |
| if (!visited.insert(value).second) { | |
| LDBG() << " Value already visited, skipping"; | |
| return; | |
| } | |
| if (maxDepth == 0) { | |
| LDBG() << " Max depth reached, adding value to output"; | |
| output.push_back(value); | |
| return; | |
| } | |
| --maxDepth; | |
| if (BlockArgument arg = dyn_cast<BlockArgument>(value)) { | |
| LDBG() << " Processing as BlockArgument"; | |
| return collectUnderlyingAddressValues(arg, maxDepth, visited, output); | |
| } | |
| LDBG() << " Processing as OpResult"; | |
| collectUnderlyingAddressValues(cast<OpResult>(value), maxDepth, visited, | |
| output); | |
| } | |
| /// Given a value, collect all of the underlying values being addressed. | |
| static void collectUnderlyingAddressValues(Value value, | |
| SmallVectorImpl<Value> &output) { | |
| LDBG() << "collectUnderlyingAddressValues: " << value; | |
| DenseSet<Value> visited; | |
| collectUnderlyingAddressValues(value, maxUnderlyingValueSearchDepth, visited, | |
| output); | |
| LDBG() << " Collected " << output.size() << " underlying values"; | |
| } | |
| //===----------------------------------------------------------------------===// | |
| // LocalAliasAnalysis: alias | |
| //===----------------------------------------------------------------------===// | |
| /// Given a value, try to get an allocation effect attached to it. If | |
| /// successful, `allocEffect` is populated with the effect. If an effect was | |
| /// found, `allocScopeOp` is also specified if a parent operation of `value` | |
| /// could be identified that bounds the scope of the allocated value; i.e. if | |
| /// non-null it specifies the parent operation that the allocation does not | |
| /// escape. If no scope is found, `allocScopeOp` is set to nullptr. | |
| static LogicalResult | |
| getAllocEffectFor(Value value, | |
| std::optional<MemoryEffects::EffectInstance> &effect, | |
| Operation *&allocScopeOp) { | |
| LDBG() << "getAllocEffectFor: " << value; | |
| // Try to get a memory effect interface for the parent operation. | |
| Operation *op; | |
| if (BlockArgument arg = dyn_cast<BlockArgument>(value)) { | |
| op = arg.getOwner()->getParentOp(); | |
| LDBG() << " BlockArgument, parent op: " | |
| << OpWithFlags(op, OpPrintingFlags().skipRegions()); | |
| } else { | |
| op = cast<OpResult>(value).getOwner(); | |
| LDBG() << " OpResult, owner op: " | |
| << OpWithFlags(op, OpPrintingFlags().skipRegions()); | |
| } | |
| MemoryEffectOpInterface interface = dyn_cast<MemoryEffectOpInterface>(op); | |
| if (!interface) { | |
| LDBG() << " No memory effect interface found"; | |
| return failure(); | |
| } | |
| // Try to find an allocation effect on the resource. | |
| if (!(effect = interface.getEffectOnValue<MemoryEffects::Allocate>(value))) { | |
| LDBG() << " No allocation effect found on value"; | |
| return failure(); | |
| } | |
| LDBG() << " Found allocation effect"; | |
| // If we found an allocation effect, try to find a scope for the allocation. | |
| // If the resource of this allocation is automatically scoped, find the parent | |
| // operation that bounds the allocation scope. | |
| if (llvm::isa<SideEffects::AutomaticAllocationScopeResource>( | |
| effect->getResource())) { | |
| allocScopeOp = op->getParentWithTrait<OpTrait::AutomaticAllocationScope>(); | |
| if (allocScopeOp) { | |
| LDBG() << " Automatic allocation scope found: " | |
| << OpWithFlags(allocScopeOp, OpPrintingFlags().skipRegions()); | |
| } else { | |
| LDBG() << " Automatic allocation scope found: null"; | |
| } | |
| return success(); | |
| } | |
| // TODO: Here we could look at the users to see if the resource is either | |
| // freed on all paths within the region, or is just not captured by anything. | |
| // For now assume allocation scope to the function scope (we don't care if | |
| // pointer escape outside function). | |
| allocScopeOp = op->getParentOfType<FunctionOpInterface>(); | |
| if (allocScopeOp) { | |
| LDBG() << " Function scope found: " | |
| << OpWithFlags(allocScopeOp, OpPrintingFlags().skipRegions()); | |
| } else { | |
| LDBG() << " Function scope found: null"; | |
| } | |
| return success(); | |
| } | |
| static Operation *isDistinctObjectsOp(Operation *op) { | |
| if (op && op->hasTrait<OpTrait::DistinctObjectsTrait>()) | |
| return op; | |
| return nullptr; | |
| } | |
| static Value getDistinctObjectsOperand(Operation *op, Value value) { | |
| unsigned argNumber = cast<OpResult>(value).getResultNumber(); | |
| return op->getOperand(argNumber); | |
| } | |
| static std::optional<AliasResult> checkDistinctObjects(Value lhs, Value rhs) { | |
| // We should already checked that lhs and rhs are different. | |
| assert(lhs != rhs && "lhs and rhs must be different"); | |
| // Result and corresponding operand must alias. | |
| auto lhsOp = isDistinctObjectsOp(lhs.getDefiningOp()); | |
| if (lhsOp && getDistinctObjectsOperand(lhsOp, lhs) == rhs) | |
| return AliasResult::MustAlias; | |
| auto rhsOp = isDistinctObjectsOp(rhs.getDefiningOp()); | |
| if (rhsOp && getDistinctObjectsOperand(rhsOp, rhs) == lhs) | |
| return AliasResult::MustAlias; | |
| // If two different values come from the same `DistinctObjects` operation, | |
| // they don't alias. | |
| if (lhsOp && lhsOp == rhsOp) | |
| return AliasResult::NoAlias; | |
| return std::nullopt; | |
| } | |
| /// Given the two values, return their aliasing behavior. | |
| AliasResult LocalAliasAnalysis::aliasImpl(Value lhs, Value rhs) { | |
| LDBG() << "aliasImpl: " << lhs << " vs " << rhs; | |
| if (lhs == rhs) { | |
| LDBG() << " Same value, must alias"; | |
| return AliasResult::MustAlias; | |
| } | |
| Operation *lhsAllocScope = nullptr, *rhsAllocScope = nullptr; | |
| std::optional<MemoryEffects::EffectInstance> lhsAlloc, rhsAlloc; | |
| // Handle the case where lhs is a constant. | |
| Attribute lhsAttr, rhsAttr; | |
| if (matchPattern(lhs, m_Constant(&lhsAttr))) { | |
| LDBG() << " lhs is constant"; | |
| // TODO: This is overly conservative. Two matching constants don't | |
| // necessarily map to the same address. For example, if the two values | |
| // correspond to different symbols that both represent a definition. | |
| if (matchPattern(rhs, m_Constant(&rhsAttr))) { | |
| LDBG() << " rhs is also constant, may alias"; | |
| return AliasResult::MayAlias; | |
| } | |
| // Try to find an alloc effect on rhs. If an effect was found we can't | |
| // alias, otherwise we might. | |
| bool rhsHasAlloc = | |
| succeeded(getAllocEffectFor(rhs, rhsAlloc, rhsAllocScope)); | |
| LDBG() << " rhs has alloc effect: " << rhsHasAlloc; | |
| return rhsHasAlloc ? AliasResult::NoAlias : AliasResult::MayAlias; | |
| } | |
| // Handle the case where rhs is a constant. | |
| if (matchPattern(rhs, m_Constant(&rhsAttr))) { | |
| LDBG() << " rhs is constant"; | |
| // Try to find an alloc effect on lhs. If an effect was found we can't | |
| // alias, otherwise we might. | |
| bool lhsHasAlloc = | |
| succeeded(getAllocEffectFor(lhs, lhsAlloc, lhsAllocScope)); | |
| LDBG() << " lhs has alloc effect: " << lhsHasAlloc; | |
| return lhsHasAlloc ? AliasResult::NoAlias : AliasResult::MayAlias; | |
| } | |
| if (std::optional<AliasResult> result = checkDistinctObjects(lhs, rhs)) | |
| return *result; | |
| // Otherwise, neither of the values are constant so check to see if either has | |
| // an allocation effect. | |
| bool lhsHasAlloc = succeeded(getAllocEffectFor(lhs, lhsAlloc, lhsAllocScope)); | |
| bool rhsHasAlloc = succeeded(getAllocEffectFor(rhs, rhsAlloc, rhsAllocScope)); | |
| LDBG() << " lhs has alloc effect: " << lhsHasAlloc; | |
| LDBG() << " rhs has alloc effect: " << rhsHasAlloc; | |
| if (lhsHasAlloc == rhsHasAlloc) { | |
| // If both values have an allocation effect we know they don't alias, and if | |
| // neither have an effect we can't make an assumptions. | |
| LDBG() << " Both have same alloc status: " | |
| << (lhsHasAlloc ? "NoAlias" : "MayAlias"); | |
| return lhsHasAlloc ? AliasResult::NoAlias : AliasResult::MayAlias; | |
| } | |
| // When we reach this point we have one value with a known allocation effect, | |
| // and one without. Move the one with the effect to the lhs to make the next | |
| // checks simpler. | |
| if (rhsHasAlloc) { | |
| LDBG() << " Swapping lhs and rhs to put alloc effect on lhs"; | |
| std::swap(lhs, rhs); | |
| lhsAlloc = rhsAlloc; | |
| lhsAllocScope = rhsAllocScope; | |
| } | |
| // If the effect has a scoped allocation region, check to see if the | |
| // non-effect value is defined above that scope. | |
| if (lhsAllocScope) { | |
| LDBG() << " Checking allocation scope: " | |
| << OpWithFlags(lhsAllocScope, OpPrintingFlags().skipRegions()); | |
| // If the parent operation of rhs is an ancestor of the allocation scope, or | |
| // if rhs is an entry block argument of the allocation scope we know the two | |
| // values can't alias. | |
| Operation *rhsParentOp = rhs.getParentRegion()->getParentOp(); | |
| if (rhsParentOp->isProperAncestor(lhsAllocScope)) { | |
| LDBG() << " rhs parent is ancestor of alloc scope, no alias"; | |
| return AliasResult::NoAlias; | |
| } | |
| if (rhsParentOp == lhsAllocScope) { | |
| BlockArgument rhsArg = dyn_cast<BlockArgument>(rhs); | |
| if (rhsArg && rhs.getParentBlock()->isEntryBlock()) { | |
| LDBG() << " rhs is entry block arg of alloc scope, no alias"; | |
| return AliasResult::NoAlias; | |
| } | |
| } | |
| } | |
| // If we couldn't reason about the relationship between the two values, | |
| // conservatively assume they might alias. | |
| LDBG() << " Cannot reason about relationship, may alias"; | |
| return AliasResult::MayAlias; | |
| } | |
| /// Given the two values, return their aliasing behavior. | |
| AliasResult LocalAliasAnalysis::alias(Value lhs, Value rhs) { | |
| LDBG() << "alias: " << lhs << " vs " << rhs; | |
| if (lhs == rhs) { | |
| LDBG() << " Same value, must alias"; | |
| return AliasResult::MustAlias; | |
| } | |
| // Get the underlying values being addressed. | |
| SmallVector<Value, 8> lhsValues, rhsValues; | |
| collectUnderlyingAddressValues(lhs, lhsValues); | |
| collectUnderlyingAddressValues(rhs, rhsValues); | |
| LDBG() << " lhs underlying values: " << lhsValues.size(); | |
| LDBG() << " rhs underlying values: " << rhsValues.size(); | |
| // If we failed to collect for either of the values somehow, conservatively | |
| // assume they may alias. | |
| if (lhsValues.empty() || rhsValues.empty()) { | |
| LDBG() << " Failed to collect underlying values, may alias"; | |
| return AliasResult::MayAlias; | |
| } | |
| // Check the alias results against each of the underlying values. | |
| std::optional<AliasResult> result; | |
| for (Value lhsVal : lhsValues) { | |
| for (Value rhsVal : rhsValues) { | |
| LDBG() << " Checking underlying values: " << lhsVal << " vs " << rhsVal; | |
| AliasResult nextResult = aliasImpl(lhsVal, rhsVal); | |
| LDBG() << " Result: " | |
| << (nextResult == AliasResult::MustAlias ? "MustAlias" | |
| : nextResult == AliasResult::NoAlias ? "NoAlias" | |
| : "MayAlias"); | |
| result = result ? result->merge(nextResult) : nextResult; | |
| } | |
| } | |
| // We should always have a valid result here. | |
| LDBG() << " Final result: " | |
| << (result->isMust() ? "MustAlias" | |
| : result->isNo() ? "NoAlias" | |
| : "MayAlias"); | |
| return *result; | |
| } | |
| //===----------------------------------------------------------------------===// | |
| // LocalAliasAnalysis: getModRef | |
| //===----------------------------------------------------------------------===// | |
| ModRefResult LocalAliasAnalysis::getModRef(Operation *op, Value location) { | |
| LDBG() << "getModRef: " << OpWithFlags(op, OpPrintingFlags().skipRegions()) | |
| << " on location " << location; | |
| // Check to see if this operation relies on nested side effects. | |
| if (op->hasTrait<OpTrait::HasRecursiveMemoryEffects>()) { | |
| LDBG() << " Operation has recursive memory effects, returning ModAndRef"; | |
| // TODO: To check recursive operations we need to check all of the nested | |
| // operations, which can result in a quadratic number of queries. We should | |
| // introduce some caching of some kind to help alleviate this, especially as | |
| // this caching could be used in other areas of the codebase (e.g. when | |
| // checking `wouldOpBeTriviallyDead`). | |
| return ModRefResult::getModAndRef(); | |
| } | |
| // Otherwise, check to see if this operation has a memory effect interface. | |
| MemoryEffectOpInterface interface = dyn_cast<MemoryEffectOpInterface>(op); | |
| if (!interface) { | |
| LDBG() << " No memory effect interface, returning ModAndRef"; | |
| return ModRefResult::getModAndRef(); | |
| } | |
| // Build a ModRefResult by merging the behavior of the effects of this | |
| // operation. | |
| SmallVector<MemoryEffects::EffectInstance> effects; | |
| interface.getEffects(effects); | |
| LDBG() << " Found " << effects.size() << " memory effects"; | |
| ModRefResult result = ModRefResult::getNoModRef(); | |
| for (const MemoryEffects::EffectInstance &effect : effects) { | |
| if (isa<MemoryEffects::Allocate, MemoryEffects::Free>(effect.getEffect())) { | |
| LDBG() << " Skipping alloc/free effect"; | |
| continue; | |
| } | |
| // Check for an alias between the effect and our memory location. | |
| // TODO: Add support for checking an alias with a symbol reference. | |
| AliasResult aliasResult = AliasResult::MayAlias; | |
| if (Value effectValue = effect.getValue()) { | |
| LDBG() << " Checking alias between effect value " << effectValue | |
| << " and location " << location; | |
| aliasResult = alias(effectValue, location); | |
| LDBG() << " Alias result: " | |
| << (aliasResult.isMust() ? "MustAlias" | |
| : aliasResult.isNo() ? "NoAlias" | |
| : "MayAlias"); | |
| } else { | |
| // An effect on a non-addressable resource cannot affect a pointer-based | |
| // location. | |
| if (!effect.getResource()->isAddressable()) { | |
| LDBG() << " Effect on non-addressable resource '" | |
| << effect.getResource()->getName() << "', skipping (NoAlias)"; | |
| aliasResult = AliasResult::NoAlias; | |
| } else { | |
| LDBG() << " No effect value, assuming MayAlias"; | |
| } | |
| } | |
| // If we don't alias, ignore this effect. | |
| if (aliasResult.isNo()) { | |
| LDBG() << " No alias, ignoring effect"; | |
| continue; | |
| } | |
| // Merge in the corresponding mod or ref for this effect. | |
| if (isa<MemoryEffects::Read>(effect.getEffect())) { | |
| LDBG() << " Adding Ref to result"; | |
| result = result.merge(ModRefResult::getRef()); | |
| } else { | |
| assert(isa<MemoryEffects::Write>(effect.getEffect())); | |
| LDBG() << " Adding Mod to result"; | |
| result = result.merge(ModRefResult::getMod()); | |
| } | |
| if (result.isModAndRef()) { | |
| LDBG() << " Result is now ModAndRef, breaking"; | |
| break; | |
| } | |
| } | |
| LDBG() << " Final ModRef result: " | |
| << (result.isModAndRef() ? "ModAndRef" | |
| : result.isMod() ? "Mod" | |
| : result.isRef() ? "Ref" | |
| : "NoModRef"); | |
| return result; | |
| } |