X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fbitboard.h;h=d1cf40f25b0e0f480f04c488babe248805d4442f;hp=8c6a7007e7263b069ebea469ac687c0e327d7fc6;hb=72c7595f8ac72c7831ee319b8b0bc46404c5fc27;hpb=d3600c39a745179ed6b094b305d0645e83a1ee86 diff --git a/src/bitboard.h b/src/bitboard.h index 8c6a7007..d1cf40f2 100644 --- a/src/bitboard.h +++ b/src/bitboard.h @@ -7,12 +7,13 @@ it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. - + + Stockfish 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, see . */ @@ -30,6 +31,10 @@ // platform macros defined below #define AUTO_CONFIGURATION +// Quiet a warning on Intel compiler +#if !defined(__SIZEOF_INT__ ) +#define __SIZEOF_INT__ 0 +#endif // Check for 64 bits for different compilers: Intel, MSVC and gcc #if defined(__x86_64) || defined(_WIN64) || (__SIZEOF_INT__ > 4) @@ -39,7 +44,7 @@ #if !defined(AUTO_CONFIGURATION) || defined(IS_64BIT) //#define USE_COMPACT_ROOK_ATTACKS -//#define USE_32BIT_ATTACKS +//#define USE_32BIT_ATTACKS #define USE_FOLDED_BITSCAN #define BITCOUNT_SWAR_64 @@ -48,7 +53,7 @@ #else -#define USE_32BIT_ATTACKS +#define USE_32BIT_ATTACKS #define USE_FOLDED_BITSCAN #define BITCOUNT_SWAR_32 @@ -79,8 +84,7 @@ const Bitboard EmptyBoardBB = 0ULL; const Bitboard WhiteSquaresBB = 0x55AA55AA55AA55AAULL; const Bitboard BlackSquaresBB = 0xAA55AA55AA55AA55ULL; - -extern const Bitboard SquaresByColorBB[2]; +const Bitboard SquaresByColorBB[2] = { BlackSquaresBB, WhiteSquaresBB }; const Bitboard FileABB = 0x0101010101010101ULL; const Bitboard FileBBB = 0x0202020202020202ULL; @@ -91,9 +95,21 @@ const Bitboard FileFBB = 0x2020202020202020ULL; const Bitboard FileGBB = 0x4040404040404040ULL; const Bitboard FileHBB = 0x8080808080808080ULL; -extern const Bitboard FileBB[8]; -extern const Bitboard NeighboringFilesBB[8]; -extern const Bitboard ThisAndNeighboringFilesBB[8]; +const Bitboard FileBB[8] = { + FileABB, FileBBB, FileCBB, FileDBB, FileEBB, FileFBB, FileGBB, FileHBB +}; + +const Bitboard NeighboringFilesBB[8] = { + FileBBB, FileABB|FileCBB, FileBBB|FileDBB, FileCBB|FileEBB, + FileDBB|FileFBB, FileEBB|FileGBB, FileFBB|FileHBB, FileGBB +}; + +const Bitboard ThisAndNeighboringFilesBB[8] = { + FileABB|FileBBB, FileABB|FileBBB|FileCBB, + FileBBB|FileCBB|FileDBB, FileCBB|FileDBB|FileEBB, + FileDBB|FileEBB|FileFBB, FileEBB|FileFBB|FileGBB, + FileFBB|FileGBB|FileHBB, FileGBB|FileHBB +}; const Bitboard Rank1BB = 0xFFULL; const Bitboard Rank2BB = 0xFF00ULL; @@ -104,12 +120,38 @@ const Bitboard Rank6BB = 0xFF0000000000ULL; const Bitboard Rank7BB = 0xFF000000000000ULL; const Bitboard Rank8BB = 0xFF00000000000000ULL; -extern const Bitboard RankBB[8]; -extern const Bitboard RelativeRankBB[2][8]; -extern const Bitboard InFrontBB[2][8]; - -extern Bitboard SetMaskBB[64]; -extern Bitboard ClearMaskBB[64]; +const Bitboard RankBB[8] = { + Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB +}; + +const Bitboard RelativeRankBB[2][8] = { + { Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB }, + { Rank8BB, Rank7BB, Rank6BB, Rank5BB, Rank4BB, Rank3BB, Rank2BB, Rank1BB } +}; + +const Bitboard InFrontBB[2][8] = { + { Rank2BB | Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB, + Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB, + Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB, + Rank5BB | Rank6BB | Rank7BB | Rank8BB, + Rank6BB | Rank7BB | Rank8BB, + Rank7BB | Rank8BB, + Rank8BB, + EmptyBoardBB + }, + { EmptyBoardBB, + Rank1BB, + Rank2BB | Rank1BB, + Rank3BB | Rank2BB | Rank1BB, + Rank4BB | Rank3BB | Rank2BB | Rank1BB, + Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB, + Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB, + Rank7BB | Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB + } +}; + +extern Bitboard SetMaskBB[65]; +extern Bitboard ClearMaskBB[65]; extern Bitboard StepAttackBB[16][64]; extern Bitboard RayBB[64][8]; @@ -119,16 +161,20 @@ extern Bitboard PassedPawnMask[2][64]; extern Bitboard OutpostMask[2][64]; #if defined(USE_COMPACT_ROOK_ATTACKS) + extern Bitboard RankAttacks[8][64], FileAttacks[8][64]; + #else + extern const uint64_t RMult[64]; extern const int RShift[64]; extern Bitboard RMask[64]; extern int RAttackIndex[64]; extern Bitboard RAttacks[0x19000]; + #endif // defined(USE_COMPACT_ROOK_ATTACKS) -extern const uint64_t BMult[64]; +extern const uint64_t BMult[64]; extern const int BShift[64]; extern Bitboard BMask[64]; extern int BAttackIndex[64]; @@ -143,29 +189,19 @@ extern Bitboard QueenPseudoAttacks[64]; //// Inline functions //// -/// Functions for testing whether a given bit is set in a bitboard, and for +/// Functions for testing whether a given bit is set in a bitboard, and for /// setting and clearing bits. -inline Bitboard set_mask_bb(Square s) { - // return 1ULL << s; - return SetMaskBB[s]; -} - -inline Bitboard clear_mask_bb(Square s) { - // return ~set_mask_bb(s); - return ClearMaskBB[s]; -} - inline Bitboard bit_is_set(Bitboard b, Square s) { - return b & set_mask_bb(s); + return b & SetMaskBB[s]; } inline void set_bit(Bitboard *b, Square s) { - *b |= set_mask_bb(s); + *b |= SetMaskBB[s]; } inline void clear_bit(Bitboard *b, Square s) { - *b &= clear_mask_bb(s); + *b &= ClearMaskBB[s]; } @@ -200,7 +236,7 @@ inline Bitboard neighboring_files_bb(File f) { inline Bitboard neighboring_files_bb(Square s) { return neighboring_files_bb(square_file(s)); } - + /// this_and_neighboring_files_bb takes a file or a square as input, and /// returns a bitboard representing all squares on the given and neighboring @@ -217,7 +253,7 @@ inline Bitboard this_and_neighboring_files_bb(Square s) { /// relative_rank_bb() takes a color and a rank as input, and returns a bitboard /// representing all squares on the given rank from the given color's point of -/// view. For instance, relative_rank_bb(WHITE, 7) gives all squares on the +/// view. For instance, relative_rank_bb(WHITE, 7) gives all squares on the /// 7th rank, while relative_rank_bb(BLACK, 7) gives all squares on the 2nd /// rank. @@ -241,6 +277,19 @@ inline Bitboard in_front_bb(Color c, Square s) { } +/// behind_bb() takes a color and a rank or square as input, and returns a +/// bitboard representing all the squares on all ranks behind of the rank +/// (or square), from the given color's point of view. + +inline Bitboard behind_bb(Color c, Rank r) { + return InFrontBB[opposite_color(c)][r]; +} + +inline Bitboard behind_bb(Color c, Square s) { + return in_front_bb(opposite_color(c), square_rank(s)); +} + + /// ray_bb() gives a bitboard representing all squares along the ray in a /// given direction from a given square. @@ -275,9 +324,9 @@ inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) { inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) { Bitboard b = blockers & RMask[s]; - return RAttacks[RAttackIndex[s] + + return RAttacks[RAttackIndex[s] + (unsigned(int(b) * int(RMult[s]) ^ - int(b >> 32) * int(RMult[s] >> 32)) + int(b >> 32) * int(RMult[s] >> 32)) >> RShift[s])]; } @@ -294,9 +343,9 @@ inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) { inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) { Bitboard b = blockers & BMask[s]; - return BAttacks[BAttackIndex[s] + + return BAttacks[BAttackIndex[s] + (unsigned(int(b) * int(BMult[s]) ^ - int(b >> 32) * int(BMult[s] >> 32)) + int(b >> 32) * int(BMult[s] >> 32)) >> BShift[s])]; } @@ -324,9 +373,9 @@ inline Bitboard squares_between(Square s1, Square s2) { } -/// squares_in_front_of takes a color and a square as input, and returns a +/// squares_in_front_of takes a color and a square as input, and returns a /// bitboard representing all squares along the line in front of the square, -/// from the point of view of the given color. For instance, +/// from the point of view of the given color. For instance, /// squares_in_front_of(BLACK, SQ_E4) returns a bitboard with the squares /// e3, e2 and e1 set. @@ -343,8 +392,8 @@ inline Bitboard squares_behind(Color c, Square s) { } -/// passed_pawn_mask takes a color and a square as input, and returns a -/// bitboard mask which can be used to test if a pawn of the given color on +/// passed_pawn_mask takes a color and a square as input, and returns a +/// bitboard mask which can be used to test if a pawn of the given color on /// the given square is a passed pawn. inline Bitboard passed_pawn_mask(Color c, Square s) { @@ -361,7 +410,7 @@ inline Bitboard outpost_mask(Color c, Square s) { } -/// isolated_pawn_mask takes a square as input, and returns a bitboard mask +/// isolated_pawn_mask takes a square as input, and returns a bitboard mask /// which can be used to test whether a pawn on the given square is isolated. inline Bitboard isolated_pawn_mask(Square s) { @@ -387,24 +436,25 @@ inline int count_1s_max_15(Bitboard b) { inline int count_1s(Bitboard b) { unsigned w = unsigned(b >> 32), v = unsigned(b); - v = v - ((v >> 1) & 0x55555555); - w = w - ((w >> 1) & 0x55555555); - v = (v & 0x33333333) + ((v >> 2) & 0x33333333); - w = (w & 0x33333333) + ((w >> 2) & 0x33333333); - v = (v + (v >> 4)) & 0x0F0F0F0F; - w = (w + (w >> 4)) & 0x0F0F0F0F; - v = ((v+w) * 0x01010101) >> 24; // mul is fast on amd procs - return int(v); + v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits + w -= (w >> 1) & 0x55555555; + v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits + w = ((w >> 2) & 0x33333333) + (w & 0x33333333); + v = ((v >> 4) + v) & 0x0F0F0F0F; // 0-8 in 8 bits + v += (((w >> 4) + w) & 0x0F0F0F0F); // 0-16 in 8 bits + v *= 0x01010101; // mul is fast on amd procs + return int(v >> 24); } inline int count_1s_max_15(Bitboard b) { unsigned w = unsigned(b >> 32), v = unsigned(b); - v = v - ((v >> 1) & 0x55555555); - w = w - ((w >> 1) & 0x55555555); - v = (v & 0x33333333) + ((v >> 2) & 0x33333333); - w = (w & 0x33333333) + ((w >> 2) & 0x33333333); - v = ((v+w) * 0x11111111) >> 28; - return int(v); + v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits + w -= (w >> 1) & 0x55555555; + v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits + w = ((w >> 2) & 0x33333333) + (w & 0x33333333); + v += w; // 0-8 in 4 bits + v *= 0x11111111; + return int(v >> 28); } #elif defined(BITCOUNT_SWAR_64)