On 06/08/2016 05:48 PM, Dave Airlie wrote: > From: Dave Airlie <airl...@redhat.com> > > This adds the builtins and the lexer support. > > To avoid too many warnings, it adds basic > support to the type in a few other places > in mesa, mostly in the trivial places. > > It also adds a query to be used later for > if a type is an integer 32 or 64.
The line wrapping is kind of weird here. > Signed-off-by: Dave Airlie <airl...@redhat.com> > --- > src/compiler/builtin_type_macros.h | 10 ++++++ > src/compiler/glsl/ast_to_hir.cpp | 2 ++ > src/compiler/glsl/builtin_types.cpp | 12 +++++++ > src/compiler/glsl/glsl_lexer.ll | 10 ++++++ > src/compiler/glsl/glsl_parser.yy | 9 +++++ > src/compiler/glsl/ir_clone.cpp | 2 ++ > src/compiler/glsl/link_uniform_initializers.cpp | 2 ++ > src/compiler/glsl_types.cpp | 45 > +++++++++++++++++++++++++ > src/compiler/glsl_types.h | 19 +++++++++-- > src/mesa/program/ir_to_mesa.cpp | 14 ++++++++ > src/mesa/state_tracker/st_glsl_types.cpp | 6 ++++ > 11 files changed, 129 insertions(+), 2 deletions(-) > > diff --git a/src/compiler/builtin_type_macros.h > b/src/compiler/builtin_type_macros.h > index da3f19e..1986684 100644 > --- a/src/compiler/builtin_type_macros.h > +++ b/src/compiler/builtin_type_macros.h > @@ -78,6 +78,16 @@ DECL_TYPE(dmat3x4, GL_DOUBLE_MAT3x4, GLSL_TYPE_DOUBLE, 4, > 3) > DECL_TYPE(dmat4x2, GL_DOUBLE_MAT4x2, GLSL_TYPE_DOUBLE, 2, 4) > DECL_TYPE(dmat4x3, GL_DOUBLE_MAT4x3, GLSL_TYPE_DOUBLE, 3, 4) > > +DECL_TYPE(int64_t, GL_INT64_ARB, GLSL_TYPE_INT64, 1, 1) > +DECL_TYPE(i64vec2, GL_INT64_VEC2_ARB, GLSL_TYPE_INT64, 2, 1) > +DECL_TYPE(i64vec3, GL_INT64_VEC3_ARB, GLSL_TYPE_INT64, 3, 1) > +DECL_TYPE(i64vec4, GL_INT64_VEC4_ARB, GLSL_TYPE_INT64, 4, 1) > + > +DECL_TYPE(uint64_t, GL_UNSIGNED_INT64_ARB, GLSL_TYPE_UINT64, 1, 1) > +DECL_TYPE(u64vec2, GL_UNSIGNED_INT64_VEC2_ARB, GLSL_TYPE_UINT64, 2, 1) > +DECL_TYPE(u64vec3, GL_UNSIGNED_INT64_VEC3_ARB, GLSL_TYPE_UINT64, 3, 1) > +DECL_TYPE(u64vec4, GL_UNSIGNED_INT64_VEC4_ARB, GLSL_TYPE_UINT64, 4, 1) > + > DECL_TYPE(sampler, GL_SAMPLER_1D, > GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D, 0, 0, GLSL_TYPE_VOID) > DECL_TYPE(sampler1D, GL_SAMPLER_1D, > GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D, 0, 0, GLSL_TYPE_FLOAT) > DECL_TYPE(sampler2D, GL_SAMPLER_2D, > GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_2D, 0, 0, GLSL_TYPE_FLOAT) > diff --git a/src/compiler/glsl/ast_to_hir.cpp > b/src/compiler/glsl/ast_to_hir.cpp > index 1c751f6..b75ddbd 100644 > --- a/src/compiler/glsl/ast_to_hir.cpp > +++ b/src/compiler/glsl/ast_to_hir.cpp > @@ -1089,6 +1089,8 @@ do_comparison(void *mem_ctx, int operation, ir_rvalue > *op0, ir_rvalue *op1) > case GLSL_TYPE_INT: > case GLSL_TYPE_BOOL: > case GLSL_TYPE_DOUBLE: > + case GLSL_TYPE_UINT64: > + case GLSL_TYPE_INT64: > return new(mem_ctx) ir_expression(operation, op0, op1); > > case GLSL_TYPE_ARRAY: { > diff --git a/src/compiler/glsl/builtin_types.cpp > b/src/compiler/glsl/builtin_types.cpp > index 5f208f8..1a9292a 100644 > --- a/src/compiler/glsl/builtin_types.cpp > +++ b/src/compiler/glsl/builtin_types.cpp > @@ -402,5 +402,17 @@ _mesa_glsl_initialize_types(struct > _mesa_glsl_parse_state *state) > add_type(symbols, glsl_type::dmat4x2_type); > add_type(symbols, glsl_type::dmat4x3_type); > } > + > + if (state->ARB_gpu_shader_int64_enable) { > + add_type(symbols, glsl_type::int64_t_type); > + add_type(symbols, glsl_type::i64vec2_type); > + add_type(symbols, glsl_type::i64vec3_type); > + add_type(symbols, glsl_type::i64vec4_type); > + > + add_type(symbols, glsl_type::uint64_t_type); > + add_type(symbols, glsl_type::u64vec2_type); > + add_type(symbols, glsl_type::u64vec3_type); > + add_type(symbols, glsl_type::u64vec4_type); > + } > } > /** @} */ > diff --git a/src/compiler/glsl/glsl_lexer.ll b/src/compiler/glsl/glsl_lexer.ll > index 11711ee..9c6d943 100644 > --- a/src/compiler/glsl/glsl_lexer.ll > +++ b/src/compiler/glsl/glsl_lexer.ll > @@ -587,6 +587,16 @@ resource KEYWORD(420, 300, 0, 0, RESOURCE); > sample KEYWORD_WITH_ALT(400, 300, 400, 320, > yyextra->ARB_gpu_shader5_enable || > yyextra->OES_shader_multisample_interpolation_enable, SAMPLE); > subroutine KEYWORD_WITH_ALT(400, 300, 400, 0, > yyextra->ARB_shader_subroutine_enable, SUBROUTINE); > > + /* Additional words for ARB_gpu_shader_int64 */ > +int64_t KEYWORD_WITH_ALT(110, 100, 0, 0, > yyextra->ARB_gpu_shader_int64_enable, INT64); > +i64vec2 KEYWORD_WITH_ALT(110, 100, 0, 0, > yyextra->ARB_gpu_shader_int64_enable, I64VEC2); > +i64vec3 KEYWORD_WITH_ALT(110, 100, 0, 0, > yyextra->ARB_gpu_shader_int64_enable, I64VEC3); > +i64vec4 KEYWORD_WITH_ALT(110, 100, 0, 0, > yyextra->ARB_gpu_shader_int64_enable, I64VEC4); > + > +uint64_t KEYWORD_WITH_ALT(110, 100, 0, 0, > yyextra->ARB_gpu_shader_int64_enable, UINT64); > +u64vec2 KEYWORD_WITH_ALT(110, 100, 0, 0, > yyextra->ARB_gpu_shader_int64_enable, U64VEC2); > +u64vec3 KEYWORD_WITH_ALT(110, 100, 0, 0, > yyextra->ARB_gpu_shader_int64_enable, U64VEC3); > +u64vec4 KEYWORD_WITH_ALT(110, 100, 0, 0, > yyextra->ARB_gpu_shader_int64_enable, U64VEC4); These are not correct. The first two numbers are the versions of GLSL and GLSL ES, respectively, where the thing was made a reserved keyword. If we do this, valid shaders that use int64_t as, say, a variable name in a GLSL 110 shader will fail to compile. To my dismay, none of these were ever marked as "reserved for future use". :( I checked all versions of the GLSL and GLSL ES specs just to be sure. So... all of these should be KEYWORD_WITH_ALT(0, 0, 0, 0, yyextra->ARB_gpu_shader_int64_enable, ...) > > [_a-zA-Z][_a-zA-Z0-9]* { > struct _mesa_glsl_parse_state *state = yyextra; > diff --git a/src/compiler/glsl/glsl_parser.yy > b/src/compiler/glsl/glsl_parser.yy > index 3885688..2cd4ed8 100644 > --- a/src/compiler/glsl/glsl_parser.yy > +++ b/src/compiler/glsl/glsl_parser.yy > @@ -136,6 +136,7 @@ static bool match_layout_qualifier(const char *s1, const > char *s2, > %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 INT64 UINT64 I64VEC2 I64VEC3 I64VEC4 U64VEC2 U64VEC3 U64VEC4 > %token CENTROID IN_TOK OUT_TOK INOUT_TOK UNIFORM VARYING SAMPLE > %token NOPERSPECTIVE FLAT SMOOTH > %token MAT2X2 MAT2X3 MAT2X4 > @@ -2178,6 +2179,14 @@ basic_type_specifier_nonarray: > | UIMAGE2DMS { $$ = "uimage2DMS"; } > | UIMAGE2DMSARRAY { $$ = "uimage2DMSArray"; } > | ATOMIC_UINT { $$ = "atomic_uint"; } > + | INT64 { $$ = "int64_t"; } > + | I64VEC2 { $$ = "i64vec2"; } > + | I64VEC3 { $$ = "i64vec3"; } > + | I64VEC4 { $$ = "i64vec4"; } > + | UINT64 { $$ = "uint64_t"; } > + | U64VEC2 { $$ = "u64vec2"; } > + | U64VEC3 { $$ = "u64vec3"; } > + | U64VEC4 { $$ = "u64vec4"; } > ; > > precision_qualifier: > diff --git a/src/compiler/glsl/ir_clone.cpp b/src/compiler/glsl/ir_clone.cpp > index 60d1526..509eabf 100644 > --- a/src/compiler/glsl/ir_clone.cpp > +++ b/src/compiler/glsl/ir_clone.cpp > @@ -338,6 +338,8 @@ ir_constant::clone(void *mem_ctx, struct hash_table *ht) > const > case GLSL_TYPE_FLOAT: > case GLSL_TYPE_DOUBLE: > case GLSL_TYPE_BOOL: > + case GLSL_TYPE_UINT64: > + case GLSL_TYPE_INT64: > return new(mem_ctx) ir_constant(this->type, &this->value); > > case GLSL_TYPE_STRUCT: { > diff --git a/src/compiler/glsl/link_uniform_initializers.cpp > b/src/compiler/glsl/link_uniform_initializers.cpp > index acf8222..bec2dae 100644 > --- a/src/compiler/glsl/link_uniform_initializers.cpp > +++ b/src/compiler/glsl/link_uniform_initializers.cpp > @@ -71,6 +71,8 @@ copy_constant_to_storage(union gl_constant_value *storage, > case GLSL_TYPE_BOOL: > storage[i].b = val->value.b[i] ? boolean_true : 0; > break; > + case GLSL_TYPE_INT64: > + case GLSL_TYPE_UINT64: > case GLSL_TYPE_ARRAY: > case GLSL_TYPE_STRUCT: > case GLSL_TYPE_IMAGE: > diff --git a/src/compiler/glsl_types.cpp b/src/compiler/glsl_types.cpp > index 884f311..2b4a265 100644 > --- a/src/compiler/glsl_types.cpp > +++ b/src/compiler/glsl_types.cpp > @@ -378,6 +378,10 @@ const glsl_type *glsl_type::get_base_type() const > return double_type; > case GLSL_TYPE_BOOL: > return bool_type; > + case GLSL_TYPE_UINT64: > + return uint64_t_type; > + case GLSL_TYPE_INT64: > + return int64_t_type; > default: > return error_type; > } > @@ -404,6 +408,10 @@ const glsl_type *glsl_type::get_scalar_type() const > return double_type; > case GLSL_TYPE_BOOL: > return bool_type; > + case GLSL_TYPE_UINT64: > + return uint64_t_type; > + case GLSL_TYPE_INT64: > + return int64_t_type; > default: > /* Handle everything else */ > return type; > @@ -544,6 +552,31 @@ glsl_type::bvec(unsigned components) > > > const glsl_type * > +glsl_type::i64vec(unsigned components) > +{ > + if (components == 0 || components > 4) > + return error_type; > + > + static const glsl_type *const ts[] = { > + int64_t_type, i64vec2_type, i64vec3_type, i64vec4_type > + }; > + return ts[components - 1]; > +} > + > + > +const glsl_type * > +glsl_type::u64vec(unsigned components) > +{ > + if (components == 0 || components > 4) > + return error_type; > + > + static const glsl_type *const ts[] = { > + uint64_t_type, u64vec2_type, u64vec3_type, u64vec4_type > + }; > + return ts[components - 1]; > +} > + > +const glsl_type * > glsl_type::get_instance(unsigned base_type, unsigned rows, unsigned columns) > { > if (base_type == GLSL_TYPE_VOID) > @@ -566,6 +599,10 @@ glsl_type::get_instance(unsigned base_type, unsigned > rows, unsigned columns) > return dvec(rows); > case GLSL_TYPE_BOOL: > return bvec(rows); > + case GLSL_TYPE_UINT64: > + return u64vec(rows); > + case GLSL_TYPE_INT64: > + return i64vec(rows); > default: > return error_type; > } > @@ -1250,6 +1287,8 @@ glsl_type::component_slots() const > return this->components(); > > case GLSL_TYPE_DOUBLE: > + case GLSL_TYPE_UINT64: > + case GLSL_TYPE_INT64: > return 2 * this->components(); > > case GLSL_TYPE_STRUCT: > @@ -1332,6 +1371,8 @@ glsl_type::uniform_locations() const > case GLSL_TYPE_INT: > case GLSL_TYPE_FLOAT: > case GLSL_TYPE_DOUBLE: > + case GLSL_TYPE_UINT64: > + case GLSL_TYPE_INT64: > case GLSL_TYPE_BOOL: > case GLSL_TYPE_SAMPLER: > case GLSL_TYPE_IMAGE: > @@ -1361,6 +1402,8 @@ glsl_type::varying_count() const > case GLSL_TYPE_FLOAT: > case GLSL_TYPE_DOUBLE: > case GLSL_TYPE_BOOL: > + case GLSL_TYPE_UINT64: > + case GLSL_TYPE_INT64: > return 1; > > case GLSL_TYPE_STRUCT: > @@ -1931,6 +1974,8 @@ glsl_type::count_attribute_slots(bool is_vertex_input) > const > case GLSL_TYPE_BOOL: > return this->matrix_columns; > case GLSL_TYPE_DOUBLE: > + case GLSL_TYPE_UINT64: > + case GLSL_TYPE_INT64: > if (this->vector_elements > 2 && !is_vertex_input) > return this->matrix_columns * 2; > else > diff --git a/src/compiler/glsl_types.h b/src/compiler/glsl_types.h > index c3a0185..cb53ea7 100644 > --- a/src/compiler/glsl_types.h > +++ b/src/compiler/glsl_types.h > @@ -51,6 +51,8 @@ enum glsl_base_type { > GLSL_TYPE_INT, > GLSL_TYPE_FLOAT, > GLSL_TYPE_DOUBLE, > + GLSL_TYPE_UINT64, > + GLSL_TYPE_INT64, We should keep all the integer types together. GLSL_TYPE_{U,}INT{8,16} will be added soon. What I hadn't decided is whether or not it was better to have the enums ordered by size or leave the "unsized" version first. That is, GLSL_TYPE_UINT8, GLSL_TYPE_UINT16, GLSL_TYPE_UINT, GLSL_TYPE_UINT64, vs GLSL_TYPE_UINT, GLSL_TYPE_UINT8, GLSL_TYPE_UINT16, GLSL_TYPE_UINT64, The latter would mean that places that are already doing things like (t >= GLSL_TYPE_UINT && t <= GLSL_TYPE_DOUBLE) wouldn't have to change. I had also considered changing the glsl_base_type enum to encode "raw type" and "bit size". That would simplify glsl_base_type_is_64bit and related (future) functions. > GLSL_TYPE_BOOL, > GLSL_TYPE_SAMPLER, > GLSL_TYPE_IMAGE, > @@ -66,7 +68,9 @@ enum glsl_base_type { > > static inline bool glsl_base_type_is_64bit(enum glsl_base_type type) > { > - return type == GLSL_TYPE_DOUBLE; > + return type == GLSL_TYPE_DOUBLE || > + type == GLSL_TYPE_UINT64 || > + type == GLSL_TYPE_INT64; I know Matt would ask for 'type' to line up. > } > > enum glsl_sampler_dim { > @@ -219,6 +223,8 @@ struct glsl_type { > static const glsl_type *ivec(unsigned components); > static const glsl_type *uvec(unsigned components); > static const glsl_type *bvec(unsigned components); > + static const glsl_type *i64vec(unsigned components); > + static const glsl_type *u64vec(unsigned components); > /**@}*/ > > /** > @@ -455,7 +461,7 @@ struct glsl_type { > */ > bool is_numeric() const > { > - return (base_type >= GLSL_TYPE_UINT) && (base_type <= > GLSL_TYPE_DOUBLE); > + return (base_type >= GLSL_TYPE_UINT) && (base_type <= GLSL_TYPE_INT64); > } > > /** > @@ -467,6 +473,15 @@ struct glsl_type { > } > > /** > + * Query whether or not a type is a 32-bit or 64-bit integer > + */ > + bool is_integer_32_64() const > + { > + return (base_type == GLSL_TYPE_UINT) || (base_type == GLSL_TYPE_INT) || > + (base_type == GLSL_TYPE_UINT64) || (base_type == > GLSL_TYPE_INT64); > + } It's not immediately obvious why this is necessary in addition to (an extended) is_integer, but I'll wait until I look through the rest of the series. > + > + /** > * Query whether or not type is an integral type, or for struct and array > * types, contains an integral type. > */ > diff --git a/src/mesa/program/ir_to_mesa.cpp b/src/mesa/program/ir_to_mesa.cpp > index 3a5f058..94a6ca3 100644 > --- a/src/mesa/program/ir_to_mesa.cpp > +++ b/src/mesa/program/ir_to_mesa.cpp > @@ -532,6 +532,12 @@ type_size(const struct glsl_type *type) > return 1; > } > break; > + case GLSL_TYPE_UINT64: > + case GLSL_TYPE_INT64: > + if (type->vector_elements > 2) > + return 2; > + else > + return 1; > case GLSL_TYPE_ARRAY: > assert(type->length > 0); > return type_size(type->fields.array) * type->length; > @@ -2521,11 +2527,19 @@ _mesa_associate_uniform_storage(struct gl_context > *ctx, > unsigned columns = 0; > int dmul = 4 * sizeof(float); > switch (storage->type->base_type) { > + case GLSL_TYPE_UINT64: > + if (storage->type->vector_elements > 2) > + dmul *= 2; > + /* fallthrough */ > case GLSL_TYPE_UINT: > assert(ctx->Const.NativeIntegers); > format = uniform_native; > columns = 1; > break; > + case GLSL_TYPE_INT64: > + if (storage->type->vector_elements > 2) > + dmul *= 2; > + /* fallthrough */ > case GLSL_TYPE_INT: > format = > (ctx->Const.NativeIntegers) ? uniform_native : uniform_int_float; > diff --git a/src/mesa/state_tracker/st_glsl_types.cpp > b/src/mesa/state_tracker/st_glsl_types.cpp > index 857e143..37c3164 100644 > --- a/src/mesa/state_tracker/st_glsl_types.cpp > +++ b/src/mesa/state_tracker/st_glsl_types.cpp > @@ -67,6 +67,12 @@ st_glsl_attrib_type_size(const struct glsl_type *type, > bool is_vs_input) > return 2; > } > break; > + case GLSL_TYPE_UINT64: > + case GLSL_TYPE_INT64: > + if (type->vector_elements <= 2 || is_vs_input) > + return 1; > + else > + return 2; > case GLSL_TYPE_ARRAY: > assert(type->length > 0); > return st_glsl_attrib_type_size(type->fields.array, is_vs_input) * > type->length; > _______________________________________________ mesa-dev mailing list mesa-dev@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/mesa-dev