[cc1as] Add support for emitting the build version load command for -darwin-target-variant

[bc-lee]

Summary

This patch extends cc1as to export the build version load command with
LC_VERSION_MIN_MACOSX.
This is especially important for Mac Catalyst as Mac Catalyst uses
the MacOS's compiler rt built-ins.

[MaskRay]

This may need a test in clang/test/Misc/cc1as-*.

Can you add to the description what the clang -cc1as usage looks like?

clang/tools/driver/cc1as_main.cpp

217

417

https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

[bc-lee]

Addressing review comments.

[bc-lee]

Hi, could you have a look at it once more?

[MaskRay]

clang/lib/Driver/ToolChains/Darwin.h

495

llvm::None

clang/test/Misc/cc1as-darwin-target-variant-triple.s

13

Prefer -NEXT

[bc-lee]

clang/lib/Driver/ToolChains/Darwin.h

495

Do you mean to modify the method in clang/include/clang/Driver/ToolChain.h?

[MaskRay]

clang/lib/Driver/ToolChains/Darwin.h

495

Ah, yes, return llvm::Optional<llvm::Triple>(); Sorry for commenting on the wrong place.

clang/test/Misc/cc1as-darwin-target-variant-triple.s

3

-filetype obj on the %clang -cc1as line seems weird.

[bc-lee]

Address review comments

[bc-lee]

clang/test/Misc/cc1as-darwin-target-variant-triple.s

3

Without this, I cannot create object file and validate it using llvm-readobj.

[thakis]

Hm, is adding this flag the right thing to do? Looking at clang's -S output for (say) -target arm64-apple-macos -darwin-target-variant arm64-apple-ios13.1-macabi, it emits lines like:

	.build_version macos, 12, 0	sdk_version 12, 3
	.build_version macCatalyst, 14, 0	sdk_version 15, 4

That suggests that this should be part of the .s file instead of a flag to cc1as (?)

[bc-lee]

As you confirmed at https://crbug.com/1259122#c21, there is a problem with assembly files like floatundidf.S and this patch is intended to fix it. C/C++ files are fine.

[thakis]

Xcode's clang seems to support this:

 % clang -target arm64-apple-macos -target-variant arm64-apple-ios13.1-macabi foo.s -c                                  
% otool -l foo.o | rg -A2 BUILD                                                                                        
      cmd LC_BUILD_VERSION
  cmdsize 24
 platform 1
--
      cmd LC_BUILD_VERSION
  cmdsize 24
 platform 6

But normal clang doesn't:

% out/gn/bin/clang -target arm64-apple-macos -darwin-target-variant arm64-apple-ios13.1-macabi foo.s -isysroot $(xcrun -show-sdk-path) -c
% otool -l foo.o | rg -A2 BUILD                                                                                                                  
      cmd LC_BUILD_VERSION
  cmdsize 24
 platform 1

So based on that, I agree it's good to land this.

You have commit permissions, right?

clang/test/Misc/cc1as-darwin-target-variant-triple.s

3

If you use emit-obj I think this test needs a REQUIRES: x86-registered-target.

I'm not sure if piping binary data works on Windows – it might have stdout in text mode, which will do some byte replacements.

[bc-lee]

Add REQUIRES: x86-registered-target on the test.

clang/test/Misc/cc1as-darwin-target-variant-triple.s

3

A search for -o -.*\n.*RUN.*llvm-readobj in the LLVM codebase suggests that there are already several tests using that pattern. Does that really matter?

[thakis]

Thanks!

clang/test/Misc/cc1as-darwin-target-variant-triple.s

3

Well, if it works, it doesn't matter :)

I'll land this and the bots can tell us if it works.

clang/include/clang/Driver/Options.td

 def target_feature : Separate<["-"], "target-feature">,
   HelpText<"Target specific attributes">,
   MarshallingInfoStringVector<TargetOpts<"FeaturesAsWritten">>;
 def target_abi : Separate<["-"], "target-abi">,
   HelpText<"Target a particular ABI type">,
   MarshallingInfoString<TargetOpts<"ABI">>;
 def target_sdk_version_EQ : Joined<["-"], "target-sdk-version=">,
   HelpText<"The version of target SDK used for compilation">;
-def darwin_target_variant_triple : Separate<["-"], "darwin-target-variant-triple">,
-  HelpText<"Specify the darwin target variant triple">,
-  MarshallingInfoString<TargetOpts<"DarwinTargetVariantTriple">>,
-  Normalizer<"normalizeTriple">;
 def darwin_target_variant_sdk_version_EQ : Joined<["-"],
   "darwin-target-variant-sdk-version=">,
   HelpText<"The version of darwin target variant SDK used for compilation">;
 
 } // let Flags = [CC1Option, CC1AsOption, NoDriverOption]
 
