compiler.h

/* MLPACK 0.2
 *
 * Copyright (c) 2008, 2009 Alexander Gray,
 *                          Garry Boyer,
 *                          Ryan Riegel,
 *                          Nikolaos Vasiloglou,
 *                          Dongryeol Lee,
 *                          Chip Mappus, 
 *                          Nishant Mehta,
 *                          Hua Ouyang,
 *                          Parikshit Ram,
 *                          Long Tran,
 *                          Wee Chin Wong
 *
 * Copyright (c) 2008, 2009 Georgia Institute of Technology
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */
#ifndef BASE_COMPILER_H
#define BASE_COMPILER_H

#ifdef __cplusplus
#define EXTERN_C_BEGIN extern "C" {
#else
#define EXTERN_C_BEGIN
#endif

#ifdef __cplusplus
#define EXTERN_C_END };
#else
#define EXTERN_C_END
#endif

/* Check for availability of compiler optimizations and directives. */
#if !defined(__GNUC__) && !defined(__INTEL_COMPILER)
#warning Unknown compiler; optimizations and directives disabled.
#ifndef NO_COMPILER_DEFS
#define NO_COMPILER_DEFS
#endif
#endif



#ifndef NO_COMPILER_DEFS
#define expect(expr, value) (__builtin_expect((expr), (value)))
#else
#define expect(expr, value) (expr)
#endif

#define likely(cond) expect(!!(cond), 1)

#define unlikely(cond) expect(!!(cond), 0)

#ifndef NO_COMPILER_DEFS
#define IS_CONST_EXPR(expr) (__builtin_constant_p(expr))
#else
#define IS_CONST_EXPR(expr) 0
#endif



#ifndef NO_COMPILER_DEFS
#define COMPILER_NO_RETURN __attribute__((noreturn))
#else
#define COMPILER_NO_RETURN
#endif

#ifndef NO_COMPILER_DEFS
#define COMPILER_PRINTF(format_arg, dotdotdot_arg) \
    __attribute__((format(printf, format_arg, dotdotdot_arg)))
#else
#define COMPILER_PRINTF(format_arg, dotdotdot_arg)
#endif

#ifndef NO_COMPILER_DEFS
#define COMPILER_FUNCTIONAL __attribute__((const))
#else
#define COMPILER_FUNCTIONAL
#endif

#ifndef NO_COMPILER_DEFS
#define COMPILER_NO_INLINE __attribute__((noinline))
#else
#define COMPILER_NO_INLINE
#endif

#if !defined(NO_COMPILER_DEFS) && !defined(NO_DEPRECATION_WARNINGS)
#define COMPILER_DEPRECATED __attribute__((deprecated))
#else
#define COMPILER_DEPRECATED
#endif

#if !defined(NO_COMPILER_DEFS) && !defined(NO_DEPRECATION_WARNINGS)
#define COMPILER_DEPRECATED_MSG(msg) COMPILER_DEPRECATED
#else
#define COMPILER_DEPRECATED_MSG(msg)
#endif



#ifdef __cplusplus
#define strideof(T) (compiler_strideof<T>::STRIDE)
template <typename T>
struct compiler_strideof {
  struct S {T x; char c;};
  /* The compiler gives this stride in a struct. */
  static const int NATURAL_STRIDE =
      (sizeof(S) > sizeof(T)) ? (sizeof(S) - sizeof(T)) : sizeof(T);
  /* This power-of-two stride is likely to be faster. */
  static const int PREFERRED_STRIDE =
      sizeof(T) >= 8 ? 8 : sizeof(T) >= 4 ? 4 : 0;
  /* Use the larger of the two. */
  enum { STRIDE = NATURAL_STRIDE > PREFERRED_STRIDE
      ? NATURAL_STRIDE : PREFERRED_STRIDE };
};
#else
#define strideof(T) (sizeof(struct {T x; char c;}) - sizeof(T))
#endif

#define stride_align(num, T) \
    (((size_t)(num) + strideof(T) - 1) / strideof(T) * strideof(T))

#define MAX_STRIDE 16 /* TODO: confirm correct */

#define stride_align_max(num) \
    (((size_t)(num) + MAX_STRIDE - 1) & ~(size_t)(MAX_STRIDE - 1))

/* Fill possibly lacking definition for member memory offsets. */
#ifndef offsetof
#define offsetof(S, member) ((size_t)(&((S const *)0)->member))
#endif



#ifdef __cplusplus
#define COMPILER_CAST(cast, T, val) (cast< T >(val))
#else
#define COMPILER_CAST(cast, T, val) ((T)(val))
#endif

#define STATIC_CAST(T, val) COMPILER_CAST(static_cast, T, val)

#define REINTERPRET_CAST(T, val) COMPILER_CAST(reinterpret_cast, T, val)



#ifdef __cplusplus
#define CONST_REF const &
#else
#define CONST_REF const *
#endif

#ifdef __cplusplus
#define REF &
#else
#define REF *
#endif



#endif /* BASE_COMPILER_H */