[clang][Interp] Add function pointers

[tbaeder]

Summary

This adds a FunctionPointer class as well as a new FnPtr primtype.

It also adds a CallPtr opcode that pops a FunctionPointer from the stack and calls its function.

[aaron.ballman]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

134–137

Can we still reach this bit now?

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

134–137

Nope!

[aaron.ballman]

Design question -- do you anticipate this class handling *all* function pointers, including pointer to member functions that might be virtual: https://godbolt.org/z/hT8fMY37n

[tbaeder]

In D141472#4091662, @aaron.ballman wrote:

Design question -- do you anticipate this class handling *all* function pointers, including pointer to member functions that might be virtual: https://godbolt.org/z/hT8fMY37n

I had to make a few adjustments but I have that example working locally now, of course no idea if that would work generally. Do you see any problem with the proposed FunctionPointer class?

According to https://clang.llvm.org/docs/ConstantInterpreter.html#pointers, there was a MemberPointer class that sounds related to this, but I don't know more about it. I guess, since you made func() virtual, that matters and becomes a bytecode-runtime decision instead of being known at compile-time, which seems to be the case in your example?

[aaron.ballman]

In D141472#4092745, @tbaeder wrote:

In D141472#4091662, @aaron.ballman wrote:

Design question -- do you anticipate this class handling *all* function pointers, including pointer to member functions that might be virtual: https://godbolt.org/z/hT8fMY37n

I had to make a few adjustments but I have that example working locally now, of course no idea if that would work generally. Do you see any problem with the proposed FunctionPointer class?

According to https://clang.llvm.org/docs/ConstantInterpreter.html#pointers, there was a MemberPointer class that sounds related to this, but I don't know more about it. I guess, since you made func() virtual, that matters and becomes a bytecode-runtime decision instead of being known at compile-time, which seems to be the case in your example?

Member pointers (for functions or for data) are weird in that they're not the typical pointer width. They're actually a pointer and between one-to-three other fields in a trenchcoat, depending on the circumstances. You generally need the function pointer, but you also may need various offsets (to this, to the vtable, etc). There's some more information about how it's done in MSVC (which is different from Itanium ABI, but we can do what we want for the constant expression interpreter): https://rants.vastheman.com/2021/09/21/msvc/

I don't think there's a problem with FunctionPointer per se, I'm more wondering are you planning to also add a MemberPointer type or are you planning to reuse FunctionPointer to handle function members (and presumably something else for data members)?

As for virtual functions in general, the standard has rules: http://eel.is/c++draft/expr.const#5.6 and http://eel.is/c++draft/expr.const#7

[tbaeder]

Member pointers (for functions or for data) are weird in that they're not the typical pointer width. They're actually a pointer and between one-to-three other fields in a trenchcoat, depending on the circumstances. You generally need the function pointer, but you also may need various offsets (to this, to the vtable, etc). There's some more information about how it's done in MSVC (which is different from Itanium ABI, but we can do what we want for the constant expression interpreter): https://rants.vastheman.com/2021/09/21/msvc/

I don't think there's a problem with FunctionPointer per se, I'm more wondering are you planning to also add a MemberPointer type or are you planning to reuse FunctionPointer to handle function members (and presumably something else for data members)?

As for virtual functions in general, the standard has rules: http://eel.is/c++draft/expr.const#5.6 and http://eel.is/c++draft/expr.const#7

I was thinking that the dynamicDispatch in https://godbolt.org/z/rf9Ks77Wo would be a good reproducer since the actual function to call is only known when calling dynamicDispatch(), but that example already works when doing a few changes to classify() the right types and adding a if (BO->isPtrMemOP()) { return visit(RHS); } to VisitBinaryOperator().

[aaron.ballman]

In D141472#4106091, @tbaeder wrote:

Member pointers (for functions or for data) are weird in that they're not the typical pointer width. They're actually a pointer and between one-to-three other fields in a trenchcoat, depending on the circumstances. You generally need the function pointer, but you also may need various offsets (to this, to the vtable, etc). There's some more information about how it's done in MSVC (which is different from Itanium ABI, but we can do what we want for the constant expression interpreter): https://rants.vastheman.com/2021/09/21/msvc/

