-//===- Expressions.cpp - Expression Analysis Utilities ----------------------=//
+//===- Expressions.cpp - Expression Analysis Utilities --------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
//
// This file defines a package of expression analysis utilties:
//
//===----------------------------------------------------------------------===//
#include "llvm/Analysis/Expressions.h"
-#include "llvm/ConstantHandling.h"
+#include "llvm/Constants.h"
#include "llvm/Function.h"
-#include "llvm/BasicBlock.h"
-#include "llvm/Instruction.h"
-#include <iostream>
-
-using namespace analysis;
+#include "llvm/Type.h"
+using namespace llvm;
ExprType::ExprType(Value *Val) {
if (Val)
const ConstantInt *offset) {
Scale = var ? scale : 0; Var = var; Offset = offset;
ExprTy = Scale ? ScaledLinear : (Var ? Linear : Constant);
- if (Scale && Scale->equalsInt(0)) { // Simplify 0*Var + const
+ if (Scale && Scale->isNullValue()) { // Simplify 0*Var + const
Scale = 0; Var = 0;
ExprTy = Constant;
}
}
-
-class DefVal {
- const ConstantInt * const Val;
- const Type * const Ty;
-protected:
- inline DefVal(const ConstantInt *val, const Type *ty) : Val(val), Ty(ty) {}
-public:
- inline const Type *getType() const { return Ty; }
- inline const ConstantInt *getVal() const { return Val; }
- inline operator const ConstantInt * () const { return Val; }
- inline const ConstantInt *operator->() const { return Val; }
-};
-
-struct DefZero : public DefVal {
- inline DefZero(const ConstantInt *val, const Type *ty) : DefVal(val, ty) {}
- inline DefZero(const ConstantInt *val) : DefVal(val, val->getType()) {}
-};
-
-struct DefOne : public DefVal {
- inline DefOne(const ConstantInt *val, const Type *ty) : DefVal(val, ty) {}
-};
+namespace {
+ class DefVal {
+ const ConstantInt * const Val;
+ const Type * const Ty;
+ protected:
+ inline DefVal(const ConstantInt *val, const Type *ty) : Val(val), Ty(ty) {}
+ public:
+ inline const Type *getType() const { return Ty; }
+ inline const ConstantInt *getVal() const { return Val; }
+ inline operator const ConstantInt * () const { return Val; }
+ inline const ConstantInt *operator->() const { return Val; }
+ };
+
+ struct DefZero : public DefVal {
+ inline DefZero(const ConstantInt *val, const Type *ty) : DefVal(val, ty) {}
+ inline DefZero(const ConstantInt *val) : DefVal(val, val->getType()) {}
+ };
+
+ struct DefOne : public DefVal {
+ inline DefOne(const ConstantInt *val, const Type *ty) : DefVal(val, ty) {}
+ };
+}
// getUnsignedConstant - Return a constant value of the specified type. If the
assert(Arg1->getType() == Arg2->getType() && "Types must be compatible!");
// Actually perform the computation now!
- Constant *Result = *Arg1 + *Arg2;
- assert(Result && Result->getType() == Arg1->getType() &&
- "Couldn't perform addition!");
+ Constant *Result = ConstantExpr::get(Instruction::Add, (Constant*)Arg1,
+ (Constant*)Arg2);
ConstantInt *ResultI = cast<ConstantInt>(Result);
// Check to see if the result is one of the special cases that we want to
return ResultI;
}
-inline const ConstantInt *operator+(const DefZero &L, const DefZero &R) {
+static inline const ConstantInt *operator+(const DefZero &L, const DefZero &R) {
if (L == 0) return R;
if (R == 0) return L;
return Add(L, R, false);
}
-inline const ConstantInt *operator+(const DefOne &L, const DefOne &R) {
+static inline const ConstantInt *operator+(const DefOne &L, const DefOne &R) {
if (L == 0) {
if (R == 0)
return getUnsignedConstant(2, L.getType());
// 3. If DefOne is true, a null return value indicates a value of 1, if DefOne
// is false, a null return value indicates a value of 0.
//
-inline const ConstantInt *Mul(const ConstantInt *Arg1,
- const ConstantInt *Arg2, bool DefOne) {
+static inline const ConstantInt *Mul(const ConstantInt *Arg1,
+ const ConstantInt *Arg2, bool DefOne) {
assert(Arg1 && Arg2 && "No null arguments should exist now!");
assert(Arg1->getType() == Arg2->getType() && "Types must be compatible!");
// Actually perform the computation now!
- Constant *Result = *Arg1 * *Arg2;
+ Constant *Result = ConstantExpr::get(Instruction::Mul, (Constant*)Arg1,
+ (Constant*)Arg2);
assert(Result && Result->getType() == Arg1->getType() &&
"Couldn't perform multiplication!");
ConstantInt *ResultI = cast<ConstantInt>(Result);
return ResultI;
}
-inline const ConstantInt *operator*(const DefZero &L, const DefZero &R) {
- if (L == 0 || R == 0) return 0;
- return Mul(L, R, false);
-}
-inline const ConstantInt *operator*(const DefOne &L, const DefZero &R) {
- if (R == 0) return getUnsignedConstant(0, L.getType());
- if (L == 0) return R->equalsInt(1) ? 0 : R.getVal();
- return Mul(L, R, true);
-}
-inline const ConstantInt *operator*(const DefZero &L, const DefOne &R) {
- if (L == 0 || R == 0) return L.getVal();
- return Mul(R, L, false);
+namespace {
+ inline const ConstantInt *operator*(const DefZero &L, const DefZero &R) {
+ if (L == 0 || R == 0) return 0;
+ return Mul(L, R, false);
+ }
+ inline const ConstantInt *operator*(const DefOne &L, const DefZero &R) {
+ if (R == 0) return getUnsignedConstant(0, L.getType());
+ if (L == 0) return R->equalsInt(1) ? 0 : R.getVal();
+ return Mul(L, R, true);
+ }
+ inline const ConstantInt *operator*(const DefZero &L, const DefOne &R) {
+ if (L == 0 || R == 0) return L.getVal();
+ return Mul(R, L, false);
+ }
}
// handleAddition - Add two expressions together, creating a new expression that
const Type *Ty = V->getType();
ConstantInt *Zero = getUnsignedConstant(0, Ty);
ConstantInt *One = getUnsignedConstant(1, Ty);
- ConstantInt *NegOne = cast<ConstantInt>(*Zero - *One);
+ ConstantInt *NegOne = cast<ConstantInt>(ConstantExpr::get(Instruction::Sub,
+ Zero, One));
if (NegOne == 0) return V; // Couldn't subtract values...
return ExprType(DefOne (E.Scale , Ty) * NegOne, E.Var,
}
-// ClassifyExpression: Analyze an expression to determine the complexity of the
-// expression, and which other values it depends on.
+// ClassifyExpr: Analyze an expression to determine the complexity of the
+// expression, and which other values it depends on.
//
// 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 llvm::ClassifyExpr(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
case Value::ArgumentVal: // nothing known, return variable itself
return Expr;
case Value::ConstantVal: // Constant value, just return constant
- Constant *CPV = cast<Constant>(Expr);
- if (CPV->getType()->isIntegral()) { // It's an integral constant!
- ConstantInt *CPI = cast<ConstantInt>(Expr);
- return ExprType(CPI->equalsInt(0) ? 0 : CPI);
- }
+ if (ConstantInt *CPI = dyn_cast<ConstantInt>(cast<Constant>(Expr)))
+ // It's an integral constant!
+ return ExprType(CPI->isNullValue() ? 0 : CPI);
return Expr;
}
Instruction *I = cast<Instruction>(Expr);
const Type *Ty = I->getType();
- switch (I->getOpcode()) { // Handle each instruction type seperately
+ switch (I->getOpcode()) { // Handle each instruction type separately
case Instruction::Add: {
- ExprType Left (ClassifyExpression(I->getOperand(0)));
- ExprType Right(ClassifyExpression(I->getOperand(1)));
+ ExprType Left (ClassifyExpr(I->getOperand(0)));
+ ExprType Right(ClassifyExpr(I->getOperand(1)));
return handleAddition(Left, Right, I);
} // end case Instruction::Add
case Instruction::Sub: {
- ExprType Left (ClassifyExpression(I->getOperand(0)));
- ExprType Right(ClassifyExpression(I->getOperand(1)));
+ ExprType Left (ClassifyExpr(I->getOperand(0)));
+ ExprType Right(ClassifyExpr(I->getOperand(1)));
ExprType RightNeg = negate(Right, I);
if (RightNeg.Var == I && !RightNeg.Offset && !RightNeg.Scale)
return I; // Could not negate value...
} // end case Instruction::Sub
case Instruction::Shl: {
- ExprType Right(ClassifyExpression(I->getOperand(1)));
+ ExprType Right(ClassifyExpr(I->getOperand(1)));
if (Right.ExprTy != ExprType::Constant) break;
- ExprType Left(ClassifyExpression(I->getOperand(0)));
+ ExprType Left(ClassifyExpr(I->getOperand(0)));
if (Right.Offset == 0) return Left; // shl x, 0 = x
assert(Right.Offset->getType() == Type::UByteTy &&
"Shift amount must always be a unsigned byte!");
- uint64_t ShiftAmount = ((ConstantUInt*)Right.Offset)->getValue();
+ uint64_t ShiftAmount = cast<ConstantUInt>(Right.Offset)->getValue();
ConstantInt *Multiplier = getUnsignedConstant(1ULL << ShiftAmount, Ty);
// We don't know how to classify it if they are shifting by more than what
} // end case Instruction::Shl
case Instruction::Mul: {
- ExprType Left (ClassifyExpression(I->getOperand(0)));
- ExprType Right(ClassifyExpression(I->getOperand(1)));
+ ExprType Left (ClassifyExpr(I->getOperand(0)));
+ ExprType Right(ClassifyExpr(I->getOperand(1)));
if (Left.ExprTy > Right.ExprTy)
std::swap(Left, Right); // Make left be simpler than right
} // end case Instruction::Mul
case Instruction::Cast: {
- ExprType Src(ClassifyExpression(I->getOperand(0)));
+ ExprType Src(ClassifyExpr(I->getOperand(0)));
const Type *DestTy = I->getType();
if (isa<PointerType>(DestTy))
DestTy = Type::ULongTy; // Pointer types are represented as ulong
- /*
- if (!Src.getExprType(0)->isLosslesslyConvertableTo(DestTy)) {
+ const Type *SrcValTy = Src.getExprType(0);
+ if (!SrcValTy) return I;
+ if (!SrcValTy->isLosslesslyConvertibleTo(DestTy)) {
if (Src.ExprTy != ExprType::Constant)
return I; // Converting cast, and not a constant value...
}
- */
const ConstantInt *Offset = Src.Offset;
const ConstantInt *Scale = Src.Scale;
if (Offset) {
- const Constant *CPV = ConstantFoldCastInstruction(Offset, DestTy);
- if (!CPV) return I;
+ const Constant *CPV = ConstantExpr::getCast((Constant*)Offset, DestTy);
+ if (!isa<ConstantInt>(CPV)) return I;
Offset = cast<ConstantInt>(CPV);
}
if (Scale) {
- const Constant *CPV = ConstantFoldCastInstruction(Scale, DestTy);
+ const Constant *CPV = ConstantExpr::getCast((Constant*)Scale, DestTy);
if (!CPV) return I;
Scale = cast<ConstantInt>(CPV);
}
projects / oota-llvm.git / blobdiff