1 | //==---- CodeGenABITypes.h - Convert Clang types to LLVM types for ABI -----==// |
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 | // CodeGenABITypes is a simple interface for getting LLVM types for |
10 | // the parameters and the return value of a function given the Clang |
11 | // types. |
12 | // |
13 | // The class is implemented as a public wrapper around the private |
14 | // CodeGenTypes class in lib/CodeGen. |
15 | // |
16 | // It allows other clients, like LLDB, to determine the LLVM types that are |
17 | // actually used in function calls, which makes it possible to then determine |
18 | // the actual ABI locations (e.g. registers, stack locations, etc.) that |
19 | // these parameters are stored in. |
20 | // |
21 | //===----------------------------------------------------------------------===// |
22 | |
23 | #ifndef LLVM_CLANG_CODEGEN_CODEGENABITYPES_H |
24 | #define LLVM_CLANG_CODEGEN_CODEGENABITYPES_H |
25 | |
26 | #include "clang/AST/CanonicalType.h" |
27 | #include "clang/AST/Type.h" |
28 | #include "clang/Basic/ABI.h" |
29 | #include "clang/CodeGen/CGFunctionInfo.h" |
30 | #include "llvm/IR/BasicBlock.h" |
31 | |
32 | namespace llvm { |
33 | class AttrBuilder; |
34 | class Constant; |
35 | class Function; |
36 | class FunctionType; |
37 | class Type; |
38 | } |
39 | |
40 | namespace clang { |
41 | class CXXConstructorDecl; |
42 | class CXXDestructorDecl; |
43 | class CXXRecordDecl; |
44 | class CXXMethodDecl; |
45 | class ObjCMethodDecl; |
46 | class ObjCProtocolDecl; |
47 | |
48 | namespace CodeGen { |
49 | class CGFunctionInfo; |
50 | class CodeGenModule; |
51 | |
52 | /// Additional implicit arguments to add to a constructor argument list. |
53 | struct ImplicitCXXConstructorArgs { |
54 | /// Implicit arguments to add before the explicit arguments, but after the |
55 | /// `*this` argument (which always comes first). |
56 | SmallVector<llvm::Value *, 1> Prefix; |
57 | |
58 | /// Implicit arguments to add after the explicit arguments. |
59 | SmallVector<llvm::Value *, 1> Suffix; |
60 | }; |
61 | |
62 | const CGFunctionInfo &arrangeObjCMessageSendSignature(CodeGenModule &CGM, |
63 | const ObjCMethodDecl *MD, |
64 | QualType receiverType); |
65 | |
66 | const CGFunctionInfo &arrangeFreeFunctionType(CodeGenModule &CGM, |
67 | CanQual<FunctionProtoType> Ty); |
68 | |
69 | const CGFunctionInfo &arrangeFreeFunctionType(CodeGenModule &CGM, |
70 | CanQual<FunctionNoProtoType> Ty); |
71 | |
72 | const CGFunctionInfo &arrangeCXXMethodType(CodeGenModule &CGM, |
73 | const CXXRecordDecl *RD, |
74 | const FunctionProtoType *FTP, |
75 | const CXXMethodDecl *MD); |
76 | |
77 | const CGFunctionInfo &arrangeFreeFunctionCall(CodeGenModule &CGM, |
78 | CanQualType returnType, |
79 | ArrayRef<CanQualType> argTypes, |
80 | FunctionType::ExtInfo info, |
81 | RequiredArgs args); |
82 | |
83 | /// Returns the implicit arguments to add to a complete, non-delegating C++ |
84 | /// constructor call. |
85 | ImplicitCXXConstructorArgs |
86 | getImplicitCXXConstructorArgs(CodeGenModule &CGM, const CXXConstructorDecl *D); |
87 | |
88 | llvm::Value * |
89 | getCXXDestructorImplicitParam(CodeGenModule &CGM, llvm::BasicBlock *InsertBlock, |
90 | llvm::BasicBlock::iterator InsertPoint, |
91 | const CXXDestructorDecl *D, CXXDtorType Type, |
92 | bool ForVirtualBase, bool Delegating); |
93 | |
94 | /// Returns null if the function type is incomplete and can't be lowered. |
95 | llvm::FunctionType *convertFreeFunctionType(CodeGenModule &CGM, |
96 | const FunctionDecl *FD); |
97 | |
98 | llvm::Type *convertTypeForMemory(CodeGenModule &CGM, QualType T); |
99 | |
100 | /// Given a non-bitfield struct field, return its index within the elements of |
101 | /// the struct's converted type. The returned index refers to a field number in |
102 | /// the complete object type which is returned by convertTypeForMemory. FD must |
103 | /// be a field in RD directly (i.e. not an inherited field). |
104 | unsigned getLLVMFieldNumber(CodeGenModule &CGM, |
105 | const RecordDecl *RD, const FieldDecl *FD); |
106 | |
107 | /// Given the language and code-generation options that Clang was configured |
108 | /// with, set the default LLVM IR attributes for a function definition. |
109 | /// The attributes set here are mostly global target-configuration and |
110 | /// pipeline-configuration options like the target CPU, variant stack |
111 | /// rules, whether to optimize for size, and so on. This is useful for |
112 | /// frontends (such as Swift) that generally intend to interoperate with |
113 | /// C code and rely on Clang's target configuration logic. |
114 | /// |
115 | /// As a general rule, this function assumes that meaningful attributes |
116 | /// haven't already been added to the builder. It won't intentionally |
117 | /// displace any existing attributes, but it also won't check to avoid |
118 | /// overwriting them. Callers should generally apply customizations after |
119 | /// making this call. |
120 | /// |
121 | /// This function assumes that the caller is not defining a function that |
122 | /// requires special no-builtin treatment. |
123 | void addDefaultFunctionDefinitionAttributes(CodeGenModule &CGM, |
124 | llvm::AttrBuilder &attrs); |
125 | |
126 | /// Returns the default constructor for a C struct with non-trivially copyable |
127 | /// fields, generating it if necessary. The returned function uses the `cdecl` |
128 | /// calling convention, returns void, and takes a single argument that is a |
129 | /// pointer to the address of the struct. |
130 | llvm::Function *getNonTrivialCStructDefaultConstructor(CodeGenModule &GCM, |
131 | CharUnits DstAlignment, |
132 | bool IsVolatile, |
133 | QualType QT); |
134 | |
135 | /// Returns the copy constructor for a C struct with non-trivially copyable |
136 | /// fields, generating it if necessary. The returned function uses the `cdecl` |
137 | /// calling convention, returns void, and takes two arguments: pointers to the |
138 | /// addresses of the destination and source structs, respectively. |
139 | llvm::Function *getNonTrivialCStructCopyConstructor(CodeGenModule &CGM, |
140 | CharUnits DstAlignment, |
141 | CharUnits SrcAlignment, |
142 | bool IsVolatile, |
143 | QualType QT); |
144 | |
145 | /// Returns the move constructor for a C struct with non-trivially copyable |
146 | /// fields, generating it if necessary. The returned function uses the `cdecl` |
147 | /// calling convention, returns void, and takes two arguments: pointers to the |
148 | /// addresses of the destination and source structs, respectively. |
149 | llvm::Function *getNonTrivialCStructMoveConstructor(CodeGenModule &CGM, |
150 | CharUnits DstAlignment, |
151 | CharUnits SrcAlignment, |
152 | bool IsVolatile, |
153 | QualType QT); |
154 | |
155 | /// Returns the copy assignment operator for a C struct with non-trivially |
156 | /// copyable fields, generating it if necessary. The returned function uses the |
157 | /// `cdecl` calling convention, returns void, and takes two arguments: pointers |
158 | /// to the addresses of the destination and source structs, respectively. |
159 | llvm::Function *getNonTrivialCStructCopyAssignmentOperator( |
160 | CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment, |
161 | bool IsVolatile, QualType QT); |
162 | |
163 | /// Return the move assignment operator for a C struct with non-trivially |
164 | /// copyable fields, generating it if necessary. The returned function uses the |
165 | /// `cdecl` calling convention, returns void, and takes two arguments: pointers |
166 | /// to the addresses of the destination and source structs, respectively. |
167 | llvm::Function *getNonTrivialCStructMoveAssignmentOperator( |
168 | CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment, |
169 | bool IsVolatile, QualType QT); |
170 | |
171 | /// Returns the destructor for a C struct with non-trivially copyable fields, |
172 | /// generating it if necessary. The returned function uses the `cdecl` calling |
173 | /// convention, returns void, and takes a single argument that is a pointer to |
174 | /// the address of the struct. |
175 | llvm::Function *getNonTrivialCStructDestructor(CodeGenModule &CGM, |
176 | CharUnits DstAlignment, |
177 | bool IsVolatile, QualType QT); |
178 | |
179 | /// Get a pointer to a protocol object for the given declaration, emitting it if |
180 | /// it hasn't already been emitted in this translation unit. Note that the ABI |
181 | /// for emitting a protocol reference in code (e.g. for a protocol expression) |
182 | /// in most runtimes is not as simple as just materializing a pointer to this |
183 | /// object. |
184 | llvm::Constant *emitObjCProtocolObject(CodeGenModule &CGM, |
185 | const ObjCProtocolDecl *p); |
186 | } // end namespace CodeGen |
187 | } // end namespace clang |
188 | |
189 | #endif |
190 | |