contrib/llvm/tools/clang/lib/CodeGen/CodeGenTypeCache.h

   1 //===--- CodeGenTypeCache.h - Commonly used LLVM types and info -*- C++ -*-===//
   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 // This structure provides a set of common types useful during IR emission.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_LIB_CODEGEN_CODEGENTYPECACHE_H
  15 #define LLVM_CLANG_LIB_CODEGEN_CODEGENTYPECACHE_H
  16
  17 #include "clang/AST/CharUnits.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   /// float, double
  39   llvm::Type *FloatTy, *DoubleTy;
  40
  41   /// int
  42   llvm::IntegerType *IntTy;
  43
  44   /// intptr_t, size_t, and ptrdiff_t, which we assume are the same size.
  45   union {
  46     llvm::IntegerType *IntPtrTy;
  47     llvm::IntegerType *SizeTy;
  48     llvm::IntegerType *PtrDiffTy;
  49   };
  50
  51   /// void* in address space 0
  52   union {
  53     llvm::PointerType *VoidPtrTy;
  54     llvm::PointerType *Int8PtrTy;
  55   };
  56
  57   /// void** in address space 0
  58   union {
  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   /// The size and alignment of the builtin C type 'int'.  This comes
  70   /// up enough in various ABI lowering tasks to be worth pre-computing.
  71   union {
  72     unsigned char IntSizeInBytes;
  73     unsigned char IntAlignInBytes;
  74   };
  75   CharUnits getIntSize() const {
  76     return CharUnits::fromQuantity(IntSizeInBytes);
  77   }
  78   CharUnits getIntAlign() const {
  79     return CharUnits::fromQuantity(IntAlignInBytes);
  80   }
  81
  82   /// The width of a pointer into the generic address space.
  83   unsigned char PointerWidthInBits;
  84
  85   /// The size and alignment of a pointer into the generic address space.
  86   union {
  87     unsigned char PointerAlignInBytes;
  88     unsigned char PointerSizeInBytes;
  89   };
  90
  91   /// The size and alignment of size_t.
  92   union {
  93     unsigned char SizeSizeInBytes; // sizeof(size_t)
  94     unsigned char SizeAlignInBytes;
  95   };
  96
  97   CharUnits getSizeSize() const {
  98     return CharUnits::fromQuantity(SizeSizeInBytes);
  99   }
 100   CharUnits getSizeAlign() const {
 101     return CharUnits::fromQuantity(SizeAlignInBytes);
 102   }
 103   CharUnits getPointerSize() const {
 104     return CharUnits::fromQuantity(PointerSizeInBytes);
 105   }
 106   CharUnits getPointerAlign() const {
 107     return CharUnits::fromQuantity(PointerAlignInBytes);
 108   }
 109
 110   llvm::CallingConv::ID RuntimeCC;
 111   llvm::CallingConv::ID getRuntimeCC() const { return RuntimeCC; }
 112   llvm::CallingConv::ID BuiltinCC;
 113   llvm::CallingConv::ID getBuiltinCC() const { return BuiltinCC; }
 114 };
 115
 116 }  // end namespace CodeGen
 117 }  // end namespace clang
 118
 119 #endif