home *** CD-ROM | disk | FTP | other *** search
/ Dream 57 / Amiga_Dream_57.iso / Amiga / Jeux / Reflexion / Crafty-15.19.lha / crafty-15.19 / src / X86.s < prev   
Text File  |  1998-09-13  |  19KB  |  585 lines
  1. alignment = 4
  2.  
  3.         .text
  4.         .align  alignment, 0x90
  5.         .globl  _PopCnt
  6. _PopCnt:
  7.         movl    4(%esp), %eax
  8.         movl    8(%esp), %edx
  9.         pushl   %ebx
  10.         pushl   %esi
  11. # x = (x >> 1  & 0x55555555) + (x & 0x55555555);
  12.         movl    $0x55555555, %esi
  13.         movl    %eax, %ecx
  14.         shrl    $1, %eax
  15.         movl    %edx, %ebx
  16.         shrl    $1, %edx
  17.         andl    %esi, %ecx
  18.         andl    %esi, %ebx
  19.         andl    %esi, %eax
  20.         andl    %esi, %edx
  21.         addl    %ecx, %eax
  22.         addl    %ebx, %edx
  23. # x = ((x >> 2) & 0x33333333) + (x & 0x33333333);
  24.         movl    $0x33333333, %esi
  25.         movl    %eax, %ecx
  26.         shrl    $2, %eax
  27.         movl    %edx, %ebx
  28.         shrl    $2, %edx
  29.         andl    %esi, %ecx
  30.         andl    %esi, %ebx
  31.         andl    %esi, %eax
  32.         andl    %esi, %edx
  33.         addl    %ecx, %eax
  34.         addl    %ebx, %edx
  35. # x = ((x >> 4) + x) & 0x0f0f0f0f;
  36.         movl    %eax, %ecx
  37.         shrl    $4, %eax
  38.         movl    %edx, %ebx
  39.         shrl    $4, %edx
  40.         addl    %ecx, %eax
  41.         addl    %ebx, %edx
  42.         andl    $0x0f0f0f0f, %eax
  43.         andl    $0x0f0f0f0f, %edx
  44. # x = ((x >> 8) + x);
  45.         movl    %eax, %ecx
  46.         shrl    $8, %eax
  47.         movl    %edx, %ebx
  48.         shrl    $8, %edx
  49.         addl    %ecx, %eax
  50.         addl    %ebx, %edx
  51. # return (x + (x >> 16)) & 0xff;
  52.         movl    %eax, %ecx
  53.         shrl    $16, %eax
  54.         movl    %edx, %ebx
  55.         shrl    $16, %edx
  56.         addl    %ecx, %eax
  57.         addl    %ebx, %edx
  58.         popl    %esi
  59.         popl    %ebx
  60.         addl    %edx, %eax
  61.         andl    $0x7f, %eax
  62.         ret
  63.  
  64. /*----------------------------------------------------------------------------*/
  65.  
  66.         .align  alignment, 0x90
  67.         .globl  _FirstOne
  68. _FirstOne:
  69.         cmpl    $1, 8(%esp)
  70.         sbbl    %eax, %eax
  71.         movl    $65535, %ecx
  72.         movl    8(%esp,%eax,4), %edx
  73.         andl    $32, %eax
  74.         cmpl    %edx, %ecx
  75.         sbbl    %ecx, %ecx
  76.         andl    $16, %ecx
  77.         shrl    %cl, %edx
  78.         subl    %ecx, %eax
  79.         movl    $255, %ecx
  80.         cmpl    %edx, %ecx
  81.         sbbl    %ecx, %ecx
  82.         andl    $8, %ecx
  83.         shrl    %cl, %edx
  84.         subl    %ecx, %eax
  85.         addl    $24, %eax
  86.         movzbl  _first_ones_8bit(%edx), %ecx
  87.         addl    %ecx, %eax
  88.         ret
  89.  
  90. /*----------------------------------------------------------------------------*/
  91.  
  92.         .align  alignment, 0x90
  93.         .globl  _LastOne
  94. _LastOne:
  95.         cmpl    $1, 4(%esp)
  96.         sbbl    %ecx, %ecx
  97.         movl    %ecx, %eax
  98.         negl    %ecx
  99.         notl    %eax
  100.         andl    $32, %eax
  101.         movl    4(%esp,%ecx,4), %edx
  102.         pushl   %esi
  103.         movl    %edx, %esi
  104.         andl    $0x0000ffff, %esi
  105.         cmpl    $1, %esi
  106.         sbbl    %ecx, %ecx
  107.         andl    $16, %ecx
  108.         shrl    %cl, %edx
  109.         subl    %ecx, %eax
  110.         movl    %edx, %esi
  111.         andl    $0x000000ff, %esi
  112.         cmpl    $1, %esi
  113.         sbbl    %ecx, %ecx
  114.         andl    $8, %ecx
  115.         shrl    %cl, %edx
  116.         subl    %ecx, %eax
  117.         andl    $0x000000ff, %edx
  118.         addl    $24, %eax
  119.         cmpl    $1, %edx
  120.         sbbl    %ecx, %ecx
  121.         popl    %esi
  122.         movzbl  _last_ones_8bit(%edx), %edx
  123.         andl    $56, %ecx
  124.         addl    %edx, %eax
  125.         addl    %ecx, %eax
  126.         ret
  127.  
  128. /*----------------------------------------------------------------------------*/
  129.  
  130.         .align  alignment, 0x90
  131.  
  132. /*----------------------------------------------------------------------------*/
  133.  
  134.         .comm   _first_ones_8bit, 256
  135.         .comm   _last_ones_8bit, 256
  136.  
  137. /*----------------------------------------------------------------------------*/
  138.  
  139. /* Diag info offsets */
  140.     
  141. D_ATTACKS       = 0             # Must be 0 - hard-coded (see comments)
  142. D_MOBILITY      = 4
  143. D_WHICH_ATTACK  = 8
  144. D_SHIFT         = 12
  145. D_MASK          = 13
  146. AD_SHIFT        = 14
  147. AD_MASK         = 15
  148. AD_WHICH_ATTACK = 16
  149. AD_MOBILITY     = 20
  150. AD_ATTACKS      = 24
  151.  
  152. /* Position offsets */
  153.     
  154. W_OCCUPIED       =  0
  155. B_OCCUPIED       =  8
  156. RL90             = 16
  157. RL45             = 24
  158. RR45             = 32
  159.     
  160. /* Struct at offsets:
  161.         struct at {
  162.           unsigned char which_attack[8][64];
  163.           BITBOARD      file_attack_bitboards[8][12];
  164.           unsigned char rank_attack_bitboards[8][12];
  165.           unsigned char length8_mobility[8][12];
  166.           unsigned char short_mobility[116];
  167.         } at;
  168. */
  169.  
  170. WHICH_ATTACK     = 0
  171. FILE_ATTACKS     = 512
  172. RANK_ATTACKS     = 1280
  173. LEN8_MOBILITY    = 1376
  174. SHRT_MOBILITY    = 1472
  175.  
  176.         .text
  177.  
  178. /*
  179.   BITBOARD AttacksDiaga1Func (DIAG_INFO *diag, CHESS_POSITION *board)
  180. */
  181. /*
  182.   #define AttacksDiaga1Int(diagp,boardp)                \
  183.     (diagp)->ad_attacks [               \
  184.       (diagp)->ad_which_attack [            \
  185.     And (SplitShiftr((boardp)->occupied_rl45,   \
  186.              (diagp)->ad_shift),        \
  187.          (diagp)->ad_mask) ] ]
  188. */
  189.         .align  alignment, 0x90
  190.         .globl  _AttacksDiaga1Func
  191. _AttacksDiaga1Func:
  192.         pushl   %esi
  193.         movl    8(%esp), %esi                   /* diag_info     */
  194.         movl    12(%esp), %eax                  /* boardp        */
  195.         movb    AD_SHIFT(%esi), %cl             /* shift         */
  196.         cmpb    $32, %cl
  197.         sbbl    %edx, %edx
  198.         movl    RL45+4(%eax,%edx,4), %eax       /* occupied      */
  199.         movzbl  AD_MASK(%esi), %edx             /* mask          */
  200.         shrl    %cl, %eax
  201.         andl    %edx, %eax
  202.         addl    AD_WHICH_ATTACK(%esi), %eax     /* which_attack  */
  203.         movl    AD_ATTACKS(%esi), %ecx          /* attack_vector */
  204.         movzbl  (%eax), %edx                    /* attack_index  */
  205.         popl    %esi
  206.         movl    (%ecx,%edx,8), %eax
  207.         movl    4(%ecx,%edx,8), %edx
  208.         ret
  209.  
  210. /*
  211.   BITBOARD AttacksDiagh1Func(DIAG_INFO *diag, CHESS_POSITION *board)
  212. */
  213. /*
  214.   #define AttacksDiagh1Int(diagp,boardp)        \
  215.     (diagp)->d_attacks [                \
  216.       (diagp)->d_which_attack [             \
  217.     And (SplitShiftr((boardp)->occupied_rr45,   \
  218.              (diagp)->d_shift),     \
  219.          (diagp)->d_mask) ] ]
  220. */
  221.         .align  alignment, 0x90
  222.         .globl  _AttacksDiagh1Func
  223. _AttacksDiagh1Func:
  224.         pushl   %esi
  225.         movl    8(%esp), %esi                   /* diag_info     */
  226.         movl    12(%esp), %eax                  /* boardp        */
  227.         movb    D_SHIFT(%esi), %cl              /* shift         */
  228.         cmpb    $32, %cl
  229.         sbbl    %edx, %edx
  230.         movl    RR45+4(%eax,%edx,4), %eax       /* occupied      */
  231.         movzbl  D_MASK(%esi), %edx              /* mask          */
  232.         shrl    %cl, %eax
  233.         andl    %edx, %eax
  234.         addl    D_WHICH_ATTACK(%esi), %eax      /* which_attack  */
  235.         movl    (%esi), %ecx                    /* D_ATTACKS     */
  236.                                                 # attack_vector
  237.         movzbl  (%eax), %edx                    /* attack_index  */
  238.         popl    %esi
  239.         movl    (%ecx,%edx,8), %eax
  240.         movl    4(%ecx,%edx,8), %edx
  241.         ret
  242.  
  243. /*
  244.   BITBOARD AttacksBishopFunc(DIAG_INFO *diag, CHESS_POSITION *board)
  245. */
  246. /*
  247.   return Or(AttacksDiaga1Int(diag,board), AttacksDiagh1Int(diag,board));
  248. */
  249.         .align  alignment, 0x90
  250.         .globl  _AttacksBishopFunc
  251. _AttacksBishopFunc:
  252.         pushl   %ebx
  253.         pushl   %esi
  254.         pushl   %edi
  255.         movl    16(%esp), %esi                  /* diag_info     */
  256.         movl    20(%esp), %edi                  /* boardp        */
  257.         movb    AD_SHIFT(%esi), %cl             /* shift         */
  258.         cmpb    $32, %cl
  259.         sbbl    %edx, %edx
  260.         movzbl  AD_MASK(%esi), %ebx             /* mask          */
  261.         movl    RL45+4(%edi,%edx,4), %edi       /* occupied      */
  262.         shrl    %cl, %edi
  263.         andl    %ebx, %edi
  264.         addl    AD_WHICH_ATTACK(%esi), %edi     /* which_attack  */
  265.         movl    AD_ATTACKS(%esi), %ecx          /* attack_vector */
  266.         movzbl  (%edi), %ebx                    /* attack_index  */
  267.         movl    20(%esp), %edi                  /* again boardp  */
  268.         leal    (%ecx,%ebx,8), %edx
  269.         movb    D_SHIFT(%esi), %cl              /* shift         */
  270.         cmpb    $32, %cl
  271.         sbbl    %ebx, %ebx
  272.         movl    RR45+4(%edi,%ebx,4), %edi       /* occupied      */
  273.         movzbl  D_MASK(%esi), %ebx              /* mask          */
  274.         shrl    %cl, %edi
  275.         movl    (%esi), %ecx                    /* D_ATTACKS     */
  276.                                                 # attack_vector
  277.         andl    %ebx, %edi
  278.         movl    (%edx), %eax
  279.         addl    D_WHICH_ATTACK(%esi), %edi      /* which_attack  */
  280.         movl    4(%edx), %edx
  281.         movzbl  (%edi), %ebx                    /* attack_index  */
  282.         popl    %edi
  283.         orl     (%ecx,%ebx,8), %eax
  284.         popl    %esi
  285.         orl     4(%ecx,%ebx,8), %edx
  286.         popl    %ebx
  287.         ret
  288.  
  289. /*
  290.   unsigned MobilityDiaga1Func(DIAG_INFO *diag, CHESS_POSITION *board)
  291. */
  292. /*
  293.   #define MobilityDiaga1Int(diagp,boardp)               \
  294.     (diagp)->ad_mobility [              \
  295.       (diagp)->ad_which_attack [            \
  296.     And (SplitShiftr ((boardp)->occupied_rl45,  \
  297.               (diagp)->ad_shift),       \
  298.              (diagp)->ad_mask) ] ]
  299. */
  300.  
  301.         .align  alignment, 0x90
  302.         .globl  _MobilityDiaga1Func
  303. _MobilityDiaga1Func:
  304.         pushl   %esi
  305.         movl    8(%esp), %esi                   /* diag_info     */
  306.         movl    12(%esp), %eax                  /* boardp        */
  307.         movb    AD_SHIFT(%esi), %cl             /* shift         */
  308.         cmpb    $32, %cl
  309.         sbbl    %edx, %edx
  310.         movl    RL45+4(%eax,%edx,4), %eax       /* occupied      */
  311.         movzbl  AD_MASK(%esi), %edx             /* mask          */
  312.         shrl    %cl, %eax
  313.         andl    %edx, %eax
  314.         addl    AD_WHICH_ATTACK(%esi), %eax     /* which_attack  */
  315.         movl    AD_MOBILITY(%esi), %ecx         /* mobility_vector */
  316.         movzbl  (%eax), %edx                    /* attack_index  */
  317.         popl    %esi
  318.         movzbl  (%ecx,%edx,1), %eax
  319.         ret
  320.  
  321. /*
  322.   unsigned MobilityDiagh1Func(DIAG_INFO *diag, CHESS_POSITION *board)
  323. */
  324. /*
  325.   #define MobilityDiagh1Int(diagp,boardp)       \
  326.     (diagp)->d_mobility [               \
  327.       (diagp)->d_which_attack [             \
  328.     And (SplitShiftr ((boardp)->occupied_rr45,  \
  329.               (diagp)->d_shift),        \
  330.          (diagp)->d_mask) ] ]
  331. */
  332.  
  333.         .align  alignment, 0x90
  334.         .globl  _MobilityDiagh1Func
  335. _MobilityDiagh1Func:
  336.         pushl   %esi
  337.         movl    8(%esp), %esi                   /* diag_info     */
  338.         movl    12(%esp), %eax                  /* boardp        */
  339.         movb    D_SHIFT(%esi), %cl              /* shift         */
  340.         cmpb    $32, %cl
  341.         sbbl    %edx, %edx
  342.         movl    RR45+4(%eax,%edx,4), %eax       /* occupied      */
  343.         movzbl  D_MASK(%esi), %edx              /* mask          */
  344.         shrl    %cl, %eax
  345.         andl    %edx, %eax
  346.         addl    D_WHICH_ATTACK(%esi), %eax      /* which_attack  */
  347.         movl    D_MOBILITY(%esi), %ecx          /* mobility_vector */
  348.         movzbl  (%eax), %edx                    /* attack_index  */
  349.         popl    %esi
  350.         movzbl  (%ecx,%edx,1), %eax
  351.         ret
  352.  
  353. /*
  354.   BITBOARD AttacksRankFunc(int square, CHESS_POSITION *board)
  355. */
  356. /*
  357.   #define AttacksRankInt(a,boardp)              \
  358.     SplitShiftl(                \
  359.       at.rank_attack_bitboards[File(a)] [   \
  360.     at.which_attack[File(a)] [      \
  361.       And(SplitShiftr(          \
  362.         Or((boardp)->w_occupied,    \
  363.            (boardp)->b_occupied),   \
  364.         (Rank(~(a))<<3)+1),     \
  365.           0x3f) ] ],            \
  366.       Rank(~(a))<<3)
  367. */
  368.         .align  alignment, 0x90
  369.         .globl  _AttacksRankFunc
  370. _AttacksRankFunc:
  371.         movl    4(%esp), %ecx                   /* square               */
  372.         movl    8(%esp), %edx                   /* boardp               */
  373.         pushl   %esi
  374.         movl    %ecx, %esi
  375.         andl    $7, %esi                        /* file                 */
  376.         notl    %ecx
  377.         andl    $0x38, %ecx
  378.         pushl   %ebp
  379.         cmpl    $32, %ecx
  380.         pushl   %edi
  381.         sbbl    %ebp, %ebp
  382.         leal    (%esi,%esi,2), %edi             /* file * 3             */
  383.         shll    $6, %esi                        /* file * 64            */
  384.         movl    W_OCCUPIED+4(%edx,%ebp,4), %eax
  385.         incl    %ecx
  386.         orl     B_OCCUPIED+4(%edx,%ebp,4), %eax
  387.         shrl    %cl, %eax
  388.         andl    $0x3f, %eax
  389.         movzbl  _at+WHICH_ATTACK(%eax,%esi), %edx
  390.         decl    %ecx
  391.         movzbl  _at+RANK_ATTACKS(%edx,%edi,4), %eax
  392.         shll    %cl, %eax
  393.         popl    %edi
  394.         movl    %eax, %edx
  395.         andl    %ebp, %eax
  396.         notl    %ebp
  397.         andl    %ebp, %edx
  398.         popl    %ebp
  399.         popl    %esi
  400.         ret
  401.  
  402. /*
  403.   BITBOARD AttacksFileFunc(int square, CHESS_POSITION *board)
  404. */
  405. /*
  406.   #define AttacksFileInt(a,boardp)                      \
  407.     Shiftl(at.file_attack_bitboards[Rank(a)] [      \
  408.          at.which_attack[Rank(a)] [         \
  409.            And(SplitShiftr((boardp)->occupied_rl90, \
  410.                    (File(~(a))<<3)+1),  \
  411.            0x3f) ] ],               \
  412.        File(~(a)) )
  413. */
  414.         .align  alignment, 0x90
  415.         .globl  _AttacksFileFunc
  416. _AttacksFileFunc:
  417.         movl    4(%esp), %ecx                   /* square               */
  418.         movl    8(%esp), %edx                   /* boardp               */
  419.         pushl   %esi
  420.         movl    %ecx, %esi
  421.         notl    %ecx
  422.         andl    $7, %ecx                        /* file                 */
  423.         shrl    $3, %esi                        /* rank                 */
  424.         pushl   %edi
  425.         leal    (%esi,%esi,2), %edi             /* rank * 3             */
  426.         shll    $6, %esi                        /* rank * 64            */
  427.         leal    1(,%ecx,8), %ecx                /* (file << 3) + 1      */
  428.         cmpl    $32, %ecx
  429.         sbbl    %eax, %eax
  430.         shll    $5, %edi
  431.         movl    RL90+4(%edx,%eax,4), %eax
  432.         shrl    %cl, %eax
  433.         andl    $0x3f, %eax
  434.         movzbl  _at+WHICH_ATTACK(%eax,%esi), %edx
  435.         decl    %ecx
  436.         movl    _at+FILE_ATTACKS(%edi,%edx,8), %eax
  437.         shrl    $3, %ecx
  438.         movl    _at+FILE_ATTACKS+4(%edi,%edx,8), %edx
  439.         popl    %edi
  440.         shll    %cl, %eax
  441.         popl    %esi
  442.         shll    %cl, %edx
  443.         ret
  444.  
  445. /*
  446.   BITBOARD AttacksRookFunc(int square, CHESS_POSITION *board)
  447. */
  448. /*
  449.   return Or(AttacksRankInt(square, board), AttacksFileInt(square, board));
  450. */
  451.         .align  alignment, 0x90
  452.         .globl  _AttacksRookFunc
  453. _AttacksRookFunc:
  454.         movl    4(%esp), %ecx                   /* square               */
  455.         movl    8(%esp), %edx                   /* boardp               */
  456.         pushl   %ebp
  457.         pushl   %esi
  458.         movl    %ecx, %esi
  459.         notl    %ecx
  460.         andl    $7, %esi                        /* file                 */
  461.         pushl   %ebx
  462.         andl    $0x38, %ecx                     /* rank << 3            */
  463.         pushl   %edi
  464.         cmpl    $32, %ecx
  465.         leal    (%esi,%esi,2), %edi             /* file * 3             */
  466.         sbbl    %eax, %eax
  467.         shll    $6, %esi                        /* file * 64            */
  468.         movl    W_OCCUPIED+4(%edx,%eax,4), %ebp
  469.         incl    %ecx
  470.         orl     B_OCCUPIED+4(%edx,%eax,4), %ebp
  471.         shrl    %cl, %ebp
  472.         andl    $0x3f, %ebp
  473.         movzbl  _at+WHICH_ATTACK(%esi,%ebp,1), %ebx
  474.         decl    %ecx
  475.         movl    20(%esp), %esi                  /* square               */
  476.         movzbl  _at+RANK_ATTACKS(%ebx,%edi,4), %ebp
  477.         shll    %cl, %ebp
  478.         movl    %esi, %ecx
  479.         movl    %ebp, %ebx
  480.         notl    %ecx
  481.         andl    %eax, %ebp
  482.         andl    $7, %ecx                        /* file                 */
  483.         notl    %eax
  484.         shrl    $3, %esi                        /* rank                 */
  485.         andl    %eax, %ebx
  486. # Now we have: ebp - lo, ebx - hi
  487.         leal    1(,%ecx,8), %ecx                /* (file << 3) + 1      */
  488.         leal    (%esi,%esi,2), %edi             /* rank * 3             */
  489.         shll    $6, %esi                        /* rank * 64            */
  490.         cmpl    $32, %ecx
  491.         sbbl    %eax, %eax
  492.         shll    $5, %edi
  493.         movl    RL90+4(%edx,%eax,4), %eax
  494.         shrl    %cl, %eax
  495.         andl    $0x3f, %eax
  496.         movzbl  _at+WHICH_ATTACK(%eax,%esi), %edx
  497.         decl    %ecx
  498.         movl    _at+FILE_ATTACKS(%edi,%edx,8), %eax
  499.         shrl    $3, %ecx
  500.         shll    %cl, %eax
  501.         movl    _at+FILE_ATTACKS+4(%edi,%edx,8), %edx
  502.         shll    %cl, %edx
  503.         popl    %edi
  504.         orl     %ebx, %edx
  505.         popl    %ebx
  506.         orl     %ebp, %eax
  507.         popl    %esi
  508.         popl    %ebp
  509.         ret
  510.  
  511. /*
  512.   unsigned MobilityRankFunc(int square, CHESS_POSITION *board)
  513. */
  514. /*
  515.   #define MobilityRankInt(a,boardp)                     \
  516.     at.length8_mobility[File(a)][           \
  517.       at.which_attack[File(a)] [            \
  518.     And(SplitShiftr(Or((boardp)->w_occupied,    \
  519.                (boardp)->b_occupied),   \
  520.             (Rank(~(a))<<3)+1),     \
  521.         0x3f) ] ]
  522. */
  523.         .align  alignment, 0x90
  524.         .globl  _MobilityRankFunc
  525. _MobilityRankFunc:
  526.         movl    4(%esp), %ecx                   /* square               */
  527.         pushl   %esi
  528.         movl    %ecx, %esi
  529.         notl    %ecx
  530.         andl    $0x38, %ecx
  531.         cmpl    $32, %ecx
  532.         sbbl    %edx, %edx
  533.         shll    $2, %edx
  534.         addl    12(%esp), %edx                  /* boardp               */
  535.         andl    $7, %esi                        /* file                 */
  536.         movl    W_OCCUPIED+4(%edx), %eax
  537.         incl    %ecx
  538.         orl     B_OCCUPIED+4(%edx), %eax
  539.         shrl    %cl, %eax
  540.         leal    (%esi,%esi,2), %ecx             /* file * 3             */
  541.         shll    $6, %esi                        /* file * 64            */
  542.         andl    $0x3f, %eax
  543.         movzbl  _at+WHICH_ATTACK(%eax,%esi), %edx
  544.         popl    %esi
  545.         movzbl  _at+LEN8_MOBILITY(%edx,%ecx,4), %eax
  546.         ret
  547.  
  548. /*
  549.   unsigned MobilityFileFunc(int square, CHESS_POSITION *board)
  550. */
  551. /*
  552.   #define MobilityFileInt(a,boardp)                     \
  553.     at.length8_mobility[Rank(a)][           \
  554.       at.which_attack[Rank(a)] [            \
  555.     And(SplitShiftr((boardp)->occupied_rl90,    \
  556.             (File(~(a))<<3)+1 ),        \
  557.         0x3f) ] ]
  558. */
  559.         .align  alignment, 0x90
  560.         .globl  _MobilityFileFunc
  561. _MobilityFileFunc:
  562.         movl    4(%esp), %ecx                   /* square               */
  563.         pushl   %esi
  564.         movl    %ecx, %esi
  565.         notl    %ecx
  566.         andl    $7, %ecx                        /* file                 */
  567.         shrl    $3, %esi                        /* rank                 */
  568.         leal    1(,%ecx,8), %ecx                /* (file << 3) + 1      */
  569.         cmpl    $32, %ecx
  570.         sbbl    %edx, %edx
  571.         shll    $2, %edx
  572.         addl    12(%esp), %edx                  /* boardp               */
  573.         movl    RL90+4(%edx), %eax
  574.         shrl    %cl, %eax
  575.         leal    (%esi,%esi,2), %ecx             /* rank * 3             */
  576.         shll    $6, %esi                        /* rank * 64            */
  577.         andl    $0x3f, %eax
  578.         movzbl  _at+WHICH_ATTACK(%eax,%esi), %edx
  579.         popl    %esi
  580.         movzbl  _at+LEN8_MOBILITY(%edx,%ecx,4), %eax
  581.         ret
  582.  
  583.         .align  alignment, 0x90
  584.         .end
  585.