[clang][Interp] Implement __builtin_nan family of functions

[tbaeder]

Summary

One existing problem is that we can't do much with the values since comparing with nans is broken ATM and I don't want to make this patch depend on the __builtin_bit_cast patch.

[aaron.ballman]

clang/lib/AST/Interp/InterpBuiltin.cpp

90

Please add test coverage for a case like __builtin_nan("derp") to show it's not a valid constant expression.

108

LOL, thank you for this comment and wow. :-D

140–142

We should have test coverage for these odd sizes just to ensure we're properly pushing/popping what we expect off the stack.

clang/test/AST/Interp/builtin-functions.cpp

44

Probably worth a comment here mentioning that the ref-error is a rejects-valid issue that the experimental compiler accepts correctly.

[tbaeder]

clang/test/AST/Interp/builtin-functions.cpp

44

I thought you said on Discord that the current interpreter is correct? I made the new one reject anything but string literals in https://reviews.llvm.org/D155545.

[aaron.ballman]

clang/test/AST/Interp/builtin-functions.cpp

44

Oops, crossing streams as I just mentioned this in another review of yours in the same area.

I think I misunderstood the question on Discord when we were chatting. I was thinking the situation was more that Sema was allowing through something like __builtin_nan(12); and diagnosing it later during CodeGen. I think constexpr builtins should generally behave the same as regular constexpr functions the user could write.

I'm really sorry if I made extra work for you with this confusion!

[tbaeder]

clang/lib/AST/Interp/InterpBuiltin.cpp

108

That's just copy/paste from ExprConst.cpp :)

clang/test/AST/Interp/builtin-functions.cpp

44

No problem, passing the CallExpr along still makes sense.

[tbaeder]

One thing I'm wondering though is:

constexpr char A[] = {'1', '2', '3'};
constexpr double d = __builtin_nans(A);

what's expected here? The given char array is not null-terminated.
Should the interpreter ignore the null byte at the end if it's there? StringRef::getAsInteger() always returns an error if it encounters one, so the currentcode in InterpBuiltin.cpp ignores the last byte and will pass 12 along for the example above.

[aaron.ballman]

In D155356#4513303, @tbaeder wrote:

One thing I'm wondering though is:

constexpr char A[] = {'1', '2', '3'};
constexpr double d = __builtin_nans(A);

what's expected here? The given char array is not null-terminated.

The builtin expects a null terminated string, so that should be an invalid constant expression due to reading off the end of the array.

Should the interpreter ignore the null byte at the end if it's there? StringRef::getAsInteger() always returns an error if it encounters one, so the currentcode in InterpBuiltin.cpp ignores the last byte and will pass 12 along for the example above.

Yeah, we should not do that. :-D In GCC, this builtin exists to support the nans() function from https://www.open-std.org/jtc1/sc22/wg14/www/docs/n965.htm (which was proposed but never adopted); Clang's support is for parity with GCC.

[aaron.ballman]

clang/test/AST/Interp/builtin-functions.cpp

45

This should be accepted by both the current and the new interpreter, right?

53

This should be accepted, shouldn't it? The payload is a valid integer constant (as a string).

[tbaeder]

clang/test/AST/Interp/builtin-functions.cpp

53

So answer both your questions: Yes, but the current interpreter has a isa<StringLiteral>() check and rejects everything that isn't a string literal.

[aaron.ballman]

LG!

clang/test/AST/Interp/builtin-functions.cpp

53

Ah! Slap some FIXME comments around the two cases to explain what's going on and that can be solved separately. Seem reasonable?

[tbaeder]

clang/test/AST/Interp/builtin-functions.cpp

53

Sure, I can do that.

clang/lib/AST/Interp/InterpBuiltin.cpp

 //===--- InterpBuiltin.cpp - Interpreter for the constexpr VM ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "Boolean.h"
 #include "Interp.h"
 #include "PrimType.h"
 #include "clang/Basic/Builtins.h"
