[TextAPI][elfabi] Fix YAML support for weak symbols

[amontanez]

Summary

Weak symbols are supposed to be supported in the ELF TextAPI implementation, but the YAML handler didn't read or write the Weak member of ELFSymbol. This change adds the YAML mapping and updates tests to ensure correct behavior.

[phosek]

LGTM

llvm/trunk/lib/TextAPI/ELF/TBEHandler.cpp

static void mapping(IO &IO, ELFSymbol &Symbol) {
     if (Symbol.Type == ELFSymbolType::NoType) {
       IO.mapOptional("Size", Symbol.Size, (uint64_t)0);
     } else if (Symbol.Type == ELFSymbolType::Func) {
       Symbol.Size = 0;
     } else {
       IO.mapRequired("Size", Symbol.Size);
     }
     IO.mapOptional("Undefined", Symbol.Undefined, false);
+    IO.mapOptional("Weak", Symbol.Weak, false);
     IO.mapOptional("Warning", Symbol.Warning);
   }
 
   // Compacts symbol information into a single line.
   static const bool flow = true;
 };
 
 /// YAML traits for set of ELFSymbols.

llvm/trunk/unittests/TextAPI/ELFYAMLTest.cpp

const char Data[] = "--- !tapi-tbe\n"
                       "SoName: test.so\n"
                       "Arch: x86_64\n"
                       "Symbols:\n"
                       "  bar: { Type: Object, Size: 42 }\n"
                       "  baz: { Type: TLS, Size: 3 }\n"
                       "  foo: { Type: Func, Warning: \"Deprecated!\" }\n"
                       "  nor: { Type: NoType, Undefined: true }\n"
                       "  not: { Type: File, Undefined: true, Size: 111, "
-                      "Warning: \'All fields populated!\' }\n"
+                      "Weak: true, Warning: \'All fields populated!\' }\n"
                       "...\n";
   Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
   ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
   std::unique_ptr<ELFStub> Stub = std::move(StubOrErr.get());
   EXPECT_NE(Stub.get(), nullptr);
   EXPECT_TRUE(Stub->SoName.hasValue());
   EXPECT_STREQ(Stub->SoName->c_str(), "test.so");
   EXPECT_EQ(Stub->Symbols.size(), 5u);
 
   auto Iterator = Stub->Symbols.begin();
   ELFSymbol const &SymBar = *Iterator++;
   EXPECT_STREQ(SymBar.Name.c_str(), "bar");
   EXPECT_EQ(SymBar.Size, 42u);
   EXPECT_EQ(SymBar.Type, ELFSymbolType::Object);
   EXPECT_FALSE(SymBar.Undefined);
+  EXPECT_FALSE(SymBar.Weak);
   EXPECT_FALSE(SymBar.Warning.hasValue());
 
   ELFSymbol const &SymBaz = *Iterator++;
   EXPECT_STREQ(SymBaz.Name.c_str(), "baz");
   EXPECT_EQ(SymBaz.Size, 3u);
   EXPECT_EQ(SymBaz.Type, ELFSymbolType::TLS);
   EXPECT_FALSE(SymBaz.Undefined);
+  EXPECT_FALSE(SymBaz.Weak);
   EXPECT_FALSE(SymBaz.Warning.hasValue());
 
   ELFSymbol const &SymFoo = *Iterator++;
   EXPECT_STREQ(SymFoo.Name.c_str(), "foo");
   EXPECT_EQ(SymFoo.Size, 0u);
   EXPECT_EQ(SymFoo.Type, ELFSymbolType::Func);
   EXPECT_FALSE(SymFoo.Undefined);
+  EXPECT_FALSE(SymFoo.Weak);
   EXPECT_TRUE(SymFoo.Warning.hasValue());
   EXPECT_STREQ(SymFoo.Warning->c_str(), "Deprecated!");
 
   ELFSymbol const &SymNor = *Iterator++;
   EXPECT_STREQ(SymNor.Name.c_str(), "nor");
   EXPECT_EQ(SymNor.Size, 0u);
   EXPECT_EQ(SymNor.Type, ELFSymbolType::NoType);
   EXPECT_TRUE(SymNor.Undefined);
+  EXPECT_FALSE(SymNor.Weak);
   EXPECT_FALSE(SymNor.Warning.hasValue());
 
   ELFSymbol const &SymNot = *Iterator++;
   EXPECT_STREQ(SymNot.Name.c_str(), "not");
   EXPECT_EQ(SymNot.Size, 111u);
   EXPECT_EQ(SymNot.Type, ELFSymbolType::Unknown);
   EXPECT_TRUE(SymNot.Undefined);
+  EXPECT_TRUE(SymNot.Weak);
   EXPECT_TRUE(SymNot.Warning.hasValue());
   EXPECT_STREQ(SymNot.Warning->c_str(), "All fields populated!");
 }
 
 TEST(ElfYamlTextAPI, YAMLReadsNoTBESyms) {
   const char Data[] = "--- !tapi-tbe\n"
                       "TbeVersion: 1.0\n"
                       "SoName: test.so\n"

 }
 
 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"
       "  nor:             { Type: Func, Undefined: true }\n"
       "  not:             { Type: Unknown, Size: 12345678901234 }\n"
       "...\n";
   ELFStub Stub;
   Stub.TbeVersion = VersionTuple(1, 0);
   Stub.Arch = ELF::EM_AARCH64;
 
   ELFSymbol SymFoo("foo");
   SymFoo.Size = 99u;
   SymFoo.Type = ELFSymbolType::NoType;
   SymFoo.Undefined = false;
+  SymFoo.Weak = false;
   SymFoo.Warning = "Does nothing";
 
+  ELFSymbol SymBar("bar");
+  SymBar.Size = 128u;
+  SymBar.Type = ELFSymbolType::Func;
+  SymBar.Weak = true;
+
   ELFSymbol SymNor("nor");
   SymNor.Type = ELFSymbolType::Func;
   SymNor.Undefined = true;
+  SymNor.Weak = false;
 
   ELFSymbol SymNot("not");
   SymNot.Size = 12345678901234u;
   SymNot.Type = ELFSymbolType::Unknown;
   SymNot.Undefined = false;
+  SymNot.Weak = false;
 
   // Deliberately not in order to check that result is sorted.
   Stub.Symbols.insert(SymNot);
+  Stub.Symbols.insert(SymBar);
   Stub.Symbols.insert(SymFoo);
   Stub.Symbols.insert(SymNor);
 
   // Ensure move constructor works as expected.
   ELFStub Moved = std::move(Stub);
 
   std::string Result;
   raw_string_ostream OS(Result);