SwiftCallingConv.h source code [clang_source_code/include/clang/CodeGen/SwiftCallingConv.h]

1	//==-- SwiftCallingConv.h - Swift ABI lowering ------------------- 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	// Defines constants and types related to Swift ABI lowering.
10	//
11	//===----------------------------------------------------------------------===//
12
13	#ifndef LLVM_CLANG_CODEGEN_SWIFTCALLINGCONV_H
14	#define LLVM_CLANG_CODEGEN_SWIFTCALLINGCONV_H
15
16	#include "clang/AST/CanonicalType.h"
17	#include "clang/AST/CharUnits.h"
18	#include "clang/AST/Type.h"
19	#include "llvm/Support/TrailingObjects.h"
20	#include <cassert>
21
22	namespace llvm {
23	class IntegerType;
24	class Type;
25	class StructType;
26	class VectorType;
27	}
28
29	namespace clang {
30	class Decl;
31	class FieldDecl;
32	class ASTRecordLayout;
33
34	namespace CodeGen {
35	class ABIArgInfo;
36	class CodeGenModule;
37	class CGFunctionInfo;
38
39	namespace swiftcall {
40
41	class SwiftAggLowering {
42	CodeGenModule &CGM;
43
44	struct StorageEntry {
45	CharUnits Begin;
46	CharUnits End;
47	llvm::Type *Type;
48
49	CharUnits getWidth() const {
50	return End - Begin;
51	}
52	};
53	SmallVector<StorageEntry, 4> Entries;
54	bool Finished = false;
55
56	public:
57	SwiftAggLowering(CodeGenModule &CGM) : CGM(CGM) {}
58
59	void addOpaqueData(CharUnits begin, CharUnits end) {
60	addEntry(nullptr, begin, end);
61	}
62
63	void addTypedData(QualType type, CharUnits begin);
64	void addTypedData(const RecordDecl *record, CharUnits begin);
65	void addTypedData(const RecordDecl *record, CharUnits begin,
66	const ASTRecordLayout &layout);
67	void addTypedData(llvm::Type *type, CharUnits begin);
68	void addTypedData(llvm::Type *type, CharUnits begin, CharUnits end);
69
70	void finish();
71
72	/// Does this lowering require passing any data?
73	bool empty() const {
74	(0) . __assert_fail ("Finished && \"didn't finish lowering before calling empty()\"", "/home/seafit/code_projects/clang_source/clang/include/clang/CodeGen/SwiftCallingConv.h", 74, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(Finished && "didn't finish lowering before calling empty()");
75	return Entries.empty();
76	}
77
78	/// According to the target Swift ABI, should a value with this lowering
79	/// be passed indirectly?
80	///
81	/// Note that this decision is based purely on the data layout of the
82	/// value and does not consider whether the type is address-only,
83	/// must be passed indirectly to match a function abstraction pattern, or
84	/// anything else that is expected to be handled by high-level lowering.
85	///
86	/// \param asReturnValue - if true, answer whether it should be passed
87	/// indirectly as a return value; if false, answer whether it should be
88	/// passed indirectly as an argument
89	bool shouldPassIndirectly(bool asReturnValue) const;
90
91	using EnumerationCallback =
92	llvm::function_ref<void(CharUnits offset, CharUnits end, llvm::Type *type)>;
93
94	/// Enumerate the expanded components of this type.
95	///
96	/// The component types will always be legal vector, floating-point,
97	/// integer, or pointer types.
98	void enumerateComponents(EnumerationCallback callback) const;
99
100	/// Return the types for a coerce-and-expand operation.
101	///
102	/// The first type matches the memory layout of the data that's been
103	/// added to this structure, including explicit [N x i8] arrays for any
104	/// internal padding.
105	///
106	/// The second type removes any internal padding members and, if only
107	/// one element remains, is simply that element type.
108	std::pair<llvm::StructType, llvm::Type> getCoerceAndExpandTypes() const;
109
110	private:
111	void addBitFieldData(const FieldDecl *field, CharUnits begin,
112	uint64_t bitOffset);
113	void addLegalTypedData(llvm::Type *type, CharUnits begin, CharUnits end);
114	void addEntry(llvm::Type *type, CharUnits begin, CharUnits end);
115	void splitVectorEntry(unsigned index);
116	static bool shouldMergeEntries(const StorageEntry &first,
117	const StorageEntry &second,
118	CharUnits chunkSize);
119	};
120
121	/// Should an aggregate which expands to the given type sequence
122	/// be passed/returned indirectly under swiftcall?
123	bool shouldPassIndirectly(CodeGenModule &CGM,
124	ArrayRef<llvm::Type*> types,
125	bool asReturnValue);
126
127	/// Return the maximum voluntary integer size for the current target.
128	CharUnits getMaximumVoluntaryIntegerSize(CodeGenModule &CGM);
129
130	/// Return the Swift CC's notion of the natural alignment of a type.
131	CharUnits getNaturalAlignment(CodeGenModule &CGM, llvm::Type *type);
132
133	/// Is the given integer type "legal" for Swift's perspective on the
134	/// current platform?
135	bool isLegalIntegerType(CodeGenModule &CGM, llvm::IntegerType *type);
136
137	/// Is the given vector type "legal" for Swift's perspective on the
138	/// current platform?
139	bool isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
140	llvm::VectorType *vectorTy);
141	bool isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
142	llvm::Type *eltTy, unsigned numElts);
143
144	/// Minimally split a legal vector type.
145	std::pair<llvm::Type*, unsigned>
146	splitLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
147	llvm::VectorType *vectorTy);
148
149	/// Turn a vector type in a sequence of legal component vector types.
150	///
151	/// The caller may assume that the sum of the data sizes of the resulting
152	/// types will equal the data size of the vector type.
153	void legalizeVectorType(CodeGenModule &CGM, CharUnits vectorSize,
154	llvm::VectorType *vectorTy,
155	llvm::SmallVectorImpl<llvm::Type*> &types);
156
157	/// Is the given record type required to be passed and returned indirectly
158	/// because of language restrictions?
159	///
160	/// This considers only mandatory indirectness due to language restrictions,
161	/// such as C++'s non-trivially-copyable types and Objective-C's __weak
162	/// references. A record for which this returns true may still be passed
163	/// indirectly for other reasons, such as being too large to fit in a
164	/// reasonable number of registers.
165	bool mustPassRecordIndirectly(CodeGenModule &CGM, const RecordDecl *record);
166
167	/// Classify the rules for how to return a particular type.
168	ABIArgInfo classifyReturnType(CodeGenModule &CGM, CanQualType type);
169
170	/// Classify the rules for how to pass a particular type.
171	ABIArgInfo classifyArgumentType(CodeGenModule &CGM, CanQualType type);
172
173	/// Compute the ABI information of a swiftcall function. This is a
174	/// private interface for Clang.
175	void computeABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI);
176
177	/// Is swifterror lowered to a register by the target ABI?
178	bool isSwiftErrorLoweredInRegister(CodeGenModule &CGM);
179
180	} // end namespace swiftcall
181	} // end namespace CodeGen
182	} // end namespace clang
183
184	#endif
185