Files
swift-mirror/lib/SILOptimizer/UtilityPasses/EpilogueRetainReleaseMatcherDumper.cpp
Erik Eckstein d2fc6eb3b5 AliasAnalysis: make AliasAnalysis a function analysis and simplify the cache keys
Instead of caching alias results globally for the module, make AliasAnalysis a FunctionAnalysisBase which caches the alias results per function.
Why?
* So far the result caches could only grow. They were reset when they reached a certain size. This was not ideal. Now, they are invalidated whenever the function changes.
* It was not possible to actually invalidate an alias analysis result. This is required, for example in TempRValueOpt and TempLValueOpt (so far it was done manually with invalidateInstruction).
* Type based alias analysis results were also cached for the whole module, while it is actually dependent on the function, because it depends on the function's resilience expansion. This was a potential bug.

I also added a new PassManager API to directly get a function-base analysis:
    getAnalysis(SILFunction *f)

The second change of this commit is the removal of the instruction-index indirection for the cache keys. Now the cache keys directly work on instruction pointers instead of instruction indices. This reduces the number of hash table lookups for a cache lookup from 3 to 1.
This indirection was needed to avoid dangling instruction pointers in the cache keys. But this is not needed anymore, because of the new delayed instruction deletion mechanism.
2021-05-26 21:57:54 +02:00

78 lines
2.7 KiB
C++

//===--- EpilogueRetainReleaseMatcherDumper.cpp - Find Epilogue Releases --===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This pass finds the epilogue releases matched to each argument of the
/// function.
///
//===----------------------------------------------------------------------===//
#define DEBUG_TYPE "sil-epilogue-release-dumper"
#include "swift/SILOptimizer/PassManager/Passes.h"
#include "swift/SIL/SILArgument.h"
#include "swift/SIL/SILFunction.h"
#include "swift/SIL/SILValue.h"
#include "swift/SILOptimizer/Analysis/AliasAnalysis.h"
#include "swift/SILOptimizer/Analysis/ARCAnalysis.h"
#include "swift/SILOptimizer/Analysis/Analysis.h"
#include "swift/SILOptimizer/Analysis/RCIdentityAnalysis.h"
#include "swift/SILOptimizer/PassManager/Transforms.h"
using namespace swift;
//===----------------------------------------------------------------------===//
// Top Level Driver
//===----------------------------------------------------------------------===//
namespace {
/// Find and dump the epilogue release instructions for the arguments.
class SILEpilogueRetainReleaseMatcherDumper : public SILModuleTransform {
void run() override {
auto *RCIA = getAnalysis<RCIdentityAnalysis>();
for (auto &Fn: *getModule()) {
// Function is not definition.
if (!Fn.isDefinition())
continue;
auto *AA = PM->getAnalysis<AliasAnalysis>(&Fn);
llvm::outs() << "START: sil @" << Fn.getName() << "\n";
// Handle @owned return value.
ConsumedResultToEpilogueRetainMatcher RetMap(RCIA->get(&Fn), AA, &Fn);
for (auto &RI : RetMap)
llvm::outs() << *RI;
// Handle @owned function arguments.
ConsumedArgToEpilogueReleaseMatcher RelMap(RCIA->get(&Fn), &Fn);
// Iterate over arguments and dump their epilogue releases.
for (auto Arg : Fn.getArguments()) {
llvm::outs() << *Arg;
// Can not find an epilogue release instruction for the argument.
for (auto &RI : RelMap.getReleasesForArgument(Arg))
llvm::outs() << *RI;
}
llvm::outs() << "END: sil @" << Fn.getName() << "\n";
}
}
};
} // end anonymous namespace
SILTransform *swift::createEpilogueRetainReleaseMatcherDumper() {
return new SILEpilogueRetainReleaseMatcherDumper();
}