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 GlobalDecl; 46 class ObjCMethodDecl; 47 class ObjCProtocolDecl; 48 49 namespace CodeGen { 50 class CGFunctionInfo; 51 class CodeGenModule; 52 53 /// Additional implicit arguments to add to a constructor argument list. 54 struct ImplicitCXXConstructorArgs { 55 /// Implicit arguments to add before the explicit arguments, but after the 56 /// `*this` argument (which always comes first). 57 SmallVector<llvm::Value *, 1> Prefix; 58 59 /// Implicit arguments to add after the explicit arguments. 60 SmallVector<llvm::Value *, 1> Suffix; 61 }; 62 63 const CGFunctionInfo &arrangeObjCMessageSendSignature(CodeGenModule &CGM, 64 const ObjCMethodDecl *MD, 65 QualType receiverType); 66 67 const CGFunctionInfo &arrangeFreeFunctionType(CodeGenModule &CGM, 68 CanQual<FunctionProtoType> Ty); 69 70 const CGFunctionInfo &arrangeFreeFunctionType(CodeGenModule &CGM, 71 CanQual<FunctionNoProtoType> Ty); 72 73 const CGFunctionInfo &arrangeCXXMethodType(CodeGenModule &CGM, 74 const CXXRecordDecl *RD, 75 const FunctionProtoType *FTP, 76 const CXXMethodDecl *MD); 77 78 const CGFunctionInfo &arrangeFreeFunctionCall(CodeGenModule &CGM, 79 CanQualType returnType, 80 ArrayRef<CanQualType> argTypes, 81 FunctionType::ExtInfo info, 82 RequiredArgs args); 83 84 /// Returns the implicit arguments to add to a complete, non-delegating C++ 85 /// constructor call. 86 ImplicitCXXConstructorArgs 87 getImplicitCXXConstructorArgs(CodeGenModule &CGM, const CXXConstructorDecl *D); 88 89 llvm::Value * 90 getCXXDestructorImplicitParam(CodeGenModule &CGM, llvm::BasicBlock *InsertBlock, 91 llvm::BasicBlock::iterator InsertPoint, 92 const CXXDestructorDecl *D, CXXDtorType Type, 93 bool ForVirtualBase, bool Delegating); 94 95 /// Returns null if the function type is incomplete and can't be lowered. 96 llvm::FunctionType *convertFreeFunctionType(CodeGenModule &CGM, 97 const FunctionDecl *FD); 98 99 llvm::Type *convertTypeForMemory(CodeGenModule &CGM, QualType T); 100 101 /// Given a non-bitfield struct field, return its index within the elements of 102 /// the struct's converted type. The returned index refers to a field number in 103 /// the complete object type which is returned by convertTypeForMemory. FD must 104 /// be a field in RD directly (i.e. not an inherited field). 105 unsigned getLLVMFieldNumber(CodeGenModule &CGM, 106 const RecordDecl *RD, const FieldDecl *FD); 107 108 /// Return a declaration discriminator for the given global decl. 109 uint16_t getPointerAuthDeclDiscriminator(CodeGenModule &CGM, GlobalDecl GD); 110 111 /// Return a type discriminator for the given function type. 112 uint16_t getPointerAuthTypeDiscriminator(CodeGenModule &CGM, 113 QualType FunctionType); 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. 131 void 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. 138 llvm::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. 147 llvm::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. 157 llvm::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. 167 llvm::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. 175 llvm::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. 183 llvm::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. 192 llvm::Constant *emitObjCProtocolObject(CodeGenModule &CGM, 193 const ObjCProtocolDecl *p); 194 } // end namespace CodeGen 195 } // end namespace clang 196 197 #endif 198