[clang][Fuchsia] Support __attribute__((availability)) on Fuchsia

[haowei]

Summary

Also in this patch:

• Control the fuchsia version via a new flag (-ffuchsia-api-level).
• Add a warning that triggers when a non-zero minor/subminor are used for the fuchsia version.

[leonardchan]

Some extra comments/open questions:

• This patch supports using N.0.0 as a version number. Do we want to just only accept N and disallow any number for minor/subminor, or will zeros be allowed?
• This currently will only work if the major number is provided via the target triple (x86_64-unknown-fuchsia16). Do we have a concept of a default version number for fuchsia we can fall back to if this is not provided?

[phosek]

clang/include/clang/Basic/LangOptions.def

432

This is more consistent with other options.

clang/lib/Basic/Targets/OSTargets.h

893

We also want to define a __FUCHSIA_VERSION__ so the version can be read at compile time.

clang/test/Frontend/attr-availability-fuchsia.c

4 ↗

(On Diff #368423)

Would this also set the availability attribute? Can we test it? If not then this isn't particularly useful.

[aaron.ballman]

clang/test/Frontend/attr-availability-fuchsia.c

2 ↗

(On Diff #368423)

Is |& intentional? I think that's causing shell parse errors on Windows (same for the other test).

Also should this test be in Driver instead as it's testing the driver functionality?

[haowei]

I am commandeering this work as original author stopped working this project.

[aaron.ballman]

clang/include/clang/Basic/DiagnosticSemaKinds.td

3557

clang/lib/Basic/Targets/OSTargets.h

893

I think this macro should be using a reserved name, as suggested by @phosek.

clang/test/Frontend/attr-availability-fuchsia.c

2 ↗

(On Diff #377389)

Can you also add a test that shows how we handle -ffuchsia-api-level=16.0.0?

2 ↗

(On Diff #368423)

This test should be in Driver, right?

clang/test/Sema/attr-availability-fuchsia.c

15

FWIW, this surprises me. I would have expected that 16, 16.0, and 16.0.0 were all equivalent and the issue was with specifying a nonzero value for those. I've suggested new wording for the diagnostic that might make it more clear.

[phosek]

clang/lib/Basic/Targets/OSTargets.h

893

@aaron.ballman Do you have any thoughts on the letter case? I think that __Fuchsia_API_level__ might be a better match for __Fuchsia__. Upper case is perhaps more usual, but other platforms like *BSD also use mixed case.

[haowei]

clang/lib/Basic/Targets/OSTargets.h

893

I changed it to "Fuchsia_API_level" for now.

clang/test/Frontend/attr-availability-fuchsia.c

2 ↗

(On Diff #377389)

I did. But it does not fail. I will look into it to see if I can add the same constraint like the attributes tomorrow.

4 ↗

(On Diff #368423)

Do you mean the macros? I can add one.

[aaron.ballman]

clang/lib/Basic/Targets/OSTargets.h

893

I don't have strong opinions so long as the identifier is reserved (and it is). I would note that the current capitalization might be a bit annoying for users to remember because it's Fuchsia, API, and level, all with different casing styles.

[haowei]

I added unit test for macros. I am still working on adding error checks on --ffuchsia-api-level flags but the rest is pretty much done.

clang/test/Frontend/attr-availability-fuchsia.c

4 ↗

(On Diff #368423)

@phosek I added unit test for macros. Could you confirm it is what you suggested in the previous comments? Thanks.

[haowei]

Added unit test when "-ffuchsia-api-level" is supplied with a non integer value.

[phosek]

LGTM

clang/include/clang/Basic/LangOptions.def

432

clang/include/clang/Driver/Options.td

3166

clang/test/Driver/attr-availability-fuchsia.c

2–25

Can you reorder this so CHECK always follows the corresponding RUN and separate each case by an empty line? I find it more readable.

[haowei]

Fix test failures on Windows.

[haowei]

Address review comments.

clang/include/clang/Basic/Attr.td

let Args = [IdentifierArgument<"platform">, VersionArgument<"introduced">,
               VersionArgument<"deprecated">, VersionArgument<"obsoleted">,
               BoolArgument<"unavailable">, StringArgument<"message">,
               BoolArgument<"strict">, StringArgument<"replacement">,
               IntArgument<"priority">];
   let AdditionalMembers =
 [{static llvm::StringRef getPrettyPlatformName(llvm::StringRef Platform) {
     return llvm::StringSwitch<llvm::StringRef>(Platform)
              .Case("android", "Android")
+             .Case("fuchsia", "Fuchsia")
              .Case("ios", "iOS")
              .Case("macos", "macOS")
              .Case("tvos", "tvOS")
              .Case("watchos", "watchOS")
              .Case("ios_app_extension", "iOS (App Extension)")
              .Case("macos_app_extension", "macOS (App Extension)")
              .Case("tvos_app_extension", "tvOS (App Extension)")
              .Case("watchos_app_extension", "watchOS (App Extension)")

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_availability_on_static_initializer : Warning<
   InGroup<Availability>;
 def note_overridden_method : Note<
   "overridden method is here">;
 def warn_availability_swift_unavailable_deprecated_only : Warning<
   "only 'unavailable' and 'deprecated' are supported for Swift availability">,
   InGroup<Availability>;
 def note_protocol_method : Note<
   "protocol method is here">;
+def warn_availability_fuchsia_unavailable_minor : Warning<
+  "Fuchsia API Level prohibits specifying a minor or sub-minor version">,
+  InGroup<Availability>;
 
 def warn_unguarded_availability :
   Warning<"%0 is only available on %1 %2 or newer">,
   InGroup<UnguardedAvailability>, DefaultIgnore;
 def warn_unguarded_availability_new :
   Warning<warn_unguarded_availability.Text>,
   InGroup<UnguardedAvailabilityNew>;
 def note_decl_unguarded_availability_silence : Note<

clang/include/clang/Basic/LangOptions.def

LANGOPT(RelativeCXXABIVTables, 1, 0,
         "Use an ABI-incompatible v-table layout that uses relative references")
 
 LANGOPT(ArmSveVectorBits, 32, 0, "SVE vector size in bits")
 
 ENUM_LANGOPT(ExtendIntArgs, ExtendArgsKind, 1, ExtendArgsKind::ExtendTo32,
              "Controls how scalar integer arguments are extended in calls "
              "to unprototyped and varargs functions")
 
+VALUE_LANGOPT(FuchsiaAPILevel, 32, 0, "Fuchsia API Level")
+
 #undef LANGOPT
 #undef COMPATIBLE_LANGOPT
 #undef BENIGN_LANGOPT
 #undef ENUM_LANGOPT
 #undef COMPATIBLE_ENUM_LANGOPT
 #undef BENIGN_ENUM_LANGOPT
 #undef VALUE_LANGOPT
 #undef COMPATIBLE_VALUE_LANGOPT
 #undef BENIGN_VALUE_LANGOPT

clang/include/clang/Driver/Options.td

 def mios_simulator_version_min_EQ : Joined<["-"], "mios-simulator-version-min=">;
 def miphonesimulator_version_min_EQ : Joined<["-"], "miphonesimulator-version-min=">, Alias<mios_simulator_version_min_EQ>;
 def mkernel : Flag<["-"], "mkernel">, Group<m_Group>;
 def mlinker_version_EQ : Joined<["-"], "mlinker-version=">,
   Flags<[NoXarchOption]>;
 def mllvm : Separate<["-"], "mllvm">, Flags<[CC1Option,CC1AsOption,CoreOption]>,
   HelpText<"Additional arguments to forward to LLVM's option processing">,
   MarshallingInfoStringVector<FrontendOpts<"LLVMArgs">>;
+def ffuchsia_api_level_EQ : Joined<["-"], "ffuchsia-api-level=">,
+  Group<m_Group>, Flags<[CC1Option]>, HelpText<"Set Fuchsia API Level target">,
+  MarshallingInfoInt<LangOpts<"FuchsiaAPILevel">>;
 def mmacosx_version_min_EQ : Joined<["-"], "mmacosx-version-min=">,
   Group<m_Group>, HelpText<"Set Mac OS X deployment target">;
 def mmacos_version_min_EQ : Joined<["-"], "mmacos-version-min=">,
   Group<m_Group>, Alias<mmacosx_version_min_EQ>;
 def mms_bitfields : Flag<["-"], "mms-bitfields">, Group<m_Group>, Flags<[CC1Option]>,
   HelpText<"Set the default structure layout to be compatible with the Microsoft compiler standard">,
   MarshallingInfoFlag<LangOpts<"MSBitfields">>;
 def moutline : Flag<["-"], "moutline">, Group<f_clang_Group>, Flags<[CC1Option]>,

clang/lib/Basic/Targets/OSTargets.h

void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     Builder.defineMacro("__Fuchsia__");
     Builder.defineMacro("__ELF__");
     if (Opts.POSIXThreads)
       Builder.defineMacro("_REENTRANT");
     // Required by the libc++ locale support.
     if (Opts.CPlusPlus)
       Builder.defineMacro("_GNU_SOURCE");
+    Builder.defineMacro("__Fuchsia_API_level__", Twine(Opts.FuchsiaAPILevel));
+    this->PlatformName = "fuchsia";
+    this->PlatformMinVersion = VersionTuple(Opts.FuchsiaAPILevel);
   }
 
 public:
   FuchsiaTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : OSTargetInfo<Target>(Triple, Opts) {
     this->MCountName = "__mcount";
     this->TheCXXABI.set(TargetCXXABI::Fuchsia);
   }

clang/lib/Driver/ToolChains/Clang.cpp

if (Args.hasFlag(options::OPT_ffixed_point, options::OPT_fno_fixed_point,
     Args.AddLastArg(CmdArgs, options::OPT_ffixed_point);
 
   if (Arg *A = Args.getLastArg(options::OPT_fcxx_abi_EQ))
     A->render(Args, CmdArgs);
 
   Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables,
                   options::OPT_fno_experimental_relative_cxx_abi_vtables);
 
+  if (Arg *A = Args.getLastArg(options::OPT_ffuchsia_api_level_EQ))
+    A->render(Args, CmdArgs);
+
   // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
   // (-ansi is equivalent to -std=c89 or -std=c++98).
   //
   // If a std is supplied, only add -trigraphs if it follows the
   // option.
   bool ImplyVCPPCVer = false;
   bool ImplyVCPPCXXVer = false;
   const Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);

clang/lib/Sema/SemaDeclAttr.cpp

if (II->isStr("swift")) {
     if (Introduced.isValid() || Obsoleted.isValid() ||
         (!IsUnavailable && !Deprecated.isValid())) {
       S.Diag(AL.getLoc(),
              diag::warn_availability_swift_unavailable_deprecated_only);
       return;
     }
   }
 
+  if (II->isStr("fuchsia")) {
+    Optional<unsigned> Min, Sub;
+    if ((Min = Introduced.Version.getMinor()) ||
+        (Sub = Introduced.Version.getSubminor())) {
+      S.Diag(AL.getLoc(), diag::warn_availability_fuchsia_unavailable_minor);
+      return;
+    }
+  }
+
   int PriorityModifier = AL.isPragmaClangAttribute()
                              ? Sema::AP_PragmaClangAttribute
                              : Sema::AP_Explicit;
   AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(
       ND, AL, II, false /*Implicit*/, Introduced.Version, Deprecated.Version,
       Obsoleted.Version, IsUnavailable, Str, IsStrict, Replacement,
       Sema::AMK_None, PriorityModifier);
   if (NewAttr)

clang/test/Driver/attr-availability-fuchsia.c

+// Test that `-ffuchsia-api-level` is propagated to cc1.
+// RUN: %clang -target x86_64-unknown-fuchsia -ffuchsia-api-level=16 -c %s -### 2>&1| FileCheck %s
+//
+// RUN: not %clang -target x86_64-unknown-fuchsia -ffuchsia-api-level=16.0.0 -c %s  2>&1| FileCheck %s  --check-prefix=CHECK-ERROR
+
+// It should also be exposed to non-fuchsia platforms. This is desireable when
+// using common Fuchsia headers for building host libraries that also depend on
+// the Fuchsia version (such as using a compatible host-side FIDL library that
+// talks with a Fuchsia FIDL library of the same version).
+// RUN: %clang -target x86_64-unknown-linux-gnu -ffuchsia-api-level=16 -c %s -### 2>&1 | FileCheck %s
+//
+// Check Fuchsia API Level macro.
+// RUN: %clang -target x86_64-unknown-fuchsia -ffuchsia-api-level=15 -c %s -o %t
+// RUN: llvm-readobj --symbols %t | FileCheck %s --check-prefix=CHECK-F15
+
+// RUN: %clang -target x86_64-unknown-fuchsia -ffuchsia-api-level=16 -c %s -o %t
+// RUN: llvm-readobj --symbols %t | FileCheck %s --check-prefix=CHECK-F16
+
+// CHECK: "-ffuchsia-api-level=16"
+
+// CHECK-F15:   Name: f15
+
+// CHECK-F16:   Name: f16
+
+// CHECK-ERROR: error: invalid integral value '16.0.0' in '-ffuchsia-api-level=16.0.0'
+
+#if __Fuchsia_API_level__ >= 16
+void f16() {
+
+}
+#else
+void f15() {
+
+}
+#endif
+
+int main(int argc, char* argv[]) {
+#if __Fuchsia_API_level__ >= 16
+    f16();
+#else
+    f15();
+#endif
+}

clang/test/Sema/attr-availability-fuchsia.c

+// RUN: %clang_cc1 "-triple" "x86_64-unknown-fuchsia" -ffuchsia-api-level=16 -fsyntax-only -verify %s
+// RUN: %clang_cc1 "-triple" "x86_64-unknown-fuchsia" -fsyntax-only %s |& FileCheck %s
+
+// If the version is not specified, we should not get any errors since there
+// is no checking (the major version number is zero).
+// CHECK-NOT: error:
+
+void f0(int) __attribute__((availability(fuchsia, introduced = 14, deprecated = 19)));
+void f1(int) __attribute__((availability(fuchsia, introduced = 16)));
+void f2(int) __attribute__((availability(fuchsia, introduced = 14, deprecated = 16))); // expected-note {{'f2' has been explicitly marked deprecated here}}
+void f3(int) __attribute__((availability(fuchsia, introduced = 19)));
+void f4(int) __attribute__((availability(fuchsia, introduced = 9, deprecated = 11, obsoleted = 16), availability(ios, introduced = 2.0, deprecated = 3.0))); // expected-note{{explicitly marked unavailable}}
+void f5(int) __attribute__((availability(ios, introduced = 3.2), availability(fuchsia, unavailable)));                                                       // expected-note{{'f5' has been explicitly marked unavailable here}}
+void f6(int) __attribute__((availability(fuchsia, introduced = 16.0)));                                                                                      // expected-warning {{Fuchsia API Level prohibits specifying a minor or sub-minor version}}
+void f7(int) __attribute__((availability(fuchsia, introduced = 16.1))); // expected-warning {{Fuchsia API Level prohibits specifying a minor or sub-minor version}}
+
+void test() {
+  f0(0);
+  f1(0);
+  f2(0); // expected-warning{{'f2' is deprecated: first deprecated in Fuchsia 16}}
+  f3(0);
+  f4(0); // expected-error{{f4' is unavailable: obsoleted in Fuchsia 16}}
+  f5(0); // expected-error{{'f5' is unavailable: not available on Fuchsia}}
+}