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/BinaryFormat/ELF.h"
14#include "llvm/InterfaceStub/IFSStub.h"
15#include "llvm/Support/Error.h"
16#include "llvm/Support/GlobPattern.h"
17#include "llvm/Support/LineIterator.h"
18#include "llvm/Support/YAMLTraits.h"
19#include "llvm/TargetParser/Triple.h"
20#include <functional>
21#include <optional>
22
23using namespace llvm;
24using namespace llvm::ifs;
25
26LLVM_YAML_IS_SEQUENCE_VECTOR(IFSSymbol)
27
28namespace llvm {
29namespace yaml {
30
31/// YAML traits for ELFSymbolType.
32template <> struct ScalarEnumerationTraits<IFSSymbolType> {
33 static void enumeration(IO &IO, IFSSymbolType &SymbolType) {
34 IO.enumCase(Val&: SymbolType, Str: "NoType", ConstVal: IFSSymbolType::NoType);
35 IO.enumCase(Val&: SymbolType, Str: "Func", ConstVal: IFSSymbolType::Func);
36 IO.enumCase(Val&: SymbolType, Str: "Object", ConstVal: IFSSymbolType::Object);
37 IO.enumCase(Val&: SymbolType, Str: "TLS", ConstVal: IFSSymbolType::TLS);
38 IO.enumCase(Val&: SymbolType, Str: "Unknown", ConstVal: 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
45template <> struct ScalarTraits<IFSEndiannessType> {
46 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
60 static StringRef input(StringRef Scalar, void *, IFSEndiannessType &Value) {
61 Value = StringSwitch<IFSEndiannessType>(Scalar)
62 .Case(S: "big", Value: IFSEndiannessType::Big)
63 .Case(S: "little", Value: IFSEndiannessType::Little)
64 .Default(Value: IFSEndiannessType::Unknown);
65 if (Value == IFSEndiannessType::Unknown) {
66 return "Unsupported endianness";
67 }
68 return StringRef();
69 }
70
71 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
72};
73
74template <> struct ScalarTraits<IFSBitWidthType> {
75 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
89 static StringRef input(StringRef Scalar, void *, IFSBitWidthType &Value) {
90 Value = StringSwitch<IFSBitWidthType>(Scalar)
91 .Case(S: "32", Value: IFSBitWidthType::IFS32)
92 .Case(S: "64", Value: IFSBitWidthType::IFS64)
93 .Default(Value: IFSBitWidthType::Unknown);
94 if (Value == IFSBitWidthType::Unknown) {
95 return "Unsupported bit width";
96 }
97 return StringRef();
98 }
99
100 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
101};
102
103template <> struct MappingTraits<IFSTarget> {
104 static void mapping(IO &IO, IFSTarget &Target) {
105 IO.mapOptional(Key: "ObjectFormat", Val&: Target.ObjectFormat);
106 IO.mapOptional(Key: "Arch", Val&: Target.ArchString);
107 IO.mapOptional(Key: "Endianness", Val&: Target.Endianness);
108 IO.mapOptional(Key: "BitWidth", Val&: 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.
116template <> struct MappingTraits<IFSSymbol> {
117 static void mapping(IO &IO, IFSSymbol &Symbol) {
118 IO.mapRequired(Key: "Name", Val&: Symbol.Name);
119 IO.mapRequired(Key: "Type", Val&: 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(Key: "Size", Val&: Symbol.Size);
126 } else if (Symbol.Type != IFSSymbolType::Func) {
127 IO.mapOptional(Key: "Size", Val&: Symbol.Size);
128 }
129 IO.mapOptional(Key: "Undefined", Val&: Symbol.Undefined, Default: false);
130 IO.mapOptional(Key: "Weak", Val&: Symbol.Weak, Default: false);
131 IO.mapOptional(Key: "Warning", Val&: 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.
139template <> struct MappingTraits<IFSStub> {
140 static void mapping(IO &IO, IFSStub &Stub) {
141 if (!IO.mapTag(Tag: "!ifs-v1", Default: true))
142 IO.setError("Not a .tbe YAML file.");
143 IO.mapRequired(Key: "IfsVersion", Val&: Stub.IfsVersion);
144 IO.mapOptional(Key: "SoName", Val&: Stub.SoName);
145 IO.mapOptional(Key: "Target", Val&: Stub.Target);
146 IO.mapOptional(Key: "NeededLibs", Val&: Stub.NeededLibs);
147 IO.mapRequired(Key: "Symbols", Val&: Stub.Symbols);
148 }
149};
150
151/// YAML traits for ELFStubTriple objects.
152template <> struct MappingTraits<IFSStubTriple> {
153 static void mapping(IO &IO, IFSStubTriple &Stub) {
154 if (!IO.mapTag(Tag: "!ifs-v1", Default: true))
155 IO.setError("Not a .tbe YAML file.");
156 IO.mapRequired(Key: "IfsVersion", Val&: Stub.IfsVersion);
157 IO.mapOptional(Key: "SoName", Val&: Stub.SoName);
158 IO.mapOptional(Key: "Target", Val&: Stub.Target.Triple);
159 IO.mapOptional(Key: "NeededLibs", Val&: Stub.NeededLibs);
160 IO.mapRequired(Key: "Symbols", Val&: Stub.Symbols);
161 }
162};
163} // end namespace yaml
164} // end namespace llvm
165
166/// Attempt to determine if a Text stub uses target triple.
167bool usesTriple(StringRef Buf) {
168 for (line_iterator I(MemoryBufferRef(Buf, "ELFStub")); !I.is_at_eof(); ++I) {
169 StringRef Line = (*I).trim();
170 if (Line.starts_with(Prefix: "Target:")) {
171 if (Line == "Target:" || Line.contains(Other: "{")) {
172 return false;
173 }
174 }
175 }
176 return true;
177}
178
179Expected<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(EC: Err, S: "YAML failed reading as IFS");
189 }
190
191 if (Stub->IfsVersion > IFSVersionCurrent)
192 return make_error<StringError>(
193 Args: "IFS version " + Stub->IfsVersion.getAsString() + " is unsupported.",
194 Args: std::make_error_code(e: std::errc::invalid_argument));
195 if (Stub->Target.ArchString) {
196 uint16_t eMachine =
197 ELF::convertArchNameToEMachine(Arch: *Stub->Target.ArchString);
198 if (eMachine == ELF::EM_NONE)
199 return createStringError(
200 EC: std::make_error_code(e: std::errc::invalid_argument),
201 S: "IFS arch '" + *Stub->Target.ArchString + "' is unsupported");
202 Stub->Target.Arch = eMachine;
203 }
204 for (const auto &Item : Stub->Symbols) {
205 if (Item.Type == IFSSymbolType::Unknown)
206 return createStringError(
207 EC: std::make_error_code(e: std::errc::invalid_argument),
208 S: "IFS symbol type for symbol '" + Item.Name + "' is unsupported");
209 }
210 return std::move(Stub);
211}
212
213Error ifs::writeIFSToOutputStream(raw_ostream &OS, const IFSStub &Stub) {
214 yaml::Output YamlOut(OS, nullptr, /*WrapColumn =*/0);
215 std::unique_ptr<IFSStubTriple> CopyStub(new IFSStubTriple(Stub));
216 if (Stub.Target.Arch) {
217 CopyStub->Target.ArchString =
218 std::string(ELF::convertEMachineToArchName(EMachine: *Stub.Target.Arch));
219 }
220
221 if (CopyStub->Target.Triple ||
222 (!CopyStub->Target.ArchString && !CopyStub->Target.Endianness &&
223 !CopyStub->Target.BitWidth))
224 YamlOut << *CopyStub;
225 else
226 YamlOut << *static_cast<IFSStub *>(CopyStub.get());
227 return Error::success();
228}
229
230Error ifs::overrideIFSTarget(
231 IFSStub &Stub, std::optional<IFSArch> OverrideArch,
232 std::optional<IFSEndiannessType> OverrideEndianness,
233 std::optional<IFSBitWidthType> OverrideBitWidth,
234 std::optional<std::string> OverrideTriple) {
235 std::error_code OverrideEC(1, std::generic_category());
236 if (OverrideArch) {
237 if (Stub.Target.Arch && *Stub.Target.Arch != *OverrideArch) {
238 return make_error<StringError>(
239 Args: "Supplied Arch conflicts with the text stub", Args&: OverrideEC);
240 }
241 Stub.Target.Arch = *OverrideArch;
242 }
243 if (OverrideEndianness) {
244 if (Stub.Target.Endianness &&
245 *Stub.Target.Endianness != *OverrideEndianness) {
246 return make_error<StringError>(
247 Args: "Supplied Endianness conflicts with the text stub", Args&: OverrideEC);
248 }
249 Stub.Target.Endianness = *OverrideEndianness;
250 }
251 if (OverrideBitWidth) {
252 if (Stub.Target.BitWidth && *Stub.Target.BitWidth != *OverrideBitWidth) {
253 return make_error<StringError>(
254 Args: "Supplied BitWidth conflicts with the text stub", Args&: OverrideEC);
255 }
256 Stub.Target.BitWidth = *OverrideBitWidth;
257 }
258 if (OverrideTriple) {
259 if (Stub.Target.Triple && *Stub.Target.Triple != *OverrideTriple) {
260 return make_error<StringError>(
261 Args: "Supplied Triple conflicts with the text stub", Args&: OverrideEC);
262 }
263 Stub.Target.Triple = *OverrideTriple;
264 }
265 return Error::success();
266}
267
268Error ifs::validateIFSTarget(IFSStub &Stub, bool ParseTriple) {
269 std::error_code ValidationEC(1, std::generic_category());
270 if (Stub.Target.Triple) {
271 if (Stub.Target.Arch || Stub.Target.BitWidth || Stub.Target.Endianness ||
272 Stub.Target.ObjectFormat) {
273 return make_error<StringError>(
274 Args: "Target triple cannot be used simultaneously with ELF target format",
275 Args&: ValidationEC);
276 }
277 if (ParseTriple) {
278 IFSTarget TargetFromTriple = parseTriple(TripleStr: *Stub.Target.Triple);
279 Stub.Target.Arch = TargetFromTriple.Arch;
280 Stub.Target.BitWidth = TargetFromTriple.BitWidth;
281 Stub.Target.Endianness = TargetFromTriple.Endianness;
282 }
283 return Error::success();
284 }
285 if (!Stub.Target.Arch || !Stub.Target.BitWidth || !Stub.Target.Endianness) {
286 // TODO: unify the error message.
287 if (!Stub.Target.Arch) {
288 return make_error<StringError>(Args: "Arch is not defined in the text stub",
289 Args&: ValidationEC);
290 }
291 if (!Stub.Target.BitWidth) {
292 return make_error<StringError>(Args: "BitWidth is not defined in the text stub",
293 Args&: ValidationEC);
294 }
295 if (!Stub.Target.Endianness) {
296 return make_error<StringError>(
297 Args: "Endianness is not defined in the text stub", Args&: ValidationEC);
298 }
299 }
300 return Error::success();
301}
302
303IFSTarget ifs::parseTriple(StringRef TripleStr) {
304 Triple IFSTriple(TripleStr);
305 IFSTarget RetTarget;
306 IFSArch TripleArch =
307 ELF::convertTripleArchTypeToEMachine(ArchType: IFSTriple.getArch());
308 if (TripleArch != ELF::EM_NONE) {
309 RetTarget.Arch = TripleArch;
310 }
311 RetTarget.Endianness = IFSTriple.isLittleEndian() ? IFSEndiannessType::Little
312 : IFSEndiannessType::Big;
313 RetTarget.BitWidth =
314 IFSTriple.isArch64Bit() ? IFSBitWidthType::IFS64 : IFSBitWidthType::IFS32;
315 return RetTarget;
316}
317
318void ifs::stripIFSTarget(IFSStub &Stub, bool StripTriple, bool StripArch,
319 bool StripEndianness, bool StripBitWidth) {
320 if (StripTriple || StripArch) {
321 Stub.Target.Arch.reset();
322 Stub.Target.ArchString.reset();
323 }
324 if (StripTriple || StripEndianness) {
325 Stub.Target.Endianness.reset();
326 }
327 if (StripTriple || StripBitWidth) {
328 Stub.Target.BitWidth.reset();
329 }
330 if (StripTriple) {
331 Stub.Target.Triple.reset();
332 }
333 if (!Stub.Target.Arch && !Stub.Target.BitWidth && !Stub.Target.Endianness) {
334 Stub.Target.ObjectFormat.reset();
335 }
336}
337
338Error ifs::filterIFSSyms(IFSStub &Stub, bool StripUndefined,
339 const std::vector<std::string> &Exclude) {
340 std::function<bool(const IFSSymbol &)> Filter = [](const IFSSymbol &) {
341 return false;
342 };
343
344 if (StripUndefined) {
345 Filter = [Filter](const IFSSymbol &Sym) {
346 return Sym.Undefined || Filter(Sym);
347 };
348 }
349
350 for (StringRef Glob : Exclude) {
351 Expected<llvm::GlobPattern> PatternOrErr = llvm::GlobPattern::create(Pat: Glob);
352 if (!PatternOrErr)
353 return PatternOrErr.takeError();
354 Filter = [Pattern = *PatternOrErr, Filter](const IFSSymbol &Sym) {
355 return Pattern.match(S: Sym.Name) || Filter(Sym);
356 };
357 }
358
359 llvm::erase_if(C&: Stub.Symbols, P: Filter);
360
361 return Error::success();
362}
363