clang  8.0.0svn
SwiftCallingConv.h
Go to the documentation of this file.
1 //==-- SwiftCallingConv.h - Swift ABI lowering ------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Defines constants and types related to Swift ABI lowering.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_CODEGEN_SWIFTCALLINGCONV_H
15 #define LLVM_CLANG_CODEGEN_SWIFTCALLINGCONV_H
16 
18 #include "clang/AST/CharUnits.h"
19 #include "clang/AST/Type.h"
20 #include "llvm/Support/TrailingObjects.h"
21 #include <cassert>
22 
23 namespace llvm {
24  class IntegerType;
25  class Type;
26  class StructType;
27  class VectorType;
28 }
29 
30 namespace clang {
31 class Decl;
32 class FieldDecl;
33 class ASTRecordLayout;
34 
35 namespace CodeGen {
36 class ABIArgInfo;
37 class CodeGenModule;
38 class CGFunctionInfo;
39 
40 namespace swiftcall {
41 
43  CodeGenModule &CGM;
44 
45  struct StorageEntry {
47  CharUnits End;
48  llvm::Type *Type;
49 
50  CharUnits getWidth() const {
51  return End - Begin;
52  }
53  };
55  bool Finished = false;
56 
57 public:
58  SwiftAggLowering(CodeGenModule &CGM) : CGM(CGM) {}
59 
60  void addOpaqueData(CharUnits begin, CharUnits end) {
61  addEntry(nullptr, begin, end);
62  }
63 
64  void addTypedData(QualType type, CharUnits begin);
65  void addTypedData(const RecordDecl *record, CharUnits begin);
66  void addTypedData(const RecordDecl *record, CharUnits begin,
67  const ASTRecordLayout &layout);
68  void addTypedData(llvm::Type *type, CharUnits begin);
69  void addTypedData(llvm::Type *type, CharUnits begin, CharUnits end);
70 
71  void finish();
72 
73  /// Does this lowering require passing any data?
74  bool empty() const {
75  assert(Finished && "didn't finish lowering before calling empty()");
76  return Entries.empty();
77  }
78 
79  /// According to the target Swift ABI, should a value with this lowering
80  /// be passed indirectly?
81  ///
82  /// Note that this decision is based purely on the data layout of the
83  /// value and does not consider whether the type is address-only,
84  /// must be passed indirectly to match a function abstraction pattern, or
85  /// anything else that is expected to be handled by high-level lowering.
86  ///
87  /// \param asReturnValue - if true, answer whether it should be passed
88  /// indirectly as a return value; if false, answer whether it should be
89  /// passed indirectly as an argument
90  bool shouldPassIndirectly(bool asReturnValue) const;
91 
92  using EnumerationCallback =
93  llvm::function_ref<void(CharUnits offset, CharUnits end, llvm::Type *type)>;
94 
95  /// Enumerate the expanded components of this type.
96  ///
97  /// The component types will always be legal vector, floating-point,
98  /// integer, or pointer types.
99  void enumerateComponents(EnumerationCallback callback) const;
100 
101  /// Return the types for a coerce-and-expand operation.
102  ///
103  /// The first type matches the memory layout of the data that's been
104  /// added to this structure, including explicit [N x i8] arrays for any
105  /// internal padding.
106  ///
107  /// The second type removes any internal padding members and, if only
108  /// one element remains, is simply that element type.
109  std::pair<llvm::StructType*, llvm::Type*> getCoerceAndExpandTypes() const;
110 
111 private:
112  void addBitFieldData(const FieldDecl *field, CharUnits begin,
113  uint64_t bitOffset);
114  void addLegalTypedData(llvm::Type *type, CharUnits begin, CharUnits end);
115  void addEntry(llvm::Type *type, CharUnits begin, CharUnits end);
116  void splitVectorEntry(unsigned index);
117 };
118 
119 /// Should an aggregate which expands to the given type sequence
120 /// be passed/returned indirectly under swiftcall?
123  bool asReturnValue);
124 
125 /// Return the maximum voluntary integer size for the current target.
127 
128 /// Return the Swift CC's notion of the natural alignment of a type.
130 
131 /// Is the given integer type "legal" for Swift's perspective on the
132 /// current platform?
133 bool isLegalIntegerType(CodeGenModule &CGM, llvm::IntegerType *type);
134 
135 /// Is the given vector type "legal" for Swift's perspective on the
136 /// current platform?
137 bool isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
138  llvm::VectorType *vectorTy);
139 bool isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
140  llvm::Type *eltTy, unsigned numElts);
141 
142 /// Minimally split a legal vector type.
143 std::pair<llvm::Type*, unsigned>
145  llvm::VectorType *vectorTy);
146 
147 /// Turn a vector type in a sequence of legal component vector types.
148 ///
149 /// The caller may assume that the sum of the data sizes of the resulting
150 /// types will equal the data size of the vector type.
151 void legalizeVectorType(CodeGenModule &CGM, CharUnits vectorSize,
152  llvm::VectorType *vectorTy,
154 
155 /// Is the given record type required to be passed and returned indirectly
156 /// because of language restrictions?
157 ///
158 /// This considers *only* mandatory indirectness due to language restrictions,
159 /// such as C++'s non-trivially-copyable types and Objective-C's __weak
160 /// references. A record for which this returns true may still be passed
161 /// indirectly for other reasons, such as being too large to fit in a
162 /// reasonable number of registers.
163 bool mustPassRecordIndirectly(CodeGenModule &CGM, const RecordDecl *record);
164 
165 /// Classify the rules for how to return a particular type.
167 
168 /// Classify the rules for how to pass a particular type.
170 
171 /// Compute the ABI information of a swiftcall function. This is a
172 /// private interface for Clang.
174 
175 /// Is swifterror lowered to a register by the target ABI?
177 
178 } // end namespace swiftcall
179 } // end namespace CodeGen
180 } // end namespace clang
181 
182 #endif
A (possibly-)qualified type.
Definition: Type.h:642
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:30
bool isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize, llvm::Type *eltTy, unsigned numElts)
C Language Family Type Representation.
The base class of the type hierarchy.
Definition: Type.h:1415
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
std::pair< llvm::Type *, unsigned > splitLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize, llvm::VectorType *vectorTy)
Minimally split a legal vector type.
Represents a struct/union/class.
Definition: Decl.h:3570
ABIArgInfo classifyArgumentType(CodeGenModule &CGM, CanQualType type)
Classify the rules for how to pass a particular type.
Represents a member of a struct/union/class.
Definition: Decl.h:2556
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
llvm::function_ref< void(CharUnits offset, CharUnits end, llvm::Type *type)> EnumerationCallback
ABIArgInfo - Helper class to encapsulate information about how a specific C type should be passed to ...
CharUnits getNaturalAlignment(CodeGenModule &CGM, llvm::Type *type)
Return the Swift CC&#39;s notion of the natural alignment of a type.
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:39
void addOpaqueData(CharUnits begin, CharUnits end)
SourceLocation End
bool isSwiftErrorLoweredInRegister(CodeGenModule &CGM)
Is swifterror lowered to a register by the target ABI?
SourceLocation Begin
static bool classifyReturnType(const CGCXXABI &CXXABI, CGFunctionInfo &FI, const ABIInfo &Info)
Definition: TargetInfo.cpp:159
bool shouldPassIndirectly(CodeGenModule &CGM, ArrayRef< llvm::Type *> types, bool asReturnValue)
Should an aggregate which expands to the given type sequence be passed/returned indirectly under swif...
bool empty() const
Does this lowering require passing any data?
void computeABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI)
Compute the ABI information of a swiftcall function.
void legalizeVectorType(CodeGenModule &CGM, CharUnits vectorSize, llvm::VectorType *vectorTy, llvm::SmallVectorImpl< llvm::Type *> &types)
Turn a vector type in a sequence of legal component vector types.
CGFunctionInfo - Class to encapsulate the information about a function definition.
This class organizes the cross-function state that is used while generating LLVM code.
Optional< types::ID > Type
Dataflow Directional Tag Classes.
bool mustPassRecordIndirectly(CodeGenModule &CGM, const RecordDecl *record)
Is the given record type required to be passed and returned indirectly because of language restrictio...
bool isLegalIntegerType(CodeGenModule &CGM, llvm::IntegerType *type)
Is the given integer type "legal" for Swift&#39;s perspective on the current platform?
CharUnits getMaximumVoluntaryIntegerSize(CodeGenModule &CGM)
Return the maximum voluntary integer size for the current target.