← Back to branch summary

~mmach/netext73/mesa-ryzen

« back to all changes in this revision

Viewing changes to src/gallium/drivers/d3d12/d3d12_nir_passes.c

  • Committer: mmach
  • Date: 2023-11-02 21:31:35 UTC
  • Revision ID: netbit73@gmail.com-20231102213135-18d4tzh7tj0uz752
2023-11-02 22:11:57

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/drivers/d3d12/d3d12_nir_passes.c
46
46
{
47
47
   const gl_state_index16 tokens[STATE_LENGTH] = { STATE_INTERNAL_DRIVER, var_enum };
48
48
   if (*out_var == NULL) {
49
 
      nir_variable *var = nir_variable_create(b->shader,
50
 
                                              nir_var_uniform,
51
 
                                              var_type,
52
 
                                              var_name);
53
 
 
54
 
      var->num_state_slots = 1;
55
 
      var->state_slots = ralloc_array(var, nir_state_slot, 1);
56
 
      memcpy(var->state_slots[0].tokens, tokens,
57
 
             sizeof(var->state_slots[0].tokens));
 
49
      nir_variable *var = nir_state_variable_create(b->shader, var_type,
 
50
                                                    var_name, tokens);
58
51
      var->data.how_declared = nir_var_hidden;
59
 
      b->shader->num_uniforms++;
60
52
      *out_var = var;
61
53
   }
62
54
   return nir_load_var(b, *out_var);
100
92
       nir->info.stage != MESA_SHADER_GEOMETRY)
101
93
      return;
102
94
 
