Add Attribute to define nonlazy objc classes

[joedaniels29]

Summary

Currently to get a nonlazy class in objective c, you need to define a +load method.
Because we do other work when we realize a class, other than just call that load method, it would be ideal to have an attribute to mark a class as nonlazy.
libdispatch, libtrace, objc, Foundation all define empty +load methods, simply to make certain classes nonlazy. This is done during process initialization which causes code pages to be faulted in that shouldn't be and increase the code side working set that is needed only for the sake of creating a process.

[aaron.ballman]

The patch is missing SemaObjC tests that ensure the attribute only appertains to the expected subjects, accepts no args, etc.

clang/include/clang/Basic/Attr.td

1696 ↗

(On Diff #181139)

No new undocumented attributes, please.

Does this attribute make sense when compiling a non-ObjC compiland? e.g., should this also have a let LangOpts = [ObjC]; as well?

clang/lib/Sema/SemaDeclAttr.cpp

6377–6379 ↗

(On Diff #181139)

Formatting is incorrect here -- you should run the patch through clang-format.

[joedaniels29]

Tried to fix Aaron Ballman's feedback. Thanks Aaron!

[aaron.ballman]

It's still missing the tests in SemaObjC -- you can use clang\test\SemaObjC\attr-root-class.m as an example of what I'm talking about.

clang/include/clang/Basic/Attr.td

1697 ↗

(On Diff #181371)

You need to hook this up to ObjCNonLazyClassDocs.

clang/test/CodeGenObjC/non-lazy-classes.m

39–40 ↗

(On Diff #181371)

The formatting is incorrect here.

[joedaniels29]

Hopefully addressed Aaron's comments. Thanks again Aaron.

[joedaniels29]

never mind, I didnt address

It's still missing the tests in SemaObjC -- you can use clang\test\SemaObjC\attr-root-class.m as an example of what I'm talking about.

[joedaniels29]

On second thought, I have addressed everything, I think.

clang/test/SemaObjC/attr-objc-non-lazy.m

Aaron, would you mind taking another look? Thanks a bunch.

[aaron.ballman]

In terms of implementation, the attribute code looks pretty close (just a few nits). However, someone more familiar with Obj-C should chime in with whether the attribute semantics make sense and whether the documentation will be sufficiently clear for an Objective-C user.

clang/include/clang/Basic/AttrDocs.td

3506 ↗

(On Diff #181692)

Add backticks around objc_init() because it should be in code font.

clang/test/CodeGenObjC/non-lazy-classes.m

6–7 ↗

(On Diff #181692)

Spurious change that can be reverted?

31–32 ↗

(On Diff #181692)

Spurious change that can be reverted?

clang/test/SemaObjC/attr-objc-non-lazy.m

35 ↗

(On Diff #181692)

Please add a newline to the end of this file.

[rjmccall]

clang/include/clang/Basic/AttrDocs.td

3506 ↗

(On Diff #181692)

I don't think "objc_init() time" is a widely-recognized concept. How about:

A non-lazy class will be initialized eagerly when the Objective-C runtime is loaded.  This is required for certain system classes which have instances allocated in non-standard ways, such as the classes for blocks and constant strings.  Adding this attribute is essentially equivalent to providing a trivial `+load` method but avoids the (fairly small) load-time overheads associated with defining and calling such a method.

[joedaniels29]

Docs changes, formatting.

[rjmccall]

Thanks! I'd like Aaron to sign off as well before we commit this.

[aaron.ballman]

LGTM!

cfe/trunk/include/clang/Basic/Attr.td

 }
 
 def ObjCRootClass : InheritableAttr {
   let Spellings = [Clang<"objc_root_class">];
   let Subjects = SubjectList<[ObjCInterface], ErrorDiag>;
   let Documentation = [Undocumented];
 }
 
+def ObjCNonLazyClass : Attr {
+  let Spellings = [Clang<"objc_nonlazy_class">];
+  let Subjects = SubjectList<[ObjCInterface], ErrorDiag>;
+  let LangOpts = [ObjC];
+  let Documentation = [ObjCNonLazyClassDocs];
+}
+
 def ObjCSubclassingRestricted : InheritableAttr {
   let Spellings = [Clang<"objc_subclassing_restricted">];
   let Subjects = SubjectList<[ObjCInterface], ErrorDiag>;
   let Documentation = [ObjCSubclassingRestrictedDocs];
 }
 
 def ObjCExplicitProtocolImpl : InheritableAttr {
   let Spellings = [Clang<"objc_protocol_requires_explicit_implementation">];

cfe/trunk/include/clang/Basic/AttrDocs.td

 def ObjCSubclassingRestrictedDocs : Documentation {
   let Category = DocCatType;
   let Content = [{
 This attribute can be added to an Objective-C ``@interface`` declaration to
 ensure that this class cannot be subclassed.
   }];
 }
 
+def ObjCNonLazyClassDocs : Documentation {
+  let Category = DocCatType;
+  let Content = [{
+This attribute can be added to an Objective-C ``@interface`` declaration to
+add the class to the list of non-lazily initialized classes. A non-lazy class
+will be initialized eagerly when the Objective-C runtime is loaded.  This is
+required for certain system classes which have instances allocated in
+non-standard ways, such as the classes for blocks and constant strings.  Adding
+this attribute is essentially equivalent to providing a trivial `+load` method 
+but avoids the (fairly small) load-time overheads associated with defining and
+calling such a method.
+  }];
+}
 
 def SelectAnyDocs : Documentation {
   let Category = DocCatType;
   let Content = [{
 This attribute appertains to a global symbol, causing it to have a weak
 definition (
 `linkonce <https://llvm.org/docs/LangRef.html#linkage-types>`_
 ), allowing the linker to select any definition.

cfe/trunk/lib/CodeGen/CGObjCMac.cpp

CGObjCNonFragileABIMac::BuildClassObject(const ObjCInterfaceDecl *CI,
   GV->setAlignment(
       CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABITy));
   if (!CGM.getTriple().isOSBinFormatCOFF())
     if (HiddenVisibility)
       GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
   return GV;
 }
 
-bool
-CGObjCNonFragileABIMac::ImplementationIsNonLazy(const ObjCImplDecl *OD) const {
-  return OD->getClassMethod(GetNullarySelector("load")) != nullptr;
+bool CGObjCNonFragileABIMac::ImplementationIsNonLazy(
+    const ObjCImplDecl *OD) const {
+  return OD->getClassMethod(GetNullarySelector("load")) != nullptr ||
+         OD->getClassInterface()->hasAttr<ObjCNonLazyClassAttr>();
 }
 
 void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID,
                                               uint32_t &InstanceStart,
                                               uint32_t &InstanceSize) {
   const ASTRecordLayout &RL =
     CGM.getContext().getASTObjCImplementationLayout(OID);
 

cfe/trunk/lib/Sema/SemaDeclAttr.cpp

case ParsedAttr::AT_Unavailable:
     handleAttrWithMessage<UnavailableAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_ArcWeakrefUnavailable:
     handleSimpleAttribute<ArcWeakrefUnavailableAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_ObjCRootClass:
     handleSimpleAttribute<ObjCRootClassAttr>(S, D, AL);
     break;
+  case ParsedAttr::AT_ObjCNonLazyClass:
+    handleSimpleAttribute<ObjCNonLazyClassAttr>(S, D, AL);
+    break;
   case ParsedAttr::AT_ObjCSubclassingRestricted:
     handleSimpleAttribute<ObjCSubclassingRestrictedAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_ObjCExplicitProtocolImpl:
     handleObjCSuppresProtocolAttr(S, D, AL);
     break;
   case ParsedAttr::AT_ObjCRequiresPropertyDefs:
     handleSimpleAttribute<ObjCRequiresPropertyDefsAttr>(S, D, AL);

cfe/trunk/test/CodeGenObjC/non-lazy-classes.m

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -Wno-objc-root-class -emit-llvm -o - %s | \
 // RUN: FileCheck %s
-// CHECK: @"OBJC_LABEL_NONLAZY_CLASS_$" = private global [1 x {{.*}}] {{.*}}@"OBJC_CLASS_$_A"{{.*}}, section "__DATA,__objc_nlclslist,regular,no_dead_strip", align 8
+// CHECK: @"OBJC_LABEL_NONLAZY_CLASS_$" = private global [2 x {{.*}}]{{.*}}@"OBJC_CLASS_$_A"{{.*}},{{.*}}@"OBJC_CLASS_$_D"{{.*}} section "__DATA,__objc_nlclslist,regular,no_dead_strip", align 8
 // CHECK: @"OBJC_LABEL_NONLAZY_CATEGORY_$" = private global [1 x {{.*}}] {{.*}}@"\01l_OBJC_$_CATEGORY_A_$_Cat"{{.*}}, section "__DATA,__objc_nlcatlist,regular,no_dead_strip", align 8
 
 @interface A @end
 @implementation A
 +(void) load {
 }
 @end
 

 @implementation B (Cat)
 -(void) load {
 }
 @end
 
 @interface C : A @end
 @implementation C
 @end
+
+__attribute__((objc_nonlazy_class))
+@interface D @end
+
+@implementation D @end

cfe/trunk/test/Misc/pragma-attribute-supported-attributes-list.test

 // CHECK-NEXT: ObjCBoxable (SubjectMatchRule_record)
 // CHECK-NEXT: ObjCBridge (SubjectMatchRule_record, SubjectMatchRule_type_alias)
 // CHECK-NEXT: ObjCBridgeMutable (SubjectMatchRule_record)
 // CHECK-NEXT: ObjCBridgeRelated (SubjectMatchRule_record)
 // CHECK-NEXT: ObjCException (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: ObjCExplicitProtocolImpl (SubjectMatchRule_objc_protocol)
 // CHECK-NEXT: ObjCExternallyRetained (SubjectMatchRule_variable_not_is_parameter, SubjectMatchRule_function, SubjectMatchRule_block, SubjectMatchRule_objc_method)
 // CHECK-NEXT: ObjCMethodFamily (SubjectMatchRule_objc_method)
+// CHECK-NEXT: ObjCNonLazyClass (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: ObjCPreciseLifetime (SubjectMatchRule_variable)
 // CHECK-NEXT: ObjCRequiresPropertyDefs (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: ObjCRequiresSuper (SubjectMatchRule_objc_method)
 // CHECK-NEXT: ObjCReturnsInnerPointer (SubjectMatchRule_objc_method, SubjectMatchRule_objc_property)
 // CHECK-NEXT: ObjCRootClass (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: ObjCRuntimeName (SubjectMatchRule_objc_interface, SubjectMatchRule_objc_protocol)
 // CHECK-NEXT: ObjCRuntimeVisible (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: ObjCSubclassingRestricted (SubjectMatchRule_objc_interface)

cfe/trunk/test/SemaObjC/attr-objc-non-lazy.m

+// RUN: %clang_cc1 -verify -Wno-objc-root-class  -fsyntax-only  %s
+
+__attribute__((objc_nonlazy_class))
+@interface A
+@end
+@implementation A
+@end
+
+__attribute__((objc_nonlazy_class)) int X; // expected-error {{'objc_nonlazy_class' attribute only applies to Objective-C interfaces}}
+
+__attribute__((objc_nonlazy_class()))
+@interface B
+@end
+@implementation B
+@end
+
+__attribute__((objc_nonlazy_class("foo"))) // expected-error{{'objc_nonlazy_class' attribute takes no arguments}}
+@interface C
+@end
+@implementation C
+@end
+
+__attribute__((objc_nonlazy_class)) // expected-error {{'objc_nonlazy_class' attribute only applies to Objective-C interfaces}}
+@protocol B
+@end
+
+__attribute__((objc_nonlazy_class)) // expected-error {{'objc_nonlazy_class' attribute only applies to Objective-C interfaces}}
+void foo();
+
+@interface E
+@end
+__attribute__((objc_nonlazy_class))
+@implementation E // expected-error {{prefix attribute must be followed by an interface or protocol}}
+@end