[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:
       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_unreachable("builtin functions are handled elsewhere");
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