← Back to branch summary

~ubuntu-branches/ubuntu/natty/mesa/natty-proposed

« back to all changes in this revision

Viewing changes to src/glsl/ir_function.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Robert Hooker, Robert Hooker, Christopher James Halse Rogers
  • Date: 2010-09-14 08:55:40 UTC
  • mfrom: (1.2.28 upstream)
  • Revision ID: james.westby@ubuntu.com-20100914085540-m4fpl0hdjlfd4jgz
Tags: 7.9~git20100909-0ubuntu1
https://launchpad.net/bugs/631413
https://launchpad.net/bugs/628930
https://launchpad.net/bugs/628727
https://launchpad.net/bugs/596292
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/630315
https://launchpad.net/bugs/613694
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/578619
https://launchpad.net/bugs/626943
https://launchpad.net/bugs/610541
https://launchpad.net/bugs/601052
[ Robert Hooker ]
* New upstream git snapshot up to commit 94118fe2d4b1e5 (LP: #631413)
* New features include ATI HD5xxx series support in r600, and a vastly
  improved glsl compiler.
* Remove pre-generated .pc's, use the ones generated at build time
  instead.
* Remove all references to mesa-utils now that its no longer shipped
  with the mesa source.
* Disable the experimental ARB_fragment_shader option by default on
  i915, it exposes incomplete functionality that breaks KDE compositing
  among other things. It can be enabled via driconf still. (LP: #628930).

[ Christopher James Halse Rogers ]
* debian/patches/04_osmesa_version.diff:
  - Refresh for new upstream
* Bugs fixed in this release:
  - Fixes severe rendering corruption in Unity on radeon (LP: #628727,
    LP: #596292, LP: #599741, LP: #630315, LP: #613694, LP: #599741).
  - Also fixes rendering in gnome-shell (LP: #578619).
  - Flickering in OpenGL apps on radeon (LP: #626943, LP: #610541).
  - Provides preliminary support for new intel chips (LP: #601052).
* debian/rules:
  - Update configure flags to match upstream reshuffling.
  - Explicitly remove gallium DRI drivers that we don't want to ship.
* Update debian/gbp.conf for this Maverick-specific packaging
* libegl1-mesa-dri-x11,kms: There are no longer separate kms or x11 drivers
  for EGL, libegl1-mesa-drivers now contains a single driver that provides
  both backends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/glsl/ir_function.cpp
 
1
/*
 
2
 * Copyright © 2010 Intel Corporation
 
3
 *
 
4
 * Permission is hereby granted, free of charge, to any person obtaining a
 
5
 * copy of this software and associated documentation files (the "Software"),
 
6
 * to deal in the Software without restriction, including without limitation
 
7
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 
8
 * and/or sell copies of the Software, and to permit persons to whom the
 
9
 * Software is furnished to do so, subject to the following conditions:
 
10
 *
 
11
 * The above copyright notice and this permission notice (including the next
 
12
 * paragraph) shall be included in all copies or substantial portions of the
 
13
 * Software.
 
14
 *
 
15
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
16
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
17
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 
18
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
19
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 
20
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 
21
 * DEALINGS IN THE SOFTWARE.
 
22
 */
 
23
 
 
24
#include "glsl_types.h"
 
25
#include "ir.h"
 
26
 
 
27
int
 
28
type_compare(const glsl_type *a, const glsl_type *b)
 
29
{
 
30
   /* If the types are the same, they trivially match.
 
31
    */
 
32
   if (a == b)
 
33
      return 0;
 
34
 
 
35
   switch (a->base_type) {
 
36
   case GLSL_TYPE_UINT:
 
37
   case GLSL_TYPE_INT:
 
38
   case GLSL_TYPE_BOOL:
 
39
      /* There is no implicit conversion to or from integer types or bool.
 
40
       */
 
41
      if ((a->is_integer() != b->is_integer())
 
42
          || (a->is_boolean() != b->is_boolean()))
 
43
         return -1;
 
44
 
 
45
      /* FALLTHROUGH */
 
46
 
 
47
   case GLSL_TYPE_FLOAT:
 
48
      if ((a->vector_elements != b->vector_elements)
 
49
          || (a->matrix_columns != b->matrix_columns))
 
50
         return -1;
 
51
 
 
52
      return 1;
 
53
 
 
54
   case GLSL_TYPE_SAMPLER:
 
55
   case GLSL_TYPE_STRUCT:
 
56
      /* Samplers and structures must match exactly.
 
57
       */
 
58
      return -1;
 
59
 
 
60
   case GLSL_TYPE_ARRAY:
 
61
      if ((b->base_type != GLSL_TYPE_ARRAY)
 
62
          || (a->length != b->length))
 
63
         return -1;
 
64
 
 
65
      /* From GLSL 1.50 spec, page 27 (page 33 of the PDF):
 
66
       *    "There are no implicit array or structure conversions."
 
67
       *
 
68
       * If the comparison of the array element types detects that a conversion
 
69
       * would be required, the array types do not match.
 
70
       */
 
71
      return (type_compare(a->fields.array, b->fields.array) == 0) ? 0 : -1;
 
72
 
 
73
   case GLSL_TYPE_FUNCTION:
 
74
   case GLSL_TYPE_VOID:
 
75
   case GLSL_TYPE_ERROR:
 
76
   default:
 
77
      /* These are all error conditions.  It is invalid for a parameter to
 
78
       * a function to be declared as error, void, or a function.
 
79
       */
 
80
      return -1;
 
81
   }
 
82
 
 
83
   /* This point should be unreachable.
 
84
    */
 
85
   assert(0);
 
86
}
 
87
 
 
88
 
 
89
static int
 
90
parameter_lists_match(const exec_list *list_a, const exec_list *list_b)
 
91
{
 
92
   const exec_node *node_a = list_a->head;
 
93
   const exec_node *node_b = list_b->head;
 
94
   int total_score = 0;
 
95
 
 
96
   for (/* empty */
 
97
        ; !node_a->is_tail_sentinel()
 
98
        ; node_a = node_a->next, node_b = node_b->next) {
 
99
      /* If all of the parameters from the other parameter list have been
 
100
       * exhausted, the lists have different length and, by definition,
 
101
       * do not match.
 
102
       */
 
103
      if (node_b->is_tail_sentinel())
 
104
         return -1;
 
105
 
 
106
 
 
107
      const ir_variable *const param = (ir_variable *) node_a;
 
108
      const ir_instruction *const actual = (ir_instruction *) node_b;
 
109
 
 
110
      /* Determine whether or not the types match.  If the types are an
 
111
       * exact match, the match score is zero.  If the types don't match
 
112
       * but the actual parameter can be coerced to the type of the declared
 
113
       * parameter, the match score is one.
 
114
       */
 
115
      int score;
 
116
      switch ((enum ir_variable_mode)(param->mode)) {
 
117
      case ir_var_auto:
 
118
      case ir_var_uniform:
 
119
      case ir_var_temporary:
 
120
         /* These are all error conditions.  It is invalid for a parameter to
 
121
          * a function to be declared as auto (not in, out, or inout) or
 
122
          * as uniform.
 
123
          */
 
124
         assert(0);
 
125
         return -1;
 
126
 
 
127
      case ir_var_in:
 
128
         score = type_compare(param->type, actual->type);
 
129
         break;
 
130
 
 
131
      case ir_var_out:
 
132
         score = type_compare(actual->type, param->type);
 
133
         break;
 
134
 
 
135
      case ir_var_inout:
 
136
         /* Since there are no bi-directional automatic conversions (e.g.,
 
137
          * there is int -> float but no float -> int), inout parameters must
 
138
          * be exact matches.
 
139
          */
 
140
         score = (type_compare(actual->type, param->type) == 0) ? 0 : -1;
 
141
         break;
 
142
 
 
143
      default:
 
144
         assert(false);
 
145
      }
 
146
 
 
147
      if (score < 0)
 
148
         return -1;
 
149
 
 
150
      total_score += score;
 
151
   }
 
152
 
 
153
   /* If all of the parameters from the other parameter list have been
 
154
    * exhausted, the lists have different length and, by definition, do not
 
155
    * match.
 
156
    */
 
157
   if (!node_b->is_tail_sentinel())
 
158
      return -1;
 
159
 
 
160
   return total_score;
 
161
}
 
162
 
 
163
 
 
164
ir_function_signature *
 
165
ir_function::matching_signature(const exec_list *actual_parameters)
 
166
{
 
167
   ir_function_signature *match = NULL;
 
168
 
 
169
   foreach_iter(exec_list_iterator, iter, signatures) {
 
170
      ir_function_signature *const sig =
 
171
         (ir_function_signature *) iter.get();
 
172
 
 
173
      const int score = parameter_lists_match(& sig->parameters,
 
174
                                              actual_parameters);
 
175
 
 
176
      if (score == 0)
 
177
         return sig;
 
178
 
 
179
      if (score > 0) {
 
180
         if (match != NULL)
 
181
            return NULL;
 
182
 
 
183
         match = sig;
 
184
      }
 
185
   }
 
186
 
 
187
   return match;
 
188
}
 
189
 
 
190
 
 
191
static bool
 
192
parameter_lists_match_exact(const exec_list *list_a, const exec_list *list_b)
 
193
{
 
194
   const exec_node *node_a = list_a->head;
 
195
   const exec_node *node_b = list_b->head;
 
196
 
 
197
   for (/* empty */
 
198
        ; !node_a->is_tail_sentinel() && !node_b->is_tail_sentinel()
 
199
        ; node_a = node_a->next, node_b = node_b->next) {
 
200
      ir_variable *a = (ir_variable *) node_a;
 
201
      ir_variable *b = (ir_variable *) node_b;
 
202
 
 
203
      /* If the types of the parameters do not match, the parameters lists
 
204
       * are different.
 
205
       */
 
206
      if (a->type != b->type)
 
207
         return false;
 
208
   }
 
209
 
 
210
   /* Unless both lists are exhausted, they differ in length and, by
 
211
    * definition, do not match.
 
212
    */
 
213
   return (node_a->is_tail_sentinel() == node_b->is_tail_sentinel());
 
214
}
 
215
 
 
216
ir_function_signature *
 
217
ir_function::exact_matching_signature(const exec_list *actual_parameters)
 
218
{
 
219
   foreach_iter(exec_list_iterator, iter, signatures) {
 
220
      ir_function_signature *const sig =
 
221
         (ir_function_signature *) iter.get();
 
222
 
 
223
      if (parameter_lists_match_exact(&sig->parameters, actual_parameters))
 
224
         return sig;
 
225
   }
 
226
   return NULL;
 
227
}