6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-12 13:30:51 +00:00
Code Issues Projects Releases Wiki Activity

Delete the GEPSplitter experiment.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@126671 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dan Gohman 2011-02-28 19:47:47 +00:00
parent 1551abdea6
commit 00141694fa
5 changed files with 0 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/llvm/InitializePasses.h
View File

@ -99,7 +99,6 @@ void initializeExpandISelPseudosPass(PassRegistry&);
void initializeFindUsedTypesPass(PassRegistry&);
void initializeFunctionAttrsPass(PassRegistry&);
void initializeGCModuleInfoPass(PassRegistry&);
void initializeGEPSplitterPass(PassRegistry&);
void initializeGVNPass(PassRegistry&);
void initializeGlobalDCEPass(PassRegistry&);
void initializeGlobalOptPass(PassRegistry&);

1
include/llvm/LinkAllPasses.h
View File

@ -143,7 +143,6 @@ namespace {
(void) llvm::createDbgInfoPrinterPass();
(void) llvm::createModuleDebugInfoPrinterPass();
(void) llvm::createPartialInliningPass();
(void) llvm::createGEPSplitterPass();
(void) llvm::createLintPass();
(void) llvm::createSinkingPass();
(void) llvm::createLowerAtomicPass();

12
lib/CodeGen/LLVMTargetMachine.cpp
View File

@ -98,12 +98,6 @@ static cl::opt<cl::boolOrDefault>
EnableFastISelOption("fast-isel", cl::Hidden,
cl::desc("Enable the \"fast\" instruction selector"));
// Enable or disable an experimental optimization to split GEPs
// and run a special GVN pass which does not examine loads, in
// an effort to factor out redundancy implicit in complex GEPs.
static cl::opt<bool> EnableSplitGEPGVN("split-gep-gvn", cl::Hidden,
cl::desc("Split GEPs and run no-load GVN"));
LLVMTargetMachine::LLVMTargetMachine(const Target &T,
const std::string &Triple)
: TargetMachine(T), TargetTriple(Triple) {
@ -272,12 +266,6 @@ bool LLVMTargetMachine::addCommonCodeGenPasses(PassManagerBase &PM,
if (!DisableVerify)
PM.add(createVerifierPass());
// Optionally, tun split-GEPs and no-load GVN.
if (EnableSplitGEPGVN) {
PM.add(createGEPSplitterPass());
PM.add(createGVNPass(/*NoLoads=*/true));
}
// Run loop strength reduction before anything else.
if (OptLevel != CodeGenOpt::None && !DisableLSR) {
PM.add(createLoopStrengthReducePass(getTargetLowering()));

83
lib/Transforms/Scalar/GEPSplitter.cpp
View File

@ -1,83 +0,0 @@
//===- GEPSplitter.cpp - Split complex GEPs into simple ones --------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This function breaks GEPs with more than 2 non-zero operands into smaller
// GEPs each with no more than 2 non-zero operands. This exposes redundancy
// between GEPs with common initial operand sequences.
//
//===----------------------------------------------------------------------===//
#define DEBUG_TYPE "split-geps"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Constants.h"
#include "llvm/Function.h"
#include "llvm/Instructions.h"
#include "llvm/Pass.h"
using namespace llvm;
namespace {
class GEPSplitter : public FunctionPass {
virtual bool runOnFunction(Function &F);
virtual void getAnalysisUsage(AnalysisUsage &AU) const;
public:
static char ID; // Pass identification, replacement for typeid
explicit GEPSplitter() : FunctionPass(ID) {
initializeGEPSplitterPass(*PassRegistry::getPassRegistry());
}
};
}
char GEPSplitter::ID = 0;
INITIALIZE_PASS(GEPSplitter, "split-geps",
"split complex GEPs into simple GEPs", false, false)
FunctionPass *llvm::createGEPSplitterPass() {
return new GEPSplitter();
}
bool GEPSplitter::runOnFunction(Function &F) {
bool Changed = false;
// Visit each GEP instruction.
for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
for (BasicBlock::iterator II = I->begin(), IE = I->end(); II != IE; )
if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(II++)) {
unsigned NumOps = GEP->getNumOperands();
// Ignore GEPs which are already simple.
if (NumOps <= 2)
continue;
bool FirstIndexIsZero = isa<ConstantInt>(GEP->getOperand(1)) &&
cast<ConstantInt>(GEP->getOperand(1))->isZero();
if (NumOps == 3 && FirstIndexIsZero)
continue;
// The first index is special and gets expanded with a 2-operand GEP
// (unless it's zero, in which case we can skip this).
Value *NewGEP = FirstIndexIsZero ?
GEP->getOperand(0) :
GetElementPtrInst::Create(GEP->getOperand(0), GEP->getOperand(1),
"tmp", GEP);
// All remaining indices get expanded with a 3-operand GEP with zero
// as the second operand.
Value *Idxs[2];
Idxs[0] = ConstantInt::get(Type::getInt64Ty(F.getContext()), 0);
for (unsigned i = 2; i != NumOps; ++i) {
Idxs[1] = GEP->getOperand(i);
NewGEP = GetElementPtrInst::Create(NewGEP, Idxs, Idxs+2, "tmp", GEP);
}
GEP->replaceAllUsesWith(NewGEP);
GEP->eraseFromParent();
Changed = true;
}
return Changed;
}
void GEPSplitter::getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesCFG();
}

1
lib/Transforms/Scalar/Scalar.cpp
View File

@ -34,7 +34,6 @@ void llvm::initializeScalarOpts(PassRegistry &Registry) {
initializeDCEPass(Registry);
initializeDeadInstEliminationPass(Registry);
initializeDSEPass(Registry);
initializeGEPSplitterPass(Registry);
initializeGVNPass(Registry);
initializeEarlyCSEPass(Registry);
initializeIndVarSimplifyPass(Registry);