summaryrefslogtreecommitdiffstats
path: root/llvm
diff options
context:
space:
mode:
Diffstat (limited to 'llvm')
-rw-r--r--llvm/include/llvm/Transforms/FunctionInlining.h4
-rw-r--r--llvm/include/llvm/Transforms/Scalar/ConstantProp.h4
-rw-r--r--llvm/include/llvm/Transforms/Scalar/DCE.h4
-rw-r--r--llvm/include/llvm/Transforms/Scalar/SymbolStripping.h3
-rw-r--r--llvm/lib/Analysis/Expressions.cpp3
-rw-r--r--llvm/lib/Makefile2
-rw-r--r--llvm/lib/Transforms/ExprTypeConvert.cpp8
-rw-r--r--llvm/lib/Transforms/IPO/InlineSimple.cpp17
-rw-r--r--llvm/lib/Transforms/LevelRaise.cpp10
-rw-r--r--llvm/lib/Transforms/Scalar/ADCE.cpp4
-rw-r--r--llvm/lib/Transforms/Scalar/ConstantProp.cpp25
-rw-r--r--llvm/lib/Transforms/Scalar/DCE.cpp16
-rw-r--r--llvm/lib/Transforms/Scalar/InductionVars.cpp2
-rw-r--r--llvm/lib/Transforms/Scalar/InstructionCombining.cpp6
-rw-r--r--llvm/lib/Transforms/Scalar/SCCP.cpp19
-rw-r--r--llvm/lib/Transforms/Scalar/SymbolStripping.cpp6
-rw-r--r--llvm/lib/VMCore/ConstantHandling.cpp2
-rw-r--r--llvm/tools/gccas/gccas.cpp6
-rw-r--r--llvm/tools/opt/opt.cpp24
19 files changed, 73 insertions, 92 deletions
diff --git a/llvm/include/llvm/Transforms/FunctionInlining.h b/llvm/include/llvm/Transforms/FunctionInlining.h
index abc08fdbadf..252489749e9 100644
--- a/llvm/include/llvm/Transforms/FunctionInlining.h
+++ b/llvm/include/llvm/Transforms/FunctionInlining.h
@@ -11,8 +11,6 @@
#include "llvm/BasicBlock.h"
class CallInst;
-namespace opt {
-
struct MethodInlining : public MethodPass {
// DoMethodInlining - Use a heuristic based approach to inline methods that
// seem to look good.
@@ -37,6 +35,4 @@ struct MethodInlining : public MethodPass {
bool InlineMethod(CallInst *C);
bool InlineMethod(BasicBlock::iterator CI); // *CI must be CallInst
-} // end namespace opt
-
#endif
diff --git a/llvm/include/llvm/Transforms/Scalar/ConstantProp.h b/llvm/include/llvm/Transforms/Scalar/ConstantProp.h
index f4418665f9d..d9adf3f399a 100644
--- a/llvm/include/llvm/Transforms/Scalar/ConstantProp.h
+++ b/llvm/include/llvm/Transforms/Scalar/ConstantProp.h
@@ -10,8 +10,6 @@
#include "llvm/Pass.h"
class TerminatorInst;
-namespace opt {
-
struct ConstantPropogation : public MethodPass {
// doConstantPropogation - Do trivial constant propogation and expression
// folding
@@ -47,6 +45,4 @@ struct SCCPPass : public MethodPass {
}
};
-} // End Namespace opt
-
#endif
diff --git a/llvm/include/llvm/Transforms/Scalar/DCE.h b/llvm/include/llvm/Transforms/Scalar/DCE.h
index 0e9c620548d..bc498c34a76 100644
--- a/llvm/include/llvm/Transforms/Scalar/DCE.h
+++ b/llvm/include/llvm/Transforms/Scalar/DCE.h
@@ -11,8 +11,6 @@
#include "llvm/Pass.h"
#include "llvm/BasicBlock.h"
-namespace opt {
-
struct DeadCodeElimination : public MethodPass {
// External Interface:
//
@@ -66,6 +64,4 @@ struct AgressiveDCE : public MethodPass {
//
bool SimplifyCFG(Method::iterator &BBIt);
-} // End namespace opt
-
#endif
diff --git a/llvm/include/llvm/Transforms/Scalar/SymbolStripping.h b/llvm/include/llvm/Transforms/Scalar/SymbolStripping.h
index ff31a4b5323..156e21171f2 100644
--- a/llvm/include/llvm/Transforms/Scalar/SymbolStripping.h
+++ b/llvm/include/llvm/Transforms/Scalar/SymbolStripping.h
@@ -10,8 +10,6 @@
#include "llvm/Pass.h"
-namespace opt {
-
struct SymbolStripping : public MethodPass {
// doSymbolStripping - Remove all symbolic information from a method
//
@@ -38,5 +36,4 @@ struct FullSymbolStripping : public MethodPass {
}
};
-} // End namespace opt
#endif
diff --git a/llvm/lib/Analysis/Expressions.cpp b/llvm/lib/Analysis/Expressions.cpp
index e94c7960596..8fdfba6ada6 100644
--- a/llvm/lib/Analysis/Expressions.cpp
+++ b/llvm/lib/Analysis/Expressions.cpp
@@ -8,12 +8,11 @@
//===----------------------------------------------------------------------===//
#include "llvm/Analysis/Expressions.h"
-#include "llvm/Optimizations/ConstantHandling.h"
+#include "llvm/Transforms/Scalar/ConstantHandling.h"
#include "llvm/Method.h"
#include "llvm/BasicBlock.h"
#include <iostream>
-using namespace opt; // Get all the constant handling stuff
using namespace analysis;
ExprType::ExprType(Value *Val) {
diff --git a/llvm/lib/Makefile b/llvm/lib/Makefile
index 5ff4f16e62f..3ec77717007 100644
--- a/llvm/lib/Makefile
+++ b/llvm/lib/Makefile
@@ -1,5 +1,5 @@
LEVEL = ..
-DIRS = VMCore Analysis Transforms Assembly Bytecode Optimizations Support CodeGen Target
+DIRS = VMCore Analysis Transforms Assembly Bytecode Support CodeGen Target
include $(LEVEL)/Makefile.common
diff --git a/llvm/lib/Transforms/ExprTypeConvert.cpp b/llvm/lib/Transforms/ExprTypeConvert.cpp
index 7f33fe280b8..d75a8ac68cb 100644
--- a/llvm/lib/Transforms/ExprTypeConvert.cpp
+++ b/llvm/lib/Transforms/ExprTypeConvert.cpp
@@ -12,8 +12,8 @@
#include "llvm/iPHINode.h"
#include "llvm/iMemory.h"
#include "llvm/ConstantVals.h"
-#include "llvm/Optimizations/ConstantHandling.h"
-#include "llvm/Optimizations/DCE.h"
+#include "llvm/Transforms/Scalar/ConstantHandling.h"
+#include "llvm/Transforms/Scalar/DCE.h"
#include "llvm/Analysis/Expressions.h"
#include "Support/STLExtras.h"
#include <map>
@@ -190,7 +190,7 @@ bool ExpressionConvertableToType(Value *V, const Type *Ty,
// it can convert the value...
//
if (Constant *CPV = dyn_cast<Constant>(V))
- if (opt::ConstantFoldCastInstruction(CPV, Ty))
+ if (ConstantFoldCastInstruction(CPV, Ty))
return true; // Don't worry about deallocating, it's a constant.
return false; // Otherwise, we can't convert!
@@ -369,7 +369,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) {
if (Constant *CPV = cast<Constant>(V)) {
// Constants are converted by constant folding the cast that is required.
// We assume here that all casts are implemented for constant prop.
- Value *Result = opt::ConstantFoldCastInstruction(CPV, Ty);
+ Value *Result = ConstantFoldCastInstruction(CPV, Ty);
assert(Result && "ConstantFoldCastInstruction Failed!!!");
assert(Result->getType() == Ty && "Const prop of cast failed!");
diff --git a/llvm/lib/Transforms/IPO/InlineSimple.cpp b/llvm/lib/Transforms/IPO/InlineSimple.cpp
index 9d86c868953..a71acd2a79f 100644
--- a/llvm/lib/Transforms/IPO/InlineSimple.cpp
+++ b/llvm/lib/Transforms/IPO/InlineSimple.cpp
@@ -9,17 +9,16 @@
// . Has a smart heuristic for when to inline a method
//
// Notice that:
-// * This pass has a habit of introducing duplicated constant pool entries,
-// and also opens up a lot of opportunities for constant propogation. It is
-// a good idea to to run a constant propogation pass, then a DCE pass
+// * This pass opens up a lot of opportunities for constant propogation. It
+// is a good idea to to run a constant propogation pass, then a DCE pass
// sometime after running this pass.
//
// TODO: Currently this throws away all of the symbol names in the method being
-// inlined to try to avoid name clashes. Use a name if it's not taken
+// inlined. This shouldn't happen.
//
//===----------------------------------------------------------------------===//
-#include "llvm/Optimizations/MethodInlining.h"
+#include "llvm/Transforms/MethodInlining.h"
#include "llvm/Module.h"
#include "llvm/Method.h"
#include "llvm/iTerminators.h"
@@ -32,8 +31,6 @@ using std::cerr;
#include "llvm/Assembly/Writer.h"
-using namespace opt;
-
// RemapInstruction - Convert the instruction operands from referencing the
// current values into those specified by ValueMap.
//
@@ -65,7 +62,7 @@ static inline void RemapInstruction(Instruction *I,
// exists in the instruction stream. Similiarly this will inline a recursive
// method by one level.
//
-bool opt::InlineMethod(BasicBlock::iterator CIIt) {
+bool InlineMethod(BasicBlock::iterator CIIt) {
assert(isa<CallInst>(*CIIt) && "InlineMethod only works on CallInst nodes!");
assert((*CIIt)->getParent() && "Instruction not embedded in basic block!");
assert((*CIIt)->getParent()->getParent() && "Instruction not in method!");
@@ -207,7 +204,7 @@ bool opt::InlineMethod(BasicBlock::iterator CIIt) {
return true;
}
-bool opt::InlineMethod(CallInst *CI) {
+bool InlineMethod(CallInst *CI) {
assert(CI->getParent() && "CallInst not embeded in BasicBlock!");
BasicBlock *PBB = CI->getParent();
@@ -248,7 +245,7 @@ static inline bool DoMethodInlining(BasicBlock *BB) {
return false;
}
-bool opt::MethodInlining::doMethodInlining(Method *M) {
+bool MethodInlining::doMethodInlining(Method *M) {
bool Changed = false;
// Loop through now and inline instructions a basic block at a time...
diff --git a/llvm/lib/Transforms/LevelRaise.cpp b/llvm/lib/Transforms/LevelRaise.cpp
index f1406769371..38865003bb3 100644
--- a/llvm/lib/Transforms/LevelRaise.cpp
+++ b/llvm/lib/Transforms/LevelRaise.cpp
@@ -12,9 +12,9 @@
#include "llvm/iOther.h"
#include "llvm/iMemory.h"
#include "llvm/ConstantVals.h"
-#include "llvm/Optimizations/ConstantHandling.h"
-#include "llvm/Optimizations/DCE.h"
-#include "llvm/Optimizations/ConstantProp.h"
+#include "llvm/Transforms/Scalar/DCE.h"
+#include "llvm/Transforms/Scalar/ConstantHandling.h"
+#include "llvm/Transforms/Scalar/ConstantProp.h"
#include "llvm/Analysis/Expressions.h"
#include "Support/STLExtras.h"
#include <algorithm>
@@ -413,8 +413,8 @@ static bool DoRaisePass(Method *M) {
#if DEBUG_PEEPHOLE_INSTS
cerr << "Processing: " << *BI;
#endif
- if (opt::DeadCodeElimination::dceInstruction(BIL, BI) ||
- opt::ConstantPropogation::doConstantPropogation(BB, BI)) {
+ if (DeadCodeElimination::dceInstruction(BIL, BI) ||
+ ConstantPropogation::doConstantPropogation(BB, BI)) {
Changed = true;
#ifdef DEBUG_PEEPHOLE_INSTS
cerr << "DeadCode Elinated!\n";
diff --git a/llvm/lib/Transforms/Scalar/ADCE.cpp b/llvm/lib/Transforms/Scalar/ADCE.cpp
index 45a57a2f438..01046b00337 100644
--- a/llvm/lib/Transforms/Scalar/ADCE.cpp
+++ b/llvm/lib/Transforms/Scalar/ADCE.cpp
@@ -6,7 +6,7 @@
//
//===----------------------------------------------------------------------===//
-#include "llvm/Optimizations/DCE.h"
+#include "llvm/Transforms/Scalar/DCE.h"
#include "llvm/Instruction.h"
#include "llvm/Type.h"
#include "llvm/Analysis/Dominators.h"
@@ -297,7 +297,7 @@ BasicBlock *ADCE::fixupCFG(BasicBlock *BB, std::set<BasicBlock*> &VisitedBlocks,
// doADCE - Execute the Agressive Dead Code Elimination Algorithm
//
-bool opt::AgressiveDCE::doADCE(Method *M) {
+bool AgressiveDCE::doADCE(Method *M) {
if (M->isExternal()) return false;
ADCE DCE(M);
return DCE.doADCE();
diff --git a/llvm/lib/Transforms/Scalar/ConstantProp.cpp b/llvm/lib/Transforms/Scalar/ConstantProp.cpp
index a961bad927c..190bd4b919c 100644
--- a/llvm/lib/Transforms/Scalar/ConstantProp.cpp
+++ b/llvm/lib/Transforms/Scalar/ConstantProp.cpp
@@ -21,8 +21,8 @@
//
//===----------------------------------------------------------------------===//
-#include "llvm/Optimizations/ConstantProp.h"
-#include "llvm/Optimizations/ConstantHandling.h"
+#include "llvm/Transforms/Scalar/ConstantProp.h"
+#include "llvm/Transforms/Scalar/ConstantHandling.h"
#include "llvm/Module.h"
#include "llvm/Method.h"
#include "llvm/BasicBlock.h"
@@ -34,8 +34,7 @@
inline static bool
ConstantFoldUnaryInst(BasicBlock *BB, BasicBlock::iterator &II,
UnaryOperator *Op, Constant *D) {
- Constant *ReplaceWith =
- opt::ConstantFoldUnaryInstruction(Op->getOpcode(), D);
+ Constant *ReplaceWith = ConstantFoldUnaryInstruction(Op->getOpcode(), D);
if (!ReplaceWith) return false; // Nothing new to change...
@@ -57,8 +56,7 @@ ConstantFoldUnaryInst(BasicBlock *BB, BasicBlock::iterator &II,
inline static bool
ConstantFoldCast(BasicBlock *BB, BasicBlock::iterator &II,
CastInst *CI, Constant *D) {
- Constant *ReplaceWith =
- opt::ConstantFoldCastInstruction(D, CI->getType());
+ Constant *ReplaceWith = ConstantFoldCastInstruction(D, CI->getType());
if (!ReplaceWith) return false; // Nothing new to change...
@@ -81,8 +79,7 @@ inline static bool
ConstantFoldBinaryInst(BasicBlock *BB, BasicBlock::iterator &II,
BinaryOperator *Op,
Constant *D1, Constant *D2) {
- Constant *ReplaceWith =
- opt::ConstantFoldBinaryInstruction(Op->getOpcode(), D1, D2);
+ Constant *ReplaceWith = ConstantFoldBinaryInstruction(Op->getOpcode(), D1,D2);
if (!ReplaceWith) return false; // Nothing new to change...
// Replaces all of the uses of a variable with uses of the constant.
@@ -104,7 +101,7 @@ ConstantFoldBinaryInst(BasicBlock *BB, BasicBlock::iterator &II,
// constant value, convert it into an unconditional branch to the constant
// destination.
//
-bool opt::ConstantFoldTerminator(TerminatorInst *T) {
+bool ConstantFoldTerminator(TerminatorInst *T) {
// Branch - See if we are conditional jumping on constant
if (BranchInst *BI = dyn_cast<BranchInst>(T)) {
if (BI->isUnconditional()) return false; // Can't optimize uncond branch
@@ -156,8 +153,8 @@ bool opt::ConstantFoldTerminator(TerminatorInst *T) {
// ConstantFoldInstruction - If an instruction references constants, try to fold
// them together...
//
-bool opt::ConstantPropogation::doConstantPropogation(BasicBlock *BB,
- BasicBlock::iterator &II) {
+bool ConstantPropogation::doConstantPropogation(BasicBlock *BB,
+ BasicBlock::iterator &II) {
Instruction *Inst = *II;
if (isa<BinaryOperator>(Inst)) {
Constant *D1 = dyn_cast<Constant>(Inst->getOperand(0));
@@ -174,7 +171,7 @@ bool opt::ConstantPropogation::doConstantPropogation(BasicBlock *BB,
Constant *D = dyn_cast<Constant>(UInst->getOperand(0));
if (D) return ConstantFoldUnaryInst(BB, II, UInst, D);
} else if (TerminatorInst *TInst = dyn_cast<TerminatorInst>(Inst)) {
- return opt::ConstantFoldTerminator(TInst);
+ return ConstantFoldTerminator(TInst);
} else if (PHINode *PN = dyn_cast<PHINode>(Inst)) {
// If it's a PHI node and only has one operand
@@ -203,7 +200,7 @@ static bool DoConstPropPass(Method *M) {
for (Method::iterator BBI = M->begin(); BBI != M->end(); ++BBI) {
BasicBlock *BB = *BBI;
for (BasicBlock::iterator I = BB->begin(); I != BB->end(); )
- if (opt::ConstantPropogation::doConstantPropogation(BB, I))
+ if (ConstantPropogation::doConstantPropogation(BB, I))
SomethingChanged = true;
else
++I;
@@ -214,7 +211,7 @@ static bool DoConstPropPass(Method *M) {
// returns whether or not the underlying method was modified
//
-bool opt::ConstantPropogation::doConstantPropogation(Method *M) {
+bool ConstantPropogation::doConstantPropogation(Method *M) {
bool Modified = false;
// Fold constants until we make no progress...
diff --git a/llvm/lib/Transforms/Scalar/DCE.cpp b/llvm/lib/Transforms/Scalar/DCE.cpp
index eadf7b18e0a..218c0add8be 100644
--- a/llvm/lib/Transforms/Scalar/DCE.cpp
+++ b/llvm/lib/Transforms/Scalar/DCE.cpp
@@ -23,7 +23,7 @@
//
//===----------------------------------------------------------------------===//
-#include "llvm/Optimizations/DCE.h"
+#include "llvm/Transforms/Scalar/DCE.h"
#include "llvm/Module.h"
#include "llvm/GlobalVariable.h"
#include "llvm/Method.h"
@@ -39,8 +39,8 @@
// to point to the instruction that immediately succeeded the original
// instruction.
//
-bool opt::DeadCodeElimination::dceInstruction(BasicBlock::InstListType &BBIL,
- BasicBlock::iterator &BBI) {
+bool DeadCodeElimination::dceInstruction(BasicBlock::InstListType &BBIL,
+ BasicBlock::iterator &BBI) {
// Look for un"used" definitions...
if ((*BBI)->use_empty() && !(*BBI)->hasSideEffects() &&
!isa<TerminatorInst>(*BBI)) {
@@ -54,7 +54,7 @@ static inline bool RemoveUnusedDefs(BasicBlock::InstListType &Vals) {
bool Changed = false;
for (BasicBlock::InstListType::iterator DI = Vals.begin();
DI != Vals.end(); )
- if (opt::DeadCodeElimination::dceInstruction(Vals, DI))
+ if (DeadCodeElimination::dceInstruction(Vals, DI))
Changed = true;
else
++DI;
@@ -155,7 +155,7 @@ static bool PropogatePredecessorsForPHIs(BasicBlock *BB, BasicBlock *Succ) {
//
// WARNING: The entry node of a method may not be simplified.
//
-bool opt::SimplifyCFG(Method::iterator &BBIt) {
+bool SimplifyCFG(Method::iterator &BBIt) {
BasicBlock *BB = *BBIt;
Method *M = BB->getParent();
@@ -282,7 +282,7 @@ static bool DoDCEPass(Method *M) {
// if they are unneeded...
//
for (BBIt = M->begin(), ++BBIt; BBIt != M->end(); ) {
- if (opt::SimplifyCFG(BBIt)) {
+ if (SimplifyCFG(BBIt)) {
Changed = true;
} else {
++BBIt;
@@ -296,13 +296,13 @@ static bool DoDCEPass(Method *M) {
// It is possible that we may require multiple passes over the code to fully
// eliminate dead code. Iterate until we are done.
//
-bool opt::DeadCodeElimination::doDCE(Method *M) {
+bool DeadCodeElimination::doDCE(Method *M) {
bool Changed = false;
while (DoDCEPass(M)) Changed = true;
return Changed;
}
-bool opt::DeadCodeElimination::RemoveUnusedGlobalValues(Module *Mod) {
+bool DeadCodeElimination::RemoveUnusedGlobalValues(Module *Mod) {
bool Changed = false;
for (Module::iterator MI = Mod->begin(); MI != Mod->end(); ) {
diff --git a/llvm/lib/Transforms/Scalar/InductionVars.cpp b/llvm/lib/Transforms/Scalar/InductionVars.cpp
index 93ab189dee6..cab778e025b 100644
--- a/llvm/lib/Transforms/Scalar/InductionVars.cpp
+++ b/llvm/lib/Transforms/Scalar/InductionVars.cpp
@@ -19,7 +19,7 @@
//
//===----------------------------------------------------------------------===//
-#include "llvm/Optimizations/InductionVars.h"
+#include "llvm/Transforms/Scalar/InductionVars.h"
#include "llvm/ConstantVals.h"
#include "llvm/Analysis/IntervalPartition.h"
#include "llvm/Assembly/Writer.h"
diff --git a/llvm/lib/Transforms/Scalar/InstructionCombining.cpp b/llvm/lib/Transforms/Scalar/InstructionCombining.cpp
index 795418f939b..25590661b77 100644
--- a/llvm/lib/Transforms/Scalar/InstructionCombining.cpp
+++ b/llvm/lib/Transforms/Scalar/InstructionCombining.cpp
@@ -15,12 +15,10 @@
//===----------------------------------------------------------------------===//
#include "llvm/Transforms/Scalar/InstructionCombining.h"
-#include "../TransformInternals.h"
-#include "llvm/Optimizations/ConstantHandling.h"
+#include "llvm/Transforms/Scalar/ConstantHandling.h"
#include "llvm/Method.h"
#include "llvm/iMemory.h"
-
-using namespace opt;
+#include "../TransformInternals.h"
static Instruction *CombineBinOp(BinaryOperator *I) {
bool Changed = false;
diff --git a/llvm/lib/Transforms/Scalar/SCCP.cpp b/llvm/lib/Transforms/Scalar/SCCP.cpp
index 68be8440953..9b2343c936c 100644
--- a/llvm/lib/Transforms/Scalar/SCCP.cpp
+++ b/llvm/lib/Transforms/Scalar/SCCP.cpp
@@ -15,8 +15,8 @@
//
//===----------------------------------------------------------------------===//
-#include "llvm/Optimizations/ConstantProp.h"
-#include "llvm/Optimizations/ConstantHandling.h"
+#include "llvm/Transforms/Scalar/ConstantProp.h"
+#include "llvm/Transforms/Scalar/ConstantHandling.h"
#include "llvm/Method.h"
#include "llvm/BasicBlock.h"
#include "llvm/ConstantVals.h"
@@ -273,7 +273,7 @@ bool SCCP::doSCCP() {
MadeChanges = true;
continue; // Skip the ++II at the end of the loop here...
} else if (Inst->isTerminator()) {
- MadeChanges |= opt::ConstantFoldTerminator(cast<TerminatorInst>(Inst));
+ MadeChanges |= ConstantFoldTerminator(cast<TerminatorInst>(Inst));
}
++II;
@@ -446,9 +446,8 @@ void SCCP::UpdateInstruction(Instruction *I) {
markOverdefined(I);
} else if (VState.isConstant()) { // Propogate constant value
Constant *Result = isa<CastInst>(I)
- ? opt::ConstantFoldCastInstruction(VState.getConstant(), I->getType())
- : opt::ConstantFoldUnaryInstruction(I->getOpcode(),
- VState.getConstant());
+ ? ConstantFoldCastInstruction(VState.getConstant(), I->getType())
+ : ConstantFoldUnaryInstruction(I->getOpcode(), VState.getConstant());
if (Result) {
// This instruction constant folds!
@@ -473,9 +472,9 @@ void SCCP::UpdateInstruction(Instruction *I) {
markOverdefined(I);
} else if (V1State.isConstant() && V2State.isConstant()) {
Constant *Result =
- opt::ConstantFoldBinaryInstruction(I->getOpcode(),
- V1State.getConstant(),
- V2State.getConstant());
+ ConstantFoldBinaryInstruction(I->getOpcode(),
+ V1State.getConstant(),
+ V2State.getConstant());
if (Result) {
// This instruction constant folds!
markConstant(I, Result);
@@ -511,7 +510,7 @@ void SCCP::OperandChangedState(User *U) {
// DoSparseConditionalConstantProp - Use Sparse Conditional Constant Propogation
// to prove whether a value is constant and whether blocks are used.
//
-bool opt::SCCPPass::doSCCP(Method *M) {
+bool SCCPPass::doSCCP(Method *M) {
if (M->isExternal()) return false;
SCCP S(M);
return S.doSCCP();
diff --git a/llvm/lib/Transforms/Scalar/SymbolStripping.cpp b/llvm/lib/Transforms/Scalar/SymbolStripping.cpp
index 417376b89db..12f8e918b3f 100644
--- a/llvm/lib/Transforms/Scalar/SymbolStripping.cpp
+++ b/llvm/lib/Transforms/Scalar/SymbolStripping.cpp
@@ -14,7 +14,7 @@
//
//===----------------------------------------------------------------------===//
-#include "llvm/Optimizations/AllOpts.h"
+#include "llvm/Transforms/SymbolStripping.h"
#include "llvm/Module.h"
#include "llvm/Method.h"
#include "llvm/SymbolTable.h"
@@ -44,14 +44,14 @@ static bool StripSymbolTable(SymbolTable *SymTab) {
// DoSymbolStripping - Remove all symbolic information from a method
//
-bool opt::SymbolStripping::doSymbolStripping(Method *M) {
+bool SymbolStripping::doSymbolStripping(Method *M) {
return StripSymbolTable(M->getSymbolTable());
}
// doStripGlobalSymbols - Remove all symbolic information from all methods
// in a module, and all module level symbols. (method names, etc...)
//
-bool opt::FullSymbolStripping::doStripGlobalSymbols(Module *M) {
+bool FullSymbolStripping::doStripGlobalSymbols(Module *M) {
// Remove all symbols from methods in this module... and then strip all of the
// symbols in this module...
//
diff --git a/llvm/lib/VMCore/ConstantHandling.cpp b/llvm/lib/VMCore/ConstantHandling.cpp
index fa561de6a38..80374f339c5 100644
--- a/llvm/lib/VMCore/ConstantHandling.cpp
+++ b/llvm/lib/VMCore/ConstantHandling.cpp
@@ -4,7 +4,7 @@
//
//===----------------------------------------------------------------------===//
-#include "llvm/Optimizations/ConstantHandling.h"
+#include "llvm/Transforms/Scalar/ConstantHandling.h"
AnnotationID ConstRules::AID(AnnotationManager::getID("opt::ConstRules",
&ConstRules::find));
diff --git a/llvm/tools/gccas/gccas.cpp b/llvm/tools/gccas/gccas.cpp
index 7e2b6f3e46c..24a5e87b1ba 100644
--- a/llvm/tools/gccas/gccas.cpp
+++ b/llvm/tools/gccas/gccas.cpp
@@ -11,8 +11,8 @@
#include "llvm/Assembly/Parser.h"
#include "llvm/Transforms/CleanupGCCOutput.h"
#include "llvm/Transforms/LevelChange.h"
-#include "llvm/Optimizations/DCE.h"
#include "llvm/Transforms/ConstantMerge.h"
+#include "llvm/Transforms/Scalar/DCE.h"
#include "llvm/Transforms/Scalar/IndVarSimplify.h"
#include "llvm/Transforms/Scalar/InstructionCombining.h"
#include "llvm/Bytecode/Writer.h"
@@ -64,13 +64,13 @@ int main(int argc, char **argv) {
// a little bit. Do this now.
//
PassManager Passes;
- Passes.add(new opt::DeadCodeElimination()); // Remove Dead code/vars
+ Passes.add(new DeadCodeElimination()); // Remove Dead code/vars
Passes.add(new CleanupGCCOutput()); // Fix gccisms
Passes.add(new InductionVariableSimplify()); // Simplify indvars
Passes.add(new RaisePointerReferences()); // Eliminate casts
Passes.add(new ConstantMerge()); // Merge dup global consts
Passes.add(new InstructionCombining()); // Combine silly seq's
- Passes.add(new opt::DeadCodeElimination()); // Remove Dead code/vars
+ Passes.add(new DeadCodeElimination()); // Remove Dead code/vars
// Run our queue of passes all at once now, efficiently. This form of
// runAllPasses frees the Pass objects after runAllPasses completes.
diff --git a/llvm/tools/opt/opt.cpp b/llvm/tools/opt/opt.cpp
index bbf1489ca62..36de3bfbf73 100644
--- a/llvm/tools/opt/opt.cpp
+++ b/llvm/tools/opt/opt.cpp
@@ -9,20 +9,26 @@
#include "llvm/Module.h"
#include "llvm/Bytecode/Reader.h"
#include "llvm/Bytecode/Writer.h"
-#include "llvm/Optimizations/AllOpts.h"
-#include "llvm/Transforms/Instrumentation/TraceValues.h"
#include "llvm/Assembly/PrintModulePass.h"
#include "llvm/Transforms/ConstantMerge.h"
#include "llvm/Transforms/CleanupGCCOutput.h"
#include "llvm/Transforms/LevelChange.h"
+#include "llvm/Transforms/MethodInlining.h"
+#include "llvm/Transforms/SymbolStripping.h"
#include "llvm/Transforms/IPO/SimpleStructMutation.h"
#include "llvm/Transforms/IPO/GlobalDCE.h"
+#include "llvm/Transforms/Scalar/DCE.h"
+#include "llvm/Transforms/Scalar/ConstantProp.h"
+#include "llvm/Transforms/Scalar/InductionVars.h"
#include "llvm/Transforms/Scalar/IndVarSimplify.h"
#include "llvm/Transforms/Scalar/InstructionCombining.h"
+#include "llvm/Transforms/Instrumentation/TraceValues.h"
#include "Support/CommandLine.h"
#include <fstream>
#include <memory>
+
+
enum Opts {
// Basic optimizations
dce, constprop, inlining, constmerge, strip, mstrip,
@@ -41,16 +47,16 @@ struct {
enum Opts OptID;
Pass *ThePass;
} OptTable[] = {
- { dce , new opt::DeadCodeElimination() },
- { constprop , new opt::ConstantPropogation() },
- { inlining , new opt::MethodInlining() },
+ { dce , new DeadCodeElimination() },
+ { constprop , new ConstantPropogation() },
+ { inlining , new MethodInlining() },
{ constmerge , new ConstantMerge() },
- { strip , new opt::SymbolStripping() },
- { mstrip , new opt::FullSymbolStripping() },
+ { strip , new SymbolStripping() },
+ { mstrip , new FullSymbolStripping() },
{ indvars , new InductionVariableSimplify() },
{ instcombine, new InstructionCombining() },
- { sccp , new opt::SCCPPass() },
- { adce , new opt::AgressiveDCE() },
+ { sccp , new SCCPPass() },
+ { adce , new AgressiveDCE() },
{ raise , new RaisePointerReferences() },
{ trace , new InsertTraceCode(true, true) },
{ tracem , new InsertTraceCode(false, true) },
OpenPOWER on IntegriCloud