LLVM  16.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 
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 
22 using namespace llvm;
23 using namespace llvm::ifs;
24 
25 LLVM_YAML_IS_SEQUENCE_VECTOR(IFSSymbol)
26 
27 namespace llvm {
28 namespace yaml {
29 
30 /// YAML traits for ELFSymbolType.
31 template <> struct ScalarEnumerationTraits<IFSSymbolType> {
32  static void enumeration(IO &IO, IFSSymbolType &SymbolType) {
33  IO.enumCase(SymbolType, "NoType", IFSSymbolType::NoType);
34  IO.enumCase(SymbolType, "Func", IFSSymbolType::Func);
35  IO.enumCase(SymbolType, "Object", IFSSymbolType::Object);
36  IO.enumCase(SymbolType, "TLS", IFSSymbolType::TLS);
37  IO.enumCase(SymbolType, "Unknown", IFSSymbolType::Unknown);
38  // Treat other symbol types as noise, and map to Unknown.
39  if (!IO.outputting() && IO.matchEnumFallback())
40  SymbolType = IFSSymbolType::Unknown;
41  }
42 };
43 
44 template <> struct ScalarTraits<IFSEndiannessType> {
45  static void output(const IFSEndiannessType &Value, void *,
46  llvm::raw_ostream &Out) {
47  switch (Value) {
48  case IFSEndiannessType::Big:
49  Out << "big";
50  break;
51  case IFSEndiannessType::Little:
52  Out << "little";
53  break;
54  default:
55  llvm_unreachable("Unsupported endianness");
56  }
57  }
58 
59  static StringRef input(StringRef Scalar, void *, IFSEndiannessType &Value) {
60  Value = StringSwitch<IFSEndiannessType>(Scalar)
61  .Case("big", IFSEndiannessType::Big)
62  .Case("little", IFSEndiannessType::Little)
63  .Default(IFSEndiannessType::Unknown);
64  if (Value == IFSEndiannessType::Unknown) {
65  return "Unsupported endianness";
66  }
67  return StringRef();
68  }
69 
70  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
71 };
72 
73 template <> struct ScalarTraits<IFSBitWidthType> {
74  static void output(const IFSBitWidthType &Value, void *,
75  llvm::raw_ostream &Out) {
76  switch (Value) {
77  case IFSBitWidthType::IFS32:
78  Out << "32";
79  break;
80  case IFSBitWidthType::IFS64:
81  Out << "64";
82  break;
83  default:
84  llvm_unreachable("Unsupported bit width");
85  }
86  }
87 
88  static StringRef input(StringRef Scalar, void *, IFSBitWidthType &Value) {
89  Value = StringSwitch<IFSBitWidthType>(Scalar)
90  .Case("32", IFSBitWidthType::IFS32)
91  .Case("64", IFSBitWidthType::IFS64)
92  .Default(IFSBitWidthType::Unknown);
93  if (Value == IFSBitWidthType::Unknown) {
94  return "Unsupported bit width";
95  }
96  return StringRef();
97  }
98 
99  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
100 };
101 
102 template <> struct MappingTraits<IFSTarget> {
103  static void mapping(IO &IO, IFSTarget &Target) {
104  IO.mapOptional("ObjectFormat", Target.ObjectFormat);
105  IO.mapOptional("Arch", Target.ArchString);
106  IO.mapOptional("Endianness", Target.Endianness);
107  IO.mapOptional("BitWidth", Target.BitWidth);
108  }
109 
110  // Compacts symbol information into a single line.
111  static const bool flow = true; // NOLINT(readability-identifier-naming)
112 };
113 
114 /// YAML traits for ELFSymbol.
115 template <> struct MappingTraits<IFSSymbol> {
116  static void mapping(IO &IO, IFSSymbol &Symbol) {
117  IO.mapRequired("Name", Symbol.Name);
118  IO.mapRequired("Type", Symbol.Type);
119  // The need for symbol size depends on the symbol type.
120  if (Symbol.Type == IFSSymbolType::NoType) {
121  // Size is None, so we are reading it in, or it is non 0 so we
122  // should emit it.
123  if (!Symbol.Size || *Symbol.Size)
124  IO.mapOptional("Size", Symbol.Size);
125  } else if (Symbol.Type != IFSSymbolType::Func) {
126  IO.mapOptional("Size", Symbol.Size);
127  }
128  IO.mapOptional("Undefined", Symbol.Undefined, false);
129  IO.mapOptional("Weak", Symbol.Weak, false);
130  IO.mapOptional("Warning", Symbol.Warning);
131  }
132 
133  // Compacts symbol information into a single line.
134  static const bool flow = true; // NOLINT(readability-identifier-naming)
135 };
136 
137 /// YAML traits for ELFStub objects.
138 template <> struct MappingTraits<IFSStub> {
139  static void mapping(IO &IO, IFSStub &Stub) {
140  if (!IO.mapTag("!ifs-v1", true))
141  IO.setError("Not a .tbe YAML file.");
142  IO.mapRequired("IfsVersion", Stub.IfsVersion);
143  IO.mapOptional("SoName", Stub.SoName);
144  IO.mapOptional("Target", Stub.Target);
145  IO.mapOptional("NeededLibs", Stub.NeededLibs);
146  IO.mapRequired("Symbols", Stub.Symbols);
147  }
148 };
149 
150 /// YAML traits for ELFStubTriple objects.
151 template <> struct MappingTraits<IFSStubTriple> {
152  static void mapping(IO &IO, IFSStubTriple &Stub) {
153  if (!IO.mapTag("!ifs-v1", true))
154  IO.setError("Not a .tbe YAML file.");
155  IO.mapRequired("IfsVersion", Stub.IfsVersion);
156  IO.mapOptional("SoName", Stub.SoName);
157  IO.mapOptional("Target", Stub.Target.Triple);
158  IO.mapOptional("NeededLibs", Stub.NeededLibs);
159  IO.mapRequired("Symbols", Stub.Symbols);
160  }
161 };
162 } // end namespace yaml
163 } // end namespace llvm
164 
165 /// Attempt to determine if a Text stub uses target triple.
166 bool usesTriple(StringRef Buf) {
167  for (line_iterator I(MemoryBufferRef(Buf, "ELFStub")); !I.is_at_eof(); ++I) {
168  StringRef Line = (*I).trim();
169  if (Line.startswith("Target:")) {
170  if (Line == "Target:" || Line.contains("{")) {
171  return false;
172  }
173  }
174  }
175  return true;
176 }
177 
178 Expected<std::unique_ptr<IFSStub>> ifs::readIFSFromBuffer(StringRef Buf) {
179  yaml::Input YamlIn(Buf);
180  std::unique_ptr<IFSStubTriple> Stub(new IFSStubTriple());
181  if (usesTriple(Buf)) {
182  YamlIn >> *Stub;
183  } else {
184  YamlIn >> *static_cast<IFSStub *>(Stub.get());
185  }
186  if (std::error_code Err = YamlIn.error()) {
187  return createStringError(Err, "YAML failed reading as IFS");
188  }
189 
190  if (Stub->IfsVersion > IFSVersionCurrent)
191  return make_error<StringError>(
192  "IFS version " + Stub->IfsVersion.getAsString() + " is unsupported.",
193  std::make_error_code(std::errc::invalid_argument));
194  if (Stub->Target.ArchString) {
195  Stub->Target.Arch =
196  ELF::convertArchNameToEMachine(*Stub->Target.ArchString);
197  }
198  return std::move(Stub);
199 }
200 
201 Error ifs::writeIFSToOutputStream(raw_ostream &OS, const IFSStub &Stub) {
202  yaml::Output YamlOut(OS, nullptr, /*WrapColumn =*/0);
203  std::unique_ptr<IFSStubTriple> CopyStub(new IFSStubTriple(Stub));
204  if (Stub.Target.Arch) {
205  CopyStub->Target.ArchString =
206  std::string(ELF::convertEMachineToArchName(Stub.Target.Arch.value()));
207  }
208  IFSTarget Target = Stub.Target;
209 
210  if (CopyStub->Target.Triple ||
211  (!CopyStub->Target.ArchString && !CopyStub->Target.Endianness &&
212  !CopyStub->Target.BitWidth))
213  YamlOut << *CopyStub;
214  else
215  YamlOut << *static_cast<IFSStub *>(CopyStub.get());
216  return Error::success();
217 }
218 
219 Error ifs::overrideIFSTarget(IFSStub &Stub, Optional<IFSArch> OverrideArch,
220  Optional<IFSEndiannessType> OverrideEndianness,
221  Optional<IFSBitWidthType> OverrideBitWidth,
222  Optional<std::string> OverrideTriple) {
223  std::error_code OverrideEC(1, std::generic_category());
224  if (OverrideArch) {
225  if (Stub.Target.Arch && Stub.Target.Arch.value() != OverrideArch.value()) {
226  return make_error<StringError>(
227  "Supplied Arch conflicts with the text stub", OverrideEC);
228  }
229  Stub.Target.Arch = OverrideArch.value();
230  }
231  if (OverrideEndianness) {
232  if (Stub.Target.Endianness &&
233  Stub.Target.Endianness.value() != OverrideEndianness.value()) {
234  return make_error<StringError>(
235  "Supplied Endianness conflicts with the text stub", OverrideEC);
236  }
237  Stub.Target.Endianness = OverrideEndianness.value();
238  }
239  if (OverrideBitWidth) {
240  if (Stub.Target.BitWidth &&
241  Stub.Target.BitWidth.value() != OverrideBitWidth.value()) {
242  return make_error<StringError>(
243  "Supplied BitWidth conflicts with the text stub", OverrideEC);
244  }
245  Stub.Target.BitWidth = OverrideBitWidth.value();
246  }
247  if (OverrideTriple) {
248  if (Stub.Target.Triple &&
249  Stub.Target.Triple.value() != OverrideTriple.value()) {
250  return make_error<StringError>(
251  "Supplied Triple conflicts with the text stub", OverrideEC);
252  }
253  Stub.Target.Triple = OverrideTriple.value();
254  }
255  return Error::success();
256 }
257 
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 
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 
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 
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 }
llvm::StringSwitch::Case
StringSwitch & Case(StringLiteral S, T Value)
Definition: StringSwitch.h:70
llvm::ifs::IFSSymbolType::Unknown
@ Unknown
llvm::ifs::IFSStub::NeededLibs
std::vector< std::string > NeededLibs
Definition: IFSStub.h:94
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::ifs::IFSBitWidthType
IFSBitWidthType
Definition: IFSStub.h:44
llvm::line_iterator
A forward iterator which reads text lines from a buffer.
Definition: LineIterator.h:33
llvm::yaml::ScalarTraits< IFSBitWidthType >::output
static void output(const IFSBitWidthType &Value, void *, llvm::raw_ostream &Out)
Definition: IFSHandler.cpp:74
llvm::ifs::IFSSymbol
Definition: IFSStub.h:52
llvm::ifs
Definition: ELFObjHandler.h:23
StringRef.h
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:149
llvm::ifs::filterIFSSyms
Error filterIFSSyms(IFSStub &Stub, bool StripUndefined, const std::vector< std::string > &Exclude={})
Definition: IFSHandler.cpp:334
llvm::ifs::IFSTarget::Arch
Optional< IFSArch > Arch
Definition: IFSStub.h:67
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:329
llvm::XCOFF::SymbolType
SymbolType
Definition: XCOFF.h:227
llvm::erase_if
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:1997
llvm::yaml::ScalarTraits< IFSEndiannessType >::input
static StringRef input(StringRef Scalar, void *, IFSEndiannessType &Value)
Definition: IFSHandler.cpp:59
Error.h
llvm::ifs::IFSVersionCurrent
const VersionTuple IFSVersionCurrent(3, 0)
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
LLVM_YAML_IS_SEQUENCE_VECTOR
#define LLVM_YAML_IS_SEQUENCE_VECTOR(type)
llvm::ELF::EM_NONE
@ EM_NONE
Definition: ELF.h:133
IFSHandler.h
llvm::Optional
Definition: APInt.h:33
llvm::yaml::MappingTraits< IFSStub >::mapping
static void mapping(IO &IO, IFSStub &Stub)
Definition: IFSHandler.cpp:139
llvm::ifs::writeIFSToOutputStream
Error writeIFSToOutputStream(raw_ostream &OS, const IFSStub &Stub)
Attempts to write an IFS interface file to a raw_ostream.
Definition: IFSHandler.cpp:201
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:41
STLExtras.h
llvm::yaml::MappingTraits
Definition: ModuleSummaryIndex.h:53
llvm::Pattern::match
MatchResult match(StringRef Buffer, const SourceMgr &SM) const
Matches the pattern string against the input buffer Buffer.
llvm::MemoryBufferRef
Definition: MemoryBufferRef.h:22
llvm::Triple::isArch64Bit
bool isArch64Bit() const
Test whether the architecture is 64-bit.
Definition: Triple.cpp:1462
llvm::ifs::IFSBitWidthType::Unknown
@ Unknown
llvm::ifs::IFSArch
uint16_t IFSArch
Definition: IFSStub.h:24
llvm::Triple::isLittleEndian
bool isLittleEndian() const
Tests whether the target triple is little endian.
Definition: Triple.cpp:1735
ELF.h
llvm::ifs::IFSSymbolType
IFSSymbolType
Definition: IFSStub.h:26
llvm::ifs::validateIFSTarget
Error validateIFSTarget(IFSStub &Stub, bool ParseTriple)
Validate the target platform inforation in the text stub.
Definition: IFSHandler.cpp:258
llvm::ifs::IFSStub
Definition: IFSStub.h:89
llvm::ifs::IFSSymbolType::TLS
@ TLS
llvm::ifs::readIFSFromBuffer
Expected< std::unique_ptr< IFSStub > > readIFSFromBuffer(StringRef Buf)
Attempts to read an IFS interface file from a StringRef buffer.
Definition: IFSHandler.cpp:178
llvm::ifs::IFSBitWidthType::IFS32
@ IFS32
LineIterator.h
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::ifs::IFSEndiannessType::Big
@ Big
llvm::ifs::IFSStub::SoName
Optional< std::string > SoName
Definition: IFSStub.h:92
llvm::Triple::getArch
ArchType getArch() const
Get the parsed architecture type of this triple.
Definition: Triple.h:354
IFSStub.h
llvm::ifs::IFSTarget::BitWidth
Optional< IFSBitWidthType > BitWidth
Definition: IFSStub.h:70
llvm::ifs::IFSEndiannessType::Unknown
@ Unknown
llvm::ifs::IFSTarget::ArchString
Optional< std::string > ArchString
Definition: IFSStub.h:68
llvm::ClrHandlerType::Filter
@ Filter
llvm::ifs::IFSSymbolType::NoType
@ NoType
llvm::ifs::IFSTarget::Triple
Optional< std::string > Triple
Definition: IFSStub.h:65
llvm::yaml::ScalarTraits< IFSBitWidthType >::input
static StringRef input(StringRef Scalar, void *, IFSBitWidthType &Value)
Definition: IFSHandler.cpp:88
llvm::Optional::reset
void reset()
Definition: Optional.h:275
llvm::ifs::stripIFSTarget
void stripIFSTarget(IFSStub &Stub, bool StripTriple, bool StripArch, bool StripEndianness, bool StripBitWidth)
Strips target platform information from the text stub.
Definition: IFSHandler.cpp:314
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::yaml::ScalarTraits< IFSEndiannessType >::output
static void output(const IFSEndiannessType &Value, void *, llvm::raw_ostream &Out)
Definition: IFSHandler.cpp:45
llvm::yaml::ScalarEnumerationTraits< IFSSymbolType >::enumeration
static void enumeration(IO &IO, IFSSymbolType &SymbolType)
Definition: IFSHandler.cpp:32
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::ifs::IFSBitWidthType::IFS64
@ IFS64
llvm::ifs::IFSEndiannessType::Little
@ Little
llvm::ifs::IFSStubTriple
Definition: IFSStub.h:107
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:82
Triple.h
YAMLTraits.h
llvm::ifs::IFSEndiannessType
IFSEndiannessType
Definition: IFSStub.h:36
llvm::GlobPattern::create
static Expected< GlobPattern > create(StringRef Pat)
Definition: GlobPattern.cpp:108
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::yaml::MappingTraits< IFSStubTriple >::mapping
static void mapping(IO &IO, IFSStubTriple &Stub)
Definition: IFSHandler.cpp:152
llvm::ifs::IFSSymbolType::Func
@ Func
llvm::make_error_code
std::error_code make_error_code(BitcodeError E)
Definition: BitcodeReader.h:274
GlobPattern.h
llvm::yaml::MappingTraits< IFSTarget >::mapping
static void mapping(IO &IO, IFSTarget &Target)
Definition: IFSHandler.cpp:103
llvm::ifs::IFSTarget
Definition: IFSStub.h:64
llvm::ifs::parseTriple
IFSTarget parseTriple(StringRef TripleStr)
Parse llvm triple string into a IFSTarget struct.
Definition: IFSHandler.cpp:293
llvm::createStringError
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1238
llvm::None
constexpr std::nullopt_t None
Definition: None.h:27
llvm::ifs::IFSStub::Target
IFSTarget Target
Definition: IFSStub.h:93
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:155
llvm::ELF::convertEMachineToArchName
StringRef convertEMachineToArchName(uint16_t EMachine)
Convert an ELF's e_machine value into an architecture name.
Definition: ELF.cpp:205
llvm::ifs::IFSStub::IfsVersion
VersionTuple IfsVersion
Definition: IFSStub.h:91
StringSwitch.h
llvm::ifs::IFSSymbolType::Object
@ Object
llvm::ifs::IFSStub::Symbols
std::vector< IFSSymbol > Symbols
Definition: IFSStub.h:95
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:596
llvm::Pattern
Definition: FileCheckImpl.h:614
llvm::ELF::EM_X86_64
@ EM_X86_64
Definition: ELF.h:178
usesTriple
bool usesTriple(StringRef Buf)
Attempt to determine if a Text stub uses target triple.
Definition: IFSHandler.cpp:166
llvm::Optional::value
constexpr const T & value() const &
Definition: Optional.h:281
llvm::yaml::MappingTraits< IFSSymbol >::mapping
static void mapping(IO &IO, IFSSymbol &Symbol)
Definition: IFSHandler.cpp:116
llvm::yaml::ScalarTraits< IFSEndiannessType >::mustQuote
static QuotingType mustQuote(StringRef)
Definition: IFSHandler.cpp:70
llvm::StringSwitch::Default
R Default(T Value)
Definition: StringSwitch.h:183
llvm::yaml::ScalarTraits< IFSBitWidthType >::mustQuote
static QuotingType mustQuote(StringRef)
Definition: IFSHandler.cpp:99
llvm::StringSwitch
A switch()-like statement whose cases are string literals.
Definition: StringSwitch.h:45
llvm::ELF::EM_AARCH64
@ EM_AARCH64
Definition: ELF.h:280
llvm::ELF::convertArchNameToEMachine
uint16_t convertArchNameToEMachine(StringRef Arch)
Convert an architecture name into ELF's e_machine value.
Definition: ELF.cpp:17
llvm::ifs::IFSTarget::ObjectFormat
Optional< std::string > ObjectFormat
Definition: IFSStub.h:66
llvm::ifs::IFSTarget::Endianness
Optional< IFSEndiannessType > Endianness
Definition: IFSStub.h:69
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::ifs::overrideIFSTarget
Error overrideIFSTarget(IFSStub &Stub, Optional< IFSArch > OverrideArch, Optional< IFSEndiannessType > OverrideEndianness, Optional< IFSBitWidthType > OverrideBitWidth, Optional< std::string > OverrideTriple)
Override the target platform inforation in the text stub.
Definition: IFSHandler.cpp:219
Generated on Wed Nov 30 2022 23:24:00 for LLVM by   doxygen 1.8.17