X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fbitboard.cpp;h=84e576c62d1577a3615e4e11f465ae8bb3d82c45;hp=1ac32293387b511bcf1b0f82bac72dc70acd0288;hb=e26d13bb318776bd0b156e55bb392d096a7dc37a;hpb=875a8079bc142ca92027b07427d72c03fe5268a5

diff --git a/src/bitboard.cpp b/src/bitboard.cpp
index 1ac32293..84e576c6 100644
--- a/src/bitboard.cpp
+++ b/src/bitboard.cpp
@@ -30,12 +30,12 @@ CACHE_LINE_ALIGNMENT
 Bitboard RMasks[64];
 Bitboard RMagics[64];
 Bitboard* RAttacks[64];
-int RShifts[64];
+unsigned RShifts[64];
 
 Bitboard BMasks[64];
 Bitboard BMagics[64];
 Bitboard* BAttacks[64];
-int BShifts[64];
+unsigned BShifts[64];
 
 Bitboard SquareBB[64];
 Bitboard FileBB[8];
@@ -64,7 +64,7 @@ namespace {
   typedef unsigned (Fn)(Square, Bitboard);
 
   void init_magics(Bitboard table[], Bitboard* attacks[], Bitboard magics[],
-                   Bitboard masks[], int shifts[], Square deltas[], Fn get_index);
+                   Bitboard masks[], unsigned shifts[], Square deltas[], Fn index);
 }
 
 
@@ -77,7 +77,7 @@ void print_bitboard(Bitboard b) {
   {
       std::cout << "+---+---+---+---+---+---+---+---+" << '\n';
       for (File f = FILE_A; f <= FILE_H; f++)
-          std::cout << "| " << (bit_is_set(b, make_square(f, r)) ? "X " : "  ");
+          std::cout << "| " << ((b & make_square(f, r)) ? "X " : "  ");
 
       std::cout << "|\n";
   }
@@ -112,7 +112,7 @@ Square first_1(Bitboard b) {
 // Use type-punning
 union b_union {
 
-    Bitboard b;
+    Bitboard dummy;
     struct {
 #if defined (BIGENDIAN)
         uint32_t h;
@@ -121,27 +121,21 @@ union b_union {
         uint32_t l;
         uint32_t h;
 #endif
-    } dw;
+    } b;
 };
 
-Square pop_1st_bit(Bitboard* bb) {
-
-   b_union u;
-   Square ret;
+Square pop_1st_bit(Bitboard* b) {
 
-   u.b = *bb;
+   const b_union u = *((b_union*)b);
 
-   if (u.dw.l)
+   if (u.b.l)
    {
-       ret = Square(BSFTable[((u.dw.l ^ (u.dw.l - 1)) * 0x783A9B23) >> 26]);
-       u.dw.l &= (u.dw.l - 1);
-       *bb = u.b;
-       return ret;
+       ((b_union*)b)->b.l = u.b.l & (u.b.l - 1);
+       return Square(BSFTable[((u.b.l ^ (u.b.l - 1)) * 0x783A9B23) >> 26]);
    }
-   ret = Square(BSFTable[((~(u.dw.h ^ (u.dw.h - 1))) * 0x783A9B23) >> 26]);
-   u.dw.h &= (u.dw.h - 1);
-   *bb = u.b;
-   return ret;
+
+   ((b_union*)b)->b.h = u.b.h & (u.b.h - 1);
+   return Square(BSFTable[((~(u.b.h ^ (u.b.h - 1))) * 0x783A9B23) >> 26]);
 }
 
 #endif // !defined(USE_BSFQ)
@@ -213,30 +207,30 @@ void bitboards_init() {
                   Square to = s + Square(c == WHITE ? steps[pt][k] : -steps[pt][k]);
 
                   if (square_is_ok(to) && square_distance(s, to) < 3)
-                      set_bit(&StepAttacksBB[make_piece(c, pt)][s], to);
+                      StepAttacksBB[make_piece(c, pt)][s] |= to;
               }
 
   Square RDeltas[] = { DELTA_N,  DELTA_E,  DELTA_S,  DELTA_W  };
   Square BDeltas[] = { DELTA_NE, DELTA_SE, DELTA_SW, DELTA_NW };
 
-  init_magics(RTable, RAttacks, RMagics, RMasks, RShifts, RDeltas, r_index);
-  init_magics(BTable, BAttacks, BMagics, BMasks, BShifts, BDeltas, b_index);
+  init_magics(RTable, RAttacks, RMagics, RMasks, RShifts, RDeltas, magic_index<ROOK>);
+  init_magics(BTable, BAttacks, BMagics, BMasks, BShifts, BDeltas, magic_index<BISHOP>);
 
   for (Square s = SQ_A1; s <= SQ_H8; s++)
   {
-      PseudoAttacks[BISHOP][s] = bishop_attacks_bb(s, 0);
-      PseudoAttacks[ROOK][s]   = rook_attacks_bb(s, 0);
+      PseudoAttacks[BISHOP][s] = attacks_bb<BISHOP>(s, 0);
+      PseudoAttacks[ROOK][s]   = attacks_bb<ROOK>(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(PseudoAttacks[QUEEN][s1], s2))
+          if (PseudoAttacks[QUEEN][s1] & s2)
           {
               Square delta = (s2 - s1) / square_distance(s1, s2);
 
               for (Square s = s1 + delta; s != s2; s += delta)
-                  set_bit(&BetweenBB[s1][s2], s);
+                  BetweenBB[s1][s2] |= s;
           }
 }
 
@@ -252,9 +246,9 @@ namespace {
              square_is_ok(s) && square_distance(s, s - deltas[i]) == 1;
              s += deltas[i])
         {
-            set_bit(&attack, s);
+            attack |= s;
 
-            if (bit_is_set(occupied, s))
+            if (occupied & s)
                 break;
         }
 
@@ -290,7 +284,7 @@ namespace {
   // use the so called "fancy" approach.
 
   void init_magics(Bitboard table[], Bitboard* attacks[], Bitboard magics[],
-                   Bitboard masks[], int shifts[], Square deltas[], Fn get_index) {
+                   Bitboard masks[], unsigned shifts[], Square deltas[], Fn index) {
 
     int MagicBoosters[][8] = { { 3191, 2184, 1310, 3618, 2091, 1308, 2452, 3996 },
                                { 1059, 3608,  605, 3234, 3326,   38, 2029, 3043 } };
@@ -342,7 +336,7 @@ namespace {
             // effect of verifying the magic.
             for (i = 0; i < size; i++)
             {
-                Bitboard& attack = attacks[s][get_index(s, occupancy[i])];
+                Bitboard& attack = attacks[s][index(s, occupancy[i])];
 
                 if (attack && attack != reference[i])
                     break;