class Value;
class ConstantInt;
-namespace analysis {
-
struct ExprType;
// ClassifyExpression: Analyze an expression to determine the complexity of the
const Type *getExprType(const Type *Default) const;
};
-} // End namespace analysis
-
#endif
#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)
// 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
#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;
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);
}
if (Step == 0) { // Unrecognized step value...
- ExprType StepE = analysis::ClassifyExpression(V2);
+ ExprType StepE = ClassifyExpression(V2);
if (StepE.ExprTy != ExprType::Linear ||
StepE.Var != Phi) return;
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;
#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,
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);
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();
// 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.
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;
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;