Lines Matching refs:var
92 ir_variable *var = ir->variable_referenced();
100 if (!var || var->data.mode != ir_var_shader_storage)
103 if (var->data.memory_write_only) {
104 found = var;
176 ir_variable *const var = node->as_variable();
178 if (var == NULL)
181 var->remove();
182 instructions->push_head(var);
186 ir_variable *const var = state->symbols->get_variable("gl_FragCoord");
187 if (var != NULL)
188 state->fs_uses_gl_fragcoord = var->data.used;
845 ir_variable *var = lhs->variable_referenced();
846 if (var && var->data.mode == ir_var_shader_out && !var->data.patch) {
924 if (deref && deref->var) {
925 deref->var->data.max_array_access = deref->type->length - 1;
1004 ir_variable *const var = d->variable_referenced();
1006 assert(var != NULL);
1008 if (var->data.max_array_access >= rhs->type->array_size()) {
1012 var->data.max_array_access);
1015 var->type = glsl_type::get_array_instance(lhs->type->fields.array,
1017 d->type = var->type;
1041 ir_variable *var = new(ctx) ir_variable(rhs->type, "assignment_tmp",
1043 instructions->push_tail(var);
1044 instructions->push_tail(assign(var, rhs));
1047 new(ctx) ir_dereference_variable(var);
1049 rvalue = new(ctx) ir_dereference_variable(var);
1067 ir_variable *var;
1069 var = new(ctx) ir_variable(lvalue->type, "_post_incdec_tmp",
1071 instructions->push_tail(var);
1073 instructions->push_tail(new(ctx) ir_assignment(new(ctx) ir_dereference_variable(var),
1076 return new(ctx) ir_dereference_variable(var);
2046 ir_variable *var =
2049 if (var == NULL) {
2053 var = state->symbols->get_variable(sub_name);
2057 if (var != NULL) {
2058 var->data.used = true;
2059 result = new(ctx) ir_dereference_variable(var);
2061 if ((var->data.mode == ir_var_auto || var->data.mode == ir_var_shader_out)
2064 && !is_gl_identifier(var->name)) {
2069 if (var->is_fb_fetch_color_output()) {
2076 if (var->data.memory_coherent && !state->EXT_shader_framebuffer_fetch_enable) {
2081 } else if (var->data.fb_fetch_output) {
2757 is_varying_var(ir_variable *var, gl_shader_stage target)
2761 return var->data.mode == ir_var_shader_out;
2763 return var->data.mode == ir_var_shader_in ||
2764 (var->data.mode == ir_var_system_value &&
2765 var->data.location == SYSTEM_VALUE_FRAG_COORD);
2767 return var->data.mode == ir_var_shader_out || var->data.mode == ir_var_shader_in;
2772 is_allowed_invariant(ir_variable *var, struct _mesa_glsl_parse_state *state)
2774 if (is_varying_var(var, state->stage))
2789 var->data.mode == ir_var_shader_out)
2828 ir_variable *var)
2830 if (var && !var->is_in_buffer_block()) {
2947 ir_variable *var,
3052 var->data.explicit_binding = true;
3053 var->data.binding = qual_binding;
3267 ir_variable *var,
3281 if (!state->check_explicit_uniform_location_allowed(loc, var))
3285 unsigned max_loc = qual_location + var->type->uniform_locations() - 1;
3289 ">= MAX_UNIFORM_LOCATIONS (%u)", var->name,
3294 var->data.explicit_location = true;
3295 var->data.location = qual_location;
3314 if (var->data.mode == ir_var_shader_in) {
3315 if (!state->check_explicit_attrib_location_allowed(loc, var))
3321 if (var->data.mode == ir_var_shader_out) {
3322 if (!state->check_separate_shader_objects_allowed(loc, var))
3334 if (var->data.mode == ir_var_shader_in || var->data.mode == ir_var_shader_out) {
3335 if (!state->check_separate_shader_objects_allowed(loc, var))
3345 if (var->data.mode == ir_var_shader_in) {
3346 if (!state->check_separate_shader_objects_allowed(loc, var))
3352 if (var->data.mode == ir_var_shader_out) {
3353 if (!state->check_explicit_attrib_location_allowed(loc, var))
3375 mode_string(var),
3378 var->data.explicit_location = true;
3382 var->data.location = (var->data.mode == ir_var_shader_in)
3390 if (var->data.patch)
3391 var->data.location = qual_location + VARYING_SLOT_PATCH0;
3393 var->data.location = qual_location + VARYING_SLOT_VAR0;
3397 var->data.location = (var->data.mode == ir_var_shader_out)
3430 var->data.explicit_index = true;
3431 var->data.index = qual_index;
3438 validate_storage_for_sampler_image_types(ir_variable *var,
3458 if (var->data.mode != ir_var_auto &&
3459 var->data.mode != ir_var_uniform &&
3460 var->data.mode != ir_var_shader_in &&
3461 var->data.mode != ir_var_shader_out &&
3462 var->data.mode != ir_var_function_in &&
3463 var->data.mode != ir_var_function_out &&
3464 var->data.mode != ir_var_function_inout) {
3472 if (var->data.mode != ir_var_uniform &&
3473 var->data.mode != ir_var_function_in) {
3531 ir_variable *var,
3535 const glsl_type *base_type = var->type->without_array();
3544 if (!validate_storage_for_sampler_image_types(var, state, loc))
3547 var->data.memory_read_only |= qual->flags.q.read_only;
3548 var->data.memory_write_only |= qual->flags.q.write_only;
3549 var->data.memory_coherent |= qual->flags.q.coherent;
3550 var->data.memory_volatile |= qual->flags.q._volatile;
3551 var->data.memory_restrict |= qual->flags.q.restrict_flag;
3554 if (var->data.mode == ir_var_function_in) {
3564 var->data.image_format = qual->image_format;
3566 if (var->data.mode == ir_var_uniform &&
3571 if (var->data.mode == ir_var_uniform) {
3581 var->data.image_format = PIPE_FORMAT_NONE;
3591 var->data.image_format != PIPE_FORMAT_R32_FLOAT &&
3592 var->data.image_format != PIPE_FORMAT_R32_SINT &&
3593 var->data.image_format != PIPE_FORMAT_R32_UINT &&
3594 !var->data.memory_read_only &&
3595 !var->data.memory_write_only) {
3661 ir_variable *var,
3692 !var->type->contains_sampler()) {
3699 !var->type->contains_image()) {
3709 if (var->type->contains_sampler() || var->type->contains_image()) {
3710 var->data.bindless = qual->flags.q.bindless_sampler ||
3715 var->data.bound = qual->flags.q.bound_sampler ||
3724 ir_variable *var,
3728 if (var->name != NULL && strcmp(var->name, "gl_FragCoord") == 0) {
3776 && (strcmp(var->name, "gl_FragCoord") != 0)) {
3787 apply_explicit_location(qual, var, state, loc);
3793 validate_component_layout_for_type(state, loc, var->type,
3795 var->data.explicit_component = true;
3796 var->data.location_frac = qual_component;
3809 apply_explicit_binding(state, loc, var, var->type, qual);
3818 var->data.stream = qual_stream;
3827 var->data.xfb_buffer = qual_xfb_buffer;
3829 var->data.explicit_xfb_buffer = true;
3835 unsigned component_size = var->type->contains_double() ? 8 : 4;
3840 var->type, component_size)) {
3841 var->data.offset = qual_xfb_offset;
3842 var->data.explicit_xfb_offset = true;
3850 var->data.xfb_stride = qual_xfb_stride;
3851 var->data.explicit_xfb_stride = true;
3855 if (var->type->contains_atomic()) {
3856 if (var->data.mode == ir_var_uniform) {
3857 if (var->data.explicit_binding) {
3859 &state->atomic_counter_offsets[var->data.binding];
3865 var->data.offset = *offset;
3866 *offset += var->type->atomic_size();
3872 } else if (var->data.mode != ir_var_function_in) {
3879 if (var->type->contains_sampler() &&
3880 !validate_storage_for_sampler_image_types(var, state, loc))
3932 && strcmp(var->name, "gl_FragDepth") != 0) {
3940 var->data.depth_layout = ir_depth_layout_any;
3943 var->data.depth_layout = ir_depth_layout_greater;
3946 var->data.depth_layout = ir_depth_layout_less;
3949 var->data.depth_layout = ir_depth_layout_unchanged;
3952 var->data.depth_layout = ir_depth_layout_none;
3968 validate_matrix_layout_for_type(state, loc, var->type, var);
3996 apply_bindless_qualifier_to_variable(qual, var, state, loc);
4008 if (var->name != NULL && strcmp(var->name, "gl_Layer") == 0) {
4026 ir_variable *var,
4034 if (var->data.used) {
4038 var->name);
4040 var->data.explicit_invariant = true;
4041 var->data.invariant = true;
4046 if (var->data.used) {
4050 var->name);
4052 var->data.precise = 1;
4065 var->data.read_only = 1;
4068 var->data.centroid = 1;
4071 var->data.sample = 1;
4075 var->data.precision =
4076 select_gles_precision(qual->precision, var->type, state, loc);
4080 var->data.patch = 1;
4083 var->type = glsl_type::error_type;
4115 assert(var->data.mode != ir_var_temporary);
4117 var->data.mode = is_parameter ? ir_var_function_inout : ir_var_shader_out;
4119 var->data.mode = is_parameter ? ir_var_function_in : ir_var_shader_in;
4122 var->data.mode = ir_var_shader_in;
4124 var->data.mode = is_parameter ? ir_var_function_out : ir_var_shader_out;
4126 var->data.mode = ir_var_shader_out;
4128 var->data.mode = ir_var_uniform;
4130 var->data.mode = ir_var_shader_storage;
4132 var->data.mode = ir_var_shader_shared;
4137 var->data.fb_fetch_output = qual->flags.q.in && qual->flags.q.out;
4139 var->data.fb_fetch_output = (strcmp(var->name, "gl_LastFragData") == 0);
4143 (strcmp(var->name, "gl_LastFragDepthARM") == 0 ||
4144 strcmp(var->name, "gl_LastFragStencilARM") == 0)) {
4145 var->data.fb_fetch_output = 1;
4149 if (var->data.fb_fetch_output)
4150 var->data.assigned = true;
4152 if (var->is_fb_fetch_color_output()) {
4153 var->data.memory_coherent = !qual->flags.q.non_coherent;
4161 if (var->data.memory_coherent &&
4179 if (!is_parameter && is_varying_var(var, state->stage)) {
4225 switch (var->type->without_array()->base_type) {
4259 if (state->all_invariant && var->data.mode == ir_var_shader_out) {
4260 var->data.explicit_invariant = true;
4261 var->data.invariant = true;
4264 var->data.interpolation =
4265 interpret_interpolation_qualifier(qual, var->type,
4266 (ir_variable_mode) var->data.mode,
4293 if (qual->flags.q.sample && (!is_varying_var(var, state->stage) || uses_deprecated_qualifier)) {
4298 if (qual->flags.q.centroid && !is_varying_var(var, state->stage)) {
4310 apply_image_qualifier_to_variable(qual, var, state, loc);
4333 ir_variable *var = *var_ptr;
4341 ir_variable *earlier = state->symbols->get_variable(var->name);
4344 !state->symbols->name_declared_this_scope(var->name))) {
4346 return var;
4363 if (earlier->data.mode != var->data.mode &&
4365 var->data.mode == ir_var_shader_in) &&
4366 !(strcmp(var->name, "gl_LastFragData") == 0 &&
4367 var->data.mode == ir_var_auto)) {
4370 var->name);
4380 if (earlier->type->is_unsized_array() && var->type->is_array()
4381 && (var->type->fields.array == earlier->type->fields.array)) {
4382 const int size = var->type->array_size();
4383 check_builtin_array_max_size(var->name, size, loc, state);
4390 earlier->type = var->type;
4391 delete var;
4392 var = NULL;
4394 } else if (earlier->type != var->type) {
4397 var->name);
4400 && strcmp(var->name, "gl_FragCoord") == 0) {
4421 && (strcmp(var->name, "gl_FrontColor") == 0
4422 || strcmp(var->name, "gl_BackColor") == 0
4423 || strcmp(var->name, "gl_FrontSecondaryColor") == 0
4424 || strcmp(var->name, "gl_BackSecondaryColor") == 0
4425 || strcmp(var->name, "gl_Color") == 0
4426 || strcmp(var->name, "gl_SecondaryColor") == 0)) {
4427 earlier->data.interpolation = var->data.interpolation;
4433 && strcmp(var->name, "gl_FragDepth") == 0) {
4447 && earlier->data.depth_layout != var->data.depth_layout) {
4452 depth_layout_string(var->data.depth_layout),
4456 earlier->data.depth_layout = var->data.depth_layout;
4459 strcmp(var->name, "gl_LastFragData") == 0 &&
4460 var->data.mode == ir_var_auto) {
4470 earlier->data.precision = var->data.precision;
4471 earlier->data.memory_coherent = var->data.memory_coherent;
4474 strcmp(var->name, "gl_Layer") == 0 &&
4480 (strcmp(var->name, "gl_Position") == 0 ||
4481 strcmp(var->name, "gl_PointSize") == 0)) {
4497 "%s must appear before any use", var->name);
4506 _mesa_glsl_error(&loc, state, "`%s' redeclared", var->name);
4516 process_initializer(ir_variable *var, ast_declaration *decl,
4532 if (var->data.mode == ir_var_uniform) {
4535 var->name);
4542 if (var->data.mode == ir_var_shader_storage) {
4545 var->name);
4564 if (var->type->contains_atomic() ||
4565 (!state->has_bindless() && var->type->contains_opaque())) {
4568 var->name, state->has_bindless() ? "atomic" : "opaque");
4571 if ((var->data.mode == ir_var_shader_in) && (state->current_function == NULL)) {
4577 var->name);
4580 if (var->data.mode == ir_var_shader_out && state->current_function == NULL) {
4584 var->name);
4592 _mesa_ast_set_aggregate_type(var->type, decl->initializer);
4594 ir_dereference *const lhs = new(state) ir_dereference_variable(var);
4679 if (var->type->is_numeric()) {
4681 var->constant_value = type->qualifier.flags.q.constant
4682 ? ir_constant::zero(state, var->type) : NULL;
4687 var->constant_value = type->qualifier.flags.q.constant
4691 if (var->type->is_numeric()) {
4693 rhs = var->constant_value = type->qualifier.flags.q.constant
4694 ? ir_constant::zero(state, var->type) : NULL;
4700 bool temp = var->data.read_only;
4702 var->data.read_only = false;
4719 var->constant_initializer = rhs->constant_expression_value(mem_ctx);
4720 var->data.has_initializer = true;
4721 var->data.is_implicit_initializer = false;
4743 var->type = initializer_type;
4746 var->data.read_only = temp;
4754 YYLTYPE loc, ir_variable *var,
4759 if (var->type->is_unsized_array()) {
4772 var->type = glsl_type::get_array_instance(var->type->fields.array,
4794 if (num_vertices != 0 && var->type->length != num_vertices) {
4798 var_category, var->type->length, num_vertices);
4799 } else if (*size != 0 && var->type->length != *size) {
4803 var_category, var->type->length, *size);
4805 *size = var->type->length;
4812 YYLTYPE loc, ir_variable *var)
4830 if (!var->type->is_array() && !var->data.patch) {
4838 if (var->data.patch)
4841 validate_layout_qualifier_vertex_count(state, loc, var, num_vertices,
4853 YYLTYPE loc, ir_variable *var)
4855 if (!var->type->is_array() && !var->data.patch) {
4862 if (var->data.patch)
4874 if (var->type->is_unsized_array()) {
4875 var->type = glsl_type::get_array_instance(var->type->fields.array,
4877 } else if (var->type->length != state->Const.MaxPatchVertices) {
4892 YYLTYPE loc, ir_variable *var)
4903 if (!var->type->is_array()) {
4910 validate_layout_qualifier_vertex_count(state, loc, var, num_vertices,
5052 * This is done here, based on the layout qualifier and the type of the image var
5261 ir_variable *var;
5297 var = new(ctx) ir_variable(var_type, identifier, ir_var_auto);
5354 apply_type_qualifier_to_variable(& this->type->qualifier, var, state,
5356 apply_layout_qualifier_to_variable(&this->type->qualifier, var, state,
5359 if ((state->zero_init & (1u << var->data.mode)) &&
5360 (var->type->is_numeric() || var->type->is_boolean())) {
5362 var->data.has_initializer = true;
5363 var->data.is_implicit_initializer = true;
5364 var->constant_initializer = new(var) ir_constant(var->type, &data);
5368 if (!is_allowed_invariant(var, state)) {
5371 "shader stages only", var->name);
5402 mode, var->name, extra);
5404 } else if (var->data.mode == ir_var_shader_in) {
5405 var->data.read_only = true;
5442 const glsl_type *check_type = var->type->without_array();
5471 var->type->is_array() ? "array of " : "",
5473 } else if (var->type->is_array() &&
5487 if (!var->type->is_array()) {
5492 handle_geometry_shader_input_decl(state, loc, var);
5507 const glsl_type *check_type = var->type->without_array();
5514 if (var->type->is_array() &&
5515 var->type->fields.array->is_array()) {
5521 if (var->type->is_array() &&
5522 var->type->fields.array->is_struct()) {
5527 if (var->type->is_struct()) {
5528 for (unsigned i = 0; i < var->type->length; i++) {
5529 if (var->type->fields.structure[i].type->is_array() ||
5530 var->type->fields.structure[i].type->is_struct())
5540 handle_tess_shader_input_decl(state, loc, var);
5542 } else if (var->data.mode == ir_var_shader_out) {
5543 const glsl_type *check_type = var->type->without_array();
5613 if (var->type->is_array() &&
5614 var->type->fields.array->is_array()) {
5621 const glsl_type *type = var->type;
5624 !var->data.patch && var->type->is_array()) {
5625 type = var->type->fields.array;
5649 handle_tess_ctrl_shader_output_decl(state, loc, var);
5651 } else if (var->type->contains_subroutine()) {
5653 var->data.how_declared = ir_var_hidden;
5690 !precision_qualifier_allowed(var->type)) {
5727 /* Examine var name here since var may get deleted in the next call */
5728 bool var_is_gl_id = is_gl_identifier(var->name);
5731 var = get_variable_being_redeclared(&var, decl->get_location(), state,
5736 var->data.how_declared == ir_var_declared_in_block) {
5739 "gl_PerVertex", var->name);
5741 var->data.how_declared = ir_var_declared_normally;
5745 result = process_initializer(var,
5765 const glsl_type *const t = var->type;
5787 (var->data.mode == ir_var_shader_in &&
5790 (var->data.mode == ir_var_shader_out &&
5821 if (var->type->is_unsized_array() &&
5822 var->type->without_array()->base_type == GLSL_TYPE_ATOMIC_UINT) {
5846 if (!state->symbols->add_variable(var)) {
5856 * global var is decled, then the function is defined with usage of
5857 * the global var. See glslparsertest's CorrectModule.frag.
5859 instructions->push_head(var);
5942 ir_variable *var = new(ctx)
5948 apply_type_qualifier_to_variable(& this->type->qualifier, var, state, & loc,
5951 if (((1u << var->data.mode) & state->zero_init) &&
5952 (var->type->is_numeric() || var->type->is_boolean())) {
5954 var->data.has_initializer = true;
5955 var->data.is_implicit_initializer = true;
5956 var->constant_initializer = new(var) ir_constant(var->type, &data);
5975 if ((var->data.mode == ir_var_function_inout || var->data.mode == ir_var_function_out)
5998 if ((var->data.mode == ir_var_function_inout || var->data.mode == ir_var_function_out)
6005 instructions->push_tail(var);
6429 foreach_in_list(ir_variable, var, &signature->parameters) {
6430 assert(var->as_variable() != NULL);
6435 if (state->symbols->name_declared_this_scope(var->name)) {
6438 _mesa_glsl_error(& loc, state, "parameter `%s' redeclared", var->name);
6440 state->symbols->add_variable(var);
7930 if (ir->var->data.mode == mode && ir->var->get_interface_type() == block) {
7963 apply_memory_qualifiers(ir_variable *var, glsl_struct_field field)
7965 var->data.memory_read_only = field.memory_read_only;
7966 var->data.memory_write_only = field.memory_write_only;
7967 var->data.memory_coherent = field.memory_coherent;
7968 var->data.memory_volatile = field.memory_volatile;
7969 var->data.memory_restrict = field.memory_restrict;
8198 ir_variable *var = state->symbols->get_variable(this->block_name);
8199 if (var && !var->type->is_interface()) {
8408 ir_variable *var;
8528 var = new(state) ir_variable(block_array_type,
8532 var = new(state) ir_variable(block_type,
8537 var->data.matrix_layout = matrix_layout == GLSL_MATRIX_LAYOUT_INHERITED
8541 var->data.read_only = true;
8543 var->data.patch = this->layout.flags.q.patch;
8546 handle_geometry_shader_input_decl(state, loc, var);
8549 handle_tess_shader_input_decl(state, loc, var);
8551 handle_tess_ctrl_shader_output_decl(state, loc, var);
8554 if (var->data.mode == ir_var_shader_storage)
8555 apply_memory_qualifiers(var, fields[i]);
8565 earlier->type = var->type;
8567 delete var;
8570 apply_explicit_binding(state, &loc, var, var->type,
8574 var->data.stream = qual_stream;
8576 var->data.location = expl_location;
8577 var->data.explicit_location = true;
8580 state->symbols->add_variable(var);
8581 instructions->push_tail(var);
8590 ir_variable *var =
8594 var->data.interpolation = fields[i].interpolation;
8595 var->data.centroid = fields[i].centroid;
8596 var->data.sample = fields[i].sample;
8597 var->data.patch = fields[i].patch;
8598 var->data.stream = qual_stream;
8599 var->data.location = fields[i].location;
8602 var->data.explicit_location = true;
8604 var->data.explicit_xfb_buffer = fields[i].explicit_xfb_buffer;
8605 var->data.xfb_buffer = fields[i].xfb_buffer;
8608 var->data.explicit_xfb_offset = true;
8609 var->data.offset = fields[i].offset;
8611 var->init_interface_type(block_type);
8614 var->data.read_only = true;
8618 var->data.precision =
8624 var->data.matrix_layout = matrix_layout == GLSL_MATRIX_LAYOUT_INHERITED
8627 var->data.matrix_layout = fields[i].matrix_layout;
8630 if (var->data.mode == ir_var_shader_storage)
8631 apply_memory_qualifiers(var, fields[i]);
8633 /* Examine var name here since var may get deleted in the next call */
8634 bool var_is_gl_id = is_gl_identifier(var->name);
8638 var =
8639 get_variable_being_redeclared(&var, loc, state,
8646 } else if (var->data.how_declared == ir_var_declared_normally) {
8649 var->name);
8651 var->data.how_declared = ir_var_declared_in_block;
8652 var->reinit_interface_type(block_type);
8657 if (state->symbols->get_variable(var->name) != NULL)
8658 _mesa_glsl_error(&loc, state, "`%s' redeclared", var->name);
8665 apply_explicit_binding(state, &loc, var,
8666 var->get_interface_type(), &this->layout);
8669 if (var->type->is_unsized_array()) {
8670 if (var->is_in_shader_storage_block() &&
8671 is_unsized_array_last_element(var)) {
8672 var->data.from_ssbo_unsized_array = true;
8694 state->symbols->add_variable(var);
8695 instructions->push_tail(var);
8721 ir_variable *const var = node->as_variable();
8722 if (var != NULL &&
8723 var->get_interface_type() == earlier_per_vertex &&
8724 var->data.mode == var_mode) {
8725 if (var->data.how_declared == ir_var_declared_normally) {
8729 var->name);
8731 state->symbols->disable_variable(var->name);
8732 var->remove();
8775 ir_variable *var = node->as_variable();
8776 if (var == NULL || var->data.mode != ir_var_shader_out)
8780 if (!var->type->is_unsized_array() || var->data.patch)
8783 if (var->data.max_array_access >= (int)num_vertices) {
8788 var->data.max_array_access, var->name);
8790 var->type = glsl_type::get_array_instance(var->type->fields.array,
8828 ir_variable *var = node->as_variable();
8829 if (var == NULL || var->data.mode != ir_var_shader_in)
8836 if (var->type->is_unsized_array()) {
8837 if (var->data.max_array_access >= (int)num_vertices) {
8842 var->data.max_array_access, var->name);
8844 var->type = glsl_type::get_array_instance(var->type->fields.array,
8942 ir_variable *var = new(state->symbols)
8944 var->data.how_declared = ir_var_declared_implicitly;
8945 var->data.read_only = true;
8946 instructions->push_tail(var);
8947 state->symbols->add_variable(var);
8952 var->constant_value = new(var) ir_constant(glsl_type::uvec3_type, &data);
8953 var->constant_initializer =
8954 new(var) ir_constant(glsl_type::uvec3_type, &data);
8955 var->data.has_initializer = true;
8956 var->data.is_implicit_initializer = false;
8978 ir_variable *var = node->as_variable();
8980 if (!var || !var->data.assigned)
8983 if (strcmp(var->name, "gl_FragColor") == 0) {
8985 if (!var->constant_initializer && state->zero_init) {
8987 var->data.has_initializer = true;
8988 var->data.is_implicit_initializer = true;
8989 var->constant_initializer = new(var) ir_constant(var->type, &data);
8992 else if (strcmp(var->name, "gl_FragData") == 0)
8994 else if (strcmp(var->name, "gl_SecondaryFragColorEXT") == 0)
8996 else if (strcmp(var->name, "gl_SecondaryFragDataEXT") == 0)
8998 else if (!is_gl_identifier(var->name)) {
9000 var->data.mode == ir_var_shader_out) {
9002 user_defined_fs_output = var;
9129 ir_variable *const var = node->as_variable();
9130 if (var != NULL && var->get_interface_type() == per_vertex &&
9131 var->data.mode == mode) {
9132 state->symbols->disable_variable(var->name);
9133 var->remove();