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
20namespace llvm {
21 class Type;
22 class IntegerType;
23 class PointerType;
24}
25
26namespace clang {
27namespace 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.
32struct 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 address space 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(Quantity: IntSizeInBytes);
86 }
87 CharUnits getIntAlign() const {
88 return CharUnits::fromQuantity(Quantity: 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(Quantity: SizeSizeInBytes);
110 }
111 CharUnits getSizeAlign() const {
112 return CharUnits::fromQuantity(Quantity: SizeAlignInBytes);
113 }
114 CharUnits getPointerSize() const {
115 return CharUnits::fromQuantity(Quantity: PointerSizeInBytes);
116 }
117 CharUnits getPointerAlign() const {
118 return CharUnits::fromQuantity(Quantity: 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
131

source code of clang/lib/CodeGen/CodeGenTypeCache.h