Halide 17.0.1
Halide compiler and libraries
Loading...
Searching...
No Matches
Type.h
Go to the documentation of this file.
1#ifndef HALIDE_TYPE_H
2#define HALIDE_TYPE_H
3
4#include "Error.h"
5#include "Float16.h"
6#include "Util.h"
8#include <cstdint>
9
10/** \file
11 * Defines halide types
12 */
13
14/** A set of types to represent a C++ function signature. This allows
15 * two things. First, proper prototypes can be provided for Halide
16 * generated functions, giving better compile time type
17 * checking. Second, C++ name mangling can be done to provide link
18 * time type checking for both Halide generated functions and calls
19 * from Halide to external functions.
20 *
21 * These are intended to be constexpr producable.
22 *
23 * halide_handle_traits has to go outside the Halide namespace due to template
24 * resolution rules. TODO(zalman): Do all types need to be in global namespace?
25 */
26//@{
27
28/** A structure to represent the (unscoped) name of a C++ composite type for use
29 * as a single argument (or return value) in a function signature.
30 *
31 * Currently does not support the restrict qualifier, references, or
32 * r-value references. These features cannot be used in extern
33 * function calls from Halide or in the generated function from
34 * Halide, but their applicability seems limited anyway.
35 *
36 * Although this is in the global namespace, it should be considered "Halide Internal"
37 * and subject to change; code outside Halide should avoid referencing it.
38 */
40 /// An enum to indicate whether a C++ type is non-composite, a struct, class, or union
42 Simple, ///< "int"
43 Struct, ///< "struct Foo"
44 Class, ///< "class Foo"
45 Union, ///< "union Foo"
46 Enum, ///< "enum Foo"
47 } cpp_type_type; // Note: order is reflected in map_to_name table in CPlusPlusMangle.cpp
48
49 std::string name;
50
54
55 bool operator==(const halide_cplusplus_type_name &rhs) const {
56 return cpp_type_type == rhs.cpp_type_type &&
57 name == rhs.name;
58 }
59
60 bool operator!=(const halide_cplusplus_type_name &rhs) const {
61 return !(*this == rhs);
62 }
63
64 bool operator<(const halide_cplusplus_type_name &rhs) const {
65 return cpp_type_type < rhs.cpp_type_type ||
67 name < rhs.name);
68 }
69};
70
71/** A structure to represent the fully scoped name of a C++ composite
72 * type for use in generating function signatures that use that type.
73 *
74 * This is intended to be a constexpr usable type.
75 *
76 * Although this is in the global namespace, it should be considered "Halide Internal"
77 * and subject to change; code outside Halide should avoid referencing it.
78 */
81 std::vector<std::string> namespaces;
82 std::vector<halide_cplusplus_type_name> enclosing_types;
83
84 /// One set of modifiers on a type.
85 /// The const/volatile/restrict properties are "inside" the pointer property.
87 Const = 1 << 0, ///< Bitmask flag for "const"
88 Volatile = 1 << 1, ///< Bitmask flag for "volatile"
89 Restrict = 1 << 2, ///< Bitmask flag for "restrict"
90 Pointer = 1 << 3, ///< Bitmask flag for a pointer "*"
91 FunctionTypedef = 1 << 4, ///< Bitmask flag for a function typedef; when this is set, Pointer should also always be set
92 };
93
94 /// Qualifiers and indirections on type. 0 is innermost.
95 std::vector<uint8_t> cpp_type_modifiers;
96
97 /// References are separate because they only occur at the outermost level.
98 /// No modifiers are needed for references as they are not allowed to apply
99 /// to the reference itself. (This isn't true for restrict, but that is a C++
100 /// extension anyway.) If modifiers are needed, the last entry in the above
101 /// array would be the modifers for the reference.
104 LValueReference = 1, // "&"
105 RValueReference = 2, // "&&"
106 };
108
110 const std::vector<std::string> &namespaces = {},
111 const std::vector<halide_cplusplus_type_name> &enclosing_types = {},
112 const std::vector<uint8_t> &modifiers = {},
117 cpp_type_modifiers(modifiers),
119 }
120
121 template<typename T>
123};
124//@}
125
126/** halide_c_type_to_name is a utility class used to provide a user-extensible
127 * way of naming Handle types.
128 *
129 * Although this is in the global namespace, it should be considered "Halide Internal"
130 * and subject to change; code outside Halide should avoid referencing it
131 * directly (use the HALIDE_DECLARE_EXTERN_xxx macros instead).
132 */
133template<typename T>
135 static constexpr bool known_type = false;
139};
140
141#define HALIDE_DECLARE_EXTERN_TYPE(TypeType, Type) \
142 template<> \
143 struct halide_c_type_to_name<Type> { \
144 static constexpr bool known_type = true; \
145 static halide_cplusplus_type_name name() { \
146 return {halide_cplusplus_type_name::TypeType, #Type}; \
147 } \
148 }
149
150#define HALIDE_DECLARE_EXTERN_SIMPLE_TYPE(T) HALIDE_DECLARE_EXTERN_TYPE(Simple, T)
151#define HALIDE_DECLARE_EXTERN_STRUCT_TYPE(T) HALIDE_DECLARE_EXTERN_TYPE(Struct, T)
152#define HALIDE_DECLARE_EXTERN_CLASS_TYPE(T) HALIDE_DECLARE_EXTERN_TYPE(Class, T)
153#define HALIDE_DECLARE_EXTERN_UNION_TYPE(T) HALIDE_DECLARE_EXTERN_TYPE(Union, T)
154
178
179// You can make arbitrary user-defined types be "Known" using the
180// macro above. This is useful for making Param<> arguments for
181// Generators type safe. e.g.,
182//
183// struct MyFunStruct { ... };
184//
185// ...
186//
187// HALIDE_DECLARE_EXTERN_STRUCT_TYPE(MyFunStruct);
188//
189// ...
190//
191// class MyGenerator : public Generator<MyGenerator> {
192// Param<const MyFunStruct *> my_struct_ptr;
193// ...
194// };
195
196template<typename T>
198 constexpr bool is_ptr = std::is_pointer<T>::value;
199 constexpr bool is_lvalue_reference = std::is_lvalue_reference<T>::value;
200 constexpr bool is_rvalue_reference = std::is_rvalue_reference<T>::value;
201
202 using TNoRef = typename std::remove_reference<T>::type;
203 using TNoRefNoPtr = typename std::remove_pointer<TNoRef>::type;
204 constexpr bool is_function_pointer = std::is_pointer<TNoRef>::value &&
205 std::is_function<TNoRefNoPtr>::value;
206
207 // Don't remove the pointer-ness from a function pointer.
208 using TBase = typename std::conditional<is_function_pointer, TNoRef, TNoRefNoPtr>::type;
209 constexpr bool is_const = std::is_const<TBase>::value;
210 constexpr bool is_volatile = std::is_volatile<TBase>::value;
211
212 constexpr uint8_t modifiers = static_cast<uint8_t>(
213 (is_function_pointer ? halide_handle_cplusplus_type::FunctionTypedef : 0) |
215 (is_const ? halide_handle_cplusplus_type::Const : 0) |
216 (is_volatile ? halide_handle_cplusplus_type::Volatile : 0));
217
218 // clang-format off
220 (is_lvalue_reference ? halide_handle_cplusplus_type::LValueReference :
223 // clang-format on
224
225 using TNonCVBase = typename std::remove_cv<TBase>::type;
226 constexpr bool known_type = halide_c_type_to_name<TNonCVBase>::known_type;
227 static_assert(!(!known_type && !is_ptr), "Unknown types must be pointers");
228
231 {},
232 {},
233 {modifiers},
234 ref_type};
235 // Pull off any namespaces
237 return info;
238}
239
240/** A type traits template to provide a halide_handle_cplusplus_type
241 * value from a C++ type.
242 *
243 * Note the type represented is implicitly a pointer.
244 *
245 * A NULL pointer of type halide_handle_traits represents "void *".
246 * This is chosen for compactness or representation as Type is a very
247 * widely used data structure.
248 *
249 * Although this is in the global namespace, it should be considered "Halide Internal"
250 * and subject to change; code outside Halide should avoid referencing it directly.
251 */
252template<typename T>
254 // This trait must return a pointer to a global structure. I.e. it should never be freed.
255 // A return value of nullptr here means "void *".
257 if (std::is_pointer<T>::value ||
258 std::is_lvalue_reference<T>::value ||
259 std::is_rvalue_reference<T>::value) {
260 static const halide_handle_cplusplus_type the_info = halide_handle_cplusplus_type::make<T>();
261 return &the_info;
262 }
263 return nullptr;
264 }
265};
266
267namespace Halide {
268
269struct Expr;
270
271/** Types in the halide type system. They can be ints, unsigned ints,
272 * or floats of various bit-widths (the 'bits' field). They can also
273 * be vectors of the same (by setting the 'lanes' field to something
274 * larger than one). Front-end code shouldn't use vector
275 * types. Instead vectorize a function. */
276struct Type {
277private:
278 halide_type_t type;
279
280public:
281 /** Aliases for halide_type_code_t values for legacy compatibility
282 * and to match the Halide internal C++ style. */
283 // @{
289 // @}
290
291 /** The number of bytes required to store a single scalar value of this type. Ignores vector lanes. */
292 int bytes() const {
293 return (bits() + 7) / 8;
294 }
295
296 // Default ctor initializes everything to predictable-but-unlikely values
298 : type(Handle, 0, 0) {
299 }
300
301 /** Construct a runtime representation of a Halide type from:
302 * code: The fundamental type from an enum.
303 * bits: The bit size of one element.
304 * lanes: The number of vector elements in the type. */
307 user_assert(lanes == type.lanes)
308 << "Halide only supports vector types with up to 65535 lanes. " << lanes << " lanes requested.";
309 user_assert(bits == type.bits)
310 << "Halide only supports types with up to 255 bits. " << bits << " bits requested.";
311 }
312
313 /** Trivial copy constructor. */
314 Type(const Type &that) = default;
315
316 /** Trivial copy assignment operator. */
317 Type &operator=(const Type &that) = default;
318
319 /** Type is a wrapper around halide_type_t with more methods for use
320 * inside the compiler. This simply constructs the wrapper around
321 * the runtime value. */
326
327 /** Unwrap the runtime halide_type_t for use in runtime calls, etc.
328 * Representation is exactly equivalent. */
330 operator halide_type_t() const {
331 return type;
332 }
333
334 /** Return the underlying data type of an element as an enum value. */
337 return (halide_type_code_t)type.code;
338 }
339
340 /** Return the bit size of a single element of this type. */
342 int bits() const {
343 return type.bits;
344 }
345
346 /** Return the number of vector elements in this type. */
348 int lanes() const {
349 return type.lanes;
350 }
351
352 /** Return Type with same number of bits and lanes, but new_code for a type code. */
354 return Type(new_code, bits(), lanes(),
355 (new_code == code()) ? handle_type : nullptr);
356 }
357
358 /** Return Type with same type code and lanes, but new_bits for the number of bits. */
360 return Type(code(), new_bits, lanes(),
361 (new_bits == bits()) ? handle_type : nullptr);
362 }
363
364 /** Return Type with same type code and number of bits,
365 * but new_lanes for the number of vector lanes. */
367 return Type(code(), bits(), new_lanes, handle_type);
368 }
369
370 /** Return Type with the same type code and number of lanes, but with at least twice as many bits. */
371 Type widen() const {
372 if (bits() == 1) {
373 // Widening a 1-bit type should produce an 8-bit type.
374 return with_bits(8);
375 } else {
376 return with_bits(bits() * 2);
377 }
378 }
379
380 /** Return Type with the same type code and number of lanes, but with at most half as many bits. */
381 Type narrow() const {
382 internal_assert(bits() != 1) << "Attempting to narrow a 1-bit type\n";
383 if (bits() == 8) {
384 // Narrowing an 8-bit type should produce a 1-bit type.
385 return with_bits(1);
386 } else {
387 return with_bits(bits() / 2);
388 }
389 }
390
391 /** Type to be printed when declaring handles of this type. */
393
394 /** Is this type boolean (represented as UInt(1))? */
396 bool is_bool() const {
397 return code() == UInt && bits() == 1;
398 }
399
400 /** Is this type a vector type? (lanes() != 1).
401 * TODO(abadams): Decide what to do for lanes() == 0. */
403 bool is_vector() const {
404 return lanes() != 1;
405 }
406
407 /** Is this type a scalar type? (lanes() == 1).
408 * TODO(abadams): Decide what to do for lanes() == 0. */
410 bool is_scalar() const {
411 return lanes() == 1;
412 }
413
414 /** Is this type a floating point type (float or double). */
416 bool is_float() const {
417 return code() == Float || code() == BFloat;
418 }
419
420 /** Is this type a floating point type (float or double). */
422 bool is_bfloat() const {
423 return code() == BFloat;
424 }
425
426 /** Is this type a signed integer type? */
428 bool is_int() const {
429 return code() == Int;
430 }
431
432 /** Is this type an unsigned integer type? */
434 bool is_uint() const {
435 return code() == UInt;
436 }
437
438 /** Is this type an integer type of any sort? */
440 bool is_int_or_uint() const {
441 return code() == Int || code() == UInt;
442 }
443
444 /** Is this type an opaque handle type (void *) */
446 bool is_handle() const {
447 return code() == Handle;
448 }
449
450 // Returns true iff type is a signed integral type where overflow is defined.
452 bool can_overflow_int() const {
453 return is_int() && bits() <= 16;
454 }
455
456 // Returns true iff type does have a well-defined overflow behavior.
458 bool can_overflow() const {
459 return is_uint() || can_overflow_int();
460 }
461
462 /** Check that the type name of two handles matches. */
463 bool same_handle_type(const Type &other) const;
464
465 /** Compare two types for equality */
466 bool operator==(const Type &other) const {
467 return type == other.type && (code() != Handle || same_handle_type(other));
468 }
469
470 /** Compare two types for inequality */
471 bool operator!=(const Type &other) const {
472 return type != other.type || (code() == Handle && !same_handle_type(other));
473 }
474
475 /** Compare two types for equality */
476 bool operator==(const halide_type_t &other) const {
477 return type == other;
478 }
479
480 /** Compare two types for inequality */
481 bool operator!=(const halide_type_t &other) const {
482 return type != other;
483 }
484
485 /** Compare ordering of two types so they can be used in certain containers and algorithms */
486 bool operator<(const Type &other) const {
487 if (type < other.type) {
488 return true;
489 }
490 if (code() == Handle) {
491 return handle_type < other.handle_type;
492 }
493 return false;
494 }
495
496 /** Produce the scalar type (that of a single element) of this vector type */
497 Type element_of() const {
498 return with_lanes(1);
499 }
500
501 /** Can this type represent all values of another type? */
503
504 /** Can this type represent a particular constant? */
505 // @{
506 bool can_represent(double x) const;
507 bool can_represent(int64_t x) const;
508 bool can_represent(uint64_t x) const;
509 // @}
510
511 /** Check if an integer constant value is the maximum or minimum
512 * representable value for this type. */
513 // @{
514 bool is_max(uint64_t) const;
515 bool is_max(int64_t) const;
516 bool is_min(uint64_t) const;
517 bool is_min(int64_t) const;
518 // @}
519
520 /** Return an expression which is the maximum value of this type.
521 * Returns infinity for types which can represent it. */
522 Expr max() const;
523
524 /** Return an expression which is the minimum value of this type.
525 * Returns -infinity for types which can represent it. */
526 Expr min() const;
527};
528
529/** Constructing a signed integer type */
530inline Type Int(int bits, int lanes = 1) {
531 return Type(Type::Int, bits, lanes);
532}
533
534/** Constructing an unsigned integer type */
535inline Type UInt(int bits, int lanes = 1) {
536 return Type(Type::UInt, bits, lanes);
537}
538
539/** Construct a floating-point type */
540inline Type Float(int bits, int lanes = 1) {
541 return Type(Type::Float, bits, lanes);
542}
543
544/** Construct a floating-point type in the bfloat format. Only 16-bit currently supported. */
545inline Type BFloat(int bits, int lanes = 1) {
546 return Type(Type::BFloat, bits, lanes);
547}
548
549/** Construct a boolean type */
550inline Type Bool(int lanes = 1) {
551 return UInt(1, lanes);
552}
553
554/** Construct a handle type */
555inline Type Handle(int lanes = 1, const halide_handle_cplusplus_type *handle_type = nullptr) {
556 return Type(Type::Handle, 64, lanes, handle_type);
557}
558
559/** Construct the halide equivalent of a C type */
560template<typename T>
564
565/** Halide type to a C++ type */
566std::string type_to_c_type(Type type, bool include_space, bool c_plus_plus = true);
567
568} // namespace Halide
569
570#endif
#define internal_assert(c)
Definition Errors.h:19
This file declares the routines used by Halide internally in its runtime.
int(* halide_task_t)(void *user_context, int task_number, uint8_t *closure)
Define halide_do_par_for to replace the default thread pool implementation.
halide_type_code_t
Types in the halide type system.
@ halide_type_float
IEEE floating point numbers.
@ halide_type_handle
opaque pointer type (void *)
@ halide_type_bfloat
floating point numbers in the bfloat format
@ halide_type_int
signed integers
@ halide_type_uint
unsigned integers
int(* halide_loop_task_t)(void *user_context, int min, int extent, uint8_t *closure, void *task_parent)
A task representing a serial for loop evaluated over some range.
#define HALIDE_ALWAYS_INLINE
#define HALIDE_DECLARE_EXTERN_STRUCT_TYPE(T)
Definition Type.h:151
#define HALIDE_DECLARE_EXTERN_SIMPLE_TYPE(T)
Definition Type.h:150
Various utility functions used internally Halide.
std::string extract_namespaces(const std::string &name, std::vector< std::string > &namespaces)
Returns base name and fills in namespaces, outermost one first in vector.
This file defines the class FunctionDAG, which is our representation of a Halide pipeline,...
std::string type_to_c_type(Type type, bool include_space, bool c_plus_plus=true)
Halide type to a C++ type.
Type BFloat(int bits, int lanes=1)
Construct a floating-point type in the bfloat format.
Definition Type.h:545
Type UInt(int bits, int lanes=1)
Constructing an unsigned integer type.
Definition Type.h:535
Type Float(int bits, int lanes=1)
Construct a floating-point type.
Definition Type.h:540
Type type_of()
Construct the halide equivalent of a C type.
Definition Type.h:561
Expr cast(Expr a)
Cast an expression to the halide type corresponding to the C++ type T.
Definition IROperator.h:364
Type Int(int bits, int lanes=1)
Constructing a signed integer type.
Definition Type.h:530
Type Handle(int lanes=1, const halide_handle_cplusplus_type *handle_type=nullptr)
Construct a handle type.
Definition Type.h:555
Type Bool(int lanes=1)
Construct a boolean type.
Definition Type.h:550
unsigned __INT64_TYPE__ uint64_t
signed __INT64_TYPE__ int64_t
signed __INT32_TYPE__ int32_t
unsigned __INT8_TYPE__ uint8_t
unsigned __INT16_TYPE__ uint16_t
unsigned __INT32_TYPE__ uint32_t
signed __INT16_TYPE__ int16_t
signed __INT8_TYPE__ int8_t
A fragment of Halide syntax.
Definition Expr.h:258
HALIDE_ALWAYS_INLINE Type type() const
Get the type of this expression node.
Definition Expr.h:322
Types in the halide type system.
Definition Type.h:276
HALIDE_ALWAYS_INLINE halide_type_code_t code() const
Return the underlying data type of an element as an enum value.
Definition Type.h:336
static const halide_type_code_t Float
Definition Type.h:286
Type widen() const
Return Type with the same type code and number of lanes, but with at least twice as many bits.
Definition Type.h:371
Type(halide_type_code_t code, int bits, int lanes, const halide_handle_cplusplus_type *handle_type=nullptr)
Construct a runtime representation of a Halide type from: code: The fundamental type from an enum.
Definition Type.h:305
Type element_of() const
Produce the scalar type (that of a single element) of this vector type.
Definition Type.h:497
bool is_max(uint64_t) const
Check if an integer constant value is the maximum or minimum representable value for this type.
static const halide_type_code_t Int
Aliases for halide_type_code_t values for legacy compatibility and to match the Halide internal C++ s...
Definition Type.h:284
Type with_bits(int new_bits) const
Return Type with same type code and lanes, but new_bits for the number of bits.
Definition Type.h:359
HALIDE_ALWAYS_INLINE bool is_int() const
Is this type a signed integer type?
Definition Type.h:428
Expr min() const
Return an expression which is the minimum value of this type.
bool operator!=(const Type &other) const
Compare two types for inequality.
Definition Type.h:471
HALIDE_ALWAYS_INLINE int lanes() const
Return the number of vector elements in this type.
Definition Type.h:348
HALIDE_ALWAYS_INLINE bool is_uint() const
Is this type an unsigned integer type?
Definition Type.h:434
HALIDE_ALWAYS_INLINE bool is_bool() const
Is this type boolean (represented as UInt(1))?
Definition Type.h:396
Type with_lanes(int new_lanes) const
Return Type with same type code and number of bits, but new_lanes for the number of vector lanes.
Definition Type.h:366
HALIDE_ALWAYS_INLINE Type(const halide_type_t &that, const halide_handle_cplusplus_type *handle_type=nullptr)
Type is a wrapper around halide_type_t with more methods for use inside the compiler.
Definition Type.h:323
static const halide_type_code_t BFloat
Definition Type.h:287
bool operator<(const Type &other) const
Compare ordering of two types so they can be used in certain containers and algorithms.
Definition Type.h:486
Type(const Type &that)=default
Trivial copy constructor.
HALIDE_ALWAYS_INLINE int bits() const
Return the bit size of a single element of this type.
Definition Type.h:342
HALIDE_ALWAYS_INLINE bool can_overflow_int() const
Definition Type.h:452
bool operator!=(const halide_type_t &other) const
Compare two types for inequality.
Definition Type.h:481
bool same_handle_type(const Type &other) const
Check that the type name of two handles matches.
HALIDE_ALWAYS_INLINE bool is_int_or_uint() const
Is this type an integer type of any sort?
Definition Type.h:440
static const halide_type_code_t UInt
Definition Type.h:285
HALIDE_ALWAYS_INLINE bool is_vector() const
Is this type a vector type? (lanes() != 1).
Definition Type.h:403
HALIDE_ALWAYS_INLINE bool is_bfloat() const
Is this type a floating point type (float or double).
Definition Type.h:422
const halide_handle_cplusplus_type * handle_type
Type to be printed when declaring handles of this type.
Definition Type.h:392
int bytes() const
The number of bytes required to store a single scalar value of this type.
Definition Type.h:292
bool is_max(int64_t) const
bool can_represent(Type other) const
Can this type represent all values of another type?
bool is_min(int64_t) const
bool operator==(const Type &other) const
Compare two types for equality.
Definition Type.h:466
HALIDE_ALWAYS_INLINE bool can_overflow() const
Definition Type.h:458
Type with_code(halide_type_code_t new_code) const
Return Type with same number of bits and lanes, but new_code for a type code.
Definition Type.h:353
Type & operator=(const Type &that)=default
Trivial copy assignment operator.
static const halide_type_code_t Handle
Definition Type.h:288
bool can_represent(double x) const
Can this type represent a particular constant?
Type narrow() const
Return Type with the same type code and number of lanes, but with at most half as many bits.
Definition Type.h:381
HALIDE_ALWAYS_INLINE bool is_handle() const
Is this type an opaque handle type (void *)
Definition Type.h:446
bool can_represent(int64_t x) const
bool is_min(uint64_t) const
bool can_represent(uint64_t x) const
bool operator==(const halide_type_t &other) const
Compare two types for equality.
Definition Type.h:476
HALIDE_ALWAYS_INLINE bool is_scalar() const
Is this type a scalar type? (lanes() == 1).
Definition Type.h:410
Expr max() const
Return an expression which is the maximum value of this type.
HALIDE_ALWAYS_INLINE bool is_float() const
Is this type a floating point type (float or double).
Definition Type.h:416
Class that provides a type that implements half precision floating point (IEEE754 2008 binary16) in s...
Definition Float16.h:17
The raw representation of an image passed around by generated Halide code.
halide_c_type_to_name is a utility class used to provide a user-extensible way of naming Handle types...
Definition Type.h:134
static constexpr bool known_type
Definition Type.h:135
static halide_cplusplus_type_name name()
Definition Type.h:136
A set of types to represent a C++ function signature.
Definition Type.h:39
bool operator<(const halide_cplusplus_type_name &rhs) const
Definition Type.h:64
bool operator==(const halide_cplusplus_type_name &rhs) const
Definition Type.h:55
enum halide_cplusplus_type_name::CPPTypeType cpp_type_type
halide_cplusplus_type_name(CPPTypeType cpp_type_type, const std::string &name)
Definition Type.h:51
bool operator!=(const halide_cplusplus_type_name &rhs) const
Definition Type.h:60
CPPTypeType
An enum to indicate whether a C++ type is non-composite, a struct, class, or union.
Definition Type.h:41
@ Class
"class Foo"
Definition Type.h:44
@ Union
"union Foo"
Definition Type.h:45
@ Struct
"struct Foo"
Definition Type.h:43
Each GPU API provides a halide_device_interface_t struct pointing to the code that manages device all...
A structure to represent the fully scoped name of a C++ composite type for use in generating function...
Definition Type.h:79
ReferenceType reference_type
Definition Type.h:107
halide_cplusplus_type_name inner_name
Definition Type.h:80
static halide_handle_cplusplus_type make()
Definition Type.h:197
ReferenceType
References are separate because they only occur at the outermost level.
Definition Type.h:102
halide_handle_cplusplus_type(const halide_cplusplus_type_name &inner_name, const std::vector< std::string > &namespaces={}, const std::vector< halide_cplusplus_type_name > &enclosing_types={}, const std::vector< uint8_t > &modifiers={}, ReferenceType reference_type=NotReference)
Definition Type.h:109
std::vector< std::string > namespaces
Definition Type.h:81
std::vector< halide_cplusplus_type_name > enclosing_types
Definition Type.h:82
Modifier
One set of modifiers on a type.
Definition Type.h:86
@ Const
Bitmask flag for "const".
Definition Type.h:87
@ Restrict
Bitmask flag for "restrict".
Definition Type.h:89
@ FunctionTypedef
Bitmask flag for a function typedef; when this is set, Pointer should also always be set.
Definition Type.h:91
@ Volatile
Bitmask flag for "volatile".
Definition Type.h:88
@ Pointer
Bitmask flag for a pointer "*".
Definition Type.h:90
std::vector< uint8_t > cpp_type_modifiers
Qualifiers and indirections on type. 0 is innermost.
Definition Type.h:95
A type traits template to provide a halide_handle_cplusplus_type value from a C++ type.
Definition Type.h:253
static HALIDE_ALWAYS_INLINE const halide_handle_cplusplus_type * type_info()
Definition Type.h:256
A parallel task to be passed to halide_do_parallel_tasks.
A struct representing a semaphore and a number of items that must be acquired from it.
An opaque struct representing a semaphore.
A runtime tag for a type in the halide type system.
uint8_t bits
The number of bits of precision of a single scalar value of this type.
uint16_t lanes
How many elements in a vector.
uint8_t code
The basic type code: signed integer, unsigned integer, or floating point.
#define user_assert(c)
Definition test.h:10