Make changes to CodeGen and Serialization that are needed to support

feature-based availability

rdar://137999979

Author: ahatanaka

clang/lib/CodeGen/CGExprScalar.cpp

@@ -552,6 +552,13 @@ class ScalarExprEmitter
   }
 
   Value *VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
+    if (E->hasDomainName()) {
+      auto DomainName = E->getDomainName();
+      ASTContext::AvailabilityDomainInfo Info =
+          CGF.getContext().getFeatureAvailInfo(DomainName);
+      return CGF.EmitScalarExpr(Info.Call);
+    }
+
     VersionTuple Version = E->getVersionAsWritten();
 
     // If we're checking for a platform older than our minimum deployment

clang/lib/CodeGen/CGObjCMac.cpp

@@ -3197,6 +3197,8 @@ PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*,16> &PropertySet,
                        const ObjCProtocolDecl *Proto,
                        bool IsClassProperty) {
   for (const auto *PD : Proto->properties()) {
+    if (Proto->getASTContext().hasUnavailableFeature(PD))
+      continue;
     if (IsClassProperty != PD->isClassProperty())
       continue;
     if (!PropertySet.insert(PD->getIdentifier()).second)
@@ -3240,6 +3242,8 @@ llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name,
   if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
     for (const ObjCCategoryDecl *ClassExt : OID->known_extensions())
       for (auto *PD : ClassExt->properties()) {
+        if (CGM.getContext().hasUnavailableFeature(PD))
+          continue;
         if (IsClassProperty != PD->isClassProperty())
           continue;
         if (PD->isDirectProperty())
@@ -3249,6 +3253,8 @@ llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name,
       }
 
   for (const auto *PD : OCD->properties()) {
+    if (CGM.getContext().hasUnavailableFeature(PD))
+      continue;
     if (IsClassProperty != PD->isClassProperty())
       continue;
     // Don't emit duplicate metadata for properties that were already in a
@@ -6735,6 +6741,9 @@ void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
 void CGObjCNonFragileABIMac::emitMethodConstant(ConstantArrayBuilder &builder,
                                                 const ObjCMethodDecl *MD,
                                                 bool forProtocol) {
+  if (CGM.getContext().hasUnavailableFeature(MD))
+    return;
+
   auto method = builder.beginStruct(ObjCTypes.MethodTy);
   method.add(GetMethodVarName(MD->getSelector()));
   method.add(GetMethodVarType(MD));
@@ -6934,6 +6943,9 @@ llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList(
     if (!IVD->getDeclName())
       continue;
 
+    if (CGM.getContext().hasUnavailableFeature(IVD))
+      continue;
+
     auto ivar = ivars.beginStruct(ObjCTypes.IvarnfABITy);
     ivar.add(EmitIvarOffsetVar(ID->getClassInterface(), IVD,
                                ComputeIvarBaseOffset(CGM, ID, IVD)));

clang/lib/CodeGen/CodeGenModule.cpp

@@ -5222,6 +5222,9 @@ void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
       return;
   }
 
+  if (Context.hasUnavailableFeature(D))
+    return;
+
   // The tentative definition is the only definition.
   EmitGlobalVarDefinition(D);
 }
@@ -6729,6 +6732,9 @@ ConstantAddress CodeGenModule::GetAddrOfGlobalTemporary(
 void CodeGenModule::EmitObjCPropertyImplementations(const
                                                     ObjCImplementationDecl *D) {
   for (const auto *PID : D->property_impls()) {
+    if (Context.hasUnavailableFeature(PID->getPropertyDecl()))
+      continue;
+
     // Dynamic is just for type-checking.
     if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
       ObjCPropertyDecl *PD = PID->getPropertyDecl();
@@ -6887,6 +6893,9 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) {
   if (auto *FD = dyn_cast<FunctionDecl>(D); FD && FD->isImmediateFunction())
     return;
 
+  if (Context.hasUnavailableFeature(D))
+    return;
+
   switch (D->getKind()) {
   case Decl::CXXConversion:
   case Decl::CXXMethod:
@@ -7016,6 +7025,8 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) {
   }
   case Decl::ObjCMethod: {
     auto *OMD = cast<ObjCMethodDecl>(D);
+    if (Context.hasUnavailableFeature(OMD->getClassInterface()))
+      break;
     // If this is not a prototype, emit the body.
     if (OMD->getBody())
       CodeGenFunction(*this).GenerateObjCMethod(OMD);

clang/lib/Serialization/ASTReaderStmt.cpp

@@ -1659,11 +1659,18 @@ void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
 
 void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
   VisitExpr(E);
+  unsigned DomainNameLength = Record.readInt();
+  E->setHasDomainName(Record.readInt());
   SourceRange R = Record.readSourceRange();
   E->AtLoc = R.getBegin();
   E->RParen = R.getEnd();
   E->VersionToCheck.Version = Record.readVersionTuple();
   E->VersionToCheck.SourceVersion = Record.readVersionTuple();
+  if (E->hasDomainName()) {
+    std::string DomainName = Record.readString();
+    assert(DomainNameLength == DomainName.size());
+    strcpy(E->getTrailingObjects<char>(), DomainName.data());
+  }
 }
 
 //===----------------------------------------------------------------------===//
@@ -3481,7 +3488,8 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
       break;
 
     case EXPR_OBJC_AVAILABILITY_CHECK:
-      S = new (Context) ObjCAvailabilityCheckExpr(Empty);
+      S = ObjCAvailabilityCheckExpr::CreateEmpty(
+          Context, Empty, Record[ASTStmtReader::NumExprFields]);
       break;
 
     case STMT_SEH_LEAVE:

clang/lib/Serialization/ASTWriterStmt.cpp

@@ -1623,9 +1623,13 @@ void ASTStmtWriter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
 
 void ASTStmtWriter::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
   VisitExpr(E);
+  Record.push_back(E->hasDomainName() ? E->getDomainName().size() : 0);
+  Record.push_back(E->hasDomainName());
   Record.AddSourceRange(E->getSourceRange());
   Record.AddVersionTuple(E->getVersion());
   Record.AddVersionTuple(E->getVersionAsWritten());
+  if (E->hasDomainName())
+    Record.AddString(E->getDomainName());
   Code = serialization::EXPR_OBJC_AVAILABILITY_CHECK;
 }
 

clang/test/CodeGen/feature-availability.c

@@ -0,0 +1,109 @@
+// RUN: %clang_cc1 -triple arm64-apple-macosx -fblocks -ffeature-availability=feature1:on -ffeature-availability=feature2:off -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple arm64-apple-macosx -fblocks -emit-llvm -o - -DUSE_DOMAIN %s | FileCheck --check-prefixes=CHECK,DOMAIN %s
+
+// RUN: %clang_cc1 -triple arm64-apple-macosx -fblocks -ffeature-availability=feature1:on -ffeature-availability=feature2:off -emit-pch -o %t %s
+// RUN: %clang_cc1 -triple arm64-apple-macosx -fblocks -ffeature-availability=feature1:on -ffeature-availability=feature2:off -include-pch %t -emit-llvm -o - %s | FileCheck %s
+
+// CHECK: %[[STRUCT_S0:.*]] = type { i32 }
+// CHECK: @g0 = external global i32, align 4
+// CHECK-NOT: @g1
+// CHECK-NOT: @g2
+
+#ifndef HEADER
+#define HEADER
+
+#include <feature-availability.h>
+
+#define AVAIL 0
+
+#ifdef USE_DOMAIN
+// DOMAIN: @g3 = extern_weak global i32, align 4
+
+static struct __AvailabilityDomain feature1 __attribute__((availability_domain(feature1))) = {__AVAILABILITY_DOMAIN_ENABLED, 0};
+static struct __AvailabilityDomain feature2 __attribute__((availability_domain(feature2))) = {__AVAILABILITY_DOMAIN_DISABLED, 0};
+#endif
+
+__attribute__((availability(domain:feature1, AVAIL))) int func0(void);
+__attribute__((availability(domain:feature2, AVAIL))) int func1(void);
+int func2(void);
+
+__attribute__((availability(domain:feature1, AVAIL))) extern int g0;
+__attribute__((availability(domain:feature2, AVAIL))) int g1 = 100;
+__attribute__((availability(domain:feature2, AVAIL))) int g2;
+
+struct __attribute__((availability(domain:feature1, AVAIL))) S0 {
+  int d0;
+};
+
+// CHECK-LABEL: define void @test0()
+// CHECK-NOT: br
+// CHECK: call i32 @func0()
+// CHECK: store i32 123, ptr @g0, align 4
+// CHECK-NOT: func1()
+// CHECK-NOT: func2()
+void test0(void) {
+  if (__builtin_available(domain:feature1)) {
+    func0();
+    g0 = 123;
+  }
+
+  if (__builtin_available(domain:feature2)) {
+    func1();
+    g1 = 123;
+  }
+
+  if (__builtin_available(domain:feature1))
+    if (__builtin_available(domain:feature2)) {
+      func2();
+    }
+}
+
+// CHECK-LABEL: define void @test1()
+__attribute__((availability(domain:feature1, AVAIL)))
+void test1(void) {
+}
+
+// CHECK-NOT: @test2(
+__attribute__((availability(domain:feature2, AVAIL)))
+void test2(void) {
+}
+
+// CHECK-LABEL: define void @test3(
+// CHECK: %[[D0:.*]] = getelementptr inbounds %[[STRUCT_S0]], ptr %{{.*}}, i32 0, i32 0
+// CHECK: store i32 134, ptr %[[D0]], align 4
+__attribute__((availability(domain:feature1, AVAIL)))
+void test3(struct S0 *s0) {
+  s0->d0 = 134;
+}
+
+#ifdef USE_DOMAIN
+// DOMAIN-LABEL: define void @test4()
+// DOMAIN: %[[CALL:.*]] = call i32 @pred1()
+// DOMAIN-NEXT: %[[TOBOOL:.*]] = icmp ne i32 %[[CALL]], 0
+// DOMAIN-NEXT: br i1 %[[TOBOOL]], label %[[IF_THEN:.*]], label %[[IF_END:.*]]
+//
+// DOMAIN: [[IF_THEN]]:
+// DOMAIN-NEXT: %[[CALL1:.*]] = call i32 @func3()
+// DOMAIN-NEXT: store i32 1, ptr @g3, align 4
+// DOMAIN-NEXT: br label %[[IF_END]]
+//
+// DOMAIN: [[IF_END]]:
+// DOMAIN-NEXT: ret void
+
+int pred1(void);
+static struct __AvailabilityDomain feature3 __attribute__((availability_domain(feature3))) = {__AVAILABILITY_DOMAIN_DYNAMIC, pred1};
+__attribute__((availability(domain:feature3, AVAIL))) int func3(void);
+__attribute__((availability(domain:feature3, AVAIL))) extern int g3;
+
+void test4(void) {
+  if (__builtin_available(domain:feature3)) {
+    func3();
+    g3 = 1;
+  }
+}
+
+// DOMAIN: declare extern_weak i32 @func3()
+
+#endif
+
+#endif /* HEADER */