From b7e824347a5de25cc013af30e43bd405b8b5698f Mon Sep 17 00:00:00 2001 From: ArielG-NV <159081215+ArielG-NV@users.noreply.github.com> Date: Wed, 12 Jun 2024 12:46:24 -0400 Subject: Add slangc flag to `-zero-initialize` all variables (#3987) * Default (zero'd) values with `-zero-initialize` flag Adds `-zero-initialize` flag to set values to a __default() expression if they are missing a initExpr. * address review and ensure __default calls ctor + zero's fields. 1. We must keep zero-initialize in SemanticsDeclHeaderVisitor. This is done because else a ctor will be initialized before we can set struct fields to `__default`. 2. IRDefaultCtorDecoration was added to track default ctor's with parent struct. 3. ParentAggTypeModifier was added to track ChildOfStruct->IRType for sharing data such as with functions. This is required to ensure we associate a lowered function with a lowered struct type * Removed decoration to track defaultCtor in favor of field. This was done since decorations are checked for IR objects, storing auxillary info does not work here as a result if usable object. * address some review comments Since `IDefaultInitializable` is taking a considerabley larger amount of time than anticipated I am pushing some of the other fixes requested. I did not remove the "IRStruct storing a default Ctor" hack yet. mostly renamed/adjusted tests to work as intended added test to ensure we don't synthisize a junk `= 0` when not in `zero initialize` mode removed member in favor of sharedContext+dictionary. * a working but incorrect impl * default init without any IR hacks (fully working aside from generic/containored-types) * Finish zero init code 1. IDefaultInitializer interface was added. If conforming, your type may be zero-initialized. To Conform a `__init()` is required 2. `[OnlyAutoInitIfForced]` was added. This attribute states that a default initializer should only be implicitly called if forced by the compiler (`zero-initialize` for example). This allows types which implicitly/explicitly conform to IDefaultInitialize to have optional auto-init behavior (which is Slang's default for user structs) to be disabled. * note about `[OnlyAutoInitIfForced]`. This is required for std-lib to not automatically resolve init-expressions for std-lib, but it has the added benifit of allowing user made structs/classes to control the default behavior of initializing * fix ErrType assumption * testing why dx12 fails local but passes CI * push vector changes to generic test * push syntax adjustment, still figuring out what is wrong with cuda. * remove debug changes & adjust style * fix field-init expressions with structs initializers don't init a static in a ctor. This would be illegal code and wrong code (init list in lower-to-ir) * minor adjustments temporarily while the rest of the issue is discussed * fix * implement IDefaultInitializable * remove a unneeded whitespace change * fix type checking error should be checking if a valid type is `Type`, not `BasicExpressionType` * needs to be DeclRefType, not Type * fix langguage server error * change findinheritance for correctness + cleanup * remove return false verified the issue was `findInheritance` * push attempt at language server fix * still trying to fix inheritance * added extension support, remove redundant code Did not address all review comments yet, want to see if CI also passes my changes * undo a change which caused CI to fail * change logic + DefaultConstructExpr setup code to use defaultConstructExpr when possible to construct a default without overhead of invoke/related also changed code so parent's defaultInitializable propegates to derived member * 1. fix error in `isSubtype` 2. add flag to isSubtype `subtypeInheritanceIsNotFullyResolved` was added since we may not be done the lookup stage but still require `isSubtype` checking to verify usage of inheritance while working with inheritance. In This case we will just skip `ensureLookup` and "caching" (since we don't have a cache invalidation system, nor need) * fix bug in logic + add test to better catch the bug * address comment + isSubTypeOption + wrapper type test, * fix wrong code adjustment I checked on the CI and realized I caused a failure, mistake was made not negating some code * syntax, class naming capital * remove stdlib default initialize changes, replace with `__default()` for init * remove redundant code + fix defaultConstruct emitting previously defaultConstruct emitting was crashing due to having generics unresolved. By not resolving the default construct immediately, everything works. * remove a coment * add test to ensure static variables dont `init` inside a struct's `__init` * fix Ptr members breaking struct use * address review and add -zero-initialize test `-zero-initialize` test was added to be sure debug pointers are not broken with default init values --------- Co-authored-by: Yong He --- .../IDefaultExplicit-wrapper-type.slang | 52 +++++++++ .../zero-initialize/IDefaultExplicit.slang | 103 ++++++++++++++++++ .../zero-initialize/IDefaultExplicitGenerics.slang | 30 ++++++ .../language-feature/zero-initialize/generic.slang | 113 ++++++++++++++++++++ .../zero-initialize/missing-zero-init.slang | 23 ++++ .../language-feature/zero-initialize/regular.slang | 116 +++++++++++++++++++++ .../static-struct-field-init-list.slang | 24 +++++ .../zero-initialize/static-struct-field-init.slang | 25 +++++ .../struct-array-some-member-missing-init.slang | 42 ++++++++ .../zero-initialize/struct-array.slang | 38 +++++++ .../zero-initialize/struct-no-zero-init.slang | 33 ++++++ ...struct-some-member-init-missing-zero-init.slang | 35 +++++++ .../zero-initialize/struct-some-zero-init.slang | 39 +++++++ .../language-feature/zero-initialize/struct.slang | 37 +++++++ 14 files changed, 710 insertions(+) create mode 100644 tests/language-feature/zero-initialize/IDefaultExplicit-wrapper-type.slang create mode 100644 tests/language-feature/zero-initialize/IDefaultExplicit.slang create mode 100644 tests/language-feature/zero-initialize/IDefaultExplicitGenerics.slang create mode 100644 tests/language-feature/zero-initialize/generic.slang create mode 100644 tests/language-feature/zero-initialize/missing-zero-init.slang create mode 100644 tests/language-feature/zero-initialize/regular.slang create mode 100644 tests/language-feature/zero-initialize/static-struct-field-init-list.slang create mode 100644 tests/language-feature/zero-initialize/static-struct-field-init.slang create mode 100644 tests/language-feature/zero-initialize/struct-array-some-member-missing-init.slang create mode 100644 tests/language-feature/zero-initialize/struct-array.slang create mode 100644 tests/language-feature/zero-initialize/struct-no-zero-init.slang create mode 100644 tests/language-feature/zero-initialize/struct-some-member-init-missing-zero-init.slang create mode 100644 tests/language-feature/zero-initialize/struct-some-zero-init.slang create mode 100644 tests/language-feature/zero-initialize/struct.slang (limited to 'tests/language-feature/zero-initialize') diff --git a/tests/language-feature/zero-initialize/IDefaultExplicit-wrapper-type.slang b/tests/language-feature/zero-initialize/IDefaultExplicit-wrapper-type.slang new file mode 100644 index 000000000..fd08b5bee --- /dev/null +++ b/tests/language-feature/zero-initialize/IDefaultExplicit-wrapper-type.slang @@ -0,0 +1,52 @@ +//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain +// CHECK: {{.* }}= 0; +// CHECK-NOT: {{.* }}= 0; + +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -emit-spirv-directly -allow-glsl +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-cpu -compute -entry computeMain -allow-glsl +//TEST(smoke,compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-dx12 -use-dxil -compute -entry computeMain -allow-glsl -profile sm_6_2 -xslang -DDX12 + +//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +struct Base : IDefaultInitializableType +{ + int data1; +}; + +struct idefault1_base : IDefaultInitializableType +{ +}; +interface idefault2_base : IDefaultInitializableType +{ +}; + +struct idefault1 : idefault1_base = Base; + +struct idefault2 : idefault2_base = Base; + +idefault1 getDefault1() +{ + idefault1 default1; + return default1; +} +idefault2 getDefault2() +{ + idefault2 default2; + return default2; +} + +[numthreads(1, 1, 1)] +void computeMain(int3 dispatchThreadID: SV_DispatchThreadID) +{ + // BUF: 1 + idefault1 default1 = getDefault1(); + idefault2 default2 = getDefault2(); + + outputBuffer[0] = true + && default1.inner.data1 == 0 + + && default2.inner.data1 == 0 + ; +} diff --git a/tests/language-feature/zero-initialize/IDefaultExplicit.slang b/tests/language-feature/zero-initialize/IDefaultExplicit.slang new file mode 100644 index 000000000..78c6b1596 --- /dev/null +++ b/tests/language-feature/zero-initialize/IDefaultExplicit.slang @@ -0,0 +1,103 @@ +//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain +// CHECK-COUNT-6: {{.* }}= 0U; + +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -emit-spirv-directly -allow-glsl +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-cpu -compute -entry computeMain -allow-glsl +//TEST(smoke,compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-dx12 -use-dxil -compute -entry computeMain -allow-glsl -profile sm_6_2 -xslang -DDX12 + +//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +struct idefault1 : IDefaultInitializableType +{ + uint data; +}; + +struct idefault2_base : IDefaultInitializableType +{ + uint data1; +}; +struct idefault2 : idefault2_base +{ + uint data2 = 1; +}; + +interface idefault3_base : IDefaultInitializableType +{ +}; +struct idefault3 : idefault3_base +{ + uint data; +}; + +struct idefault4 +{ + uint data; +}; + +extension idefault4 : IDefaultInitializableType +{ +} + +struct idefault5_base : IDefaultInitializableType +{ + uint data1; +}; + +struct idefault5 : idefault5_base +{ + uint data2; +}; + +idefault1 getDefault1() +{ + idefault1 default1; + return default1; +} +idefault2 getDefault2() +{ + idefault2 default2; + return default2; +} +idefault3 getDefault3() +{ + idefault3 default3; + return default3; +} +idefault4 getDefault4() +{ + idefault4 default4; + return default4; +} + +idefault5 getDefault5() +{ + idefault5 default5; + return default5; +} + +[numthreads(1, 1, 1)] +void computeMain(int3 dispatchThreadID: SV_DispatchThreadID) +{ + // BUF: 1 + idefault1 default1 = getDefault1(); + idefault2 default2 = getDefault2(); + idefault3 default3 = getDefault3(); + idefault4 default4 = getDefault4(); + idefault5 default5 = getDefault5(); + + outputBuffer[0] = true + && default1.data == 0 + + && default2.data1 == 0 + && default2.data2 == 1 + + && default3.data == 0 + + && default4.data == 0 + + && default5.data1 == 0 + && default5.data2 == 0 + ; +} diff --git a/tests/language-feature/zero-initialize/IDefaultExplicitGenerics.slang b/tests/language-feature/zero-initialize/IDefaultExplicitGenerics.slang new file mode 100644 index 000000000..edb438c1c --- /dev/null +++ b/tests/language-feature/zero-initialize/IDefaultExplicitGenerics.slang @@ -0,0 +1,30 @@ +//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain +// CHECK: vec4(0.0 + +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -emit-spirv-directly -allow-glsl +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-cpu -compute -entry computeMain -allow-glsl +//TEST(smoke,compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-dx12 -use-dxil -compute -entry computeMain -allow-glsl -profile sm_6_2 + +//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +__generic +struct idefault1 : IDefaultInitializableType +{ + vector data; +}; + +[numthreads(1, 1, 1)] +void computeMain(int3 dispatchThreadID: SV_DispatchThreadID) +{ + // BUF: 1 + idefault1 default1; + + outputBuffer[0] = true + && default1.data[0] == 0 + && default1.data[1] == 0 + && default1.data[2] == 0 + && default1.data[3] == 0 + ; +} diff --git a/tests/language-feature/zero-initialize/generic.slang b/tests/language-feature/zero-initialize/generic.slang new file mode 100644 index 000000000..25f52238c --- /dev/null +++ b/tests/language-feature/zero-initialize/generic.slang @@ -0,0 +1,113 @@ +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl -xslang -zero-initialize +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -emit-spirv-directly -allow-glsl -xslang -zero-initialize +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-cpu -compute -entry computeMain -allow-glsl -xslang -zero-initialize +//TEST(smoke,compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-dx12 -use-dxil -compute -entry computeMain -allow-glsl -profile sm_6_2 -xslang -zero-initialize -xslang -DDX12 + +//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +__generic +bool getValue() +{ + T genericOut; + return genericOut == T(0); +} +bool getValueBoolean() +{ + bool genericOut; + return genericOut == bool(0); +} + +__generic +bool getValueVector() +{ + typealias gvec = vector; + + gvec genericOut; + for (int i = 0; i < N; ++i) + if (genericOut[i] != T(0)) + return false; + return true; +} +__generic +bool getValueVectorBoolean() +{ + typealias gvec = vector; + + gvec genericOut; + for (int i = 0; i < N; ++i) + if (genericOut[i] != bool(0)) + return false; + return true; +} + +[numthreads(1, 1, 1)] +void computeMain(int3 dispatchThreadID: SV_DispatchThreadID) +{ +// BUF: 1 + outputBuffer[0] = true + && getValue() +#ifndef DX12 + && getValue() + && getValue() +#endif + && getValue() + && getValue() + && getValue() + && getValue() + && getValue() + && getValue() + && getValue() + && getValue() + && getValue() + && getValueBoolean() + + && getValueVector() +#ifndef DX12 + && getValueVector() + && getValueVector() +#endif + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVectorBoolean<2>() + + && getValueVector() +#ifndef DX12 + && getValueVector() + && getValueVector() +#endif + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVectorBoolean<3>() + + && getValueVector() +#ifndef DX12 + && getValueVector() + && getValueVector() +#endif + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVector() + && getValueVectorBoolean<4>() + ; +} diff --git a/tests/language-feature/zero-initialize/missing-zero-init.slang b/tests/language-feature/zero-initialize/missing-zero-init.slang new file mode 100644 index 000000000..f9d715e10 --- /dev/null +++ b/tests/language-feature/zero-initialize/missing-zero-init.slang @@ -0,0 +1,23 @@ +//TEST:SIMPLE(filecheck=CHECK): -target hlsl -stage compute -entry computeMain +//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain + +// CHECK-NOT: {{.* }}= 0; +// CHECK-NOT: return 0; + +RWStructuredBuffer outputBuffer; + +[noinline] +int returnInt() +{ + int myInt; + return myInt; +} + +[numthreads(1, 1, 1)] +void computeMain(int3 dispatchThreadID: SV_DispatchThreadID) +{ +// BUF: 1 + outputBuffer[0] = true + && returnInt() == 0 + ; +} diff --git a/tests/language-feature/zero-initialize/regular.slang b/tests/language-feature/zero-initialize/regular.slang new file mode 100644 index 000000000..5627762c3 --- /dev/null +++ b/tests/language-feature/zero-initialize/regular.slang @@ -0,0 +1,116 @@ +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl -xslang -zero-initialize +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -emit-spirv-directly -allow-glsl -xslang -zero-initialize +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-cpu -compute -entry computeMain -allow-glsl -xslang -zero-initialize +//TEST(smoke,compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-dx12 -use-dxil -compute -entry computeMain -allow-glsl -profile sm_6_2 -xslang -zero-initialize -xslang -DDX12 + +//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +enum MyFlags +{ + Zero = 0, + One, +} +MyFlags getMyFlagsUint_One() +{ + return MyFlags::One; +} + +#ifndef DX12 +enum MyFlags_uint8 : uint8_t +{ + Zero = 0, + One, +} +MyFlags_uint8 getMyFlagsUint8_One() +{ + return MyFlags_uint8::One; +} +#endif + +enum MyFlags_uint16 : uint16_t +{ + Zero = 0, + One, +} +MyFlags_uint16 getMyFlagsUint16_One() +{ + return MyFlags_uint16::One; +} + +enum MyFlags_uint32 : uint32_t +{ + Zero = 0, + One, +} +MyFlags_uint32 getMyFlagsUint32_One() +{ + return MyFlags_uint32::One; +} + +enum MyFlags_uint64 : uint64_t +{ + Zero = 0, + One, +} +MyFlags_uint64 getMyFlagsUint64_One() +{ + return MyFlags_uint64::One; +} + +int getDefaultInt() +{ + int val; + return val; +} +float getDefaultFloat() +{ + float val; + return val; +} +double getDefaultDouble() +{ + double val; + return val; +} +vector getDefaultIntVec2() +{ + vector val; + return val; +} +vector getDefaultIntVec3() +{ + vector val; + return val; +} +vector getDefaultIntVec4() +{ + vector val; + return val; +} +[numthreads(1, 1, 1)] +void computeMain(int3 dispatchThreadID: SV_DispatchThreadID) +{ + int defaultInt = getDefaultInt(); + float defaultFloat = getDefaultFloat(); + double defaultDouble = getDefaultDouble(); + vector vector2 = getDefaultIntVec2(); + vector vector3 = getDefaultIntVec3(); + vector vector4 = getDefaultIntVec4(); +// BUF: 1 + outputBuffer[0] = true + && defaultInt == 0 + && defaultFloat == 0 + && defaultDouble == 0 + && vector2 == vector(0) + && vector3 == vector(0) + && vector4 == vector(0) + && MyFlags::One == getMyFlagsUint_One() +#ifndef DX12 + && MyFlags_uint8::One == getMyFlagsUint8_One() +#endif + && MyFlags_uint16::One == getMyFlagsUint16_One() + && MyFlags_uint32::One == getMyFlagsUint32_One() + && MyFlags_uint64::One == getMyFlagsUint64_One(); + ; +} diff --git a/tests/language-feature/zero-initialize/static-struct-field-init-list.slang b/tests/language-feature/zero-initialize/static-struct-field-init-list.slang new file mode 100644 index 000000000..e40ca7e56 --- /dev/null +++ b/tests/language-feature/zero-initialize/static-struct-field-init-list.slang @@ -0,0 +1,24 @@ +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl -xslang -zero-initialize + +//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +struct structData +{ + uint data; +}; + +struct structOuterData +{ + static structData data1 = { 1 }; +}; + +[numthreads(1,1,1)] +void computeMain() +{ + // BUF: 1 + structOuterData mat; + outputBuffer[0] = true + && mat.data1.data == 1 + ; +} \ No newline at end of file diff --git a/tests/language-feature/zero-initialize/static-struct-field-init.slang b/tests/language-feature/zero-initialize/static-struct-field-init.slang new file mode 100644 index 000000000..ad2db5027 --- /dev/null +++ b/tests/language-feature/zero-initialize/static-struct-field-init.slang @@ -0,0 +1,25 @@ +//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain -zero-initialize +// CHECK: {{.* }}= 0U; + +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl -xslang -zero-initialize + +//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +struct structData +{ + uint data; +}; + +struct structOuterData +{ + static structData data; +}; + +[numthreads(1,1,1)] +void computeMain() +{ + // BUF: 1 + structOuterData mat; + outputBuffer[0] = mat.data.data == 0; +} \ No newline at end of file diff --git a/tests/language-feature/zero-initialize/struct-array-some-member-missing-init.slang b/tests/language-feature/zero-initialize/struct-array-some-member-missing-init.slang new file mode 100644 index 000000000..cdd3f703f --- /dev/null +++ b/tests/language-feature/zero-initialize/struct-array-some-member-missing-init.slang @@ -0,0 +1,42 @@ +//TEST:SIMPLE(filecheck=CHECK): -target hlsl -stage compute -entry computeMain -xslang -zero-initialize +//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain -xslang -zero-initialize + +// CHECK-NOT: {{.* }}= 0; + +RWStructuredBuffer outputBuffer; + +struct MyStruct_base +{ + int a = 1; + int b; +}; +struct MyStruct : MyStruct_base +{ + int c = 1; + int d; +}; + +Array getStructs() +{ + Array outData; + return outData; +} + +[numthreads(1, 1, 1)] +void computeMain(int3 dispatchThreadID: SV_DispatchThreadID) +{ + Array myStruct = getStructs(); + +// BUF: 1 + outputBuffer[0] = true + && myStruct[0].a == 1 + && myStruct[0].b == 0 + && myStruct[0].c == 1 + && myStruct[0].d == 0 + + && myStruct[1].a == 1 + && myStruct[1].b == 0 + && myStruct[1].c == 1 + && myStruct[1].d == 0 + ; +} diff --git a/tests/language-feature/zero-initialize/struct-array.slang b/tests/language-feature/zero-initialize/struct-array.slang new file mode 100644 index 000000000..1f1b8eede --- /dev/null +++ b/tests/language-feature/zero-initialize/struct-array.slang @@ -0,0 +1,38 @@ +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl -xslang -zero-initialize +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -emit-spirv-directly -allow-glsl -xslang -zero-initialize +//TEST(compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-cpu -compute -entry computeMain -allow-glsl -xslang -zero-initialize +//TEST(smoke,compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-dx12 -use-dxil -compute -entry computeMain -allow-glsl -xslang -zero-initialize + +//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +struct MyStruct_base +{ + int a; +}; +struct MyStruct : MyStruct_base +{ + int b; + int c; +}; +[numthreads(1, 1, 1)] +void computeMain(int3 dispatchThreadID: SV_DispatchThreadID) +{ + + Array myStructs; + +// BUF: 1 + outputBuffer[0] = true + && myStructs[0].a == 0 + && myStructs[0].b == 0 + && myStructs[0].c == 0 + + && myStructs[1].a == 0 + && myStructs[1].b == 0 + && myStructs[1].c == 0 + + && myStructs[2].a == 0 + && myStructs[2].b == 0 + && myStructs[2].c == 0 + ; +} diff --git a/tests/language-feature/zero-initialize/struct-no-zero-init.slang b/tests/language-feature/zero-initialize/struct-no-zero-init.slang new file mode 100644 index 000000000..3a4a5f945 --- /dev/null +++ b/tests/language-feature/zero-initialize/struct-no-zero-init.slang @@ -0,0 +1,33 @@ +//TEST:SIMPLE(filecheck=CHECK): -target hlsl -stage compute -entry computeMain +//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain + +// CHECK-NOT: {{.* }}= 0; + +RWStructuredBuffer outputBuffer; + +struct MyStruct_base +{ + int a; +}; +struct MyStruct : MyStruct_base +{ + int b; + int c; +}; +MyStruct getStruct() +{ + MyStruct myStruct; + return myStruct; +} +[numthreads(1, 1, 1)] +void computeMain(int3 dispatchThreadID: SV_DispatchThreadID) +{ + MyStruct myStruct = getStruct(); + +// BUF: 1 + outputBuffer[0] = true + && myStruct.a == 0 + && myStruct.b == 0 + && myStruct.c == 0 + ; +} diff --git a/tests/language-feature/zero-initialize/struct-some-member-init-missing-zero-init.slang b/tests/language-feature/zero-initialize/struct-some-member-init-missing-zero-init.slang new file mode 100644 index 000000000..2b584ad00 --- /dev/null +++ b/tests/language-feature/zero-initialize/struct-some-member-init-missing-zero-init.slang @@ -0,0 +1,35 @@ +//TEST:SIMPLE(filecheck=CHECK): -target hlsl -stage compute -entry computeMain +//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain + +// CHECK-NOT: {{.* }}= 0; + +RWStructuredBuffer outputBuffer; + +struct MyStruct_base +{ + int a = 1; + int b; +}; +struct MyStruct : MyStruct_base +{ + int c = 1; + int d; +}; +MyStruct getStruct() +{ + MyStruct myStruct; + return myStruct; +} +[numthreads(1, 1, 1)] +void computeMain(int3 dispatchThreadID: SV_DispatchThreadID) +{ + MyStruct myStruct = getStruct(); + +// BUF: 1 + outputBuffer[0] = true + && myStruct.a == 1 + && myStruct.b == 0 + && myStruct.c == 1 + && myStruct.d == 0 + ; +} diff --git a/tests/language-feature/zero-initialize/struct-some-zero-init.slang b/tests/language-feature/zero-initialize/struct-some-zero-init.slang new file mode 100644 index 000000000..9bbb1f49e --- /dev/null +++ b/tests/language-feature/zero-initialize/struct-some-zero-init.slang @@ -0,0 +1,39 @@ +//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain -zero-initialize +// CHECK-COUNT-2: {{.* }}= 0; + +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl -xslang -zero-initialize +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -emit-spirv-directly -allow-glsl -xslang -zero-initialize +//TEST(compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-cpu -compute -entry computeMain -allow-glsl -xslang -zero-initialize +//TEST(smoke,compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-dx12 -use-dxil -compute -entry computeMain -allow-glsl -xslang -zero-initialize + +//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +struct MyStruct_base +{ + int a = 1; + int b; +}; +struct MyStruct : MyStruct_base +{ + int c = 1; + int d; +}; +MyStruct getStruct() +{ + MyStruct myStruct; + return myStruct; +} +[numthreads(1, 1, 1)] +void computeMain(int3 dispatchThreadID: SV_DispatchThreadID) +{ + MyStruct myStruct = getStruct(); + +// BUF: 1 + outputBuffer[0] = true + && myStruct.a == 1 + && myStruct.b == 0 + && myStruct.c == 1 + && myStruct.d == 0 + ; +} diff --git a/tests/language-feature/zero-initialize/struct.slang b/tests/language-feature/zero-initialize/struct.slang new file mode 100644 index 000000000..62f403903 --- /dev/null +++ b/tests/language-feature/zero-initialize/struct.slang @@ -0,0 +1,37 @@ +//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain -zero-initialize +// CHECK-COUNT-3: {{.* }}= 0; + +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl -xslang -zero-initialize +//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -emit-spirv-directly -allow-glsl -xslang -zero-initialize +//TEST(compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-cpu -compute -entry computeMain -allow-glsl -xslang -zero-initialize +//TEST(smoke,compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-dx12 -use-dxil -compute -entry computeMain -allow-glsl -xslang -zero-initialize + +//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +struct MyStruct_base +{ + int a; +}; +struct MyStruct : MyStruct_base +{ + int b; + int c; +}; +MyStruct getStruct() +{ + MyStruct myStruct; + return myStruct; +} +[numthreads(1, 1, 1)] +void computeMain(int3 dispatchThreadID: SV_DispatchThreadID) +{ + MyStruct myStruct = getStruct(); + +// BUF: 1 + outputBuffer[0] = true + && myStruct.a == 0 + && myStruct.b == 0 + && myStruct.c == 0 + ; +} -- cgit v1.2.3