X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Ftypes.h;h=f6d993d07cf56be595331b9ce3ed5f892559a63b;hp=95e3f6eeb46c4357b297f308f63f666bb5679757;hb=85a7456bd7e8a1a01cdbfa8f4b6fb563d15a37c6;hpb=f3d0b76feb2f27e78832950e54702e81901ddbbc diff --git a/src/types.h b/src/types.h index 95e3f6ee..f6d993d0 100644 --- a/src/types.h +++ b/src/types.h @@ -1,7 +1,7 @@ /* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2009 Marco Costalba + Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad Stockfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -33,7 +33,7 @@ typedef __int16 int16; typedef unsigned __int16 uint16_t; typedef __int32 int32_t; typedef unsigned __int32 uint32_t; -typedef __int64 int64; +typedef __int64 int64_t; typedef unsigned __int64 uint64_t; typedef __int16 int16_t; @@ -49,21 +49,124 @@ typedef uint64_t Bitboard; //// -//// Compiler specific defines +//// Configuration //// -// Quiet a warning on Intel compiler -#if !defined(__SIZEOF_INT__ ) -#define __SIZEOF_INT__ 0 -#endif +//// For Linux and OSX configuration is done automatically using Makefile. +//// To get started type "make help". +//// +//// For windows part of the configuration is detected automatically, but +//// some switches need to be set manually: +//// +//// -DNDEBUG | Disable debugging mode. Use always. +//// +//// -DNO_PREFETCH | Disable use of prefetch asm-instruction. A must if you want the +//// | executable to run on some very old machines. +//// +//// -DUSE_POPCNT | Add runtime support for use of popcnt asm-instruction. +//// | Works only in 64-bit mode. For compiling requires hardware +//// | with popcnt support. Around 4% speed-up. -// Check for 64 bits for different compilers: Intel, MSVC and gcc -#if defined(__x86_64) || defined(_M_X64) || defined(_WIN64) || (__SIZEOF_INT__ > 4) +// Automatic detection for 64-bit under Windows +#if defined(_WIN64) #define IS_64BIT #endif -#if defined(IS_64BIT) && (defined(__GNUC__) || defined(__INTEL_COMPILER)) +// Automatic detection for use of bsfq asm-instruction under Windows. +// Works only in 64-bit mode. Does not work with MSVC. +#if defined(_WIN64) && defined(__INTEL_COMPILER) #define USE_BSFQ #endif +// Cache line alignment specification +#if defined(_MSC_VER) || defined(__INTEL_COMPILER) +#define CACHE_LINE_ALIGNMENT __declspec(align(64)) +#else +#define CACHE_LINE_ALIGNMENT __attribute__ ((aligned(64))) +#endif + +// Define a __cpuid() function for gcc compilers, for Intel and MSVC +// is already available as an intrinsic. +#if defined(_MSC_VER) +#include +#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) +inline void __cpuid(int CPUInfo[4], int InfoType) +{ + int* eax = CPUInfo + 0; + int* ebx = CPUInfo + 1; + int* ecx = CPUInfo + 2; + int* edx = CPUInfo + 3; + + *eax = InfoType; + *ecx = 0; + __asm__("cpuid" : "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx) + : "0" (*eax), "2" (*ecx)); +} +#else +inline void __cpuid(int CPUInfo[4], int) +{ + CPUInfo[0] = CPUInfo[1] = CPUInfo[2] = CPUInfo[3] = 0; +} +#endif + + +// Templetized operators used by enum types like Depth, Piece, Square and so on. +// We don't want to write the same inline for each different enum. Note that we +// pass by value to silence scaring warnings when using volatiles. +// Because these templates override common operators and are included in all the +// files, there is a possibility that the compiler silently performs some unwanted +// overrides. To avoid possible very nasty bugs the templates are disabled by default +// and must be enabled for each type on a case by case base. The enabling trick +// uses template specialization, namely we just declare following struct. +template struct TempletizedOperator; + +// Then to enable the enum type we use following macro that defines a specialization +// of TempletizedOperator for the given enum T. Here is defined typedef Not_Enabled. +// Name of typedef is chosen to produce somewhat informative compile error messages. +#define ENABLE_OPERATORS_ON(T) \ + template<> struct TempletizedOperator { typedef T Not_Enabled; } + +// Finally we use macro OK(T) to check if type T is enabled. The macro simply +// tries to use Not_Enabled, if was not previously defined a compile error occurs. +// The check is done fully at compile time and there is zero overhead at runtime. +#define OK(T) typedef typename TempletizedOperator::Not_Enabled Type + +template +inline T operator+ (const T d1, const T d2) { OK(T); return T(int(d1) + int(d2)); } + +template +inline T operator- (const T d1, const T d2) { OK(T); return T(int(d1) - int(d2)); } + +template +inline T operator* (int i, const T d) { OK(T); return T(i * int(d)); } + +template +inline T operator* (const T d, int i) { OK(T); return T(int(d) * i); } + +template +inline T operator/ (const T d, int i) { OK(T); return T(int(d) / i); } + +template +inline T operator- (const T d) { OK(T); return T(-int(d)); } + +template +inline T operator++ (T& d, int) { OK(T); d = T(int(d) + 1); return d; } + +template +inline T operator-- (T& d, int) { OK(T); d = T(int(d) - 1); return d; } + +template +inline void operator+= (T& d1, const T d2) { OK(T); d1 = d1 + d2; } + +template +inline void operator-= (T& d1, const T d2) { OK(T); d1 = d1 - d2; } + +template +inline void operator*= (T& d, int i) { OK(T); d = T(int(d) * i); } + +template +inline void operator/= (T& d, int i) { OK(T); d = T(int(d) / i); } + +#undef OK + #endif // !defined(TYPES_H_INCLUDED)