//===----------------------------------------------------------------------===//
#include "llvm/Analysis/Expressions.h"
-#include "llvm/Transforms/Scalar/ConstantHandling.h"
+#include "llvm/ConstantHandling.h"
#include "llvm/Function.h"
-#include "llvm/BasicBlock.h"
-#include <iostream>
-
-using namespace analysis;
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;
}
// happen for values in the range of 0 to 127.
//
static ConstantInt *getUnsignedConstant(uint64_t V, const Type *Ty) {
- if (Ty->isPointerType()) Ty = Type::ULongTy;
+ if (isa<PointerType>(Ty)) Ty = Type::ULongTy;
if (Ty->isSigned()) {
// If this value is not a valid unsigned value for this type, return null!
if (V > 127 && ((int64_t)V < 0 ||
// 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
switch (Expr->getValueType()) {
case Value::InstructionVal: break; // Instruction... hmmm... investigate.
case Value::TypeVal: case Value::BasicBlockVal:
- case Value::FunctionVal: case Value::ModuleVal: default:
+ case Value::FunctionVal: default:
//assert(0 && "Unexpected expression type to classify!");
std::cerr << "Bizarre thing to expr classify: " << Expr << "\n";
return Expr;
case Value::GlobalVariableVal: // Global Variable & Function argument:
- case Value::FunctionArgumentVal: // nothing known, return variable itself
+ 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;
}
case Instruction::Cast: {
ExprType Src(ClassifyExpression(I->getOperand(0)));
const Type *DestTy = I->getType();
- if (DestTy->isPointerType())
+ if (isa<PointerType>(DestTy))
DestTy = Type::ULongTy; // Pointer types are represented as ulong
/*