Why does Delphi insert a nop in the middle of nowhere?

Question

The following code:

while Assigned(p) do begin np:= p^.next; h:= leaf_hash(p^.data); <<-- inline routine h:= h mod nhashprime; p^.next:= nhashtab[h]; nhashtab[h]:= p; p:= np; end; { while } 

Performs the following assembly:

 hlife.pas.605: h:= leaf_hash(p^.data); 00000000005D4602 498B4018 mov rax,[r8+$18] 00000000005D4606 48C1E830 shr rax,$30 00000000005D460A 498B5018 mov rdx,[r8+$18] 00000000005D460E 48C1EA20 shr rdx,$20 00000000005D4612 81E2FFFF0000 and edx,$0000ffff 00000000005D4618 4D8B5818 mov r11,[r8+$18] 00000000005D461C 49C1EB10 shr r11,$10 00000000005D4620 4181E3FFFF0000 and r11d,$0000ffff 00000000005D4627 418B7018 mov esi,[r8+$18] 00000000005D462B 81E6FFFF0000 and esi,$0000ffff 00000000005D4631 488D34F6 lea rsi,[rsi+rsi*8] 00000000005D4635 4403DE add r11d,esi 00000000005D4638 4F8D1CDB lea r11,[r11+r11*8] 00000000005D463C 4103D3 add edx,r11d 00000000005D463F 488D14D2 lea rdx,[rdx+rdx*8] 00000000005D4643 03C2 add eax,edx hlife.pas.606: h:= h mod nhashprime; 00000000005D4645 8BC0 mov eax,eax <<--- Why is there a NOP here? 00000000005D4647 4C63DB movsxd r11,rbx 00000000005D464A 4899 cwd 00000000005D464C 49F7FB idiv r11 00000000005D464F 488BC2 mov rax,rdx hlife.pas.607: p^.next:= nhashtab[h]; 00000000005D4652 488B5538 mov rdx,[rbp+$38] 

Delphi inserts a NOP before the line nhashtab[h]:= p; . If leaf_hash was a normal function, that would make sense.
_{(not really, because RET will still return to [5D4645] by doing nop)}
But now this is not the goal of the transition.

So I'm (just) curious why this is doing?

