mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-02-08 06:32:24 +00:00
5a9cd4d44e
a cache of assumptions for a single function, and an immutable pass that manages those caches. The motivation for this change is two fold. Immutable analyses are really hacks around the current pass manager design and don't exist in the new design. This is usually OK, but it requires that the core logic of an immutable pass be reasonably partitioned off from the pass logic. This change does precisely that. As a consequence it also paves the way for the *many* utility functions that deal in the assumptions to live in both pass manager worlds by creating an separate non-pass object with its own independent API that they all rely on. Now, the only bits of the system that deal with the actual pass mechanics are those that actually need to deal with the pass mechanics. Once this separation is made, several simplifications become pretty obvious in the assumption cache itself. Rather than using a set and callback value handles, it can just be a vector of weak value handles. The callers can easily skip the handles that are null, and eventually we can wrap all of this up behind a filter iterator. For now, this adds boiler plate to the various passes, but this kind of boiler plate will end up making it possible to port these passes to the new pass manager, and so it will end up factored away pretty reasonably. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@225131 91177308-0d34-0410-b5e6-96231b3b80d8
94 lines
3.2 KiB
C++
94 lines
3.2 KiB
C++
//===- LazyValueInfo.h - Value constraint analysis --------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the interface for lazy computation of value constraint
|
|
// information.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_ANALYSIS_LAZYVALUEINFO_H
|
|
#define LLVM_ANALYSIS_LAZYVALUEINFO_H
|
|
|
|
#include "llvm/Pass.h"
|
|
|
|
namespace llvm {
|
|
class AssumptionCache;
|
|
class Constant;
|
|
class DataLayout;
|
|
class DominatorTree;
|
|
class Instruction;
|
|
class TargetLibraryInfo;
|
|
class Value;
|
|
|
|
/// LazyValueInfo - This pass computes, caches, and vends lazy value constraint
|
|
/// information.
|
|
class LazyValueInfo : public FunctionPass {
|
|
AssumptionCache *AC;
|
|
const DataLayout *DL;
|
|
class TargetLibraryInfo *TLI;
|
|
DominatorTree *DT;
|
|
void *PImpl;
|
|
LazyValueInfo(const LazyValueInfo&) LLVM_DELETED_FUNCTION;
|
|
void operator=(const LazyValueInfo&) LLVM_DELETED_FUNCTION;
|
|
public:
|
|
static char ID;
|
|
LazyValueInfo() : FunctionPass(ID), PImpl(nullptr) {
|
|
initializeLazyValueInfoPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
~LazyValueInfo() { assert(!PImpl && "releaseMemory not called"); }
|
|
|
|
/// Tristate - This is used to return true/false/dunno results.
|
|
enum Tristate {
|
|
Unknown = -1, False = 0, True = 1
|
|
};
|
|
|
|
|
|
// Public query interface.
|
|
|
|
/// getPredicateOnEdge - Determine whether the specified value comparison
|
|
/// with a constant is known to be true or false on the specified CFG edge.
|
|
/// Pred is a CmpInst predicate.
|
|
Tristate getPredicateOnEdge(unsigned Pred, Value *V, Constant *C,
|
|
BasicBlock *FromBB, BasicBlock *ToBB,
|
|
Instruction *CxtI = nullptr);
|
|
|
|
/// getPredicateAt - Determine whether the specified value comparison
|
|
/// with a constant is known to be true or false at the specified instruction
|
|
/// (from an assume intrinsic). Pred is a CmpInst predicate.
|
|
Tristate getPredicateAt(unsigned Pred, Value *V, Constant *C,
|
|
Instruction *CxtI);
|
|
|
|
/// getConstant - Determine whether the specified value is known to be a
|
|
/// constant at the end of the specified block. Return null if not.
|
|
Constant *getConstant(Value *V, BasicBlock *BB, Instruction *CxtI = nullptr);
|
|
|
|
/// getConstantOnEdge - Determine whether the specified value is known to be a
|
|
/// constant on the specified edge. Return null if not.
|
|
Constant *getConstantOnEdge(Value *V, BasicBlock *FromBB, BasicBlock *ToBB,
|
|
Instruction *CxtI = nullptr);
|
|
|
|
/// threadEdge - Inform the analysis cache that we have threaded an edge from
|
|
/// PredBB to OldSucc to be from PredBB to NewSucc instead.
|
|
void threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc, BasicBlock *NewSucc);
|
|
|
|
/// eraseBlock - Inform the analysis cache that we have erased a block.
|
|
void eraseBlock(BasicBlock *BB);
|
|
|
|
// Implementation boilerplate.
|
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override;
|
|
void releaseMemory() override;
|
|
bool runOnFunction(Function &F) override;
|
|
};
|
|
|
|
} // end namespace llvm
|
|
|
|
#endif
|
|
|