clang 18.0.0git
CodeGenABITypes.h
Go to the documentation of this file.
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
27#include "clang/AST/Type.h"
28#include "clang/Basic/ABI.h"
30#include "llvm/IR/BasicBlock.h"
31
32namespace llvm {
33class AttrBuilder;
34class Constant;
35class Function;
36class FunctionType;
37class Type;
38}
39
40namespace clang {
41class CXXConstructorDecl;
42class CXXDestructorDecl;
43class CXXRecordDecl;
44class CXXMethodDecl;
45class ObjCMethodDecl;
46class ObjCProtocolDecl;
47
48namespace CodeGen {
49class CGFunctionInfo;
50class CodeGenModule;
51
52/// Additional implicit arguments to add to a constructor argument list.
54 /// Implicit arguments to add before the explicit arguments, but after the
55 /// `*this` argument (which always comes first).
57
58 /// Implicit arguments to add after the explicit arguments.
60};
61
63 const ObjCMethodDecl *MD,
64 QualType receiverType);
65
68
71
73 const CXXRecordDecl *RD,
74 const FunctionProtoType *FTP,
75 const CXXMethodDecl *MD);
76
78 CanQualType returnType,
79 ArrayRef<CanQualType> argTypes,
81 RequiredArgs args);
82
83/// Returns the implicit arguments to add to a complete, non-delegating C++
84/// constructor call.
87
88llvm::Value *
89getCXXDestructorImplicitParam(CodeGenModule &CGM, llvm::BasicBlock *InsertBlock,
90 llvm::BasicBlock::iterator InsertPoint,
92 bool ForVirtualBase, bool Delegating);
93
94/// Returns null if the function type is incomplete and can't be lowered.
95llvm::FunctionType *convertFreeFunctionType(CodeGenModule &CGM,
96 const FunctionDecl *FD);
97
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).
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.
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.
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.
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.
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.
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.
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.
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.
184llvm::Constant *emitObjCProtocolObject(CodeGenModule &CGM,
185 const ObjCProtocolDecl *p);
186} // end namespace CodeGen
187} // end namespace clang
188
189#endif
Enums/classes describing ABI related information about constructors, destructors and thunks.
MatchType Type
C Language Family Type Representation.
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2528
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2792
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2053
Represents a C++ struct/union/class.
Definition: DeclCXX.h:258
Represents a canonical, potentially-qualified type.
Definition: CanonicalType.h:65
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
CGFunctionInfo - Class to encapsulate the information about a function definition.
This class organizes the cross-function state that is used while generating LLVM code.
A class for recording the number of arguments that a function signature requires.
Represents a member of a struct/union/class.
Definition: Decl.h:3015
Represents a function declaration or definition.
Definition: Decl.h:1957
Represents a prototype with parameter type info, e.g.
Definition: Type.h:4160
A class which abstracts out some details necessary for making a call.
Definition: Type.h:3905
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:140
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2079
A (possibly-)qualified type.
Definition: Type.h:736
Represents a struct/union/class.
Definition: Decl.h:4117
The base class of the type hierarchy.
Definition: Type.h:1602
llvm::Value * getCXXDestructorImplicitParam(CodeGenModule &CGM, llvm::BasicBlock *InsertBlock, llvm::BasicBlock::iterator InsertPoint, const CXXDestructorDecl *D, CXXDtorType Type, bool ForVirtualBase, bool Delegating)
const CGFunctionInfo & arrangeFreeFunctionType(CodeGenModule &CGM, CanQual< FunctionProtoType > Ty)
llvm::Type * convertTypeForMemory(CodeGenModule &CGM, QualType T)
const CGFunctionInfo & arrangeObjCMessageSendSignature(CodeGenModule &CGM, const ObjCMethodDecl *MD, QualType receiverType)
llvm::Function * getNonTrivialCStructCopyConstructor(CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment, bool IsVolatile, QualType QT)
Returns the copy constructor for a C struct with non-trivially copyable fields, generating it if nece...
unsigned getLLVMFieldNumber(CodeGenModule &CGM, const RecordDecl *RD, const FieldDecl *FD)
Given a non-bitfield struct field, return its index within the elements of the struct's converted typ...
llvm::Function * getNonTrivialCStructMoveConstructor(CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment, bool IsVolatile, QualType QT)
Returns the move constructor for a C struct with non-trivially copyable fields, generating it if nece...
void addDefaultFunctionDefinitionAttributes(CodeGenModule &CGM, llvm::AttrBuilder &attrs)
Given the language and code-generation options that Clang was configured with, set the default LLVM I...
const CGFunctionInfo & arrangeCXXMethodType(CodeGenModule &CGM, const CXXRecordDecl *RD, const FunctionProtoType *FTP, const CXXMethodDecl *MD)
llvm::Function * getNonTrivialCStructCopyAssignmentOperator(CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment, bool IsVolatile, QualType QT)
Returns the copy assignment operator for a C struct with non-trivially copyable fields,...
const CGFunctionInfo & arrangeFreeFunctionCall(CodeGenModule &CGM, CanQualType returnType, ArrayRef< CanQualType > argTypes, FunctionType::ExtInfo info, RequiredArgs args)
llvm::FunctionType * convertFreeFunctionType(CodeGenModule &CGM, const FunctionDecl *FD)
Returns null if the function type is incomplete and can't be lowered.
llvm::Function * getNonTrivialCStructMoveAssignmentOperator(CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment, bool IsVolatile, QualType QT)
Return the move assignment operator for a C struct with non-trivially copyable fields,...
llvm::Constant * emitObjCProtocolObject(CodeGenModule &CGM, const ObjCProtocolDecl *p)
Get a pointer to a protocol object for the given declaration, emitting it if it hasn't already been e...
llvm::Function * getNonTrivialCStructDestructor(CodeGenModule &CGM, CharUnits DstAlignment, bool IsVolatile, QualType QT)
Returns the destructor for a C struct with non-trivially copyable fields, generating it if necessary.
ImplicitCXXConstructorArgs getImplicitCXXConstructorArgs(CodeGenModule &CGM, const CXXConstructorDecl *D)
Returns the implicit arguments to add to a complete, non-delegating C++ constructor call.
llvm::Function * getNonTrivialCStructDefaultConstructor(CodeGenModule &GCM, CharUnits DstAlignment, bool IsVolatile, QualType QT)
Returns the default constructor for a C struct with non-trivially copyable fields,...
CXXDtorType
C++ destructor types.
Definition: ABI.h:33
YAML serialization mapping.
Definition: Dominators.h:30
Additional implicit arguments to add to a constructor argument list.
SmallVector< llvm::Value *, 1 > Prefix
Implicit arguments to add before the explicit arguments, but after the *this argument (which always c...
SmallVector< llvm::Value *, 1 > Suffix
Implicit arguments to add after the explicit arguments.