103
 
   nir_foreach_function(function, nir) {
104
 
      if (function->impl) {
105
 
         nir_builder b;
106
 
         nir_builder_init(&b, function->impl);
 
95
   nir_foreach_function_impl(impl, nir) {
 
96
      nir_builder b = nir_builder_create(impl);
107
97
 
108
 
         nir_foreach_block(block, function->impl) {
109
 
            nir_foreach_instr_safe(instr, block) {
110
 
               lower_pos_write(&b, instr, &flip);
111
 
            }
 
98
      nir_foreach_block(block, impl) {
 
99
         nir_foreach_instr_safe(instr, block) {
 
100
            lower_pos_write(&b, instr, &flip);
112
101
         }
113
 
 
114
 
         nir_metadata_preserve(function->impl, nir_metadata_block_index |
115
 
                                               nir_metadata_dominance);
116
102
      }
 
103
 
 
104
      nir_metadata_preserve(impl, nir_metadata_block_index |
 
105
                                  nir_metadata_dominance);
117
106
   }
118
107
}
119
108
 
158
147
{
159
148
   assert(nir->info.stage == MESA_SHADER_FRAGMENT);
160
149
   nir_variable *depth_transform = NULL;
161
 
   nir_foreach_function(function, nir) {
162
 
      if (function->impl) {
163
 
         nir_builder b;
164
 
         nir_builder_init(&b, function->impl);
 
150
   nir_foreach_function_impl(impl, nir) {
 
151
      nir_builder b = nir_builder_create(impl);
165
152
 
166
 
         nir_foreach_block(block, function->impl) {
167
 
            nir_foreach_instr_safe(instr, block) {
168
 
               lower_pos_read(&b, instr, &depth_transform);
169
 
            }
 
153
      nir_foreach_block(block, impl) {
 
154
         nir_foreach_instr_safe(instr, block) {
 
155
            lower_pos_read(&b, instr, &depth_transform);
170
156
         }
171
 
 
172
 
         nir_metadata_preserve(function->impl, nir_metadata_block_index |
173
 
                                               nir_metadata_dominance);
174
157
      }
 
158
 
 
159
      nir_metadata_preserve(impl, nir_metadata_block_index |
 
160
                                  nir_metadata_dominance);
175
161
   }
176
162
}
177
163
 
243
229
   nir_ssa_def *def = is_signed ? nir_format_float_to_snorm(b, col, bits) :
244
230
                                  nir_format_float_to_unorm(b, col, bits);
245
231
   if (is_signed)
246
 
      def = nir_bcsel(b, nir_ilt(b, def, nir_imm_int(b, 0)),
247
 
                      nir_iadd(b, def, nir_imm_int(b, 1 << NUM_BITS)),
 
232
      def = nir_bcsel(b, nir_ilt_imm(b, def, 0),
 
233
                      nir_iadd_imm(b, def, 1ull << NUM_BITS),
248
234
                      def);
249
235
   nir_instr_rewrite_src(&intr->instr, intr->src + 1, nir_src_for_ssa(def));
250
236
}
255
241
   if (nir->info.stage != MESA_SHADER_FRAGMENT)
256
242
      return;
257
243
 
258
 
   nir_foreach_function(function, nir) {
259
 
      if (function->impl) {
260
 
         nir_builder b;
261
 
         nir_builder_init(&b, function->impl);
 
244
   nir_foreach_function_impl(impl, nir) {
 
245
      nir_builder b = nir_builder_create(impl);
262
246
 
263
 
         nir_foreach_block(block, function->impl) {
264
 
            nir_foreach_instr_safe(instr, block) {
265
 
               lower_uint_color_write(&b, instr, is_signed);
266
 
            }
 
247
      nir_foreach_block(block, impl) {
 
248
         nir_foreach_instr_safe(instr, block) {
 
249
            lower_uint_color_write(&b, instr, is_signed);
267
250
         }
268
 
 
269
 
         nir_metadata_preserve(function->impl, nir_metadata_block_index |
270
 
                                               nir_metadata_dominance);
271
251
      }
 
252
 
 
253
      nir_metadata_preserve(impl, nir_metadata_block_index |
 
254
                                  nir_metadata_dominance);
272
255
   }
273
256
}
274
257
 
425
408
      return;
426
409
 
427
410
   struct invert_depth_state state = { viewport_mask, clip_halfz };
428
 
   nir_foreach_function(function, shader) {
429
 
      if (function->impl) {
430
 
         nir_builder b;
431
 
         nir_builder_init(&b, function->impl);
432
 
 
433
 
         nir_foreach_block(block, function->impl) {
434
 
            nir_foreach_instr_safe(instr, block) {
435
 
               invert_depth_instr(&b, instr, &state);
436
 
            }
437
 
         }
438
 
 
439
 
         if (state.store_pos_instr) {
440
 
            b.cursor = nir_after_block(function->impl->end_block);
441
 
            invert_depth_impl(&b, &state);
442
 
         }
443
 
 
444
 
         nir_metadata_preserve(function->impl, nir_metadata_block_index |
445
 
                                               nir_metadata_dominance);
446
 
      }
 
411
   nir_foreach_function_impl(impl, shader) {
 
412
      nir_builder b = nir_builder_create(impl);
 
413
 
 
414
      nir_foreach_block(block, impl) {
 
415
         nir_foreach_instr_safe(instr, block) {
 
416
            invert_depth_instr(&b, instr, &state);
 
417
         }
 
418
      }
 
419
 
 
420
      if (state.store_pos_instr) {
 
421
         b.cursor = nir_after_block(impl->end_block);
 
422
         invert_depth_impl(&b, &state);
 
423
      }
 
424
 
 
425
      nir_metadata_preserve(impl, nir_metadata_block_index |
 
426
                                  nir_metadata_dominance);
447
427
   }
448
428
}
449
429
 
547
527
      }
548
528
   }
549
529
 
550
 
   nir_foreach_function(function, nir) {
551
 
      if (function->impl) {
552
 
         nir_builder builder;
553
 
         nir_builder_init(&builder, function->impl);
554
 
         nir_foreach_block(block, function->impl) {
555
 
            nir_foreach_instr_safe(instr, block) {
556
 
               if (instr->type == nir_instr_type_intrinsic)
557
 
                  progress |= lower_instr(nir_instr_as_intrinsic(instr),
558
 
                                          &builder,
559
 
                                          shader,
560
 
                                          binding);
561
 
            }
 
530
   nir_foreach_function_impl(impl, nir) {
 
531
      nir_builder builder = nir_builder_create(impl);
 
532
      nir_foreach_block(block, impl) {
 
533
         nir_foreach_instr_safe(instr, block) {
 
534
            if (instr->type == nir_instr_type_intrinsic)
 
535
               progress |= lower_instr(nir_instr_as_intrinsic(instr),
 
536
                                       &builder,
 
537
                                       shader,
 
538
                                       binding);
562
539
         }
563
 
 
564
 
         nir_metadata_preserve(function->impl, nir_metadata_block_index |
565
 
                                               nir_metadata_dominance);
566
540
      }
 
541
 
 
542
      nir_metadata_preserve(impl, nir_metadata_block_index |
 
543
                                  nir_metadata_dominance);
567
544
   }
568
545
 
569
546
   if (progress) {
613
590
   assert(missing_mask != 0);
614
591
   nir_builder b;
615
592
   nir_function_impl *impl = nir_shader_get_entrypoint(s);
616
 
   nir_builder_init(&b, impl);
617
 
   b.cursor = nir_before_cf_list(&impl->body);
 
593
   b = nir_builder_at(nir_before_cf_list(&impl->body));
618
594
 
619
595
   nir_ssa_def *zero = nir_imm_zero(&b, 4, 32);
620
596
   for (unsigned i = 0; i < 2; ++i) {
636
612
                               nir_metadata_dominance);
637
613
}
638
614
 
639
 
static bool
640
 
lower_load_ubo_packed_filter(const nir_instr *instr,
641
 
                             UNUSED const void *_options) {
642
 
   if (instr->type != nir_instr_type_intrinsic)
643
 
      return false;
644
 
 
645
 
   nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
646
 
 
647
 
   return intr->intrinsic == nir_intrinsic_load_ubo;
648
 
}
649
 
 
650
 
static nir_ssa_def *
651
 
lower_load_ubo_packed_impl(nir_builder *b, nir_instr *instr,
652
 
                              UNUSED void *_options) {
653
 
   nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
654
 
 
655
 
   nir_ssa_def *buffer = intr->src[0].ssa;
656
 
   nir_ssa_def *offset = intr->src[1].ssa;
657
 
 
658
 
   nir_ssa_def *result =
659
 
      build_load_ubo_dxil(b, buffer,
660
 
                          offset,
661
 
                          nir_dest_num_components(intr->dest),
662
 
                          nir_dest_bit_size(intr->dest),
663
 
                          nir_intrinsic_align(intr));
664
 
   return result;
665
 
}
666
 
 
667
 
bool
668
 
nir_lower_packed_ubo_loads(nir_shader *nir) {
669
 
   return nir_shader_lower_instructions(nir,
670
 
                                        lower_load_ubo_packed_filter,
671
 
                                        lower_load_ubo_packed_impl,
672
 
                                        NULL);
673
 
}
674
 
 
675
615
void
676
616
d3d12_lower_primitive_id(nir_shader *shader)
677
617
{
678
618
   nir_builder b;
679
619
   nir_function_impl *impl = nir_shader_get_entrypoint(shader);
680
620
   nir_ssa_def *primitive_id;
681
 
   nir_builder_init(&b, impl);
 
621
   b = nir_builder_create(impl);
682
622
 
683
623
   nir_variable *primitive_id_var = nir_variable_create(shader, nir_var_shader_out,
684
624
                                                        glsl_uint_type(), "primitive_id");
770
710
 
771
711
   nir_pop_if(b, count_check);
772
712
 
773
 
   vertex_count = nir_iadd(b, vertex_count, nir_imm_int(b, 1));
 
713
   vertex_count = nir_iadd_imm(b, vertex_count, 1);
774
714
   nir_store_var(b, vertex_count_var, vertex_count, 0x1);
775
715
 
776
716
   nir_instr_remove(&intr->instr);
794
734
   nir_function_impl *impl = nir_shader_get_entrypoint(shader);
795
735
   nir_variable *tmp_vars[VARYING_SLOT_MAX] = {0};
796
736
   nir_variable *out_vars[VARYING_SLOT_MAX] = {0};
797
 
   nir_builder_init(&b, impl);
 
737
   b = nir_builder_create(impl);
798
738
 
799
739
   shader->info.gs.vertices_out = (shader->info.gs.vertices_out - 2) * 3;
800
740
 
852
792
      nir_io_semantics semantics = nir_intrinsic_io_semantics(intr);
853
793
      return semantics.location == FRAG_RESULT_SAMPLE_MASK;
854
794
   } else if (intr->intrinsic == nir_intrinsic_store_deref) {
855
 
      nir_variable *var = nir_deref_instr_get_variable(nir_src_as_deref(intr->src[0]));
 
795
      nir_variable *var = nir_intrinsic_get_var(intr, 0);
856
796
      return var->data.location == FRAG_RESULT_SAMPLE_MASK;
857
797
   } else if (intr->intrinsic == nir_intrinsic_load_sample_id ||
858
798
              intr->intrinsic == nir_intrinsic_load_sample_mask_in)
1057
997
   if (s->info.stage == MESA_SHADER_TESS_CTRL && !var->data.patch)
1058
998
      return;
1059
999
 
1060
 
   nir_foreach_function(func, s) {
1061
 
      if (!func->impl)
1062
 
         continue;
1063
 
 
1064
 
      nir_builder b;
1065
 
      nir_builder_init(&b, func->impl);
1066
 
 
1067
 
      nir_foreach_block(block, func->impl) {
 
1000
   nir_foreach_function_impl(impl, s) {
 
1001
      nir_builder b = nir_builder_create(impl);
 
1002
 
 
1003
      nir_foreach_block(block, impl) {
1068
1004
         b.cursor = nir_before_block(block);
1069
1005
         if (s->info.stage != MESA_SHADER_GEOMETRY) {
1070
1006
            write_0(&b, nir_build_deref_var(&b, var));
1083
1019
         }
1084
1020
      }
1085
1021
 
1086
 
      nir_metadata_preserve(func->impl, nir_metadata_block_index | nir_metadata_dominance);
 
1022
      nir_metadata_preserve(impl, nir_metadata_block_index | nir_metadata_dominance);
1087
1023
   }
1088
1024
}