llvm-6502/include/llvm/Analysis/LiveValues.h
Dan Gohman 3751f564e3 Add a liveness analysis pass for LLVM IR values. This computes
the set of blocks in which values are used, the set in which
values are live-through, and the set in which values are
killed. For the live-through and killed sets, conservative
approximations are used.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@67309 91177308-0d34-0410-b5e6-96231b3b80d8
2009-03-19 17:29:04 +00:00

104 lines
3.1 KiB
C++

//===- LiveValues.h - Liveness information for LLVM IR Values. ------------===//
//
// 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 the LLVM IR Value liveness
// analysis pass.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_LIVEVALUES_H
#define LLVM_ANALYSIS_LIVEVALUES_H
#include "llvm/Pass.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallPtrSet.h"
namespace llvm {
class DominatorTree;
class LoopInfo;
class Value;
/// LiveValues - Analysis that provides liveness information for
/// LLVM IR Values.
///
class LiveValues : public FunctionPass {
DominatorTree *DT;
LoopInfo *LI;
/// Memo - A bunch of state to be associated with a value.
///
struct Memo {
/// Used - The set of blocks which contain a use of the value.
///
SmallPtrSet<const BasicBlock *, 4> Used;
/// LiveThrough - A conservative approximation of the set of blocks in
/// which the value is live-through, meaning blocks properly dominated
/// by the definition, and from which blocks containing uses of the
/// value are reachable.
///
SmallPtrSet<const BasicBlock *, 4> LiveThrough;
/// Killed - A conservative approximation of the set of blocks in which
/// the value is used and not live-out.
///
SmallPtrSet<const BasicBlock *, 4> Killed;
};
/// Memos - Remembers the Memo for each Value. This is populated on
/// demand.
///
DenseMap<const Value *, Memo> Memos;
/// getMemo - Retrieve an existing Memo for the given value if one
/// is available, otherwise compute a new one.
///
Memo &getMemo(const Value *V);
/// compute - Compute a new Memo for the given value.
///
Memo &compute(const Value *V);
public:
static char ID;
LiveValues();
virtual void getAnalysisUsage(AnalysisUsage &AU) const;
virtual bool runOnFunction(Function &F);
virtual void releaseMemory();
/// isUsedInBlock - Test if the given value is used in the given block.
///
bool isUsedInBlock(const Value *V, const BasicBlock *BB);
/// isLiveThroughBlock - Test if the given value is known to be
/// live-through the given block, meaning that the block is properly
/// dominated by the value's definition, and there exists a block
/// reachable from it that contains a use. This uses a conservative
/// approximation that errs on the side of returning false.
///
bool isLiveThroughBlock(const Value *V, const BasicBlock *BB);
/// isKilledInBlock - Test if the given value is known to be killed in
/// the given block, meaning that the block contains a use of the value,
/// and no blocks reachable from the block contain a use. This uses a
/// conservative approximation that errs on the side of returning false.
///
bool isKilledInBlock(const Value *V, const BasicBlock *BB);
};
/// createLiveValuesPass - This creates an instance of the LiveValues pass.
///
FunctionPass *createLiveValuesPass();
}
#endif