I don't think there's a problem with FunctionPointer per se, I'm more wondering are you planning to also add a MemberPointer type or are you planning to reuse FunctionPointer to handle function members (and presumably something else for data members)?

As for virtual functions in general, the standard has rules: http://eel.is/c++draft/expr.const#5.6 and http://eel.is/c++draft/expr.const#7

I was thinking that the dynamicDispatch in https://godbolt.org/z/rf9Ks77Wo would be a good reproducer since the actual function to call is only known when calling dynamicDispatch(), but that example already works when doing a few changes to classify() the right types and adding a if (BO->isPtrMemOP()) { return visit(RHS); } to VisitBinaryOperator().

That is a reasonable test, but probably not sufficient as nothing is really testing the layout of those objects (the calls return a constant). How about a test like: https://godbolt.org/z/rhhhvxYxf where there are offsets to member variables involved?

[tbaeder]

In D141472#4107008, @aaron.ballman wrote:

In D141472#4106091, @tbaeder wrote:

Member pointers (for functions or for data) are weird in that they're not the typical pointer width. They're actually a pointer and between one-to-three other fields in a trenchcoat, depending on the circumstances. You generally need the function pointer, but you also may need various offsets (to this, to the vtable, etc). There's some more information about how it's done in MSVC (which is different from Itanium ABI, but we can do what we want for the constant expression interpreter): https://rants.vastheman.com/2021/09/21/msvc/

I don't think there's a problem with FunctionPointer per se, I'm more wondering are you planning to also add a MemberPointer type or are you planning to reuse FunctionPointer to handle function members (and presumably something else for data members)?

As for virtual functions in general, the standard has rules: http://eel.is/c++draft/expr.const#5.6 and http://eel.is/c++draft/expr.const#7

I was thinking that the dynamicDispatch in https://godbolt.org/z/rf9Ks77Wo would be a good reproducer since the actual function to call is only known when calling dynamicDispatch(), but that example already works when doing a few changes to classify() the right types and adding a if (BO->isPtrMemOP()) { return visit(RHS); } to VisitBinaryOperator().

That is a reasonable test, but probably not sufficient as nothing is really testing the layout of those objects (the calls return a constant). How about a test like: https://godbolt.org/z/rhhhvxYxf where there are offsets to member variables involved?

Ah I get what you mean now.

The pointer we have on the stack is of type S but then we end up calling a function expecting a S2 pointer, and which one we're calling is not known at compile time.

I'm not sure what to do about this right now. I was wondering about restructuring pointers so all the metadata is before all the actual data, but that would be a large refactoring.

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[aaron.ballman]

In D141472#4112790, @tbaeder wrote:

I'm not sure what to do about this right now. I was wondering about restructuring pointers so all the metadata is before all the actual data, but that would be a large refactoring.

For right now, we can move forward with basic function pointer support and we can revisit this when you get around to doing member function pointers.

clang/lib/AST/Interp/ByteCodeExprGen.cpp

967

Shouldn't this call emitNullPtr() in this case? e.g.,

struct S {
  int i;
  void (*fp)();
};

constexpr S s{ 12 };
static_assert(s.fp == nullptr);

[tbaeder]

In D141472#4217479, @aaron.ballman wrote:

In D141472#4112790, @tbaeder wrote:

I'm not sure what to do about this right now. I was wondering about restructuring pointers so all the metadata is before all the actual data, but that would be a large refactoring.

For right now, we can move forward with basic function pointer support and we can revisit this when you get around to doing member function pointers.

FWIW, I did that refactoring locally but it didn't really turn out to work like that. This example works now and there should be a test for it AFAIK.

clang/lib/AST/Interp/ByteCodeExprGen.cpp

967

Heh, that function is dead code right now, I keep it around because I think I might need it later. But your reproducer is broken anyway, I'll fix it, thanks.

