X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fbitboard.cpp;h=c56d8e902ec4fb794098c0faf99b6db2ba58718f;hp=794f54cf68326cf92fec7ff172a1f1959eaa62d2;hb=2aec8fb9560dc1fc266437ad4276db2b0381d9d5;hpb=5c5af4fa6533e22fb56dd22985cf2b3938efde6c

diff --git a/src/bitboard.cpp b/src/bitboard.cpp
index 794f54cf..c56d8e90 100644
--- a/src/bitboard.cpp
+++ b/src/bitboard.cpp
@@ -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-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2012 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
@@ -38,11 +38,10 @@ int BShifts[64];
 Bitboard SetMaskBB[65];
 Bitboard ClearMaskBB[65];
 
-Bitboard SquaresByColorBB[2];
 Bitboard FileBB[8];
 Bitboard RankBB[8];
-Bitboard NeighboringFilesBB[8];
-Bitboard ThisAndNeighboringFilesBB[8];
+Bitboard AdjacentFilesBB[8];
+Bitboard ThisAndAdjacentFilesBB[8];
 Bitboard InFrontBB[2][8];
 Bitboard StepAttacksBB[16][64];
 Bitboard BetweenBB[64][64];
@@ -50,9 +49,7 @@ Bitboard SquaresInFrontMask[2][64];
 Bitboard PassedPawnMask[2][64];
 Bitboard AttackSpanMask[2][64];
 
-Bitboard BishopPseudoAttacks[64];
-Bitboard RookPseudoAttacks[64];
-Bitboard QueenPseudoAttacks[64];
+Bitboard PseudoAttacks[6][64];
 
 uint8_t BitCount8Bit[256];
 int SquareDistance[64][64];
@@ -155,10 +152,7 @@ Square pop_1st_bit(Bitboard* bb) {
 void bitboards_init() {
 
   for (Bitboard b = 0; b < 256; b++)
-      BitCount8Bit[b] = (uint8_t)count_1s<CNT32_MAX15>(b);
-
-  SquaresByColorBB[DARK]  =  0xAA55AA55AA55AA55ULL;
-  SquaresByColorBB[LIGHT] = ~SquaresByColorBB[DARK];
+      BitCount8Bit[b] = (uint8_t)popcount<Max15>(b);
 
   for (Square s = SQ_A1; s <= SQ_H8; s++)
   {
@@ -166,7 +160,7 @@ void bitboards_init() {
       ClearMaskBB[s] = ~SetMaskBB[s];
   }
 
-  ClearMaskBB[SQ_NONE] = ~EmptyBoardBB;
+  ClearMaskBB[SQ_NONE] = ~0ULL;
 
   FileBB[FILE_A] = FileABB;
   RankBB[RANK_1] = Rank1BB;
@@ -179,8 +173,8 @@ void bitboards_init() {
 
   for (int f = FILE_A; f <= FILE_H; f++)
   {
-      NeighboringFilesBB[f] = (f > FILE_A ? FileBB[f - 1] : 0) | (f < FILE_H ? FileBB[f + 1] : 0);
-      ThisAndNeighboringFilesBB[f] = FileBB[f] | NeighboringFilesBB[f];
+      AdjacentFilesBB[f] = (f > FILE_A ? FileBB[f - 1] : 0) | (f < FILE_H ? FileBB[f + 1] : 0);
+      ThisAndAdjacentFilesBB[f] = FileBB[f] | AdjacentFilesBB[f];
   }
 
   for (int rw = RANK_7, rb = RANK_2; rw >= RANK_1; rw--, rb++)
@@ -193,8 +187,8 @@ void bitboards_init() {
       for (Square s = SQ_A1; s <= SQ_H8; s++)
       {
           SquaresInFrontMask[c][s] = in_front_bb(c, s) & file_bb(s);
-          PassedPawnMask[c][s]     = in_front_bb(c, s) & this_and_neighboring_files_bb(file_of(s));
-          AttackSpanMask[c][s]     = in_front_bb(c, s) & neighboring_files_bb(file_of(s));
+          PassedPawnMask[c][s]     = in_front_bb(c, s) & this_and_adjacent_files_bb(file_of(s));
+          AttackSpanMask[c][s]     = in_front_bb(c, s) & adjacent_files_bb(file_of(s));
       }
 
   for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
@@ -202,12 +196,12 @@ void bitboards_init() {
           SquareDistance[s1][s2] = std::max(file_distance(s1, s2), rank_distance(s1, s2));
 
   for (int i = 0; i < 64; i++)
-      if (!CpuIs64Bit) // Matt Taylor's folding trick for 32 bit systems
+      if (!Is64Bit) // Matt Taylor's folding trick for 32 bit systems
       {
           Bitboard b = 1ULL << i;
           b ^= b - 1;
           b ^= b >> 32;
-          BSFTable[uint32_t(b * 0x783A9B23) >> 26] = i;
+          BSFTable[(uint32_t)(b * 0x783A9B23) >> 26] = i;
       }
       else
           BSFTable[((1ULL << i) * 0x218A392CD3D5DBFULL) >> 58] = i;
@@ -231,14 +225,14 @@ void bitboards_init() {
 
   for (Square s = SQ_A1; s <= SQ_H8; s++)
   {
-      BishopPseudoAttacks[s] = bishop_attacks_bb(s, EmptyBoardBB);
-      RookPseudoAttacks[s]   = rook_attacks_bb(s, EmptyBoardBB);
-      QueenPseudoAttacks[s]  = queen_attacks_bb(s, EmptyBoardBB);
+      PseudoAttacks[BISHOP][s] = bishop_attacks_bb(s, 0);
+      PseudoAttacks[ROOK][s]   = rook_attacks_bb(s, 0);
+      PseudoAttacks[QUEEN][s]  = PseudoAttacks[BISHOP][s] | PseudoAttacks[ROOK][s];
   }
 
   for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
       for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
-          if (bit_is_set(QueenPseudoAttacks[s1], s2))
+          if (bit_is_set(PseudoAttacks[QUEEN][s1], s2))
           {
               Square delta = (s2 - s1) / square_distance(s1, s2);
 
@@ -324,8 +318,8 @@ namespace {
         // all the attacks for each possible subset of the mask and so is 2 power
         // the number of 1s of the mask. Hence we deduce the size of the shift to
         // apply to the 64 or 32 bits word to get the index.
-        masks[s]  = sliding_attacks(pt, s, EmptyBoardBB) & ~edges;
-        shifts[s] = (CpuIs64Bit ? 64 : 32) - count_1s<CNT32_MAX15>(masks[s]);
+        masks[s]  = sliding_attacks(pt, s, 0) & ~edges;
+        shifts[s] = (Is64Bit ? 64 : 32) - popcount<Max15>(masks[s]);
 
         // Use Carry-Rippler trick to enumerate all subsets of masks[s] and
         // store the corresponding sliding attacks bitboard in reference[].
@@ -341,7 +335,7 @@ namespace {
         if (s < SQ_H8)
             attacks[s + 1] = attacks[s] + size;
 
-        booster = MagicBoosters[CpuIs64Bit][rank_of(s)];
+        booster = MagicBoosters[Is64Bit][rank_of(s)];
 
         // Find a magic for square 's' picking up an (almost) random number
         // until we find the one that passes the verification test.