Newsgroup: it.comp.lang.delphi
Titolo: Resto ammirato per come il compilatore ottimizza il codice

Sto osservando in che modo il compilatore traduce in codice macchina, le 
istruzioni scritte in linguaggio Delphi.
Non posso fare a meno di rimanere stupito per quanto sia ottimizzato il 
codice prodotto.
Per esempio, guardate questa semplice funzione, dove ho trascritto il 
disassemblato del codice generato dal compilatore: qualcuno avrebbe saputo 
scrivere di meglio?
(**********************************************************************)
function IsDirectory(const Name: string): Boolean;
{ restituisce True se Name (nome completo di path) è una directory
  NON fa alcun controllo se Name è una stringa vuota! 
  NON fa alcun controllo se Name è '.' o '..'}
var
  Code: Integer;
begin
  Code:= GetFileAttributes(PChar(Name));
  Result:= (Code <> -1) and ((Code and FILE_ATTRIBUTE_DIRECTORY) <> 0)
{ questa riga è ben ottimizzata dal compilatore come segue:
 (ho fatto solo modifiche di forma per rendere il codice più 
  comprensibile/leggibile):
  CMP   EAX,-1        //guardo se c'è differenza tra Code e -1
                      //qui è stato usato tutto EAX, perchè -1 necessita 
                      //di tutti i 32 bit per
                      //essere codificato ($FFFFFFFF);
  JZ    @step1        //solo se Code <> -1 eseguo il test successivo,
                      //se invece Code = 1, salto a @step1
                      //è la "boolean short-circuit evaluation"!
  TEST  AL,FILE_ATTRIBUTE_DIRECTORY
                      //eseguo un AND tra FILE_ATTRIBUTE_DIRECTORY e Code
                      //qui sono sufficienti soli 8 bit per questa 
                      //operazione, perchè FILE_ATTRIBUTE_DIRECTORY 
    	                //vale $10;
                      //TEST è più veloce di AND perchè TEST modifica
    	                //solo i flag e non memorizza il risultato da
                      //nessuna parte (infatti il risultato non serve)
  JNZ   step2:        //se (FILE_ATTRIBUTE_DIRECTORY and Code) <> 0, 
                      //salto a @step2
@step1:
  XOR   EAX,EAX       //Result:= False
  RET
@step2:
  MOV   AL,1          //Result:= True
                      //l'operazione è su soli 8 bit, 
                      //cioè lo stretto necessario
}
end;
(**********************************************************************)
-- 
Mauro Falzari 
   [ 
http://digilander.libero.it/mauro.falzari
 ]
 
 "Se guardi nell'abisso, anche l'abisso guarda in te." 
   (Friedrich Nietzsche)

Be', non mi sembra che abbia fatto ottimizzazioni particolari.
Usare un TEST per verificare i bit o uno XOR per azzerare i registri
sono normali tecniche che qualunque (discreto) programmatore asm
conosce ;-)



sai, essendo la prima volta in vita mia (in VB è impossibile) che ho la 
possibilità di "guardare dentro" come lavora un compilatore, in una maniera 
poi tanto semplice e immediata [CTRL+ALT+C], mi stupisco!!
E poi non credo che quel codice si potrebbe ottimizzare ulteriormente.


 E poi non credo che quel codice si potrebbe ottimizzare ulteriormente.
Più che altro perché non c'è altro da ottimizzare...
Andrea

 Piů che altro perché non c'č altro da ottimizzare...
Dipende dalla "granularita'" delle ottimizzazioni... penso che se ci fossero
3-4 righe in piu' si potrebbe tirarne fuori ancora qualcosa... ma non ne
vale sempre la pena.