- Eliminate the last traces of the 'analysis' namespace
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@3550 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/include/llvm/Analysis/Expressions.h b/include/llvm/Analysis/Expressions.h
index f64f8f1..6d1d686 100644
--- a/include/llvm/Analysis/Expressions.h
+++ b/include/llvm/Analysis/Expressions.h
@@ -15,8 +15,6 @@
class Value;
class ConstantInt;
-namespace analysis {
-
struct ExprType;
// ClassifyExpression: Analyze an expression to determine the complexity of the
@@ -52,6 +50,4 @@
const Type *getExprType(const Type *Default) const;
};
-} // End namespace analysis
-
#endif
diff --git a/lib/Analysis/Expressions.cpp b/lib/Analysis/Expressions.cpp
index f4f76af..7901b14 100644
--- a/lib/Analysis/Expressions.cpp
+++ b/lib/Analysis/Expressions.cpp
@@ -10,11 +10,6 @@
#include "llvm/Analysis/Expressions.h"
#include "llvm/ConstantHandling.h"
#include "llvm/Function.h"
-#include "llvm/BasicBlock.h"
-#include "llvm/Instruction.h"
-#include <iostream>
-
-using namespace analysis;
ExprType::ExprType(Value *Val) {
if (Val)
@@ -233,7 +228,7 @@
// Note that this analysis cannot get into infinite loops because it treats PHI
// nodes as being an unknown linear expression.
//
-ExprType analysis::ClassifyExpression(Value *Expr) {
+ExprType ClassifyExpression(Value *Expr) {
assert(Expr != 0 && "Can't classify a null expression!");
if (Expr->getType() == Type::FloatTy || Expr->getType() == Type::DoubleTy)
return Expr; // FIXME: Can't handle FP expressions
diff --git a/lib/Analysis/InductionVariable.cpp b/lib/Analysis/InductionVariable.cpp
index 485586a..5703d6d 100644
--- a/lib/Analysis/InductionVariable.cpp
+++ b/lib/Analysis/InductionVariable.cpp
@@ -25,9 +25,6 @@
#include "llvm/Constants.h"
#include "llvm/Assembly/Writer.h"
-using analysis::ExprType;
-
-
static bool isLoopInvariant(const Value *V, const Loop *L) {
if (isa<Constant>(V) || isa<Argument>(V) || isa<GlobalValue>(V))
return true;
@@ -85,8 +82,8 @@
Value *V2 = Phi->getIncomingValue(1);
if (L == 0) { // No loop information? Base everything on expression analysis
- ExprType E1 = analysis::ClassifyExpression(V1);
- ExprType E2 = analysis::ClassifyExpression(V2);
+ ExprType E1 = ClassifyExpression(V1);
+ ExprType E2 = ClassifyExpression(V2);
if (E1.ExprTy > E2.ExprTy) // Make E1 be the simpler expression
std::swap(E1, E2);
@@ -128,7 +125,7 @@
}
if (Step == 0) { // Unrecognized step value...
- ExprType StepE = analysis::ClassifyExpression(V2);
+ ExprType StepE = ClassifyExpression(V2);
if (StepE.ExprTy != ExprType::Linear ||
StepE.Var != Phi) return;
@@ -136,7 +133,7 @@
if (isa<PointerType>(ETy)) ETy = Type::ULongTy;
Step = (Value*)(StepE.Offset ? StepE.Offset : ConstantInt::get(ETy, 0));
} else { // We were able to get a step value, simplify with expr analysis
- ExprType StepE = analysis::ClassifyExpression(Step);
+ ExprType StepE = ClassifyExpression(Step);
if (StepE.ExprTy == ExprType::Linear && StepE.Offset == 0) {
// No offset from variable? Grab the variable
Step = StepE.Var;
diff --git a/lib/Transforms/ExprTypeConvert.cpp b/lib/Transforms/ExprTypeConvert.cpp
index 33aa3cb..01c8d6f 100644
--- a/lib/Transforms/ExprTypeConvert.cpp
+++ b/lib/Transforms/ExprTypeConvert.cpp
@@ -15,7 +15,6 @@
#include "Support/STLExtras.h"
#include "Support/StatisticReporter.h"
#include <algorithm>
-#include <iostream>
using std::cerr;
static bool OperandConvertableToType(User *U, Value *V, const Type *Ty,
@@ -44,7 +43,7 @@
if (!Ty->isSized()) return false; // Can only alloc something with a size
// Analyze the number of bytes allocated...
- analysis::ExprType Expr = analysis::ClassifyExpression(MI->getArraySize());
+ ExprType Expr = ClassifyExpression(MI->getArraySize());
// Get information about the base datatype being allocated, before & after
int ReqTypeSize = TD.getTypeSize(Ty);
@@ -79,7 +78,7 @@
BasicBlock::iterator It = BB->end();
// Analyze the number of bytes allocated...
- analysis::ExprType Expr = analysis::ClassifyExpression(MI->getArraySize());
+ ExprType Expr = ClassifyExpression(MI->getArraySize());
const PointerType *AllocTy = cast<PointerType>(Ty);
const Type *ElType = AllocTy->getElementType();
diff --git a/lib/Transforms/TransformInternals.cpp b/lib/Transforms/TransformInternals.cpp
index f847623..3f61864 100644
--- a/lib/Transforms/TransformInternals.cpp
+++ b/lib/Transforms/TransformInternals.cpp
@@ -94,7 +94,7 @@
// See if the cast is of an integer expression that is either a constant,
// or a value scaled by some amount with a possible offset.
//
- analysis::ExprType Expr = analysis::ClassifyExpression(OffsetVal);
+ ExprType Expr = ClassifyExpression(OffsetVal);
// Get the offset and scale values if they exists...
// A scale of zero with Expr.Var != 0 means a scale of 1.
diff --git a/tools/analyze/AnalysisWrappers.cpp b/tools/analyze/AnalysisWrappers.cpp
index a674e7c..027866b 100644
--- a/tools/analyze/AnalysisWrappers.cpp
+++ b/tools/analyze/AnalysisWrappers.cpp
@@ -71,20 +71,20 @@
OS << *I;
if ((*I)->getType() == Type::VoidTy) continue;
- analysis::ExprType R = analysis::ClassifyExpression(*I);
+ ExprType R = ClassifyExpression(*I);
if (R.Var == *I) continue; // Doesn't tell us anything
OS << "\t\tExpr =";
switch (R.ExprTy) {
- case analysis::ExprType::ScaledLinear:
+ case ExprType::ScaledLinear:
WriteAsOperand(OS << "(", (Value*)R.Scale) << " ) *";
// fall through
- case analysis::ExprType::Linear:
+ case ExprType::Linear:
WriteAsOperand(OS << "(", R.Var) << " )";
if (R.Offset == 0) break;
else OS << " +";
// fall through
- case analysis::ExprType::Constant:
+ case ExprType::Constant:
if (R.Offset) WriteAsOperand(OS, (Value*)R.Offset);
else OS << " 0";
break;
diff --git a/tools/opt/AnalysisWrappers.cpp b/tools/opt/AnalysisWrappers.cpp
index a674e7c..027866b 100644
--- a/tools/opt/AnalysisWrappers.cpp
+++ b/tools/opt/AnalysisWrappers.cpp
@@ -71,20 +71,20 @@
OS << *I;
if ((*I)->getType() == Type::VoidTy) continue;
- analysis::ExprType R = analysis::ClassifyExpression(*I);
+ ExprType R = ClassifyExpression(*I);
if (R.Var == *I) continue; // Doesn't tell us anything
OS << "\t\tExpr =";
switch (R.ExprTy) {
- case analysis::ExprType::ScaledLinear:
+ case ExprType::ScaledLinear:
WriteAsOperand(OS << "(", (Value*)R.Scale) << " ) *";
// fall through
- case analysis::ExprType::Linear:
+ case ExprType::Linear:
WriteAsOperand(OS << "(", R.Var) << " )";
if (R.Offset == 0) break;
else OS << " +";
// fall through
- case analysis::ExprType::Constant:
+ case ExprType::Constant:
if (R.Offset) WriteAsOperand(OS, (Value*)R.Offset);
else OS << " 0";
break;