[clang][Interp] Handle PredefinedExprs

[tbaeder]

Ping

[shafik]

clang/test/AST/Interp/literals.cpp

855

Can we add tests for each predefined expressions, it does not look like there are a lot of them.

[tbaeder]

clang/test/AST/Interp/literals.cpp

855

Not sure that adds much value? Didn't the output of __PRETTY_FUNCTION__ change at some point in the last release even, which would make this test brittle?

[aaron.ballman]

clang/test/AST/Interp/literals.cpp

855

The behavior doesn't change all that often and we should test that we get the expected results from each of the expressions. It should be straightforward: https://godbolt.org/z/qveWPGWjK

[tbaeder]

clang/test/AST/Interp/literals.cpp

855

Oh well if you provide the test cases as well, that's of course a completely different situation :)

[aaron.ballman]

clang/test/AST/Interp/literals.cpp

869

You should add coverage for the others as well:

enum IdentKind {
  Func,
  Function,
  LFunction, // Same as Function, but as wide string.
  FuncDName,
  FuncSig,
  LFuncSig, // Same as FuncSig, but as wide string
  PrettyFunction,
  /// The same as PrettyFunction, except that the
  /// 'virtual' keyword is omitted for virtual member functions.
  PrettyFunctionNoVirtual
};

(you can handle the wide string variants by making strings_match into a template.)

[tbaeder]

clang/test/AST/Interp/literals.cpp

869

These don't seem to exist in C++14 onwards:

array.cpp:1238:33: error: use of undeclared identifier '__FUNCDNAME__'
 1238 |     static_assert(strings_match(__FUNCDNAME__, "foo"), "");
      |                                 ^
array.cpp:1239:33: error: use of undeclared identifier '__FUNCSIG__'
 1239 |     static_assert(strings_match(__FUNCSIG__, "foo"), "");
      |                                 ^
array.cpp:1240:33: error: use of undeclared identifier '__LFUNCSIG__'
 1240 |     static_assert(strings_match(__LFUNCSIG__, "foo"), "");
      |                                 ^
array.cpp:1241:33: error: use of undeclared identifier '__LFUNCTION__'
 1241 |     static_assert(strings_match(__LFUNCTION__, "foo"), "");
      |                                 ^
array.cpp:1244:33: error: use of undeclared identifier '__PRETTY_FUNCTION_NO_VIRTUAL__'
 1244 |     static_assert(strings_match(__PRETTY_FUNCTION_NO_VIRTUAL__, "void PredefinedExprs::foo()"), "");
      |                                 ^
5 errors generated.

... but I can't use a while loop (or any kind of loop, I think?) before C++14 :)

869

e

[aaron.ballman]

clang/test/AST/Interp/literals.cpp

869

They exist, but you need to enable -fms-extensions for them: https://godbolt.org/z/E94snrMd9

[aaron.ballman]

LGTM with a caution about testing the mangled signature (you can fix that up when landing though).

clang/test/AST/Interp/literals.cpp

868

I suspect this will pass for you on one ABI but fail on another due to mangling differences. You might need to specify an ABI on the RUN lines to account for that.

[shafik]

LGTM

clang/lib/AST/Interp/ByteCodeExprGen.h

public:
   bool VisitCompoundAssignOperator(const CompoundAssignOperator *E);
   bool VisitFloatCompoundAssignOperator(const CompoundAssignOperator *E);
   bool VisitPointerCompoundAssignOperator(const CompoundAssignOperator *E);
   bool VisitExprWithCleanups(const ExprWithCleanups *E);
   bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
   bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
   bool VisitTypeTraitExpr(const TypeTraitExpr *E);
   bool VisitLambdaExpr(const LambdaExpr *E);
+  bool VisitPredefinedExpr(const PredefinedExpr *E);
 
 protected:
   bool visitExpr(const Expr *E) override;
   bool visitDecl(const VarDecl *VD) override;
 
 protected:
   /// Emits scope cleanup instructions.
   void emitCleanup();

clang/lib/AST/Interp/ByteCodeExprGen.cpp

if (std::optional<PrimType> T = classify(Init)) {
       if (!this->emitPopPtr(E))
         return false;
     }
   }
 
   return true;
 }
 
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitPredefinedExpr(const PredefinedExpr *E) {
+  if (DiscardResult)
+    return true;
+
+  return this->visit(E->getFunctionName());
+}
+
 template <class Emitter> bool ByteCodeExprGen<Emitter>::discard(const Expr *E) {
   if (E->containsErrors())
     return false;
 
   OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/true);
   return this->Visit(E);
 }
 

clang/test/AST/Interp/literals.cpp

-// RUN: %clang_cc1 -fexperimental-new-constant-interpreter -std=c++11 -verify %s
-// RUN: %clang_cc1 -fexperimental-new-constant-interpreter -std=c++20 -verify %s
-// RUN: %clang_cc1 -std=c++11 -verify=ref %s
-// RUN: %clang_cc1 -std=c++20 -verify=ref %s
+// RUN: %clang_cc1 -fexperimental-new-constant-interpreter -fms-extensions -std=c++11 -verify %s
+// RUN: %clang_cc1 -fexperimental-new-constant-interpreter -fms-extensions -std=c++20 -verify %s
+// RUN: %clang_cc1 -std=c++11 -fms-extensions -verify=ref %s
+// RUN: %clang_cc1 -std=c++20 -fms-extensions -verify=ref %s
 
 #define INT_MIN (~__INT_MAX__)
 #define INT_MAX __INT_MAX__
 
 
 static_assert(true, "");
 static_assert(false, ""); // expected-error{{failed}} ref-error{{failed}}
 static_assert(nullptr == nullptr, "");
constexpr int ignoredExprs() {
   (void)a;
   (a); // expected-warning {{unused}} \
        // ref-warning {{unused}}
 
   return 0;
 }
 
 #endif
+
+namespace PredefinedExprs {
+#if __cplusplus >= 201402L
+  template<typename CharT>
+  constexpr bool strings_match(const CharT *str1, const CharT *str2) {
+    while (*str1 && *str2) {
+      if (*str1++ != *str2++)
+        return false;
+    };
+
+    return *str1 == *str2;
+  }
+
+  void foo() {
+    static_assert(strings_match(__FUNCSIG__, "void __cdecl PredefinedExprs::foo(void)"), "");
+    static_assert(strings_match(L__FUNCSIG__, L"void __cdecl PredefinedExprs::foo(void)"), "");
+    static_assert(strings_match(L__FUNCTION__, L"foo"), "");
+    static_assert(strings_match(__FUNCTION__, "foo"), "");
+    static_assert(strings_match(__func__, "foo"), "");
+    static_assert(strings_match(__PRETTY_FUNCTION__, "void PredefinedExprs::foo()"), "");
+  }
+#endif
+}