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 { 28 PT_Sint8, 29 PT_Uint8, 30 PT_Sint16, 31 PT_Uint16, 32 PT_Sint32, 33 PT_Uint32, 34 PT_Sint64, 35 PT_Uint64, 36 PT_Bool, 37 PT_Ptr, 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; B; break; } 85 #define TYPE_SWITCH(Expr, B) \ 86 do { \ 87 switch (Expr) { \ 88 TYPE_SWITCH_CASE(PT_Sint8, B) \ 89 TYPE_SWITCH_CASE(PT_Uint8, B) \ 90 TYPE_SWITCH_CASE(PT_Sint16, B) \ 91 TYPE_SWITCH_CASE(PT_Uint16, B) \ 92 TYPE_SWITCH_CASE(PT_Sint32, B) \ 93 TYPE_SWITCH_CASE(PT_Uint32, B) \ 94 TYPE_SWITCH_CASE(PT_Sint64, B) \ 95 TYPE_SWITCH_CASE(PT_Uint64, B) \ 96 TYPE_SWITCH_CASE(PT_Bool, B) \ 97 TYPE_SWITCH_CASE(PT_Ptr, B) \ 98 } \ 99 } while (0) 100 #define COMPOSITE_TYPE_SWITCH(Expr, B, D) \ 101 do { \ 102 switch (Expr) { \ 103 TYPE_SWITCH_CASE(PT_Ptr, B) \ 104 default: { D; break; } \ 105 } \ 106 } while (0) 107 #endif 108