Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/lib/CodeGen/CodeGenTypeCache.h
Line
Count
Source
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
  /// float, double
39
  llvm::Type *HalfTy, *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
3.68k
  CharUnits getIntSize() const {
76
3.68k
    return CharUnits::fromQuantity(IntSizeInBytes);
77
3.68k
  }
78
83
  CharUnits getIntAlign() const {
79
83
    return CharUnits::fromQuantity(IntAlignInBytes);
80
83
  }
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
  LangAS ASTAllocaAddressSpace;
98
99
106
  CharUnits getSizeSize() const {
100
106
    return CharUnits::fromQuantity(SizeSizeInBytes);
101
106
  }
102
918
  CharUnits getSizeAlign() const {
103
918
    return CharUnits::fromQuantity(SizeAlignInBytes);
104
918
  }
105
6.73k
  CharUnits getPointerSize() const {
106
6.73k
    return CharUnits::fromQuantity(PointerSizeInBytes);
107
6.73k
  }
108
72.1k
  CharUnits getPointerAlign() const {
109
72.1k
    return CharUnits::fromQuantity(PointerAlignInBytes);
110
72.1k
  }
111
112
  llvm::CallingConv::ID RuntimeCC;
113
147k
  llvm::CallingConv::ID getRuntimeCC() const { return RuntimeCC; }
114
115
1.50M
  LangAS getASTAllocaAddressSpace() const { return ASTAllocaAddressSpace; }
116
};
117
118
}  // end namespace CodeGen
119
}  // end namespace clang
120
121
#endif