← Back to branch summary

~mmach/netext73/mesa-ryzen

« back to all changes in this revision

Viewing changes to src/gallium/frontends/d3d10umd/ShaderTGSI.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/frontends/d3d10umd/ShaderTGSI.c
217
217
   uint indexable_temp_offsets[SHADER_MAX_INDEXABLE_TEMPS];
218
218
 
219
219
   struct {
220
 
      boolean declared;
221
 
      uint    writemask;
222
 
      uint    siv_name;
223
 
      boolean overloaded;
 
220
      bool declared;
 
221
      uint writemask;
 
222
      uint siv_name;
 
223
      bool overloaded;
224
224
      struct ureg_src reg;
225
225
   } inputs[SHADER_MAX_INPUTS];
226
226
 
260
260
 
261
261
   case D3D10_SB_INTERPOLATION_LINEAR_CENTROID:
262
262
   case D3D10_SB_INTERPOLATION_LINEAR_SAMPLE: // DX10.1
263
 
      LOG_UNSUPPORTED(TRUE);
 
263
      LOG_UNSUPPORTED(true);
264
264
      return TGSI_INTERPOLATE_PERSPECTIVE;
265
265
 
266
266
   case D3D10_SB_INTERPOLATION_LINEAR_NOPERSPECTIVE_CENTROID:
267
267
   case D3D10_SB_INTERPOLATION_LINEAR_NOPERSPECTIVE_SAMPLE: // DX10.1
268
 
      LOG_UNSUPPORTED(TRUE);
 
268
      LOG_UNSUPPORTED(true);
269
269
      return TGSI_INTERPOLATE_LINEAR;
270
270
   }
271
271
 
298
298
   case D3D10_SB_NAME_IS_FRONT_FACE:
299
299
      return TGSI_SEMANTIC_FACE;
300
300
   case D3D10_SB_NAME_SAMPLE_INDEX:
301
 
      LOG_UNSUPPORTED(TRUE);
 
301
      LOG_UNSUPPORTED(true);
302
302
      return TGSI_SEMANTIC_GENERIC;
303
303
   }
304
304
 
351
351
      return TGSI_RETURN_TYPE_FLOAT;
352
352
   case D3D10_SB_RETURN_TYPE_MIXED:
353
353
   default:
354
 
      LOG_UNSUPPORTED(TRUE);
 
354
      LOG_UNSUPPORTED(true);
355
355
      return TGSI_RETURN_TYPE_FLOAT;
356
356
   }
357
357
}
466
466
      ureg_MOV(ureg, ureg_writemask(temp, writemask),
467
467
               swizzle_reg(dcl_reg, writemask, siv_name));
468
468
      sx->inputs[index].reg = ureg_src(temp);
469
 
      sx->inputs[index].overloaded = TRUE;
 
469
      sx->inputs[index].overloaded = true;
470
470
      sx->inputs[index].writemask |= writemask;
471
471
   } else if (sx->inputs[index].overloaded) {
472
472
      struct ureg_dst temp = ureg_dst(sx->inputs[index].reg);
477
477
      assert(!sx->inputs[index].declared);
478
478
 
479
479
      sx->inputs[index].reg = dcl_reg;
480
 
      sx->inputs[index].declared = TRUE;
 
480
      sx->inputs[index].declared = true;
481
481
      sx->inputs[index].writemask = writemask;
482
482
      sx->inputs[index].siv_name = siv_name;
483
483
   }
690
690
   case D3D10_SB_OPERAND_TYPE_NULL:
691
691
   case D3D10_SB_OPERAND_TYPE_RASTERIZER:
692
692
   case D3D10_SB_OPERAND_TYPE_OUTPUT_COVERAGE_MASK:
693
 
      LOG_UNSUPPORTED(TRUE);
 
693
      LOG_UNSUPPORTED(true);
694
694
      reg = ureg_src(ureg_DECL_temporary(sx->ureg));
695
695
      break;
696
696
 
