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 "compiler/glsl_types.h"
  25 #include "ir.h"
  26 #include "glsl_parser_extras.h"
  27 #include "main/errors.h"
  28
  29 typedef enum {
  30    PARAMETER_LIST_NO_MATCH,
  31    PARAMETER_LIST_EXACT_MATCH,
  32    PARAMETER_LIST_INEXACT_MATCH /*< Match requires implicit conversion. */
  33 } parameter_list_match_t;
  34
  35 /**
  36  * \brief Check if two parameter lists match.
  37  *
  38  * \param list_a Parameters of the function definition.
  39  * \param list_b Actual parameters passed to the function.
  40  * \see matching_signature()
  41  */
  42 static parameter_list_match_t
  43 parameter_lists_match(_mesa_glsl_parse_state *state,
  44                       const exec_list *list_a, const exec_list *list_b)
  45 {
  46    const exec_node *node_a = list_a->head;
  47    const exec_node *node_b = list_b->head;
  48
  49    /* This is set to true if there is an inexact match requiring an implicit
  50     * conversion. */
  51    bool inexact_match = false;
  52
  53    for (/* empty */
  54         ; !node_a->is_tail_sentinel()
  55         ; node_a = node_a->next, node_b = node_b->next) {
  56       /* If all of the parameters from the other parameter list have been
  57        * exhausted, the lists have different length and, by definition,
  58        * do not match.
  59        */
  60       if (node_b->is_tail_sentinel())
  61          return PARAMETER_LIST_NO_MATCH;
  62
  63
  64       const ir_variable *const param = (ir_variable *) node_a;
  65       const ir_rvalue *const actual = (ir_rvalue *) node_b;
  66
  67       if (param->type == actual->type)
  68          continue;
  69
  70       /* Try to find an implicit conversion from actual to param. */
  71       inexact_match = true;
  72       switch ((enum ir_variable_mode)(param->data.mode)) {
  73       case ir_var_auto:
  74       case ir_var_uniform:
  75       case ir_var_shader_storage:
  76       case ir_var_temporary:
  77          /* These are all error conditions.  It is invalid for a parameter to
  78           * a function to be declared as auto (not in, out, or inout) or
  79           * as uniform.
  80           */
  81          assert(0);
  82          return PARAMETER_LIST_NO_MATCH;
  83
  84       case ir_var_const_in:
  85       case ir_var_function_in:
  86          if (!actual->type->can_implicitly_convert_to(param->type, state))
  87             return PARAMETER_LIST_NO_MATCH;
  88          break;
  89
  90       case ir_var_function_out:
  91          if (!param->type->can_implicitly_convert_to(actual->type, state))
  92             return PARAMETER_LIST_NO_MATCH;
  93          break;
  94
  95       case ir_var_function_inout:
  96          /* Since there are no bi-directional automatic conversions (e.g.,
  97           * there is int -> float but no float -> int), inout parameters must
  98           * be exact matches.
  99           */
 100          return PARAMETER_LIST_NO_MATCH;
 101
 102       default:
 103          assert(false);
 104          return PARAMETER_LIST_NO_MATCH;
 105       }
 106    }
 107
 108    /* If all of the parameters from the other parameter list have been
 109     * exhausted, the lists have different length and, by definition, do not
 110     * match.
 111     */
 112    if (!node_b->is_tail_sentinel())
 113       return PARAMETER_LIST_NO_MATCH;
 114
 115    if (inexact_match)
 116       return PARAMETER_LIST_INEXACT_MATCH;
 117    else
 118       return PARAMETER_LIST_EXACT_MATCH;
 119 }
 120
 121
 122 /* Classes of parameter match, sorted (mostly) best matches first.
 123  * See is_better_parameter_match() below for the exceptions.
 124  * */
 125 typedef enum {
 126    PARAMETER_EXACT_MATCH,
 127    PARAMETER_FLOAT_TO_DOUBLE,
 128    PARAMETER_INT_TO_FLOAT,
 129    PARAMETER_INT_TO_DOUBLE,
 130    PARAMETER_OTHER_CONVERSION,
 131 } parameter_match_t;
 132
 133
 134 static parameter_match_t
 135 get_parameter_match_type(const ir_variable *param,
 136                          const ir_rvalue *actual)
 137 {
 138    const glsl_type *from_type;
 139    const glsl_type *to_type;
 140
 141    if (param->data.mode == ir_var_function_out) {
 142       from_type = param->type;
 143       to_type = actual->type;
 144    } else {
 145       from_type = actual->type;
 146       to_type = param->type;
 147    }
 148
 149    if (from_type == to_type)
 150       return PARAMETER_EXACT_MATCH;
 151
 152    if (to_type->base_type == GLSL_TYPE_DOUBLE) {
 153       if (from_type->base_type == GLSL_TYPE_FLOAT)
 154          return PARAMETER_FLOAT_TO_DOUBLE;
 155       return PARAMETER_INT_TO_DOUBLE;
 156    }
 157
 158    if (to_type->base_type == GLSL_TYPE_FLOAT)
 159       return PARAMETER_INT_TO_FLOAT;
 160
 161    /* int -> uint and any other oddball conversions */
 162    return PARAMETER_OTHER_CONVERSION;
 163 }
 164
 165
 166 static bool
 167 is_better_parameter_match(parameter_match_t a_match,
 168                           parameter_match_t b_match)
 169 {
 170    /* From section 6.1 of the GLSL 4.00 spec (and the ARB_gpu_shader5 spec):
 171     *
 172     * 1. An exact match is better than a match involving any implicit
 173     * conversion.
 174     *
 175     * 2. A match involving an implicit conversion from float to double
 176     * is better than match involving any other implicit conversion.
 177     *
 178     * [XXX: Not in GLSL 4.0: Only in ARB_gpu_shader5:
 179     * 3. A match involving an implicit conversion from either int or uint
 180     * to float is better than a match involving an implicit conversion
 181     * from either int or uint to double.]
 182     *
 183     * If none of the rules above apply to a particular pair of conversions,
 184     * neither conversion is considered better than the other.
 185     *
 186     * --
 187     *
 188     * Notably, the int->uint conversion is *not* considered to be better
 189     * or worse than int/uint->float or int/uint->double.
 190     */
 191
 192    if (a_match >= PARAMETER_INT_TO_FLOAT && b_match == PARAMETER_OTHER_CONVERSION)
 193       return false;
 194
 195    return a_match < b_match;
 196 }
 197
 198
 199 static bool
 200 is_best_inexact_overload(const exec_list *actual_parameters,
 201                          ir_function_signature **matches,
 202                          int num_matches,
 203                          ir_function_signature *sig)
 204 {
 205    /* From section 6.1 of the GLSL 4.00 spec (and the ARB_gpu_shader5 spec):
 206     *
 207     * "A function definition A is considered a better
 208     * match than function definition B if:
 209     *
 210     *   * for at least one function argument, the conversion for that argument
 211     *     in A is better than the corresponding conversion in B; and
 212     *
 213     *   * there is no function argument for which the conversion in B is better
 214     *     than the corresponding conversion in A.
 215     *
 216     * If a single function definition is considered a better match than every
 217     * other matching function definition, it will be used.  Otherwise, a
 218     * semantic error occurs and the shader will fail to compile."
 219     */
 220    for (ir_function_signature **other = matches;
 221         other < matches + num_matches; other++) {
 222       if (*other == sig)
 223          continue;
 224
 225       const exec_node *node_a = sig->parameters.head;
 226       const exec_node *node_b = (*other)->parameters.head;
 227       const exec_node *node_p = actual_parameters->head;
 228
 229       bool better_for_some_parameter = false;
 230
 231       for (/* empty */
 232            ; !node_a->is_tail_sentinel()
 233            ; node_a = node_a->next,
 234              node_b = node_b->next,
 235              node_p = node_p->next) {
 236          parameter_match_t a_match = get_parameter_match_type(
 237                (const ir_variable *)node_a,
 238                (const ir_rvalue *)node_p);
 239          parameter_match_t b_match = get_parameter_match_type(
 240                (const ir_variable *)node_b,
 241                (const ir_rvalue *)node_p);
 242
 243          if (is_better_parameter_match(a_match, b_match))
 244                better_for_some_parameter = true;
 245
 246          if (is_better_parameter_match(b_match, a_match))
 247                return false;     /* B is better for this parameter */
 248       }
 249
 250       if (!better_for_some_parameter)
 251          return false;     /* A must be better than B for some parameter */
 252
 253    }
 254
 255    return true;
 256 }
 257
 258
 259 static ir_function_signature *
 260 choose_best_inexact_overload(_mesa_glsl_parse_state *state,
 261                              const exec_list *actual_parameters,
 262                              ir_function_signature **matches,
 263                              int num_matches)
 264 {
 265    if (num_matches == 0)
 266       return NULL;
 267
 268    if (num_matches == 1)
 269       return *matches;
 270
 271    /* Without GLSL 4.0 / ARB_gpu_shader5, there is no overload resolution
 272     * among multiple inexact matches. Note that state may be NULL here if
 273     * called from the linker; in that case we assume everything supported in
 274     * any GLSL version is available. */
 275    if (!state || state->is_version(400, 0) || state->ARB_gpu_shader5_enable) {
 276       for (ir_function_signature **sig = matches; sig < matches + num_matches; sig++) {
 277          if (is_best_inexact_overload(actual_parameters, matches, num_matches, *sig))
 278             return *sig;
 279       }
 280    }
 281
 282    return NULL;   /* no best candidate */
 283 }
 284
 285
 286 ir_function_signature *
 287 ir_function::matching_signature(_mesa_glsl_parse_state *state,
 288                                 const exec_list *actual_parameters,
 289                                 bool allow_builtins)
 290 {
 291    bool is_exact;
 292    return matching_signature(state, actual_parameters, allow_builtins,
 293                              &is_exact);
 294 }
 295
 296 ir_function_signature *
 297 ir_function::matching_signature(_mesa_glsl_parse_state *state,
 298                                 const exec_list *actual_parameters,
 299                                 bool allow_builtins,
 300                                 bool *is_exact)
 301 {
 302    ir_function_signature **inexact_matches = NULL;
 303    ir_function_signature **inexact_matches_temp;
 304    ir_function_signature *match = NULL;
 305    int num_inexact_matches = 0;
 306
 307    /* From page 42 (page 49 of the PDF) of the GLSL 1.20 spec:
 308     *
 309     * "If an exact match is found, the other signatures are ignored, and
 310     *  the exact match is used.  Otherwise, if no exact match is found, then
 311     *  the implicit conversions in Section 4.1.10 "Implicit Conversions" will
 312     *  be applied to the calling arguments if this can make their types match
 313     *  a signature.  In this case, it is a semantic error if there are
 314     *  multiple ways to apply these conversions to the actual arguments of a
 315     *  call such that the call can be made to match multiple signatures."
 316     */
 317    foreach_in_list(ir_function_signature, sig, &this->signatures) {
 318       /* Skip over any built-ins that aren't available in this shader. */
 319       if (sig->is_builtin() && (!allow_builtins ||
 320                                 !sig->is_builtin_available(state)))
 321          continue;
 322
 323       switch (parameter_lists_match(state, & sig->parameters, actual_parameters)) {
 324       case PARAMETER_LIST_EXACT_MATCH:
 325          *is_exact = true;
 326          free(inexact_matches);
 327          return sig;
 328       case PARAMETER_LIST_INEXACT_MATCH:
 329          inexact_matches_temp = (ir_function_signature **)
 330                realloc(inexact_matches,
 331                        sizeof(*inexact_matches) *
 332                        (num_inexact_matches + 1));
 333          if (inexact_matches_temp == NULL) {
 334             _mesa_error_no_memory(__func__);
 335             free(inexact_matches);
 336             return NULL;
 337          }
 338          inexact_matches = inexact_matches_temp;
 339          inexact_matches[num_inexact_matches++] = sig;
 340          continue;
 341       case PARAMETER_LIST_NO_MATCH:
 342          continue;
 343       default:
 344          assert(false);
 345          return NULL;
 346       }
 347    }
 348
 349    /* There is no exact match (we would have returned it by now).  If there
 350     * are multiple inexact matches, the call is ambiguous, which is an error.
 351     *
 352     * FINISHME: Report a decent error.  Returning NULL will likely result in
 353     * FINISHME: a "no matching signature" error; it should report that the
 354     * FINISHME: call is ambiguous.  But reporting errors from here is hard.
 355     */
 356    *is_exact = false;
 357
 358    match = choose_best_inexact_overload(state, actual_parameters,
 359                                         inexact_matches, num_inexact_matches);
 360
 361    free(inexact_matches);
 362    return match;
 363 }
 364
 365
 366 static bool
 367 parameter_lists_match_exact(const exec_list *list_a, const exec_list *list_b)
 368 {
 369    const exec_node *node_a = list_a->head;
 370    const exec_node *node_b = list_b->head;
 371
 372    for (/* empty */
 373         ; !node_a->is_tail_sentinel() && !node_b->is_tail_sentinel()
 374         ; node_a = node_a->next, node_b = node_b->next) {
 375       ir_variable *a = (ir_variable *) node_a;
 376       ir_variable *b = (ir_variable *) node_b;
 377
 378       /* If the types of the parameters do not match, the parameters lists
 379        * are different.
 380        */
 381       if (a->type != b->type)
 382          return false;
 383    }
 384
 385    /* Unless both lists are exhausted, they differ in length and, by
 386     * definition, do not match.
 387     */
 388    return (node_a->is_tail_sentinel() == node_b->is_tail_sentinel());
 389 }
 390
 391 ir_function_signature *
 392 ir_function::exact_matching_signature(_mesa_glsl_parse_state *state,
 393                                       const exec_list *actual_parameters)
 394 {
 395    foreach_in_list(ir_function_signature, sig, &this->signatures) {
 396       /* Skip over any built-ins that aren't available in this shader. */
 397       if (sig->is_builtin() && !sig->is_builtin_available(state))
 398          continue;
 399
 400       if (parameter_lists_match_exact(&sig->parameters, actual_parameters))
 401          return sig;
 402    }
 403    return NULL;
 404 }