Lazarus Inline Assembler/es

│ English (en) │ español (es) │ français (fr) │ 日本語 (ja) │ 한국어 (ko) │ русский (ru) │ Tiếng Việt (vi) │

   Esto es un esbozo para alentar a otros a contribuir con más información. A continuación un ejemplo sencillo como punto de partida Lazarus_Inline_Assembler:

 unit unit_asm;
 {$mode objfpc}{$H+}
 interface
 uses
  Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs, StdCtrls;
 type
  { TForm1 }
  TForm1 = class(TForm)
    btnGo: TButton;
    edtInput: TEdit;
    edtOutput: TEdit;
    Label1: TLabel;
    Label2: TLabel;
    procedure btnGoClick(Sender: TObject);
  private
    { private declarations }
  public
    { public declarations }
  end; 
 var
  Form1: TForm1; 
 implementation
 { TForm1 }

 procedure TForm1.btnGoClick(Sender: TObject);
 var
  num, answer : integer; {define dos variables de tipo entero: num (número) y answer (respuesta) }
 begin
  num := StrToInt(edtInput.Text); { Convierte la cadena a entero y se lo asigna a la variable num }
  // Se requiere esto con Lazarus en x86, definimos el modo ensamblador de Intel:
  {$ASMMODE intel}
  asm
    MOV EAX, num
    ADD EAX, 110B //sumar el numero 110 binario (6 en decimal) al contenido del registro EAX. 
    SUB EAX, 2    //restar o substraer el número 2 decimal  (no lleva la B de binario) al contenido del registro EAX.
    MOV answer, EAX //mover el contenido de EAX a la variable answer.
  end;
  edtOutput.Text := IntToStr(answer); { Convierte el número entero a su equivalente en cadena & pasa a la propiedad texto }
 end;

 initialization
  {$I unit_asm.lrs}
 end.

   En el siguiente enlace podéis encontrar una muy buena descripción al respecto en la documentación de FreePascal:

• Utilizando lenguaje ensamblador en el codigo fuente, está en inglés así que lo pongo aquí traducido, añadiendo también este enlace a directivas para ensamblador y su respectiva traducción:

 $ASMMODE : Modo ensamblador (Intel 80x86 solamente)

   La directiva {$ASMMODE XXX} informa al compilador sobre el tipo de ensamblador que debe esperar en el/los bloques escritos en ensamblador. Aquí XXX debería reemplazarse por alguno de los siguientes valores:

• att: Indica que los bloques asm contienen sintaxis en la modalidad ensamblador de AT&T.

• intel: Indica que los bloques asm contienen sintaxis en la modalidad ensamblador de Intel.

• direct: Indica al compilador que los bloques asm deben ser copiados directamente al fichero en ensamblador. No es posible utilizar estos bloques en ensamblador cuando se está utilizando un ensamblador interno por parte del compilador.

   Estas opciones son locales y retienen su valor hasta el final de la unidad que es compilada, al menos que sean reemplazados utilizando alguna otra directiva del mismo tipo. La opción a nivel de línea de mandatos que corresponde a esto es -R.

   En el IDE de Lazarus podemos encontrar estas opciones para el proyecto en curso:

   El interprete de ensamblador predeterminado, si no se especifica otro, es AT&T.

   Hay esencialmente 2 modos de embeber código ensamblador en código fuente pascal. La primera es la más simple y consiste en utilizar un bloque asm:

 var  
  I : Integer;  
 begin  
  I:=3;  
  asm  
   movl I,%eax  
  end;  
 end;

   Todo lo que está contenido entre 'asm' y 'end' define un bloque que se inserta como código ensamblador en el código generado. Dependiendo del modo del interprete ensamblador, el compilador realizará la sustitución de ciertos nombres por sus direcciones.

   El segundo modo es implementando una función o bien un procedimiento completamente en ensamblador. Esto se realiza añadiendo el modificador assembler a la cabecera de la función o procedimiento :

 {$ASMMODE att} // pero recordar que es el que utiliza por defecto si no se especifica otro
 function geteipasebx : pointer;assembler;  
 asm  
  movl (%esp),%ebx  
  ret  
 end;

   Es posible todavía declarar variables para el procedimiento en ensamblador:

 procedure Move(const source;var dest;count:SizeInt);assembler;  
 var  
  saveesi,saveedi : longint;  
 asm  
  movl %edi,saveedi  
 end;

   El compilador reservará espacio en la pila para estas variables, esto inserta algunos comandos para ello.

   Debemos tener en cuenta que el nombre ensamblador de una función en ensamblador todavía puede ser 'mangled' por el compilador. Por ejemplo la etiqueta para esta función no deberá ser el nombre de la función declarada. Para cambiar esto se puede utilizar un modificador Alias:

 function geteipasebx : pointer;assembler;[alias:’FPC_GETEIPINEBX’];  
 asm  
  movl (%esp),%ebx  
  ret  
 end;

   Para hacer que la función esté disponible en código ensamblador fuera de la unidad actual debemos añadir el modificador public:

 function geteipasebx : pointer;assembler;[public,alias:’FPC_GETEIPINEBX’];  
 asm  
  movl (%esp),%ebx  
  ret  
 end;