The Tor Browser: comparison mfbt/Attributes.h

--1:000000000000
+:7aaec72a79ef
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+/* Implementations of various class and method modifier attributes. */
+#ifndef mozilla_Attributes_h
+#define mozilla_Attributes_h
+#include "mozilla/Compiler.h"
+/*
+* MOZ_ALWAYS_INLINE is a macro which expands to tell the compiler that the
+* method decorated with it must be inlined, even if the compiler thinks
+* otherwise.  This is only a (much) stronger version of the inline hint:
+* compilers are not guaranteed to respect it (although they're much more likely
+* to do so).
+*
+* The MOZ_ALWAYS_INLINE_EVEN_DEBUG macro is yet stronger. It tells the
+* compiler to inline even in DEBUG builds. It should be used very rarely.
+*/
+#if defined(_MSC_VER)
+#  define MOZ_ALWAYS_INLINE_EVEN_DEBUG     __forceinline
+#elif defined(__GNUC__)
+#  define MOZ_ALWAYS_INLINE_EVEN_DEBUG     __attribute__((always_inline)) inline
+#else
+#  define MOZ_ALWAYS_INLINE_EVEN_DEBUG     inline
+#endif
+#if !defined(DEBUG)
+#  define MOZ_ALWAYS_INLINE     MOZ_ALWAYS_INLINE_EVEN_DEBUG
+#elif defined(_MSC_VER) && !defined(__cplusplus)
+#  define MOZ_ALWAYS_INLINE     __inline
+#else
+#  define MOZ_ALWAYS_INLINE     inline
+#endif
+/*
+* g++ requires -std=c++0x or -std=gnu++0x to support C++11 functionality
+* without warnings (functionality used by the macros below).  These modes are
+* detectable by checking whether __GXX_EXPERIMENTAL_CXX0X__ is defined or, more
+* standardly, by checking whether __cplusplus has a C++11 or greater value.
+* Current versions of g++ do not correctly set __cplusplus, so we check both
+* for forward compatibility.
+*/
+#if defined(__clang__)
+/*
+* Per Clang documentation, "Note that marketing version numbers should not
+* be used to check for language features, as different vendors use different
+* numbering schemes. Instead, use the feature checking macros."
+*/
+#  ifndef __has_extension
+#    define __has_extension __has_feature /* compatibility, for older versions of clang */
+#  endif
+#  if __has_extension(cxx_constexpr)
+#    define MOZ_HAVE_CXX11_CONSTEXPR
+#  endif
+#  if __has_extension(cxx_explicit_conversions)
+#    define MOZ_HAVE_EXPLICIT_CONVERSION
+#  endif
+#  if __has_extension(cxx_deleted_functions)
+#    define MOZ_HAVE_CXX11_DELETE
+#  endif
+#  if __has_extension(cxx_override_control)
+#    define MOZ_HAVE_CXX11_OVERRIDE
+#    define MOZ_HAVE_CXX11_FINAL         final
+#  endif
+#  if __has_attribute(noinline)
+#    define MOZ_HAVE_NEVER_INLINE        __attribute__((noinline))
+#  endif
+#  if __has_attribute(noreturn)
+#    define MOZ_HAVE_NORETURN            __attribute__((noreturn))
+#  endif
+#elif defined(__GNUC__)
+#  if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
+#    if MOZ_GCC_VERSION_AT_LEAST(4, 7, 0)
+#      define MOZ_HAVE_CXX11_OVERRIDE
+#      define MOZ_HAVE_CXX11_FINAL       final
+#    endif
+#    if MOZ_GCC_VERSION_AT_LEAST(4, 6, 0)
+#      define MOZ_HAVE_CXX11_CONSTEXPR
+#    endif
+#    if MOZ_GCC_VERSION_AT_LEAST(4, 5, 0)
+#      define MOZ_HAVE_EXPLICIT_CONVERSION
+#    endif
+#    define MOZ_HAVE_CXX11_DELETE
+#  else
+/* __final is a non-C++11 GCC synonym for 'final', per GCC r176655. */
+#    if MOZ_GCC_VERSION_AT_LEAST(4, 7, 0)
+#      define MOZ_HAVE_CXX11_FINAL       __final
+#    endif
+#  endif
+#  define MOZ_HAVE_NEVER_INLINE          __attribute__((noinline))
+#  define MOZ_HAVE_NORETURN              __attribute__((noreturn))
+#elif defined(_MSC_VER)
+#  if _MSC_VER >= 1800
+#    define MOZ_HAVE_CXX11_DELETE
+#  endif
+#  if _MSC_VER >= 1700
+#    define MOZ_HAVE_CXX11_FINAL         final
+#  else
+/* MSVC <= 10 used to spell "final" as "sealed". */
+#    define MOZ_HAVE_CXX11_FINAL         sealed
+#  endif
+#  define MOZ_HAVE_CXX11_OVERRIDE
+#  define MOZ_HAVE_NEVER_INLINE          __declspec(noinline)
+#  define MOZ_HAVE_NORETURN              __declspec(noreturn)
+// Staying away from explicit conversion operators in MSVC for now, see
+// http://stackoverflow.com/questions/20498142/visual-studio-2013-explicit-keyword-bug
+#endif
+/*
+* The MOZ_CONSTEXPR specifier declares that a C++11 compiler can evaluate a
+* function at compile time. A constexpr function cannot examine any values
+* except its arguments and can have no side effects except its return value.
+* The MOZ_CONSTEXPR_VAR specifier tells a C++11 compiler that a variable's
+* value may be computed at compile time.  It should be prefered to just
+* marking variables as MOZ_CONSTEXPR because if the compiler does not support
+* constexpr it will fall back to making the variable const, and some compilers
+* do not accept variables being marked both const and constexpr.
+*/
+#ifdef MOZ_HAVE_CXX11_CONSTEXPR
+#  define MOZ_CONSTEXPR         constexpr
+#  define MOZ_CONSTEXPR_VAR     constexpr
+#else
+#  define MOZ_CONSTEXPR         /* no support */
+#  define MOZ_CONSTEXPR_VAR     const
+#endif
+/*
+* MOZ_EXPLICIT_CONVERSION is a specifier on a type conversion
+* overloaded operator that declares that a C++11 compiler should restrict
+* this operator to allow only explicit type conversions, disallowing
+* implicit conversions.
+*
+* Example:
+*
+*   template<typename T>
+*   class Ptr
+*   {
+*      T* ptr;
+*      MOZ_EXPLICIT_CONVERSION operator bool() const {
+*        return ptr != nullptr;
+*      }
+*   };
+*
+*/
+#ifdef MOZ_HAVE_EXPLICIT_CONVERSION
+#  define MOZ_EXPLICIT_CONVERSION explicit
+#else
+#  define MOZ_EXPLICIT_CONVERSION /* no support */
+#endif
+/*
+* MOZ_NEVER_INLINE is a macro which expands to tell the compiler that the
+* method decorated with it must never be inlined, even if the compiler would
+* otherwise choose to inline the method.  Compilers aren't absolutely
+* guaranteed to support this, but most do.
+*/
+#if defined(MOZ_HAVE_NEVER_INLINE)
+#  define MOZ_NEVER_INLINE      MOZ_HAVE_NEVER_INLINE
+#else
+#  define MOZ_NEVER_INLINE      /* no support */
+#endif
+/*
+* MOZ_NORETURN, specified at the start of a function declaration, indicates
+* that the given function does not return.  (The function definition does not
+* need to be annotated.)
+*
+*   MOZ_NORETURN void abort(const char* msg);
+*
+* This modifier permits the compiler to optimize code assuming a call to such a
+* function will never return.  It also enables the compiler to avoid spurious
+* warnings about not initializing variables, or about any other seemingly-dodgy
+* operations performed after the function returns.
+*
+* This modifier does not affect the corresponding function's linking behavior.
+*/
+#if defined(MOZ_HAVE_NORETURN)
+#  define MOZ_NORETURN          MOZ_HAVE_NORETURN
+#else
+#  define MOZ_NORETURN          /* no support */
+#endif
+/*
+* MOZ_ASAN_BLACKLIST is a macro to tell AddressSanitizer (a compile-time
+* instrumentation shipped with Clang and GCC) to not instrument the annotated
+* function. Furthermore, it will prevent the compiler from inlining the
+* function because inlining currently breaks the blacklisting mechanism of
+* AddressSanitizer.
+*/
+#if defined(__has_feature)
+#  if __has_feature(address_sanitizer)
+#    define MOZ_HAVE_ASAN_BLACKLIST
+#  endif
+#elif defined(__GNUC__)
+#  if defined(__SANITIZE_ADDRESS__)
+#    define MOZ_HAVE_ASAN_BLACKLIST
+#  endif
+#endif
+#if defined(MOZ_HAVE_ASAN_BLACKLIST)
+#  define MOZ_ASAN_BLACKLIST MOZ_NEVER_INLINE __attribute__((no_sanitize_address))
+#else
+#  define MOZ_ASAN_BLACKLIST /* nothing */
+#endif
+/*
+* MOZ_TSAN_BLACKLIST is a macro to tell ThreadSanitizer (a compile-time
+* instrumentation shipped with Clang) to not instrument the annotated function.
+* Furthermore, it will prevent the compiler from inlining the function because
+* inlining currently breaks the blacklisting mechanism of ThreadSanitizer.
+*/
+#if defined(__has_feature)
+#  if __has_feature(thread_sanitizer)
+#    define MOZ_TSAN_BLACKLIST MOZ_NEVER_INLINE __attribute__((no_sanitize_thread))
+#  else
+#    define MOZ_TSAN_BLACKLIST /* nothing */
+#  endif
+#else
+#  define MOZ_TSAN_BLACKLIST /* nothing */
+#endif
+#ifdef __cplusplus
+/*
+* MOZ_DELETE, specified immediately prior to the ';' terminating an undefined-
+* method declaration, attempts to delete that method from the corresponding
+* class.  An attempt to use the method will always produce an error *at compile
+* time* (instead of sometimes as late as link time) when this macro can be
+* implemented.  For example, you can use MOZ_DELETE to produce classes with no
+* implicit copy constructor or assignment operator:
+*
+*   struct NonCopyable
+*   {
+*     private:
+*       NonCopyable(const NonCopyable& other) MOZ_DELETE;
+*       void operator=(const NonCopyable& other) MOZ_DELETE;
+*   };
+*
+* If MOZ_DELETE can't be implemented for the current compiler, use of the
+* annotated method will still cause an error, but the error might occur at link
+* time in some cases rather than at compile time.
+*
+* MOZ_DELETE relies on C++11 functionality not universally implemented.  As a
+* backstop, method declarations using MOZ_DELETE should be private.
+*/
+#if defined(MOZ_HAVE_CXX11_DELETE)
+#  define MOZ_DELETE            = delete
+#else
+#  define MOZ_DELETE            /* no support */
+#endif
+/*
+* MOZ_OVERRIDE explicitly indicates that a virtual member function in a class
+* overrides a member function of a base class, rather than potentially being a
+* new member function.  MOZ_OVERRIDE should be placed immediately before the
+* ';' terminating the member function's declaration, or before '= 0;' if the
+* member function is pure.  If the member function is defined in the class
+* definition, it should appear before the opening brace of the function body.
+*
+*   class Base
+*   {
+*     public:
+*       virtual void f() = 0;
+*   };
+*   class Derived1 : public Base
+*   {
+*     public:
+*       virtual void f() MOZ_OVERRIDE;
+*   };
+*   class Derived2 : public Base
+*   {
+*     public:
+*       virtual void f() MOZ_OVERRIDE = 0;
+*   };
+*   class Derived3 : public Base
+*   {
+*     public:
+*       virtual void f() MOZ_OVERRIDE { }
+*   };
+*
+* In compilers supporting C++11 override controls, MOZ_OVERRIDE *requires* that
+* the function marked with it override a member function of a base class: it
+* is a compile error if it does not.  Otherwise MOZ_OVERRIDE does not affect
+* semantics and merely documents the override relationship to the reader (but
+* of course must still be used correctly to not break C++11 compilers).
+*/
+#if defined(MOZ_HAVE_CXX11_OVERRIDE)
+#  define MOZ_OVERRIDE          override
+#else
+#  define MOZ_OVERRIDE          /* no support */
+#endif
+/*
+* MOZ_FINAL indicates that some functionality cannot be overridden through
+* inheritance.  It can be used to annotate either classes/structs or virtual
+* member functions.
+*
+* To annotate a class/struct with MOZ_FINAL, place MOZ_FINAL immediately after
+* the name of the class, before the list of classes from which it derives (if
+* any) and before its opening brace.  MOZ_FINAL must not be used to annotate
+* unnamed classes or structs.  (With some compilers, and with C++11 proper, the
+* underlying expansion is ambiguous with specifying a class name.)
+*
+*   class Base MOZ_FINAL
+*   {
+*     public:
+*       Base();
+*       ~Base();
+*       virtual void f() { }
+*   };
+*   // This will be an error in some compilers:
+*   class Derived : public Base
+*   {
+*     public:
+*       ~Derived() { }
+*   };
+*
+* One particularly common reason to specify MOZ_FINAL upon a class is to tell
+* the compiler that it's not dangerous for it to have a non-virtual destructor
+* yet have one or more virtual functions, silencing the warning it might emit
+* in this case.  Suppose Base above weren't annotated with MOZ_FINAL.  Because
+* ~Base() is non-virtual, an attempt to delete a Derived* through a Base*
+* wouldn't call ~Derived(), so any cleanup ~Derived() might do wouldn't happen.
+* (Formally C++ says behavior is undefined, but compilers will likely just call
+* ~Base() and not ~Derived().)  Specifying MOZ_FINAL tells the compiler that
+* it's safe for the destructor to be non-virtual.
+*
+* In compilers implementing final controls, it is an error to inherit from a
+* class annotated with MOZ_FINAL.  In other compilers it serves only as
+* documentation.
+*
+* To annotate a virtual member function with MOZ_FINAL, place MOZ_FINAL
+* immediately before the ';' terminating the member function's declaration, or
+* before '= 0;' if the member function is pure.  If the member function is
+* defined in the class definition, it should appear before the opening brace of
+* the function body.  (This placement is identical to that for MOZ_OVERRIDE.
+* If both are used, they should appear in the order 'MOZ_FINAL MOZ_OVERRIDE'
+* for consistency.)
+*
+*   class Base
+*   {
+*     public:
+*       virtual void f() MOZ_FINAL;
+*   };
+*   class Derived
+*   {
+*     public:
+*       // This will be an error in some compilers:
+*       virtual void f();
+*   };
+*
+* In compilers implementing final controls, it is an error for a derived class
+* to override a method annotated with MOZ_FINAL.  In other compilers it serves
+* only as documentation.
+*/
+#if defined(MOZ_HAVE_CXX11_FINAL)
+#  define MOZ_FINAL             MOZ_HAVE_CXX11_FINAL
+#else
+#  define MOZ_FINAL             /* no support */
+#endif
+/**
+* MOZ_WARN_UNUSED_RESULT tells the compiler to emit a warning if a function's
+* return value is not used by the caller.
+*
+* Place this attribute at the very beginning of a function definition. For
+* example, write
+*
+*   MOZ_WARN_UNUSED_RESULT int foo();
+*
+* or
+*
+*   MOZ_WARN_UNUSED_RESULT int foo() { return 42; }
+*/
+#if defined(__GNUC__) || defined(__clang__)
+#  define MOZ_WARN_UNUSED_RESULT __attribute__ ((warn_unused_result))
+#else
+#  define MOZ_WARN_UNUSED_RESULT
+#endif
+/*
+* The following macros are attributes that support the static analysis plugin
+* included with Mozilla, and will be implemented (when such support is enabled)
+* as C++11 attributes. Since such attributes are legal pretty much everywhere
+* and have subtly different semantics depending on their placement, the
+* following is a guide on where to place the attributes.
+*
+* Attributes that apply to a struct or class precede the name of the class:
+* (Note that this is different from the placement of MOZ_FINAL for classes!)
+*
+*   class MOZ_CLASS_ATTRIBUTE SomeClass {};
+*
+* Attributes that apply to functions follow the parentheses and const
+* qualifiers but precede MOZ_FINAL, MOZ_OVERRIDE and the function body:
+*
+*   void DeclaredFunction() MOZ_FUNCTION_ATTRIBUTE;
+*   void SomeFunction() MOZ_FUNCTION_ATTRIBUTE {}
+*   void PureFunction() const MOZ_FUNCTION_ATTRIBUTE = 0;
+*   void OverriddenFunction() MOZ_FUNCTION_ATTIRBUTE MOZ_OVERRIDE;
+*
+* Attributes that apply to variables or parameters follow the variable's name:
+*
+*   int variable MOZ_VARIABLE_ATTRIBUTE;
+*
+* Attributes that apply to types follow the type name:
+*
+*   typedef int MOZ_TYPE_ATTRIBUTE MagicInt;
+*   int MOZ_TYPE_ATTRIBUTE someVariable;
+*   int * MOZ_TYPE_ATTRIBUTE magicPtrInt;
+*   int MOZ_TYPE_ATTRIBUTE * ptrToMagicInt;
+*
+* Attributes that apply to statements precede the statement:
+*
+*   MOZ_IF_ATTRIBUTE if (x == 0)
+*   MOZ_DO_ATTRIBUTE do { } while(0);
+*
+* Attributes that apply to labels precede the label:
+*
+*   MOZ_LABEL_ATTRIBUTE target:
+*     goto target;
+*   MOZ_CASE_ATTRIBUTE case 5:
+*   MOZ_DEFAULT_ATTRIBUTE default:
+*
+* The static analyses that are performed by the plugin are as follows:
+*
+* MOZ_MUST_OVERRIDE: Applies to all C++ member functions. All immediate
+*   subclasses must provide an exact override of this method; if a subclass
+*   does not override this method, the compiler will emit an error. This
+*   attribute is not limited to virtual methods, so if it is applied to a
+*   nonvirtual method and the subclass does not provide an equivalent
+*   definition, the compiler will emit an error.
+* MOZ_STACK_CLASS: Applies to all classes. Any class with this annotation is
+*   expected to live on the stack, so it is a compile-time error to use it, or
+*   an array of such objects, as a global or static variable, or as the type of
+*   a new expression (unless placement new is being used). If a member of
+*   another class uses this class, or if another class inherits from this
+*   class, then it is considered to be a stack class as well, although this
+*   attribute need not be provided in such cases.
+* MOZ_NONHEAP_CLASS: Applies to all classes. Any class with this annotation is
+*   expected to live on the stack or in static storage, so it is a compile-time
+*   error to use it, or an array of such objects, as the type of a new
+*   expression (unless placement new is being used). If a member of another
+*   class uses this class, or if another class inherits from this class, then
+*   it is considered to be a non-heap class as well, although this attribute
+*   need not be provided in such cases.
+* MOZ_HEAP_ALLOCATOR: Applies to any function. This indicates that the return
+*   value is allocated on the heap, and will as a result check such allocations
+*   during MOZ_STACK_CLASS and MOZ_NONHEAP_CLASS annotation checking.
+*/
+#ifdef MOZ_CLANG_PLUGIN
+#  define MOZ_MUST_OVERRIDE __attribute__((annotate("moz_must_override")))
+#  define MOZ_STACK_CLASS __attribute__((annotate("moz_stack_class")))
+#  define MOZ_NONHEAP_CLASS __attribute__((annotate("moz_nonheap_class")))
+/*
+* It turns out that clang doesn't like void func() __attribute__ {} without a
+* warning, so use pragmas to disable the warning. This code won't work on GCC
+* anyways, so the warning is safe to ignore.
+*/
+#  define MOZ_HEAP_ALLOCATOR \
+_Pragma("clang diagnostic push") \
+_Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+__attribute__((annotate("moz_heap_allocator"))) \
+_Pragma("clang diagnostic pop")
+#else
+#  define MOZ_MUST_OVERRIDE /* nothing */
+#  define MOZ_STACK_CLASS /* nothing */
+#  define MOZ_NONHEAP_CLASS /* nothing */
+#  define MOZ_HEAP_ALLOCATOR /* nothing */
+#endif /* MOZ_CLANG_PLUGIN */
+/*
+* MOZ_THIS_IN_INITIALIZER_LIST is used to avoid a warning when we know that
+* it's safe to use 'this' in an initializer list.
+*/
+#ifdef _MSC_VER
+#  define MOZ_THIS_IN_INITIALIZER_LIST() \
+__pragma(warning(push)) \
+__pragma(warning(disable:4355)) \
+this \
+__pragma(warning(pop))
+#else
+#  define MOZ_THIS_IN_INITIALIZER_LIST() this
+#endif
+#endif /* __cplusplus */
+#endif /* mozilla_Attributes_h */

The Tor Browser / file comparison

comparison: mfbt/Attributes.h

mfbt/Attributes.h