[llvm] Fix ODRViolations for VersionTuple YAML specializations NFC

[cishida]

Summary

It appears for Swift there was confusing errors when trying to parse APINotes, when libAPINotes and libInterfaceStub are linked, they both export symbol
__ZN4llvm4yaml7yamlizeINS_12VersionTupleEEENSt3__19enable_ifIXsr16has_ScalarTraitsIT_EE5valueEvE4typeERNS0_2IOERS5_bRNS0_12EmptyContextE, and discovered
same symbol defined within llvm-ifs.

This consolidates the boilerplate into YAMLTraits and defers the specific validation in reading the whole input.
fixes: rdar://problem/70450563

[dblaikie]

Alternatively - if two places in the project need a ScalarTraits for VersionTuple, perhaps we should implement that in one central place (either near VersionTuple or ScalarTraits or, if necessary, in some 3rd utility location that can be include/used by those who depend on both (if there's code that really needs to be able to depend on either one without always depending on both))

[plotfi]

I think I am overall ok with this for now until the TBE folks post some more patches to integrate ifs and tbe.

[cishida]

Address dblaikie's suggestion and move specialization into YAMLTraits.

[dblaikie]

Looks good to me

[plotfi]

Thanks for fixing this @cishida!

[phosek]

LGTM

llvm/include/llvm/Support/YAMLTraits.h

 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/AlignOf.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/VersionTuple.h"
 #include "llvm/Support/YAMLParser.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cctype>
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
 #include <map>

 
 template<>
 struct ScalarTraits<Hex64> {
   static void output(const Hex64 &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, Hex64 &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
+template <> struct ScalarTraits<VersionTuple> {
+  static void output(const VersionTuple &Value, void *, llvm::raw_ostream &Out);
+  static StringRef input(StringRef, void *, VersionTuple &);
+  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
+};
+
 // Define non-member operator>> so that Input can stream in a document list.
 template <typename T>
 inline std::enable_if_t<has_DocumentListTraits<T>::value, Input &>
 operator>>(Input &yin, T &docList) {
   int i = 0;
   EmptyContext Ctx;
   while ( yin.setCurrentDocument() ) {
     yamlize(yin, DocumentListTraits<T>::element(yin, docList, i), true, Ctx);

llvm/lib/InterfaceStub/TBEHandler.cpp

static StringRef input(StringRef Scalar, void *, ELFArchMapper &Value) {
     // Returning empty StringRef indicates successful parse.
     return StringRef();
   }
 
   // Don't place quotation marks around architecture value.
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
-/// YAML traits for TbeVersion.
-template <> struct ScalarTraits<VersionTuple> {
-  static void output(const VersionTuple &Value, void *,
-                     llvm::raw_ostream &Out) {
-    Out << Value.getAsString();
-  }
-
-  static StringRef input(StringRef Scalar, void *, VersionTuple &Value) {
-    if (Value.tryParse(Scalar))
-      return StringRef("Can't parse version: invalid version format.");
-
-    if (Value > TBEVersionCurrent)
-      return StringRef("Unsupported TBE version.");
-
-    // Returning empty StringRef indicates successful parse.
-    return StringRef();
-  }
-
-  // Don't place quotation marks around version value.
-  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
-};
-
 /// YAML traits for ELFSymbol.
 template <> struct MappingTraits<ELFSymbol> {
   static void mapping(IO &IO, ELFSymbol &Symbol) {
     IO.mapRequired("Type", Symbol.Type);
     // The need for symbol size depends on the symbol type.
     if (Symbol.Type == ELFSymbolType::NoType) {
       IO.mapOptional("Size", Symbol.Size, (uint64_t)0);
     } else if (Symbol.Type == ELFSymbolType::Func) {

 
 Expected<std::unique_ptr<ELFStub>> elfabi::readTBEFromBuffer(StringRef Buf) {
   yaml::Input YamlIn(Buf);
   std::unique_ptr<ELFStub> Stub(new ELFStub());
   YamlIn >> *Stub;
   if (std::error_code Err = YamlIn.error())
     return createStringError(Err, "YAML failed reading as TBE");
 
+  if (Stub->TbeVersion > elfabi::TBEVersionCurrent)
+    return make_error<StringError>(
+        "TBE version " + Stub->TbeVersion.getAsString() + " is unsupported.",
+        std::make_error_code(std::errc::invalid_argument));
+
   return std::move(Stub);
 }
 
 Error elfabi::writeTBEToOutputStream(raw_ostream &OS, const ELFStub &Stub) {
   yaml::Output YamlOut(OS, NULL, /*WrapColumn =*/0);
 
   YamlOut << const_cast<ELFStub &>(Stub);
   return Error::success();
 }

llvm/lib/Support/YAMLTraits.cpp

 
 StringRef ScalarTraits<Hex64>::input(StringRef Scalar, void *, Hex64 &Val) {
   unsigned long long Num;
   if (getAsUnsignedInteger(Scalar, 0, Num))
     return "invalid hex64 number";
   Val = Num;
   return StringRef();
 }
+
+void ScalarTraits<VersionTuple>::output(const VersionTuple &Val, void *,
+                                        llvm::raw_ostream &Out) {
+  Out << Val.getAsString();
+}
+
+StringRef ScalarTraits<VersionTuple>::input(StringRef Scalar, void *,
+                                            VersionTuple &Val) {
+  if (Val.tryParse(Scalar))
+    return "invalid version format";
+  return StringRef();
+}

llvm/tools/llvm-ifs/llvm-ifs.cpp

static void enumeration(IO &IO, IFSSymbolType &SymbolType) {
     IO.enumCase(SymbolType, "Object", IFSSymbolType::Object);
     IO.enumCase(SymbolType, "Unknown", IFSSymbolType::Unknown);
     // Treat other symbol types as noise, and map to Unknown.
     if (!IO.outputting() && IO.matchEnumFallback())
       SymbolType = IFSSymbolType::Unknown;
   }
 };
 
-template <> struct ScalarTraits<VersionTuple> {
-  static void output(const VersionTuple &Value, void *,
-                     llvm::raw_ostream &Out) {
-    Out << Value.getAsString();
-  }
-
-  static StringRef input(StringRef Scalar, void *, VersionTuple &Value) {
-    if (Value.tryParse(Scalar))
-      return StringRef("Can't parse version: invalid version format.");
-
-    if (Value > IFSVersionCurrent)
-      return StringRef("Unsupported IFS version.");
-
-    // Returning empty StringRef indicates successful parse.
-    return StringRef();
-  }
-
-  // Don't place quotation marks around version value.
-  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
-};
-
 /// YAML traits for IFSSymbol.
 template <> struct MappingTraits<IFSSymbol> {
   static void mapping(IO &IO, IFSSymbol &Symbol) {
     IO.mapRequired("Name", Symbol.Name);
     IO.mapRequired("Type", Symbol.Type);
     // The need for symbol size depends on the symbol type.
     if (Symbol.Type == IFSSymbolType::NoType)
       IO.mapOptional("Size", Symbol.Size, (uint64_t)0);
static Expected<std::unique_ptr<IFSStub>> readInputFile(StringRef FilePath) {
   std::unique_ptr<MemoryBuffer> FileReadBuffer = std::move(*BufOrError);
   yaml::Input YamlIn(FileReadBuffer->getBuffer());
   std::unique_ptr<IFSStub> Stub(new IFSStub());
   YamlIn >> *Stub;
 
   if (std::error_code Err = YamlIn.error())
     return createStringError(Err, "Failed reading Interface Stub File.");
 
+  if (Stub->IfsVersion > IFSVersionCurrent)
+    return make_error<StringError>(
+        "IFS version " + Stub->IfsVersion.getAsString() + " is unsupported.",
+        std::make_error_code(std::errc::invalid_argument));
+
   return std::move(Stub);
 }
 
 static int writeTbdStub(const Triple &T, const std::vector<IFSSymbol> &Symbols,
                         const StringRef Format, raw_ostream &Out) {
 
   auto PlatformKindOrError =
       [](const llvm::Triple &T) -> llvm::Expected<llvm::MachO::PlatformKind> {

llvm/unittests/InterfaceStub/ELFYAMLTest.cpp

const char Data[] = "--- !tapi-tbz\n"
                       "SoName: test.so\n"
                       "Arch: x86_64\n"
                       "Symbols:\n"
                       "  foo: { Type: Func, Undefined: true }\n";
   Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
   ASSERT_THAT_ERROR(StubOrErr.takeError(), Failed());
 }
 
+TEST(ElfYamlTextAPI, YAMLUnsupportedVersion) {
+  const char Data[] = "--- !tapi-tbe\n"
+                      "TbeVersion: 9.9.9\n"
+                      "SoName: test.so\n"
+                      "Arch: x86_64\n"
+                      "Symbols: {}\n"
+                      "...\n";
+  Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
+  std::string ErrorMessage = toString(StubOrErr.takeError());
+  EXPECT_EQ("TBE version 9.9.9 is unsupported.", ErrorMessage);
+}
+
 TEST(ElfYamlTextAPI, YAMLWritesTBESymbols) {
   const char Expected[] =
       "--- !tapi-tbe\n"
       "TbeVersion:      1.0\n"
       "Arch:            AArch64\n"
       "Symbols:\n"
       "  bar:             { Type: Func, Weak: true }\n"
       "  foo:             { Type: NoType, Size: 99, Warning: Does nothing }\n"