ast->set_is_lhs(true);
ir_rvalue *result = ast->hir(instructions, state);
+ /* Error happened processing function parameter */
+ if (!result) {
+ actual_parameters->push_tail(ir_rvalue::error_value(mem_ctx));
+ count++;
+ continue;
+ }
+
ir_constant *const constant =
result->constant_expression_value(mem_ctx);
!strcmp(func_name, "atomicCompSwap");
}
+static bool
+verify_atomic_image_parameter_qualifier(YYLTYPE *loc, _mesa_glsl_parse_state *state,
+ ir_variable *var)
+{
+ if (!var ||
+ (var->data.image_format != PIPE_FORMAT_R32_UINT &&
+ var->data.image_format != PIPE_FORMAT_R32_SINT &&
+ var->data.image_format != PIPE_FORMAT_R32_FLOAT)) {
+ _mesa_glsl_error(loc, state, "Image atomic functions should use r32i/r32ui "
+ "format qualifier");
+ return false;
+ }
+ return true;
+}
+
+static bool
+is_atomic_image_function(const char *func_name)
+{
+ return !strcmp(func_name, "imageAtomicAdd") ||
+ !strcmp(func_name, "imageAtomicMin") ||
+ !strcmp(func_name, "imageAtomicMax") ||
+ !strcmp(func_name, "imageAtomicAnd") ||
+ !strcmp(func_name, "imageAtomicOr") ||
+ !strcmp(func_name, "imageAtomicXor") ||
+ !strcmp(func_name, "imageAtomicExchange") ||
+ !strcmp(func_name, "imageAtomicCompSwap") ||
+ !strcmp(func_name, "imageAtomicIncWrap") ||
+ !strcmp(func_name, "imageAtomicDecWrap");
+}
+
+
/**
* Verify that 'out' and 'inout' actual parameters are lvalues. Also, verify
* that 'const_in' formal parameters (an extension in our IR) correspond to
const ast_expression *const actual_ast =
exec_node_data(ast_expression, actual_ast_node, link);
- /* FIXME: 'loc' is incorrect (as of 2011-01-21). It is always
- * FIXME: 0:0(0).
- */
YYLTYPE loc = actual_ast->get_location();
/* Verify that 'const_in' parameters are ir_constants. */
actual->variable_referenced())) {
return false;
}
+ } else if (is_atomic_image_function(func_name)) {
+ const ir_rvalue *const actual =
+ (ir_rvalue *) actual_ir_parameters.get_head_raw();
+
+ const ast_expression *const actual_ast =
+ exec_node_data(ast_expression,
+ actual_ast_parameters.get_head_raw(), link);
+ YYLTYPE loc = actual_ast->get_location();
+
+ if (!verify_atomic_image_parameter_qualifier(&loc, state,
+ actual->variable_referenced())) {
+ return false;
+ }
}
return true;
ir_call *call = new(ctx) ir_call(sig, deref,
actual_parameters, sub_var, array_idx);
instructions->push_tail(call);
- if (sig->is_builtin()) {
- /* inline immediately */
- call->generate_inline(call);
- call->remove();
- }
/* Also emit any necessary out-parameter conversions. */
instructions->append_list(&post_call_conversions);
}
/* Local shader has no exact candidates; check the built-ins. */
- _mesa_glsl_initialize_builtin_functions();
sig = _mesa_glsl_find_builtin_function(state, name, actual_parameters);
/* if _mesa_glsl_find_builtin_function failed, fall back to the result
}
}
+static bool
+function_exists(_mesa_glsl_parse_state *state,
+ struct glsl_symbol_table *symbols, const char *name)
+{
+ ir_function *f = symbols->get_function(name);
+ if (f != NULL) {
+ foreach_in_list(ir_function_signature, sig, &f->signatures) {
+ if (sig->is_builtin() && !sig->is_builtin_available(state))
+ continue;
+ return true;
+ }
+ }
+ return false;
+}
+
static void
print_function_prototypes(_mesa_glsl_parse_state *state, YYLTYPE *loc,
ir_function *f)
{
gl_shader *sh = _mesa_glsl_get_builtin_function_shader();
- if (state->symbols->get_function(name) == NULL
+ if (!function_exists(state, state->symbols, name)
&& (!state->uses_builtin_functions
- || sh->symbols->get_function(name) == NULL)) {
+ || !function_exists(state, sh->symbols, name))) {
_mesa_glsl_error(loc, state, "no function with name '%s'", name);
} else {
char *str = prototype_string(NULL, name, actual_parameters);
}
if (constructor_type->is_array()) {
- if (!state->check_version(120, 300, &loc,
- "array constructors forbidden")) {
+ if (!state->check_version(state->allow_glsl_120_subset_in_110 ? 110 : 120,
+ 300, &loc, "array constructors forbidden")) {
return ir_rvalue::error_value(ctx);
}
new(ctx) ir_dereference_variable(mvp),
new(ctx) ir_dereference_variable(vtx));
} else {
- if (state->stage == MESA_SHADER_TESS_CTRL &&
- sig->is_builtin() && strcmp(func_name, "barrier") == 0) {
+ bool is_begin_interlock = false;
+ bool is_end_interlock = false;
+ if (sig->is_builtin() &&
+ state->stage == MESA_SHADER_FRAGMENT &&
+ state->ARB_fragment_shader_interlock_enable) {
+ is_begin_interlock = strcmp(func_name, "beginInvocationInterlockARB") == 0;
+ is_end_interlock = strcmp(func_name, "endInvocationInterlockARB") == 0;
+ }
+
+ if (sig->is_builtin() &&
+ ((state->stage == MESA_SHADER_TESS_CTRL &&
+ strcmp(func_name, "barrier") == 0) ||
+ is_begin_interlock || is_end_interlock)) {
if (state->current_function == NULL ||
strcmp(state->current_function->function_name(), "main") != 0) {
_mesa_glsl_error(&loc, state,
- "barrier() may only be used in main()");
+ "%s() may only be used in main()", func_name);
}
if (state->found_return) {
_mesa_glsl_error(&loc, state,
- "barrier() may not be used after return");
+ "%s() may not be used after return", func_name);
}
if (instructions != &state->current_function->body) {
_mesa_glsl_error(&loc, state,
- "barrier() may not be used in control flow");
+ "%s() may not be used in control flow", func_name);
}
}
+ /* There can be only one begin/end interlock pair in the function. */
+ if (is_begin_interlock) {
+ if (state->found_begin_interlock)
+ _mesa_glsl_error(&loc, state,
+ "beginInvocationInterlockARB may not be used twice");
+ state->found_begin_interlock = true;
+ } else if (is_end_interlock) {
+ if (!state->found_begin_interlock)
+ _mesa_glsl_error(&loc, state,
+ "endInvocationInterlockARB may not be used "
+ "before beginInvocationInterlockARB");
+ if (state->found_end_interlock)
+ _mesa_glsl_error(&loc, state,
+ "endInvocationInterlockARB may not be used twice");
+ state->found_end_interlock = true;
+ }
+
value = generate_call(instructions, sig, &actual_parameters, sub_var,
array_idx, state);
if (!value) {