[clang][CGExprConstant] handle FunctionToPointerDecay

[nickdesaulniers]

Summary

Consider the following code:

void foo (void) {}
void (*bar)(void) = foo;

And the corresponding AST:

|-FunctionDecl 0x561e9cf12728 <x.c:14:1, col:18> col:6 used foo 'void (void)'
| `-CompoundStmt 0x561e9cf12818 <col:17, col:18>
`-VarDecl 0x561e9cf12958 <line:15:1, col:21> col:8 bar 'void (*)(void)' cinit
  `-ImplicitCastExpr 0x561e9cf129e0 <col:21> 'void (*)(void)' <FunctionToPointerDecay>
    `-DeclRefExpr 0x561e9cf129c0 <col:21> 'void (void)' Function 0x561e9cf12728 'foo' 'void (void)'

The ImplicitCastExpr of FunctionToPointerDecay is obviously const.
Lookup the corresponding llvm::Function in the Module by name.

[nickdesaulniers]

• update

[shafik]

Makes sense but I want @efriedma to look at as well.

[efriedma]

clang/lib/CodeGen/CGExprConstant.cpp

1128

I think I'd prefer to continue treating an undecayed function as an "lvalue", to keep things straightforward. To that end, I'd prefer a separate "ConstLValueExprEmitter", or something like that, so ConstExprEmitter only visits rvalues.

The new emitter should reuse code from ConstLValueExprEmitter where possible.

1247

You 100% can't use VD->getName() like this; I'm shocked this isn't causing any test failures. GetAddrOfFunction() resolves names correctly.

clang/lib/CodeGen/CGExprConstant.cpp

case CK_LValueToRValue: {
       // special case, allow compound literals to support the gcc extension
       // allowing "struct x {int x;} x = (struct x) {};".
       if (auto *E = dyn_cast<CompoundLiteralExpr>(subExpr->IgnoreParens()))
         return Visit(E->getInitializer(), destType);
       return nullptr;
     }
 
     case CK_AtomicToNonAtomic:
-    case CK_NonAtomicToAtomic:
-    case CK_NoOp:
     case CK_ConstructorConversion:
+    case CK_FunctionToPointerDecay:
+    case CK_NoOp:
+    case CK_NonAtomicToAtomic:
       return Visit(subExpr, destType);
 
     case CK_ArrayToPointerDecay:
       if (const auto *S = dyn_cast<StringLiteral>(subExpr))
         return CGM.GetAddrOfConstantStringFromLiteral(S).getPointer();
       return nullptr;
     case CK_NullToPointer:
       if (llvm::Constant *C = Visit(subExpr, destType))
llvm::Constant *VisitCastExpr(CastExpr *E, QualType destType) {
     case CK_Dynamic:
     case CK_LValueBitCast:
     case CK_LValueToRValueBitCast:
     case CK_NullToMemberPointer:
     case CK_UserDefinedConversion:
     case CK_CPointerToObjCPointerCast:
     case CK_BlockPointerToObjCPointerCast:
     case CK_AnyPointerToBlockPointerCast:
-    case CK_FunctionToPointerDecay:
     case CK_BaseToDerived:
     case CK_DerivedToBase:
     case CK_UncheckedDerivedToBase:
     case CK_MemberPointerToBoolean:
     case CK_VectorSplat:
     case CK_FloatingRealToComplex:
     case CK_FloatingComplexToReal:
     case CK_FloatingComplexToBoolean:
public:
   llvm::Constant *VisitExprWithCleanups(ExprWithCleanups *E, QualType T) {
     return Visit(E->getSubExpr(), T);
   }
 
   llvm::Constant *VisitIntegerLiteral(IntegerLiteral *I, QualType T) {
     return llvm::ConstantInt::get(CGM.getLLVMContext(), I->getValue());
   }
 
+  llvm::Constant *VisitDeclRefExpr(DeclRefExpr *D, QualType T) {
+    ValueDecl *VD = D->getDecl();
+    if (isa<FunctionDecl>(VD))
+      return CGM.getModule().getNamedValue(VD->getName());
+    return nullptr;
+  }
+
   llvm::Constant *EmitArrayInitialization(InitListExpr *ILE, QualType T) {
     auto *CAT = CGM.getContext().getAsConstantArrayType(ILE->getType());
     assert(CAT && "can't emit array init for non-constant-bound array");
     unsigned NumInitElements = ILE->getNumInits();
     unsigned NumElements = CAT->getSize().getZExtValue();
 
     // Initialising an array requires us to automatically
     // initialise any elements that have not been initialised explicitly