147 lines
5.5 KiB
C++
147 lines
5.5 KiB
C++
/*
|
|
* Copyright (C) 2015 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <stddef.h> // for size_t
|
|
#include <unistd.h> // for TEMP_FAILURE_RETRY
|
|
|
|
#include <utility>
|
|
|
|
// bionic and glibc both have TEMP_FAILURE_RETRY, but eg Mac OS' libc doesn't.
|
|
#ifndef TEMP_FAILURE_RETRY
|
|
#define TEMP_FAILURE_RETRY(exp) \
|
|
({ \
|
|
decltype(exp) _rc; \
|
|
do { \
|
|
_rc = (exp); \
|
|
} while (_rc == -1 && errno == EINTR); \
|
|
_rc; \
|
|
})
|
|
#endif
|
|
|
|
// A macro to disallow the copy constructor and operator= functions
|
|
// This must be placed in the private: declarations for a class.
|
|
//
|
|
// For disallowing only assign or copy, delete the relevant operator or
|
|
// constructor, for example:
|
|
// void operator=(const TypeName&) = delete;
|
|
// Note, that most uses of DISALLOW_ASSIGN and DISALLOW_COPY are broken
|
|
// semantically, one should either use disallow both or neither. Try to
|
|
// avoid these in new code.
|
|
#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
|
|
TypeName(const TypeName&) = delete; \
|
|
void operator=(const TypeName&) = delete
|
|
|
|
// A macro to disallow all the implicit constructors, namely the
|
|
// default constructor, copy constructor and operator= functions.
|
|
//
|
|
// This should be used in the private: declarations for a class
|
|
// that wants to prevent anyone from instantiating it. This is
|
|
// especially useful for classes containing only static methods.
|
|
#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
|
|
TypeName() = delete; \
|
|
DISALLOW_COPY_AND_ASSIGN(TypeName)
|
|
|
|
// The arraysize(arr) macro returns the # of elements in an array arr.
|
|
// The expression is a compile-time constant, and therefore can be
|
|
// used in defining new arrays, for example. If you use arraysize on
|
|
// a pointer by mistake, you will get a compile-time error.
|
|
//
|
|
// One caveat is that arraysize() doesn't accept any array of an
|
|
// anonymous type or a type defined inside a function. In these rare
|
|
// cases, you have to use the unsafe ARRAYSIZE_UNSAFE() macro below. This is
|
|
// due to a limitation in C++'s template system. The limitation might
|
|
// eventually be removed, but it hasn't happened yet.
|
|
|
|
// This template function declaration is used in defining arraysize.
|
|
// Note that the function doesn't need an implementation, as we only
|
|
// use its type.
|
|
template <typename T, size_t N>
|
|
char(&ArraySizeHelper(T(&array)[N]))[N]; // NOLINT(readability/casting)
|
|
|
|
#define arraysize(array) (sizeof(ArraySizeHelper(array)))
|
|
|
|
#define SIZEOF_MEMBER(t, f) sizeof(std::declval<t>().f)
|
|
|
|
// Changing this definition will cause you a lot of pain. A majority of
|
|
// vendor code defines LIKELY and UNLIKELY this way, and includes
|
|
// this header through an indirect path.
|
|
#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true ))
|
|
#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
|
|
|
|
#define WARN_UNUSED __attribute__((warn_unused_result))
|
|
|
|
// A deprecated function to call to create a false use of the parameter, for
|
|
// example:
|
|
// int foo(int x) { UNUSED(x); return 10; }
|
|
// to avoid compiler warnings. Going forward we prefer ATTRIBUTE_UNUSED.
|
|
template <typename... T>
|
|
void UNUSED(const T&...) {
|
|
}
|
|
|
|
// An attribute to place on a parameter to a function, for example:
|
|
// int foo(int x ATTRIBUTE_UNUSED) { return 10; }
|
|
// to avoid compiler warnings.
|
|
#define ATTRIBUTE_UNUSED __attribute__((__unused__))
|
|
|
|
// The FALLTHROUGH_INTENDED macro can be used to annotate implicit fall-through
|
|
// between switch labels:
|
|
// switch (x) {
|
|
// case 40:
|
|
// case 41:
|
|
// if (truth_is_out_there) {
|
|
// ++x;
|
|
// FALLTHROUGH_INTENDED; // Use instead of/along with annotations in
|
|
// // comments.
|
|
// } else {
|
|
// return x;
|
|
// }
|
|
// case 42:
|
|
// ...
|
|
//
|
|
// As shown in the example above, the FALLTHROUGH_INTENDED macro should be
|
|
// followed by a semicolon. It is designed to mimic control-flow statements
|
|
// like 'break;', so it can be placed in most places where 'break;' can, but
|
|
// only if there are no statements on the execution path between it and the
|
|
// next switch label.
|
|
//
|
|
// When compiled with clang, the FALLTHROUGH_INTENDED macro is expanded to
|
|
// [[clang::fallthrough]] attribute, which is analysed when performing switch
|
|
// labels fall-through diagnostic ('-Wimplicit-fallthrough'). See clang
|
|
// documentation on language extensions for details:
|
|
// http://clang.llvm.org/docs/LanguageExtensions.html#clang__fallthrough
|
|
//
|
|
// When used with unsupported compilers, the FALLTHROUGH_INTENDED macro has no
|
|
// effect on diagnostics.
|
|
//
|
|
// In either case this macro has no effect on runtime behavior and performance
|
|
// of code.
|
|
#ifndef FALLTHROUGH_INTENDED
|
|
#define FALLTHROUGH_INTENDED [[clang::fallthrough]] // NOLINT
|
|
#endif
|
|
|
|
// Current ABI string
|
|
#if defined(__arm__)
|
|
#define ABI_STRING "arm"
|
|
#elif defined(__aarch64__)
|
|
#define ABI_STRING "arm64"
|
|
#elif defined(__i386__)
|
|
#define ABI_STRING "x86"
|
|
#elif defined(__x86_64__)
|
|
#define ABI_STRING "x86_64"
|
|
#endif
|