[Mesa-dev] [PATCH] glsl: rename image_* qualifiers to memory_*

Andres Gomez agomez at igalia.com
Thu May 4 05:49:42 UTC 2017


This is:

Reviewed-by: Andres Gomez <agomez at igalia.com>

On Wed, 2017-05-03 at 11:16 +0200, Samuel Pitoiset wrote:
> It doesn't make sense to prefix them with 'image' because
> they are called "Memory Qualifiers" and they can be applied
> to members of storage buffer blocks.
> 
> Signed-off-by: Samuel Pitoiset <samuel.pitoiset at gmail.com>
> ---
>  src/compiler/glsl/ast_function.cpp         | 10 +++---
>  src/compiler/glsl/ast_to_hir.cpp           | 54 +++++++++++++++---------------
>  src/compiler/glsl/builtin_functions.cpp    | 30 ++++++++---------
>  src/compiler/glsl/builtin_variables.cpp    | 10 +++---
>  src/compiler/glsl/glsl_to_nir.cpp          | 10 +++---
>  src/compiler/glsl/ir.cpp                   | 20 +++++------
>  src/compiler/glsl/ir.h                     | 12 +++----
>  src/compiler/glsl/link_uniforms.cpp        |  4 +--
>  src/compiler/glsl/lower_ubo_reference.cpp  | 12 +++----
>  src/compiler/glsl_types.cpp                | 20 +++++------
>  src/compiler/glsl_types.h                  | 18 +++++-----
>  src/mesa/state_tracker/st_glsl_to_tgsi.cpp |  6 ++--
>  12 files changed, 103 insertions(+), 103 deletions(-)
> 
> diff --git a/src/compiler/glsl/ast_function.cpp b/src/compiler/glsl/ast_function.cpp
> index 1b90937ec8..bee5f0588b 100644
> --- a/src/compiler/glsl/ast_function.cpp
> +++ b/src/compiler/glsl/ast_function.cpp
> @@ -107,35 +107,35 @@ verify_image_parameter(YYLTYPE *loc, _mesa_glsl_parse_state *state,
>      *  qualifiers. [...] It is legal to have additional qualifiers
>      *  on a formal parameter, but not to have fewer."
>      */
> -   if (actual->data.image_coherent && !formal->data.image_coherent) {
> +   if (actual->data.memory_coherent && !formal->data.memory_coherent) {
>        _mesa_glsl_error(loc, state,
>                         "function call parameter `%s' drops "
>                         "`coherent' qualifier", formal->name);
>        return false;
>     }
>  
> -   if (actual->data.image_volatile && !formal->data.image_volatile) {
> +   if (actual->data.memory_volatile && !formal->data.memory_volatile) {
>        _mesa_glsl_error(loc, state,
>                         "function call parameter `%s' drops "
>                         "`volatile' qualifier", formal->name);
>        return false;
>     }
>  
> -   if (actual->data.image_restrict && !formal->data.image_restrict) {
> +   if (actual->data.memory_restrict && !formal->data.memory_restrict) {
>        _mesa_glsl_error(loc, state,
>                         "function call parameter `%s' drops "
>                         "`restrict' qualifier", formal->name);
>        return false;
>     }
>  
> -   if (actual->data.image_read_only && !formal->data.image_read_only) {
> +   if (actual->data.memory_read_only && !formal->data.memory_read_only) {
>        _mesa_glsl_error(loc, state,
>                         "function call parameter `%s' drops "
>                         "`readonly' qualifier", formal->name);
>        return false;
>     }
>  
> -   if (actual->data.image_write_only && !formal->data.image_write_only) {
> +   if (actual->data.memory_write_only && !formal->data.memory_write_only) {
>        _mesa_glsl_error(loc, state,
>                         "function call parameter `%s' drops "
>                         "`writeonly' qualifier", formal->name);
> diff --git a/src/compiler/glsl/ast_to_hir.cpp b/src/compiler/glsl/ast_to_hir.cpp
> index 20a0f11755..4cb62cdb23 100644
> --- a/src/compiler/glsl/ast_to_hir.cpp
> +++ b/src/compiler/glsl/ast_to_hir.cpp
> @@ -86,17 +86,17 @@ public:
>           return visit_continue;
>  
>        ir_variable *var = ir->variable_referenced();
> -      /* We can have image_write_only set on both images and buffer variables,
> +      /* We can have memory_write_only set on both images and buffer variables,
>         * but in the former there is a distinction between reads from
>         * the variable itself (write_only) and from the memory they point to
> -       * (image_write_only), while in the case of buffer variables there is
> +       * (memory_write_only), while in the case of buffer variables there is
>         * no such distinction, that is why this check here is limited to
>         * buffer variables alone.
>         */
>        if (!var || var->data.mode != ir_var_shader_storage)
>           return visit_continue;
>  
> -      if (var->data.image_write_only) {
> +      if (var->data.memory_write_only) {
>           found = var;
>           return visit_stop;
>        }
> @@ -947,11 +947,11 @@ do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,
>           error_emitted = true;
>        } else if (lhs_var != NULL && (lhs_var->data.read_only ||
>                   (lhs_var->data.mode == ir_var_shader_storage &&
> -                  lhs_var->data.image_read_only))) {
> -         /* We can have image_read_only set on both images and buffer variables,
> +                  lhs_var->data.memory_read_only))) {
> +         /* We can have memory_read_only set on both images and buffer variables,
>            * but in the former there is a distinction between assignments to
>            * the variable itself (read_only) and to the memory they point to
> -          * (image_read_only), while in the case of buffer variables there is
> +          * (memory_read_only), while in the case of buffer variables there is
>            * no such distinction, that is why this check here is limited to
>            * buffer variables alone.
>            */
> @@ -3359,11 +3359,11 @@ apply_image_qualifier_to_variable(const struct ast_type_qualifier *qual,
>                         "global variables");
>     }
>  
> -   var->data.image_read_only |= qual->flags.q.read_only;
> -   var->data.image_write_only |= qual->flags.q.write_only;
> -   var->data.image_coherent |= qual->flags.q.coherent;
> -   var->data.image_volatile |= qual->flags.q._volatile;
> -   var->data.image_restrict |= qual->flags.q.restrict_flag;
> +   var->data.memory_read_only |= qual->flags.q.read_only;
> +   var->data.memory_write_only |= qual->flags.q.write_only;
> +   var->data.memory_coherent |= qual->flags.q.coherent;
> +   var->data.memory_volatile |= qual->flags.q._volatile;
> +   var->data.memory_restrict |= qual->flags.q.restrict_flag;
>     var->data.read_only = true;
>  
>     if (qual->flags.q.explicit_image_format) {
> @@ -3401,8 +3401,8 @@ apply_image_qualifier_to_variable(const struct ast_type_qualifier *qual,
>         var->data.image_format != GL_R32F &&
>         var->data.image_format != GL_R32I &&
>         var->data.image_format != GL_R32UI &&
> -       !var->data.image_read_only &&
> -       !var->data.image_write_only) {
> +       !var->data.memory_read_only &&
> +       !var->data.memory_write_only) {
>        _mesa_glsl_error(loc, state, "image variables of format other than r32f, "
>                         "r32i or r32ui must be qualified `readonly' or "
>                         "`writeonly'");
> @@ -7153,24 +7153,24 @@ ast_process_struct_or_iface_block_members(exec_list *instructions,
>               * if set, overwrites the layout qualifier.
>               */
>              if (qual->flags.q.read_only) {
> -               fields[i].image_read_only = true;
> -               fields[i].image_write_only = false;
> +               fields[i].memory_read_only = true;
> +               fields[i].memory_write_only = false;
>              } else if (qual->flags.q.write_only) {
> -               fields[i].image_read_only = false;
> -               fields[i].image_write_only = true;
> +               fields[i].memory_read_only = false;
> +               fields[i].memory_write_only = true;
>              } else {
> -               fields[i].image_read_only = layout->flags.q.read_only;
> -               fields[i].image_write_only = layout->flags.q.write_only;
> +               fields[i].memory_read_only = layout->flags.q.read_only;
> +               fields[i].memory_write_only = layout->flags.q.write_only;
>              }
>  
>              /* For other qualifiers, we set the flag if either the layout
>               * qualifier or the field qualifier are set
>               */
> -            fields[i].image_coherent = qual->flags.q.coherent ||
> +            fields[i].memory_coherent = qual->flags.q.coherent ||
>                                          layout->flags.q.coherent;
> -            fields[i].image_volatile = qual->flags.q._volatile ||
> +            fields[i].memory_volatile = qual->flags.q._volatile ||
>                                          layout->flags.q._volatile;
> -            fields[i].image_restrict = qual->flags.q.restrict_flag ||
> +            fields[i].memory_restrict = qual->flags.q.restrict_flag ||
>                                          layout->flags.q.restrict_flag;
>           }
>  
> @@ -7295,11 +7295,11 @@ is_unsized_array_last_element(ir_variable *v)
>  static void
>  apply_memory_qualifiers(ir_variable *var, glsl_struct_field field)
>  {
> -   var->data.image_read_only = field.image_read_only;
> -   var->data.image_write_only = field.image_write_only;
> -   var->data.image_coherent = field.image_coherent;
> -   var->data.image_volatile = field.image_volatile;
> -   var->data.image_restrict = field.image_restrict;
> +   var->data.memory_read_only = field.memory_read_only;
> +   var->data.memory_write_only = field.memory_write_only;
> +   var->data.memory_coherent = field.memory_coherent;
> +   var->data.memory_volatile = field.memory_volatile;
> +   var->data.memory_restrict = field.memory_restrict;
>  }
>  
>  ir_rvalue *
> diff --git a/src/compiler/glsl/builtin_functions.cpp b/src/compiler/glsl/builtin_functions.cpp
> index 3abbb0c9f2..cc1432197b 100644
> --- a/src/compiler/glsl/builtin_functions.cpp
> +++ b/src/compiler/glsl/builtin_functions.cpp
> @@ -5929,11 +5929,11 @@ builtin_builder::_image_prototype(const glsl_type *image_type,
>      * accept everything that needs to be accepted, and reject cases
>      * like loads from write-only or stores to read-only images.
>      */
> -   image->data.image_read_only = (flags & IMAGE_FUNCTION_READ_ONLY) != 0;
> -   image->data.image_write_only = (flags & IMAGE_FUNCTION_WRITE_ONLY) != 0;
> -   image->data.image_coherent = true;
> -   image->data.image_volatile = true;
> -   image->data.image_restrict = true;
> +   image->data.memory_read_only = (flags & IMAGE_FUNCTION_READ_ONLY) != 0;
> +   image->data.memory_write_only = (flags & IMAGE_FUNCTION_WRITE_ONLY) != 0;
> +   image->data.memory_coherent = true;
> +   image->data.memory_volatile = true;
> +   image->data.memory_restrict = true;
>  
>     return sig;
>  }
> @@ -5969,11 +5969,11 @@ builtin_builder::_image_size_prototype(const glsl_type *image_type,
>      * accept everything that needs to be accepted, and reject cases
>      * like loads from write-only or stores to read-only images.
>      */
> -   image->data.image_read_only = true;
> -   image->data.image_write_only = true;
> -   image->data.image_coherent = true;
> -   image->data.image_volatile = true;
> -   image->data.image_restrict = true;
> +   image->data.memory_read_only = true;
> +   image->data.memory_write_only = true;
> +   image->data.memory_coherent = true;
> +   image->data.memory_volatile = true;
> +   image->data.memory_restrict = true;
>  
>     return sig;
>  }
> @@ -5994,11 +5994,11 @@ builtin_builder::_image_samples_prototype(const glsl_type *image_type,
>      * accept everything that needs to be accepted, and reject cases
>      * like loads from write-only or stores to read-only images.
>      */
> -   image->data.image_read_only = true;
> -   image->data.image_write_only = true;
> -   image->data.image_coherent = true;
> -   image->data.image_volatile = true;
> -   image->data.image_restrict = true;
> +   image->data.memory_read_only = true;
> +   image->data.memory_write_only = true;
> +   image->data.memory_coherent = true;
> +   image->data.memory_volatile = true;
> +   image->data.memory_restrict = true;
>  
>     return sig;
>  }
> diff --git a/src/compiler/glsl/builtin_variables.cpp b/src/compiler/glsl/builtin_variables.cpp
> index c232571f26..a45c9d62c7 100644
> --- a/src/compiler/glsl/builtin_variables.cpp
> +++ b/src/compiler/glsl/builtin_variables.cpp
> @@ -336,11 +336,11 @@ per_vertex_accumulator::add_field(int slot, const glsl_type *type,
>     this->fields[this->num_fields].sample = 0;
>     this->fields[this->num_fields].patch = 0;
>     this->fields[this->num_fields].precision = GLSL_PRECISION_NONE;
> -   this->fields[this->num_fields].image_read_only = 0;
> -   this->fields[this->num_fields].image_write_only = 0;
> -   this->fields[this->num_fields].image_coherent = 0;
> -   this->fields[this->num_fields].image_volatile = 0;
> -   this->fields[this->num_fields].image_restrict = 0;
> +   this->fields[this->num_fields].memory_read_only = 0;
> +   this->fields[this->num_fields].memory_write_only = 0;
> +   this->fields[this->num_fields].memory_coherent = 0;
> +   this->fields[this->num_fields].memory_volatile = 0;
> +   this->fields[this->num_fields].memory_restrict = 0;
>     this->fields[this->num_fields].explicit_xfb_buffer = 0;
>     this->fields[this->num_fields].xfb_buffer = -1;
>     this->fields[this->num_fields].xfb_stride = -1;
> diff --git a/src/compiler/glsl/glsl_to_nir.cpp b/src/compiler/glsl/glsl_to_nir.cpp
> index 189eb24ac6..307276555e 100644
> --- a/src/compiler/glsl/glsl_to_nir.cpp
> +++ b/src/compiler/glsl/glsl_to_nir.cpp
> @@ -426,11 +426,11 @@ nir_visitor::visit(ir_variable *ir)
>     var->data.index = ir->data.index;
>     var->data.binding = ir->data.binding;
>     var->data.offset = ir->data.offset;
> -   var->data.image.read_only = ir->data.image_read_only;
> -   var->data.image.write_only = ir->data.image_write_only;
> -   var->data.image.coherent = ir->data.image_coherent;
> -   var->data.image._volatile = ir->data.image_volatile;
> -   var->data.image.restrict_flag = ir->data.image_restrict;
> +   var->data.image.read_only = ir->data.memory_read_only;
> +   var->data.image.write_only = ir->data.memory_write_only;
> +   var->data.image.coherent = ir->data.memory_coherent;
> +   var->data.image._volatile = ir->data.memory_volatile;
> +   var->data.image.restrict_flag = ir->data.memory_restrict;
>     var->data.image.format = ir->data.image_format;
>     var->data.fb_fetch_output = ir->data.fb_fetch_output;
>  
> diff --git a/src/compiler/glsl/ir.cpp b/src/compiler/glsl/ir.cpp
> index 356eb0fbcf..6a8b790493 100644
> --- a/src/compiler/glsl/ir.cpp
> +++ b/src/compiler/glsl/ir.cpp
> @@ -1722,11 +1722,11 @@ ir_variable::ir_variable(const struct glsl_type *type, const char *name,
>     this->data.max_array_access = -1;
>     this->data.offset = 0;
>     this->data.precision = GLSL_PRECISION_NONE;
> -   this->data.image_read_only = false;
> -   this->data.image_write_only = false;
> -   this->data.image_coherent = false;
> -   this->data.image_volatile = false;
> -   this->data.image_restrict = false;
> +   this->data.memory_read_only = false;
> +   this->data.memory_write_only = false;
> +   this->data.memory_coherent = false;
> +   this->data.memory_volatile = false;
> +   this->data.memory_restrict = false;
>     this->data.from_ssbo_unsized_array = false;
>     this->data.fb_fetch_output = false;
>  
> @@ -1846,11 +1846,11 @@ ir_function_signature::qualifiers_match(exec_list *params)
>  	  a->data.centroid != b->data.centroid ||
>            a->data.sample != b->data.sample ||
>            a->data.patch != b->data.patch ||
> -          a->data.image_read_only != b->data.image_read_only ||
> -          a->data.image_write_only != b->data.image_write_only ||
> -          a->data.image_coherent != b->data.image_coherent ||
> -          a->data.image_volatile != b->data.image_volatile ||
> -          a->data.image_restrict != b->data.image_restrict) {
> +          a->data.memory_read_only != b->data.memory_read_only ||
> +          a->data.memory_write_only != b->data.memory_write_only ||
> +          a->data.memory_coherent != b->data.memory_coherent ||
> +          a->data.memory_volatile != b->data.memory_volatile ||
> +          a->data.memory_restrict != b->data.memory_restrict) {
>  
>  	 /* parameter a's qualifiers don't match */
>  	 return a->name;
> diff --git a/src/compiler/glsl/ir.h b/src/compiler/glsl/ir.h
> index 9ab4df7219..5a5729cdbe 100644
> --- a/src/compiler/glsl/ir.h
> +++ b/src/compiler/glsl/ir.h
> @@ -827,13 +827,13 @@ public:
>        ir_depth_layout depth_layout:3;
>  
>        /**
> -       * ARB_shader_image_load_store qualifiers.
> +       * Memory qualifiers.
>         */
> -      unsigned image_read_only:1; /**< "readonly" qualifier. */
> -      unsigned image_write_only:1; /**< "writeonly" qualifier. */
> -      unsigned image_coherent:1;
> -      unsigned image_volatile:1;
> -      unsigned image_restrict:1;
> +      unsigned memory_read_only:1; /**< "readonly" qualifier. */
> +      unsigned memory_write_only:1; /**< "writeonly" qualifier. */
> +      unsigned memory_coherent:1;
> +      unsigned memory_volatile:1;
> +      unsigned memory_restrict:1;
>  
>        /**
>         * ARB_shader_storage_buffer_object
> diff --git a/src/compiler/glsl/link_uniforms.cpp b/src/compiler/glsl/link_uniforms.cpp
> index f1e0885fbd..c195e767e2 100644
> --- a/src/compiler/glsl/link_uniforms.cpp
> +++ b/src/compiler/glsl/link_uniforms.cpp
> @@ -586,8 +586,8 @@ private:
>  
>           /* Set image access qualifiers */
>           const GLenum access =
> -            (current_var->data.image_read_only ? GL_READ_ONLY :
> -             current_var->data.image_write_only ? GL_WRITE_ONLY :
> +            (current_var->data.memory_read_only ? GL_READ_ONLY :
> +             current_var->data.memory_write_only ? GL_WRITE_ONLY :
>                  GL_READ_WRITE);
>  
>           const unsigned first = this->next_image;
> diff --git a/src/compiler/glsl/lower_ubo_reference.cpp b/src/compiler/glsl/lower_ubo_reference.cpp
> index bfaddac3ad..365b8ebc65 100644
> --- a/src/compiler/glsl/lower_ubo_reference.cpp
> +++ b/src/compiler/glsl/lower_ubo_reference.cpp
> @@ -411,13 +411,13 @@ lower_ubo_reference_visitor::ssbo_access_params()
>     if (variable->is_interface_instance()) {
>        assert(struct_field);
>  
> -      return ((struct_field->image_coherent ? ACCESS_COHERENT : 0) |
> -              (struct_field->image_restrict ? ACCESS_RESTRICT : 0) |
> -              (struct_field->image_volatile ? ACCESS_VOLATILE : 0));
> +      return ((struct_field->memory_coherent ? ACCESS_COHERENT : 0) |
> +              (struct_field->memory_restrict ? ACCESS_RESTRICT : 0) |
> +              (struct_field->memory_volatile ? ACCESS_VOLATILE : 0));
>     } else {
> -      return ((variable->data.image_coherent ? ACCESS_COHERENT : 0) |
> -              (variable->data.image_restrict ? ACCESS_RESTRICT : 0) |
> -              (variable->data.image_volatile ? ACCESS_VOLATILE : 0));
> +      return ((variable->data.memory_coherent ? ACCESS_COHERENT : 0) |
> +              (variable->data.memory_restrict ? ACCESS_RESTRICT : 0) |
> +              (variable->data.memory_volatile ? ACCESS_VOLATILE : 0));
>     }
>  }
>  
> diff --git a/src/compiler/glsl_types.cpp b/src/compiler/glsl_types.cpp
> index bf078ad614..22a54d06ef 100644
> --- a/src/compiler/glsl_types.cpp
> +++ b/src/compiler/glsl_types.cpp
> @@ -940,20 +940,20 @@ glsl_type::record_compare(const glsl_type *b, bool match_locations) const
>        if (this->fields.structure[i].patch
>            != b->fields.structure[i].patch)
>           return false;
> -      if (this->fields.structure[i].image_read_only
> -          != b->fields.structure[i].image_read_only)
> +      if (this->fields.structure[i].memory_read_only
> +          != b->fields.structure[i].memory_read_only)
>           return false;
> -      if (this->fields.structure[i].image_write_only
> -          != b->fields.structure[i].image_write_only)
> +      if (this->fields.structure[i].memory_write_only
> +          != b->fields.structure[i].memory_write_only)
>           return false;
> -      if (this->fields.structure[i].image_coherent
> -          != b->fields.structure[i].image_coherent)
> +      if (this->fields.structure[i].memory_coherent
> +          != b->fields.structure[i].memory_coherent)
>           return false;
> -      if (this->fields.structure[i].image_volatile
> -          != b->fields.structure[i].image_volatile)
> +      if (this->fields.structure[i].memory_volatile
> +          != b->fields.structure[i].memory_volatile)
>           return false;
> -      if (this->fields.structure[i].image_restrict
> -          != b->fields.structure[i].image_restrict)
> +      if (this->fields.structure[i].memory_restrict
> +          != b->fields.structure[i].memory_restrict)
>           return false;
>        if (this->fields.structure[i].precision
>            != b->fields.structure[i].precision)
> diff --git a/src/compiler/glsl_types.h b/src/compiler/glsl_types.h
> index 403663f7b8..9885866866 100644
> --- a/src/compiler/glsl_types.h
> +++ b/src/compiler/glsl_types.h
> @@ -966,14 +966,14 @@ struct glsl_struct_field {
>     unsigned precision:2;
>  
>     /**
> -    * Image qualifiers, applicable to buffer variables defined in shader
> +    * Memory qualifiers, applicable to buffer variables defined in shader
>      * storage buffer objects (SSBOs)
>      */
> -   unsigned image_read_only:1;
> -   unsigned image_write_only:1;
> -   unsigned image_coherent:1;
> -   unsigned image_volatile:1;
> -   unsigned image_restrict:1;
> +   unsigned memory_read_only:1;
> +   unsigned memory_write_only:1;
> +   unsigned memory_coherent:1;
> +   unsigned memory_volatile:1;
> +   unsigned memory_restrict:1;
>  
>     /**
>      * Any of the xfb_* qualifiers trigger the shader to be in transform
> @@ -988,9 +988,9 @@ struct glsl_struct_field {
>        : type(_type), name(_name), location(-1), offset(0), xfb_buffer(0),
>          xfb_stride(0), interpolation(0), centroid(0),
>          sample(0), matrix_layout(GLSL_MATRIX_LAYOUT_INHERITED), patch(0),
> -        precision(GLSL_PRECISION_NONE), image_read_only(0), image_write_only(0),
> -        image_coherent(0), image_volatile(0), image_restrict(0),
> -        explicit_xfb_buffer(0), implicit_sized_array(0)
> +        precision(GLSL_PRECISION_NONE), memory_read_only(0),
> +        memory_write_only(0), memory_coherent(0), memory_volatile(0),
> +        memory_restrict(0), explicit_xfb_buffer(0), implicit_sized_array(0)
>     {
>        /* empty */
>     }
> diff --git a/src/mesa/state_tracker/st_glsl_to_tgsi.cpp b/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
> index 0f8688a41c..1209bc6e65 100644
> --- a/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
> +++ b/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
> @@ -3888,11 +3888,11 @@ glsl_to_tgsi_visitor::visit_image_intrinsic(ir_call *ir)
>     inst->image_format = st_mesa_format_to_pipe_format(st_context(ctx),
>           _mesa_get_shader_image_format(imgvar->data.image_format));
>  
> -   if (imgvar->data.image_coherent)
> +   if (imgvar->data.memory_coherent)
>        inst->buffer_access |= TGSI_MEMORY_COHERENT;
> -   if (imgvar->data.image_restrict)
> +   if (imgvar->data.memory_restrict)
>        inst->buffer_access |= TGSI_MEMORY_RESTRICT;
> -   if (imgvar->data.image_volatile)
> +   if (imgvar->data.memory_volatile)
>        inst->buffer_access |= TGSI_MEMORY_VOLATILE;
>  }
>  
-- 
Br,

Andres


More information about the mesa-dev mailing list