Coverage Report

Created: 2024-09-08 06:07

/proc/self/cwd/external/com_google_absl/absl/base/internal/atomic_hook.h
Line
Count
Source (jump to first uncovered line)
1
// Copyright 2017 The Abseil Authors.
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//      https://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14
15
#ifndef ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
16
#define ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
17
18
#include <atomic>
19
#include <cassert>
20
#include <cstdint>
21
#include <utility>
22
23
#include "absl/base/attributes.h"
24
#include "absl/base/config.h"
25
26
#if defined(_MSC_VER) && !defined(__clang__)
27
#define ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT 0
28
#else
29
#define ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT 1
30
#endif
31
32
#if defined(_MSC_VER)
33
#define ABSL_HAVE_WORKING_ATOMIC_POINTER 0
34
#else
35
#define ABSL_HAVE_WORKING_ATOMIC_POINTER 1
36
#endif
37
38
namespace absl {
39
ABSL_NAMESPACE_BEGIN
40
namespace base_internal {
41
42
template <typename T>
43
class AtomicHook;
44
45
// To workaround AtomicHook not being constant-initializable on some platforms,
46
// prefer to annotate instances with `ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES`
47
// instead of `ABSL_CONST_INIT`.
48
#if ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
49
#define ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_CONST_INIT
50
#else
51
#define ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
52
#endif
53
54
// `AtomicHook` is a helper class, templatized on a raw function pointer type,
55
// for implementing Abseil customization hooks.  It is a callable object that
56
// dispatches to the registered hook.  Objects of type `AtomicHook` must have
57
// static or thread storage duration.
58
//
59
// A default constructed object performs a no-op (and returns a default
60
// constructed object) if no hook has been registered.
61
//
62
// Hooks can be pre-registered via constant initialization, for example:
63
//
64
// ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static AtomicHook<void(*)()>
65
//     my_hook(DefaultAction);
66
//
67
// and then changed at runtime via a call to `Store()`.
68
//
69
// Reads and writes guarantee memory_order_acquire/memory_order_release
70
// semantics.
71
template <typename ReturnType, typename... Args>
72
class AtomicHook<ReturnType (*)(Args...)> {
73
 public:
74
  using FnPtr = ReturnType (*)(Args...);
75
76
  // Constructs an object that by default performs a no-op (and
77
  // returns a default constructed object) when no hook as been registered.
78
  constexpr AtomicHook() : AtomicHook(DummyFunction) {}
79
80
  // Constructs an object that by default dispatches to/returns the
81
  // pre-registered default_fn when no hook has been registered at runtime.
82
#if ABSL_HAVE_WORKING_ATOMIC_POINTER && ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
83
  explicit constexpr AtomicHook(FnPtr default_fn)
84
      : hook_(default_fn), default_fn_(default_fn) {}
85
#elif ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
86
  explicit constexpr AtomicHook(FnPtr default_fn)
87
      : hook_(kUninitialized), default_fn_(default_fn) {}
88
#else
89
  // As of January 2020, on all known versions of MSVC this constructor runs in
90
  // the global constructor sequence.  If `Store()` is called by a dynamic
91
  // initializer, we want to preserve the value, even if this constructor runs
92
  // after the call to `Store()`.  If not, `hook_` will be
93
  // zero-initialized by the linker and we have no need to set it.
94
  // https://developercommunity.visualstudio.com/content/problem/336946/class-with-constexpr-constructor-not-using-static.html
95
  explicit constexpr AtomicHook(FnPtr default_fn)
96
      : /* hook_(deliberately omitted), */ default_fn_(default_fn) {
97
    static_assert(kUninitialized == 0, "here we rely on zero-initialization");
98
  }
99
#endif
100
101
  // Stores the provided function pointer as the value for this hook.
102
  //
103
  // This is intended to be called once.  Multiple calls are legal only if the
104
  // same function pointer is provided for each call.  The store is implemented
105
  // as a memory_order_release operation, and read accesses are implemented as
106
  // memory_order_acquire.
107
0
  void Store(FnPtr fn) {
108
0
    bool success = DoStore(fn);
109
0
    static_cast<void>(success);
110
0
    assert(success);
111
0
  }
Unexecuted instantiation: absl::base_internal::AtomicHook<bool (*)(absl::LogSeverity, char const*, int, char**, int*)>::Store(bool (*)(absl::LogSeverity, char const*, int, char**, int*))
Unexecuted instantiation: absl::base_internal::AtomicHook<void (*)(char const*, int, char const*, char const*, char const*)>::Store(void (*)(char const*, int, char const*, char const*, char const*))
Unexecuted instantiation: absl::base_internal::AtomicHook<void (*)(absl::LogSeverity, char const*, int, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)>::Store(void (*)(absl::LogSeverity, char const*, int, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&))
112
113
  // Invokes the registered callback.  If no callback has yet been registered, a
114
  // default-constructed object of the appropriate type is returned instead.
115
  template <typename... CallArgs>
116
0
  ReturnType operator()(CallArgs&&... args) const {
117
0
    return DoLoad()(std::forward<CallArgs>(args)...);
118
0
  }
Unexecuted instantiation: void absl::base_internal::AtomicHook<void (*)(absl::LogSeverity, char const*, int, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)>::operator()<absl::LogSeverity, char const* const&, int, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&>(absl::LogSeverity&&, char const* const&, int&&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&) const
Unexecuted instantiation: bool absl::base_internal::AtomicHook<bool (*)(absl::LogSeverity, char const*, int, char**, int*)>::operator()<absl::LogSeverity&, char const*&, int&, char**, int*>(absl::LogSeverity&, char const*&, int&, char**&&, int*&&) const
Unexecuted instantiation: void absl::base_internal::AtomicHook<void (*)(char const*, int, char const*, char const*, char const*)>::operator()<char const*&, int&, char (&) [3000], char const* const&, char*>(char const*&, int&, char (&) [3000], char const* const&, char*&&) const
119
120
  // Returns the registered callback, or nullptr if none has been registered.
121
  // Useful if client code needs to conditionalize behavior based on whether a
122
  // callback was registered.
123
  //
124
  // Note that atomic_hook.Load()() and atomic_hook() have different semantics:
125
  // operator()() will perform a no-op if no callback was registered, while
126
  // Load()() will dereference a null function pointer.  Prefer operator()() to
127
  // Load()() unless you must conditionalize behavior on whether a hook was
128
  // registered.
129
  FnPtr Load() const {
130
    FnPtr ptr = DoLoad();
131
    return (ptr == DummyFunction) ? nullptr : ptr;
132
  }
133
134
 private:
135
0
  static ReturnType DummyFunction(Args...) {
136
0
    return ReturnType();
137
0
  }
138
139
  // Current versions of MSVC (as of September 2017) have a broken
140
  // implementation of std::atomic<T*>:  Its constructor attempts to do the
141
  // equivalent of a reinterpret_cast in a constexpr context, which is not
142
  // allowed.
143
  //
144
  // This causes an issue when building with LLVM under Windows.  To avoid this,
145
  // we use a less-efficient, intptr_t-based implementation on Windows.
146
#if ABSL_HAVE_WORKING_ATOMIC_POINTER
147
  // Return the stored value, or DummyFunction if no value has been stored.
148
0
  FnPtr DoLoad() const { return hook_.load(std::memory_order_acquire); }
Unexecuted instantiation: absl::base_internal::AtomicHook<void (*)(absl::LogSeverity, char const*, int, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)>::DoLoad() const
Unexecuted instantiation: absl::base_internal::AtomicHook<bool (*)(absl::LogSeverity, char const*, int, char**, int*)>::DoLoad() const
Unexecuted instantiation: absl::base_internal::AtomicHook<void (*)(char const*, int, char const*, char const*, char const*)>::DoLoad() const
149
150
  // Store the given value.  Returns false if a different value was already
151
  // stored to this object.
152
0
  bool DoStore(FnPtr fn) {
153
0
    assert(fn);
154
0
    FnPtr expected = default_fn_;
155
0
    const bool store_succeeded = hook_.compare_exchange_strong(
156
0
        expected, fn, std::memory_order_acq_rel, std::memory_order_acquire);
157
0
    const bool same_value_already_stored = (expected == fn);
158
0
    return store_succeeded || same_value_already_stored;
159
0
  }
Unexecuted instantiation: absl::base_internal::AtomicHook<bool (*)(absl::LogSeverity, char const*, int, char**, int*)>::DoStore(bool (*)(absl::LogSeverity, char const*, int, char**, int*))
Unexecuted instantiation: absl::base_internal::AtomicHook<void (*)(char const*, int, char const*, char const*, char const*)>::DoStore(void (*)(char const*, int, char const*, char const*, char const*))
Unexecuted instantiation: absl::base_internal::AtomicHook<void (*)(absl::LogSeverity, char const*, int, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)>::DoStore(void (*)(absl::LogSeverity, char const*, int, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&))
160
161
  std::atomic<FnPtr> hook_;
162
#else  // !ABSL_HAVE_WORKING_ATOMIC_POINTER
163
  // Use a sentinel value unlikely to be the address of an actual function.
164
  static constexpr intptr_t kUninitialized = 0;
165
166
  static_assert(sizeof(intptr_t) >= sizeof(FnPtr),
167
                "intptr_t can't contain a function pointer");
168
169
  FnPtr DoLoad() const {
170
    const intptr_t value = hook_.load(std::memory_order_acquire);
171
    if (value == kUninitialized) {
172
      return default_fn_;
173
    }
174
    return reinterpret_cast<FnPtr>(value);
175
  }
176
177
  bool DoStore(FnPtr fn) {
178
    assert(fn);
179
    const auto value = reinterpret_cast<intptr_t>(fn);
180
    intptr_t expected = kUninitialized;
181
    const bool store_succeeded = hook_.compare_exchange_strong(
182
        expected, value, std::memory_order_acq_rel, std::memory_order_acquire);
183
    const bool same_value_already_stored = (expected == value);
184
    return store_succeeded || same_value_already_stored;
185
  }
186
187
  std::atomic<intptr_t> hook_;
188
#endif
189
190
  const FnPtr default_fn_;
191
};
192
193
#undef ABSL_HAVE_WORKING_ATOMIC_POINTER
194
#undef ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
195
196
}  // namespace base_internal
197
ABSL_NAMESPACE_END
198
}  // namespace absl
199
200
#endif  // ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_