microsoft
/
DirectXShaderCompiler
зеркало из https://github.com/microsoft/DirectXShaderCompiler.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

[lit][SPIRV] convert runFileTest shaders to lit FileCheck test (154 left to go) (#6051) 

Convert from bottom of CodeGenSpirvTest.cpp
Skipped FileTest::CompatibilityWithVk1p1 as barrier for runCodeTest.
This commit is contained in:
Xiang Li 2023-11-22 05:36:20 -05:00 коммит произвёл GitHub
Родитель 3861c5eef7
Коммит 773fed3060
Не найден ключ, соответствующий данной подписи
Идентификатор ключа GPG: 4AEE18F83AFDEB23
81 изменённых файлов: 2204 добавлений и 2312 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

103
tools/clang/test/CodeGenSPIRV/cast.2bool.explicit.hlsl
Просмотреть файл

@ -1,103 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
// CHECK: [[v2uint_0_0:%\d+]] = OpConstantComposite %v2uint %uint_0 %uint_0
// CHECK: [[v3float_0_0_0:%\d+]] = OpConstantComposite %v3float %float_0 %float_0 %float_0
// CHECK: [[v2bool_1_1:%\d+]] = OpConstantComposite %v2bool %true %true
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
bool b;
int from1;
uint from2;
float from3;
bool1 vb1;
bool2 vb2;
bool3 vb3;
int1 vfrom1;
uint2 vfrom2;
float3 vfrom3;
// C style cast
// From constant (explicit)
// CHECK: OpStore %b %true
b = (bool)35;
// CHECK-NEXT: OpStore %b %false
b = (bool)0.0;
// From constant expr
// CHECK-NEXT: OpStore %b %true
b = (bool)(3.5 - 3.4);
// From variable (explicit)
// CHECK-NEXT: [[from1:%\d+]] = OpLoad %int %from1
// CHECK-NEXT: [[c1:%\d+]] = OpINotEqual %bool [[from1]] %int_0
// CHECK-NEXT: OpStore %b [[c1]]
b = (bool)from1;
// CHECK-NEXT: [[from2:%\d+]] = OpLoad %uint %from2
// CHECK-NEXT: [[c2:%\d+]] = OpINotEqual %bool [[from2]] %uint_0
// CHECK-NEXT: OpStore %b [[c2]]
b = (bool)from2;
// CHECK-NEXT: [[from3:%\d+]] = OpLoad %float %from3
// CHECK-NEXT: [[c3:%\d+]] = OpFOrdNotEqual %bool [[from3]] %float_0
// CHECK-NEXT: OpStore %b [[c3]]
b = (bool)from3;
// C++ function style cast
// CHECK-NEXT: OpStore %b %false
b = bool(0);
// CHECK-NEXT: OpStore %b %true
b = bool(3.5);
// CHECK-NEXT: OpStore %b %true
b = bool(42 + 1);
// CHECK-NEXT: [[from4:%\d+]] = OpLoad %int %from1
// CHECK-NEXT: [[c4:%\d+]] = OpINotEqual %bool [[from4]] %int_0
// CHECK-NEXT: OpStore %b [[c4]]
b = bool(from1);
// CHECK-NEXT: [[from5:%\d+]] = OpLoad %uint %from2
// CHECK-NEXT: [[c5:%\d+]] = OpINotEqual %bool [[from5]] %uint_0
// CHECK-NEXT: OpStore %b [[c5]]
b = bool(from2);
// CHECK-NEXT: [[from6:%\d+]] = OpLoad %float %from3
// CHECK-NEXT: [[c6:%\d+]] = OpFOrdNotEqual %bool [[from6]] %float_0
// CHECK-NEXT: OpStore %b [[c6]]
b = bool(from3);
// Vector cases
// CHECK-NEXT: OpStore %vb1 %true
vb1 = (bool1)42;
// CHECK-NEXT: [[vfrom1:%\d+]] = OpLoad %int %vfrom1
// CHECK-NEXT: [[vc1:%\d+]] = OpINotEqual %bool [[vfrom1]] %int_0
// CHECK-NEXT: OpStore %vb1 [[vc1]]
vb1 = (bool1)vfrom1;
// CHECK-NEXT: [[vfrom2:%\d+]] = OpLoad %v2uint %vfrom2
// CHECK-NEXT: [[vc2:%\d+]] = OpINotEqual %v2bool [[vfrom2]] [[v2uint_0_0]]
// CHECK-NEXT: OpStore %vb2 [[vc2]]
vb2 = (bool2)vfrom2;
// CHECK-NEXT: [[vfrom3:%\d+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc3:%\d+]] = OpFOrdNotEqual %v3bool [[vfrom3]] [[v3float_0_0_0]]
// CHECK-NEXT: OpStore %vb3 [[vc3]]
vb3 = (bool3)vfrom3;
// CHECK-NEXT: OpStore %vb1 %true
vb1 = bool1(3.5);
// CHECK-NEXT: OpStore %vb2 [[v2bool_1_1]]
vb2 = bool2(1.1 + 1.2, 3.0);
// CHECK-NEXT: [[vfrom4:%\d+]] = OpLoad %int %vfrom1
// CHECK-NEXT: [[vc4:%\d+]] = OpINotEqual %bool [[vfrom4]] %int_0
// CHECK-NEXT: OpStore %vb1 [[vc4]]
vb1 = bool1(vfrom1);
// CHECK-NEXT: [[vfrom5:%\d+]] = OpLoad %v2uint %vfrom2
// CHECK-NEXT: [[vc5:%\d+]] = OpINotEqual %v2bool [[vfrom5]] [[v2uint_0_0]]
// CHECK-NEXT: OpStore %vb2 [[vc5]]
vb2 = bool2(vfrom2);
// CHECK-NEXT: [[vfrom6:%\d+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc6:%\d+]] = OpFOrdNotEqual %v3bool [[vfrom6]] [[v3float_0_0_0]]
// CHECK-NEXT: OpStore %vb3 [[vc6]]
vb3 = bool3(vfrom3);
}

96
tools/clang/test/CodeGenSPIRV/cast.2bool.implicit.hlsl
Просмотреть файл

@ -1,96 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
// CHECK: [[v2bool_1_0:%\d+]] = OpConstantComposite %v2bool %true %false
// CHECK: [[v3bool_0_1_1:%\d+]] = OpConstantComposite %v3bool %false %true %true
// CHECK: [[v2uint_0_0:%\d+]] = OpConstantComposite %v2uint %uint_0 %uint_0
// CHECK: [[v3float_0_0_0:%\d+]] = OpConstantComposite %v3float %float_0 %float_0 %float_0
// CHECK: [[v3i0:%\d+]] = OpConstantComposite %v3int %int_0 %int_0 %int_0
// CHECK: [[v3u0:%\d+]] = OpConstantComposite %v3uint %uint_0 %uint_0 %uint_0
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
bool b;
int from1;
uint from2;
float from3;
bool1 vb1;
bool2 vb2;
bool3 vb3;
int1 vfrom1;
uint2 vfrom2;
float3 vfrom3;
// From constant (implicit)
// CHECK: OpStore %b %true
b = 42;
// CHECK-NEXT: OpStore %b %false
b = 0.0;
// From constant expr
// CHECK-NEXT: OpStore %b %false
b = 35 - 35;
// From variable (implicit)
// CHECK-NEXT: [[from1:%\d+]] = OpLoad %int %from1
// CHECK-NEXT: [[c1:%\d+]] = OpINotEqual %bool [[from1]] %int_0
// CHECK-NEXT: OpStore %b [[c1]]
b = from1;
// CHECK-NEXT: [[from2:%\d+]] = OpLoad %uint %from2
// CHECK-NEXT: [[c2:%\d+]] = OpINotEqual %bool [[from2]] %uint_0
// CHECK-NEXT: OpStore %b [[c2]]
b = from2;
// CHECK-NEXT: [[from3:%\d+]] = OpLoad %float %from3
// CHECK-NEXT: [[c3:%\d+]] = OpFOrdNotEqual %bool [[from3]] %float_0
// CHECK-NEXT: OpStore %b [[c3]]
b = from3;
// Vector cases
// CHECK: OpStore %vbc2 [[v2bool_1_0]]
// CHECK: OpStore %vbc3 [[v3bool_0_1_1]]
bool2 vbc2 = {1, 15 - 15};
bool3 vbc3 = {0.0, 1.2 + 1.1, 3}; // Mixed
// CHECK-NEXT: [[vfrom1:%\d+]] = OpLoad %int %vfrom1
// CHECK-NEXT: [[vc1:%\d+]] = OpINotEqual %bool [[vfrom1]] %int_0
// CHECK-NEXT: OpStore %vb1 [[vc1]]
vb1 = vfrom1;
// CHECK-NEXT: [[vfrom2:%\d+]] = OpLoad %v2uint %vfrom2
// CHECK-NEXT: [[vc2:%\d+]] = OpINotEqual %v2bool [[vfrom2]] [[v2uint_0_0]]
// CHECK-NEXT: OpStore %vb2 [[vc2]]
vb2 = vfrom2;
// CHECK-NEXT: [[vfrom3:%\d+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc3:%\d+]] = OpFOrdNotEqual %v3bool [[vfrom3]] [[v3float_0_0_0]]
// CHECK-NEXT: OpStore %vb3 [[vc3]]
vb3 = vfrom3;
float2x3 floatMat;
int2x3 intMat;
uint2x3 uintMat;
bool2x3 boolMat;
// CHECK: [[floatMat:%\d+]] = OpLoad %mat2v3float %floatMat
// CHECK-NEXT: [[floatMat0:%\d+]] = OpCompositeExtract %v3float [[floatMat]] 0
// CHECK-NEXT: [[boolMat0:%\d+]] = OpFOrdNotEqual %v3bool [[floatMat0]] [[v3float_0_0_0]]
// CHECK-NEXT: [[floatMat1:%\d+]] = OpCompositeExtract %v3float [[floatMat]] 1
// CHECK-NEXT: [[boolMat1:%\d+]] = OpFOrdNotEqual %v3bool [[floatMat1]] [[v3float_0_0_0]]
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %_arr_v3bool_uint_2 [[boolMat0]] [[boolMat1]]
boolMat = floatMat;
// CHECK: [[intMat:%\d+]] = OpLoad %_arr_v3int_uint_2 %intMat
// CHECK-NEXT: [[intMat0:%\d+]] = OpCompositeExtract %v3int [[intMat]] 0
// CHECK-NEXT: [[boolMat0:%\d+]] = OpINotEqual %v3bool [[intMat0]] [[v3i0]]
// CHECK-NEXT: [[intMat1:%\d+]] = OpCompositeExtract %v3int [[intMat]] 1
// CHECK-NEXT: [[boolMat1:%\d+]] = OpINotEqual %v3bool [[intMat1]] [[v3i0]]
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %_arr_v3bool_uint_2 [[boolMat0]] [[boolMat1]]
boolMat = intMat;
// CHECK: [[uintMat:%\d+]] = OpLoad %_arr_v3uint_uint_2 %uintMat
// CHECK-NEXT: [[uintMat0:%\d+]] = OpCompositeExtract %v3uint [[uintMat]] 0
// CHECK-NEXT: [[boolMat0:%\d+]] = OpINotEqual %v3bool [[uintMat0]] [[v3u0]]
// CHECK-NEXT: [[uintMat1:%\d+]] = OpCompositeExtract %v3uint [[uintMat]] 1
// CHECK-NEXT: [[boolMat1:%\d+]] = OpINotEqual %v3bool [[uintMat1]] [[v3u0]]
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %_arr_v3bool_uint_2 [[boolMat0]] [[boolMat1]]
boolMat = uintMat;
}

104
tools/clang/test/CodeGenSPIRV/cast.2fp.explicit.hlsl
Просмотреть файл

@ -1,104 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
// CHECK: [[v2float_1_1:%\d+]] = OpConstantComposite %v2float %float_1 %float_1
// CHECK: [[v2float_0_0:%\d+]] = OpConstantComposite %v2float %float_0 %float_0
// CHECK: [[v3float_1_2_n3:%\d+]] = OpConstantComposite %v3float %float_1 %float_2 %float_n3
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
float f;
uint from1;
bool from2;
int from3;
float1 vf1;
float2 vf2;
float3 vf3;
uint1 vfrom1;
bool2 vfrom2;
int3 vfrom3;
// C style cast
// From constant (explicit)
// CHECK: OpStore %f %float_1
f = (float)true;
// CHECK-NEXT: OpStore %f %float_4
f = (float)4u;
// From constant expr
// CHECK-NEXT: OpStore %f %float_n2
f = (float)(3 - 5);
// From variable (explicit)
// CHECK-NEXT: [[from1:%\d+]] = OpLoad %uint %from1
// CHECK-NEXT: [[c1:%\d+]] = OpConvertUToF %float [[from1]]
// CHECK-NEXT: OpStore %f [[c1]]
f = (float)from1;
// CHECK-NEXT: [[from2:%\d+]] = OpLoad %bool %from2
// CHECK-NEXT: [[c2:%\d+]] = OpSelect %float [[from2]] %float_1 %float_0
// CHECK-NEXT: OpStore %f [[c2]]
f = (float)from2;
// CHECK-NEXT: [[from3:%\d+]] = OpLoad %int %from3
// CHECK-NEXT: [[c3:%\d+]] = OpConvertSToF %float [[from3]]
// CHECK-NEXT: OpStore %f [[c3]]
f = (float)from3;
// C++ function style cast
// CHECK-NEXT: OpStore %f %float_0
f = float(false);
// CHECK-NEXT: OpStore %f %float_2
f = float(2u);
// CHECK-NEXT: OpStore %f %float_3
f = float(-1 + 4);
// CHECK-NEXT: [[from4:%\d+]] = OpLoad %uint %from1
// CHECK-NEXT: [[c4:%\d+]] = OpConvertUToF %float [[from4]]
// CHECK-NEXT: OpStore %f [[c4]]
f = float(from1);
// CHECK-NEXT: [[from5:%\d+]] = OpLoad %bool %from2
// CHECK-NEXT: [[c5:%\d+]] = OpSelect %float [[from5]] %float_1 %float_0
// CHECK-NEXT: OpStore %f [[c5]]
f = float(from2);
// CHECK-NEXT: [[from6:%\d+]] = OpLoad %int %from3
// CHECK-NEXT: [[c6:%\d+]] = OpConvertSToF %float [[from6]]
// CHECK-NEXT: OpStore %f [[c6]]
f = float(from3);
// Vector cases
// CHECK-NEXT: OpStore %vf1 %float_7
vf1 = (float1)7;
// CHECK-NEXT: [[vfrom1:%\d+]] = OpLoad %uint %vfrom1
// CHECK-NEXT: [[vc1:%\d+]] = OpConvertUToF %float [[vfrom1]]
// CHECK-NEXT: OpStore %vf1 [[vc1]]
vf1 = (float1)vfrom1;
// CHECK-NEXT: [[vfrom2:%\d+]] = OpLoad %v2bool %vfrom2
// CHECK-NEXT: [[vc2:%\d+]] = OpSelect %v2float [[vfrom2]] [[v2float_1_1]] [[v2float_0_0]]
// CHECK-NEXT: OpStore %vf2 [[vc2]]
vf2 = (float2)vfrom2;
// CHECK-NEXT: [[vfrom3:%\d+]] = OpLoad %v3int %vfrom3
// CHECK-NEXT: [[vc3:%\d+]] = OpConvertSToF %v3float [[vfrom3]]
// CHECK-NEXT: OpStore %vf3 [[vc3]]
vf3 = (float3)vfrom3;
// CHECK-NEXT: OpStore %vf1 %float_3
vf1 = float1(3);
// CHECK-NEXT: OpStore %vf3 [[v3float_1_2_n3]]
vf3 = float3(true, 2u, -3);
// CHECK-NEXT: [[vfrom4:%\d+]] = OpLoad %uint %vfrom1
// CHECK-NEXT: [[vc4:%\d+]] = OpConvertUToF %float [[vfrom4]]
// CHECK-NEXT: OpStore %vf1 [[vc4]]
vf1 = float1(vfrom1);
// CHECK-NEXT: [[vfrom5:%\d+]] = OpLoad %v2bool %vfrom2
// CHECK-NEXT: [[vc5:%\d+]] = OpSelect %v2float [[vfrom5]] [[v2float_1_1]] [[v2float_0_0]]
// CHECK-NEXT: OpStore %vf2 [[vc5]]
vf2 = float2(vfrom2);
// CHECK-NEXT: [[vfrom6:%\d+]] = OpLoad %v3int %vfrom3
// CHECK-NEXT: [[vc6:%\d+]] = OpConvertSToF %v3float [[vfrom6]]
// CHECK-NEXT: OpStore %vf3 [[vc6]]
vf3 = float3(vfrom3);
}

99
tools/clang/test/CodeGenSPIRV/cast.2fp.implicit.hlsl
Просмотреть файл

@ -1,99 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
// CHECK: [[v2float_1_0:%\d+]] = OpConstantComposite %v2float %float_1 %float_0
// CHECK: [[v3float_0_4_n3:%\d+]] = OpConstantComposite %v3float %float_0 %float_4 %float_n3
// CHECK: [[v3f1:%\d+]] = OpConstantComposite %v3float %float_1 %float_1 %float_1
// CHECK: [[v3f0:%\d+]] = OpConstantComposite %v3float %float_0 %float_0 %float_0
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
float f;
bool from1;
uint from2;
int from3;
float1 vf1;
float2 vf2;
float3 vf3;
bool1 vfrom1;
uint2 vfrom2;
int3 vfrom3;
// From constant (implicit)
// CHECK: OpStore %f %float_1
f = true;
// CHECK-NEXT: OpStore %f %float_3
f = 3u;
// From constant expr
// CHECK-NEXT: OpStore %f %float_n1
f = 5 - 6;
// From variable (implicit)
// CHECK-NEXT: [[from1:%\d+]] = OpLoad %bool %from1
// CHECK-NEXT: [[c1:%\d+]] = OpSelect %float [[from1]] %float_1 %float_0
// CHECK-NEXT: OpStore %f [[c1]]
f = from1;
// CHECK-NEXT: [[from2:%\d+]] = OpLoad %uint %from2
// CHECK-NEXT: [[c2:%\d+]] = OpConvertUToF %float [[from2]]
// CHECK-NEXT: OpStore %f [[c2]]
f = from2;
// CHECK-NEXT: [[from3:%\d+]] = OpLoad %int %from3
// CHECK-NEXT: [[c3:%\d+]] = OpConvertSToF %float [[from3]]
// CHECK-NEXT: OpStore %f [[c3]]
f = from3;
// Vector cases
// CHECK: OpStore %vfc2 [[v2float_1_0]]
// CHECK: OpStore %vfc3 [[v3float_0_4_n3]]
float2 vfc2 = {true, false};
float3 vfc3 = {false, 4u, -3}; // Mixed
// CHECK-NEXT: [[vfrom1:%\d+]] = OpLoad %bool %vfrom1
// CHECK-NEXT: [[vc1:%\d+]] = OpSelect %float [[vfrom1]] %float_1 %float_0
// CHECK-NEXT: OpStore %vf1 [[vc1]]
vf1 = vfrom1;
// CHECK-NEXT: [[vfrom2:%\d+]] = OpLoad %v2uint %vfrom2
// CHECK-NEXT: [[vc2:%\d+]] = OpConvertUToF %v2float [[vfrom2]]
// CHECK-NEXT: OpStore %vf2 [[vc2]]
vf2 = vfrom2;
// CHECK-NEXT: [[vfrom3:%\d+]] = OpLoad %v3int %vfrom3
// CHECK-NEXT: [[vc3:%\d+]] = OpConvertSToF %v3float [[vfrom3]]
// CHECK-NEXT: OpStore %vf3 [[vc3]]
vf3 = vfrom3;
// CHECK: [[a:%\d+]] = OpLoad %bool %a
// CHECK-NEXT: [[int_a:%\d+]] = OpSelect %int [[a]] %int_1 %int_0
// CHECK-NEXT: [[zero_minus_a:%\d+]] = OpISub %int %int_0 [[int_a]]
// CHECK-NEXT: {{%\d+}} = OpConvertSToF %float [[zero_minus_a]]
bool a = false;
float c = 0-a;
int2x3 intMat;
float2x3 floatMat;
uint2x3 uintMat;
bool2x3 boolMat;
// CHECK: [[boolMat:%\d+]] = OpLoad %_arr_v3bool_uint_2 %boolMat
// CHECK-NEXT: [[boolMat0:%\d+]] = OpCompositeExtract %v3bool [[boolMat]] 0
// CHECK-NEXT: [[floatMat0:%\d+]] = OpSelect %v3float [[boolMat0]] [[v3f1]] [[v3f0]]
// CHECK-NEXT: [[boolMat1:%\d+]] = OpCompositeExtract %v3bool [[boolMat]] 1
// CHECK-NEXT: [[floatMat1:%\d+]] = OpSelect %v3float [[boolMat1]] [[v3f1]] [[v3f0]]
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %mat2v3float [[floatMat0]] [[floatMat1]]
floatMat = boolMat;
// CHECK: [[uintMat:%\d+]] = OpLoad %_arr_v3uint_uint_2 %uintMat
// CHECK-NEXT: [[uintMat0:%\d+]] = OpCompositeExtract %v3uint [[uintMat]] 0
// CHECK-NEXT: [[floatMat0:%\d+]] = OpConvertUToF %v3float [[uintMat0]]
// CHECK-NEXT: [[uintMat1:%\d+]] = OpCompositeExtract %v3uint [[uintMat]] 1
// CHECK-NEXT: [[floatMat1:%\d+]] = OpConvertUToF %v3float [[uintMat1]]
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %mat2v3float [[floatMat0]] [[floatMat1]]
floatMat = uintMat;
// CHECK: [[intMat:%\d+]] = OpLoad %_arr_v3int_uint_2 %intMat
// CHECK-NEXT: [[intMat0:%\d+]] = OpCompositeExtract %v3int [[intMat]] 0
// CHECK-NEXT: [[floatMat0:%\d+]] = OpConvertSToF %v3float [[intMat0]]
// CHECK-NEXT: [[intMat1:%\d+]] = OpCompositeExtract %v3int [[intMat]] 1
// CHECK-NEXT: [[floatMat1:%\d+]] = OpConvertSToF %v3float [[intMat1]]
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %mat2v3float [[floatMat0]] [[floatMat1]]
floatMat = intMat;
}

19
tools/clang/test/CodeGenSPIRV/cast.2literal-int.implicit.hlsl
Просмотреть файл

@ -1,19 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
void main() {
int a, b;
// CHECK: [[a:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[b:%\d+]] = OpLoad %int %b
// CHECK-NEXT: [[eq:%\d+]] = OpIEqual %bool [[a]] [[b]]
// CHECK-NEXT: [[c_int:%\d+]] = OpSelect %int [[eq]] %int_1 %int_0
// CHECK-NEXT: {{%\d+}} = OpINotEqual %bool [[c_int]] %int_1
bool c = (a == b) != 1;
// CHECK: [[a:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[b:%\d+]] = OpLoad %int %b
// CHECK-NEXT: [[eq:%\d+]] = OpIEqual %bool [[a]] [[b]]
// CHECK-NEXT: [[d_float:%\d+]] = OpSelect %float [[eq]] %float_1 %float_0
// CHECK-NEXT: {{%\d+}} = OpFOrdNotEqual %bool [[d_float]] %float_1
bool d = (a == b) != 1.0;
}

103
tools/clang/test/CodeGenSPIRV/cast.2sint.explicit.hlsl
Просмотреть файл

@ -1,103 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
// CHECK: [[v2int_1_1:%\d+]] = OpConstantComposite %v2int %int_1 %int_1
// CHECK: [[v2int_0_0:%\d+]] = OpConstantComposite %v2int %int_0 %int_0
// CHECK: [[v2int_2_n3:%\d+]] = OpConstantComposite %v2int %int_2 %int_n3
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
int i;
uint from1;
bool from2;
float from3;
int1 vi1;
int2 vi2;
int3 vi3;
uint1 vfrom1;
bool2 vfrom2;
float3 vfrom3;
// C style cast
// From constant (explicit)
// CHECK: OpStore %i %int_1
i = (int)true;
// CHECK-NEXT: OpStore %i %int_3
i = (int)3.0;
// From constant expr
// CHECK-NEXT: OpStore %i %int_n2
i = (int)(3.4 - 5.5);
// From variable (explicit)
// CHECK-NEXT: [[from1:%\d+]] = OpLoad %uint %from1
// CHECK-NEXT: [[c1:%\d+]] = OpBitcast %int [[from1]]
// CHECK-NEXT: OpStore %i [[c1]]
i = (int)from1;
// CHECK-NEXT: [[from2:%\d+]] = OpLoad %bool %from2
// CHECK-NEXT: [[c2:%\d+]] = OpSelect %int [[from2]] %int_1 %int_0
// CHECK-NEXT: OpStore %i [[c2]]
i = (int)from2;
// CHECK-NEXT: [[from3:%\d+]] = OpLoad %float %from3
// CHECK-NEXT: [[c3:%\d+]] = OpConvertFToS %int [[from3]]
// CHECK-NEXT: OpStore %i [[c3]]
i = (int)from3;
// C++ function style cast
// CHECK-NEXT: OpStore %i %int_0
i = int(false);
// CHECK-NEXT: OpStore %i %int_3
i = int(3.5);
// CHECK-NEXT: OpStore %i %int_5
i = int(3.3 + 2.2);
// CHECK-NEXT: [[from4:%\d+]] = OpLoad %uint %from1
// CHECK-NEXT: [[c4:%\d+]] = OpBitcast %int [[from4]]
// CHECK-NEXT: OpStore %i [[c4]]
i = int(from1);
// CHECK-NEXT: [[from5:%\d+]] = OpLoad %bool %from2
// CHECK-NEXT: [[c5:%\d+]] = OpSelect %int [[from5]] %int_1 %int_0
// CHECK-NEXT: OpStore %i [[c5]]
i = int(from2);
// CHECK-NEXT: [[from6:%\d+]] = OpLoad %float %from3
// CHECK-NEXT: [[c6:%\d+]] = OpConvertFToS %int [[from6]]
// CHECK-NEXT: OpStore %i [[c6]]
i = int(from3);
// Vector cases
// CHECK-NEXT: OpStore %vi1 %int_3
vi1 = (int1)3.6;
// CHECK-NEXT: [[vfrom1:%\d+]] = OpLoad %uint %vfrom1
// CHECK-NEXT: [[vc1:%\d+]] = OpBitcast %int [[vfrom1]]
// CHECK-NEXT: OpStore %vi1 [[vc1]]
vi1 = (int1)vfrom1;
// CHECK-NEXT: [[vfrom2:%\d+]] = OpLoad %v2bool %vfrom2
// CHECK-NEXT: [[vc2:%\d+]] = OpSelect %v2int [[vfrom2]] [[v2int_1_1]] [[v2int_0_0]]
// CHECK-NEXT: OpStore %vi2 [[vc2]]
vi2 = (int2)vfrom2;
// CHECK-NEXT: [[vfrom3:%\d+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc3:%\d+]] = OpConvertFToS %v3int [[vfrom3]]
// CHECK-NEXT: OpStore %vi3 [[vc3]]
vi3 = (int3)vfrom3;
// CHECK-NEXT: OpStore %vi1 %int_3
vi1 = int1(3.5);
// CHECK-NEXT: OpStore %vi2 [[v2int_2_n3]]
vi2 = int2(1.1 + 1.2, -3);
// CHECK-NEXT: [[vfrom4:%\d+]] = OpLoad %uint %vfrom1
// CHECK-NEXT: [[vc4:%\d+]] = OpBitcast %int [[vfrom4]]
// CHECK-NEXT: OpStore %vi1 [[vc4]]
vi1 = int1(vfrom1);
// CHECK-NEXT: [[vfrom5:%\d+]] = OpLoad %v2bool %vfrom2
// CHECK-NEXT: [[vc5:%\d+]] = OpSelect %v2int [[vfrom5]] [[v2int_1_1]] [[v2int_0_0]]
// CHECK-NEXT: OpStore %vi2 [[vc5]]
vi2 = int2(vfrom2);
// CHECK-NEXT: [[vfrom6:%\d+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc6:%\d+]] = OpConvertFToS %v3int [[vfrom6]]
// CHECK-NEXT: OpStore %vi3 [[vc6]]
vi3 = int3(vfrom3);
}

92
tools/clang/test/CodeGenSPIRV/cast.2sint.implicit.hlsl
Просмотреть файл

@ -1,92 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
// CHECK: [[v2int_1_0:%\d+]] = OpConstantComposite %v2int %int_1 %int_0
// CHECK: [[v3int_0_2_n3:%\d+]] = OpConstantComposite %v3int %int_0 %int_2 %int_n3
// CHECK: [[v3i1:%\d+]] = OpConstantComposite %v3int %int_1 %int_1 %int_1
// CHECK: [[v3i0:%\d+]] = OpConstantComposite %v3int %int_0 %int_0 %int_0
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
int i;
bool from1;
uint from2;
float from3;
int1 vi1;
int2 vi2;
int3 vi3;
bool1 vfrom1;
uint2 vfrom2;
float3 vfrom3;
// From constant (implicit)
// CHECK: OpStore %i %int_1
i = true;
// CHECK-NEXT: OpStore %i %int_0
i = 0.0;
// From constant expr
// CHECK-NEXT: OpStore %i %int_n3
i = 1.1 - 4.3;
// From variable (implicit)
// CHECK-NEXT: [[from1:%\d+]] = OpLoad %bool %from1
// CHECK-NEXT: [[c1:%\d+]] = OpSelect %int [[from1]] %int_1 %int_0
// CHECK-NEXT: OpStore %i [[c1]]
i = from1;
// CHECK-NEXT: [[from2:%\d+]] = OpLoad %uint %from2
// CHECK-NEXT: [[c2:%\d+]] = OpBitcast %int [[from2]]
// CHECK-NEXT: OpStore %i [[c2]]
i = from2;
// CHECK-NEXT: [[from3:%\d+]] = OpLoad %float %from3
// CHECK-NEXT: [[c3:%\d+]] = OpConvertFToS %int [[from3]]
// CHECK-NEXT: OpStore %i [[c3]]
i = from3;
// Vector cases
// CHECK: OpStore %vic2 [[v2int_1_0]]
// CHECK: OpStore %vic3 [[v3int_0_2_n3]]
int2 vic2 = {true, false};
int3 vic3 = {false, 1.1 + 1.2, -3}; // Mixed
// CHECK-NEXT: [[vfrom1:%\d+]] = OpLoad %bool %vfrom1
// CHECK-NEXT: [[vc1:%\d+]] = OpSelect %int [[vfrom1]] %int_1 %int_0
// CHECK-NEXT: OpStore %vi1 [[vc1]]
vi1 = vfrom1;
// CHECK-NEXT: [[vfrom2:%\d+]] = OpLoad %v2uint %vfrom2
// CHECK-NEXT: [[vc2:%\d+]] = OpBitcast %v2int [[vfrom2]]
// CHECK-NEXT: OpStore %vi2 [[vc2]]
vi2 = vfrom2;
// CHECK-NEXT: [[vfrom3:%\d+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc3:%\d+]] = OpConvertFToS %v3int [[vfrom3]]
// CHECK-NEXT: OpStore %vi3 [[vc3]]
vi3 = vfrom3;
int2x3 intMat;
float2x3 floatMat;
uint2x3 uintMat;
bool2x3 boolMat;
// CHECK: [[boolMat:%\d+]] = OpLoad %_arr_v3bool_uint_2 %boolMat
// CHECK-NEXT: [[boolMat0:%\d+]] = OpCompositeExtract %v3bool [[boolMat]] 0
// CHECK-NEXT: [[intMat0:%\d+]] = OpSelect %v3int [[boolMat0]] [[v3i1]] [[v3i0]]
// CHECK-NEXT: [[boolMat1:%\d+]] = OpCompositeExtract %v3bool [[boolMat]] 1
// CHECK-NEXT: [[intMat1:%\d+]] = OpSelect %v3int [[boolMat1]] [[v3i1]] [[v3i0]]
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %_arr_v3int_uint_2 [[intMat0]] [[intMat1]]
intMat = boolMat;
// CHECK: [[uintMat:%\d+]] = OpLoad %_arr_v3uint_uint_2 %uintMat
// CHECK-NEXT: [[uintMat0:%\d+]] = OpCompositeExtract %v3uint [[uintMat]] 0
// CHECK-NEXT: [[intMat0:%\d+]] = OpBitcast %v3int [[uintMat0]]
// CHECK-NEXT: [[uintMat1:%\d+]] = OpCompositeExtract %v3uint [[uintMat]] 1
// CHECK-NEXT: [[intMat1:%\d+]] = OpBitcast %v3int [[uintMat1]]
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %_arr_v3int_uint_2 [[intMat0]] [[intMat1]]
intMat = uintMat;
// CHECK: [[floatMat:%\d+]] = OpLoad %mat2v3float %floatMat
// CHECK-NEXT: [[floatMat0:%\d+]] = OpCompositeExtract %v3float [[floatMat]] 0
// CHECK-NEXT: [[intMat0:%\d+]] = OpConvertFToS %v3int [[floatMat0]]
// CHECK-NEXT: [[floatMat1:%\d+]] = OpCompositeExtract %v3float [[floatMat]] 1
// CHECK-NEXT: [[intMat1:%\d+]] = OpConvertFToS %v3int [[floatMat1]]
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %_arr_v3int_uint_2 [[intMat0]] [[intMat1]]
intMat = floatMat;
}

104
tools/clang/test/CodeGenSPIRV/cast.2uint.explicit.hlsl
Просмотреть файл

@ -1,104 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
// CHECK: [[v2uint_1_1:%\d+]] = OpConstantComposite %v2uint %uint_1 %uint_1
// CHECK: [[v2uint_0_0:%\d+]] = OpConstantComposite %v2uint %uint_0 %uint_0
// CHECK: [[v2uint_2_3:%\d+]] = OpConstantComposite %v2uint %uint_2 %uint_3
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
uint i;
int from1;
bool from2;
float from3;
uint1 vi1;
uint2 vi2;
uint3 vi3;
int1 vfrom1;
bool2 vfrom2;
float3 vfrom3;
// C style cast
// From constant (explicit)
// CHECK: OpStore %i %uint_1
i = (uint)true;
// CHECK-NEXT: OpStore %i %uint_3
i = (uint)3.0;
// From constant expr
// CHECK-NEXT: OpStore %i %uint_2
i = (uint)(5.5 - 3.4);
// From variable (explicit)
// CHECK-NEXT: [[from1:%\d+]] = OpLoad %int %from1
// CHECK-NEXT: [[c1:%\d+]] = OpBitcast %uint [[from1]]
// CHECK-NEXT: OpStore %i [[c1]]
i = (uint)from1;
// CHECK-NEXT: [[from2:%\d+]] = OpLoad %bool %from2
// CHECK-NEXT: [[c2:%\d+]] = OpSelect %uint [[from2]] %uint_1 %uint_0
// CHECK-NEXT: OpStore %i [[c2]]
i = (uint)from2;
// CHECK-NEXT: [[from3:%\d+]] = OpLoad %float %from3
// CHECK-NEXT: [[c3:%\d+]] = OpConvertFToU %uint [[from3]]
// CHECK-NEXT: OpStore %i [[c3]]
i = (uint)from3;
// C++ function style cast
// CHECK-NEXT: OpStore %i %uint_0
i = uint(false);
// CHECK-NEXT: OpStore %i %uint_3
i = uint(3.5);
// CHECK-NEXT: OpStore %i %uint_5
i = uint(3.3 + 2.2);
// CHECK-NEXT: [[from4:%\d+]] = OpLoad %int %from1
// CHECK-NEXT: [[c4:%\d+]] = OpBitcast %uint [[from4]]
// CHECK-NEXT: OpStore %i [[c4]]
i = uint(from1);
// CHECK-NEXT: [[from5:%\d+]] = OpLoad %bool %from2
// CHECK-NEXT: [[c5:%\d+]] = OpSelect %uint [[from5]] %uint_1 %uint_0
// CHECK-NEXT: OpStore %i [[c5]]
i = uint(from2);
// CHECK-NEXT: [[from6:%\d+]] = OpLoad %float %from3
// CHECK-NEXT: [[c6:%\d+]] = OpConvertFToU %uint [[from6]]
// CHECK-NEXT: OpStore %i [[c6]]
i = uint(from3);
// Vector cases
// CHECK-NEXT: OpStore %vi1 %uint_3
vi1 = (uint1)3.6;
// CHECK-NEXT: [[vfrom1:%\d+]] = OpLoad %int %vfrom1
// CHECK-NEXT: [[vc1:%\d+]] = OpBitcast %uint [[vfrom1]]
// CHECK-NEXT: OpStore %vi1 [[vc1]]
vi1 = (uint1)vfrom1;
// CHECK-NEXT: [[vfrom2:%\d+]] = OpLoad %v2bool %vfrom2
// CHECK-NEXT: [[vc2:%\d+]] = OpSelect %v2uint [[vfrom2]] [[v2uint_1_1]] [[v2uint_0_0]]
// CHECK-NEXT: OpStore %vi2 [[vc2]]
vi2 = (uint2)vfrom2;
// CHECK-NEXT: [[vfrom3:%\d+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc3:%\d+]] = OpConvertFToU %v3uint [[vfrom3]]
// CHECK-NEXT: OpStore %vi3 [[vc3]]
vi3 = (uint3)vfrom3;
// CHECK-NEXT: OpStore %vi1 %uint_3
vi1 = uint1(3.5);
// CHECK-NEXT: OpStore %vi2 [[v2uint_2_3]]
vi2 = uint2(1.1 + 1.2, 3);
// CHECK-NEXT: [[vfrom4:%\d+]] = OpLoad %int %vfrom1
// CHECK-NEXT: [[vc4:%\d+]] = OpBitcast %uint [[vfrom4]]
// CHECK-NEXT: OpStore %vi1 [[vc4]]
vi1 = uint1(vfrom1);
// CHECK-NEXT: [[vfrom5:%\d+]] = OpLoad %v2bool %vfrom2
// CHECK-NEXT: [[vc5:%\d+]] = OpSelect %v2uint [[vfrom5]] [[v2uint_1_1]] [[v2uint_0_0]]
// CHECK-NEXT: OpStore %vi2 [[vc5]]
vi2 = uint2(vfrom2);
// CHECK-NEXT: [[vfrom6:%\d+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc6:%\d+]] = OpConvertFToU %v3uint [[vfrom6]]
// CHECK-NEXT: OpStore %vi3 [[vc6]]
vi3 = uint3(vfrom3);
}

92
tools/clang/test/CodeGenSPIRV/cast.2uint.implicit.hlsl
Просмотреть файл

@ -1,92 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
// CHECK: [[v2uint_1_0:%\d+]] = OpConstantComposite %v2uint %uint_1 %uint_0
// CHECK: [[v3uint_0_2_3:%\d+]] = OpConstantComposite %v3uint %uint_0 %uint_2 %uint_3
// CHECK: [[v3u1:%\d+]] = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1
// CHECK: [[v3u0:%\d+]] = OpConstantComposite %v3uint %uint_0 %uint_0 %uint_0
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
uint i;
bool from1;
int from2;
float from3;
uint1 vi1;
uint2 vi2;
uint3 vi3;
bool1 vfrom1;
int2 vfrom2;
float3 vfrom3;
// From constant (implicit)
// CHECK: OpStore %i %uint_1
i = true;
// CHECK-NEXT: OpStore %i %uint_0
i = 0.0;
// From constant expr
// CHECK-NEXT: OpStore %i %uint_3
i = 4.3 - 1.1;
// From variable (implicit)
// CHECK-NEXT: [[from1:%\d+]] = OpLoad %bool %from1
// CHECK-NEXT: [[c1:%\d+]] = OpSelect %uint [[from1]] %uint_1 %uint_0
// CHECK-NEXT: OpStore %i [[c1]]
i = from1;
// CHECK-NEXT: [[from2:%\d+]] = OpLoad %int %from2
// CHECK-NEXT: [[c2:%\d+]] = OpBitcast %uint [[from2]]
// CHECK-NEXT: OpStore %i [[c2]]
i = from2;
// CHECK-NEXT: [[from3:%\d+]] = OpLoad %float %from3
// CHECK-NEXT: [[c3:%\d+]] = OpConvertFToU %uint [[from3]]
// CHECK-NEXT: OpStore %i [[c3]]
i = from3;
// Vector cases
// CHECK: OpStore %vic2 [[v2uint_1_0]]
// CHECK: OpStore %vic3 [[v3uint_0_2_3]]
uint2 vic2 = {true, false};
uint3 vic3 = {false, 1.1 + 1.2, 3}; // Mixed
// CHECK-NEXT: [[vfrom1:%\d+]] = OpLoad %bool %vfrom1
// CHECK-NEXT: [[vc1:%\d+]] = OpSelect %uint [[vfrom1]] %uint_1 %uint_0
// CHECK-NEXT: OpStore %vi1 [[vc1]]
vi1 = vfrom1;
// CHECK-NEXT: [[vfrom2:%\d+]] = OpLoad %v2int %vfrom2
// CHECK-NEXT: [[vc2:%\d+]] = OpBitcast %v2uint [[vfrom2]]
// CHECK-NEXT: OpStore %vi2 [[vc2]]
vi2 = vfrom2;
// CHECK-NEXT: [[vfrom3:%\d+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc3:%\d+]] = OpConvertFToU %v3uint [[vfrom3]]
// CHECK-NEXT: OpStore %vi3 [[vc3]]
vi3 = vfrom3;
int2x3 intMat;
float2x3 floatMat;
uint2x3 uintMat;
bool2x3 boolMat;
// CHECK: [[boolMat:%\d+]] = OpLoad %_arr_v3bool_uint_2 %boolMat
// CHECK-NEXT: [[boolMat0:%\d+]] = OpCompositeExtract %v3bool [[boolMat]] 0
// CHECK-NEXT: [[uintMat0:%\d+]] = OpSelect %v3uint [[boolMat0]] [[v3u1]] [[v3u0]]
// CHECK-NEXT: [[boolMat1:%\d+]] = OpCompositeExtract %v3bool [[boolMat]] 1
// CHECK-NEXT: [[uintMat1:%\d+]] = OpSelect %v3uint [[boolMat1]] [[v3u1]] [[v3u0]]
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %_arr_v3uint_uint_2 [[uintMat0]] [[uintMat1]]
uintMat = boolMat;
// CHECK: [[intMat:%\d+]] = OpLoad %_arr_v3int_uint_2 %intMat
// CHECK-NEXT: [[intMat0:%\d+]] = OpCompositeExtract %v3int [[intMat]] 0
// CHECK-NEXT: [[uintMat0:%\d+]] = OpBitcast %v3uint [[intMat0]]
// CHECK-NEXT: [[intMat1:%\d+]] = OpCompositeExtract %v3int [[intMat]] 1
// CHECK-NEXT: [[uintMat1:%\d+]] = OpBitcast %v3uint [[intMat1]]
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %_arr_v3uint_uint_2 [[uintMat0]] [[uintMat1]]
uintMat = intMat;
// CHECK: [[floatMat:%\d+]] = OpLoad %mat2v3float %floatMat
// CHECK-NEXT: [[floatMat0:%\d+]] = OpCompositeExtract %v3float [[floatMat]] 0
// CHECK-NEXT: [[uintMat0:%\d+]] = OpConvertFToU %v3uint [[floatMat0]]
// CHECK-NEXT: [[floatMat1:%\d+]] = OpCompositeExtract %v3float [[floatMat]] 1
// CHECK-NEXT: [[uintMat1:%\d+]] = OpConvertFToU %v3uint [[floatMat1]]
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %_arr_v3uint_uint_2 [[uintMat0]] [[uintMat1]]
uintMat = floatMat;
}

165
tools/clang/test/CodeGenSPIRV/cast.bitwidth.hlsl
Просмотреть файл

@ -1,165 +0,0 @@
// RUN: %dxc -T ps_6_2 -E main -enable-16bit-types
void main() {
// 32-bit uint to various 64-bit types.
uint a;
// CHECK: [[a:%\d+]] = OpLoad %uint %a
// CHECK-NEXT: [[a_ulong:%\d+]] = OpUConvert %ulong [[a]]
// CHECK-NEXT: OpStore %b [[a_ulong]]
uint64_t b = a;
// CHECK: [[a:%\d+]] = OpLoad %uint %a
// CHECK-NEXT: [[a_ulong:%\d+]] = OpUConvert %ulong [[a]]
// CHECK-NEXT:[[a_double:%\d+]] = OpConvertUToF %double [[a_ulong]]
// CHECK-NEXT: OpStore %c [[a_double]]
double c = a;
// CHECK: [[a:%\d+]] = OpLoad %uint %a
// CHECK-NEXT: [[a_ulong:%\d+]] = OpUConvert %ulong [[a]]
// CHECK-NEXT: [[a_long:%\d+]] = OpBitcast %long [[a_ulong]]
// CHECK-NEXT: OpStore %d [[a_long]]
int64_t d = a;
// 32-bit int to various 64-bit types.
int aa;
// CHECK: [[aa:%\d+]] = OpLoad %int %aa
// CHECK-NEXT: [[aa_long:%\d+]] = OpSConvert %long [[aa]]
// CHECK-NEXT: [[aa_ulong:%\d+]] = OpBitcast %ulong [[aa_long]]
// CHECK-NEXT: OpStore %bb [[aa_ulong]]
uint64_t bb = aa;
// CHECK: [[aa:%\d+]] = OpLoad %int %aa
// CHECK-NEXT: [[aa_long:%\d+]] = OpSConvert %long [[aa]]
// CHECK-NEXT: [[aa_double:%\d+]] = OpConvertSToF %double [[aa_long]]
// CHECK-NEXT: OpStore %cc [[aa_double]]
double cc = aa;
// CHECK: [[aa:%\d+]] = OpLoad %int %aa
// CHECK-NEXT: [[aa_long:%\d+]] = OpSConvert %long [[aa]]
// CHECK-NEXT: OpStore %dd [[aa_long]]
int64_t dd = aa;
// 32-bit float to various 64-bit types.
float aaa;
// CHECK: [[aaa:%\d+]] = OpLoad %float %aaa
// CHECK-NEXT: [[aaa_double:%\d+]] = OpFConvert %double [[aaa]]
// CHECK-NEXT: [[aaa_ulong:%\d+]] = OpConvertFToU %ulong [[aaa_double]]
// CHECK-NEXT: OpStore %bbb [[aaa_ulong]]
uint64_t bbb = aaa;
// CHECK: [[aaa:%\d+]] = OpLoad %float %aaa
// CHECK-NEXT: [[aaa_double:%\d+]] = OpFConvert %double [[aaa]]
// CHECK-NEXT: OpStore %ccc [[aaa_double]]
double ccc = aaa;
// CHECK: [[aaa:%\d+]] = OpLoad %float %aaa
// CHECK-NEXT: [[aaa_double:%\d+]] = OpFConvert %double [[aaa]]
// CHECK-NEXT: [[aaa_long:%\d+]] = OpConvertFToS %long [[aaa_double]]
// CHECK-NEXT: OpStore %ddd [[aaa_long]]
int64_t ddd = aaa;
// 64-bit uint to various 32-bit types.
uint64_t e;
// CHECK: [[e64:%\d+]] = OpLoad %ulong %e
// CHECK-NEXT: [[e32:%\d+]] = OpUConvert %uint [[e64]]
// CHECK-NEXT: OpStore %f [[e32]]
uint f = e;
// CHECK: [[e64:%\d+]] = OpLoad %ulong %e
// CHECK-NEXT: [[e32:%\d+]] = OpUConvert %uint [[e64]]
// CHECK-NEXT: [[e_float:%\d+]] = OpConvertUToF %float [[e32]]
// CHECK-NEXT: OpStore %g [[e_float]]
float g = e;
// CHECK: [[e64:%\d+]] = OpLoad %ulong %e
// CHECK-NEXT: [[e32:%\d+]] = OpUConvert %uint [[e64]]
// CHECK-NEXT: [[e_int:%\d+]] = OpBitcast %int [[e32]]
// CHECK-NEXT: OpStore %h [[e_int]]
int h = e;
// 64-bit int to various 32-bit types.
int64_t ee;
// CHECK: [[e:%\d+]] = OpLoad %long %ee
// CHECK-NEXT: [[e_int:%\d+]] = OpSConvert %int [[e]]
// CHECK-NEXT: [[e_uint:%\d+]] = OpBitcast %uint [[e_int]]
// CHECK-NEXT: OpStore %ff [[e_uint]]
uint ff = ee;
// CHECK: [[e:%\d+]] = OpLoad %long %ee
// CHECK-NEXT: [[e_int:%\d+]] = OpSConvert %int [[e]]
// CHECK-NEXT: [[e_float:%\d+]] = OpConvertSToF %float [[e_int]]
// CHECK-NEXT: OpStore %gg [[e_float]]
float gg = ee;
// CHECK: [[e:%\d+]] = OpLoad %long %ee
// CHECK-NEXT: [[e_int:%\d+]] = OpSConvert %int [[e]]
// CHECK-NEXT: OpStore %hh [[e_int]]
int hh = ee;
// 64-bit float to various 32-bit types.
double eee;
// CHECK: [[e64:%\d+]] = OpLoad %double %eee
// CHECK-NEXT: [[e32:%\d+]] = OpFConvert %float [[e64]]
// CHECK-NEXT: [[e_uint:%\d+]] = OpConvertFToU %uint [[e32]]
// CHECK-NEXT: OpStore %fff [[e_uint]]
uint fff = eee;
// CHECK: [[e:%\d+]] = OpLoad %double %eee
// CHECK-NEXT: [[e_float:%\d+]] = OpFConvert %float [[e]]
// CHECK-NEXT: OpStore %ggg [[e_float]]
float ggg = eee;
// CHECK: [[e:%\d+]] = OpLoad %double %eee
// CHECK-NEXT: [[e_float:%\d+]] = OpFConvert %float [[e]]
// CHECK-NEXT: [[e_int:%\d+]] = OpConvertFToS %int [[e_float]]
// CHECK-NEXT: OpStore %hhh [[e_int]]
int hhh = eee;
// Vector case: 64-bit float to various 32-bit types.
double2 i;
// CHECK: [[i_double:%\d+]] = OpLoad %v2double %i
// CHECK-NEXT: [[i_float:%\d+]] = OpFConvert %v2float [[i_double]]
// CHECK-NEXT: [[i_uint:%\d+]] = OpConvertFToU %v2uint [[i_float]]
// CHECK-NEXT: OpStore %j [[i_uint]]
uint2 j = i;
// CHECK: [[i_double:%\d+]] = OpLoad %v2double %i
// CHECK-NEXT: [[i_float:%\d+]] = OpFConvert %v2float [[i_double]]
// CHECK-NEXT: [[i_int:%\d+]] = OpConvertFToS %v2int [[i_float]]
// CHECK-NEXT: OpStore %k [[i_int]]
int2 k = i;
// CHECK: [[i_double:%\d+]] = OpLoad %v2double %i
// CHECK-NEXT: [[i_float:%\d+]] = OpFConvert %v2float [[i_double]]
// CHECK-NEXT: OpStore %l [[i_float]]
float2 l = i;
// 16-bit uint to various 32-bit types.
uint16_t m;
// CHECK: [[m_ushort:%\d+]] = OpLoad %ushort %m
// CHECK-NEXT: [[m_uint:%\d+]] = OpUConvert %uint [[m_ushort]]
// CHECK-NEXT: OpStore %n [[m_uint]]
uint n = m;
// CHECK: [[m_ushort:%\d+]] = OpLoad %ushort %m
// CHECK-NEXT: [[m_uint:%\d+]] = OpUConvert %uint [[m_ushort]]
// CHECK-NEXT: [[m_float:%\d+]] = OpConvertUToF %float [[m_uint]]
// CHECK-NEXT: OpStore %o [[m_float]]
float o = m;
// CHECK: [[m_ushort:%\d+]] = OpLoad %ushort %m
// CHECK-NEXT: [[m_uint:%\d+]] = OpUConvert %uint [[m_ushort]]
// CHECK-NEXT: [[m_int:%\d+]] = OpBitcast %int [[m_uint]]
// CHECK-NEXT: OpStore %p [[m_int]]
int p = m;
// 16-bit int to various 32-bit types.
int16_t mm;
// CHECK: [[mm_short:%\d+]] = OpLoad %short %mm
// CHECK-NEXT: [[mm_int:%\d+]] = OpSConvert %int [[mm_short]]
// CHECK-NEXT: [[mm_uint:%\d+]] = OpBitcast %uint [[mm_int]]
// CHECK-NEXT: OpStore %nn [[mm_uint]]
uint nn = mm;
// CHECK: [[mm_short:%\d+]] = OpLoad %short %mm
// CHECK-NEXT: [[mm_int:%\d+]] = OpSConvert %int [[mm_short]]
// CHECK-NEXT: [[mm_float:%\d+]] = OpConvertSToF %float [[mm_int]]
// CHECK-NEXT: OpStore %oo [[mm_float]]
float oo = mm;
// CHECK: [[mm_short:%\d+]] = OpLoad %short %mm
// CHECK-NEXT: [[mm_int:%\d+]] = OpSConvert %int [[mm_short]]
// CHECK-NEXT: OpStore %pp [[mm_int]]
int pp = mm;
}

105
tools/clang/test/CodeGenSPIRV/cast.flat-conversion.array-to-vector.hlsl
Просмотреть файл

@ -1,105 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
typedef int A[2];
ConsumeStructuredBuffer<A> intarr_consume;
A getA() {
A a = intarr_consume.Consume();
return a;
}
typedef float B[2];
ConsumeStructuredBuffer<B> floatarr_consume;
B getB() {
B b = floatarr_consume.Consume();
return b;
}
typedef bool C[2];
ConsumeStructuredBuffer<C> boolarr_consume;
C getC() {
C c = boolarr_consume.Consume();
return c;
}
void main() {
// CHECK: [[call_0:%\d+]] = OpFunctionCall %_arr_int_uint_2_0 %getA
// CHECK-NEXT: [[i_0_0:%\d+]] = OpCompositeExtract %int [[call_0]] 0
// CHECK-NEXT: [[i_0_1:%\d+]] = OpCompositeExtract %int [[call_0]] 1
// CHECK-NEXT: [[vi_0:%\d+]] = OpCompositeConstruct %v2int [[i_0_0]] [[i_0_1]]
// CHECK-NEXT: OpStore %intarray_to_intvec [[vi_0]]
int2 intarray_to_intvec = (int2)getA();
// CHECK: [[call_1:%\d+]] = OpFunctionCall %_arr_float_uint_2_0 %getB
// CHECK-NEXT: [[f_1_0:%\d+]] = OpCompositeExtract %float [[call_1]] 0
// CHECK-NEXT: [[f_1_1:%\d+]] = OpCompositeExtract %float [[call_1]] 1
// CHECK-NEXT: [[vf_1:%\d+]] = OpCompositeConstruct %v2float [[f_1_0]] [[f_1_1]]
// CHECK-NEXT: OpStore %floatarray_to_floatvec [[vf_1]]
float2 floatarray_to_floatvec = (float2)getB();
// CHECK: [[call_2:%\d+]] = OpFunctionCall %_arr_bool_uint_2 %getC
// CHECK-NEXT: [[b_2_0:%\d+]] = OpCompositeExtract %bool [[call_2]] 0
// CHECK-NEXT: [[b_2_1:%\d+]] = OpCompositeExtract %bool [[call_2]] 1
// CHECK-NEXT: [[vb_2:%\d+]] = OpCompositeConstruct %v2bool [[b_2_0]] [[b_2_1]]
// CHECK-NEXT: OpStore %boolarray_to_boolvec [[vb_2]]
bool2 boolarray_to_boolvec = (bool2)getC();
// CHECK: [[call_3:%\d+]] = OpFunctionCall %_arr_float_uint_2_0 %getB
// CHECK-NEXT: [[f_3_0:%\d+]] = OpCompositeExtract %float [[call_3]] 0
// CHECK-NEXT: [[f_3_1:%\d+]] = OpCompositeExtract %float [[call_3]] 1
// CHECK-NEXT: [[i_3_0:%\d+]] = OpConvertFToS %int [[f_3_0]]
// CHECK-NEXT: [[i_3_1:%\d+]] = OpConvertFToS %int [[f_3_1]]
// CHECK-NEXT: [[vi_3:%\d+]] = OpCompositeConstruct %v2int [[i_3_0]] [[i_3_1]]
// CHECK-NEXT: OpStore %floatarray_to_intvec [[vi_3]]
int2 floatarray_to_intvec = (int2)getB();
// CHECK: [[call_4:%\d+]] = OpFunctionCall %_arr_bool_uint_2 %getC
// CHECK-NEXT: [[b_4_0:%\d+]] = OpCompositeExtract %bool [[call_4]] 0
// CHECK-NEXT: [[b_4_1:%\d+]] = OpCompositeExtract %bool [[call_4]] 1
// CHECK-NEXT: [[i_4_0:%\d+]] = OpSelect %int [[b_4_0]] %int_1 %int_0
// CHECK-NEXT: [[i_4_1:%\d+]] = OpSelect %int [[b_4_1]] %int_1 %int_0
// CHECK-NEXT: [[vi_4:%\d+]] = OpCompositeConstruct %v2int [[i_4_0]] [[i_4_1]]
// CHECK-NEXT: OpStore %boolarray_to_intvec [[vi_4]]
int2 boolarray_to_intvec = (int2)getC();
// CHECK: [[call_5:%\d+]] = OpFunctionCall %_arr_int_uint_2_0 %getA
// CHECK-NEXT: [[i_5_0:%\d+]] = OpCompositeExtract %int [[call_5]] 0
// CHECK-NEXT: [[i_5_1:%\d+]] = OpCompositeExtract %int [[call_5]] 1
// CHECK-NEXT: [[f_5_0:%\d+]] = OpConvertSToF %float [[i_5_0]]
// CHECK-NEXT: [[f_5_1:%\d+]] = OpConvertSToF %float [[i_5_1]]
// CHECK-NEXT: [[vf_5:%\d+]] = OpCompositeConstruct %v2float [[f_5_0]] [[f_5_1]]
// CHECK-NEXT: OpStore %intarray_to_floatvec [[vf_5]]
float2 intarray_to_floatvec = (float2)getA();
// CHECK: [[call_6:%\d+]] = OpFunctionCall %_arr_bool_uint_2 %getC
// CHECK-NEXT: [[b_6_0:%\d+]] = OpCompositeExtract %bool [[call_6]] 0
// CHECK-NEXT: [[b_6_1:%\d+]] = OpCompositeExtract %bool [[call_6]] 1
// CHECK-NEXT: [[f_6_0:%\d+]] = OpSelect %float [[b_6_0]] %float_1 %float_0
// CHECK-NEXT: [[f_6_1:%\d+]] = OpSelect %float [[b_6_1]] %float_1 %float_0
// CHECK-NEXT: [[vf_6:%\d+]] = OpCompositeConstruct %v2float [[f_6_0]] [[f_6_1]]
// CHECK-NEXT: OpStore %boolarray_to_floatvec [[vf_6]]
float2 boolarray_to_floatvec = (float2)getC();
// CHECK: [[call_7:%\d+]] = OpFunctionCall %_arr_int_uint_2_0 %getA
// CHECK-NEXT: [[i_7_0:%\d+]] = OpCompositeExtract %int [[call_7]] 0
// CHECK-NEXT: [[i_7_1:%\d+]] = OpCompositeExtract %int [[call_7]] 1
// CHECK-NEXT: [[b_7_0:%\d+]] = OpINotEqual %bool [[i_7_0]] %int_0
// CHECK-NEXT: [[b_7_1:%\d+]] = OpINotEqual %bool [[i_7_1]] %int_0
// CHECK-NEXT: [[vb_7:%\d+]] = OpCompositeConstruct %v2bool [[b_7_0]] [[b_7_1]]
// CHECK-NEXT: OpStore %intarray_to_boolvec [[vb_7]]
bool2 intarray_to_boolvec = (bool2)getA();
// CHECK: [[call_8:%\d+]] = OpFunctionCall %_arr_float_uint_2_0 %getB
// CHECK-NEXT: [[f_8_0:%\d+]] = OpCompositeExtract %float [[call_8]] 0
// CHECK-NEXT: [[f_8_1:%\d+]] = OpCompositeExtract %float [[call_8]] 1
// CHECK-NEXT: [[b_8_0:%\d+]] = OpFOrdNotEqual %bool [[f_8_0]] %float_0
// CHECK-NEXT: [[b_8_1:%\d+]] = OpFOrdNotEqual %bool [[f_8_1]] %float_0
// CHECK-NEXT: [[vb_8:%\d+]] = OpCompositeConstruct %v2bool [[b_8_0]] [[b_8_1]]
// CHECK-NEXT: OpStore %floatarray_to_boolvec [[vb_8]]
bool2 floatarray_to_boolvec = (bool2)getB();
}

19
tools/clang/test/CodeGenSPIRV/cast.flat-conversion.decl-ref.hlsl
Просмотреть файл

@ -1,19 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
struct A {
float a;
uint b;
float GetA() { return a; }
};
ConstantBuffer<A> foo : register(b0, space2);
void main(out float4 col : SV_Target0) {
// CHECK: [[foo:%\d+]] = OpLoad %type_ConstantBuffer_A %foo
// CHECK: [[foo_a:%\d+]] = OpCompositeExtract %float [[foo]] 0
// CHECK: [[foo_b:%\d+]] = OpCompositeExtract %uint [[foo]] 1
// CHECK: [[foo_rvalue:%\d+]] = OpCompositeConstruct %A [[foo_a]] [[foo_b]]
// CHECK: OpStore %temp_var_A [[foo_rvalue]]
// CHECK: OpFunctionCall %float %A_GetA %temp_var_A
col.x = foo.GetA();
}

109
tools/clang/test/CodeGenSPIRV/cast.flat-conversion.implicit.hlsl
Просмотреть файл

@ -1,109 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
struct VSOutput {
float4 sv_pos : SV_POSITION;
uint3 normal : NORMAL;
int2 tex_coord : TEXCOORD;
bool mybool[2] : MYBOOL;
int arr[5] : MYARRAY;
float2x3 mat2x3 : MYMATRIX;
int2x3 intmat : MYINTMATRIX;
bool2x3 boolmat : MYBOOLMATRIX;
};
// CHECK: [[nullVSOutput:%\d+]] = OpConstantNull %VSOutput
void main() {
int x = 3;
// CHECK: OpStore %output1 [[nullVSOutput]]
VSOutput output1 = (VSOutput)0;
// CHECK: OpStore %output2 [[nullVSOutput]]
VSOutput output2 = (VSOutput)0.0;
// CHECK: OpStore %output3 [[nullVSOutput]]
VSOutput output3 = (VSOutput)false;
// CHECK: [[f1:%\d+]] = OpConvertSToF %float %int_1
// CHECK-NEXT: [[v4f1:%\d+]] = OpCompositeConstruct %v4float [[f1]] [[f1]] [[f1]] [[f1]]
// CHECK-NEXT: [[u1:%\d+]] = OpBitcast %uint %int_1
// CHECK-NEXT: [[v3u1:%\d+]] = OpCompositeConstruct %v3uint [[u1]] [[u1]] [[u1]]
// CHECK-NEXT: [[v2i1:%\d+]] = OpCompositeConstruct %v2int %int_1 %int_1
// CHECK-NEXT: [[bool1:%\d+]] = OpINotEqual %bool %int_1 %int_0
// CHECK-NEXT: [[arr2bool1:%\d+]] = OpCompositeConstruct %_arr_bool_uint_2 [[bool1]] [[bool1]]
// CHECK-NEXT: [[arr5i1:%\d+]] = OpCompositeConstruct %_arr_int_uint_5 %int_1 %int_1 %int_1 %int_1 %int_1
// CHECK-NEXT: [[f1_1:%\d+]] = OpConvertSToF %float %int_1
// CHECK-NEXT: [[col3:%\d+]] = OpCompositeConstruct %v3float [[f1_1]] [[f1_1]] [[f1_1]]
// CHECK-NEXT: [[matFloat1:%\d+]] = OpCompositeConstruct %mat2v3float [[col3]] [[col3]]
// CHECK-NEXT: [[v3i1:%\d+]] = OpCompositeConstruct %v3int %int_1 %int_1 %int_1
// CHECK-NEXT: [[intmat:%\d+]] = OpCompositeConstruct %_arr_v3int_uint_2 [[v3i1]] [[v3i1]]
// CHECK-NEXT: [[true:%\d+]] = OpINotEqual %bool %int_1 %int_0
// CHECK-NEXT: [[boolvec:%\d+]] = OpCompositeConstruct %v3bool [[true]] [[true]] [[true]]
// CHECK-NEXT: [[boolmat:%\d+]] = OpCompositeConstruct %_arr_v3bool_uint_2 [[boolvec]] [[boolvec]]
// CHECK-NEXT: [[flatConvert1:%\d+]] = OpCompositeConstruct %VSOutput [[v4f1]] [[v3u1]] [[v2i1]] [[arr2bool1]] [[arr5i1]] [[matFloat1]] [[intmat]] [[boolmat]]
// CHECK-NEXT: OpStore %output4 [[flatConvert1]]
VSOutput output4 = (VSOutput)1;
// CHECK: [[x:%\d+]] = OpLoad %int %x
// CHECK-NEXT: [[floatX:%\d+]] = OpConvertSToF %float [[x]]
// CHECK-NEXT: [[v4fX:%\d+]] = OpCompositeConstruct %v4float [[floatX]] [[floatX]] [[floatX]] [[floatX]]
// CHECK-NEXT: [[uintX:%\d+]] = OpBitcast %uint [[x]]
// CHECK-NEXT: [[v3uX:%\d+]] = OpCompositeConstruct %v3uint [[uintX]] [[uintX]] [[uintX]]
// CHECK-NEXT: [[v2iX:%\d+]] = OpCompositeConstruct %v2int [[x]] [[x]]
// CHECK-NEXT: [[boolX:%\d+]] = OpINotEqual %bool [[x]] %int_0
// CHECK-NEXT: [[arr2boolX:%\d+]] = OpCompositeConstruct %_arr_bool_uint_2 [[boolX]] [[boolX]]
// CHECK-NEXT: [[arr5iX:%\d+]] = OpCompositeConstruct %_arr_int_uint_5 [[x]] [[x]] [[x]] [[x]] [[x]]
// CHECK-NEXT: [[floatX2:%\d+]] = OpConvertSToF %float [[x]]
// CHECK-NEXT: [[v3fX:%\d+]] = OpCompositeConstruct %v3float [[floatX2]] [[floatX2]] [[floatX2]]
// CHECK-NEXT: [[matFloatX:%\d+]] = OpCompositeConstruct %mat2v3float [[v3fX]] [[v3fX]]
// CHECK-NEXT: [[intvec:%\d+]] = OpCompositeConstruct %v3int [[x]] [[x]] [[x]]
// CHECK-NEXT: [[intmat:%\d+]] = OpCompositeConstruct %_arr_v3int_uint_2 [[intvec]] [[intvec]]
// CHECK-NEXT: [[boolx:%\d+]] = OpINotEqual %bool [[x]] %int_0
// CHECK-NEXT: [[boolvec:%\d+]] = OpCompositeConstruct %v3bool [[boolx]] [[boolx]] [[boolx]]
// CHECK-NEXT: [[boolmat:%\d+]] = OpCompositeConstruct %_arr_v3bool_uint_2 [[boolvec]] [[boolvec]]
// CHECK-NEXT: [[flatConvert2:%\d+]] = OpCompositeConstruct %VSOutput [[v4fX]] [[v3uX]] [[v2iX]] [[arr2boolX]] [[arr5iX]] [[matFloatX]] [[intmat]] [[boolmat]]
// CHECK-NEXT: OpStore %output5 [[flatConvert2]]
VSOutput output5 = (VSOutput)x;
// CHECK: [[v4f1_5:%\d+]] = OpCompositeConstruct %v4float %float_1_5 %float_1_5 %float_1_5 %float_1_5
// CHECK-NEXT: [[u1_5:%\d+]] = OpConvertFToU %uint %float_1_5
// CHECK-NEXT: [[v3u1_5:%\d+]] = OpCompositeConstruct %v3uint [[u1_5]] [[u1_5]] [[u1_5]]
// CHECK-NEXT: [[i1_5:%\d+]] = OpConvertFToS %int %float_1_5
// CHECK-NEXT: [[v2i1_5:%\d+]] = OpCompositeConstruct %v2int [[i1_5]] [[i1_5]]
// CHECK-NEXT: [[bool1_5:%\d+]] = OpFOrdNotEqual %bool %float_1_5 %float_0
// CHECK-NEXT: [[arr2bool_1_5:%\d+]] = OpCompositeConstruct %_arr_bool_uint_2 [[bool1_5]] [[bool1_5]]
// CHECK-NEXT: [[i1_5:%\d+]] = OpConvertFToS %int %float_1_5
// CHECK-NEXT: [[arr5i1_5:%\d+]] = OpCompositeConstruct %_arr_int_uint_5 [[i1_5]] [[i1_5]] [[i1_5]] [[i1_5]] [[i1_5]]
// CHECK-NEXT: [[v3f_1_5:%\d+]] = OpCompositeConstruct %v3float %float_1_5 %float_1_5 %float_1_5
// CHECK-NEXT: [[matFloat_1_5:%\d+]] = OpCompositeConstruct %mat2v3float [[v3f_1_5]] [[v3f_1_5]]
// CHECK-NEXT: [[int_1_5:%\d+]] = OpConvertFToS %int %float_1_5
// CHECK-NEXT: [[intvec:%\d+]] = OpCompositeConstruct %v3int [[int_1_5]] [[int_1_5]] [[int_1_5]]
// CHECK-NEXT: [[intmat:%\d+]] = OpCompositeConstruct %_arr_v3int_uint_2 [[intvec]] [[intvec]]
// CHECK-NEXT: [[bool_1_5:%\d+]] = OpFOrdNotEqual %bool %float_1_5 %float_0
// CHECK-NEXT: [[boolvec:%\d+]] = OpCompositeConstruct %v3bool [[bool_1_5]] [[bool_1_5]] [[bool_1_5]]
// CHECK-NEXT: [[boolmat:%\d+]] = OpCompositeConstruct %_arr_v3bool_uint_2 [[boolvec]] [[boolvec]]
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %VSOutput [[v4f1_5]] [[v3u1_5]] [[v2i1_5]] [[arr2bool_1_5]] [[arr5i1_5]] [[matFloat_1_5]] [[intmat]] [[boolmat]]
VSOutput output6 = (VSOutput)1.5;
// CHECK: [[float_true:%\d+]] = OpSelect %float %true %float_1 %float_0
// CHECK-NEXT: [[v4f_true:%\d+]] = OpCompositeConstruct %v4float [[float_true]] [[float_true]] [[float_true]] [[float_true]]
// CHECK-NEXT: [[uint_true:%\d+]] = OpSelect %uint %true %uint_1 %uint_0
// CHECK-NEXT: [[v3u_true:%\d+]] = OpCompositeConstruct %v3uint [[uint_true]] [[uint_true]] [[uint_true]]
// CHECK-NEXT: [[int_true:%\d+]] = OpSelect %int %true %int_1 %int_0
// CHECK-NEXT: [[v2i_true:%\d+]] = OpCompositeConstruct %v2int [[int_true]] [[int_true]]
// CHECK-NEXT: [[arr2_true:%\d+]] = OpCompositeConstruct %_arr_bool_uint_2 %true %true
// CHECK-NEXT: [[int_true:%\d+]] = OpSelect %int %true %int_1 %int_0
// CHECK-NEXT: [[arr5i_true:%\d+]] = OpCompositeConstruct %_arr_int_uint_5 [[int_true]] [[int_true]] [[int_true]] [[int_true]] [[int_true]]
// CHECK-NEXT: [[float_true:%\d+]] = OpSelect %float %true %float_1 %float_0
// CHECK-NEXT: [[v3f_true:%\d+]] = OpCompositeConstruct %v3float [[float_true]] [[float_true]] [[float_true]]
// CHECK-NEXT:[[mat2v3_true:%\d+]] = OpCompositeConstruct %mat2v3float [[v3f_true]] [[v3f_true]]
// CHECK-NEXT: [[true_int:%\d+]] = OpSelect %int %true %int_1 %int_0
// CHECK-NEXT: [[intvec:%\d+]] = OpCompositeConstruct %v3int [[true_int]] [[true_int]] [[true_int]]
// CHECK-NEXT: [[intmat:%\d+]] = OpCompositeConstruct %_arr_v3int_uint_2 [[intvec]] [[intvec]]
// CHECK-NEXT: [[boolvec:%\d+]] = OpCompositeConstruct %v3bool %true %true %true
// CHECK-NEXT: [[boolmat:%\d+]] = OpCompositeConstruct %_arr_v3bool_uint_2 [[boolvec]] [[boolvec]]
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %VSOutput [[v4f_true]] [[v3u_true]] [[v2i_true]] [[arr2_true]] [[arr5i_true]] [[mat2v3_true]] [[intmat]] [[boolmat]]
VSOutput output7 = (VSOutput)true;
}

50
tools/clang/test/CodeGenSPIRV/cast.flat-conversion.literal-initializer.hlsl
Просмотреть файл

@ -1,50 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
struct S {
float2 a;
float b;
double2 c;
double d;
int64_t e;
uint64_t f;
};
void main() {
// CHECK: [[inf:%\d+]] = OpFDiv %float %float_1 %float_0
// CHECK-NEXT: [[inf2:%\d+]] = OpCompositeConstruct %v2float [[inf]] [[inf]]
// CHECK-NEXT: [[inf_double:%\d+]] = OpFConvert %double [[inf]]
// CHECK-NEXT: [[inf2_double:%\d+]] = OpCompositeConstruct %v2double [[inf_double]] [[inf_double]]
// CHECK-NEXT: [[inf_double:%\d+]] = OpFConvert %double [[inf]]
// CHECK-NEXT: [[inf_double_:%\d+]] = OpFConvert %double [[inf]]
// CHECK-NEXT: [[inf_int64:%\d+]] = OpConvertFToS %long [[inf_double_]]
// CHECK-NEXT: [[inf_double_:%\d+]] = OpFConvert %double [[inf]]
// CHECK-NEXT: [[inf_uint64:%\d+]] = OpConvertFToU %ulong [[inf_double_]]
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %S [[inf2]] [[inf]] [[inf2_double]] [[inf_double]] [[inf_int64]] [[inf_uint64]]
S s3 = (S)(1.0 / 0.0);
// CHECK: [[b:%\d+]] = OpLoad %float %b
// CHECK-NEXT: [[b2_float:%\d+]] = OpCompositeConstruct %v2float [[b]] [[b]]
// CHECK-NEXT: [[b_double:%\d+]] = OpFConvert %double [[b]]
// CHECK-NEXT: [[b2_double:%\d+]] = OpCompositeConstruct %v2double [[b_double]] [[b_double]]
// CHECK-NEXT: [[b_double:%\d+]] = OpFConvert %double [[b]]
// CHECK-NEXT: [[b_double_:%\d+]] = OpFConvert %double [[b]]
// CHECK-NEXT: [[b_int64:%\d+]] = OpConvertFToS %long [[b_double_]]
// CHECK-NEXT: [[b_double_:%\d+]] = OpFConvert %double [[b]]
// CHECK-NEXT: [[b_uint64:%\d+]] = OpConvertFToU %ulong [[b_double_]]
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %S [[b2_float]] [[b]] [[b2_double]] [[b_double]] [[b_int64]] [[b_uint64]]
float b;
S s2 = (S)(b);
// CHECK: [[a:%\d+]] = OpLoad %double %a
// CHECK-NEXT: [[a_float:%\d+]] = OpFConvert %float [[a]]
// CHECK-NEXT: [[a2_float:%\d+]] = OpCompositeConstruct %v2float [[a_float]] [[a_float]]
// CHECK-NEXT: [[a_float:%\d+]] = OpFConvert %float [[a]]
// CHECK-NEXT: [[a2_double:%\d+]] = OpCompositeConstruct %v2double [[a]] [[a]]
// CHECK-NEXT: [[a_int64:%\d+]] = OpConvertFToS %long [[a]]
// CHECK-NEXT: [[a_uint64:%\d+]] = OpConvertFToU %ulong [[a]]
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %S [[a2_float]] [[a_float]] [[a2_double]] [[a]] [[a_int64]] [[a_uint64]]
double a;
S s1 = (S)(a);
}

44
tools/clang/test/CodeGenSPIRV/cast.flat-conversion.no-op.hlsl
Просмотреть файл

@ -1,44 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
cbuffer Data {
float gScalars[1];
float4 gVecs[2];
float2x3 gMats[1];
}
struct T {
float scalars[1];
float4 vecs[2];
float2x3 mats[1];
};
float4 main() : SV_Target {
T t;
// CHECK: [[gscalars_ptr:%\d+]] = OpAccessChain %_ptr_Uniform__arr_float_uint_1 %Data %int_0
// CHECK-NEXT: [[gscalars_val:%\d+]] = OpLoad %_arr_float_uint_1 [[gscalars_ptr]]
// CHECK-NEXT: [[scalars_ptr:%\d+]] = OpAccessChain %_ptr_Function__arr_float_uint_1_0 %t %int_0
// CHECK-NEXT: [[gscalars0:%\d+]] = OpCompositeExtract %float [[gscalars_val]] 0
// CHECK-NEXT: [[scalars_val:%\d+]] = OpCompositeConstruct %_arr_float_uint_1_0 [[gscalars0]]
// CHECK-NEXT: OpStore [[scalars_ptr]] [[scalars_val]]
t.scalars = gScalars;
// CHECK-NEXT: [[gvecs_ptr:%\d+]] = OpAccessChain %_ptr_Uniform__arr_v4float_uint_2 %Data %int_1
// CHECK-NEXT: [[gvecs_val:%\d+]] = OpLoad %_arr_v4float_uint_2 [[gvecs_ptr]]
// CHECK-NEXT: [[vecs_ptr:%\d+]] = OpAccessChain %_ptr_Function__arr_v4float_uint_2_0 %t %int_1
// CHECK-NEXT: [[gvecs0:%\d+]] = OpCompositeExtract %v4float [[gvecs_val]] 0
// CHECK-NEXT: [[gvecs1:%\d+]] = OpCompositeExtract %v4float [[gvecs_val]] 1
// CHECK-NEXT: [[vecs_val:%\d+]] = OpCompositeConstruct %_arr_v4float_uint_2_0 [[gvecs0]] [[gvecs1]]
// CHECK-NEXT: OpStore [[vecs_ptr]] [[vecs_val]]
t.vecs = gVecs;
// CHECK-NEXT: [[gmats_ptr:%\d+]] = OpAccessChain %_ptr_Uniform__arr_mat2v3float_uint_1 %Data %int_2
// CHECK-NEXT: [[gmats_val:%\d+]] = OpLoad %_arr_mat2v3float_uint_1 [[gmats_ptr]]
// CHECK-NEXT: [[mats_ptr:%\d+]] = OpAccessChain %_ptr_Function__arr_mat2v3float_uint_1_0 %t %int_2
// CHECK-NEXT: [[gmats0:%\d+]] = OpCompositeExtract %mat2v3float [[gmats_val]] 0
// CHECK-NEXT: [[mats_val:%\d+]] = OpCompositeConstruct %_arr_mat2v3float_uint_1_0 [[gmats0]]
// CHECK-NEXT: OpStore [[mats_ptr]] [[mats_val]]
t.mats = gMats;
return t.vecs[1];
}

59
tools/clang/test/CodeGenSPIRV/cast.flat-conversion.struct-to-struct.hlsl
Просмотреть файл

@ -1,59 +0,0 @@
// RUN: %dxc -T cs_6_0 -HV 2018 -E main
// Processing FlatConversion when source and destination
// are both structures with identical members.
struct FirstStruct {
float3 anArray[4];
float2x3 mats[1];
int2 ints[3];
};
struct SecondStruct {
float3 anArray[4];
float2x3 mats[1];
int2 ints[3];
};
RWStructuredBuffer<FirstStruct> rwBuf : register(u0);
[ numthreads ( 16 , 16 , 1 ) ]
void main() {
SecondStruct values;
FirstStruct v;
// Yes, this is a FlatConversion!
// CHECK: [[values:%\d+]] = OpLoad %SecondStruct %values
// CHECK-NEXT: [[v0:%\d+]] = OpCompositeExtract %_arr_v3float_uint_4_0 [[values]] 0
// CHECK-NEXT: [[v1:%\d+]] = OpCompositeExtract %_arr_mat2v3float_uint_1_0 [[values]] 1
// CHECK-NEXT: [[v2:%\d+]] = OpCompositeExtract %_arr_v2int_uint_3_0 [[values]] 2
// CHECK-NEXT: [[v:%\d+]] = OpCompositeConstruct %FirstStruct_0 [[v0]] [[v1]] [[v2]]
// CHECK-NEXT: OpStore %v [[v]]
v = values;
// CHECK-NEXT: [[values:%\d+]] = OpLoad %SecondStruct %values
// CHECK-NEXT: [[v0:%\d+]] = OpCompositeExtract %_arr_v3float_uint_4_0 [[values]] 0
// CHECK-NEXT: [[v1:%\d+]] = OpCompositeExtract %_arr_mat2v3float_uint_1_0 [[values]] 1
// CHECK-NEXT: [[v2:%\d+]] = OpCompositeExtract %_arr_v2int_uint_3_0 [[values]] 2
// CHECK-NEXT: [[v:%\d+]] = OpCompositeConstruct %FirstStruct_0 [[v0]] [[v1]] [[v2]]
// CHECK-NEXT: [[rwBuf_ptr:%\d+]] = OpAccessChain %_ptr_Uniform_FirstStruct %rwBuf %int_0 %uint_0
// CHECK-NEXT: [[anArray:%\d+]] = OpCompositeExtract %_arr_v3float_uint_4_0 [[v]] 0
// CHECK-NEXT: [[anArray1:%\d+]] = OpCompositeExtract %v3float [[anArray]] 0
// CHECK-NEXT: [[anArray2:%\d+]] = OpCompositeExtract %v3float [[anArray]] 1
// CHECK-NEXT: [[anArray3:%\d+]] = OpCompositeExtract %v3float [[anArray]] 2
// CHECK-NEXT: [[anArray4:%\d+]] = OpCompositeExtract %v3float [[anArray]] 3
// CHECK-NEXT: [[res1:%\d+]] = OpCompositeConstruct %_arr_v3float_uint_4 [[anArray1]] [[anArray2]] [[anArray3]] [[anArray4]]
// CHECK-NEXT: [[mats:%\d+]] = OpCompositeExtract %_arr_mat2v3float_uint_1_0 [[v]] 1
// CHECK-NEXT: [[mat:%\d+]] = OpCompositeExtract %mat2v3float [[mats]] 0
// CHECK-NEXT: [[res2:%\d+]] = OpCompositeConstruct %_arr_mat2v3float_uint_1 [[mat]]
// CHECK-NEXT: [[ints:%\d+]] = OpCompositeExtract %_arr_v2int_uint_3_0 [[v]] 2
// CHECK-NEXT: [[ints1:%\d+]] = OpCompositeExtract %v2int [[ints]] 0
// CHECK-NEXT: [[ints2:%\d+]] = OpCompositeExtract %v2int [[ints]] 1
// CHECK-NEXT: [[ints3:%\d+]] = OpCompositeExtract %v2int [[ints]] 2
// CHECK-NEXT: [[res3:%\d+]] = OpCompositeConstruct %_arr_v2int_uint_3 [[ints1]] [[ints2]] [[ints3]]
// CHECK-NEXT: [[result:%\d+]] = OpCompositeConstruct %FirstStruct [[res1]] [[res2]] [[res3]]
// CHECK-NEXT: OpStore [[rwBuf_ptr]] [[result]]
rwBuf[0] = values;
}

27
tools/clang/test/CodeGenSPIRV/cast.flat-conversion.struct.hlsl
Просмотреть файл

@ -1,27 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
// Compositing a struct by casting from its single member
struct S {
float4 val;
};
struct T {
S val;
};
float4 main(float4 a: A) : SV_Target {
// CHECK: [[a:%\d+]] = OpLoad %v4float %a
// CHECK-NEXT: [[s:%\d+]] = OpCompositeConstruct %S [[a]]
// CHECK-NEXT: OpStore %s [[s]]
S s = (S)a;
// CHECK: [[s:%\d+]] = OpLoad %S %s
// CHECK-NEXT: [[val:%\d+]] = OpCompositeExtract %v4float [[s]] 0
// CHECK-NEXT: [[s:%\d+]] = OpCompositeConstruct %S [[val]]
// CHECK-NEXT: [[t:%\d+]] = OpCompositeConstruct %T [[s]]
// CHECK-NEXT: OpStore %t [[t]]
T t = (T)s;
return s.val + t.val.val;
}

23
tools/clang/test/CodeGenSPIRV/cast.flat-conversion.vector.hlsl
Просмотреть файл

@ -1,23 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
struct S {
float2 data[2];
};
StructuredBuffer<S> MySB;
float4 main() : SV_TARGET
{
// CHECK: [[ac:%\d+]] = OpAccessChain %_ptr_Uniform__arr_v2float_uint_2 %MySB %int_0 %uint_0 %int_0
// CHECK-NEXT: [[mysb:%\d+]] = OpLoad %_arr_v2float_uint_2 [[ac]]
// CHECK-NEXT: [[vec0:%\d+]] = OpCompositeExtract %v2float [[mysb]] 0
// CHECK-NEXT: [[vec1:%\d+]] = OpCompositeExtract %v2float [[mysb]] 1
// CHECK-NEXT: [[v1:%\d+]] = OpCompositeExtract %float [[vec0]] 0
// CHECK-NEXT: [[v2:%\d+]] = OpCompositeExtract %float [[vec0]] 1
// CHECK-NEXT: [[v3:%\d+]] = OpCompositeExtract %float [[vec1]] 0
// CHECK-NEXT: [[v4:%\d+]] = OpCompositeExtract %float [[vec1]] 1
// CHECK-NEXT: [[val:%\d+]] = OpCompositeConstruct %_arr_float_uint_4 [[v1]] [[v2]] [[v3]] [[v4]]
// CHECK-NEXT: OpStore %data [[val]]
float data[4] = (float[4])MySB[0].data;
return data[1];
}

12
tools/clang/test/CodeGenSPIRV/cast.literal-type.array-subscript.hlsl
Просмотреть файл

@ -1,12 +0,0 @@
// RUN: %dxc -T cs_6_0 -E main
RWStructuredBuffer<uint> Out;
groupshared uint Mem[1];
[numthreads(1, 1, 1)]
void main() {
// CHECK: [[sub:%\d+]] = OpISub %int %int_1 %int_1
// CHECK: {{%\d+}} = OpAccessChain %_ptr_Workgroup_uint %Mem [[sub]]
Mem[1 - 1] = 0;
Out[0] = Mem[0];
}

23
tools/clang/test/CodeGenSPIRV/cast.literal-type.ternary.2021.hlsl
Просмотреть файл

@ -1,23 +0,0 @@
// RUN: %dxc -T ps_6_0 -HV 2021 -E main
// The 'out' argument in the function should be handled correctly when deducing
// the literal type, even in HLSL 2021 (with shortcicuiting).
void foo(out uint value, uint x) {
// CHECK: [[cond:%\d+]] = OpULessThan %bool {{%\d+}} %uint_64
// CHECK: OpBranchConditional [[cond]] [[ternary_lhs:%\w+]] [[ternary_rhs:%\w+]]
// CHECK: [[ternary_lhs]] = OpLabel
// CHECK: OpStore [[tmp:%\w+]] %int_1
// CHECK: OpBranch [[merge:%\w+]]
// CHECK: [[ternary_rhs]] = OpLabel
// CHECK: OpStore [[tmp:%\w+]] %int_0
// CHECK: OpBranch [[merge]]
// CHECK: [[merge]] = OpLabel
// CHECK: [[res:%\d+]] = OpLoad %int [[tmp]]
// CHECK: {{%\d+}} = OpBitcast %uint [[res]]
value = x < 64 ? 1 : 0;
}
void main() {
uint value;
foo(value, 2);
}

15
tools/clang/test/CodeGenSPIRV/cast.literal-type.ternary.hlsl
Просмотреть файл

@ -1,15 +0,0 @@
// RUN: %dxc -T ps_6_0 -HV 2018 -E main
// The 'out' argument in the function should be handled correctly when deducing
// the literal type.
void foo(out uint value, uint x) {
// CHECK: [[cond:%\d+]] = OpULessThan %bool {{%\d+}} %uint_64
// CHECK: [[result:%\d+]] = OpSelect %int [[cond]] %int_1 %int_0
// CHECK: {{%\d+}} = OpBitcast %uint [[result]]
value = x < 64 ? 1 : 0;
}
void main() {
uint value;
foo(value, 2);
}

33
tools/clang/test/CodeGenSPIRV/cast.mat-to-vec.hlsl
Просмотреть файл

@ -1,33 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
float4 main(float4 input : A) : SV_Target {
float2x2 floatMat;
int2x2 intMat;
bool2x2 boolMat;
// CHECK: [[floatMat:%\d+]] = OpLoad %mat2v2float %floatMat
// CHECK-NEXT: [[row0:%\d+]] = OpCompositeExtract %v2float [[floatMat]] 0
// CHECK-NEXT: [[row1:%\d+]] = OpCompositeExtract %v2float [[floatMat]] 1
// CHECK-NEXT: [[vec:%\d+]] = OpVectorShuffle %v4float [[row0]] [[row1]] 0 1 2 3
// CHECK-NEXT: OpStore %c [[vec]]
float4 c = floatMat;
// CHECK: [[intMat:%\d+]] = OpLoad %_arr_v2int_uint_2 %intMat
// CHECK-NEXT: [[row0:%\d+]] = OpCompositeExtract %v2int [[intMat]] 0
// CHECK-NEXT: [[row1:%\d+]] = OpCompositeExtract %v2int [[intMat]] 1
// CHECK-NEXT: [[vecInt:%\d+]] = OpVectorShuffle %v4int [[row0]] [[row1]] 0 1 2 3
// CHECK-NEXT: [[vecFloat:%\d+]] = OpConvertSToF %v4float [[vecInt]]
// CHECK-NEXT: OpStore %d [[vecFloat]]
float4 d = intMat;
// CHECK: [[boolMat:%\d+]] = OpLoad %_arr_v2bool_uint_2 %boolMat
// CHECK-NEXT: [[row0:%\d+]] = OpCompositeExtract %v2bool [[boolMat]] 0
// CHECK-NEXT: [[row1:%\d+]] = OpCompositeExtract %v2bool [[boolMat]] 1
// CHECK-NEXT: [[vec:%\d+]] = OpVectorShuffle %v4bool [[row0]] [[row1]] 0 1 2 3
// CHECK-NEXT: [[vecFloat:%\d+]] = OpSelect %v4float [[vec]] {{%\d+}} {{%\d+}}
// CHECK-NEXT: OpStore %e [[vecFloat]]
float4 e = boolMat;
return 0.xxxx;
}

86
tools/clang/test/CodeGenSPIRV/cast.matrix.splat.hlsl
Просмотреть файл

@ -1,86 +0,0 @@
// RUN: %dxc -T vs_6_0 -E main
// CHECK: [[v2f8_5:%\d+]] = OpConstantComposite %v2float %float_8_5 %float_8_5
// CHECK: [[v3f9_5:%\d+]] = OpConstantComposite %v3float %float_9_5 %float_9_5 %float_9_5
// CHECK: [[v2f10_5:%\d+]] = OpConstantComposite %v2float %float_10_5 %float_10_5
// CHECK: [[m3v2f10_5:%\d+]] = OpConstantComposite %mat3v2float [[v2f10_5]] [[v2f10_5]] [[v2f10_5]]
// CHECK: [[v2i10:%\d+]] = OpConstantComposite %v2int %int_10 %int_10
// CHECK: [[int3x2_i10:%\d+]] = OpConstantComposite %_arr_v2int_uint_3 [[v2i10]] [[v2i10]] [[v2i10]]
// CHECK: [[v2true:%\d+]] = OpConstantComposite %v2bool %true %true
// CHECK: [[bool3x2_true:%\d+]] = OpConstantComposite %_arr_v2bool_uint_3 [[v2true]] [[v2true]] [[v2true]]
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
// TODO: Optimally the following literals can be attached to variable
// definitions instead of OpStore. Constant evaluation in the front
// end doesn't really support it for now.
// CHECK: OpStore %a %float_7_5
float1x1 a = 7.5;
// CHECK-NEXT: OpStore %b [[v2f8_5]]
float1x2 b = 8.5;
// CHECK-NEXT: OpStore %c [[v3f9_5]]
float3x1 c = 9.5;
// CHECK-NEXT: OpStore %d [[m3v2f10_5]]
float3x2 d = 10.5;
// CHECK-NEXT: OpStore %e [[int3x2_i10]]
int3x2 e = 10;
// CHECK-NEXT: OpStore %f [[bool3x2_true]]
bool3x2 f = true;
float val;
// CHECK-NEXT: [[val0:%\d+]] = OpLoad %float %val
// CHECK-NEXT: OpStore %h [[val0]]
float1x1 h = val;
// CHECK-NEXT: [[val1:%\d+]] = OpLoad %float %val
// CHECK-NEXT: [[cc0:%\d+]] = OpCompositeConstruct %v3float [[val1]] [[val1]] [[val1]]
// CHECK-NEXT: OpStore %i [[cc0]]
float1x3 i = val;
float2x1 j;
float2x3 k;
// CHECK-NEXT: [[val2:%\d+]] = OpLoad %float %val
// CHECK-NEXT: [[cc1:%\d+]] = OpCompositeConstruct %v2float [[val2]] [[val2]]
// CHECK-NEXT: OpStore %j [[cc1]]
j = val;
// CHECK-NEXT: [[val3:%\d+]] = OpLoad %float %val
// CHECK-NEXT: [[cc2:%\d+]] = OpCompositeConstruct %v3float [[val3]] [[val3]] [[val3]]
// CHECK-NEXT: [[cc3:%\d+]] = OpCompositeConstruct %mat2v3float [[cc2]] [[cc2]]
// CHECK-NEXT: OpStore %k [[cc3]]
k = val;
int intVal;
// CHECK: [[intVal:%\d+]] = OpLoad %int %intVal
// CHECK-NEXT: [[cc4:%\d+]] = OpCompositeConstruct %v3int [[intVal]] [[intVal]] [[intVal]]
// CHECK-NEXT: OpStore %m [[cc4]]
int1x3 m = intVal;
int2x1 n;
int2x3 o;
// CHECK: [[intVal:%\d+]] = OpLoad %int %intVal
// CHECK-NEXT: [[cc5:%\d+]] = OpCompositeConstruct %v2int [[intVal]] [[intVal]]
// CHECK-NEXT: OpStore %n [[cc5]]
n = intVal;
// CHECK: [[intVal:%\d+]] = OpLoad %int %intVal
// CHECK-NEXT: [[v3intVal:%\d+]] = OpCompositeConstruct %v3int [[intVal]] [[intVal]] [[intVal]]
// CHECK-NEXT: [[cc6:%\d+]] = OpCompositeConstruct %_arr_v3int_uint_2 [[v3intVal]] [[v3intVal]]
// CHECK-NEXT: OpStore %o [[cc6]]
o = intVal;
bool boolVal;
// CHECK: [[boolVal:%\d+]] = OpLoad %bool %boolVal
// CHECK-NEXT: [[cc7:%\d+]] = OpCompositeConstruct %v3bool [[boolVal]] [[boolVal]] [[boolVal]]
// CHECK-NEXT: OpStore %p [[cc7]]
bool1x3 p = boolVal;
bool2x1 q;
bool2x3 r;
// CHECK: [[boolVal:%\d+]] = OpLoad %bool %boolVal
// CHECK-NEXT: [[cc8:%\d+]] = OpCompositeConstruct %v2bool [[boolVal]] [[boolVal]]
// CHECK-NEXT: OpStore %q [[cc8]]
q = boolVal;
// CHECK: [[boolVal:%\d+]] = OpLoad %bool %boolVal
// CHECK-NEXT: [[v3boolVal:%\d+]] = OpCompositeConstruct %v3bool [[boolVal]] [[boolVal]] [[boolVal]]
// CHECK-NEXT: [[cc9:%\d+]] = OpCompositeConstruct %_arr_v3bool_uint_2 [[v3boolVal]] [[v3boolVal]]
// CHECK-NEXT: OpStore %r [[cc9]]
r = boolVal;
}

139
tools/clang/test/CodeGenSPIRV/cast.matrix.trunc.hlsl
Просмотреть файл

@ -1,139 +0,0 @@
// RUN: %dxc -T vs_6_0 -E main
// Note: Matrix truncation cast does not allow truncation into a mat1x1.
void main() {
float3x4 m = { 1, 2, 3, 4,
5, 6, 7, 8,
9, 10, 11, 12 };
float1x4 n = {1, 2, 3, 4};
float3x1 o = {1, 2, 3};
// TEST: float3x4 --> float2x3
// CHECK: [[m_0:%\d+]] = OpLoad %mat3v4float %m
// CHECK-NEXT: [[m_0_row0:%\d+]] = OpCompositeExtract %v4float [[m_0]] 0
// CHECK-NEXT: [[a_row0:%\d+]] = OpVectorShuffle %v3float [[m_0_row0]] [[m_0_row0]] 0 1 2
// CHECK-NEXT: [[m_0_row1:%\d+]] = OpCompositeExtract %v4float [[m_0]] 1
// CHECK-NEXT: [[a_row1:%\d+]] = OpVectorShuffle %v3float [[m_0_row1]] [[m_0_row1]] 0 1 2
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %mat2v3float [[a_row0]] [[a_row1]]
float2x3 a = (float2x3)m;
// TEST: float3x4 --> float1x3
// CHECK: [[m_1:%\d+]] = OpLoad %mat3v4float %m
// CHECK-NEXT: [[m_1_row0:%\d+]] = OpCompositeExtract %v4float [[m_1]] 0
// CHECK-NEXT: {{%\d+}} = OpVectorShuffle %v3float [[m_1_row0]] [[m_1_row0]] 0 1 2
float1x3 b = m;
// TEST: float3x4 --> float1x4
// CHECK: [[m_2:%\d+]] = OpLoad %mat3v4float %m
// CHECK-NEXT: {{%\d+}} = OpCompositeExtract %v4float [[m_2]] 0
float1x4 c = m;
// TEST: float3x4 --> float2x1
// CHECK: [[m_3:%\d+]] = OpLoad %mat3v4float %m
// CHECK-NEXT: [[m_3_row0:%\d+]] = OpCompositeExtract %v4float [[m_3]] 0
// CHECK-NEXT: [[d_row0:%\d+]] = OpCompositeExtract %float [[m_3_row0]] 0
// CHECK-NEXT: [[m_3_row1:%\d+]] = OpCompositeExtract %v4float [[m_3]] 1
// CHECK-NEXT: [[d_row1:%\d+]] = OpCompositeExtract %float [[m_3_row1]] 0
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %v2float [[d_row0]] [[d_row1]]
float2x1 d = m;
// TEST: float3x4 --> float3x1
// CHECK: [[m_4:%\d+]] = OpLoad %mat3v4float %m
// CHECK-NEXT: [[m_4_row0:%\d+]] = OpCompositeExtract %v4float [[m_4]] 0
// CHECK-NEXT: [[e_row0:%\d+]] = OpCompositeExtract %float [[m_4_row0]] 0
// CHECK-NEXT: [[m_4_row1:%\d+]] = OpCompositeExtract %v4float [[m_4]] 1
// CHECK-NEXT: [[e_row1:%\d+]] = OpCompositeExtract %float [[m_4_row1]] 0
// CHECK-NEXT: [[m_4_row2:%\d+]] = OpCompositeExtract %v4float [[m_4]] 2
// CHECK-NEXT: [[e_row2:%\d+]] = OpCompositeExtract %float [[m_4_row2]] 0
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %v3float [[e_row0]] [[e_row1]] [[e_row2]]
float3x1 e = (float3x1)m;
// TEST float1x4 --> float1x3
// CHECK: [[n:%\d+]] = OpLoad %v4float %n
// CHECK-NEXT: {{%\d+}} = OpVectorShuffle %v3float [[n]] [[n]] 0 1 2
float1x3 f = n;
// TEST float1x4 --> float1x3
// CHECK: [[n:%\d+]] = OpLoad %v4float %n
// CHECK-NEXT: [[n0:%\d+]] = OpCompositeExtract %float [[n]] 0
// CHECK-NEXT: OpStore %scalar [[n0]]
float1x1 scalar = n;
// TEST float3x1 --> float2x1
// CHECK: [[o:%\d+]] = OpLoad %v3float %o
// CHECK-NEXT: {{%\d+}} = OpVectorShuffle %v2float [[o]] [[o]] 0 1
float2x1 g = (float2x1)o;
// Non-floating point matrices
int3x4 h;
int2x3 i;
int3x1 j;
int1x4 k;
// CHECK: [[h:%\d+]] = OpLoad %_arr_v4int_uint_3 %h
// CHECK-NEXT: [[h0:%\d+]] = OpCompositeExtract %v4int [[h]] 0
// CHECK-NEXT: [[i0:%\d+]] = OpVectorShuffle %v3int [[h0]] [[h0]] 0 1 2
// CHECK-NEXT: [[h1:%\d+]] = OpCompositeExtract %v4int [[h]] 1
// CHECK-NEXT: [[i1:%\d+]] = OpVectorShuffle %v3int [[h1]] [[h1]] 0 1 2
// CHECK-NEXT: [[i:%\d+]] = OpCompositeConstruct %_arr_v3int_uint_2 [[i0]] [[i1]]
// CHECK-NEXT: OpStore %i [[i]]
i = (int2x3)h;
// CHECK: [[h:%\d+]] = OpLoad %_arr_v4int_uint_3 %h
// CHECK-NEXT: [[h0:%\d+]] = OpCompositeExtract %v4int [[h]] 0
// CHECK-NEXT: [[h0e0:%\d+]] = OpCompositeExtract %int [[h0]] 0
// CHECK-NEXT: [[h1:%\d+]] = OpCompositeExtract %v4int [[h]] 1
// CHECK-NEXT: [[h1e0:%\d+]] = OpCompositeExtract %int [[h1]] 0
// CHECK-NEXT: [[h2:%\d+]] = OpCompositeExtract %v4int [[h]] 2
// CHECK-NEXT: [[h2e0:%\d+]] = OpCompositeExtract %int [[h2]] 0
// CHECK-NEXT: [[j:%\d+]] = OpCompositeConstruct %v3int [[h0e0]] [[h1e0]] [[h2e0]]
// CHECK-NEXT: OpStore %j [[j]]
j = (int3x1)h;
// CHECK: [[h:%\d+]] = OpLoad %_arr_v4int_uint_3 %h
// CHECK-NEXT: [[h0:%\d+]] = OpCompositeExtract %v4int [[h]] 0
// CHECK-NEXT: OpStore %k [[h0]]
k = (int1x4)h;
bool3x4 p;
bool2x3 q;
bool3x1 r;
bool1x4 s;
// CHECK: [[p:%\d+]] = OpLoad %_arr_v4bool_uint_3 %p
// CHECK-NEXT: [[p0:%\d+]] = OpCompositeExtract %v4bool [[p]] 0
// CHECK-NEXT: [[q0:%\d+]] = OpVectorShuffle %v3bool [[p0]] [[p0]] 0 1 2
// CHECK-NEXT: [[p1:%\d+]] = OpCompositeExtract %v4bool [[p]] 1
// CHECK-NEXT: [[q1:%\d+]] = OpVectorShuffle %v3bool [[p1]] [[p1]] 0 1 2
// CHECK-NEXT: [[q:%\d+]] = OpCompositeConstruct %_arr_v3bool_uint_2 [[q0]] [[q1]]
// CHECK-NEXT: OpStore %q [[q]]
q = (bool2x3)p;
// CHECK: [[p:%\d+]] = OpLoad %_arr_v4bool_uint_3 %p
// CHECK-NEXT: [[p0:%\d+]] = OpCompositeExtract %v4bool [[p]] 0
// CHECK-NEXT: [[p0e0:%\d+]] = OpCompositeExtract %bool [[p0]] 0
// CHECK-NEXT: [[p1:%\d+]] = OpCompositeExtract %v4bool [[p]] 1
// CHECK-NEXT: [[p1e0:%\d+]] = OpCompositeExtract %bool [[p1]] 0
// CHECK-NEXT: [[p2:%\d+]] = OpCompositeExtract %v4bool [[p]] 2
// CHECK-NEXT: [[p2e0:%\d+]] = OpCompositeExtract %bool [[p2]] 0
// CHECK-NEXT: [[r:%\d+]] = OpCompositeConstruct %v3bool [[p0e0]] [[p1e0]] [[p2e0]]
// CHECK-NEXT: OpStore %r [[r]]
r = (bool3x1)p;
// CHECK: [[p:%\d+]] = OpLoad %_arr_v4bool_uint_3 %p
// CHECK-NEXT: [[p0:%\d+]] = OpCompositeExtract %v4bool [[p]] 0
// CHECK-NEXT: OpStore %s [[p0]]
s = (bool1x4)p;
}

14
tools/clang/test/CodeGenSPIRV/cast.no-op.matrix.float-to-int.hlsl
Просмотреть файл

@ -1,14 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
void main() {
float2x2 a;
int4 b;
// CHECK: [[a:%\d+]] = OpLoad %mat2v2float %a
// CHECK-NEXT: [[a_0:%\d+]] = OpCompositeExtract %v2float [[a]] 0
// CHECK-NEXT: [[a_0:%\d+]] = OpConvertFToS %v2int [[a_0]]
// CHECK-NEXT: [[a_1:%\d+]] = OpCompositeExtract %v2float [[a]] 1
// CHECK-NEXT: [[a_1:%\d+]] = OpConvertFToS %v2int [[a_1]]
// CHECK-NEXT: [[a:%\d+]] = OpCompositeConstruct %_arr_v2int_uint_2 [[a_0]] [[a_1]]
b.zw = mul(int2x2(a), b.yx);
}

33
tools/clang/test/CodeGenSPIRV/cast.vec-to-mat.explicit.hlsl
Просмотреть файл

@ -1,33 +0,0 @@
// RUN: %dxc -T ps_6_0 -E main
float4 main(float4 input : A) : SV_Target {
// CHECK: [[vec:%\d+]] = OpLoad %v4float %input
// CHECK-NEXT: [[vec1:%\d+]] = OpVectorShuffle %v2float [[vec]] [[vec]] 0 1
// CHECK-NEXT: [[vec2:%\d+]] = OpVectorShuffle %v2float [[vec]] [[vec]] 2 3
// CHECK-NEXT: [[mat:%\d+]] = OpCompositeConstruct %mat2v2float [[vec1]] [[vec2]]
// CHECK-NEXT: OpStore %mat1 [[mat]]
float2x2 mat1 = ( float2x2)input;
// CHECK: [[vec:%\d+]] = OpLoad %v4float %input
// CHECK-NEXT: [[vec1:%\d+]] = OpVectorShuffle %v2float [[vec]] [[vec]] 0 1
// CHECK-NEXT: [[vec2:%\d+]] = OpVectorShuffle %v2float [[vec]] [[vec]] 2 3
// CHECK-NEXT: [[mat:%\d+]] = OpCompositeConstruct %mat2v2float [[vec1]] [[vec2]]
// CHECK-NEXT: OpStore %mat2 [[mat]]
float2x2 mat2 = (row_major float2x2)input;
// CHECK: [[vec:%\d+]] = OpLoad %v4float %input
// CHECK-NEXT: [[vec1:%\d+]] = OpVectorShuffle %v2float [[vec]] [[vec]] 0 1
// CHECK-NEXT: [[vec2:%\d+]] = OpVectorShuffle %v2float [[vec]] [[vec]] 2 3
// CHECK-NEXT: [[mat:%\d+]] = OpCompositeConstruct %mat2v2float [[vec1]] [[vec2]]
// CHECK-NEXT: OpStore %mat3 [[mat]]
float2x2 mat3 = (column_major float2x2)input;
// CHECK: [[a:%\d+]] = OpLoad %v4int %a
// CHECK-NEXT: [[vec1:%\d+]] = OpVectorShuffle %v2int [[a]] [[a]] 0 1
// CHECK-NEXT: [[vec2:%\d+]] = OpVectorShuffle %v2int [[a]] [[a]] 2 3
// CHECK-NEXT: {{%\d+}} = OpCompositeConstruct %_arr_v2int_uint_2 [[vec1]] [[vec2]]
int4 a;
int2x2 b = a;
return float4(mat1[0][0], mat2[0][1], mat3[1][0], mat1[1][1]);
}

56
tools/clang/test/CodeGenSPIRV/cast.vector.splat.hlsl
Просмотреть файл

@ -1,56 +0,0 @@
// RUN: %dxc -T vs_6_0 -E main
// CHECK: [[v4f32c:%\d+]] = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1
// CHECK: [[v3f32c:%\d+]] = OpConstantComposite %v3float %float_2 %float_2 %float_2
// CHECK: [[v4fc_2:%\d+]] = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2
// CHECK: [[v4fc_3:%\d+]] = OpConstantComposite %v4float %float_3 %float_3 %float_3 %float_3
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
// From constant
// CHECK: OpStore %vf4 [[v4f32c]]
float4 vf4 = 1;
// CHECK-NEXT: OpStore %vf3 [[v3f32c]]
float3 vf3;
vf3 = float1(2);
// CHECK-NEXT: [[si:%\d+]] = OpLoad %int %si
// CHECK-NEXT: [[vi4:%\d+]] = OpCompositeConstruct %v4int [[si]] [[si]] [[si]] [[si]]
// CHECK-NEXT: OpStore %vi4 [[vi4]]
int si;
int4 vi4 = si;
// CHECK-NEXT: [[si1:%\d+]] = OpLoad %int %si1
// CHECK-NEXT: [[vi3:%\d+]] = OpCompositeConstruct %v3int [[si1]] [[si1]] [[si1]]
// CHECK-NEXT: OpStore %vi3 [[vi3]]
int1 si1;
int3 vi3;
vi3 = si1;
// CHECK-NEXT: [[v0p5:%\d+]] = OpCompositeConstruct %v4float %float_0_5 %float_0_5 %float_0_5 %float_0_5
// CHECK-NEXT: OpStore %vf4 [[v0p5]]
vf4 = float4(0.5.xxxx);
// CHECK-NEXT: [[v3:%\d+]] = OpCompositeConstruct %v3int %int_3 %int_3 %int_3
// CHECK-NEXT: OpStore %vi3 [[v3]]
vi3 = int3(3.xxx);
float sf;
// CHECK: [[sf:%\d+]] = OpLoad %float %sf
// CHECK-NEXT: [[sf_v4:%\d+]] = OpCompositeConstruct %v4float [[sf]] [[sf]] [[sf]] [[sf]]
// CHECK-NEXT: OpStore %vf4_0 [[sf_v4]]
float4 vf4_0 = (sf, sf, sf, sf);
// CHECK: [[sf:%\d+]] = OpLoad %float %sf
// CHECK-NEXT: [[sf_v4:%\d+]] = OpCompositeConstruct %v4float [[sf]] [[sf]] [[sf]] [[sf]]
// CHECK-NEXT: OpStore %vf4 [[sf_v4]]
vf4 = (sf, sf, sf, sf);
// CHECK: OpStore %vf4_1 [[v4fc_2]]
float4 vf4_1 = (2.0f, 2.0f, 2.0f, 2.0f);
// CHECK: OpStore %vf4 [[v4fc_3]]
vf4 = (3.0f, 3.0f, 3.0f, 3.0f);
}

56
tools/clang/test/CodeGenSPIRV/cast.vector.trunc.hlsl
Просмотреть файл

@ -1,56 +0,0 @@
// RUN: %dxc -T vs_6_0 -E main
// CHECK: [[v3f32c0:%\d+]] = OpConstantComposite %v3float %float_1 %float_2 %float_3
// CHECK: [[v3f32c1:%\d+]] = OpConstantComposite %v3float %float_5 %float_6 %float_7
// CHECK: [[v2f32c:%\d+]] = OpConstantComposite %v2float %float_8 %float_9
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
// From constant
// CHECK: OpStore %vf3 [[v3f32c0]]
float3 vf3 = float4(1, 2, 3, 4);
// CHECK-NEXT: [[c5:%\d+]] = OpCompositeExtract %float [[v3f32c1]] 0
// CHECK-NEXT: OpStore %vf1 [[c5]]
float1 vf1;
vf1 = float3(5, 6, 7);
// CHECK-NEXT: [[c8:%\d+]] = OpCompositeExtract %float [[v2f32c]] 0
// CHECK-NEXT: OpStore %sfa [[c8]]
float sfa = float2(8, 9);
// CHECK-NEXT: OpStore %sfb %float_10
float sfb;
sfb = float1(10);
// From variable
int4 vi4;
// CHECK-NEXT: [[vi4:%\d+]] = OpLoad %v4int %vi4
// CHECK-NEXT: [[e1:%\d+]] = OpCompositeExtract %int [[vi4]] 0
// CHECK-NEXT: [[e2:%\d+]] = OpCompositeExtract %int [[vi4]] 1
// CHECK-NEXT: [[e3:%\d+]] = OpCompositeExtract %int [[vi4]] 2
// CHECK-NEXT: [[vi3:%\d+]] = OpCompositeConstruct %v3int [[e1]] [[e2]] [[e3]]
// CHECK-NEXT: OpStore %vi3 [[vi3]]
int3 vi3;
vi3 = vi4;
// CHECK-NEXT: [[vi3_1:%\d+]] = OpLoad %v3int %vi3
// CHECK-NEXT: [[e4:%\d+]] = OpCompositeExtract %int [[vi3_1]] 0
// CHECK-NEXT: OpStore %vi1 [[e4]]
int1 vi1 = vi3;
// CHECK-NEXT: [[vi3_2:%\d+]] = OpLoad %v3int %vi3
// CHECK-NEXT: [[e5:%\d+]] = OpCompositeExtract %int [[vi3_2]] 0
// CHECK-NEXT: OpStore %sia [[e5]]
int sia;
sia = vi3;
// CHECK-NEXT: [[vi1:%\d+]] = OpLoad %int %vi1
// CHECK-NEXT: OpStore %sib [[vi1]]
int sib = vi1;
// Used in expression
// CHECK-NEXT: [[sia:%\d+]] = OpLoad %int %sia
// CHECK-NEXT: [[cc0:%\d+]] = OpCompositeConstruct %v3int [[sia]] [[sia]] [[sia]]
// CHECK-NEXT: [[vi3_3:%\d+]] = OpLoad %v3int %vi3
// CHECK-NEXT: [[add:%\d+]] = OpIAdd %v3int [[cc0]] [[vi3_3]]
// CHECK-NEXT: [[e6:%\d+]] = OpCompositeExtract %int [[add]] 0
// CHECK-NEXT: OpStore %sib [[e6]]
sib = sia + vi3;
}

59
tools/clang/test/CodeGenSPIRV/select.long.lit.hlsl2021.hlsl
Просмотреть файл

@ -1,59 +0,0 @@
// RUN: %dxc -T ps_6_0 -HV 2021 -E main
// Check that the literals get a 64-bit type, and the result of the select is
// then cast to an unsigned 64-bit value.
void foo(uint x) {
// CHECK: %foo = OpFunction
// CHECK-NEXT: [[param:%\w+]] = OpFunctionParameter %_ptr_Function_uint
// CHECK-NEXT: OpLabel
// CHECK-NEXT: [[value:%\w+]] = OpVariable %_ptr_Function_ulong Function
// CHECK-NEXT: [[temp:%\w+]] = OpVariable %_ptr_Function_long Function
// CHECK-NEXT: [[ld:%\w+]] = OpLoad %uint [[param]]
// CHECK-NEXT: [[cmp:%\w+]] = OpULessThan %bool [[ld]] %uint_64
// CHECK-NEXT: OpSelectionMerge [[merge_bb:%\w+]] None
// CHECK-NEXT: OpBranchConditional [[cmp]] [[true_bb:%\w+]] [[false_bb:%\w+]]
// CHECK-NEXT: [[true_bb]] = OpLabel
// CHECK-NEXT: OpStore [[temp]] %long_1
// CHECK-NEXT: OpBranch [[merge_bb]]
// CHECK-NEXT: [[false_bb]] = OpLabel
// CHECK-NEXT: OpStore [[temp]] %long_0
// CHECK-NEXT: OpBranch [[merge_bb]]
// CHECK-NEXT: [[merge_bb]] = OpLabel
// CHECK-NEXT: [[ld2:%\w+]] = OpLoad %long [[temp]]
// CHECK-NEXT: [[res:%\w+]] = OpBitcast %ulong [[ld2]]
// CHECK-NEXT: OpStore [[value]] [[res:%\w+]]
uint64_t value = x < 64 ? 1 : 0;
}
// Check that the literals get a 64-bit type, and the result of the select is
// then cast to an signed 64-bit value. Note that the bitcast is redundant in
// this case, but we add the bitcast before the type of the literal has been
// determined, so we add it anyway.
void bar(uint x) {
// CHECK: %bar = OpFunction
// CHECK-NEXT: [[param:%\w+]] = OpFunctionParameter %_ptr_Function_uint
// CHECK-NEXT: OpLabel
// CHECK-NEXT: [[value:%\w+]] = OpVariable %_ptr_Function_long Function
// CHECK-NEXT: [[temp:%\w+]] = OpVariable %_ptr_Function_long Function
// CHECK-NEXT: [[ld:%\w+]] = OpLoad %uint [[param]]
// CHECK-NEXT: [[cmp:%\w+]] = OpULessThan %bool [[ld]] %uint_64
// CHECK-NEXT: OpSelectionMerge [[merge_bb:%\w+]] None
// CHECK-NEXT: OpBranchConditional [[cmp]] [[true_bb:%\w+]] [[false_bb:%\w+]]
// CHECK-NEXT: [[true_bb]] = OpLabel
// CHECK-NEXT: OpStore [[temp]] %long_1
// CHECK-NEXT: OpBranch [[merge_bb]]
// CHECK-NEXT: [[false_bb]] = OpLabel
// CHECK-NEXT: OpStore [[temp]] %long_0
// CHECK-NEXT: OpBranch [[merge_bb]]
// CHECK-NEXT: [[merge_bb]] = OpLabel
// CHECK-NEXT: [[ld2:%\w+]] = OpLoad %long [[temp]]
// CHECK-NEXT: [[res:%\w+]] = OpBitcast %long [[ld2]]
// CHECK-NEXT: OpStore [[value]] [[res:%\w+]]
int64_t value = x < 64 ? 1 : 0;
}
void main() {
uint value;
foo(2);
bar(2);
}

59
tools/clang/test/CodeGenSPIRV/select.short.lit.hlsl2021.hlsl
Просмотреть файл

@ -1,59 +0,0 @@
// RUN: %dxc -T ps_6_2 -HV 2021 -E main -enable-16bit-types
// Check that the literals get a 16-bit type, and the result of the select is
// then cast to an unsigned 16-bit value.
void foo(uint x) {
// CHECK: %foo = OpFunction
// CHECK-NEXT: [[param:%\w+]] = OpFunctionParameter %_ptr_Function_uint
// CHECK-NEXT: OpLabel
// CHECK-NEXT: [[value:%\w+]] = OpVariable %_ptr_Function_ushort Function
// CHECK-NEXT: [[temp:%\w+]] = OpVariable %_ptr_Function_short Function
// CHECK-NEXT: [[ld:%\w+]] = OpLoad %uint [[param]]
// CHECK-NEXT: [[cmp:%\w+]] = OpULessThan %bool [[ld]] %uint_64
// CHECK-NEXT: OpSelectionMerge [[merge_bb:%\w+]] None
// CHECK-NEXT: OpBranchConditional [[cmp]] [[true_bb:%\w+]] [[false_bb:%\w+]]
// CHECK-NEXT: [[true_bb]] = OpLabel
// CHECK-NEXT: OpStore [[temp]] %short_1
// CHECK-NEXT: OpBranch [[merge_bb]]
// CHECK-NEXT: [[false_bb]] = OpLabel
// CHECK-NEXT: OpStore [[temp]] %short_0
// CHECK-NEXT: OpBranch [[merge_bb]]
// CHECK-NEXT: [[merge_bb]] = OpLabel
// CHECK-NEXT: [[ld2:%\w+]] = OpLoad %short [[temp]]
// CHECK-NEXT: [[res:%\w+]] = OpBitcast %ushort [[ld2]]
// CHECK-NEXT: OpStore [[value]] [[res:%\w+]]
uint16_t value = x < 64 ? 1 : 0;
}
// Check that the literals get a 16-bit type, and the result of the select is
// then cast to an signed 16-bit value. Note that the bitcast is redundant in
// this case, but we add the bitcast before the type of the literal has been
// determined, so we add it anyway.
void bar(uint x) {
// CHECK: %bar = OpFunction
// CHECK-NEXT: [[param:%\w+]] = OpFunctionParameter %_ptr_Function_uint
// CHECK-NEXT: OpLabel
// CHECK-NEXT: [[value:%\w+]] = OpVariable %_ptr_Function_short Function
// CHECK-NEXT: [[temp:%\w+]] = OpVariable %_ptr_Function_short Function
// CHECK-NEXT: [[ld:%\w+]] = OpLoad %uint [[param]]
// CHECK-NEXT: [[cmp:%\w+]] = OpULessThan %bool [[ld]] %uint_64
// CHECK-NEXT: OpSelectionMerge [[merge_bb:%\w+]] None
// CHECK-NEXT: OpBranchConditional [[cmp]] [[true_bb:%\w+]] [[false_bb:%\w+]]
// CHECK-NEXT: [[true_bb]] = OpLabel
// CHECK-NEXT: OpStore [[temp]] %short_1
// CHECK-NEXT: OpBranch [[merge_bb]]
// CHECK-NEXT: [[false_bb]] = OpLabel
// CHECK-NEXT: OpStore [[temp]] %short_0
// CHECK-NEXT: OpBranch [[merge_bb]]
// CHECK-NEXT: [[merge_bb]] = OpLabel
// CHECK-NEXT: [[ld2:%\w+]] = OpLoad %short [[temp]]
// CHECK-NEXT: [[res:%\w+]] = OpBitcast %short [[ld2]]
// CHECK-NEXT: OpStore [[value]] [[res:%\w+]]
int16_t value = x < 64 ? 1 : 0;
}
void main() {
uint value;
foo(2);
bar(2);
}

103
tools/clang/test/CodeGenSPIRV_Lit/cast.2bool.explicit.hlsl Normal file
Просмотреть файл

@ -0,0 +1,103 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
// CHECK: [[v2uint_1:%[0-9]+]] = OpConstantComposite %v2uint %uint_0 %uint_0
// CHECK: [[v3float_2:%[0-9]+]] = OpConstantComposite %v3float %float_0 %float_0 %float_0
// CHECK: [[v2bool_1_1:%[0-9]+]] = OpConstantComposite %v2bool %true %true
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
bool b;
int from1;
uint from2;
float from3;
bool1 vb1;
bool2 vb2;
bool3 vb3;
int1 vfrom1;
uint2 vfrom2;
float3 vfrom3;
// C style cast
// From constant (explicit)
// CHECK: OpStore %b %true
b = (bool)35;
// CHECK-NEXT: OpStore %b %false
b = (bool)0.0;
// From constant expr
// CHECK-NEXT: OpStore %b %true
b = (bool)(3.5 - 3.4);
// From variable (explicit)
// CHECK-NEXT: [[from1:%[0-9]+]] = OpLoad %int %from1
// CHECK-NEXT: [[c1:%[0-9]+]] = OpINotEqual %bool [[from1]] %int_0
// CHECK-NEXT: OpStore %b [[c1]]
b = (bool)from1;
// CHECK-NEXT: [[from2:%[0-9]+]] = OpLoad %uint %from2
// CHECK-NEXT: [[c2:%[0-9]+]] = OpINotEqual %bool [[from2]] %uint_0
// CHECK-NEXT: OpStore %b [[c2]]
b = (bool)from2;
// CHECK-NEXT: [[from3:%[0-9]+]] = OpLoad %float %from3
// CHECK-NEXT: [[c3:%[0-9]+]] = OpFOrdNotEqual %bool [[from3]] %float_0
// CHECK-NEXT: OpStore %b [[c3]]
b = (bool)from3;
// C++ function style cast
// CHECK-NEXT: OpStore %b %false
b = bool(0);
// CHECK-NEXT: OpStore %b %true
b = bool(3.5);
// CHECK-NEXT: OpStore %b %true
b = bool(42 + 1);
// CHECK-NEXT: [[from4:%[0-9]+]] = OpLoad %int %from1
// CHECK-NEXT: [[c4:%[0-9]+]] = OpINotEqual %bool [[from4]] %int_0
// CHECK-NEXT: OpStore %b [[c4]]
b = bool(from1);
// CHECK-NEXT: [[from5:%[0-9]+]] = OpLoad %uint %from2
// CHECK-NEXT: [[c5:%[0-9]+]] = OpINotEqual %bool [[from5]] %uint_0
// CHECK-NEXT: OpStore %b [[c5]]
b = bool(from2);
// CHECK-NEXT: [[from6:%[0-9]+]] = OpLoad %float %from3
// CHECK-NEXT: [[c6:%[0-9]+]] = OpFOrdNotEqual %bool [[from6]] %float_0
// CHECK-NEXT: OpStore %b [[c6]]
b = bool(from3);
// Vector cases
// CHECK-NEXT: OpStore %vb1 %true
vb1 = (bool1)42;
// CHECK-NEXT: [[vfrom1:%[0-9]+]] = OpLoad %int %vfrom1
// CHECK-NEXT: [[vc1:%[0-9]+]] = OpINotEqual %bool [[vfrom1]] %int_0
// CHECK-NEXT: OpStore %vb1 [[vc1]]
vb1 = (bool1)vfrom1;
// CHECK-NEXT: [[vfrom2:%[0-9]+]] = OpLoad %v2uint %vfrom2
// CHECK-NEXT: [[vc2:%[0-9]+]] = OpINotEqual %v2bool [[vfrom2]] [[v2uint_1]]
// CHECK-NEXT: OpStore %vb2 [[vc2]]
vb2 = (bool2)vfrom2;
// CHECK-NEXT: [[vfrom3:%[0-9]+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc3:%[0-9]+]] = OpFOrdNotEqual %v3bool [[vfrom3]] [[v3float_2]]
// CHECK-NEXT: OpStore %vb3 [[vc3]]
vb3 = (bool3)vfrom3;
// CHECK-NEXT: OpStore %vb1 %true
vb1 = bool1(3.5);
// CHECK-NEXT: OpStore %vb2 [[v2bool_1_1]]
vb2 = bool2(1.1 + 1.2, 3.0);
// CHECK-NEXT: [[vfrom4:%[0-9]+]] = OpLoad %int %vfrom1
// CHECK-NEXT: [[vc4:%[0-9]+]] = OpINotEqual %bool [[vfrom4]] %int_0
// CHECK-NEXT: OpStore %vb1 [[vc4]]
vb1 = bool1(vfrom1);
// CHECK-NEXT: [[vfrom5:%[0-9]+]] = OpLoad %v2uint %vfrom2
// CHECK-NEXT: [[vc5:%[0-9]+]] = OpINotEqual %v2bool [[vfrom5]] [[v2uint_1]]
// CHECK-NEXT: OpStore %vb2 [[vc5]]
vb2 = bool2(vfrom2);
// CHECK-NEXT: [[vfrom6:%[0-9]+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc6:%[0-9]+]] = OpFOrdNotEqual %v3bool [[vfrom6]] [[v3float_2]]
// CHECK-NEXT: OpStore %vb3 [[vc6]]
vb3 = bool3(vfrom3);
}

96
tools/clang/test/CodeGenSPIRV_Lit/cast.2bool.implicit.hlsl Normal file
Просмотреть файл

@ -0,0 +1,96 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
// CHECK: [[v2bool_1_0:%[0-9]+]] = OpConstantComposite %v2bool %true %false
// CHECK: [[v3bool_0_1_1:%[0-9]+]] = OpConstantComposite %v3bool %false %true %true
// CHECK: [[v2uint_1:%[0-9]+]] = OpConstantComposite %v2uint %uint_0 %uint_0
// CHECK: [[v3float_2:%[0-9]+]] = OpConstantComposite %v3float %float_0 %float_0 %float_0
// CHECK: [[v3i0:%[0-9]+]] = OpConstantComposite %v3int %int_0 %int_0 %int_0
// CHECK: [[v3u0:%[0-9]+]] = OpConstantComposite %v3uint %uint_0 %uint_0 %uint_0
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
bool b;
int from1;
uint from2;
float from3;
bool1 vb1;
bool2 vb2;
bool3 vb3;
int1 vfrom1;
uint2 vfrom2;
float3 vfrom3;
// From constant (implicit)
// CHECK: OpStore %b %true
b = 42;
// CHECK-NEXT: OpStore %b %false
b = 0.0;
// From constant expr
// CHECK-NEXT: OpStore %b %false
b = 35 - 35;
// From variable (implicit)
// CHECK-NEXT: [[from1:%[0-9]+]] = OpLoad %int %from1
// CHECK-NEXT: [[c1:%[0-9]+]] = OpINotEqual %bool [[from1]] %int_0
// CHECK-NEXT: OpStore %b [[c1]]
b = from1;
// CHECK-NEXT: [[from2:%[0-9]+]] = OpLoad %uint %from2
// CHECK-NEXT: [[c2:%[0-9]+]] = OpINotEqual %bool [[from2]] %uint_0
// CHECK-NEXT: OpStore %b [[c2]]
b = from2;
// CHECK-NEXT: [[from3:%[0-9]+]] = OpLoad %float %from3
// CHECK-NEXT: [[c3:%[0-9]+]] = OpFOrdNotEqual %bool [[from3]] %float_0
// CHECK-NEXT: OpStore %b [[c3]]
b = from3;
// Vector cases
// CHECK: OpStore %vbc2 [[v2bool_1_0]]
// CHECK: OpStore %vbc3 [[v3bool_0_1_1]]
bool2 vbc2 = {1, 15 - 15};
bool3 vbc3 = {0.0, 1.2 + 1.1, 3}; // Mixed
// CHECK-NEXT: [[vfrom1:%[0-9]+]] = OpLoad %int %vfrom1
// CHECK-NEXT: [[vc1:%[0-9]+]] = OpINotEqual %bool [[vfrom1]] %int_0
// CHECK-NEXT: OpStore %vb1 [[vc1]]
vb1 = vfrom1;
// CHECK-NEXT: [[vfrom2:%[0-9]+]] = OpLoad %v2uint %vfrom2
// CHECK-NEXT: [[vc2:%[0-9]+]] = OpINotEqual %v2bool [[vfrom2]] [[v2uint_1]]
// CHECK-NEXT: OpStore %vb2 [[vc2]]
vb2 = vfrom2;
// CHECK-NEXT: [[vfrom3:%[0-9]+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc3:%[0-9]+]] = OpFOrdNotEqual %v3bool [[vfrom3]] [[v3float_2]]
// CHECK-NEXT: OpStore %vb3 [[vc3]]
vb3 = vfrom3;
float2x3 floatMat;
int2x3 intMat;
uint2x3 uintMat;
bool2x3 boolMat;
// CHECK: [[floatMat:%[0-9]+]] = OpLoad %mat2v3float %floatMat
// CHECK-NEXT: [[floatMat0:%[0-9]+]] = OpCompositeExtract %v3float [[floatMat]] 0
// CHECK-NEXT: [[boolMat0:%[0-9]+]] = OpFOrdNotEqual %v3bool [[floatMat0]] [[v3float_2]]
// CHECK-NEXT: [[floatMat1:%[0-9]+]] = OpCompositeExtract %v3float [[floatMat]] 1
// CHECK-NEXT: [[boolMat1:%[0-9]+]] = OpFOrdNotEqual %v3bool [[floatMat1]] [[v3float_2]]
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %_arr_v3bool_uint_2 [[boolMat0]] [[boolMat1]]
boolMat = floatMat;
// CHECK: [[intMat:%[0-9]+]] = OpLoad %_arr_v3int_uint_2 %intMat
// CHECK-NEXT: [[intMat0:%[0-9]+]] = OpCompositeExtract %v3int [[intMat]] 0
// CHECK-NEXT: [[boolMat0_0:%[0-9]+]] = OpINotEqual %v3bool [[intMat0]] [[v3i0]]
// CHECK-NEXT: [[intMat1:%[0-9]+]] = OpCompositeExtract %v3int [[intMat]] 1
// CHECK-NEXT: [[boolMat1_0:%[0-9]+]] = OpINotEqual %v3bool [[intMat1]] [[v3i0]]
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %_arr_v3bool_uint_2 [[boolMat0_0]] [[boolMat1_0]]
boolMat = intMat;
// CHECK: [[uintMat:%[0-9]+]] = OpLoad %_arr_v3uint_uint_2 %uintMat
// CHECK-NEXT: [[uintMat0:%[0-9]+]] = OpCompositeExtract %v3uint [[uintMat]] 0
// CHECK-NEXT: [[boolMat0_1:%[0-9]+]] = OpINotEqual %v3bool [[uintMat0]] [[v3u0]]
// CHECK-NEXT: [[uintMat1:%[0-9]+]] = OpCompositeExtract %v3uint [[uintMat]] 1
// CHECK-NEXT: [[boolMat1_1:%[0-9]+]] = OpINotEqual %v3bool [[uintMat1]] [[v3u0]]
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %_arr_v3bool_uint_2 [[boolMat0_1]] [[boolMat1_1]]
boolMat = uintMat;
}

104
tools/clang/test/CodeGenSPIRV_Lit/cast.2fp.explicit.hlsl Normal file
Просмотреть файл

@ -0,0 +1,104 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
// CHECK: [[v2float_1_1:%[0-9]+]] = OpConstantComposite %v2float %float_1 %float_1
// CHECK: [[v2float_1:%[0-9]+]] = OpConstantComposite %v2float %float_0 %float_0
// CHECK: [[v3float_1_2_n3:%[0-9]+]] = OpConstantComposite %v3float %float_1 %float_2 %float_n3
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
float f;
uint from1;
bool from2;
int from3;
float1 vf1;
float2 vf2;
float3 vf3;
uint1 vfrom1;
bool2 vfrom2;
int3 vfrom3;
// C style cast
// From constant (explicit)
// CHECK: OpStore %f %float_1
f = (float)true;
// CHECK-NEXT: OpStore %f %float_4
f = (float)4u;
// From constant expr
// CHECK-NEXT: OpStore %f %float_n2
f = (float)(3 - 5);
// From variable (explicit)
// CHECK-NEXT: [[from1:%[0-9]+]] = OpLoad %uint %from1
// CHECK-NEXT: [[c1:%[0-9]+]] = OpConvertUToF %float [[from1]]
// CHECK-NEXT: OpStore %f [[c1]]
f = (float)from1;
// CHECK-NEXT: [[from2:%[0-9]+]] = OpLoad %bool %from2
// CHECK-NEXT: [[c2:%[0-9]+]] = OpSelect %float [[from2]] %float_1 %float_0
// CHECK-NEXT: OpStore %f [[c2]]
f = (float)from2;
// CHECK-NEXT: [[from3:%[0-9]+]] = OpLoad %int %from3
// CHECK-NEXT: [[c3:%[0-9]+]] = OpConvertSToF %float [[from3]]
// CHECK-NEXT: OpStore %f [[c3]]
f = (float)from3;
// C++ function style cast
// CHECK-NEXT: OpStore %f %float_0
f = float(false);
// CHECK-NEXT: OpStore %f %float_2
f = float(2u);
// CHECK-NEXT: OpStore %f %float_3
f = float(-1 + 4);
// CHECK-NEXT: [[from4:%[0-9]+]] = OpLoad %uint %from1
// CHECK-NEXT: [[c4:%[0-9]+]] = OpConvertUToF %float [[from4]]
// CHECK-NEXT: OpStore %f [[c4]]
f = float(from1);
// CHECK-NEXT: [[from5:%[0-9]+]] = OpLoad %bool %from2
// CHECK-NEXT: [[c5:%[0-9]+]] = OpSelect %float [[from5]] %float_1 %float_0
// CHECK-NEXT: OpStore %f [[c5]]
f = float(from2);
// CHECK-NEXT: [[from6:%[0-9]+]] = OpLoad %int %from3
// CHECK-NEXT: [[c6:%[0-9]+]] = OpConvertSToF %float [[from6]]
// CHECK-NEXT: OpStore %f [[c6]]
f = float(from3);
// Vector cases
// CHECK-NEXT: OpStore %vf1 %float_7
vf1 = (float1)7;
// CHECK-NEXT: [[vfrom1:%[0-9]+]] = OpLoad %uint %vfrom1
// CHECK-NEXT: [[vc1:%[0-9]+]] = OpConvertUToF %float [[vfrom1]]
// CHECK-NEXT: OpStore %vf1 [[vc1]]
vf1 = (float1)vfrom1;
// CHECK-NEXT: [[vfrom2:%[0-9]+]] = OpLoad %v2bool %vfrom2
// CHECK-NEXT: [[vc2:%[0-9]+]] = OpSelect %v2float [[vfrom2]] [[v2float_1_1]] [[v2float_1]]
// CHECK-NEXT: OpStore %vf2 [[vc2]]
vf2 = (float2)vfrom2;
// CHECK-NEXT: [[vfrom3:%[0-9]+]] = OpLoad %v3int %vfrom3
// CHECK-NEXT: [[vc3:%[0-9]+]] = OpConvertSToF %v3float [[vfrom3]]
// CHECK-NEXT: OpStore %vf3 [[vc3]]
vf3 = (float3)vfrom3;
// CHECK-NEXT: OpStore %vf1 %float_3
vf1 = float1(3);
// CHECK-NEXT: OpStore %vf3 [[v3float_1_2_n3]]
vf3 = float3(true, 2u, -3);
// CHECK-NEXT: [[vfrom4:%[0-9]+]] = OpLoad %uint %vfrom1
// CHECK-NEXT: [[vc4:%[0-9]+]] = OpConvertUToF %float [[vfrom4]]
// CHECK-NEXT: OpStore %vf1 [[vc4]]
vf1 = float1(vfrom1);
// CHECK-NEXT: [[vfrom5:%[0-9]+]] = OpLoad %v2bool %vfrom2
// CHECK-NEXT: [[vc5:%[0-9]+]] = OpSelect %v2float [[vfrom5]] [[v2float_1_1]] [[v2float_1]]
// CHECK-NEXT: OpStore %vf2 [[vc5]]
vf2 = float2(vfrom2);
// CHECK-NEXT: [[vfrom6:%[0-9]+]] = OpLoad %v3int %vfrom3
// CHECK-NEXT: [[vc6:%[0-9]+]] = OpConvertSToF %v3float [[vfrom6]]
// CHECK-NEXT: OpStore %vf3 [[vc6]]
vf3 = float3(vfrom3);
}

99
tools/clang/test/CodeGenSPIRV_Lit/cast.2fp.implicit.hlsl Normal file
Просмотреть файл

@ -0,0 +1,99 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
// CHECK: [[v2float_1_0:%[0-9]+]] = OpConstantComposite %v2float %float_1 %float_0
// CHECK: [[v3float_0_4_n3:%[0-9]+]] = OpConstantComposite %v3float %float_0 %float_4 %float_n3
// CHECK: [[v3f1:%[0-9]+]] = OpConstantComposite %v3float %float_1 %float_1 %float_1
// CHECK: [[v3f0:%[0-9]+]] = OpConstantComposite %v3float %float_0 %float_0 %float_0
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
float f;
bool from1;
uint from2;
int from3;
float1 vf1;
float2 vf2;
float3 vf3;
bool1 vfrom1;
uint2 vfrom2;
int3 vfrom3;
// From constant (implicit)
// CHECK: OpStore %f %float_1
f = true;
// CHECK-NEXT: OpStore %f %float_3
f = 3u;
// From constant expr
// CHECK-NEXT: OpStore %f %float_n1
f = 5 - 6;
// From variable (implicit)
// CHECK-NEXT: [[from1:%[0-9]+]] = OpLoad %bool %from1
// CHECK-NEXT: [[c1:%[0-9]+]] = OpSelect %float [[from1]] %float_1 %float_0
// CHECK-NEXT: OpStore %f [[c1]]
f = from1;
// CHECK-NEXT: [[from2:%[0-9]+]] = OpLoad %uint %from2
// CHECK-NEXT: [[c2:%[0-9]+]] = OpConvertUToF %float [[from2]]
// CHECK-NEXT: OpStore %f [[c2]]
f = from2;
// CHECK-NEXT: [[from3:%[0-9]+]] = OpLoad %int %from3
// CHECK-NEXT: [[c3:%[0-9]+]] = OpConvertSToF %float [[from3]]
// CHECK-NEXT: OpStore %f [[c3]]
f = from3;
// Vector cases
// CHECK: OpStore %vfc2 [[v2float_1_0]]
// CHECK: OpStore %vfc3 [[v3float_0_4_n3]]
float2 vfc2 = {true, false};
float3 vfc3 = {false, 4u, -3}; // Mixed
// CHECK-NEXT: [[vfrom1:%[0-9]+]] = OpLoad %bool %vfrom1
// CHECK-NEXT: [[vc1:%[0-9]+]] = OpSelect %float [[vfrom1]] %float_1 %float_0
// CHECK-NEXT: OpStore %vf1 [[vc1]]
vf1 = vfrom1;
// CHECK-NEXT: [[vfrom2:%[0-9]+]] = OpLoad %v2uint %vfrom2
// CHECK-NEXT: [[vc2:%[0-9]+]] = OpConvertUToF %v2float [[vfrom2]]
// CHECK-NEXT: OpStore %vf2 [[vc2]]
vf2 = vfrom2;
// CHECK-NEXT: [[vfrom3:%[0-9]+]] = OpLoad %v3int %vfrom3
// CHECK-NEXT: [[vc3:%[0-9]+]] = OpConvertSToF %v3float [[vfrom3]]
// CHECK-NEXT: OpStore %vf3 [[vc3]]
vf3 = vfrom3;
// CHECK: [[a:%[0-9]+]] = OpLoad %bool %a
// CHECK-NEXT: [[int_a:%[0-9]+]] = OpSelect %int [[a]] %int_1 %int_0
// CHECK-NEXT: [[zero_minus_a:%[0-9]+]] = OpISub %int %int_0 [[int_a]]
// CHECK-NEXT: {{%[0-9]+}} = OpConvertSToF %float [[zero_minus_a]]
bool a = false;
float c = 0-a;
int2x3 intMat;
float2x3 floatMat;
uint2x3 uintMat;
bool2x3 boolMat;
// CHECK: [[boolMat:%[0-9]+]] = OpLoad %_arr_v3bool_uint_2 %boolMat
// CHECK-NEXT: [[boolMat0:%[0-9]+]] = OpCompositeExtract %v3bool [[boolMat]] 0
// CHECK-NEXT: [[floatMat0:%[0-9]+]] = OpSelect %v3float [[boolMat0]] [[v3f1]] [[v3f0]]
// CHECK-NEXT: [[boolMat1:%[0-9]+]] = OpCompositeExtract %v3bool [[boolMat]] 1
// CHECK-NEXT: [[floatMat1:%[0-9]+]] = OpSelect %v3float [[boolMat1]] [[v3f1]] [[v3f0]]
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %mat2v3float [[floatMat0]] [[floatMat1]]
floatMat = boolMat;
// CHECK: [[uintMat:%[0-9]+]] = OpLoad %_arr_v3uint_uint_2 %uintMat
// CHECK-NEXT: [[uintMat0:%[0-9]+]] = OpCompositeExtract %v3uint [[uintMat]] 0
// CHECK-NEXT: [[floatMat0_0:%[0-9]+]] = OpConvertUToF %v3float [[uintMat0]]
// CHECK-NEXT: [[uintMat1:%[0-9]+]] = OpCompositeExtract %v3uint [[uintMat]] 1
// CHECK-NEXT: [[floatMat1_0:%[0-9]+]] = OpConvertUToF %v3float [[uintMat1]]
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %mat2v3float [[floatMat0_0]] [[floatMat1_0]]
floatMat = uintMat;
// CHECK: [[intMat:%[0-9]+]] = OpLoad %_arr_v3int_uint_2 %intMat
// CHECK-NEXT: [[intMat0:%[0-9]+]] = OpCompositeExtract %v3int [[intMat]] 0
// CHECK-NEXT: [[floatMat0_1:%[0-9]+]] = OpConvertSToF %v3float [[intMat0]]
// CHECK-NEXT: [[intMat1:%[0-9]+]] = OpCompositeExtract %v3int [[intMat]] 1
// CHECK-NEXT: [[floatMat1_1:%[0-9]+]] = OpConvertSToF %v3float [[intMat1]]
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %mat2v3float [[floatMat0_1]] [[floatMat1_1]]
floatMat = intMat;
}

19
tools/clang/test/CodeGenSPIRV_Lit/cast.2literal-int.implicit.hlsl Normal file
Просмотреть файл

@ -0,0 +1,19 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
void main() {
int a, b;
// CHECK: [[a:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: [[b:%[0-9]+]] = OpLoad %int %b
// CHECK-NEXT: [[eq:%[0-9]+]] = OpIEqual %bool [[a]] [[b]]
// CHECK-NEXT: [[c_int:%[0-9]+]] = OpSelect %int [[eq]] %int_1 %int_0
// CHECK-NEXT: {{%[0-9]+}} = OpINotEqual %bool [[c_int]] %int_1
bool c = (a == b) != 1;
// CHECK: [[a_0:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: [[b_0:%[0-9]+]] = OpLoad %int %b
// CHECK-NEXT: [[eq_0:%[0-9]+]] = OpIEqual %bool [[a_0]] [[b_0]]
// CHECK-NEXT: [[d_float:%[0-9]+]] = OpSelect %float [[eq_0]] %float_1 %float_0
// CHECK-NEXT: {{%[0-9]+}} = OpFOrdNotEqual %bool [[d_float]] %float_1
bool d = (a == b) != 1.0;
}

103
tools/clang/test/CodeGenSPIRV_Lit/cast.2sint.explicit.hlsl Normal file
Просмотреть файл

@ -0,0 +1,103 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
// CHECK: [[v2int_1_1:%[0-9]+]] = OpConstantComposite %v2int %int_1 %int_1
// CHECK: [[v2int_1:%[0-9]+]] = OpConstantComposite %v2int %int_0 %int_0
// CHECK: [[v2int_2_n3:%[0-9]+]] = OpConstantComposite %v2int %int_2 %int_n3
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
int i;
uint from1;
bool from2;
float from3;
int1 vi1;
int2 vi2;
int3 vi3;
uint1 vfrom1;
bool2 vfrom2;
float3 vfrom3;
// C style cast
// From constant (explicit)
// CHECK: OpStore %i %int_1
i = (int)true;
// CHECK-NEXT: OpStore %i %int_3
i = (int)3.0;
// From constant expr
// CHECK-NEXT: OpStore %i %int_n2
i = (int)(3.4 - 5.5);
// From variable (explicit)
// CHECK-NEXT: [[from1:%[0-9]+]] = OpLoad %uint %from1
// CHECK-NEXT: [[c1:%[0-9]+]] = OpBitcast %int [[from1]]
// CHECK-NEXT: OpStore %i [[c1]]
i = (int)from1;
// CHECK-NEXT: [[from2:%[0-9]+]] = OpLoad %bool %from2
// CHECK-NEXT: [[c2:%[0-9]+]] = OpSelect %int [[from2]] %int_1 %int_0
// CHECK-NEXT: OpStore %i [[c2]]
i = (int)from2;
// CHECK-NEXT: [[from3:%[0-9]+]] = OpLoad %float %from3
// CHECK-NEXT: [[c3:%[0-9]+]] = OpConvertFToS %int [[from3]]
// CHECK-NEXT: OpStore %i [[c3]]
i = (int)from3;
// C++ function style cast
// CHECK-NEXT: OpStore %i %int_0
i = int(false);
// CHECK-NEXT: OpStore %i %int_3
i = int(3.5);
// CHECK-NEXT: OpStore %i %int_5
i = int(3.3 + 2.2);
// CHECK-NEXT: [[from4:%[0-9]+]] = OpLoad %uint %from1
// CHECK-NEXT: [[c4:%[0-9]+]] = OpBitcast %int [[from4]]
// CHECK-NEXT: OpStore %i [[c4]]
i = int(from1);
// CHECK-NEXT: [[from5:%[0-9]+]] = OpLoad %bool %from2
// CHECK-NEXT: [[c5:%[0-9]+]] = OpSelect %int [[from5]] %int_1 %int_0
// CHECK-NEXT: OpStore %i [[c5]]
i = int(from2);
// CHECK-NEXT: [[from6:%[0-9]+]] = OpLoad %float %from3
// CHECK-NEXT: [[c6:%[0-9]+]] = OpConvertFToS %int [[from6]]
// CHECK-NEXT: OpStore %i [[c6]]
i = int(from3);
// Vector cases
// CHECK-NEXT: OpStore %vi1 %int_3
vi1 = (int1)3.6;
// CHECK-NEXT: [[vfrom1:%[0-9]+]] = OpLoad %uint %vfrom1
// CHECK-NEXT: [[vc1:%[0-9]+]] = OpBitcast %int [[vfrom1]]
// CHECK-NEXT: OpStore %vi1 [[vc1]]
vi1 = (int1)vfrom1;
// CHECK-NEXT: [[vfrom2:%[0-9]+]] = OpLoad %v2bool %vfrom2
// CHECK-NEXT: [[vc2:%[0-9]+]] = OpSelect %v2int [[vfrom2]] [[v2int_1_1]] [[v2int_1]]
// CHECK-NEXT: OpStore %vi2 [[vc2]]
vi2 = (int2)vfrom2;
// CHECK-NEXT: [[vfrom3:%[0-9]+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc3:%[0-9]+]] = OpConvertFToS %v3int [[vfrom3]]
// CHECK-NEXT: OpStore %vi3 [[vc3]]
vi3 = (int3)vfrom3;
// CHECK-NEXT: OpStore %vi1 %int_3
vi1 = int1(3.5);
// CHECK-NEXT: OpStore %vi2 [[v2int_2_n3]]
vi2 = int2(1.1 + 1.2, -3);
// CHECK-NEXT: [[vfrom4:%[0-9]+]] = OpLoad %uint %vfrom1
// CHECK-NEXT: [[vc4:%[0-9]+]] = OpBitcast %int [[vfrom4]]
// CHECK-NEXT: OpStore %vi1 [[vc4]]
vi1 = int1(vfrom1);
// CHECK-NEXT: [[vfrom5:%[0-9]+]] = OpLoad %v2bool %vfrom2
// CHECK-NEXT: [[vc5:%[0-9]+]] = OpSelect %v2int [[vfrom5]] [[v2int_1_1]] [[v2int_1]]
// CHECK-NEXT: OpStore %vi2 [[vc5]]
vi2 = int2(vfrom2);
// CHECK-NEXT: [[vfrom6:%[0-9]+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc6:%[0-9]+]] = OpConvertFToS %v3int [[vfrom6]]
// CHECK-NEXT: OpStore %vi3 [[vc6]]
vi3 = int3(vfrom3);
}

92
tools/clang/test/CodeGenSPIRV_Lit/cast.2sint.implicit.hlsl Normal file
Просмотреть файл

@ -0,0 +1,92 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
// CHECK: [[v2int_1_0:%[0-9]+]] = OpConstantComposite %v2int %int_1 %int_0
// CHECK: [[v3int_0_2_n3:%[0-9]+]] = OpConstantComposite %v3int %int_0 %int_2 %int_n3
// CHECK: [[v3i1:%[0-9]+]] = OpConstantComposite %v3int %int_1 %int_1 %int_1
// CHECK: [[v3i0:%[0-9]+]] = OpConstantComposite %v3int %int_0 %int_0 %int_0
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
int i;
bool from1;
uint from2;
float from3;
int1 vi1;
int2 vi2;
int3 vi3;
bool1 vfrom1;
uint2 vfrom2;
float3 vfrom3;
// From constant (implicit)
// CHECK: OpStore %i %int_1
i = true;
// CHECK-NEXT: OpStore %i %int_0
i = 0.0;
// From constant expr
// CHECK-NEXT: OpStore %i %int_n3
i = 1.1 - 4.3;
// From variable (implicit)
// CHECK-NEXT: [[from1:%[0-9]+]] = OpLoad %bool %from1
// CHECK-NEXT: [[c1:%[0-9]+]] = OpSelect %int [[from1]] %int_1 %int_0
// CHECK-NEXT: OpStore %i [[c1]]
i = from1;
// CHECK-NEXT: [[from2:%[0-9]+]] = OpLoad %uint %from2
// CHECK-NEXT: [[c2:%[0-9]+]] = OpBitcast %int [[from2]]
// CHECK-NEXT: OpStore %i [[c2]]
i = from2;
// CHECK-NEXT: [[from3:%[0-9]+]] = OpLoad %float %from3
// CHECK-NEXT: [[c3:%[0-9]+]] = OpConvertFToS %int [[from3]]
// CHECK-NEXT: OpStore %i [[c3]]
i = from3;
// Vector cases
// CHECK: OpStore %vic2 [[v2int_1_0]]
// CHECK: OpStore %vic3 [[v3int_0_2_n3]]
int2 vic2 = {true, false};
int3 vic3 = {false, 1.1 + 1.2, -3}; // Mixed
// CHECK-NEXT: [[vfrom1:%[0-9]+]] = OpLoad %bool %vfrom1
// CHECK-NEXT: [[vc1:%[0-9]+]] = OpSelect %int [[vfrom1]] %int_1 %int_0
// CHECK-NEXT: OpStore %vi1 [[vc1]]
vi1 = vfrom1;
// CHECK-NEXT: [[vfrom2:%[0-9]+]] = OpLoad %v2uint %vfrom2
// CHECK-NEXT: [[vc2:%[0-9]+]] = OpBitcast %v2int [[vfrom2]]
// CHECK-NEXT: OpStore %vi2 [[vc2]]
vi2 = vfrom2;
// CHECK-NEXT: [[vfrom3:%[0-9]+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc3:%[0-9]+]] = OpConvertFToS %v3int [[vfrom3]]
// CHECK-NEXT: OpStore %vi3 [[vc3]]
vi3 = vfrom3;
int2x3 intMat;
float2x3 floatMat;
uint2x3 uintMat;
bool2x3 boolMat;
// CHECK: [[boolMat:%[0-9]+]] = OpLoad %_arr_v3bool_uint_2 %boolMat
// CHECK-NEXT: [[boolMat0:%[0-9]+]] = OpCompositeExtract %v3bool [[boolMat]] 0
// CHECK-NEXT: [[intMat0:%[0-9]+]] = OpSelect %v3int [[boolMat0]] [[v3i1]] [[v3i0]]
// CHECK-NEXT: [[boolMat1:%[0-9]+]] = OpCompositeExtract %v3bool [[boolMat]] 1
// CHECK-NEXT: [[intMat1:%[0-9]+]] = OpSelect %v3int [[boolMat1]] [[v3i1]] [[v3i0]]
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %_arr_v3int_uint_2 [[intMat0]] [[intMat1]]
intMat = boolMat;
// CHECK: [[uintMat:%[0-9]+]] = OpLoad %_arr_v3uint_uint_2 %uintMat
// CHECK-NEXT: [[uintMat0:%[0-9]+]] = OpCompositeExtract %v3uint [[uintMat]] 0
// CHECK-NEXT: [[intMat0_0:%[0-9]+]] = OpBitcast %v3int [[uintMat0]]
// CHECK-NEXT: [[uintMat1:%[0-9]+]] = OpCompositeExtract %v3uint [[uintMat]] 1
// CHECK-NEXT: [[intMat1_0:%[0-9]+]] = OpBitcast %v3int [[uintMat1]]
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %_arr_v3int_uint_2 [[intMat0_0]] [[intMat1_0]]
intMat = uintMat;
// CHECK: [[floatMat:%[0-9]+]] = OpLoad %mat2v3float %floatMat
// CHECK-NEXT: [[floatMat0:%[0-9]+]] = OpCompositeExtract %v3float [[floatMat]] 0
// CHECK-NEXT: [[intMat0_1:%[0-9]+]] = OpConvertFToS %v3int [[floatMat0]]
// CHECK-NEXT: [[floatMat1:%[0-9]+]] = OpCompositeExtract %v3float [[floatMat]] 1
// CHECK-NEXT: [[intMat1_1:%[0-9]+]] = OpConvertFToS %v3int [[floatMat1]]
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %_arr_v3int_uint_2 [[intMat0_1]] [[intMat1_1]]
intMat = floatMat;
}

104
tools/clang/test/CodeGenSPIRV_Lit/cast.2uint.explicit.hlsl Normal file
Просмотреть файл

@ -0,0 +1,104 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
// CHECK: [[v2uint_1_1:%[0-9]+]] = OpConstantComposite %v2uint %uint_1 %uint_1
// CHECK: [[v2uint_1:%[0-9]+]] = OpConstantComposite %v2uint %uint_0 %uint_0
// CHECK: [[v2uint_2_3:%[0-9]+]] = OpConstantComposite %v2uint %uint_2 %uint_3
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
uint i;
int from1;
bool from2;
float from3;
uint1 vi1;
uint2 vi2;
uint3 vi3;
int1 vfrom1;
bool2 vfrom2;
float3 vfrom3;
// C style cast
// From constant (explicit)
// CHECK: OpStore %i %uint_1
i = (uint)true;
// CHECK-NEXT: OpStore %i %uint_3
i = (uint)3.0;
// From constant expr
// CHECK-NEXT: OpStore %i %uint_2
i = (uint)(5.5 - 3.4);
// From variable (explicit)
// CHECK-NEXT: [[from1:%[0-9]+]] = OpLoad %int %from1
// CHECK-NEXT: [[c1:%[0-9]+]] = OpBitcast %uint [[from1]]
// CHECK-NEXT: OpStore %i [[c1]]
i = (uint)from1;
// CHECK-NEXT: [[from2:%[0-9]+]] = OpLoad %bool %from2
// CHECK-NEXT: [[c2:%[0-9]+]] = OpSelect %uint [[from2]] %uint_1 %uint_0
// CHECK-NEXT: OpStore %i [[c2]]
i = (uint)from2;
// CHECK-NEXT: [[from3:%[0-9]+]] = OpLoad %float %from3
// CHECK-NEXT: [[c3:%[0-9]+]] = OpConvertFToU %uint [[from3]]
// CHECK-NEXT: OpStore %i [[c3]]
i = (uint)from3;
// C++ function style cast
// CHECK-NEXT: OpStore %i %uint_0
i = uint(false);
// CHECK-NEXT: OpStore %i %uint_3
i = uint(3.5);
// CHECK-NEXT: OpStore %i %uint_5
i = uint(3.3 + 2.2);
// CHECK-NEXT: [[from4:%[0-9]+]] = OpLoad %int %from1
// CHECK-NEXT: [[c4:%[0-9]+]] = OpBitcast %uint [[from4]]
// CHECK-NEXT: OpStore %i [[c4]]
i = uint(from1);
// CHECK-NEXT: [[from5:%[0-9]+]] = OpLoad %bool %from2
// CHECK-NEXT: [[c5:%[0-9]+]] = OpSelect %uint [[from5]] %uint_1 %uint_0
// CHECK-NEXT: OpStore %i [[c5]]
i = uint(from2);
// CHECK-NEXT: [[from6:%[0-9]+]] = OpLoad %float %from3
// CHECK-NEXT: [[c6:%[0-9]+]] = OpConvertFToU %uint [[from6]]
// CHECK-NEXT: OpStore %i [[c6]]
i = uint(from3);
// Vector cases
// CHECK-NEXT: OpStore %vi1 %uint_3
vi1 = (uint1)3.6;
// CHECK-NEXT: [[vfrom1:%[0-9]+]] = OpLoad %int %vfrom1
// CHECK-NEXT: [[vc1:%[0-9]+]] = OpBitcast %uint [[vfrom1]]
// CHECK-NEXT: OpStore %vi1 [[vc1]]
vi1 = (uint1)vfrom1;
// CHECK-NEXT: [[vfrom2:%[0-9]+]] = OpLoad %v2bool %vfrom2
// CHECK-NEXT: [[vc2:%[0-9]+]] = OpSelect %v2uint [[vfrom2]] [[v2uint_1_1]] [[v2uint_1]]
// CHECK-NEXT: OpStore %vi2 [[vc2]]
vi2 = (uint2)vfrom2;
// CHECK-NEXT: [[vfrom3:%[0-9]+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc3:%[0-9]+]] = OpConvertFToU %v3uint [[vfrom3]]
// CHECK-NEXT: OpStore %vi3 [[vc3]]
vi3 = (uint3)vfrom3;
// CHECK-NEXT: OpStore %vi1 %uint_3
vi1 = uint1(3.5);
// CHECK-NEXT: OpStore %vi2 [[v2uint_2_3]]
vi2 = uint2(1.1 + 1.2, 3);
// CHECK-NEXT: [[vfrom4:%[0-9]+]] = OpLoad %int %vfrom1
// CHECK-NEXT: [[vc4:%[0-9]+]] = OpBitcast %uint [[vfrom4]]
// CHECK-NEXT: OpStore %vi1 [[vc4]]
vi1 = uint1(vfrom1);
// CHECK-NEXT: [[vfrom5:%[0-9]+]] = OpLoad %v2bool %vfrom2
// CHECK-NEXT: [[vc5:%[0-9]+]] = OpSelect %v2uint [[vfrom5]] [[v2uint_1_1]] [[v2uint_1]]
// CHECK-NEXT: OpStore %vi2 [[vc5]]
vi2 = uint2(vfrom2);
// CHECK-NEXT: [[vfrom6:%[0-9]+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc6:%[0-9]+]] = OpConvertFToU %v3uint [[vfrom6]]
// CHECK-NEXT: OpStore %vi3 [[vc6]]
vi3 = uint3(vfrom3);
}

92
tools/clang/test/CodeGenSPIRV_Lit/cast.2uint.implicit.hlsl Normal file
Просмотреть файл

@ -0,0 +1,92 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
// CHECK: [[v2uint_1_0:%[0-9]+]] = OpConstantComposite %v2uint %uint_1 %uint_0
// CHECK: [[v3uint_0_2_3:%[0-9]+]] = OpConstantComposite %v3uint %uint_0 %uint_2 %uint_3
// CHECK: [[v3u1:%[0-9]+]] = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1
// CHECK: [[v3u0:%[0-9]+]] = OpConstantComposite %v3uint %uint_0 %uint_0 %uint_0
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
uint i;
bool from1;
int from2;
float from3;
uint1 vi1;
uint2 vi2;
uint3 vi3;
bool1 vfrom1;
int2 vfrom2;
float3 vfrom3;
// From constant (implicit)
// CHECK: OpStore %i %uint_1
i = true;
// CHECK-NEXT: OpStore %i %uint_0
i = 0.0;
// From constant expr
// CHECK-NEXT: OpStore %i %uint_3
i = 4.3 - 1.1;
// From variable (implicit)
// CHECK-NEXT: [[from1:%[0-9]+]] = OpLoad %bool %from1
// CHECK-NEXT: [[c1:%[0-9]+]] = OpSelect %uint [[from1]] %uint_1 %uint_0
// CHECK-NEXT: OpStore %i [[c1]]
i = from1;
// CHECK-NEXT: [[from2:%[0-9]+]] = OpLoad %int %from2
// CHECK-NEXT: [[c2:%[0-9]+]] = OpBitcast %uint [[from2]]
// CHECK-NEXT: OpStore %i [[c2]]
i = from2;
// CHECK-NEXT: [[from3:%[0-9]+]] = OpLoad %float %from3
// CHECK-NEXT: [[c3:%[0-9]+]] = OpConvertFToU %uint [[from3]]
// CHECK-NEXT: OpStore %i [[c3]]
i = from3;
// Vector cases
// CHECK: OpStore %vic2 [[v2uint_1_0]]
// CHECK: OpStore %vic3 [[v3uint_0_2_3]]
uint2 vic2 = {true, false};
uint3 vic3 = {false, 1.1 + 1.2, 3}; // Mixed
// CHECK-NEXT: [[vfrom1:%[0-9]+]] = OpLoad %bool %vfrom1
// CHECK-NEXT: [[vc1:%[0-9]+]] = OpSelect %uint [[vfrom1]] %uint_1 %uint_0
// CHECK-NEXT: OpStore %vi1 [[vc1]]
vi1 = vfrom1;
// CHECK-NEXT: [[vfrom2:%[0-9]+]] = OpLoad %v2int %vfrom2
// CHECK-NEXT: [[vc2:%[0-9]+]] = OpBitcast %v2uint [[vfrom2]]
// CHECK-NEXT: OpStore %vi2 [[vc2]]
vi2 = vfrom2;
// CHECK-NEXT: [[vfrom3:%[0-9]+]] = OpLoad %v3float %vfrom3
// CHECK-NEXT: [[vc3:%[0-9]+]] = OpConvertFToU %v3uint [[vfrom3]]
// CHECK-NEXT: OpStore %vi3 [[vc3]]
vi3 = vfrom3;
int2x3 intMat;
float2x3 floatMat;
uint2x3 uintMat;
bool2x3 boolMat;
// CHECK: [[boolMat:%[0-9]+]] = OpLoad %_arr_v3bool_uint_2 %boolMat
// CHECK-NEXT: [[boolMat0:%[0-9]+]] = OpCompositeExtract %v3bool [[boolMat]] 0
// CHECK-NEXT: [[uintMat0:%[0-9]+]] = OpSelect %v3uint [[boolMat0]] [[v3u1]] [[v3u0]]
// CHECK-NEXT: [[boolMat1:%[0-9]+]] = OpCompositeExtract %v3bool [[boolMat]] 1
// CHECK-NEXT: [[uintMat1:%[0-9]+]] = OpSelect %v3uint [[boolMat1]] [[v3u1]] [[v3u0]]
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %_arr_v3uint_uint_2 [[uintMat0]] [[uintMat1]]
uintMat = boolMat;
// CHECK: [[intMat:%[0-9]+]] = OpLoad %_arr_v3int_uint_2 %intMat
// CHECK-NEXT: [[intMat0:%[0-9]+]] = OpCompositeExtract %v3int [[intMat]] 0
// CHECK-NEXT: [[uintMat0_0:%[0-9]+]] = OpBitcast %v3uint [[intMat0]]
// CHECK-NEXT: [[intMat1:%[0-9]+]] = OpCompositeExtract %v3int [[intMat]] 1
// CHECK-NEXT: [[uintMat1_0:%[0-9]+]] = OpBitcast %v3uint [[intMat1]]
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %_arr_v3uint_uint_2 [[uintMat0_0]] [[uintMat1_0]]
uintMat = intMat;
// CHECK: [[floatMat:%[0-9]+]] = OpLoad %mat2v3float %floatMat
// CHECK-NEXT: [[floatMat0:%[0-9]+]] = OpCompositeExtract %v3float [[floatMat]] 0
// CHECK-NEXT: [[uintMat0_1:%[0-9]+]] = OpConvertFToU %v3uint [[floatMat0]]
// CHECK-NEXT: [[floatMat1:%[0-9]+]] = OpCompositeExtract %v3float [[floatMat]] 1
// CHECK-NEXT: [[uintMat1_1:%[0-9]+]] = OpConvertFToU %v3uint [[floatMat1]]
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %_arr_v3uint_uint_2 [[uintMat0_1]] [[uintMat1_1]]
uintMat = floatMat;
}

165
tools/clang/test/CodeGenSPIRV_Lit/cast.bitwidth.hlsl Normal file
Просмотреть файл

@ -0,0 +1,165 @@
// RUN: %dxc -T ps_6_2 -E main -enable-16bit-types -fcgl %s -spirv | FileCheck %s
void main() {
// 32-bit uint to various 64-bit types.
uint a;
// CHECK: [[a:%[0-9]+]] = OpLoad %uint %a
// CHECK-NEXT: [[a_ulong:%[0-9]+]] = OpUConvert %ulong [[a]]
// CHECK-NEXT: OpStore %b [[a_ulong]]
uint64_t b = a;
// CHECK: [[a_0:%[0-9]+]] = OpLoad %uint %a
// CHECK-NEXT: [[a_ulong_0:%[0-9]+]] = OpUConvert %ulong [[a_0]]
// CHECK-NEXT:[[a_double:%[0-9]+]] = OpConvertUToF %double [[a_ulong_0]]
// CHECK-NEXT: OpStore %c [[a_double]]
double c = a;
// CHECK: [[a_1:%[0-9]+]] = OpLoad %uint %a
// CHECK-NEXT: [[a_ulong_1:%[0-9]+]] = OpUConvert %ulong [[a_1]]
// CHECK-NEXT: [[a_long:%[0-9]+]] = OpBitcast %long [[a_ulong_1]]
// CHECK-NEXT: OpStore %d [[a_long]]
int64_t d = a;
// 32-bit int to various 64-bit types.
int aa;
// CHECK: [[aa:%[0-9]+]] = OpLoad %int %aa
// CHECK-NEXT: [[aa_long:%[0-9]+]] = OpSConvert %long [[aa]]
// CHECK-NEXT: [[aa_ulong:%[0-9]+]] = OpBitcast %ulong [[aa_long]]
// CHECK-NEXT: OpStore %bb [[aa_ulong]]
uint64_t bb = aa;
// CHECK: [[aa_0:%[0-9]+]] = OpLoad %int %aa
// CHECK-NEXT: [[aa_long_0:%[0-9]+]] = OpSConvert %long [[aa_0]]
// CHECK-NEXT: [[aa_double:%[0-9]+]] = OpConvertSToF %double [[aa_long_0]]
// CHECK-NEXT: OpStore %cc [[aa_double]]
double cc = aa;
// CHECK: [[aa_1:%[0-9]+]] = OpLoad %int %aa
// CHECK-NEXT: [[aa_long_1:%[0-9]+]] = OpSConvert %long [[aa_1]]
// CHECK-NEXT: OpStore %dd [[aa_long_1]]
int64_t dd = aa;
// 32-bit float to various 64-bit types.
float aaa;
// CHECK: [[aaa:%[0-9]+]] = OpLoad %float %aaa
// CHECK-NEXT: [[aaa_double:%[0-9]+]] = OpFConvert %double [[aaa]]
// CHECK-NEXT: [[aaa_ulong:%[0-9]+]] = OpConvertFToU %ulong [[aaa_double]]
// CHECK-NEXT: OpStore %bbb [[aaa_ulong]]
uint64_t bbb = aaa;
// CHECK: [[aaa_0:%[0-9]+]] = OpLoad %float %aaa
// CHECK-NEXT: [[aaa_double_0:%[0-9]+]] = OpFConvert %double [[aaa_0]]
// CHECK-NEXT: OpStore %ccc [[aaa_double_0]]
double ccc = aaa;
// CHECK: [[aaa_1:%[0-9]+]] = OpLoad %float %aaa
// CHECK-NEXT: [[aaa_double_1:%[0-9]+]] = OpFConvert %double [[aaa_1]]
// CHECK-NEXT: [[aaa_long:%[0-9]+]] = OpConvertFToS %long [[aaa_double_1]]
// CHECK-NEXT: OpStore %ddd [[aaa_long]]
int64_t ddd = aaa;
// 64-bit uint to various 32-bit types.
uint64_t e;
// CHECK: [[e64:%[0-9]+]] = OpLoad %ulong %e
// CHECK-NEXT: [[e32:%[0-9]+]] = OpUConvert %uint [[e64]]
// CHECK-NEXT: OpStore %f [[e32]]
uint f = e;
// CHECK: [[e64_0:%[0-9]+]] = OpLoad %ulong %e
// CHECK-NEXT: [[e32_0:%[0-9]+]] = OpUConvert %uint [[e64_0]]
// CHECK-NEXT: [[e_float:%[0-9]+]] = OpConvertUToF %float [[e32_0]]
// CHECK-NEXT: OpStore %g [[e_float]]
float g = e;
// CHECK: [[e64_1:%[0-9]+]] = OpLoad %ulong %e
// CHECK-NEXT: [[e32_1:%[0-9]+]] = OpUConvert %uint [[e64_1]]
// CHECK-NEXT: [[e_int:%[0-9]+]] = OpBitcast %int [[e32_1]]
// CHECK-NEXT: OpStore %h [[e_int]]
int h = e;
// 64-bit int to various 32-bit types.
int64_t ee;
// CHECK: [[e:%[0-9]+]] = OpLoad %long %ee
// CHECK-NEXT: [[e_int_0:%[0-9]+]] = OpSConvert %int [[e]]
// CHECK-NEXT: [[e_uint:%[0-9]+]] = OpBitcast %uint [[e_int_0]]
// CHECK-NEXT: OpStore %ff [[e_uint]]
uint ff = ee;
// CHECK: [[e_0:%[0-9]+]] = OpLoad %long %ee
// CHECK-NEXT: [[e_int_1:%[0-9]+]] = OpSConvert %int [[e_0]]
// CHECK-NEXT: [[e_float_0:%[0-9]+]] = OpConvertSToF %float [[e_int_1]]
// CHECK-NEXT: OpStore %gg [[e_float_0]]
float gg = ee;
// CHECK: [[e_1:%[0-9]+]] = OpLoad %long %ee
// CHECK-NEXT: [[e_int_2:%[0-9]+]] = OpSConvert %int [[e_1]]
// CHECK-NEXT: OpStore %hh [[e_int_2]]
int hh = ee;
// 64-bit float to various 32-bit types.
double eee;
// CHECK: [[e64_2:%[0-9]+]] = OpLoad %double %eee
// CHECK-NEXT: [[e32_2:%[0-9]+]] = OpFConvert %float [[e64_2]]
// CHECK-NEXT: [[e_uint_0:%[0-9]+]] = OpConvertFToU %uint [[e32_2]]
// CHECK-NEXT: OpStore %fff [[e_uint_0]]
uint fff = eee;
// CHECK: [[e_2:%[0-9]+]] = OpLoad %double %eee
// CHECK-NEXT: [[e_float_1:%[0-9]+]] = OpFConvert %float [[e_2]]
// CHECK-NEXT: OpStore %ggg [[e_float_1]]
float ggg = eee;
// CHECK: [[e_3:%[0-9]+]] = OpLoad %double %eee
// CHECK-NEXT: [[e_float_2:%[0-9]+]] = OpFConvert %float [[e_3]]
// CHECK-NEXT: [[e_int_3:%[0-9]+]] = OpConvertFToS %int [[e_float_2]]
// CHECK-NEXT: OpStore %hhh [[e_int_3]]
int hhh = eee;
// Vector case: 64-bit float to various 32-bit types.
double2 i;
// CHECK: [[i_double:%[0-9]+]] = OpLoad %v2double %i
// CHECK-NEXT: [[i_float:%[0-9]+]] = OpFConvert %v2float [[i_double]]
// CHECK-NEXT: [[i_uint:%[0-9]+]] = OpConvertFToU %v2uint [[i_float]]
// CHECK-NEXT: OpStore %j [[i_uint]]
uint2 j = i;
// CHECK: [[i_double_0:%[0-9]+]] = OpLoad %v2double %i
// CHECK-NEXT: [[i_float_0:%[0-9]+]] = OpFConvert %v2float [[i_double_0]]
// CHECK-NEXT: [[i_int:%[0-9]+]] = OpConvertFToS %v2int [[i_float_0]]
// CHECK-NEXT: OpStore %k [[i_int]]
int2 k = i;
// CHECK: [[i_double_1:%[0-9]+]] = OpLoad %v2double %i
// CHECK-NEXT: [[i_float_1:%[0-9]+]] = OpFConvert %v2float [[i_double_1]]
// CHECK-NEXT: OpStore %l [[i_float_1]]
float2 l = i;
// 16-bit uint to various 32-bit types.
uint16_t m;
// CHECK: [[m_ushort:%[0-9]+]] = OpLoad %ushort %m
// CHECK-NEXT: [[m_uint:%[0-9]+]] = OpUConvert %uint [[m_ushort]]
// CHECK-NEXT: OpStore %n [[m_uint]]
uint n = m;
// CHECK: [[m_ushort_0:%[0-9]+]] = OpLoad %ushort %m
// CHECK-NEXT: [[m_uint_0:%[0-9]+]] = OpUConvert %uint [[m_ushort_0]]
// CHECK-NEXT: [[m_float:%[0-9]+]] = OpConvertUToF %float [[m_uint_0]]
// CHECK-NEXT: OpStore %o [[m_float]]
float o = m;
// CHECK: [[m_ushort_1:%[0-9]+]] = OpLoad %ushort %m
// CHECK-NEXT: [[m_uint_1:%[0-9]+]] = OpUConvert %uint [[m_ushort_1]]
// CHECK-NEXT: [[m_int:%[0-9]+]] = OpBitcast %int [[m_uint_1]]
// CHECK-NEXT: OpStore %p [[m_int]]
int p = m;
// 16-bit int to various 32-bit types.
int16_t mm;
// CHECK: [[mm_short:%[0-9]+]] = OpLoad %short %mm
// CHECK-NEXT: [[mm_int:%[0-9]+]] = OpSConvert %int [[mm_short]]
// CHECK-NEXT: [[mm_uint:%[0-9]+]] = OpBitcast %uint [[mm_int]]
// CHECK-NEXT: OpStore %nn [[mm_uint]]
uint nn = mm;
// CHECK: [[mm_short_0:%[0-9]+]] = OpLoad %short %mm
// CHECK-NEXT: [[mm_int_0:%[0-9]+]] = OpSConvert %int [[mm_short_0]]
// CHECK-NEXT: [[mm_float:%[0-9]+]] = OpConvertSToF %float [[mm_int_0]]
// CHECK-NEXT: OpStore %oo [[mm_float]]
float oo = mm;
// CHECK: [[mm_short_1:%[0-9]+]] = OpLoad %short %mm
// CHECK-NEXT: [[mm_int_1:%[0-9]+]] = OpSConvert %int [[mm_short_1]]
// CHECK-NEXT: OpStore %pp [[mm_int_1]]
int pp = mm;
}

105
tools/clang/test/CodeGenSPIRV_Lit/cast.flat-conversion.array-to-vector.hlsl Normal file
Просмотреть файл

@ -0,0 +1,105 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
typedef int A[2];
ConsumeStructuredBuffer<A> intarr_consume;
A getA() {
A a = intarr_consume.Consume();
return a;
}
typedef float B[2];
ConsumeStructuredBuffer<B> floatarr_consume;
B getB() {
B b = floatarr_consume.Consume();
return b;
}
typedef bool C[2];
ConsumeStructuredBuffer<C> boolarr_consume;
C getC() {
C c = boolarr_consume.Consume();
return c;
}
void main() {
// CHECK: [[call_0:%[0-9]+]] = OpFunctionCall %_arr_int_uint_2_0 %getA
// CHECK-NEXT: [[i_1:%[0-9]+]] = OpCompositeExtract %int [[call_0]] 0
// CHECK-NEXT: [[i_0_1:%[0-9]+]] = OpCompositeExtract %int [[call_0]] 1
// CHECK-NEXT: [[vi_0:%[0-9]+]] = OpCompositeConstruct %v2int [[i_1]] [[i_0_1]]
// CHECK-NEXT: OpStore %intarray_to_intvec [[vi_0]]
int2 intarray_to_intvec = (int2)getA();
// CHECK: [[call_1:%[0-9]+]] = OpFunctionCall %_arr_float_uint_2_0 %getB
// CHECK-NEXT: [[f_1_0:%[0-9]+]] = OpCompositeExtract %float [[call_1]] 0
// CHECK-NEXT: [[f_1_1:%[0-9]+]] = OpCompositeExtract %float [[call_1]] 1
// CHECK-NEXT: [[vf_1:%[0-9]+]] = OpCompositeConstruct %v2float [[f_1_0]] [[f_1_1]]
// CHECK-NEXT: OpStore %floatarray_to_floatvec [[vf_1]]
float2 floatarray_to_floatvec = (float2)getB();
// CHECK: [[call_2:%[0-9]+]] = OpFunctionCall %_arr_bool_uint_2 %getC
// CHECK-NEXT: [[b_2_0:%[0-9]+]] = OpCompositeExtract %bool [[call_2]] 0
// CHECK-NEXT: [[b_2_1:%[0-9]+]] = OpCompositeExtract %bool [[call_2]] 1
// CHECK-NEXT: [[vb_2:%[0-9]+]] = OpCompositeConstruct %v2bool [[b_2_0]] [[b_2_1]]
// CHECK-NEXT: OpStore %boolarray_to_boolvec [[vb_2]]
bool2 boolarray_to_boolvec = (bool2)getC();
// CHECK: [[call_3:%[0-9]+]] = OpFunctionCall %_arr_float_uint_2_0 %getB
// CHECK-NEXT: [[f_3_0:%[0-9]+]] = OpCompositeExtract %float [[call_3]] 0
// CHECK-NEXT: [[f_3_1:%[0-9]+]] = OpCompositeExtract %float [[call_3]] 1
// CHECK-NEXT: [[i_3_0:%[0-9]+]] = OpConvertFToS %int [[f_3_0]]
// CHECK-NEXT: [[i_3_1:%[0-9]+]] = OpConvertFToS %int [[f_3_1]]
// CHECK-NEXT: [[vi_3:%[0-9]+]] = OpCompositeConstruct %v2int [[i_3_0]] [[i_3_1]]
// CHECK-NEXT: OpStore %floatarray_to_intvec [[vi_3]]
int2 floatarray_to_intvec = (int2)getB();
// CHECK: [[call_4:%[0-9]+]] = OpFunctionCall %_arr_bool_uint_2 %getC
// CHECK-NEXT: [[b_4_0:%[0-9]+]] = OpCompositeExtract %bool [[call_4]] 0
// CHECK-NEXT: [[b_4_1:%[0-9]+]] = OpCompositeExtract %bool [[call_4]] 1
// CHECK-NEXT: [[i_4_0:%[0-9]+]] = OpSelect %int [[b_4_0]] %int_1 %int_0
// CHECK-NEXT: [[i_4_1:%[0-9]+]] = OpSelect %int [[b_4_1]] %int_1 %int_0
// CHECK-NEXT: [[vi_4:%[0-9]+]] = OpCompositeConstruct %v2int [[i_4_0]] [[i_4_1]]
// CHECK-NEXT: OpStore %boolarray_to_intvec [[vi_4]]
int2 boolarray_to_intvec = (int2)getC();
// CHECK: [[call_5:%[0-9]+]] = OpFunctionCall %_arr_int_uint_2_0 %getA
// CHECK-NEXT: [[i_5_0:%[0-9]+]] = OpCompositeExtract %int [[call_5]] 0
// CHECK-NEXT: [[i_5_1:%[0-9]+]] = OpCompositeExtract %int [[call_5]] 1
// CHECK-NEXT: [[f_5_0:%[0-9]+]] = OpConvertSToF %float [[i_5_0]]
// CHECK-NEXT: [[f_5_1:%[0-9]+]] = OpConvertSToF %float [[i_5_1]]
// CHECK-NEXT: [[vf_5:%[0-9]+]] = OpCompositeConstruct %v2float [[f_5_0]] [[f_5_1]]
// CHECK-NEXT: OpStore %intarray_to_floatvec [[vf_5]]
float2 intarray_to_floatvec = (float2)getA();
// CHECK: [[call_6:%[0-9]+]] = OpFunctionCall %_arr_bool_uint_2 %getC
// CHECK-NEXT: [[b_6_0:%[0-9]+]] = OpCompositeExtract %bool [[call_6]] 0
// CHECK-NEXT: [[b_6_1:%[0-9]+]] = OpCompositeExtract %bool [[call_6]] 1
// CHECK-NEXT: [[f_6_0:%[0-9]+]] = OpSelect %float [[b_6_0]] %float_1 %float_0
// CHECK-NEXT: [[f_6_1:%[0-9]+]] = OpSelect %float [[b_6_1]] %float_1 %float_0
// CHECK-NEXT: [[vf_6:%[0-9]+]] = OpCompositeConstruct %v2float [[f_6_0]] [[f_6_1]]
// CHECK-NEXT: OpStore %boolarray_to_floatvec [[vf_6]]
float2 boolarray_to_floatvec = (float2)getC();
// CHECK: [[call_7:%[0-9]+]] = OpFunctionCall %_arr_int_uint_2_0 %getA
// CHECK-NEXT: [[i_7_0:%[0-9]+]] = OpCompositeExtract %int [[call_7]] 0
// CHECK-NEXT: [[i_7_1:%[0-9]+]] = OpCompositeExtract %int [[call_7]] 1
// CHECK-NEXT: [[b_7_0:%[0-9]+]] = OpINotEqual %bool [[i_7_0]] %int_0
// CHECK-NEXT: [[b_7_1:%[0-9]+]] = OpINotEqual %bool [[i_7_1]] %int_0
// CHECK-NEXT: [[vb_7:%[0-9]+]] = OpCompositeConstruct %v2bool [[b_7_0]] [[b_7_1]]
// CHECK-NEXT: OpStore %intarray_to_boolvec [[vb_7]]
bool2 intarray_to_boolvec = (bool2)getA();
// CHECK: [[call_8:%[0-9]+]] = OpFunctionCall %_arr_float_uint_2_0 %getB
// CHECK-NEXT: [[f_8_0:%[0-9]+]] = OpCompositeExtract %float [[call_8]] 0
// CHECK-NEXT: [[f_8_1:%[0-9]+]] = OpCompositeExtract %float [[call_8]] 1
// CHECK-NEXT: [[b_8_0:%[0-9]+]] = OpFOrdNotEqual %bool [[f_8_0]] %float_0
// CHECK-NEXT: [[b_8_1:%[0-9]+]] = OpFOrdNotEqual %bool [[f_8_1]] %float_0
// CHECK-NEXT: [[vb_8:%[0-9]+]] = OpCompositeConstruct %v2bool [[b_8_0]] [[b_8_1]]
// CHECK-NEXT: OpStore %floatarray_to_boolvec [[vb_8]]
bool2 floatarray_to_boolvec = (bool2)getB();
}

19
tools/clang/test/CodeGenSPIRV_Lit/cast.flat-conversion.decl-ref.hlsl Normal file
Просмотреть файл

@ -0,0 +1,19 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
struct A {
float a;
uint b;
float GetA() { return a; }
};
ConstantBuffer<A> foo : register(b0, space2);
void main(out float4 col : SV_Target0) {
// CHECK: [[foo:%[0-9]+]] = OpLoad %type_ConstantBuffer_A %foo
// CHECK: [[foo_a:%[0-9]+]] = OpCompositeExtract %float [[foo]] 0
// CHECK: [[foo_b:%[0-9]+]] = OpCompositeExtract %uint [[foo]] 1
// CHECK: [[foo_rvalue:%[0-9]+]] = OpCompositeConstruct %A [[foo_a]] [[foo_b]]
// CHECK: OpStore %temp_var_A [[foo_rvalue]]
// CHECK: OpFunctionCall %float %A_GetA %temp_var_A
col.x = foo.GetA();
}

109
tools/clang/test/CodeGenSPIRV_Lit/cast.flat-conversion.implicit.hlsl Normal file
Просмотреть файл

@ -0,0 +1,109 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
struct VSOutput {
float4 sv_pos : SV_POSITION;
uint3 normal : NORMAL;
int2 tex_coord : TEXCOORD;
bool mybool[2] : MYBOOL;
int arr[5] : MYARRAY;
float2x3 mat2x3 : MYMATRIX;
int2x3 intmat : MYINTMATRIX;
bool2x3 boolmat : MYBOOLMATRIX;
};
// CHECK: [[nullVSOutput:%[0-9]+]] = OpConstantNull %VSOutput
void main() {
int x = 3;
// CHECK: OpStore %output1 [[nullVSOutput]]
VSOutput output1 = (VSOutput)0;
// CHECK: OpStore %output2 [[nullVSOutput]]
VSOutput output2 = (VSOutput)0.0;
// CHECK: OpStore %output3 [[nullVSOutput]]
VSOutput output3 = (VSOutput)false;
// CHECK: [[f1:%[0-9]+]] = OpConvertSToF %float %int_1
// CHECK-NEXT: [[v4f1:%[0-9]+]] = OpCompositeConstruct %v4float [[f1]] [[f1]] [[f1]] [[f1]]
// CHECK-NEXT: [[u1:%[0-9]+]] = OpBitcast %uint %int_1
// CHECK-NEXT: [[v3u1:%[0-9]+]] = OpCompositeConstruct %v3uint [[u1]] [[u1]] [[u1]]
// CHECK-NEXT: [[v2i1:%[0-9]+]] = OpCompositeConstruct %v2int %int_1 %int_1
// CHECK-NEXT: [[bool1:%[0-9]+]] = OpINotEqual %bool %int_1 %int_0
// CHECK-NEXT: [[arr2bool1:%[0-9]+]] = OpCompositeConstruct %_arr_bool_uint_2 [[bool1]] [[bool1]]
// CHECK-NEXT: [[arr5i1:%[0-9]+]] = OpCompositeConstruct %_arr_int_uint_5 %int_1 %int_1 %int_1 %int_1 %int_1
// CHECK-NEXT: [[f1_1:%[0-9]+]] = OpConvertSToF %float %int_1
// CHECK-NEXT: [[col3:%[0-9]+]] = OpCompositeConstruct %v3float [[f1_1]] [[f1_1]] [[f1_1]]
// CHECK-NEXT: [[matFloat1:%[0-9]+]] = OpCompositeConstruct %mat2v3float [[col3]] [[col3]]
// CHECK-NEXT: [[v3i1:%[0-9]+]] = OpCompositeConstruct %v3int %int_1 %int_1 %int_1
// CHECK-NEXT: [[intmat:%[0-9]+]] = OpCompositeConstruct %_arr_v3int_uint_2 [[v3i1]] [[v3i1]]
// CHECK-NEXT: [[true:%[0-9]+]] = OpINotEqual %bool %int_1 %int_0
// CHECK-NEXT: [[boolvec:%[0-9]+]] = OpCompositeConstruct %v3bool [[true]] [[true]] [[true]]
// CHECK-NEXT: [[boolmat:%[0-9]+]] = OpCompositeConstruct %_arr_v3bool_uint_2 [[boolvec]] [[boolvec]]
// CHECK-NEXT: [[flatConvert1:%[0-9]+]] = OpCompositeConstruct %VSOutput [[v4f1]] [[v3u1]] [[v2i1]] [[arr2bool1]] [[arr5i1]] [[matFloat1]] [[intmat]] [[boolmat]]
// CHECK-NEXT: OpStore %output4 [[flatConvert1]]
VSOutput output4 = (VSOutput)1;
// CHECK: [[x:%[0-9]+]] = OpLoad %int %x
// CHECK-NEXT: [[floatX:%[0-9]+]] = OpConvertSToF %float [[x]]
// CHECK-NEXT: [[v4fX:%[0-9]+]] = OpCompositeConstruct %v4float [[floatX]] [[floatX]] [[floatX]] [[floatX]]
// CHECK-NEXT: [[uintX:%[0-9]+]] = OpBitcast %uint [[x]]
// CHECK-NEXT: [[v3uX:%[0-9]+]] = OpCompositeConstruct %v3uint [[uintX]] [[uintX]] [[uintX]]
// CHECK-NEXT: [[v2iX:%[0-9]+]] = OpCompositeConstruct %v2int [[x]] [[x]]
// CHECK-NEXT: [[boolX:%[0-9]+]] = OpINotEqual %bool [[x]] %int_0
// CHECK-NEXT: [[arr2boolX:%[0-9]+]] = OpCompositeConstruct %_arr_bool_uint_2 [[boolX]] [[boolX]]
// CHECK-NEXT: [[arr5iX:%[0-9]+]] = OpCompositeConstruct %_arr_int_uint_5 [[x]] [[x]] [[x]] [[x]] [[x]]
// CHECK-NEXT: [[floatX2:%[0-9]+]] = OpConvertSToF %float [[x]]
// CHECK-NEXT: [[v3fX:%[0-9]+]] = OpCompositeConstruct %v3float [[floatX2]] [[floatX2]] [[floatX2]]
// CHECK-NEXT: [[matFloatX:%[0-9]+]] = OpCompositeConstruct %mat2v3float [[v3fX]] [[v3fX]]
// CHECK-NEXT: [[intvec:%[0-9]+]] = OpCompositeConstruct %v3int [[x]] [[x]] [[x]]
// CHECK-NEXT: [[intmat_0:%[0-9]+]] = OpCompositeConstruct %_arr_v3int_uint_2 [[intvec]] [[intvec]]
// CHECK-NEXT: [[boolx:%[0-9]+]] = OpINotEqual %bool [[x]] %int_0
// CHECK-NEXT: [[boolvec_0:%[0-9]+]] = OpCompositeConstruct %v3bool [[boolx]] [[boolx]] [[boolx]]
// CHECK-NEXT: [[boolmat_0:%[0-9]+]] = OpCompositeConstruct %_arr_v3bool_uint_2 [[boolvec_0]] [[boolvec_0]]
// CHECK-NEXT: [[flatConvert2:%[0-9]+]] = OpCompositeConstruct %VSOutput [[v4fX]] [[v3uX]] [[v2iX]] [[arr2boolX]] [[arr5iX]] [[matFloatX]] [[intmat_0]] [[boolmat_0]]
// CHECK-NEXT: OpStore %output5 [[flatConvert2]]
VSOutput output5 = (VSOutput)x;
// CHECK: [[v4f1_5:%[0-9]+]] = OpCompositeConstruct %v4float %float_1_5 %float_1_5 %float_1_5 %float_1_5
// CHECK-NEXT: [[u1_5:%[0-9]+]] = OpConvertFToU %uint %float_1_5
// CHECK-NEXT: [[v3u1_5:%[0-9]+]] = OpCompositeConstruct %v3uint [[u1_5]] [[u1_5]] [[u1_5]]
// CHECK-NEXT: [[i1_5:%[0-9]+]] = OpConvertFToS %int %float_1_5
// CHECK-NEXT: [[v2i1_5:%[0-9]+]] = OpCompositeConstruct %v2int [[i1_5]] [[i1_5]]
// CHECK-NEXT: [[bool1_5:%[0-9]+]] = OpFOrdNotEqual %bool %float_1_5 %float_0
// CHECK-NEXT: [[arr2bool_1_5:%[0-9]+]] = OpCompositeConstruct %_arr_bool_uint_2 [[bool1_5]] [[bool1_5]]
// CHECK-NEXT: [[i1_5_0:%[0-9]+]] = OpConvertFToS %int %float_1_5
// CHECK-NEXT: [[arr5i1_5:%[0-9]+]] = OpCompositeConstruct %_arr_int_uint_5 [[i1_5_0]] [[i1_5_0]] [[i1_5_0]] [[i1_5_0]] [[i1_5_0]]
// CHECK-NEXT: [[v3f_1_5:%[0-9]+]] = OpCompositeConstruct %v3float %float_1_5 %float_1_5 %float_1_5
// CHECK-NEXT: [[matFloat_1_5:%[0-9]+]] = OpCompositeConstruct %mat2v3float [[v3f_1_5]] [[v3f_1_5]]
// CHECK-NEXT: [[int_1_5:%[0-9]+]] = OpConvertFToS %int %float_1_5
// CHECK-NEXT: [[intvec_0:%[0-9]+]] = OpCompositeConstruct %v3int [[int_1_5]] [[int_1_5]] [[int_1_5]]
// CHECK-NEXT: [[intmat_1:%[0-9]+]] = OpCompositeConstruct %_arr_v3int_uint_2 [[intvec_0]] [[intvec_0]]
// CHECK-NEXT: [[bool_1_5:%[0-9]+]] = OpFOrdNotEqual %bool %float_1_5 %float_0
// CHECK-NEXT: [[boolvec_1:%[0-9]+]] = OpCompositeConstruct %v3bool [[bool_1_5]] [[bool_1_5]] [[bool_1_5]]
// CHECK-NEXT: [[boolmat_1:%[0-9]+]] = OpCompositeConstruct %_arr_v3bool_uint_2 [[boolvec_1]] [[boolvec_1]]
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %VSOutput [[v4f1_5]] [[v3u1_5]] [[v2i1_5]] [[arr2bool_1_5]] [[arr5i1_5]] [[matFloat_1_5]] [[intmat_1]] [[boolmat_1]]
VSOutput output6 = (VSOutput)1.5;
// CHECK: [[float_true:%[0-9]+]] = OpSelect %float %true %float_1 %float_0
// CHECK-NEXT: [[v4f_true:%[0-9]+]] = OpCompositeConstruct %v4float [[float_true]] [[float_true]] [[float_true]] [[float_true]]
// CHECK-NEXT: [[uint_true:%[0-9]+]] = OpSelect %uint %true %uint_1 %uint_0
// CHECK-NEXT: [[v3u_true:%[0-9]+]] = OpCompositeConstruct %v3uint [[uint_true]] [[uint_true]] [[uint_true]]
// CHECK-NEXT: [[int_true:%[0-9]+]] = OpSelect %int %true %int_1 %int_0
// CHECK-NEXT: [[v2i_true:%[0-9]+]] = OpCompositeConstruct %v2int [[int_true]] [[int_true]]
// CHECK-NEXT: [[arr2_true:%[0-9]+]] = OpCompositeConstruct %_arr_bool_uint_2 %true %true
// CHECK-NEXT: [[int_true_0:%[0-9]+]] = OpSelect %int %true %int_1 %int_0
// CHECK-NEXT: [[arr5i_true:%[0-9]+]] = OpCompositeConstruct %_arr_int_uint_5 [[int_true_0]] [[int_true_0]] [[int_true_0]] [[int_true_0]] [[int_true_0]]
// CHECK-NEXT: [[float_true_0:%[0-9]+]] = OpSelect %float %true %float_1 %float_0
// CHECK-NEXT: [[v3f_true:%[0-9]+]] = OpCompositeConstruct %v3float [[float_true_0]] [[float_true_0]] [[float_true_0]]
// CHECK-NEXT:[[mat2v3_true:%[0-9]+]] = OpCompositeConstruct %mat2v3float [[v3f_true]] [[v3f_true]]
// CHECK-NEXT: [[true_int:%[0-9]+]] = OpSelect %int %true %int_1 %int_0
// CHECK-NEXT: [[intvec_1:%[0-9]+]] = OpCompositeConstruct %v3int [[true_int]] [[true_int]] [[true_int]]
// CHECK-NEXT: [[intmat_2:%[0-9]+]] = OpCompositeConstruct %_arr_v3int_uint_2 [[intvec_1]] [[intvec_1]]
// CHECK-NEXT: [[boolvec_2:%[0-9]+]] = OpCompositeConstruct %v3bool %true %true %true
// CHECK-NEXT: [[boolmat_2:%[0-9]+]] = OpCompositeConstruct %_arr_v3bool_uint_2 [[boolvec_2]] [[boolvec_2]]
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %VSOutput [[v4f_true]] [[v3u_true]] [[v2i_true]] [[arr2_true]] [[arr5i_true]] [[mat2v3_true]] [[intmat_2]] [[boolmat_2]]
VSOutput output7 = (VSOutput)true;
}

50
tools/clang/test/CodeGenSPIRV_Lit/cast.flat-conversion.literal-initializer.hlsl Normal file
Просмотреть файл

@ -0,0 +1,50 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
struct S {
float2 a;
float b;
double2 c;
double d;
int64_t e;
uint64_t f;
};
void main() {
// CHECK: [[inf:%[0-9]+]] = OpFDiv %float %float_1 %float_0
// CHECK-NEXT: [[inf2:%[0-9]+]] = OpCompositeConstruct %v2float [[inf]] [[inf]]
// CHECK-NEXT: [[inf_double:%[0-9]+]] = OpFConvert %double [[inf]]
// CHECK-NEXT: [[inf2_double:%[0-9]+]] = OpCompositeConstruct %v2double [[inf_double]] [[inf_double]]
// CHECK-NEXT: [[inf_double_0:%[0-9]+]] = OpFConvert %double [[inf]]
// CHECK-NEXT: [[inf_double_:%[0-9]+]] = OpFConvert %double [[inf]]
// CHECK-NEXT: [[inf_int64:%[0-9]+]] = OpConvertFToS %long [[inf_double_]]
// CHECK-NEXT: [[inf_double__0:%[0-9]+]] = OpFConvert %double [[inf]]
// CHECK-NEXT: [[inf_uint64:%[0-9]+]] = OpConvertFToU %ulong [[inf_double__0]]
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %S [[inf2]] [[inf]] [[inf2_double]] [[inf_double_0]] [[inf_int64]] [[inf_uint64]]
S s3 = (S)(1.0 / 0.0);
// CHECK: [[b:%[0-9]+]] = OpLoad %float %b
// CHECK-NEXT: [[b2_float:%[0-9]+]] = OpCompositeConstruct %v2float [[b]] [[b]]
// CHECK-NEXT: [[b_double:%[0-9]+]] = OpFConvert %double [[b]]
// CHECK-NEXT: [[b2_double:%[0-9]+]] = OpCompositeConstruct %v2double [[b_double]] [[b_double]]
// CHECK-NEXT: [[b_double_0:%[0-9]+]] = OpFConvert %double [[b]]
// CHECK-NEXT: [[b_double_:%[0-9]+]] = OpFConvert %double [[b]]
// CHECK-NEXT: [[b_int64:%[0-9]+]] = OpConvertFToS %long [[b_double_]]
// CHECK-NEXT: [[b_double__0:%[0-9]+]] = OpFConvert %double [[b]]
// CHECK-NEXT: [[b_uint64:%[0-9]+]] = OpConvertFToU %ulong [[b_double__0]]
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %S [[b2_float]] [[b]] [[b2_double]] [[b_double_0]] [[b_int64]] [[b_uint64]]
float b;
S s2 = (S)(b);
// CHECK: [[a:%[0-9]+]] = OpLoad %double %a
// CHECK-NEXT: [[a_float:%[0-9]+]] = OpFConvert %float [[a]]
// CHECK-NEXT: [[a2_float:%[0-9]+]] = OpCompositeConstruct %v2float [[a_float]] [[a_float]]
// CHECK-NEXT: [[a_float_0:%[0-9]+]] = OpFConvert %float [[a]]
// CHECK-NEXT: [[a2_double:%[0-9]+]] = OpCompositeConstruct %v2double [[a]] [[a]]
// CHECK-NEXT: [[a_int64:%[0-9]+]] = OpConvertFToS %long [[a]]
// CHECK-NEXT: [[a_uint64:%[0-9]+]] = OpConvertFToU %ulong [[a]]
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %S [[a2_float]] [[a_float_0]] [[a2_double]] [[a]] [[a_int64]] [[a_uint64]]
double a;
S s1 = (S)(a);
}

44
tools/clang/test/CodeGenSPIRV_Lit/cast.flat-conversion.no-op.hlsl Normal file
Просмотреть файл

@ -0,0 +1,44 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
cbuffer Data {
float gScalars[1];
float4 gVecs[2];
float2x3 gMats[1];
}
struct T {
float scalars[1];
float4 vecs[2];
float2x3 mats[1];
};
float4 main() : SV_Target {
T t;
// CHECK: [[gscalars_ptr:%[0-9]+]] = OpAccessChain %_ptr_Uniform__arr_float_uint_1 %Data %int_0
// CHECK-NEXT: [[gscalars_val:%[0-9]+]] = OpLoad %_arr_float_uint_1 [[gscalars_ptr]]
// CHECK-NEXT: [[scalars_ptr:%[0-9]+]] = OpAccessChain %_ptr_Function__arr_float_uint_1_0 %t %int_0
// CHECK-NEXT: [[gscalars0:%[0-9]+]] = OpCompositeExtract %float [[gscalars_val]] 0
// CHECK-NEXT: [[scalars_val:%[0-9]+]] = OpCompositeConstruct %_arr_float_uint_1_0 [[gscalars0]]
// CHECK-NEXT: OpStore [[scalars_ptr]] [[scalars_val]]
t.scalars = gScalars;
// CHECK-NEXT: [[gvecs_ptr:%[0-9]+]] = OpAccessChain %_ptr_Uniform__arr_v4float_uint_2 %Data %int_1
// CHECK-NEXT: [[gvecs_val:%[0-9]+]] = OpLoad %_arr_v4float_uint_2 [[gvecs_ptr]]
// CHECK-NEXT: [[vecs_ptr:%[0-9]+]] = OpAccessChain %_ptr_Function__arr_v4float_uint_2_0 %t %int_1
// CHECK-NEXT: [[gvecs0:%[0-9]+]] = OpCompositeExtract %v4float [[gvecs_val]] 0
// CHECK-NEXT: [[gvecs1:%[0-9]+]] = OpCompositeExtract %v4float [[gvecs_val]] 1
// CHECK-NEXT: [[vecs_val:%[0-9]+]] = OpCompositeConstruct %_arr_v4float_uint_2_0 [[gvecs0]] [[gvecs1]]
// CHECK-NEXT: OpStore [[vecs_ptr]] [[vecs_val]]
t.vecs = gVecs;
// CHECK-NEXT: [[gmats_ptr:%[0-9]+]] = OpAccessChain %_ptr_Uniform__arr_mat2v3float_uint_1 %Data %int_2
// CHECK-NEXT: [[gmats_val:%[0-9]+]] = OpLoad %_arr_mat2v3float_uint_1 [[gmats_ptr]]
// CHECK-NEXT: [[mats_ptr:%[0-9]+]] = OpAccessChain %_ptr_Function__arr_mat2v3float_uint_1_0 %t %int_2
// CHECK-NEXT: [[gmats0:%[0-9]+]] = OpCompositeExtract %mat2v3float [[gmats_val]] 0
// CHECK-NEXT: [[mats_val:%[0-9]+]] = OpCompositeConstruct %_arr_mat2v3float_uint_1_0 [[gmats0]]
// CHECK-NEXT: OpStore [[mats_ptr]] [[mats_val]]
t.mats = gMats;
return t.vecs[1];
}

59
tools/clang/test/CodeGenSPIRV_Lit/cast.flat-conversion.struct-to-struct.hlsl Normal file
Просмотреть файл

@ -0,0 +1,59 @@
// RUN: %dxc -T cs_6_0 -HV 2018 -E main -fcgl %s -spirv | FileCheck %s
// Processing FlatConversion when source and destination
// are both structures with identical members.
struct FirstStruct {
float3 anArray[4];
float2x3 mats[1];
int2 ints[3];
};
struct SecondStruct {
float3 anArray[4];
float2x3 mats[1];
int2 ints[3];
};
RWStructuredBuffer<FirstStruct> rwBuf : register(u0);
[ numthreads ( 16 , 16 , 1 ) ]
void main() {
SecondStruct values;
FirstStruct v;
// Yes, this is a FlatConversion!
// CHECK: [[values:%[0-9]+]] = OpLoad %SecondStruct %values
// CHECK-NEXT: [[v0:%[0-9]+]] = OpCompositeExtract %_arr_v3float_uint_4_0 [[values]] 0
// CHECK-NEXT: [[v1:%[0-9]+]] = OpCompositeExtract %_arr_mat2v3float_uint_1_0 [[values]] 1
// CHECK-NEXT: [[v2:%[0-9]+]] = OpCompositeExtract %_arr_v2int_uint_3_0 [[values]] 2
// CHECK-NEXT: [[v:%[0-9]+]] = OpCompositeConstruct %FirstStruct_0 [[v0]] [[v1]] [[v2]]
// CHECK-NEXT: OpStore %v [[v]]
v = values;
// CHECK-NEXT: [[values_0:%[0-9]+]] = OpLoad %SecondStruct %values
// CHECK-NEXT: [[v0_0:%[0-9]+]] = OpCompositeExtract %_arr_v3float_uint_4_0 [[values_0]] 0
// CHECK-NEXT: [[v1_0:%[0-9]+]] = OpCompositeExtract %_arr_mat2v3float_uint_1_0 [[values_0]] 1
// CHECK-NEXT: [[v2_0:%[0-9]+]] = OpCompositeExtract %_arr_v2int_uint_3_0 [[values_0]] 2
// CHECK-NEXT: [[v_0:%[0-9]+]] = OpCompositeConstruct %FirstStruct_0 [[v0_0]] [[v1_0]] [[v2_0]]
// CHECK-NEXT: [[rwBuf_ptr:%[0-9]+]] = OpAccessChain %_ptr_Uniform_FirstStruct %rwBuf %int_0 %uint_0
// CHECK-NEXT: [[anArray:%[0-9]+]] = OpCompositeExtract %_arr_v3float_uint_4_0 [[v_0]] 0
// CHECK-NEXT: [[anArray1:%[0-9]+]] = OpCompositeExtract %v3float [[anArray]] 0
// CHECK-NEXT: [[anArray2:%[0-9]+]] = OpCompositeExtract %v3float [[anArray]] 1
// CHECK-NEXT: [[anArray3:%[0-9]+]] = OpCompositeExtract %v3float [[anArray]] 2
// CHECK-NEXT: [[anArray4:%[0-9]+]] = OpCompositeExtract %v3float [[anArray]] 3
// CHECK-NEXT: [[res1:%[0-9]+]] = OpCompositeConstruct %_arr_v3float_uint_4 [[anArray1]] [[anArray2]] [[anArray3]] [[anArray4]]
// CHECK-NEXT: [[mats:%[0-9]+]] = OpCompositeExtract %_arr_mat2v3float_uint_1_0 [[v_0]] 1
// CHECK-NEXT: [[mat:%[0-9]+]] = OpCompositeExtract %mat2v3float [[mats]] 0
// CHECK-NEXT: [[res2:%[0-9]+]] = OpCompositeConstruct %_arr_mat2v3float_uint_1 [[mat]]
// CHECK-NEXT: [[ints:%[0-9]+]] = OpCompositeExtract %_arr_v2int_uint_3_0 [[v_0]] 2
// CHECK-NEXT: [[ints1:%[0-9]+]] = OpCompositeExtract %v2int [[ints]] 0
// CHECK-NEXT: [[ints2:%[0-9]+]] = OpCompositeExtract %v2int [[ints]] 1
// CHECK-NEXT: [[ints3:%[0-9]+]] = OpCompositeExtract %v2int [[ints]] 2
// CHECK-NEXT: [[res3:%[0-9]+]] = OpCompositeConstruct %_arr_v2int_uint_3 [[ints1]] [[ints2]] [[ints3]]
// CHECK-NEXT: [[result:%[0-9]+]] = OpCompositeConstruct %FirstStruct [[res1]] [[res2]] [[res3]]
// CHECK-NEXT: OpStore [[rwBuf_ptr]] [[result]]
rwBuf[0] = values;
}

27
tools/clang/test/CodeGenSPIRV_Lit/cast.flat-conversion.struct.hlsl Normal file
Просмотреть файл

@ -0,0 +1,27 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
// Compositing a struct by casting from its single member
struct S {
float4 val;
};
struct T {
S val;
};
float4 main(float4 a: A) : SV_Target {
// CHECK: [[a:%[0-9]+]] = OpLoad %v4float %a
// CHECK-NEXT: [[s:%[0-9]+]] = OpCompositeConstruct %S [[a]]
// CHECK-NEXT: OpStore %s [[s]]
S s = (S)a;
// CHECK: [[s_0:%[0-9]+]] = OpLoad %S %s
// CHECK-NEXT: [[val:%[0-9]+]] = OpCompositeExtract %v4float [[s_0]] 0
// CHECK-NEXT: [[s_1:%[0-9]+]] = OpCompositeConstruct %S [[val]]
// CHECK-NEXT: [[t:%[0-9]+]] = OpCompositeConstruct %T [[s_1]]
// CHECK-NEXT: OpStore %t [[t]]
T t = (T)s;
return s.val + t.val.val;
}

23
tools/clang/test/CodeGenSPIRV_Lit/cast.flat-conversion.vector.hlsl Normal file
Просмотреть файл

@ -0,0 +1,23 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
struct S {
float2 data[2];
};
StructuredBuffer<S> MySB;
float4 main() : SV_TARGET
{
// CHECK: [[ac:%[0-9]+]] = OpAccessChain %_ptr_Uniform__arr_v2float_uint_2 %MySB %int_0 %uint_0 %int_0
// CHECK-NEXT: [[mysb:%[0-9]+]] = OpLoad %_arr_v2float_uint_2 [[ac]]
// CHECK-NEXT: [[vec0:%[0-9]+]] = OpCompositeExtract %v2float [[mysb]] 0
// CHECK-NEXT: [[vec1:%[0-9]+]] = OpCompositeExtract %v2float [[mysb]] 1
// CHECK-NEXT: [[v1:%[0-9]+]] = OpCompositeExtract %float [[vec0]] 0
// CHECK-NEXT: [[v2:%[0-9]+]] = OpCompositeExtract %float [[vec0]] 1
// CHECK-NEXT: [[v3:%[0-9]+]] = OpCompositeExtract %float [[vec1]] 0
// CHECK-NEXT: [[v4:%[0-9]+]] = OpCompositeExtract %float [[vec1]] 1
// CHECK-NEXT: [[val:%[0-9]+]] = OpCompositeConstruct %_arr_float_uint_4 [[v1]] [[v2]] [[v3]] [[v4]]
// CHECK-NEXT: OpStore %data [[val]]
float data[4] = (float[4])MySB[0].data;
return data[1];
}

12
tools/clang/test/CodeGenSPIRV_Lit/cast.literal-type.array-subscript.hlsl Normal file
Просмотреть файл

@ -0,0 +1,12 @@
// RUN: %dxc -T cs_6_0 -E main -fcgl %s -spirv | FileCheck %s
RWStructuredBuffer<uint> Out;
groupshared uint Mem[1];
[numthreads(1, 1, 1)]
void main() {
// CHECK: [[sub:%[0-9]+]] = OpISub %int %int_1 %int_1
// CHECK: {{%[0-9]+}} = OpAccessChain %_ptr_Workgroup_uint %Mem [[sub]]
Mem[1 - 1] = 0;
Out[0] = Mem[0];
}

23
tools/clang/test/CodeGenSPIRV_Lit/cast.literal-type.ternary.2021.hlsl Normal file
Просмотреть файл

@ -0,0 +1,23 @@
// RUN: %dxc -T ps_6_0 -HV 2021 -E main -fcgl %s -spirv | FileCheck %s
// The 'out' argument in the function should be handled correctly when deducing
// the literal type, even in HLSL 2021 (with shortcicuiting).
void foo(out uint value, uint x) {
// CHECK: [[cond:%[0-9]+]] = OpULessThan %bool {{%[0-9]+}} %uint_64
// CHECK: OpBranchConditional [[cond]] [[ternary_lhs:%[a-zA-Z0-9_]+]] [[ternary_rhs:%[a-zA-Z0-9_]+]]
// CHECK: [[ternary_lhs]] = OpLabel
// CHECK: OpStore [[tmp:%[a-zA-Z0-9_]+]] %int_1
// CHECK: OpBranch [[merge:%[a-zA-Z0-9_]+]]
// CHECK: [[ternary_rhs]] = OpLabel
// CHECK: OpStore [[tmp_0:%[a-zA-Z0-9_]+]] %int_0
// CHECK: OpBranch [[merge]]
// CHECK: [[merge]] = OpLabel
// CHECK: [[res:%[0-9]+]] = OpLoad %int [[tmp_0]]
// CHECK: {{%[0-9]+}} = OpBitcast %uint [[res]]
value = x < 64 ? 1 : 0;
}
void main() {
uint value;
foo(value, 2);
}

15
tools/clang/test/CodeGenSPIRV_Lit/cast.literal-type.ternary.hlsl Normal file
Просмотреть файл

@ -0,0 +1,15 @@
// RUN: %dxc -T ps_6_0 -HV 2018 -E main -fcgl %s -spirv | FileCheck %s
// The 'out' argument in the function should be handled correctly when deducing
// the literal type.
void foo(out uint value, uint x) {
// CHECK: [[cond:%[0-9]+]] = OpULessThan %bool {{%[0-9]+}} %uint_64
// CHECK: [[result:%[0-9]+]] = OpSelect %int [[cond]] %int_1 %int_0
// CHECK: {{%[0-9]+}} = OpBitcast %uint [[result]]
value = x < 64 ? 1 : 0;
}
void main() {
uint value;
foo(value, 2);
}

33
tools/clang/test/CodeGenSPIRV_Lit/cast.mat-to-vec.hlsl Normal file
Просмотреть файл

@ -0,0 +1,33 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
float4 main(float4 input : A) : SV_Target {
float2x2 floatMat;
int2x2 intMat;
bool2x2 boolMat;
// CHECK: [[floatMat:%[0-9]+]] = OpLoad %mat2v2float %floatMat
// CHECK-NEXT: [[row0:%[0-9]+]] = OpCompositeExtract %v2float [[floatMat]] 0
// CHECK-NEXT: [[row1:%[0-9]+]] = OpCompositeExtract %v2float [[floatMat]] 1
// CHECK-NEXT: [[vec:%[0-9]+]] = OpVectorShuffle %v4float [[row0]] [[row1]] 0 1 2 3
// CHECK-NEXT: OpStore %c [[vec]]
float4 c = floatMat;
// CHECK: [[intMat:%[0-9]+]] = OpLoad %_arr_v2int_uint_2 %intMat
// CHECK-NEXT: [[row0_0:%[0-9]+]] = OpCompositeExtract %v2int [[intMat]] 0
// CHECK-NEXT: [[row1_0:%[0-9]+]] = OpCompositeExtract %v2int [[intMat]] 1
// CHECK-NEXT: [[vecInt:%[0-9]+]] = OpVectorShuffle %v4int [[row0_0]] [[row1_0]] 0 1 2 3
// CHECK-NEXT: [[vecFloat:%[0-9]+]] = OpConvertSToF %v4float [[vecInt]]
// CHECK-NEXT: OpStore %d [[vecFloat]]
float4 d = intMat;
// CHECK: [[boolMat:%[0-9]+]] = OpLoad %_arr_v2bool_uint_2 %boolMat
// CHECK-NEXT: [[row0_1:%[0-9]+]] = OpCompositeExtract %v2bool [[boolMat]] 0
// CHECK-NEXT: [[row1_1:%[0-9]+]] = OpCompositeExtract %v2bool [[boolMat]] 1
// CHECK-NEXT: [[vec_0:%[0-9]+]] = OpVectorShuffle %v4bool [[row0_1]] [[row1_1]] 0 1 2 3
// CHECK-NEXT: [[vecFloat_0:%[0-9]+]] = OpSelect %v4float [[vec_0]] {{%[0-9]+}} {{%[0-9]+}}
// CHECK-NEXT: OpStore %e [[vecFloat_0]]
float4 e = boolMat;
return 0.xxxx;
}

86
tools/clang/test/CodeGenSPIRV_Lit/cast.matrix.splat.hlsl Normal file
Просмотреть файл

@ -0,0 +1,86 @@
// RUN: %dxc -T vs_6_0 -E main -fcgl %s -spirv | FileCheck %s
// CHECK: [[v2f8_5:%[0-9]+]] = OpConstantComposite %v2float %float_8_5 %float_8_5
// CHECK: [[v3f9_5:%[0-9]+]] = OpConstantComposite %v3float %float_9_5 %float_9_5 %float_9_5
// CHECK: [[v2f10_5:%[0-9]+]] = OpConstantComposite %v2float %float_10_5 %float_10_5
// CHECK: [[m3v2f10_5:%[0-9]+]] = OpConstantComposite %mat3v2float [[v2f10_5]] [[v2f10_5]] [[v2f10_5]]
// CHECK: [[v2i10:%[0-9]+]] = OpConstantComposite %v2int %int_10 %int_10
// CHECK: [[int3x2_i10:%[0-9]+]] = OpConstantComposite %_arr_v2int_uint_3 [[v2i10]] [[v2i10]] [[v2i10]]
// CHECK: [[v2true:%[0-9]+]] = OpConstantComposite %v2bool %true %true
// CHECK: [[bool3x2_true:%[0-9]+]] = OpConstantComposite %_arr_v2bool_uint_3 [[v2true]] [[v2true]] [[v2true]]
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
// TODO: Optimally the following literals can be attached to variable
// definitions instead of OpStore. Constant evaluation in the front
// end doesn't really support it for now.
// CHECK: OpStore %a %float_7_5
float1x1 a = 7.5;
// CHECK-NEXT: OpStore %b [[v2f8_5]]
float1x2 b = 8.5;
// CHECK-NEXT: OpStore %c [[v3f9_5]]
float3x1 c = 9.5;
// CHECK-NEXT: OpStore %d [[m3v2f10_5]]
float3x2 d = 10.5;
// CHECK-NEXT: OpStore %e [[int3x2_i10]]
int3x2 e = 10;
// CHECK-NEXT: OpStore %f [[bool3x2_true]]
bool3x2 f = true;
float val;
// CHECK-NEXT: [[val0:%[0-9]+]] = OpLoad %float %val
// CHECK-NEXT: OpStore %h [[val0]]
float1x1 h = val;
// CHECK-NEXT: [[val1:%[0-9]+]] = OpLoad %float %val
// CHECK-NEXT: [[cc0:%[0-9]+]] = OpCompositeConstruct %v3float [[val1]] [[val1]] [[val1]]
// CHECK-NEXT: OpStore %i [[cc0]]
float1x3 i = val;
float2x1 j;
float2x3 k;
// CHECK-NEXT: [[val2:%[0-9]+]] = OpLoad %float %val
// CHECK-NEXT: [[cc1:%[0-9]+]] = OpCompositeConstruct %v2float [[val2]] [[val2]]
// CHECK-NEXT: OpStore %j [[cc1]]
j = val;
// CHECK-NEXT: [[val3:%[0-9]+]] = OpLoad %float %val
// CHECK-NEXT: [[cc2:%[0-9]+]] = OpCompositeConstruct %v3float [[val3]] [[val3]] [[val3]]
// CHECK-NEXT: [[cc3:%[0-9]+]] = OpCompositeConstruct %mat2v3float [[cc2]] [[cc2]]
// CHECK-NEXT: OpStore %k [[cc3]]
k = val;
int intVal;
// CHECK: [[intVal:%[0-9]+]] = OpLoad %int %intVal
// CHECK-NEXT: [[cc4:%[0-9]+]] = OpCompositeConstruct %v3int [[intVal]] [[intVal]] [[intVal]]
// CHECK-NEXT: OpStore %m [[cc4]]
int1x3 m = intVal;
int2x1 n;
int2x3 o;
// CHECK: [[intVal_0:%[0-9]+]] = OpLoad %int %intVal
// CHECK-NEXT: [[cc5:%[0-9]+]] = OpCompositeConstruct %v2int [[intVal_0]] [[intVal_0]]
// CHECK-NEXT: OpStore %n [[cc5]]
n = intVal;
// CHECK: [[intVal_1:%[0-9]+]] = OpLoad %int %intVal
// CHECK-NEXT: [[v3intVal:%[0-9]+]] = OpCompositeConstruct %v3int [[intVal_1]] [[intVal_1]] [[intVal_1]]
// CHECK-NEXT: [[cc6:%[0-9]+]] = OpCompositeConstruct %_arr_v3int_uint_2 [[v3intVal]] [[v3intVal]]
// CHECK-NEXT: OpStore %o [[cc6]]
o = intVal;
bool boolVal;
// CHECK: [[boolVal:%[0-9]+]] = OpLoad %bool %boolVal
// CHECK-NEXT: [[cc7:%[0-9]+]] = OpCompositeConstruct %v3bool [[boolVal]] [[boolVal]] [[boolVal]]
// CHECK-NEXT: OpStore %p [[cc7]]
bool1x3 p = boolVal;
bool2x1 q;
bool2x3 r;
// CHECK: [[boolVal_0:%[0-9]+]] = OpLoad %bool %boolVal
// CHECK-NEXT: [[cc8:%[0-9]+]] = OpCompositeConstruct %v2bool [[boolVal_0]] [[boolVal_0]]
// CHECK-NEXT: OpStore %q [[cc8]]
q = boolVal;
// CHECK: [[boolVal_1:%[0-9]+]] = OpLoad %bool %boolVal
// CHECK-NEXT: [[v3boolVal:%[0-9]+]] = OpCompositeConstruct %v3bool [[boolVal_1]] [[boolVal_1]] [[boolVal_1]]
// CHECK-NEXT: [[cc9:%[0-9]+]] = OpCompositeConstruct %_arr_v3bool_uint_2 [[v3boolVal]] [[v3boolVal]]
// CHECK-NEXT: OpStore %r [[cc9]]
r = boolVal;
}

139
tools/clang/test/CodeGenSPIRV_Lit/cast.matrix.trunc.hlsl Normal file
Просмотреть файл

@ -0,0 +1,139 @@
// RUN: %dxc -T vs_6_0 -E main -fcgl %s -spirv | FileCheck %s
// Note: Matrix truncation cast does not allow truncation into a mat1x1.
void main() {
float3x4 m = { 1, 2, 3, 4,
5, 6, 7, 8,
9, 10, 11, 12 };
float1x4 n = {1, 2, 3, 4};
float3x1 o = {1, 2, 3};
// TEST: float3x4 --> float2x3
// CHECK: [[m_0:%[0-9]+]] = OpLoad %mat3v4float %m
// CHECK-NEXT: [[m_0_row0:%[0-9]+]] = OpCompositeExtract %v4float [[m_0]] 0
// CHECK-NEXT: [[a_row0:%[0-9]+]] = OpVectorShuffle %v3float [[m_0_row0]] [[m_0_row0]] 0 1 2
// CHECK-NEXT: [[m_0_row1:%[0-9]+]] = OpCompositeExtract %v4float [[m_0]] 1
// CHECK-NEXT: [[a_row1:%[0-9]+]] = OpVectorShuffle %v3float [[m_0_row1]] [[m_0_row1]] 0 1 2
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %mat2v3float [[a_row0]] [[a_row1]]
float2x3 a = (float2x3)m;
// TEST: float3x4 --> float1x3
// CHECK: [[m_1:%[0-9]+]] = OpLoad %mat3v4float %m
// CHECK-NEXT: [[m_1_row0:%[0-9]+]] = OpCompositeExtract %v4float [[m_1]] 0
// CHECK-NEXT: {{%[0-9]+}} = OpVectorShuffle %v3float [[m_1_row0]] [[m_1_row0]] 0 1 2
float1x3 b = m;
// TEST: float3x4 --> float1x4
// CHECK: [[m_2:%[0-9]+]] = OpLoad %mat3v4float %m
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeExtract %v4float [[m_2]] 0
float1x4 c = m;
// TEST: float3x4 --> float2x1
// CHECK: [[m_3:%[0-9]+]] = OpLoad %mat3v4float %m
// CHECK-NEXT: [[m_3_row0:%[0-9]+]] = OpCompositeExtract %v4float [[m_3]] 0
// CHECK-NEXT: [[d_row0:%[0-9]+]] = OpCompositeExtract %float [[m_3_row0]] 0
// CHECK-NEXT: [[m_3_row1:%[0-9]+]] = OpCompositeExtract %v4float [[m_3]] 1
// CHECK-NEXT: [[d_row1:%[0-9]+]] = OpCompositeExtract %float [[m_3_row1]] 0
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %v2float [[d_row0]] [[d_row1]]
float2x1 d = m;
// TEST: float3x4 --> float3x1
// CHECK: [[m_4:%[0-9]+]] = OpLoad %mat3v4float %m
// CHECK-NEXT: [[m_4_row0:%[0-9]+]] = OpCompositeExtract %v4float [[m_4]] 0
// CHECK-NEXT: [[e_row0:%[0-9]+]] = OpCompositeExtract %float [[m_4_row0]] 0
// CHECK-NEXT: [[m_4_row1:%[0-9]+]] = OpCompositeExtract %v4float [[m_4]] 1
// CHECK-NEXT: [[e_row1:%[0-9]+]] = OpCompositeExtract %float [[m_4_row1]] 0
// CHECK-NEXT: [[m_4_row2:%[0-9]+]] = OpCompositeExtract %v4float [[m_4]] 2
// CHECK-NEXT: [[e_row2:%[0-9]+]] = OpCompositeExtract %float [[m_4_row2]] 0
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %v3float [[e_row0]] [[e_row1]] [[e_row2]]
float3x1 e = (float3x1)m;
// TEST float1x4 --> float1x3
// CHECK: [[n:%[0-9]+]] = OpLoad %v4float %n
// CHECK-NEXT: {{%[0-9]+}} = OpVectorShuffle %v3float [[n]] [[n]] 0 1 2
float1x3 f = n;
// TEST float1x4 --> float1x3
// CHECK: [[n_0:%[0-9]+]] = OpLoad %v4float %n
// CHECK-NEXT: [[n0:%[0-9]+]] = OpCompositeExtract %float [[n_0]] 0
// CHECK-NEXT: OpStore %scalar [[n0]]
float1x1 scalar = n;
// TEST float3x1 --> float2x1
// CHECK: [[o:%[0-9]+]] = OpLoad %v3float %o
// CHECK-NEXT: {{%[0-9]+}} = OpVectorShuffle %v2float [[o]] [[o]] 0 1
float2x1 g = (float2x1)o;
// Non-floating point matrices
int3x4 h;
int2x3 i;
int3x1 j;
int1x4 k;
// CHECK: [[h:%[0-9]+]] = OpLoad %_arr_v4int_uint_3 %h
// CHECK-NEXT: [[h0:%[0-9]+]] = OpCompositeExtract %v4int [[h]] 0
// CHECK-NEXT: [[i0:%[0-9]+]] = OpVectorShuffle %v3int [[h0]] [[h0]] 0 1 2
// CHECK-NEXT: [[h1:%[0-9]+]] = OpCompositeExtract %v4int [[h]] 1
// CHECK-NEXT: [[i1:%[0-9]+]] = OpVectorShuffle %v3int [[h1]] [[h1]] 0 1 2
// CHECK-NEXT: [[i:%[0-9]+]] = OpCompositeConstruct %_arr_v3int_uint_2 [[i0]] [[i1]]
// CHECK-NEXT: OpStore %i [[i]]
i = (int2x3)h;
// CHECK: [[h_0:%[0-9]+]] = OpLoad %_arr_v4int_uint_3 %h
// CHECK-NEXT: [[h0_0:%[0-9]+]] = OpCompositeExtract %v4int [[h_0]] 0
// CHECK-NEXT: [[h0e0:%[0-9]+]] = OpCompositeExtract %int [[h0_0]] 0
// CHECK-NEXT: [[h1_0:%[0-9]+]] = OpCompositeExtract %v4int [[h_0]] 1
// CHECK-NEXT: [[h1e0:%[0-9]+]] = OpCompositeExtract %int [[h1_0]] 0
// CHECK-NEXT: [[h2:%[0-9]+]] = OpCompositeExtract %v4int [[h_0]] 2
// CHECK-NEXT: [[h2e0:%[0-9]+]] = OpCompositeExtract %int [[h2]] 0
// CHECK-NEXT: [[j:%[0-9]+]] = OpCompositeConstruct %v3int [[h0e0]] [[h1e0]] [[h2e0]]
// CHECK-NEXT: OpStore %j [[j]]
j = (int3x1)h;
// CHECK: [[h_1:%[0-9]+]] = OpLoad %_arr_v4int_uint_3 %h
// CHECK-NEXT: [[h0_1:%[0-9]+]] = OpCompositeExtract %v4int [[h_1]] 0
// CHECK-NEXT: OpStore %k [[h0_1]]
k = (int1x4)h;
bool3x4 p;
bool2x3 q;
bool3x1 r;
bool1x4 s;
// CHECK: [[p:%[0-9]+]] = OpLoad %_arr_v4bool_uint_3 %p
// CHECK-NEXT: [[p0:%[0-9]+]] = OpCompositeExtract %v4bool [[p]] 0
// CHECK-NEXT: [[q0:%[0-9]+]] = OpVectorShuffle %v3bool [[p0]] [[p0]] 0 1 2
// CHECK-NEXT: [[p1:%[0-9]+]] = OpCompositeExtract %v4bool [[p]] 1
// CHECK-NEXT: [[q1:%[0-9]+]] = OpVectorShuffle %v3bool [[p1]] [[p1]] 0 1 2
// CHECK-NEXT: [[q:%[0-9]+]] = OpCompositeConstruct %_arr_v3bool_uint_2 [[q0]] [[q1]]
// CHECK-NEXT: OpStore %q [[q]]
q = (bool2x3)p;
// CHECK: [[p_0:%[0-9]+]] = OpLoad %_arr_v4bool_uint_3 %p
// CHECK-NEXT: [[p0_0:%[0-9]+]] = OpCompositeExtract %v4bool [[p_0]] 0
// CHECK-NEXT: [[p0e0:%[0-9]+]] = OpCompositeExtract %bool [[p0_0]] 0
// CHECK-NEXT: [[p1_0:%[0-9]+]] = OpCompositeExtract %v4bool [[p_0]] 1
// CHECK-NEXT: [[p1e0:%[0-9]+]] = OpCompositeExtract %bool [[p1_0]] 0
// CHECK-NEXT: [[p2:%[0-9]+]] = OpCompositeExtract %v4bool [[p_0]] 2
// CHECK-NEXT: [[p2e0:%[0-9]+]] = OpCompositeExtract %bool [[p2]] 0
// CHECK-NEXT: [[r:%[0-9]+]] = OpCompositeConstruct %v3bool [[p0e0]] [[p1e0]] [[p2e0]]
// CHECK-NEXT: OpStore %r [[r]]
r = (bool3x1)p;
// CHECK: [[p_1:%[0-9]+]] = OpLoad %_arr_v4bool_uint_3 %p
// CHECK-NEXT: [[p0_1:%[0-9]+]] = OpCompositeExtract %v4bool [[p_1]] 0
// CHECK-NEXT: OpStore %s [[p0_1]]
s = (bool1x4)p;
}

8
tools/clang/test/CodeGenSPIRV/cast.no-op.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cast.no-op.hlsl
Просмотреть файл

@ -1,19 +1,19 @@
// RUN: %dxc -T ps_6_0 -E main
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
int a, b;
// CHECK: [[a0:%\d+]] = OpLoad %int %a
// CHECK: [[a0:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: OpStore %b [[a0]]
b = int(a);
uint1 c, d;
// CHECK-NEXT: [[c0:%\d+]] = OpLoad %uint %c
// CHECK-NEXT: [[c0:%[0-9]+]] = OpLoad %uint %c
// CHECK-NEXT: OpStore %d [[c0]]
d = uint1(c);
float2 e, f;
// CHECK-NEXT: [[e0:%\d+]] = OpLoad %v2float %e
// CHECK-NEXT: [[e0:%[0-9]+]] = OpLoad %v2float %e
// CHECK-NEXT: OpStore %f [[e0]]
f = float2(e);
}

14
tools/clang/test/CodeGenSPIRV_Lit/cast.no-op.matrix.float-to-int.hlsl Normal file
Просмотреть файл

@ -0,0 +1,14 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
void main() {
float2x2 a;
int4 b;
// CHECK: [[a:%[0-9]+]] = OpLoad %mat2v2float %a
// CHECK-NEXT: [[a_0:%[0-9]+]] = OpCompositeExtract %v2float [[a]] 0
// CHECK-NEXT: [[a_1:%[0-9]+]] = OpConvertFToS %v2int [[a_0]]
// CHECK-NEXT: [[a_2:%[0-9]+]] = OpCompositeExtract %v2float [[a]] 1
// CHECK-NEXT: [[a_3:%[0-9]+]] = OpConvertFToS %v2int [[a_2]]
// CHECK-NEXT: [[a:%[0-9]+]] = OpCompositeConstruct %_arr_v2int_uint_2 [[a_1]] [[a_3]]
b.zw = mul(int2x2(a), b.yx);
}

24
tools/clang/test/CodeGenSPIRV/cast.struct-to-int.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cast.struct-to-int.hlsl
Просмотреть файл

@ -1,4 +1,4 @@
// RUN: %dxc -T cs_6_4 -HV 2021 -E main
// RUN: %dxc -T cs_6_4 -HV 2021 -E main -fcgl %s -spirv | FileCheck %s
struct ColorRGB {
uint R : 8;
@ -91,26 +91,26 @@ void main()
// CHECK: [[RGB:%[^ ]*]] = OpLoad [[COLORRGB]]
// CHECK: [[RGB0:%[^ ]*]] = OpCompositeExtract [[UINT]] [[RGB]] 0
// CHECK: [[RGB00:%[^ ]*]] = OpBitFieldUExtract [[UINT]] [[RGB0]] [[U0]] [[U8]]
// CHECK: [[BUF00:%[^ ]*]] = OpAccessChain %{{[^ ]*}} [[BUF]] [[I0]] [[U0]]
// CHECK: [[V1:%[^ ]*]] = OpLoad [[UINT]] [[BUF00]]
// CHECK: [[BUF00_0:%[^ ]*]] = OpAccessChain %{{[^ ]*}} [[BUF]] [[I0]] [[U0]]
// CHECK: [[V1:%[^ ]*]] = OpLoad [[UINT]] [[BUF00_0]]
// CHECK: [[V2:%[^ ]*]] = OpISub [[UINT]] [[V1]] [[RGB00]]
// CHECK: OpStore [[BUF00]] [[V2]]
// CHECK: OpStore [[BUF00_0]] [[V2]]
lbuf[0] = (uint64_t) v;
// CHECK: [[VECS:%[^ ]*]] = OpLoad [[VECTORS]]
// CHECK: [[VECS00:%[^ ]*]] = OpCompositeExtract [[UINT]] [[VECS]] 0 0
// CHECK: [[V1:%[^ ]*]] = OpUConvert [[ULONG]] [[VECS00]]
// CHECK: [[V1_0:%[^ ]*]] = OpUConvert [[ULONG]] [[VECS00]]
// CHECK: [[LBUF00:%[^ ]*]] = OpAccessChain %{{[^ ]*}} [[LBUF]] [[I0]] [[U0]]
// CHECK: OpStore [[LBUF00]] [[V1]]
// CHECK: OpStore [[LBUF00]] [[V1_0]]
lbuf[0] += (uint64_t) m;
// CHECK: [[MIX:%[^ ]*]] = OpLoad [[MIXED]]
// CHECK: [[MIX0:%[^ ]*]] = OpCompositeExtract [[FLOAT]] [[MIX]] 0
// CHECK: [[V1:%[^ ]*]] = OpFConvert [[DOUBLE]] [[MIX0]]
// CHECK: [[V2:%[^ ]*]] = OpConvertFToU [[ULONG]] [[V1]]
// CHECK: [[LBUF00:%[^ ]*]] = OpAccessChain %{{[^ ]*}} [[LBUF]] [[I0]] [[U0]]
// CHECK: [[V3:%[^ ]*]] = OpLoad [[ULONG]] [[LBUF00]]
// CHECK: [[V4:%[^ ]*]] = OpIAdd [[ULONG]] [[V3]] [[V2]]
// CHECK: OpStore [[LBUF00]] [[V4]]
// CHECK: [[V1_1:%[^ ]*]] = OpFConvert [[DOUBLE]] [[MIX0]]
// CHECK: [[V2_0:%[^ ]*]] = OpConvertFToU [[ULONG]] [[V1_1]]
// CHECK: [[LBUF00_0:%[^ ]*]] = OpAccessChain %{{[^ ]*}} [[LBUF]] [[I0]] [[U0]]
// CHECK: [[V3:%[^ ]*]] = OpLoad [[ULONG]] [[LBUF00_0]]
// CHECK: [[V4:%[^ ]*]] = OpIAdd [[ULONG]] [[V3]] [[V2_0]]
// CHECK: OpStore [[LBUF00_0]] [[V4]]
}

33
tools/clang/test/CodeGenSPIRV_Lit/cast.vec-to-mat.explicit.hlsl Normal file
Просмотреть файл

@ -0,0 +1,33 @@
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
float4 main(float4 input : A) : SV_Target {
// CHECK: [[vec:%[0-9]+]] = OpLoad %v4float %input
// CHECK-NEXT: [[vec1:%[0-9]+]] = OpVectorShuffle %v2float [[vec]] [[vec]] 0 1
// CHECK-NEXT: [[vec2:%[0-9]+]] = OpVectorShuffle %v2float [[vec]] [[vec]] 2 3
// CHECK-NEXT: [[mat:%[0-9]+]] = OpCompositeConstruct %mat2v2float [[vec1]] [[vec2]]
// CHECK-NEXT: OpStore %mat1 [[mat]]
float2x2 mat1 = ( float2x2)input;
// CHECK: [[vec_0:%[0-9]+]] = OpLoad %v4float %input
// CHECK-NEXT: [[vec1_0:%[0-9]+]] = OpVectorShuffle %v2float [[vec_0]] [[vec_0]] 0 1
// CHECK-NEXT: [[vec2_0:%[0-9]+]] = OpVectorShuffle %v2float [[vec_0]] [[vec_0]] 2 3
// CHECK-NEXT: [[mat_0:%[0-9]+]] = OpCompositeConstruct %mat2v2float [[vec1_0]] [[vec2_0]]
// CHECK-NEXT: OpStore %mat2 [[mat_0]]
float2x2 mat2 = (row_major float2x2)input;
// CHECK: [[vec_1:%[0-9]+]] = OpLoad %v4float %input
// CHECK-NEXT: [[vec1_1:%[0-9]+]] = OpVectorShuffle %v2float [[vec_1]] [[vec_1]] 0 1
// CHECK-NEXT: [[vec2_1:%[0-9]+]] = OpVectorShuffle %v2float [[vec_1]] [[vec_1]] 2 3
// CHECK-NEXT: [[mat_1:%[0-9]+]] = OpCompositeConstruct %mat2v2float [[vec1_1]] [[vec2_1]]
// CHECK-NEXT: OpStore %mat3 [[mat_1]]
float2x2 mat3 = (column_major float2x2)input;
// CHECK: [[a:%[0-9]+]] = OpLoad %v4int %a
// CHECK-NEXT: [[vec1_2:%[0-9]+]] = OpVectorShuffle %v2int [[a]] [[a]] 0 1
// CHECK-NEXT: [[vec2_2:%[0-9]+]] = OpVectorShuffle %v2int [[a]] [[a]] 2 3
// CHECK-NEXT: {{%[0-9]+}} = OpCompositeConstruct %_arr_v2int_uint_2 [[vec1_2]] [[vec2_2]]
int4 a;
int2x2 b = a;
return float4(mat1[0][0], mat2[0][1], mat3[1][0], mat1[1][1]);
}

10
tools/clang/test/CodeGenSPIRV/cast.vec-to-mat.implicit.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cast.vec-to-mat.implicit.hlsl
Просмотреть файл

@ -1,19 +1,19 @@
// RUN: %dxc -T ps_6_0 -E main
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
float4 main(float4 input : A) : SV_Target {
// CHECK: [[vec:%\d+]] = OpConstantComposite %v4float %float_1 %float_2 %float_3 %float_4
// CHECK: [[vec:%[0-9]+]] = OpConstantComposite %v4float %float_1 %float_2 %float_3 %float_4
// CHECK: OpStore %var1 [[vec]]
float4 var1 = float4(1,2,3,4);
// CHECK-NEXT: [[vec1:%\d+]] = OpLoad %v4float %var1
// CHECK-NEXT: [[vec1:%[0-9]+]] = OpLoad %v4float %var1
// CHECK-NEXT: OpStore %var2 [[vec1]]
float4x1 var2 = var1;
// CHECK-NEXT: [[vec2:%\d+]] = OpLoad %v4float %input
// CHECK-NEXT: [[vec2:%[0-9]+]] = OpLoad %v4float %input
// CHECK-NEXT: OpStore %var3 [[vec2]]
float1x4 var3 = input;
// CHECK-NEXT: [[vec3:%\d+]] = OpLoad %v4float %input
// CHECK-NEXT: [[vec3:%[0-9]+]] = OpLoad %v4float %input
// CHECK-NEXT: OpStore %var4 [[vec3]]
float4x1 var4 = input;

56
tools/clang/test/CodeGenSPIRV_Lit/cast.vector.splat.hlsl Normal file
Просмотреть файл

@ -0,0 +1,56 @@
// RUN: %dxc -T vs_6_0 -E main -fcgl %s -spirv | FileCheck %s
// CHECK: [[v4f32c:%[0-9]+]] = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1
// CHECK: [[v3f32c:%[0-9]+]] = OpConstantComposite %v3float %float_2 %float_2 %float_2
// CHECK: [[v4fc_2:%[0-9]+]] = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2
// CHECK: [[v4fc_3:%[0-9]+]] = OpConstantComposite %v4float %float_3 %float_3 %float_3 %float_3
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
// From constant
// CHECK: OpStore %vf4 [[v4f32c]]
float4 vf4 = 1;
// CHECK-NEXT: OpStore %vf3 [[v3f32c]]
float3 vf3;
vf3 = float1(2);
// CHECK-NEXT: [[si:%[0-9]+]] = OpLoad %int %si
// CHECK-NEXT: [[vi4:%[0-9]+]] = OpCompositeConstruct %v4int [[si]] [[si]] [[si]] [[si]]
// CHECK-NEXT: OpStore %vi4 [[vi4]]
int si;
int4 vi4 = si;
// CHECK-NEXT: [[si1:%[0-9]+]] = OpLoad %int %si1
// CHECK-NEXT: [[vi3:%[0-9]+]] = OpCompositeConstruct %v3int [[si1]] [[si1]] [[si1]]
// CHECK-NEXT: OpStore %vi3 [[vi3]]
int1 si1;
int3 vi3;
vi3 = si1;
// CHECK-NEXT: [[v0p5:%[0-9]+]] = OpCompositeConstruct %v4float %float_0_5 %float_0_5 %float_0_5 %float_0_5
// CHECK-NEXT: OpStore %vf4 [[v0p5]]
vf4 = float4(0.5.xxxx);
// CHECK-NEXT: [[v3:%[0-9]+]] = OpCompositeConstruct %v3int %int_3 %int_3 %int_3
// CHECK-NEXT: OpStore %vi3 [[v3]]
vi3 = int3(3.xxx);
float sf;
// CHECK: [[sf:%[0-9]+]] = OpLoad %float %sf
// CHECK-NEXT: [[sf_v4:%[0-9]+]] = OpCompositeConstruct %v4float [[sf]] [[sf]] [[sf]] [[sf]]
// CHECK-NEXT: OpStore %vf4_0 [[sf_v4]]
float4 vf4_0 = (sf, sf, sf, sf);
// CHECK: [[sf_0:%[0-9]+]] = OpLoad %float %sf
// CHECK-NEXT: [[sf_v4_0:%[0-9]+]] = OpCompositeConstruct %v4float [[sf_0]] [[sf_0]] [[sf_0]] [[sf_0]]
// CHECK-NEXT: OpStore %vf4 [[sf_v4_0]]
vf4 = (sf, sf, sf, sf);
// CHECK: OpStore %vf4_1 [[v4fc_2]]
float4 vf4_1 = (2.0f, 2.0f, 2.0f, 2.0f);
// CHECK: OpStore %vf4 [[v4fc_3]]
vf4 = (3.0f, 3.0f, 3.0f, 3.0f);
}

56
tools/clang/test/CodeGenSPIRV_Lit/cast.vector.trunc.hlsl Normal file
Просмотреть файл

@ -0,0 +1,56 @@
// RUN: %dxc -T vs_6_0 -E main -fcgl %s -spirv | FileCheck %s
// CHECK: [[v3f32c0:%[0-9]+]] = OpConstantComposite %v3float %float_1 %float_2 %float_3
// CHECK: [[v3f32c1:%[0-9]+]] = OpConstantComposite %v3float %float_5 %float_6 %float_7
// CHECK: [[v2f32c:%[0-9]+]] = OpConstantComposite %v2float %float_8 %float_9
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
// From constant
// CHECK: OpStore %vf3 [[v3f32c0]]
float3 vf3 = float4(1, 2, 3, 4);
// CHECK-NEXT: [[c5:%[0-9]+]] = OpCompositeExtract %float [[v3f32c1]] 0
// CHECK-NEXT: OpStore %vf1 [[c5]]
float1 vf1;
vf1 = float3(5, 6, 7);
// CHECK-NEXT: [[c8:%[0-9]+]] = OpCompositeExtract %float [[v2f32c]] 0
// CHECK-NEXT: OpStore %sfa [[c8]]
float sfa = float2(8, 9);
// CHECK-NEXT: OpStore %sfb %float_10
float sfb;
sfb = float1(10);
// From variable
int4 vi4;
// CHECK-NEXT: [[vi4:%[0-9]+]] = OpLoad %v4int %vi4
// CHECK-NEXT: [[e1:%[0-9]+]] = OpCompositeExtract %int [[vi4]] 0
// CHECK-NEXT: [[e2:%[0-9]+]] = OpCompositeExtract %int [[vi4]] 1
// CHECK-NEXT: [[e3:%[0-9]+]] = OpCompositeExtract %int [[vi4]] 2
// CHECK-NEXT: [[vi3:%[0-9]+]] = OpCompositeConstruct %v3int [[e1]] [[e2]] [[e3]]
// CHECK-NEXT: OpStore %vi3 [[vi3]]
int3 vi3;
vi3 = vi4;
// CHECK-NEXT: [[vi3_1:%[0-9]+]] = OpLoad %v3int %vi3
// CHECK-NEXT: [[e4:%[0-9]+]] = OpCompositeExtract %int [[vi3_1]] 0
// CHECK-NEXT: OpStore %vi1 [[e4]]
int1 vi1 = vi3;
// CHECK-NEXT: [[vi3_2:%[0-9]+]] = OpLoad %v3int %vi3
// CHECK-NEXT: [[e5:%[0-9]+]] = OpCompositeExtract %int [[vi3_2]] 0
// CHECK-NEXT: OpStore %sia [[e5]]
int sia;
sia = vi3;
// CHECK-NEXT: [[vi1:%[0-9]+]] = OpLoad %int %vi1
// CHECK-NEXT: OpStore %sib [[vi1]]
int sib = vi1;
// Used in expression
// CHECK-NEXT: [[sia:%[0-9]+]] = OpLoad %int %sia
// CHECK-NEXT: [[cc0:%[0-9]+]] = OpCompositeConstruct %v3int [[sia]] [[sia]] [[sia]]
// CHECK-NEXT: [[vi3_3:%[0-9]+]] = OpLoad %v3int %vi3
// CHECK-NEXT: [[add:%[0-9]+]] = OpIAdd %v3int [[cc0]] [[vi3_3]]
// CHECK-NEXT: [[e6:%[0-9]+]] = OpCompositeExtract %int [[add]] 0
// CHECK-NEXT: OpStore %sib [[e6]]
sib = sia + vi3;
}

10
tools/clang/test/CodeGenSPIRV/cf.for.break.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cf.for.break.hlsl
Просмотреть файл

@ -1,4 +1,4 @@
// RUN: %dxc -T ps_6_0 -E main
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
void main() {
int val = 0;
@ -6,11 +6,11 @@ void main() {
// CHECK: OpBranch %for_check
// CHECK-NEXT: %for_check = OpLabel
// CHECK: OpLoopMerge %for_merge %for_continue None
// CHECK-NEXT: OpBranchConditional {{%\d+}} %for_body %for_merge
// CHECK-NEXT: OpBranchConditional {{%[0-9]+}} %for_body %for_merge
for (int i = 0; i < 10; ++i) {
// CHECK-NEXT: %for_body = OpLabel
// CHECK: OpSelectionMerge %if_merge None
// CHECK-NEXT: OpBranchConditional {{%\d+}} %if_true %if_merge
// CHECK-NEXT: OpBranchConditional {{%[0-9]+}} %if_true %if_merge
if (i < 5) {
// CHECK-NEXT: %if_true = OpLabel
// CHECK-NEXT: OpBranch %for_merge
@ -39,7 +39,7 @@ void main() {
// CHECK-NEXT: %for_check_0 = OpLabel
// CHECK: OpLoopMerge %for_merge_1 %for_continue_1 None
// CHECK-NEXT: OpBranchConditional {{%\d+}} %for_body_0 %for_merge_1
// CHECK-NEXT: OpBranchConditional {{%[0-9]+}} %for_body_0 %for_merge_1
for (int j = 0; j < 10; ++j) {
// CHECK-NEXT: %for_body_0 = OpLabel
val = j+5;
@ -47,7 +47,7 @@ void main() {
// CHECK-NEXT: %for_check_1 = OpLabel
// CHECK: OpLoopMerge %for_merge_0 %for_continue_0 None
// CHECK-NEXT: OpBranchConditional {{%\d+}} %for_body_1 %for_merge_0
// CHECK-NEXT: OpBranchConditional {{%[0-9]+}} %for_body_1 %for_merge_0
for ( ; val < 20; ++val) {
// CHECK-NEXT: %for_body_1 = OpLabel
int k = val + j;

10
tools/clang/test/CodeGenSPIRV/cf.for.continue.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cf.for.continue.hlsl
Просмотреть файл

@ -1,4 +1,4 @@
// RUN: %dxc -T ps_6_0 -E main
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
void main() {
int val = 0;
@ -6,11 +6,11 @@ void main() {
// CHECK: OpBranch %for_check
// CHECK-NEXT: %for_check = OpLabel
// CHECK: OpLoopMerge %for_merge %for_continue None
// CHECK-NEXT: OpBranchConditional {{%\d+}} %for_body %for_merge
// CHECK-NEXT: OpBranchConditional {{%[0-9]+}} %for_body %for_merge
for (int i = 0; i < 10; ++i) {
// CHECK-NEXT: %for_body = OpLabel
// CHECK: OpSelectionMerge %if_merge None
// CHECK-NEXT: OpBranchConditional {{%\d+}} %if_true %if_merge
// CHECK-NEXT: OpBranchConditional {{%[0-9]+}} %if_true %if_merge
if (i < 5) {
// CHECK-NEXT: %if_true = OpLabel
// CHECK-NEXT: OpBranch %for_continue
@ -41,7 +41,7 @@ void main() {
// CHECK-NEXT: %for_check_0 = OpLabel
// CHECK: OpLoopMerge %for_merge_1 %for_continue_1 None
// CHECK-NEXT: OpBranchConditional {{%\d+}} %for_body_0 %for_merge_1
// CHECK-NEXT: OpBranchConditional {{%[0-9]+}} %for_body_0 %for_merge_1
for (int j = 0; j < 10; ++j) {
// CHECK-NEXT: %for_body_0 = OpLabel
val = j+5;
@ -49,7 +49,7 @@ void main() {
// CHECK-NEXT: %for_check_1 = OpLabel
// CHECK: OpLoopMerge %for_merge_0 %for_continue_0 None
// CHECK-NEXT: OpBranchConditional {{%\d+}} %for_body_1 %for_merge_0
// CHECK-NEXT: OpBranchConditional {{%[0-9]+}} %for_body_1 %for_merge_0
for ( ; val < 20; ++val) {
// CHECK-NEXT: %for_body_1 = OpLabel
int k = val + j;

42
tools/clang/test/CodeGenSPIRV/cf.for.nested.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cf.for.nested.hlsl
Просмотреть файл

@ -1,4 +1,4 @@
// RUN: %dxc -T ps_6_0 -E main
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
@ -9,23 +9,23 @@ void main() {
// CHECK-NEXT: OpBranch %for_check
// CHECK-LABEL: %for_check = OpLabel
// CHECK-NEXT: [[i0:%\d+]] = OpLoad %int %i
// CHECK-NEXT: [[lt0:%\d+]] = OpSLessThan %bool [[i0]] %int_10
// CHECK-NEXT: [[i0:%[0-9]+]] = OpLoad %int %i
// CHECK-NEXT: [[lt0:%[0-9]+]] = OpSLessThan %bool [[i0]] %int_10
// CHECK-NEXT: OpLoopMerge %for_merge_1 %for_continue_1 Unroll
// CHECK-NEXT: OpBranchConditional [[lt0]] %for_body %for_merge_1
[unroll] for (int i = 0; i < 10; ++i) {
// CHECK-LABEL: %for_body = OpLabel
// CHECK-NEXT: [[val0:%\d+]] = OpLoad %int %val
// CHECK-NEXT: [[i1:%\d+]] = OpLoad %int %i
// CHECK-NEXT: [[add0:%\d+]] = OpIAdd %int [[val0]] [[i1]]
// CHECK-NEXT: [[val0:%[0-9]+]] = OpLoad %int %val
// CHECK-NEXT: [[i1:%[0-9]+]] = OpLoad %int %i
// CHECK-NEXT: [[add0:%[0-9]+]] = OpIAdd %int [[val0]] [[i1]]
// CHECK-NEXT: OpStore %val [[add0]]
val = val + i;
// CHECK-NEXT: OpStore %j %int_0
// CHECK-NEXT: OpBranch %for_check_0
// CHECK-LABEL: %for_check_0 = OpLabel
// CHECK-NEXT: [[j0:%\d+]] = OpLoad %int %j
// CHECK-NEXT: [[lt1:%\d+]] = OpSLessThan %bool [[j0]] %int_10
// CHECK-NEXT: [[j0:%[0-9]+]] = OpLoad %int %j
// CHECK-NEXT: [[lt1:%[0-9]+]] = OpSLessThan %bool [[j0]] %int_10
// CHECK-NEXT: OpLoopMerge %for_merge_0 %for_continue_0 DontUnroll
// CHECK-NEXT: OpBranchConditional [[lt1]] %for_body_0 %for_merge_0
[loop] for (int j = 0; j < 10; ++j) {
@ -34,36 +34,36 @@ void main() {
// CHECK-NEXT: OpBranch %for_check_1
// CHECK-LABEL: %for_check_1 = OpLabel
// CHECK-NEXT: [[k0:%\d+]] = OpLoad %int %k
// CHECK-NEXT: [[lt2:%\d+]] = OpSLessThan %bool [[k0]] %int_10
// CHECK-NEXT: [[k0:%[0-9]+]] = OpLoad %int %k
// CHECK-NEXT: [[lt2:%[0-9]+]] = OpSLessThan %bool [[k0]] %int_10
// CHECK-NEXT: OpLoopMerge %for_merge %for_continue DontUnroll
// CHECK-NEXT: OpBranchConditional [[lt2]] %for_body_1 %for_merge
[fastopt] for (int k = 0; k < 10; ++k) {
// CHECK-LABEL: %for_body_1 = OpLabel
// CHECK-NEXT: [[val1:%\d+]] = OpLoad %int %val
// CHECK-NEXT: [[k1:%\d+]] = OpLoad %int %k
// CHECK-NEXT: [[add1:%\d+]] = OpIAdd %int [[val1]] [[k1]]
// CHECK-NEXT: [[val1:%[0-9]+]] = OpLoad %int %val
// CHECK-NEXT: [[k1:%[0-9]+]] = OpLoad %int %k
// CHECK-NEXT: [[add1:%[0-9]+]] = OpIAdd %int [[val1]] [[k1]]
// CHECK-NEXT: OpStore %val [[add1]]
// CHECK-NEXT: OpBranch %for_continue
val = val + k;
// CHECK-LABEL: %for_continue = OpLabel
// CHECK-NEXT: [[k2:%\d+]] = OpLoad %int %k
// CHECK-NEXT: [[add2:%\d+]] = OpIAdd %int [[k2]] %int_1
// CHECK-NEXT: [[k2:%[0-9]+]] = OpLoad %int %k
// CHECK-NEXT: [[add2:%[0-9]+]] = OpIAdd %int [[k2]] %int_1
// CHECK-NEXT: OpStore %k [[add2]]
// CHECK-NEXT: OpBranch %for_check_1
}
// CHECK-LABEL: %for_merge = OpLabel
// CHECK-NEXT: [[val2:%\d+]] = OpLoad %int %val
// CHECK-NEXT: [[mul0:%\d+]] = OpIMul %int [[val2]] %int_2
// CHECK-NEXT: [[val2:%[0-9]+]] = OpLoad %int %val
// CHECK-NEXT: [[mul0:%[0-9]+]] = OpIMul %int [[val2]] %int_2
// CHECK-NEXT: OpStore %val [[mul0]]
// CHECK-NEXT: OpBranch %for_continue_0
val = val * 2;
// CHECK-LABEL: %for_continue_0 = OpLabel
// CHECK-NEXT: [[j1:%\d+]] = OpLoad %int %j
// CHECK-NEXT: [[add3:%\d+]] = OpIAdd %int [[j1]] %int_1
// CHECK-NEXT: [[j1:%[0-9]+]] = OpLoad %int %j
// CHECK-NEXT: [[add3:%[0-9]+]] = OpIAdd %int [[j1]] %int_1
// CHECK-NEXT: OpStore %j [[add3]]
// CHECK-NEXT: OpBranch %for_check_0
}
@ -71,8 +71,8 @@ void main() {
// CHECK-NEXT: OpBranch %for_continue_1
// CHECK-LABEL: %for_continue_1 = OpLabel
// CHECK-NEXT: [[i2:%\d+]] = OpLoad %int %i
// CHECK-NEXT: [[add4:%\d+]] = OpIAdd %int [[i2]] %int_1
// CHECK-NEXT: [[i2:%[0-9]+]] = OpLoad %int %i
// CHECK-NEXT: [[add4:%[0-9]+]] = OpIAdd %int [[i2]] %int_1
// CHECK-NEXT: OpStore %i [[add4]]
// CHECK-NEXT: OpBranch %for_check
}

20
tools/clang/test/CodeGenSPIRV/cf.for.plain.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cf.for.plain.hlsl
Просмотреть файл

@ -1,4 +1,4 @@
// RUN: %dxc -T ps_6_0 -E main
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
@ -6,19 +6,19 @@ void main() {
// CHECK: OpBranch %for_check
// CHECK-LABEL: %for_check = OpLabel
// CHECK-NEXT: [[i0:%\d+]] = OpLoad %int %i
// CHECK-NEXT: [[lt0:%\d+]] = OpSLessThan %bool [[i0]] %int_10
// CHECK-NEXT: [[i0:%[0-9]+]] = OpLoad %int %i
// CHECK-NEXT: [[lt0:%[0-9]+]] = OpSLessThan %bool [[i0]] %int_10
// CHECK-NEXT: OpLoopMerge %for_merge %for_continue None
// CHECK-NEXT: OpBranchConditional [[lt0]] %for_body %for_merge
for (int i = 0; i < 10; ++i) {
// CHECK-LABEL: %for_body = OpLabel
// CHECK-NEXT: [[i1:%\d+]] = OpLoad %int %i
// CHECK-NEXT: [[i1:%[0-9]+]] = OpLoad %int %i
// CHECK-NEXT: OpStore %val [[i1]]
// CHECK-NEXT: OpBranch %for_continue
val = i;
// CHECK-LABEL: %for_continue = OpLabel
// CHECK-NEXT: [[i2:%\d+]] = OpLoad %int %i
// CHECK-NEXT: [[add0:%\d+]] = OpIAdd %int [[i2]] %int_1
// CHECK-NEXT: [[i2:%[0-9]+]] = OpLoad %int %i
// CHECK-NEXT: [[add0:%[0-9]+]] = OpIAdd %int [[i2]] %int_1
// CHECK-NEXT: OpStore %i [[add0]]
// CHECK-NEXT: OpBranch %for_check
}
@ -42,8 +42,8 @@ void main() {
// Null body
// CHECK-LABEL: %for_check_1 = OpLabel
// CHECK-NEXT: [[j0:%\d+]] = OpLoad %int %j
// CHECK-NEXT: [[lt1:%\d+]] = OpSLessThan %bool [[j0]] %int_10
// CHECK-NEXT: [[j0:%[0-9]+]] = OpLoad %int %j
// CHECK-NEXT: [[lt1:%[0-9]+]] = OpSLessThan %bool [[j0]] %int_10
// CHECK-NEXT: OpLoopMerge %for_merge_1 %for_continue_1 None
// CHECK-NEXT: OpBranchConditional [[lt1]] %for_body_1 %for_merge_1
for (int j = 0; j < 10; ++j)
@ -51,8 +51,8 @@ void main() {
// CHECK-NEXT: OpBranch %for_continue_1
;
// CHECK-LABEL: %for_continue_1 = OpLabel
// CHECK-NEXT: [[j1:%\d+]] = OpLoad %int %j
// CHECK-NEXT: [[add1:%\d+]] = OpIAdd %int [[j1]] %int_1
// CHECK-NEXT: [[j1:%[0-9]+]] = OpLoad %int %j
// CHECK-NEXT: [[add1:%[0-9]+]] = OpIAdd %int [[j1]] %int_1
// CHECK-NEXT: OpStore %j [[add1]]
// CHECK-NEXT: OpBranch %for_check_1

12
tools/clang/test/CodeGenSPIRV/cf.for.short-circuited-cond.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cf.for.short-circuited-cond.hlsl
Просмотреть файл

@ -1,4 +1,4 @@
// RUN: %dxc -T ps_6_0 -E main -HV 2021
// RUN: %dxc -T ps_6_0 -E main -HV 2021 -fcgl %s -spirv | FileCheck %s
void main() {
bool a, b;
@ -7,7 +7,7 @@ void main() {
// CHECK-NEXT: OpLoopMerge %for_merge %for_continue None
// CHECK-NEXT: OpBranch %for_check
// CHECK-NEXT: %for_check = OpLabel
// CHECK: OpBranchConditional {{%\d+}} %for_body %for_merge
// CHECK: OpBranchConditional {{%[0-9]+}} %for_body %for_merge
for (int i = 0; a && b; ++i) {
// CHECK-NEXT: %for_body = OpLabel
// CHECK-NEXT: OpBranch %for_continue
@ -21,7 +21,7 @@ void main() {
// CHECK-NEXT: OpLoopMerge %for_merge_0 %for_continue_0 None
// CHECK-NEXT: OpBranch %for_check_0
// CHECK-NEXT: %for_check_0 = OpLabel
// CHECK: OpBranchConditional {{%\d+}} %for_body_0 %for_merge_0
// CHECK: OpBranchConditional {{%[0-9]+}} %for_body_0 %for_merge_0
for (int i = 0; a || b; ++i) {
// CHECK-NEXT: %for_body_0 = OpLabel
// CHECK-NEXT: OpBranch %for_continue_0
@ -35,7 +35,7 @@ void main() {
// CHECK-NEXT: OpLoopMerge %for_merge_1 %for_continue_1 None
// CHECK-NEXT: OpBranch %for_check_1
// CHECK-NEXT: %for_check_1 = OpLabel
// CHECK: OpBranchConditional {{%\d+}} %for_body_1 %for_merge_1
// CHECK: OpBranchConditional {{%[0-9]+}} %for_body_1 %for_merge_1
for (int i = 0; a && ((a || b) && b); ++i) {
// CHECK-NEXT: %for_body_1 = OpLabel
// CHECK-NEXT: OpBranch %for_continue_1
@ -49,7 +49,7 @@ void main() {
// CHECK-NEXT: OpLoopMerge %for_merge_2 %for_continue_2 None
// CHECK-NEXT: OpBranch %for_check_2
// CHECK-NEXT: %for_check_2 = OpLabel
// CHECK: OpBranchConditional {{%\d+}} %for_body_2 %for_merge_2
// CHECK: OpBranchConditional {{%[0-9]+}} %for_body_2 %for_merge_2
for (int i = 0; a ? a : b; ++i) {
// CHECK-NEXT: %for_body_2 = OpLabel
// CHECK-NEXT: OpBranch %for_continue_2
@ -64,7 +64,7 @@ void main() {
// CHECK-NEXT: OpLoopMerge %for_merge_3 %for_continue_3 None
// CHECK-NEXT: OpBranch %for_check_3
// CHECK-NEXT: %for_check_3 = OpLabel
// CHECK: OpBranchConditional {{%\d+}} %for_body_3 %for_merge_3
// CHECK: OpBranchConditional {{%[0-9]+}} %for_body_3 %for_merge_3
for (int i = 0; x + (x && y); ++i) {
// CHECK-NEXT: %for_body_3 = OpLabel
// CHECK-NEXT: OpBranch %for_continue_3

2
tools/clang/test/CodeGenSPIRV/cf.if.const-cond.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cf.if.const-cond.hlsl
Просмотреть файл

@ -1,4 +1,4 @@
// RUN: %dxc -T vs_6_0 -E main
// RUN: %dxc -T vs_6_0 -E main -fcgl %s -spirv | FileCheck %s
void main(out float a: A, out float b: B) {
// CHECK-LABEL: %bb_entry = OpLabel

10
tools/clang/test/CodeGenSPIRV/cf.if.nested.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cf.if.nested.hlsl
Просмотреть файл

@ -1,17 +1,17 @@
// RUN: %dxc -T ps_6_0 -E main
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
bool c1, c2, c3, c4;
int val = 0;
// CHECK: [[c1:%\d+]] = OpLoad %bool %c1
// CHECK: [[c1:%[0-9]+]] = OpLoad %bool %c1
// CHECK-NEXT: OpSelectionMerge %if_merge_2 None
// CHECK-NEXT: OpBranchConditional [[c1]] %if_true %if_false
if (c1) {
// CHECK-LABEL: %if_true = OpLabel
// CHECK-NEXT: [[c2:%\d+]] = OpLoad %bool %c2
// CHECK-NEXT: [[c2:%[0-9]+]] = OpLoad %bool %c2
// CHECK-NEXT: OpSelectionMerge %if_merge None
// CHECK-NEXT: OpBranchConditional [[c2]] %if_true_0 %if_merge
if (c2)
@ -25,7 +25,7 @@ void main() {
} else {
// CHECK-LABEL: %if_false = OpLabel
// CHECK-NEXT: [[c3:%\d+]] = OpLoad %bool %c3
// CHECK-NEXT: [[c3:%[0-9]+]] = OpLoad %bool %c3
// CHECK-NEXT: OpSelectionMerge %if_merge_1 None
// CHECK-NEXT: OpBranchConditional [[c3]] %if_true_1 %if_false_0
if (c3) {
@ -37,7 +37,7 @@ void main() {
} else {
// CHECK-LABEL: %if_false_0 = OpLabel
// CHECK-NEXT: [[c4:%\d+]] = OpLoad %bool %c4
// CHECK-NEXT: [[c4:%[0-9]+]] = OpLoad %bool %c4
// CHECK-NEXT: OpSelectionMerge %if_merge_0 None
// CHECK-NEXT: OpBranchConditional [[c4]] %if_true_2 %if_merge_0
if (c4) {

24
tools/clang/test/CodeGenSPIRV/cf.if.plain.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cf.if.plain.hlsl
Просмотреть файл

@ -1,4 +1,4 @@
// RUN: %dxc -T ps_6_0 -E main
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
void main() {
// CHECK-LABEL: %bb_entry = OpLabel
@ -6,20 +6,20 @@ void main() {
int val;
// Both then and else
// CHECK: [[c0:%\d+]] = OpLoad %bool %c
// CHECK: [[c0:%[0-9]+]] = OpLoad %bool %c
// CHECK-NEXT: OpSelectionMerge %if_merge Flatten
// CHECK-NEXT: OpBranchConditional [[c0]] %if_true %if_false
[flatten] if (c) {
// CHECK-LABEL: %if_true = OpLabel
// CHECK-NEXT: [[val0:%\d+]] = OpLoad %int %val
// CHECK-NEXT: [[val1:%\d+]] = OpIAdd %int [[val0]] %int_1
// CHECK-NEXT: [[val0:%[0-9]+]] = OpLoad %int %val
// CHECK-NEXT: [[val1:%[0-9]+]] = OpIAdd %int [[val0]] %int_1
// CHECK-NEXT: OpStore %val [[val1]]
// CHECK-NEXT: OpBranch %if_merge
val = val + 1;
} else {
// CHECK-LABEL: %if_false = OpLabel
// CHECK-NEXT: [[val2:%\d+]] = OpLoad %int %val
// CHECK-NEXT: [[val3:%\d+]] = OpIAdd %int [[val2]] %int_2
// CHECK-NEXT: [[val2:%[0-9]+]] = OpLoad %int %val
// CHECK-NEXT: [[val3:%[0-9]+]] = OpIAdd %int [[val2]] %int_2
// CHECK-NEXT: OpStore %val [[val3]]
// CHECK-NEXT: OpBranch %if_merge
val = val + 2;
@ -27,7 +27,7 @@ void main() {
// CHECK-LABEL: %if_merge = OpLabel
// No else
// CHECK-NEXT: [[c1:%\d+]] = OpLoad %bool %c
// CHECK-NEXT: [[c1:%[0-9]+]] = OpLoad %bool %c
// CHECK-NEXT: OpSelectionMerge %if_merge_0 None
// CHECK-NEXT: OpBranchConditional [[c1]] %if_true_0 %if_merge_0
if (c)
@ -38,7 +38,7 @@ void main() {
// CHECK-LABEL: %if_merge_0 = OpLabel
// Empty then
// CHECK-NEXT: [[c2:%\d+]] = OpLoad %bool %c
// CHECK-NEXT: [[c2:%[0-9]+]] = OpLoad %bool %c
// CHECK-NEXT: OpSelectionMerge %if_merge_1 None
// CHECK-NEXT: OpBranchConditional [[c2]] %if_true_1 %if_false_0
if (c) {
@ -53,7 +53,7 @@ void main() {
// CHECK-LABEL: %if_merge_1 = OpLabel
// Null body
// CHECK-NEXT: [[c3:%\d+]] = OpLoad %bool %c
// CHECK-NEXT: [[c3:%[0-9]+]] = OpLoad %bool %c
// CHECK-NEXT: OpSelectionMerge %if_merge_2 None
// CHECK-NEXT: OpBranchConditional [[c3]] %if_true_2 %if_merge_2
if (c)
@ -63,10 +63,10 @@ void main() {
// CHECK-LABEL: %if_merge_2 = OpLabel
// CHECK-NEXT: [[val4:%\d+]] = OpLoad %int %val
// CHECK-NEXT: [[val4:%[0-9]+]] = OpLoad %int %val
// CHECK-NEXT: OpStore %d [[val4]]
// CHECK-NEXT: [[d:%\d+]] = OpLoad %int %d
// CHECK-NEXT: [[cmp:%\d+]] = OpINotEqual %bool [[d]] %int_0
// CHECK-NEXT: [[d:%[0-9]+]] = OpLoad %int %d
// CHECK-NEXT: [[cmp:%[0-9]+]] = OpINotEqual %bool [[d]] %int_0
// CHECK-NEXT: OpSelectionMerge %if_merge_3 DontFlatten
// CHECK-NEXT: OpBranchConditional [[cmp]] %if_true_3 %if_merge_3
[branch] if (int d = val) {

84
tools/clang/test/CodeGenSPIRV/cf.switch.ifstmt.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cf.switch.ifstmt.hlsl
Просмотреть файл

@ -1,4 +1,4 @@
// RUN: %dxc -T ps_6_0 -E main
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
int foo() { return 200; }
@ -18,16 +18,16 @@ void main() {
// DefaultStmt is the first statement //
////////////////////////////////////////
// CHECK: [[a0:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[is_a_1:%\d+]] = OpIEqual %bool [[a0]] %int_1
// CHECK: [[a0:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: [[is_a_1:%[0-9]+]] = OpIEqual %bool [[a0]] %int_1
// CHECK-NEXT: OpSelectionMerge %if_merge_0 None
// CHECK-NEXT: OpBranchConditional [[is_a_1]] %if_true %if_false
// CHECK-NEXT: %if_true = OpLabel
// CHECK-NEXT: OpStore %b %int_1
// CHECK-NEXT: OpBranch %if_merge_0
// CHECK-NEXT: %if_false = OpLabel
// CHECK-NEXT: [[a1:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[is_a_2:%\d+]] = OpIEqual %bool [[a1]] %int_2
// CHECK-NEXT: [[a1:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: [[is_a_2:%[0-9]+]] = OpIEqual %bool [[a1]] %int_2
// CHECK-NEXT: OpSelectionMerge %if_merge None
// CHECK-NEXT: OpBranchConditional [[is_a_2]] %if_true_0 %if_false_0
// CHECK-NEXT: %if_true_0 = OpLabel
@ -55,8 +55,8 @@ void main() {
// DefaultStmt in the middle of other cases //
//////////////////////////////////////////////
// CHECK-NEXT: [[a2:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[is_a_10:%\d+]] = OpIEqual %bool [[a2]] %int_10
// CHECK-NEXT: [[a2:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: [[is_a_10:%[0-9]+]] = OpIEqual %bool [[a2]] %int_10
// CHECK-NEXT: OpSelectionMerge %if_merge_2 None
// CHECK-NEXT: OpBranchConditional [[is_a_10]] %if_true_1 %if_false_1
// CHECK-NEXT: %if_true_1 = OpLabel
@ -65,8 +65,8 @@ void main() {
// CHECK-NEXT: OpStore %b %int_2
// CHECK-NEXT: OpBranch %if_merge_2
// CHECK-NEXT: %if_false_1 = OpLabel
// CHECK-NEXT: [[a3:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[is_a_20:%\d+]] = OpIEqual %bool [[a3]] %int_20
// CHECK-NEXT: [[a3:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: [[is_a_20:%[0-9]+]] = OpIEqual %bool [[a3]] %int_20
// CHECK-NEXT: OpSelectionMerge %if_merge_1 None
// CHECK-NEXT: OpBranchConditional [[is_a_20]] %if_true_2 %if_false_2
// CHECK-NEXT: %if_true_2 = OpLabel
@ -94,70 +94,70 @@ void main() {
// DefaultStmt is the last statement //
///////////////////////////////////////////////
// CHECK: [[d0:%\d+]] = OpLoad %int %d
// CHECK-NEXT: [[is_d_1:%\d+]] = OpIEqual %bool [[d0]] %int_1
// CHECK: [[d0:%[0-9]+]] = OpLoad %int %d
// CHECK-NEXT: [[is_d_1:%[0-9]+]] = OpIEqual %bool [[d0]] %int_1
// CHECK-NEXT: OpSelectionMerge %if_merge_10 None
// CHECK-NEXT: OpBranchConditional [[is_d_1]] %if_true_3 %if_false_3
// CHECK-NEXT: %if_true_3 = OpLabel
// CHECK-NEXT: OpStore %b %int_1
// CHECK-NEXT: [[foo:%\d+]] = OpFunctionCall %int %foo
// CHECK-NEXT: [[foo:%[0-9]+]] = OpFunctionCall %int %foo
// CHECK-NEXT: OpStore %c [[foo]]
// CHECK-NEXT: OpStore %b %int_2
// CHECK-NEXT: OpBranch %if_merge_10
// CHECK-NEXT: %if_false_3 = OpLabel
// CHECK-NEXT: [[d1:%\d+]] = OpLoad %int %d
// CHECK-NEXT: [[is_d_2:%\d+]] = OpIEqual %bool [[d1]] %int_2
// CHECK-NEXT: [[d1:%[0-9]+]] = OpLoad %int %d
// CHECK-NEXT: [[is_d_2:%[0-9]+]] = OpIEqual %bool [[d1]] %int_2
// CHECK-NEXT: OpSelectionMerge %if_merge_9 None
// CHECK-NEXT: OpBranchConditional [[is_d_2]] %if_true_4 %if_false_4
// CHECK-NEXT: %if_true_4 = OpLabel
// CHECK-NEXT: OpStore %b %int_2
// CHECK-NEXT: OpBranch %if_merge_9
// CHECK-NEXT: %if_false_4 = OpLabel
// CHECK-NEXT: [[d2:%\d+]] = OpLoad %int %d
// CHECK-NEXT: [[is_d_3:%\d+]] = OpIEqual %bool [[d2]] %int_3
// CHECK-NEXT: [[d2:%[0-9]+]] = OpLoad %int %d
// CHECK-NEXT: [[is_d_3:%[0-9]+]] = OpIEqual %bool [[d2]] %int_3
// CHECK-NEXT: OpSelectionMerge %if_merge_8 None
// CHECK-NEXT: OpBranchConditional [[is_d_3]] %if_true_5 %if_false_5
// CHECK-NEXT: %if_true_5 = OpLabel
// CHECK-NEXT: OpStore %b %int_3
// CHECK-NEXT: OpBranch %if_merge_8
// CHECK-NEXT: %if_false_5 = OpLabel
// CHECK-NEXT: [[d3:%\d+]] = OpLoad %int %d
// CHECK-NEXT: [[d3:%[0-9]+]] = OpLoad %int %d
// TODO: We should try to const fold `t` and avoid the following OpLoad:
// CHECK-NEXT: [[t:%\d+]] = OpLoad %int %t
// CHECK-NEXT: [[is_d_eq_t:%\d+]] = OpIEqual %bool [[d3]] [[t]]
// CHECK-NEXT: [[t:%[0-9]+]] = OpLoad %int %t
// CHECK-NEXT: [[is_d_eq_t:%[0-9]+]] = OpIEqual %bool [[d3]] [[t]]
// CHECK-NEXT: OpSelectionMerge %if_merge_7 None
// CHECK-NEXT: OpBranchConditional [[is_d_eq_t]] %if_true_6 %if_false_6
// CHECK-NEXT: %if_true_6 = OpLabel
// CHECK-NEXT: [[t1:%\d+]] = OpLoad %int %t
// CHECK-NEXT: [[t1:%[0-9]+]] = OpLoad %int %t
// CHECK-NEXT: OpStore %b [[t1]]
// CHECK-NEXT: OpStore %b %int_5
// CHECK-NEXT: OpBranch %if_merge_7
// CHECK-NEXT: %if_false_6 = OpLabel
// CHECK-NEXT: [[d4:%\d+]] = OpLoad %int %d
// CHECK-NEXT: [[is_d_4:%\d+]] = OpIEqual %bool [[d4]] %int_4
// CHECK-NEXT: [[d4:%[0-9]+]] = OpLoad %int %d
// CHECK-NEXT: [[is_d_4:%[0-9]+]] = OpIEqual %bool [[d4]] %int_4
// CHECK-NEXT: OpSelectionMerge %if_merge_6 None
// CHECK-NEXT: OpBranchConditional [[is_d_4]] %if_true_7 %if_false_7
// CHECK-NEXT: %if_true_7 = OpLabel
// CHECK-NEXT: OpStore %b %int_5
// CHECK-NEXT: OpBranch %if_merge_6
// CHECK-NEXT: %if_false_7 = OpLabel
// CHECK-NEXT: [[d5:%\d+]] = OpLoad %int %d
// CHECK-NEXT: [[is_d_5:%\d+]] = OpIEqual %bool [[d5]] %int_5
// CHECK-NEXT: [[d5:%[0-9]+]] = OpLoad %int %d
// CHECK-NEXT: [[is_d_5:%[0-9]+]] = OpIEqual %bool [[d5]] %int_5
// CHECK-NEXT: OpSelectionMerge %if_merge_5 None
// CHECK-NEXT: OpBranchConditional [[is_d_5]] %if_true_8 %if_false_8
// CHECK-NEXT: %if_true_8 = OpLabel
// CHECK-NEXT: OpStore %b %int_5
// CHECK-NEXT: OpBranch %if_merge_5
// CHECK-NEXT: %if_false_8 = OpLabel
// CHECK-NEXT: [[d6:%\d+]] = OpLoad %int %d
// CHECK-NEXT: [[is_d_6:%\d+]] = OpIEqual %bool [[d6]] %int_6
// CHECK-NEXT: [[d6:%[0-9]+]] = OpLoad %int %d
// CHECK-NEXT: [[is_d_6:%[0-9]+]] = OpIEqual %bool [[d6]] %int_6
// CHECK-NEXT: OpSelectionMerge %if_merge_4 None
// CHECK-NEXT: OpBranchConditional [[is_d_6]] %if_true_9 %if_false_9
// CHECK-NEXT: %if_true_9 = OpLabel
// CHECK-NEXT: OpBranch %if_merge_4
// CHECK-NEXT: %if_false_9 = OpLabel
// CHECK-NEXT: [[d7:%\d+]] = OpLoad %int %d
// CHECK-NEXT: [[is_d_7:%\d+]] = OpIEqual %bool [[d7]] %int_7
// CHECK-NEXT: [[d7:%[0-9]+]] = OpLoad %int %d
// CHECK-NEXT: [[is_d_7:%[0-9]+]] = OpIEqual %bool [[d7]] %int_7
// CHECK-NEXT: OpSelectionMerge %if_merge_3 None
// CHECK-NEXT: OpBranchConditional [[is_d_7]] %if_true_10 %if_false_10
// CHECK-NEXT: %if_true_10 = OpLabel
@ -209,8 +209,8 @@ void main() {
// No Default statement //
//////////////////////////
// CHECK-NEXT: [[a4:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[is_a_100:%\d+]] = OpIEqual %bool [[a4]] %int_100
// CHECK-NEXT: [[a4:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: [[is_a_100:%[0-9]+]] = OpIEqual %bool [[a4]] %int_100
// CHECK-NEXT: OpSelectionMerge %if_merge_11 None
// CHECK-NEXT: OpBranchConditional [[is_a_100]] %if_true_11 %if_merge_11
// CHECK-NEXT: %if_true_11 = OpLabel
@ -245,22 +245,22 @@ void main() {
// both cases of the outer switch (case 300 and case 400) //
////////////////////////////////////////////////////////////
// CHECK-NEXT: [[a5:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[is_a_300:%\d+]] = OpIEqual %bool [[a5]] %int_300
// CHECK-NEXT: [[a5:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: [[is_a_300:%[0-9]+]] = OpIEqual %bool [[a5]] %int_300
// CHECK-NEXT: OpSelectionMerge %if_merge_17 None
// CHECK-NEXT: OpBranchConditional [[is_a_300]] %if_true_12 %if_false_12
// CHECK-NEXT: %if_true_12 = OpLabel
// CHECK-NEXT: OpStore %b %int_300
// CHECK-NEXT: [[c0:%\d+]] = OpLoad %int %c
// CHECK-NEXT: [[is_c_500:%\d+]] = OpIEqual %bool [[c0]] %int_500
// CHECK-NEXT: [[c0:%[0-9]+]] = OpLoad %int %c
// CHECK-NEXT: [[is_c_500:%[0-9]+]] = OpIEqual %bool [[c0]] %int_500
// CHECK-NEXT: OpSelectionMerge %if_merge_13 None
// CHECK-NEXT: OpBranchConditional [[is_c_500]] %if_true_13 %if_false_11
// CHECK-NEXT: %if_true_13 = OpLabel
// CHECK-NEXT: OpStore %b %int_500
// CHECK-NEXT: OpBranch %if_merge_13
// CHECK-NEXT: %if_false_11 = OpLabel
// CHECK-NEXT: [[c1:%\d+]] = OpLoad %int %c
// CHECK-NEXT: [[is_c_600:%\d+]] = OpIEqual %bool [[c1]] %int_600
// CHECK-NEXT: [[c1:%[0-9]+]] = OpLoad %int %c
// CHECK-NEXT: [[is_c_600:%[0-9]+]] = OpIEqual %bool [[c1]] %int_600
// CHECK-NEXT: OpSelectionMerge %if_merge_12 None
// CHECK-NEXT: OpBranchConditional [[is_c_600]] %if_true_14 %if_merge_12
// CHECK-NEXT: %if_true_14 = OpLabel
@ -272,21 +272,21 @@ void main() {
// CHECK-NEXT: %if_merge_13 = OpLabel
// CHECK-NEXT: OpBranch %if_merge_17
// CHECK-NEXT: %if_false_12 = OpLabel
// CHECK-NEXT: [[a6:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[is_a_400:%\d+]] = OpIEqual %bool [[a6]] %int_400
// CHECK-NEXT: [[a6:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: [[is_a_400:%[0-9]+]] = OpIEqual %bool [[a6]] %int_400
// CHECK-NEXT: OpSelectionMerge %if_merge_16 None
// CHECK-NEXT: OpBranchConditional [[is_a_400]] %if_true_15 %if_merge_16
// CHECK-NEXT: %if_true_15 = OpLabel
// CHECK-NEXT: [[c2:%\d+]] = OpLoad %int %c
// CHECK-NEXT: [[is_c_500_again:%\d+]] = OpIEqual %bool [[c2]] %int_500
// CHECK-NEXT: [[c2:%[0-9]+]] = OpLoad %int %c
// CHECK-NEXT: [[is_c_500_again:%[0-9]+]] = OpIEqual %bool [[c2]] %int_500
// CHECK-NEXT: OpSelectionMerge %if_merge_15 None
// CHECK-NEXT: OpBranchConditional [[is_c_500_again]] %if_true_16 %if_false_13
// CHECK-NEXT: %if_true_16 = OpLabel
// CHECK-NEXT: OpStore %b %int_500
// CHECK-NEXT: OpBranch %if_merge_15
// CHECK-NEXT: %if_false_13 = OpLabel
// CHECK-NEXT: [[c3:%\d+]] = OpLoad %int %c
// CHECK-NEXT: [[is_c_600_again:%\d+]] = OpIEqual %bool [[c3]] %int_600
// CHECK-NEXT: [[c3:%[0-9]+]] = OpLoad %int %c
// CHECK-NEXT: [[is_c_600_again:%[0-9]+]] = OpIEqual %bool [[c3]] %int_600
// CHECK-NEXT: OpSelectionMerge %if_merge_14 None
// CHECK-NEXT: OpBranchConditional [[is_c_600_again]] %if_true_17 %if_merge_14
// CHECK-NEXT: %if_true_17 = OpLabel

34
tools/clang/test/CodeGenSPIRV/cf.switch.opswitch.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cf.switch.opswitch.hlsl
Просмотреть файл

@ -1,4 +1,4 @@
// RUN: %dxc -T ps_6_0 -E main
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
int foo() { return 200; }
@ -14,7 +14,7 @@ void main() {
////////////////////////////
int a = 0;
// CHECK: [[a:%\d+]] = OpLoad %int %a
// CHECK: [[a:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: OpSelectionMerge %switch_merge None
// CHECK-NEXT: OpSwitch [[a]] %switch_default -3 %switch_n3 0 %switch_0 1 %switch_1 2 %switch_2
switch(a) {
@ -37,7 +37,7 @@ void main() {
result = 100;
break;
// CHECK-NEXT: %switch_2 = OpLabel
// CHECK-NEXT: [[foo:%\d+]] = OpFunctionCall %int %foo
// CHECK-NEXT: [[foo:%[0-9]+]] = OpFunctionCall %int %foo
// CHECK-NEXT: OpStore %result [[foo]]
// CHECK-NEXT: OpBranch %switch_merge
case 2:
@ -60,9 +60,9 @@ void main() {
// All cases have 'break' //
////////////////////////////////////
// CHECK-NEXT: [[a1:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[a1:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: OpStore %c [[a1]]
// CHECK-NEXT: [[c:%\d+]] = OpLoad %int %c
// CHECK-NEXT: [[c:%[0-9]+]] = OpLoad %int %c
// CHECK-NEXT: OpSelectionMerge %switch_merge_0 None
// CHECK-NEXT: OpSwitch [[c]] %switch_merge_0 -4 %switch_n4 4 %switch_4
switch(int c = a) {
@ -88,7 +88,7 @@ void main() {
// The last case is fall-through //
///////////////////////////////////
// CHECK-NEXT: [[a2:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[a2:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: OpSelectionMerge %switch_merge_1 None
// CHECK-NEXT: OpSwitch [[a2]] %switch_merge_1 -5 %switch_n5 5 %switch_5
switch(a) {
@ -112,7 +112,7 @@ void main() {
// The last case is not fall-through //
///////////////////////////////////////
// CHECK-NEXT: [[a3:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[a3:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: OpSelectionMerge %switch_merge_2 None
// CHECK-NEXT: OpSwitch [[a3]] %switch_default_0 6 %switch_6 7 %switch_7 8 %switch_8
switch(a) {
@ -147,7 +147,7 @@ void main() {
// Fall-through cases with no body //
///////////////////////////////////////
// CHECK-NEXT: [[a4:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[a4:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: OpSelectionMerge %switch_merge_3 None
// CHECK-NEXT: OpSwitch [[a4]] %switch_default_1 10 %switch_10 11 %switch_11 12 %switch_12
switch(a) {
@ -174,7 +174,7 @@ void main() {
// No-op. Two nested cases and a nested break //
////////////////////////////////////////////////
// CHECK-NEXT: [[a5:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[a5:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: OpSelectionMerge %switch_merge_4 None
// CHECK-NEXT: OpSwitch [[a5]] %switch_merge_4 15 %switch_15 16 %switch_16
switch(a) {
@ -196,7 +196,7 @@ void main() {
// Also uses 'forcecase' attribute //
////////////////////////////////////////////////////////////////
// CHECK-NEXT: [[a6:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[a6:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: OpSelectionMerge %switch_merge_5 None
// CHECK-NEXT: OpSwitch [[a6]] %switch_merge_5 20 %switch_20 21 %switch_21 22 %switch_22 23 %switch_23 24 %switch_24 25 %switch_25 26 %switch_26 27 %switch_27 28 %switch_28 29 %switch_29
[forcecase] switch(a) {
@ -261,7 +261,7 @@ void main() {
// Nested Switch statements with mixed use of fall-through and braces //
////////////////////////////////////////////////////////////////////////
// CHECK-NEXT: [[a7:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[a7:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: OpSelectionMerge %switch_merge_7 None
// CHECK-NEXT: OpSwitch [[a7]] %switch_merge_7 30 %switch_30
switch(a) {
@ -269,7 +269,7 @@ void main() {
case 30: {
// CHECK-NEXT: OpStore %result %int_30
result = 30;
// CHECK-NEXT: [[result:%\d+]] = OpLoad %int %result
// CHECK-NEXT: [[result:%[0-9]+]] = OpLoad %int %result
// CHECK-NEXT: OpSelectionMerge %switch_merge_6 None
// CHECK-NEXT: OpSwitch [[result]] %switch_default_2 50 %switch_50 51 %switch_51 52 %switch_52 53 %switch_53 54 %switch_54
switch(result) {
@ -322,18 +322,18 @@ void main() {
const int s = 45;
const int t = 2*r + s; // evaluates to 115.
// CHECK: [[a8:%\d+]] = OpLoad %int %a
// CHECK: [[a8:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: OpSelectionMerge %switch_merge_8 None
// CHECK-NEXT: OpSwitch [[a8]] %switch_merge_8 35 %switch_35 115 %switch_115
switch(a) {
// CHECK-NEXT: %switch_35 = OpLabel
// CHECK-NEXT: [[r:%\d+]] = OpLoad %int %r
// CHECK-NEXT: [[r:%[0-9]+]] = OpLoad %int %r
// CHECK-NEXT: OpStore %result [[r]]
// CHECK-NEXT: OpBranch %switch_115
case r:
result = r;
// CHECK-NEXT: %switch_115 = OpLabel
// CHECK-NEXT: [[t:%\d+]] = OpLoad %int %t
// CHECK-NEXT: [[t:%[0-9]+]] = OpLoad %int %t
// CHECK-NEXT: OpStore %result [[t]]
// CHECK-NEXT: OpBranch %switch_merge_8
case t:
@ -347,8 +347,8 @@ void main() {
// Using float as selector results in multiple casts in the AST //
//////////////////////////////////////////////////////////////////
float sel;
// CHECK: [[floatSelector:%\d+]] = OpLoad %float %sel
// CHECK-NEXT: [[sel:%\d+]] = OpConvertFToS %int [[floatSelector]]
// CHECK: [[floatSelector:%[0-9]+]] = OpLoad %float %sel
// CHECK-NEXT: [[sel:%[0-9]+]] = OpConvertFToS %int [[floatSelector]]
// CHECK-NEXT: OpSelectionMerge %switch_merge_9 None
// CHECK-NEXT: OpSwitch [[sel]] %switch_merge_9 0 %switch_0_0
switch (sel) {

10
tools/clang/test/CodeGenSPIRV/cf.while.break.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cf.while.break.hlsl
Просмотреть файл

@ -1,4 +1,4 @@
// RUN: %dxc -T ps_6_0 -E main
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
int foo() { return true; }
@ -9,13 +9,13 @@ void main() {
// CHECK: OpBranch %while_check
// CHECK: %while_check = OpLabel
// CHECK: [[i_lt_10:%\d+]] = OpSLessThan %bool {{%\d+}} %int_10
// CHECK: [[i_lt_10:%[0-9]+]] = OpSLessThan %bool {{%[0-9]+}} %int_10
// CHECK-NEXT: OpLoopMerge %while_merge %while_continue None
// CHECK-NEXT: OpBranchConditional [[i_lt_10]] %while_body %while_merge
while (i < 10) {
// CHECK-NEXT: %while_body = OpLabel
val = i;
// CHECK: [[val_gt_5:%\d+]] = OpSGreaterThan %bool {{%\d+}} %int_5
// CHECK: [[val_gt_5:%[0-9]+]] = OpSGreaterThan %bool {{%[0-9]+}} %int_5
// CHECK-NEXT: OpSelectionMerge %if_merge None
// CHECK-NEXT: OpBranchConditional [[val_gt_5]] %if_true %if_merge
if (val > 5) {
@ -25,7 +25,7 @@ void main() {
}
// CHECK-NEXT: %if_merge = OpLabel
// CHECK: [[val_gt_6:%\d+]] = OpSGreaterThan %bool {{%\d+}} %int_6
// CHECK: [[val_gt_6:%[0-9]+]] = OpSGreaterThan %bool {{%[0-9]+}} %int_6
// CHECK-NEXT: OpSelectionMerge %if_merge_0 None
// CHECK-NEXT: OpBranchConditional [[val_gt_6]] %if_true_0 %if_merge_0
if (val > 6) {
@ -63,7 +63,7 @@ void main() {
// CHECK: OpBranch %while_check_1
// CHECK-NEXT: %while_check_1 = OpLabel
// CHECK: [[i_lt_20:%\d+]] = OpSLessThan %bool {{%\d+}} %int_20
// CHECK: [[i_lt_20:%[0-9]+]] = OpSLessThan %bool {{%[0-9]+}} %int_20
// CHECK-NEXT: OpLoopMerge %while_merge_0 %while_continue_0 None
// CHECK-NEXT: OpBranchConditional [[i_lt_20]] %while_body_1 %while_merge_0
while(i<20) {

10
tools/clang/test/CodeGenSPIRV/cf.while.continue.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cf.while.continue.hlsl
Просмотреть файл

@ -1,4 +1,4 @@
// RUN: %dxc -T ps_6_0 -E main
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
int foo() { return true; }
@ -9,13 +9,13 @@ void main() {
// CHECK: OpBranch %while_check
// CHECK: %while_check = OpLabel
// CHECK: [[i_lt_10:%\d+]] = OpSLessThan %bool {{%\d+}} %int_10
// CHECK: [[i_lt_10:%[0-9]+]] = OpSLessThan %bool {{%[0-9]+}} %int_10
// CHECK-NEXT: OpLoopMerge %while_merge %while_continue None
// CHECK-NEXT: OpBranchConditional [[i_lt_10]] %while_body %while_merge
while (i < 10) {
// CHECK-NEXT: %while_body = OpLabel
val = i;
// CHECK: [[val_gt_5:%\d+]] = OpSGreaterThan %bool {{%\d+}} %int_5
// CHECK: [[val_gt_5:%[0-9]+]] = OpSGreaterThan %bool {{%[0-9]+}} %int_5
// CHECK-NEXT: OpSelectionMerge %if_merge None
// CHECK-NEXT: OpBranchConditional [[val_gt_5]] %if_true %if_merge
if (val > 5) {
@ -25,7 +25,7 @@ void main() {
}
// CHECK-NEXT: %if_merge = OpLabel
// CHECK: [[val_gt_6:%\d+]] = OpSGreaterThan %bool {{%\d+}} %int_6
// CHECK: [[val_gt_6:%[0-9]+]] = OpSGreaterThan %bool {{%[0-9]+}} %int_6
// CHECK-NEXT: OpSelectionMerge %if_merge_0 None
// CHECK-NEXT: OpBranchConditional [[val_gt_6]] %if_true_0 %if_merge_0
if (val > 6) {
@ -63,7 +63,7 @@ void main() {
// CHECK: OpBranch %while_check_1
// CHECK-NEXT: %while_check_1 = OpLabel
// CHECK: [[i_lt_20:%\d+]] = OpSLessThan %bool {{%\d+}} %int_20
// CHECK: [[i_lt_20:%[0-9]+]] = OpSLessThan %bool {{%[0-9]+}} %int_20
// CHECK-NEXT: OpLoopMerge %while_merge_0 %while_continue_0 None
// CHECK-NEXT: OpBranchConditional [[i_lt_20]] %while_body_1 %while_merge_0
while(i<20) {

42
tools/clang/test/CodeGenSPIRV/cf.while.nested.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cf.while.nested.hlsl
Просмотреть файл

@ -1,25 +1,25 @@
// RUN: %dxc -T ps_6_0 -E main
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
void main() {
int val=0, i=0, j=0, k=0;
// CHECK: OpBranch %while_check
// CHECK-NEXT: %while_check = OpLabel
// CHECK-NEXT: [[i0:%\d+]] = OpLoad %int %i
// CHECK-NEXT: [[i_lt_10:%\d+]] = OpSLessThan %bool [[i0]] %int_10
// CHECK-NEXT: [[i0:%[0-9]+]] = OpLoad %int %i
// CHECK-NEXT: [[i_lt_10:%[0-9]+]] = OpSLessThan %bool [[i0]] %int_10
// CHECK-NEXT: OpLoopMerge %while_merge_1 %while_continue_1 DontUnroll
// CHECK-NEXT: OpBranchConditional [[i_lt_10]] %while_body %while_merge_1
[loop] while (i < 10) {
// CHECK-NEXT: %while_body = OpLabel
// CHECK-NEXT: [[val1:%\d+]] = OpLoad %int %val
// CHECK-NEXT: [[i1:%\d+]] = OpLoad %int %i
// CHECK-NEXT: [[val_plus_i:%\d+]] = OpIAdd %int [[val1]] [[i1]]
// CHECK-NEXT: [[val1:%[0-9]+]] = OpLoad %int %val
// CHECK-NEXT: [[i1:%[0-9]+]] = OpLoad %int %i
// CHECK-NEXT: [[val_plus_i:%[0-9]+]] = OpIAdd %int [[val1]] [[i1]]
// CHECK-NEXT: OpStore %val [[val_plus_i]]
// CHECK-NEXT: OpBranch %while_check_0
val = val + i;
// CHECK-NEXT: %while_check_0 = OpLabel
// CHECK-NEXT: [[j0:%\d+]] = OpLoad %int %j
// CHECK-NEXT: [[j_lt_20:%\d+]] = OpSLessThan %bool [[j0]] %int_20
// CHECK-NEXT: [[j0:%[0-9]+]] = OpLoad %int %j
// CHECK-NEXT: [[j_lt_20:%[0-9]+]] = OpSLessThan %bool [[j0]] %int_20
// CHECK-NEXT: OpLoopMerge %while_merge_0 %while_continue_0 Unroll
// CHECK-NEXT: OpBranchConditional [[j_lt_20]] %while_body_0 %while_merge_0
[unroll(20)] while (j < 20) {
@ -27,19 +27,19 @@ void main() {
// CHECK-NEXT: OpBranch %while_check_1
// CHECK-NEXT: %while_check_1 = OpLabel
// CHECK-NEXT: [[k0:%\d+]] = OpLoad %int %k
// CHECK-NEXT: [[k_lt_30:%\d+]] = OpSLessThan %bool [[k0]] %int_30
// CHECK-NEXT: [[k0:%[0-9]+]] = OpLoad %int %k
// CHECK-NEXT: [[k_lt_30:%[0-9]+]] = OpSLessThan %bool [[k0]] %int_30
// CHECK-NEXT: OpLoopMerge %while_merge %while_continue DontUnroll
// CHECK-NEXT: OpBranchConditional [[k_lt_30]] %while_body_1 %while_merge
[fastopt] while (k < 30) {
// CHECK-NEXT: %while_body_1 = OpLabel
// CHECK-NEXT: [[val2:%\d+]] = OpLoad %int %val
// CHECK-NEXT: [[k2:%\d+]] = OpLoad %int %k
// CHECK-NEXT: [[val_plus_k:%\d+]] = OpIAdd %int [[val2]] [[k2]]
// CHECK-NEXT: [[val2:%[0-9]+]] = OpLoad %int %val
// CHECK-NEXT: [[k2:%[0-9]+]] = OpLoad %int %k
// CHECK-NEXT: [[val_plus_k:%[0-9]+]] = OpIAdd %int [[val2]] [[k2]]
// CHECK-NEXT: OpStore %val [[val_plus_k]]
val = val + k;
// CHECK-NEXT: [[k3:%\d+]] = OpLoad %int %k
// CHECK-NEXT: [[k_plus_1:%\d+]] = OpIAdd %int [[k3]] %int_1
// CHECK-NEXT: [[k3:%[0-9]+]] = OpLoad %int %k
// CHECK-NEXT: [[k_plus_1:%[0-9]+]] = OpIAdd %int [[k3]] %int_1
// CHECK-NEXT: OpStore %k [[k_plus_1]]
++k;
// CHECK-NEXT: OpBranch %while_continue
@ -48,12 +48,12 @@ void main() {
}
// CHECK-NEXT: %while_merge = OpLabel
// CHECK-NEXT: [[val3:%\d+]] = OpLoad %int %val
// CHECK-NEXT: [[val_mult_2:%\d+]] = OpIMul %int [[val3]] %int_2
// CHECK-NEXT: [[val3:%[0-9]+]] = OpLoad %int %val
// CHECK-NEXT: [[val_mult_2:%[0-9]+]] = OpIMul %int [[val3]] %int_2
// CHECK-NEXT: OpStore %val [[val_mult_2]]
val = val * 2;
// CHECK-NEXT: [[j1:%\d+]] = OpLoad %int %j
// CHECK-NEXT: [[j_plus_1:%\d+]] = OpIAdd %int [[j1]] %int_1
// CHECK-NEXT: [[j1:%[0-9]+]] = OpLoad %int %j
// CHECK-NEXT: [[j_plus_1:%[0-9]+]] = OpIAdd %int [[j1]] %int_1
// CHECK-NEXT: OpStore %j [[j_plus_1]]
++j;
// CHECK-NEXT: OpBranch %while_continue_0
@ -62,8 +62,8 @@ void main() {
}
// CHECK-NEXT: %while_merge_0 = OpLabel
// CHECK-NEXT: [[i2:%\d+]] = OpLoad %int %i
// CHECK-NEXT: [[i_plus_1:%\d+]] = OpIAdd %int [[i2]] %int_1
// CHECK-NEXT: [[i2:%[0-9]+]] = OpLoad %int %i
// CHECK-NEXT: [[i_plus_1:%[0-9]+]] = OpIAdd %int [[i2]] %int_1
// CHECK-NEXT: OpStore %i [[i_plus_1]]
++i;
// CHECK-NEXT: OpBranch %while_continue_1

20
tools/clang/test/CodeGenSPIRV/cf.while.plain.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cf.while.plain.hlsl
Просмотреть файл

@ -1,4 +1,4 @@
// RUN: %dxc -T ps_6_0 -E main
// RUN: %dxc -T ps_6_0 -E main -fcgl %s -spirv | FileCheck %s
int foo() { return true; }
@ -13,13 +13,13 @@ void main() {
// CHECK: OpBranch %while_check
// CHECK-NEXT: %while_check = OpLabel
// CHECK-NEXT: [[i:%\d+]] = OpLoad %int %i
// CHECK-NEXT: [[i_lt_10:%\d+]] = OpSLessThan %bool [[i]] %int_10
// CHECK-NEXT: [[i:%[0-9]+]] = OpLoad %int %i
// CHECK-NEXT: [[i_lt_10:%[0-9]+]] = OpSLessThan %bool [[i]] %int_10
// CHECK-NEXT: OpLoopMerge %while_merge %while_continue None
// CHECK-NEXT: OpBranchConditional [[i_lt_10]] %while_body %while_merge
while (i < 10) {
// CHECK-NEXT: %while_body = OpLabel
// CHECK-NEXT: [[i1:%\d+]] = OpLoad %int %i
// CHECK-NEXT: [[i1:%[0-9]+]] = OpLoad %int %i
// CHECK-NEXT: OpStore %val [[i1]]
val = i;
// CHECK-NEXT: OpBranch %while_continue
@ -56,8 +56,8 @@ void main() {
//////////////////////////
// CHECK-NEXT: %while_check_1 = OpLabel
// CHECK-NEXT: [[val1:%\d+]] = OpLoad %int %val
// CHECK-NEXT: [[val_lt_20:%\d+]] = OpSLessThan %bool [[val1]] %int_20
// CHECK-NEXT: [[val1:%[0-9]+]] = OpLoad %int %val
// CHECK-NEXT: [[val_lt_20:%[0-9]+]] = OpSLessThan %bool [[val1]] %int_20
// CHECK-NEXT: OpLoopMerge %while_merge_1 %while_continue_1 None
// CHECK-NEXT: OpBranchConditional [[val_lt_20]] %while_body_1 %while_merge_1
while (val < 20)
@ -77,15 +77,15 @@ void main() {
////////////////////////////////////////////////////////////////
// CHECK-NEXT: %while_check_2 = OpLabel
// CHECK-NEXT: [[foo:%\d+]] = OpFunctionCall %int %foo
// CHECK-NEXT: [[foo:%[0-9]+]] = OpFunctionCall %int %foo
// CHECK-NEXT: OpStore %a [[foo]]
// CHECK-NEXT: [[a:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[is_a_true:%\d+]] = OpINotEqual %bool [[a]] %int_0
// CHECK-NEXT: [[a:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: [[is_a_true:%[0-9]+]] = OpINotEqual %bool [[a]] %int_0
// CHECK-NEXT: OpLoopMerge %while_merge_2 %while_continue_2 None
// CHECK-NEXT: OpBranchConditional [[is_a_true]] %while_body_2 %while_merge_2
while (int a = foo()) {
// CHECK-NEXT: %while_body_2 = OpLabel
// CHECK-NEXT: [[a1:%\d+]] = OpLoad %int %a
// CHECK-NEXT: [[a1:%[0-9]+]] = OpLoad %int %a
// CHECK-NEXT: OpStore %val [[a1]]
val = a;
// CHECK-NEXT: OpBranch %while_continue_2

12
tools/clang/test/CodeGenSPIRV/cf.while.short-circuited-cond.hlsl → tools/clang/test/CodeGenSPIRV_Lit/cf.while.short-circuited-cond.hlsl
Просмотреть файл

@ -1,4 +1,4 @@
// RUN: %dxc -T ps_6_0 -E main -HV 2021
// RUN: %dxc -T ps_6_0 -E main -HV 2021 -fcgl %s -spirv | FileCheck %s
void main() {
bool a, b;
@ -7,7 +7,7 @@ void main() {
// CHECK-NEXT: OpLoopMerge %while_merge %while_continue None
// CHECK-NEXT: OpBranch %while_check
// CHECK-NEXT: %while_check = OpLabel
// CHECK: OpBranchConditional {{%\d+}} %while_body %while_merge
// CHECK: OpBranchConditional {{%[0-9]+}} %while_body %while_merge
while (a && b) {
// CHECK-NEXT: %while_body = OpLabel
// CHECK-NEXT: OpBranch %while_continue
@ -21,7 +21,7 @@ void main() {
// CHECK-NEXT: OpLoopMerge %while_merge_0 %while_continue_0 None
// CHECK-NEXT: OpBranch %while_check_0
// CHECK-NEXT: %while_check_0 = OpLabel
// CHECK: OpBranchConditional {{%\d+}} %while_body_0 %while_merge_0
// CHECK: OpBranchConditional {{%[0-9]+}} %while_body_0 %while_merge_0
while (a || b) {
// CHECK-NEXT: %while_body_0 = OpLabel
// CHECK-NEXT: OpBranch %while_continue_0
@ -35,7 +35,7 @@ void main() {
// CHECK-NEXT: OpLoopMerge %while_merge_1 %while_continue_1 None
// CHECK-NEXT: OpBranch %while_check_1
// CHECK-NEXT: %while_check_1 = OpLabel
// CHECK: OpBranchConditional {{%\d+}} %while_body_1 %while_merge_1
// CHECK: OpBranchConditional {{%[0-9]+}} %while_body_1 %while_merge_1
while (a && ((a || b) && b)) {
// CHECK-NEXT: %while_body_1 = OpLabel
// CHECK-NEXT: OpBranch %while_continue_1
@ -49,7 +49,7 @@ void main() {
// CHECK-NEXT: OpLoopMerge %while_merge_2 %while_continue_2 None
// CHECK-NEXT: OpBranch %while_check_2
// CHECK-NEXT: %while_check_2 = OpLabel
// CHECK: OpBranchConditional {{%\d+}} %while_body_2 %while_merge_2
// CHECK: OpBranchConditional {{%[0-9]+}} %while_body_2 %while_merge_2
while (a ? a : b) {
// CHECK-NEXT: %while_body_2 = OpLabel
// CHECK-NEXT: OpBranch %while_continue_2
@ -64,7 +64,7 @@ void main() {
// CHECK-NEXT: OpLoopMerge %while_merge_3 %while_continue_3 None
// CHECK-NEXT: OpBranch %while_check_3
// CHECK-NEXT: %while_check_3 = OpLabel
// CHECK: OpBranchConditional {{%\d+}} %while_body_3 %while_merge_3
// CHECK: OpBranchConditional {{%[0-9]+}} %while_body_3 %while_merge_3
while (x + (x && y)) {
// CHECK-NEXT: %while_body_3 = OpLabel
// CHECK-NEXT: OpBranch %while_continue_3

14
tools/clang/test/CodeGenSPIRV/select.long.lit.hlsl → tools/clang/test/CodeGenSPIRV_Lit/select.long.lit.hlsl
Просмотреть файл

@ -1,12 +1,12 @@
// RUN: %dxc -T ps_6_0 -HV 2018 -E main
// RUN: %dxc -T ps_6_0 -HV 2018 -E main -fcgl %s -spirv | FileCheck %s
// Check that the literals get a 64-bit type, and the result of the select is
// then cast to an unsigned 64-bit value.
void foo(uint x) {
// CHECK: %foo = OpFunction
// CHECK: [[cond:%\d+]] = OpULessThan %bool {{%\d+}} %uint_64
// CHECK: [[result:%\d+]] = OpSelect %long [[cond]] %long_1 %long_0
// CHECK: {{%\d+}} = OpBitcast %ulong [[result]]
// CHECK: [[cond:%[0-9]+]] = OpULessThan %bool {{%[0-9]+}} %uint_64
// CHECK: [[result:%[0-9]+]] = OpSelect %long [[cond]] %long_1 %long_0
// CHECK: {{%[0-9]+}} = OpBitcast %ulong [[result]]
uint64_t value = x < 64 ? 1 : 0;
}
@ -16,9 +16,9 @@ void foo(uint x) {
// determined, so we add it anyway.
void bar(uint x) {
// CHECK: %bar = OpFunction
// CHECK: [[cond:%\d+]] = OpULessThan %bool {{%\d+}} %uint_64
// CHECK: [[result:%\d+]] = OpSelect %long [[cond]] %long_1 %long_0
// CHECK: {{%\d+}} = OpBitcast %long [[result]]
// CHECK: [[cond_0:%[0-9]+]] = OpULessThan %bool {{%[0-9]+}} %uint_64
// CHECK: [[result_0:%[0-9]+]] = OpSelect %long [[cond_0]] %long_1 %long_0
// CHECK: {{%[0-9]+}} = OpBitcast %long [[result_0]]
int64_t value = x < 64 ? 1 : 0;
}

59
tools/clang/test/CodeGenSPIRV_Lit/select.long.lit.hlsl2021.hlsl Normal file
Просмотреть файл

@ -0,0 +1,59 @@
// RUN: %dxc -T ps_6_0 -HV 2021 -E main -fcgl %s -spirv | FileCheck %s
// Check that the literals get a 64-bit type, and the result of the select is
// then cast to an unsigned 64-bit value.
void foo(uint x) {
// CHECK: %foo = OpFunction
// CHECK-NEXT: [[param:%[a-zA-Z0-9_]+]] = OpFunctionParameter %_ptr_Function_uint
// CHECK-NEXT: OpLabel
// CHECK-NEXT: [[value:%[a-zA-Z0-9_]+]] = OpVariable %_ptr_Function_ulong Function
// CHECK-NEXT: [[temp:%[a-zA-Z0-9_]+]] = OpVariable %_ptr_Function_long Function
// CHECK-NEXT: [[ld:%[a-zA-Z0-9_]+]] = OpLoad %uint [[param]]
// CHECK-NEXT: [[cmp:%[a-zA-Z0-9_]+]] = OpULessThan %bool [[ld]] %uint_64
// CHECK-NEXT: OpSelectionMerge [[merge_bb:%[a-zA-Z0-9_]+]] None
// CHECK-NEXT: OpBranchConditional [[cmp]] [[true_bb:%[a-zA-Z0-9_]+]] [[false_bb:%[a-zA-Z0-9_]+]]
// CHECK-NEXT: [[true_bb]] = OpLabel
// CHECK-NEXT: OpStore [[temp]] %long_1
// CHECK-NEXT: OpBranch [[merge_bb]]
// CHECK-NEXT: [[false_bb]] = OpLabel
// CHECK-NEXT: OpStore [[temp]] %long_0
// CHECK-NEXT: OpBranch [[merge_bb]]
// CHECK-NEXT: [[merge_bb]] = OpLabel
// CHECK-NEXT: [[ld2:%[a-zA-Z0-9_]+]] = OpLoad %long [[temp]]
// CHECK-NEXT: [[res:%[a-zA-Z0-9_]+]] = OpBitcast %ulong [[ld2]]
// CHECK-NEXT: OpStore [[value]] [[res_0:%[a-zA-Z0-9_]+]]
uint64_t value = x < 64 ? 1 : 0;
}
// Check that the literals get a 64-bit type, and the result of the select is
// then cast to an signed 64-bit value. Note that the bitcast is redundant in
// this case, but we add the bitcast before the type of the literal has been
// determined, so we add it anyway.
void bar(uint x) {
// CHECK: %bar = OpFunction
// CHECK-NEXT: [[param_0:%[a-zA-Z0-9_]+]] = OpFunctionParameter %_ptr_Function_uint
// CHECK-NEXT: OpLabel
// CHECK-NEXT: [[value_0:%[a-zA-Z0-9_]+]] = OpVariable %_ptr_Function_long Function
// CHECK-NEXT: [[temp_0:%[a-zA-Z0-9_]+]] = OpVariable %_ptr_Function_long Function
// CHECK-NEXT: [[ld_0:%[a-zA-Z0-9_]+]] = OpLoad %uint [[param_0]]
// CHECK-NEXT: [[cmp_0:%[a-zA-Z0-9_]+]] = OpULessThan %bool [[ld_0]] %uint_64
// CHECK-NEXT: OpSelectionMerge [[merge_bb_0:%[a-zA-Z0-9_]+]] None
// CHECK-NEXT: OpBranchConditional [[cmp_0]] [[true_bb_0:%[a-zA-Z0-9_]+]] [[false_bb_0:%[a-zA-Z0-9_]+]]
// CHECK-NEXT: [[true_bb_0]] = OpLabel
// CHECK-NEXT: OpStore [[temp_0]] %long_1
// CHECK-NEXT: OpBranch [[merge_bb_0]]
// CHECK-NEXT: [[false_bb_0]] = OpLabel
// CHECK-NEXT: OpStore [[temp_0]] %long_0
// CHECK-NEXT: OpBranch [[merge_bb_0]]
// CHECK-NEXT: [[merge_bb_0]] = OpLabel
// CHECK-NEXT: [[ld2_0:%[a-zA-Z0-9_]+]] = OpLoad %long [[temp_0]]
// CHECK-NEXT: [[res_1:%[a-zA-Z0-9_]+]] = OpBitcast %long [[ld2_0]]
// CHECK-NEXT: OpStore [[value_0]] [[res_2:%[a-zA-Z0-9_]+]]
int64_t value = x < 64 ? 1 : 0;
}
void main() {
uint value;
foo(2);
bar(2);
}

14
tools/clang/test/CodeGenSPIRV/select.short.lit.hlsl → tools/clang/test/CodeGenSPIRV_Lit/select.short.lit.hlsl
Просмотреть файл

@ -1,12 +1,12 @@
// RUN: %dxc -T ps_6_2 -HV 2018 -E main -enable-16bit-types
// RUN: %dxc -T ps_6_2 -HV 2018 -E main -enable-16bit-types -fcgl %s -spirv | FileCheck %s
// Check that the literals get a 16-bit type, and the result of the select is
// then cast to an unsigned 16-bit value.
void foo(uint x) {
// CHECK: %foo = OpFunction
// CHECK: [[cond:%\d+]] = OpULessThan %bool {{%\d+}} %uint_64
// CHECK: [[result:%\d+]] = OpSelect %short [[cond]] %short_1 %short_0
// CHECK: {{%\d+}} = OpBitcast %ushort [[result]]
// CHECK: [[cond:%[0-9]+]] = OpULessThan %bool {{%[0-9]+}} %uint_64
// CHECK: [[result:%[0-9]+]] = OpSelect %short [[cond]] %short_1 %short_0
// CHECK: {{%[0-9]+}} = OpBitcast %ushort [[result]]
uint16_t value = x < 64 ? 1 : 0;
}
@ -16,9 +16,9 @@ void foo(uint x) {
// determined, so we add it anyway.
void bar(uint x) {
// CHECK: %bar = OpFunction
// CHECK: [[cond:%\d+]] = OpULessThan %bool {{%\d+}} %uint_64
// CHECK: [[result:%\d+]] = OpSelect %short [[cond]] %short_1 %short_0
// CHECK: {{%\d+}} = OpBitcast %short [[result]]
// CHECK: [[cond_0:%[0-9]+]] = OpULessThan %bool {{%[0-9]+}} %uint_64
// CHECK: [[result_0:%[0-9]+]] = OpSelect %short [[cond_0]] %short_1 %short_0
// CHECK: {{%[0-9]+}} = OpBitcast %short [[result_0]]
int16_t value = x < 64 ? 1 : 0;
}

59
tools/clang/test/CodeGenSPIRV_Lit/select.short.lit.hlsl2021.hlsl Normal file
Просмотреть файл

@ -0,0 +1,59 @@
// RUN: %dxc -T ps_6_2 -HV 2021 -E main -enable-16bit-types -fcgl %s -spirv | FileCheck %s
// Check that the literals get a 16-bit type, and the result of the select is
// then cast to an unsigned 16-bit value.
void foo(uint x) {
// CHECK: %foo = OpFunction
// CHECK-NEXT: [[param:%[a-zA-Z0-9_]+]] = OpFunctionParameter %_ptr_Function_uint
// CHECK-NEXT: OpLabel
// CHECK-NEXT: [[value:%[a-zA-Z0-9_]+]] = OpVariable %_ptr_Function_ushort Function
// CHECK-NEXT: [[temp:%[a-zA-Z0-9_]+]] = OpVariable %_ptr_Function_short Function
// CHECK-NEXT: [[ld:%[a-zA-Z0-9_]+]] = OpLoad %uint [[param]]
// CHECK-NEXT: [[cmp:%[a-zA-Z0-9_]+]] = OpULessThan %bool [[ld]] %uint_64
// CHECK-NEXT: OpSelectionMerge [[merge_bb:%[a-zA-Z0-9_]+]] None
// CHECK-NEXT: OpBranchConditional [[cmp]] [[true_bb:%[a-zA-Z0-9_]+]] [[false_bb:%[a-zA-Z0-9_]+]]
// CHECK-NEXT: [[true_bb]] = OpLabel
// CHECK-NEXT: OpStore [[temp]] %short_1
// CHECK-NEXT: OpBranch [[merge_bb]]
// CHECK-NEXT: [[false_bb]] = OpLabel
// CHECK-NEXT: OpStore [[temp]] %short_0
// CHECK-NEXT: OpBranch [[merge_bb]]
// CHECK-NEXT: [[merge_bb]] = OpLabel
// CHECK-NEXT: [[ld2:%[a-zA-Z0-9_]+]] = OpLoad %short [[temp]]
// CHECK-NEXT: [[res:%[a-zA-Z0-9_]+]] = OpBitcast %ushort [[ld2]]
// CHECK-NEXT: OpStore [[value]] [[res_0:%[a-zA-Z0-9_]+]]
uint16_t value = x < 64 ? 1 : 0;
}
// Check that the literals get a 16-bit type, and the result of the select is
// then cast to an signed 16-bit value. Note that the bitcast is redundant in
// this case, but we add the bitcast before the type of the literal has been
// determined, so we add it anyway.
void bar(uint x) {
// CHECK: %bar = OpFunction
// CHECK-NEXT: [[param_0:%[a-zA-Z0-9_]+]] = OpFunctionParameter %_ptr_Function_uint
// CHECK-NEXT: OpLabel
// CHECK-NEXT: [[value_0:%[a-zA-Z0-9_]+]] = OpVariable %_ptr_Function_short Function
// CHECK-NEXT: [[temp_0:%[a-zA-Z0-9_]+]] = OpVariable %_ptr_Function_short Function
// CHECK-NEXT: [[ld_0:%[a-zA-Z0-9_]+]] = OpLoad %uint [[param_0]]
// CHECK-NEXT: [[cmp_0:%[a-zA-Z0-9_]+]] = OpULessThan %bool [[ld_0]] %uint_64
// CHECK-NEXT: OpSelectionMerge [[merge_bb_0:%[a-zA-Z0-9_]+]] None
// CHECK-NEXT: OpBranchConditional [[cmp_0]] [[true_bb_0:%[a-zA-Z0-9_]+]] [[false_bb_0:%[a-zA-Z0-9_]+]]
// CHECK-NEXT: [[true_bb_0]] = OpLabel
// CHECK-NEXT: OpStore [[temp_0]] %short_1
// CHECK-NEXT: OpBranch [[merge_bb_0]]
// CHECK-NEXT: [[false_bb_0]] = OpLabel
// CHECK-NEXT: OpStore [[temp_0]] %short_0
// CHECK-NEXT: OpBranch [[merge_bb_0]]
// CHECK-NEXT: [[merge_bb_0]] = OpLabel
// CHECK-NEXT: [[ld2_0:%[a-zA-Z0-9_]+]] = OpLoad %short [[temp_0]]
// CHECK-NEXT: [[res_1:%[a-zA-Z0-9_]+]] = OpBitcast %short [[ld2_0]]
// CHECK-NEXT: OpStore [[value_0]] [[res_2:%[a-zA-Z0-9_]+]]
int16_t value = x < 64 ? 1 : 0;
}
void main() {
uint value;
foo(2);
bar(2);
}

108
tools/clang/unittests/SPIRV/CodeGenSpirvTest.cpp
Просмотреть файл

@ -329,114 +329,6 @@ TEST_F(FileTest, OpSizeOfSameForInitAndReturn) {
runFileTest("op.sizeof.same.for.init.and.return.hlsl");
}
// For casting
TEST_F(FileTest, CastNoOp) { runFileTest("cast.no-op.hlsl"); }
TEST_F(FileTest, CastNoOpMatrixFloatToInt) {
runFileTest("cast.no-op.matrix.float-to-int.hlsl");
}
TEST_F(FileTest, CastImplicit2Bool) { runFileTest("cast.2bool.implicit.hlsl"); }
TEST_F(FileTest, CastExplicit2Bool) { runFileTest("cast.2bool.explicit.hlsl"); }
TEST_F(FileTest, CastImplicit2SInt) { runFileTest("cast.2sint.implicit.hlsl"); }
TEST_F(FileTest, CastExplicit2SInt) { runFileTest("cast.2sint.explicit.hlsl"); }
TEST_F(FileTest, CastImplicit2UInt) { runFileTest("cast.2uint.implicit.hlsl"); }
TEST_F(FileTest, CastExplicit2UInt) { runFileTest("cast.2uint.explicit.hlsl"); }
TEST_F(FileTest, CastImplicit2FP) { runFileTest("cast.2fp.implicit.hlsl"); }
TEST_F(FileTest, CastExplicit2FP) { runFileTest("cast.2fp.explicit.hlsl"); }
TEST_F(FileTest, CastImplicit2LiteralInt) {
runFileTest("cast.2literal-int.implicit.hlsl");
}
TEST_F(FileTest, CastFlatConversionArrayToVector) {
runFileTest("cast.flat-conversion.array-to-vector.hlsl");
}
TEST_F(FileTest, CastImplicitFlatConversion) {
runFileTest("cast.flat-conversion.implicit.hlsl");
}
TEST_F(FileTest, CastFlatConversionDeclRef) {
runFileTest("cast.flat-conversion.decl-ref.hlsl");
}
TEST_F(FileTest, CastFlatConversionStruct) {
runFileTest("cast.flat-conversion.struct.hlsl");
}
TEST_F(FileTest, CastFlatConversionNoOp) {
runFileTest("cast.flat-conversion.no-op.hlsl");
}
TEST_F(FileTest, CastFlatConversionStructToStruct) {
runFileTest("cast.flat-conversion.struct-to-struct.hlsl");
}
TEST_F(FileTest, CastFlatConversionLiteralInitializer) {
runFileTest("cast.flat-conversion.literal-initializer.hlsl");
}
TEST_F(FileTest, CastFlatConversionDecomposeVector) {
runFileTest("cast.flat-conversion.vector.hlsl");
}
TEST_F(FileTest, CastExplicitVecToMat) {
runFileTest("cast.vec-to-mat.explicit.hlsl");
}
TEST_F(FileTest, CastImplicitVecToMat) {
runFileTest("cast.vec-to-mat.implicit.hlsl");
}
TEST_F(FileTest, CastMatrixToVector) { runFileTest("cast.mat-to-vec.hlsl"); }
TEST_F(FileTest, CastStructToInt) { runFileTest("cast.struct-to-int.hlsl"); }
TEST_F(FileTest, CastBitwidth) { runFileTest("cast.bitwidth.hlsl"); }
TEST_F(FileTest, CastLiteralTypeForArraySubscript) {
runFileTest("cast.literal-type.array-subscript.hlsl");
}
TEST_F(FileTest, CastLiteralTypeForTernary) {
runFileTest("cast.literal-type.ternary.hlsl");
}
TEST_F(FileTest, SelectLongLit) { runFileTest("select.long.lit.hlsl"); }
TEST_F(FileTest, SelectShortLit) { runFileTest("select.short.lit.hlsl"); }
TEST_F(FileTest, SelectLongLit2021) {
runFileTest("select.long.lit.hlsl2021.hlsl");
}
TEST_F(FileTest, SelectShortLit2021) {
runFileTest("select.short.lit.hlsl2021.hlsl");
}
TEST_F(FileTest, CastLiteralTypeForTernary2021) {
runFileTest("cast.literal-type.ternary.2021.hlsl");
}
// For vector/matrix splatting and trunction
TEST_F(FileTest, CastTruncateVector) { runFileTest("cast.vector.trunc.hlsl"); }
TEST_F(FileTest, CastTruncateMatrix) { runFileTest("cast.matrix.trunc.hlsl"); }
TEST_F(FileTest, CastSplatVector) { runFileTest("cast.vector.splat.hlsl"); }
TEST_F(FileTest, CastSplatMatrix) { runFileTest("cast.matrix.splat.hlsl"); }
// For if statements
TEST_F(FileTest, IfStmtPlainAssign) { runFileTest("cf.if.plain.hlsl"); }
TEST_F(FileTest, IfStmtNestedIfStmt) { runFileTest("cf.if.nested.hlsl"); }
TEST_F(FileTest, IfStmtConstCondition) { runFileTest("cf.if.const-cond.hlsl"); }
// For switch statements
TEST_F(FileTest, SwitchStmtUsingOpSwitch) {
runFileTest("cf.switch.opswitch.hlsl");
}
TEST_F(FileTest, SwitchStmtUsingIfStmt) {
runFileTest("cf.switch.ifstmt.hlsl");
}
// For for statements
TEST_F(FileTest, ForStmtPlainAssign) { runFileTest("cf.for.plain.hlsl"); }
TEST_F(FileTest, ForStmtNestedForStmt) { runFileTest("cf.for.nested.hlsl"); }
TEST_F(FileTest, ForStmtContinue) { runFileTest("cf.for.continue.hlsl"); }
TEST_F(FileTest, ForStmtBreak) { runFileTest("cf.for.break.hlsl"); }
TEST_F(FileTest, ForStmtShortCircuitedCond) {
runFileTest("cf.for.short-circuited-cond.hlsl");
}
// For while statements
TEST_F(FileTest, WhileStmtPlain) { runFileTest("cf.while.plain.hlsl"); }
TEST_F(FileTest, WhileStmtNested) { runFileTest("cf.while.nested.hlsl"); }
TEST_F(FileTest, WhileStmtContinue) { runFileTest("cf.while.continue.hlsl"); }
TEST_F(FileTest, WhileStmtBreak) { runFileTest("cf.while.break.hlsl"); }
TEST_F(FileTest, WhileStmtShortCircuitedCond) {
runFileTest("cf.while.short-circuited-cond.hlsl");
}
// Test shaders that require Vulkan1.1 support with
// -fspv-target-env=vulkan1.2 option to make sure that enabling
// Vulkan1.2 also enables Vulkan1.1.