Home | History | Annotate | Download | only in CodeGen
      1 //==---- CodeGenABITypes.h - Convert Clang types to LLVM types for ABI -----==//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // CodeGenABITypes is a simple interface for getting LLVM types for
     11 // the parameters and the return value of a function given the Clang
     12 // types.
     13 //
     14 // The class is implemented as a public wrapper around the private
     15 // CodeGenTypes class in lib/CodeGen.
     16 //
     17 // It allows other clients, like LLDB, to determine the LLVM types that are
     18 // actually used in function calls, which makes it possible to then determine
     19 // the acutal ABI locations (e.g. registers, stack locations, etc.) that
     20 // these parameters are stored in.
     21 //
     22 //===----------------------------------------------------------------------===//
     23 
     24 #ifndef LLVM_CLANG_CODEGEN_CODEGENABITYPES_H
     25 #define LLVM_CLANG_CODEGEN_CODEGENABITYPES_H
     26 
     27 #include "clang/AST/CanonicalType.h"
     28 #include "clang/AST/Type.h"
     29 #include "clang/CodeGen/CGFunctionInfo.h"
     30 
     31 namespace llvm {
     32   class DataLayout;
     33   class Module;
     34 }
     35 
     36 namespace clang {
     37 class ASTContext;
     38 class CXXRecordDecl;
     39 class CXXMethodDecl;
     40 class CodeGenOptions;
     41 class CoverageSourceInfo;
     42 class DiagnosticsEngine;
     43 class HeaderSearchOptions;
     44 class ObjCMethodDecl;
     45 class PreprocessorOptions;
     46 
     47 namespace CodeGen {
     48 class CGFunctionInfo;
     49 class CodeGenModule;
     50 
     51 class CodeGenABITypes
     52 {
     53 public:
     54   CodeGenABITypes(ASTContext &C, llvm::Module &M,
     55                   CoverageSourceInfo *CoverageInfo = nullptr);
     56   ~CodeGenABITypes();
     57 
     58   /// These methods all forward to methods in the private implementation class
     59   /// CodeGenTypes.
     60 
     61   const CGFunctionInfo &arrangeObjCMessageSendSignature(
     62                                                      const ObjCMethodDecl *MD,
     63                                                      QualType receiverType);
     64   const CGFunctionInfo &arrangeFreeFunctionType(CanQual<FunctionProtoType> Ty,
     65                                                 const FunctionDecl *FD);
     66   const CGFunctionInfo &arrangeFreeFunctionType(
     67                                              CanQual<FunctionNoProtoType> Ty);
     68   const CGFunctionInfo &arrangeCXXMethodType(const CXXRecordDecl *RD,
     69                                              const FunctionProtoType *FTP,
     70                                              const CXXMethodDecl *MD);
     71   const CGFunctionInfo &arrangeFreeFunctionCall(CanQualType returnType,
     72                                                 ArrayRef<CanQualType> argTypes,
     73                                                 FunctionType::ExtInfo info,
     74                                                 RequiredArgs args);
     75 
     76 private:
     77   /// Default CodeGenOptions object used to initialize the
     78   /// CodeGenModule and otherwise not used. More specifically, it is
     79   /// not used in ABI type generation, so none of the options matter.
     80   std::unique_ptr<CodeGenOptions> CGO;
     81   std::unique_ptr<HeaderSearchOptions> HSO;
     82   std::unique_ptr<PreprocessorOptions> PPO;
     83 
     84   /// The CodeGenModule we use get to the CodeGenTypes object.
     85   std::unique_ptr<CodeGen::CodeGenModule> CGM;
     86 };
     87 
     88 }  // end namespace CodeGen
     89 }  // end namespace clang
     90 
     91 #endif
     92