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/CodeGen/CGFunctionInfo.h" 29 30 namespace llvm { 31 class DataLayout; 32 class Module; 33 class Function; 34 class FunctionType; 35 class Type; 36 } 37 38 namespace clang { 39 class ASTContext; 40 class CXXRecordDecl; 41 class CXXMethodDecl; 42 class CodeGenOptions; 43 class CoverageSourceInfo; 44 class DiagnosticsEngine; 45 class HeaderSearchOptions; 46 class ObjCMethodDecl; 47 class PreprocessorOptions; 48 49 namespace CodeGen { 50 class CGFunctionInfo; 51 class CodeGenModule; 52 53 const CGFunctionInfo &arrangeObjCMessageSendSignature(CodeGenModule &CGM, 54 const ObjCMethodDecl *MD, 55 QualType receiverType); 56 57 const CGFunctionInfo &arrangeFreeFunctionType(CodeGenModule &CGM, 58 CanQual<FunctionProtoType> Ty); 59 60 const CGFunctionInfo &arrangeFreeFunctionType(CodeGenModule &CGM, 61 CanQual<FunctionNoProtoType> Ty); 62 63 const CGFunctionInfo &arrangeCXXMethodType(CodeGenModule &CGM, 64 const CXXRecordDecl *RD, 65 const FunctionProtoType *FTP, 66 const CXXMethodDecl *MD); 67 68 const CGFunctionInfo &arrangeFreeFunctionCall(CodeGenModule &CGM, 69 CanQualType returnType, 70 ArrayRef<CanQualType> argTypes, 71 FunctionType::ExtInfo info, 72 RequiredArgs args); 73 74 /// Returns null if the function type is incomplete and can't be lowered. 75 llvm::FunctionType *convertFreeFunctionType(CodeGenModule &CGM, 76 const FunctionDecl *FD); 77 78 llvm::Type *convertTypeForMemory(CodeGenModule &CGM, QualType T); 79 80 /// Given a non-bitfield struct field, return its index within the elements of 81 /// the struct's converted type. The returned index refers to a field number in 82 /// the complete object type which is returned by convertTypeForMemory. FD must 83 /// be a field in RD directly (i.e. not an inherited field). 84 unsigned getLLVMFieldNumber(CodeGenModule &CGM, 85 const RecordDecl *RD, const FieldDecl *FD); 86 87 /// Returns the default constructor for a C struct with non-trivially copyable 88 /// fields, generating it if necessary. The returned function uses the `cdecl` 89 /// calling convention, returns void, and takes a single argument that is a 90 /// pointer to the address of the struct. 91 llvm::Function *getNonTrivialCStructDefaultConstructor(CodeGenModule &GCM, 92 CharUnits DstAlignment, 93 bool IsVolatile, 94 QualType QT); 95 96 /// Returns the copy constructor for a C struct with non-trivially copyable 97 /// fields, generating it if necessary. The returned function uses the `cdecl` 98 /// calling convention, returns void, and takes two arguments: pointers to the 99 /// addresses of the destination and source structs, respectively. 100 llvm::Function *getNonTrivialCStructCopyConstructor(CodeGenModule &CGM, 101 CharUnits DstAlignment, 102 CharUnits SrcAlignment, 103 bool IsVolatile, 104 QualType QT); 105 106 /// Returns the move constructor for a C struct with non-trivially copyable 107 /// fields, generating it if necessary. The returned function uses the `cdecl` 108 /// calling convention, returns void, and takes two arguments: pointers to the 109 /// addresses of the destination and source structs, respectively. 110 llvm::Function *getNonTrivialCStructMoveConstructor(CodeGenModule &CGM, 111 CharUnits DstAlignment, 112 CharUnits SrcAlignment, 113 bool IsVolatile, 114 QualType QT); 115 116 /// Returns the copy assignment operator for a C struct with non-trivially 117 /// copyable fields, generating it if necessary. The returned function uses the 118 /// `cdecl` calling convention, returns void, and takes two arguments: pointers 119 /// to the addresses of the destination and source structs, respectively. 120 llvm::Function *getNonTrivialCStructCopyAssignmentOperator( 121 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment, 122 bool IsVolatile, QualType QT); 123 124 /// Return the move assignment operator for a C struct with non-trivially 125 /// copyable fields, generating it if necessary. The returned function uses the 126 /// `cdecl` calling convention, returns void, and takes two arguments: pointers 127 /// to the addresses of the destination and source structs, respectively. 128 llvm::Function *getNonTrivialCStructMoveAssignmentOperator( 129 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment, 130 bool IsVolatile, QualType QT); 131 132 /// Returns the destructor for a C struct with non-trivially copyable fields, 133 /// generating it if necessary. The returned function uses the `cdecl` calling 134 /// convention, returns void, and takes a single argument that is a pointer to 135 /// the address of the struct. 136 llvm::Function *getNonTrivialCStructDestructor(CodeGenModule &CGM, 137 CharUnits DstAlignment, 138 bool IsVolatile, QualType QT); 139 140 } // end namespace CodeGen 141 } // end namespace clang 142 143 #endif 144