clang  10.0.0svn
PrimType.h
Go to the documentation of this file.
1 //===--- PrimType.h - Types for the constexpr VM --------------------*- 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 // Defines the VM types and helpers operating on types.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_CLANG_AST_INTERP_TYPE_H
14 #define LLVM_CLANG_AST_INTERP_TYPE_H
15 
16 #include <climits>
17 #include <cstddef>
18 #include <cstdint>
19 #include "Boolean.h"
20 #include "Integral.h"
21 #include "Pointer.h"
22 
23 namespace clang {
24 namespace interp {
25 
26 /// Enumeration of the primitive types of the VM.
27 enum PrimType : unsigned {
38 };
39 
40 /// Mapping from primitive types to their representation.
41 template <PrimType T> struct PrimConv;
42 template <> struct PrimConv<PT_Sint8> { using T = Integral<8, true>; };
43 template <> struct PrimConv<PT_Uint8> { using T = Integral<8, false>; };
44 template <> struct PrimConv<PT_Sint16> { using T = Integral<16, true>; };
45 template <> struct PrimConv<PT_Uint16> { using T = Integral<16, false>; };
46 template <> struct PrimConv<PT_Sint32> { using T = Integral<32, true>; };
47 template <> struct PrimConv<PT_Uint32> { using T = Integral<32, false>; };
48 template <> struct PrimConv<PT_Sint64> { using T = Integral<64, true>; };
49 template <> struct PrimConv<PT_Uint64> { using T = Integral<64, false>; };
50 template <> struct PrimConv<PT_Bool> { using T = Boolean; };
51 template <> struct PrimConv<PT_Ptr> { using T = Pointer; };
52 
53 /// Returns the size of a primitive type in bytes.
54 size_t primSize(PrimType Type);
55 
56 /// Aligns a size to the pointer alignment.
57 constexpr size_t align(size_t Size) {
58  return ((Size + alignof(void *) - 1) / alignof(void *)) * alignof(void *);
59 }
60 
61 inline bool isPrimitiveIntegral(PrimType Type) {
62  switch (Type) {
63  case PT_Bool:
64  case PT_Sint8:
65  case PT_Uint8:
66  case PT_Sint16:
67  case PT_Uint16:
68  case PT_Sint32:
69  case PT_Uint32:
70  case PT_Sint64:
71  case PT_Uint64:
72  return true;
73  default:
74  return false;
75  }
76 }
77 
78 } // namespace interp
79 } // namespace clang
80 
81 /// Helper macro to simplify type switches.
82 /// The macro implicitly exposes a type T in the scope of the inner block.
83 #define TYPE_SWITCH_CASE(Name, B) \
84  case Name: { using T = PrimConv<Name>::T; do {B;} while(0); break; }
85 #define TYPE_SWITCH(Expr, B) \
86  switch (Expr) { \
87  TYPE_SWITCH_CASE(PT_Sint8, B) \
88  TYPE_SWITCH_CASE(PT_Uint8, B) \
89  TYPE_SWITCH_CASE(PT_Sint16, B) \
90  TYPE_SWITCH_CASE(PT_Uint16, B) \
91  TYPE_SWITCH_CASE(PT_Sint32, B) \
92  TYPE_SWITCH_CASE(PT_Uint32, B) \
93  TYPE_SWITCH_CASE(PT_Sint64, B) \
94  TYPE_SWITCH_CASE(PT_Uint64, B) \
95  TYPE_SWITCH_CASE(PT_Bool, B) \
96  TYPE_SWITCH_CASE(PT_Ptr, B) \
97  }
98 #define COMPOSITE_TYPE_SWITCH(Expr, B, D) \
99  switch (Expr) { \
100  TYPE_SWITCH_CASE(PT_Ptr, B) \
101  default: do { D; } while(0); break; \
102  }
103 #define INT_TYPE_SWITCH(Expr, B) \
104  switch (Expr) { \
105  TYPE_SWITCH_CASE(PT_Sint8, B) \
106  TYPE_SWITCH_CASE(PT_Uint8, B) \
107  TYPE_SWITCH_CASE(PT_Sint16, B) \
108  TYPE_SWITCH_CASE(PT_Uint16, B) \
109  TYPE_SWITCH_CASE(PT_Sint32, B) \
110  TYPE_SWITCH_CASE(PT_Uint32, B) \
111  TYPE_SWITCH_CASE(PT_Sint64, B) \
112  TYPE_SWITCH_CASE(PT_Uint64, B) \
113  default: llvm_unreachable("not an integer"); \
114  }
115 #endif
size_t primSize(PrimType Type)
Returns the size of a primitive type in bytes.
Definition: PrimType.cpp:17
bool isPrimitiveIntegral(PrimType Type)
Definition: PrimType.h:61
Mapping from primitive types to their representation.
Definition: PrimType.h:41
Wrapper around numeric types.
Definition: Integral.h:56
Wrapper around boolean types.
Definition: Boolean.h:25
The base class of the type hierarchy.
Definition: Type.h:1436
constexpr size_t align(size_t Size)
Aligns a size to the pointer alignment.
Definition: PrimType.h:57
A pointer to a memory block, live or dead.
Definition: Pointer.h:39
PrimType
Enumeration of the primitive types of the VM.
Definition: PrimType.h:27
Dataflow Directional Tag Classes.