"Fossies" - the Fresh Open Source Software Archive

Member "mesa-20.1.8/src/compiler/glsl_types.h" (16 Sep 2020, 39055 Bytes) of package /linux/misc/mesa-20.1.8.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "glsl_types.h" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 20.1.5_vs_20.2.0-rc1.

    1 /* -*- c++ -*- */
    2 /*
    3  * Copyright © 2009 Intel Corporation
    4  *
    5  * Permission is hereby granted, free of charge, to any person obtaining a
    6  * copy of this software and associated documentation files (the "Software"),
    7  * to deal in the Software without restriction, including without limitation
    8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
    9  * and/or sell copies of the Software, and to permit persons to whom the
   10  * Software is furnished to do so, subject to the following conditions:
   11  *
   12  * The above copyright notice and this permission notice (including the next
   13  * paragraph) shall be included in all copies or substantial portions of the
   14  * Software.
   15  *
   16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
   19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
   21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
   22  * DEALINGS IN THE SOFTWARE.
   23  */
   24 
   25 #ifndef GLSL_TYPES_H
   26 #define GLSL_TYPES_H
   27 
   28 #include <string.h>
   29 #include <assert.h>
   30 
   31 #include "shader_enums.h"
   32 #include "c11/threads.h"
   33 #include "util/blob.h"
   34 #include "util/format/u_format.h"
   35 #include "util/macros.h"
   36 
   37 #ifdef __cplusplus
   38 #include "main/config.h"
   39 #endif
   40 
   41 struct glsl_type;
   42 
   43 #ifdef __cplusplus
   44 extern "C" {
   45 #endif
   46 
   47 struct _mesa_glsl_parse_state;
   48 struct glsl_symbol_table;
   49 
   50 extern void
   51 glsl_type_singleton_init_or_ref();
   52 
   53 extern void
   54 glsl_type_singleton_decref();
   55 
   56 extern void
   57 _mesa_glsl_initialize_types(struct _mesa_glsl_parse_state *state);
   58 
   59 void encode_type_to_blob(struct blob *blob, const struct glsl_type *type);
   60 
   61 const struct glsl_type *decode_type_from_blob(struct blob_reader *blob);
   62 
   63 typedef void (*glsl_type_size_align_func)(const struct glsl_type *type,
   64                                           unsigned *size, unsigned *align);
   65 
   66 enum glsl_base_type {
   67    /* Note: GLSL_TYPE_UINT, GLSL_TYPE_INT, and GLSL_TYPE_FLOAT must be 0, 1,
   68     * and 2 so that they will fit in the 2 bits of glsl_type::sampled_type.
   69     */
   70    GLSL_TYPE_UINT = 0,
   71    GLSL_TYPE_INT,
   72    GLSL_TYPE_FLOAT,
   73    GLSL_TYPE_FLOAT16,
   74    GLSL_TYPE_DOUBLE,
   75    GLSL_TYPE_UINT8,
   76    GLSL_TYPE_INT8,
   77    GLSL_TYPE_UINT16,
   78    GLSL_TYPE_INT16,
   79    GLSL_TYPE_UINT64,
   80    GLSL_TYPE_INT64,
   81    GLSL_TYPE_BOOL,
   82    GLSL_TYPE_SAMPLER,
   83    GLSL_TYPE_IMAGE,
   84    GLSL_TYPE_ATOMIC_UINT,
   85    GLSL_TYPE_STRUCT,
   86    GLSL_TYPE_INTERFACE,
   87    GLSL_TYPE_ARRAY,
   88    GLSL_TYPE_VOID,
   89    GLSL_TYPE_SUBROUTINE,
   90    GLSL_TYPE_FUNCTION,
   91    GLSL_TYPE_ERROR
   92 };
   93 
   94 /* Return the bit size of a type. Note that this differs from 
   95  * glsl_get_bit_size in that it returns 32 bits for bools, whereas at
   96  * the NIR level we would want to return 1 bit for bools.
   97  */
   98 static unsigned glsl_base_type_bit_size(enum glsl_base_type type)
   99 {
  100    switch (type) {
  101    case GLSL_TYPE_BOOL:
  102    case GLSL_TYPE_INT:
  103    case GLSL_TYPE_UINT:
  104    case GLSL_TYPE_FLOAT: /* TODO handle mediump */
  105    case GLSL_TYPE_SUBROUTINE:
  106       return 32;
  107 
  108    case GLSL_TYPE_FLOAT16:
  109    case GLSL_TYPE_UINT16:
  110    case GLSL_TYPE_INT16:
  111       return 16;
  112 
  113    case GLSL_TYPE_UINT8:
  114    case GLSL_TYPE_INT8:
  115       return 8;
  116 
  117    case GLSL_TYPE_DOUBLE:
  118    case GLSL_TYPE_INT64:
  119    case GLSL_TYPE_UINT64:
  120    case GLSL_TYPE_IMAGE:
  121    case GLSL_TYPE_SAMPLER:
  122       return 64;
  123 
  124    default:
  125       /* For GLSL_TYPE_STRUCT etc, it should be ok to return 0. This usually
  126        * happens when calling this method through is_64bit and is_16bit
  127        * methods
  128        */
  129       return 0;
  130    }
  131 
  132    return 0;
  133 }
  134 
  135 static inline bool glsl_base_type_is_16bit(enum glsl_base_type type)
  136 {
  137    return glsl_base_type_bit_size(type) == 16;
  138 }
  139 
  140 static inline bool glsl_base_type_is_64bit(enum glsl_base_type type)
  141 {
  142    return glsl_base_type_bit_size(type) == 64;
  143 }
  144 
  145 static inline bool glsl_base_type_is_integer(enum glsl_base_type type)
  146 {
  147    return type == GLSL_TYPE_UINT8 ||
  148           type == GLSL_TYPE_INT8 ||
  149           type == GLSL_TYPE_UINT16 ||
  150           type == GLSL_TYPE_INT16 ||
  151           type == GLSL_TYPE_UINT ||
  152           type == GLSL_TYPE_INT ||
  153           type == GLSL_TYPE_UINT64 ||
  154           type == GLSL_TYPE_INT64 ||
  155           type == GLSL_TYPE_BOOL ||
  156           type == GLSL_TYPE_SAMPLER ||
  157           type == GLSL_TYPE_IMAGE;
  158 }
  159 
  160 static inline unsigned int
  161 glsl_base_type_get_bit_size(const enum glsl_base_type base_type)
  162 {
  163    switch (base_type) {
  164    case GLSL_TYPE_BOOL:
  165       return 1;
  166 
  167    case GLSL_TYPE_INT:
  168    case GLSL_TYPE_UINT:
  169    case GLSL_TYPE_FLOAT: /* TODO handle mediump */
  170    case GLSL_TYPE_SUBROUTINE:
  171       return 32;
  172 
  173    case GLSL_TYPE_FLOAT16:
  174    case GLSL_TYPE_UINT16:
  175    case GLSL_TYPE_INT16:
  176       return 16;
  177 
  178    case GLSL_TYPE_UINT8:
  179    case GLSL_TYPE_INT8:
  180       return 8;
  181 
  182    case GLSL_TYPE_DOUBLE:
  183    case GLSL_TYPE_INT64:
  184    case GLSL_TYPE_UINT64:
  185    case GLSL_TYPE_IMAGE:
  186    case GLSL_TYPE_SAMPLER:
  187       return 64;
  188 
  189    default:
  190       unreachable("unknown base type");
  191    }
  192 
  193    return 0;
  194 }
  195 
  196 static inline enum glsl_base_type
  197 glsl_unsigned_base_type_of(enum glsl_base_type type)
  198 {
  199    switch (type) {
  200    case GLSL_TYPE_INT:
  201       return GLSL_TYPE_UINT;
  202    case GLSL_TYPE_INT8:
  203       return GLSL_TYPE_UINT8;
  204    case GLSL_TYPE_INT16:
  205       return GLSL_TYPE_UINT16;
  206    case GLSL_TYPE_INT64:
  207       return GLSL_TYPE_UINT64;
  208    default:
  209       assert(type == GLSL_TYPE_UINT ||
  210              type == GLSL_TYPE_UINT8 ||
  211              type == GLSL_TYPE_UINT16 ||
  212              type == GLSL_TYPE_UINT64);
  213       return type;
  214    }
  215 }
  216 
  217 enum glsl_sampler_dim {
  218    GLSL_SAMPLER_DIM_1D = 0,
  219    GLSL_SAMPLER_DIM_2D,
  220    GLSL_SAMPLER_DIM_3D,
  221    GLSL_SAMPLER_DIM_CUBE,
  222    GLSL_SAMPLER_DIM_RECT,
  223    GLSL_SAMPLER_DIM_BUF,
  224    GLSL_SAMPLER_DIM_EXTERNAL,
  225    GLSL_SAMPLER_DIM_MS,
  226    GLSL_SAMPLER_DIM_SUBPASS, /* for vulkan input attachments */
  227    GLSL_SAMPLER_DIM_SUBPASS_MS, /* for multisampled vulkan input attachments */
  228 };
  229 
  230 int
  231 glsl_get_sampler_dim_coordinate_components(enum glsl_sampler_dim dim);
  232 
  233 enum glsl_matrix_layout {
  234    /**
  235     * The layout of the matrix is inherited from the object containing the
  236     * matrix (the top level structure or the uniform block).
  237     */
  238    GLSL_MATRIX_LAYOUT_INHERITED,
  239 
  240    /**
  241     * Explicit column-major layout
  242     *
  243     * If a uniform block doesn't have an explicit layout set, it will default
  244     * to this layout.
  245     */
  246    GLSL_MATRIX_LAYOUT_COLUMN_MAJOR,
  247 
  248    /**
  249     * Row-major layout
  250     */
  251    GLSL_MATRIX_LAYOUT_ROW_MAJOR
  252 };
  253 
  254 enum {
  255    GLSL_PRECISION_NONE = 0,
  256    GLSL_PRECISION_HIGH,
  257    GLSL_PRECISION_MEDIUM,
  258    GLSL_PRECISION_LOW
  259 };
  260 
  261 #ifdef __cplusplus
  262 } /* extern "C" */
  263 
  264 #include "GL/gl.h"
  265 #include "util/ralloc.h"
  266 #include "main/menums.h" /* for gl_texture_index, C++'s enum rules are broken */
  267 
  268 struct glsl_type {
  269    GLenum gl_type;
  270    glsl_base_type base_type:8;
  271 
  272    glsl_base_type sampled_type:8; /**< Type of data returned using this
  273                                    * sampler or image.  Only \c
  274                                    * GLSL_TYPE_FLOAT, \c GLSL_TYPE_INT,
  275                                    * and \c GLSL_TYPE_UINT are valid.
  276                                    */
  277 
  278    unsigned sampler_dimensionality:4; /**< \see glsl_sampler_dim */
  279    unsigned sampler_shadow:1;
  280    unsigned sampler_array:1;
  281    unsigned interface_packing:2;
  282    unsigned interface_row_major:1;
  283 
  284    /**
  285     * For \c GLSL_TYPE_STRUCT this specifies if the struct is packed or not.
  286     *
  287     * Only used for Compute kernels
  288     */
  289    unsigned packed:1;
  290 
  291 private:
  292    glsl_type() : mem_ctx(NULL)
  293    {
  294       // Dummy constructor, just for the sake of ASSERT_BITFIELD_SIZE.
  295    }
  296 
  297 public:
  298    /**
  299     * \name Vector and matrix element counts
  300     *
  301     * For scalars, each of these values will be 1.  For non-numeric types
  302     * these will be 0.
  303     */
  304    /*@{*/
  305    uint8_t vector_elements;    /**< 1, 2, 3, or 4 vector elements. */
  306    uint8_t matrix_columns;     /**< 1, 2, 3, or 4 matrix columns. */
  307    /*@}*/
  308 
  309    /**
  310     * For \c GLSL_TYPE_ARRAY, this is the length of the array.  For
  311     * \c GLSL_TYPE_STRUCT or \c GLSL_TYPE_INTERFACE, it is the number of
  312     * elements in the structure and the number of values pointed to by
  313     * \c fields.structure (below).
  314     */
  315    unsigned length;
  316 
  317    /**
  318     * Name of the data type
  319     *
  320     * Will never be \c NULL.
  321     */
  322    const char *name;
  323 
  324    /**
  325     * Explicit array, matrix, or vector stride.  This is used to communicate
  326     * explicit array layouts from SPIR-V.  Should be 0 if the type has no
  327     * explicit stride.
  328     */
  329    unsigned explicit_stride;
  330 
  331    /**
  332     * Subtype of composite data types.
  333     */
  334    union {
  335       const struct glsl_type *array;            /**< Type of array elements. */
  336       struct glsl_function_param *parameters;   /**< Parameters to function. */
  337       struct glsl_struct_field *structure;      /**< List of struct fields. */
  338    } fields;
  339 
  340    /**
  341     * \name Pointers to various public type singletons
  342     */
  343    /*@{*/
  344 #undef  DECL_TYPE
  345 #define DECL_TYPE(NAME, ...) \
  346    static const glsl_type *const NAME##_type;
  347 #undef  STRUCT_TYPE
  348 #define STRUCT_TYPE(NAME) \
  349    static const glsl_type *const struct_##NAME##_type;
  350 #include "compiler/builtin_type_macros.h"
  351    /*@}*/
  352 
  353    /**
  354     * Convenience accessors for vector types (shorter than get_instance()).
  355     * @{
  356     */
  357    static const glsl_type *vec(unsigned components, const glsl_type *const ts[]);
  358    static const glsl_type *vec(unsigned components);
  359    static const glsl_type *f16vec(unsigned components);
  360    static const glsl_type *dvec(unsigned components);
  361    static const glsl_type *ivec(unsigned components);
  362    static const glsl_type *uvec(unsigned components);
  363    static const glsl_type *bvec(unsigned components);
  364    static const glsl_type *i64vec(unsigned components);
  365    static const glsl_type *u64vec(unsigned components);
  366    static const glsl_type *i16vec(unsigned components);
  367    static const glsl_type *u16vec(unsigned components);
  368    static const glsl_type *i8vec(unsigned components);
  369    static const glsl_type *u8vec(unsigned components);
  370    /**@}*/
  371 
  372    /**
  373     * For numeric and boolean derived types returns the basic scalar type
  374     *
  375     * If the type is a numeric or boolean scalar, vector, or matrix type,
  376     * this function gets the scalar type of the individual components.  For
  377     * all other types, including arrays of numeric or boolean types, the
  378     * error type is returned.
  379     */
  380    const glsl_type *get_base_type() const;
  381 
  382    /**
  383     * Get the basic scalar type which this type aggregates.
  384     *
  385     * If the type is a numeric or boolean scalar, vector, or matrix, or an
  386     * array of any of those, this function gets the scalar type of the
  387     * individual components.  For structs and arrays of structs, this function
  388     * returns the struct type.  For samplers and arrays of samplers, this
  389     * function returns the sampler type.
  390     */
  391    const glsl_type *get_scalar_type() const;
  392 
  393    /**
  394     * Gets the "bare" type without any decorations or layout information.
  395     */
  396    const glsl_type *get_bare_type() const;
  397 
  398    /**
  399     * Gets the float16 version of this type.
  400     */
  401    const glsl_type *get_float16_type() const;
  402 
  403    /**
  404     * Get the instance of a built-in scalar, vector, or matrix type
  405     */
  406    static const glsl_type *get_instance(unsigned base_type, unsigned rows,
  407                                         unsigned columns,
  408                                         unsigned explicit_stride = 0,
  409                                         bool row_major = false);
  410 
  411    /**
  412     * Get the instance of a sampler type
  413     */
  414    static const glsl_type *get_sampler_instance(enum glsl_sampler_dim dim,
  415                                                 bool shadow,
  416                                                 bool array,
  417                                                 glsl_base_type type);
  418 
  419    static const glsl_type *get_image_instance(enum glsl_sampler_dim dim,
  420                                               bool array, glsl_base_type type);
  421 
  422    /**
  423     * Get the instance of an array type
  424     */
  425    static const glsl_type *get_array_instance(const glsl_type *base,
  426                                               unsigned elements,
  427                                               unsigned explicit_stride = 0);
  428 
  429    /**
  430     * Get the instance of a record type
  431     */
  432    static const glsl_type *get_struct_instance(const glsl_struct_field *fields,
  433                            unsigned num_fields,
  434                            const char *name,
  435                            bool packed = false);
  436 
  437    /**
  438     * Get the instance of an interface block type
  439     */
  440    static const glsl_type *get_interface_instance(const glsl_struct_field *fields,
  441                           unsigned num_fields,
  442                           enum glsl_interface_packing packing,
  443                           bool row_major,
  444                           const char *block_name);
  445 
  446    /**
  447     * Get the instance of an subroutine type
  448     */
  449    static const glsl_type *get_subroutine_instance(const char *subroutine_name);
  450 
  451    /**
  452     * Get the instance of a function type
  453     */
  454    static const glsl_type *get_function_instance(const struct glsl_type *return_type,
  455                                                  const glsl_function_param *parameters,
  456                                                  unsigned num_params);
  457 
  458    /**
  459     * Get the type resulting from a multiplication of \p type_a * \p type_b
  460     */
  461    static const glsl_type *get_mul_type(const glsl_type *type_a,
  462                                         const glsl_type *type_b);
  463 
  464    /**
  465     * Query the total number of scalars that make up a scalar, vector or matrix
  466     */
  467    unsigned components() const
  468    {
  469       return vector_elements * matrix_columns;
  470    }
  471 
  472    /**
  473     * Calculate the number of components slots required to hold this type
  474     *
  475     * This is used to determine how many uniform or varying locations a type
  476     * might occupy.
  477     */
  478    unsigned component_slots() const;
  479 
  480    /**
  481     * Calculate offset between the base location of the struct in
  482     * uniform storage and a struct member.
  483     * For the initial call, length is the index of the member to find the
  484     * offset for.
  485     */
  486    unsigned struct_location_offset(unsigned length) const;
  487 
  488    /**
  489     * Calculate the number of unique values from glGetUniformLocation for the
  490     * elements of the type.
  491     *
  492     * This is used to allocate slots in the UniformRemapTable, the amount of
  493     * locations may not match with actual used storage space by the driver.
  494     */
  495    unsigned uniform_locations() const;
  496 
  497    /**
  498     * Used to count the number of varyings contained in the type ignoring
  499     * innermost array elements.
  500     */
  501    unsigned varying_count() const;
  502 
  503    /**
  504     * Calculate the number of vec4 slots required to hold this type.
  505     *
  506     * This is the underlying recursive type_size function for
  507     * count_attribute_slots() (vertex inputs and varyings) but also for
  508     * gallium's !PIPE_CAP_PACKED_UNIFORMS case.
  509     */
  510    unsigned count_vec4_slots(bool is_gl_vertex_input, bool bindless) const;
  511 
  512    /**
  513     * Calculate the number of vec4 slots required to hold this type.
  514     *
  515     * This is the underlying recursive type_size function for
  516     * gallium's PIPE_CAP_PACKED_UNIFORMS case.
  517     */
  518    unsigned count_dword_slots(bool bindless) const;
  519 
  520    /**
  521     * Calculate the number of attribute slots required to hold this type
  522     *
  523     * This implements the language rules of GLSL 1.50 for counting the number
  524     * of slots used by a vertex attribute.  It also determines the number of
  525     * varying slots the type will use up in the absence of varying packing
  526     * (and thus, it can be used to measure the number of varying slots used by
  527     * the varyings that are generated by lower_packed_varyings).
  528     *
  529     * For vertex shader attributes - doubles only take one slot.
  530     * For inter-shader varyings - dvec3/dvec4 take two slots.
  531     *
  532     * Vulkan doesn’t make this distinction so the argument should always be
  533     * false.
  534     */
  535    unsigned count_attribute_slots(bool is_gl_vertex_input) const {
  536       return count_vec4_slots(is_gl_vertex_input, true);
  537    }
  538 
  539    /**
  540     * Alignment in bytes of the start of this type in a std140 uniform
  541     * block.
  542     */
  543    unsigned std140_base_alignment(bool row_major) const;
  544 
  545    /** Size in bytes of this type in a std140 uniform block.
  546     *
  547     * Note that this is not GL_UNIFORM_SIZE (which is the number of
  548     * elements in the array)
  549     */
  550    unsigned std140_size(bool row_major) const;
  551 
  552    /**
  553     * Gets an explicitly laid out type with the std140 layout.
  554     */
  555    const glsl_type *get_explicit_std140_type(bool row_major) const;
  556 
  557    /**
  558     * Alignment in bytes of the start of this type in a std430 shader
  559     * storage block.
  560     */
  561    unsigned std430_base_alignment(bool row_major) const;
  562 
  563    /**
  564     * Calculate array stride in bytes of this type in a std430 shader storage
  565     * block.
  566     */
  567    unsigned std430_array_stride(bool row_major) const;
  568 
  569    /**
  570     * Size in bytes of this type in a std430 shader storage block.
  571     *
  572     * Note that this is not GL_BUFFER_SIZE
  573     */
  574    unsigned std430_size(bool row_major) const;
  575 
  576    /**
  577     * Gets an explicitly laid out type with the std430 layout.
  578     */
  579    const glsl_type *get_explicit_std430_type(bool row_major) const;
  580 
  581    /**
  582     * Gets an explicitly laid out interface type.
  583     */
  584    const glsl_type *get_explicit_interface_type(bool supports_std430) const;
  585 
  586    /** Returns an explicitly laid out type given a type and size/align func
  587     *
  588     * The size/align func is only called for scalar and vector types and the
  589     * returned type is otherwise laid out in the natural way as follows:
  590     *
  591     *  - Arrays and matrices have a stride of ALIGN(elem_size, elem_align).
  592     *
  593     *  - Structure types have their elements in-order and as tightly packed as
  594     *    possible following the alignment required by the size/align func.
  595     *
  596     *  - All composite types (structures, matrices, and arrays) have an
  597     *    alignment equal to the highest alighment of any member of the composite.
  598     *
  599     * The types returned by this function are likely not suitable for most UBO
  600     * or SSBO layout because they do not add the extra array and substructure
  601     * alignment that is required by std140 and std430.
  602     */
  603    const glsl_type *get_explicit_type_for_size_align(glsl_type_size_align_func type_info,
  604                                                      unsigned *size, unsigned *align) const;
  605 
  606    /**
  607     * Alignment in bytes of the start of this type in OpenCL memory.
  608     */
  609    unsigned cl_alignment() const;
  610 
  611    /**
  612     * Size in bytes of this type in OpenCL memory
  613     */
  614    unsigned cl_size() const;
  615 
  616    /**
  617     * Size in bytes of this type based on its explicit data.
  618     *
  619     * When using SPIR-V shaders (ARB_gl_spirv), memory layouts are expressed
  620     * through explicit offset, stride and matrix layout, so the size
  621     * can/should be computed used those values.
  622     *
  623     * Note that the value returned by this method is only correct if such
  624     * values are set, so only with SPIR-V shaders. Should not be used with
  625     * GLSL shaders.
  626     */
  627    unsigned explicit_size(bool align_to_stride=false) const;
  628 
  629    /**
  630     * \brief Can this type be implicitly converted to another?
  631     *
  632     * \return True if the types are identical or if this type can be converted
  633     *         to \c desired according to Section 4.1.10 of the GLSL spec.
  634     *
  635     * \verbatim
  636     * From page 25 (31 of the pdf) of the GLSL 1.50 spec, Section 4.1.10
  637     * Implicit Conversions:
  638     *
  639     *     In some situations, an expression and its type will be implicitly
  640     *     converted to a different type. The following table shows all allowed
  641     *     implicit conversions:
  642     *
  643     *     Type of expression | Can be implicitly converted to
  644     *     --------------------------------------------------
  645     *     int                  float
  646     *     uint
  647     *
  648     *     ivec2                vec2
  649     *     uvec2
  650     *
  651     *     ivec3                vec3
  652     *     uvec3
  653     *
  654     *     ivec4                vec4
  655     *     uvec4
  656     *
  657     *     There are no implicit array or structure conversions. For example,
  658     *     an array of int cannot be implicitly converted to an array of float.
  659     *     There are no implicit conversions between signed and unsigned
  660     *     integers.
  661     * \endverbatim
  662     */
  663    bool can_implicitly_convert_to(const glsl_type *desired,
  664                                   _mesa_glsl_parse_state *state) const;
  665 
  666    /**
  667     * Query whether or not a type is a scalar (non-vector and non-matrix).
  668     */
  669    bool is_scalar() const
  670    {
  671       return (vector_elements == 1)
  672      && (base_type >= GLSL_TYPE_UINT)
  673      && (base_type <= GLSL_TYPE_IMAGE);
  674    }
  675 
  676    /**
  677     * Query whether or not a type is a vector
  678     */
  679    bool is_vector() const
  680    {
  681       return (vector_elements > 1)
  682      && (matrix_columns == 1)
  683      && (base_type >= GLSL_TYPE_UINT)
  684      && (base_type <= GLSL_TYPE_BOOL);
  685    }
  686 
  687    /**
  688     * Query whether or not a type is a matrix
  689     */
  690    bool is_matrix() const
  691    {
  692       /* GLSL only has float matrices. */
  693       return (matrix_columns > 1) && (base_type == GLSL_TYPE_FLOAT ||
  694                                       base_type == GLSL_TYPE_DOUBLE ||
  695                                       base_type == GLSL_TYPE_FLOAT16);
  696    }
  697 
  698    /**
  699     * Query whether or not a type is a non-array numeric type
  700     */
  701    bool is_numeric() const
  702    {
  703       return (base_type >= GLSL_TYPE_UINT) && (base_type <= GLSL_TYPE_INT64);
  704    }
  705 
  706    /**
  707     * Query whether or not a type is an integer.
  708     */
  709    bool is_integer() const
  710    {
  711       return glsl_base_type_is_integer(base_type);
  712    }
  713 
  714    /**
  715     * Query whether or not a type is an 32-bit integer.
  716     */
  717    bool is_integer_32() const
  718    {
  719       return (base_type == GLSL_TYPE_UINT) || (base_type == GLSL_TYPE_INT);
  720    }
  721 
  722    /**
  723     * Query whether or not a type is a 64-bit integer.
  724     */
  725    bool is_integer_64() const
  726    {
  727       return base_type == GLSL_TYPE_UINT64 || base_type == GLSL_TYPE_INT64;
  728    }
  729 
  730    /**
  731     * Query whether or not a type is a 32-bit or 64-bit integer
  732     */
  733    bool is_integer_32_64() const
  734    {
  735       return is_integer_32() || is_integer_64();
  736    }
  737 
  738    /**
  739     * Query whether or not type is an integral type, or for struct and array
  740     * types, contains an integral type.
  741     */
  742    bool contains_integer() const;
  743 
  744    /**
  745     * Query whether or not type is a double type, or for struct, interface and
  746     * array types, contains a double type.
  747     */
  748    bool contains_double() const;
  749 
  750    /**
  751     * Query whether or not type is a 64-bit type, or for struct, interface and
  752     * array types, contains a double type.
  753     */
  754    bool contains_64bit() const;
  755 
  756    /**
  757     * Query whether or not a type is a float type
  758     */
  759    bool is_float() const
  760    {
  761       return base_type == GLSL_TYPE_FLOAT;
  762    }
  763 
  764    /**
  765     * Query whether or not a type is a half-float or float type
  766     */
  767    bool is_float_16_32() const
  768    {
  769       return base_type == GLSL_TYPE_FLOAT16 || is_float();
  770    }
  771 
  772    /**
  773     * Query whether or not a type is a half-float, float or double
  774     */
  775    bool is_float_16_32_64() const
  776    {
  777       return base_type == GLSL_TYPE_FLOAT16 || is_float() || is_double();
  778    }
  779 
  780    /**
  781     * Query whether or not a type is a double type
  782     */
  783    bool is_double() const
  784    {
  785       return base_type == GLSL_TYPE_DOUBLE;
  786    }
  787 
  788    /**
  789     * Query whether a 64-bit type takes two slots.
  790     */
  791    bool is_dual_slot() const
  792    {
  793       return is_64bit() && vector_elements > 2;
  794    }
  795 
  796    /**
  797     * Query whether or not a type is 64-bit
  798     */
  799    bool is_64bit() const
  800    {
  801       return glsl_base_type_is_64bit(base_type);
  802    }
  803 
  804    /**
  805     * Query whether or not a type is 16-bit
  806     */
  807    bool is_16bit() const
  808    {
  809       return glsl_base_type_is_16bit(base_type);
  810    }
  811 
  812    /**
  813     * Query whether or not a type is 32-bit
  814     */
  815    bool is_32bit() const
  816    {
  817       return base_type == GLSL_TYPE_UINT ||
  818              base_type == GLSL_TYPE_INT ||
  819              base_type == GLSL_TYPE_FLOAT;
  820    }
  821 
  822    /**
  823     * Query whether or not a type is a non-array boolean type
  824     */
  825    bool is_boolean() const
  826    {
  827       return base_type == GLSL_TYPE_BOOL;
  828    }
  829 
  830    /**
  831     * Query whether or not a type is a sampler
  832     */
  833    bool is_sampler() const
  834    {
  835       return base_type == GLSL_TYPE_SAMPLER;
  836    }
  837 
  838    /**
  839     * Query whether or not type is a sampler, or for struct, interface and
  840     * array types, contains a sampler.
  841     */
  842    bool contains_sampler() const;
  843 
  844    /**
  845     * Query whether or not type is an array or for struct, interface and
  846     * array types, contains an array.
  847     */
  848    bool contains_array() const;
  849 
  850    /**
  851     * Get the Mesa texture target index for a sampler type.
  852     */
  853    gl_texture_index sampler_index() const;
  854 
  855    /**
  856     * Query whether or not type is an image, or for struct, interface and
  857     * array types, contains an image.
  858     */
  859    bool contains_image() const;
  860 
  861    /**
  862     * Query whether or not a type is an image
  863     */
  864    bool is_image() const
  865    {
  866       return base_type == GLSL_TYPE_IMAGE;
  867    }
  868 
  869    /**
  870     * Query whether or not a type is an array
  871     */
  872    bool is_array() const
  873    {
  874       return base_type == GLSL_TYPE_ARRAY;
  875    }
  876 
  877    bool is_array_of_arrays() const
  878    {
  879       return is_array() && fields.array->is_array();
  880    }
  881 
  882    /**
  883     * Query whether or not a type is a record
  884     */
  885    bool is_struct() const
  886    {
  887       return base_type == GLSL_TYPE_STRUCT;
  888    }
  889 
  890    /**
  891     * Query whether or not a type is an interface
  892     */
  893    bool is_interface() const
  894    {
  895       return base_type == GLSL_TYPE_INTERFACE;
  896    }
  897 
  898    /**
  899     * Query whether or not a type is the void type singleton.
  900     */
  901    bool is_void() const
  902    {
  903       return base_type == GLSL_TYPE_VOID;
  904    }
  905 
  906    /**
  907     * Query whether or not a type is the error type singleton.
  908     */
  909    bool is_error() const
  910    {
  911       return base_type == GLSL_TYPE_ERROR;
  912    }
  913 
  914    /**
  915     * Query if a type is unnamed/anonymous (named by the parser)
  916     */
  917 
  918    bool is_subroutine() const
  919    {
  920       return base_type == GLSL_TYPE_SUBROUTINE;
  921    }
  922    bool contains_subroutine() const;
  923 
  924    bool is_anonymous() const
  925    {
  926       return !strncmp(name, "#anon", 5);
  927    }
  928 
  929    /**
  930     * Get the type stripped of any arrays
  931     *
  932     * \return
  933     * Pointer to the type of elements of the first non-array type for array
  934     * types, or pointer to itself for non-array types.
  935     */
  936    const glsl_type *without_array() const
  937    {
  938       const glsl_type *t = this;
  939 
  940       while (t->is_array())
  941          t = t->fields.array;
  942 
  943       return t;
  944    }
  945 
  946    /**
  947     * Return the total number of elements in an array including the elements
  948     * in arrays of arrays.
  949     */
  950    unsigned arrays_of_arrays_size() const
  951    {
  952       if (!is_array())
  953          return 0;
  954 
  955       unsigned size = length;
  956       const glsl_type *base_type = fields.array;
  957 
  958       while (base_type->is_array()) {
  959          size = size * base_type->length;
  960          base_type = base_type->fields.array;
  961       }
  962       return size;
  963    }
  964 
  965    /**
  966     * Return bit size for this type.
  967     */
  968    unsigned bit_size() const
  969    {
  970       return glsl_base_type_bit_size(this->base_type);
  971    }
  972 
  973 
  974    /**
  975     * Query whether or not a type is an atomic_uint.
  976     */
  977    bool is_atomic_uint() const
  978    {
  979       return base_type == GLSL_TYPE_ATOMIC_UINT;
  980    }
  981 
  982    /**
  983     * Return the amount of atomic counter storage required for a type.
  984     */
  985    unsigned atomic_size() const
  986    {
  987       if (is_atomic_uint())
  988          return ATOMIC_COUNTER_SIZE;
  989       else if (is_array())
  990          return length * fields.array->atomic_size();
  991       else
  992          return 0;
  993    }
  994 
  995    /**
  996     * Return whether a type contains any atomic counters.
  997     */
  998    bool contains_atomic() const
  999    {
 1000       return atomic_size() > 0;
 1001    }
 1002 
 1003    /**
 1004     * Return whether a type contains any opaque types.
 1005     */
 1006    bool contains_opaque() const;
 1007 
 1008    /**
 1009     * Query the full type of a matrix row
 1010     *
 1011     * \return
 1012     * If the type is not a matrix, \c glsl_type::error_type is returned.
 1013     * Otherwise a type matching the rows of the matrix is returned.
 1014     */
 1015    const glsl_type *row_type() const
 1016    {
 1017       if (!is_matrix())
 1018          return error_type;
 1019 
 1020       if (explicit_stride && !interface_row_major)
 1021          return get_instance(base_type, matrix_columns, 1, explicit_stride);
 1022       else
 1023          return get_instance(base_type, matrix_columns, 1);
 1024    }
 1025 
 1026    /**
 1027     * Query the full type of a matrix column
 1028     *
 1029     * \return
 1030     * If the type is not a matrix, \c glsl_type::error_type is returned.
 1031     * Otherwise a type matching the columns of the matrix is returned.
 1032     */
 1033    const glsl_type *column_type() const
 1034    {
 1035       if (!is_matrix())
 1036          return error_type;
 1037 
 1038       if (explicit_stride && interface_row_major)
 1039          return get_instance(base_type, vector_elements, 1, explicit_stride);
 1040       else
 1041          return get_instance(base_type, vector_elements, 1);
 1042    }
 1043 
 1044    /**
 1045     * Get the type of a structure field
 1046     *
 1047     * \return
 1048     * Pointer to the type of the named field.  If the type is not a structure
 1049     * or the named field does not exist, \c glsl_type::error_type is returned.
 1050     */
 1051    const glsl_type *field_type(const char *name) const;
 1052 
 1053    /**
 1054     * Get the location of a field within a record type
 1055     */
 1056    int field_index(const char *name) const;
 1057 
 1058    /**
 1059     * Query the number of elements in an array type
 1060     *
 1061     * \return
 1062     * The number of elements in the array for array types or -1 for non-array
 1063     * types.  If the number of elements in the array has not yet been declared,
 1064     * zero is returned.
 1065     */
 1066    int array_size() const
 1067    {
 1068       return is_array() ? length : -1;
 1069    }
 1070 
 1071    /**
 1072     * Query whether the array size for all dimensions has been declared.
 1073     */
 1074    bool is_unsized_array() const
 1075    {
 1076       return is_array() && length == 0;
 1077    }
 1078 
 1079    /**
 1080     * Return the number of coordinate components needed for this
 1081     * sampler or image type.
 1082     *
 1083     * This is based purely on the sampler's dimensionality.  For example, this
 1084     * returns 1 for sampler1D, and 3 for sampler2DArray.
 1085     *
 1086     * Note that this is often different than actual coordinate type used in
 1087     * a texturing built-in function, since those pack additional values (such
 1088     * as the shadow comparator or projector) into the coordinate type.
 1089     */
 1090    int coordinate_components() const;
 1091 
 1092    /**
 1093     * Compares whether this type matches another type without taking into
 1094     * account the precision in structures.
 1095     *
 1096     * This is applied recursively so that structures containing structure
 1097     * members can also ignore the precision.
 1098     */
 1099    bool compare_no_precision(const glsl_type *b) const;
 1100 
 1101    /**
 1102     * Compare a record type against another record type.
 1103     *
 1104     * This is useful for matching record types declared on the same shader
 1105     * stage as well as across different shader stages.
 1106     * The option to not match name is needed for matching record types
 1107     * declared across different shader stages.
 1108     * The option to not match locations is to deal with places where the
 1109     * same struct is defined in a block which has a location set on it.
 1110     */
 1111    bool record_compare(const glsl_type *b, bool match_name,
 1112                        bool match_locations = true,
 1113                        bool match_precision = true) const;
 1114 
 1115    /**
 1116     * Get the type interface packing.
 1117     */
 1118    enum glsl_interface_packing get_interface_packing() const
 1119    {
 1120       return (enum glsl_interface_packing)interface_packing;
 1121    }
 1122 
 1123    /**
 1124     * Get the type interface packing used internally. For shared and packing
 1125     * layouts this is implementation defined.
 1126     */
 1127    enum glsl_interface_packing get_internal_ifc_packing(bool std430_supported) const
 1128    {
 1129       enum glsl_interface_packing packing = this->get_interface_packing();
 1130       if (packing == GLSL_INTERFACE_PACKING_STD140 ||
 1131           (!std430_supported &&
 1132            (packing == GLSL_INTERFACE_PACKING_SHARED ||
 1133             packing == GLSL_INTERFACE_PACKING_PACKED))) {
 1134          return GLSL_INTERFACE_PACKING_STD140;
 1135       } else {
 1136          assert(packing == GLSL_INTERFACE_PACKING_STD430 ||
 1137                 (std430_supported &&
 1138                  (packing == GLSL_INTERFACE_PACKING_SHARED ||
 1139                   packing == GLSL_INTERFACE_PACKING_PACKED)));
 1140          return GLSL_INTERFACE_PACKING_STD430;
 1141       }
 1142    }
 1143 
 1144    /**
 1145     * Check if the type interface is row major
 1146     */
 1147    bool get_interface_row_major() const
 1148    {
 1149       return (bool) interface_row_major;
 1150    }
 1151 
 1152    ~glsl_type();
 1153 
 1154 private:
 1155 
 1156    static mtx_t hash_mutex;
 1157 
 1158    /**
 1159     * ralloc context for the type itself.
 1160     */
 1161    void *mem_ctx;
 1162 
 1163    /** Constructor for vector and matrix types */
 1164    glsl_type(GLenum gl_type,
 1165              glsl_base_type base_type, unsigned vector_elements,
 1166              unsigned matrix_columns, const char *name,
 1167              unsigned explicit_stride = 0, bool row_major = false);
 1168 
 1169    /** Constructor for sampler or image types */
 1170    glsl_type(GLenum gl_type, glsl_base_type base_type,
 1171          enum glsl_sampler_dim dim, bool shadow, bool array,
 1172          glsl_base_type type, const char *name);
 1173 
 1174    /** Constructor for record types */
 1175    glsl_type(const glsl_struct_field *fields, unsigned num_fields,
 1176          const char *name, bool packed = false);
 1177 
 1178    /** Constructor for interface types */
 1179    glsl_type(const glsl_struct_field *fields, unsigned num_fields,
 1180          enum glsl_interface_packing packing,
 1181          bool row_major, const char *name);
 1182 
 1183    /** Constructor for interface types */
 1184    glsl_type(const glsl_type *return_type,
 1185              const glsl_function_param *params, unsigned num_params);
 1186 
 1187    /** Constructors for array types */
 1188    glsl_type(const glsl_type *array, unsigned length, unsigned explicit_stride);
 1189 
 1190    /** Constructor for subroutine types */
 1191    glsl_type(const char *name);
 1192 
 1193    /** Hash table containing the known explicit matrix and vector types. */
 1194    static struct hash_table *explicit_matrix_types;
 1195 
 1196    /** Hash table containing the known array types. */
 1197    static struct hash_table *array_types;
 1198 
 1199    /** Hash table containing the known struct types. */
 1200    static struct hash_table *struct_types;
 1201 
 1202    /** Hash table containing the known interface types. */
 1203    static struct hash_table *interface_types;
 1204 
 1205    /** Hash table containing the known subroutine types. */
 1206    static struct hash_table *subroutine_types;
 1207 
 1208    /** Hash table containing the known function types. */
 1209    static struct hash_table *function_types;
 1210 
 1211    static bool record_key_compare(const void *a, const void *b);
 1212    static unsigned record_key_hash(const void *key);
 1213 
 1214    /**
 1215     * \name Built-in type flyweights
 1216     */
 1217    /*@{*/
 1218 #undef  DECL_TYPE
 1219 #define DECL_TYPE(NAME, ...) static const glsl_type _##NAME##_type;
 1220 #undef  STRUCT_TYPE
 1221 #define STRUCT_TYPE(NAME)        static const glsl_type _struct_##NAME##_type;
 1222 #include "compiler/builtin_type_macros.h"
 1223    /*@}*/
 1224 
 1225    /**
 1226     * \name Friend functions.
 1227     *
 1228     * These functions are friends because they must have C linkage and the
 1229     * need to call various private methods or access various private static
 1230     * data.
 1231     */
 1232    /*@{*/
 1233    friend void glsl_type_singleton_init_or_ref(void);
 1234    friend void glsl_type_singleton_decref(void);
 1235    friend void _mesa_glsl_initialize_types(struct _mesa_glsl_parse_state *);
 1236    /*@}*/
 1237 };
 1238 
 1239 #undef DECL_TYPE
 1240 #undef STRUCT_TYPE
 1241 #endif /* __cplusplus */
 1242 
 1243 struct glsl_struct_field {
 1244    const struct glsl_type *type;
 1245    const char *name;
 1246 
 1247    /**
 1248     * For interface blocks, gl_varying_slot corresponding to the input/output
 1249     * if this is a built-in input/output (i.e. a member of the built-in
 1250     * gl_PerVertex interface block); -1 otherwise.
 1251     *
 1252     * Ignored for structs.
 1253     */
 1254    int location;
 1255 
 1256    /**
 1257     * For interface blocks, members may have an explicit byte offset
 1258     * specified; -1 otherwise. Also used for xfb_offset layout qualifier.
 1259     *
 1260     * Unless used for xfb_offset this field is ignored for structs.
 1261     */
 1262    int offset;
 1263 
 1264    /**
 1265     * For interface blocks, members may define a transform feedback buffer;
 1266     * -1 otherwise.
 1267     */
 1268    int xfb_buffer;
 1269 
 1270    /**
 1271     * For interface blocks, members may define a transform feedback stride;
 1272     * -1 otherwise.
 1273     */
 1274    int xfb_stride;
 1275 
 1276    /**
 1277     * For interface blocks, the interpolation mode (as in
 1278     * ir_variable::interpolation).  0 otherwise.
 1279     */
 1280    unsigned interpolation:3;
 1281 
 1282    /**
 1283     * For interface blocks, 1 if this variable uses centroid interpolation (as
 1284     * in ir_variable::centroid).  0 otherwise.
 1285     */
 1286    unsigned centroid:1;
 1287 
 1288    /**
 1289     * For interface blocks, 1 if this variable uses sample interpolation (as
 1290     * in ir_variable::sample). 0 otherwise.
 1291     */
 1292    unsigned sample:1;
 1293 
 1294    /**
 1295     * Layout of the matrix.  Uses glsl_matrix_layout values.
 1296     */
 1297    unsigned matrix_layout:2;
 1298 
 1299    /**
 1300     * For interface blocks, 1 if this variable is a per-patch input or output
 1301     * (as in ir_variable::patch). 0 otherwise.
 1302     */
 1303    unsigned patch:1;
 1304 
 1305    /**
 1306     * Precision qualifier
 1307     */
 1308    unsigned precision:2;
 1309 
 1310    /**
 1311     * Memory qualifiers, applicable to buffer variables defined in shader
 1312     * storage buffer objects (SSBOs)
 1313     */
 1314    unsigned memory_read_only:1;
 1315    unsigned memory_write_only:1;
 1316    unsigned memory_coherent:1;
 1317    unsigned memory_volatile:1;
 1318    unsigned memory_restrict:1;
 1319 
 1320    /**
 1321     * Layout format, applicable to image variables only.
 1322     */
 1323    enum pipe_format image_format;
 1324 
 1325    /**
 1326     * Any of the xfb_* qualifiers trigger the shader to be in transform
 1327     * feedback mode so we need to keep track of whether the buffer was
 1328     * explicitly set or if its just been assigned the default global value.
 1329     */
 1330    unsigned explicit_xfb_buffer:1;
 1331 
 1332    unsigned implicit_sized_array:1;
 1333 #ifdef __cplusplus
 1334 #define DEFAULT_CONSTRUCTORS(_type, _precision, _name)                  \
 1335    type(_type), name(_name), location(-1), offset(-1), xfb_buffer(0),   \
 1336    xfb_stride(0), interpolation(0), centroid(0),                        \
 1337    sample(0), matrix_layout(GLSL_MATRIX_LAYOUT_INHERITED), patch(0),    \
 1338    precision(_precision), memory_read_only(0),                          \
 1339    memory_write_only(0), memory_coherent(0), memory_volatile(0),        \
 1340    memory_restrict(0), image_format(PIPE_FORMAT_NONE),                  \
 1341    explicit_xfb_buffer(0),                                              \
 1342    implicit_sized_array(0)
 1343 
 1344    glsl_struct_field(const struct glsl_type *_type,
 1345                      int _precision,
 1346                      const char *_name)
 1347       : DEFAULT_CONSTRUCTORS(_type, _precision, _name)
 1348    {
 1349       /* empty */
 1350    }
 1351 
 1352    glsl_struct_field(const struct glsl_type *_type, const char *_name)
 1353       : DEFAULT_CONSTRUCTORS(_type, GLSL_PRECISION_NONE, _name)
 1354    {
 1355       /* empty */
 1356    }
 1357 
 1358    glsl_struct_field()
 1359       : DEFAULT_CONSTRUCTORS(NULL, GLSL_PRECISION_NONE, NULL)
 1360    {
 1361       /* empty */
 1362    }
 1363 #undef DEFAULT_CONSTRUCTORS
 1364 #endif
 1365 };
 1366 
 1367 struct glsl_function_param {
 1368    const struct glsl_type *type;
 1369 
 1370    bool in;
 1371    bool out;
 1372 };
 1373 
 1374 static inline unsigned int
 1375 glsl_align(unsigned int a, unsigned int align)
 1376 {
 1377    return (a + align - 1) / align * align;
 1378 }
 1379 
 1380 #endif /* GLSL_TYPES_H */