• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===------------------------- ParameterType.h ---------------------------===//
2 //
3 //                              SPIR Tools
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===---------------------------------------------------------------------===//
9 /*
10  * Contributed by: Intel Corporation.
11  */
12 
13 #ifndef __PARAMETER_TYPE_H__
14 #define __PARAMETER_TYPE_H__
15 
16 #include "Refcount.h"
17 #include <string>
18 #include <vector>
19 
20 // The Type class hierarchy models the different types in OCL.
21 
22 namespace SPIR {
23 
24   // Supported SPIR versions
25   enum SPIRversion {
26     SPIR12 = 1,
27     SPIR20 = 2
28   };
29 
30   // Error Status values
31   enum MangleError {
32     MANGLE_SUCCESS,
33     MANGLE_TYPE_NOT_SUPPORTED,
34     MANGLE_NULL_FUNC_DESCRIPTOR
35   };
36 
37   enum TypePrimitiveEnum {
38     PRIMITIVE_FIRST,
39     PRIMITIVE_BOOL = PRIMITIVE_FIRST,
40     PRIMITIVE_UCHAR,
41     PRIMITIVE_CHAR,
42     PRIMITIVE_USHORT,
43     PRIMITIVE_SHORT,
44     PRIMITIVE_UINT,
45     PRIMITIVE_INT,
46     PRIMITIVE_ULONG,
47     PRIMITIVE_LONG,
48     PRIMITIVE_HALF,
49     PRIMITIVE_FLOAT,
50     PRIMITIVE_DOUBLE,
51     PRIMITIVE_VOID,
52     PRIMITIVE_VAR_ARG,
53     PRIMITIVE_STRUCT_FIRST,
54     PRIMITIVE_IMAGE_1D_T = PRIMITIVE_STRUCT_FIRST,
55     PRIMITIVE_IMAGE_1D_ARRAY_T,
56     PRIMITIVE_IMAGE_1D_BUFFER_T,
57     PRIMITIVE_IMAGE_2D_T,
58     PRIMITIVE_IMAGE_2D_ARRAY_T,
59     PRIMITIVE_IMAGE_3D_T,
60     PRIMITIVE_IMAGE_2D_MSAA_T,
61     PRIMITIVE_IMAGE_2D_ARRAY_MSAA_T,
62     PRIMITIVE_IMAGE_2D_MSAA_DEPTH_T,
63     PRIMITIVE_IMAGE_2D_ARRAY_MSAA_DEPTH_T,
64     PRIMITIVE_IMAGE_2D_DEPTH_T,
65     PRIMITIVE_IMAGE_2D_ARRAY_DEPTH_T,
66     PRIMITIVE_EVENT_T,
67     PRIMITIVE_PIPE_T,
68     PRIMITIVE_RESERVE_ID_T,
69     PRIMITIVE_QUEUE_T,
70     PRIMITIVE_NDRANGE_T,
71     PRIMITIVE_CLK_EVENT_T,
72     PRIMITIVE_STRUCT_LAST = PRIMITIVE_CLK_EVENT_T,
73     PRIMITIVE_SAMPLER_T,
74     PRIMITIVE_KERNEL_ENQUEUE_FLAGS_T,
75     PRIMITIVE_CLK_PROFILING_INFO,
76     PRIMITIVE_LAST = PRIMITIVE_CLK_PROFILING_INFO,
77     PRIMITIVE_NONE,
78     // Keep this at the end.
79     PRIMITIVE_NUM = PRIMITIVE_NONE
80   };
81 
82   enum TypeEnum {
83     TYPE_ID_PRIMITIVE,
84     TYPE_ID_POINTER,
85     TYPE_ID_VECTOR,
86     TYPE_ID_ATOMIC,
87     TYPE_ID_BLOCK,
88     TYPE_ID_STRUCTURE
89   };
90 
91   enum TypeAttributeEnum {
92     ATTR_QUALIFIER_FIRST = 0,
93     ATTR_RESTRICT = ATTR_QUALIFIER_FIRST,
94     ATTR_VOLATILE,
95     ATTR_CONST,
96     ATTR_QUALIFIER_LAST = ATTR_CONST,
97     ATTR_ADDR_SPACE_FIRST,
98     ATTR_PRIVATE = ATTR_ADDR_SPACE_FIRST,
99     ATTR_GLOBAL,
100     ATTR_CONSTANT,
101     ATTR_LOCAL,
102     ATTR_GENERIC,
103     ATTR_ADDR_SPACE_LAST = ATTR_GENERIC,
104     ATTR_NONE,
105     ATTR_NUM = ATTR_NONE
106   };
107 
108   // Forward declaration for abstract structure.
109   struct ParamType;
110   typedef RefCount<ParamType> RefParamType;
111 
112   // Forward declaration for abstract structure.
113   struct TypeVisitor;
114 
115   struct ParamType {
116     /// @brief Constructor.
117     /// @param TypeEnum type id.
ParamTypeParamType118     ParamType(TypeEnum typeId) : m_typeId(typeId) {};
119 
120     /// @brief Destructor.
~ParamTypeParamType121     virtual ~ParamType() {};
122 
123     /// Abstract Methods ///
124 
125     /// @brief Visitor service method. (see TypeVisitor for more details).
126     ///        When overridden in subclasses, preform a 'double dispatch' to the
127     ///        appropriate visit method in the given visitor.
128     /// @param TypeVisitor type visitor.
129     virtual MangleError accept(TypeVisitor*) const = 0;
130 
131     /// @brief Returns a string representation of the underlying type.
132     /// @return type as string.
133     virtual std::string toString() const = 0;
134 
135     /// @brief Returns true if given param type is equal to this type.
136     /// @param ParamType given param type.
137     /// @return true if given param type is equal to this type and false otherwise.
138     virtual bool equals(const ParamType*) const = 0;
139 
140     /// Common Base-Class Methods ///
141 
142     /// @brief Returns type id of underlying type.
143     /// @return type id.
getTypeIdParamType144     TypeEnum getTypeId() const {
145       return m_typeId;
146     }
147 
148   private:
149     // @brief Default Constructor.
150     ParamType();
151 
152   protected:
153     /// An enumeration to identify the type id of this instance.
154     TypeEnum m_typeId;
155   };
156 
157 
158   struct PrimitiveType : public ParamType {
159     /// An enumeration to identify the type id of this class.
160     const static TypeEnum enumTy;
161 
162     /// @brief Constructor.
163     /// @param TypePrimitiveEnum primitive id.
164     PrimitiveType(TypePrimitiveEnum);
165 
166     /// Implementation of Abstract Methods ///
167 
168     /// @brief Visitor service method. (see TypeVisitor for more details).
169     ///        When overridden in subclasses, preform a 'double dispatch' to the
170     ///        appropriate visit method in the given visitor.
171     /// @param TypeVisitor type visitor.
172     MangleError accept(TypeVisitor*) const;
173 
174     /// @brief Returns a string representation of the underlying type.
175     /// @return type as string.
176     std::string toString() const;
177 
178     /// @brief Returns true if given param type is equal to this type.
179     /// @param ParamType given param type.
180     /// @return true if given param type is equal to this type and false otherwise.
181     bool equals(const ParamType*) const;
182 
183     /// Non-Common Methods ///
184 
185     /// @brief Returns the primitive enumeration of the type.
186     /// @return primitive type.
getPrimitivePrimitiveType187     TypePrimitiveEnum getPrimitive() const {
188       return m_primitive;
189     }
190 
191   protected:
192     /// An enumeration to identify the primitive type.
193     TypePrimitiveEnum m_primitive;
194   };
195 
196   struct PointerType: public ParamType {
197     /// An enumeration to identify the type id of this class.
198     const static TypeEnum enumTy;
199 
200     /// @brief Constructor.
201     /// @param RefParamType the type of pointee (that the pointer points at).
202     PointerType(const RefParamType type);
203 
204     /// Implementation of Abstract Methods ///
205 
206     /// @brief Visitor service method. (see TypeVisitor for more details).
207     ///        When overridden in subclasses, preform a 'double dispatch' to the
208     ///        appropriate visit method in the given visitor.
209     /// @param TypeVisitor type visitor
210     MangleError accept(TypeVisitor*) const;
211 
212     /// @brief Returns a string representation of the underlying type.
213     /// @return type as string.
214     std::string toString() const;
215 
216     /// @brief Returns true if given param type is equal to this type.
217     /// @param ParamType given param type.
218     /// @return true if given param type is equal to this type and false otherwise.
219     bool equals(const ParamType*) const;
220 
221     /// Non-Common Methods ///
222 
223     /// @brief Returns the type the pointer is pointing at.
224     /// @return pointee type.
getPointeePointerType225     const RefParamType& getPointee() const {
226       return m_pType;
227     }
228 
229     /// @brief Sets the address space attribute - default is __private
230     /// @param TypeAttributeEnum address space attribute id.
231     void setAddressSpace(TypeAttributeEnum attr);
232 
233     /// @brief Returns the pointer's address space.
234     /// @return pointer's address space.
235     TypeAttributeEnum getAddressSpace() const;
236 
237     /// @brief Adds or removes a pointer's qualifier.
238     /// @param TypeAttributeEnum qual - qualifier to add/remove.
239     /// @param bool enabled - true if qualifier should exist false otherwise.
240     ///        default is set to false.
241     void setQualifier(TypeAttributeEnum qual, bool enabled);
242 
243     /// @brief Checks if the pointer has a certain qualifier.
244     /// @param TypeAttributeEnum qual - qualifier to check.
245     /// @return true if the qualifier exists and false otherwise.
246     bool hasQualifier(TypeAttributeEnum qual) const;
247 
248   private:
249     /// The type this pointer is pointing at.
250     RefParamType m_pType;
251     /// Array of the pointer's enabled type qualifiers.
252     bool m_qualifiers[ATTR_QUALIFIER_LAST - ATTR_QUALIFIER_FIRST + 1];
253     /// Pointer's address space.
254     TypeAttributeEnum m_address_space;
255   };
256 
257   struct VectorType : public ParamType {
258     /// An enumeration to identify the type id of this class.
259     const static TypeEnum enumTy;
260 
261     /// @brief Constructor.
262     /// @param RefParamType the type of each scalar element in the vector.
263     /// @param int the length of the vector.
264     VectorType(const RefParamType type, int len);
265 
266     /// Implementation of Abstract Methods ///
267 
268     /// @brief Visitor service method. (see TypeVisitor for more details).
269     ///        When overridden in subclasses, preform a 'double dispatch' to the
270     ///        appropriate visit method in the given visitor.
271     /// @param TypeVisitor type visitor.
272     MangleError accept(TypeVisitor*) const;
273 
274     /// @brief Returns a string representation of the underlying type.
275     /// @return type as string.
276     std::string toString() const;
277 
278     /// @brief Returns true if given param type is equal to this type.
279     /// @param ParamType given param type.
280     /// @return true if given param type is equal to this type and false otherwise.
281     bool equals(const ParamType*) const;
282 
283     /// Non-Common Methods ///
284 
285     /// @brief Returns the type the vector is packing.
286     /// @return scalar type.
getScalarTypeVectorType287     const RefParamType& getScalarType() const {
288       return m_pType;
289     }
290 
291     /// @brief Returns the length of the vector type.
292     /// @return vector type length.
getLengthVectorType293     int getLength() const {
294       return m_len;
295     }
296 
297   private:
298     /// The scalar type of this vector type.
299     RefParamType m_pType;
300     /// The length of the vector.
301     int m_len;
302   };
303 
304   struct AtomicType: public ParamType {
305     ///an enumeration to identify the type id of this class
306     const static TypeEnum enumTy;
307 
308     /// @brief Constructor
309     /// @param RefParamType the type refernced as atomic.
310     AtomicType(const RefParamType type);
311 
312     /// Implementation of Abstract Methods ///
313 
314     /// @brief visitor service method. (see TypeVisitor for more details).
315     ///       When overridden in subclasses, preform a 'double dispatch' to the
316     ///       appropriate visit method in the given visitor.
317     /// @param TypeVisitor type visitor
318     MangleError accept(TypeVisitor*) const;
319 
320     /// @brief returns a string representation of the underlying type.
321     /// @return type as string
322     std::string toString() const;
323 
324     /// @brief returns true if given param type is equal to this type.
325     /// @param ParamType given param type
326     /// @return true if given param type is equal to this type and false otherwise
327     bool equals(const ParamType*) const;
328 
329     /// Non-Common Methods ///
330 
331     /// @brief returns the base type of the atomic parameter.
332     /// @return base type
getBaseTypeAtomicType333     const RefParamType& getBaseType() const {
334       return m_pType;
335     }
336 
337   private:
338     ///the type this pointer is pointing at
339     RefParamType m_pType;
340   };
341 
342   struct BlockType : public ParamType {
343     ///an enumeration to identify the type id of this class
344     const static TypeEnum enumTy;
345 
346     ///@brief Constructor
347     BlockType();
348 
349     /// Implementation of Abstract Methods ///
350 
351     /// @brief visitor service method. (see TypeVisitor for more details).
352     ///       When overridden in subclasses, preform a 'double dispatch' to the
353     ///       appropriate visit method in the given visitor.
354     /// @param TypeVisitor type visitor
355     MangleError accept(TypeVisitor*) const;
356 
357     /// @brief returns a string representation of the underlying type.
358     /// @return type as string
359     std::string toString() const;
360 
361     /// @brief returns true if given param type is equal to this type.
362     /// @param ParamType given param type
363     /// @return true if given param type is equal to this type and false otherwise
364     bool equals(const ParamType*) const;
365 
366     /// Non-Common Methods ///
367 
368     /// @brief returns the number of parameters of the block.
369     /// @return parameters count
getNumOfParamsBlockType370     unsigned int getNumOfParams() const {
371       return (unsigned int)m_params.size();
372     }
373 
374     ///@brief returns the type of parameter "index" of the block.
375     // @param index the sequential number of the queried parameter
376     ///@return parameter type
getParamBlockType377     const RefParamType& getParam(unsigned int index) const {
378       assert(m_params.size() > index && "index is OOB");
379       return m_params[index];
380     }
381 
382     ///@brief set the type of parameter "index" of the block.
383     // @param index the sequential number of the queried parameter
384     // @param type the parameter type
setParamBlockType385     void setParam(unsigned int index, RefParamType type) {
386       if(index < getNumOfParams()) {
387         m_params[index] = type;
388       }
389       else if (index == getNumOfParams()) {
390         m_params.push_back(type);
391       }
392       else {
393         assert(false && "index is OOB");
394       }
395     }
396 
397   protected:
398     ///an enumeration to identify the primitive type
399     std::vector<RefParamType> m_params;
400   };
401 
402 
403   struct UserDefinedType : public ParamType {
404     /// An enumeration to identify the type id of this class.
405     const static TypeEnum enumTy;
406 
407     /// @brief Constructor.
408     UserDefinedType(const std::string&);
409 
410     /// Implementation of Abstract Methods ///
411 
412     /// @brief Visitor service method. (see TypeVisitor for more details).
413     ///        When overridden in subclasses, preform a 'double dispatch' to the
414     ///        appropriate visit method in the given visitor.
415     /// @param TypeVisitor type visitor.
416     MangleError accept(TypeVisitor*) const;
417 
418     /// @brief Returns a string representation of the underlying type.
419     /// @return type as string.
420     std::string toString() const;
421 
422     /// @brief Returns true if given param type is equal to this type.
423     /// @param ParamType given param type.
424     /// @return true if given param type is equal to this type and false otherwise.
425     bool equals(const ParamType*) const;
426 
427   protected:
428     /// The name of the user defined type.
429     std::string m_name;
430   };
431 
432 
433   /// @brief Can be overridden so an object of static type Type* will
434   ///        dispatch the correct visit method according to its dynamic type.
435   struct TypeVisitor{
436     SPIRversion spirVer;
TypeVisitorTypeVisitor437     TypeVisitor(SPIRversion ver) : spirVer(ver) {};
438 
439     /// should usually have virtual destructor if there are any
440     /// virtual functions
~TypeVisitorTypeVisitor441     virtual ~TypeVisitor() { }
442 
443     virtual MangleError visit(const PrimitiveType*)   = 0;
444     virtual MangleError visit(const VectorType*)      = 0;
445     virtual MangleError visit(const PointerType*)     = 0;
446     virtual MangleError visit(const AtomicType*)      = 0;
447     virtual MangleError visit(const BlockType*)       = 0;
448     virtual MangleError visit(const UserDefinedType*) = 0;
449   };
450 
451   /// @brief Template dynamic cast function for ParamType derived classes.
452   /// @param ParamType given param type.
453   /// @return required casting type if given param type is an instance if
454   //          that type, NULL otherwise.
455   template <typename T>
dyn_cast(ParamType * pType)456   T* dyn_cast(ParamType* pType) {
457     assert(pType && "dyn_cast does not support casting of NULL");
458     return (T::enumTy == pType->getTypeId()) ? (T*)pType : NULL;
459   }
460 
461   /// @brief Template dynamic cast function for ParamType derived classes
462   ///        (the constant version).
463   /// @param ParamType given param type.
464   /// @return required casting type if given param type is an instance if
465   //          that type, NULL otherwise.
466   template <typename T>
dyn_cast(const ParamType * pType)467   const T* dyn_cast(const ParamType* pType) {
468     assert(pType && "dyn_cast does not support casting of NULL");
469     return (T::enumTy == pType->getTypeId()) ? (const T*)pType : NULL;
470   }
471 
472 } // End SPIR namespace
473 #endif //__PARAMETER_TYPE_H__
474