[EDIT]: SSCCE
OK I have SSCCE (this is not very short, but it needs to be done.

Pay attention to the compiler settings (Debug + Win64)

 unit Unit16; interface uses Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls; type pnode = ^node; tflavour = (tnode, tleaf, tleaf64); node = record case flavour: tflavour of tnode: (next: pnode; (* hash link *) nw, ne, sw, se: pnode; (* constant; nw not= 0 means nonleaf *) res: pnode); (* cache *) tleaf: (next1: pnode; (* hash link *) isnode: pnode; (* must always be zero for leaves *) nw1, ne1, sw1, se1: word; (* constant *) res1, res2: word; (* constant *) ); tleaf64: (next2: pnode; (* hash link *) isnode1: pnode; (* must always be zero for leaves *) data: Uint64; (* constant *) res1a, res2a: word; (* constant *) ) end; ppnode = array of pnode; THashBox = class(TPersistent) strict private leafhashpop: integer; leafhashlimit: integer; leafhashprime: integer; leafhashtab: ppnode; nodehashpop: integer; nodehashlimit: integer; nodehashprime: integer; nodehashtab: ppnode; private TotalTime, Occurrences: Uint64; StartTime, EndTime: Uint64; procedure resize_leaves(); public constructor Create; end; TForm16 = class(TForm) Button1: TButton; procedure Button1Click(Sender: TObject); private HashBox: THashBox; public end; var Form16: TForm16; implementation {$R *.dfm} const maxmem = 2000*1000*1000; {2GB} var alloced: cardinal; function rdtsc: int64; assembler; asm { xor eax,eax; push rbx cpuid pop rbx } rdtsc end; function node_hash(n: pnode): cardinal; { inline; } assembler; overload; // var // a: pnativeint; // begin // Result:= nativeint(n^.se) + 3 * (nativeint(n^.sw) + 3 * (nativeint(n^.ne) + 3 * nativeint(n^.nw) + 3)); asm mov eax,[rcx+node.nw] lea eax,[eax+eax*2+3] add eax,[rcx+node.ne] lea eax,[eax+eax*2] add eax,[rcx+node.sw] lea eax,[eax+eax*2] add eax,[rcx+node.se] end; function leaf_hash(a, b, c, d: cardinal): cardinal; inline; overload; begin Result:= (d + 9 * (c + 9 * (b + 9 * a))) end; function leaf_hash(data: Uint64): cardinal; inline; overload; begin // Result:= d + 9 * (c + 9 * (b + 9 * a)); Result:= ((data shr 48) + 9 * (((data shr 32) and $FFFF) + 9 * (((data shr 16) and $FFFF) + 9 * (data and $FFFF)))); Inc(Result); end; procedure TForm16.Button1Click(Sender: TObject); begin HashBox:= THashBox.Create; Hashbox.resize_leaves; end; function nextprime(old: integer): integer; begin Result:= 1009; end; constructor THashBox.Create; begin leafhashprime:= 7; SetLength(leafhashtab, leafhashprime); end; procedure THashBox.resize_leaves(); var i, i1, i2: integer; nhashprime: Cardinal; p: pnode; nhashtab: ppnode; np: pnode; h: Integer; n, n2: integer; diff1, diff2: integer; begin nhashprime:= nextprime(4 * leafhashprime); if (nhashprime * sizeof(pnode) > maxmem - alloced) then begin leafhashlimit:= 2000 * 1000 * 1000; exit; end; (* * Don't let the hash table buckets take more than 4% of the * memory. If we're starting to strain memory, let the buckets * fill up a bit more. *) if (nhashprime > maxmem div 100) then begin nhashprime:= nextprime(maxmem div 100); if (nhashprime = leafhashprime) then begin leafhashlimit:= 2000 * 1000 * 1000; exit; end; end; SetLength(nhashtab, nhashprime); //make a new table, do not resize the existing one. alloced:= alloced + sizeof(pnode) * (nhashprime - leafhashprime); diff1:= maxint; for i1:= 0 to 100 do begin n:= 0; StartTime:= rdtsc; for i:= 0 to leafhashprime - 1 do begin p:= leafhashtab[i]; if Assigned(p) then begin h:= node_hash(p); h:= h mod nhashprime; inc(n, h); end; end; EndTime:= rdtsc; if ((EndTime - StartTime) < diff1) then diff1:= (EndTime - StartTime); end; diff2:= maxint; for i1:= 0 to 100 do begin n2:= 0; StartTime:= rdtsc; for i:= 0 to leafhashprime - 1 do begin p:= leafhashtab[i]; if Assigned(p) then begin inc(n2); end; end; EndTime:= rdtsc; if (endtime - starttime) < diff2 then diff2:= endtime - starttime; end; TotalTime:= diff1 - diff2; if n <> n2 then Occurrences:= nhashprime; for i:= 0 to leafhashprime - 1 do begin // for (p=hashtab[i]; p;) { p:= leafhashtab[i]; while Assigned(p) do begin <<--- put a breakpoint here np:= p^.next; h:= leaf_hash(p^.data); h:= h mod nhashprime; p^.next:= nhashtab[h]; nhashtab[h]:= p; p:= np; end; { while } end; { for i } // free(hashtab); leafhashtab:= nhashtab; leafhashprime:= nhashprime; leafhashlimit:= leafhashprime; end; end. 

You will see this showdown:

 Unit16.pas.196: h:= h mod nhashprime; 000000000059CE4B 4863C0 movsxd rax,rax 000000000059CE4E 448B5528 mov r10d,[rbp+$28] 000000000059CE52 458BD2 mov r10d,r10d <<--- weird NOP here 000000000059CE55 4899 cwd 000000000059CE57 49F7FA idiv r10 000000000059CE5A 488BC2 mov rax,rdx Unit16.pas.197: p^.next:= nhashtab[h]; 000000000059CE5D 488B5538 mov rdx,[rbp+$38] 

Answer 1

Answer:

 MOV EAX,EAX 

Does not work

On x64, which controls the lower 32 bits of the 64-bit register, the upper 32 bits will be set to zero.
Therefore, the above instruction should really be read as:

 MOVZX RAX,EAX 

According to AMD

The results of 32-bit operations implicitly increase to 64-bit values.

Answer 2

IMHO is not a nop for alignment, but it sounds to me just like non-optimized generated code and incorrect signing of your own variables.

 h:= h mod nhashprime; 

Can be divided into:

 mov eax,eax new h = eax, old h = eax // which does not mean anything movsxd r11,rbx convert with sign nhashprime stored in rbx into temp registry r11 cwd signed rax into rdx:rax idiv r11 signed divide rdx:rax by r11 -> rax=quotient, rdx=remainder mov rax,rdx store remainder rdx into rax 

Have you tried turning on code generation optimization? I believe that it will commit the contents of mov eax,eax .

But your source code is also under-optimized. You should use unsigned arithmetic in your case.

And you better use the power of two nhashprime , calculate a simple binary action and instead of slow division:

 var h, nhashprimeMask: cardinal; // use UNSIGNED arithmetic here! // here nhashprime is a POWER OF TWO (128,256,512,1024,2048...) nhashprimeMask := nhashprime-1; // compute the mask while Assigned(p) do begin np:= p^.next; h:= leaf_hash(p^.data) and nhashprimeMask; p^.next:= nhashtab[h]; nhashtab[h]:= p; p:= np; end; { while } 

This code will be much faster and should compile much better.

Answer 3

This is an optimization for code alignment, especially in loops, to avoid kiosks, etc.