tvos_version_min and watchos_version_min flag

[carlokok]

Summary

This introduces the tvos_version_min and watchos_version_min flags, mirroring what ld64 does here.

[kristina]

As trivial as it may seem, this is missing tests, even if it's for a few flags. Also please try to include context with your patches as it makes them much easier to review. If you have some sort of plan for actually bringing Mach-O LLD closer to ld64 feature-wise, I think llvm-dev may be a good place to actually outline your plan for this, which will give everyone a more clear picture of what future changes you have planned in mind.

include/lld/ReaderWriter/MachOLinkingContext.h

     unknown,
     macOSX,
     iOS,
-    iOS_simulator
+    iOS_simulator,
+    tvOS,
+    watchOS
   };
 
   enum class ExportMode {

   void addInputFileNotFound(StringRef path) const;
   void addOutputFileDependency(StringRef path) const;
 
-  bool minOS(StringRef mac, StringRef iOS) const;
+  bool minOS(StringRef mac, StringRef iOS, StringRef tvOS,
+             StringRef watchOS) const;
   void setDoNothing(bool value) { _doNothing = value; }
   bool doNothing() const { return _doNothing; }
   bool printAtoms() const { return _printAtoms; }

lib/Driver/DarwinLdDriver.cpp

   uint32_t minOSVersion = 0;
   if (llvm::opt::Arg *minOS =
           parsedArgs.getLastArg(OPT_macosx_version_min, OPT_ios_version_min,
-                                OPT_ios_simulator_version_min)) {
+                                OPT_ios_simulator_version_min, 
+                                OPT_tvos_version_min,
+                                OPT_watchos_version_min)) {
     switch (minOS->getOption().getID()) {
     case OPT_macosx_version_min:
       os = MachOLinkingContext::OS::macOSX;

         return false;
       }
       break;
+    case OPT_tvos_version_min:
+      os = MachOLinkingContext::OS::tvOS;
+      if (MachOLinkingContext::parsePackedVersion(minOS->getValue(),
+                                                  minOSVersion)) {
+        error("malformed tvos_version_min value");
+        return false;
+      }
+      break;
+    case OPT_watchos_version_min:
+      os = MachOLinkingContext::OS::watchOS;
+      if (MachOLinkingContext::parsePackedVersion(minOS->getValue(),
+                                                  minOSVersion)) {
+        error("malformed watchos_version_min value");
+        return false;
+      }
+      break;
     }
   } else {
     // No min-os version on command line, check environment variables

           return false;
         }
         break;
+      case MachOLinkingContext::OS::tvOS:
+      case MachOLinkingContext::OS::watchOS:
       case MachOLinkingContext::OS::unknown:
         break;
       }

       case llvm::MachO::MH_EXECUTE:
       case llvm::MachO::MH_DYLIB:
       case llvm::MachO::MH_BUNDLE:
-        if (!ctx.minOS("10.5", "2.0")) {
+        if (!ctx.minOS("10.5", "2.0", "1.0", "1.0")) {
           if (ctx.os() == MachOLinkingContext::OS::macOSX)
             error("-rpath can only be used when targeting OS X 10.5 or later");
           else

lib/Driver/DarwinLdOptions.td

 def ios_version_min : Separate<["-"], "ios_version_min">,
      MetaVarName<"<version>">,
      HelpText<"Minimum iOS version">, Group<grp_opts>;
+def tvos_version_min : Separate<["-"], "tvos_version_min">,
+     MetaVarName<"<version>">,
+     HelpText<"Minimum tvOS version">, Group<grp_opts>;
+def watchos_version_min : Separate<["-"], "watchos_version_min">,
+     MetaVarName<"<version>">,
+     HelpText<"Minimum watchOS version">, Group<grp_opts>;
 def iphoneos_version_min : Separate<["-"], "iphoneos_version_min">,
      Alias<ios_version_min>;
 def ios_simulator_version_min : Separate<["-"], "ios_simulator_version_min">,

lib/ReaderWriter/MachO/MachOLinkingContext.cpp

   switch (_outputMachOType) {
   case llvm::MachO::MH_EXECUTE:
     // If targeting newer OS, use _main
-    if (minOS("10.8", "6.0")) {
+    if (minOS("10.8", "6.0", "1.0", "1.0")) {
       _entrySymbolName = "_main";
     } else {
       // If targeting older OS, use start (in crt1.o)

         if (minOSVersion >= 0x00040300) // iOS 4.3
           _pie = true;
        break;
-       case OS::iOS_simulator:
+      case OS::tvOS:
+      case OS::watchOS:
+      case OS::iOS_simulator:
         _pie = true;
        break;
        case OS::unknown:

   return archHandler().stubInfo().binderSymbolName;
 }
 
-bool MachOLinkingContext::minOS(StringRef mac, StringRef iOS) const {
+bool MachOLinkingContext::minOS(StringRef mac, StringRef iOS, StringRef tvOS, StringRef watchOS) const {
   uint32_t parsedVersion;
   switch (_os) {
   case OS::macOSX:

     if (parsePackedVersion(iOS, parsedVersion))
       return false;
     return _osMinVersion >= parsedVersion;
+  case OS::tvOS:
+    if (parsePackedVersion(tvOS, parsedVersion))
+      return false;
+    return _osMinVersion >= parsedVersion;
+  case OS::watchOS:
+    if (parsePackedVersion(watchOS, parsedVersion))
+      return false;
+    return _osMinVersion >= parsedVersion;
   case OS::unknown:
     // If we don't know the target, then assume that we don't meet the min OS.
     // This matches the ld64 behaviour

 
 bool MachOLinkingContext::addEntryPointLoadCommand() const {
   if ((_outputMachOType == MH_EXECUTE) && !_outputMachOTypeStatic) {
-    return minOS("10.8", "6.0");
+    return minOS("10.8", "6.0", "1.0", "1.0");
   }
   return false;
 }

     if (_outputMachOTypeStatic)
       return true;
     else
-      return !minOS("10.8", "6.0");
+      return !minOS("10.8", "6.0", "1.0", "1.0");
     break;
   case MH_DYLINKER:
   case MH_PRELOAD:

lib/ReaderWriter/MachO/MachONormalizedFileBinaryWriter.cpp

       vm->version = _file.minOSverson;
       vm->sdk     = _file.sdkVersion;
       break;
+    case MachOLinkingContext::OS::tvOS:
+      vm->cmd = LC_VERSION_MIN_TVOS;
+      vm->cmdsize = sizeof(version_min_command);
+      vm->version = _file.minOSverson;
+      vm->sdk = _file.sdkVersion;
+      break;
+    case MachOLinkingContext::OS::watchOS:
+      vm->cmd = LC_VERSION_MIN_WATCHOS;
+      vm->cmdsize = sizeof(version_min_command);
+      vm->version = _file.minOSverson;
+      vm->sdk = _file.sdkVersion;
+      break;
   }
   if (_swap)
     swapStruct(*vm);

lib/ReaderWriter/MachO/TLVPass.cpp

 
 private:
   llvm::Error perform(SimpleFile &mergedFile) override {
-    bool allowTLV = _ctx.minOS("10.7", "1.0");
+    bool allowTLV = _ctx.minOS("10.7", "1.0", "1.0", "1.0");
 
     for (const DefinedAtom *atom : mergedFile.defined()) {
       for (const Reference *ref : *atom) {