[clang][Interp] Implement __builtin_strlen

[cor3ntin]

clang/lib/AST/Interp/InterpBuiltin.cpp

136–147

maybe a do while would be cleaner

149

Why not do that in this patch?

[tbaeder]

clang/lib/AST/Interp/InterpBuiltin.cpp

149

I was trying to keep the patch small but here it is.

[cor3ntin]

LGTM, modulo suggestion

clang/lib/AST/Interp/InterpBuiltin.cpp

63–69

Maybe we could have

pushSignedInteger(InterpState &S, unsigned bit width, int64_t Val);
pushUnsignedInteger(InterpState &S, unsigned bit width, int64_t Val)

to simplify pushSizeT and pushInt

[vitalybuka]

Reverted with D155568

[tbaeder]

This has been pushed already.

clang/lib/AST/Interp/InterpBuiltin.cpp

static bool retInt(InterpState &S, CodePtr OpPC, APValue &Result) {
 
   if (IntWidth == 32)
     return Ret<PT_Sint32>(S, OpPC, Result);
   else if (IntWidth == 16)
     return Ret<PT_Sint16>(S, OpPC, Result);
   llvm_unreachable("Int isn't 16 or 32 bit?");
 }
 
+static void pushSizeT(InterpState &S, uint64_t Val) {
+  const TargetInfo &TI = S.getCtx().getTargetInfo();
+  unsigned SizeTWidth = TI.getTypeWidth(TI.getSizeType());
+
+  if (SizeTWidth == 64)
+    S.Stk.push<Integral<64, false>>(Integral<64, false>::from(Val));
+  else if (SizeTWidth == 32)
+    S.Stk.push<Integral<32, false>>(Integral<32, false>::from(Val));
+  else
+    llvm_unreachable("size_t isn't 64 or 32 bit?");
+}
+
+static bool retSizeT(InterpState &S, CodePtr OpPC, APValue &Result) {
+  const TargetInfo &TI = S.getCtx().getTargetInfo();
+  unsigned SizeTWidth = TI.getTypeWidth(TI.getSizeType());
+
+  if (SizeTWidth == 64)
+    return Ret<PT_Uint64>(S, OpPC, Result);
+  else if (SizeTWidth == 32)
+    return Ret<PT_Uint32>(S, OpPC, Result);
+
+  llvm_unreachable("size_t isn't 64 or 32 bit?");
+}
+
 static bool interp__builtin_strcmp(InterpState &S, CodePtr OpPC,
                                    const InterpFrame *Frame) {
   const Pointer &A = getParam<Pointer>(Frame, 0);
   const Pointer &B = getParam<Pointer>(Frame, 1);
 
   if (!CheckLive(S, OpPC, A, AK_Read) || !CheckLive(S, OpPC, B, AK_Read))
     return false;
 
for (;; ++IndexA, ++IndexB) {
     if (CA == 0 || CB == 0)
       break;
   }
 
   pushInt(S, Result);
   return true;
 }
 
+static bool interp__builtin_strlen(InterpState &S, CodePtr OpPC,
+                                   const InterpFrame *Frame) {
+  const Pointer &StrPtr = getParam<Pointer>(Frame, 0);
+
+  if (!CheckArray(S, OpPC, StrPtr))
+    return false;
+
+  if (!CheckLive(S, OpPC, StrPtr, AK_Read))
+    return false;
+
+  assert(StrPtr.getFieldDesc()->isPrimitiveArray());
+
+  size_t Len = 0;
+  for (size_t I = StrPtr.getIndex();; ++I, ++Len) {
+    const Pointer &ElemPtr = StrPtr.atIndex(I);
+
+    if (!CheckRange(S, OpPC, ElemPtr, AK_Read))
+      return false;
+
+    uint8_t Val = ElemPtr.deref<uint8_t>();
+    if (Val == 0)
+      break;
+  }
+
+  pushSizeT(S, Len);
+  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;
 
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 retInt(S, OpPC, Dummy);
     break;
+  case Builtin::BI__builtin_strlen:
+    if (interp__builtin_strlen(S, OpPC, Frame))
+      return retSizeT(S, OpPC, Dummy);
+    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;

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
+// RUN: %clang_cc1 -Wno-string-plus-int -fexperimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -Wno-string-plus-int -fexperimental-new-constant-interpreter -triple i686 %s -verify
+// RUN: %clang_cc1 -Wno-string-plus-int -verify=ref %s -Wno-constant-evaluated
+// RUN: %clang_cc1 -std=c++20 -Wno-string-plus-int -fexperimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++20 -Wno-string-plus-int -fexperimental-new-constant-interpreter -triple i686 %s -verify
+// RUN: %clang_cc1 -std=c++20 -Wno-string-plus-int -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, "");
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}}
 }
 