770
770
   case D3D10_SB_OPERAND_TYPE_OUTPUT_COVERAGE_MASK:
771
771
      /* XXX: Translate more operands types.
772
772
       */
773
 
      LOG_UNSUPPORTED(TRUE);
 
773
      LOG_UNSUPPORTED(true);
774
774
      reg = ureg_DECL_temporary(sx->ureg);
775
775
   }
776
776
 
806
806
   default:
807
807
      /* XXX: Other index representations.
808
808
       */
809
 
      LOG_UNSUPPORTED(TRUE);
 
809
      LOG_UNSUPPORTED(true);
810
810
      reg = ureg_src(ureg_DECL_temporary(sx->ureg));
811
811
   }
812
812
   return reg;
815
815
static struct ureg_dst
816
816
translate_dst_operand(struct Shader_xlate *sx,
817
817
                      const struct Shader_dst_operand *operand,
818
 
                      boolean saturate)
 
818
                      bool saturate)
819
819
{
820
820
   struct ureg_dst reg;
821
821
   unsigned writemask =
882
882
         default:
883
883
            /* XXX: Other index representations.
884
884
             */
885
 
            LOG_UNSUPPORTED(TRUE);
 
885
            LOG_UNSUPPORTED(true);
886
886
 
887
887
         }
888
888
      } else {
908
908
         default:
909
909
            /* XXX: Other index representations.
910
910
             */
911
 
            LOG_UNSUPPORTED(TRUE);
 
911
            LOG_UNSUPPORTED(true);
912
912
         }
913
913
 
914
914
         switch (operand->base.index[0].index_rep) {
930
930
         default:
931
931
            /* XXX: Other index representations.
932
932
             */
933
 
            LOG_UNSUPPORTED(TRUE);
 
933
            LOG_UNSUPPORTED(true);
934
934
         }
935
935
      }
936
936
      break;
1012
1012
      default:
1013
1013
         /* XXX: Other index representations.
1014
1014
          */
1015
 
         LOG_UNSUPPORTED(TRUE);
 
1015
         LOG_UNSUPPORTED(true);
1016
1016
      }
1017
1017
 
1018
1018
      break;
1036
1036
      default:
1037
1037
         /* XXX: Other index representations.
1038
1038
          */
1039
 
         LOG_UNSUPPORTED(TRUE);
 
1039
         LOG_UNSUPPORTED(true);
1040
1040
      }
1041
1041
      break;
1042
1042
 
1128
1128
   }
1129
1129
}
1130
1130
 
1131
 
static boolean
 
1131
static bool
1132
1132
operand_is_scalar(const struct Shader_src_operand *operand)
1133
1133
{
1134
1134
   return operand->swizzle[0] == operand->swizzle[1] &&
1247
1247
   struct Shader_opcode opcode;
1248
1248
   const struct tgsi_token *tokens = NULL;
1249
1249
   uint nr_tokens;
1250
 
   boolean shader_dumped = FALSE;
1251
 
   boolean inside_sub = FALSE;
 
1250
   bool shader_dumped = false;
 
1251
   bool inside_sub = false;
1252
1252
   uint i, j;
1253
1253
 
1254
1254
   memset(&sx, 0, sizeof sx);
1257
1257
 
1258
1258
   if (st_debug & ST_DEBUG_TGSI) {
1259
1259
      dx10_shader_dump_tokens(code);
1260
 
      shader_dumped = TRUE;
 
1260
      shader_dumped = true;
1261
1261
   }
1262
1262
 
1263
1263
   sx.max_calls = 64;
1873
1873
         case D3D10_SB_PRIMITIVE_TOPOLOGY_POINTLIST:
1874
1874
            ureg_property(sx.ureg,
1875
1875
                          TGSI_PROPERTY_GS_OUTPUT_PRIM,
1876
 
                          PIPE_PRIM_POINTS);
 
1876
                          MESA_PRIM_POINTS);
1877
1877
            break;
1878
1878
 
