• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //
2 // Copyright 2017 The Abseil Authors.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //      https://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 // -----------------------------------------------------------------------------
17 // File: macros.h
18 // -----------------------------------------------------------------------------
19 //
20 // This header file defines the set of language macros used within Abseil code.
21 // For the set of macros used to determine supported compilers and platforms,
22 // see absl/base/config.h instead.
23 //
24 // This code is compiled directly on many platforms, including client
25 // platforms like Windows, Mac, and embedded systems.  Before making
26 // any changes here, make sure that you're not breaking any platforms.
27 
28 #ifndef ABSL_BASE_MACROS_H_
29 #define ABSL_BASE_MACROS_H_
30 
31 #include <cassert>
32 #include <cstddef>
33 
34 #include "absl/base/attributes.h"
35 #include "absl/base/config.h"
36 #include "absl/base/optimization.h"
37 #include "absl/base/port.h"
38 
39 // ABSL_ARRAYSIZE()
40 //
41 // Returns the number of elements in an array as a compile-time constant, which
42 // can be used in defining new arrays. If you use this macro on a pointer by
43 // mistake, you will get a compile-time error.
44 #define ABSL_ARRAYSIZE(array) \
45   (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
46 
47 namespace absl {
48 ABSL_NAMESPACE_BEGIN
49 namespace macros_internal {
50 // Note: this internal template function declaration is used by ABSL_ARRAYSIZE.
51 // The function doesn't need a definition, as we only use its type.
52 template <typename T, size_t N>
53 auto ArraySizeHelper(const T (&array)[N]) -> char (&)[N];
54 }  // namespace macros_internal
55 ABSL_NAMESPACE_END
56 }  // namespace absl
57 
58 // ABSL_BAD_CALL_IF()
59 //
60 // Used on a function overload to trap bad calls: any call that matches the
61 // overload will cause a compile-time error. This macro uses a clang-specific
62 // "enable_if" attribute, as described at
63 // https://clang.llvm.org/docs/AttributeReference.html#enable-if
64 //
65 // Overloads which use this macro should be bracketed by
66 // `#ifdef ABSL_BAD_CALL_IF`.
67 //
68 // Example:
69 //
70 //   int isdigit(int c);
71 //   #ifdef ABSL_BAD_CALL_IF
72 //   int isdigit(int c)
73 //     ABSL_BAD_CALL_IF(c <= -1 || c > 255,
74 //                       "'c' must have the value of an unsigned char or EOF");
75 //   #endif // ABSL_BAD_CALL_IF
76 #if ABSL_HAVE_ATTRIBUTE(enable_if)
77 #define ABSL_BAD_CALL_IF(expr, msg) \
78   __attribute__((enable_if(expr, "Bad call trap"), unavailable(msg)))
79 #endif
80 
81 // ABSL_ASSERT()
82 //
83 // In C++11, `assert` can't be used portably within constexpr functions.
84 // ABSL_ASSERT functions as a runtime assert but works in C++11 constexpr
85 // functions.  Example:
86 //
87 // constexpr double Divide(double a, double b) {
88 //   return ABSL_ASSERT(b != 0), a / b;
89 // }
90 //
91 // This macro is inspired by
92 // https://akrzemi1.wordpress.com/2017/05/18/asserts-in-constexpr-functions/
93 #if defined(NDEBUG)
94 #define ABSL_ASSERT(expr) \
95   (false ? static_cast<void>(expr) : static_cast<void>(0))
96 #else
97 #define ABSL_ASSERT(expr)                           \
98   (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
99                              : [] { assert(false && #expr); }())  // NOLINT
100 #endif
101 
102 // `ABSL_INTERNAL_HARDENING_ABORT()` controls how `ABSL_HARDENING_ASSERT()`
103 // aborts the program in release mode (when NDEBUG is defined). The
104 // implementation should abort the program as quickly as possible and ideally it
105 // should not be possible to ignore the abort request.
106 #if (ABSL_HAVE_BUILTIN(__builtin_trap) &&         \
107      ABSL_HAVE_BUILTIN(__builtin_unreachable)) || \
108     (defined(__GNUC__) && !defined(__clang__))
109 #define ABSL_INTERNAL_HARDENING_ABORT() \
110   do {                                  \
111     __builtin_trap();                   \
112     __builtin_unreachable();            \
113   } while (false)
114 #else
115 #define ABSL_INTERNAL_HARDENING_ABORT() abort()
116 #endif
117 
118 // ABSL_HARDENING_ASSERT()
119 //
120 // `ABSL_HARDENING_ASSERT()` is like `ABSL_ASSERT()`, but used to implement
121 // runtime assertions that should be enabled in hardened builds even when
122 // `NDEBUG` is defined.
123 //
124 // When `NDEBUG` is not defined, `ABSL_HARDENING_ASSERT()` is identical to
125 // `ABSL_ASSERT()`.
126 //
127 // See `ABSL_OPTION_HARDENED` in `absl/base/options.h` for more information on
128 // hardened mode.
129 #if ABSL_OPTION_HARDENED == 1 && defined(NDEBUG)
130 #define ABSL_HARDENING_ASSERT(expr)                 \
131   (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
132                              : [] { ABSL_INTERNAL_HARDENING_ABORT(); }())
133 #else
134 #define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
135 #endif
136 
137 #ifdef ABSL_HAVE_EXCEPTIONS
138 #define ABSL_INTERNAL_TRY try
139 #define ABSL_INTERNAL_CATCH_ANY catch (...)
140 #define ABSL_INTERNAL_RETHROW do { throw; } while (false)
141 #else  // ABSL_HAVE_EXCEPTIONS
142 #define ABSL_INTERNAL_TRY if (true)
143 #define ABSL_INTERNAL_CATCH_ANY else if (false)
144 #define ABSL_INTERNAL_RETHROW do {} while (false)
145 #endif  // ABSL_HAVE_EXCEPTIONS
146 
147 // `ABSL_INTERNAL_UNREACHABLE` is an unreachable statement.  A program which
148 // reaches one has undefined behavior, and the compiler may optimize
149 // accordingly.
150 #if defined(__GNUC__) || ABSL_HAVE_BUILTIN(__builtin_unreachable)
151 #define ABSL_INTERNAL_UNREACHABLE __builtin_unreachable()
152 #elif defined(_MSC_VER)
153 #define ABSL_INTERNAL_UNREACHABLE __assume(0)
154 #else
155 #define ABSL_INTERNAL_UNREACHABLE
156 #endif
157 
158 #endif  // ABSL_BASE_MACROS_H_
159