Halide  14.0.0
Halide compiler and libraries
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
41  enum CPPTypeType {
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 
53  }
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 ||
66  (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.
86  enum Modifier : uint8_t {
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  };
92 
93  /// Qualifiers and indirections on type. 0 is innermost.
94  std::vector<uint8_t> cpp_type_modifiers;
95 
96  /// References are separate because they only occur at the outermost level.
97  /// No modifiers are needed for references as they are not allowed to apply
98  /// to the reference itself. (This isn't true for restrict, but that is a C++
99  /// extension anyway.) If modifiers are needed, the last entry in the above
100  /// array would be the modifers for the reference.
103  LValueReference = 1, // "&"
104  RValueReference = 2, // "&&"
105  };
107 
109  const std::vector<std::string> &namespaces = {},
110  const std::vector<halide_cplusplus_type_name> &enclosing_types = {},
111  const std::vector<uint8_t> &modifiers = {},
116  cpp_type_modifiers(modifiers),
118  }
119 
120  template<typename T>
122 };
123 //@}
124 
125 /** halide_c_type_to_name is a utility class used to provide a user-extensible
126  * way of naming Handle types.
127  *
128  * Although this is in the global namespace, it should be considered "Halide Internal"
129  * and subject to change; code outside Halide should avoid referencing it
130  * directly (use the HALIDE_DECLARE_EXTERN_xxx macros instead).
131  */
132 template<typename T>
134  static constexpr bool known_type = false;
136  return {halide_cplusplus_type_name::Simple, "void"};
137  }
138 };
139 
140 #define HALIDE_DECLARE_EXTERN_TYPE(TypeType, Type) \
141  template<> \
142  struct halide_c_type_to_name<Type> { \
143  static constexpr bool known_type = true; \
144  static halide_cplusplus_type_name name() { \
145  return {halide_cplusplus_type_name::TypeType, #Type}; \
146  } \
147  }
148 
149 #define HALIDE_DECLARE_EXTERN_SIMPLE_TYPE(T) HALIDE_DECLARE_EXTERN_TYPE(Simple, T)
150 #define HALIDE_DECLARE_EXTERN_STRUCT_TYPE(T) HALIDE_DECLARE_EXTERN_TYPE(Struct, T)
151 #define HALIDE_DECLARE_EXTERN_CLASS_TYPE(T) HALIDE_DECLARE_EXTERN_TYPE(Class, T)
152 #define HALIDE_DECLARE_EXTERN_UNION_TYPE(T) HALIDE_DECLARE_EXTERN_TYPE(Union, T)
153 
175 
176 // You can make arbitrary user-defined types be "Known" using the
177 // macro above. This is useful for making Param<> arguments for
178 // Generators type safe. e.g.,
179 //
180 // struct MyFunStruct { ... };
181 //
182 // ...
183 //
184 // HALIDE_DECLARE_EXTERN_STRUCT_TYPE(MyFunStruct);
185 //
186 // ...
187 //
188 // class MyGenerator : public Generator<MyGenerator> {
189 // Param<const MyFunStruct *> my_struct_ptr;
190 // ...
191 // };
192 
193 template<typename T>
195  constexpr bool is_ptr = std::is_pointer<T>::value;
196  constexpr bool is_lvalue_reference = std::is_lvalue_reference<T>::value;
197  constexpr bool is_rvalue_reference = std::is_rvalue_reference<T>::value;
198 
199  using TBase = typename std::remove_pointer<typename std::remove_reference<T>::type>::type;
200  constexpr bool is_const = std::is_const<TBase>::value;
201  constexpr bool is_volatile = std::is_volatile<TBase>::value;
202 
203  constexpr uint8_t modifiers = static_cast<uint8_t>(
206  (is_volatile ? halide_handle_cplusplus_type::Volatile : 0));
207 
208  // clang-format off
210  (is_lvalue_reference ? halide_handle_cplusplus_type::LValueReference :
211  is_rvalue_reference ? halide_handle_cplusplus_type::RValueReference :
213  // clang-format on
214 
215  using TNonCVBase = typename std::remove_cv<TBase>::type;
216  constexpr bool known_type = halide_c_type_to_name<TNonCVBase>::known_type;
217  static_assert(!(!known_type && !is_ptr), "Unknown types must be pointers");
218 
221  {},
222  {},
223  {modifiers},
224  ref_type};
225  // Pull off any namespaces
227  return info;
228 }
229 
230 /** A type traits template to provide a halide_handle_cplusplus_type
231  * value from a C++ type.
232  *
233  * Note the type represented is implicitly a pointer.
234  *
235  * A NULL pointer of type halide_handle_traits represents "void *".
236  * This is chosen for compactness or representation as Type is a very
237  * widely used data structure.
238  *
239  * Although this is in the global namespace, it should be considered "Halide Internal"
240  * and subject to change; code outside Halide should avoid referencing it directly.
241  */
242 template<typename T>
244  // This trait must return a pointer to a global structure. I.e. it should never be freed.
245  // A return value of nullptr here means "void *".
247  if (std::is_pointer<T>::value ||
248  std::is_lvalue_reference<T>::value ||
249  std::is_rvalue_reference<T>::value) {
250  static const halide_handle_cplusplus_type the_info = halide_handle_cplusplus_type::make<T>();
251  return &the_info;
252  }
253  return nullptr;
254  }
255 };
256 
257 namespace Halide {
258 
259 struct Expr;
260 
261 /** Types in the halide type system. They can be ints, unsigned ints,
262  * or floats of various bit-widths (the 'bits' field). They can also
263  * be vectors of the same (by setting the 'lanes' field to something
264  * larger than one). Front-end code shouldn't use vector
265  * types. Instead vectorize a function. */
266 struct Type {
267 private:
268  halide_type_t type;
269 
270 public:
271  /** Aliases for halide_type_code_t values for legacy compatibility
272  * and to match the Halide internal C++ style. */
273  // @{
279  // @}
280 
281  /** The number of bytes required to store a single scalar value of this type. Ignores vector lanes. */
282  int bytes() const {
283  return (bits() + 7) / 8;
284  }
285 
286  // Default ctor initializes everything to predictable-but-unlikely values
288  : type(Handle, 0, 0) {
289  }
290 
291  /** Construct a runtime representation of a Halide type from:
292  * code: The fundamental type from an enum.
293  * bits: The bit size of one element.
294  * lanes: The number of vector elements in the type. */
297  }
298 
299  /** Trivial copy constructor. */
300  Type(const Type &that) = default;
301 
302  /** Trivial copy assignment operator. */
303  Type &operator=(const Type &that) = default;
304 
305  /** Type is a wrapper around halide_type_t with more methods for use
306  * inside the compiler. This simply constructs the wrapper around
307  * the runtime value. */
310  : type(that), handle_type(handle_type) {
311  }
312 
313  /** Unwrap the runtime halide_type_t for use in runtime calls, etc.
314  * Representation is exactly equivalent. */
316  operator halide_type_t() const {
317  return type;
318  }
319 
320  /** Return the underlying data type of an element as an enum value. */
323  return (halide_type_code_t)type.code;
324  }
325 
326  /** Return the bit size of a single element of this type. */
328  int bits() const {
329  return type.bits;
330  }
331 
332  /** Return the number of vector elements in this type. */
334  int lanes() const {
335  return type.lanes;
336  }
337 
338  /** Return Type with same number of bits and lanes, but new_code for a type code. */
340  return Type(new_code, bits(), lanes(),
341  (new_code == code()) ? handle_type : nullptr);
342  }
343 
344  /** Return Type with same type code and lanes, but new_bits for the number of bits. */
345  Type with_bits(int new_bits) const {
346  return Type(code(), new_bits, lanes(),
347  (new_bits == bits()) ? handle_type : nullptr);
348  }
349 
350  /** Return Type with same type code and number of bits,
351  * but new_lanes for the number of vector lanes. */
352  Type with_lanes(int new_lanes) const {
353  return Type(code(), bits(), new_lanes, handle_type);
354  }
355 
356  /** Return Type with the same type code and number of lanes, but with at least twice as many bits. */
357  Type widen() const {
358  if (bits() == 1) {
359  // Widening a 1-bit type should produce an 8-bit type.
360  return with_bits(8);
361  } else {
362  return with_bits(bits() * 2);
363  }
364  }
365 
366  /** Return Type with the same type code and number of lanes, but with at most half as many bits. */
367  Type narrow() const {
368  internal_assert(bits() != 1) << "Attempting to narrow a 1-bit type\n";
369  if (bits() == 8) {
370  // Narrowing an 8-bit type should produce a 1-bit type.
371  return with_bits(1);
372  } else {
373  return with_bits(bits() / 2);
374  }
375  }
376 
377  /** Type to be printed when declaring handles of this type. */
379 
380  /** Is this type boolean (represented as UInt(1))? */
382  bool is_bool() const {
383  return code() == UInt && bits() == 1;
384  }
385 
386  /** Is this type a vector type? (lanes() != 1).
387  * TODO(abadams): Decide what to do for lanes() == 0. */
389  bool is_vector() const {
390  return lanes() != 1;
391  }
392 
393  /** Is this type a scalar type? (lanes() == 1).
394  * TODO(abadams): Decide what to do for lanes() == 0. */
396  bool is_scalar() const {
397  return lanes() == 1;
398  }
399 
400  /** Is this type a floating point type (float or double). */
402  bool is_float() const {
403  return code() == Float || code() == BFloat;
404  }
405 
406  /** Is this type a floating point type (float or double). */
408  bool is_bfloat() const {
409  return code() == BFloat;
410  }
411 
412  /** Is this type a signed integer type? */
414  bool is_int() const {
415  return code() == Int;
416  }
417 
418  /** Is this type an unsigned integer type? */
420  bool is_uint() const {
421  return code() == UInt;
422  }
423 
424  /** Is this type an integer type of any sort? */
426  bool is_int_or_uint() const {
427  return code() == Int || code() == UInt;
428  }
429 
430  /** Is this type an opaque handle type (void *) */
432  bool is_handle() const {
433  return code() == Handle;
434  }
435 
436  // Returns true iff type is a signed integral type where overflow is defined.
438  bool can_overflow_int() const {
439  return is_int() && bits() <= 16;
440  }
441 
442  // Returns true iff type does have a well-defined overflow behavior.
444  bool can_overflow() const {
445  return is_uint() || can_overflow_int();
446  }
447 
448  /** Check that the type name of two handles matches. */
449  bool same_handle_type(const Type &other) const;
450 
451  /** Compare two types for equality */
452  bool operator==(const Type &other) const {
453  return type == other.type && (code() != Handle || same_handle_type(other));
454  }
455 
456  /** Compare two types for inequality */
457  bool operator!=(const Type &other) const {
458  return type != other.type || (code() == Handle && !same_handle_type(other));
459  }
460 
461  /** Compare two types for equality */
462  bool operator==(const halide_type_t &other) const {
463  return type == other;
464  }
465 
466  /** Compare two types for inequality */
467  bool operator!=(const halide_type_t &other) const {
468  return type != other;
469  }
470 
471  /** Compare ordering of two types so they can be used in certain containers and algorithms */
472  bool operator<(const Type &other) const {
473  if (type < other.type) {
474  return true;
475  }
476  if (code() == Handle) {
477  return handle_type < other.handle_type;
478  }
479  return false;
480  }
481 
482  /** Produce the scalar type (that of a single element) of this vector type */
483  Type element_of() const {
484  return with_lanes(1);
485  }
486 
487  /** Can this type represent all values of another type? */
488  bool can_represent(Type other) const;
489 
490  /** Can this type represent a particular constant? */
491  // @{
492  bool can_represent(double x) const;
493  bool can_represent(int64_t x) const;
494  bool can_represent(uint64_t x) const;
495  // @}
496 
497  /** Check if an integer constant value is the maximum or minimum
498  * representable value for this type. */
499  // @{
500  bool is_max(uint64_t) const;
501  bool is_max(int64_t) const;
502  bool is_min(uint64_t) const;
503  bool is_min(int64_t) const;
504  // @}
505 
506  /** Return an expression which is the maximum value of this type.
507  * Returns infinity for types which can represent it. */
508  Expr max() const;
509 
510  /** Return an expression which is the minimum value of this type.
511  * Returns -infinity for types which can represent it. */
512  Expr min() const;
513 };
514 
515 /** Constructing a signed integer type */
516 inline Type Int(int bits, int lanes = 1) {
517  return Type(Type::Int, bits, lanes);
518 }
519 
520 /** Constructing an unsigned integer type */
521 inline Type UInt(int bits, int lanes = 1) {
522  return Type(Type::UInt, bits, lanes);
523 }
524 
525 /** Construct a floating-point type */
526 inline Type Float(int bits, int lanes = 1) {
527  return Type(Type::Float, bits, lanes);
528 }
529 
530 /** Construct a floating-point type in the bfloat format. Only 16-bit currently supported. */
531 inline Type BFloat(int bits, int lanes = 1) {
532  return Type(Type::BFloat, bits, lanes);
533 }
534 
535 /** Construct a boolean type */
536 inline Type Bool(int lanes = 1) {
537  return UInt(1, lanes);
538 }
539 
540 /** Construct a handle type */
541 inline Type Handle(int lanes = 1, const halide_handle_cplusplus_type *handle_type = nullptr) {
542  return Type(Type::Handle, 64, lanes, handle_type);
543 }
544 
545 /** Construct the halide equivalent of a C type */
546 template<typename T>
547 inline Type type_of() {
548  return Type(halide_type_of<T>(), halide_handle_traits<T>::type_info());
549 }
550 
551 /** Halide type to a C++ type */
552 std::string type_to_c_type(Type type, bool include_space, bool c_plus_plus = true);
553 
554 } // namespace Halide
555 
556 #endif
#define internal_assert(c)
Definition: Errors.h:19
This file declares the routines used by Halide internally in its runtime.
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
#define HALIDE_ALWAYS_INLINE
Definition: HalideRuntime.h:38
#define HALIDE_DECLARE_EXTERN_STRUCT_TYPE(T)
Definition: Type.h:150
#define HALIDE_DECLARE_EXTERN_SIMPLE_TYPE(T)
Definition: Type.h:149
Various utility functions used internally Halide.
HALIDE_ALWAYS_INLINE auto is_const(A &&a) noexcept -> IsConst< decltype(pattern_arg(a))>
Definition: IRMatch.h:2219
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:531
Type UInt(int bits, int lanes=1)
Constructing an unsigned integer type.
Definition: Type.h:521
Type Float(int bits, int lanes=1)
Construct a floating-point type.
Definition: Type.h:526
Type type_of()
Construct the halide equivalent of a C type.
Definition: Type.h:547
Type Int(int bits, int lanes=1)
Constructing a signed integer type.
Definition: Type.h:516
Type Handle(int lanes=1, const halide_handle_cplusplus_type *handle_type=nullptr)
Construct a handle type.
Definition: Type.h:541
Type Bool(int lanes=1)
Construct a boolean type.
Definition: Type.h:536
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:256
Types in the halide type system.
Definition: Type.h:266
HALIDE_ALWAYS_INLINE halide_type_code_t code() const
Return the underlying data type of an element as an enum value.
Definition: Type.h:322
static const halide_type_code_t Float
Definition: Type.h:276
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:357
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:295
Type element_of() const
Produce the scalar type (that of a single element) of this vector type.
Definition: Type.h:483
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:274
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:345
HALIDE_ALWAYS_INLINE bool is_int() const
Is this type a signed integer type?
Definition: Type.h:414
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:457
HALIDE_ALWAYS_INLINE int lanes() const
Return the number of vector elements in this type.
Definition: Type.h:334
HALIDE_ALWAYS_INLINE bool is_uint() const
Is this type an unsigned integer type?
Definition: Type.h:420
HALIDE_ALWAYS_INLINE bool is_bool() const
Is this type boolean (represented as UInt(1))?
Definition: Type.h:382
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:352
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:309
static const halide_type_code_t BFloat
Definition: Type.h:277
bool operator<(const Type &other) const
Compare ordering of two types so they can be used in certain containers and algorithms.
Definition: Type.h:472
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:328
HALIDE_ALWAYS_INLINE bool can_overflow_int() const
Definition: Type.h:438
bool operator!=(const halide_type_t &other) const
Compare two types for inequality.
Definition: Type.h:467
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:426
static const halide_type_code_t UInt
Definition: Type.h:275
HALIDE_ALWAYS_INLINE bool is_vector() const
Is this type a vector type? (lanes() != 1).
Definition: Type.h:389
HALIDE_ALWAYS_INLINE bool is_bfloat() const
Is this type a floating point type (float or double).
Definition: Type.h:408
const halide_handle_cplusplus_type * handle_type
Type to be printed when declaring handles of this type.
Definition: Type.h:378
int bytes() const
The number of bytes required to store a single scalar value of this type.
Definition: Type.h:282
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:452
HALIDE_ALWAYS_INLINE bool can_overflow() const
Definition: Type.h:444
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:339
static const halide_type_code_t Handle
Definition: Type.h:278
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:367
HALIDE_ALWAYS_INLINE bool is_handle() const
Is this type an opaque handle type (void *)
Definition: Type.h:432
bool can_represent(int64_t x) const
bool is_min(uint64_t) const
bool can_represent(uint64_t x) const
Type & operator=(const Type &that)=default
Trivial copy assignment operator.
bool operator==(const halide_type_t &other) const
Compare two types for equality.
Definition: Type.h:462
HALIDE_ALWAYS_INLINE bool is_scalar() const
Is this type a scalar type? (lanes() == 1).
Definition: Type.h:396
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:402
Class that provides a type that implements half precision floating point using the bfloat16 format.
Definition: Float16.h:142
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:133
static constexpr bool known_type
Definition: Type.h:134
static halide_cplusplus_type_name name()
Definition: Type.h:135
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
std::string name
Definition: Type.h:49
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
@ Enum
"enum Foo"
Definition: Type.h:46
@ 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:106
halide_cplusplus_type_name inner_name
Definition: Type.h:80
static halide_handle_cplusplus_type make()
Definition: Type.h:194
ReferenceType
References are separate because they only occur at the outermost level.
Definition: Type.h:101
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:108
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
@ 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:94
A type traits template to provide a halide_handle_cplusplus_type value from a C++ type.
Definition: Type.h:243
static HALIDE_ALWAYS_INLINE const halide_handle_cplusplus_type * type_info()
Definition: Type.h:246
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.