Discussion :

[Roland Chastain]

Bonjour !

Je cherche à compiler avec Delphi 7 un programme de jeu d'échecs qui, d'après le fichier *.cfg, a été développé avec Delphi 5. L'une des unités du programme contient de l'assembleur et c'est justement cette unité qui ne se compile pas. J'obtiens le message d'erreur suivant : "Non concordance de taille d'opérande".

Je ne connais pas du tout l'assembleur. J'aimerais avec votre aide comprendre le problème et trouver un moyen de le résoudre, quitte à remplacer le code en assembleur par du code en Pascal. L'unité en question fait une centaine de lignes.

Voici le lien pour télécharger le programme : DeepRoss8

Apparemment le programme utilise des composants Indy, ce qui fait un autre problème à régler, mais cette fonctionnalité ne m'intéresse pas et donc je pense plutôt la supprimer.

[tourlourou]

Bonjour Roland,

Ce serait donc l'unité uASMTools qui poserait problème ?
Et aBoard: int64 représenterait quoi ? L'échiquier ? Cases libres ou occupées ?
Serait-ce un souci d'opérande entre CPU 32 bits et 64 bits ?
On dirait (vu en diagonale) que certaines de ces routines émulent ce que feraient les opérandes 32 bits sur du 64 bits, ce qu'elles feraient pê d'ailleurs à peu près en 64 bits... A voir.

Par commodité, je mets l'unité ici :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
unit uASMTools;
 
interface
 
 
  function FirstOne(aBoard: Int64): Integer;
  function LastOne(aBoard: Int64): Integer;
  function BitCount(aBoard: Int64): Byte; assembler;
  function BitScanForward(var X: Int64): Integer;
  function BitScanReverse(var X: Int64): Integer;
  function BitScan(var X, Y: Integer; Z: pointer): Integer;
  function BitScanForwardAndClear(var X: Int64): Integer;
 
implementation
 
 
//FirstOne scans low register first (forward)
//LastOne scans high register first (reverse)
//PopCount count the number of bits set in a Int64
 
function FirstOne(aBoard: Int64): Integer;
asm
      xor     eax, eax
      bsf     edx, dword ptr aBoard
      jnz     @@1
      mov     eax, 32
      bsf     edx, dword ptr aBoard + 4
 @@1: add     eax, edx
end;
 
function LastOne(aBoard: Int64): Integer;
asm
      xor     eax, eax
      bsr     edx, dword ptr aBoard
      jnz     @@1
      mov     eax, 32
      bsr     edx, dword ptr aBoard + 4
 @@1: add     eax, edx
end;
 
function BitCount(aBoard: Int64): Byte; assembler;
asm
      mov     ecx, dword ptr aBoard
      xor     eax, eax
      test    ecx, ecx
      jz      @@1
 @@0: lea     edx, [ecx-1]
      inc     eax
      and     ecx, edx
      jnz     @@0
 @@1: mov     ecx, dword ptr aBoard+4
      test    ecx, ecx
      jz      @@3
 @@2: lea     edx, [ecx-1]
      inc     eax
      and     ecx, edx
      jnz     @@2
 @@3:
end;

[tourlourou]

rapidement, non testé, en asm x86 64 bits, l'équivalent de la première fonction (j'espère !)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
function FirstOne(aBoard: Int64): Integer;
asm
      xor     rax, rax // met Result à zéro
      bsf     rax, rcx // met dans Result l'indice du 1° bit non nul de aBoard 
end;

[Roland Chastain]

@tourlourou

Bonjour ! Merci pour ta réponse. Aiguillé par tes observations, j'ai essayé le programme Project1 (qui lui se compile) et j'ai commencé à voir ce que faisait le programme. Effectivement les 64 bits sont les cases de l'échiquier. Du coup un Int64 permet de représenter les mouvements possibles d'une pièce.

Chez moi ta fonction ne se compile pas mais du reste ce n'est pas cette fonction qui pose problème, c'est seulement la dernière fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

function BitScanForwardAndClear(var X: Int64): Integer;

Je tenterais bien de la refaire en Pascal si j'étais sûr de savoir exactement ce qu'elle fait.

[Roland Chastain]

Je ferais comme ça. Le programme a l'air de fonctionner : j'ai pu échanger quelques coups avec l'ordinateur. Joli programme !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
function BitScanForwardAndClear(var X: Int64): Integer;
const
  ERROR = -1;
var
  i: integer;
begin
  i := 0;
  result := ERROR;
  while (i <= 63) and (result = ERROR) do
    if (1 shl (63 - i)) and X > 0 then
    begin
      result := i;
      X := X and not (1 shl (63 - i));
    end else
      Inc(i);
end;
 
