1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
// Copyright 2022 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_COMPILER_TURBOSHAFT_UTILS_H_
#define V8_COMPILER_TURBOSHAFT_UTILS_H_
#include <iostream>
#include <tuple>
#include "src/base/logging.h"
namespace v8::internal::compiler::turboshaft {
template <class... Ts>
struct any_of : std::tuple<const Ts&...> {
explicit any_of(const Ts&... args) : std::tuple<const Ts&...>(args...) {}
template <class T, size_t... indices>
bool Contains(const T& value, std::index_sequence<indices...>) {
return ((value == std::get<indices>(*this)) || ...);
}
template <size_t... indices>
std::ostream& PrintTo(std::ostream& os, std::index_sequence<indices...>) {
bool first = true;
os << "any_of(";
(((first ? (first = false, os) : os << ", "),
os << base::PrintCheckOperand(std::get<indices>(*this))),
...);
return os << ")";
}
};
template <class... Args>
any_of(const Args&...) -> any_of<Args...>;
template <class T, class... Ts>
bool operator==(const T& value, any_of<Ts...> options) {
return options.Contains(value, std::index_sequence_for<Ts...>{});
}
template <class... Ts>
std::ostream& operator<<(std::ostream& os, any_of<Ts...> any) {
return any.PrintTo(os, std::index_sequence_for<Ts...>{});
}
template <class... Ts>
struct all_of : std::tuple<const Ts&...> {
explicit all_of(const Ts&... args) : std::tuple<const Ts&...>(args...) {}
template <class T, size_t... indices>
bool AllEqualTo(const T& value, std::index_sequence<indices...>) {
return ((value == std::get<indices>(*this)) && ...);
}
template <size_t... indices>
std::ostream& PrintTo(std::ostream& os, std::index_sequence<indices...>) {
bool first = true;
os << "all_of(";
(((first ? (first = false, os) : os << ", "),
os << base::PrintCheckOperand(std::get<indices>(*this))),
...);
return os << ")";
}
};
template <class... Args>
all_of(const Args&...) -> all_of<Args...>;
template <class T, class... Ts>
bool operator==(all_of<Ts...> values, const T& target) {
return values.AllEqualTo(target, std::index_sequence_for<Ts...>{});
}
template <class... Ts>
std::ostream& operator<<(std::ostream& os, all_of<Ts...> all) {
return all.PrintTo(os, std::index_sequence_for<Ts...>{});
}
#ifdef DEBUG
bool ShouldSkipOptimizationStep();
#else
inline bool ShouldSkipOptimizationStep() { return false; }
#endif
// Set `*ptr` to `new_value` while the scope is active, reset to the previous
// value upon destruction.
template <class T>
class ScopedModification {
public:
ScopedModification(T* ptr, T new_value)
: ptr_(ptr), old_value_(std::move(*ptr)) {
*ptr = std::move(new_value);
}
~ScopedModification() { *ptr_ = std::move(old_value_); }
const T& old_value() const { return old_value_; }
private:
T* ptr_;
T old_value_;
};
} // namespace v8::internal::compiler::turboshaft
#endif // V8_COMPILER_TURBOSHAFT_UTILS_H_
|
