WebSVN – QNX 8.QNX8 LLVM/Clang compiler suite – Blame – /llvm-build/x86_64/include/llvm/InterfaceStub/IFSStub.h

Rev	Author	Line No.	Line
14	pmbaty	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
		21	namespace llvm {
		22	namespace ifs {
		23
		24	typedef uint16_t IFSArch;
		25
		26	enum 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
		36	enum class IFSEndiannessType {
		37	Little,
		38	Big,
		39
		40	// Endianness info is 1 bytes, 256 is safely out of range.
		41	Unknown = 256,
		42	};
		43
		44	enum 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
		52	struct 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;
		58	bool Undefined;
		59	bool Weak;
		60	std::optional<std::string> Warning;
		61	bool operator<(const IFSSymbol &RHS) const { return Name < RHS.Name; }
		62	};
		63
		64	struct 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
		75	inline 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
		83	inline 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.
		89	struct 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	};
		101
		102	// Create a alias class for IFSStub.
		103	// LLVM's YAML library does not allow mapping a class with 2 traits,
		104	// which prevents us using 'Target:' field with different definitions.
		105	// This class makes it possible to map a second traits so the same data
		106	// structure can be used for 2 different yaml schema.
		107	struct IFSStubTriple : IFSStub {
		108	IFSStubTriple() = default;
		109	IFSStubTriple(const IFSStub &Stub);
		110	IFSStubTriple(const IFSStubTriple &Stub);
		111	IFSStubTriple(IFSStubTriple &&Stub);
		112	};
		113
		114	/// This function convert bit width type from IFS enum to ELF format
		115	/// Currently, ELFCLASS32 and ELFCLASS64 are supported.
		116	///
		117	/// @param BitWidth IFS bit width type.
		118	uint8_t convertIFSBitWidthToELF(IFSBitWidthType BitWidth);
		119
		120	/// This function convert endianness type from IFS enum to ELF format
		121	/// Currently, ELFDATA2LSB and ELFDATA2MSB are supported.
		122	///
		123	/// @param Endianness IFS endianness type.
		124	uint8_t convertIFSEndiannessToELF(IFSEndiannessType Endianness);
		125
		126	/// This function convert symbol type from IFS enum to ELF format
		127	/// Currently, STT_NOTYPE, STT_OBJECT, STT_FUNC, and STT_TLS are supported.
		128	///
		129	/// @param SymbolType IFS symbol type.
		130	uint8_t convertIFSSymbolTypeToELF(IFSSymbolType SymbolType);
		131
		132	/// This function extracts ELF bit width from e_ident[EI_CLASS] of an ELF file
		133	/// Currently, ELFCLASS32 and ELFCLASS64 are supported.
		134	/// Other endianness types are mapped to IFSBitWidthType::Unknown.
		135	///
		136	/// @param BitWidth e_ident[EI_CLASS] value to extract bit width from.
		137	IFSBitWidthType convertELFBitWidthToIFS(uint8_t BitWidth);
		138
		139	/// This function extracts ELF endianness from e_ident[EI_DATA] of an ELF file
		140	/// Currently, ELFDATA2LSB and ELFDATA2MSB are supported.
		141	/// Other endianness types are mapped to IFSEndiannessType::Unknown.
		142	///
		143	/// @param Endianness e_ident[EI_DATA] value to extract endianness type from.
		144	IFSEndiannessType convertELFEndiannessToIFS(uint8_t Endianness);
		145
		146	/// This function extracts symbol type from a symbol's st_info member and
		147	/// maps it to an IFSSymbolType enum.
		148	/// Currently, STT_NOTYPE, STT_OBJECT, STT_FUNC, and STT_TLS are supported.
		149	/// Other symbol types are mapped to IFSSymbolType::Unknown.
		150	///
		151	/// @param SymbolType Binary symbol st_info to extract symbol type from.
		152	IFSSymbolType convertELFSymbolTypeToIFS(uint8_t SymbolType);
		153	} // namespace ifs
		154	} // end namespace llvm
		155
		156	#endif // LLVM_INTERFACESTUB_IFSSTUB_H

Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

QNX 8.QNX8 LLVM/Clang compiler suite/llvm-build/x86_64/include/llvm/InterfaceStub/IFSStub.h – Rev 14