maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[ORC-RT] Remove __orc_rt::apply_tuple. 

This utility was a substitute for std::apply, which is now available.
This commit is contained in:
Lang Hames 2022-08-26 17:06:56 -07:00
parent faf373e526
commit 16d538c5ef
3 changed files with 0 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
compiler-rt/lib/orc/stl_extras.h
View File

@ -18,29 +18,6 @@
namespace __orc_rt {
namespace detail {
template <typename F, typename Tuple, std::size_t... I>
decltype(auto) apply_tuple_impl(F &&f, Tuple &&t, std::index_sequence<I...>) {
return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
}
} // end namespace detail
/// Given an input tuple (a1, a2, ..., an), pass the arguments of the
/// tuple variadically to f as if by calling f(a1, a2, ..., an) and
/// return the result.
///
/// FIXME: Switch to std::apply once we can use c++17.
template <typename F, typename Tuple>
decltype(auto) apply_tuple(F &&f, Tuple &&t) {
using Indices = std::make_index_sequence<
std::tuple_size<typename std::decay<Tuple>::type>::value>;
return detail::apply_tuple_impl(std::forward<F>(f), std::forward<Tuple>(t),
Indices{});
}
/// Substitute for std::identity.
/// Switch to std::identity once we can use c++20.
template <class Ty> struct identity {

1
compiler-rt/lib/orc/unittests/CMakeLists.txt
View File

@ -84,7 +84,6 @@ set(UNITTEST_SOURCES
executor_address_test.cpp
extensible_rtti_test.cpp
orc_unit_test_main.cpp
stl_extras_test.cpp
wrapper_function_utils_test.cpp
simple_packed_serialization_test.cpp
)

65
compiler-rt/lib/orc/unittests/stl_extras_test.cpp
View File

@ -1,65 +0,0 @@
//===-- stl_extras_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.
//
// Note:
// This unit test was adapted from tests in
// llvm/unittests/ADT/STLExtrasTest.cpp
//
//===----------------------------------------------------------------------===//
#include "stl_extras.h"
#include "gtest/gtest.h"
using namespace __orc_rt;
TEST(STLExtrasTest, ApplyTuple) {
auto T = std::make_tuple(1, 3, 7);
auto U = __orc_rt::apply_tuple(
[](int A, int B, int C) { return std::make_tuple(A - B, B - C, C - A); },
T);
EXPECT_EQ(-2, std::get<0>(U));
EXPECT_EQ(-4, std::get<1>(U));
EXPECT_EQ(6, std::get<2>(U));
auto V = __orc_rt::apply_tuple(
[](int A, int B, int C) {
return std::make_tuple(std::make_pair(A, char('A' + A)),
std::make_pair(B, char('A' + B)),
std::make_pair(C, char('A' + C)));
},
T);
EXPECT_EQ(std::make_pair(1, 'B'), std::get<0>(V));
EXPECT_EQ(std::make_pair(3, 'D'), std::get<1>(V));
EXPECT_EQ(std::make_pair(7, 'H'), std::get<2>(V));
}
class apply_variadic {
static int apply_one(int X) { return X + 1; }
static char apply_one(char C) { return C + 1; }
static std::string apply_one(std::string S) {
return S.substr(0, S.size() - 1);
}
public:
template <typename... Ts> auto operator()(Ts &&... Items) {
return std::make_tuple(apply_one(Items)...);
}
};
TEST(STLExtrasTest, ApplyTupleVariadic) {
auto Items = std::make_tuple(1, std::string("Test"), 'X');
auto Values = __orc_rt::apply_tuple(apply_variadic(), Items);
EXPECT_EQ(2, std::get<0>(Values));
EXPECT_EQ("Tes", std::get<1>(Values));
EXPECT_EQ('Y', std::get<2>(Values));
}