mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-23 11:13:28 +01:00
84780666b4
accept an Invalidator that allows them to invalidate themselves if their dependencies are in turn invalidated. Rather than recording the dependency graph ahead of time when analysis get results from other analyses, this simply lets each result trigger the immediate invalidation of any analyses they actually depend on. They do this in a way that has three nice properties: 1) They don't have to handle transitive dependencies because the infrastructure will recurse for them. 2) The invalidate methods are still called only once. We just dynamically discover the necessary topological ordering, everything is memoized nicely. 3) The infrastructure still provides a default implementation and can access it so that only analyses which have dependencies need to do anything custom. To make this work at all, the invalidation logic also has to defer the deletion of the result objects themselves so that they can remain alive until we have collected the complete set of results to invalidate. A unittest is added here that has exactly the dependency pattern we are concerned with. It hit the use-after-free described by Sean in much detail in the long thread about analysis invalidation before this change, and even in an intermediate form of this change where we failed to defer the deletion of the result objects. There is an important problem with doing dependency invalidation that *isn't* solved here: we don't *enforce* that results correctly invalidate all the analyses whose results they depend on. I actually looked at what it would take to do that, and it isn't as hard as I had thought but the complexity it introduces seems very likely to outweigh the benefit. The technique would be to provide a base class for an analysis result that would be populated with other results, and automatically provide the invalidate method which immediately does the correct thing. This approach has some nice pros IMO: - Handles the case we care about and nothing else: only *results* that depend on other analyses trigger extra invalidation. - Localized to the result rather than centralized in the analysis manager. - Ties the storage of the reference to another result to the triggering of the invalidation of that analysis. - Still supports extending invalidation in customized ways. But the down sides here are: - Very heavy-weight meta-programming is needed to provide this base class. - Requires a pretty awful API for accessing the dependencies. Ultimately, I fear it will not pull its weight. But we can re-evaluate this at any point if we start discovering consistent problems where the invalidation and dependencies get out of sync. It will fit as a clean layer on top of the facilities in this patch that we can add if and when we need it. Note that I'm not really thrilled with the names for these APIs... The name "Invalidator" seems ok but not great. The method name "invalidate" also. In review some improvements were suggested, but they really need *other* uses of these terms to be updated as well so I'm going to do that in a follow-up commit. I'm working on the actual fixes to various analyses that need to use these, but I want to try to get tests for each of them so we don't regress. And those changes are seperable and obvious so once this goes in I should be able to roll them out throughout LLVM. Many thanks to Sean, Justin, and others for help reviewing here. Differential Revision: https://reviews.llvm.org/D23738 llvm-svn: 288077
98 lines
3.2 KiB
C++
98 lines
3.2 KiB
C++
//===- ObjCARCAliasAnalysis.h - ObjC ARC Alias Analysis ---------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
/// \file
|
|
/// This file declares a simple ARC-aware AliasAnalysis using special knowledge
|
|
/// of Objective C to enhance other optimization passes which rely on the Alias
|
|
/// Analysis infrastructure.
|
|
///
|
|
/// WARNING: This file knows about certain library functions. It recognizes them
|
|
/// by name, and hardwires knowledge of their semantics.
|
|
///
|
|
/// WARNING: This file knows about how certain Objective-C library functions are
|
|
/// used. Naive LLVM IR transformations which would otherwise be
|
|
/// behavior-preserving may break these assumptions.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_ANALYSIS_OBJCARCALIASANALYSIS_H
|
|
#define LLVM_ANALYSIS_OBJCARCALIASANALYSIS_H
|
|
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
|
#include "llvm/Pass.h"
|
|
|
|
namespace llvm {
|
|
namespace objcarc {
|
|
|
|
/// \brief This is a simple alias analysis implementation that uses knowledge
|
|
/// of ARC constructs to answer queries.
|
|
///
|
|
/// TODO: This class could be generalized to know about other ObjC-specific
|
|
/// tricks. Such as knowing that ivars in the non-fragile ABI are non-aliasing
|
|
/// even though their offsets are dynamic.
|
|
class ObjCARCAAResult : public AAResultBase<ObjCARCAAResult> {
|
|
friend AAResultBase<ObjCARCAAResult>;
|
|
|
|
const DataLayout &DL;
|
|
|
|
public:
|
|
explicit ObjCARCAAResult(const DataLayout &DL) : AAResultBase(), DL(DL) {}
|
|
ObjCARCAAResult(ObjCARCAAResult &&Arg)
|
|
: AAResultBase(std::move(Arg)), DL(Arg.DL) {}
|
|
|
|
/// Handle invalidation events from the new pass manager.
|
|
///
|
|
/// By definition, this result is stateless and so remains valid.
|
|
bool invalidate(Function &, const PreservedAnalyses &,
|
|
FunctionAnalysisManager::Invalidator &) {
|
|
return false;
|
|
}
|
|
|
|
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB);
|
|
bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal);
|
|
|
|
using AAResultBase::getModRefBehavior;
|
|
FunctionModRefBehavior getModRefBehavior(const Function *F);
|
|
|
|
using AAResultBase::getModRefInfo;
|
|
ModRefInfo getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc);
|
|
};
|
|
|
|
/// Analysis pass providing a never-invalidated alias analysis result.
|
|
class ObjCARCAA : public AnalysisInfoMixin<ObjCARCAA> {
|
|
friend AnalysisInfoMixin<ObjCARCAA>;
|
|
static AnalysisKey Key;
|
|
|
|
public:
|
|
typedef ObjCARCAAResult Result;
|
|
|
|
ObjCARCAAResult run(Function &F, FunctionAnalysisManager &AM);
|
|
};
|
|
|
|
/// Legacy wrapper pass to provide the ObjCARCAAResult object.
|
|
class ObjCARCAAWrapperPass : public ImmutablePass {
|
|
std::unique_ptr<ObjCARCAAResult> Result;
|
|
|
|
public:
|
|
static char ID;
|
|
|
|
ObjCARCAAWrapperPass();
|
|
|
|
ObjCARCAAResult &getResult() { return *Result; }
|
|
const ObjCARCAAResult &getResult() const { return *Result; }
|
|
|
|
bool doInitialization(Module &M) override;
|
|
bool doFinalization(Module &M) override;
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override;
|
|
};
|
|
|
|
} // namespace objcarc
|
|
} // namespace llvm
|
|
|
|
#endif
|