aboutsummaryrefslogtreecommitdiff
path: root/llvm/unittests/Frontend
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/unittests/Frontend')
-rw-r--r--llvm/unittests/Frontend/CMakeLists.txt1
-rw-r--r--llvm/unittests/Frontend/HLSLBindingTest.cpp273
-rw-r--r--llvm/unittests/Frontend/OpenMPDecompositionTest.cpp16
3 files changed, 282 insertions, 8 deletions
diff --git a/llvm/unittests/Frontend/CMakeLists.txt b/llvm/unittests/Frontend/CMakeLists.txt
index 281d509..6e4ba5d 100644
--- a/llvm/unittests/Frontend/CMakeLists.txt
+++ b/llvm/unittests/Frontend/CMakeLists.txt
@@ -11,6 +11,7 @@ set(LLVM_LINK_COMPONENTS
)
add_llvm_unittest(LLVMFrontendTests
+ HLSLBindingTest.cpp
HLSLRootSignatureDumpTest.cpp
HLSLRootSignatureRangesTest.cpp
OpenACCTest.cpp
diff --git a/llvm/unittests/Frontend/HLSLBindingTest.cpp b/llvm/unittests/Frontend/HLSLBindingTest.cpp
new file mode 100644
index 0000000..bd6a0ff
--- /dev/null
+++ b/llvm/unittests/Frontend/HLSLBindingTest.cpp
@@ -0,0 +1,273 @@
+//===------ HLSLBindingTest.cpp - Resource binding tests ------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Frontend/HLSL/HLSLBinding.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/DXILABI.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::dxil;
+
+MATCHER_P(HasSpecificValue, Value, "") {
+ return arg.has_value() && *arg == Value;
+}
+
+static void
+checkExpectedSpaceAndFreeRanges(hlsl::BindingInfo::RegisterSpace &RegSpace,
+ uint32_t ExpSpace,
+ ArrayRef<uint32_t> ExpValues) {
+ EXPECT_EQ(RegSpace.Space, ExpSpace);
+ EXPECT_EQ(RegSpace.FreeRanges.size() * 2, ExpValues.size());
+ unsigned I = 0;
+ for (auto &R : RegSpace.FreeRanges) {
+ EXPECT_EQ(R.LowerBound, ExpValues[I]);
+ EXPECT_EQ(R.UpperBound, ExpValues[I + 1]);
+ I += 2;
+ }
+}
+
+TEST(HLSLBindingTest, TestTrivialCase) {
+ hlsl::BindingInfoBuilder Builder;
+
+ Builder.trackBinding(ResourceClass::UAV, /*Space=*/0, /*LowerBound=*/5,
+ /*UpperBound=*/5, /*Cookie=*/nullptr);
+ bool HasOverlap;
+ hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap);
+
+ EXPECT_FALSE(HasOverlap);
+
+ // check that UAV has exactly one gap
+ hlsl::BindingInfo::BindingSpaces &UAVSpaces =
+ Info.getBindingSpaces(ResourceClass::UAV);
+ EXPECT_EQ(UAVSpaces.RC, ResourceClass::UAV);
+ EXPECT_EQ(UAVSpaces.Spaces.size(), 1u);
+ checkExpectedSpaceAndFreeRanges(UAVSpaces.Spaces[0], 0, {0u, 4u, 6u, ~0u});
+
+ // check that other kinds of register spaces are all available
+ for (auto RC :
+ {ResourceClass::SRV, ResourceClass::CBuffer, ResourceClass::Sampler}) {
+ hlsl::BindingInfo::BindingSpaces &Spaces = Info.getBindingSpaces(RC);
+ EXPECT_EQ(Spaces.RC, RC);
+ EXPECT_EQ(Spaces.Spaces.size(), 0u);
+ }
+}
+
+TEST(HLSLBindingTest, TestManyBindings) {
+ hlsl::BindingInfoBuilder Builder;
+
+ // cbuffer CB : register(b3) { int a; }
+ // RWBuffer<float4> A[5] : register(u10, space20);
+ // StructuredBuffer<int> B : register(t5);
+ // RWBuffer<float> C : register(u5);
+ // StructuredBuffer<int> D[5] : register(t0);
+ // RWBuffer<float> E[2] : register(u2);
+ // SamplerState S1 : register(s5, space2);
+ // SamplerState S2 : register(s4, space2);
+ Builder.trackBinding(ResourceClass::CBuffer, /*Space=*/0, /*LowerBound=*/3,
+ /*UpperBound=*/3, /*Cookie=*/nullptr);
+ Builder.trackBinding(ResourceClass::UAV, /*Space=*/20, /*LowerBound=*/10,
+ /*UpperBound=*/14, /*Cookie=*/nullptr);
+ Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/5,
+ /*UpperBound=*/5, /*Cookie=*/nullptr);
+ Builder.trackBinding(ResourceClass::UAV, /*Space=*/0, /*LowerBound=*/5,
+ /*UpperBound=*/5, /*Cookie=*/nullptr);
+ Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/0,
+ /*UpperBound=*/4, /*Cookie=*/nullptr);
+ Builder.trackBinding(ResourceClass::UAV, /*Space=*/0, /*LowerBound=*/2,
+ /*UpperBound=*/3, /*Cookie=*/nullptr);
+ Builder.trackBinding(ResourceClass::Sampler, /*Space=*/2, /*LowerBound=*/5,
+ /*UpperBound=*/5, /*Cookie=*/nullptr);
+ Builder.trackBinding(ResourceClass::Sampler, /*Space=*/2, /*LowerBound=*/4,
+ /*UpperBound=*/4, /*Cookie=*/nullptr);
+ bool HasOverlap;
+ hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap);
+
+ EXPECT_FALSE(HasOverlap);
+
+ hlsl::BindingInfo::BindingSpaces &SRVSpaces =
+ Info.getBindingSpaces(ResourceClass::SRV);
+ EXPECT_EQ(SRVSpaces.RC, ResourceClass::SRV);
+ EXPECT_EQ(SRVSpaces.Spaces.size(), 1u);
+ // verify that consecutive bindings are merged
+ // (SRVSpaces has only one free space range {6, ~0u}).
+ checkExpectedSpaceAndFreeRanges(SRVSpaces.Spaces[0], 0, {6u, ~0u});
+
+ hlsl::BindingInfo::BindingSpaces &UAVSpaces =
+ Info.getBindingSpaces(ResourceClass::UAV);
+ EXPECT_EQ(UAVSpaces.RC, ResourceClass::UAV);
+ EXPECT_EQ(UAVSpaces.Spaces.size(), 2u);
+ checkExpectedSpaceAndFreeRanges(UAVSpaces.Spaces[0], 0,
+ {0u, 1u, 4u, 4u, 6u, ~0u});
+ checkExpectedSpaceAndFreeRanges(UAVSpaces.Spaces[1], 20, {0u, 9u, 15u, ~0u});
+
+ hlsl::BindingInfo::BindingSpaces &CBufferSpaces =
+ Info.getBindingSpaces(ResourceClass::CBuffer);
+ EXPECT_EQ(CBufferSpaces.RC, ResourceClass::CBuffer);
+ EXPECT_EQ(CBufferSpaces.Spaces.size(), 1u);
+ checkExpectedSpaceAndFreeRanges(CBufferSpaces.Spaces[0], 0,
+ {0u, 2u, 4u, ~0u});
+
+ hlsl::BindingInfo::BindingSpaces &SamplerSpaces =
+ Info.getBindingSpaces(ResourceClass::Sampler);
+ EXPECT_EQ(SamplerSpaces.RC, ResourceClass::Sampler);
+ EXPECT_EQ(SamplerSpaces.Spaces.size(), 1u);
+ checkExpectedSpaceAndFreeRanges(SamplerSpaces.Spaces[0], 2,
+ {0u, 3u, 6u, ~0u});
+}
+
+TEST(HLSLBindingTest, TestUnboundedAndOverlap) {
+ hlsl::BindingInfoBuilder Builder;
+
+ // StructuredBuffer<float> A[] : register(t5);
+ // StructuredBuffer<float> B[3] : register(t0);
+ // StructuredBuffer<float> C[] : register(t0, space2);
+ // StructuredBuffer<float> D : register(t4, space2); /* overlapping */
+ Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/5,
+ /*UpperBound=*/~0u, /*Cookie=*/nullptr);
+ Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/0,
+ /*UpperBound=*/2, /*Cookie=*/nullptr);
+ Builder.trackBinding(ResourceClass::SRV, /*Space=*/2, /*LowerBound=*/0,
+ /*UpperBound=*/~0u, /*Cookie=*/nullptr);
+ Builder.trackBinding(ResourceClass::SRV, /*Space=*/2, /*LowerBound=*/4,
+ /*UpperBound=*/4, /*Cookie=*/nullptr);
+ bool HasOverlap;
+ hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap);
+
+ EXPECT_TRUE(HasOverlap);
+
+ hlsl::BindingInfo::BindingSpaces &SRVSpaces =
+ Info.getBindingSpaces(ResourceClass::SRV);
+ EXPECT_EQ(SRVSpaces.RC, ResourceClass::SRV);
+ EXPECT_EQ(SRVSpaces.Spaces.size(), 2u);
+ checkExpectedSpaceAndFreeRanges(SRVSpaces.Spaces[0], 0, {3, 4});
+ checkExpectedSpaceAndFreeRanges(SRVSpaces.Spaces[1], 2, {});
+}
+
+TEST(HLSLBindingTest, TestExactOverlap) {
+ hlsl::BindingInfoBuilder Builder;
+
+ // Since the bindings overlap exactly we need sigil values to differentiate
+ // them.
+ char ID1;
+ char ID2;
+
+ // StructuredBuffer<float> A : register(t5);
+ // StructuredBuffer<float> B : register(t5);
+ Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/5,
+ /*UpperBound=*/5, /*Cookie=*/&ID1);
+ Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/5,
+ /*UpperBound=*/5, /*Cookie=*/&ID2);
+ bool HasOverlap;
+ hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap);
+
+ EXPECT_TRUE(HasOverlap);
+
+ hlsl::BindingInfo::BindingSpaces &SRVSpaces =
+ Info.getBindingSpaces(ResourceClass::SRV);
+ EXPECT_EQ(SRVSpaces.RC, ResourceClass::SRV);
+ EXPECT_EQ(SRVSpaces.Spaces.size(), 1u);
+ checkExpectedSpaceAndFreeRanges(SRVSpaces.Spaces[0], 0, {0u, 4u, 6u, ~0u});
+}
+
+TEST(HLSLBindingTest, TestEndOfRange) {
+ hlsl::BindingInfoBuilder Builder;
+
+ // RWBuffer<float> A : register(u4294967295); /* UINT32_MAX */
+ // RWBuffer<float> B[10] : register(u4294967286, space1);
+ // /* range (UINT32_MAX - 9, UINT32_MAX )*/
+ // RWBuffer<float> C[10] : register(u2147483647, space2);
+ // /* range (INT32_MAX, INT32_MAX + 9) */
+ Builder.trackBinding(ResourceClass::UAV, /*Space=*/0, /*LowerBound=*/~0u,
+ /*UpperBound=*/~0u, /*Cookie=*/nullptr);
+ Builder.trackBinding(ResourceClass::UAV, /*Space=*/1, /*LowerBound=*/~0u - 9u,
+ /*UpperBound=*/~0u, /*Cookie=*/nullptr);
+ Builder.trackBinding(ResourceClass::UAV, /*Space=*/2,
+ /*LowerBound=*/2147483647u,
+ /*UpperBound=*/2147483647u + 9u, /*Cookie=*/nullptr);
+ bool HasOverlap;
+ hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap);
+
+ EXPECT_FALSE(HasOverlap);
+
+ hlsl::BindingInfo::BindingSpaces &UAVSpaces =
+ Info.getBindingSpaces(ResourceClass::UAV);
+ EXPECT_EQ(UAVSpaces.RC, ResourceClass::UAV);
+ EXPECT_EQ(UAVSpaces.Spaces.size(), 3u);
+ checkExpectedSpaceAndFreeRanges(
+ UAVSpaces.Spaces[0], 0, {0, std::numeric_limits<uint32_t>::max() - 1});
+ checkExpectedSpaceAndFreeRanges(
+ UAVSpaces.Spaces[1], 1, {0, std::numeric_limits<uint32_t>::max() - 10});
+ checkExpectedSpaceAndFreeRanges(
+ UAVSpaces.Spaces[2], 2,
+ {0, static_cast<uint32_t>(std::numeric_limits<int32_t>::max()) - 1u,
+ static_cast<uint32_t>(std::numeric_limits<int32_t>::max()) + 10u,
+ std::numeric_limits<uint32_t>::max()});
+}
+
+TEST(HLSLBindingTest, TestFindAvailable) {
+ hlsl::BindingInfoBuilder Builder;
+
+ // RWBuffer<float> A : register(u5);
+ // RWBuffer<float> B : register(u5, space1);
+ // RWBuffer<float> C : register(u11, space1);
+ // RWBuffer<float> D[] : register(u1, space2);
+ Builder.trackBinding(ResourceClass::UAV, /*Space=*/0, /*LowerBound=*/5u,
+ /*UpperBound=*/5u, /*Cookie=*/nullptr);
+ Builder.trackBinding(ResourceClass::UAV, /*Space=*/1, /*LowerBound=*/2u,
+ /*UpperBound=*/2u, /*Cookie=*/nullptr);
+ Builder.trackBinding(ResourceClass::UAV, /*Space=*/1, /*LowerBound=*/6u,
+ /*UpperBound=*/6u, /*Cookie=*/nullptr);
+ Builder.trackBinding(ResourceClass::UAV, /*Space=*/2, /*LowerBound=*/1u,
+ /*UpperBound=*/~0u, /*Cookie=*/nullptr);
+ Builder.trackBinding(ResourceClass::UAV, /*Space=*/3, /*LowerBound=*/~0u - 1,
+ /*UpperBound=*/~0u - 1, /*Cookie=*/nullptr);
+ bool HasOverlap;
+ hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap);
+
+ EXPECT_FALSE(HasOverlap);
+
+ // In space 0, we find room for a small binding at the beginning and
+ // a large binding after `A`'s binding.
+ std::optional<uint32_t> V =
+ Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/0, /*Size=*/1);
+ EXPECT_THAT(V, HasSpecificValue(0u));
+ V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/0, /*Size=*/100);
+ EXPECT_THAT(V, HasSpecificValue(6u));
+
+ // In space 1, we try to fit larger bindings in the fill the gaps. Note that
+ // we do this largest to smallest and observe that the gaps that are earlier
+ // still exist.
+ V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/1, /*Size=*/4);
+ EXPECT_THAT(V, HasSpecificValue(7u));
+ V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/1, /*Size=*/3);
+ EXPECT_THAT(V, HasSpecificValue(3u));
+ V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/1, /*Size=*/2);
+ EXPECT_THAT(V, HasSpecificValue(0u));
+ // At this point, we've used all of the contiguous space up to 11u
+ V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/1, /*Size=*/1);
+ EXPECT_THAT(V, HasSpecificValue(11u));
+
+ // Space 2 is mostly full, we can only fit into the room at the beginning.
+ V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/2, /*Size=*/2);
+ EXPECT_FALSE(V.has_value());
+ V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/2, /*Size=*/1);
+ EXPECT_THAT(V, HasSpecificValue(0u));
+
+ // Finding space for an unbounded array is a bit funnier. it always needs to
+ // go a the end of the available space.
+ V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/3,
+ /*Size=*/~0u);
+ // Note that we end up with a size 1 array here, starting at ~0u.
+ EXPECT_THAT(V, HasSpecificValue(~0u));
+ V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/4,
+ /*Size=*/~0u);
+ // In an empty space we find the slot at the beginning.
+ EXPECT_THAT(V, HasSpecificValue(0u));
+}
diff --git a/llvm/unittests/Frontend/OpenMPDecompositionTest.cpp b/llvm/unittests/Frontend/OpenMPDecompositionTest.cpp
index 6189d09..95c26b1 100644
--- a/llvm/unittests/Frontend/OpenMPDecompositionTest.cpp
+++ b/llvm/unittests/Frontend/OpenMPDecompositionTest.cpp
@@ -431,8 +431,8 @@ TEST_F(OpenMPDecompositionTest, Firstprivate3) {
std::string Dir0 = stringify(Dec.output[0]);
std::string Dir1 = stringify(Dec.output[1]);
std::string Dir2 = stringify(Dec.output[2]);
- ASSERT_EQ(Dir0, "target map(2, , , , (x))"); // (12), (27)
- ASSERT_EQ(Dir1, "teams shared(x)"); // (6), (17)
+ ASSERT_EQ(Dir0, "target map(2, , , , , (x))"); // (12), (27)
+ ASSERT_EQ(Dir1, "teams shared(x)"); // (6), (17)
ASSERT_EQ(Dir2, "distribute firstprivate(x) lastprivate(, (x))"); // (5), (21)
}
@@ -574,9 +574,9 @@ TEST_F(OpenMPDecompositionTest, Lastprivate3) {
std::string Dir0 = stringify(Dec.output[0]);
std::string Dir1 = stringify(Dec.output[1]);
std::string Dir2 = stringify(Dec.output[2]);
- ASSERT_EQ(Dir0, "target map(2, , , , (x))"); // (21), (27)
- ASSERT_EQ(Dir1, "parallel shared(x)"); // (22)
- ASSERT_EQ(Dir2, "do lastprivate(, (x))"); // (21)
+ ASSERT_EQ(Dir0, "target map(2, , , , , (x))"); // (21), (27)
+ ASSERT_EQ(Dir1, "parallel shared(x)"); // (22)
+ ASSERT_EQ(Dir2, "do lastprivate(, (x))"); // (21)
}
// SHARED
@@ -984,9 +984,9 @@ TEST_F(OpenMPDecompositionTest, Reduction7) {
std::string Dir0 = stringify(Dec.output[0]);
std::string Dir1 = stringify(Dec.output[1]);
std::string Dir2 = stringify(Dec.output[2]);
- ASSERT_EQ(Dir0, "target map(2, , , , (x))"); // (36), (10)
- ASSERT_EQ(Dir1, "parallel shared(x)"); // (36), (1), (4)
- ASSERT_EQ(Dir2, "do reduction(, (3), (x))"); // (36)
+ ASSERT_EQ(Dir0, "target map(2, , , , , (x))"); // (36), (10)
+ ASSERT_EQ(Dir1, "parallel shared(x)"); // (36), (1), (4)
+ ASSERT_EQ(Dir2, "do reduction(, (3), (x))"); // (36)
}
// IF
generated by cgit v1.1 at 2025-08-01 02:04:20 +0000