+/// Copied from constant-expression-cxx11.cpp
+namespace strlen {
+constexpr const char *a = "foo\0quux";
+  constexpr char b[] = "foo\0quux";
+  constexpr int f() { return 'u'; }
+  constexpr char c[] = { 'f', 'o', 'o', 0, 'q', f(), 'u', 'x', 0 };
+
+  static_assert(__builtin_strlen("foo") == 3, "");
+  static_assert(__builtin_strlen("foo\0quux") == 3, "");
+  static_assert(__builtin_strlen("foo\0quux" + 4) == 4, "");
+
+  constexpr bool check(const char *p) {
+    return __builtin_strlen(p) == 3 &&
+           __builtin_strlen(p + 1) == 2 &&
+           __builtin_strlen(p + 2) == 1 &&
+           __builtin_strlen(p + 3) == 0 &&
+           __builtin_strlen(p + 4) == 4 &&
+           __builtin_strlen(p + 5) == 3 &&
+           __builtin_strlen(p + 6) == 2 &&
+           __builtin_strlen(p + 7) == 1 &&
+           __builtin_strlen(p + 8) == 0;
+  }
+
+  static_assert(check(a), "");
+  static_assert(check(b), "");
+  static_assert(check(c), "");
+
+  constexpr int over1 = __builtin_strlen(a + 9); // expected-error {{constant expression}} \
+                                                 // expected-note {{one-past-the-end}} \
+                                                 // expected-note {{in call to}} \
+                                                 // ref-error {{constant expression}} \
+                                                 // ref-note {{one-past-the-end}}
+  constexpr int over2 = __builtin_strlen(b + 9); // expected-error {{constant expression}} \
+                                                 // expected-note {{one-past-the-end}} \
+                                                 // expected-note {{in call to}} \
+                                                 // ref-error {{constant expression}} \
+                                                 // ref-note {{one-past-the-end}}
+  constexpr int over3 = __builtin_strlen(c + 9); // expected-error {{constant expression}} \
+                                                 // expected-note {{one-past-the-end}} \
+                                                 // expected-note {{in call to}} \
+                                                 // ref-error {{constant expression}} \
+                                                 // ref-note {{one-past-the-end}}
+
+  constexpr int under1 = __builtin_strlen(a - 1); // expected-error {{constant expression}} \
+                                                  // expected-note {{cannot refer to element -1}} \
+                                                  // ref-error {{constant expression}} \
+                                                  // ref-note {{cannot refer to element -1}}
+  constexpr int under2 = __builtin_strlen(b - 1); // expected-error {{constant expression}} \
+                                                  // expected-note {{cannot refer to element -1}} \
+                                                  // ref-error {{constant expression}} \
+                                                  // ref-note {{cannot refer to element -1}}
+  constexpr int under3 = __builtin_strlen(c - 1); // expected-error {{constant expression}} \
+                                                  // expected-note {{cannot refer to element -1}} \
+                                                  // ref-error {{constant expression}} \
+                                                  // ref-note {{cannot refer to element -1}}
+
+  constexpr char d[] = { 'f', 'o', 'o' }; // no nul terminator.
+  constexpr int bad = __builtin_strlen(d); // expected-error {{constant expression}} \
+                                           // expected-note {{one-past-the-end}} \
+                                           // expected-note {{in call to}} \
+                                           // ref-error {{constant expression}} \
+                                           // ref-note {{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}}