{
function BitScanForwardAndClear(var X: Int64): Integer;
asm
  // store lowest 32 bit into ECX and higher into EDX
  XOR     CL,CL
  MOV     EDX,[EAX]
  // test if lower 32 bit contain a '1'
  BSF     CL,EDX
  // clear anyhow
  JNZ     @CLEARBITLOW
  // test if higher 32 bit contain a '1'
  MOV     EDX,[EAX+4]
  BSF     CL,EDX
  JNZ     @CALCINDEX
  //else set error code
  MOV     EAX, -1
  JMP     @READY
@CALCINDEX:
  //clear the bit(ch) in the highest 32 bit area
  BTR     EDX, CL
  MOV     [EAX+4],EDX
  // add 32 to get the overall index
  ADD     CL, 32
  JMP     @READY
@CLEARBITLOW:
  //clear the bit(ch) in the lowest 32 bit area
  BTR     EDX, CL
  MOV     [EAX],EDX
@READY:
  //store the return value in EAX
  MOV     EAX,ECX
end;
}

Je vais essayer de faire une partie entière. Autrement ça vous paraît juste ce que j'ai fait ou pas ?

[Roland Chastain]

Le programme a l'air de fonctionner

Pas étonnant puisqu'en regardant les choses de plus près, je m'aperçois que la fonction est question n'est utilisée nulle part ! Du coup on peut purement et simplement la supprimer.

Mais pour essayer de comprendre quand même : donc le problème viendrait du fait que le programme a été écrit pour une machine 32 bits et que j'essaie de le compiler sur une machine 64 bits, c'est ça ?

@tourlourou
En essayant de compiler la fonction que tu as proposée, j'obtiens une erreur "Identificateur non déclaré".

P.-S. Mais encore une fois, quel joli programme ! Et l'adversaire artificiel a l'air coriace. Je posterais bien le programme dans nos sources. Dans l'enthousiasme j'ai même fait l'effort d'installer Indy. Mais je n'ai pas compris à quoi correspond l'option Internet. Pour jouer contre quelqu'un à distance ? Mais comment ça marche ?

[tourlourou]

Bonsoir Roland,

Il est possible que :
- 1) mon code asm soit erroné
- 2) tous les opérandes ou registres ne soient pas acceptés par le compilo
- 3) autre explication

Sinon, ton code me semble bien fidèle, à défaut d'être appelé !

[Roland Chastain]

@tourlourou

Merci pour tes réponses. Mon problème est résolu par la suppression de la fonction.

Je ne pense pas me mettre à l'assembleur mais le truc des 64 bits pour représenter l'échiquier, c'est quelque chose que je vais creuser.

P.-S. J'ai tenté une conversion automatique de Deep Ross en projet Lazarus : j'ai eu d'autres messages d'erreur sur les parties en assembleur. Apparemment l'assembleur de FPC n'est pas le même que l'assembleur de Delphi.

[Cirec]

Bonjour à tous,

je sais que le problème est résolu par la suppression de la fonction "BitScanForwardAndClear"

mais à tout hasard, si ça vous intéresse,
j'ai modifié la fonction et elle semble fonctionner selon le tableau qui figure dans le fichier "Square"
sauf pour la dernière valeur du tableau ???
si quelqu'un voit pourquoi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
function BitScanForwardAndClear(var X: Int64): Integer;
asm
  // store lowest 32 bit into ECX and higher into EDX
  XOR     CL,CL
  MOV     EDX,[EAX]
  // test if lower 32 bit contain a '1'
  BSF     ECX,EDX                                   // modifié
  // clear anyhow
  JNZ     @CLEARBITLOW
  // test if higher 32 bit contain a '1'
  MOV     EDX,[EAX+4]
  BSF     ECX,EDX                                   // modifié
  JNZ     @CALCINDEX
  //else set error code
  MOV     EAX, -1
  JMP     @READY
@CALCINDEX:
  //clear the bit(ch) in the highest 32 bit area
  BTR     EDX, ECX                                   // modifié
  MOV     [EAX+4],EDX
  // add 32 to get the overall index
  ADD     CL, 32
  JMP     @READY
@CLEARBITLOW:
  //clear the bit(ch) in the lowest 32 bit area
  BTR     EDX, ECX                                   // modifié
  MOV     [EAX],EDX
@READY:
  //store the return value in EAX
  MOV     EAX,ECX
end;
 
 // pour tester vous pouvez entrer une des valeurs figurant dans le fichier "Square"
 // sauf la dernière !!!
procedure TForm1.Button2Click(Sender: TObject);
var
 aInt64: Int64;
begin
  aInt64 := 64;
  Caption := IntToStr(BitScanForwardAndClear(aInt64));
end;

[Roland Chastain]

@Cirec

Merci, je vais tester ta fonction.