Address Daniel's comment

Author: DataCorrupted

clang/lib/AST/Mangle.cpp

@@ -40,7 +40,7 @@ void clang::mangleObjCMethodName(raw_ostream &OS, bool includePrefixByte,
   OS << '[';
   OS << ClassName;
   if (CategoryName)
-    OS << "(" << CategoryName.value() << ")";
+    OS << "(" << *CategoryName << ")";
   OS << " ";
   OS << MethodName;
   OS << ']';

clang/lib/CodeGen/CGCall.cpp

@@ -3452,7 +3452,7 @@ void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI,
   if (InnerFn) {
     // Don't emit any arg except for `self` if we are in a thunk function.
     // We still need self for nil check, other arguments aren't used in this
-    // function and thus is not needed. Avoid emitting them also prevents
+    // function and thus are not needed. Avoid emitting them also prevents
     // accidental release/retain.
     EmitParmDecl(*Args[0], ArgVals[0], 1);
   } else if (getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()) {

clang/lib/CodeGen/CGObjC.cpp

@@ -789,9 +789,7 @@ void CodeGenFunction::StartObjCMethod(const ObjCMethodDecl *OMD,
       if (CGM.shouldHaveNilCheckThunk(OMD))
         // Go generate  a nil check thunk around `Fn`
         CodeGenFunction(CGM, /*InnerFn=*/Fn).GenerateObjCDirectThunk(OMD, CD);
-      else
-        CGM.getObjCRuntime().GenerateObjCDirectNilCheck(*this, OMD, CD);
-      CGM.getObjCRuntime().GenerateCmdIfNecessary(*this, OMD);
+      CGM.getObjCRuntime().GenerateDirectMethodPrologue(*this, Fn, OMD, CD);
     } else {
       // For GNU family, since GNU Step2 also supports direct methods now.
       CGM.getObjCRuntime().GenerateDirectMethodPrologue(*this, Fn, OMD, CD);
@@ -1660,7 +1658,7 @@ void CodeGenFunction::GenerateObjCDirectThunk(const ObjCMethodDecl *OMD,
     EHStack.popCleanup();
 
   // Generate a nil check.
-  CGM.getObjCRuntime().GenerateObjCDirectNilCheck(*this, OMD, CD);
+  CGM.getObjCRuntime().GenerateDirectMethodPrologue(*this, CurFn, OMD, CD);
   // Call the InnerFn and pass the return value
   SmallVector<llvm::Value *> Args(CurFn->arg_size());
   std::transform(CurFn->arg_begin(), CurFn->arg_end(), Args.begin(),

clang/lib/CodeGen/CGObjCGNU.cpp

@@ -594,15 +594,6 @@ class CGObjCGNU : public CGObjCRuntime {
   }
   llvm::Constant *GetEHType(QualType T) override;
 
-  void GenerateObjCDirectNilCheck(CodeGenFunction &CGF,
-                                  const ObjCMethodDecl *OMD,
-                                  const ObjCContainerDecl *CD) override {
-    // GNU runtime doesn't support nil check thunks at this time
-  };
-  void GenerateCmdIfNecessary(CodeGenFunction &CGF,
-                              const ObjCMethodDecl *OMD) override {
-    // GNU runtime doesn't support nil check thunks at this time
-  }
   llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
                                  const ObjCContainerDecl *CD,
                                  bool isThunk) override {

clang/lib/CodeGen/CGObjCMac.cpp

@@ -1079,15 +1079,6 @@ class CGObjCCommonMac : public CodeGen::CGObjCRuntime {
   void GenerateDirectMethodPrologue(CodeGenFunction &CGF, llvm::Function *Fn,
                                     const ObjCMethodDecl *OMD,
                                     const ObjCContainerDecl *CD) override;
-  /// We split `GenerateDirectMethodPrologue` into the following two functions.
-  /// The motivation is that nil check thunk function does the nil check, it
-  /// definitely doesn't need _cmd.
-  void GenerateObjCDirectNilCheck(CodeGenFunction &CGF,
-                                  const ObjCMethodDecl *OMD,
-                                  const ObjCContainerDecl *CD) override;
-  /// The inner function can decide if it needs `_cmd` for itself.
-  void GenerateCmdIfNecessary(CodeGenFunction &CGF,
-                              const ObjCMethodDecl *OMD) override;
 
   void GenerateProtocol(const ObjCProtocolDecl *PD) override;
 
@@ -3948,99 +3939,16 @@ llvm::Function *CGObjCCommonMac::GenerateDirectMethod(
   return Fn;
 }
 
-void CGObjCCommonMac::GenerateObjCDirectNilCheck(CodeGenFunction &CGF,
-                                                 const ObjCMethodDecl *OMD,
-                                                 const ObjCContainerDecl *CD) {
-  auto &Builder = CGF.Builder;
-  bool ReceiverCanBeNull = true;
-  auto selfAddr = CGF.GetAddrOfLocalVar(OMD->getSelfDecl());
-  auto selfValue = Builder.CreateLoad(selfAddr);
-
-  // Generate:
-  //
-  // /* for class methods only to force class lazy initialization */
-  // self = [self self];
-  //
-  // /* unless the receiver is never NULL */
-  // if (self == nil) {
-  //     return (ReturnType){ };
-  // }
-
-  if (OMD->isClassMethod()) {
-    const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(CD);
-    assert(OID &&
-           "GenerateDirectMethod() should be called with the Class Interface");
-    Selector SelfSel = GetNullarySelector("self", CGM.getContext());
-    auto ResultType = CGF.getContext().getObjCIdType();
-    RValue result;
-    CallArgList Args;
-
-    // TODO: If this method is inlined, the caller might know that `self` is
-    // already initialized; for example, it might be an ordinary Objective-C
-    // method which always receives an initialized `self`, or it might have just
-    // forced initialization on its own.
-    //
-    // We should find a way to eliminate this unnecessary initialization in such
-    // cases in LLVM.
-    result = GeneratePossiblySpecializedMessageSend(
-        CGF, ReturnValueSlot(), ResultType, SelfSel, selfValue, Args, OID,
-        nullptr, true);
-    Builder.CreateStore(result.getScalarVal(), selfAddr);
-
-    // Nullable `Class` expressions cannot be messaged with a direct method
-    // so the only reason why the receive can be null would be because
-    // of weak linking.
-    ReceiverCanBeNull = isWeakLinkedClass(OID);
-  }
-
-  if (ReceiverCanBeNull) {
-    llvm::BasicBlock *SelfIsNilBlock =
-        CGF.createBasicBlock("objc_direct_method.self_is_nil");
-    llvm::BasicBlock *ContBlock =
-        CGF.createBasicBlock("objc_direct_method.cont");
-
-    // if (self == nil) {
-    auto selfTy = cast<llvm::PointerType>(selfValue->getType());
-    auto Zero = llvm::ConstantPointerNull::get(selfTy);
-
-    llvm::MDBuilder MDHelper(CGM.getLLVMContext());
-    Builder.CreateCondBr(Builder.CreateICmpEQ(selfValue, Zero), SelfIsNilBlock,
-                         ContBlock, MDHelper.createBranchWeights(1, 1 << 20));
-
-    CGF.EmitBlock(SelfIsNilBlock);
-
-    //   return (ReturnType){ };
-    auto retTy = OMD->getReturnType();
-    Builder.SetInsertPoint(SelfIsNilBlock);
-    if (!retTy->isVoidType()) {
-      CGF.EmitNullInitialization(CGF.ReturnValue, retTy);
-    }
-    CGF.EmitBranchThroughCleanup(CGF.ReturnBlock);
-    // }
-
-    CGF.EmitBlock(ContBlock);
-    Builder.SetInsertPoint(ContBlock);
-  }
-}
-void CGObjCCommonMac::GenerateCmdIfNecessary(CodeGenFunction &CGF,
-                                             const ObjCMethodDecl *OMD) {
-  // only synthesize _cmd if it's referenced
-  if (OMD->getCmdDecl()->isUsed()) {
-    // `_cmd` is not a parameter to direct methods, so storage must be
-    // explicitly declared for it.
-    CGF.EmitVarDecl(*OMD->getCmdDecl());
-    CGF.Builder.CreateStore(GetSelector(CGF, OMD),
-                            CGF.GetAddrOfLocalVar(OMD->getCmdDecl()));
-  }
-}
-
 void CGObjCCommonMac::GenerateDirectMethodPrologue(
     CodeGenFunction &CGF, llvm::Function *Fn, const ObjCMethodDecl *OMD,
     const ObjCContainerDecl *CD) {
   auto &Builder = CGF.Builder;
   bool ReceiverCanBeNull = true;
   auto selfAddr = CGF.GetAddrOfLocalVar(OMD->getSelfDecl());
   auto selfValue = Builder.CreateLoad(selfAddr);
+  bool shouldHaveNilCheckThunk =
+      CGF.CGM.shouldHaveNilCheckThunk(OMD) bool isNilCheckThunk =
+          shouldHaveNilCheckThunk && CGF.InnerFn;
 
   // Generate:
   //
@@ -4082,7 +3990,10 @@ void CGObjCCommonMac::GenerateDirectMethodPrologue(
     ReceiverCanBeNull = isWeakLinkedClass(OID);
   }
 
-  if (ReceiverCanBeNull) {
+  // Only emit nil check if this is a nil check thunk or the method
+  // decides that its receiver can be null
+  if (isNilCheckThunk ||
+      (!CGF.CGM.shouldHaveNilCheckThunk(OMD) && ReceiverCanBeNull)) {
     llvm::BasicBlock *SelfIsNilBlock =
         CGF.createBasicBlock("objc_direct_method.self_is_nil");
     llvm::BasicBlock *ContBlock =
@@ -4112,14 +4023,19 @@ void CGObjCCommonMac::GenerateDirectMethodPrologue(
     Builder.SetInsertPoint(ContBlock);
   }
 
-  // only synthesize _cmd if it's referenced
-  if (OMD->getCmdDecl()->isUsed()) {
+  // Only synthesize _cmd if it's referenced
+  // However, a nil check thunk doesn't need _cmd even if it's referenced
+  if (!isNilCheckThunk && OMD->getCmdDecl()->isUsed()) {
     // `_cmd` is not a parameter to direct methods, so storage must be
     // explicitly declared for it.
     CGF.EmitVarDecl(*OMD->getCmdDecl());
     Builder.CreateStore(GetSelector(CGF, OMD),
                         CGF.GetAddrOfLocalVar(OMD->getCmdDecl()));
   }
+
+  // It's possible that selfValue is never used.
+  if (selfValue->use_empty())
+    selfValue->eraseFromParent();
 }
 
 llvm::GlobalVariable *

clang/lib/CodeGen/CGObjCRuntime.h

@@ -233,11 +233,6 @@ class CGObjCRuntime {
                                             const ObjCMethodDecl *OMD,
                                             const ObjCContainerDecl *CD) = 0;
 
-  virtual void GenerateObjCDirectNilCheck(CodeGenFunction &CGF,
-                                          const ObjCMethodDecl *OMD,
-                                          const ObjCContainerDecl *CD) = 0;
-  virtual void GenerateCmdIfNecessary(CodeGenFunction &CGF,
-                                      const ObjCMethodDecl *OMD) = 0;
   /// Return the runtime function for getting properties.
   virtual llvm::FunctionCallee GetPropertyGetFunction() = 0;