X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fbitboard.cpp;h=82608eab4f1ba1e937dc4dd56b29a73b5b2a6e20;hp=03080d15657500ffec995248646bb4816d7fcc83;hb=c2cd75843eb0b6a29ce291fc3ac041b5a082afbc;hpb=9793fa1906cc204fc2a520ebb8dd3093f7fc7e40

diff --git a/src/bitboard.cpp b/src/bitboard.cpp
index 03080d15..82608eab 100644
--- a/src/bitboard.cpp
+++ b/src/bitboard.cpp
@@ -23,6 +23,7 @@
 
 #include "bitboard.h"
 #include "bitcount.h"
+#include "misc.h"
 #include "rkiss.h"
 
 CACHE_LINE_ALIGNMENT
@@ -55,10 +56,14 @@ int SquareDistance[64][64];
 
 namespace {
 
+  // De Bruijn sequences. See chessprogramming.wikispaces.com/BitScan
+  const uint64_t DeBruijn_64 = 0x3F79D71B4CB0A89ULL;
+  const uint32_t DeBruijn_32 = 0x783A9B23;
+
   CACHE_LINE_ALIGNMENT
 
-  int BSFTable[64];
   int MS1BTable[256];
+  Square BSFTable[64];
   Bitboard RTable[0x19000]; // Storage space for rook attacks
   Bitboard BTable[0x1480];  // Storage space for bishop attacks
   uint8_t BitCount8Bit[256];
@@ -67,42 +72,31 @@ namespace {
 
   void init_magics(Bitboard table[], Bitboard* attacks[], Bitboard magics[],
                    Bitboard masks[], unsigned shifts[], Square deltas[], Fn index);
-}
 
-/// first_1() finds the least significant nonzero bit in a nonzero bitboard.
-/// pop_1st_bit() finds and clears the least significant nonzero bit in a
-/// nonzero bitboard.
+  FORCE_INLINE unsigned bsf_index(Bitboard b) {
 
-#if defined(IS_64BIT) && !defined(USE_BSFQ)
-
-Square first_1(Bitboard b) {
-  return Square(BSFTable[((b & -b) * 0x218A392CD3D5DBFULL) >> 58]);
+    // Matt Taylor's folding for 32 bit systems, extended to 64 bits by Kim Walisch
+    b ^= (b - 1);
+    return Is64Bit ? (b * DeBruijn_64) >> 58
+                   : ((unsigned(b) ^ unsigned(b >> 32)) * DeBruijn_32) >> 26;
+  }
 }
 
-Square pop_1st_bit(Bitboard* b) {
-  Bitboard bb = *b;
-  *b &= (*b - 1);
-  return Square(BSFTable[((bb & -bb) * 0x218A392CD3D5DBFULL) >> 58]);
-}
+/// lsb()/msb() finds the least/most significant bit in a nonzero bitboard.
+/// pop_lsb() finds and clears the least significant bit in a nonzero bitboard.
 
-#elif !defined(USE_BSFQ)
+#if !defined(USE_BSFQ)
 
-Square first_1(Bitboard b) {
-  b ^= (b - 1);
-  uint32_t fold = unsigned(b) ^ unsigned(b >> 32);
-  return Square(BSFTable[(fold * 0x783A9B23) >> 26]);
-}
+Square lsb(Bitboard b) { return BSFTable[bsf_index(b)]; }
 
-Square pop_1st_bit(Bitboard* b) {
+Square pop_lsb(Bitboard* b) {
 
   Bitboard bb = *b;
   *b = bb & (bb - 1);
-  bb ^= (bb - 1);
-  uint32_t fold = unsigned(bb) ^ unsigned(bb >> 32);
-  return Square(BSFTable[(fold * 0x783A9B23) >> 26]);
+  return BSFTable[bsf_index(bb)];
 }
 
-Square last_1(Bitboard b) {
+Square msb(Bitboard b) {
 
   unsigned b32;
   int result = 0;
@@ -127,7 +121,7 @@ Square last_1(Bitboard b) {
       result += 8;
   }
 
-  return Square(result + MS1BTable[b32]);
+  return (Square)(result + MS1BTable[b32]);
 }
 
 #endif // !defined(USE_BSFQ)
@@ -138,16 +132,18 @@ Square last_1(Bitboard b) {
 
 void Bitboards::print(Bitboard b) {
 
+  sync_cout;
+
   for (Rank rank = RANK_8; rank >= RANK_1; rank--)
   {
       std::cout << "+---+---+---+---+---+---+---+---+" << '\n';
 
       for (File file = FILE_A; file <= FILE_H; file++)
-          std::cout << "| " << (b & make_square(file, rank) ? "X " : "  ");
+          std::cout << "| " << (b & (file | rank) ? "X " : "  ");
 
       std::cout << "|\n";
   }
-  std::cout << "+---+---+---+---+---+---+---+---+" << std::endl;
+  std::cout << "+---+---+---+---+---+---+---+---+" << sync_endl;
 }
 
 
@@ -160,6 +156,9 @@ void Bitboards::init() {
       while (k < (2 << i))
           MS1BTable[k++] = i;
 
+  for (int i = 0; i < 64; i++)
+      BSFTable[bsf_index(1ULL << i)] = Square(i);
+
   for (Bitboard b = 0; b < 256; b++)
       BitCount8Bit[b] = (uint8_t)popcount<Max15>(b);
 
@@ -202,17 +201,6 @@ void Bitboards::init() {
               if (SquareDistance[s1][s2] == d)
                   DistanceRingsBB[s1][d - 1] |= s2;
 
-  for (int i = 0; i < 64; i++)
-      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;
-      }
-      else
-          BSFTable[((1ULL << i) * 0x218A392CD3D5DBFULL) >> 58] = i;
-
   int steps[][9] = { {}, { 7, 9 }, { 17, 15, 10, 6, -6, -10, -15, -17 },
                      {}, {}, {}, { 9, 7, -7, -9, 8, 1, -1, -8 } };