Module X86_64

module X86_64: sig .. end
Bibliothèque pour l'écriture de programmes X86-64

Il s'agit là uniquement d'un fragment relativement petit de l'assembleur X86-64.
Author(s): Jean-Christophe Filliâtre (CNRS), Kim Nguyen (Université Paris Sud)



Code


type 'a asm 
type abstrait du code assembleur. Le paramètre 'a est utilisé comme type fantôme.
type text = [ `text ] asm 
du code assembleur se trouvant dans la zone de texte
type data = [ `data ] asm 
du code assembleur se trouvant dans la zone de données
type label = string 
les étiquettes d'addresses sont des chaînes de caractères
val nop : [>  ] asm
l'instruction vide. Peut se trouver dans du text ou du data
val (++) : ([< `data | `text ] as 'a) asm -> 'a asm -> 'a asm
concatène deux bouts de codes (soit text avec text, soit data avec data)
val inline : string -> [>  ] asm
inline s recopie la chaîne s telle quelle dans le fichier assembleur
type program = {
   text : text;
   data : data;
}
un programme est constitué d'une zone de texte et d'une zone de données
val print_program : Format.formatter -> program -> unit
print_program fmt p imprime le code du programme p dans le formatter fmt
val print_in_file : file:string -> program -> unit

Registres


type size = [ `B | `L | `Q | `W ] 
type 'size register 
type abstrait des registres
val rax : [ `Q ] register
val rbx : [ `Q ] register
val rcx : [ `Q ] register
val rdx : [ `Q ] register
val rsi : [ `Q ] register
val rdi : [ `Q ] register
val rbp : [ `Q ] register
val rsp : [ `Q ] register
val r8 : [ `Q ] register
val r9 : [ `Q ] register
val r10 : [ `Q ] register
val r11 : [ `Q ] register
val r12 : [ `Q ] register
val r13 : [ `Q ] register
val r14 : [ `Q ] register
val r15 : [ `Q ] register
registres 64 bits
val eax : [ `L ] register
val ebx : [ `L ] register
val ecx : [ `L ] register
val edx : [ `L ] register
val esi : [ `L ] register
val edi : [ `L ] register
val ebp : [ `L ] register
val esp : [ `L ] register
val r8d : [ `L ] register
val r9d : [ `L ] register
val r10d : [ `L ] register
val r11d : [ `L ] register
val r12d : [ `L ] register
val r13d : [ `L ] register
val r14d : [ `L ] register
val r15d : [ `L ] register
registres 32 bits
val ax : [ `W ] register
val bx : [ `W ] register
val cx : [ `W ] register
val dx : [ `W ] register
val si : [ `W ] register
val di : [ `W ] register
val bp : [ `W ] register
val sp : [ `W ] register
val r8w : [ `W ] register
val r9w : [ `W ] register
val r10w : [ `W ] register
val r11w : [ `W ] register
val r12w : [ `W ] register
val r13w : [ `W ] register
val r14w : [ `W ] register
val r15w : [ `W ] register
registres 16 bits
val al : [ `B ] register
val bl : [ `B ] register
val cl : [ `B ] register
val dl : [ `B ] register
val ah : [ `B ] register
val bh : [ `B ] register
val ch : [ `B ] register
val dh : [ `B ] register
val sil : [ `B ] register
val dil : [ `B ] register
val bpl : [ `B ] register
val spl : [ `B ] register
val r8b : [ `B ] register
val r9b : [ `B ] register
val r10b : [ `B ] register
val r11b : [ `B ] register
val r12b : [ `B ] register
val r13b : [ `B ] register
val r14b : [ `B ] register
val r15b : [ `B ] register
registres 8 bits

Opérandes


type 'size operand 
Le type abstrait des opérandes
val imm : int -> [>  ] operand
opérande immédiate $i
val imm32 : int32 -> [>  ] operand
opérande immédiate $i
val reg : 'size register -> 'size operand
registre
val ind : ?ofs:int ->
?index:'size1 register ->
?scale:int -> 'size2 register -> [> ] operand
opérande indirecte ofs(register, index, scale)
val lab : label -> [>  ] operand
étiquette L
val ilab : label -> [ `Q ] operand
étiquette immédiate $L

Instructions



Instructions



Transfert


val movb : [ `B ] operand -> [ `B ] operand -> text
val movw : [ `W ] operand -> [ `W ] operand -> text
val movl : [ `L ] operand -> [ `L ] operand -> text
val movq : [ `Q ] operand -> [ `Q ] operand -> text
attention : toutes les combinaisons d'opérandes ne sont pas permises
val movsbw : [ `B ] operand -> [ `W ] register -> text
val movsbl : [ `B ] operand -> [ `L ] register -> text
val movsbq : [ `B ] operand -> [ `Q ] register -> text
val movswl : [ `W ] operand -> [ `L ] register -> text
val movswq : [ `W ] operand -> [ `Q ] register -> text
val movslq : [ `L ] operand -> [ `Q ] register -> text
8->64 bit, avec extension de signe
val movzbw : [ `B ] operand -> [ `W ] register -> text
val movzbl : [ `B ] operand -> [ `L ] register -> text
val movzbq : [ `B ] operand -> [ `Q ] register -> text
val movzwl : [ `W ] operand -> [ `L ] register -> text
val movzwq : [ `W ] operand -> [ `Q ] register -> text
8->64 bit, avec extension par zéro
val movabsq : int64 -> [ `Q ] register -> text
copie une valeur immédiate 64 bits dans un registre

Arithmétique


val leab : [ `B ] operand -> [ `B ] register -> text
val leaw : [ `W ] operand -> [ `W ] register -> text
val leal : [ `L ] operand -> [ `L ] register -> text
val leaq : [ `Q ] operand -> [ `Q ] register -> text
val incb : [ `B ] operand -> text
val incw : [ `W ] operand -> text
val incl : [ `L ] operand -> text
val incq : [ `Q ] operand -> text
val decb : [ `B ] operand -> text
val decw : [ `W ] operand -> text
val decl : [ `L ] operand -> text
val decq : [ `Q ] operand -> text
val negb : [ `B ] operand -> text
val negw : [ `W ] operand -> text
val negl : [ `L ] operand -> text
val negq : [ `Q ] operand -> text
val addb : [ `B ] operand -> [ `B ] operand -> text
val addw : [ `W ] operand -> [ `W ] operand -> text
val addl : [ `L ] operand -> [ `L ] operand -> text
val addq : [ `Q ] operand -> [ `Q ] operand -> text
val subb : [ `B ] operand -> [ `B ] operand -> text
val subw : [ `W ] operand -> [ `W ] operand -> text
val subl : [ `L ] operand -> [ `L ] operand -> text
val subq : [ `Q ] operand -> [ `Q ] operand -> text
val imulw : [ `W ] operand -> [ `W ] operand -> text
val imull : [ `L ] operand -> [ `L ] operand -> text
val imulq : [ `Q ] operand -> [ `Q ] operand -> text
val idivq : [ `Q ] operand -> text
val cqto : text

Opérations logiques


val notb : [ `B ] operand -> text
val notw : [ `W ] operand -> text
val notl : [ `L ] operand -> text
val notq : [ `Q ] operand -> text
val andb : [ `B ] operand -> [ `B ] operand -> text
val andw : [ `W ] operand -> [ `W ] operand -> text
val andl : [ `L ] operand -> [ `L ] operand -> text
val andq : [ `Q ] operand -> [ `Q ] operand -> text
val orb : [ `B ] operand -> [ `B ] operand -> text
val orw : [ `W ] operand -> [ `W ] operand -> text
val orl : [ `L ] operand -> [ `L ] operand -> text
val orq : [ `Q ] operand -> [ `Q ] operand -> text
val xorb : [ `B ] operand -> [ `B ] operand -> text
val xorw : [ `W ] operand -> [ `W ] operand -> text
val xorl : [ `L ] operand -> [ `L ] operand -> text
val xorq : [ `Q ] operand -> [ `Q ] operand -> text
Opérations de manipulation de bits. "et" bit à bit, "ou" bit à bit, "not" bit à bit

Décalages


val shlb : [ `B ] operand -> [ `B ] operand -> text
val shlw : [ `W ] operand -> [ `W ] operand -> text
val shll : [ `L ] operand -> [ `L ] operand -> text
val shlq : [ `Q ] operand -> [ `Q ] operand -> text
note: shl est la même chose que sal
val shrb : [ `B ] operand -> [ `B ] operand -> text
val shrw : [ `W ] operand -> [ `W ] operand -> text
val shrl : [ `L ] operand -> [ `L ] operand -> text
val shrq : [ `Q ] operand -> [ `Q ] operand -> text
val sarb : [ `B ] operand -> [ `B ] operand -> text
val sarw : [ `W ] operand -> [ `W ] operand -> text
val sarl : [ `L ] operand -> [ `L ] operand -> text
val sarq : [ `Q ] operand -> [ `Q ] operand -> text

Sauts


val call : label -> text
val call_star : [ `Q ] operand -> text
val leave : text
val ret : text
appel de fonction et retour
val jmp : label -> text
saut inconditionnel
val jmp_star : [ `Q ] operand -> text
saut à une adresse calculée
val je : label -> text
val jz : label -> text
val jne : label -> text
val jnz : label -> text
val js : label -> text
val jns : label -> text
val jg : label -> text
val jge : label -> text
val jl : label -> text
val jle : label -> text
val ja : label -> text
val jae : label -> text
val jb : label -> text
val jbe : label -> text

sauts conditionnels

sauts conditionnels

Conditions


val cmpb : [ `B ] operand -> [ `B ] operand -> text
val cmpw : [ `W ] operand -> [ `W ] operand -> text
val cmpl : [ `L ] operand -> [ `L ] operand -> text
val cmpq : [ `Q ] operand -> [ `Q ] operand -> text
val testb : [ `B ] operand -> [ `B ] operand -> text
val testw : [ `W ] operand -> [ `W ] operand -> text
val testl : [ `L ] operand -> [ `L ] operand -> text
val testq : [ `Q ] operand -> [ `Q ] operand -> text
val sete : [ `B ] operand -> text
val setne : [ `B ] operand -> text
val sets : [ `B ] operand -> text
val setns : [ `B ] operand -> text
val setg : [ `B ] operand -> text
val setge : [ `B ] operand -> text
val setl : [ `B ] operand -> text
val setle : [ `B ] operand -> text
val seta : [ `B ] operand -> text
val setae : [ `B ] operand -> text
val setb : [ `B ] operand -> text
val setbe : [ `B ] operand -> text

positionne l'octet opérande à 1 ou 0 selon que le test est vrai ou non

positionne l'octet opérande à 1 ou 0 selon que le test est vrai ou non

Manipulation de la pile


val pushq : [ `Q ] operand -> text
pushq r place le contenu de r au sommet de la pile. Rappel : %rsp pointe sur l'adresse de la dernière case occupée
val popq : [ `Q ] register -> text
popq r place le mot en sommet de pile dans r et dépile

Divers


val label : label -> [>  ] asm
un label. Peut se retrouver dans du text ou du data
val globl : label -> [>  ] asm
déclaration .globl (pour main, typiquement)
val comment : string -> [>  ] asm
place un commentaire dans le code généré. Peut se retrouver dans du text ou du data

Données


val string : string -> data
une constante chaîne de caractères (terminée par 0)
val dbyte : int list -> data
val dword : int list -> data
val dint : int list -> data
val dquad : int list -> data
place une liste de valeurs sur 1/2/4/8 octets dans la zone data
val address : label list -> data
place une liste d'adresses dans la zone data (avec .quad)
val space : int -> data
space n alloue n octets (valant 0) dans le segment de données