diff --git a/include/llvm/Transforms/Scalar.h b/include/llvm/Transforms/Scalar.h
index 2a586fd0695..74bbfa5b9de 100644
--- a/include/llvm/Transforms/Scalar.h
+++ b/include/llvm/Transforms/Scalar.h
@@ -18,7 +18,6 @@
 namespace llvm {
 
 class FunctionPass;
-class LoopPass;
 class Pass;
 class GetElementPtrInst;
 class PassInfo;
@@ -81,7 +80,7 @@ FunctionPass *createScalarReplAggregatesPass(signed Threshold = -1);
 // InductionVariableSimplify - Transform induction variables in a program to all
 // use a single canonical induction variable per loop.
 //
-LoopPass *createIndVarSimplifyPass();
+Pass *createIndVarSimplifyPass();
 
 //===----------------------------------------------------------------------===//
 //
@@ -101,7 +100,7 @@ FunctionPass *createInstructionCombiningPass();
 //
 // LICM - This pass is a loop invariant code motion and memory promotion pass.
 //
-LoopPass *createLICMPass();
+Pass *createLICMPass();
 
 //===----------------------------------------------------------------------===//
 //
@@ -110,32 +109,32 @@ LoopPass *createLICMPass();
 // optional parameter used to consult the target machine whether certain
 // transformations are profitable.
 //
-LoopPass *createLoopStrengthReducePass(const TargetLowering *TLI = 0);
+Pass *createLoopStrengthReducePass(const TargetLowering *TLI = 0);
 
 //===----------------------------------------------------------------------===//
 //
 // LoopUnswitch - This pass is a simple loop unswitching pass.
 //
-LoopPass *createLoopUnswitchPass(bool OptimizeForSize = false);
+Pass *createLoopUnswitchPass(bool OptimizeForSize = false);
 
 //===----------------------------------------------------------------------===//
 //
 // LoopUnroll - This pass is a simple loop unrolling pass.
 //
-LoopPass *createLoopUnrollPass();
+Pass *createLoopUnrollPass();
 
 //===----------------------------------------------------------------------===//
 //
 // LoopRotate - This pass is a simple loop rotating pass.
 //
-LoopPass *createLoopRotatePass();
+Pass *createLoopRotatePass();
 
 //===----------------------------------------------------------------------===//
 //
 // LoopIndexSplit - This pass divides loop's iteration range by spliting loop
 // such that each individual loop is executed efficiently.
 //
-LoopPass *createLoopIndexSplitPass();
+Pass *createLoopIndexSplitPass();
 
 //===----------------------------------------------------------------------===//
 //
@@ -274,7 +273,7 @@ FunctionPass *createBlockPlacementPass();
 // LCSSA - This pass inserts phi nodes at loop boundaries to simplify other loop
 // optimizations.
 //
-LoopPass *createLCSSAPass();
+Pass *createLCSSAPass();
 extern const PassInfo *const LCSSAID;
 
 //===----------------------------------------------------------------------===//
@@ -310,7 +309,7 @@ FunctionPass *createMemCpyOptPass();
 // LoopDeletion - This pass performs DCE of non-infinite loops that it
 // can prove are dead.
 //
-LoopPass *createLoopDeletionPass();
+Pass *createLoopDeletionPass();
   
 //===----------------------------------------------------------------------===//
 //
diff --git a/lib/Transforms/Scalar/IndVarSimplify.cpp b/lib/Transforms/Scalar/IndVarSimplify.cpp
index 13be455c4d0..4dfd8b920b6 100644
--- a/lib/Transforms/Scalar/IndVarSimplify.cpp
+++ b/lib/Transforms/Scalar/IndVarSimplify.cpp
@@ -102,7 +102,7 @@ char IndVarSimplify::ID = 0;
 static RegisterPass<IndVarSimplify>
 X("indvars", "Canonicalize Induction Variables");
 
-LoopPass *llvm::createIndVarSimplifyPass() {
+Pass *llvm::createIndVarSimplifyPass() {
   return new IndVarSimplify();
 }
 
diff --git a/lib/Transforms/Scalar/LICM.cpp b/lib/Transforms/Scalar/LICM.cpp
index 3eee4a27f7d..b5d5bfda6f4 100644
--- a/lib/Transforms/Scalar/LICM.cpp
+++ b/lib/Transforms/Scalar/LICM.cpp
@@ -230,7 +230,7 @@ namespace {
 char LICM::ID = 0;
 static RegisterPass<LICM> X("licm", "Loop Invariant Code Motion");
 
-LoopPass *llvm::createLICMPass() { return new LICM(); }
+Pass *llvm::createLICMPass() { return new LICM(); }
 
 /// Hoist expressions out of the specified loop. Note, alias info for inner
 /// loop is not preserved so it is not a good idea to run LICM multiple 
diff --git a/lib/Transforms/Scalar/LoopDeletion.cpp b/lib/Transforms/Scalar/LoopDeletion.cpp
index 74190f5f776..86edcfaac80 100644
--- a/lib/Transforms/Scalar/LoopDeletion.cpp
+++ b/lib/Transforms/Scalar/LoopDeletion.cpp
@@ -60,7 +60,7 @@ namespace {
 char LoopDeletion::ID = 0;
 static RegisterPass<LoopDeletion> X("loop-deletion", "Delete dead loops");
 
-LoopPass* llvm::createLoopDeletionPass() {
+Pass* llvm::createLoopDeletionPass() {
   return new LoopDeletion();
 }
 
diff --git a/lib/Transforms/Scalar/LoopIndexSplit.cpp b/lib/Transforms/Scalar/LoopIndexSplit.cpp
index 6a2c7587f6e..9a5920c8b97 100644
--- a/lib/Transforms/Scalar/LoopIndexSplit.cpp
+++ b/lib/Transforms/Scalar/LoopIndexSplit.cpp
@@ -205,7 +205,7 @@ char LoopIndexSplit::ID = 0;
 static RegisterPass<LoopIndexSplit>
 X("loop-index-split", "Index Split Loops");
 
-LoopPass *llvm::createLoopIndexSplitPass() {
+Pass *llvm::createLoopIndexSplitPass() {
   return new LoopIndexSplit();
 }
 
diff --git a/lib/Transforms/Scalar/LoopRotation.cpp b/lib/Transforms/Scalar/LoopRotation.cpp
index 488ab0eacff..e8df49b6e4e 100644
--- a/lib/Transforms/Scalar/LoopRotation.cpp
+++ b/lib/Transforms/Scalar/LoopRotation.cpp
@@ -107,7 +107,7 @@ namespace {
 char LoopRotate::ID = 0;
 static RegisterPass<LoopRotate> X("loop-rotate", "Rotate Loops");
 
-LoopPass *llvm::createLoopRotatePass() { return new LoopRotate(); }
+Pass *llvm::createLoopRotatePass() { return new LoopRotate(); }
 
 /// Rotate Loop L as many times as possible. Return true if
 /// loop is rotated at least once.
diff --git a/lib/Transforms/Scalar/LoopStrengthReduce.cpp b/lib/Transforms/Scalar/LoopStrengthReduce.cpp
index 30e86447f25..9052d6088e3 100644
--- a/lib/Transforms/Scalar/LoopStrengthReduce.cpp
+++ b/lib/Transforms/Scalar/LoopStrengthReduce.cpp
@@ -213,7 +213,7 @@ char LoopStrengthReduce::ID = 0;
 static RegisterPass<LoopStrengthReduce>
 X("loop-reduce", "Loop Strength Reduction");
 
-LoopPass *llvm::createLoopStrengthReducePass(const TargetLowering *TLI) {
+Pass *llvm::createLoopStrengthReducePass(const TargetLowering *TLI) {
   return new LoopStrengthReduce(TLI);
 }
 
diff --git a/lib/Transforms/Scalar/LoopUnroll.cpp b/lib/Transforms/Scalar/LoopUnroll.cpp
index ed4ea895cc2..6d685d58f96 100644
--- a/lib/Transforms/Scalar/LoopUnroll.cpp
+++ b/lib/Transforms/Scalar/LoopUnroll.cpp
@@ -73,7 +73,7 @@ namespace {
 char LoopUnroll::ID = 0;
 static RegisterPass<LoopUnroll> X("loop-unroll", "Unroll loops");
 
-LoopPass *llvm::createLoopUnrollPass() { return new LoopUnroll(); }
+Pass *llvm::createLoopUnrollPass() { return new LoopUnroll(); }
 
 /// ApproximateLoopSize - Approximate the size of the loop.
 static unsigned ApproximateLoopSize(const Loop *L) {
diff --git a/lib/Transforms/Scalar/LoopUnswitch.cpp b/lib/Transforms/Scalar/LoopUnswitch.cpp
index 455338b3341..65034f5577c 100644
--- a/lib/Transforms/Scalar/LoopUnswitch.cpp
+++ b/lib/Transforms/Scalar/LoopUnswitch.cpp
@@ -154,7 +154,7 @@ namespace {
 char LoopUnswitch::ID = 0;
 static RegisterPass<LoopUnswitch> X("loop-unswitch", "Unswitch loops");
 
-LoopPass *llvm::createLoopUnswitchPass(bool Os) { 
+Pass *llvm::createLoopUnswitchPass(bool Os) { 
   return new LoopUnswitch(Os); 
 }
 
diff --git a/lib/Transforms/Utils/LCSSA.cpp b/lib/Transforms/Utils/LCSSA.cpp
index bcba3c13990..38558886115 100644
--- a/lib/Transforms/Utils/LCSSA.cpp
+++ b/lib/Transforms/Utils/LCSSA.cpp
@@ -99,7 +99,7 @@ namespace {
 char LCSSA::ID = 0;
 static RegisterPass<LCSSA> X("lcssa", "Loop-Closed SSA Form Pass");
 
-LoopPass *llvm::createLCSSAPass() { return new LCSSA(); }
+Pass *llvm::createLCSSAPass() { return new LCSSA(); }
 const PassInfo *const llvm::LCSSAID = &X;
 
 /// runOnFunction - Process all loops in the function, inner-most out.