[clang][Interp] Handle PredefinedExprs

[tbaeder]

Ping

[shafik]

clang/test/AST/Interp/literals.cpp

835

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

835

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

835

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

835

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

849

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

849

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 :)

849

e

[aaron.ballman]

clang/test/AST/Interp/literals.cpp

849

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

848

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 VisitPointerCompoundAssignOperator(const CompoundAssignOperator *E);
   bool VisitExprWithCleanups(const ExprWithCleanups *E);
   bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
   bool VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *E);
   bool VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *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(__FUNCDNAME__, "_ZN15PredefinedExprs3fooEv"), "");
+    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"), "0x402010");
+    static_assert(strings_match(__FUNCTION__, "foo"), "");
+    static_assert(strings_match(__func__, "foo"), "");
+    static_assert(strings_match(__PRETTY_FUNCTION__, "void PredefinedExprs::foo()"), "");
+  }
+#endif
+}