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 DataLayout; 36 class Module; 37 class Function; 38 class FunctionType; 39 class Type; 40 } 41 42 namespace clang { 43 class ASTContext; 44 class CXXConstructorDecl; 45 class CXXDestructorDecl; 46 class CXXRecordDecl; 47 class CXXMethodDecl; 48 class CodeGenOptions; 49 class CoverageSourceInfo; 50 class DiagnosticsEngine; 51 class HeaderSearchOptions; 52 class ObjCMethodDecl; 53 class ObjCProtocolDecl; 54 class PreprocessorOptions; 55 56 namespace CodeGen { 57 class CGFunctionInfo; 58 class CodeGenModule; 59 60 /// Additional implicit arguments to add to a constructor argument list. 61 struct 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 70 const CGFunctionInfo &arrangeObjCMessageSendSignature(CodeGenModule &CGM, 71 const ObjCMethodDecl *MD, 72 QualType receiverType); 73 74 const CGFunctionInfo &arrangeFreeFunctionType(CodeGenModule &CGM, 75 CanQual<FunctionProtoType> Ty); 76 77 const CGFunctionInfo &arrangeFreeFunctionType(CodeGenModule &CGM, 78 CanQual<FunctionNoProtoType> Ty); 79 80 const CGFunctionInfo &arrangeCXXMethodType(CodeGenModule &CGM, 81 const CXXRecordDecl *RD, 82 const FunctionProtoType *FTP, 83 const CXXMethodDecl *MD); 84 85 const 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. 93 ImplicitCXXConstructorArgs 94 getImplicitCXXConstructorArgs(CodeGenModule &CGM, const CXXConstructorDecl *D); 95 96 llvm::Value * 97 getCXXDestructorImplicitParam(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. 103 llvm::FunctionType *convertFreeFunctionType(CodeGenModule &CGM, 104 const FunctionDecl *FD); 105 106 llvm::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). 112 unsigned 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. 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