1 //===- IFSHandler.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/InterfaceStub/IFSHandler.h"
10 #include "llvm/ADT/STLExtras.h"
11 #include "llvm/ADT/StringRef.h"
12 #include "llvm/ADT/StringSwitch.h"
13 #include "llvm/ADT/Triple.h"
14 #include "llvm/BinaryFormat/ELF.h"
15 #include "llvm/InterfaceStub/IFSStub.h"
16 #include "llvm/Support/Error.h"
17 #include "llvm/Support/GlobPattern.h"
18 #include "llvm/Support/LineIterator.h"
19 #include "llvm/Support/YAMLTraits.h"
20 #include <functional>
21 #include <optional>
22
23 using namespace llvm;
24 using namespace llvm::ifs;
25
26 LLVM_YAML_IS_SEQUENCE_VECTOR(IFSSymbol)
27
28 namespace llvm {
29 namespace yaml {
30
31 /// YAML traits for ELFSymbolType.
32 template <> struct ScalarEnumerationTraits<IFSSymbolType> {
enumerationllvm::yaml::ScalarEnumerationTraits33 static void enumeration(IO &IO, IFSSymbolType &SymbolType) {
34 IO.enumCase(SymbolType, "NoType", IFSSymbolType::NoType);
35 IO.enumCase(SymbolType, "Func", IFSSymbolType::Func);
36 IO.enumCase(SymbolType, "Object", IFSSymbolType::Object);
37 IO.enumCase(SymbolType, "TLS", IFSSymbolType::TLS);
38 IO.enumCase(SymbolType, "Unknown", IFSSymbolType::Unknown);
39 // Treat other symbol types as noise, and map to Unknown.
40 if (!IO.outputting() && IO.matchEnumFallback())
41 SymbolType = IFSSymbolType::Unknown;
42 }
43 };
44
45 template <> struct ScalarTraits<IFSEndiannessType> {
outputllvm::yaml::ScalarTraits46 static void output(const IFSEndiannessType &Value, void *,
47 llvm::raw_ostream &Out) {
48 switch (Value) {
49 case IFSEndiannessType::Big:
50 Out << "big";
51 break;
52 case IFSEndiannessType::Little:
53 Out << "little";
54 break;
55 default:
56 llvm_unreachable("Unsupported endianness");
57 }
58 }
59
inputllvm::yaml::ScalarTraits60 static StringRef input(StringRef Scalar, void *, IFSEndiannessType &Value) {
61 Value = StringSwitch<IFSEndiannessType>(Scalar)
62 .Case("big", IFSEndiannessType::Big)
63 .Case("little", IFSEndiannessType::Little)
64 .Default(IFSEndiannessType::Unknown);
65 if (Value == IFSEndiannessType::Unknown) {
66 return "Unsupported endianness";
67 }
68 return StringRef();
69 }
70
mustQuotellvm::yaml::ScalarTraits71 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
72 };
73
74 template <> struct ScalarTraits<IFSBitWidthType> {
outputllvm::yaml::ScalarTraits75 static void output(const IFSBitWidthType &Value, void *,
76 llvm::raw_ostream &Out) {
77 switch (Value) {
78 case IFSBitWidthType::IFS32:
79 Out << "32";
80 break;
81 case IFSBitWidthType::IFS64:
82 Out << "64";
83 break;
84 default:
85 llvm_unreachable("Unsupported bit width");
86 }
87 }
88
inputllvm::yaml::ScalarTraits89 static StringRef input(StringRef Scalar, void *, IFSBitWidthType &Value) {
90 Value = StringSwitch<IFSBitWidthType>(Scalar)
91 .Case("32", IFSBitWidthType::IFS32)
92 .Case("64", IFSBitWidthType::IFS64)
93 .Default(IFSBitWidthType::Unknown);
94 if (Value == IFSBitWidthType::Unknown) {
95 return "Unsupported bit width";
96 }
97 return StringRef();
98 }
99
mustQuotellvm::yaml::ScalarTraits100 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
101 };
102
103 template <> struct MappingTraits<IFSTarget> {
mappingllvm::yaml::MappingTraits104 static void mapping(IO &IO, IFSTarget &Target) {
105 IO.mapOptional("ObjectFormat", Target.ObjectFormat);
106 IO.mapOptional("Arch", Target.ArchString);
107 IO.mapOptional("Endianness", Target.Endianness);
108 IO.mapOptional("BitWidth", Target.BitWidth);
109 }
110
111 // Compacts symbol information into a single line.
112 static const bool flow = true; // NOLINT(readability-identifier-naming)
113 };
114
115 /// YAML traits for ELFSymbol.
116 template <> struct MappingTraits<IFSSymbol> {
mappingllvm::yaml::MappingTraits117 static void mapping(IO &IO, IFSSymbol &Symbol) {
118 IO.mapRequired("Name", Symbol.Name);
119 IO.mapRequired("Type", Symbol.Type);
120 // The need for symbol size depends on the symbol type.
121 if (Symbol.Type == IFSSymbolType::NoType) {
122 // Size is None, so we are reading it in, or it is non 0 so we
123 // should emit it.
124 if (!Symbol.Size || *Symbol.Size)
125 IO.mapOptional("Size", Symbol.Size);
126 } else if (Symbol.Type != IFSSymbolType::Func) {
127 IO.mapOptional("Size", Symbol.Size);
128 }
129 IO.mapOptional("Undefined", Symbol.Undefined, false);
130 IO.mapOptional("Weak", Symbol.Weak, false);
131 IO.mapOptional("Warning", Symbol.Warning);
132 }
133
134 // Compacts symbol information into a single line.
135 static const bool flow = true; // NOLINT(readability-identifier-naming)
136 };
137
138 /// YAML traits for ELFStub objects.
139 template <> struct MappingTraits<IFSStub> {
mappingllvm::yaml::MappingTraits140 static void mapping(IO &IO, IFSStub &Stub) {
141 if (!IO.mapTag("!ifs-v1", true))
142 IO.setError("Not a .tbe YAML file.");
143 IO.mapRequired("IfsVersion", Stub.IfsVersion);
144 IO.mapOptional("SoName", Stub.SoName);
145 IO.mapOptional("Target", Stub.Target);
146 IO.mapOptional("NeededLibs", Stub.NeededLibs);
147 IO.mapRequired("Symbols", Stub.Symbols);
148 }
149 };
150
151 /// YAML traits for ELFStubTriple objects.
152 template <> struct MappingTraits<IFSStubTriple> {
mappingllvm::yaml::MappingTraits153 static void mapping(IO &IO, IFSStubTriple &Stub) {
154 if (!IO.mapTag("!ifs-v1", true))
155 IO.setError("Not a .tbe YAML file.");
156 IO.mapRequired("IfsVersion", Stub.IfsVersion);
157 IO.mapOptional("SoName", Stub.SoName);
158 IO.mapOptional("Target", Stub.Target.Triple);
159 IO.mapOptional("NeededLibs", Stub.NeededLibs);
160 IO.mapRequired("Symbols", Stub.Symbols);
161 }
162 };
163 } // end namespace yaml
164 } // end namespace llvm
165
166 /// Attempt to determine if a Text stub uses target triple.
usesTriple(StringRef Buf)167 bool usesTriple(StringRef Buf) {
168 for (line_iterator I(MemoryBufferRef(Buf, "ELFStub")); !I.is_at_eof(); ++I) {
169 StringRef Line = (*I).trim();
170 if (Line.startswith("Target:")) {
171 if (Line == "Target:" || Line.contains("{")) {
172 return false;
173 }
174 }
175 }
176 return true;
177 }
178
readIFSFromBuffer(StringRef Buf)179 Expected<std::unique_ptr<IFSStub>> ifs::readIFSFromBuffer(StringRef Buf) {
180 yaml::Input YamlIn(Buf);
181 std::unique_ptr<IFSStubTriple> Stub(new IFSStubTriple());
182 if (usesTriple(Buf)) {
183 YamlIn >> *Stub;
184 } else {
185 YamlIn >> *static_cast<IFSStub *>(Stub.get());
186 }
187 if (std::error_code Err = YamlIn.error()) {
188 return createStringError(Err, "YAML failed reading as IFS");
189 }
190
191 if (Stub->IfsVersion > IFSVersionCurrent)
192 return make_error<StringError>(
193 "IFS version " + Stub->IfsVersion.getAsString() + " is unsupported.",
194 std::make_error_code(std::errc::invalid_argument));
195 if (Stub->Target.ArchString) {
196 Stub->Target.Arch =
197 ELF::convertArchNameToEMachine(*Stub->Target.ArchString);
198 }
199 return std::move(Stub);
200 }
201
writeIFSToOutputStream(raw_ostream & OS,const IFSStub & Stub)202 Error ifs::writeIFSToOutputStream(raw_ostream &OS, const IFSStub &Stub) {
203 yaml::Output YamlOut(OS, nullptr, /*WrapColumn =*/0);
204 std::unique_ptr<IFSStubTriple> CopyStub(new IFSStubTriple(Stub));
205 if (Stub.Target.Arch) {
206 CopyStub->Target.ArchString =
207 std::string(ELF::convertEMachineToArchName(*Stub.Target.Arch));
208 }
209 IFSTarget Target = Stub.Target;
210
211 if (CopyStub->Target.Triple ||
212 (!CopyStub->Target.ArchString && !CopyStub->Target.Endianness &&
213 !CopyStub->Target.BitWidth))
214 YamlOut << *CopyStub;
215 else
216 YamlOut << *static_cast<IFSStub *>(CopyStub.get());
217 return Error::success();
218 }
219
overrideIFSTarget(IFSStub & Stub,std::optional<IFSArch> OverrideArch,std::optional<IFSEndiannessType> OverrideEndianness,std::optional<IFSBitWidthType> OverrideBitWidth,std::optional<std::string> OverrideTriple)220 Error ifs::overrideIFSTarget(
221 IFSStub &Stub, std::optional<IFSArch> OverrideArch,
222 std::optional<IFSEndiannessType> OverrideEndianness,
223 std::optional<IFSBitWidthType> OverrideBitWidth,
224 std::optional<std::string> OverrideTriple) {
225 std::error_code OverrideEC(1, std::generic_category());
226 if (OverrideArch) {
227 if (Stub.Target.Arch && *Stub.Target.Arch != *OverrideArch) {
228 return make_error<StringError>(
229 "Supplied Arch conflicts with the text stub", OverrideEC);
230 }
231 Stub.Target.Arch = *OverrideArch;
232 }
233 if (OverrideEndianness) {
234 if (Stub.Target.Endianness &&
235 *Stub.Target.Endianness != *OverrideEndianness) {
236 return make_error<StringError>(
237 "Supplied Endianness conflicts with the text stub", OverrideEC);
238 }
239 Stub.Target.Endianness = *OverrideEndianness;
240 }
241 if (OverrideBitWidth) {
242 if (Stub.Target.BitWidth && *Stub.Target.BitWidth != *OverrideBitWidth) {
243 return make_error<StringError>(
244 "Supplied BitWidth conflicts with the text stub", OverrideEC);
245 }
246 Stub.Target.BitWidth = *OverrideBitWidth;
247 }
248 if (OverrideTriple) {
249 if (Stub.Target.Triple && *Stub.Target.Triple != *OverrideTriple) {
250 return make_error<StringError>(
251 "Supplied Triple conflicts with the text stub", OverrideEC);
252 }
253 Stub.Target.Triple = *OverrideTriple;
254 }
255 return Error::success();
256 }
257
validateIFSTarget(IFSStub & Stub,bool ParseTriple)258 Error ifs::validateIFSTarget(IFSStub &Stub, bool ParseTriple) {
259 std::error_code ValidationEC(1, std::generic_category());
260 if (Stub.Target.Triple) {
261 if (Stub.Target.Arch || Stub.Target.BitWidth || Stub.Target.Endianness ||
262 Stub.Target.ObjectFormat) {
263 return make_error<StringError>(
264 "Target triple cannot be used simultaneously with ELF target format",
265 ValidationEC);
266 }
267 if (ParseTriple) {
268 IFSTarget TargetFromTriple = parseTriple(*Stub.Target.Triple);
269 Stub.Target.Arch = TargetFromTriple.Arch;
270 Stub.Target.BitWidth = TargetFromTriple.BitWidth;
271 Stub.Target.Endianness = TargetFromTriple.Endianness;
272 }
273 return Error::success();
274 }
275 if (!Stub.Target.Arch || !Stub.Target.BitWidth || !Stub.Target.Endianness) {
276 // TODO: unify the error message.
277 if (!Stub.Target.Arch) {
278 return make_error<StringError>("Arch is not defined in the text stub",
279 ValidationEC);
280 }
281 if (!Stub.Target.BitWidth) {
282 return make_error<StringError>("BitWidth is not defined in the text stub",
283 ValidationEC);
284 }
285 if (!Stub.Target.Endianness) {
286 return make_error<StringError>(
287 "Endianness is not defined in the text stub", ValidationEC);
288 }
289 }
290 return Error::success();
291 }
292
parseTriple(StringRef TripleStr)293 IFSTarget ifs::parseTriple(StringRef TripleStr) {
294 Triple IFSTriple(TripleStr);
295 IFSTarget RetTarget;
296 // TODO: Implement a Triple Arch enum to e_machine map.
297 switch (IFSTriple.getArch()) {
298 case Triple::ArchType::aarch64:
299 RetTarget.Arch = (IFSArch)ELF::EM_AARCH64;
300 break;
301 case Triple::ArchType::x86_64:
302 RetTarget.Arch = (IFSArch)ELF::EM_X86_64;
303 break;
304 default:
305 RetTarget.Arch = (IFSArch)ELF::EM_NONE;
306 }
307 RetTarget.Endianness = IFSTriple.isLittleEndian() ? IFSEndiannessType::Little
308 : IFSEndiannessType::Big;
309 RetTarget.BitWidth =
310 IFSTriple.isArch64Bit() ? IFSBitWidthType::IFS64 : IFSBitWidthType::IFS32;
311 return RetTarget;
312 }
313
stripIFSTarget(IFSStub & Stub,bool StripTriple,bool StripArch,bool StripEndianness,bool StripBitWidth)314 void ifs::stripIFSTarget(IFSStub &Stub, bool StripTriple, bool StripArch,
315 bool StripEndianness, bool StripBitWidth) {
316 if (StripTriple || StripArch) {
317 Stub.Target.Arch.reset();
318 Stub.Target.ArchString.reset();
319 }
320 if (StripTriple || StripEndianness) {
321 Stub.Target.Endianness.reset();
322 }
323 if (StripTriple || StripBitWidth) {
324 Stub.Target.BitWidth.reset();
325 }
326 if (StripTriple) {
327 Stub.Target.Triple.reset();
328 }
329 if (!Stub.Target.Arch && !Stub.Target.BitWidth && !Stub.Target.Endianness) {
330 Stub.Target.ObjectFormat.reset();
331 }
332 }
333
filterIFSSyms(IFSStub & Stub,bool StripUndefined,const std::vector<std::string> & Exclude)334 Error ifs::filterIFSSyms(IFSStub &Stub, bool StripUndefined,
335 const std::vector<std::string> &Exclude) {
336 std::function<bool(const IFSSymbol &)> Filter = [](const IFSSymbol &) {
337 return false;
338 };
339
340 if (StripUndefined) {
341 Filter = [Filter](const IFSSymbol &Sym) {
342 return Sym.Undefined || Filter(Sym);
343 };
344 }
345
346 for (StringRef Glob : Exclude) {
347 Expected<llvm::GlobPattern> PatternOrErr = llvm::GlobPattern::create(Glob);
348 if (!PatternOrErr)
349 return PatternOrErr.takeError();
350 Filter = [Pattern = *PatternOrErr, Filter](const IFSSymbol &Sym) {
351 return Pattern.match(Sym.Name) || Filter(Sym);
352 };
353 }
354
355 llvm::erase_if(Stub.Symbols, Filter);
356
357 return Error::success();
358 }
359