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): : 2015 Jean-Christophe Filliâtre (CNRS) d'après un module similaire pour MIPS par 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



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

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

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 glabel : label -> [>  ] asm
même chose, avec une 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
place une constante chaîne de caractères (terminées par 0) dans a zone data
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