+let Flags = [CC1Option, CC1AsOption] in {
+
+def darwin_target_variant_triple : Separate<["-"], "darwin-target-variant-triple">,
+  HelpText<"Specify the darwin target variant triple">,
+  MarshallingInfoString<TargetOpts<"DarwinTargetVariantTriple">>,
+  Normalizer<"normalizeTriple">;
+
+} // let Flags = [CC1Option, CC1AsOption]
+
 //===----------------------------------------------------------------------===//
 // Target Options (cc1 + cc1as + fc1)
 //===----------------------------------------------------------------------===//
 
 let Flags = [CC1Option, CC1AsOption, FC1Option, NoDriverOption] in {
 
 def triple : Separate<["-"], "triple">,
   HelpText<"Specify target triple (e.g. i686-apple-darwin9)">,

clang/include/clang/Driver/ToolChain.h

public:
   /// environment for the given \p FPType if given. Otherwise, the default
   /// assumed mode for any floating point type.
   virtual llvm::DenormalMode getDefaultDenormalModeForType(
       const llvm::opt::ArgList &DriverArgs, const JobAction &JA,
       const llvm::fltSemantics *FPType = nullptr) const {
     return llvm::DenormalMode::getIEEE();
   }
 
+  virtual Optional<llvm::Triple> getTargetVariantTriple() const {
+    return llvm::None;
+  }
+
   // We want to expand the shortened versions of the triples passed in to
   // the values used for the bitcode libraries.
   static llvm::Triple getOpenMPTriple(StringRef TripleStr) {
     llvm::Triple TT(TripleStr);
     if (TT.getVendor() == llvm::Triple::UnknownVendor ||
         TT.getOS() == llvm::Triple::UnknownOS) {
       if (TT.getArch() == llvm::Triple::nvptx)
         return llvm::Triple("nvptx-nvidia-cuda");

clang/lib/Driver/ToolChains/Clang.cpp

void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
                            const char *LinkingOutput) const {
   ArgStringList CmdArgs;
 
   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
   const InputInfo &Input = Inputs[0];
 
   const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
   const std::string &TripleStr = Triple.getTriple();
+  const Optional<llvm::Triple> TargetVariantTriple =
+      getToolChain().getTargetVariantTriple();
   const auto &D = getToolChain().getDriver();
 
   // Don't warn about "clang -w -c foo.s"
   Args.ClaimAllArgs(options::OPT_w);
   // and "clang -emit-llvm -c foo.s"
   Args.ClaimAllArgs(options::OPT_emit_llvm);
 
   claimNoWarnArgs(Args);
 
   // Invoke ourselves in -cc1as mode.
   //
   // FIXME: Implement custom jobs for internal actions.
   CmdArgs.push_back("-cc1as");
 
   // Add the "effective" target triple.
   CmdArgs.push_back("-triple");
   CmdArgs.push_back(Args.MakeArgString(TripleStr));
+  if (TargetVariantTriple) {
+    CmdArgs.push_back("-darwin-target-variant-triple");
+    CmdArgs.push_back(Args.MakeArgString(TargetVariantTriple->getTriple()));
+  }
 
   // Set the output mode, we currently only expect to be used as a real
   // assembler.
   CmdArgs.push_back("-filetype");
   CmdArgs.push_back("obj");
 
   // Set the main file name, so that debug info works even with
   // -save-temps or preprocessed assembly.

clang/lib/Driver/ToolChains/Darwin.h

bool isMacosxVersionLT(unsigned V0, unsigned V1 = 0, unsigned V2 = 0) const {
     VersionTuple MinVers =
         llvm::Triple(getTriple().getArchName(), "apple", "macos")
             .getMinimumSupportedOSVersion();
     return (!MinVers.empty() && MinVers > TargetVersion
                 ? MinVers
                 : TargetVersion) < VersionTuple(V0, V1, V2);
   }
 
+  /// Returns the darwin target variant triple, the variant of the deployment
+  /// target for which the code is being compiled.
+  Optional<llvm::Triple> getTargetVariantTriple() const override {
+    return TargetVariantTriple;
+  }
+
 protected:
   /// Return true if c++17 aligned allocation/deallocation functions are not
   /// implemented in the c++ standard library of the deployment target we are
   /// targeting.
   bool isAlignedAllocationUnavailable() const;
 
   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
                              llvm::opt::ArgStringList &CC1Args,

clang/test/Misc/cc1as-darwin-target-variant-triple.s

+// Run cc1as using darwin-target-variant-triple
+// REQUIRES: x86-registered-target
+// RUN: %clang -cc1as -triple x86_64-apple-macos10.9 -darwin-target-variant-triple x86_64-apple-ios13.1-macabi -filetype obj %s -o - \
+// RUN: | llvm-readobj --file-headers --macho-version-min - \
+// RUN: | FileCheck --check-prefix=CHECK %s
+
+// CHECK: File: <stdin>
+// CHECK-NEXT: Format: Mach-O 64-bit x86-64
+// CHECK-NEXT: Arch: x86_64
+// CHECK-NEXT: AddressSize: 64bit
+// CHECK-NEXT: MachHeader {
+// CHECK-NEXT:   Magic: Magic64 (0xFEEDFACF)
+// CHECK-NEXT:   CpuType: X86-64 (0x1000007)
+// CHECK-NEXT:   CpuSubType: CPU_SUBTYPE_X86_64_ALL (0x3)
+// CHECK-NEXT:   FileType: Relocatable (0x1)
+// CHECK-NEXT:   NumOfLoadCommands: 3
+// CHECK-NEXT:   SizeOfLoadCommands: 192
+// CHECK-NEXT:   Flags [ (0x0)
+// CHECK-NEXT:   ]
+// CHECK-NEXT:   Reserved: 0x0
+// CHECK-NEXT: }
+// CHECK-NEXT: MinVersion {
+// CHECK-NEXT:   Cmd: LC_VERSION_MIN_MACOSX
+// CHECK-NEXT:   Size: 16
+// CHECK-NEXT:   Version: 10.9
+// CHECK-NEXT:   SDK: n/a
+// CHECK-NEXT: }
+// CHECK-NEXT: MinVersion {
+// CHECK-NEXT:   Cmd: LC_BUILD_VERSION
+// CHECK-NEXT:   Size: 24
+// CHECK-NEXT:   Platform: macCatalyst
+// CHECK-NEXT:   Version: 13.1
+// CHECK-NEXT:   SDK: n/a
+// CHECK-NEXT: }

clang/tools/driver/cc1as_main.cpp

struct AssemblerInvocation {
 
   /// The name of the relocation model to use.
   std::string RelocationModel;
 
   /// The ABI targeted by the backend. Specified using -target-abi. Empty
   /// otherwise.
   std::string TargetABI;
 
+  /// Darwin target variant triple, the variant of the deployment target
+  /// for which the code is being compiled.
+  llvm::Optional<llvm::Triple> DarwinTargetVariantTriple;
   /// @}
 
 public:
   AssemblerInvocation() {
     Triple = "";
     NoInitialTextSection = 0;
     InputFile = "-";
     OutputPath = "-";
else
           << ArgString << Nearest;
     Success = false;
   }
 
   // Construct the invocation.
 
   // Target Options
   Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
+  if (Arg *A = Args.getLastArg(options::OPT_darwin_target_variant_triple))
+    Opts.DarwinTargetVariantTriple = llvm::Triple(A->getValue());
+
   Opts.CPU = std::string(Args.getLastArgValue(OPT_target_cpu));
   Opts.Features = Args.getAllArgValues(OPT_target_feature);
 
   // Use the default target triple if unspecified.
   if (Opts.Triple.empty())
     Opts.Triple = llvm::sys::getDefaultTargetTriple();
 
   // Language Options
assert(Opts.RelocationModel == "dynamic-no-pic" &&
            "Invalid PIC model!");
     PIC = false;
   }
 
   // FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
   // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
   std::unique_ptr<MCObjectFileInfo> MOFI(
       TheTarget->createMCObjectFileInfo(Ctx, PIC));
+  if (Opts.DarwinTargetVariantTriple)
+    MOFI->setDarwinTargetVariantTriple(*Opts.DarwinTargetVariantTriple);
   Ctx.setObjectFileInfo(MOFI.get());
 
   if (Opts.SaveTemporaryLabels)
     Ctx.setAllowTemporaryLabels(false);
   if (Opts.GenDwarfForAssembly)
     Ctx.setGenDwarfForAssembly(true);
   if (!Opts.DwarfDebugFlags.empty())
     Ctx.setDwarfDebugFlags(StringRef(Opts.DwarfDebugFlags));