01859da84b
The pointsToConstantMemory() method returns true only if the memory pointed to by the memory location is globally invariant. However, the LLVM memory model also has the semantic notion of *locally-invariant*: memory that is known to be invariant for the life of the SSA value representing that pointer. The most common example of this is a pointer argument that is marked readonly noalias, which the Rust compiler frequently emits. It'd be desirable for LLVM to treat locally-invariant memory the same way as globally-invariant memory when it's safe to do so. This patch implements that, by introducing the concept of a *ModRefInfo mask*. A ModRefInfo mask is a bound on the Mod/Ref behavior of an instruction that writes to a memory location, based on the knowledge that the memory is globally-constant memory (in which case the mask is NoModRef) or locally-constant memory (in which case the mask is Ref). ModRefInfo values for an instruction can be combined with the ModRefInfo mask by simply using the & operator. Where appropriate, this patch has modified uses of pointsToConstantMemory() to instead examine the mask. The most notable optimization change I noticed with this patch is that now redundant loads from readonly noalias pointers can be eliminated across calls, even when the pointer is captured. Internally, before this patch, AliasAnalysis was assigning Ref to reads from constant memory; now AA can assign NoModRef, which is a tighter bound. Differential Revision: https://reviews.llvm.org/D136659
100 lines
3.0 KiB
C++
100 lines
3.0 KiB
C++
//===- AMDGPUAliasAnalysis --------------------------------------*- C++ -*-===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
/// \file
|
|
/// This is the AMGPU address space based alias analysis pass.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_LIB_TARGET_AMDGPU_AMDGPUALIASANALYSIS_H
|
|
#define LLVM_LIB_TARGET_AMDGPU_AMDGPUALIASANALYSIS_H
|
|
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
|
|
|
namespace llvm {
|
|
|
|
class DataLayout;
|
|
class MemoryLocation;
|
|
|
|
/// A simple AA result that uses TBAA metadata to answer queries.
|
|
class AMDGPUAAResult : public AAResultBase {
|
|
const DataLayout &DL;
|
|
|
|
public:
|
|
explicit AMDGPUAAResult(const DataLayout &DL) : DL(DL) {}
|
|
AMDGPUAAResult(AMDGPUAAResult &&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 &Inv) {
|
|
return false;
|
|
}
|
|
|
|
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
|
|
AAQueryInfo &AAQI);
|
|
ModRefInfo getModRefInfoMask(const MemoryLocation &Loc, AAQueryInfo &AAQI,
|
|
bool IgnoreLocals);
|
|
};
|
|
|
|
/// Analysis pass providing a never-invalidated alias analysis result.
|
|
class AMDGPUAA : public AnalysisInfoMixin<AMDGPUAA> {
|
|
friend AnalysisInfoMixin<AMDGPUAA>;
|
|
|
|
static AnalysisKey Key;
|
|
|
|
public:
|
|
using Result = AMDGPUAAResult;
|
|
|
|
AMDGPUAAResult run(Function &F, AnalysisManager<Function> &AM) {
|
|
return AMDGPUAAResult(F.getParent()->getDataLayout());
|
|
}
|
|
};
|
|
|
|
/// Legacy wrapper pass to provide the AMDGPUAAResult object.
|
|
class AMDGPUAAWrapperPass : public ImmutablePass {
|
|
std::unique_ptr<AMDGPUAAResult> Result;
|
|
|
|
public:
|
|
static char ID;
|
|
|
|
AMDGPUAAWrapperPass();
|
|
|
|
AMDGPUAAResult &getResult() { return *Result; }
|
|
const AMDGPUAAResult &getResult() const { return *Result; }
|
|
|
|
bool doInitialization(Module &M) override {
|
|
Result.reset(new AMDGPUAAResult(M.getDataLayout()));
|
|
return false;
|
|
}
|
|
|
|
bool doFinalization(Module &M) override {
|
|
Result.reset();
|
|
return false;
|
|
}
|
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override;
|
|
};
|
|
|
|
// Wrapper around ExternalAAWrapperPass so that the default constructor gets the
|
|
// callback.
|
|
class AMDGPUExternalAAWrapper : public ExternalAAWrapperPass {
|
|
public:
|
|
static char ID;
|
|
|
|
AMDGPUExternalAAWrapper() : ExternalAAWrapperPass(
|
|
[](Pass &P, Function &, AAResults &AAR) {
|
|
if (auto *WrapperPass = P.getAnalysisIfAvailable<AMDGPUAAWrapperPass>())
|
|
AAR.addAAResult(WrapperPass->getResult());
|
|
}) {}
|
|
};
|
|
|
|
} // end namespace llvm
|
|
|
|
#endif // LLVM_LIB_TARGET_AMDGPU_AMDGPUALIASANALYSIS_H
|