Move all Obj-C runtime interaction into CodeGenFunction.

- Drop duplicate (and broken) code for sending messages.
 - Add EmitObjCProtocolExpr to CodeGenFunction.

llvm-svn: 55024

clang/lib/CodeGen/CGExprScalar.cpp

@@ -13,7 +13,6 @@
 
 #include "CodeGenFunction.h"
 #include "CodeGenModule.h"
-#include "CGObjCRuntime.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/StmtVisitor.h"
@@ -45,15 +44,11 @@ class VISIBILITY_HIDDEN ScalarExprEmitter
   : public StmtVisitor<ScalarExprEmitter, Value*> {
   CodeGenFunction &CGF;
   llvm::IRBuilder<> &Builder;
-  CGObjCRuntime *Runtime;
 
 public:
 
   ScalarExprEmitter(CodeGenFunction &cgf) : CGF(cgf), 
-    Builder(CGF.Builder), 
-    Runtime(0) {
-    if (CGF.CGM.hasObjCRuntime())
-      Runtime = &CGF.CGM.getObjCRuntime();
+    Builder(CGF.Builder) {
   }
   
   //===--------------------------------------------------------------------===//
@@ -472,46 +467,15 @@ Value *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
 }
 
 Value *ScalarExprEmitter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
-  // Only the lookup mechanism and first two arguments of the method
-  // implementation vary between runtimes.  We can get the receiver and
-  // arguments in generic code.
-  
-  // Find the receiver
-  llvm::Value *Receiver = CGF.EmitScalarExpr(E->getReceiver());
-
-  // Process the arguments
-  unsigned ArgC = E->getNumArgs();
-  llvm::SmallVector<llvm::Value*, 16> Args;
-  for (unsigned i = 0; i != ArgC; ++i) {
-    Expr *ArgExpr = E->getArg(i);
-    QualType ArgTy = ArgExpr->getType();
-    if (!CGF.hasAggregateLLVMType(ArgTy)) {
-      // Scalar argument is passed by-value.
-      Args.push_back(CGF.EmitScalarExpr(ArgExpr));
-    } else if (ArgTy->isAnyComplexType()) {
-      // Make a temporary alloca to pass the argument.
-      llvm::Value *DestMem = CGF.CreateTempAlloca(ConvertType(ArgTy));
-      CGF.EmitComplexExprIntoAddr(ArgExpr, DestMem, false);
-      Args.push_back(DestMem);
-    } else {
-      llvm::Value *DestMem = CGF.CreateTempAlloca(ConvertType(ArgTy));
-      CGF.EmitAggExpr(ArgExpr, DestMem, false);
-      Args.push_back(DestMem);
-    }
-  }
-
-  return Runtime->GenerateMessageSend(Builder, ConvertType(E->getType()),
-                                      Receiver, E->getSelector(),
-                                      &Args[0], Args.size());
+  return CGF.EmitObjCMessageExpr(E);
 }
 
 Value *ScalarExprEmitter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
-  return Runtime->GetSelector(Builder, E->getSelector());
+  return CGF.EmitObjCSelectorExpr(E);
 }
 
 Value *ScalarExprEmitter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
-  // FIXME: This should pass the Decl not the name.
-  return Runtime->GenerateProtocolRef(Builder, E->getProtocol());
+  return CGF.EmitObjCProtocolExpr(E);
 }
 
 Value *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {

clang/lib/CodeGen/CGObjC.cpp

@@ -23,6 +23,7 @@ using namespace CodeGen;
 llvm::Value *CodeGenFunction::EmitObjCStringLiteral(const ObjCStringLiteral *E) {
   std::string String(E->getString()->getStrData(), E->getString()->getByteLength());
   llvm::Constant *C = CGM.getObjCRuntime().GenerateConstantString(String);
+  // FIXME: This bitcast should just be made an invariant on the Runtime.
   return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType()));
 }
 
@@ -35,6 +36,10 @@ llvm::Value *CodeGenFunction::EmitObjCSelectorExpr(const ObjCSelectorExpr *E) {
   return CGM.getObjCRuntime().GetSelector(Builder, E->getSelector());
 }
 
+llvm::Value *CodeGenFunction::EmitObjCProtocolExpr(const ObjCProtocolExpr *E) {
+  // FIXME: This should pass the Decl not the name.
+  return CGM.getObjCRuntime().GenerateProtocolRef(Builder, E->getProtocol());
+}
 
 
 llvm::Value *CodeGenFunction::EmitObjCMessageExpr(const ObjCMessageExpr *E) {

clang/lib/CodeGen/CodeGenFunction.h

@@ -475,12 +475,12 @@ public:
   llvm::Value *EmitVector(llvm::Value * const *Vals, unsigned NumVals,
                           bool isSplat = false);
   
+  llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E);
   llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
   llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E);
   llvm::Value *EmitObjCMessageExpr(const ObjCMessageExpr *E);
 
 
-
   //===--------------------------------------------------------------------===//
   //                           Expression Emission
   //===--------------------------------------------------------------------===//