2008-07-03 12:20:39 +08:00
|
|
|
//===--- Expr.cpp - Expression Constant Evaluator -------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements the Expr constant evaluator.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "clang/AST/APValue.h"
|
|
|
|
#include "clang/AST/ASTContext.h"
|
|
|
|
#include "clang/AST/Expr.h"
|
2008-07-08 13:13:58 +08:00
|
|
|
#include "clang/AST/STmtVisitor.h"
|
2008-07-08 13:49:43 +08:00
|
|
|
#include "clang/Basic/TargetInfo.h"
|
2008-07-08 13:13:58 +08:00
|
|
|
#include "llvm/Support/Compiler.h"
|
2008-07-03 12:20:39 +08:00
|
|
|
|
|
|
|
using namespace clang;
|
|
|
|
|
2008-07-08 13:13:58 +08:00
|
|
|
#define USE_NEW_EVALUATOR 0
|
2008-07-03 12:20:39 +08:00
|
|
|
|
|
|
|
static bool CalcFakeICEVal(const Expr* Expr,
|
|
|
|
llvm::APSInt& Result,
|
|
|
|
ASTContext& Context) {
|
|
|
|
// Calculate the value of an expression that has a calculatable
|
|
|
|
// value, but isn't an ICE. Currently, this only supports
|
|
|
|
// a very narrow set of extensions, but it can be expanded if needed.
|
|
|
|
if (const ParenExpr *PE = dyn_cast<ParenExpr>(Expr))
|
|
|
|
return CalcFakeICEVal(PE->getSubExpr(), Result, Context);
|
|
|
|
|
|
|
|
if (const CastExpr *CE = dyn_cast<CastExpr>(Expr)) {
|
|
|
|
QualType CETy = CE->getType();
|
|
|
|
if ((CETy->isIntegralType() && !CETy->isBooleanType()) ||
|
|
|
|
CETy->isPointerType()) {
|
|
|
|
if (CalcFakeICEVal(CE->getSubExpr(), Result, Context)) {
|
|
|
|
Result.extOrTrunc(Context.getTypeSize(CETy));
|
|
|
|
// FIXME: This assumes pointers are signed.
|
|
|
|
Result.setIsSigned(CETy->isSignedIntegerType() ||
|
|
|
|
CETy->isPointerType());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Expr->getType()->isIntegralType())
|
|
|
|
return Expr->isIntegerConstantExpr(Result, Context);
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-07-08 13:13:58 +08:00
|
|
|
namespace {
|
|
|
|
class VISIBILITY_HIDDEN IntExprEvaluator
|
|
|
|
: public StmtVisitor<IntExprEvaluator, APValue> {
|
|
|
|
ASTContext &Ctx;
|
|
|
|
|
|
|
|
IntExprEvaluator(ASTContext &ctx)
|
|
|
|
: Ctx(ctx) {}
|
|
|
|
|
|
|
|
public:
|
2008-07-08 13:49:43 +08:00
|
|
|
static bool Evaluate(const Expr* E, llvm::APSInt& Result, ASTContext &Ctx) {
|
|
|
|
APValue Value = IntExprEvaluator(Ctx).Visit(const_cast<Expr*>(E));
|
|
|
|
if (!Value.isSInt())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Result = Value.getSInt();
|
|
|
|
return true;
|
2008-07-08 13:13:58 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
// Visitor Methods
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
APValue VisitStmt(Stmt *S) {
|
|
|
|
// FIXME: Remove this when we support more expressions.
|
|
|
|
printf("Unhandled statement\n");
|
|
|
|
S->dump();
|
|
|
|
return APValue();
|
|
|
|
}
|
|
|
|
|
2008-07-08 13:49:43 +08:00
|
|
|
APValue VisitParenExpr(ParenExpr *E) { return Visit(E->getSubExpr()); }
|
|
|
|
|
|
|
|
APValue VisitBinaryOperator(const BinaryOperator *E) {
|
|
|
|
// The LHS of a constant expr is always evaluated and needed.
|
|
|
|
llvm::APSInt Result(32);
|
|
|
|
if (!Evaluate(E->getRHS(), Result, Ctx))
|
|
|
|
return APValue();
|
|
|
|
|
|
|
|
llvm::APSInt RHS(32);
|
|
|
|
if (!Evaluate(E->getRHS(), RHS, Ctx))
|
|
|
|
return APValue();
|
|
|
|
|
|
|
|
switch (E->getOpcode()) {
|
|
|
|
default:
|
|
|
|
return APValue();
|
|
|
|
case BinaryOperator::Mul:
|
|
|
|
Result *= RHS;
|
|
|
|
break;
|
|
|
|
case BinaryOperator::Div:
|
|
|
|
if (RHS == 0)
|
|
|
|
return APValue();
|
|
|
|
Result /= RHS;
|
|
|
|
break;
|
|
|
|
case BinaryOperator::Rem:
|
|
|
|
if (RHS == 0)
|
|
|
|
return APValue();
|
|
|
|
Result %= RHS;
|
|
|
|
break;
|
|
|
|
case BinaryOperator::Add: Result += RHS; break;
|
|
|
|
case BinaryOperator::Sub: Result -= RHS; break;
|
|
|
|
case BinaryOperator::Shl:
|
|
|
|
Result <<=
|
|
|
|
static_cast<uint32_t>(RHS.getLimitedValue(Result.getBitWidth()-1));
|
|
|
|
break;
|
|
|
|
case BinaryOperator::Shr:
|
|
|
|
Result >>=
|
|
|
|
static_cast<uint32_t>(RHS.getLimitedValue(Result.getBitWidth()-1));
|
|
|
|
break;
|
|
|
|
case BinaryOperator::LT: Result = Result < RHS; break;
|
|
|
|
case BinaryOperator::GT: Result = Result > RHS; break;
|
|
|
|
case BinaryOperator::LE: Result = Result <= RHS; break;
|
|
|
|
case BinaryOperator::GE: Result = Result >= RHS; break;
|
|
|
|
case BinaryOperator::EQ: Result = Result == RHS; break;
|
|
|
|
case BinaryOperator::NE: Result = Result != RHS; break;
|
|
|
|
case BinaryOperator::And: Result &= RHS; break;
|
|
|
|
case BinaryOperator::Xor: Result ^= RHS; break;
|
|
|
|
case BinaryOperator::Or: Result |= RHS; break;
|
|
|
|
|
|
|
|
case BinaryOperator::Comma:
|
|
|
|
// C99 6.6p3: "shall not contain assignment, ..., or comma operators,
|
|
|
|
// *except* when they are contained within a subexpression that is not
|
|
|
|
// evaluated". Note that Assignment can never happen due to constraints
|
|
|
|
// on the LHS subexpr, so we don't need to check it here.
|
|
|
|
// FIXME: Need to come up with an efficient way to deal with the C99
|
|
|
|
// rules on evaluation while still evaluating this. Maybe a
|
|
|
|
// "evaluated comma" out parameter?
|
|
|
|
return APValue();
|
|
|
|
}
|
|
|
|
|
|
|
|
Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
|
|
|
|
|
|
|
|
return APValue(Result);
|
|
|
|
}
|
|
|
|
|
|
|
|
APValue VisitUnaryOperator(const UnaryOperator *E) {
|
|
|
|
llvm::APSInt Result(32);
|
|
|
|
|
|
|
|
if (E->isOffsetOfOp())
|
|
|
|
Result = E->evaluateOffsetOf(Ctx);
|
|
|
|
else if (E->isSizeOfAlignOfOp()) {
|
|
|
|
// Return the result in the right width.
|
|
|
|
Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(E->getType())));
|
2008-07-08 13:13:58 +08:00
|
|
|
|
2008-07-08 13:49:43 +08:00
|
|
|
// sizeof(void) and __alignof__(void) = 1 as a gcc extension.
|
|
|
|
if (E->getSubExpr()->getType()->isVoidType())
|
|
|
|
Result = 1;
|
|
|
|
|
|
|
|
// sizeof(vla) is not a constantexpr: C99 6.5.3.4p2.
|
|
|
|
if (!E->getSubExpr()->getType()->isConstantSizeType()) {
|
|
|
|
// FIXME: Should we attempt to evaluate this?
|
|
|
|
return APValue();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get information about the size or align.
|
|
|
|
if (E->getSubExpr()->getType()->isFunctionType()) {
|
|
|
|
// GCC extension: sizeof(function) = 1.
|
|
|
|
// FIXME: AlignOf shouldn't be unconditionally 4!
|
|
|
|
Result = E->getOpcode() == UnaryOperator::AlignOf ? 4 : 1;
|
|
|
|
} else {
|
|
|
|
unsigned CharSize = Ctx.Target.getCharWidth();
|
|
|
|
if (E->getOpcode() == UnaryOperator::AlignOf)
|
|
|
|
Result = Ctx.getTypeAlign(E->getSubExpr()->getType()) / CharSize;
|
|
|
|
else
|
|
|
|
Result = Ctx.getTypeSize(E->getSubExpr()->getType()) / CharSize;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Get the operand value. If this is sizeof/alignof, do not evalute the
|
|
|
|
// operand. This affects C99 6.6p3.
|
|
|
|
if (!Evaluate(E->getSubExpr(), Result, Ctx))
|
|
|
|
return APValue();
|
|
|
|
|
|
|
|
switch (E->getOpcode()) {
|
|
|
|
// Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
|
|
|
|
// See C99 6.6p3.
|
|
|
|
default:
|
|
|
|
return APValue();
|
|
|
|
case UnaryOperator::Extension:
|
|
|
|
assert(0 && "Handle UnaryOperator::Extension");
|
|
|
|
return APValue();
|
|
|
|
case UnaryOperator::LNot: {
|
|
|
|
bool Val = Result == 0;
|
|
|
|
uint32_t typeSize = Ctx.getTypeSize(E->getType());
|
|
|
|
Result.zextOrTrunc(typeSize);
|
|
|
|
Result = Val;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case UnaryOperator::Plus:
|
|
|
|
break;
|
|
|
|
case UnaryOperator::Minus:
|
|
|
|
Result = -Result;
|
|
|
|
break;
|
|
|
|
case UnaryOperator::Not:
|
|
|
|
Result = ~Result;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Result.setIsUnsigned(E->getType()->isUnsignedIntegerType());
|
|
|
|
return APValue(Result);
|
|
|
|
}
|
2008-07-08 13:13:58 +08:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2008-07-03 12:20:39 +08:00
|
|
|
bool Expr::tryEvaluate(APValue& Result, ASTContext &Ctx) const
|
|
|
|
{
|
|
|
|
llvm::APSInt sInt(1);
|
|
|
|
|
2008-07-08 13:13:58 +08:00
|
|
|
#if USE_NEW_EVALUATOR
|
2008-07-08 13:49:43 +08:00
|
|
|
if (getType()->isIntegerType()) {
|
|
|
|
if (IntExprEvaluator::Evaluate(this, sInt, Ctx)) {
|
|
|
|
Result = APValue(sInt);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
} else
|
2008-07-08 13:13:58 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
#else
|
2008-07-03 12:20:39 +08:00
|
|
|
if (CalcFakeICEVal(this, sInt, Ctx)) {
|
|
|
|
Result = APValue(sInt);
|
|
|
|
return true;
|
|
|
|
}
|
2008-07-08 13:13:58 +08:00
|
|
|
#endif
|
2008-07-03 12:20:39 +08:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|