| //===- llvm/unittest/IR/WaymarkTest.cpp - Waymarking unit 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/ADT/Waymarking.h" |
| #include "gtest/gtest.h" |
| |
| using namespace llvm; |
| |
| static const int N = 100; |
| |
| // Get the Waymarking Tag of the pointer. |
| static int tag(int *P) { |
| return static_cast<int>(reinterpret_cast<uintptr_t>(P) & |
| uintptr_t(alignof(int *) - 1)); |
| } |
| |
| // Get the actual pointer, by stripping the Waymarking Tag. |
| static int *ref(int *P) { |
| return reinterpret_cast<int *>(reinterpret_cast<uintptr_t>(P) & |
| ~uintptr_t(alignof(int *) - 1)); |
| } |
| |
| static int **createArray(int Len) { |
| int **A = new int *[Len]; |
| for (int I = 0; I < Len; ++I) |
| A[I] = new int(I); |
| return A; |
| } |
| |
| static void freeArray(int **A, int Len) { |
| for (int I = 0; I < Len; ++I) |
| delete ref(A[I]); |
| delete[] A; |
| } |
| |
| // Verify the values stored in the array are as expected, and did not change due |
| // to fillWaymarks. |
| static void verifyArrayValues(int **A, int Begin, int End) { |
| for (int I = Begin; I < End; ++I) |
| EXPECT_EQ(I, *ref(A[I])); |
| } |
| |
| static void verifyArrayValues(int **A, int Len) { |
| verifyArrayValues(A, 0, Len); |
| } |
| |
| // Verify that we can follow the waymarks to the array's head from each element |
| // of the array. |
| static void verifyFollowWaymarks(int **A, int Len) { |
| for (int I = 0; I < Len; ++I) { |
| int **P = followWaymarks(A + I); |
| EXPECT_EQ(A, P); |
| } |
| } |
| |
| namespace { |
| |
| // Test filling and following the waymarks of a single array. |
| TEST(WaymarkingTest, SingleHead) { |
| const int N2 = 2 * N; |
| int **volatile A = createArray(N2); |
| |
| // Fill the first half of the array with waymarks. |
| fillWaymarks(A, A + N, 0); |
| verifyArrayValues(A, N2); |
| |
| verifyFollowWaymarks(A, N); |
| |
| // Fill the rest of the waymarks (continuing from where we stopped). |
| fillWaymarks(A + N, A + N2, N); |
| verifyArrayValues(A, N2); |
| |
| verifyFollowWaymarks(A, N); |
| |
| freeArray(A, N2); |
| } |
| |
| // Test filling and following the waymarks of an array split into several |
| // different sections of waymarks (treated just like separate arrays). |
| TEST(WaymarkingTest, MultiHead) { |
| const int N2 = 2 * N; |
| const int N3 = 3 * N; |
| int **volatile A = createArray(N3); |
| |
| // Separate the array into 3 sections of waymarks. |
| fillWaymarks(A, A + N, 0); |
| fillWaymarks(A + N, A + N2, 0); |
| fillWaymarks(A + N2, A + N3, 0); |
| verifyArrayValues(A, N3); |
| |
| verifyFollowWaymarks(A, N); |
| verifyFollowWaymarks(A + N, N2 - N); |
| verifyFollowWaymarks(A + N2, N3 - N2); |
| |
| freeArray(A, N3); |
| } |
| |
| // Test reseting (value and tag of) elements inside an array of waymarks. |
| TEST(WaymarkingTest, Reset) { |
| int **volatile A = createArray(N); |
| |
| fillWaymarks(A, A + N, 0); |
| verifyArrayValues(A, N); |
| |
| const int N2 = N / 2; |
| const int N3 = N / 3; |
| const int N4 = N / 4; |
| |
| // Reset specific elements and check that the tag remains the same. |
| int T2 = tag(A[N2]); |
| delete ref(A[N2]); |
| A[N2] = new int(N2); |
| fillWaymarks(A + N2, A + N2 + 1, N2); |
| verifyArrayValues(A, N2, N2 + 1); |
| EXPECT_EQ(T2, tag(A[N2])); |
| |
| int T3 = tag(A[N3]); |
| delete ref(A[N3]); |
| A[N3] = new int(N3); |
| fillWaymarks(A + N3, A + N3 + 1, N3); |
| verifyArrayValues(A, N3, N3 + 1); |
| EXPECT_EQ(T3, tag(A[N3])); |
| |
| int T4 = tag(A[N4]); |
| delete ref(A[N4]); |
| A[N4] = new int(N4); |
| fillWaymarks(A + N4, A + N4 + 1, N4); |
| verifyArrayValues(A, N4, N4 + 1); |
| EXPECT_EQ(T4, tag(A[N4])); |
| |
| verifyArrayValues(A, N); |
| verifyFollowWaymarks(A, N); |
| |
| freeArray(A, N); |
| } |
| |
| } // end anonymous namespace |