Cómo incrustar un programa ensamblador en lenguaje C
Diferentes compiladores incorporan ensamblador de diferentes maneras, de la siguiente manera:
1. Turbo
C,
es decir TC.
1. Utilice las pseudoinstrucciones del preprocesador #asm y #endasm. #asm se usa para iniciar un bloque de ensamblaje y la instrucción #endasm se usa para finalizar el bloque.
Código de referencia:
int mul(int a, int b)
{
/*Inicio del montaje*/
#asm
mov hacha, palabra ptr 8[bp]
imul hacha palabra ptr 10[bp]
#endasm
/*La compilación finaliza. */
}
2. Utilice la declaración asm:
Formato: asmlt; declaración ensamblada gt;
Código de referencia:
p>
int mul(int a, int b)
{
asm mov ax, palabra ptr 8[bp]
asm imul ax word ptr 10[bp]
/*
Cada asm corresponde a una oración de ensamblaje
Tenga en cuenta que no se requiere punto y coma al final
*/
}
2 VC /VS
Formato:
__asm
Instrucciones de montaje
[
]
__asm
{
Instrucciones de montaje
}
[
]
asm está precedido por dos guiones bajos y los siguientes corchetes indican que el punto y coma es opcional.
Uso:
1. Utilice uno por uno:
__asm mov al, 2
__asm mov dx, 0xD007
p>__asm out dx, al
Una línea de ensamblaje por línea,
puede tener o no punto y coma.
2. Para formar un terreno:
__asm {
mov al, 2
mov dx, 0xD007
out dx, al
}
El conjunto como un bloque de código ensamblador.
3. También puedes escribir varias líneas de ensamblaje en una línea:
__asm mov al, 2 __asm mov dx, 0xD007 __asm out dx, al
3. GNU
GCC
GCC tiene el soporte más completo para ensamblaje. Una breve introducción es la siguiente:
1. >
Palabras clave utilizadas Word:
"__asm__"
Indica que el siguiente código es un ensamblado en línea y "asm" es un alias de "__asm__".
"__volatile__" significa que el compilador no optimiza el código y las siguientes instrucciones permanecen intactas. "volatile" es su alias.
Las instrucciones de montaje se encuentran dentro de los soportes.
La sintaxis de ensamblaje incrustada es la siguiente:
__asm__(
Plantilla de declaración de ensamblaje:
Parte de salida:
Parte de entrada:
Parte de descripción de la destrucción)
Una plantilla de ensamblaje simple:
int a=10, b
asm; ( "movl 1, eax;
movl eax, 0;"
: "=r"(b) /*Parte de salida*/
: " r "(a) /*Parte de entrada*/
："eax" /*Parte de destrucción*/
);
Representa "b" en C idioma =a;".
La r interna significa usar cualquier registro, 0 y 1 significa usar dos registros, generalmente solo se pueden asignar diez operandos del 0 al 9*** según el orden en que aparecen las variables de entrada y salida.
El registro utiliza signos de dos por ciento porque el uso de los números 01 le da un significado especial al signo de por ciento, por lo que el registro donde aparece el operando debe estar representado por signos de doble por ciento.
El eax en la parte de destrucción significa que el registro eax se reescribirá durante la ejecución del bloque de código ensamblador y debe protegerse antes de la ejecución. Esto se envía al compilador para su decisión.