#include "glsl_parser_extras.h"
#include "compiler/glsl_types.h"
#include "main/context.h"
+#include "util/u_string.h"
+#include "util/format/u_format.h"
#ifdef _MSC_VER
#pragma warning( disable : 4065 ) // switch statement contains 'default' but no 'case' labels
@$.last_line = 1;
@$.last_column = 1;
@$.source = 0;
+ @$.path = NULL;
}
%lex-param {struct _mesa_glsl_parse_state *state}
%union {
int n;
+ int64_t n64;
float real;
double dreal;
const char *identifier;
ast_node *then_statement;
ast_node *else_statement;
} selection_rest_statement;
+
+ const glsl_type *type;
}
-%token ATTRIBUTE CONST_TOK BOOL_TOK FLOAT_TOK INT_TOK UINT_TOK DOUBLE_TOK
-%token BREAK BUFFER CONTINUE DO ELSE FOR IF DISCARD RETURN SWITCH CASE DEFAULT
-%token BVEC2 BVEC3 BVEC4 IVEC2 IVEC3 IVEC4 UVEC2 UVEC3 UVEC4 VEC2 VEC3 VEC4 DVEC2 DVEC3 DVEC4
+%token ATTRIBUTE CONST_TOK
+%token <type> BASIC_TYPE_TOK
+%token BREAK BUFFER CONTINUE DO ELSE FOR IF DEMOTE DISCARD RETURN SWITCH CASE DEFAULT
%token CENTROID IN_TOK OUT_TOK INOUT_TOK UNIFORM VARYING SAMPLE
%token NOPERSPECTIVE FLAT SMOOTH
-%token MAT2X2 MAT2X3 MAT2X4
-%token MAT3X2 MAT3X3 MAT3X4
-%token MAT4X2 MAT4X3 MAT4X4
-%token DMAT2X2 DMAT2X3 DMAT2X4
-%token DMAT3X2 DMAT3X3 DMAT3X4
-%token DMAT4X2 DMAT4X3 DMAT4X4
-%token SAMPLER1D SAMPLER2D SAMPLER3D SAMPLERCUBE SAMPLER1DSHADOW SAMPLER2DSHADOW
-%token SAMPLERCUBESHADOW SAMPLER1DARRAY SAMPLER2DARRAY SAMPLER1DARRAYSHADOW
-%token SAMPLER2DARRAYSHADOW SAMPLERCUBEARRAY SAMPLERCUBEARRAYSHADOW
-%token ISAMPLER1D ISAMPLER2D ISAMPLER3D ISAMPLERCUBE
-%token ISAMPLER1DARRAY ISAMPLER2DARRAY ISAMPLERCUBEARRAY
-%token USAMPLER1D USAMPLER2D USAMPLER3D USAMPLERCUBE USAMPLER1DARRAY
-%token USAMPLER2DARRAY USAMPLERCUBEARRAY
-%token SAMPLER2DRECT ISAMPLER2DRECT USAMPLER2DRECT SAMPLER2DRECTSHADOW
-%token SAMPLERBUFFER ISAMPLERBUFFER USAMPLERBUFFER
-%token SAMPLER2DMS ISAMPLER2DMS USAMPLER2DMS
-%token SAMPLER2DMSARRAY ISAMPLER2DMSARRAY USAMPLER2DMSARRAY
-%token SAMPLEREXTERNALOES
-%token IMAGE1D IMAGE2D IMAGE3D IMAGE2DRECT IMAGECUBE IMAGEBUFFER
-%token IMAGE1DARRAY IMAGE2DARRAY IMAGECUBEARRAY IMAGE2DMS IMAGE2DMSARRAY
-%token IIMAGE1D IIMAGE2D IIMAGE3D IIMAGE2DRECT IIMAGECUBE IIMAGEBUFFER
-%token IIMAGE1DARRAY IIMAGE2DARRAY IIMAGECUBEARRAY IIMAGE2DMS IIMAGE2DMSARRAY
-%token UIMAGE1D UIMAGE2D UIMAGE3D UIMAGE2DRECT UIMAGECUBE UIMAGEBUFFER
-%token UIMAGE1DARRAY UIMAGE2DARRAY UIMAGECUBEARRAY UIMAGE2DMS UIMAGE2DMSARRAY
%token IMAGE1DSHADOW IMAGE2DSHADOW IMAGE1DARRAYSHADOW IMAGE2DARRAYSHADOW
%token COHERENT VOLATILE RESTRICT READONLY WRITEONLY
-%token ATOMIC_UINT
%token SHARED
%token STRUCT VOID_TOK WHILE
%token <identifier> IDENTIFIER TYPE_IDENTIFIER NEW_IDENTIFIER
%token <real> FLOATCONSTANT
%token <dreal> DOUBLECONSTANT
%token <n> INTCONSTANT UINTCONSTANT BOOLCONSTANT
+%token <n64> INT64CONSTANT UINT64CONSTANT
%token <identifier> FIELD_SELECTION
%token LEFT_OP RIGHT_OP
%token INC_OP DEC_OP LE_OP GE_OP EQ_OP NE_OP
%token VERSION_TOK EXTENSION LINE COLON EOL INTERFACE OUTPUT
%token PRAGMA_DEBUG_ON PRAGMA_DEBUG_OFF
%token PRAGMA_OPTIMIZE_ON PRAGMA_OPTIMIZE_OFF
+%token PRAGMA_WARNING_ON PRAGMA_WARNING_OFF
%token PRAGMA_INVARIANT_ALL
%token LAYOUT_TOK
%token DOT_TOK
%type <type_specifier> type_specifier
%type <type_specifier> type_specifier_nonarray
%type <array_specifier> array_specifier
-%type <identifier> basic_type_specifier_nonarray
+%type <type> basic_type_specifier_nonarray
%type <fully_specified_type> fully_specified_type
%type <function> function_prototype
%type <function> function_header
%type <n> unary_operator
%type <expression> function_identifier
%type <node> external_declaration
+%type <node> pragma_statement
%type <declarator_list> init_declarator_list
%type <declarator_list> single_declaration
%type <expression> initializer
%type <node> declaration
%type <node> declaration_statement
%type <node> jump_statement
+%type <node> demote_statement
%type <node> interface_block
%type <interface_block> basic_interface_block
%type <struct_specifier> struct_specifier
;
pragma_statement:
- PRAGMA_DEBUG_ON EOL
- | PRAGMA_DEBUG_OFF EOL
- | PRAGMA_OPTIMIZE_ON EOL
- | PRAGMA_OPTIMIZE_OFF EOL
+ PRAGMA_DEBUG_ON EOL { $$ = NULL; }
+ | PRAGMA_DEBUG_OFF EOL { $$ = NULL; }
+ | PRAGMA_OPTIMIZE_ON EOL { $$ = NULL; }
+ | PRAGMA_OPTIMIZE_OFF EOL { $$ = NULL; }
| PRAGMA_INVARIANT_ALL EOL
{
/* Pragma invariant(all) cannot be used in a fragment shader.
} else {
state->all_invariant = true;
}
+
+ $$ = NULL;
+ }
+ | PRAGMA_WARNING_ON EOL
+ {
+ void *mem_ctx = state->linalloc;
+ $$ = new(mem_ctx) ast_warnings_toggle(true);
+ }
+ | PRAGMA_WARNING_OFF EOL
+ {
+ void *mem_ctx = state->linalloc;
+ $$ = new(mem_ctx) ast_warnings_toggle(false);
}
;
$$->set_location(@1);
$$->primary_expression.uint_constant = $1;
}
+ | INT64CONSTANT
+ {
+ void *ctx = state->linalloc;
+ $$ = new(ctx) ast_expression(ast_int64_constant, NULL, NULL, NULL);
+ $$->set_location(@1);
+ $$->primary_expression.int64_constant = $1;
+ }
+ | UINT64CONSTANT
+ {
+ void *ctx = state->linalloc;
+ $$ = new(ctx) ast_expression(ast_uint64_constant, NULL, NULL, NULL);
+ $$->set_location(@1);
+ $$->primary_expression.uint64_constant = $1;
+ }
| FLOATCONSTANT
{
void *ctx = state->linalloc;
}
}
block->layout = block->default_layout;
-
+ if (!block->layout.push_to_global(& @1, state)) {
+ YYERROR;
+ }
$$ = $1;
}
;
$$->return_type = $1;
$$->identifier = $2;
- if ($1->qualifier.flags.q.subroutine) {
+ if ($1->qualifier.is_subroutine_decl()) {
/* add type for IDENTIFIER search */
state->symbols->add_type($2, glsl_type::get_subroutine_instance($2));
} else
$$->identifier = $2;
state->symbols->add_variable(new(state) ir_variable(NULL, $2, ir_var_auto));
}
+ | layout_qualifier type_specifier any_identifier
+ {
+ if (state->allow_layout_qualifier_on_function_parameter) {
+ void *ctx = state->linalloc;
+ $$ = new(ctx) ast_parameter_declarator();
+ $$->set_location_range(@2, @3);
+ $$->type = new(ctx) ast_fully_specified_type();
+ $$->type->set_location(@2);
+ $$->type->specifier = $2;
+ $$->identifier = $3;
+ state->symbols->add_variable(new(state) ir_variable(NULL, $3, ir_var_auto));
+ } else {
+ _mesa_glsl_error(&@1, state,
+ "is is not allowed on function parameter");
+ YYERROR;
+ }
+ }
| type_specifier any_identifier array_specifier
{
void *ctx = state->linalloc;
{
$$ = $2;
$$->type->qualifier = $1;
+ if (!$$->type->qualifier.push_to_global(& @1, state)) {
+ YYERROR;
+ }
}
| parameter_qualifier parameter_type_specifier
{
$$->type = new(ctx) ast_fully_specified_type();
$$->type->set_location_range(@1, @2);
$$->type->qualifier = $1;
+ if (!$$->type->qualifier.push_to_global(& @1, state)) {
+ YYERROR;
+ }
$$->type->specifier = $2;
}
;
$$ = new(ctx) ast_fully_specified_type();
$$->set_location_range(@1, @2);
$$->qualifier = $1;
+ if (!$$->qualifier.push_to_global(& @1, state)) {
+ YYERROR;
+ }
$$->specifier = $2;
if ($$->specifier->structure != NULL &&
$$->specifier->structure->is_declaration) {
state->ARB_conservative_depth_enable ||
state->is_version(420, 0))) {
if (match_layout_qualifier($1, "depth_any", state) == 0) {
- $$.flags.q.depth_any = 1;
+ $$.flags.q.depth_type = 1;
+ $$.depth_type = ast_depth_any;
} else if (match_layout_qualifier($1, "depth_greater", state) == 0) {
- $$.flags.q.depth_greater = 1;
+ $$.flags.q.depth_type = 1;
+ $$.depth_type = ast_depth_greater;
} else if (match_layout_qualifier($1, "depth_less", state) == 0) {
- $$.flags.q.depth_less = 1;
+ $$.flags.q.depth_type = 1;
+ $$.depth_type = ast_depth_less;
} else if (match_layout_qualifier($1, "depth_unchanged",
state) == 0) {
- $$.flags.q.depth_unchanged = 1;
+ $$.flags.q.depth_type = 1;
+ $$.depth_type = ast_depth_unchanged;
}
if ($$.flags.i && state->AMD_conservative_depth_warn) {
}
/* Layout qualifiers for ARB_shader_image_load_store. */
- if (state->ARB_shader_image_load_store_enable ||
- state->is_version(420, 310)) {
+ if (state->has_shader_image_load_store()) {
if (!$$.flags.i) {
static const struct {
const char *name;
- GLenum format;
+ enum pipe_format format;
glsl_base_type base_type;
/** Minimum desktop GLSL version required for the image
* format. Use 130 if already present in the original
unsigned required_essl;
/* NV_image_formats */
bool nv_image_formats;
+ bool ext_qualifiers;
} map[] = {
- { "rgba32f", GL_RGBA32F, GLSL_TYPE_FLOAT, 130, 310, false },
- { "rgba16f", GL_RGBA16F, GLSL_TYPE_FLOAT, 130, 310, false },
- { "rg32f", GL_RG32F, GLSL_TYPE_FLOAT, 130, 0, true },
- { "rg16f", GL_RG16F, GLSL_TYPE_FLOAT, 130, 0, true },
- { "r11f_g11f_b10f", GL_R11F_G11F_B10F, GLSL_TYPE_FLOAT, 130, 0, true },
- { "r32f", GL_R32F, GLSL_TYPE_FLOAT, 130, 310, false },
- { "r16f", GL_R16F, GLSL_TYPE_FLOAT, 130, 0, true },
- { "rgba32ui", GL_RGBA32UI, GLSL_TYPE_UINT, 130, 310, false },
- { "rgba16ui", GL_RGBA16UI, GLSL_TYPE_UINT, 130, 310, false },
- { "rgb10_a2ui", GL_RGB10_A2UI, GLSL_TYPE_UINT, 130, 0, true },
- { "rgba8ui", GL_RGBA8UI, GLSL_TYPE_UINT, 130, 310, false },
- { "rg32ui", GL_RG32UI, GLSL_TYPE_UINT, 130, 0, true },
- { "rg16ui", GL_RG16UI, GLSL_TYPE_UINT, 130, 0, true },
- { "rg8ui", GL_RG8UI, GLSL_TYPE_UINT, 130, 0, true },
- { "r32ui", GL_R32UI, GLSL_TYPE_UINT, 130, 310, false },
- { "r16ui", GL_R16UI, GLSL_TYPE_UINT, 130, 0, true },
- { "r8ui", GL_R8UI, GLSL_TYPE_UINT, 130, 0, true },
- { "rgba32i", GL_RGBA32I, GLSL_TYPE_INT, 130, 310, false },
- { "rgba16i", GL_RGBA16I, GLSL_TYPE_INT, 130, 310, false },
- { "rgba8i", GL_RGBA8I, GLSL_TYPE_INT, 130, 310, false },
- { "rg32i", GL_RG32I, GLSL_TYPE_INT, 130, 0, true },
- { "rg16i", GL_RG16I, GLSL_TYPE_INT, 130, 0, true },
- { "rg8i", GL_RG8I, GLSL_TYPE_INT, 130, 0, true },
- { "r32i", GL_R32I, GLSL_TYPE_INT, 130, 310, false },
- { "r16i", GL_R16I, GLSL_TYPE_INT, 130, 0, true },
- { "r8i", GL_R8I, GLSL_TYPE_INT, 130, 0, true },
- { "rgba16", GL_RGBA16, GLSL_TYPE_FLOAT, 130, 0, false },
- { "rgb10_a2", GL_RGB10_A2, GLSL_TYPE_FLOAT, 130, 0, true },
- { "rgba8", GL_RGBA8, GLSL_TYPE_FLOAT, 130, 310, false },
- { "rg16", GL_RG16, GLSL_TYPE_FLOAT, 130, 0, false },
- { "rg8", GL_RG8, GLSL_TYPE_FLOAT, 130, 0, true },
- { "r16", GL_R16, GLSL_TYPE_FLOAT, 130, 0, false },
- { "r8", GL_R8, GLSL_TYPE_FLOAT, 130, 0, true },
- { "rgba16_snorm", GL_RGBA16_SNORM, GLSL_TYPE_FLOAT, 130, 0, false },
- { "rgba8_snorm", GL_RGBA8_SNORM, GLSL_TYPE_FLOAT, 130, 310, false },
- { "rg16_snorm", GL_RG16_SNORM, GLSL_TYPE_FLOAT, 130, 0, false },
- { "rg8_snorm", GL_RG8_SNORM, GLSL_TYPE_FLOAT, 130, 0, true },
- { "r16_snorm", GL_R16_SNORM, GLSL_TYPE_FLOAT, 130, 0, false },
- { "r8_snorm", GL_R8_SNORM, GLSL_TYPE_FLOAT, 130, 0, true }
+ { "rgba32f", PIPE_FORMAT_R32G32B32A32_FLOAT, GLSL_TYPE_FLOAT, 130, 310, false, false },
+ { "rgba16f", PIPE_FORMAT_R16G16B16A16_FLOAT, GLSL_TYPE_FLOAT, 130, 310, false, false },
+ { "rg32f", PIPE_FORMAT_R32G32_FLOAT, GLSL_TYPE_FLOAT, 130, 0, true, false },
+ { "rg16f", PIPE_FORMAT_R16G16_FLOAT, GLSL_TYPE_FLOAT, 130, 0, true, false },
+ { "r11f_g11f_b10f", PIPE_FORMAT_R11G11B10_FLOAT, GLSL_TYPE_FLOAT, 130, 0, true, false },
+ { "r32f", PIPE_FORMAT_R32_FLOAT, GLSL_TYPE_FLOAT, 130, 310, false, false },
+ { "r16f", PIPE_FORMAT_R16_FLOAT, GLSL_TYPE_FLOAT, 130, 0, true, false },
+ { "rgba32ui", PIPE_FORMAT_R32G32B32A32_UINT, GLSL_TYPE_UINT, 130, 310, false, false },
+ { "rgba16ui", PIPE_FORMAT_R16G16B16A16_UINT, GLSL_TYPE_UINT, 130, 310, false, false },
+ { "rgb10_a2ui", PIPE_FORMAT_R10G10B10A2_UINT, GLSL_TYPE_UINT, 130, 0, true, false },
+ { "rgba8ui", PIPE_FORMAT_R8G8B8A8_UINT, GLSL_TYPE_UINT, 130, 310, false, false },
+ { "rg32ui", PIPE_FORMAT_R32G32_UINT, GLSL_TYPE_UINT, 130, 0, true, false },
+ { "rg16ui", PIPE_FORMAT_R16G16_UINT, GLSL_TYPE_UINT, 130, 0, true, false },
+ { "rg8ui", PIPE_FORMAT_R8G8_UINT, GLSL_TYPE_UINT, 130, 0, true, false },
+ { "r32ui", PIPE_FORMAT_R32_UINT, GLSL_TYPE_UINT, 130, 310, false, false },
+ { "r16ui", PIPE_FORMAT_R16_UINT, GLSL_TYPE_UINT, 130, 0, true, false },
+ { "r8ui", PIPE_FORMAT_R8_UINT, GLSL_TYPE_UINT, 130, 0, true, false },
+ { "rgba32i", PIPE_FORMAT_R32G32B32A32_SINT, GLSL_TYPE_INT, 130, 310, false, false },
+ { "rgba16i", PIPE_FORMAT_R16G16B16A16_SINT, GLSL_TYPE_INT, 130, 310, false, false },
+ { "rgba8i", PIPE_FORMAT_R8G8B8A8_SINT, GLSL_TYPE_INT, 130, 310, false, false },
+ { "rg32i", PIPE_FORMAT_R32G32_SINT, GLSL_TYPE_INT, 130, 0, true, false },
+ { "rg16i", PIPE_FORMAT_R16G16_SINT, GLSL_TYPE_INT, 130, 0, true, false },
+ { "rg8i", PIPE_FORMAT_R8G8_SINT, GLSL_TYPE_INT, 130, 0, true, false },
+ { "r32i", PIPE_FORMAT_R32_SINT, GLSL_TYPE_INT, 130, 310, false, false },
+ { "r16i", PIPE_FORMAT_R16_SINT, GLSL_TYPE_INT, 130, 0, true, false },
+ { "r8i", PIPE_FORMAT_R8_SINT, GLSL_TYPE_INT, 130, 0, true, false },
+ { "rgba16", PIPE_FORMAT_R16G16B16A16_UNORM, GLSL_TYPE_FLOAT, 130, 0, true, false },
+ { "rgb10_a2", PIPE_FORMAT_R10G10B10A2_UNORM, GLSL_TYPE_FLOAT, 130, 0, true, false },
+ { "rgba8", PIPE_FORMAT_R8G8B8A8_UNORM, GLSL_TYPE_FLOAT, 130, 310, false, false },
+ { "rg16", PIPE_FORMAT_R16G16_UNORM, GLSL_TYPE_FLOAT, 130, 0, true, false },
+ { "rg8", PIPE_FORMAT_R8G8_UNORM, GLSL_TYPE_FLOAT, 130, 0, true, false },
+ { "r16", PIPE_FORMAT_R16_UNORM, GLSL_TYPE_FLOAT, 130, 0, true, false },
+ { "r8", PIPE_FORMAT_R8_UNORM, GLSL_TYPE_FLOAT, 130, 0, true, false },
+ { "rgba16_snorm", PIPE_FORMAT_R16G16B16A16_SNORM, GLSL_TYPE_FLOAT, 130, 0, true, false },
+ { "rgba8_snorm", PIPE_FORMAT_R8G8B8A8_SNORM, GLSL_TYPE_FLOAT, 130, 310, false, false },
+ { "rg16_snorm", PIPE_FORMAT_R16G16_SNORM, GLSL_TYPE_FLOAT, 130, 0, true, false },
+ { "rg8_snorm", PIPE_FORMAT_R8G8_SNORM, GLSL_TYPE_FLOAT, 130, 0, true, false },
+ { "r16_snorm", PIPE_FORMAT_R16_SNORM, GLSL_TYPE_FLOAT, 130, 0, true, false },
+ { "r8_snorm", PIPE_FORMAT_R8_SNORM, GLSL_TYPE_FLOAT, 130, 0, true, false },
+
+ /* From GL_EXT_shader_image_load_store: */
+ /* base_type is incorrect but it'll be patched later when we know
+ * the variable type. See ast_to_hir.cpp */
+ { "size1x8", PIPE_FORMAT_R8_SINT, GLSL_TYPE_VOID, 130, 0, false, true },
+ { "size1x16", PIPE_FORMAT_R16_SINT, GLSL_TYPE_VOID, 130, 0, false, true },
+ { "size1x32", PIPE_FORMAT_R32_SINT, GLSL_TYPE_VOID, 130, 0, false, true },
+ { "size2x32", PIPE_FORMAT_R32G32_SINT, GLSL_TYPE_VOID, 130, 0, false, true },
+ { "size4x32", PIPE_FORMAT_R32G32B32A32_SINT, GLSL_TYPE_VOID, 130, 0, false, true },
};
for (unsigned i = 0; i < ARRAY_SIZE(map); i++) {
(state->NV_image_formats_enable &&
map[i].nv_image_formats)) &&
match_layout_qualifier($1, map[i].name, state) == 0) {
+ /* Skip ARB_shader_image_load_store qualifiers if not enabled */
+ if (!map[i].ext_qualifiers && !(state->ARB_shader_image_load_store_enable ||
+ state->is_version(420, 310))) {
+ continue;
+ }
+ /* Skip EXT_shader_image_load_store qualifiers if not enabled */
+ if (map[i].ext_qualifiers && !state->EXT_shader_image_load_store_enable) {
+ continue;
+ }
$$.flags.q.explicit_image_format = 1;
$$.image_format = map[i].format;
$$.image_base_type = map[i].base_type;
}
}
}
+ }
- if (!$$.flags.i &&
- match_layout_qualifier($1, "early_fragment_tests", state) == 0) {
+ if (!$$.flags.i) {
+ if (match_layout_qualifier($1, "early_fragment_tests", state) == 0) {
/* From section 4.4.1.3 of the GLSL 4.50 specification
* (Fragment Shader Inputs):
*
$$.flags.q.early_fragment_tests = 1;
}
+
+ if (match_layout_qualifier($1, "inner_coverage", state) == 0) {
+ if (state->stage != MESA_SHADER_FRAGMENT) {
+ _mesa_glsl_error(& @1, state,
+ "inner_coverage layout qualifier only "
+ "valid in fragment shaders");
+ }
+
+ if (state->INTEL_conservative_rasterization_enable) {
+ $$.flags.q.inner_coverage = 1;
+ } else {
+ _mesa_glsl_error(& @1, state,
+ "inner_coverage layout qualifier present, "
+ "but the INTEL_conservative_rasterization extension "
+ "is not enabled.");
+ }
+ }
+
+ if (match_layout_qualifier($1, "post_depth_coverage", state) == 0) {
+ if (state->stage != MESA_SHADER_FRAGMENT) {
+ _mesa_glsl_error(& @1, state,
+ "post_depth_coverage layout qualifier only "
+ "valid in fragment shaders");
+ }
+
+ if (state->ARB_post_depth_coverage_enable ||
+ state->INTEL_conservative_rasterization_enable) {
+ $$.flags.q.post_depth_coverage = 1;
+ } else {
+ _mesa_glsl_error(& @1, state,
+ "post_depth_coverage layout qualifier present, "
+ "but the GL_ARB_post_depth_coverage extension "
+ "is not enabled.");
+ }
+ }
+
+ if ($$.flags.q.post_depth_coverage && $$.flags.q.inner_coverage) {
+ _mesa_glsl_error(& @1, state,
+ "post_depth_coverage & inner_coverage layout qualifiers "
+ "are mutually exclusive");
+ }
+ }
+
+ const bool pixel_interlock_ordered = match_layout_qualifier($1,
+ "pixel_interlock_ordered", state) == 0;
+ const bool pixel_interlock_unordered = match_layout_qualifier($1,
+ "pixel_interlock_unordered", state) == 0;
+ const bool sample_interlock_ordered = match_layout_qualifier($1,
+ "sample_interlock_ordered", state) == 0;
+ const bool sample_interlock_unordered = match_layout_qualifier($1,
+ "sample_interlock_unordered", state) == 0;
+
+ if (pixel_interlock_ordered + pixel_interlock_unordered +
+ sample_interlock_ordered + sample_interlock_unordered > 0 &&
+ state->stage != MESA_SHADER_FRAGMENT) {
+ _mesa_glsl_error(& @1, state, "interlock layout qualifiers: "
+ "pixel_interlock_ordered, pixel_interlock_unordered, "
+ "sample_interlock_ordered and sample_interlock_unordered, "
+ "only valid in fragment shader input layout declaration.");
+ } else if (pixel_interlock_ordered + pixel_interlock_unordered +
+ sample_interlock_ordered + sample_interlock_unordered > 0 &&
+ !state->ARB_fragment_shader_interlock_enable &&
+ !state->NV_fragment_shader_interlock_enable) {
+ _mesa_glsl_error(& @1, state,
+ "interlock layout qualifier present, but the "
+ "GL_ARB_fragment_shader_interlock or "
+ "GL_NV_fragment_shader_interlock extension is not "
+ "enabled.");
+ } else {
+ $$.flags.q.pixel_interlock_ordered = pixel_interlock_ordered;
+ $$.flags.q.pixel_interlock_unordered = pixel_interlock_unordered;
+ $$.flags.q.sample_interlock_ordered = sample_interlock_ordered;
+ $$.flags.q.sample_interlock_unordered = sample_interlock_unordered;
}
/* Layout qualifiers for tessellation evaluation shaders. */
if (!$$.flags.i) {
static const struct {
const char *s;
- GLenum e;
+ enum gl_tess_spacing e;
} map[] = {
- { "equal_spacing", GL_EQUAL },
- { "fractional_odd_spacing", GL_FRACTIONAL_ODD },
- { "fractional_even_spacing", GL_FRACTIONAL_EVEN },
+ { "equal_spacing", TESS_SPACING_EQUAL },
+ { "fractional_odd_spacing", TESS_SPACING_FRACTIONAL_ODD },
+ { "fractional_even_spacing", TESS_SPACING_FRACTIONAL_EVEN },
};
for (unsigned i = 0; i < ARRAY_SIZE(map); i++) {
if (match_layout_qualifier($1, map[i].s, state) == 0) {
const char *s;
uint32_t mask;
} map[] = {
- { "blend_support_multiply", BLEND_MULTIPLY },
- { "blend_support_screen", BLEND_SCREEN },
- { "blend_support_overlay", BLEND_OVERLAY },
- { "blend_support_darken", BLEND_DARKEN },
- { "blend_support_lighten", BLEND_LIGHTEN },
- { "blend_support_colordodge", BLEND_COLORDODGE },
- { "blend_support_colorburn", BLEND_COLORBURN },
- { "blend_support_hardlight", BLEND_HARDLIGHT },
- { "blend_support_softlight", BLEND_SOFTLIGHT },
- { "blend_support_difference", BLEND_DIFFERENCE },
- { "blend_support_exclusion", BLEND_EXCLUSION },
- { "blend_support_hsl_hue", BLEND_HSL_HUE },
- { "blend_support_hsl_saturation", BLEND_HSL_SATURATION },
- { "blend_support_hsl_color", BLEND_HSL_COLOR },
- { "blend_support_hsl_luminosity", BLEND_HSL_LUMINOSITY },
- { "blend_support_all_equations", BLEND_ALL },
+ { "blend_support_multiply", BITFIELD_BIT(BLEND_MULTIPLY) },
+ { "blend_support_screen", BITFIELD_BIT(BLEND_SCREEN) },
+ { "blend_support_overlay", BITFIELD_BIT(BLEND_OVERLAY) },
+ { "blend_support_darken", BITFIELD_BIT(BLEND_DARKEN) },
+ { "blend_support_lighten", BITFIELD_BIT(BLEND_LIGHTEN) },
+ { "blend_support_colordodge", BITFIELD_BIT(BLEND_COLORDODGE) },
+ { "blend_support_colorburn", BITFIELD_BIT(BLEND_COLORBURN) },
+ { "blend_support_hardlight", BITFIELD_BIT(BLEND_HARDLIGHT) },
+ { "blend_support_softlight", BITFIELD_BIT(BLEND_SOFTLIGHT) },
+ { "blend_support_difference", BITFIELD_BIT(BLEND_DIFFERENCE) },
+ { "blend_support_exclusion", BITFIELD_BIT(BLEND_EXCLUSION) },
+ { "blend_support_hsl_hue", BITFIELD_BIT(BLEND_HSL_HUE) },
+ { "blend_support_hsl_saturation", BITFIELD_BIT(BLEND_HSL_SATURATION) },
+ { "blend_support_hsl_color", BITFIELD_BIT(BLEND_HSL_COLOR) },
+ { "blend_support_hsl_luminosity", BITFIELD_BIT(BLEND_HSL_LUMINOSITY) },
+ { "blend_support_all_equations", (1u << (BLEND_HSL_LUMINOSITY + 1)) - 2 },
};
for (unsigned i = 0; i < ARRAY_SIZE(map); i++) {
if (match_layout_qualifier($1, map[i].s, state) == 0) {
}
}
+ /* Layout qualifiers for ARB_bindless_texture. */
+ if (!$$.flags.i) {
+ if (match_layout_qualifier($1, "bindless_sampler", state) == 0)
+ $$.flags.q.bindless_sampler = 1;
+ if (match_layout_qualifier($1, "bound_sampler", state) == 0)
+ $$.flags.q.bound_sampler = 1;
+
+ if (state->has_shader_image_load_store()) {
+ if (match_layout_qualifier($1, "bindless_image", state) == 0)
+ $$.flags.q.bindless_image = 1;
+ if (match_layout_qualifier($1, "bound_image", state) == 0)
+ $$.flags.q.bound_image = 1;
+ }
+
+ if ($$.flags.i && !state->has_bindless()) {
+ _mesa_glsl_error(& @1, state,
+ "qualifier `%s` requires "
+ "ARB_bindless_texture", $1);
+ }
+ }
+
+ if (!$$.flags.i &&
+ state->EXT_shader_framebuffer_fetch_non_coherent_enable) {
+ if (match_layout_qualifier($1, "noncoherent", state) == 0)
+ $$.flags.q.non_coherent = 1;
+ }
+
+ // Layout qualifiers for NV_compute_shader_derivatives.
+ if (!$$.flags.i) {
+ if (match_layout_qualifier($1, "derivative_group_quadsNV", state) == 0) {
+ $$.flags.q.derivative_group = 1;
+ $$.derivative_group = DERIVATIVE_GROUP_QUADS;
+ } else if (match_layout_qualifier($1, "derivative_group_linearNV", state) == 0) {
+ $$.flags.q.derivative_group = 1;
+ $$.derivative_group = DERIVATIVE_GROUP_LINEAR;
+ }
+
+ if ($$.flags.i) {
+ if (!state->has_compute_shader()) {
+ _mesa_glsl_error(& @1, state,
+ "qualifier `%s' requires "
+ "a compute shader", $1);
+ }
+
+ if (!state->NV_compute_shader_derivatives_enable) {
+ _mesa_glsl_error(& @1, state,
+ "qualifier `%s' requires "
+ "NV_compute_shader_derivatives", $1);
+ }
+
+ if (state->NV_compute_shader_derivatives_warn) {
+ _mesa_glsl_warning(& @1, state,
+ "NV_compute_shader_derivatives layout "
+ "qualifier `%s' used", $1);
+ }
+ }
+ }
+
+ /* Layout qualifier for NV_viewport_array2. */
+ if (!$$.flags.i && state->stage != MESA_SHADER_FRAGMENT) {
+ if (match_layout_qualifier($1, "viewport_relative", state) == 0) {
+ $$.flags.q.viewport_relative = 1;
+ }
+
+ if ($$.flags.i && !state->NV_viewport_array2_enable) {
+ _mesa_glsl_error(& @1, state,
+ "qualifier `%s' requires "
+ "GL_NV_viewport_array2", $1);
+ }
+
+ if ($$.flags.i && state->NV_viewport_array2_warn) {
+ _mesa_glsl_warning(& @1, state,
+ "GL_NV_viewport_array2 layout "
+ "identifier `%s' used", $1);
+ }
+ }
+
if (!$$.flags.i) {
_mesa_glsl_error(& @1, state, "unrecognized layout identifier "
"`%s'", $1);
| SUBROUTINE '(' subroutine_type_list ')'
{
memset(& $$, 0, sizeof($$));
- $$.flags.q.subroutine_def = 1;
+ $$.flags.q.subroutine = 1;
$$.subroutine_list = $3;
}
;
* precise qualifiers since these are useful in ARB_separate_shader_objects.
* There is no clear spec guidance on this either.
*/
- if (!state->has_420pack_or_es31() && $2.has_layout())
- _mesa_glsl_error(&@1, state, "duplicate layout(...) qualifiers");
-
$$ = $1;
$$.merge_qualifier(& @1, state, $2, false, $2.has_layout());
}
"duplicate auxiliary storage qualifier (centroid or sample)");
}
- if (!state->has_420pack_or_es31() &&
+ if ((!state->has_420pack_or_es31() && !state->EXT_gpu_shader4_enable) &&
($2.flags.q.precise || $2.flags.q.invariant ||
$2.has_interpolation() || $2.has_layout())) {
_mesa_glsl_error(&@1, state, "auxiliary storage qualifiers must come "
/* Section 4.3 of the GLSL 1.20 specification states:
* "Variable declarations may have a storage qualifier specified..."
* 1.30 clarifies this to "may have one storage qualifier".
+ *
+ * GL_EXT_gpu_shader4 allows "varying out" in fragment shaders.
*/
- if ($2.has_storage())
+ if ($2.has_storage() &&
+ (!state->EXT_gpu_shader4_enable ||
+ state->stage != MESA_SHADER_FRAGMENT ||
+ !$1.flags.q.varying || !$2.flags.q.out))
_mesa_glsl_error(&@1, state, "duplicate storage qualifier");
if (!state->has_420pack_or_es31() &&
;
basic_type_specifier_nonarray:
- VOID_TOK { $$ = "void"; }
- | FLOAT_TOK { $$ = "float"; }
- | DOUBLE_TOK { $$ = "double"; }
- | INT_TOK { $$ = "int"; }
- | UINT_TOK { $$ = "uint"; }
- | BOOL_TOK { $$ = "bool"; }
- | VEC2 { $$ = "vec2"; }
- | VEC3 { $$ = "vec3"; }
- | VEC4 { $$ = "vec4"; }
- | BVEC2 { $$ = "bvec2"; }
- | BVEC3 { $$ = "bvec3"; }
- | BVEC4 { $$ = "bvec4"; }
- | IVEC2 { $$ = "ivec2"; }
- | IVEC3 { $$ = "ivec3"; }
- | IVEC4 { $$ = "ivec4"; }
- | UVEC2 { $$ = "uvec2"; }
- | UVEC3 { $$ = "uvec3"; }
- | UVEC4 { $$ = "uvec4"; }
- | DVEC2 { $$ = "dvec2"; }
- | DVEC3 { $$ = "dvec3"; }
- | DVEC4 { $$ = "dvec4"; }
- | MAT2X2 { $$ = "mat2"; }
- | MAT2X3 { $$ = "mat2x3"; }
- | MAT2X4 { $$ = "mat2x4"; }
- | MAT3X2 { $$ = "mat3x2"; }
- | MAT3X3 { $$ = "mat3"; }
- | MAT3X4 { $$ = "mat3x4"; }
- | MAT4X2 { $$ = "mat4x2"; }
- | MAT4X3 { $$ = "mat4x3"; }
- | MAT4X4 { $$ = "mat4"; }
- | DMAT2X2 { $$ = "dmat2"; }
- | DMAT2X3 { $$ = "dmat2x3"; }
- | DMAT2X4 { $$ = "dmat2x4"; }
- | DMAT3X2 { $$ = "dmat3x2"; }
- | DMAT3X3 { $$ = "dmat3"; }
- | DMAT3X4 { $$ = "dmat3x4"; }
- | DMAT4X2 { $$ = "dmat4x2"; }
- | DMAT4X3 { $$ = "dmat4x3"; }
- | DMAT4X4 { $$ = "dmat4"; }
- | SAMPLER1D { $$ = "sampler1D"; }
- | SAMPLER2D { $$ = "sampler2D"; }
- | SAMPLER2DRECT { $$ = "sampler2DRect"; }
- | SAMPLER3D { $$ = "sampler3D"; }
- | SAMPLERCUBE { $$ = "samplerCube"; }
- | SAMPLEREXTERNALOES { $$ = "samplerExternalOES"; }
- | SAMPLER1DSHADOW { $$ = "sampler1DShadow"; }
- | SAMPLER2DSHADOW { $$ = "sampler2DShadow"; }
- | SAMPLER2DRECTSHADOW { $$ = "sampler2DRectShadow"; }
- | SAMPLERCUBESHADOW { $$ = "samplerCubeShadow"; }
- | SAMPLER1DARRAY { $$ = "sampler1DArray"; }
- | SAMPLER2DARRAY { $$ = "sampler2DArray"; }
- | SAMPLER1DARRAYSHADOW { $$ = "sampler1DArrayShadow"; }
- | SAMPLER2DARRAYSHADOW { $$ = "sampler2DArrayShadow"; }
- | SAMPLERBUFFER { $$ = "samplerBuffer"; }
- | SAMPLERCUBEARRAY { $$ = "samplerCubeArray"; }
- | SAMPLERCUBEARRAYSHADOW { $$ = "samplerCubeArrayShadow"; }
- | ISAMPLER1D { $$ = "isampler1D"; }
- | ISAMPLER2D { $$ = "isampler2D"; }
- | ISAMPLER2DRECT { $$ = "isampler2DRect"; }
- | ISAMPLER3D { $$ = "isampler3D"; }
- | ISAMPLERCUBE { $$ = "isamplerCube"; }
- | ISAMPLER1DARRAY { $$ = "isampler1DArray"; }
- | ISAMPLER2DARRAY { $$ = "isampler2DArray"; }
- | ISAMPLERBUFFER { $$ = "isamplerBuffer"; }
- | ISAMPLERCUBEARRAY { $$ = "isamplerCubeArray"; }
- | USAMPLER1D { $$ = "usampler1D"; }
- | USAMPLER2D { $$ = "usampler2D"; }
- | USAMPLER2DRECT { $$ = "usampler2DRect"; }
- | USAMPLER3D { $$ = "usampler3D"; }
- | USAMPLERCUBE { $$ = "usamplerCube"; }
- | USAMPLER1DARRAY { $$ = "usampler1DArray"; }
- | USAMPLER2DARRAY { $$ = "usampler2DArray"; }
- | USAMPLERBUFFER { $$ = "usamplerBuffer"; }
- | USAMPLERCUBEARRAY { $$ = "usamplerCubeArray"; }
- | SAMPLER2DMS { $$ = "sampler2DMS"; }
- | ISAMPLER2DMS { $$ = "isampler2DMS"; }
- | USAMPLER2DMS { $$ = "usampler2DMS"; }
- | SAMPLER2DMSARRAY { $$ = "sampler2DMSArray"; }
- | ISAMPLER2DMSARRAY { $$ = "isampler2DMSArray"; }
- | USAMPLER2DMSARRAY { $$ = "usampler2DMSArray"; }
- | IMAGE1D { $$ = "image1D"; }
- | IMAGE2D { $$ = "image2D"; }
- | IMAGE3D { $$ = "image3D"; }
- | IMAGE2DRECT { $$ = "image2DRect"; }
- | IMAGECUBE { $$ = "imageCube"; }
- | IMAGEBUFFER { $$ = "imageBuffer"; }
- | IMAGE1DARRAY { $$ = "image1DArray"; }
- | IMAGE2DARRAY { $$ = "image2DArray"; }
- | IMAGECUBEARRAY { $$ = "imageCubeArray"; }
- | IMAGE2DMS { $$ = "image2DMS"; }
- | IMAGE2DMSARRAY { $$ = "image2DMSArray"; }
- | IIMAGE1D { $$ = "iimage1D"; }
- | IIMAGE2D { $$ = "iimage2D"; }
- | IIMAGE3D { $$ = "iimage3D"; }
- | IIMAGE2DRECT { $$ = "iimage2DRect"; }
- | IIMAGECUBE { $$ = "iimageCube"; }
- | IIMAGEBUFFER { $$ = "iimageBuffer"; }
- | IIMAGE1DARRAY { $$ = "iimage1DArray"; }
- | IIMAGE2DARRAY { $$ = "iimage2DArray"; }
- | IIMAGECUBEARRAY { $$ = "iimageCubeArray"; }
- | IIMAGE2DMS { $$ = "iimage2DMS"; }
- | IIMAGE2DMSARRAY { $$ = "iimage2DMSArray"; }
- | UIMAGE1D { $$ = "uimage1D"; }
- | UIMAGE2D { $$ = "uimage2D"; }
- | UIMAGE3D { $$ = "uimage3D"; }
- | UIMAGE2DRECT { $$ = "uimage2DRect"; }
- | UIMAGECUBE { $$ = "uimageCube"; }
- | UIMAGEBUFFER { $$ = "uimageBuffer"; }
- | UIMAGE1DARRAY { $$ = "uimage1DArray"; }
- | UIMAGE2DARRAY { $$ = "uimage2DArray"; }
- | UIMAGECUBEARRAY { $$ = "uimageCubeArray"; }
- | UIMAGE2DMS { $$ = "uimage2DMS"; }
- | UIMAGE2DMSARRAY { $$ = "uimage2DMSArray"; }
- | ATOMIC_UINT { $$ = "atomic_uint"; }
+ VOID_TOK { $$ = glsl_type::void_type; }
+ | BASIC_TYPE_TOK { $$ = $1; }
+ | UNSIGNED BASIC_TYPE_TOK
+ {
+ if ($2 == glsl_type::int_type) {
+ $$ = glsl_type::uint_type;
+ } else {
+ _mesa_glsl_error(&@1, state,
+ "\"unsigned\" is only allowed before \"int\"");
+ }
+ }
;
precision_qualifier:
STRUCT any_identifier '{' struct_declaration_list '}'
{
void *ctx = state->linalloc;
- $$ = new(ctx) ast_struct_specifier(ctx, $2, $4);
+ $$ = new(ctx) ast_struct_specifier($2, $4);
$$->set_location_range(@2, @5);
state->symbols->add_type($2, glsl_type::void_type);
}
| STRUCT '{' struct_declaration_list '}'
{
void *ctx = state->linalloc;
- $$ = new(ctx) ast_struct_specifier(ctx, NULL, $3);
+
+ /* All anonymous structs have the same name. This simplifies matching of
+ * globals whose type is an unnamed struct.
+ *
+ * It also avoids a memory leak when the same shader is compiled over and
+ * over again.
+ */
+ $$ = new(ctx) ast_struct_specifier("#anon_struct", $3);
+
$$->set_location_range(@2, @4);
}
;
ast_fully_specified_type *const type = $1;
type->set_location(@1);
- if (type->qualifier.flags.i != 0)
- _mesa_glsl_error(&@1, state,
- "only precision qualifiers may be applied to "
- "structure members");
+ if (state->has_bindless()) {
+ ast_type_qualifier input_layout_mask;
+
+ /* Allow to declare qualifiers for images. */
+ input_layout_mask.flags.i = 0;
+ input_layout_mask.flags.q.coherent = 1;
+ input_layout_mask.flags.q._volatile = 1;
+ input_layout_mask.flags.q.restrict_flag = 1;
+ input_layout_mask.flags.q.read_only = 1;
+ input_layout_mask.flags.q.write_only = 1;
+ input_layout_mask.flags.q.explicit_image_format = 1;
+
+ if ((type->qualifier.flags.i & ~input_layout_mask.flags.i) != 0) {
+ _mesa_glsl_error(&@1, state,
+ "only precision and image qualifiers may be "
+ "applied to structure members");
+ }
+ } else {
+ if (type->qualifier.flags.i != 0)
+ _mesa_glsl_error(&@1, state,
+ "only precision qualifiers may be applied to "
+ "structure members");
+ }
$$ = new(ctx) ast_declarator_list(type);
$$->set_location(@2);
| switch_statement
| iteration_statement
| jump_statement
+ | demote_statement
;
compound_statement:
$$ = $1;
$$->link.insert_before(& $2->link);
}
+ | statement_list extension_statement
+ {
+ if (!state->allow_extension_directive_midshader) {
+ _mesa_glsl_error(& @1, state,
+ "#extension directive is not allowed "
+ "in the middle of a shader");
+ YYERROR;
+ }
+ }
;
expression_statement:
}
;
+demote_statement:
+ DEMOTE ';'
+ {
+ void *ctx = state->linalloc;
+ $$ = new(ctx) ast_demote_statement();
+ $$->set_location(@1);
+ }
+ ;
+
external_declaration:
function_definition { $$ = $1; }
| declaration { $$ = $1; }
- | pragma_statement { $$ = NULL; }
+ | pragma_statement { $$ = $1; }
| layout_defaults { $$ = $1; }
+ | ';' { $$ = NULL; }
;
function_definition:
{
ast_interface_block *block = (ast_interface_block *) $2;
- if (!state->has_420pack_or_es31() && block->layout.has_layout()) {
- _mesa_glsl_error(&@1, state, "duplicate layout(...) qualifiers");
- YYERROR;
- }
-
if (!$1.merge_qualifier(& @1, state, block->layout, false,
block->layout.has_layout())) {
YYERROR;
layout_qualifier layout_uniform_defaults
{
$$ = $1;
- if (!state->has_420pack_or_es31()) {
- _mesa_glsl_error(&@1, state, "duplicate layout(...) qualifiers");
- YYERROR;
- }
if (!$$.merge_qualifier(& @1, state, $2, false, true)) {
YYERROR;
}
layout_qualifier layout_buffer_defaults
{
$$ = $1;
- if (!state->has_420pack_or_es31()) {
- _mesa_glsl_error(&@1, state, "duplicate layout(...) qualifiers");
- YYERROR;
- }
if (!$$.merge_qualifier(& @1, state, $2, false, true)) {
YYERROR;
}
layout_qualifier layout_in_defaults
{
$$ = $1;
- if (!state->has_420pack_or_es31()) {
- _mesa_glsl_error(&@1, state, "duplicate layout(...) qualifiers");
- YYERROR;
- }
if (!$$.merge_qualifier(& @1, state, $2, false, true)) {
YYERROR;
}
layout_qualifier layout_out_defaults
{
$$ = $1;
- if (!state->has_420pack_or_es31()) {
- _mesa_glsl_error(&@1, state, "duplicate layout(...) qualifiers");
- YYERROR;
- }
if (!$$.merge_qualifier(& @1, state, $2, false, true)) {
YYERROR;
}
merge_qualifier(& @1, state, $1, false)) {
YYERROR;
}
+ if (!state->default_uniform_qualifier->
+ push_to_global(& @1, state)) {
+ YYERROR;
+ }
}
| layout_buffer_defaults
{
merge_qualifier(& @1, state, $1, false)) {
YYERROR;
}
+ if (!state->default_shader_storage_qualifier->
+ push_to_global(& @1, state)) {
+ YYERROR;
+ }
/* From the GLSL 4.50 spec, section 4.4.5:
*
| layout_in_defaults
{
$$ = NULL;
- if (!$1.merge_into_in_qualifier(& @1, state, $$, true)) {
+ if (!$1.merge_into_in_qualifier(& @1, state, $$)) {
+ YYERROR;
+ }
+ if (!state->in_qualifier->push_to_global(& @1, state)) {
YYERROR;
}
}
| layout_out_defaults
{
$$ = NULL;
- if (!$1.merge_into_out_qualifier(& @1, state, $$, true)) {
+ if (!$1.merge_into_out_qualifier(& @1, state, $$)) {
+ YYERROR;
+ }
+ if (!state->out_qualifier->push_to_global(& @1, state)) {
YYERROR;
}
}
projects / mesa.git / blobdiff