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