[clang][Interp] Properly identify not-yet-defined functions

[tbaeder]

Summary

Since we now handle functions without a body as well, we can't just use
getHasBody() anymore. Funtions that haven't been defined yet are those
that don't have a body *and* aren't valid.

[tbaeder]

Just get the information whether the Function has a body directly from the FunctionDecl. This fixes referencing member functions that are defined later.

[tbaeder]

Ping

[tbaeder]

Ping

[aaron.ballman]

clang/test/AST/Interp/functions.cpp

166–182

Should we have some similar tests involving free functions as well?

Also, how does BodylessMemberFunction differ from F? They both look to be testing the same thing aside from return types.

Should we have a test that involves a defaulted special member function that is called explicitly? e.g., https://godbolt.org/z/nzjEcPMKG (Clang is correct here, GCC fails to catch the UB).

[tbaeder]

clang/test/AST/Interp/functions.cpp

166–182

We have a test for free-standing functions already higher up:

constexpr int f(); // expected-note {{declared here}} \
                   // ref-note {{declared here}}
[...]
constexpr int a() {
  return f();
}
constexpr int f() {
  return 5;
}
static_assert(a() == 5, "");

I think the two used to test something different, but now they test the same thing, yes. I'll remove one of them.

Should we have a test that involves a defaulted special member function that is called explicitly? e.g., https://godbolt.org/z/nzjEcPMKG (Clang is correct here, GCC fails to catch the UB).

That is also caught but the diagnostics are in the wrong place (and slightly different. The old interpreter emits "destruction of dereferenced null pointer" while the new one does "member call on dereferenced null pointer").

[shafik]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

1468

Why the check for isContexpr()?

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

1468

isConstexpr() just returns whether the function is valid (i.e. was compiled successfully). hasBody() can still return false for a valid function, if the funcdecl had no body.

[aaron.ballman]

LGTM

[shafik]

LGTM

clang/lib/AST/Interp/ByteCodeEmitter.cpp

if (!FuncDecl->isConstexpr() || !visitFunc(FuncDecl)) {
     // Create scopes from descriptors.
     llvm::SmallVector<Scope, 2> Scopes;
     for (auto &DS : Descriptors) {
       Scopes.emplace_back(std::move(DS));
     }
 
     // Set the function's code.
     Func->setCode(NextLocalOffset, std::move(Code), std::move(SrcMap),
-                  std::move(Scopes));
+                  std::move(Scopes), FuncDecl->hasBody());
     Func->setIsFullyCompiled(true);
     return Func;
   }
 }
 
 Scope::Local ByteCodeEmitter::createLocal(Descriptor *D) {
   NextLocalOffset += sizeof(Block);
   unsigned Location = NextLocalOffset;

clang/lib/AST/Interp/ByteCodeExprGen.cpp

Record *ByteCodeExprGen<Emitter>::getRecord(const RecordDecl *RD) {
   return P.getOrCreateRecord(RD);
 }
 
 template <class Emitter>
 const Function *ByteCodeExprGen<Emitter>::getFunction(const FunctionDecl *FD) {
   assert(FD);
   const Function *Func = P.getFunction(FD);
   bool IsBeingCompiled = Func && !Func->isFullyCompiled();
-  bool WasNotDefined = Func && !Func->hasBody();
+  bool WasNotDefined = Func && !Func->isConstexpr() && !Func->hasBody();
 
   if (IsBeingCompiled)
     return Func;
 
   if (!Func || WasNotDefined) {
     if (auto R = ByteCodeStmtGen<ByteCodeEmitter>(Ctx, P).compileFunc(FD))
       Func = *R;
     else {

clang/lib/AST/Interp/Function.h

 private:
   /// Construct a function representing an actual function.
   Function(Program &P, const FunctionDecl *F, unsigned ArgSize,
            llvm::SmallVector<PrimType, 8> &&ParamTypes,
            llvm::DenseMap<unsigned, ParamDescriptor> &&Params,
            bool HasThisPointer, bool HasRVO);
 
   /// Sets the code of a function.
-  void setCode(unsigned NewFrameSize, std::vector<char> &&NewCode, SourceMap &&NewSrcMap,
-               llvm::SmallVector<Scope, 2> &&NewScopes) {
+  void setCode(unsigned NewFrameSize, std::vector<char> &&NewCode,
+               SourceMap &&NewSrcMap, llvm::SmallVector<Scope, 2> &&NewScopes,
+               bool NewHasBody) {
     FrameSize = NewFrameSize;
     Code = std::move(NewCode);
     SrcMap = std::move(NewSrcMap);
     Scopes = std::move(NewScopes);
     IsValid = true;
-    HasBody = true;
+    HasBody = NewHasBody;
   }
 
   void setIsFullyCompiled(bool FC) { IsFullyCompiled = FC; }
 
 private:
   friend class Program;
   friend class ByteCodeEmitter;
 

clang/test/AST/Interp/functions.cpp

struct S {
     void (*fp)();
   };
 
   constexpr S s{ 12 };
   static_assert(s.fp == nullptr, ""); // zero-initialized function pointer.
 }
 
 }
+
+struct F {
+  constexpr bool ok() const {
+    return okRecurse();
+  }
+  constexpr bool okRecurse() const {
+    return true;
+  }
+};
+
+struct BodylessMemberFunction {
+  constexpr int first() const {
+    return second();
+  }
+  constexpr int second() const {
+    return 1;
+  }
+};