// Track this identifiable dynamic access in storageToDomMap, and optimize it if
// possible. Return true if the optimization suceeds.
bool DominatedAccessRemoval::checkDominatedAccess(
BeginAccessInst *BAI, DomAccessedStorage currDomStorage) {
// Attempt to add this access to storageToDomMap using its base storage
// location as the key.
//
// Cast this DomAccessedStorage back to a plain storage location. The
// pass-specific bits will be ignored, but reset them anyway for sanity.
AccessedStorage storage = static_cast<AccessedStorage>(currDomStorage);
storage.resetSubclassData();
auto iterAndInserted =
storageToDomMap.try_emplace(storage, DominatingAccess(BAI, currDomNode));
if (iterAndInserted.second)
return false;
// An access has already been recorded for this storage.
// If the previous domNode does not dominate currDomNode, then replace it.
DominatingAccess &domAccess = iterAndInserted.first->second;
if (!domInfo->dominates(domAccess.domNode, currDomNode)) {
domAccess = DominatingAccess(BAI, currDomNode);
return false;
}
// The previously mapped access still dominates this block, so the current
// access can potentially be optimized.
return optimizeDominatedAccess(BAI, currDomStorage, domAccess);
}
// Return true if the given access is on a 'let' lvalue.
static bool isLetAccess(const AccessedStorage &storage, SILFunction *F) {
if (auto *decl = dyn_cast_or_null<VarDecl>(storage.getDecl(F)))
return decl->isLet();
// It's unclear whether a global will ever be missing it's varDecl, but
// technically we only preserve it for debug info. So if we don't have a decl,
// check the flag on SILGlobalVariable, which is guaranteed valid,
if (storage.getKind() == AccessedStorage::Global)
return storage.getGlobal()->isLet();
return false;
}
bool swift::isPossibleFormalAccessBase(const AccessedStorage &storage,
SILFunction *F) {
switch (storage.getKind()) {
case AccessedStorage::Box:
case AccessedStorage::Stack:
if (isScratchBuffer(storage.getValue()))
return false;
break;
case AccessedStorage::Global:
break;
case AccessedStorage::Class:
break;
case AccessedStorage::Yield:
// Yields are accessed by the caller.
return false;
case AccessedStorage::Argument:
// Function arguments are accessed by the caller.
return false;
case AccessedStorage::Nested: {
// A begin_access is considered a separate base for the purpose of conflict
// checking. However, for the purpose of inserting unenforced markers and
// performaing verification, it needs to be ignored.
auto *BAI = cast<BeginAccessInst>(storage.getValue());
const AccessedStorage &nestedStorage =
findAccessedStorage(BAI->getSource());
if (!nestedStorage)
return false;
return isPossibleFormalAccessBase(nestedStorage, F);
}
case AccessedStorage::Unidentified:
if (isAddressForLocalInitOnly(storage.getValue()))
return false;
if (isa<SILPhiArgument>(storage.getValue())) {
checkSwitchEnumBlockArg(cast<SILPhiArgument>(storage.getValue()));
return false;
}
// Pointer-to-address exclusivity cannot be enforced. `baseAddress` may be
// pointing anywhere within an object.
if (isa<PointerToAddressInst>(storage.getValue()))
return false;
if (isa<SILUndef>(storage.getValue()))
return false;
if (isScratchBuffer(storage.getValue()))
return false;
}
// Additional checks that apply to anything that may fall through.
// Immutable values are only accessed for initialization.
if (isLetAccess(storage, F))
return false;
return true;
}
static unsigned getHashValue(AccessedStorage Storage) {
switch (Storage.getKind()) {
case AccessedStorageKind::Value:
return DenseMapInfo<swift::SILValue>::getHashValue(Storage.getValue());
case AccessedStorageKind::GlobalVar:
return DenseMapInfo<void *>::getHashValue(Storage.getGlobal());
case AccessedStorageKind::ClassProperty: {
const ObjectProjection &P = Storage.getObjectProjection();
return llvm::hash_combine(P.getObject(), P.getProjection());
}
}
llvm_unreachable("Unhandled AccessedStorageKind");
}
bool AccessedStorageResult::hasNoNestedConflict(
const AccessedStorage &otherStorage) const {
assert(otherStorage.isUniquelyIdentified());
assert(!hasUnidentifiedAccess());
return getStorageAccessInfo(otherStorage).hasNoNestedConflict();
}
static bool isEqual(AccessedStorage LHS, AccessedStorage RHS) {
if (LHS.getKind() != RHS.getKind())
return false;
switch (LHS.getKind()) {
case AccessedStorageKind::Value:
return LHS.getValue() == RHS.getValue();
case AccessedStorageKind::GlobalVar:
return LHS.getGlobal() == RHS.getGlobal();
case AccessedStorageKind::ClassProperty:
return LHS.getObjectProjection() == RHS.getObjectProjection();
}
llvm_unreachable("Unhandled AccessedStorageKind");
}
bool AccessedStorageResult::mayConflictWith(
SILAccessKind otherAccessKind, const AccessedStorage &otherStorage) const {
if (hasUnidentifiedAccess()
&& accessKindMayConflict(otherAccessKind,
unidentifiedAccess.getValue())) {
return true;
}
for (auto &storageAccess : storageAccessSet) {
assert(storageAccess && "FunctionAccessedStorage mapped invalid storage.");
if (!accessKindMayConflict(otherAccessKind, storageAccess.getAccessKind()))
continue;
if (!otherStorage.isDistinctFrom(storageAccess))
return true;
}
return false;
}
// Attempt to insert a new access in the loop preheader. If successful, insert
// the new access in DominatedAccessAnalysis so it can be used to dominate other
// accesses. Also convert the current access to static and update the current
// storageToDomMap since the access may already have been recorded (when it was
// still dynamic).
//
// This function cannot add or remove instructions in the current block, but
// may add instructions to the current loop's preheader.
//
// The required conditions for inserting a new dominating access are:
//
// 1. The new preheader access is not enclosed in another scope that doesn't
// also enclose the current scope.
//
// This is inferred from the loop structure; any scope that encloses the
// preheader must also enclose the entire loop.
//
// 2. The current access is not enclosed in another scope that doesn't also
// enclose the preheader.
//
// As before, it is sufficient to check this access' isInner flags in
// DominatedAccessAnalysis; if this access isn't enclosed by any scope within
// the function, then it can't be enclosed within a scope inside the loop.
//
// 3. The current header has no nested conflict within its scope.
//
// 4. The access' source operand is available in the loop preheader.
void DominatedAccessRemoval::tryInsertLoopPreheaderAccess(
BeginAccessInst *BAI, DomAccessedStorage currAccessInfo) {
// 2. the current access may be enclosed.
if (currAccessInfo.isInner())
return;
// 3. the current access must be instantaneous.
if (!BAI->hasNoNestedConflict())
return;
SILLoop *currLoop = loopInfo->getLoopFor(BAI->getParent());
if (!currLoop)
return;
SILBasicBlock *preheader = currLoop->getLoopPreheader();
if (!preheader)
return;
// 4. The source operand must be available in the preheader.
auto sourceOperand = BAI->getOperand();
auto *sourceBB = sourceOperand->getParentBlock();
if (!domInfo->dominates(sourceBB, preheader))
return;
// Insert a new access scope immediately before the
// preheader's terminator.
TermInst *preheaderTerm = preheader->getTerminator();
SILBuilderWithScope scopeBuilder(preheaderTerm);
BeginAccessInst *newBegin = scopeBuilder.createBeginAccess(
preheaderTerm->getLoc(), sourceOperand, BAI->getAccessKind(),
SILAccessEnforcement::Dynamic, true /*no nested conflict*/,
BAI->isFromBuiltin());
scopeBuilder.createEndAccess(preheaderTerm->getLoc(), newBegin, false);
LLVM_DEBUG(llvm::dbgs() << "Created loop preheader access: " << *newBegin
<< "\n"
<< "dominating: " << *BAI << "\n");
BAI->setEnforcement(SILAccessEnforcement::Static);
hasChanged = true;
// Insert the new dominating instruction in both DominatedAccessAnalysis and
// storageToDomMap if it has uniquely identifiable storage.
if (!currAccessInfo.isUniquelyIdentifiedOrClass())
return;
AccessedStorage storage = static_cast<AccessedStorage>(currAccessInfo);
storage.resetSubclassData();
// Create a DomAccessedStorage for the new access with no flags set.
DAA.accessMap.try_emplace(newBegin, DomAccessedStorage(storage));
// Track the new access as long as no other accesses from the same storage are
// already tracked. This also necessarily replaces the current access, which
// was just made static.
DominatingAccess newDomAccess(newBegin, domInfo->getNode(preheader));
auto iterAndInserted = storageToDomMap.try_emplace(storage, newDomAccess);
if (!iterAndInserted.second) {
DominatingAccess &curDomAccess = iterAndInserted.first->second;
if (curDomAccess.beginAccess == BAI)
curDomAccess = newDomAccess;
}
}
