[CodeGen] Move `emitConstant` from ScalarExprEmitter to CodeGenFunction. NFC.

[vsapsai]

Summary

The goal is to use emitConstant in more places. Didn't move
ComplexExprEmitter::emitConstant because it returns a different type.

[rjmccall]

This should at least be named emitScalarConstant.

[vsapsai]

• Rename EmitConstant to EmitScalarConstant.

[vsapsai]

In D53725#1278067, @rjmccall wrote:

This should at least be named emitScalarConstant.

Agree. I've just capitalized 'e' as it looks like the majority of Emit... methods are capitalized that way.

[rjmccall]

Well, that's the old style, but we've been slowly moving to the camelCase style instead. Very, very slowly. I won't hold up your patch over it.

[vsapsai]

• Switch to camelCase.

[rjmccall]

Thanks. Still LGTM. :)

[vsapsai]

Can you please check https://reviews.llvm.org/D53674 ? It builds on top of this change and I plan to commit them together.

clang/lib/CodeGen/CGExpr.cpp

 
 CodeGenFunction::ConstantEmission
 CodeGenFunction::tryEmitAsConstant(const MemberExpr *ME) {
   if (DeclRefExpr *DRE = tryToConvertMemberExprToDeclRefExpr(*this, ME))
     return tryEmitAsConstant(DRE);
   return ConstantEmission();
 }
 
+llvm::Value *
+CodeGenFunction::EmitConstant(const CodeGenFunction::ConstantEmission &Constant,
+                              Expr *E) {
+  assert(Constant && "not a constant");
+  if (Constant.isReference())
+    return EmitLoadOfLValue(Constant.getReferenceLValue(*this, E),
+                            E->getExprLoc())
+        .getScalarVal();
+  return Constant.getValue();
+}
+
 llvm::Value *CodeGenFunction::EmitLoadOfScalar(LValue lvalue,
                                                SourceLocation Loc) {
   return EmitLoadOfScalar(lvalue.getAddress(), lvalue.isVolatile(),
                           lvalue.getType(), Loc, lvalue.getBaseInfo(),
                           lvalue.getTBAAInfo(), lvalue.isNontemporal());
 }
 
 static bool hasBooleanRepresentation(QualType Ty) {

clang/lib/CodeGen/CGExprScalar.cpp

Value *VisitOpaqueValueExpr(OpaqueValueExpr *E) {
     if (E->isGLValue())
       return EmitLoadOfLValue(CGF.getOrCreateOpaqueLValueMapping(E),
                               E->getExprLoc());
 
     // Otherwise, assume the mapping is the scalar directly.
     return CGF.getOrCreateOpaqueRValueMapping(E).getScalarVal();
   }
 
-  Value *emitConstant(const CodeGenFunction::ConstantEmission &Constant,
-                      Expr *E) {
-    assert(Constant && "not a constant");
-    if (Constant.isReference())
-      return EmitLoadOfLValue(Constant.getReferenceLValue(CGF, E),
-                              E->getExprLoc());
-    return Constant.getValue();
-  }
-
   // l-values.
   Value *VisitDeclRefExpr(DeclRefExpr *E) {
     if (CodeGenFunction::ConstantEmission Constant = CGF.tryEmitAsConstant(E))
-      return emitConstant(Constant, E);
+      return CGF.EmitConstant(Constant, E);
     return EmitLoadOfLValue(E);
   }
 
   Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
     return CGF.EmitObjCSelectorExpr(E);
   }
   Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
     return CGF.EmitObjCProtocolExpr(E);
Value *ScalarExprEmitter::VisitConvertVectorExpr(ConvertVectorExpr *E) {
   }
 
   return Res;
 }
 
 Value *ScalarExprEmitter::VisitMemberExpr(MemberExpr *E) {
   if (CodeGenFunction::ConstantEmission Constant = CGF.tryEmitAsConstant(E)) {
     CGF.EmitIgnoredExpr(E->getBase());
-    return emitConstant(Constant, E);
+    return CGF.EmitConstant(Constant, E);
   } else {
     llvm::APSInt Value;
     if (E->EvaluateAsInt(Value, CGF.getContext(), Expr::SE_AllowSideEffects)) {
       CGF.EmitIgnoredExpr(E->getBase());
       return Builder.getInt(Value);
     }
   }
 

clang/lib/CodeGen/CodeGenFunction.h

public:
     llvm::Constant *getValue() const {
       assert(!isReference());
       return ValueAndIsReference.getPointer();
     }
   };
 
   ConstantEmission tryEmitAsConstant(DeclRefExpr *refExpr);
   ConstantEmission tryEmitAsConstant(const MemberExpr *ME);
+  llvm::Value *EmitConstant(const ConstantEmission &Constant, Expr *E);
 
   RValue EmitPseudoObjectRValue(const PseudoObjectExpr *e,
                                 AggValueSlot slot = AggValueSlot::ignored());
   LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e);
 
   llvm::Value *EmitIvarOffset(const ObjCInterfaceDecl *Interface,
                               const ObjCIvarDecl *Ivar);
   LValue EmitLValueForField(LValue Base, const FieldDecl* Field);