From: Kazu Hirata Date: Tue, 17 Jan 2023 21:36:03 +0000 (-0800) Subject: Revert "[ORC-RT] Add IntervalMap and IntervalSet collections." X-Git-Tag: upstream/17.0.6~20647 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=c151e8428a29a5579557985e16244c35e8bc76dd;p=platform%2Fupstream%2Fllvm.git Revert "[ORC-RT] Add IntervalMap and IntervalSet collections." This reverts commit ab59185fbfb15c9ce5a64e3aacd3a8c7f6a97621. It looks like this commit is missing interval_set_test.cpp. --- diff --git a/compiler-rt/lib/orc/interval_map.h b/compiler-rt/lib/orc/interval_map.h deleted file mode 100644 index 16f22c6..0000000 --- a/compiler-rt/lib/orc/interval_map.h +++ /dev/null @@ -1,153 +0,0 @@ -//===--------- interval_map.h - A sorted interval map -----------*- C++ -*-===// -// -// 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 -// -//===----------------------------------------------------------------------===// -// -// Implements a coalescing interval map. -// -//===----------------------------------------------------------------------===// - -#ifndef ORC_RT_INTERVAL_MAP_H -#define ORC_RT_INTERVAL_MAP_H - -#include "adt.h" -#include -#include - -namespace __orc_rt { - -enum class IntervalCoalescing { Enabled, Disabled }; - -/// Maps intervals to keys with optional coalescing. -/// -/// NOTE: The interface is kept mostly compatible with LLVM's IntervalMap -/// collection to make it easy to swap over in the future if we choose -/// to. -template -class IntervalMap { -private: - using KeyPairT = std::pair; - - struct Compare { - using is_transparent = std::true_type; - bool operator()(const KeyPairT &LHS, const KeyPairT &RHS) const { - return LHS < RHS; - } - bool operator()(const KeyPairT &LHS, const KeyT &RHS) const { - return LHS.first < RHS; - } - bool operator()(const KeyT &LHS, const KeyPairT &RHS) const { - return LHS < RHS.first; - } - }; - - using ImplMap = std::map; - -public: - using iterator = typename ImplMap::iterator; - using const_iterator = typename ImplMap::const_iterator; - using size_type = typename ImplMap::size_type; - - bool empty() const { return Impl.empty(); } - - void clear() { Impl.clear(); } - - iterator begin() { return Impl.begin(); } - iterator end() { return Impl.end(); } - - const_iterator begin() const { return Impl.begin(); } - const_iterator end() const { return Impl.end(); } - - iterator find(KeyT K) { - // Early out if the key is clearly outside the range. - if (empty() || K < begin()->first.first || - K >= std::prev(end())->first.second) - return end(); - - auto I = Impl.upper_bound(K); - assert(I != begin() && "Should have hit early out above"); - I = std::prev(I); - if (K < I->first.second) - return I; - return end(); - } - - const_iterator find(KeyT K) const { - return const_cast *>(this)->find(K); - } - - ValT lookup(KeyT K, ValT NotFound = ValT()) const { - auto I = find(K); - if (I == end()) - return NotFound; - return I->second; - } - - void insert(KeyT KS, KeyT KE, ValT V) { - if (Coalescing == IntervalCoalescing::Enabled) { - auto J = Impl.upper_bound(KS); - - // Coalesce-right if possible. Either way, J points at our insertion - // point. - if (J != end() && KE == J->first.first && J->second == V) { - KE = J->first.second; - auto Tmp = J++; - Impl.erase(Tmp); - } - - // Coalesce-left if possible. - if (J != begin()) { - auto I = std::prev(J); - if (I->first.second == KS && I->second == V) { - KS = I->first.first; - Impl.erase(I); - } - } - Impl.insert(J, std::make_pair(std::make_pair(KS, KE), std::move(V))); - } else - Impl.insert(std::make_pair(std::make_pair(KS, KE), std::move(V))); - } - - // Erase [KS, KE), which must be entirely containing within one existing - // range in the map. Removal is allowed to split the range. - void erase(KeyT KS, KeyT KE) { - if (empty()) - return; - - auto J = Impl.upper_bound(KS); - - // Check previous range. Bail out if range to remove is entirely after - // it. - auto I = std::prev(J); - if (KS >= I->first.second) - return; - - // Assert that range is wholly contained. - assert(KE <= I->first.second); - - auto Tmp = std::move(*I); - Impl.erase(I); - - // Split-right -- introduce right-split range. - if (KE < Tmp.first.second) { - Impl.insert( - J, std::make_pair(std::make_pair(KE, Tmp.first.second), Tmp.second)); - J = std::prev(J); - } - - // Split-left -- introduce left-split range. - if (KS > Tmp.first.first) - Impl.insert( - J, std::make_pair(std::make_pair(Tmp.first.first, KS), Tmp.second)); - } - -private: - ImplMap Impl; -}; - -} // End namespace __orc_rt - -#endif // ORC_RT_INTERVAL_MAP_H diff --git a/compiler-rt/lib/orc/macho_platform.cpp b/compiler-rt/lib/orc/macho_platform.cpp index 5a5c8e4..7d611e1 100644 --- a/compiler-rt/lib/orc/macho_platform.cpp +++ b/compiler-rt/lib/orc/macho_platform.cpp @@ -14,7 +14,6 @@ #include "common.h" #include "debug.h" #include "error.h" -#include "interval_map.h" #include "wrapper_function_utils.h" #include diff --git a/compiler-rt/lib/orc/tests/unit/CMakeLists.txt b/compiler-rt/lib/orc/tests/unit/CMakeLists.txt index 7792d21..e8cd2f9 100644 --- a/compiler-rt/lib/orc/tests/unit/CMakeLists.txt +++ b/compiler-rt/lib/orc/tests/unit/CMakeLists.txt @@ -5,8 +5,6 @@ set(UNITTEST_SOURCES error_test.cpp executor_address_test.cpp extensible_rtti_test.cpp - interval_map_test.cpp - interval_set_test.cpp orc_unit_test_main.cpp wrapper_function_utils_test.cpp simple_packed_serialization_test.cpp diff --git a/compiler-rt/lib/orc/tests/unit/interval_map_test.cpp b/compiler-rt/lib/orc/tests/unit/interval_map_test.cpp deleted file mode 100644 index 6f6474b..0000000 --- a/compiler-rt/lib/orc/tests/unit/interval_map_test.cpp +++ /dev/null @@ -1,188 +0,0 @@ -//===-- interval_map_test.cpp ---------------------------------------------===// -// -// 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 -// -//===----------------------------------------------------------------------===// -// -// This file is a part of the ORC runtime. -// -//===----------------------------------------------------------------------===// - -#include "interval_map.h" -#include "gtest/gtest.h" - -using namespace __orc_rt; - -TEST(IntervalMapTest, DefaultConstructed) { - // Check that a default-constructed IntervalMap behaves as expected. - IntervalMap M; - - EXPECT_TRUE(M.empty()); - EXPECT_TRUE(M.begin() == M.end()); - EXPECT_TRUE(M.find(0) == M.end()); -} - -TEST(IntervalMapTest, InsertSingleElement) { - // Check that a map with a single element inserted behaves as expected. - IntervalMap M; - - M.insert(7, 8, 42); - - EXPECT_FALSE(M.empty()); - EXPECT_EQ(std::next(M.begin()), M.end()); - EXPECT_EQ(M.find(7), M.begin()); - EXPECT_EQ(M.find(8), M.end()); - EXPECT_EQ(M.lookup(7), 42U); - EXPECT_EQ(M.lookup(8), 0U); // 8 not present, so should return unsigned(). -} - -TEST(IntervalMapTest, InsertCoalesceWithPrevious) { - // Check that insertions coalesce with previous ranges that share the same - // value. Also check that they _don't_ coalesce if the values are different. - - // Check that insertion coalesces with previous range when values are equal. - IntervalMap M1; - - M1.insert(7, 8, 42); - M1.insert(8, 9, 42); - - EXPECT_FALSE(M1.empty()); - EXPECT_EQ(std::next(M1.begin()), M1.end()); // Should see just one range. - EXPECT_EQ(M1.find(7), M1.find(8)); // 7 and 8 should point to same range. - EXPECT_EQ(M1.lookup(7), 42U); // Value should be preserved. - - // Check that insertion does not coalesce with previous range when values are - // not equal. - IntervalMap M2; - - M2.insert(7, 8, 42); - M2.insert(8, 9, 7); - - EXPECT_FALSE(M2.empty()); - EXPECT_EQ(std::next(std::next(M2.begin())), M2.end()); // Expect two ranges. - EXPECT_NE(M2.find(7), M2.find(8)); // 7 and 8 should be different ranges. - EXPECT_EQ(M2.lookup(7), 42U); // Keys 7 and 8 should map to different values. - EXPECT_EQ(M2.lookup(8), 7U); -} - -TEST(IntervalMapTest, InsertCoalesceWithFollowing) { - // Check that insertions coalesce with following ranges that share the same - // value. Also check that they _don't_ coalesce if the values are different. - - // Check that insertion coalesces with following range when values are equal. - IntervalMap M1; - - M1.insert(8, 9, 42); - M1.insert(7, 8, 42); - - EXPECT_FALSE(M1.empty()); - EXPECT_EQ(std::next(M1.begin()), M1.end()); // Should see just one range. - EXPECT_EQ(M1.find(7), M1.find(8)); // 7 and 8 should point to same range. - EXPECT_EQ(M1.lookup(7), 42U); // Value should be preserved. - - // Check that insertion does not coalesce with previous range when values are - // not equal. - IntervalMap M2; - - M2.insert(8, 9, 42); - M2.insert(7, 8, 7); - - EXPECT_FALSE(M2.empty()); - EXPECT_EQ(std::next(std::next(M2.begin())), M2.end()); // Expect two ranges. - EXPECT_EQ(M2.lookup(7), 7U); // Keys 7 and 8 should map to different values. - EXPECT_EQ(M2.lookup(8), 42U); -} - -TEST(IntervalMapTest, InsertCoalesceBoth) { - // Check that insertions coalesce with ranges on both sides where posssible. - // Also check that they _don't_ coalesce if the values are different. - - // Check that insertion coalesces with both previous and following ranges - // when values are equal. - IntervalMap M1; - - M1.insert(7, 8, 42); - M1.insert(9, 10, 42); - - // Check no coalescing yet. - EXPECT_NE(M1.find(7), M1.find(9)); - - // Insert a 3rd range to trigger coalescing on both sides. - M1.insert(8, 9, 42); - - EXPECT_FALSE(M1.empty()); - EXPECT_EQ(std::next(M1.begin()), M1.end()); // Should see just one range. - EXPECT_EQ(M1.find(7), M1.find(8)); // 7, 8, and 9 should point to same range. - EXPECT_EQ(M1.find(8), M1.find(9)); - EXPECT_EQ(M1.lookup(7), 42U); // Value should be preserved. - - // Check that insertion does not coalesce with previous range when values are - // not equal. - IntervalMap M2; - - M2.insert(7, 8, 42); - M2.insert(8, 9, 7); - M2.insert(9, 10, 42); - - EXPECT_FALSE(M2.empty()); - // Expect three ranges. - EXPECT_EQ(std::next(std::next(std::next(M2.begin()))), M2.end()); - EXPECT_NE(M2.find(7), M2.find(8)); // All keys should map to different ranges. - EXPECT_NE(M2.find(8), M2.find(9)); - EXPECT_EQ(M2.lookup(7), 42U); // Key 7, 8, and 9 should map to different vals. - EXPECT_EQ(M2.lookup(8), 7U); - EXPECT_EQ(M2.lookup(9), 42U); -} - -TEST(IntervalMapTest, EraseSingleElement) { - // Check that we can insert and then remove a single range. - IntervalMap M; - - M.insert(7, 10, 42); - EXPECT_FALSE(M.empty()); - M.erase(7, 10); - EXPECT_TRUE(M.empty()); -} - -TEST(IntervalMapTest, EraseSplittingLeft) { - // Check that removal of a trailing subrange succeeds, but leaves the - // residual range in-place. - IntervalMap M; - - M.insert(7, 10, 42); - EXPECT_FALSE(M.empty()); - M.erase(9, 10); - EXPECT_EQ(std::next(M.begin()), M.end()); - EXPECT_EQ(M.begin()->first.first, 7U); - EXPECT_EQ(M.begin()->first.second, 9U); -} - -TEST(IntervalMapTest, EraseSplittingRight) { - // Check that removal of a leading subrange succeeds, but leaves the - // residual range in-place. - IntervalMap M; - - M.insert(7, 10, 42); - EXPECT_FALSE(M.empty()); - M.erase(7, 8); - EXPECT_EQ(std::next(M.begin()), M.end()); - EXPECT_EQ(M.begin()->first.first, 8U); - EXPECT_EQ(M.begin()->first.second, 10U); -} - -TEST(IntervalMapTest, EraseSplittingBoth) { - // Check that removal of an interior subrange leaves both the leading and - // trailing residual subranges in-place. - IntervalMap M; - - M.insert(7, 10, 42); - EXPECT_FALSE(M.empty()); - M.erase(8, 9); - EXPECT_EQ(std::next(std::next(M.begin())), M.end()); - EXPECT_EQ(M.begin()->first.first, 7U); - EXPECT_EQ(M.begin()->first.second, 8U); - EXPECT_EQ(std::next(M.begin())->first.first, 9U); - EXPECT_EQ(std::next(M.begin())->first.second, 10U); -}