1 /* 2 * Copyright 2012 Advanced Micro Devices, Inc. 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 * on the rights to use, copy, modify, merge, publish, distribute, sub 8 * license, and/or sell copies of the Software, and to permit persons to whom 9 * the 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 NON-INFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, 19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 21 * USE OR OTHER DEALINGS IN THE SOFTWARE. 22 */ 23 24 /* The compiler middle-end architecture: Explaining (non-)monolithic shaders 25 * ------------------------------------------------------------------------- 26 * 27 * Typically, there is one-to-one correspondence between API and HW shaders, 28 * that is, for every API shader, there is exactly one shader binary in 29 * the driver. 30 * 31 * The problem with that is that we also have to emulate some API states 32 * (e.g. alpha-test, and many others) in shaders too. The two obvious ways 33 * to deal with it are: 34 * - each shader has multiple variants for each combination of emulated states, 35 * and the variants are compiled on demand, possibly relying on a shader 36 * cache for good performance 37 * - patch shaders at the binary level 38 * 39 * This driver uses something completely different. The emulated states are 40 * usually implemented at the beginning or end of shaders. Therefore, we can 41 * split the shader into 3 parts: 42 * - prolog part (shader code dependent on states) 43 * - main part (the API shader) 44 * - epilog part (shader code dependent on states) 45 * 46 * Each part is compiled as a separate shader and the final binaries are 47 * concatenated. This type of shader is called non-monolithic, because it 48 * consists of multiple independent binaries. Creating a new shader variant 49 * is therefore only a concatenation of shader parts (binaries) and doesn't 50 * involve any compilation. The main shader parts are the only parts that are 51 * compiled when applications create shader objects. The prolog and epilog 52 * parts are compiled on the first use and saved, so that their binaries can 53 * be reused by many other shaders. 54 * 55 * One of the roles of the prolog part is to compute vertex buffer addresses 56 * for vertex shaders. A few of the roles of the epilog part are color buffer 57 * format conversions in pixel shaders that we have to do manually, and write 58 * tessellation factors in tessellation control shaders. The prolog and epilog 59 * have many other important responsibilities in various shader stages. 60 * They don't just "emulate legacy stuff". 61 * 62 * Monolithic shaders are shaders where the parts are combined before LLVM 63 * compilation, and the whole thing is compiled and optimized as one unit with 64 * one binary on the output. The result is the same as the non-monolithic 65 * shader, but the final code can be better, because LLVM can optimize across 66 * all shader parts. Monolithic shaders aren't usually used except for these 67 * special cases: 68 * 69 * 1) Some rarely-used states require modification of the main shader part 70 * itself, and in such cases, only the monolithic shader variant is 71 * compiled, and that's always done on the first use. 72 * 73 * 2) When we do cross-stage optimizations for separate shader objects and 74 * e.g. eliminate unused shader varyings, the resulting optimized shader 75 * variants are always compiled as monolithic shaders, and always 76 * asynchronously (i.e. not stalling ongoing rendering). We call them 77 * "optimized monolithic" shaders. The important property here is that 78 * the non-monolithic unoptimized shader variant is always available for use 79 * when the asynchronous compilation of the optimized shader is not done 80 * yet. 81 * 82 * Starting with GFX9 chips, some shader stages are merged, and the number of 83 * shader parts per shader increased. The complete new list of shader parts is: 84 * - 1st shader: prolog part 85 * - 1st shader: main part 86 * - 2nd shader: prolog part 87 * - 2nd shader: main part 88 * - 2nd shader: epilog part 89 */ 90 91 /* How linking shader inputs and outputs between vertex, tessellation, and 92 * geometry shaders works. 93 * 94 * Inputs and outputs between shaders are stored in a buffer. This buffer 95 * lives in LDS (typical case for tessellation), but it can also live 96 * in memory (ESGS). Each input or output has a fixed location within a vertex. 97 * The highest used input or output determines the stride between vertices. 98 * 99 * Since GS and tessellation are only possible in the OpenGL core profile, 100 * only these semantics are valid for per-vertex data: 101 * 102 * Name Location 103 * 104 * POSITION 0 105 * PSIZE 1 106 * CLIPDIST0..1 2..3 107 * CULLDIST0..1 (not implemented) 108 * GENERIC0..31 4..35 109 * 110 * For example, a shader only writing GENERIC0 has the output stride of 5. 111 * 112 * Only these semantics are valid for per-patch data: 113 * 114 * Name Location 115 * 116 * TESSOUTER 0 117 * TESSINNER 1 118 * PATCH0..29 2..31 119 * 120 * That's how independent shaders agree on input and output locations. 121 * The si_shader_io_get_unique_index function assigns the locations. 122 * 123 * For tessellation, other required information for calculating the input and 124 * output addresses like the vertex stride, the patch stride, and the offsets 125 * where per-vertex and per-patch data start, is passed to the shader via 126 * user data SGPRs. The offsets and strides are calculated at draw time and 127 * aren't available at compile time. 128 */ 129 130 #ifndef SI_SHADER_H 131 #define SI_SHADER_H 132 133 #include <llvm-c/Core.h> /* LLVMModuleRef */ 134 #include <llvm-c/TargetMachine.h> 135 #include "tgsi/tgsi_scan.h" 136 #include "util/u_queue.h" 137 138 #include "ac_binary.h" 139 #include "si_state.h" 140 141 struct nir_shader; 142 143 #define SI_MAX_VS_OUTPUTS 40 144 145 /* Shader IO unique indices are supported for TGSI_SEMANTIC_GENERIC with an 146 * index smaller than this. 147 */ 148 #define SI_MAX_IO_GENERIC 46 149 150 /* SGPR user data indices */ 151 enum { 152 SI_SGPR_RW_BUFFERS, /* rings (& stream-out, VS only) */ 153 SI_SGPR_RW_BUFFERS_HI, 154 SI_SGPR_BINDLESS_SAMPLERS_AND_IMAGES, 155 SI_SGPR_BINDLESS_SAMPLERS_AND_IMAGES_HI, 156 SI_SGPR_CONST_AND_SHADER_BUFFERS, /* or just a constant buffer 0 pointer */ 157 SI_SGPR_CONST_AND_SHADER_BUFFERS_HI, 158 SI_SGPR_SAMPLERS_AND_IMAGES, 159 SI_SGPR_SAMPLERS_AND_IMAGES_HI, 160 SI_NUM_RESOURCE_SGPRS, 161 162 /* all VS variants */ 163 SI_SGPR_VERTEX_BUFFERS = SI_NUM_RESOURCE_SGPRS, 164 SI_SGPR_VERTEX_BUFFERS_HI, 165 SI_SGPR_BASE_VERTEX, 166 SI_SGPR_START_INSTANCE, 167 SI_SGPR_DRAWID, 168 SI_SGPR_VS_STATE_BITS, 169 SI_VS_NUM_USER_SGPR, 170 171 SI_SGPR_VS_BLIT_DATA = SI_SGPR_CONST_AND_SHADER_BUFFERS, 172 173 /* TES */ 174 SI_SGPR_TES_OFFCHIP_LAYOUT = SI_NUM_RESOURCE_SGPRS, 175 SI_SGPR_TES_OFFCHIP_ADDR_BASE64K, 176 SI_TES_NUM_USER_SGPR, 177 178 /* GFX6-8: TCS only */ 179 GFX6_SGPR_TCS_OFFCHIP_LAYOUT = SI_NUM_RESOURCE_SGPRS, 180 GFX6_SGPR_TCS_OUT_OFFSETS, 181 GFX6_SGPR_TCS_OUT_LAYOUT, 182 GFX6_SGPR_TCS_IN_LAYOUT, 183 GFX6_SGPR_TCS_OFFCHIP_ADDR_BASE64K, 184 GFX6_SGPR_TCS_FACTOR_ADDR_BASE64K, 185 GFX6_TCS_NUM_USER_SGPR, 186 187 /* GFX9: Merged LS-HS (VS-TCS) only. */ 188 GFX9_SGPR_TCS_OFFCHIP_LAYOUT = SI_VS_NUM_USER_SGPR, 189 GFX9_SGPR_TCS_OUT_OFFSETS, 190 GFX9_SGPR_TCS_OUT_LAYOUT, 191 GFX9_SGPR_TCS_OFFCHIP_ADDR_BASE64K, 192 GFX9_SGPR_TCS_FACTOR_ADDR_BASE64K, 193 GFX9_SGPR_unused_to_align_the_next_pointer, 194 GFX9_SGPR_TCS_CONST_AND_SHADER_BUFFERS, 195 GFX9_SGPR_TCS_CONST_AND_SHADER_BUFFERS_HI, 196 GFX9_SGPR_TCS_SAMPLERS_AND_IMAGES, 197 GFX9_SGPR_TCS_SAMPLERS_AND_IMAGES_HI, 198 GFX9_TCS_NUM_USER_SGPR, 199 200 /* GFX9: Merged ES-GS (VS-GS or TES-GS). */ 201 GFX9_SGPR_GS_CONST_AND_SHADER_BUFFERS = SI_VS_NUM_USER_SGPR, 202 GFX9_SGPR_GS_CONST_AND_SHADER_BUFFERS_HI, 203 GFX9_SGPR_GS_SAMPLERS_AND_IMAGES, 204 GFX9_SGPR_GS_SAMPLERS_AND_IMAGES_HI, 205 GFX9_GS_NUM_USER_SGPR, 206 207 /* GS limits */ 208 GFX6_GS_NUM_USER_SGPR = SI_NUM_RESOURCE_SGPRS, 209 SI_GSCOPY_NUM_USER_SGPR = SI_SGPR_RW_BUFFERS_HI + 1, 210 211 /* PS only */ 212 SI_SGPR_ALPHA_REF = SI_NUM_RESOURCE_SGPRS, 213 SI_PS_NUM_USER_SGPR, 214 }; 215 216 /* LLVM function parameter indices */ 217 enum { 218 SI_NUM_RESOURCE_PARAMS = 4, 219 220 /* PS only parameters */ 221 SI_PARAM_ALPHA_REF = SI_NUM_RESOURCE_PARAMS, 222 SI_PARAM_PRIM_MASK, 223 SI_PARAM_PERSP_SAMPLE, 224 SI_PARAM_PERSP_CENTER, 225 SI_PARAM_PERSP_CENTROID, 226 SI_PARAM_PERSP_PULL_MODEL, 227 SI_PARAM_LINEAR_SAMPLE, 228 SI_PARAM_LINEAR_CENTER, 229 SI_PARAM_LINEAR_CENTROID, 230 SI_PARAM_LINE_STIPPLE_TEX, 231 SI_PARAM_POS_X_FLOAT, 232 SI_PARAM_POS_Y_FLOAT, 233 SI_PARAM_POS_Z_FLOAT, 234 SI_PARAM_POS_W_FLOAT, 235 SI_PARAM_FRONT_FACE, 236 SI_PARAM_ANCILLARY, 237 SI_PARAM_SAMPLE_COVERAGE, 238 SI_PARAM_POS_FIXED_PT, 239 240 SI_NUM_PARAMS = SI_PARAM_POS_FIXED_PT + 9, /* +8 for COLOR[0..1] */ 241 }; 242 243 /* Fields of driver-defined VS state SGPR. */ 244 /* Clamp vertex color output (only used in VS as VS). */ 245 #define S_VS_STATE_CLAMP_VERTEX_COLOR(x) (((unsigned)(x) & 0x1) << 0) 246 #define C_VS_STATE_CLAMP_VERTEX_COLOR 0xFFFFFFFE 247 #define S_VS_STATE_INDEXED(x) (((unsigned)(x) & 0x1) << 1) 248 #define C_VS_STATE_INDEXED 0xFFFFFFFD 249 #define S_VS_STATE_LS_OUT_PATCH_SIZE(x) (((unsigned)(x) & 0x1FFF) << 8) 250 #define C_VS_STATE_LS_OUT_PATCH_SIZE 0xFFE000FF 251 #define S_VS_STATE_LS_OUT_VERTEX_SIZE(x) (((unsigned)(x) & 0xFF) << 24) 252 #define C_VS_STATE_LS_OUT_VERTEX_SIZE 0x00FFFFFF 253 254 /* SI-specific system values. */ 255 enum { 256 TGSI_SEMANTIC_DEFAULT_TESSOUTER_SI = TGSI_SEMANTIC_COUNT, 257 TGSI_SEMANTIC_DEFAULT_TESSINNER_SI, 258 }; 259 260 enum { 261 /* Use a property enum that VS wouldn't use. */ 262 TGSI_PROPERTY_VS_BLIT_SGPRS = TGSI_PROPERTY_FS_COORD_ORIGIN, 263 264 /* These represent the number of SGPRs the shader uses. */ 265 SI_VS_BLIT_SGPRS_POS = 3, 266 SI_VS_BLIT_SGPRS_POS_COLOR = 7, 267 SI_VS_BLIT_SGPRS_POS_TEXCOORD = 9, 268 }; 269 270 /* For VS shader key fix_fetch. */ 271 enum { 272 SI_FIX_FETCH_NONE = 0, 273 SI_FIX_FETCH_A2_SNORM, 274 SI_FIX_FETCH_A2_SSCALED, 275 SI_FIX_FETCH_A2_SINT, 276 SI_FIX_FETCH_RGBA_32_UNORM, 277 SI_FIX_FETCH_RGBX_32_UNORM, 278 SI_FIX_FETCH_RGBA_32_SNORM, 279 SI_FIX_FETCH_RGBX_32_SNORM, 280 SI_FIX_FETCH_RGBA_32_USCALED, 281 SI_FIX_FETCH_RGBA_32_SSCALED, 282 SI_FIX_FETCH_RGBA_32_FIXED, 283 SI_FIX_FETCH_RGBX_32_FIXED, 284 SI_FIX_FETCH_RG_64_FLOAT, 285 SI_FIX_FETCH_RGB_64_FLOAT, 286 SI_FIX_FETCH_RGBA_64_FLOAT, 287 SI_FIX_FETCH_RGB_8, /* A = 1.0 */ 288 SI_FIX_FETCH_RGB_8_INT, /* A = 1 */ 289 SI_FIX_FETCH_RGB_16, 290 SI_FIX_FETCH_RGB_16_INT, 291 }; 292 293 struct si_shader; 294 295 /* State of the context creating the shader object. */ 296 struct si_compiler_ctx_state { 297 /* Should only be used by si_init_shader_selector_async and 298 * si_build_shader_variant if thread_index == -1 (non-threaded). */ 299 LLVMTargetMachineRef tm; 300 301 /* Used if thread_index == -1 or if debug.async is true. */ 302 struct pipe_debug_callback debug; 303 304 /* Used for creating the log string for gallium/ddebug. */ 305 bool is_debug_context; 306 }; 307 308 /* A shader selector is a gallium CSO and contains shader variants and 309 * binaries for one TGSI program. This can be shared by multiple contexts. 310 */ 311 struct si_shader_selector { 312 struct pipe_reference reference; 313 struct si_screen *screen; 314 struct util_queue_fence ready; 315 struct si_compiler_ctx_state compiler_ctx_state; 316 317 mtx_t mutex; 318 struct si_shader *first_variant; /* immutable after the first variant */ 319 struct si_shader *last_variant; /* mutable */ 320 321 /* The compiled TGSI shader expecting a prolog and/or epilog (not 322 * uploaded to a buffer). 323 */ 324 struct si_shader *main_shader_part; 325 struct si_shader *main_shader_part_ls; /* as_ls is set in the key */ 326 struct si_shader *main_shader_part_es; /* as_es is set in the key */ 327 328 struct si_shader *gs_copy_shader; 329 330 struct tgsi_token *tokens; 331 struct nir_shader *nir; 332 struct pipe_stream_output_info so; 333 struct tgsi_shader_info info; 334 struct tgsi_tessctrl_info tcs_info; 335 336 /* PIPE_SHADER_[VERTEX|FRAGMENT|...] */ 337 unsigned type; 338 bool vs_needs_prolog; 339 bool force_correct_derivs_after_kill; 340 unsigned pa_cl_vs_out_cntl; 341 ubyte clipdist_mask; 342 ubyte culldist_mask; 343 344 /* ES parameters. */ 345 unsigned esgs_itemsize; 346 347 /* GS parameters. */ 348 unsigned gs_input_verts_per_prim; 349 unsigned gs_output_prim; 350 unsigned gs_max_out_vertices; 351 unsigned gs_num_invocations; 352 unsigned max_gs_stream; /* count - 1 */ 353 unsigned gsvs_vertex_size; 354 unsigned max_gsvs_emit_size; 355 unsigned enabled_streamout_buffer_mask; 356 357 /* PS parameters. */ 358 unsigned color_attr_index[2]; 359 unsigned db_shader_control; 360 /* Set 0xf or 0x0 (4 bits) per each written output. 361 * ANDed with spi_shader_col_format. 362 */ 363 unsigned colors_written_4bit; 364 365 /* CS parameters */ 366 unsigned local_size; 367 368 uint64_t outputs_written; /* "get_unique_index" bits */ 369 uint32_t patch_outputs_written; /* "get_unique_index_patch" bits */ 370 371 uint64_t inputs_read; /* "get_unique_index" bits */ 372 373 /* bitmasks of used descriptor slots */ 374 uint32_t active_const_and_shader_buffers; 375 uint64_t active_samplers_and_images; 376 }; 377 378 /* Valid shader configurations: 379 * 380 * API shaders VS | TCS | TES | GS |pass| PS 381 * are compiled as: | | | |thru| 382 * | | | | | 383 * Only VS & PS: VS | | | | | PS 384 * GFX6 - with GS: ES | | | GS | VS | PS 385 * - with tess: LS | HS | VS | | | PS 386 * - with both: LS | HS | ES | GS | VS | PS 387 * GFX9 - with GS: -> | | | GS | VS | PS 388 * - with tess: -> | HS | VS | | | PS 389 * - with both: -> | HS | -> | GS | VS | PS 390 * 391 * -> = merged with the next stage 392 */ 393 394 /* Use the byte alignment for all following structure members for optimal 395 * shader key memory footprint. 396 */ 397 #pragma pack(push, 1) 398 399 /* Common VS bits between the shader key and the prolog key. */ 400 struct si_vs_prolog_bits { 401 /* - If neither "is_one" nor "is_fetched" has a bit set, the instance 402 * divisor is 0. 403 * - If "is_one" has a bit set, the instance divisor is 1. 404 * - If "is_fetched" has a bit set, the instance divisor will be loaded 405 * from the constant buffer. 406 */ 407 uint16_t instance_divisor_is_one; /* bitmask of inputs */ 408 uint16_t instance_divisor_is_fetched; /* bitmask of inputs */ 409 unsigned ls_vgpr_fix:1; 410 }; 411 412 /* Common TCS bits between the shader key and the epilog key. */ 413 struct si_tcs_epilog_bits { 414 unsigned prim_mode:3; 415 unsigned invoc0_tess_factors_are_def:1; 416 unsigned tes_reads_tess_factors:1; 417 }; 418 419 struct si_gs_prolog_bits { 420 unsigned tri_strip_adj_fix:1; 421 }; 422 423 /* Common PS bits between the shader key and the prolog key. */ 424 struct si_ps_prolog_bits { 425 unsigned color_two_side:1; 426 unsigned flatshade_colors:1; 427 unsigned poly_stipple:1; 428 unsigned force_persp_sample_interp:1; 429 unsigned force_linear_sample_interp:1; 430 unsigned force_persp_center_interp:1; 431 unsigned force_linear_center_interp:1; 432 unsigned bc_optimize_for_persp:1; 433 unsigned bc_optimize_for_linear:1; 434 unsigned samplemask_log_ps_iter:3; 435 }; 436 437 /* Common PS bits between the shader key and the epilog key. */ 438 struct si_ps_epilog_bits { 439 unsigned spi_shader_col_format; 440 unsigned color_is_int8:8; 441 unsigned color_is_int10:8; 442 unsigned last_cbuf:3; 443 unsigned alpha_func:3; 444 unsigned alpha_to_one:1; 445 unsigned poly_line_smoothing:1; 446 unsigned clamp_color:1; 447 }; 448 449 union si_shader_part_key { 450 struct { 451 struct si_vs_prolog_bits states; 452 unsigned num_input_sgprs:6; 453 /* For merged stages such as LS-HS, HS input VGPRs are first. */ 454 unsigned num_merged_next_stage_vgprs:3; 455 unsigned last_input:4; 456 unsigned as_ls:1; 457 unsigned as_es:1; 458 /* Prologs for monolithic shaders shouldn't set EXEC. */ 459 unsigned is_monolithic:1; 460 } vs_prolog; 461 struct { 462 struct si_tcs_epilog_bits states; 463 } tcs_epilog; 464 struct { 465 struct si_gs_prolog_bits states; 466 /* Prologs of monolithic shaders shouldn't set EXEC. */ 467 unsigned is_monolithic:1; 468 } gs_prolog; 469 struct { 470 struct si_ps_prolog_bits states; 471 unsigned num_input_sgprs:6; 472 unsigned num_input_vgprs:5; 473 /* Color interpolation and two-side color selection. */ 474 unsigned colors_read:8; /* color input components read */ 475 unsigned num_interp_inputs:5; /* BCOLOR is at this location */ 476 unsigned face_vgpr_index:5; 477 unsigned ancillary_vgpr_index:5; 478 unsigned wqm:1; 479 char color_attr_index[2]; 480 char color_interp_vgpr_index[2]; /* -1 == constant */ 481 } ps_prolog; 482 struct { 483 struct si_ps_epilog_bits states; 484 unsigned colors_written:8; 485 unsigned writes_z:1; 486 unsigned writes_stencil:1; 487 unsigned writes_samplemask:1; 488 } ps_epilog; 489 }; 490 491 struct si_shader_key { 492 /* Prolog and epilog flags. */ 493 union { 494 struct { 495 struct si_vs_prolog_bits prolog; 496 } vs; 497 struct { 498 struct si_vs_prolog_bits ls_prolog; /* for merged LS-HS */ 499 struct si_shader_selector *ls; /* for merged LS-HS */ 500 struct si_tcs_epilog_bits epilog; 501 } tcs; /* tessellation control shader */ 502 struct { 503 struct si_vs_prolog_bits vs_prolog; /* for merged ES-GS */ 504 struct si_shader_selector *es; /* for merged ES-GS */ 505 struct si_gs_prolog_bits prolog; 506 } gs; 507 struct { 508 struct si_ps_prolog_bits prolog; 509 struct si_ps_epilog_bits epilog; 510 } ps; 511 } part; 512 513 /* These two are initially set according to the NEXT_SHADER property, 514 * or guessed if the property doesn't seem correct. 515 */ 516 unsigned as_es:1; /* export shader, which precedes GS */ 517 unsigned as_ls:1; /* local shader, which precedes TCS */ 518 519 /* Flags for monolithic compilation only. */ 520 struct { 521 /* One byte for every input: SI_FIX_FETCH_* enums. */ 522 uint8_t vs_fix_fetch[SI_MAX_ATTRIBS]; 523 524 union { 525 uint64_t ff_tcs_inputs_to_copy; /* for fixed-func TCS */ 526 /* When PS needs PrimID and GS is disabled. */ 527 unsigned vs_export_prim_id:1; 528 struct { 529 unsigned interpolate_at_sample_force_center:1; 530 } ps; 531 } u; 532 } mono; 533 534 /* Optimization flags for asynchronous compilation only. */ 535 struct { 536 /* For HW VS (it can be VS, TES, GS) */ 537 uint64_t kill_outputs; /* "get_unique_index" bits */ 538 unsigned clip_disable:1; 539 540 /* For shaders where monolithic variants have better code. 541 * 542 * This is a flag that has no effect on code generation, 543 * but forces monolithic shaders to be used as soon as 544 * possible, because it's in the "opt" group. 545 */ 546 unsigned prefer_mono:1; 547 } opt; 548 }; 549 550 /* Restore the pack alignment to default. */ 551 #pragma pack(pop) 552 553 struct si_shader_config { 554 unsigned num_sgprs; 555 unsigned num_vgprs; 556 unsigned spilled_sgprs; 557 unsigned spilled_vgprs; 558 unsigned private_mem_vgprs; 559 unsigned lds_size; 560 unsigned spi_ps_input_ena; 561 unsigned spi_ps_input_addr; 562 unsigned float_mode; 563 unsigned scratch_bytes_per_wave; 564 unsigned rsrc1; 565 unsigned rsrc2; 566 }; 567 568 /* GCN-specific shader info. */ 569 struct si_shader_info { 570 ubyte vs_output_param_offset[SI_MAX_VS_OUTPUTS]; 571 ubyte num_input_sgprs; 572 ubyte num_input_vgprs; 573 signed char face_vgpr_index; 574 signed char ancillary_vgpr_index; 575 bool uses_instanceid; 576 ubyte nr_pos_exports; 577 ubyte nr_param_exports; 578 }; 579 580 struct si_shader { 581 struct si_compiler_ctx_state compiler_ctx_state; 582 583 struct si_shader_selector *selector; 584 struct si_shader_selector *previous_stage_sel; /* for refcounting */ 585 struct si_shader *next_variant; 586 587 struct si_shader_part *prolog; 588 struct si_shader *previous_stage; /* for GFX9 */ 589 struct si_shader_part *prolog2; 590 struct si_shader_part *epilog; 591 592 struct si_pm4_state *pm4; 593 struct r600_resource *bo; 594 struct r600_resource *scratch_bo; 595 struct si_shader_key key; 596 struct util_queue_fence ready; 597 bool compilation_failed; 598 bool is_monolithic; 599 bool is_optimized; 600 bool is_binary_shared; 601 bool is_gs_copy_shader; 602 603 /* The following data is all that's needed for binary shaders. */ 604 struct ac_shader_binary binary; 605 struct si_shader_config config; 606 struct si_shader_info info; 607 608 /* Shader key + LLVM IR + disassembly + statistics. 609 * Generated for debug contexts only. 610 */ 611 char *shader_log; 612 size_t shader_log_size; 613 }; 614 615 struct si_shader_part { 616 struct si_shader_part *next; 617 union si_shader_part_key key; 618 struct ac_shader_binary binary; 619 struct si_shader_config config; 620 }; 621 622 /* si_shader.c */ 623 struct si_shader * 624 si_generate_gs_copy_shader(struct si_screen *sscreen, 625 LLVMTargetMachineRef tm, 626 struct si_shader_selector *gs_selector, 627 struct pipe_debug_callback *debug); 628 int si_compile_tgsi_shader(struct si_screen *sscreen, 629 LLVMTargetMachineRef tm, 630 struct si_shader *shader, 631 bool is_monolithic, 632 struct pipe_debug_callback *debug); 633 int si_shader_create(struct si_screen *sscreen, LLVMTargetMachineRef tm, 634 struct si_shader *shader, 635 struct pipe_debug_callback *debug); 636 void si_shader_destroy(struct si_shader *shader); 637 unsigned si_shader_io_get_unique_index_patch(unsigned semantic_name, unsigned index); 638 unsigned si_shader_io_get_unique_index(unsigned semantic_name, unsigned index); 639 int si_shader_binary_upload(struct si_screen *sscreen, struct si_shader *shader); 640 void si_shader_dump(struct si_screen *sscreen, const struct si_shader *shader, 641 struct pipe_debug_callback *debug, unsigned processor, 642 FILE *f, bool check_debug_option); 643 void si_multiwave_lds_size_workaround(struct si_screen *sscreen, 644 unsigned *lds_size); 645 void si_shader_apply_scratch_relocs(struct si_shader *shader, 646 uint64_t scratch_va); 647 void si_shader_binary_read_config(struct ac_shader_binary *binary, 648 struct si_shader_config *conf, 649 unsigned symbol_offset); 650 const char *si_get_shader_name(const struct si_shader *shader, unsigned processor); 651 652 /* si_shader_nir.c */ 653 void si_nir_scan_shader(const struct nir_shader *nir, 654 struct tgsi_shader_info *info); 655 void si_nir_scan_tess_ctrl(const struct nir_shader *nir, 656 const struct tgsi_shader_info *info, 657 struct tgsi_tessctrl_info *out); 658 void si_lower_nir(struct si_shader_selector *sel); 659 660 /* Inline helpers. */ 661 662 /* Return the pointer to the main shader part's pointer. */ 663 static inline struct si_shader ** 664 si_get_main_shader_part(struct si_shader_selector *sel, 665 struct si_shader_key *key) 666 { 667 if (key->as_ls) 668 return &sel->main_shader_part_ls; 669 if (key->as_es) 670 return &sel->main_shader_part_es; 671 return &sel->main_shader_part; 672 } 673 674 static inline bool 675 si_shader_uses_bindless_samplers(struct si_shader_selector *selector) 676 { 677 return selector ? selector->info.uses_bindless_samplers : false; 678 } 679 680 static inline bool 681 si_shader_uses_bindless_images(struct si_shader_selector *selector) 682 { 683 return selector ? selector->info.uses_bindless_images : false; 684 } 685 686 void si_destroy_shader_selector(struct si_context *sctx, 687 struct si_shader_selector *sel); 688 689 static inline void 690 si_shader_selector_reference(struct si_context *sctx, 691 struct si_shader_selector **dst, 692 struct si_shader_selector *src) 693 { 694 if (pipe_reference(&(*dst)->reference, &src->reference)) 695 si_destroy_shader_selector(sctx, *dst); 696 697 *dst = src; 698 } 699 700 #endif 701
