[clang][ConstExprEmitter] handle IntegerLiterals

[nickdesaulniers]

Summary

Improves the ability of ConstExprEmitter to evaluate constants.

Found by adding asserts to ConstantEmitter::tryEmitPrivate to find cases
where ConstExprEmitter::Visit() fails to resolve (obvious) constants.

[efriedma]

As a practical matter, I'm not sure this helps much; ExprConstant should be reasonably fast for simple integers. The performance issues only really show for structs/arrays. But maybe it helps a little to handle a few of the most common integer expressions.

clang/lib/CodeGen/CGExprConstant.cpp

1128

This doesn't look right; I suspect this will return an integer with the wrong width.

[nickdesaulniers]

• put back the IntegralCast, for now

[nickdesaulniers]

In D156154#4529265, @efriedma wrote:

As a practical matter, I'm not sure this helps much; ExprConstant should be reasonably fast for simple integers. The performance issues only really show for structs/arrays. But maybe it helps a little to handle a few of the most common integer expressions.

Perhaps, but after D151587, ConstExprEmitter will be tried first before ExprConstant::Evaluate (or rather Evaluate in ExprConstant.cpp; god, why is that a static function and not a method???). So it seems bad if we can't just evaluate the constant then and there.

[nickdesaulniers]

• remove mention of IntegralCasts from commit description

[efriedma]

We don't completely fall back if a subexpression fails to evaluate. EmitArrayInitialization etc. don't recursively visit; they use tryEmitPrivateForMemory, so we can fallback for subexpressions. (tryEmitPrivateForMemory can still fail for certain constructs, like the MaterializeTemporary cases we spent so much time on, but the most common cases should work.)

[efriedma]

That said, skipping all those abstraction layers for the simplest cases is probably worth it; LGTM.

[shafik]

What practical effects will this have? What kind of code do this effect?

[nickdesaulniers]

In D156154#4529889, @shafik wrote:

What practical effects will this have?

As of D151587...

From the commit message Improves the ability of ConstExprEmitter to evaluate constants. Stated another way:
Should speed up "is the below expression a constant expression?"

What kind of code do this effect?

int y = 2;
        ^ is 2 a constant expression?

[shafik]

In D156154#4529907, @nickdesaulniers wrote:

Should speed up "is the below expression a constant expression?"

What kind of code do this effect?

int y = 2;
        ^ is 2 a constant expression?

Nice!

clang/lib/CodeGen/CGExprConstant.cpp

case CK_LValueToRValue: {
         return Visit(E->getInitializer(), destType);
       return nullptr;
     }
 
     case CK_AtomicToNonAtomic:
     case CK_NonAtomicToAtomic:
     case CK_NoOp:
     case CK_ConstructorConversion:
+    case CK_IntegralCast:
       return Visit(subExpr, destType);
 
     case CK_IntToOCLSampler:
       llvm_unreachable("global sampler variables are not generated");
 
     case CK_Dependent: llvm_unreachable("saw dependent cast!");
 
     case CK_BuiltinFnToFnPtr:
llvm::Constant *VisitCastExpr(CastExpr *E, QualType destType) {
     case CK_IntegralRealToComplex:
     case CK_IntegralComplexToReal:
     case CK_IntegralComplexToBoolean:
     case CK_IntegralComplexCast:
     case CK_IntegralComplexToFloatingComplex:
     case CK_PointerToIntegral:
     case CK_PointerToBoolean:
     case CK_NullToPointer:
-    case CK_IntegralCast:
     case CK_BooleanToSignedIntegral:
     case CK_IntegralToPointer:
     case CK_IntegralToBoolean:
     case CK_IntegralToFloating:
     case CK_FloatingToIntegral:
     case CK_FloatingToBoolean:
     case CK_FloatingCast:
     case CK_FloatingToFixedPoint:
llvm::Constant *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE, QualType T) {
     // constant expression.
     return Visit(DIE->getExpr(), T);
   }
 
   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 *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