[clang][Interp] Start implementing builtin functions

[tbaeder]

Summary

Another try at this.

This time, only implement __builtin_is_constant_evaluated().

Unfortunately I can't just use clang/test/SemaCXX/builtin-is-constant-evaluated.cpp because there are some other unsupported expressions in there.

[tschuett]

clang/lib/AST/Interp/InterpBuiltin.cpp

14

You are allowed to use nested namespaces.

[tbaeder]

Ping

[erichkeane]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

1374

This is an unrelated change, perhaps could be in an NFC commit.

clang/lib/AST/Interp/Interp.h

1354–1358

directly reads oddly here? Do you mean the 'immediately' definition of this?

1355

Rather than the 'if'/'else' pair, do we just want to immediately return on the failed builtin?

1357

What is going on here? Why is this not a leak?

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

1374

Right, sure

clang/lib/AST/Interp/Interp.h

1354–1358

Yes, that was the purpose. I can reword it.

1355

Sure, that's possible. I guess this ties into the question of whether to use a different opcode for builtin functions; but so far I have found builtin calls to be too similar to regular ones, esp. since they don't have a special AST node.

1357

The current frame is deleted when successfully returning the value of the function, this happens in the Ret (and RetVoid) function in Interp.cpp.

No opinion on whether that's the best way to do it though.

[erichkeane]

clang/lib/AST/Interp/Interp.h

1357

I really dont like doing it this way, I see we're doing it the same in 1366, but if we're expecting someone else to delete a unique-ptr, we should give them ownership of the whole unique-ptr. This mechanism is just obscuring the ownership semantics that unique_ptr is supposed to imply.

[tbaeder]

clang/lib/AST/Interp/Interp.h

1357

I blame @aaron.ballman :)

I'm gonna write it on my list and create a follow-up patch.

[tbaeder]

Split CallBI out from Call, so we don't need special cases in CheckCallable etc. for builtin functions.

[shafik]

clang/lib/AST/Interp/Interp.h

1392

We don't have to update S.Current?

clang/lib/AST/Interp/InterpBuiltin.cpp

21

Why not just factor out Ret now?

[tbaeder]

clang/lib/AST/Interp/Interp.h

1392

Nope, Ret does that.

clang/lib/AST/Interp/InterpBuiltin.cpp

21

The two implementations are slightly different now and I wanted to see if they diverge more int he future. But I've factored them together as part of https://reviews.llvm.org/D141193

clang/lib/AST/CMakeLists.txt

