6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-09-16 14:26:17 +00:00
Code Issues Projects Releases Wiki Activity

Rename BlockFrequency to BlockFrequencyInfo and MachineBlockFrequency to

Browse Source 
MachineBlockFrequencyInfo.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@135937 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Jakub Staszak
2011-07-25 19:25:40 +00:00
parent 8c3fee5903
commit f55c1c8588
10 changed files with 44 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
include/llvm/Analysis/BlockFrequencyImpl.h
View File

@@ -29,8 +29,8 @@
namespace llvm { namespace llvm {
class BlockFrequency; class BlockFrequencyInfo;
class MachineBlockFrequency; class MachineBlockFrequencyInfo;
/// BlockFrequencyImpl implements block frequency algorithm for IR and /// BlockFrequencyImpl implements block frequency algorithm for IR and
/// Machine Instructions. Algorithm starts with value 1024 (START_FREQ) /// Machine Instructions. Algorithm starts with value 1024 (START_FREQ)
@@ -263,8 +263,8 @@ class BlockFrequencyImpl {
} }
} }
friend class BlockFrequency; friend class BlockFrequencyInfo;
friend class MachineBlockFrequency; friend class MachineBlockFrequencyInfo;
void doFunction(FunctionT *fn, BlockProbInfoT *bpi) { void doFunction(FunctionT *fn, BlockProbInfoT *bpi) {
Fn = fn; Fn = fn;

14
include/llvm/Analysis/BlockFrequency.h → include/llvm/Analysis/BlockFrequencyInfo.h
View File

@@ -1,4 +1,4 @@
//========-------- BlockFrequency.h - Block Frequency Analysis -------========// //========-------- BlockFrequencyInfo.h - Block Frequency Analysis -------========//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
@@ -11,8 +11,8 @@
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_BLOCKFREQUENCY_H #ifndef LLVM_ANALYSIS_BLOCKFREQUENCYINFO_H
#define LLVM_ANALYSIS_BLOCKFREQUENCY_H #define LLVM_ANALYSIS_BLOCKFREQUENCYINFO_H
#include "llvm/Pass.h" #include "llvm/Pass.h"
#include <climits> #include <climits>
@@ -23,18 +23,18 @@ class BranchProbabilityInfo;
template<class BlockT, class FunctionT, class BranchProbInfoT> template<class BlockT, class FunctionT, class BranchProbInfoT>
class BlockFrequencyImpl; class BlockFrequencyImpl;
/// BlockFrequency pass uses BlockFrequencyImpl implementation to estimate /// BlockFrequencyInfo pass uses BlockFrequencyImpl implementation to estimate
/// IR basic block frequencies. /// IR basic block frequencies.
class BlockFrequency : public FunctionPass { class BlockFrequencyInfo : public FunctionPass {
BlockFrequencyImpl<BasicBlock, Function, BranchProbabilityInfo> *BFI; BlockFrequencyImpl<BasicBlock, Function, BranchProbabilityInfo> *BFI;
public: public:
static char ID; static char ID;
BlockFrequency(); BlockFrequencyInfo();
~BlockFrequency(); ~BlockFrequencyInfo();
void getAnalysisUsage(AnalysisUsage &AU) const; void getAnalysisUsage(AnalysisUsage &AU) const;

10
include/llvm/CodeGen/MachineBlockFrequency.h → include/llvm/CodeGen/MachineBlockFrequencyInfo.h
View File

@@ -1,4 +1,4 @@
//====----- MachineBlockFrequency.h - MachineBlock Frequency Analysis ----====// //====----- MachineBlockFrequencyInfo.h - MachineBlock Frequency Analysis ----====//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
@@ -23,18 +23,18 @@ class MachineBranchProbabilityInfo;
template<class BlockT, class FunctionT, class BranchProbInfoT> template<class BlockT, class FunctionT, class BranchProbInfoT>
class BlockFrequencyImpl; class BlockFrequencyImpl;
/// MachineBlockFrequency pass uses BlockFrequencyImpl implementation to estimate /// MachineBlockFrequencyInfo pass uses BlockFrequencyImpl implementation to estimate
/// machine basic block frequencies. /// machine basic block frequencies.
class MachineBlockFrequency : public MachineFunctionPass { class MachineBlockFrequencyInfo : public MachineFunctionPass {
BlockFrequencyImpl<MachineBasicBlock, MachineFunction, MachineBranchProbabilityInfo> *MBFI; BlockFrequencyImpl<MachineBasicBlock, MachineFunction, MachineBranchProbabilityInfo> *MBFI;
public: public:
static char ID; static char ID;
MachineBlockFrequency(); MachineBlockFrequencyInfo();
~MachineBlockFrequency(); ~MachineBlockFrequencyInfo();
void getAnalysisUsage(AnalysisUsage &AU) const; void getAnalysisUsage(AnalysisUsage &AU) const;

4
include/llvm/InitializePasses.h
View File

@@ -65,7 +65,7 @@ void initializeArgPromotionPass(PassRegistry&);
void initializeBasicAliasAnalysisPass(PassRegistry&); void initializeBasicAliasAnalysisPass(PassRegistry&);
void initializeBasicCallGraphPass(PassRegistry&); void initializeBasicCallGraphPass(PassRegistry&);
void initializeBlockExtractorPassPass(PassRegistry&); void initializeBlockExtractorPassPass(PassRegistry&);
void initializeBlockFrequencyPass(PassRegistry&); void initializeBlockFrequencyInfoPass(PassRegistry&);
void initializeBlockPlacementPass(PassRegistry&); void initializeBlockPlacementPass(PassRegistry&);
void initializeBranchProbabilityInfoPass(PassRegistry&); void initializeBranchProbabilityInfoPass(PassRegistry&);
void initializeBreakCriticalEdgesPass(PassRegistry&); void initializeBreakCriticalEdgesPass(PassRegistry&);
@@ -145,7 +145,7 @@ void initializeLowerIntrinsicsPass(PassRegistry&);
void initializeLowerInvokePass(PassRegistry&); void initializeLowerInvokePass(PassRegistry&);
void initializeLowerSetJmpPass(PassRegistry&); void initializeLowerSetJmpPass(PassRegistry&);
void initializeLowerSwitchPass(PassRegistry&); void initializeLowerSwitchPass(PassRegistry&);
void initializeMachineBlockFrequencyPass(PassRegistry&); void initializeMachineBlockFrequencyInfoPass(PassRegistry&);
void initializeMachineBranchProbabilityInfoPass(PassRegistry&); void initializeMachineBranchProbabilityInfoPass(PassRegistry&);
void initializeMachineCSEPass(PassRegistry&); void initializeMachineCSEPass(PassRegistry&);
void initializeMachineDominatorTreePass(PassRegistry&); void initializeMachineDominatorTreePass(PassRegistry&);

2
lib/Analysis/Analysis.cpp
View File

@@ -23,7 +23,7 @@ void llvm::initializeAnalysis(PassRegistry &Registry) {
initializeAliasSetPrinterPass(Registry); initializeAliasSetPrinterPass(Registry);
initializeNoAAPass(Registry); initializeNoAAPass(Registry);
initializeBasicAliasAnalysisPass(Registry); initializeBasicAliasAnalysisPass(Registry);
initializeBlockFrequencyPass(Registry); initializeBlockFrequencyInfoPass(Registry);
initializeBranchProbabilityInfoPass(Registry); initializeBranchProbabilityInfoPass(Registry);
initializeCFGViewerPass(Registry); initializeCFGViewerPass(Registry);
initializeCFGPrinterPass(Registry); initializeCFGPrinterPass(Registry);

22
lib/Analysis/BlockFrequency.cpp → lib/Analysis/BlockFrequencyInfo.cpp
View File

@@ -1,4 +1,4 @@
//=======-------- BlockFrequency.cpp - Block Frequency Analysis -------=======// //=======-------- BlockFrequencyInfo.cpp - Block Frequency Analysis -------=======//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
@@ -13,37 +13,37 @@
#include "llvm/InitializePasses.h" #include "llvm/InitializePasses.h"
#include "llvm/Analysis/BlockFrequencyImpl.h" #include "llvm/Analysis/BlockFrequencyImpl.h"
#include "llvm/Analysis/BlockFrequency.h" #include "llvm/Analysis/BlockFrequencyInfo.h"
#include "llvm/Analysis/LoopInfo.h" #include "llvm/Analysis/LoopInfo.h"
#include "llvm/Analysis/Passes.h" #include "llvm/Analysis/Passes.h"
#include "llvm/Analysis/BranchProbabilityInfo.h" #include "llvm/Analysis/BranchProbabilityInfo.h"
using namespace llvm; using namespace llvm;
INITIALIZE_PASS_BEGIN(BlockFrequency, "block-freq", "Block Frequency Analysis", INITIALIZE_PASS_BEGIN(BlockFrequencyInfo, "block-freq", "Block Frequency Analysis",
true, true) true, true)
INITIALIZE_PASS_DEPENDENCY(BranchProbabilityInfo) INITIALIZE_PASS_DEPENDENCY(BranchProbabilityInfo)
INITIALIZE_PASS_END(BlockFrequency, "block-freq", "Block Frequency Analysis", INITIALIZE_PASS_END(BlockFrequencyInfo, "block-freq", "Block Frequency Analysis",
true, true) true, true)
char BlockFrequency::ID = 0; char BlockFrequencyInfo::ID = 0;
BlockFrequency::BlockFrequency() : FunctionPass(ID) { BlockFrequencyInfo::BlockFrequencyInfo() : FunctionPass(ID) {
initializeBlockFrequencyPass(*PassRegistry::getPassRegistry()); initializeBlockFrequencyInfoPass(*PassRegistry::getPassRegistry());
BFI = new BlockFrequencyImpl<BasicBlock, Function, BranchProbabilityInfo>(); BFI = new BlockFrequencyImpl<BasicBlock, Function, BranchProbabilityInfo>();
} }
BlockFrequency::~BlockFrequency() { BlockFrequencyInfo::~BlockFrequencyInfo() {
delete BFI; delete BFI;
} }
void BlockFrequency::getAnalysisUsage(AnalysisUsage &AU) const { void BlockFrequencyInfo::getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<BranchProbabilityInfo>(); AU.addRequired<BranchProbabilityInfo>();
AU.setPreservesAll(); AU.setPreservesAll();
} }
bool BlockFrequency::runOnFunction(Function &F) { bool BlockFrequencyInfo::runOnFunction(Function &F) {
BranchProbabilityInfo &BPI = getAnalysis<BranchProbabilityInfo>(); BranchProbabilityInfo &BPI = getAnalysis<BranchProbabilityInfo>();
BFI->doFunction(&F, &BPI); BFI->doFunction(&F, &BPI);
return false; return false;
@@ -54,6 +54,6 @@ bool BlockFrequency::runOnFunction(Function &F) {
/// that we should not rely on the value itself, but only on the comparison to /// that we should not rely on the value itself, but only on the comparison to
/// the other block frequencies. We do this to avoid using of floating points. /// the other block frequencies. We do this to avoid using of floating points.
/// ///
uint32_t BlockFrequency::getBlockFreq(BasicBlock *BB) { uint32_t BlockFrequencyInfo::getBlockFreq(BasicBlock *BB) {
return BFI->getBlockFreq(BB); return BFI->getBlockFreq(BB);
} }

2
lib/Analysis/CMakeLists.txt
View File

@@ -6,7 +6,7 @@ add_llvm_library(LLVMAnalysis
AliasSetTracker.cpp AliasSetTracker.cpp
Analysis.cpp Analysis.cpp
BasicAliasAnalysis.cpp BasicAliasAnalysis.cpp
BlockFrequency.cpp BlockFrequencyInfo.cpp
BranchProbabilityInfo.cpp BranchProbabilityInfo.cpp
CFGPrinter.cpp CFGPrinter.cpp
CaptureTracking.cpp CaptureTracking.cpp

2
lib/CodeGen/CMakeLists.txt
View File

@@ -33,7 +33,7 @@ add_llvm_library(LLVMCodeGen
LocalStackSlotAllocation.cpp LocalStackSlotAllocation.cpp
LowerSubregs.cpp LowerSubregs.cpp
MachineBasicBlock.cpp MachineBasicBlock.cpp
MachineBlockFrequency.cpp MachineBlockFrequencyInfo.cpp
MachineBranchProbabilityInfo.cpp MachineBranchProbabilityInfo.cpp
MachineCSE.cpp MachineCSE.cpp
MachineDominators.cpp MachineDominators.cpp

1
lib/CodeGen/CodeGen.cpp
View File

@@ -27,6 +27,7 @@ void llvm::initializeCodeGen(PassRegistry &Registry) {
initializeLiveIntervalsPass(Registry); initializeLiveIntervalsPass(Registry);
initializeLiveStacksPass(Registry); initializeLiveStacksPass(Registry);
initializeLiveVariablesPass(Registry); initializeLiveVariablesPass(Registry);
initializeMachineBlockFrequencyInfoPass(Registry);
initializeMachineCSEPass(Registry); initializeMachineCSEPass(Registry);
initializeMachineDominatorTreePass(Registry); initializeMachineDominatorTreePass(Registry);
initializeMachineLICMPass(Registry); initializeMachineLICMPass(Registry);

22
lib/CodeGen/MachineBlockFrequency.cpp → lib/CodeGen/MachineBlockFrequencyInfo.cpp
View File

@@ -1,4 +1,4 @@
//====----- MachineBlockFrequency.cpp - Machine Block Frequency Analysis ----====// //====----- MachineBlockFrequencyInfo.cpp - Machine Block Frequency Analysis ----====//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
@@ -13,38 +13,38 @@
#include "llvm/InitializePasses.h" #include "llvm/InitializePasses.h"
#include "llvm/Analysis/BlockFrequencyImpl.h" #include "llvm/Analysis/BlockFrequencyImpl.h"
#include "llvm/CodeGen/MachineBlockFrequency.h" #include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
#include "llvm/CodeGen/Passes.h" #include "llvm/CodeGen/Passes.h"
#include "llvm/CodeGen/MachineBranchProbabilityInfo.h" #include "llvm/CodeGen/MachineBranchProbabilityInfo.h"
using namespace llvm; using namespace llvm;
INITIALIZE_PASS_BEGIN(MachineBlockFrequency, "machine-block-freq", INITIALIZE_PASS_BEGIN(MachineBlockFrequencyInfo, "machine-block-freq",
"Machine Block Frequency Analysis", true, true) "Machine Block Frequency Analysis", true, true)
INITIALIZE_PASS_DEPENDENCY(MachineBranchProbabilityInfo) INITIALIZE_PASS_DEPENDENCY(MachineBranchProbabilityInfo)
INITIALIZE_PASS_END(MachineBlockFrequency, "machine-block-freq", INITIALIZE_PASS_END(MachineBlockFrequencyInfo, "machine-block-freq",
"Machine Block Frequency Analysis", true, true) "Machine Block Frequency Analysis", true, true)
char MachineBlockFrequency::ID = 0; char MachineBlockFrequencyInfo::ID = 0;
MachineBlockFrequency::MachineBlockFrequency() : MachineFunctionPass(ID) { MachineBlockFrequencyInfo::MachineBlockFrequencyInfo() : MachineFunctionPass(ID) {
initializeMachineBlockFrequencyPass(*PassRegistry::getPassRegistry()); initializeMachineBlockFrequencyInfoPass(*PassRegistry::getPassRegistry());
MBFI = new BlockFrequencyImpl<MachineBasicBlock, MachineFunction, MBFI = new BlockFrequencyImpl<MachineBasicBlock, MachineFunction,
MachineBranchProbabilityInfo>(); MachineBranchProbabilityInfo>();
} }
MachineBlockFrequency::~MachineBlockFrequency() { MachineBlockFrequencyInfo::~MachineBlockFrequencyInfo() {
delete MBFI; delete MBFI;
} }
void MachineBlockFrequency::getAnalysisUsage(AnalysisUsage &AU) const { void MachineBlockFrequencyInfo::getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<MachineBranchProbabilityInfo>(); AU.addRequired<MachineBranchProbabilityInfo>();
AU.setPreservesAll(); AU.setPreservesAll();
MachineFunctionPass::getAnalysisUsage(AU); MachineFunctionPass::getAnalysisUsage(AU);
} }
bool MachineBlockFrequency::runOnMachineFunction(MachineFunction &F) { bool MachineBlockFrequencyInfo::runOnMachineFunction(MachineFunction &F) {
MachineBranchProbabilityInfo &MBPI = getAnalysis<MachineBranchProbabilityInfo>(); MachineBranchProbabilityInfo &MBPI = getAnalysis<MachineBranchProbabilityInfo>();
MBFI->doFunction(&F, &MBPI); MBFI->doFunction(&F, &MBPI);
return false; return false;
@@ -55,6 +55,6 @@ bool MachineBlockFrequency::runOnMachineFunction(MachineFunction &F) {
/// that we should not rely on the value itself, but only on the comparison to /// that we should not rely on the value itself, but only on the comparison to
/// the other block frequencies. We do this to avoid using of floating points. /// the other block frequencies. We do this to avoid using of floating points.
/// ///
uint32_t MachineBlockFrequency::getBlockFreq(MachineBasicBlock *MBB) { uint32_t MachineBlockFrequencyInfo::getBlockFreq(MachineBasicBlock *MBB) {
return MBFI->getBlockFreq(MBB); return MBFI->getBlockFreq(MBB);
} }