[lld/mac] implement -compatibility_version, -current_version

[int3]

lgtm

lld/test/MachO/dylib-version.s

46

nit: left align with rows below

[thakis]

Thanks!

lld/MachO/Config.h

struct Configuration {
   bool implicitDylibs = false;
   bool isPic = false;
   bool headerPadMaxInstallNames = false;
   bool printEachFile = false;
   bool printWhyLoad = false;
   bool searchDylibsFirst = false;
   bool saveTemps = false;
   uint32_t headerPad;
+  uint32_t dylibCompatibilityVersion = 0;
+  uint32_t dylibCurrentVersion = 0;
   llvm::StringRef installName;
   llvm::StringRef outputFile;
   llvm::StringRef ltoObjPath;
   bool demangle = false;
   llvm::MachO::Architecture arch;
   PlatformInfo platform;
   llvm::MachO::HeaderFileType outputType;
   std::vector<llvm::StringRef> systemLibraryRoots;

lld/MachO/Driver.cpp

static void parseClangOption(StringRef opt, const Twine &msg) {
 
   const char *argv[] = {"lld", opt.data()};
   if (cl::ParseCommandLineOptions(2, argv, "", &os))
     return;
   os.flush();
   error(msg + ": " + StringRef(err).trim());
 }
 
+static uint32_t parseDylibVersion(const opt::ArgList& args, unsigned id) {
+  const opt::Arg *arg = args.getLastArg(id);
+  if (!arg)
+    return 0;
+
+  if (config->outputType != MH_DYLIB) {
+    error(arg->getAsString(args) + ": only valid with -dylib");
+    return 0;
+  }
+
+  llvm::VersionTuple version;
+  if (version.tryParse(arg->getValue()) || version.getBuild().hasValue()) {
+    error(arg->getAsString(args) + ": malformed version");
+    return 0;
+  }
+
+  unsigned major = version.getMajor();
+  if (major > UINT16_MAX) {
+    error(arg->getAsString(args) + ": component " + Twine(major) +
+          " out of range");
+    return 0;
+  }
+
+  unsigned minor = version.getMinor().getValueOr(0);
+  if (minor > UINT8_MAX) {
+    error(arg->getAsString(args) + ": component " + Twine(minor) +
+          " out of range");
+    return 0;
+  }
+
+  unsigned subminor = version.getSubminor().getValueOr(0);
+  if (subminor > UINT8_MAX) {
+    error(arg->getAsString(args) + ": component " + Twine(subminor) +
+          " out of range");
+    return 0;
+  }
+
+  return (major << 16) | (minor << 8) | subminor;
+}
+
 bool macho::link(llvm::ArrayRef<const char *> argsArr, bool canExitEarly,
                  raw_ostream &stdoutOS, raw_ostream &stderrOS) {
   lld::stdoutOS = &stdoutOS;
   lld::stderrOS = &stderrOS;
 
   stderrOS.enable_colors(stderrOS.has_colors());
   // TODO: Set up error handler properly, e.g. the errorLimitExceededMsg
 
config->librarySearchPaths =
       getLibrarySearchPaths(args, config->systemLibraryRoots);
   config->frameworkSearchPaths =
       getFrameworkSearchPaths(args, config->systemLibraryRoots);
   if (const opt::Arg *arg =
           args.getLastArg(OPT_search_paths_first, OPT_search_dylibs_first))
     config->searchDylibsFirst =
         (arg && arg->getOption().getID() == OPT_search_dylibs_first);
 
+  config->dylibCompatibilityVersion =
+      parseDylibVersion(args, OPT_compatibility_version);
+  config->dylibCurrentVersion = parseDylibVersion(args, OPT_current_version);
+
   config->saveTemps = args.hasArg(OPT_save_temps);
 
   if (args.hasArg(OPT_v)) {
     message(getLLDVersion());
     message(StringRef("Library search paths:") +
             (config->librarySearchPaths.size()
                  ? "\n\t" + llvm::join(config->librarySearchPaths, "\n\t")
                  : ""));

lld/MachO/Options.td

def dylinker_install_name : Separate<["-"], "dylinker_install_name">,
      Group<grp_dylib>;
 def mark_dead_strippable_dylib : Flag<["-"], "mark_dead_strippable_dylib">,
      HelpText<"Clients can discard this dylib if it is unreferenced">,
      Flags<[HelpHidden]>,
      Group<grp_dylib>;
 def compatibility_version : Separate<["-"], "compatibility_version">,
      MetaVarName<"<version>">,
      HelpText<"Compatibility <version> of this library">,
-     Flags<[HelpHidden]>,
      Group<grp_dylib>;
 def dylib_compatibility_version : Separate<["-"], "dylib_compatibility_version">,
      MetaVarName<"<version>">,
      Alias<compatibility_version>,
      HelpText<"Alias for -compatibility_version">,
      Flags<[HelpHidden]>,
      Group<grp_dylib>;
 def current_version : Separate<["-"], "current_version">,
      MetaVarName<"<version>">,
      HelpText<"Current <version> of this library">,
-     Flags<[HelpHidden]>,
      Group<grp_dylib>;
 def dylib_current_version : Separate<["-"], "dylib_current_version">,
      MetaVarName<"<version>">,
      Alias<current_version>,
      HelpText<"Alias for -current_version">,
      Flags<[HelpHidden]>,
      Group<grp_dylib>;
 

lld/MachO/Writer.cpp

 };
 
 // There are several dylib load commands that share the same structure:
 //   * LC_LOAD_DYLIB
 //   * LC_ID_DYLIB
 //   * LC_REEXPORT_DYLIB
 class LCDylib : public LoadCommand {
 public:
-  LCDylib(LoadCommandType type, StringRef path) : type(type), path(path) {
+  LCDylib(LoadCommandType type, StringRef path,
+          uint32_t compatibilityVersion = 0, uint32_t currentVersion = 0)
+      : type(type), path(path), compatibilityVersion(compatibilityVersion),
+        currentVersion(currentVersion) {
     instanceCount++;
   }
 
   uint32_t getSize() const override {
     return alignTo(sizeof(dylib_command) + path.size() + 1, 8);
   }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<dylib_command *>(buf);
     buf += sizeof(dylib_command);
 
     c->cmd = type;
     c->cmdsize = getSize();
     c->dylib.name = sizeof(dylib_command);
+    c->dylib.timestamp = 0;
+    c->dylib.compatibility_version = compatibilityVersion;
+    c->dylib.current_version = currentVersion;
 
     memcpy(buf, path.data(), path.size());
     buf[path.size()] = '\0';
   }
 
   static uint32_t getInstanceCount() { return instanceCount; }
 
 private:
   LoadCommandType type;
   StringRef path;
+  uint32_t compatibilityVersion;
+  uint32_t currentVersion;
   static uint32_t instanceCount;
 };
 
 uint32_t LCDylib::instanceCount = 0;
 
 class LCLoadDylinker : public LoadCommand {
 public:
   uint32_t getSize() const override {
for (StringRef path : config->runtimePaths)
     in.header->addLoadCommand(make<LCRPath>(path));
 
   switch (config->outputType) {
   case MH_EXECUTE:
     in.header->addLoadCommand(make<LCMain>());
     in.header->addLoadCommand(make<LCLoadDylinker>());
     break;
   case MH_DYLIB:
-    in.header->addLoadCommand(make<LCDylib>(LC_ID_DYLIB, config->installName));
+    in.header->addLoadCommand(make<LCDylib>(LC_ID_DYLIB, config->installName,
+                                            config->dylibCompatibilityVersion,
+                                            config->dylibCurrentVersion));
     break;
   case MH_BUNDLE:
     break;
   default:
     llvm_unreachable("unhandled output file type");
   }
 
   in.header->addLoadCommand(make<LCBuildVersion>(config->platform));

lld/test/MachO/dylib-version.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
+
+# RUN: not %lld -o %t/executable %t.o -o /dev/null \
+# RUN:     -compatibility_version 10 -current_version 11 2>&1 | \
+# RUN:     FileCheck --check-prefix=NEEDDYLIB %s
+# RUN: not %lld -execute -o %t/executable %t.o -o /dev/null \
+# RUN:     -compatibility_version 10 -current_version 11 2>&1 | \
+# RUN:     FileCheck --check-prefix=NEEDDYLIB %s
+# RUN: not %lld -bundle -o %t/executable %t.o -o /dev/null \
+# RUN:     -compatibility_version 10 -current_version 11 2>&1 | \
+# RUN:     FileCheck --check-prefix=NEEDDYLIB %s
+
+# NEEDDYLIB: error: -compatibility_version 10: only valid with -dylib
+# NEEDDYLIB: error: -current_version 11: only valid with -dylib
+
+# RUN: not %lld -dylib -o %t/executable %t.o -o /dev/null \
+# RUN:     -compatibility_version 1.2.3.4 -current_version 1.2.3.4.5 2>&1 | \
+# RUN:     FileCheck --check-prefix=MALFORMED %s
+
+# MALFORMED: error: -compatibility_version 1.2.3.4: malformed version
+# MALFORMED: error: -current_version 1.2.3.4.5: malformed version
+
+# RUN: not %lld -dylib -o %t/executable %t.o -o /dev/null \
+# RUN:     -compatibility_version 80000.1 -current_version 1.2.3 2>&1 | \
+# RUN:     FileCheck --check-prefix=BADMAJOR %s
+
+# BADMAJOR: error: -compatibility_version 80000.1: component 80000 out of range
+
+# RUN: not %lld -dylib -o %t/executable %t.o -o /dev/null \
+# RUN:     -compatibility_version 8.300 -current_version 1.2.3 2>&1 | \
+# RUN:     FileCheck --check-prefix=BADMINOR %s
+
+# BADMINOR: error: -compatibility_version 8.300: component 300 out of range
+
+# RUN: not %lld -dylib -o %t/executable %t.o -o /dev/null \
+# RUN:     -compatibility_version 8.8.300 -current_version 1.2.3 2>&1 | \
+# RUN:     FileCheck --check-prefix=BADSUBMINOR %s
+
+# BADSUBMINOR: error: -compatibility_version 8.8.300: component 300 out of range
+
+# RUN: %lld -dylib -o %t/executable %t.o -o %t.dylib \
+# RUN:     -compatibility_version 1.2.3 -current_version 2.5.6
+# RUN: llvm-objdump --macho --all-headers %t.dylib | FileCheck %s
+
+# CHECK:          cmd LC_ID_DYLIB
+# CHECK-NEXT: cmdsize
+# CHECK-NEXT: name
+# CHECK-NEXT: time stamp
+# CHECK-NEXT: current version 2.5.6
+# CHECK-NEXT: compatibility version 1.2.3
+
+.text
+.global _foo
+_foo:
+  mov $0, %rax
+  ret