SourceLocation DiagLoc;
EvalResult() : HasSideEffects(false), Diag(0), DiagExpr(0) {}
+
+ // isGlobalLValue - Return true if the evaluated lvalue expression
+ // is global.
+ bool isGlobalLValue() const;
+ // hasSideEffects - Return true if the evaluated expression has
+ // side effects.
+ bool hasSideEffects() const {
+ return HasSideEffects;
+ }
};
/// Evaluate - Return true if this is a constant which we can fold using
/// with link time known address.
bool EvaluateAsLValue(EvalResult &Result, ASTContext &Ctx) const;
+ /// EvaluateAsLValue - Evaluate an expression to see if it's a lvalue.
+ bool EvaluateAsAnyLValue(EvalResult &Result, ASTContext &Ctx) const;
+
/// \brief Enumeration used to describe how \c isNullPointerConstant()
/// should cope with value-dependent expressions.
enum NullPointerConstantValueDependence {
// Misc utilities
//===----------------------------------------------------------------------===//
-static bool IsGlobalLValue(LValue &Value) {
- const Expr *E = Value.Base;
+static bool IsGlobalLValue(const Expr* E) {
if (!E) return true;
if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
}
// Require the base expression to be a global l-value.
- if (!IsGlobalLValue(Value)) return false;
+ if (!IsGlobalLValue(Base)) return false;
// We have a non-null base expression. These are generally known to
// be true, but if it'a decl-ref to a weak symbol it can be null at
LValue LV;
if (!EvaluatePointer(E, LV, Info))
return false;
- if (!IsGlobalLValue(LV))
+ if (!IsGlobalLValue(LV.Base))
return false;
LV.moveInto(Info.EvalResult.Val);
} else if (E->getType()->isRealFloatingType()) {
LValue LV;
if (EvaluateLValue(this, LV, Info) &&
!Result.HasSideEffects &&
- IsGlobalLValue(LV)) {
+ IsGlobalLValue(LV.Base)) {
+ LV.moveInto(Result.Val);
+ return true;
+ }
+ return false;
+}
+
+bool Expr::EvaluateAsAnyLValue(EvalResult &Result, ASTContext &Ctx) const {
+ EvalInfo Info(Ctx, Result);
+
+ LValue LV;
+ if (EvaluateLValue(this, LV, Info)) {
LV.moveInto(Result.Val);
return true;
}
return EvalResult.Val.getInt();
}
+ bool Expr::EvalResult::isGlobalLValue() const {
+ assert(Val.isLValue());
+ return IsGlobalLValue(Val.getLValueBase());
+ }
+
+
/// isIntegerConstantExpr - this recursive routine will test if an expression is
/// an integer constant expression.