[TextAPI][elfabi] Make SoName optional

[amontanez]

Summary

This change makes DT_SONAME treated as an optional trait for ELF TextAPI stubs. This change accounts for the fact that shared objects aren't guaranteed to have a DT_SONAME entry. Tests have been updated to check for correct behavior of an optional soname.

[jakehehrlich]

LGTM.

llvm/trunk/include/llvm/TextAPI/ELF/ELFStub.h

 };
 
 // A cumulative representation of ELF stubs.
 // Both textual and binary stubs will read into and write from this object.
 class ELFStub {
 // TODO: Add support for symbol versioning.
 public:
   VersionTuple TbeVersion;
-  std::string SoName;
+  Optional<std::string> SoName;
   ELFArch Arch;
   std::vector<std::string> NeededLibs;
   std::set<ELFSymbol> Symbols;
 
   ELFStub() {}
   ELFStub(const ELFStub &Stub);
   ELFStub(ELFStub &&Stub);
 };
 } // end namespace elfabi
 } // end namespace llvm
 
 #endif // LLVM_TEXTAPI_ELF_ELFSTUB_H

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

 };
 
 /// YAML traits for ELFStub objects.
 template <> struct MappingTraits<ELFStub> {
   static void mapping(IO &IO, ELFStub &Stub) {
     if (!IO.mapTag("!tapi-tbe", true))
       IO.setError("Not a .tbe YAML file.");
     IO.mapRequired("TbeVersion", Stub.TbeVersion);
-    IO.mapRequired("SoName", Stub.SoName);
+    IO.mapOptional("SoName", Stub.SoName);
     IO.mapRequired("Arch", (ELFArchMapper &)Stub.Arch);
     IO.mapOptional("NeededLibs", Stub.NeededLibs);
     IO.mapRequired("Symbols", Stub.Symbols);
   }
 };
 
 } // end namespace yaml
 } // end namespace llvm

llvm/trunk/unittests/TextAPI/ELFYAMLTest.cpp

while (LHS.size() > 0 && RHS.size() > 0) {
     // cleanly compared.
     EXPECT_STREQ(Line1.str().data(), Line2.str().data());
   }
 }
 
 TEST(ElfYamlTextAPI, YAMLReadableTBE) {
   const char Data[] = "--- !tapi-tbe\n"
                       "TbeVersion: 1.0\n"
-                      "SoName: test.so\n"
                       "Arch: x86_64\n"
                       "NeededLibs: [libc.so, libfoo.so, libbar.so]\n"
                       "Symbols:\n"
                       "  foo: { Type: Func, Undefined: true }\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_FALSE(Stub->SoName.hasValue());
   EXPECT_EQ(Stub->Arch, (uint16_t)llvm::ELF::EM_X86_64);
-  EXPECT_STREQ(Stub->SoName.c_str(), "test.so");
   EXPECT_EQ(Stub->NeededLibs.size(), 3u);
   EXPECT_STREQ(Stub->NeededLibs[0].c_str(), "libc.so");
   EXPECT_STREQ(Stub->NeededLibs[1].c_str(), "libfoo.so");
   EXPECT_STREQ(Stub->NeededLibs[2].c_str(), "libbar.so");
 }
 
 TEST(ElfYamlTextAPI, YAMLReadsTBESymbols) {
   const char Data[] = "--- !tapi-tbe\n"
                       "TbeVersion: 1.0\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"
                       "...\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);
TEST(ElfYamlTextAPI, YAMLUnreadableTBE) {
   Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
   ASSERT_THAT_ERROR(StubOrErr.takeError(), Failed());
 }
 
 TEST(ElfYamlTextAPI, YAMLWritesTBESymbols) {
   const char Expected[] =
       "--- !tapi-tbe\n"
       "TbeVersion:      1.0\n"
-      "SoName:          test.so\n"
       "Arch:            AArch64\n"
       "Symbols:         \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.SoName = "test.so";
   Stub.Arch = ELF::EM_AARCH64;
 
   ELFSymbol SymFoo("foo");
   SymFoo.Size = 99u;
   SymFoo.Type = ELFSymbolType::NoType;
   SymFoo.Undefined = false;
   SymFoo.Warning = "Does nothing";