add_clang_library(clangAST
   Interp/ByteCodeStmtGen.cpp
   Interp/Context.cpp
   Interp/Descriptor.cpp
   Interp/Disasm.cpp
   Interp/EvalEmitter.cpp
   Interp/Frame.cpp
   Interp/Function.cpp
   Interp/Floating.cpp
+  Interp/InterpBuiltin.cpp
   Interp/Interp.cpp
   Interp/InterpBlock.cpp
   Interp/InterpFrame.cpp
   Interp/InterpStack.cpp
   Interp/InterpState.cpp
   Interp/Pointer.cpp
   Interp/PrimType.cpp
   Interp/Program.cpp

clang/lib/AST/Interp/ByteCodeExprGen.cpp

if (isGlobalDecl(VD)) {
     return true;
   }
 
   return false;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitCallExpr(const CallExpr *E) {
-  assert(!E->getBuiltinCallee() && "Builtin functions aren't supported yet");
-
   const Decl *Callee = E->getCalleeDecl();
-  if (const auto *FuncDecl = dyn_cast_or_null<FunctionDecl>(Callee)) {
+  if (const auto *FuncDecl = dyn_cast_if_present<FunctionDecl>(Callee)) {
     const Function *Func = getFunction(FuncDecl);
     if (!Func)
       return false;
     // If the function is being compiled right now, this is a recursive call.
     // In that case, the function can't be valid yet, even though it will be
     // later.
     // If the function is already fully compiled but not constexpr, it was
     // found to be faulty earlier on, so bail out.

clang/lib/AST/Interp/Function.h

public:
   /// Checks if the function is fully done compiling.
   bool isFullyCompiled() const { return IsFullyCompiled; }
 
   bool hasThisPointer() const { return HasThisPointer; }
 
   // Checks if the funtion already has a body attached.
   bool hasBody() const { return HasBody; }
 
+  unsigned getBuiltinID() const { return F->getBuiltinID(); }
+
   unsigned getNumParams() const { return ParamTypes.size(); }
 
 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);

clang/lib/AST/Interp/Interp.h

 
 /// Checks if Div/Rem operation on LHS and RHS is valid.
 template <typename T>
 bool CheckDivRem(InterpState &S, CodePtr OpPC, const T &LHS, const T &RHS);
 
 /// Interpreter entry point.
 bool Interpret(InterpState &S, APValue &Result);
 
+bool InterpretBuiltin(InterpState &S, CodePtr PC, unsigned BuiltinID);
+
 enum class ArithOp { Add, Sub };
 
 //===----------------------------------------------------------------------===//
 // Add, Sub, Mul
 //===----------------------------------------------------------------------===//
 
 template <typename T, bool (*OpFW)(T, T, unsigned, T *),
           template <typename U> class OpAP>
inline bool Call(InterpState &S, CodePtr &PC, const Function *Func) {
   }
 
   if (!CheckCallable(S, PC, Func))
     return false;
 
   InterpFrame *FrameBefore = S.Current;
   S.Current = NewFrame.get();
 
+  // Evaluate builtin functions directly.
+  if (unsigned BID = Func->getBuiltinID()) {
+    if (InterpretBuiltin(S, PC, BID)) {
+      NewFrame.release();
+      return true;
+    }
+  } else {
     APValue CallResult;
     // Note that we cannot assert(CallResult.hasValue()) here since
     // Ret() above only sets the APValue if the curent frame doesn't
     // have a caller set.
     if (Interpret(S, CallResult)) {
       NewFrame.release(); // Frame was delete'd already.
       assert(S.Current == FrameBefore);
 
       // For constructors, check that all fields have been initialized.
       if (Func->isConstructor()) {
         if (!CheckCtorCall(S, PC, ThisPtr))
           return false;
       }
 
       return true;
     }
+  }
 
   // Interpreting the function failed somehow. Reset to
   // previous state.
   S.Current = FrameBefore;
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // Read opcode arguments
 //===----------------------------------------------------------------------===//
 
 template <typename T> inline T ReadArg(InterpState &S, CodePtr &OpPC) {
   if constexpr (std::is_pointer<T>::value) {
     uint32_t ID = OpPC.read<uint32_t>();
     return reinterpret_cast<T>(S.P.getNativePointer(ID));
   } else {
     return OpPC.read<T>();
   }
 }
 
 } // namespace interp
 } // namespace clang
 
 #endif

clang/lib/AST/Interp/Interp.cpp

bool CheckCallable(InterpState &S, CodePtr OpPC, const Function *F) {
   if (F->isVirtual()) {
     if (!S.getLangOpts().CPlusPlus20) {
       const SourceLocation &Loc = S.Current->getLocation(OpPC);
       S.CCEDiag(Loc, diag::note_constexpr_virtual_call);
       return false;
     }
   }
 
+  // Builtin functions are always fine, provided we implement them, which
+  // we will check later.
+  if (F->getBuiltinID())
+    return true;
+
   if (!F->isConstexpr()) {
     const SourceLocation &Loc = S.Current->getLocation(OpPC);
     if (S.getLangOpts().CPlusPlus11) {
       const FunctionDecl *DiagDecl = F->getDecl();
 
       // If this function is not constexpr because it is an inherited
       // non-constexpr constructor, diagnose that directly.
       auto *CD = dyn_cast<CXXConstructorDecl>(DiagDecl);

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"
+
+namespace clang {
+namespace interp {
+
+/// This is a slightly simplified version of the Ret() we have in Interp.cpp
+/// If they end up diverging in the future, we should get rid of the code
+/// duplication.
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+static bool Ret(InterpState &S, CodePtr &PC) {
+  S.CallStackDepth--;
+  const T &Ret = S.Stk.pop<T>();
+
+  assert(S.Current->getFrameOffset() == S.Stk.size() && "Invalid frame");
+  if (!S.checkingPotentialConstantExpression())
+    S.Current->popArgs();
+
+  InterpFrame *Caller = S.Current->Caller;
+  assert(Caller);
+
+  PC = S.Current->getRetPC();
+  delete S.Current;
+  S.Current = Caller;
+  S.Stk.push<T>(Ret);
+
+  return true;
+}
+
+bool InterpretBuiltin(InterpState &S, CodePtr PC, unsigned BuiltinID) {
+  switch (BuiltinID) {
+  case Builtin::BI__builtin_is_constant_evaluated:
+    S.Stk.push<Boolean>(Boolean::from(S.inConstantContext()));
+    Ret<PT_Bool>(S, PC);
+    return true;
+  }
+
+  return false;
+}
+
+} // namespace interp
+} // namespace clang

clang/test/AST/Interp/builtins.cpp

+// RUN: %clang_cc1 -fexperimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -fexperimental-new-constant-interpreter %s -S -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -verify=ref %s -Wno-constant-evaluated
+// RUN: %clang_cc1 -verify=ref %s -Wno-constant-evaluated
+// RUN: %clang_cc1 -verify=ref %s -Wno-constant-evaluated -S -emit-llvm -o - | FileCheck %s
+
+// expected-no-diagnostics
+// ref-no-diagnostics
+
+using size_t = decltype(sizeof(int));
+
+namespace std {
+inline constexpr bool is_constant_evaluated() noexcept {
+  return __builtin_is_constant_evaluated();
+}
+} // namespace std
+
+constexpr bool b = std::is_constant_evaluated();
+static_assert(b, "");
+static_assert(std::is_constant_evaluated() , "");
+
+
+bool is_this_constant() {
+  return __builtin_is_constant_evaluated(); // CHECK: ret i1 false
+}