Premier commit

Cette révision appartient à :
Théo Gastinel a révisé 2026-10-11 01:55:22 +02:00
révision 536792a769
62 fichiers modifiés
+6766

Aucun fichier ne correspond à votre recherche

+74
Voir le fichier
@@ -0,0 +1,74 @@
// asm/demo_fill_aarch64.S — paire de DEMONSTRATION du harnais d oracle.
//
// Ces routines n ont aucune utilite en production. Elles existent pour prouver
// que le harnais (a) accepte une implementation correcte et (b) rejette une
// implementation fausse dont on connait le defaut. Un harnais qui ne sait pas
// detecter une erreur connue ne vaut rien.
//
// Contrat commun (proj3::oracle::RunFn) :
// x0 = const u8* in
// x1 = usize in_len
// x2 = u8* out
// x3 = usize out_cap
// retour x0 = nombre d octets ecrits
//
// Semantique : si in_len == 0, ne rien ecrire et rendre 0. Sinon remplir
// out_cap octets avec in[0] et rendre out_cap.
//
// Conventions : doc/convention-aarch64.md. Ces deux routines sont des feuilles
// (aucun bl, sp intact). Elles n ecrasent que x4-x6, tous caller-saved.
.text
.balign 4
.global proj3_fill_bytes_asm
.hidden proj3_fill_bytes_asm
.type proj3_fill_bytes_asm, %function
proj3_fill_bytes_asm:
cbz x1, .Lfill_bytes_empty
ldrb w4, [x0] // valeur a ecrire
mov x5, #0 // compteur
.Lfill_bytes_loop:
cmp x5, x3
b.hs .Lfill_bytes_done
strb w4, [x2, x5]
add x5, x5, #1
b .Lfill_bytes_loop
.Lfill_bytes_done:
mov x0, x3
ret
.Lfill_bytes_empty:
mov x0, #0
ret
.size proj3_fill_bytes_asm, . - proj3_fill_bytes_asm
// --- VERSION VOLONTAIREMENT FAUSSE ----------------------------------------
// Defaut injecte : un octet de moins que demande, mais la longueur RENDUE est
// correcte. C est exactement le genre de bug qu un test trop indulgent laisse
// passer — la taille est bonne, seul le dernier octet manque.
.text
.balign 4
.global proj3_fill_bytes_asm_broken
.hidden proj3_fill_bytes_asm_broken
.type proj3_fill_bytes_asm_broken, %function
proj3_fill_bytes_asm_broken:
cbz x1, .Lfill_broken_empty
ldrb w4, [x0]
mov x5, #0
subs x6, x3, #1 // <-- LE DEFAUT : out_cap - 1
b.lo .Lfill_broken_done // out_cap == 0 : rien a ecrire
.Lfill_broken_loop:
cmp x5, x6
b.hs .Lfill_broken_done
strb w4, [x2, x5]
add x5, x5, #1
b .Lfill_broken_loop
.Lfill_broken_done:
mov x0, x3 // longueur rendue correcte, contenu faux
ret
.Lfill_broken_empty:
mov x0, #0
ret
.size proj3_fill_bytes_asm_broken, . - proj3_fill_bytes_asm_broken
.section .note.GNU-stack,"",@progbits
+88
Voir le fichier
@@ -0,0 +1,88 @@
// asm/host/demo_fill_x86_64.S — la MEME paire de demonstration, en x86-64.
//
// POURQUOI CE FICHIER EXISTE. Le harnais d oracle doit tourner sur la machine
// de developpement, sans telephone et sans emulateur (contrainte de conception
// du chantier 4). Or la machine de dev est x86-64 : elle ne peut pas executer
// proj3_fill_bytes_asm, qui est de l AArch64.
//
// Sans ce fichier, le harnais compare sur l hote la reference C++ a rien du
// tout, et la preuve qu il sait rejeter une erreur ne peut se faire que sur
// la cible. C est exactement l inverse de ce qu on veut.
//
// Ce fichier n existe donc QUE pour la paire de demonstration, et il ne sera
// jamais etendu : les vraies routines optimisees seront ecrites en AArch64
// seulement, et leur comparaison se fera sur la cible (executable
// proj3_oracle_target). Sur l hote, elles apparaitront comme "reference figee,
// version assembleur absente". C est une limite assumee et documentee dans
// doc/methode-oracle.md.
//
// Contrat identique : (in, in_len, out, out_cap) -> octets ecrits.
.intel_syntax noprefix
.text
// Deux ABI possibles. On les ramene a des noms uniformes en tete de routine
// plutot que d ecrire deux fois le corps.
#if defined(_WIN64) || defined(__CYGWIN__)
// ABI Microsoft x64 : rcx, rdx, r8, r9
#define P3_IN rcx
#define P3_INLEN rdx
#define P3_OUT r8
#define P3_CAP r9
#else
// ABI System V AMD64 : rdi, rsi, rdx, rcx
#define P3_IN rdi
#define P3_INLEN rsi
#define P3_OUT rdx
#define P3_CAP rcx
#endif
.globl proj3_fill_bytes_asm
proj3_fill_bytes_asm:
test P3_INLEN, P3_INLEN
je .Lfill_bytes_empty
movzx eax, byte ptr [P3_IN]
mov r10, P3_OUT
xor r11, r11
.Lfill_bytes_loop:
cmp r11, P3_CAP
jae .Lfill_bytes_done
mov byte ptr [r10 + r11], al
inc r11
jmp .Lfill_bytes_loop
.Lfill_bytes_done:
mov rax, P3_CAP
ret
.Lfill_bytes_empty:
xor eax, eax
ret
// --- VERSION VOLONTAIREMENT FAUSSE : un octet de moins ---------------------
.globl proj3_fill_bytes_asm_broken
proj3_fill_bytes_asm_broken:
test P3_INLEN, P3_INLEN
je .Lfill_broken_empty
movzx eax, byte ptr [P3_IN]
mov r10, P3_OUT
xor r11, r11
mov rax, P3_CAP
test rax, rax
je .Lfill_broken_done
dec rax // <-- LE DEFAUT : out_cap - 1
movzx r8d, byte ptr [P3_IN] // (recharge : rax servait de compteur)
.Lfill_broken_loop:
cmp r11, rax
jae .Lfill_broken_done
mov byte ptr [r10 + r11], r8b
inc r11
jmp .Lfill_broken_loop
.Lfill_broken_done:
mov rax, P3_CAP
ret
.Lfill_broken_empty:
xor eax, eax
ret
#if defined(__ELF__)
.section .note.GNU-stack,"",@progbits
#endif
+54
Voir le fichier
@@ -0,0 +1,54 @@
// asm/start.S — point d entree du processus, sans crt1.o ni libc.
//
// Conventions : doc/convention-aarch64.md.
//
// Etat a l entree, garanti par le noyau (fs/binfmt_elf.c, ELF ABI AArch64) :
// sp -> argc, puis argv[0..argc-1], NULL, envp[...], NULL, auxv[...]
// x0 -> 0 (Linux ne passe rien ; c est l ABI System V generique qui
// prevoit un pointeur de fonction atexit, toujours nul sous Linux)
// Tous les autres registres generaux sont indefinis. Ne rien supposer.
// sp est deja aligne sur 16 octets.
//
// Ce que ce fichier NE fait PAS, et pourquoi :
// - il ne parcourt pas .init_array : le projet n a aucun constructeur
// statique non trivial (cf. ADR-0001). Si un jour il en fallait un, c est
// ici qu il faudrait le traiter, et l ADR devrait etre revise.
// - il ne met pas en place de TLS : pas de thread, pas de thread_local.
// - il ne retourne jamais. proj3_main est appele, sa valeur de retour part
// directement dans exit_group.
.text
.balign 4
.global _start
.hidden _start
.type _start, %function
_start:
// Le cadre de pile initial n a pas d appelant : on ancre le pointeur de
// trame a zero pour qu un derouleur de pile (debogueur, perf) s arrete ici
// proprement au lieu de suivre des ordures.
mov x29, xzr
mov x30, xzr
// argc et argv, pour proj3_main(int argc, char** argv).
// argc est un mot de 64 bits sur la pile ; on ne garde que 32 bits utiles.
ldr x0, [sp] // argc
add x1, sp, #8 // argv
// sp est deja aligne sur 16 ; on ne le modifie pas, donc l alignement
// requis a la frontiere d appel est trivialement respecte.
bl proj3_main
// Valeur de retour de proj3_main dans w0 -> code de sortie.
// exit_group (94) et non exit (93) : on veut terminer le processus entier,
// pas seulement le fil courant. La distinction est sans objet aujourd hui
// (mono-fil) mais le jour ou elle en aura une, ce sera silencieusement.
and x0, x0, #0xff
mov x8, #94 // __NR_exit_group
svc #0
// Inatteignable. Si le noyau revenait malgre tout, on piege plutot que de
// continuer dans du code indefini.
brk #0
.size _start, . - _start
.section .note.GNU-stack,"",@progbits
+143
Voir le fichier
@@ -0,0 +1,143 @@
// asm/syscall.S — wrappers d appels systeme AArch64, assembleur pur.
//
// Conventions : doc/convention-aarch64.md et doc/convention-syscall.md.
//
// FORME CANONIQUE, et pourquoi elle est aussi courte :
//
// proj3_sys_<nom>:
// mov x8, #PROJ3_NR_<nom>
// svc #0
// ret
//
// L ABI syscall Linux/AArch64 (arch/arm64/kernel/entry.S, et Documentation/
// arm64/) fait coincider exactement les registres d arguments de l AAPCS64 et
// ceux de l appel systeme :
//
// argument 1..6 -> x0 x1 x2 x3 x4 x5
// numero d appel -> x8
// retour -> x0
//
// Il n y a donc AUCUN mouvement de registre a faire dans le cas general. Le
// 6e argument de mmap arrive en x5 par l ABI d appel normale : rien de special
// n est requis, contrairement a x86-64 ou r10 remplace rcx.
//
// Registres detruits par svc : x0 (resultat) et x8 (que nous avons ecrit).
// Le noyau preserve x1-x7 et x9-x30. x8 etant caller-saved en AAPCS64, nous
// avons le droit de l ecraser sans le sauvegarder.
//
// ALIGNEMENT DE PILE : aucun de ces wrappers ne touche a sp ni n empile x30.
// L alignement 16 octets exige par l AAPCS64 est donc preserve trivialement,
// par construction et non par vigilance.
//
// LA VALEUR DE RETOUR N EST PAS TRANSFORMEE. Le x0 du noyau ressort tel quel,
// conformement a l option C de doc/convention-syscall.md. Le test de plage
// [-4095, -1] est fait cote C++ par proj3::sys::Result::is_err(), en constexpr
// inline, et seulement quand l appelant le demande.
#include "proj3/sys/syscall_nr.hpp"
// Macro d emission d un wrapper direct (aucun remaniement d argument).
// L usage d une macro ici n est pas de la coquetterie : il garantit que les
// 14 wrappers directs sont rigoureusement identiques, donc qu aucun d entre
// eux ne peut avoir un prologue ou une transformation qui traine.
.macro PROJ3_SYSCALL_DIRECT name, nr
.text
.balign 4
.global proj3_sys_\name
.hidden proj3_sys_\name
.type proj3_sys_\name, %function
proj3_sys_\name:
mov x8, #\nr
svc #0
ret
.size proj3_sys_\name, . - proj3_sys_\name
.endm
// --- Fichiers -------------------------------------------------------------
// open : la table generique AArch64 n a PAS de __NR_open. On passe par
// openat avec AT_FDCWD. C est le seul wrapper qui remanie ses arguments,
// et c est la raison pour laquelle il n utilise pas la macro.
//
// entree : x0 = const char* path
// x1 = int flags
// x2 = int mode (ignore par le noyau sans O_CREAT)
// sortie : x0 = fd ou -errno
.text
.balign 4
.global proj3_sys_open
.hidden proj3_sys_open
.type proj3_sys_open, %function
proj3_sys_open:
mov x3, x2 // mode -> arg4
mov x2, x1 // flags -> arg3
mov x1, x0 // path -> arg2
mov x0, #PROJ3_AT_FDCWD // dirfd -> arg1
mov x8, #PROJ3_NR_openat
svc #0
ret
.size proj3_sys_open, . - proj3_sys_open
PROJ3_SYSCALL_DIRECT close, PROJ3_NR_close
PROJ3_SYSCALL_DIRECT read, PROJ3_NR_read
PROJ3_SYSCALL_DIRECT write, PROJ3_NR_write
PROJ3_SYSCALL_DIRECT ioctl, PROJ3_NR_ioctl
PROJ3_SYSCALL_DIRECT fstat, PROJ3_NR_fstat
PROJ3_SYSCALL_DIRECT lseek, PROJ3_NR_lseek
// --- Memoire --------------------------------------------------------------
//
// mmap prend six arguments : addr, length, prot, flags, fd, offset.
// Le sixieme (offset) arrive en x5 par l AAPCS64 et c est exactement la ou le
// noyau l attend. Verifie sur arch/arm64 : le point d entree svc recopie
// x0-x5 dans les six premiers champs de pt_regs, sans decalage.
// C est la difference avec x86-64, ou l argument 4 doit etre deplace de rcx
// vers r10 parce que syscall ecrase rcx.
PROJ3_SYSCALL_DIRECT mmap, PROJ3_NR_mmap
PROJ3_SYSCALL_DIRECT munmap, PROJ3_NR_munmap
PROJ3_SYSCALL_DIRECT madvise, PROJ3_NR_madvise
// --- Temps ----------------------------------------------------------------
//
// Note d honnetete : clock_gettime passe ici par un vrai svc, PAS par le
// vDSO. Le vDSO eviterait la transition en mode noyau et couterait environ
// vingt fois moins cher. Ce n est pas un oubli : utiliser le vDSO demande de
// parcourir l auxiliary vector (AT_SYSINFO_EHDR) et de resoudre un symbole
// ELF au demarrage, ce qui n est pas dans le perimetre du chantier 2. Dette
// documentee, a traiter au chantier de mesure de latence — la ou elle
// comptera vraiment.
PROJ3_SYSCALL_DIRECT clock_gettime, PROJ3_NR_clock_gettime
PROJ3_SYSCALL_DIRECT nanosleep, PROJ3_NR_nanosleep
// --- Processus ------------------------------------------------------------
PROJ3_SYSCALL_DIRECT getpid, PROJ3_NR_getpid
// exit et exit_group ne reviennent pas. Le `ret` de la macro serait mort ;
// on met un brk a la place pour que, si le noyau revenait (il ne le fait
// pas), on s arrete net au lieu de partir dans du code indefini.
.text
.balign 4
.global proj3_sys_exit
.hidden proj3_sys_exit
.type proj3_sys_exit, %function
proj3_sys_exit:
mov x8, #PROJ3_NR_exit
svc #0
brk #0
.size proj3_sys_exit, . - proj3_sys_exit
.text
.balign 4
.global proj3_sys_exit_group
.hidden proj3_sys_exit_group
.type proj3_sys_exit_group, %function
proj3_sys_exit_group:
mov x8, #PROJ3_NR_exit_group
svc #0
brk #0
.size proj3_sys_exit_group, . - proj3_sys_exit_group
.section .note.GNU-stack,"",@progbits