LLVM 19.0.0git
IFSHandler.cpp
Go to the documentation of this file.
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
10#include "llvm/ADT/STLExtras.h"
11#include "llvm/ADT/StringRef.h"
15#include "llvm/Support/Error.h"
20#include <functional>
21#include <optional>
22
23using namespace llvm;
24using namespace llvm::ifs;
25
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(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
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) {
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
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) {
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
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("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.
116template <> struct MappingTraits<IFSSymbol> {
117 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.
139template <> struct MappingTraits<IFSStub> {
140 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.
152template <> struct MappingTraits<IFSStubTriple> {
153 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.
168 for (line_iterator I(MemoryBufferRef(Buf, "ELFStub")); !I.is_at_eof(); ++I) {
169 StringRef Line = (*I).trim();
170 if (Line.starts_with("Target:")) {
171 if (Line == "Target:" || Line.contains("{")) {
172 return false;
173 }
174 }
175 }
176 return true;
177}
178
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 uint16_t eMachine =
197 ELF::convertArchNameToEMachine(*Stub->Target.ArchString);
198 if (eMachine == ELF::EM_NONE)
199 return createStringError(
200 std::make_error_code(std::errc::invalid_argument),
201 "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 std::make_error_code(std::errc::invalid_argument),
208 "IFS symbol type for symbol '" + Item.Name + "' is unsupported");
209 }
210 return std::move(Stub);
211}
212
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(*Stub.Target.Arch));
219 }
220 IFSTarget Target = Stub.Target;
221
222 if (CopyStub->Target.Triple ||
223 (!CopyStub->Target.ArchString && !CopyStub->Target.Endianness &&
224 !CopyStub->Target.BitWidth))
225 YamlOut << *CopyStub;
226 else
227 YamlOut << *static_cast<IFSStub *>(CopyStub.get());
228 return Error::success();
229}
230
232 IFSStub &Stub, std::optional<IFSArch> OverrideArch,
233 std::optional<IFSEndiannessType> OverrideEndianness,
234 std::optional<IFSBitWidthType> OverrideBitWidth,
235 std::optional<std::string> OverrideTriple) {
236 std::error_code OverrideEC(1, std::generic_category());
237 if (OverrideArch) {
238 if (Stub.Target.Arch && *Stub.Target.Arch != *OverrideArch) {
239 return make_error<StringError>(
240 "Supplied Arch conflicts with the text stub", OverrideEC);
241 }
242 Stub.Target.Arch = *OverrideArch;
243 }
244 if (OverrideEndianness) {
245 if (Stub.Target.Endianness &&
246 *Stub.Target.Endianness != *OverrideEndianness) {
247 return make_error<StringError>(
248 "Supplied Endianness conflicts with the text stub", OverrideEC);
249 }
250 Stub.Target.Endianness = *OverrideEndianness;
251 }
252 if (OverrideBitWidth) {
253 if (Stub.Target.BitWidth && *Stub.Target.BitWidth != *OverrideBitWidth) {
254 return make_error<StringError>(
255 "Supplied BitWidth conflicts with the text stub", OverrideEC);
256 }
257 Stub.Target.BitWidth = *OverrideBitWidth;
258 }
259 if (OverrideTriple) {
260 if (Stub.Target.Triple && *Stub.Target.Triple != *OverrideTriple) {
261 return make_error<StringError>(
262 "Supplied Triple conflicts with the text stub", OverrideEC);
263 }
264 Stub.Target.Triple = *OverrideTriple;
265 }
266 return Error::success();
267}
268
269Error ifs::validateIFSTarget(IFSStub &Stub, bool ParseTriple) {
270 std::error_code ValidationEC(1, std::generic_category());
271 if (Stub.Target.Triple) {
272 if (Stub.Target.Arch || Stub.Target.BitWidth || Stub.Target.Endianness ||
273 Stub.Target.ObjectFormat) {
274 return make_error<StringError>(
275 "Target triple cannot be used simultaneously with ELF target format",
276 ValidationEC);
277 }
278 if (ParseTriple) {
279 IFSTarget TargetFromTriple = parseTriple(*Stub.Target.Triple);
280 Stub.Target.Arch = TargetFromTriple.Arch;
281 Stub.Target.BitWidth = TargetFromTriple.BitWidth;
282 Stub.Target.Endianness = TargetFromTriple.Endianness;
283 }
284 return Error::success();
285 }
286 if (!Stub.Target.Arch || !Stub.Target.BitWidth || !Stub.Target.Endianness) {
287 // TODO: unify the error message.
288 if (!Stub.Target.Arch) {
289 return make_error<StringError>("Arch is not defined in the text stub",
290 ValidationEC);
291 }
292 if (!Stub.Target.BitWidth) {
293 return make_error<StringError>("BitWidth is not defined in the text stub",
294 ValidationEC);
295 }
296 if (!Stub.Target.Endianness) {
297 return make_error<StringError>(
298 "Endianness is not defined in the text stub", ValidationEC);
299 }
300 }
301 return Error::success();
302}
303
305 Triple IFSTriple(TripleStr);
306 IFSTarget RetTarget;
307 // TODO: Implement a Triple Arch enum to e_machine map.
308 switch (IFSTriple.getArch()) {
309 case Triple::ArchType::aarch64:
310 RetTarget.Arch = (IFSArch)ELF::EM_AARCH64;
311 break;
312 case Triple::ArchType::x86_64:
313 RetTarget.Arch = (IFSArch)ELF::EM_X86_64;
314 break;
315 case Triple::ArchType::riscv64:
316 RetTarget.Arch = (IFSArch)ELF::EM_RISCV;
317 break;
318 default:
319 RetTarget.Arch = (IFSArch)ELF::EM_NONE;
320 }
321 RetTarget.Endianness = IFSTriple.isLittleEndian() ? IFSEndiannessType::Little
322 : IFSEndiannessType::Big;
323 RetTarget.BitWidth =
324 IFSTriple.isArch64Bit() ? IFSBitWidthType::IFS64 : IFSBitWidthType::IFS32;
325 return RetTarget;
326}
327
328void ifs::stripIFSTarget(IFSStub &Stub, bool StripTriple, bool StripArch,
329 bool StripEndianness, bool StripBitWidth) {
330 if (StripTriple || StripArch) {
331 Stub.Target.Arch.reset();
332 Stub.Target.ArchString.reset();
333 }
334 if (StripTriple || StripEndianness) {
335 Stub.Target.Endianness.reset();
336 }
337 if (StripTriple || StripBitWidth) {
338 Stub.Target.BitWidth.reset();
339 }
340 if (StripTriple) {
341 Stub.Target.Triple.reset();
342 }
343 if (!Stub.Target.Arch && !Stub.Target.BitWidth && !Stub.Target.Endianness) {
344 Stub.Target.ObjectFormat.reset();
345 }
346}
347
348Error ifs::filterIFSSyms(IFSStub &Stub, bool StripUndefined,
349 const std::vector<std::string> &Exclude) {
350 std::function<bool(const IFSSymbol &)> Filter = [](const IFSSymbol &) {
351 return false;
352 };
353
354 if (StripUndefined) {
355 Filter = [Filter](const IFSSymbol &Sym) {
356 return Sym.Undefined || Filter(Sym);
357 };
358 }
359
360 for (StringRef Glob : Exclude) {
362 if (!PatternOrErr)
363 return PatternOrErr.takeError();
364 Filter = [Pattern = *PatternOrErr, Filter](const IFSSymbol &Sym) {
365 return Pattern.match(Sym.Name) || Filter(Sym);
366 };
367 }
368
370
371 return Error::success();
372}
Symbol * Sym
Definition: ELF_riscv.cpp:479
bool usesTriple(StringRef Buf)
Attempt to determine if a Text stub uses target triple.
Definition: IFSHandler.cpp:167
This file declares an interface for reading and writing .ifs (text-based InterFace Stub) files.
This file defines an internal representation of an InterFace Stub.
#define I(x, y, z)
Definition: MD5.cpp:58
This file contains some templates that are useful if you are working with the STL at all.
raw_pwrite_stream & OS
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
#define LLVM_YAML_IS_SEQUENCE_VECTOR(type)
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:334
Tagged union holding either a T or a Error.
Definition: Error.h:474
Error takeError()
Take ownership of the stored error.
Definition: Error.h:601
static Expected< GlobPattern > create(StringRef Pat, std::optional< size_t > MaxSubPatterns={})
MatchResult match(StringRef Buffer, const SourceMgr &SM) const
Matches the pattern string against the input buffer Buffer.
Definition: FileCheck.cpp:1071
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
A switch()-like statement whose cases are string literals.
Definition: StringSwitch.h:44
StringSwitch & Case(StringLiteral S, T Value)
Definition: StringSwitch.h:69
R Default(T Value)
Definition: StringSwitch.h:182
Target - Wrapper for Target specific information.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
bool isLittleEndian() const
Tests whether the target triple is little endian.
Definition: Triple.cpp:1817
ArchType getArch() const
Get the parsed architecture type of this triple.
Definition: Triple.h:361
bool isArch64Bit() const
Test whether the architecture is 64-bit.
Definition: Triple.cpp:1538
LLVM Value Representation.
Definition: Value.h:74
A forward iterator which reads text lines from a buffer.
Definition: LineIterator.h:33
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ EM_NONE
Definition: ELF.h:133
@ EM_X86_64
Definition: ELF.h:178
@ EM_AARCH64
Definition: ELF.h:280
@ EM_RISCV
Definition: ELF.h:317
uint16_t convertArchNameToEMachine(StringRef Arch)
Convert an architecture name into ELF's e_machine value.
Definition: ELF.cpp:16
StringRef convertEMachineToArchName(uint16_t EMachine)
Convert an ELF's e_machine value into an architecture name.
Definition: ELF.cpp:204
void stripIFSTarget(IFSStub &Stub, bool StripTriple, bool StripArch, bool StripEndianness, bool StripBitWidth)
Strips target platform information from the text stub.
Definition: IFSHandler.cpp:328
uint16_t IFSArch
Definition: IFSStub.h:24
Expected< std::unique_ptr< IFSStub > > readIFSFromBuffer(StringRef Buf)
Attempts to read an IFS interface file from a StringRef buffer.
Definition: IFSHandler.cpp:179
Error validateIFSTarget(IFSStub &Stub, bool ParseTriple)
Validate the target platform inforation in the text stub.
Definition: IFSHandler.cpp:269
IFSTarget parseTriple(StringRef TripleStr)
Parse llvm triple string into a IFSTarget struct.
Definition: IFSHandler.cpp:304
Error writeIFSToOutputStream(raw_ostream &OS, const IFSStub &Stub)
Attempts to write an IFS interface file to a raw_ostream.
Definition: IFSHandler.cpp:213
const VersionTuple IFSVersionCurrent(3, 0)
IFSEndiannessType
Definition: IFSStub.h:36
IFSBitWidthType
Definition: IFSStub.h:44
Error filterIFSSyms(IFSStub &Stub, bool StripUndefined, const std::vector< std::string > &Exclude={})
Definition: IFSHandler.cpp:348
IFSSymbolType
Definition: IFSStub.h:26
Error overrideIFSTarget(IFSStub &Stub, std::optional< IFSArch > OverrideArch, std::optional< IFSEndiannessType > OverrideEndianness, std::optional< IFSBitWidthType > OverrideBitWidth, std::optional< std::string > OverrideTriple)
Override the target platform inforation in the text stub.
Definition: IFSHandler.cpp:231
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1244
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
Definition: STLExtras.h:2031
std::vector< IFSSymbol > Symbols
Definition: IFSStub.h:95
VersionTuple IfsVersion
Definition: IFSStub.h:91
IFSTarget Target
Definition: IFSStub.h:93
std::optional< std::string > SoName
Definition: IFSStub.h:92
std::vector< std::string > NeededLibs
Definition: IFSStub.h:94
std::optional< std::string > ArchString
Definition: IFSStub.h:68
std::optional< std::string > Triple
Definition: IFSStub.h:65
std::optional< IFSEndiannessType > Endianness
Definition: IFSStub.h:69
std::optional< IFSBitWidthType > BitWidth
Definition: IFSStub.h:70
std::optional< std::string > ObjectFormat
Definition: IFSStub.h:66
std::optional< IFSArch > Arch
Definition: IFSStub.h:67
static void mapping(IO &IO, IFSStubTriple &Stub)
Definition: IFSHandler.cpp:153
static void mapping(IO &IO, IFSStub &Stub)
Definition: IFSHandler.cpp:140
static void mapping(IO &IO, IFSSymbol &Symbol)
Definition: IFSHandler.cpp:117
static void mapping(IO &IO, IFSTarget &Target)
Definition: IFSHandler.cpp:104
static void enumeration(IO &IO, IFSSymbolType &SymbolType)
Definition: IFSHandler.cpp:33
static StringRef input(StringRef Scalar, void *, IFSBitWidthType &Value)
Definition: IFSHandler.cpp:89
static void output(const IFSBitWidthType &Value, void *, llvm::raw_ostream &Out)
Definition: IFSHandler.cpp:75
static QuotingType mustQuote(StringRef)
Definition: IFSHandler.cpp:100
static StringRef input(StringRef Scalar, void *, IFSEndiannessType &Value)
Definition: IFSHandler.cpp:60
static QuotingType mustQuote(StringRef)
Definition: IFSHandler.cpp:71
static void output(const IFSEndiannessType &Value, void *, llvm::raw_ostream &Out)
Definition: IFSHandler.cpp:46