clang/lib/CodeGen/CodeGenTypeCache.h

   1 //===--- CodeGenTypeCache.h - Commonly used LLVM types and info -*- C++ -*-===//
   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 // This structure provides a set of common types useful during IR emission.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef LLVM_CLANG_LIB_CODEGEN_CODEGENTYPECACHE_H
  14 #define LLVM_CLANG_LIB_CODEGEN_CODEGENTYPECACHE_H
  15
  16 #include "clang/AST/CharUnits.h"
  17 #include "clang/Basic/AddressSpaces.h"
  18 #include "llvm/IR/CallingConv.h"
  19
  20 namespace llvm {
  21   class Type;
  22   class IntegerType;
  23   class PointerType;
  24 }
  25
  26 namespace clang {
  27 namespace CodeGen {
  28
  29 /// This structure provides a set of types that are commonly used
  30 /// during IR emission.  It's initialized once in CodeGenModule's
  31 /// constructor and then copied around into new CodeGenFunctions.
  32 struct CodeGenTypeCache {
  33   /// void
  34   llvm::Type *VoidTy;
  35
  36   /// i8, i16, i32, and i64
  37   llvm::IntegerType *Int8Ty, *Int16Ty, *Int32Ty, *Int64Ty;
  38   /// half, bfloat, float, double
  39   llvm::Type *HalfTy, *BFloatTy, *FloatTy, *DoubleTy;
  40
  41   /// int
  42   llvm::IntegerType *IntTy;
  43
  44   /// char
  45   llvm::IntegerType *CharTy;
  46
  47   /// intptr_t, size_t, and ptrdiff_t, which we assume are the same size.
  48   union {
  49     llvm::IntegerType *IntPtrTy;
  50     llvm::IntegerType *SizeTy;
  51     llvm::IntegerType *PtrDiffTy;
  52   };
  53
  54   /// void*, void** in the target's default address space (often 0)
  55   union {
  56     llvm::PointerType *UnqualPtrTy;
  57     llvm::PointerType *VoidPtrTy;
  58     llvm::PointerType *Int8PtrTy;
  59     llvm::PointerType *VoidPtrPtrTy;
  60     llvm::PointerType *Int8PtrPtrTy;
  61   };
  62
  63   /// void* in alloca address space
  64   union {
  65     llvm::PointerType *AllocaVoidPtrTy;
  66     llvm::PointerType *AllocaInt8PtrTy;
  67   };
  68
  69   /// void* in default globals address space
  70   union {
  71     llvm::PointerType *GlobalsVoidPtrTy;
  72     llvm::PointerType *GlobalsInt8PtrTy;
  73   };
  74
  75   /// void* in the address space for constant globals
  76   llvm::PointerType *ConstGlobalsPtrTy;
  77
  78   /// The size and alignment of the builtin C type 'int'.  This comes
  79   /// up enough in various ABI lowering tasks to be worth pre-computing.
  80   union {
  81     unsigned char IntSizeInBytes;
  82     unsigned char IntAlignInBytes;
  83   };
  84   CharUnits getIntSize() const {
  85     return CharUnits::fromQuantity(IntSizeInBytes);
  86   }
  87   CharUnits getIntAlign() const {
  88     return CharUnits::fromQuantity(IntAlignInBytes);
  89   }
  90
  91   /// The width of a pointer into the generic address space.
  92   unsigned char PointerWidthInBits;
  93
  94   /// The size and alignment of a pointer into the generic address space.
  95   union {
  96     unsigned char PointerAlignInBytes;
  97     unsigned char PointerSizeInBytes;
  98   };
  99
 100   /// The size and alignment of size_t.
 101   union {
 102     unsigned char SizeSizeInBytes; // sizeof(size_t)
 103     unsigned char SizeAlignInBytes;
 104   };
 105
 106   LangAS ASTAllocaAddressSpace;
 107
 108   CharUnits getSizeSize() const {
 109     return CharUnits::fromQuantity(SizeSizeInBytes);
 110   }
 111   CharUnits getSizeAlign() const {
 112     return CharUnits::fromQuantity(SizeAlignInBytes);
 113   }
 114   CharUnits getPointerSize() const {
 115     return CharUnits::fromQuantity(PointerSizeInBytes);
 116   }
 117   CharUnits getPointerAlign() const {
 118     return CharUnits::fromQuantity(PointerAlignInBytes);
 119   }
 120
 121   llvm::CallingConv::ID RuntimeCC;
 122   llvm::CallingConv::ID getRuntimeCC() const { return RuntimeCC; }
 123
 124   LangAS getASTAllocaAddressSpace() const { return ASTAllocaAddressSpace; }
 125 };
 126
 127 }  // end namespace CodeGen
 128 }  // end namespace clang
 129
 130 #endif