1 //===- llvm/unittests/TextAPI/YAMLTest.cpp --------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===-----------------------------------------------------------------------===/ 8 9 #include "llvm/ADT/StringRef.h" 10 #include "llvm/InterfaceStub/ELFStub.h" 11 #include "llvm/InterfaceStub/TBEHandler.h" 12 #include "llvm/Support/Error.h" 13 #include "llvm/Testing/Support/Error.h" 14 #include "gtest/gtest.h" 15 #include <string> 16 17 using namespace llvm; 18 using namespace llvm::ELF; 19 using namespace llvm::elfabi; 20 21 void compareByLine(StringRef LHS, StringRef RHS) { 22 StringRef Line1; 23 StringRef Line2; 24 while (LHS.size() > 0 && RHS.size() > 0) { 25 std::tie(Line1, LHS) = LHS.split('\n'); 26 std::tie(Line2, RHS) = RHS.split('\n'); 27 // Comparing StringRef objects works, but has messy output when not equal. 28 // Using STREQ on StringRef.data() doesn't work since these substrings are 29 // not null terminated. 30 // This is inefficient, but forces null terminated strings that can be 31 // cleanly compared. 32 EXPECT_STREQ(Line1.str().data(), Line2.str().data()); 33 } 34 } 35 36 TEST(ElfYamlTextAPI, YAMLReadableTBE) { 37 const char Data[] = "--- !tapi-tbe\n" 38 "TbeVersion: 1.0\n" 39 "Arch: x86_64\n" 40 "NeededLibs: [libc.so, libfoo.so, libbar.so]\n" 41 "Symbols:\n" 42 " foo: { Type: Func, Undefined: true }\n" 43 "...\n"; 44 Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data); 45 ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded()); 46 std::unique_ptr<ELFStub> Stub = std::move(StubOrErr.get()); 47 EXPECT_NE(Stub.get(), nullptr); 48 EXPECT_FALSE(Stub->SoName.hasValue()); 49 EXPECT_EQ(Stub->Arch, (uint16_t)llvm::ELF::EM_X86_64); 50 EXPECT_EQ(Stub->NeededLibs.size(), 3u); 51 EXPECT_STREQ(Stub->NeededLibs[0].c_str(), "libc.so"); 52 EXPECT_STREQ(Stub->NeededLibs[1].c_str(), "libfoo.so"); 53 EXPECT_STREQ(Stub->NeededLibs[2].c_str(), "libbar.so"); 54 } 55 56 TEST(ElfYamlTextAPI, YAMLReadsTBESymbols) { 57 const char Data[] = "--- !tapi-tbe\n" 58 "TbeVersion: 1.0\n" 59 "SoName: test.so\n" 60 "Arch: x86_64\n" 61 "Symbols:\n" 62 " bar: { Type: Object, Size: 42 }\n" 63 " baz: { Type: TLS, Size: 3 }\n" 64 " foo: { Type: Func, Warning: \"Deprecated!\" }\n" 65 " nor: { Type: NoType, Undefined: true }\n" 66 " not: { Type: File, Undefined: true, Size: 111, " 67 "Weak: true, Warning: \'All fields populated!\' }\n" 68 "...\n"; 69 Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data); 70 ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded()); 71 std::unique_ptr<ELFStub> Stub = std::move(StubOrErr.get()); 72 EXPECT_NE(Stub.get(), nullptr); 73 EXPECT_TRUE(Stub->SoName.hasValue()); 74 EXPECT_STREQ(Stub->SoName->c_str(), "test.so"); 75 EXPECT_EQ(Stub->Symbols.size(), 5u); 76 77 auto Iterator = Stub->Symbols.begin(); 78 ELFSymbol const &SymBar = *Iterator++; 79 EXPECT_STREQ(SymBar.Name.c_str(), "bar"); 80 EXPECT_EQ(SymBar.Size, 42u); 81 EXPECT_EQ(SymBar.Type, ELFSymbolType::Object); 82 EXPECT_FALSE(SymBar.Undefined); 83 EXPECT_FALSE(SymBar.Weak); 84 EXPECT_FALSE(SymBar.Warning.hasValue()); 85 86 ELFSymbol const &SymBaz = *Iterator++; 87 EXPECT_STREQ(SymBaz.Name.c_str(), "baz"); 88 EXPECT_EQ(SymBaz.Size, 3u); 89 EXPECT_EQ(SymBaz.Type, ELFSymbolType::TLS); 90 EXPECT_FALSE(SymBaz.Undefined); 91 EXPECT_FALSE(SymBaz.Weak); 92 EXPECT_FALSE(SymBaz.Warning.hasValue()); 93 94 ELFSymbol const &SymFoo = *Iterator++; 95 EXPECT_STREQ(SymFoo.Name.c_str(), "foo"); 96 EXPECT_EQ(SymFoo.Size, 0u); 97 EXPECT_EQ(SymFoo.Type, ELFSymbolType::Func); 98 EXPECT_FALSE(SymFoo.Undefined); 99 EXPECT_FALSE(SymFoo.Weak); 100 EXPECT_TRUE(SymFoo.Warning.hasValue()); 101 EXPECT_STREQ(SymFoo.Warning->c_str(), "Deprecated!"); 102 103 ELFSymbol const &SymNor = *Iterator++; 104 EXPECT_STREQ(SymNor.Name.c_str(), "nor"); 105 EXPECT_EQ(SymNor.Size, 0u); 106 EXPECT_EQ(SymNor.Type, ELFSymbolType::NoType); 107 EXPECT_TRUE(SymNor.Undefined); 108 EXPECT_FALSE(SymNor.Weak); 109 EXPECT_FALSE(SymNor.Warning.hasValue()); 110 111 ELFSymbol const &SymNot = *Iterator++; 112 EXPECT_STREQ(SymNot.Name.c_str(), "not"); 113 EXPECT_EQ(SymNot.Size, 111u); 114 EXPECT_EQ(SymNot.Type, ELFSymbolType::Unknown); 115 EXPECT_TRUE(SymNot.Undefined); 116 EXPECT_TRUE(SymNot.Weak); 117 EXPECT_TRUE(SymNot.Warning.hasValue()); 118 EXPECT_STREQ(SymNot.Warning->c_str(), "All fields populated!"); 119 } 120 121 TEST(ElfYamlTextAPI, YAMLReadsNoTBESyms) { 122 const char Data[] = "--- !tapi-tbe\n" 123 "TbeVersion: 1.0\n" 124 "SoName: test.so\n" 125 "Arch: x86_64\n" 126 "Symbols: {}\n" 127 "...\n"; 128 Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data); 129 ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded()); 130 std::unique_ptr<ELFStub> Stub = std::move(StubOrErr.get()); 131 EXPECT_NE(Stub.get(), nullptr); 132 EXPECT_EQ(0u, Stub->Symbols.size()); 133 } 134 135 TEST(ElfYamlTextAPI, YAMLUnreadableTBE) { 136 // Can't read: wrong format/version. 137 const char Data[] = "--- !tapi-tbz\n" 138 "TbeVersion: z.3\n" 139 "SoName: test.so\n" 140 "Arch: x86_64\n" 141 "Symbols:\n" 142 " foo: { Type: Func, Undefined: true }\n"; 143 Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data); 144 ASSERT_THAT_ERROR(StubOrErr.takeError(), Failed()); 145 } 146 147 TEST(ElfYamlTextAPI, YAMLWritesTBESymbols) { 148 const char Expected[] = 149 "--- !tapi-tbe\n" 150 "TbeVersion: 1.0\n" 151 "Arch: AArch64\n" 152 "Symbols:\n" 153 " bar: { Type: Func, Weak: true }\n" 154 " foo: { Type: NoType, Size: 99, Warning: Does nothing }\n" 155 " nor: { Type: Func, Undefined: true }\n" 156 " not: { Type: Unknown, Size: 12345678901234 }\n" 157 "...\n"; 158 ELFStub Stub; 159 Stub.TbeVersion = VersionTuple(1, 0); 160 Stub.Arch = ELF::EM_AARCH64; 161 162 ELFSymbol SymFoo("foo"); 163 SymFoo.Size = 99u; 164 SymFoo.Type = ELFSymbolType::NoType; 165 SymFoo.Undefined = false; 166 SymFoo.Weak = false; 167 SymFoo.Warning = "Does nothing"; 168 169 ELFSymbol SymBar("bar"); 170 SymBar.Size = 128u; 171 SymBar.Type = ELFSymbolType::Func; 172 SymBar.Undefined = false; 173 SymBar.Weak = true; 174 175 ELFSymbol SymNor("nor"); 176 SymNor.Size = 1234u; 177 SymNor.Type = ELFSymbolType::Func; 178 SymNor.Undefined = true; 179 SymNor.Weak = false; 180 181 ELFSymbol SymNot("not"); 182 SymNot.Size = 12345678901234u; 183 SymNot.Type = ELFSymbolType::Unknown; 184 SymNot.Undefined = false; 185 SymNot.Weak = false; 186 187 // Deliberately not in order to check that result is sorted. 188 Stub.Symbols.insert(SymNot); 189 Stub.Symbols.insert(SymBar); 190 Stub.Symbols.insert(SymFoo); 191 Stub.Symbols.insert(SymNor); 192 193 // Ensure move constructor works as expected. 194 ELFStub Moved = std::move(Stub); 195 196 std::string Result; 197 raw_string_ostream OS(Result); 198 ASSERT_THAT_ERROR(writeTBEToOutputStream(OS, Moved), Succeeded()); 199 Result = OS.str(); 200 compareByLine(Result.c_str(), Expected); 201 } 202 203 TEST(ElfYamlTextAPI, YAMLWritesNoTBESyms) { 204 const char Expected[] = "--- !tapi-tbe\n" 205 "TbeVersion: 1.0\n" 206 "SoName: nosyms.so\n" 207 "Arch: x86_64\n" 208 "NeededLibs:\n" 209 " - libc.so\n" 210 " - libfoo.so\n" 211 " - libbar.so\n" 212 "Symbols: {}\n" 213 "...\n"; 214 ELFStub Stub; 215 Stub.TbeVersion = VersionTuple(1, 0); 216 Stub.SoName = "nosyms.so"; 217 Stub.Arch = ELF::EM_X86_64; 218 Stub.NeededLibs.push_back("libc.so"); 219 Stub.NeededLibs.push_back("libfoo.so"); 220 Stub.NeededLibs.push_back("libbar.so"); 221 222 std::string Result; 223 raw_string_ostream OS(Result); 224 ASSERT_THAT_ERROR(writeTBEToOutputStream(OS, Stub), Succeeded()); 225 Result = OS.str(); 226 compareByLine(Result.c_str(), Expected); 227 } 228