__builtin_constant_p should consider the parameter of a constexpr function as constant

[ogoffart]

Summary

This allows to do something like:

constexpr int func(int x) {
  return __builtin_constant_p(x) ? compute_constexpr(x) : compute_runtime(x);
}

This kind of code is accepted by GCC since GCC 4.8.

The problem was that EvaluateBuiltinConstantP was discarding the EvalInfo and its frames. So just keep the EvalInfo

[ogoffart]

Ping

[joerg]

What if the constexpr function is called with in a non-constexpr context, e.g. with a random global variable as argument?

[ogoffart]

What if the constexpr function is called with in a non-constexpr context, e.g. with a random global variable as argument?

__builtin_constant_p will still return false in this case, contrary to gcc (whose behavior actually depends on the optimization level).

I think if we really want to get the exact gcc behavior, we need to mix it with the optimizer and generate some LLVM intrinsics. But what I was interested on with this patch is at least get a closer behavior as GCC in a constexpr context

[efriedma]

See https://bugs.llvm.org/show_bug.cgi?id=4898 for more discussion of __builtin_constant_p in LLVM vs. gcc.

[ogoffart]

Thanks for the link to the bug report.
This patch mostly address the evaluation within a constexpr, which is orthogonal to the changes in the backend suggered in that bug report.

[ogoffart]

Is there any objections for this patch?

[ogoffart]

ping

lib/AST/ExprConstant.cpp

 template<typename LValue>
 static bool EvaluateBuiltinConstantPForLValue(const LValue &LV) {
   const Expr *E = LV.getLValueBase().template dyn_cast<const Expr*>();
   return E && isa<StringLiteral>(E) && LV.getLValueOffset().isZero();
 }
 
 /// EvaluateBuiltinConstantP - Evaluate __builtin_constant_p as similarly to
 /// GCC as we can manage.
-static bool EvaluateBuiltinConstantP(ASTContext &Ctx, const Expr *Arg) {
+static bool EvaluateBuiltinConstantP(EvalInfo &Info, const Expr *Arg) {
   QualType ArgType = Arg->getType();
 
   // __builtin_constant_p always has one operand. The rules which gcc follows
   // are not precisely documented, but are as follows:
   //
   //  - If the operand is of integral, floating, complex or enumeration type,
   //    and can be folded to a known value of that type, it returns 1.
   //  - If the operand and can be folded to a pointer to the first character
   //    of a string literal (or such a pointer cast to an integral type), it
   //    returns 1.
   //
   // Otherwise, it returns 0.
   //
   // FIXME: GCC also intends to return 1 for literals of aggregate types, but
   // its support for this does not currently work.
-  if (ArgType->isIntegralOrEnumerationType()) {
-    Expr::EvalResult Result;
-    if (!Arg->EvaluateAsRValue(Result, Ctx) || Result.HasSideEffects)
+  SpeculativeEvaluationRAII SpeculativeEval(Info);
+  FoldConstant Fold(Info, true);
+  if (ArgType->isIntegralOrEnumerationType() || ArgType->isFloatingType() ||
+      ArgType->isAnyComplexType()) {
+    APValue V;
+    if (!EvaluateAsRValue(Info, Arg, V) || Info.EvalStatus.HasSideEffects)
       return false;
-
-    APValue &V = Result.Val;
-    if (V.getKind() == APValue::Int)
+    if (V.getKind() == APValue::Int || V.getKind() == APValue::Float ||
+        V.getKind() == APValue::ComplexInt ||
+        V.getKind() == APValue::ComplexFloat)
       return true;
     if (V.getKind() == APValue::LValue)
       return EvaluateBuiltinConstantPForLValue(V);
-  } else if (ArgType->isFloatingType() || ArgType->isAnyComplexType()) {
-    return Arg->isEvaluatable(Ctx);
   } else if (ArgType->isPointerType() || Arg->isGLValue()) {
     LValue LV;
-    Expr::EvalStatus Status;
-    EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantFold);
     if ((Arg->isGLValue() ? EvaluateLValue(Arg, LV, Info)
                           : EvaluatePointer(Arg, LV, Info)) &&
-        !Status.HasSideEffects)
+        !Info.EvalStatus.HasSideEffects)
       return EvaluateBuiltinConstantPForLValue(LV);
   }
 
   // Anything else isn't considered to be sufficiently constant.
   return false;
 }
 
 /// Retrieves the "underlying object type" of the given expression,

       return false;
     if (!Val)
       return Error(E);
 
     return Success(Val.countLeadingZeros(), E);
   }
 
   case Builtin::BI__builtin_constant_p:
-    return Success(EvaluateBuiltinConstantP(Info.Ctx, E->getArg(0)), E);
+    return Success(EvaluateBuiltinConstantP(Info, E->getArg(0)), E);
 
   case Builtin::BI__builtin_ctz:
   case Builtin::BI__builtin_ctzl:
   case Builtin::BI__builtin_ctzll:
   case Builtin::BI__builtin_ctzs: {
     APSInt Val;
     if (!EvaluateInteger(E->getArg(0), Val, Info))
       return false;

test/SemaCXX/constant-expression-cxx11.cpp

   constexpr int *e = a + 1 + (long)-1;
   constexpr int *f = a + 1 + (unsigned long)-1; // expected-error {{constant expression}} expected-note {{cannot refer to element 1844}}
   constexpr int *g = a + 1 - (unsigned long)1;
 
   constexpr int *p = (&n + 1) + (unsigned __int128)-1; // expected-error {{constant expression}} expected-note {{cannot refer to element 3402}}
   constexpr int *q = (&n + 1) - (unsigned __int128)-1; // expected-error {{constant expression}} expected-note {{cannot refer to element -3402}}
   constexpr int *r = &(&n + 1)[(unsigned __int128)-1]; // expected-error {{constant expression}} expected-note {{cannot refer to element 3402}}
 }
+
+namespace BuiltinConstantP {
+  int computeRuntime(int);
+  constexpr int compute(int x) {
+    return __builtin_constant_p(x) ? x + 2 : computeRuntime(x);
+  }
+  constexpr int x = compute(25);
+  int n; // expected-note{{declared here}}
+  constexpr int z = compute(n); // expected-error {{constant expression}} expected-note{{non-const variable}}
+}

test/SemaCXX/constant-expression-cxx1y.cpp

 static_assert(sum(Cs) == 'a' + 'b', ""); // expected-error{{not an integral constant expression}} expected-note{{in call to 'sum(Cs)'}}
 constexpr int S = sum(Cs); // expected-error{{must be initialized by a constant expression}} expected-note{{in call}}
 }
 
 constexpr void PR28739(int n) { // expected-error {{never produces a constant}}
   int *p = &n;
   p += (__int128)(unsigned long)-1; // expected-note {{cannot refer to element 18446744073709551615 of non-array object in a constant expression}}
 }
+
+namespace BuiltinConstantP {
+  constexpr int f1(int i) { return __builtin_constant_p(i += 4) ? 0 : i += 3; }
+  static_assert(f1(10) == 13, "");
+}