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