From c74cb8698f1771603a6ab008277a407c55e47753 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Fri, 30 Aug 2002 22:53:53 +0000 Subject: [PATCH] - 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 --- include/llvm/Analysis/Expressions.h | 4 ---- lib/Analysis/Expressions.cpp | 7 +------ lib/Analysis/InductionVariable.cpp | 11 ++++------- lib/Transforms/ExprTypeConvert.cpp | 5 ++--- lib/Transforms/TransformInternals.cpp | 2 +- tools/analyze/AnalysisWrappers.cpp | 8 ++++---- tools/opt/AnalysisWrappers.cpp | 8 ++++---- 7 files changed, 16 insertions(+), 29 deletions(-) diff --git a/include/llvm/Analysis/Expressions.h b/include/llvm/Analysis/Expressions.h index f64f8f14f86..6d1d686ad25 100644 --- a/include/llvm/Analysis/Expressions.h +++ b/include/llvm/Analysis/Expressions.h @@ -15,8 +15,6 @@ class Type; class Value; class ConstantInt; -namespace analysis { - struct ExprType; // ClassifyExpression: Analyze an expression to determine the complexity of the @@ -52,6 +50,4 @@ struct ExprType { const Type *getExprType(const Type *Default) const; }; -} // End namespace analysis - #endif diff --git a/lib/Analysis/Expressions.cpp b/lib/Analysis/Expressions.cpp index f4f76af4c99..7901b1421e5 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 - -using namespace analysis; ExprType::ExprType(Value *Val) { if (Val) @@ -233,7 +228,7 @@ static inline ExprType negate(const ExprType &E, Value *V) { // 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 485586a018c..5703d6de2c0 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(V) || isa(V) || isa(V)) return true; @@ -85,8 +82,8 @@ InductionVariable::InductionVariable(PHINode *P, LoopInfo *LoopInfo) { 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 @@ InductionVariable::InductionVariable(PHINode *P, LoopInfo *LoopInfo) { } 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 @@ InductionVariable::InductionVariable(PHINode *P, LoopInfo *LoopInfo) { if (isa(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 33aa3cb4751..01c8d6f354b 100644 --- a/lib/Transforms/ExprTypeConvert.cpp +++ b/lib/Transforms/ExprTypeConvert.cpp @@ -15,7 +15,6 @@ #include "Support/STLExtras.h" #include "Support/StatisticReporter.h" #include -#include using std::cerr; static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, @@ -44,7 +43,7 @@ static bool MallocConvertableToType(MallocInst *MI, const Type *Ty, 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 @@ static Instruction *ConvertMallocToType(MallocInst *MI, const Type *Ty, 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(Ty); const Type *ElType = AllocTy->getElementType(); diff --git a/lib/Transforms/TransformInternals.cpp b/lib/Transforms/TransformInternals.cpp index f8476231cf9..3f61864c9c5 100644 --- a/lib/Transforms/TransformInternals.cpp +++ b/lib/Transforms/TransformInternals.cpp @@ -94,7 +94,7 @@ const Type *ConvertableToGEP(const Type *Ty, Value *OffsetVal, // 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 a674e7c8fbb..027866beeea 100644 --- a/tools/analyze/AnalysisWrappers.cpp +++ b/tools/analyze/AnalysisWrappers.cpp @@ -71,20 +71,20 @@ namespace { 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 a674e7c8fbb..027866beeea 100644 --- a/tools/opt/AnalysisWrappers.cpp +++ b/tools/opt/AnalysisWrappers.cpp @@ -71,20 +71,20 @@ namespace { 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; -- 2.34.1