WebSVN – Games.Chess Giants – Diff – //engine-stockfish/bitboard.h

 const Bitboard Rank6BB = Rank1BB << (8 * 5);
 const Bitboard Rank7BB = Rank1BB << (8 * 6);
 const Bitboard Rank8BB = Rank1BB << (8 * 7);
 extern int SquareDistance[SQUARE_NB][SQUARE_NB];
-extern Bitboard  RookMasks  [SQUARE_NB];
-extern Bitboard  RookMagics [SQUARE_NB];
-extern Bitboard* RookAttacks[SQUARE_NB];
-extern unsigned  RookShifts [SQUARE_NB];
-extern Bitboard  BishopMasks  [SQUARE_NB];
-extern Bitboard  BishopMagics [SQUARE_NB];
-extern Bitboard* BishopAttacks[SQUARE_NB];
-extern unsigned  BishopShifts [SQUARE_NB];
 extern Bitboard SquareBB[SQUARE_NB];
 extern Bitboard FileBB[FILE_NB];
 extern Bitboard RankBB[RANK_NB];
 extern Bitboard AdjacentFilesBB[FILE_NB];
 inline Bitboard file_bb(Square s) {
   return FileBB[file_of(s)];
+}
-/// shift_bb() moves a bitboard one step along direction Delta. Mainly for pawns
+/// shift() moves a bitboard one step along direction D. Mainly for pawns
-template<Square Delta>
+template<Square D>
-inline Bitboard shift_bb(Bitboard b) {
+inline Bitboard shift(Bitboard b) {
-  return  Delta == DELTA_N  ?  b             << 8 : Delta == DELTA_S  ?  b             >> 8
+  return  D == NORTH      ?  b             << 8 : D == SOUTH      ?  b             >> 8
-        : Delta == DELTA_NE ? (b & ~FileHBB) << 9 : Delta == DELTA_SE ? (b & ~FileHBB) >> 7
+        : D == NORTH_EAST ? (b & ~FileHBB) << 9 : D == SOUTH_EAST ? (b & ~FileHBB) >> 7
-        : Delta == DELTA_NW ? (b & ~FileABB) << 7 : Delta == DELTA_SW ? (b & ~FileABB) >> 9
+        : D == NORTH_WEST ? (b & ~FileABB) << 7 : D == SOUTH_WEST ? (b & ~FileABB) >> 9
         : 0;
+}
 /// adjacent_files_bb() returns a bitboard representing all the squares on the
 /// attacks_bb() returns a bitboard representing all the squares attacked by a
 /// piece of type Pt (bishop or rook) placed on 's'. The helper magic_index()
 /// looks up the index using the 'magic bitboards' approach.
 template<PieceType Pt>
 inline unsigned magic_index(Square s, Bitboard occupied) {
+  extern Bitboard RookMasks[SQUARE_NB];
+  extern Bitboard RookMagics[SQUARE_NB];
+  extern unsigned RookShifts[SQUARE_NB];
+  extern Bitboard BishopMasks[SQUARE_NB];
+  extern Bitboard BishopMagics[SQUARE_NB];
+  extern unsigned BishopShifts[SQUARE_NB];
   Bitboard* const Masks  = Pt == ROOK ? RookMasks  : BishopMasks;
   Bitboard* const Magics = Pt == ROOK ? RookMagics : BishopMagics;
   unsigned* const Shifts = Pt == ROOK ? RookShifts : BishopShifts;
   return (lo * unsigned(Magics[s]) ^ hi * unsigned(Magics[s] >> 32)) >> Shifts[s];
+}
 template<PieceType Pt>
 inline Bitboard attacks_bb(Square s, Bitboard occupied) {
+  extern Bitboard* RookAttacks[SQUARE_NB];
+  extern Bitboard* BishopAttacks[SQUARE_NB];
   return (Pt == ROOK ? RookAttacks : BishopAttacks)[s][magic_index<Pt>(s, occupied)];
+}
 inline Bitboard attacks_bb(Piece pc, Square s, Bitboard occupied) {
   default    : return StepAttacksBB[pc][s];
+  }
+}
-/// lsb() and msb() return the least/most significant bit in a non-zero bitboard
+/// popcount() counts the number of non-zero bits in a bitboard
-#ifdef USE_BSFQ
+inline int popcount(Bitboard b) {
-#  if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
+#ifndef USE_POPCNT
-inline Square lsb(Bitboard b) {
-  unsigned long idx;
+  extern uint8_t PopCnt16[1 << 16];
-  _BitScanForward64(&idx, b);
+  union { Bitboard bb; uint16_t u[4]; } v = { b };
-  return (Square) idx;
+  return PopCnt16[v.u[0]] + PopCnt16[v.u[1]] + PopCnt16[v.u[2]] + PopCnt16[v.u[3]];
-}
-inline Square msb(Bitboard b) {
+#elif defined(_MSC_VER) || defined(__INTEL_COMPILER)
-  unsigned long idx;
-  _BitScanReverse64(&idx, b);
-  return (Square) idx;
-}
-#  elif defined(__arm__)
+  return (int)_mm_popcnt_u64(b);
-inline int lsb32(uint32_t v) {
-  __asm__("rbit %0, %1" : "=r"(v) : "r"(v));
+#else // Assumed gcc or compatible compiler
-  return __builtin_clz(v);
-}
-inline Square msb(Bitboard b) {
-  return (Square) (63 - __builtin_clzll(b));
+  return __builtin_popcountll(b);
+#endif
+}
+/// lsb() and msb() return the least/most significant bit in a non-zero bitboard
+#if defined(__GNUC__)
 inline Square lsb(Bitboard b) {
+  assert(b);
-  return (Square) (uint32_t(b) ? lsb32(uint32_t(b)) : 32 + lsb32(uint32_t(b >> 32)));
+  return Square(__builtin_ctzll(b));
+}
+inline Square msb(Bitboard b) {
+  assert(b);
-#  else // Assumed gcc or compatible compiler
+  return Square(63 - __builtin_clzll(b));
+}
+#elif defined(_WIN64) && defined(_MSC_VER)
-inline Square lsb(Bitboard b) { // Assembly code by Heinz van Saanen
+inline Square lsb(Bitboard b) {
+  assert(b);
-  Bitboard idx;
+  unsigned long idx;
-  __asm__("bsfq %1, %0": "=r"(idx): "rm"(b) );
+  _BitScanForward64(&idx, b);
   return (Square) idx;
+}
 inline Square msb(Bitboard b) {
+  assert(b);
-  Bitboard idx;
+  unsigned long idx;
-  __asm__("bsrq %1, %0": "=r"(idx): "rm"(b) );
+  _BitScanReverse64(&idx, b);
   return (Square) idx;
+}
-#  endif
+#else
-#else // ifdef(USE_BSFQ)
+#define NO_BSF // Fallback on software implementation for other cases
 Square lsb(Bitboard b);
 Square msb(Bitboard b);
 #endif

Subversion Repositories Games.Chess Giants

Games.Chess Giants//engine-stockfish/bitboard.h – Rev 96 → 154