1//===- IFSStub.h ------------------------------------------------*- C++ -*-===//
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/// \file
10/// This file defines an internal representation of an InterFace Stub.
11///
12//===-----------------------------------------------------------------------===/
13
14#ifndef LLVM_INTERFACESTUB_IFSSTUB_H
15#define LLVM_INTERFACESTUB_IFSSTUB_H
16
17#include "llvm/Support/VersionTuple.h"
18#include <optional>
19#include <vector>
20
21namespace llvm {
22namespace ifs {
23
24typedef uint16_t IFSArch;
25
26enum class IFSSymbolType {
27 NoType,
28 Object,
29 Func,
30 TLS,
31
32 // Type information is 4 bits, so 16 is safely out of range.
33 Unknown = 16,
34};
35
36enum class IFSEndiannessType {
37 Little,
38 Big,
39
40 // Endianness info is 1 bytes, 256 is safely out of range.
41 Unknown = 256,
42};
43
44enum class IFSBitWidthType {
45 IFS32,
46 IFS64,
47
48 // Bit width info is 1 bytes, 256 is safely out of range.
49 Unknown = 256,
50};
51
52struct IFSSymbol {
53 IFSSymbol() = default;
54 explicit IFSSymbol(std::string SymbolName) : Name(std::move(SymbolName)) {}
55 std::string Name;
56 std::optional<uint64_t> Size;
57 IFSSymbolType Type = IFSSymbolType::NoType;
58 bool Undefined = false;
59 bool Weak = false;
60 std::optional<std::string> Warning;
61 bool operator<(const IFSSymbol &RHS) const { return Name < RHS.Name; }
62};
63
64struct IFSTarget {
65 std::optional<std::string> Triple;
66 std::optional<std::string> ObjectFormat;
67 std::optional<IFSArch> Arch;
68 std::optional<std::string> ArchString;
69 std::optional<IFSEndiannessType> Endianness;
70 std::optional<IFSBitWidthType> BitWidth;
71
72 bool empty();
73};
74
75inline bool operator==(const IFSTarget &Lhs, const IFSTarget &Rhs) {
76 if (Lhs.Arch != Rhs.Arch || Lhs.BitWidth != Rhs.BitWidth ||
77 Lhs.Endianness != Rhs.Endianness ||
78 Lhs.ObjectFormat != Rhs.ObjectFormat || Lhs.Triple != Rhs.Triple)
79 return false;
80 return true;
81}
82
83inline bool operator!=(const IFSTarget &Lhs, const IFSTarget &Rhs) {
84 return !(Lhs == Rhs);
85}
86
87// A cumulative representation of InterFace stubs.
88// Both textual and binary stubs will read into and write from this object.
89struct IFSStub {
90 // TODO: Add support for symbol versioning.
91 VersionTuple IfsVersion;
92 std::optional<std::string> SoName;
93 IFSTarget Target;
94 std::vector<std::string> NeededLibs;
95 std::vector<IFSSymbol> Symbols;
96
97 IFSStub() = default;
98 IFSStub(const IFSStub &Stub);
99 IFSStub(IFSStub &&Stub);
100 virtual ~IFSStub() = default;
101};
102
103// Create a alias class for IFSStub.
104// LLVM's YAML library does not allow mapping a class with 2 traits,
105// which prevents us using 'Target:' field with different definitions.
106// This class makes it possible to map a second traits so the same data
107// structure can be used for 2 different yaml schema.
108struct IFSStubTriple : IFSStub {
109 IFSStubTriple() = default;
110 IFSStubTriple(const IFSStub &Stub);
111 IFSStubTriple(const IFSStubTriple &Stub);
112 IFSStubTriple(IFSStubTriple &&Stub);
113};
114
115/// This function convert bit width type from IFS enum to ELF format
116/// Currently, ELFCLASS32 and ELFCLASS64 are supported.
117///
118/// @param BitWidth IFS bit width type.
119uint8_t convertIFSBitWidthToELF(IFSBitWidthType BitWidth);
120
121/// This function convert endianness type from IFS enum to ELF format
122/// Currently, ELFDATA2LSB and ELFDATA2MSB are supported.
123///
124/// @param Endianness IFS endianness type.
125uint8_t convertIFSEndiannessToELF(IFSEndiannessType Endianness);
126
127/// This function convert symbol type from IFS enum to ELF format
128/// Currently, STT_NOTYPE, STT_OBJECT, STT_FUNC, and STT_TLS are supported.
129///
130/// @param SymbolType IFS symbol type.
131uint8_t convertIFSSymbolTypeToELF(IFSSymbolType SymbolType);
132
133/// This function extracts ELF bit width from e_ident[EI_CLASS] of an ELF file
134/// Currently, ELFCLASS32 and ELFCLASS64 are supported.
135/// Other endianness types are mapped to IFSBitWidthType::Unknown.
136///
137/// @param BitWidth e_ident[EI_CLASS] value to extract bit width from.
138IFSBitWidthType convertELFBitWidthToIFS(uint8_t BitWidth);
139
140/// This function extracts ELF endianness from e_ident[EI_DATA] of an ELF file
141/// Currently, ELFDATA2LSB and ELFDATA2MSB are supported.
142/// Other endianness types are mapped to IFSEndiannessType::Unknown.
143///
144/// @param Endianness e_ident[EI_DATA] value to extract endianness type from.
145IFSEndiannessType convertELFEndiannessToIFS(uint8_t Endianness);
146
147/// This function extracts symbol type from a symbol's st_info member and
148/// maps it to an IFSSymbolType enum.
149/// Currently, STT_NOTYPE, STT_OBJECT, STT_FUNC, and STT_TLS are supported.
150/// Other symbol types are mapped to IFSSymbolType::Unknown.
151///
152/// @param SymbolType Binary symbol st_info to extract symbol type from.
153IFSSymbolType convertELFSymbolTypeToIFS(uint8_t SymbolType);
154} // namespace ifs
155} // end namespace llvm
156
157#endif // LLVM_INTERFACESTUB_IFSSTUB_H
158

source code of llvm/include/llvm/InterfaceStub/IFSStub.h