[tbaeder]

Okay, fixed this by using visitZeroInitializer() so now it's not dead code anymore.

TODO: Test zero-initialization of floats.

[aaron.ballman]

LGTM!

clang/lib/AST/Interp/ByteCodeExprGen.cpp

if (!ToT)
       return false;
 
     if (!this->visit(SubExpr))
       return false;
 
     return this->emitCastFloatingIntegral(*ToT, CE);
   }
 
   case CK_NullToPointer:
-  case CK_IntegralToPointer: {
-    if (isa<CXXNullPtrLiteralExpr>(SubExpr))
-      return this->visit(SubExpr);
+    if (DiscardResult)
+      return true;
+    return this->emitNull(classifyPrim(CE->getType()), CE);
 
+  case CK_IntegralToPointer: {
     if (!this->visit(SubExpr))
       return false;
 
     return this->emitCastIntegralPointer(classifyPrim(SubExpr->getType()), CE);
   }
 
   case CK_ArrayToPointerDecay:
   case CK_AtomicToNonAtomic:

 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
   std::optional<PrimType> T = classify(E);
 
   if (!T)
     return false;
 
-  if (E->getType()->isPointerType())
-    return this->emitNullPtr(E);
-
-  return this->emitZero(*T, E);
+  return this->visitZeroInitializer(*T, E);
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitArraySubscriptExpr(
     const ArraySubscriptExpr *E) {
   const Expr *Base = E->getBase();
   const Expr *Index = E->getIdx();
   PrimType IndexT = classifyPrim(Index->getType());
bool ByteCodeExprGen<Emitter>::visitZeroInitializer(PrimType T, const Expr *E) {
   case PT_Uint32:
     return this->emitZeroUint32(E);
   case PT_Sint64:
     return this->emitZeroSint64(E);
   case PT_Uint64:
     return this->emitZeroUint64(E);
   case PT_Ptr:
     return this->emitNullPtr(E);
+  case PT_FnPtr:
+    return this->emitNullFnPtr(E);
   case PT_Float:
     assert(false);
   }
   llvm_unreachable("unknown primitive type");
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::dereference(
case PT_Uint32:
     return this->emitConstUint32(Value, E);
   case PT_Sint64:
     return this->emitConstSint64(Value, E);
   case PT_Uint64:
     return this->emitConstUint64(Value, E);
   case PT_Bool:
     return this->emitConstBool(Value, E);
   case PT_Ptr:
+  case PT_FnPtr:
   case PT_Float:
     llvm_unreachable("Invalid integral type");
     break;
   }
   llvm_unreachable("unknown primitive type");
 }
 
 template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitBuiltinCallExpr(const CallExpr *E) {
   return true;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitCallExpr(const CallExpr *E) {
   if (E->getBuiltinCallee())
     return VisitBuiltinCallExpr(E);
 
-  const Decl *Callee = E->getCalleeDecl();
-  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.
-    if (Func->isFullyCompiled() && !Func->isConstexpr())
-      return false;
-
-    QualType ReturnType = E->getCallReturnType(Ctx.getASTContext());
-    std::optional<PrimType> T = classify(ReturnType);
+  bool HasRVO = !ReturnType->isVoidType() && !T;
 
-    if (Func->hasRVO() && DiscardResult) {
-      // If we need to discard the return value but the function returns its
-      // value via an RVO pointer, we need to create one such pointer just
-      // for this call.
-      if (std::optional<unsigned> LocalIndex = allocateLocal(E)) {
-        if (!this->emitGetPtrLocal(*LocalIndex, E))
-          return false;
-      }
-    }
+  if (HasRVO && DiscardResult) {
 
-    // Put arguments on the stack.
-    for (const auto *Arg : E->arguments()) {
-      if (!this->visit(Arg))
-        return false;
-    }
 
+  if (const FunctionDecl *FuncDecl = E->getDirectCallee()) {
+    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.
+    if (Func->isFullyCompiled() && !Func->isConstexpr())
+      return false;
+
+    assert(HasRVO == Func->hasRVO());
+
     // In any case call the function. The return value will end up on the stack
     // and if the function has RVO, we already have the pointer on the stack to
     // write the result into.
     if (!this->emitCall(Func, E))
       return false;
 
-    if (DiscardResult && !ReturnType->isVoidType() && T)
-      return this->emitPop(*T, E);
+  } else {
+    // Indirect call. Visit the callee, which will leave a FunctionPointer on
+    // the stack. Cleanup of the returned value if necessary will be done after
+    // the function call completed.
+    if (!this->visit(E->getCallee()))
+      return false;
+
+    if (!this->emitCallPtr(E))
+      return false;
+  }
+
+  // Cleanup for discarded return values.
 
-    return true;
-  } else {
-    assert(false && "We don't support non-FunctionDecl callees right now.");
-  }
-
-  return false;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitCXXMemberCallExpr(
     const CXXMemberCallExpr *E) {
   // Get a This pointer on the stack.
   if (!this->visit(E->getImplicitObjectArgument()))
     return false;
if (auto It = this->Params.find(PVD); It != this->Params.end()) {
       if (IsReference)
         return this->emitGetParam(PT_Ptr, It->second, E);
       return this->emitGetPtrParam(It->second, E);
     }
   } else if (const auto *ECD = dyn_cast<EnumConstantDecl>(Decl)) {
     return this->emitConst(ECD->getInitVal(), E);
   } else if (const auto *BD = dyn_cast<BindingDecl>(Decl)) {
     return this->visit(BD->getBinding());
+  } else if (const auto *FuncDecl = dyn_cast<FunctionDecl>(Decl)) {
+    const Function *F = getFunction(FuncDecl);
+    return F && this->emitGetFnPtr(F, E);
   }
 
   return false;
 }
 
 template <class Emitter>
 void ByteCodeExprGen<Emitter>::emitCleanup() {
   for (VariableScope<Emitter> *C = VarScope; C; C = C->getParent())

clang/lib/AST/Interp/Context.cpp

bool Context::evaluateAsInitializer(State &Parent, const VarDecl *VD,
 
   Stk.clear();
   return false;
 }
 
 const LangOptions &Context::getLangOpts() const { return Ctx.getLangOpts(); }
 
 std::optional<PrimType> Context::classify(QualType T) const {
-  if (T->isReferenceType() || T->isPointerType()) {
+  if (T->isFunctionPointerType() || T->isFunctionReferenceType())
+    return PT_FnPtr;
+
+  if (T->isReferenceType() || T->isPointerType())
     return PT_Ptr;
-  }
 
   if (T->isBooleanType())
     return PT_Bool;
 
   if (T->isSignedIntegerOrEnumerationType()) {
     switch (Ctx.getIntWidth(T)) {
     case 64:
       return PT_Sint64;

clang/lib/AST/Interp/Descriptor.cpp

 //===--- Descriptor.cpp - Types 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 "Descriptor.h"
 #include "Boolean.h"
 #include "Floating.h"
+#include "FunctionPointer.h"
 #include "Pointer.h"
 #include "PrimType.h"
 #include "Record.h"
 
 using namespace clang;
 using namespace clang::interp;
 
 template <typename T>

clang/lib/AST/Interp/FunctionPointer.h

+
+
+#ifndef LLVM_CLANG_AST_INTERP_FUNCTION_POINTER_H
+#define LLVM_CLANG_AST_INTERP_FUNCTION_POINTER_H
+
+#include "Function.h"
+#include "Primitives.h"
+#include "clang/AST/APValue.h"
+
+namespace clang {
+namespace interp {
+
+class FunctionPointer final {
+private:
+  const Function *Func;
+
+public:
+  FunctionPointer() : Func(nullptr) {}
+  FunctionPointer(const Function *Func) : Func(Func) { assert(Func); }
+
+  const Function *getFunction() const { return Func; }
+
+  APValue toAPValue() const {
+    if (!Func)
+      return APValue(static_cast<Expr *>(nullptr), CharUnits::Zero(), {},
+                     /*OnePastTheEnd=*/false, /*IsNull=*/true);
+
+    return APValue(Func->getDecl(), CharUnits::Zero(), {},
+                   /*OnePastTheEnd=*/false, /*IsNull=*/false);
+  }
+
+  void print(llvm::raw_ostream &OS) const {
+    OS << "FnPtr(";
+    if (Func)
+      OS << Func->getName();
+    else
+      OS << "nullptr";
+    OS << ")";
+  }
+
+  ComparisonCategoryResult compare(const FunctionPointer &RHS) const {
+    if (Func == RHS.Func)
+      return ComparisonCategoryResult::Equal;
+    return ComparisonCategoryResult::Unordered;
+  }
+};
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                                     FunctionPointer FP) {
+  FP.print(OS);
+  return OS;
+}
+
+} // namespace interp
+} // namespace clang
+
+#endif

clang/lib/AST/Interp/Interp.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_INTERP_INTERP_H
 #define LLVM_CLANG_AST_INTERP_INTERP_H
 
 #include "Boolean.h"
 #include "Floating.h"
 #include "Function.h"
+#include "FunctionPointer.h"
 #include "InterpFrame.h"
 #include "InterpStack.h"
 #include "InterpState.h"
 #include "Opcode.h"
 #include "PrimType.h"
 #include "Program.h"
 #include "State.h"
 #include "clang/AST/ASTContext.h"
inline bool CallBI(InterpState &S, CodePtr &PC, const Function *Func) {
   if (InterpretBuiltin(S, PC, Func->getBuiltinID())) {
     NewFrame.release();
     return true;
   }
   S.Current = FrameBefore;
   return false;
 }
 
+inline bool CallPtr(InterpState &S, CodePtr &PC) {
+  const FunctionPointer &FuncPtr = S.Stk.pop<FunctionPointer>();
+
+  const Function *F = FuncPtr.getFunction();
+  if (!F || !F->isConstexpr())
+    return false;
+
+  return Call(S, PC, F);
+}
+
+inline bool GetFnPtr(InterpState &S, CodePtr &PC, const Function *Func) {
+  assert(Func);
+  S.Stk.push<FunctionPointer>(Func);
+  return true;
+}
+
 //===----------------------------------------------------------------------===//
 // 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));

clang/lib/AST/Interp/InterpStack.h

 //===--- InterpStack.h - Stack implementation for the 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the upwards-growing stack used by the interpreter.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_INTERP_INTERPSTACK_H
 #define LLVM_CLANG_AST_INTERP_INTERPSTACK_H
 
+#include "FunctionPointer.h"
 #include "PrimType.h"
 #include <memory>
 #include <vector>
 
 namespace clang {
 namespace interp {
 
 /// Stack frame storing temporaries and parameters.
template <typename T> static constexpr PrimType toPrimType() {
     else if constexpr (std::is_same_v<T, int64_t> ||
                        std::is_same_v<T, Integral<64, true>>)
       return PT_Sint64;
     else if constexpr (std::is_same_v<T, uint64_t> ||
                        std::is_same_v<T, Integral<64, false>>)
       return PT_Uint64;
     else if constexpr (std::is_same_v<T, Floating>)
       return PT_Float;
+    else if constexpr (std::is_same_v<T, FunctionPointer>)
+      return PT_FnPtr;
 
     llvm_unreachable("unknown type push()'ed into InterpStack");
   }
 #endif
 };
 
 } // namespace interp
 } // namespace clang
 
 #endif

clang/lib/AST/Interp/Opcodes.td

 def Sint16 : Type;
 def Uint16 : Type;
 def Sint32 : Type;
 def Uint32 : Type;
 def Sint64 : Type;
 def Uint64 : Type;
 def Float : Type;
 def Ptr : Type;
+def FnPtr : Type;
 
 //===----------------------------------------------------------------------===//
 // Types transferred to the interpreter.
 //===----------------------------------------------------------------------===//
 
 class ArgType { string Name = ?; }
 def ArgSint8 : ArgType { let Name = "int8_t"; }
 def ArgUint8 : ArgType { let Name = "uint8_t"; }
def FloatTypeClass : TypeClass {
   let Types = [Float];
 }
 
 def AluTypeClass : TypeClass {
   let Types = !listconcat(IntegerTypeClass.Types, [Bool]);
 }
 
 def PtrTypeClass : TypeClass {
-  let Types = [Ptr];
+  let Types = [Ptr, FnPtr];
 }
 
 def BoolTypeClass : TypeClass {
   let Types = [Bool];
 }
 
 def NonPtrTypeClass : TypeClass {
   let Types = !listconcat(IntegerTypeClass.Types, [Bool], [Float]);

 }
 
 def CallBI : Opcode {
   let Args = [ArgFunction];
   let Types = [];
   let ChangesPC = 1;
 }
 
+def CallPtr : Opcode {
+  let Args = [];
+  let Types = [];
+  let ChangesPC = 1;
+}
+
 //===----------------------------------------------------------------------===//
 // Frame management
 //===----------------------------------------------------------------------===//
 
 // [] -> []
 def Destroy : Opcode {
   let Args = [ArgUint32];
   let HasCustomEval = 1;

 def Zero : Opcode {
   let Types = [AluTypeClass];
   let HasGroup = 1;
 }
 
 // [] -> [Pointer]
 def Null : Opcode {
   let Types = [PtrTypeClass];
+  let HasGroup = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Pointer generation
 //===----------------------------------------------------------------------===//
 
 // [] -> [Pointer]
 def GetPtrLocal : Opcode {
def IncPtr : Opcode {
   let HasGroup = 0;
 }
 // [Pointer] -> [Pointer]
 def DecPtr : Opcode {
   let HasGroup = 0;
 }
 
 //===----------------------------------------------------------------------===//
+// Function pointers.
+//===----------------------------------------------------------------------===//
+def GetFnPtr : Opcode {
+  let Args = [ArgFunction];
+}
+
+
+//===----------------------------------------------------------------------===//
 // Binary operators.
 //===----------------------------------------------------------------------===//
 
 // [Real, Real] -> [Real]
 def Add  : AluOpcode;
 def Addf : FloatOpcode;
 def Sub  : AluOpcode;
 def Subf : FloatOpcode;

clang/lib/AST/Interp/PrimType.h

 #include <cstdint>
 
 namespace clang {
 namespace interp {
 
 class Pointer;
 class Boolean;
 class Floating;
+class FunctionPointer;
 
 /// Enumeration of the primitive types of the VM.
 enum PrimType : unsigned {
   PT_Sint8,
   PT_Uint8,
   PT_Sint16,
   PT_Uint16,
   PT_Sint32,
   PT_Uint32,
   PT_Sint64,
   PT_Uint64,
   PT_Bool,
   PT_Float,
   PT_Ptr,
+  PT_FnPtr,
 };
 
 /// Mapping from primitive types to their representation.
 template <PrimType T> struct PrimConv;
 template <> struct PrimConv<PT_Sint8> { using T = Integral<8, true>; };
 template <> struct PrimConv<PT_Uint8> { using T = Integral<8, false>; };
 template <> struct PrimConv<PT_Sint16> { using T = Integral<16, true>; };
 template <> struct PrimConv<PT_Uint16> { using T = Integral<16, false>; };
 template <> struct PrimConv<PT_Sint32> { using T = Integral<32, true>; };
 template <> struct PrimConv<PT_Uint32> { using T = Integral<32, false>; };
 template <> struct PrimConv<PT_Sint64> { using T = Integral<64, true>; };
 template <> struct PrimConv<PT_Uint64> { using T = Integral<64, false>; };
 template <> struct PrimConv<PT_Float> { using T = Floating; };
 template <> struct PrimConv<PT_Bool> { using T = Boolean; };
 template <> struct PrimConv<PT_Ptr> { using T = Pointer; };
+template <> struct PrimConv<PT_FnPtr> {
+  using T = FunctionPointer;
+};
 
 /// Returns the size of a primitive type in bytes.
 size_t primSize(PrimType Type);
 
 /// Aligns a size to the pointer alignment.
 constexpr size_t align(size_t Size) {
   return ((Size + alignof(void *) - 1) / alignof(void *)) * alignof(void *);
 }
switch (Expr) {                                                            \
       TYPE_SWITCH_CASE(PT_Uint16, B)                                           \
       TYPE_SWITCH_CASE(PT_Sint32, B)                                           \
       TYPE_SWITCH_CASE(PT_Uint32, B)                                           \
       TYPE_SWITCH_CASE(PT_Sint64, B)                                           \
       TYPE_SWITCH_CASE(PT_Uint64, B)                                           \
       TYPE_SWITCH_CASE(PT_Float, B)                                            \
       TYPE_SWITCH_CASE(PT_Bool, B)                                             \
       TYPE_SWITCH_CASE(PT_Ptr, B)                                              \
+      TYPE_SWITCH_CASE(PT_FnPtr, B)                                            \
     }                                                                          \
   } while (0)
 #define COMPOSITE_TYPE_SWITCH(Expr, B, D)                                      \
   do {                                                                         \
     switch (Expr) {                                                            \
       TYPE_SWITCH_CASE(PT_Ptr, B)                                              \
       default: { D; break; }                                                   \
     }                                                                          \
   } while (0)
 #endif

clang/lib/AST/Interp/PrimType.cpp

 //===--- PrimType.cpp - Types 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 "PrimType.h"
 #include "Boolean.h"
 #include "Floating.h"
+#include "FunctionPointer.h"
 #include "Pointer.h"
 
 using namespace clang;
 using namespace clang::interp;
 
 namespace clang {
 namespace interp {
 
 size_t primSize(PrimType Type) {
   TYPE_SWITCH(Type, return sizeof(T));
   llvm_unreachable("not a primitive type");
 }
 
 } // namespace interp
 } // namespace clang

clang/test/AST/Interp/functions.cpp

 }
 
 constexpr void invalid2() {
   int i = 0;
   // Invalid expression in discard().
   huh(); // expected-error {{use of undeclared identifier}} \
          // ref-error {{use of undeclared identifier}}
 }
+
+namespace FunctionPointers {
+  constexpr int add(int a, int b) {
+    return a + b;
+  }
+
+  struct S { int a; };
+  constexpr S getS() {
+    return S{12};
+  }
+
+  constexpr int applyBinOp(int a, int b, int (*op)(int, int)) {
+    return op(a, b);
+  }
+  static_assert(applyBinOp(1, 2, add) == 3, "");
+
+  constexpr int ignoreReturnValue() {
+    int (*foo)(int, int) = add;
+
+    foo(1, 2);
+    return 1;
+  }
+  static_assert(ignoreReturnValue() == 1, "");
+
+  constexpr int createS(S (*gimme)()) {
+    gimme(); // Ignored return value
+    return gimme().a;
+  }
+  static_assert(createS(getS) == 12, "");
+
+namespace FunctionReturnType {
+  typedef int (*ptr)(int*);
+  typedef ptr (*pm)();
+
+  constexpr int fun1(int* y) {
+      return *y + 10;
+  }
+  constexpr ptr fun() {
+      return &fun1;
+  }
+  static_assert(fun() == nullptr, ""); // expected-error {{static assertion failed}} \
+                                       // ref-error {{static assertion failed}}
+
+  constexpr int foo() {
+    int (*f)(int *) = fun();
+    int m = 0;
+
+    m = f(&m);
+
+    return m;
+  }
+  static_assert(foo() == 10);
+
+  struct S {
+    int i;
+    void (*fp)();
+  };
+
+  constexpr S s{ 12 };
+  static_assert(s.fp == nullptr); // zero-initialized function pointer.
+}
+
+}