[Not for review, only reference] Adding attribute to private method for inlining

[hiraditya]

Summary

add function attribute to private methods
Check that private function has this attribute.

include/clang/Basic/Attr.td

   let Documentation = [SomeAttr];
 }
 
+def PrivateMethod : InheritableAttr {
+  let Spellings = [GCC<"objc_private_method">];
+  let Subjects = SubjectList<[ObjCMethod]>;
+  let Documentation = [ObjCPrivateMethodDocs];
+}
+
 def SomeAnotherAttr : InheritableAttr {
     let Spellings = [GNU<"SomeThing">];
     let Subjects = SubjectList<[Method], ErrorDiag>;

include/clang/Basic/AttrDocs.td

   }];
 }
 
+def ObjCPrivateMethodDocs : Documentation {
+
+  let Category = DocCatFunction;
+  let Content = [{
+
+In order to hide the APIs which are only meant to be used within a module,
+there are many interfaces which are declared internally within a source
+file (.m/.mm), and several methods which are declared/defined
+internally as well. Adding this attribute enables compiler optimizations
+that may benefit code size as well as performance. The compiler will remove
+the ObjC_msgSend to these calls by devirtualizing the call sites.
+
+**Usage**: ``__attribute__((objc_private_method))``.  This attribute can only
+be placed at the end of a objective C method declaration:
+
+.. code-block:: objc
+
+@interface MYObject ()
+- (void)MYObject_privateMethod __attribute__((objc_private_method));
+@end
+
+This attribute can only be applied to method declarations within a class.
+
+The user can define a macro that provides syntactic sugar for this attribute.
+This macro is conditionally defined depending on the compiler's support for
+this attribute.  If the compiler does not support the attribute the macro
+expands to nothing.
+
+
+
 def SomeMore : Documentation {
   let Category = DocCatFunction;
   let Content = [{

include/clang/Sema/Sema.h

   AlwaysInlineAttr *mergeAlwaysInlineAttr(Decl *D, SourceRange Range,
                                           IdentifierInfo *Ident,
                                           unsigned AttrSpellingListIndex);
+  PrivateMethodAttr *mergePrivateMethodAttr(Decl *D, SourceRange Range,
+                                            unsigned AttrSpellingListIndex);
   MinSizeAttr *mergeMinSizeAttr(Decl *D, SourceRange Range,
                                 unsigned AttrSpellingListIndex);
   OptimizeNoneAttr *mergeOptimizeNoneAttr(Decl *D, SourceRange Range,

lib/CodeGen/CGObjC.cpp

 
   const CGFunctionInfo &FI = CGM.getTypes().arrangeObjCMethodDeclaration(OMD);
   CGM.SetInternalFunctionAttributes(OMD, Fn, FI);
+  // Add private method attribute.
+  if (const ObjCInterfaceDecl *iface = dyn_cast<ObjCInterfaceDecl>(CD)) {
+    Selector Sel = OMD->getSelector();
+    if (Attr *A = OMD->getAttr<PrivateMethodAttr>()) {
+      // The attribute may be set in the source code or may be inferred
+      // in the SemaDeclObjC.
+      if (!Fn->hasFnAttribute(llvm::Attribute::OptimizeNone)) {
+        Fn->removeFnAttr(llvm::Attribute::NoInline);
+        Fn->removeFnAttr(llvm::Attribute::OptimizeNone);
+        Fn->addAttribute(llvm::AttributeList::FunctionIndex,
+                         llvm::Attribute::AlwaysInline);
+      }
+    }
+  }
 
   // Always add annotation on definitions so we know what are defined, and
   // which selector has a unique definition.

lib/Sema/SemaDeclAttr.cpp

       InternalLinkageAttr(AL.getRange(), Context, AL.getSpellingListIndex());
 }
 
+PrivateMethodAttr *
+Sema::mergePrivateMethodAttr(Decl *D, SourceRange Range,
+                             unsigned AttrSpellingListIndex) {
+  if (D->hasAttr<PrivateMethodAttr>())
+    return nullptr;
+
+  return ::new (Context)
+      PrivateMethodAttr(Range, Context, AttrSpellingListIndex);
+}
+
 MinSizeAttr *Sema::mergeMinSizeAttr(Decl *D, SourceRange Range,
                                     unsigned AttrSpellingListIndex) {
   if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {

       Attrs.getRange(), S.Context, Attrs.getAttributeSpellingListIndex()));
 }
 
+static void handlePrivateMethodAttr(Sema &S, Decl *D,
+                                    const AttributeList &Attr) {
+  if (D->getKind() != Decl::ObjCMethod) {
+    S.Diag(Attr.getLoc(), diag::err_stmt_attribute_invalid_on_decl)
+        << Attr.getName() << D->getLocation();
+    // Drop the attribute.
+    return;
+  }
+
+  if (PrivateMethodAttr *A = S.mergePrivateMethodAttr(
+          D, Attr.getRange(), Attr.getAttributeSpellingListIndex()))
+    D->addAttr(A);
+}
+
 static void handleAttr(Sema &S, Decl *D,
                                          const AttributeList &attr,
                                          bool Act = false) {

   case ParsedAttr::AT_Artificial:
     handleSimpleAttribute<ArtificialAttr>(S, D, AL);
     break;
+  case AttributeList::AT_PrivateMethod:
+    handlePrivateMethodAttr(S, D, AL);
+    break;
   case ParsedAttr::AT_AnalyzerNoReturn:
     handleAnalyzerNoReturnAttr(S, D, AL);
     break;