1 /* 2 * Copyright 2009 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 <stdio.h> 25 #include "main/macros.h" 26 #include "compiler/glsl/glsl_parser_extras.h" 27 #include "glsl_types.h" 28 #include "util/hash_table.h" 29 #include "util/u_cpu_detect.h" 30 #include "util/u_string.h" 31 32 33 mtx_t glsl_type::hash_mutex = _MTX_INITIALIZER_NP; 34 hash_table *glsl_type::explicit_matrix_types = NULL; 35 hash_table *glsl_type::array_types = NULL; 36 hash_table *glsl_type::struct_types = NULL; 37 hash_table *glsl_type::interface_types = NULL; 38 hash_table *glsl_type::function_types = NULL; 39 hash_table *glsl_type::subroutine_types = NULL; 40 41 /* There might be multiple users for types (e.g. application using OpenGL 42 * and Vulkan simultaneously or app using multiple Vulkan instances). Counter 43 * is used to make sure we don't release the types if a user is still present. 44 */ 45 static uint32_t glsl_type_users = 0; 46 47 glsl_type::glsl_type(GLenum gl_type, 48 glsl_base_type base_type, unsigned vector_elements, 49 unsigned matrix_columns, const char *name, 50 unsigned explicit_stride, bool row_major, 51 unsigned explicit_alignment) : 52 gl_type(gl_type), 53 base_type(base_type), sampled_type(GLSL_TYPE_VOID), 54 sampler_dimensionality(0), sampler_shadow(0), sampler_array(0), 55 interface_packing(0), interface_row_major(row_major), packed(0), 56 vector_elements(vector_elements), matrix_columns(matrix_columns), 57 length(0), explicit_stride(explicit_stride), 58 explicit_alignment(explicit_alignment) 59 { 60 /* Values of these types must fit in the two bits of 61 * glsl_type::sampled_type. 62 */ 63 STATIC_ASSERT((unsigned(GLSL_TYPE_UINT) & 3) == unsigned(GLSL_TYPE_UINT)); 64 STATIC_ASSERT((unsigned(GLSL_TYPE_INT) & 3) == unsigned(GLSL_TYPE_INT)); 65 STATIC_ASSERT((unsigned(GLSL_TYPE_FLOAT) & 3) == unsigned(GLSL_TYPE_FLOAT)); 66 67 ASSERT_BITFIELD_SIZE(glsl_type, base_type, GLSL_TYPE_ERROR); 68 ASSERT_BITFIELD_SIZE(glsl_type, sampled_type, GLSL_TYPE_ERROR); 69 ASSERT_BITFIELD_SIZE(glsl_type, sampler_dimensionality, 70 GLSL_SAMPLER_DIM_SUBPASS_MS); 71 72 this->mem_ctx = ralloc_context(NULL); 73 assert(this->mem_ctx != NULL); 74 75 assert(name != NULL); 76 this->name = ralloc_strdup(this->mem_ctx, name); 77 78 /* Neither dimension is zero or both dimensions are zero. 79 */ 80 assert((vector_elements == 0) == (matrix_columns == 0)); 81 assert(util_is_power_of_two_or_zero(explicit_alignment)); 82 memset(& fields, 0, sizeof(fields)); 83 } 84 85 glsl_type::glsl_type(GLenum gl_type, glsl_base_type base_type, 86 enum glsl_sampler_dim dim, bool shadow, bool array, 87 glsl_base_type type, const char *name) : 88 gl_type(gl_type), 89 base_type(base_type), sampled_type(type), 90 sampler_dimensionality(dim), sampler_shadow(shadow), 91 sampler_array(array), interface_packing(0), 92 interface_row_major(0), packed(0), 93 length(0), explicit_stride(0), explicit_alignment(0) 94 { 95 this->mem_ctx = ralloc_context(NULL); 96 assert(this->mem_ctx != NULL); 97 98 assert(name != NULL); 99 this->name = ralloc_strdup(this->mem_ctx, name); 100 101 memset(& fields, 0, sizeof(fields)); 102 103 matrix_columns = vector_elements = 1; 104 } 105 106 glsl_type::glsl_type(const glsl_struct_field *fields, unsigned num_fields, 107 const char *name, bool packed, 108 unsigned explicit_alignment) : 109 gl_type(0), 110 base_type(GLSL_TYPE_STRUCT), sampled_type(GLSL_TYPE_VOID), 111 sampler_dimensionality(0), sampler_shadow(0), sampler_array(0), 112 interface_packing(0), interface_row_major(0), packed(packed), 113 vector_elements(0), matrix_columns(0), 114 length(num_fields), explicit_stride(0), 115 explicit_alignment(explicit_alignment) 116 { 117 unsigned int i; 118 119 assert(util_is_power_of_two_or_zero(explicit_alignment)); 120 121 this->mem_ctx = ralloc_context(NULL); 122 assert(this->mem_ctx != NULL); 123 124 assert(name != NULL); 125 this->name = ralloc_strdup(this->mem_ctx, name); 126 /* Zero-fill to prevent spurious Valgrind errors when serializing NIR 127 * due to uninitialized unused bits in bit fields. */ 128 this->fields.structure = rzalloc_array(this->mem_ctx, 129 glsl_struct_field, length); 130 131 for (i = 0; i < length; i++) { 132 this->fields.structure[i] = fields[i]; 133 this->fields.structure[i].name = ralloc_strdup(this->fields.structure, 134 fields[i].name); 135 } 136 } 137 138 glsl_type::glsl_type(const glsl_struct_field *fields, unsigned num_fields, 139 enum glsl_interface_packing packing, 140 bool row_major, const char *name) : 141 gl_type(0), 142 base_type(GLSL_TYPE_INTERFACE), sampled_type(GLSL_TYPE_VOID), 143 sampler_dimensionality(0), sampler_shadow(0), sampler_array(0), 144 interface_packing((unsigned) packing), 145 interface_row_major((unsigned) row_major), packed(0), 146 vector_elements(0), matrix_columns(0), 147 length(num_fields), explicit_stride(0), explicit_alignment(0) 148 { 149 unsigned int i; 150 151 this->mem_ctx = ralloc_context(NULL); 152 assert(this->mem_ctx != NULL); 153 154 assert(name != NULL); 155 this->name = ralloc_strdup(this->mem_ctx, name); 156 this->fields.structure = rzalloc_array(this->mem_ctx, 157 glsl_struct_field, length); 158 for (i = 0; i < length; i++) { 159 this->fields.structure[i] = fields[i]; 160 this->fields.structure[i].name = ralloc_strdup(this->fields.structure, 161 fields[i].name); 162 } 163 } 164 165 glsl_type::glsl_type(const glsl_type *return_type, 166 const glsl_function_param *params, unsigned num_params) : 167 gl_type(0), 168 base_type(GLSL_TYPE_FUNCTION), sampled_type(GLSL_TYPE_VOID), 169 sampler_dimensionality(0), sampler_shadow(0), sampler_array(0), 170 interface_packing(0), interface_row_major(0), packed(0), 171 vector_elements(0), matrix_columns(0), 172 length(num_params), explicit_stride(0), explicit_alignment(0) 173 { 174 unsigned int i; 175 176 this->mem_ctx = ralloc_context(NULL); 177 assert(this->mem_ctx != NULL); 178 179 this->name = ralloc_strdup(this->mem_ctx, ""); 180 181 this->fields.parameters = rzalloc_array(this->mem_ctx, 182 glsl_function_param, num_params + 1); 183 184 /* We store the return type as the first parameter */ 185 this->fields.parameters[0].type = return_type; 186 this->fields.parameters[0].in = false; 187 this->fields.parameters[0].out = true; 188 189 /* We store the i'th parameter in slot i+1 */ 190 for (i = 0; i < length; i++) { 191 this->fields.parameters[i + 1].type = params[i].type; 192 this->fields.parameters[i + 1].in = params[i].in; 193 this->fields.parameters[i + 1].out = params[i].out; 194 } 195 } 196 197 glsl_type::glsl_type(const char *subroutine_name) : 198 gl_type(0), 199 base_type(GLSL_TYPE_SUBROUTINE), sampled_type(GLSL_TYPE_VOID), 200 sampler_dimensionality(0), sampler_shadow(0), sampler_array(0), 201 interface_packing(0), interface_row_major(0), packed(0), 202 vector_elements(1), matrix_columns(1), 203 length(0), explicit_stride(0), explicit_alignment(0) 204 { 205 this->mem_ctx = ralloc_context(NULL); 206 assert(this->mem_ctx != NULL); 207 208 assert(subroutine_name != NULL); 209 this->name = ralloc_strdup(this->mem_ctx, subroutine_name); 210 } 211 212 glsl_type::~glsl_type() 213 { 214 ralloc_free(this->mem_ctx); 215 } 216 217 bool 218 glsl_type::contains_sampler() const 219 { 220 if (this->is_array()) { 221 return this->fields.array->contains_sampler(); 222 } else if (this->is_struct() || this->is_interface()) { 223 for (unsigned int i = 0; i < this->length; i++) { 224 if (this->fields.structure[i].type->contains_sampler()) 225 return true; 226 } 227 return false; 228 } else { 229 return this->is_sampler(); 230 } 231 } 232 233 bool 234 glsl_type::contains_array() const 235 { 236 if (this->is_struct() || this->is_interface()) { 237 for (unsigned int i = 0; i < this->length; i++) { 238 if (this->fields.structure[i].type->contains_array()) 239 return true; 240 } 241 return false; 242 } else { 243 return this->is_array(); 244 } 245 } 246 247 bool 248 glsl_type::contains_integer() const 249 { 250 if (this->is_array()) { 251 return this->fields.array->contains_integer(); 252 } else if (this->is_struct() || this->is_interface()) { 253 for (unsigned int i = 0; i < this->length; i++) { 254 if (this->fields.structure[i].type->contains_integer()) 255 return true; 256 } 257 return false; 258 } else { 259 return this->is_integer(); 260 } 261 } 262 263 bool 264 glsl_type::contains_double() const 265 { 266 if (this->is_array()) { 267 return this->fields.array->contains_double(); 268 } else if (this->is_struct() || this->is_interface()) { 269 for (unsigned int i = 0; i < this->length; i++) { 270 if (this->fields.structure[i].type->contains_double()) 271 return true; 272 } 273 return false; 274 } else { 275 return this->is_double(); 276 } 277 } 278 279 bool 280 glsl_type::contains_64bit() const 281 { 282 if (this->is_array()) { 283 return this->fields.array->contains_64bit(); 284 } else if (this->is_struct() || this->is_interface()) { 285 for (unsigned int i = 0; i < this->length; i++) { 286 if (this->fields.structure[i].type->contains_64bit()) 287 return true; 288 } 289 return false; 290 } else { 291 return this->is_64bit(); 292 } 293 } 294 295 bool 296 glsl_type::contains_opaque() const { 297 switch (base_type) { 298 case GLSL_TYPE_SAMPLER: 299 case GLSL_TYPE_IMAGE: 300 case GLSL_TYPE_ATOMIC_UINT: 301 return true; 302 case GLSL_TYPE_ARRAY: 303 return fields.array->contains_opaque(); 304 case GLSL_TYPE_STRUCT: 305 case GLSL_TYPE_INTERFACE: 306 for (unsigned int i = 0; i < length; i++) { 307 if (fields.structure[i].type->contains_opaque()) 308 return true; 309 } 310 return false; 311 default: 312 return false; 313 } 314 } 315 316 bool 317 glsl_type::contains_subroutine() const 318 { 319 if (this->is_array()) { 320 return this->fields.array->contains_subroutine(); 321 } else if (this->is_struct() || this->is_interface()) { 322 for (unsigned int i = 0; i < this->length; i++) { 323 if (this->fields.structure[i].type->contains_subroutine()) 324 return true; 325 } 326 return false; 327 } else { 328 return this->is_subroutine(); 329 } 330 } 331 332 gl_texture_index 333 glsl_type::sampler_index() const 334 { 335 const glsl_type *const t = (this->is_array()) ? this->fields.array : this; 336 337 assert(t->is_sampler() || t->is_image()); 338 339 switch (t->sampler_dimensionality) { 340 case GLSL_SAMPLER_DIM_1D: 341 return (t->sampler_array) ? TEXTURE_1D_ARRAY_INDEX : TEXTURE_1D_INDEX; 342 case GLSL_SAMPLER_DIM_2D: 343 return (t->sampler_array) ? TEXTURE_2D_ARRAY_INDEX : TEXTURE_2D_INDEX; 344 case GLSL_SAMPLER_DIM_3D: 345 return TEXTURE_3D_INDEX; 346 case GLSL_SAMPLER_DIM_CUBE: 347 return (t->sampler_array) ? TEXTURE_CUBE_ARRAY_INDEX : TEXTURE_CUBE_INDEX; 348 case GLSL_SAMPLER_DIM_RECT: 349 return TEXTURE_RECT_INDEX; 350 case GLSL_SAMPLER_DIM_BUF: 351 return TEXTURE_BUFFER_INDEX; 352 case GLSL_SAMPLER_DIM_EXTERNAL: 353 return TEXTURE_EXTERNAL_INDEX; 354 case GLSL_SAMPLER_DIM_MS: 355 return (t->sampler_array) ? TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX : TEXTURE_2D_MULTISAMPLE_INDEX; 356 default: 357 assert(!"Should not get here."); 358 return TEXTURE_BUFFER_INDEX; 359 } 360 } 361 362 bool 363 glsl_type::contains_image() const 364 { 365 if (this->is_array()) { 366 return this->fields.array->contains_image(); 367 } else if (this->is_struct() || this->is_interface()) { 368 for (unsigned int i = 0; i < this->length; i++) { 369 if (this->fields.structure[i].type->contains_image()) 370 return true; 371 } 372 return false; 373 } else { 374 return this->is_image(); 375 } 376 } 377 378 const glsl_type *glsl_type::get_base_type() const 379 { 380 switch (base_type) { 381 case GLSL_TYPE_UINT: 382 return uint_type; 383 case GLSL_TYPE_UINT16: 384 return uint16_t_type; 385 case GLSL_TYPE_UINT8: 386 return uint8_t_type; 387 case GLSL_TYPE_INT: 388 return int_type; 389 case GLSL_TYPE_INT16: 390 return int16_t_type; 391 case GLSL_TYPE_INT8: 392 return int8_t_type; 393 case GLSL_TYPE_FLOAT: 394 return float_type; 395 case GLSL_TYPE_FLOAT16: 396 return float16_t_type; 397 case GLSL_TYPE_DOUBLE: 398 return double_type; 399 case GLSL_TYPE_BOOL: 400 return bool_type; 401 case GLSL_TYPE_UINT64: 402 return uint64_t_type; 403 case GLSL_TYPE_INT64: 404 return int64_t_type; 405 default: 406 return error_type; 407 } 408 } 409 410 411 const glsl_type *glsl_type::get_scalar_type() const 412 { 413 const glsl_type *type = this; 414 415 /* Handle arrays */ 416 while (type->base_type == GLSL_TYPE_ARRAY) 417 type = type->fields.array; 418 419 const glsl_type *scalar_type = type->get_base_type(); 420 if (scalar_type == error_type) 421 return type; 422 423 return scalar_type; 424 } 425 426 427 const glsl_type *glsl_type::get_bare_type() const 428 { 429 switch (this->base_type) { 430 case GLSL_TYPE_UINT8: 431 case GLSL_TYPE_INT8: 432 case GLSL_TYPE_UINT16: 433 case GLSL_TYPE_INT16: 434 case GLSL_TYPE_FLOAT16: 435 case GLSL_TYPE_UINT: 436 case GLSL_TYPE_INT: 437 case GLSL_TYPE_FLOAT: 438 case GLSL_TYPE_BOOL: 439 case GLSL_TYPE_DOUBLE: 440 case GLSL_TYPE_UINT64: 441 case GLSL_TYPE_INT64: 442 return get_instance(this->base_type, this->vector_elements, 443 this->matrix_columns); 444 445 case GLSL_TYPE_STRUCT: 446 case GLSL_TYPE_INTERFACE: { 447 glsl_struct_field *bare_fields = new glsl_struct_field[this->length]; 448 for (unsigned i = 0; i < this->length; i++) { 449 bare_fields[i].type = this->fields.structure[i].type->get_bare_type(); 450 bare_fields[i].name = this->fields.structure[i].name; 451 } 452 const glsl_type *bare_type = 453 get_struct_instance(bare_fields, this->length, this->name); 454 delete[] bare_fields; 455 return bare_type; 456 } 457 458 case GLSL_TYPE_ARRAY: 459 return get_array_instance(this->fields.array->get_bare_type(), 460 this->length); 461 462 case GLSL_TYPE_SAMPLER: 463 case GLSL_TYPE_IMAGE: 464 case GLSL_TYPE_ATOMIC_UINT: 465 case GLSL_TYPE_VOID: 466 case GLSL_TYPE_SUBROUTINE: 467 case GLSL_TYPE_FUNCTION: 468 case GLSL_TYPE_ERROR: 469 return this; 470 } 471 472 unreachable("Invalid base type"); 473 } 474 475 const glsl_type *glsl_type::get_float16_type() const 476 { 477 assert(this->base_type == GLSL_TYPE_FLOAT); 478 479 return get_instance(GLSL_TYPE_FLOAT16, 480 this->vector_elements, 481 this->matrix_columns, 482 this->explicit_stride, 483 this->interface_row_major); 484 } 485 486 const glsl_type *glsl_type::get_int16_type() const 487 { 488 assert(this->base_type == GLSL_TYPE_INT); 489 490 return get_instance(GLSL_TYPE_INT16, 491 this->vector_elements, 492 this->matrix_columns, 493 this->explicit_stride, 494 this->interface_row_major); 495 } 496 497 const glsl_type *glsl_type::get_uint16_type() const 498 { 499 assert(this->base_type == GLSL_TYPE_UINT); 500 501 return get_instance(GLSL_TYPE_UINT16, 502 this->vector_elements, 503 this->matrix_columns, 504 this->explicit_stride, 505 this->interface_row_major); 506 } 507 508 static void 509 hash_free_type_function(struct hash_entry *entry) 510 { 511 glsl_type *type = (glsl_type *) entry->data; 512 513 if (type->is_array()) 514 free((void*)entry->key); 515 516 delete type; 517 } 518 519 void 520 glsl_type_singleton_init_or_ref() 521 { 522 /* This is required for _mesa_half_to_float() which is 523 * required for constant-folding 16-bit float ops. 524 */ 525 util_cpu_detect(); 526 527 mtx_lock(&glsl_type::hash_mutex); 528 glsl_type_users++; 529 mtx_unlock(&glsl_type::hash_mutex); 530 } 531 532 void 533 glsl_type_singleton_decref() 534 { 535 mtx_lock(&glsl_type::hash_mutex); 536 assert(glsl_type_users > 0); 537 538 /* Do not release glsl_types if they are still used. */ 539 if (--glsl_type_users) { 540 mtx_unlock(&glsl_type::hash_mutex); 541 return; 542 } 543 544 if (glsl_type::explicit_matrix_types != NULL) { 545 _mesa_hash_table_destroy(glsl_type::explicit_matrix_types, 546 hash_free_type_function); 547 glsl_type::explicit_matrix_types = NULL; 548 } 549 550 if (glsl_type::array_types != NULL) { 551 _mesa_hash_table_destroy(glsl_type::array_types, hash_free_type_function); 552 glsl_type::array_types = NULL; 553 } 554 555 if (glsl_type::struct_types != NULL) { 556 _mesa_hash_table_destroy(glsl_type::struct_types, hash_free_type_function); 557 glsl_type::struct_types = NULL; 558 } 559 560 if (glsl_type::interface_types != NULL) { 561 _mesa_hash_table_destroy(glsl_type::interface_types, hash_free_type_function); 562 glsl_type::interface_types = NULL; 563 } 564 565 if (glsl_type::function_types != NULL) { 566 _mesa_hash_table_destroy(glsl_type::function_types, hash_free_type_function); 567 glsl_type::function_types = NULL; 568 } 569 570 if (glsl_type::subroutine_types != NULL) { 571 _mesa_hash_table_destroy(glsl_type::subroutine_types, hash_free_type_function); 572 glsl_type::subroutine_types = NULL; 573 } 574 575 mtx_unlock(&glsl_type::hash_mutex); 576 } 577 578 579 glsl_type::glsl_type(const glsl_type *array, unsigned length, 580 unsigned explicit_stride) : 581 base_type(GLSL_TYPE_ARRAY), sampled_type(GLSL_TYPE_VOID), 582 sampler_dimensionality(0), sampler_shadow(0), sampler_array(0), 583 interface_packing(0), interface_row_major(0), packed(0), 584 vector_elements(0), matrix_columns(0), 585 length(length), name(NULL), explicit_stride(explicit_stride), 586 explicit_alignment(array->explicit_alignment) 587 { 588 this->fields.array = array; 589 /* Inherit the gl type of the base. The GL type is used for 590 * uniform/statevar handling in Mesa and the arrayness of the type 591 * is represented by the size rather than the type. 592 */ 593 this->gl_type = array->gl_type; 594 595 /* Allow a maximum of 10 characters for the array size. This is enough 596 * for 32-bits of ~0. The extra 3 are for the '[', ']', and terminating 597 * NUL. 598 */ 599 const unsigned name_length = strlen(array->name) + 10 + 3; 600 601 this->mem_ctx = ralloc_context(NULL); 602 assert(this->mem_ctx != NULL); 603 604 char *const n = (char *) ralloc_size(this->mem_ctx, name_length); 605 606 if (length == 0) 607 snprintf(n, name_length, "%s[]", array->name); 608 else { 609 /* insert outermost dimensions in the correct spot 610 * otherwise the dimension order will be backwards 611 */ 612 const char *pos = strchr(array->name, '['); 613 if (pos) { 614 int idx = pos - array->name; 615 snprintf(n, idx+1, "%s", array->name); 616 snprintf(n + idx, name_length - idx, "[%u]%s", 617 length, array->name + idx); 618 } else { 619 snprintf(n, name_length, "%s[%u]", array->name, length); 620 } 621 } 622 623 this->name = n; 624 } 625 626 const glsl_type * 627 glsl_type::vec(unsigned components, const glsl_type *const ts[]) 628 { 629 unsigned n = components; 630 631 if (components == 8) 632 n = 5; 633 else if (components == 16) 634 n = 6; 635 636 if (n == 0 || n > 6) 637 return error_type; 638 639 return ts[n - 1]; 640 } 641 642 #define VECN(components, sname, vname) \ 643 const glsl_type * \ 644 glsl_type:: vname (unsigned components) \ 645 { \ 646 static const glsl_type *const ts[] = { \ 647 sname ## _type, vname ## 2_type, \ 648 vname ## 3_type, vname ## 4_type, \ 649 vname ## 8_type, vname ## 16_type, \ 650 }; \ 651 return glsl_type::vec(components, ts); \ 652 } 653 654 VECN(components, float, vec) 655 VECN(components, float16_t, f16vec) 656 VECN(components, double, dvec) 657 VECN(components, int, ivec) 658 VECN(components, uint, uvec) 659 VECN(components, bool, bvec) 660 VECN(components, int64_t, i64vec) 661 VECN(components, uint64_t, u64vec) 662 VECN(components, int16_t, i16vec) 663 VECN(components, uint16_t, u16vec) 664 VECN(components, int8_t, i8vec) 665 VECN(components, uint8_t, u8vec) 666 667 const glsl_type * 668 glsl_type::get_instance(unsigned base_type, unsigned rows, unsigned columns, 669 unsigned explicit_stride, bool row_major, 670 unsigned explicit_alignment) 671 { 672 if (base_type == GLSL_TYPE_VOID) { 673 assert(explicit_stride == 0 && explicit_alignment == 0 && !row_major); 674 return void_type; 675 } 676 677 /* Matrix and vector types with explicit strides or alignment have to be 678 * looked up in a table so they're handled separately. 679 */ 680 if (explicit_stride > 0 || explicit_alignment > 0) { 681 if (explicit_alignment > 0) { 682 assert(util_is_power_of_two_nonzero(explicit_alignment)); 683 assert(explicit_stride % explicit_alignment == 0); 684 } 685 686 const glsl_type *bare_type = get_instance(base_type, rows, columns); 687 688 assert(columns > 1 || (rows > 1 && !row_major)); 689 690 char name[128]; 691 snprintf(name, sizeof(name), "%sx%ua%uB%s", bare_type->name, 692 explicit_stride, explicit_alignment, row_major ? "RM" : ""); 693 694 mtx_lock(&glsl_type::hash_mutex); 695 assert(glsl_type_users > 0); 696 697 if (explicit_matrix_types == NULL) { 698 explicit_matrix_types = 699 _mesa_hash_table_create(NULL, _mesa_hash_string, 700 _mesa_key_string_equal); 701 } 702 703 const struct hash_entry *entry = 704 _mesa_hash_table_search(explicit_matrix_types, name); 705 if (entry == NULL) { 706 const glsl_type *t = new glsl_type(bare_type->gl_type, 707 (glsl_base_type)base_type, 708 rows, columns, name, 709 explicit_stride, row_major, 710 explicit_alignment); 711 712 entry = _mesa_hash_table_insert(explicit_matrix_types, 713 t->name, (void *)t); 714 } 715 716 assert(((glsl_type *) entry->data)->base_type == base_type); 717 assert(((glsl_type *) entry->data)->vector_elements == rows); 718 assert(((glsl_type *) entry->data)->matrix_columns == columns); 719 assert(((glsl_type *) entry->data)->explicit_stride == explicit_stride); 720 assert(((glsl_type *) entry->data)->explicit_alignment == explicit_alignment); 721 722 const glsl_type *t = (const glsl_type *) entry->data; 723 724 mtx_unlock(&glsl_type::hash_mutex); 725 726 return t; 727 } 728 729 assert(!row_major); 730 731 /* Treat GLSL vectors as Nx1 matrices. 732 */ 733 if (columns == 1) { 734 switch (base_type) { 735 case GLSL_TYPE_UINT: 736 return uvec(rows); 737 case GLSL_TYPE_INT: 738 return ivec(rows); 739 case GLSL_TYPE_FLOAT: 740 return vec(rows); 741 case GLSL_TYPE_FLOAT16: 742 return f16vec(rows); 743 case GLSL_TYPE_DOUBLE: 744 return dvec(rows); 745 case GLSL_TYPE_BOOL: 746 return bvec(rows); 747 case GLSL_TYPE_UINT64: 748 return u64vec(rows); 749 case GLSL_TYPE_INT64: 750 return i64vec(rows); 751 case GLSL_TYPE_UINT16: 752 return u16vec(rows); 753 case GLSL_TYPE_INT16: 754 return i16vec(rows); 755 case GLSL_TYPE_UINT8: 756 return u8vec(rows); 757 case GLSL_TYPE_INT8: 758 return i8vec(rows); 759 default: 760 return error_type; 761 } 762 } else { 763 if ((base_type != GLSL_TYPE_FLOAT && 764 base_type != GLSL_TYPE_DOUBLE && 765 base_type != GLSL_TYPE_FLOAT16) || (rows == 1)) 766 return error_type; 767 768 /* GLSL matrix types are named mat{COLUMNS}x{ROWS}. Only the following 769 * combinations are valid: 770 * 771 * 1 2 3 4 772 * 1 773 * 2 x x x 774 * 3 x x x 775 * 4 x x x 776 */ 777 #define IDX(c,r) (((c-1)*3) + (r-1)) 778 779 switch (base_type) { 780 case GLSL_TYPE_DOUBLE: { 781 switch (IDX(columns, rows)) { 782 case IDX(2,2): return dmat2_type; 783 case IDX(2,3): return dmat2x3_type; 784 case IDX(2,4): return dmat2x4_type; 785 case IDX(3,2): return dmat3x2_type; 786 case IDX(3,3): return dmat3_type; 787 case IDX(3,4): return dmat3x4_type; 788 case IDX(4,2): return dmat4x2_type; 789 case IDX(4,3): return dmat4x3_type; 790 case IDX(4,4): return dmat4_type; 791 default: return error_type; 792 } 793 } 794 case GLSL_TYPE_FLOAT: { 795 switch (IDX(columns, rows)) { 796 case IDX(2,2): return mat2_type; 797 case IDX(2,3): return mat2x3_type; 798 case IDX(2,4): return mat2x4_type; 799 case IDX(3,2): return mat3x2_type; 800 case IDX(3,3): return mat3_type; 801 case IDX(3,4): return mat3x4_type; 802 case IDX(4,2): return mat4x2_type; 803 case IDX(4,3): return mat4x3_type; 804 case IDX(4,4): return mat4_type; 805 default: return error_type; 806 } 807 } 808 case GLSL_TYPE_FLOAT16: { 809 switch (IDX(columns, rows)) { 810 case IDX(2,2): return f16mat2_type; 811 case IDX(2,3): return f16mat2x3_type; 812 case IDX(2,4): return f16mat2x4_type; 813 case IDX(3,2): return f16mat3x2_type; 814 case IDX(3,3): return f16mat3_type; 815 case IDX(3,4): return f16mat3x4_type; 816 case IDX(4,2): return f16mat4x2_type; 817 case IDX(4,3): return f16mat4x3_type; 818 case IDX(4,4): return f16mat4_type; 819 default: return error_type; 820 } 821 } 822 default: return error_type; 823 } 824 } 825 826 assert(!"Should not get here."); 827 return error_type; 828 } 829 830 const glsl_type * 831 glsl_type::get_sampler_instance(enum glsl_sampler_dim dim, 832 bool shadow, 833 bool array, 834 glsl_base_type type) 835 { 836 switch (type) { 837 case GLSL_TYPE_FLOAT: 838 switch (dim) { 839 case GLSL_SAMPLER_DIM_1D: 840 if (shadow) 841 return (array ? sampler1DArrayShadow_type : sampler1DShadow_type); 842 else 843 return (array ? sampler1DArray_type : sampler1D_type); 844 case GLSL_SAMPLER_DIM_2D: 845 if (shadow) 846 return (array ? sampler2DArrayShadow_type : sampler2DShadow_type); 847 else 848 return (array ? sampler2DArray_type : sampler2D_type); 849 case GLSL_SAMPLER_DIM_3D: 850 if (shadow || array) 851 return error_type; 852 else 853 return sampler3D_type; 854 case GLSL_SAMPLER_DIM_CUBE: 855 if (shadow) 856 return (array ? samplerCubeArrayShadow_type : samplerCubeShadow_type); 857 else 858 return (array ? samplerCubeArray_type : samplerCube_type); 859 case GLSL_SAMPLER_DIM_RECT: 860 if (array) 861 return error_type; 862 if (shadow) 863 return sampler2DRectShadow_type; 864 else 865 return sampler2DRect_type; 866 case GLSL_SAMPLER_DIM_BUF: 867 if (shadow || array) 868 return error_type; 869 else 870 return samplerBuffer_type; 871 case GLSL_SAMPLER_DIM_MS: 872 if (shadow) 873 return error_type; 874 return (array ? sampler2DMSArray_type : sampler2DMS_type); 875 case GLSL_SAMPLER_DIM_EXTERNAL: 876 if (shadow || array) 877 return error_type; 878 else 879 return samplerExternalOES_type; 880 case GLSL_SAMPLER_DIM_SUBPASS: 881 case GLSL_SAMPLER_DIM_SUBPASS_MS: 882 return error_type; 883 } 884 case GLSL_TYPE_INT: 885 if (shadow) 886 return error_type; 887 switch (dim) { 888 case GLSL_SAMPLER_DIM_1D: 889 return (array ? isampler1DArray_type : isampler1D_type); 890 case GLSL_SAMPLER_DIM_2D: 891 return (array ? isampler2DArray_type : isampler2D_type); 892 case GLSL_SAMPLER_DIM_3D: 893 if (array) 894 return error_type; 895 return isampler3D_type; 896 case GLSL_SAMPLER_DIM_CUBE: 897 return (array ? isamplerCubeArray_type : isamplerCube_type); 898 case GLSL_SAMPLER_DIM_RECT: 899 if (array) 900 return error_type; 901 return isampler2DRect_type; 902 case GLSL_SAMPLER_DIM_BUF: 903 if (array) 904 return error_type; 905 return isamplerBuffer_type; 906 case GLSL_SAMPLER_DIM_MS: 907 return (array ? isampler2DMSArray_type : isampler2DMS_type); 908 case GLSL_SAMPLER_DIM_EXTERNAL: 909 return error_type; 910 case GLSL_SAMPLER_DIM_SUBPASS: 911 case GLSL_SAMPLER_DIM_SUBPASS_MS: 912 return error_type; 913 } 914 case GLSL_TYPE_UINT: 915 if (shadow) 916 return error_type; 917 switch (dim) { 918 case GLSL_SAMPLER_DIM_1D: 919 return (array ? usampler1DArray_type : usampler1D_type); 920 case GLSL_SAMPLER_DIM_2D: 921 return (array ? usampler2DArray_type : usampler2D_type); 922 case GLSL_SAMPLER_DIM_3D: 923 if (array) 924 return error_type; 925 return usampler3D_type; 926 case GLSL_SAMPLER_DIM_CUBE: 927 return (array ? usamplerCubeArray_type : usamplerCube_type); 928 case GLSL_SAMPLER_DIM_RECT: 929 if (array) 930 return error_type; 931 return usampler2DRect_type; 932 case GLSL_SAMPLER_DIM_BUF: 933 if (array) 934 return error_type; 935 return usamplerBuffer_type; 936 case GLSL_SAMPLER_DIM_MS: 937 return (array ? usampler2DMSArray_type : usampler2DMS_type); 938 case GLSL_SAMPLER_DIM_EXTERNAL: 939 return error_type; 940 case GLSL_SAMPLER_DIM_SUBPASS: 941 case GLSL_SAMPLER_DIM_SUBPASS_MS: 942 return error_type; 943 } 944 case GLSL_TYPE_VOID: 945 return shadow ? samplerShadow_type : sampler_type; 946 default: 947 return error_type; 948 } 949 950 unreachable("switch statement above should be complete"); 951 } 952 953 const glsl_type * 954 glsl_type::get_image_instance(enum glsl_sampler_dim dim, 955 bool array, glsl_base_type type) 956 { 957 switch (type) { 958 case GLSL_TYPE_FLOAT: 959 switch (dim) { 960 case GLSL_SAMPLER_DIM_1D: 961 return (array ? image1DArray_type : image1D_type); 962 case GLSL_SAMPLER_DIM_2D: 963 return (array ? image2DArray_type : image2D_type); 964 case GLSL_SAMPLER_DIM_3D: 965 return image3D_type; 966 case GLSL_SAMPLER_DIM_CUBE: 967 return (array ? imageCubeArray_type : imageCube_type); 968 case GLSL_SAMPLER_DIM_RECT: 969 if (array) 970 return error_type; 971 else 972 return image2DRect_type; 973 case GLSL_SAMPLER_DIM_BUF: 974 if (array) 975 return error_type; 976 else 977 return imageBuffer_type; 978 case GLSL_SAMPLER_DIM_MS: 979 return (array ? image2DMSArray_type : image2DMS_type); 980 case GLSL_SAMPLER_DIM_SUBPASS: 981 return subpassInput_type; 982 case GLSL_SAMPLER_DIM_SUBPASS_MS: 983 return subpassInputMS_type; 984 case GLSL_SAMPLER_DIM_EXTERNAL: 985 return error_type; 986 } 987 case GLSL_TYPE_INT: 988 switch (dim) { 989 case GLSL_SAMPLER_DIM_1D: 990 return (array ? iimage1DArray_type : iimage1D_type); 991 case GLSL_SAMPLER_DIM_2D: 992 return (array ? iimage2DArray_type : iimage2D_type); 993 case GLSL_SAMPLER_DIM_3D: 994 if (array) 995 return error_type; 996 return iimage3D_type; 997 case GLSL_SAMPLER_DIM_CUBE: 998 return (array ? iimageCubeArray_type : iimageCube_type); 999 case GLSL_SAMPLER_DIM_RECT: 1000 if (array) 1001 return error_type; 1002 return iimage2DRect_type; 1003 case GLSL_SAMPLER_DIM_BUF: 1004 if (array) 1005 return error_type; 1006 return iimageBuffer_type; 1007 case GLSL_SAMPLER_DIM_MS: 1008 return (array ? iimage2DMSArray_type : iimage2DMS_type); 1009 case GLSL_SAMPLER_DIM_SUBPASS: 1010 return isubpassInput_type; 1011 case GLSL_SAMPLER_DIM_SUBPASS_MS: 1012 return isubpassInputMS_type; 1013 case GLSL_SAMPLER_DIM_EXTERNAL: 1014 return error_type; 1015 } 1016 case GLSL_TYPE_UINT: 1017 switch (dim) { 1018 case GLSL_SAMPLER_DIM_1D: 1019 return (array ? uimage1DArray_type : uimage1D_type); 1020 case GLSL_SAMPLER_DIM_2D: 1021 return (array ? uimage2DArray_type : uimage2D_type); 1022 case GLSL_SAMPLER_DIM_3D: 1023 if (array) 1024 return error_type; 1025 return uimage3D_type; 1026 case GLSL_SAMPLER_DIM_CUBE: 1027 return (array ? uimageCubeArray_type : uimageCube_type); 1028 case GLSL_SAMPLER_DIM_RECT: 1029 if (array) 1030 return error_type; 1031 return uimage2DRect_type; 1032 case GLSL_SAMPLER_DIM_BUF: 1033 if (array) 1034 return error_type; 1035 return uimageBuffer_type; 1036 case GLSL_SAMPLER_DIM_MS: 1037 return (array ? uimage2DMSArray_type : uimage2DMS_type); 1038 case GLSL_SAMPLER_DIM_SUBPASS: 1039 return usubpassInput_type; 1040 case GLSL_SAMPLER_DIM_SUBPASS_MS: 1041 return usubpassInputMS_type; 1042 case GLSL_SAMPLER_DIM_EXTERNAL: 1043 return error_type; 1044 } 1045 case GLSL_TYPE_INT64: 1046 switch (dim) { 1047 case GLSL_SAMPLER_DIM_1D: 1048 return (array ? i64image1DArray_type : i64image1D_type); 1049 case GLSL_SAMPLER_DIM_2D: 1050 return (array ? i64image2DArray_type : i64image2D_type); 1051 case GLSL_SAMPLER_DIM_3D: 1052 if (array) 1053 return error_type; 1054 return i64image3D_type; 1055 case GLSL_SAMPLER_DIM_CUBE: 1056 return (array ? i64imageCubeArray_type : i64imageCube_type); 1057 case GLSL_SAMPLER_DIM_RECT: 1058 if (array) 1059 return error_type; 1060 return i64image2DRect_type; 1061 case GLSL_SAMPLER_DIM_BUF: 1062 if (array) 1063 return error_type; 1064 return i64imageBuffer_type; 1065 case GLSL_SAMPLER_DIM_MS: 1066 return (array ? i64image2DMSArray_type : i64image2DMS_type); 1067 case GLSL_SAMPLER_DIM_SUBPASS: 1068 case GLSL_SAMPLER_DIM_SUBPASS_MS: 1069 case GLSL_SAMPLER_DIM_EXTERNAL: 1070 return error_type; 1071 } 1072 case GLSL_TYPE_UINT64: 1073 switch (dim) { 1074 case GLSL_SAMPLER_DIM_1D: 1075 return (array ? u64image1DArray_type : u64image1D_type); 1076 case GLSL_SAMPLER_DIM_2D: 1077 return (array ? u64image2DArray_type : u64image2D_type); 1078 case GLSL_SAMPLER_DIM_3D: 1079 if (array) 1080 return error_type; 1081 return u64image3D_type; 1082 case GLSL_SAMPLER_DIM_CUBE: 1083 return (array ? u64imageCubeArray_type : u64imageCube_type); 1084 case GLSL_SAMPLER_DIM_RECT: 1085 if (array) 1086 return error_type; 1087 return u64image2DRect_type; 1088 case GLSL_SAMPLER_DIM_BUF: 1089 if (array) 1090 return error_type; 1091 return u64imageBuffer_type; 1092 case GLSL_SAMPLER_DIM_MS: 1093 return (array ? u64image2DMSArray_type : u64image2DMS_type); 1094 case GLSL_SAMPLER_DIM_SUBPASS: 1095 case GLSL_SAMPLER_DIM_SUBPASS_MS: 1096 case GLSL_SAMPLER_DIM_EXTERNAL: 1097 return error_type; 1098 } 1099 case GLSL_TYPE_VOID: 1100 switch (dim) { 1101 case GLSL_SAMPLER_DIM_1D: 1102 return (array ? vimage1DArray_type : vimage1D_type); 1103 case GLSL_SAMPLER_DIM_2D: 1104 return (array ? vimage2DArray_type : vimage2D_type); 1105 case GLSL_SAMPLER_DIM_3D: 1106 return (array ? error_type : vimage3D_type); 1107 case GLSL_SAMPLER_DIM_BUF: 1108 return (array ? error_type : vbuffer_type); 1109 default: 1110 return error_type; 1111 } 1112 default: 1113 return error_type; 1114 } 1115 1116 unreachable("switch statement above should be complete"); 1117 } 1118 1119 const glsl_type * 1120 glsl_type::get_array_instance(const glsl_type *base, 1121 unsigned array_size, 1122 unsigned explicit_stride) 1123 { 1124 /* Generate a name using the base type pointer in the key. This is 1125 * done because the name of the base type may not be unique across 1126 * shaders. For example, two shaders may have different record types 1127 * named 'foo'. 1128 */ 1129 char key[128]; 1130 snprintf(key, sizeof(key), "%p[%u]x%uB", (void *) base, array_size, 1131 explicit_stride); 1132 1133 mtx_lock(&glsl_type::hash_mutex); 1134 assert(glsl_type_users > 0); 1135 1136 if (array_types == NULL) { 1137 array_types = _mesa_hash_table_create(NULL, _mesa_hash_string, 1138 _mesa_key_string_equal); 1139 } 1140 1141 const struct hash_entry *entry = _mesa_hash_table_search(array_types, key); 1142 if (entry == NULL) { 1143 const glsl_type *t = new glsl_type(base, array_size, explicit_stride); 1144 1145 entry = _mesa_hash_table_insert(array_types, 1146 strdup(key), 1147 (void *) t); 1148 } 1149 1150 assert(((glsl_type *) entry->data)->base_type == GLSL_TYPE_ARRAY); 1151 assert(((glsl_type *) entry->data)->length == array_size); 1152 assert(((glsl_type *) entry->data)->fields.array == base); 1153 1154 glsl_type *t = (glsl_type *) entry->data; 1155 1156 mtx_unlock(&glsl_type::hash_mutex); 1157 1158 return t; 1159 } 1160 1161 bool 1162 glsl_type::compare_no_precision(const glsl_type *b) const 1163 { 1164 if (this == b) 1165 return true; 1166 1167 if (this->is_array()) { 1168 if (!b->is_array() || this->length != b->length) 1169 return false; 1170 1171 const glsl_type *b_no_array = b->fields.array; 1172 1173 return this->fields.array->compare_no_precision(b_no_array); 1174 } 1175 1176 if (this->is_struct()) { 1177 if (!b->is_struct()) 1178 return false; 1179 } else if (this->is_interface()) { 1180 if (!b->is_interface()) 1181 return false; 1182 } else { 1183 return false; 1184 } 1185 1186 return record_compare(b, 1187 true, /* match_name */ 1188 true, /* match_locations */ 1189 false /* match_precision */); 1190 } 1191 1192 bool 1193 glsl_type::record_compare(const glsl_type *b, bool match_name, 1194 bool match_locations, bool match_precision) const 1195 { 1196 if (this->length != b->length) 1197 return false; 1198 1199 if (this->interface_packing != b->interface_packing) 1200 return false; 1201 1202 if (this->interface_row_major != b->interface_row_major) 1203 return false; 1204 1205 if (this->explicit_alignment != b->explicit_alignment) 1206 return false; 1207 1208 if (this->packed != b->packed) 1209 return false; 1210 1211 /* From the GLSL 4.20 specification (Sec 4.2): 1212 * 1213 * "Structures must have the same name, sequence of type names, and 1214 * type definitions, and field names to be considered the same type." 1215 * 1216 * GLSL ES behaves the same (Ver 1.00 Sec 4.2.4, Ver 3.00 Sec 4.2.5). 1217 * 1218 * Section 7.4.1 (Shader Interface Matching) of the OpenGL 4.30 spec says: 1219 * 1220 * "Variables or block members declared as structures are considered 1221 * to match in type if and only if structure members match in name, 1222 * type, qualification, and declaration order." 1223 */ 1224 if (match_name) 1225 if (strcmp(this->name, b->name) != 0) 1226 return false; 1227 1228 for (unsigned i = 0; i < this->length; i++) { 1229 if (match_precision) { 1230 if (this->fields.structure[i].type != b->fields.structure[i].type) 1231 return false; 1232 } else { 1233 const glsl_type *ta = this->fields.structure[i].type; 1234 const glsl_type *tb = b->fields.structure[i].type; 1235 if (!ta->compare_no_precision(tb)) 1236 return false; 1237 } 1238 if (strcmp(this->fields.structure[i].name, 1239 b->fields.structure[i].name) != 0) 1240 return false; 1241 if (this->fields.structure[i].matrix_layout 1242 != b->fields.structure[i].matrix_layout) 1243 return false; 1244 if (match_locations && this->fields.structure[i].location 1245 != b->fields.structure[i].location) 1246 return false; 1247 if (this->fields.structure[i].component 1248 != b->fields.structure[i].component) 1249 return false; 1250 if (this->fields.structure[i].offset 1251 != b->fields.structure[i].offset) 1252 return false; 1253 if (this->fields.structure[i].interpolation 1254 != b->fields.structure[i].interpolation) 1255 return false; 1256 if (this->fields.structure[i].centroid 1257 != b->fields.structure[i].centroid) 1258 return false; 1259 if (this->fields.structure[i].sample 1260 != b->fields.structure[i].sample) 1261 return false; 1262 if (this->fields.structure[i].patch 1263 != b->fields.structure[i].patch) 1264 return false; 1265 if (this->fields.structure[i].memory_read_only 1266 != b->fields.structure[i].memory_read_only) 1267 return false; 1268 if (this->fields.structure[i].memory_write_only 1269 != b->fields.structure[i].memory_write_only) 1270 return false; 1271 if (this->fields.structure[i].memory_coherent 1272 != b->fields.structure[i].memory_coherent) 1273 return false; 1274 if (this->fields.structure[i].memory_volatile 1275 != b->fields.structure[i].memory_volatile) 1276 return false; 1277 if (this->fields.structure[i].memory_restrict 1278 != b->fields.structure[i].memory_restrict) 1279 return false; 1280 if (this->fields.structure[i].image_format 1281 != b->fields.structure[i].image_format) 1282 return false; 1283 if (match_precision && 1284 this->fields.structure[i].precision 1285 != b->fields.structure[i].precision) 1286 return false; 1287 if (this->fields.structure[i].explicit_xfb_buffer 1288 != b->fields.structure[i].explicit_xfb_buffer) 1289 return false; 1290 if (this->fields.structure[i].xfb_buffer 1291 != b->fields.structure[i].xfb_buffer) 1292 return false; 1293 if (this->fields.structure[i].xfb_stride 1294 != b->fields.structure[i].xfb_stride) 1295 return false; 1296 } 1297 1298 return true; 1299 } 1300 1301 1302 bool 1303 glsl_type::record_key_compare(const void *a, const void *b) 1304 { 1305 const glsl_type *const key1 = (glsl_type *) a; 1306 const glsl_type *const key2 = (glsl_type *) b; 1307 1308 return strcmp(key1->name, key2->name) == 0 && 1309 key1->record_compare(key2, true); 1310 } 1311 1312 1313 /** 1314 * Generate an integer hash value for a glsl_type structure type. 1315 */ 1316 unsigned 1317 glsl_type::record_key_hash(const void *a) 1318 { 1319 const glsl_type *const key = (glsl_type *) a; 1320 uintptr_t hash = key->length; 1321 unsigned retval; 1322 1323 for (unsigned i = 0; i < key->length; i++) { 1324 /* casting pointer to uintptr_t */ 1325 hash = (hash * 13 ) + (uintptr_t) key->fields.structure[i].type; 1326 } 1327 1328 if (sizeof(hash) == 8) 1329 retval = (hash & 0xffffffff) ^ ((uint64_t) hash >> 32); 1330 else 1331 retval = hash; 1332 1333 return retval; 1334 } 1335 1336 1337 const glsl_type * 1338 glsl_type::get_struct_instance(const glsl_struct_field *fields, 1339 unsigned num_fields, 1340 const char *name, 1341 bool packed, unsigned explicit_alignment) 1342 { 1343 const glsl_type key(fields, num_fields, name, packed, explicit_alignment); 1344 1345 mtx_lock(&glsl_type::hash_mutex); 1346 assert(glsl_type_users > 0); 1347 1348 if (struct_types == NULL) { 1349 struct_types = _mesa_hash_table_create(NULL, record_key_hash, 1350 record_key_compare); 1351 } 1352 1353 const struct hash_entry *entry = _mesa_hash_table_search(struct_types, 1354 &key); 1355 if (entry == NULL) { 1356 const glsl_type *t = new glsl_type(fields, num_fields, name, packed, 1357 explicit_alignment); 1358 1359 entry = _mesa_hash_table_insert(struct_types, t, (void *) t); 1360 } 1361 1362 assert(((glsl_type *) entry->data)->base_type == GLSL_TYPE_STRUCT); 1363 assert(((glsl_type *) entry->data)->length == num_fields); 1364 assert(strcmp(((glsl_type *) entry->data)->name, name) == 0); 1365 assert(((glsl_type *) entry->data)->packed == packed); 1366 assert(((glsl_type *) entry->data)->explicit_alignment == explicit_alignment); 1367 1368 glsl_type *t = (glsl_type *) entry->data; 1369 1370 mtx_unlock(&glsl_type::hash_mutex); 1371 1372 return t; 1373 } 1374 1375 1376 const glsl_type * 1377 glsl_type::get_interface_instance(const glsl_struct_field *fields, 1378 unsigned num_fields, 1379 enum glsl_interface_packing packing, 1380 bool row_major, 1381 const char *block_name) 1382 { 1383 const glsl_type key(fields, num_fields, packing, row_major, block_name); 1384 1385 mtx_lock(&glsl_type::hash_mutex); 1386 assert(glsl_type_users > 0); 1387 1388 if (interface_types == NULL) { 1389 interface_types = _mesa_hash_table_create(NULL, record_key_hash, 1390 record_key_compare); 1391 } 1392 1393 const struct hash_entry *entry = _mesa_hash_table_search(interface_types, 1394 &key); 1395 if (entry == NULL) { 1396 const glsl_type *t = new glsl_type(fields, num_fields, 1397 packing, row_major, block_name); 1398 1399 entry = _mesa_hash_table_insert(interface_types, t, (void *) t); 1400 } 1401 1402 assert(((glsl_type *) entry->data)->base_type == GLSL_TYPE_INTERFACE); 1403 assert(((glsl_type *) entry->data)->length == num_fields); 1404 assert(strcmp(((glsl_type *) entry->data)->name, block_name) == 0); 1405 1406 glsl_type *t = (glsl_type *) entry->data; 1407 1408 mtx_unlock(&glsl_type::hash_mutex); 1409 1410 return t; 1411 } 1412 1413 const glsl_type * 1414 glsl_type::get_subroutine_instance(const char *subroutine_name) 1415 { 1416 const glsl_type key(subroutine_name); 1417 1418 mtx_lock(&glsl_type::hash_mutex); 1419 assert(glsl_type_users > 0); 1420 1421 if (subroutine_types == NULL) { 1422 subroutine_types = _mesa_hash_table_create(NULL, record_key_hash, 1423 record_key_compare); 1424 } 1425 1426 const struct hash_entry *entry = _mesa_hash_table_search(subroutine_types, 1427 &key); 1428 if (entry == NULL) { 1429 const glsl_type *t = new glsl_type(subroutine_name); 1430 1431 entry = _mesa_hash_table_insert(subroutine_types, t, (void *) t); 1432 } 1433 1434 assert(((glsl_type *) entry->data)->base_type == GLSL_TYPE_SUBROUTINE); 1435 assert(strcmp(((glsl_type *) entry->data)->name, subroutine_name) == 0); 1436 1437 glsl_type *t = (glsl_type *) entry->data; 1438 1439 mtx_unlock(&glsl_type::hash_mutex); 1440 1441 return t; 1442 } 1443 1444 1445 static bool 1446 function_key_compare(const void *a, const void *b) 1447 { 1448 const glsl_type *const key1 = (glsl_type *) a; 1449 const glsl_type *const key2 = (glsl_type *) b; 1450 1451 if (key1->length != key2->length) 1452 return false; 1453 1454 return memcmp(key1->fields.parameters, key2->fields.parameters, 1455 (key1->length + 1) * sizeof(*key1->fields.parameters)) == 0; 1456 } 1457 1458 1459 static uint32_t 1460 function_key_hash(const void *a) 1461 { 1462 const glsl_type *const key = (glsl_type *) a; 1463 return _mesa_hash_data(key->fields.parameters, 1464 (key->length + 1) * sizeof(*key->fields.parameters)); 1465 } 1466 1467 const glsl_type * 1468 glsl_type::get_function_instance(const glsl_type *return_type, 1469 const glsl_function_param *params, 1470 unsigned num_params) 1471 { 1472 const glsl_type key(return_type, params, num_params); 1473 1474 mtx_lock(&glsl_type::hash_mutex); 1475 assert(glsl_type_users > 0); 1476 1477 if (function_types == NULL) { 1478 function_types = _mesa_hash_table_create(NULL, function_key_hash, 1479 function_key_compare); 1480 } 1481 1482 struct hash_entry *entry = _mesa_hash_table_search(function_types, &key); 1483 if (entry == NULL) { 1484 const glsl_type *t = new glsl_type(return_type, params, num_params); 1485 1486 entry = _mesa_hash_table_insert(function_types, t, (void *) t); 1487 } 1488 1489 const glsl_type *t = (const glsl_type *)entry->data; 1490 1491 assert(t->base_type == GLSL_TYPE_FUNCTION); 1492 assert(t->length == num_params); 1493 1494 mtx_unlock(&glsl_type::hash_mutex); 1495 1496 return t; 1497 } 1498 1499 1500 const glsl_type * 1501 glsl_type::get_mul_type(const glsl_type *type_a, const glsl_type *type_b) 1502 { 1503 if (type_a->is_matrix() && type_b->is_matrix()) { 1504 /* Matrix multiply. The columns of A must match the rows of B. Given 1505 * the other previously tested constraints, this means the vector type 1506 * of a row from A must be the same as the vector type of a column from 1507 * B. 1508 */ 1509 if (type_a->row_type() == type_b->column_type()) { 1510 /* The resulting matrix has the number of columns of matrix B and 1511 * the number of rows of matrix A. We get the row count of A by 1512 * looking at the size of a vector that makes up a column. The 1513 * transpose (size of a row) is done for B. 1514 */ 1515 const glsl_type *const type = 1516 get_instance(type_a->base_type, 1517 type_a->column_type()->vector_elements, 1518 type_b->row_type()->vector_elements); 1519 assert(type != error_type); 1520 1521 return type; 1522 } 1523 } else if (type_a == type_b) { 1524 return type_a; 1525 } else if (type_a->is_matrix()) { 1526 /* A is a matrix and B is a column vector. Columns of A must match 1527 * rows of B. Given the other previously tested constraints, this 1528 * means the vector type of a row from A must be the same as the 1529 * vector the type of B. 1530 */ 1531 if (type_a->row_type() == type_b) { 1532 /* The resulting vector has a number of elements equal to 1533 * the number of rows of matrix A. */ 1534 const glsl_type *const type = 1535 get_instance(type_a->base_type, 1536 type_a->column_type()->vector_elements, 1537 1); 1538 assert(type != error_type); 1539 1540 return type; 1541 } 1542 } else { 1543 assert(type_b->is_matrix()); 1544 1545 /* A is a row vector and B is a matrix. Columns of A must match rows 1546 * of B. Given the other previously tested constraints, this means 1547 * the type of A must be the same as the vector type of a column from 1548 * B. 1549 */ 1550 if (type_a == type_b->column_type()) { 1551 /* The resulting vector has a number of elements equal to 1552 * the number of columns of matrix B. */ 1553 const glsl_type *const type = 1554 get_instance(type_a->base_type, 1555 type_b->row_type()->vector_elements, 1556 1); 1557 assert(type != error_type); 1558 1559 return type; 1560 } 1561 } 1562 1563 return error_type; 1564 } 1565 1566 1567 const glsl_type * 1568 glsl_type::field_type(const char *name) const 1569 { 1570 if (this->base_type != GLSL_TYPE_STRUCT 1571 && this->base_type != GLSL_TYPE_INTERFACE) 1572 return error_type; 1573 1574 for (unsigned i = 0; i < this->length; i++) { 1575 if (strcmp(name, this->fields.structure[i].name) == 0) 1576 return this->fields.structure[i].type; 1577 } 1578 1579 return error_type; 1580 } 1581 1582 1583 int 1584 glsl_type::field_index(const char *name) const 1585 { 1586 if (this->base_type != GLSL_TYPE_STRUCT 1587 && this->base_type != GLSL_TYPE_INTERFACE) 1588 return -1; 1589 1590 for (unsigned i = 0; i < this->length; i++) { 1591 if (strcmp(name, this->fields.structure[i].name) == 0) 1592 return i; 1593 } 1594 1595 return -1; 1596 } 1597 1598 1599 unsigned 1600 glsl_type::component_slots() const 1601 { 1602 switch (this->base_type) { 1603 case GLSL_TYPE_UINT: 1604 case GLSL_TYPE_INT: 1605 case GLSL_TYPE_UINT8: 1606 case GLSL_TYPE_INT8: 1607 case GLSL_TYPE_UINT16: 1608 case GLSL_TYPE_INT16: 1609 case GLSL_TYPE_FLOAT: 1610 case GLSL_TYPE_FLOAT16: 1611 case GLSL_TYPE_BOOL: 1612 return this->components(); 1613 1614 case GLSL_TYPE_DOUBLE: 1615 case GLSL_TYPE_UINT64: 1616 case GLSL_TYPE_INT64: 1617 return 2 * this->components(); 1618 1619 case GLSL_TYPE_STRUCT: 1620 case GLSL_TYPE_INTERFACE: { 1621 unsigned size = 0; 1622 1623 for (unsigned i = 0; i < this->length; i++) 1624 size += this->fields.structure[i].type->component_slots(); 1625 1626 return size; 1627 } 1628 1629 case GLSL_TYPE_ARRAY: 1630 return this->length * this->fields.array->component_slots(); 1631 1632 case GLSL_TYPE_SAMPLER: 1633 case GLSL_TYPE_IMAGE: 1634 return 2; 1635 1636 case GLSL_TYPE_SUBROUTINE: 1637 return 1; 1638 1639 case GLSL_TYPE_FUNCTION: 1640 case GLSL_TYPE_ATOMIC_UINT: 1641 case GLSL_TYPE_VOID: 1642 case GLSL_TYPE_ERROR: 1643 break; 1644 } 1645 1646 return 0; 1647 } 1648 1649 unsigned 1650 glsl_type::component_slots_aligned(unsigned offset) const 1651 { 1652 /* Align 64bit type only if it crosses attribute slot boundary. */ 1653 switch (this->base_type) { 1654 case GLSL_TYPE_UINT: 1655 case GLSL_TYPE_INT: 1656 case GLSL_TYPE_UINT8: 1657 case GLSL_TYPE_INT8: 1658 case GLSL_TYPE_UINT16: 1659 case GLSL_TYPE_INT16: 1660 case GLSL_TYPE_FLOAT: 1661 case GLSL_TYPE_FLOAT16: 1662 case GLSL_TYPE_BOOL: 1663 return this->components(); 1664 1665 case GLSL_TYPE_DOUBLE: 1666 case GLSL_TYPE_UINT64: 1667 case GLSL_TYPE_INT64: { 1668 unsigned size = 2 * this->components(); 1669 if (offset % 2 == 1 && (offset % 4 + size) > 4) { 1670 size++; 1671 } 1672 1673 return size; 1674 } 1675 1676 case GLSL_TYPE_STRUCT: 1677 case GLSL_TYPE_INTERFACE: { 1678 unsigned size = 0; 1679 1680 for (unsigned i = 0; i < this->length; i++) { 1681 const glsl_type *member = this->fields.structure[i].type; 1682 size += member->component_slots_aligned(size + offset); 1683 } 1684 1685 return size; 1686 } 1687 1688 case GLSL_TYPE_ARRAY: { 1689 unsigned size = 0; 1690 1691 for (unsigned i = 0; i < this->length; i++) { 1692 size += this->fields.array->component_slots_aligned(size + offset); 1693 } 1694 1695 return size; 1696 } 1697 1698 case GLSL_TYPE_SAMPLER: 1699 case GLSL_TYPE_IMAGE: 1700 return 2 + ((offset % 4) == 3 ? 1 : 0); 1701 1702 case GLSL_TYPE_SUBROUTINE: 1703 return 1; 1704 1705 case GLSL_TYPE_FUNCTION: 1706 case GLSL_TYPE_ATOMIC_UINT: 1707 case GLSL_TYPE_VOID: 1708 case GLSL_TYPE_ERROR: 1709 break; 1710 } 1711 1712 return 0; 1713 } 1714 1715 unsigned 1716 glsl_type::struct_location_offset(unsigned length) const 1717 { 1718 unsigned offset = 0; 1719 const glsl_type *t = this->without_array(); 1720 if (t->is_struct()) { 1721 assert(length <= t->length); 1722 1723 for (unsigned i = 0; i < length; i++) { 1724 const glsl_type *st = t->fields.structure[i].type; 1725 const glsl_type *wa = st->without_array(); 1726 if (wa->is_struct()) { 1727 unsigned r_offset = wa->struct_location_offset(wa->length); 1728 offset += st->is_array() ? 1729 st->arrays_of_arrays_size() * r_offset : r_offset; 1730 } else if (st->is_array() && st->fields.array->is_array()) { 1731 unsigned outer_array_size = st->length; 1732 const glsl_type *base_type = st->fields.array; 1733 1734 /* For arrays of arrays the outer arrays take up a uniform 1735 * slot for each element. The innermost array elements share a 1736 * single slot so we ignore the innermost array when calculating 1737 * the offset. 1738 */ 1739 while (base_type->fields.array->is_array()) { 1740 outer_array_size = outer_array_size * base_type->length; 1741 base_type = base_type->fields.array; 1742 } 1743 offset += outer_array_size; 1744 } else { 1745 /* We dont worry about arrays here because unless the array 1746 * contains a structure or another array it only takes up a single 1747 * uniform slot. 1748 */ 1749 offset += 1; 1750 } 1751 } 1752 } 1753 return offset; 1754 } 1755 1756 unsigned 1757 glsl_type::uniform_locations() const 1758 { 1759 unsigned size = 0; 1760 1761 switch (this->base_type) { 1762 case GLSL_TYPE_UINT: 1763 case GLSL_TYPE_INT: 1764 case GLSL_TYPE_FLOAT: 1765 case GLSL_TYPE_FLOAT16: 1766 case GLSL_TYPE_DOUBLE: 1767 case GLSL_TYPE_UINT16: 1768 case GLSL_TYPE_UINT8: 1769 case GLSL_TYPE_INT16: 1770 case GLSL_TYPE_INT8: 1771 case GLSL_TYPE_UINT64: 1772 case GLSL_TYPE_INT64: 1773 case GLSL_TYPE_BOOL: 1774 case GLSL_TYPE_SAMPLER: 1775 case GLSL_TYPE_IMAGE: 1776 case GLSL_TYPE_SUBROUTINE: 1777 return 1; 1778 1779 case GLSL_TYPE_STRUCT: 1780 case GLSL_TYPE_INTERFACE: 1781 for (unsigned i = 0; i < this->length; i++) 1782 size += this->fields.structure[i].type->uniform_locations(); 1783 return size; 1784 case GLSL_TYPE_ARRAY: 1785 return this->length * this->fields.array->uniform_locations(); 1786 default: 1787 return 0; 1788 } 1789 } 1790 1791 unsigned 1792 glsl_type::varying_count() const 1793 { 1794 unsigned size = 0; 1795 1796 switch (this->base_type) { 1797 case GLSL_TYPE_UINT: 1798 case GLSL_TYPE_INT: 1799 case GLSL_TYPE_FLOAT: 1800 case GLSL_TYPE_FLOAT16: 1801 case GLSL_TYPE_DOUBLE: 1802 case GLSL_TYPE_BOOL: 1803 case GLSL_TYPE_UINT16: 1804 case GLSL_TYPE_UINT8: 1805 case GLSL_TYPE_INT16: 1806 case GLSL_TYPE_INT8: 1807 case GLSL_TYPE_UINT64: 1808 case GLSL_TYPE_INT64: 1809 return 1; 1810 1811 case GLSL_TYPE_STRUCT: 1812 case GLSL_TYPE_INTERFACE: 1813 for (unsigned i = 0; i < this->length; i++) 1814 size += this->fields.structure[i].type->varying_count(); 1815 return size; 1816 case GLSL_TYPE_ARRAY: 1817 /* Don't count innermost array elements */ 1818 if (this->without_array()->is_struct() || 1819 this->without_array()->is_interface() || 1820 this->fields.array->is_array()) 1821 return this->length * this->fields.array->varying_count(); 1822 else 1823 return this->fields.array->varying_count(); 1824 default: 1825 assert(!"unsupported varying type"); 1826 return 0; 1827 } 1828 } 1829 1830 bool 1831 glsl_type::can_implicitly_convert_to(const glsl_type *desired, 1832 _mesa_glsl_parse_state *state) const 1833 { 1834 if (this == desired) 1835 return true; 1836 1837 /* GLSL 1.10 and ESSL do not allow implicit conversions. If there is no 1838 * state, we're doing intra-stage function linking where these checks have 1839 * already been done. 1840 */ 1841 if (state && !state->has_implicit_conversions()) 1842 return false; 1843 1844 /* There is no conversion among matrix types. */ 1845 if (this->matrix_columns > 1 || desired->matrix_columns > 1) 1846 return false; 1847 1848 /* Vector size must match. */ 1849 if (this->vector_elements != desired->vector_elements) 1850 return false; 1851 1852 /* int and uint can be converted to float. */ 1853 if (desired->is_float() && this->is_integer_32()) 1854 return true; 1855 1856 /* With GLSL 4.0, ARB_gpu_shader5, or MESA_shader_integer_functions, int 1857 * can be converted to uint. Note that state may be NULL here, when 1858 * resolving function calls in the linker. By this time, all the 1859 * state-dependent checks have already happened though, so allow anything 1860 * that's allowed in any shader version. 1861 */ 1862 if ((!state || state->has_implicit_int_to_uint_conversion()) && 1863 desired->base_type == GLSL_TYPE_UINT && this->base_type == GLSL_TYPE_INT) 1864 return true; 1865 1866 /* No implicit conversions from double. */ 1867 if ((!state || state->has_double()) && this->is_double()) 1868 return false; 1869 1870 /* Conversions from different types to double. */ 1871 if ((!state || state->has_double()) && desired->is_double()) { 1872 if (this->is_float()) 1873 return true; 1874 if (this->is_integer_32()) 1875 return true; 1876 } 1877 1878 return false; 1879 } 1880 1881 unsigned 1882 glsl_type::std140_base_alignment(bool row_major) const 1883 { 1884 unsigned N = is_64bit() ? 8 : 4; 1885 1886 /* (1) If the member is a scalar consuming <N> basic machine units, the 1887 * base alignment is <N>. 1888 * 1889 * (2) If the member is a two- or four-component vector with components 1890 * consuming <N> basic machine units, the base alignment is 2<N> or 1891 * 4<N>, respectively. 1892 * 1893 * (3) If the member is a three-component vector with components consuming 1894 * <N> basic machine units, the base alignment is 4<N>. 1895 */ 1896 if (this->is_scalar() || this->is_vector()) { 1897 switch (this->vector_elements) { 1898 case 1: 1899 return N; 1900 case 2: 1901 return 2 * N; 1902 case 3: 1903 case 4: 1904 return 4 * N; 1905 } 1906 } 1907 1908 /* (4) If the member is an array of scalars or vectors, the base alignment 1909 * and array stride are set to match the base alignment of a single 1910 * array element, according to rules (1), (2), and (3), and rounded up 1911 * to the base alignment of a vec4. The array may have padding at the 1912 * end; the base offset of the member following the array is rounded up 1913 * to the next multiple of the base alignment. 1914 * 1915 * (6) If the member is an array of <S> column-major matrices with <C> 1916 * columns and <R> rows, the matrix is stored identically to a row of 1917 * <S>*<C> column vectors with <R> components each, according to rule 1918 * (4). 1919 * 1920 * (8) If the member is an array of <S> row-major matrices with <C> columns 1921 * and <R> rows, the matrix is stored identically to a row of <S>*<R> 1922 * row vectors with <C> components each, according to rule (4). 1923 * 1924 * (10) If the member is an array of <S> structures, the <S> elements of 1925 * the array are laid out in order, according to rule (9). 1926 */ 1927 if (this->is_array()) { 1928 if (this->fields.array->is_scalar() || 1929 this->fields.array->is_vector() || 1930 this->fields.array->is_matrix()) { 1931 return MAX2(this->fields.array->std140_base_alignment(row_major), 16); 1932 } else { 1933 assert(this->fields.array->is_struct() || 1934 this->fields.array->is_array()); 1935 return this->fields.array->std140_base_alignment(row_major); 1936 } 1937 } 1938 1939 /* (5) If the member is a column-major matrix with <C> columns and 1940 * <R> rows, the matrix is stored identically to an array of 1941 * <C> column vectors with <R> components each, according to 1942 * rule (4). 1943 * 1944 * (7) If the member is a row-major matrix with <C> columns and <R> 1945 * rows, the matrix is stored identically to an array of <R> 1946 * row vectors with <C> components each, according to rule (4). 1947 */ 1948 if (this->is_matrix()) { 1949 const struct glsl_type *vec_type, *array_type; 1950 int c = this->matrix_columns; 1951 int r = this->vector_elements; 1952 1953 if (row_major) { 1954 vec_type = get_instance(base_type, c, 1); 1955 array_type = glsl_type::get_array_instance(vec_type, r); 1956 } else { 1957 vec_type = get_instance(base_type, r, 1); 1958 array_type = glsl_type::get_array_instance(vec_type, c); 1959 } 1960 1961 return array_type->std140_base_alignment(false); 1962 } 1963 1964 /* (9) If the member is a structure, the base alignment of the 1965 * structure is <N>, where <N> is the largest base alignment 1966 * value of any of its members, and rounded up to the base 1967 * alignment of a vec4. The individual members of this 1968 * sub-structure are then assigned offsets by applying this set 1969 * of rules recursively, where the base offset of the first 1970 * member of the sub-structure is equal to the aligned offset 1971 * of the structure. The structure may have padding at the end; 1972 * the base offset of the member following the sub-structure is 1973 * rounded up to the next multiple of the base alignment of the 1974 * structure. 1975 */ 1976 if (this->is_struct()) { 1977 unsigned base_alignment = 16; 1978 for (unsigned i = 0; i < this->length; i++) { 1979 bool field_row_major = row_major; 1980 const enum glsl_matrix_layout matrix_layout = 1981 glsl_matrix_layout(this->fields.structure[i].matrix_layout); 1982 if (matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) { 1983 field_row_major = true; 1984 } else if (matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) { 1985 field_row_major = false; 1986 } 1987 1988 const struct glsl_type *field_type = this->fields.structure[i].type; 1989 base_alignment = MAX2(base_alignment, 1990 field_type->std140_base_alignment(field_row_major)); 1991 } 1992 return base_alignment; 1993 } 1994 1995 assert(!"not reached"); 1996 return -1; 1997 } 1998 1999 unsigned 2000 glsl_type::std140_size(bool row_major) const 2001 { 2002 unsigned N = is_64bit() ? 8 : 4; 2003 2004 /* (1) If the member is a scalar consuming <N> basic machine units, the 2005 * base alignment is <N>. 2006 * 2007 * (2) If the member is a two- or four-component vector with components 2008 * consuming <N> basic machine units, the base alignment is 2<N> or 2009 * 4<N>, respectively. 2010 * 2011 * (3) If the member is a three-component vector with components consuming 2012 * <N> basic machine units, the base alignment is 4<N>. 2013 */ 2014 if (this->is_scalar() || this->is_vector()) { 2015 assert(this->explicit_stride == 0); 2016 return this->vector_elements * N; 2017 } 2018 2019 /* (5) If the member is a column-major matrix with <C> columns and 2020 * <R> rows, the matrix is stored identically to an array of 2021 * <C> column vectors with <R> components each, according to 2022 * rule (4). 2023 * 2024 * (6) If the member is an array of <S> column-major matrices with <C> 2025 * columns and <R> rows, the matrix is stored identically to a row of 2026 * <S>*<C> column vectors with <R> components each, according to rule 2027 * (4). 2028 * 2029 * (7) If the member is a row-major matrix with <C> columns and <R> 2030 * rows, the matrix is stored identically to an array of <R> 2031 * row vectors with <C> components each, according to rule (4). 2032 * 2033 * (8) If the member is an array of <S> row-major matrices with <C> columns 2034 * and <R> rows, the matrix is stored identically to a row of <S>*<R> 2035 * row vectors with <C> components each, according to rule (4). 2036 */ 2037 if (this->without_array()->is_matrix()) { 2038 const struct glsl_type *element_type; 2039 const struct glsl_type *vec_type; 2040 unsigned int array_len; 2041 2042 if (this->is_array()) { 2043 element_type = this->without_array(); 2044 array_len = this->arrays_of_arrays_size(); 2045 } else { 2046 element_type = this; 2047 array_len = 1; 2048 } 2049 2050 if (row_major) { 2051 vec_type = get_instance(element_type->base_type, 2052 element_type->matrix_columns, 1); 2053 2054 array_len *= element_type->vector_elements; 2055 } else { 2056 vec_type = get_instance(element_type->base_type, 2057 element_type->vector_elements, 1); 2058 array_len *= element_type->matrix_columns; 2059 } 2060 const glsl_type *array_type = glsl_type::get_array_instance(vec_type, 2061 array_len); 2062 2063 return array_type->std140_size(false); 2064 } 2065 2066 /* (4) If the member is an array of scalars or vectors, the base alignment 2067 * and array stride are set to match the base alignment of a single 2068 * array element, according to rules (1), (2), and (3), and rounded up 2069 * to the base alignment of a vec4. The array may have padding at the 2070 * end; the base offset of the member following the array is rounded up 2071 * to the next multiple of the base alignment. 2072 * 2073 * (10) If the member is an array of <S> structures, the <S> elements of 2074 * the array are laid out in order, according to rule (9). 2075 */ 2076 if (this->is_array()) { 2077 unsigned stride; 2078 if (this->without_array()->is_struct()) { 2079 stride = this->without_array()->std140_size(row_major); 2080 } else { 2081 unsigned element_base_align = 2082 this->without_array()->std140_base_alignment(row_major); 2083 stride = MAX2(element_base_align, 16); 2084 } 2085 2086 unsigned size = this->arrays_of_arrays_size() * stride; 2087 assert(this->explicit_stride == 0 || 2088 size == this->length * this->explicit_stride); 2089 return size; 2090 } 2091 2092 /* (9) If the member is a structure, the base alignment of the 2093 * structure is <N>, where <N> is the largest base alignment 2094 * value of any of its members, and rounded up to the base 2095 * alignment of a vec4. The individual members of this 2096 * sub-structure are then assigned offsets by applying this set 2097 * of rules recursively, where the base offset of the first 2098 * member of the sub-structure is equal to the aligned offset 2099 * of the structure. The structure may have padding at the end; 2100 * the base offset of the member following the sub-structure is 2101 * rounded up to the next multiple of the base alignment of the 2102 * structure. 2103 */ 2104 if (this->is_struct() || this->is_interface()) { 2105 unsigned size = 0; 2106 unsigned max_align = 0; 2107 2108 for (unsigned i = 0; i < this->length; i++) { 2109 bool field_row_major = row_major; 2110 const enum glsl_matrix_layout matrix_layout = 2111 glsl_matrix_layout(this->fields.structure[i].matrix_layout); 2112 if (matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) { 2113 field_row_major = true; 2114 } else if (matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) { 2115 field_row_major = false; 2116 } 2117 2118 const struct glsl_type *field_type = this->fields.structure[i].type; 2119 unsigned align = field_type->std140_base_alignment(field_row_major); 2120 2121 /* Ignore unsized arrays when calculating size */ 2122 if (field_type->is_unsized_array()) 2123 continue; 2124 2125 size = glsl_align(size, align); 2126 size += field_type->std140_size(field_row_major); 2127 2128 max_align = MAX2(align, max_align); 2129 2130 if (field_type->is_struct() && (i + 1 < this->length)) 2131 size = glsl_align(size, 16); 2132 } 2133 size = glsl_align(size, MAX2(max_align, 16)); 2134 return size; 2135 } 2136 2137 assert(!"not reached"); 2138 return -1; 2139 } 2140 2141 const glsl_type * 2142 glsl_type::get_explicit_std140_type(bool row_major) const 2143 { 2144 if (this->is_vector() || this->is_scalar()) { 2145 return this; 2146 } else if (this->is_matrix()) { 2147 const glsl_type *vec_type; 2148 if (row_major) 2149 vec_type = get_instance(this->base_type, this->matrix_columns, 1); 2150 else 2151 vec_type = get_instance(this->base_type, this->vector_elements, 1); 2152 unsigned elem_size = vec_type->std140_size(false); 2153 unsigned stride = glsl_align(elem_size, 16); 2154 return get_instance(this->base_type, this->vector_elements, 2155 this->matrix_columns, stride, row_major); 2156 } else if (this->is_array()) { 2157 unsigned elem_size = this->fields.array->std140_size(row_major); 2158 const glsl_type *elem_type = 2159 this->fields.array->get_explicit_std140_type(row_major); 2160 unsigned stride = glsl_align(elem_size, 16); 2161 return get_array_instance(elem_type, this->length, stride); 2162 } else if (this->is_struct() || this->is_interface()) { 2163 glsl_struct_field *fields = new glsl_struct_field[this->length]; 2164 unsigned offset = 0; 2165 for (unsigned i = 0; i < length; i++) { 2166 fields[i] = this->fields.structure[i]; 2167 2168 bool field_row_major = row_major; 2169 if (fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) { 2170 field_row_major = false; 2171 } else if (fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) { 2172 field_row_major = true; 2173 } 2174 fields[i].type = 2175 fields[i].type->get_explicit_std140_type(field_row_major); 2176 2177 unsigned fsize = fields[i].type->std140_size(field_row_major); 2178 unsigned falign = fields[i].type->std140_base_alignment(field_row_major); 2179 /* From the GLSL 460 spec section "Uniform and Shader Storage Block 2180 * Layout Qualifiers": 2181 * 2182 * "The actual offset of a member is computed as follows: If 2183 * offset was declared, start with that offset, otherwise start 2184 * with the next available offset. If the resulting offset is not 2185 * a multiple of the actual alignment, increase it to the first 2186 * offset that is a multiple of the actual alignment. This results 2187 * in the actual offset the member will have." 2188 */ 2189 if (fields[i].offset >= 0) { 2190 assert((unsigned)fields[i].offset >= offset); 2191 offset = fields[i].offset; 2192 } 2193 offset = glsl_align(offset, falign); 2194 fields[i].offset = offset; 2195 offset += fsize; 2196 } 2197 2198 const glsl_type *type; 2199 if (this->is_struct()) 2200 type = get_struct_instance(fields, this->length, this->name); 2201 else 2202 type = get_interface_instance(fields, this->length, 2203 (enum glsl_interface_packing)this->interface_packing, 2204 this->interface_row_major, 2205 this->name); 2206 2207 delete[] fields; 2208 return type; 2209 } else { 2210 unreachable("Invalid type for UBO or SSBO"); 2211 } 2212 } 2213 2214 unsigned 2215 glsl_type::std430_base_alignment(bool row_major) const 2216 { 2217 2218 unsigned N = is_64bit() ? 8 : 4; 2219 2220 /* (1) If the member is a scalar consuming <N> basic machine units, the 2221 * base alignment is <N>. 2222 * 2223 * (2) If the member is a two- or four-component vector with components 2224 * consuming <N> basic machine units, the base alignment is 2<N> or 2225 * 4<N>, respectively. 2226 * 2227 * (3) If the member is a three-component vector with components consuming 2228 * <N> basic machine units, the base alignment is 4<N>. 2229 */ 2230 if (this->is_scalar() || this->is_vector()) { 2231 switch (this->vector_elements) { 2232 case 1: 2233 return N; 2234 case 2: 2235 return 2 * N; 2236 case 3: 2237 case 4: 2238 return 4 * N; 2239 } 2240 } 2241 2242 /* OpenGL 4.30 spec, section 7.6.2.2 "Standard Uniform Block Layout": 2243 * 2244 * "When using the std430 storage layout, shader storage blocks will be 2245 * laid out in buffer storage identically to uniform and shader storage 2246 * blocks using the std140 layout, except that the base alignment and 2247 * stride of arrays of scalars and vectors in rule 4 and of structures 2248 * in rule 9 are not rounded up a multiple of the base alignment of a vec4. 2249 */ 2250 2251 /* (1) If the member is a scalar consuming <N> basic machine units, the 2252 * base alignment is <N>. 2253 * 2254 * (2) If the member is a two- or four-component vector with components 2255 * consuming <N> basic machine units, the base alignment is 2<N> or 2256 * 4<N>, respectively. 2257 * 2258 * (3) If the member is a three-component vector with components consuming 2259 * <N> basic machine units, the base alignment is 4<N>. 2260 */ 2261 if (this->is_array()) 2262 return this->fields.array->std430_base_alignment(row_major); 2263 2264 /* (5) If the member is a column-major matrix with <C> columns and 2265 * <R> rows, the matrix is stored identically to an array of 2266 * <C> column vectors with <R> components each, according to 2267 * rule (4). 2268 * 2269 * (7) If the member is a row-major matrix with <C> columns and <R> 2270 * rows, the matrix is stored identically to an array of <R> 2271 * row vectors with <C> components each, according to rule (4). 2272 */ 2273 if (this->is_matrix()) { 2274 const struct glsl_type *vec_type, *array_type; 2275 int c = this->matrix_columns; 2276 int r = this->vector_elements; 2277 2278 if (row_major) { 2279 vec_type = get_instance(base_type, c, 1); 2280 array_type = glsl_type::get_array_instance(vec_type, r); 2281 } else { 2282 vec_type = get_instance(base_type, r, 1); 2283 array_type = glsl_type::get_array_instance(vec_type, c); 2284 } 2285 2286 return array_type->std430_base_alignment(false); 2287 } 2288 2289 /* (9) If the member is a structure, the base alignment of the 2290 * structure is <N>, where <N> is the largest base alignment 2291 * value of any of its members, and rounded up to the base 2292 * alignment of a vec4. The individual members of this 2293 * sub-structure are then assigned offsets by applying this set 2294 * of rules recursively, where the base offset of the first 2295 * member of the sub-structure is equal to the aligned offset 2296 * of the structure. The structure may have padding at the end; 2297 * the base offset of the member following the sub-structure is 2298 * rounded up to the next multiple of the base alignment of the 2299 * structure. 2300 */ 2301 if (this->is_struct()) { 2302 unsigned base_alignment = 0; 2303 for (unsigned i = 0; i < this->length; i++) { 2304 bool field_row_major = row_major; 2305 const enum glsl_matrix_layout matrix_layout = 2306 glsl_matrix_layout(this->fields.structure[i].matrix_layout); 2307 if (matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) { 2308 field_row_major = true; 2309 } else if (matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) { 2310 field_row_major = false; 2311 } 2312 2313 const struct glsl_type *field_type = this->fields.structure[i].type; 2314 base_alignment = MAX2(base_alignment, 2315 field_type->std430_base_alignment(field_row_major)); 2316 } 2317 assert(base_alignment > 0); 2318 return base_alignment; 2319 } 2320 assert(!"not reached"); 2321 return -1; 2322 } 2323 2324 unsigned 2325 glsl_type::std430_array_stride(bool row_major) const 2326 { 2327 unsigned N = is_64bit() ? 8 : 4; 2328 2329 /* Notice that the array stride of a vec3 is not 3 * N but 4 * N. 2330 * See OpenGL 4.30 spec, section 7.6.2.2 "Standard Uniform Block Layout" 2331 * 2332 * (3) If the member is a three-component vector with components consuming 2333 * <N> basic machine units, the base alignment is 4<N>. 2334 */ 2335 if (this->is_vector() && this->vector_elements == 3) 2336 return 4 * N; 2337 2338 /* By default use std430_size(row_major) */ 2339 unsigned stride = this->std430_size(row_major); 2340 assert(this->explicit_stride == 0 || this->explicit_stride == stride); 2341 return stride; 2342 } 2343 2344 /* Note that the value returned by this method is only correct if the 2345 * explit offset, and stride values are set, so only with SPIR-V shaders. 2346 * Should not be used with GLSL shaders. 2347 */ 2348 2349 unsigned 2350 glsl_type::explicit_size(bool align_to_stride) const 2351 { 2352 if (this->is_struct() || this->is_interface()) { 2353 if (this->length > 0) { 2354 unsigned size = 0; 2355 2356 for (unsigned i = 0; i < this->length; i++) { 2357 assert(this->fields.structure[i].offset >= 0); 2358 unsigned last_byte = this->fields.structure[i].offset + 2359 this->fields.structure[i].type->explicit_size(); 2360 size = MAX2(size, last_byte); 2361 } 2362 2363 return size; 2364 } else { 2365 return 0; 2366 } 2367 } else if (this->is_array()) { 2368 /* From ARB_program_interface_query spec: 2369 * 2370 * "For the property of BUFFER_DATA_SIZE, then the implementation-dependent 2371 * minimum total buffer object size, in basic machine units, required to 2372 * hold all active variables associated with an active uniform block, shader 2373 * storage block, or atomic counter buffer is written to <params>. If the 2374 * final member of an active shader storage block is array with no declared 2375 * size, the minimum buffer size is computed assuming the array was declared 2376 * as an array with one element." 2377 * 2378 */ 2379 if (this->is_unsized_array()) 2380 return this->explicit_stride; 2381 2382 assert(this->length > 0); 2383 unsigned elem_size = align_to_stride ? this->explicit_stride : this->fields.array->explicit_size(); 2384 assert(this->explicit_stride >= elem_size); 2385 2386 return this->explicit_stride * (this->length - 1) + elem_size; 2387 } else if (this->is_matrix()) { 2388 const struct glsl_type *elem_type; 2389 unsigned length; 2390 2391 if (this->interface_row_major) { 2392 elem_type = get_instance(this->base_type, 2393 this->matrix_columns, 1); 2394 length = this->vector_elements; 2395 } else { 2396 elem_type = get_instance(this->base_type, 2397 this->vector_elements, 1); 2398 length = this->matrix_columns; 2399 } 2400 2401 unsigned elem_size = align_to_stride ? this->explicit_stride : elem_type->explicit_size(); 2402 2403 assert(this->explicit_stride); 2404 return this->explicit_stride * (length - 1) + elem_size; 2405 } 2406 2407 unsigned N = this->bit_size() / 8; 2408 2409 return this->vector_elements * N; 2410 } 2411 2412 unsigned 2413 glsl_type::std430_size(bool row_major) const 2414 { 2415 unsigned N = is_64bit() ? 8 : 4; 2416 2417 /* OpenGL 4.30 spec, section 7.6.2.2 "Standard Uniform Block Layout": 2418 * 2419 * "When using the std430 storage layout, shader storage blocks will be 2420 * laid out in buffer storage identically to uniform and shader storage 2421 * blocks using the std140 layout, except that the base alignment and 2422 * stride of arrays of scalars and vectors in rule 4 and of structures 2423 * in rule 9 are not rounded up a multiple of the base alignment of a vec4. 2424 */ 2425 if (this->is_scalar() || this->is_vector()) { 2426 assert(this->explicit_stride == 0); 2427 return this->vector_elements * N; 2428 } 2429 2430 if (this->without_array()->is_matrix()) { 2431 const struct glsl_type *element_type; 2432 const struct glsl_type *vec_type; 2433 unsigned int array_len; 2434 2435 if (this->is_array()) { 2436 element_type = this->without_array(); 2437 array_len = this->arrays_of_arrays_size(); 2438 } else { 2439 element_type = this; 2440 array_len = 1; 2441 } 2442 2443 if (row_major) { 2444 vec_type = get_instance(element_type->base_type, 2445 element_type->matrix_columns, 1); 2446 2447 array_len *= element_type->vector_elements; 2448 } else { 2449 vec_type = get_instance(element_type->base_type, 2450 element_type->vector_elements, 1); 2451 array_len *= element_type->matrix_columns; 2452 } 2453 const glsl_type *array_type = glsl_type::get_array_instance(vec_type, 2454 array_len); 2455 2456 return array_type->std430_size(false); 2457 } 2458 2459 if (this->is_array()) { 2460 unsigned stride; 2461 if (this->without_array()->is_struct()) 2462 stride = this->without_array()->std430_size(row_major); 2463 else 2464 stride = this->without_array()->std430_base_alignment(row_major); 2465 2466 unsigned size = this->arrays_of_arrays_size() * stride; 2467 assert(this->explicit_stride == 0 || 2468 size == this->length * this->explicit_stride); 2469 return size; 2470 } 2471 2472 if (this->is_struct() || this->is_interface()) { 2473 unsigned size = 0; 2474 unsigned max_align = 0; 2475 2476 for (unsigned i = 0; i < this->length; i++) { 2477 bool field_row_major = row_major; 2478 const enum glsl_matrix_layout matrix_layout = 2479 glsl_matrix_layout(this->fields.structure[i].matrix_layout); 2480 if (matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) { 2481 field_row_major = true; 2482 } else if (matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) { 2483 field_row_major = false; 2484 } 2485 2486 const struct glsl_type *field_type = this->fields.structure[i].type; 2487 unsigned align = field_type->std430_base_alignment(field_row_major); 2488 size = glsl_align(size, align); 2489 size += field_type->std430_size(field_row_major); 2490 2491 max_align = MAX2(align, max_align); 2492 } 2493 size = glsl_align(size, max_align); 2494 return size; 2495 } 2496 2497 assert(!"not reached"); 2498 return -1; 2499 } 2500 2501 const glsl_type * 2502 glsl_type::get_explicit_std430_type(bool row_major) const 2503 { 2504 if (this->is_vector() || this->is_scalar()) { 2505 return this; 2506 } else if (this->is_matrix()) { 2507 const glsl_type *vec_type; 2508 if (row_major) 2509 vec_type = get_instance(this->base_type, this->matrix_columns, 1); 2510 else 2511 vec_type = get_instance(this->base_type, this->vector_elements, 1); 2512 unsigned stride = vec_type->std430_array_stride(false); 2513 return get_instance(this->base_type, this->vector_elements, 2514 this->matrix_columns, stride, row_major); 2515 } else if (this->is_array()) { 2516 const glsl_type *elem_type = 2517 this->fields.array->get_explicit_std430_type(row_major); 2518 unsigned stride = this->fields.array->std430_array_stride(row_major); 2519 return get_array_instance(elem_type, this->length, stride); 2520 } else if (this->is_struct() || this->is_interface()) { 2521 glsl_struct_field *fields = new glsl_struct_field[this->length]; 2522 unsigned offset = 0; 2523 for (unsigned i = 0; i < length; i++) { 2524 fields[i] = this->fields.structure[i]; 2525 2526 bool field_row_major = row_major; 2527 if (fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) { 2528 field_row_major = false; 2529 } else if (fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) { 2530 field_row_major = true; 2531 } 2532 fields[i].type = 2533 fields[i].type->get_explicit_std430_type(field_row_major); 2534 2535 unsigned fsize = fields[i].type->std430_size(field_row_major); 2536 unsigned falign = fields[i].type->std430_base_alignment(field_row_major); 2537 /* From the GLSL 460 spec section "Uniform and Shader Storage Block 2538 * Layout Qualifiers": 2539 * 2540 * "The actual offset of a member is computed as follows: If 2541 * offset was declared, start with that offset, otherwise start 2542 * with the next available offset. If the resulting offset is not 2543 * a multiple of the actual alignment, increase it to the first 2544 * offset that is a multiple of the actual alignment. This results 2545 * in the actual offset the member will have." 2546 */ 2547 if (fields[i].offset >= 0) { 2548 assert((unsigned)fields[i].offset >= offset); 2549 offset = fields[i].offset; 2550 } 2551 offset = glsl_align(offset, falign); 2552 fields[i].offset = offset; 2553 offset += fsize; 2554 } 2555 2556 const glsl_type *type; 2557 if (this->is_struct()) 2558 type = get_struct_instance(fields, this->length, this->name); 2559 else 2560 type = get_interface_instance(fields, this->length, 2561 (enum glsl_interface_packing)this->interface_packing, 2562 this->interface_row_major, 2563 this->name); 2564 2565 delete[] fields; 2566 return type; 2567 } else { 2568 unreachable("Invalid type for SSBO"); 2569 } 2570 } 2571 2572 const glsl_type * 2573 glsl_type::get_explicit_interface_type(bool supports_std430) const 2574 { 2575 enum glsl_interface_packing packing = 2576 this->get_internal_ifc_packing(supports_std430); 2577 if (packing == GLSL_INTERFACE_PACKING_STD140) { 2578 return this->get_explicit_std140_type(this->interface_row_major); 2579 } else { 2580 assert(packing == GLSL_INTERFACE_PACKING_STD430); 2581 return this->get_explicit_std430_type(this->interface_row_major); 2582 } 2583 } 2584 2585 static unsigned 2586 explicit_type_scalar_byte_size(const glsl_type *type) 2587 { 2588 if (type->base_type == GLSL_TYPE_BOOL) 2589 return 4; 2590 else 2591 return glsl_base_type_get_bit_size(type->base_type) / 8; 2592 } 2593 2594 /* This differs from get_explicit_std430_type() in that it: 2595 * - can size arrays slightly smaller ("stride * (len - 1) + elem_size" instead 2596 * of "stride * len") 2597 * - consumes a glsl_type_size_align_func which allows 8 and 16-bit values to be 2598 * packed more tightly 2599 * - overrides any struct field offsets but get_explicit_std430_type() tries to 2600 * respect any existing ones 2601 */ 2602 const glsl_type * 2603 glsl_type::get_explicit_type_for_size_align(glsl_type_size_align_func type_info, 2604 unsigned *size, unsigned *alignment) const 2605 { 2606 if (this->is_image() || this->is_sampler()) { 2607 type_info(this, size, alignment); 2608 assert(*alignment > 0); 2609 return this; 2610 } else if (this->is_scalar()) { 2611 type_info(this, size, alignment); 2612 assert(*size == explicit_type_scalar_byte_size(this)); 2613 assert(*alignment == explicit_type_scalar_byte_size(this)); 2614 return this; 2615 } else if (this->is_vector()) { 2616 type_info(this, size, alignment); 2617 assert(*alignment > 0); 2618 assert(*alignment % explicit_type_scalar_byte_size(this) == 0); 2619 return glsl_type::get_instance(this->base_type, this->vector_elements, 2620 1, 0, false, *alignment); 2621 } else if (this->is_array()) { 2622 unsigned elem_size, elem_align; 2623 const struct glsl_type *explicit_element = 2624 this->fields.array->get_explicit_type_for_size_align(type_info, &elem_size, &elem_align); 2625 2626 unsigned stride = align(elem_size, elem_align); 2627 2628 *size = stride * (this->length - 1) + elem_size; 2629 *alignment = elem_align; 2630 return glsl_type::get_array_instance(explicit_element, this->length, stride); 2631 } else if (this->is_struct() || this->is_interface()) { 2632 struct glsl_struct_field *fields = (struct glsl_struct_field *) 2633 malloc(sizeof(struct glsl_struct_field) * this->length); 2634 2635 *size = 0; 2636 *alignment = 0; 2637 for (unsigned i = 0; i < this->length; i++) { 2638 fields[i] = this->fields.structure[i]; 2639 assert(fields[i].matrix_layout != GLSL_MATRIX_LAYOUT_ROW_MAJOR); 2640 2641 unsigned field_size, field_align; 2642 fields[i].type = 2643 fields[i].type->get_explicit_type_for_size_align(type_info, &field_size, &field_align); 2644 field_align = this->packed ? 1 : field_align; 2645 fields[i].offset = align(*size, field_align); 2646 2647 *size = fields[i].offset + field_size; 2648 *alignment = MAX2(*alignment, field_align); 2649 } 2650 2651 const glsl_type *type; 2652 if (this->is_struct()) { 2653 type = get_struct_instance(fields, this->length, this->name, 2654 this->packed, *alignment); 2655 } else { 2656 assert(!this->packed); 2657 type = get_interface_instance(fields, this->length, 2658 (enum glsl_interface_packing)this->interface_packing, 2659 this->interface_row_major, 2660 this->name); 2661 } 2662 free(fields); 2663 return type; 2664 } else if (this->is_matrix()) { 2665 unsigned col_size, col_align; 2666 type_info(this->column_type(), &col_size, &col_align); 2667 unsigned stride = align(col_size, col_align); 2668 2669 *size = this->matrix_columns * stride; 2670 /* Matrix and column alignments match. See glsl_type::column_type() */ 2671 assert(col_align > 0); 2672 *alignment = col_align; 2673 return glsl_type::get_instance(this->base_type, this->vector_elements, 2674 this->matrix_columns, stride, false, *alignment); 2675 } else { 2676 unreachable("Unhandled type."); 2677 } 2678 } 2679 2680 const glsl_type * 2681 glsl_type::replace_vec3_with_vec4() const 2682 { 2683 if (this->is_scalar() || this->is_vector() || this->is_matrix()) { 2684 if (this->interface_row_major) { 2685 if (this->matrix_columns == 3) { 2686 return glsl_type::get_instance(this->base_type, 2687 this->vector_elements, 2688 4, /* matrix columns */ 2689 this->explicit_stride, 2690 this->interface_row_major, 2691 this->explicit_alignment); 2692 } else { 2693 return this; 2694 } 2695 } else { 2696 if (this->vector_elements == 3) { 2697 return glsl_type::get_instance(this->base_type, 2698 4, /* vector elements */ 2699 this->matrix_columns, 2700 this->explicit_stride, 2701 this->interface_row_major, 2702 this->explicit_alignment); 2703 } else { 2704 return this; 2705 } 2706 } 2707 } else if (this->is_array()) { 2708 const glsl_type *vec4_elem_type = 2709 this->fields.array->replace_vec3_with_vec4(); 2710 if (vec4_elem_type == this->fields.array) 2711 return this; 2712 return glsl_type::get_array_instance(vec4_elem_type, 2713 this->length, 2714 this->explicit_stride); 2715 } else if (this->is_struct() || this->is_interface()) { 2716 struct glsl_struct_field *fields = (struct glsl_struct_field *) 2717 malloc(sizeof(struct glsl_struct_field) * this->length); 2718 2719 bool needs_new_type = false; 2720 for (unsigned i = 0; i < this->length; i++) { 2721 fields[i] = this->fields.structure[i]; 2722 assert(fields[i].matrix_layout != GLSL_MATRIX_LAYOUT_ROW_MAJOR); 2723 fields[i].type = fields[i].type->replace_vec3_with_vec4(); 2724 if (fields[i].type != this->fields.structure[i].type) 2725 needs_new_type = true; 2726 } 2727 2728 const glsl_type *type; 2729 if (!needs_new_type) { 2730 type = this; 2731 } else if (this->is_struct()) { 2732 type = get_struct_instance(fields, this->length, this->name, 2733 this->packed, this->explicit_alignment); 2734 } else { 2735 assert(!this->packed); 2736 type = get_interface_instance(fields, this->length, 2737 (enum glsl_interface_packing)this->interface_packing, 2738 this->interface_row_major, 2739 this->name); 2740 } 2741 free(fields); 2742 return type; 2743 } else { 2744 unreachable("Unhandled type."); 2745 } 2746 } 2747 2748 unsigned 2749 glsl_type::count_vec4_slots(bool is_gl_vertex_input, bool is_bindless) const 2750 { 2751 /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec: 2752 * 2753 * "A scalar input counts the same amount against this limit as a vec4, 2754 * so applications may want to consider packing groups of four 2755 * unrelated float inputs together into a vector to better utilize the 2756 * capabilities of the underlying hardware. A matrix input will use up 2757 * multiple locations. The number of locations used will equal the 2758 * number of columns in the matrix." 2759 * 2760 * The spec does not explicitly say how arrays are counted. However, it 2761 * should be safe to assume the total number of slots consumed by an array 2762 * is the number of entries in the array multiplied by the number of slots 2763 * consumed by a single element of the array. 2764 * 2765 * The spec says nothing about how structs are counted, because vertex 2766 * attributes are not allowed to be (or contain) structs. However, Mesa 2767 * allows varying structs, the number of varying slots taken up by a 2768 * varying struct is simply equal to the sum of the number of slots taken 2769 * up by each element. 2770 * 2771 * Doubles are counted different depending on whether they are vertex 2772 * inputs or everything else. Vertex inputs from ARB_vertex_attrib_64bit 2773 * take one location no matter what size they are, otherwise dvec3/4 2774 * take two locations. 2775 */ 2776 switch (this->base_type) { 2777 case GLSL_TYPE_UINT: 2778 case GLSL_TYPE_INT: 2779 case GLSL_TYPE_UINT8: 2780 case GLSL_TYPE_INT8: 2781 case GLSL_TYPE_UINT16: 2782 case GLSL_TYPE_INT16: 2783 case GLSL_TYPE_FLOAT: 2784 case GLSL_TYPE_FLOAT16: 2785 case GLSL_TYPE_BOOL: 2786 return this->matrix_columns; 2787 case GLSL_TYPE_DOUBLE: 2788 case GLSL_TYPE_UINT64: 2789 case GLSL_TYPE_INT64: 2790 if (this->vector_elements > 2 && !is_gl_vertex_input) 2791 return this->matrix_columns * 2; 2792 else 2793 return this->matrix_columns; 2794 case GLSL_TYPE_STRUCT: 2795 case GLSL_TYPE_INTERFACE: { 2796 unsigned size = 0; 2797 2798 for (unsigned i = 0; i < this->length; i++) { 2799 const glsl_type *member_type = this->fields.structure[i].type; 2800 size += member_type->count_vec4_slots(is_gl_vertex_input, is_bindless); 2801 } 2802 2803 return size; 2804 } 2805 2806 case GLSL_TYPE_ARRAY: { 2807 const glsl_type *element = this->fields.array; 2808 return this->length * element->count_vec4_slots(is_gl_vertex_input, 2809 is_bindless); 2810 } 2811 2812 case GLSL_TYPE_SAMPLER: 2813 case GLSL_TYPE_IMAGE: 2814 if (!is_bindless) 2815 return 0; 2816 else 2817 return 1; 2818 2819 case GLSL_TYPE_SUBROUTINE: 2820 return 1; 2821 2822 case GLSL_TYPE_FUNCTION: 2823 case GLSL_TYPE_ATOMIC_UINT: 2824 case GLSL_TYPE_VOID: 2825 case GLSL_TYPE_ERROR: 2826 break; 2827 } 2828 2829 assert(!"Unexpected type in count_attribute_slots()"); 2830 2831 return 0; 2832 } 2833 2834 unsigned 2835 glsl_type::count_dword_slots(bool is_bindless) const 2836 { 2837 switch (this->base_type) { 2838 case GLSL_TYPE_UINT: 2839 case GLSL_TYPE_INT: 2840 case GLSL_TYPE_FLOAT: 2841 case GLSL_TYPE_BOOL: 2842 return this->components(); 2843 case GLSL_TYPE_UINT16: 2844 case GLSL_TYPE_INT16: 2845 case GLSL_TYPE_FLOAT16: 2846 return DIV_ROUND_UP(this->components(), 2); 2847 case GLSL_TYPE_UINT8: 2848 case GLSL_TYPE_INT8: 2849 return DIV_ROUND_UP(this->components(), 4); 2850 case GLSL_TYPE_IMAGE: 2851 case GLSL_TYPE_SAMPLER: 2852 if (!is_bindless) 2853 return 0; 2854 FALLTHROUGH; 2855 case GLSL_TYPE_DOUBLE: 2856 case GLSL_TYPE_UINT64: 2857 case GLSL_TYPE_INT64: 2858 return this->components() * 2; 2859 case GLSL_TYPE_ARRAY: 2860 return this->fields.array->count_dword_slots(is_bindless) * 2861 this->length; 2862 2863 case GLSL_TYPE_INTERFACE: 2864 case GLSL_TYPE_STRUCT: { 2865 unsigned size = 0; 2866 for (unsigned i = 0; i < this->length; i++) { 2867 size += this->fields.structure[i].type->count_dword_slots(is_bindless); 2868 } 2869 return size; 2870 } 2871 2872 case GLSL_TYPE_ATOMIC_UINT: 2873 return 0; 2874 case GLSL_TYPE_SUBROUTINE: 2875 return 1; 2876 case GLSL_TYPE_VOID: 2877 case GLSL_TYPE_ERROR: 2878 case GLSL_TYPE_FUNCTION: 2879 default: 2880 unreachable("invalid type in st_glsl_type_dword_size()"); 2881 } 2882 2883 return 0; 2884 } 2885 2886 int 2887 glsl_type::coordinate_components() const 2888 { 2889 enum glsl_sampler_dim dim = (enum glsl_sampler_dim)sampler_dimensionality; 2890 int size = glsl_get_sampler_dim_coordinate_components(dim); 2891 2892 /* Array textures need an additional component for the array index, except 2893 * for cubemap array images that behave like a 2D array of interleaved 2894 * cubemap faces. 2895 */ 2896 if (sampler_array && 2897 !(is_image() && sampler_dimensionality == GLSL_SAMPLER_DIM_CUBE)) 2898 size += 1; 2899 2900 return size; 2901 } 2902 2903 /** 2904 * Declarations of type flyweights (glsl_type::_foo_type) and 2905 * convenience pointers (glsl_type::foo_type). 2906 * @{ 2907 */ 2908 #define DECL_TYPE(NAME, ...) \ 2909 const glsl_type glsl_type::_##NAME##_type = glsl_type(__VA_ARGS__, #NAME); \ 2910 const glsl_type *const glsl_type::NAME##_type = &glsl_type::_##NAME##_type; 2911 2912 #define STRUCT_TYPE(NAME) 2913 2914 #include "compiler/builtin_type_macros.h" 2915 /** @} */ 2916 2917 union packed_type { 2918 uint32_t u32; 2919 struct { 2920 unsigned base_type:5; 2921 unsigned interface_row_major:1; 2922 unsigned vector_elements:3; 2923 unsigned matrix_columns:3; 2924 unsigned explicit_stride:16; 2925 unsigned explicit_alignment:4; 2926 } basic; 2927 struct { 2928 unsigned base_type:5; 2929 unsigned dimensionality:4; 2930 unsigned shadow:1; 2931 unsigned array:1; 2932 unsigned sampled_type:5; 2933 unsigned _pad:16; 2934 } sampler; 2935 struct { 2936 unsigned base_type:5; 2937 unsigned length:13; 2938 unsigned explicit_stride:14; 2939 } array; 2940 struct { 2941 unsigned base_type:5; 2942 unsigned interface_packing_or_packed:2; 2943 unsigned interface_row_major:1; 2944 unsigned length:20; 2945 unsigned explicit_alignment:4; 2946 } strct; 2947 }; 2948 2949 static void 2950 encode_glsl_struct_field(blob *blob, const glsl_struct_field *struct_field) 2951 { 2952 encode_type_to_blob(blob, struct_field->type); 2953 blob_write_string(blob, struct_field->name); 2954 blob_write_uint32(blob, struct_field->location); 2955 blob_write_uint32(blob, struct_field->component); 2956 blob_write_uint32(blob, struct_field->offset); 2957 blob_write_uint32(blob, struct_field->xfb_buffer); 2958 blob_write_uint32(blob, struct_field->xfb_stride); 2959 blob_write_uint32(blob, struct_field->image_format); 2960 blob_write_uint32(blob, struct_field->flags); 2961 } 2962 2963 static void 2964 decode_glsl_struct_field_from_blob(blob_reader *blob, glsl_struct_field *struct_field) 2965 { 2966 struct_field->type = decode_type_from_blob(blob); 2967 struct_field->name = blob_read_string(blob); 2968 struct_field->location = blob_read_uint32(blob); 2969 struct_field->component = blob_read_uint32(blob); 2970 struct_field->offset = blob_read_uint32(blob); 2971 struct_field->xfb_buffer = blob_read_uint32(blob); 2972 struct_field->xfb_stride = blob_read_uint32(blob); 2973 struct_field->image_format = (pipe_format)blob_read_uint32(blob); 2974 struct_field->flags = blob_read_uint32(blob); 2975 } 2976 2977 void 2978 encode_type_to_blob(struct blob *blob, const glsl_type *type) 2979 { 2980 if (!type) { 2981 blob_write_uint32(blob, 0); 2982 return; 2983 } 2984 2985 STATIC_ASSERT(sizeof(union packed_type) == 4); 2986 union packed_type encoded; 2987 encoded.u32 = 0; 2988 encoded.basic.base_type = type->base_type; 2989 2990 switch (type->base_type) { 2991 case GLSL_TYPE_UINT: 2992 case GLSL_TYPE_INT: 2993 case GLSL_TYPE_FLOAT: 2994 case GLSL_TYPE_FLOAT16: 2995 case GLSL_TYPE_DOUBLE: 2996 case GLSL_TYPE_UINT8: 2997 case GLSL_TYPE_INT8: 2998 case GLSL_TYPE_UINT16: 2999 case GLSL_TYPE_INT16: 3000 case GLSL_TYPE_UINT64: 3001 case GLSL_TYPE_INT64: 3002 case GLSL_TYPE_BOOL: 3003 encoded.basic.interface_row_major = type->interface_row_major; 3004 assert(type->matrix_columns < 8); 3005 if (type->vector_elements <= 4) 3006 encoded.basic.vector_elements = type->vector_elements; 3007 else if (type->vector_elements == 8) 3008 encoded.basic.vector_elements = 5; 3009 else if (type->vector_elements == 16) 3010 encoded.basic.vector_elements = 6; 3011 encoded.basic.matrix_columns = type->matrix_columns; 3012 encoded.basic.explicit_stride = MIN2(type->explicit_stride, 0xffff); 3013 encoded.basic.explicit_alignment = 3014 MIN2(ffs(type->explicit_alignment), 0xf); 3015 blob_write_uint32(blob, encoded.u32); 3016 /* If we don't have enough bits for explicit_stride, store it 3017 * separately. 3018 */ 3019 if (encoded.basic.explicit_stride == 0xffff) 3020 blob_write_uint32(blob, type->explicit_stride); 3021 if (encoded.basic.explicit_alignment == 0xf) 3022 blob_write_uint32(blob, type->explicit_alignment); 3023 return; 3024 case GLSL_TYPE_SAMPLER: 3025 encoded.sampler.dimensionality = type->sampler_dimensionality; 3026 encoded.sampler.shadow = type->sampler_shadow; 3027 encoded.sampler.array = type->sampler_array; 3028 encoded.sampler.sampled_type = type->sampled_type; 3029 break; 3030 case GLSL_TYPE_SUBROUTINE: 3031 blob_write_uint32(blob, encoded.u32); 3032 blob_write_string(blob, type->name); 3033 return; 3034 case GLSL_TYPE_IMAGE: 3035 encoded.sampler.dimensionality = type->sampler_dimensionality; 3036 encoded.sampler.array = type->sampler_array; 3037 encoded.sampler.sampled_type = type->sampled_type; 3038 break; 3039 case GLSL_TYPE_ATOMIC_UINT: 3040 break; 3041 case GLSL_TYPE_ARRAY: 3042 encoded.array.length = MIN2(type->length, 0x1fff); 3043 encoded.array.explicit_stride = MIN2(type->explicit_stride, 0x3fff); 3044 blob_write_uint32(blob, encoded.u32); 3045 /* If we don't have enough bits for length or explicit_stride, store it 3046 * separately. 3047 */ 3048 if (encoded.array.length == 0x1fff) 3049 blob_write_uint32(blob, type->length); 3050 if (encoded.array.explicit_stride == 0x3fff) 3051 blob_write_uint32(blob, type->explicit_stride); 3052 encode_type_to_blob(blob, type->fields.array); 3053 return; 3054 case GLSL_TYPE_STRUCT: 3055 case GLSL_TYPE_INTERFACE: 3056 encoded.strct.length = MIN2(type->length, 0xfffff); 3057 encoded.strct.explicit_alignment = 3058 MIN2(ffs(type->explicit_alignment), 0xf); 3059 if (type->is_interface()) { 3060 encoded.strct.interface_packing_or_packed = type->interface_packing; 3061 encoded.strct.interface_row_major = type->interface_row_major; 3062 } else { 3063 encoded.strct.interface_packing_or_packed = type->packed; 3064 } 3065 blob_write_uint32(blob, encoded.u32); 3066 blob_write_string(blob, type->name); 3067 3068 /* If we don't have enough bits for length, store it separately. */ 3069 if (encoded.strct.length == 0xfffff) 3070 blob_write_uint32(blob, type->length); 3071 if (encoded.strct.explicit_alignment == 0xf) 3072 blob_write_uint32(blob, type->explicit_alignment); 3073 3074 for (unsigned i = 0; i < type->length; i++) 3075 encode_glsl_struct_field(blob, &type->fields.structure[i]); 3076 return; 3077 case GLSL_TYPE_VOID: 3078 break; 3079 case GLSL_TYPE_ERROR: 3080 default: 3081 assert(!"Cannot encode type!"); 3082 encoded.u32 = 0; 3083 break; 3084 } 3085 3086 blob_write_uint32(blob, encoded.u32); 3087 } 3088 3089 const glsl_type * 3090 decode_type_from_blob(struct blob_reader *blob) 3091 { 3092 union packed_type encoded; 3093 encoded.u32 = blob_read_uint32(blob); 3094 3095 if (encoded.u32 == 0) { 3096 return NULL; 3097 } 3098 3099 glsl_base_type base_type = (glsl_base_type)encoded.basic.base_type; 3100 3101 switch (base_type) { 3102 case GLSL_TYPE_UINT: 3103 case GLSL_TYPE_INT: 3104 case GLSL_TYPE_FLOAT: 3105 case GLSL_TYPE_FLOAT16: 3106 case GLSL_TYPE_DOUBLE: 3107 case GLSL_TYPE_UINT8: 3108 case GLSL_TYPE_INT8: 3109 case GLSL_TYPE_UINT16: 3110 case GLSL_TYPE_INT16: 3111 case GLSL_TYPE_UINT64: 3112 case GLSL_TYPE_INT64: 3113 case GLSL_TYPE_BOOL: { 3114 unsigned explicit_stride = encoded.basic.explicit_stride; 3115 if (explicit_stride == 0xffff) 3116 explicit_stride = blob_read_uint32(blob); 3117 unsigned explicit_alignment = encoded.basic.explicit_alignment; 3118 if (explicit_alignment == 0xf) 3119 explicit_alignment = blob_read_uint32(blob); 3120 else if (explicit_alignment > 0) 3121 explicit_alignment = 1 << (explicit_alignment - 1); 3122 uint32_t vector_elements = encoded.basic.vector_elements; 3123 if (vector_elements == 5) 3124 vector_elements = 8; 3125 else if (vector_elements == 6) 3126 vector_elements = 16; 3127 return glsl_type::get_instance(base_type, encoded.basic.vector_elements, 3128 encoded.basic.matrix_columns, 3129 explicit_stride, 3130 encoded.basic.interface_row_major, 3131 explicit_alignment); 3132 } 3133 case GLSL_TYPE_SAMPLER: 3134 return glsl_type::get_sampler_instance((enum glsl_sampler_dim)encoded.sampler.dimensionality, 3135 encoded.sampler.shadow, 3136 encoded.sampler.array, 3137 (glsl_base_type) encoded.sampler.sampled_type); 3138 case GLSL_TYPE_SUBROUTINE: 3139 return glsl_type::get_subroutine_instance(blob_read_string(blob)); 3140 case GLSL_TYPE_IMAGE: 3141 return glsl_type::get_image_instance((enum glsl_sampler_dim)encoded.sampler.dimensionality, 3142 encoded.sampler.array, 3143 (glsl_base_type) encoded.sampler.sampled_type); 3144 case GLSL_TYPE_ATOMIC_UINT: 3145 return glsl_type::atomic_uint_type; 3146 case GLSL_TYPE_ARRAY: { 3147 unsigned length = encoded.array.length; 3148 if (length == 0x1fff) 3149 length = blob_read_uint32(blob); 3150 unsigned explicit_stride = encoded.array.explicit_stride; 3151 if (explicit_stride == 0x3fff) 3152 explicit_stride = blob_read_uint32(blob); 3153 return glsl_type::get_array_instance(decode_type_from_blob(blob), 3154 length, explicit_stride); 3155 } 3156 case GLSL_TYPE_STRUCT: 3157 case GLSL_TYPE_INTERFACE: { 3158 char *name = blob_read_string(blob); 3159 unsigned num_fields = encoded.strct.length; 3160 if (num_fields == 0xfffff) 3161 num_fields = blob_read_uint32(blob); 3162 unsigned explicit_alignment = encoded.strct.explicit_alignment; 3163 if (explicit_alignment == 0xf) 3164 explicit_alignment = blob_read_uint32(blob); 3165 else if (explicit_alignment > 0) 3166 explicit_alignment = 1 << (explicit_alignment - 1); 3167 3168 glsl_struct_field *fields = 3169 (glsl_struct_field *) malloc(sizeof(glsl_struct_field) * num_fields); 3170 for (unsigned i = 0; i < num_fields; i++) 3171 decode_glsl_struct_field_from_blob(blob, &fields[i]); 3172 3173 const glsl_type *t; 3174 if (base_type == GLSL_TYPE_INTERFACE) { 3175 assert(explicit_alignment == 0); 3176 enum glsl_interface_packing packing = 3177 (glsl_interface_packing) encoded.strct.interface_packing_or_packed; 3178 bool row_major = encoded.strct.interface_row_major; 3179 t = glsl_type::get_interface_instance(fields, num_fields, packing, 3180 row_major, name); 3181 } else { 3182 unsigned packed = encoded.strct.interface_packing_or_packed; 3183 t = glsl_type::get_struct_instance(fields, num_fields, name, packed, 3184 explicit_alignment); 3185 } 3186 3187 free(fields); 3188 return t; 3189 } 3190 case GLSL_TYPE_VOID: 3191 return glsl_type::void_type; 3192 case GLSL_TYPE_ERROR: 3193 default: 3194 assert(!"Cannot decode type!"); 3195 return NULL; 3196 } 3197 } 3198 3199 unsigned 3200 glsl_type::cl_alignment() const 3201 { 3202 /* vectors unlike arrays are aligned to their size */ 3203 if (this->is_scalar() || this->is_vector()) 3204 return this->cl_size(); 3205 else if (this->is_array()) 3206 return this->without_array()->cl_alignment(); 3207 else if (this->is_struct()) { 3208 /* Packed Structs are 0x1 aligned despite their size. */ 3209 if (this->packed) 3210 return 1; 3211 3212 unsigned res = 1; 3213 for (unsigned i = 0; i < this->length; ++i) { 3214 struct glsl_struct_field &field = this->fields.structure[i]; 3215 res = MAX2(res, field.type->cl_alignment()); 3216 } 3217 return res; 3218 } 3219 return 1; 3220 } 3221 3222 unsigned 3223 glsl_type::cl_size() const 3224 { 3225 if (this->is_scalar() || this->is_vector()) { 3226 return util_next_power_of_two(this->vector_elements) * 3227 explicit_type_scalar_byte_size(this); 3228 } else if (this->is_array()) { 3229 unsigned size = this->without_array()->cl_size(); 3230 return size * this->length; 3231 } else if (this->is_struct()) { 3232 unsigned size = 0; 3233 for (unsigned i = 0; i < this->length; ++i) { 3234 struct glsl_struct_field &field = this->fields.structure[i]; 3235 /* if a struct is packed, members don't get aligned */ 3236 if (!this->packed) 3237 size = align(size, field.type->cl_alignment()); 3238 size += field.type->cl_size(); 3239 } 3240 return size; 3241 } 3242 return 1; 3243 } 3244 3245 extern "C" { 3246 3247 int 3248 glsl_get_sampler_dim_coordinate_components(enum glsl_sampler_dim dim) 3249 { 3250 switch (dim) { 3251 case GLSL_SAMPLER_DIM_1D: 3252 case GLSL_SAMPLER_DIM_BUF: 3253 return 1; 3254 case GLSL_SAMPLER_DIM_2D: 3255 case GLSL_SAMPLER_DIM_RECT: 3256 case GLSL_SAMPLER_DIM_MS: 3257 case GLSL_SAMPLER_DIM_EXTERNAL: 3258 case GLSL_SAMPLER_DIM_SUBPASS: 3259 case GLSL_SAMPLER_DIM_SUBPASS_MS: 3260 return 2; 3261 case GLSL_SAMPLER_DIM_3D: 3262 case GLSL_SAMPLER_DIM_CUBE: 3263 return 3; 3264 default: 3265 unreachable("Unknown sampler dim"); 3266 } 3267 } 3268 3269 void 3270 glsl_print_type(FILE *f, const glsl_type *t) 3271 { 3272 if (t->is_array()) { 3273 fprintf(f, "(array "); 3274 glsl_print_type(f, t->fields.array); 3275 fprintf(f, " %u)", t->length); 3276 } else if (t->is_struct() && !is_gl_identifier(t->name)) { 3277 fprintf(f, "%s@%p", t->name, (void *) t); 3278 } else { 3279 fprintf(f, "%s", t->name); 3280 } 3281 } 3282 3283 } 3284
Indexes created Mon Jul 27 00:28:37 UTC 2026