+#include "clang/Basic/TargetInfo.h"
 
 namespace clang {
 namespace interp {
 
 template <typename T>
 static T getParam(const InterpFrame *Frame, unsigned Index) {
   assert(Frame->getFunction()->getNumParams() > Index);
   unsigned Offset = Frame->getFunction()->getParamOffset(Index);
for (;; ++IndexA, ++IndexB) {
     if (CA == 0 || CB == 0)
       break;
   }
 
   S.Stk.push<Integral<32, true>>(Integral<32, true>::from(Result));
   return true;
 }
 
+static bool interp__builtin_nan(InterpState &S, CodePtr OpPC,
+                                const InterpFrame *Frame, const Function *F,
+                                bool Signaling) {
+  const Pointer &Arg = getParam<Pointer>(Frame, 0);
+
+  if (!CheckLoad(S, OpPC, Arg))
+    return false;
+
+  assert(Arg.getFieldDesc()->isPrimitiveArray());
+
+  // Convert the given string to an integer using StringRef's API.
+  llvm::APInt Fill;
+  std::string Str;
+  assert(Arg.getNumElems() >= 1);
+  for (unsigned I = 0;; ++I) {
+    const Pointer &Elem = Arg.atIndex(I);
+
+    if (!CheckLoad(S, OpPC, Elem))
+      return false;
+
+    if (Elem.deref<int8_t>() == 0)
+      break;
+
+    Str += Elem.deref<char>();
+  }
+
+  // Treat empty strings as if they were zero.
+  if (Str.empty())
+    Fill = llvm::APInt(32, 0);
+  else if (StringRef(Str).getAsInteger(0, Fill))
+    return false;
+
+  const llvm::fltSemantics &TargetSemantics =
+      S.getCtx().getFloatTypeSemantics(F->getDecl()->getReturnType());
+
+  Floating Result;
+  if (S.getCtx().getTargetInfo().isNan2008()) {
+    if (Signaling)
+      Result = Floating(
+          llvm::APFloat::getSNaN(TargetSemantics, /*Negative=*/false, &Fill));
+    else
+      Result = Floating(
+          llvm::APFloat::getQNaN(TargetSemantics, /*Negative=*/false, &Fill));
+  } else {
+    // Prior to IEEE 754-2008, architectures were allowed to choose whether
+    // the first bit of their significand was set for qNaN or sNaN. MIPS chose
+    // a different encoding to what became a standard in 2008, and for pre-
+    // 2008 revisions, MIPS interpreted sNaN-2008 as qNan and qNaN-2008 as
+    // sNaN. This is now known as "legacy NaN" encoding.
+    if (Signaling)
+      Result = Floating(
+          llvm::APFloat::getQNaN(TargetSemantics, /*Negative=*/false, &Fill));
+    else
+      Result = Floating(
+          llvm::APFloat::getSNaN(TargetSemantics, /*Negative=*/false, &Fill));
+  }
+
+  S.Stk.push<Floating>(Result);
+  return true;
+}
+
 bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const Function *F) {
   InterpFrame *Frame = S.Current;
   APValue Dummy;
 
   switch (F->getBuiltinID()) {
   case Builtin::BI__builtin_is_constant_evaluated:
     S.Stk.push<Boolean>(Boolean::from(S.inConstantContext()));
     return Ret<PT_Bool>(S, OpPC, Dummy);
   case Builtin::BI__builtin_assume:
     return RetVoid(S, OpPC, Dummy);
   case Builtin::BI__builtin_strcmp:
     if (interp__builtin_strcmp(S, OpPC, Frame))
       return Ret<PT_Sint32>(S, OpPC, Dummy);
-    return false;
+    break;
+  case Builtin::BI__builtin_nan:
+  case Builtin::BI__builtin_nanf:
+  case Builtin::BI__builtin_nanl:
+  case Builtin::BI__builtin_nanf16:
+  case Builtin::BI__builtin_nanf128:
+    if (interp__builtin_nan(S, OpPC, Frame, F, /*Signaling=*/false))
+      return Ret<PT_Float>(S, OpPC, Dummy);
+    break;
+  case Builtin::BI__builtin_nans:
+  case Builtin::BI__builtin_nansf:
+  case Builtin::BI__builtin_nansl:
+  case Builtin::BI__builtin_nansf16:
+  case Builtin::BI__builtin_nansf128:
+    if (interp__builtin_nan(S, OpPC, Frame, F, /*Signaling=*/true))
+      return Ret<PT_Float>(S, OpPC, Dummy);
+    break;
+
   default:
     return false;
   }
 
   return false;
 }
 
 } // namespace interp
 } // namespace clang

clang/test/AST/Interp/builtin-functions.cpp

 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter %s -verify
 // RUN: %clang_cc1 -verify=ref %s -Wno-constant-evaluated
+// RUN: %clang_cc1 -std=c++20 -fexperimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++20 -verify=ref %s -Wno-constant-evaluated
+
 
 namespace strcmp {
   constexpr char kFoobar[6] = {'f','o','o','b','a','r'};
   constexpr char kFoobazfoobar[12] = {'f','o','o','b','a','z','f','o','o','b','a','r'};
 
   static_assert(__builtin_strcmp("", "") == 0, "");
   static_assert(__builtin_strcmp("abab", "abab") == 0, "");
   static_assert(__builtin_strcmp("abab", "abba") == -1, "");
namespace strcmp {
 
   static_assert(__builtin_strcmp(kFoobar, kFoobazfoobar) == -1, "");
   static_assert(__builtin_strcmp(kFoobar, kFoobazfoobar + 6) == 0, ""); // expected-error {{not an integral constant}} \
                                                                         // expected-note {{dereferenced one-past-the-end}} \
                                                                         // expected-note {{in call to}} \
                                                                         // ref-error {{not an integral constant}} \
                                                                         // ref-note {{dereferenced one-past-the-end}}
 }
+
+namespace nan {
+  constexpr double NaN1 = __builtin_nan("");
+
+  /// The current interpreter does not accept this, but it should.
+  constexpr float NaN2 = __builtin_nans([](){return "0xAE98";}()); // ref-error {{must be initialized by a constant expression}}
+
+  constexpr double NaN3 = __builtin_nan("foo"); // expected-error {{must be initialized by a constant expression}} \
+                                                // ref-error {{must be initialized by a constant expression}}
+  constexpr float NaN4 = __builtin_nanf("");
+  constexpr long double NaN5 = __builtin_nanf128("");
+
+  /// FIXME: This should be accepted by the current interpreter as well.
+  constexpr char f[] = {'0', 'x', 'A', 'E', '\0'};
+  constexpr double NaN6 = __builtin_nan(f); // ref-error {{must be initialized by a constant expression}}
+
+  /// FIXME: Current interpreter misses diagnostics.
+  constexpr char f2[] = {'0', 'x', 'A', 'E'}; /// No trailing 0 byte.
+  constexpr double NaN7 = __builtin_nan(f2); // ref-error {{must be initialized by a constant expression}} \
+                                             // expected-error {{must be initialized by a constant expression}} \
+                                             // expected-note {{read of dereferenced one-past-the-end pointer}} \
+                                             // expected-note {{in call to}}
+}