1879
1879
         case D3D10_SB_PRIMITIVE_TOPOLOGY_LINESTRIP:
1880
1880
            ureg_property(sx.ureg,
1881
1881
                          TGSI_PROPERTY_GS_OUTPUT_PRIM,
1882
 
                          PIPE_PRIM_LINE_STRIP);
 
1882
                          MESA_PRIM_LINE_STRIP);
1883
1883
            break;
1884
1884
 
1885
1885
         case D3D10_SB_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP:
1886
1886
            ureg_property(sx.ureg,
1887
1887
                          TGSI_PROPERTY_GS_OUTPUT_PRIM,
1888
 
                          PIPE_PRIM_TRIANGLE_STRIP);
 
1888
                          MESA_PRIM_TRIANGLE_STRIP);
1889
1889
            break;
1890
1890
 
1891
1891
         default:
1903
1903
            declare_vertices_in(&sx, 1);
1904
1904
            ureg_property(sx.ureg,
1905
1905
                          TGSI_PROPERTY_GS_INPUT_PRIM,
1906
 
                          PIPE_PRIM_POINTS);
 
1906
                          MESA_PRIM_POINTS);
1907
1907
            break;
1908
1908
 
1909
1909
         case D3D10_SB_PRIMITIVE_LINE:
1910
1910
            declare_vertices_in(&sx, 2);
1911
1911
            ureg_property(sx.ureg,
1912
1912
                          TGSI_PROPERTY_GS_INPUT_PRIM,
1913
 
                          PIPE_PRIM_LINES);
 
1913
                          MESA_PRIM_LINES);
1914
1914
            break;
1915
1915
 
1916
1916
         case D3D10_SB_PRIMITIVE_TRIANGLE:
1917
1917
            declare_vertices_in(&sx, 3);
1918
1918
            ureg_property(sx.ureg,
1919
1919
                          TGSI_PROPERTY_GS_INPUT_PRIM,
1920
 
                          PIPE_PRIM_TRIANGLES);
 
1920
                          MESA_PRIM_TRIANGLES);
1921
1921
            break;
1922
1922
 
1923
1923
         case D3D10_SB_PRIMITIVE_LINE_ADJ:
1924
1924
            declare_vertices_in(&sx, 4);
1925
1925
            ureg_property(sx.ureg,
1926
1926
                          TGSI_PROPERTY_GS_INPUT_PRIM,
1927
 
                          PIPE_PRIM_LINES_ADJACENCY);
 
1927
                          MESA_PRIM_LINES_ADJACENCY);
1928
1928
            break;
1929
1929
 
1930
1930
         case D3D10_SB_PRIMITIVE_TRIANGLE_ADJ:
1931
1931
            declare_vertices_in(&sx, 6);
1932
1932
            ureg_property(sx.ureg,
1933
1933
                          TGSI_PROPERTY_GS_INPUT_PRIM,
1934
 
                          PIPE_PRIM_TRIANGLES_ADJACENCY);
 
1934
                          MESA_PRIM_TRIANGLES_ADJACENCY);
1935
1935
            break;
1936
1936
 
1937
1937
         default:
2197
2197
         }
2198
2198
         tgsi_inst_no = ureg_get_instruction_number(ureg);
2199
2199
         ureg_BGNSUB(ureg);
2200
 
         inside_sub = TRUE;
 
2200
         inside_sub = true;
2201
2201
         Shader_add_label(&sx, label, tgsi_inst_no);
2202
2202
      }
2203
2203
         break;
2233
2233
            if (ox->tgsi_opcode == TGSI_LOG_UNSUPPORTED) {
2234
2234
               if (!shader_dumped) {
2235
2235
                  dx10_shader_dump_tokens(code);
2236
 
                  shader_dumped = TRUE;
 
2236
                  shader_dumped = true;
2237
2237
               }
2238
2238
               debug_printf("%s: unsupported opcode %i\n",
2239
2239
                            __func__, ox->type);