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

+70
Voir le fichier
@@ -0,0 +1,70 @@
build*/
*.o
*.obj
*.exe
# --- double-push : exclusions generiques (secrets, builds, binaires, gros fichiers) ---
target/
node_modules/
build/
build-*/
dist/
out/
.gradle/
.idea/
venv/
.venv/
env/
__pycache__/
*.pyc
.cache/
.next/
.env
.env.*
!.env.example
accounts.json
Clee.API/
*.pem
*.key
*.p12
*.pfx
*.jks
*.keystore
keystore.properties
id_rsa*
id_ed25519*
*.kdbx
*.odt
*.sqlite
*.sqlite3
*.db
*.log
*.exe
*.dll
*.msi
*.jar
*.zip
*.7z
*.rar
*.tar
*.tar.gz
*.tgz
*.gguf
*.safetensors
*.onnx
*.pt
*.pth
*.bin
*.iso
*.gws
*.apk
*.aab
*.so
*.o
*.a
*.lib
*.pdb
*.mp4
*.mkv
*.wav
*.flac
+46
Voir le fichier
@@ -0,0 +1,46 @@
CONTEXTE PROJET
Environnement graphique déterministe pour ARM64 (AArch64), sur noyau Linux.
Cible de prototypage : Google Pixel 3a (nom de code sargo, Snapdragon 670,
4 Go de RAM, driver DRM msm mainline). Cible ultérieure : Poco F5 Pro
(mondrian, SD 8+ Gen 1). Le code doit rester portable entre les deux.
Le nom officiel du projet N'EST PAS ARRÊTÉ. N'en invente aucun. Utilise le
placeholder `proj3` pour les namespaces, préfixes et noms de dossiers, et
signale dans ton rapport tous les endroits où un vrai nom devra être
substitué plus tard.
TROIS PILIERS — contraintes de conception, pas des objectifs vagues
1. Déterminisme de latence. Ce qui compte n'est pas le débit moyen mais la
variance. Toute construction qui introduit une variabilité non bornée est
à rejeter, même si elle est plus rapide en moyenne.
2. Budget mémoire explicite. Aucune allocation dynamique après la phase
d'init. Tout est préalloué en arènes de taille fixe. Pas de free, pas de
realloc, pas de conteneur qui pousse.
3. Accès direct justifié. Chaque couche d'abstraction traversée doit être
justifiée explicitement. Pas de libc, pas de framework, pas de dépendance
externe. Les appels système passent par nos propres wrappers.
CONTRAINTES TECHNIQUES NON NÉGOCIABLES
- C++20, compilé avec `-nostdlib -fno-exceptions -fno-rtti -fno-threadsafe-statics`.
- Aucune dépendance externe. Aucune libc. Pas de STL (les headers purement
compile-time comme <type_traits> sont tolérés, à signaler s'ils sont utilisés).
- Zéro warning avec `-Wall -Wextra`.
- Toute dette technique, tout compromis, tout écart par rapport à ces
consignes doit être documenté explicitement dans le code ET dans le README.
Jamais implicite.
- Si une consigne te semble techniquement impossible ou contre-productive,
DIS-LE dans ton rapport au lieu de la contourner silencieusement.
MÉTHODE
- Reste strictement dans le périmètre du chantier demandé. Ne fais pas
"tant qu'on y est".
- Livrable systématique : rapport détaillé de ce qui a été fait, ce qui reste
en stub, ce qui est bloquant, et les décisions que tu as dû prendre seul.
- N'affirme jamais qu'une chose est vérifiée si tu ne l'as pas réellement
exécutée. Distingue explicitement "écrit" de "compilé" de "testé".
+192
Voir le fichier
@@ -0,0 +1,192 @@
# CMakeLists.txt — racine.
#
# DEUX CIBLES, ASYMETRIQUES ET ASSUMEES (cf. README, section "Double cible") :
#
# * cible EMBARQUEE (aarch64-linux, freestanding) : le vrai produit.
# -nostdlib, pas de libc, point d entree _start maison, syscalls maison.
# Selectionnee par -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-aarch64-linux.cmake
#
# * cible HOTE (la machine de dev, quelle qu elle soit) : outillage.
# Le harnais d oracle et les generateurs de references. Cette cible A LE
# DROIT d utiliser la libc de l hote. Elle ne produit JAMAIS de binaire
# livre. Aucun fichier compile pour la cible embarquee ne doit dependre de
# ce que la cible hote s autorise.
#
# Le partage de code entre les deux se fait uniquement par les fichiers listes
# dans proj3_portable_sources : ceux-la sont freestanding par construction.
cmake_minimum_required(VERSION 3.20)
project(proj3 LANGUAGES CXX ASM)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64")
set(PROJ3_EMBEDDED ON)
else()
set(PROJ3_EMBEDDED OFF)
endif()
# ---------------------------------------------------------------------------
# Sources portables : compilables a l identique par les deux cibles.
# Aucune de ces unites n inclut d en-tete systeme ni de libc.
# ---------------------------------------------------------------------------
set(proj3_portable_sources
src/proj3/mem/arena.cpp
src/proj3/mem/system.cpp
src/proj3/font/ttf.cpp
src/proj3/render/rasterizer.cpp
src/proj3/render/compose.cpp
)
# -fno-math-errno : sans lui, __builtin_sqrt genere un APPEL a sqrt() de la
# libm, uniquement pour pouvoir positionner errno sur une entree negative.
# Avec lui, le compilateur emet l instruction machine (fsqrt / sqrtsd) et rien
# d autre. C est indispensable en freestanding — le lien echoue sinon — et
# c est sans effet sur la precision : contrairement au reste de -ffast-math,
# cette option ne change ni le mode d arrondi, ni l associativite, ni le
# traitement des NaN. Elle est passee aux DEUX cibles, pour que l hote et la
# cible calculent rigoureusement pareil (cf. doc/methode-oracle.md).
set(proj3_common_flags
-std=c++20 -fno-exceptions -fno-rtti -fno-threadsafe-statics
-fno-math-errno
-Wall -Wextra -O2
)
# ===========================================================================
# CIBLE EMBARQUEE
# ===========================================================================
if(PROJ3_EMBEDDED)
separate_arguments(_p3_triple UNIX_COMMAND "${PROJ3_TARGET_TRIPLE_FLAGS}")
separate_arguments(_p3_linkdrv UNIX_COMMAND "${PROJ3_LINK_DRIVER_FLAGS}")
# Tout binaire embarque partage exactement le meme socle : meme _start,
# memes wrappers syscall, meme garde-fou, meme allocateur. On le factorise
# dans une fonction pour qu il soit impossible qu un executable de test
# soit construit avec des reglages differents du binaire livre.
function(proj3_add_embedded_executable target)
add_executable(${target}
asm/start.S
asm/syscall.S
asm/demo_fill_aarch64.S
src/proj3/base/cstring.cpp
src/proj3/sys/panic.cpp
src/proj3/mem/new_guard.cpp
src/proj3/mem/page_source_linux.cpp
${proj3_portable_sources}
${ARGN}
)
target_include_directories(${target} PRIVATE src)
target_compile_options(${target} PRIVATE
${_p3_triple}
$<$<COMPILE_LANGUAGE:CXX>:${proj3_common_flags}>
$<$<COMPILE_LANGUAGE:CXX>:-nostdlib;-ffreestanding;-fno-builtin>
$<$<COMPILE_LANGUAGE:ASM>:-Wall>
)
target_compile_definitions(${target} PRIVATE PROJ3_EMBEDDED=1)
target_link_options(${target} PRIVATE
${_p3_triple} ${_p3_linkdrv}
-nostdlib -nostartfiles -static -Wl,-e,_start -Wl,--build-id=none
)
endfunction()
# Le binaire livre.
proj3_add_embedded_executable(proj3_boot src/proj3/boot/main.cpp)
# Harnais des wrappers syscall (chantier 2). S execute sur n importe quel
# Linux AArch64 : Raspberry Pi, VM, conteneur, qemu-user. Pas de telephone.
proj3_add_embedded_executable(proj3_test_syscalls test/test_syscalls.cpp)
# Harnais d oracle, version embarquee : c est la SEULE facon d executer
# reellement les versions assembleur des paires. Sur l hote, seules les
# versions de reference et les paires a asm x86-64 tournent.
proj3_add_embedded_executable(proj3_oracle_target
test/oracle/oracle.cpp
test/oracle/main.cpp
test/oracle/pairs_demo.cpp
test/oracle/pairs_render.cpp)
# ===========================================================================
# CIBLE HOTE (outillage et tests seulement)
# ===========================================================================
else()
# -- Bibliotheque portable, compilee en mode hote --------------------------
add_library(proj3_portable STATIC
${proj3_portable_sources}
src/proj3/sys/panic_host.cpp
src/proj3/mem/page_source_host.cpp
)
target_include_directories(proj3_portable PUBLIC src)
target_compile_options(proj3_portable PRIVATE ${proj3_common_flags})
target_compile_definitions(proj3_portable PUBLIC PROJ3_EMBEDDED=0)
# -- Garde-fou d allocation, en bibliotheque separee -----------------------
# Separee parce qu il TUE le processus : on ne le lie que dans les
# executables qui pretendent ne rien allouer.
add_library(proj3_newguard STATIC src/proj3/mem/new_guard.cpp)
target_include_directories(proj3_newguard PUBLIC src)
target_compile_options(proj3_newguard PRIVATE ${proj3_common_flags})
enable_testing()
# -- Harnais d oracle ------------------------------------------------------
add_executable(proj3_oracle
test/oracle/oracle.cpp
test/oracle/main.cpp
test/oracle/pairs_demo.cpp
test/oracle/pairs_render.cpp
asm/host/demo_fill_x86_64.S
)
target_link_libraries(proj3_oracle PRIVATE proj3_portable proj3_newguard)
target_compile_options(proj3_oracle PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${proj3_common_flags}>)
add_test(NAME oracle COMMAND proj3_oracle)
# -- Preuve que le harnais rejette une implementation fausse ---------------
add_executable(proj3_oracle_selftest
test/oracle/oracle.cpp
test/oracle/selftest_main.cpp
test/oracle/pairs_demo.cpp
asm/host/demo_fill_x86_64.S
)
target_link_libraries(proj3_oracle_selftest PRIVATE proj3_portable)
target_compile_options(proj3_oracle_selftest PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${proj3_common_flags}>)
add_test(NAME oracle_selftest COMMAND proj3_oracle_selftest)
# -- Tests d arene ---------------------------------------------------------
add_executable(proj3_test_arena test/test_arena.cpp)
target_link_libraries(proj3_test_arena PRIVATE proj3_portable proj3_newguard)
target_compile_options(proj3_test_arena PRIVATE ${proj3_common_flags})
add_test(NAME arena COMMAND proj3_test_arena)
# -- Test du garde-fou : DOIT planter -------------------------------------
add_executable(proj3_test_newguard test/test_new_guard.cpp)
target_link_libraries(proj3_test_newguard PRIVATE proj3_portable proj3_newguard)
target_compile_options(proj3_test_newguard PRIVATE ${proj3_common_flags})
add_test(NAME new_guard_traps COMMAND proj3_test_newguard)
set_tests_properties(new_guard_traps PROPERTIES WILL_FAIL TRUE)
# -- Test de portage du rasterizer (golden) --------------------------------
add_executable(proj3_test_raster test/test_raster_golden.cpp)
target_link_libraries(proj3_test_raster PRIVATE proj3_portable proj3_newguard)
target_compile_options(proj3_test_raster PRIVATE ${proj3_common_flags})
add_test(NAME raster_golden COMMAND proj3_test_raster
"${CMAKE_CURRENT_SOURCE_DIR}/test/data/Inter-Regular.ttf"
"${CMAKE_CURRENT_SOURCE_DIR}/test/data/golden_write.txt")
# -- Generateur de references depuis Gastinel Write ------------------------
# Compile les sources ORIGINALES de Write (ttf.cpp + rasterizer.cpp, qui ne
# dependent d aucune API Windows) pour produire l oracle externe du portage.
# Optionnel : n existe que si -DPROJ3_WRITE_SRC=<chemin/src> est fourni.
if(PROJ3_WRITE_SRC)
add_executable(proj3_write_reference
tools/write_reference_dump.cpp
"${PROJ3_WRITE_SRC}/font/ttf.cpp"
"${PROJ3_WRITE_SRC}/render/rasterizer.cpp")
target_include_directories(proj3_write_reference PRIVATE "${PROJ3_WRITE_SRC}")
target_compile_features(proj3_write_reference PRIVATE cxx_std_20)
endif()
endif()
+200
Voir le fichier
@@ -0,0 +1,200 @@
# proj3
> **`proj3` est un PLACEHOLDER.** Le nom officiel du projet n est pas arrete.
> Il apparait comme prefixe de namespace, prefixe de symbole assembleur, prefixe
> de macro et nom de cible CMake. La liste exhaustive des endroits a substituer
> est en fin de ce fichier, section « Substitution du nom ».
Environnement graphique deterministe pour ARM64 (AArch64) sur noyau Linux.
Cible de prototypage : Google Pixel 3a (`sargo`). Cible ulterieure : Poco F5 Pro
(`mondrian`).
## Les trois piliers
1. **Determinisme de latence.** Ce qui compte est la variance, pas le debit
moyen. Toute construction a variabilite non bornee est rejetee, meme si elle
est plus rapide en moyenne.
2. **Budget memoire explicite.** Aucune allocation dynamique apres l init. Tout
est prealloue en arenes de taille fixe.
3. **Acces direct justifie.** Chaque couche traversee doit etre justifiee. Pas
de libc, pas de framework, pas de dependance externe.
## Arborescence
| dossier | contenu |
|---|---|
| `src/` | code C++ (`src/proj3/` : `base`, `sys`, `mem`, `font`, `render`, `boot`) |
| `asm/` | code assembleur AArch64 (`.S`) ; `asm/host/` contient la seule exception x86-64, expliquee plus bas |
| `doc/` | conventions, decisions (`doc/adr/`), notes de methode |
| `test/` | harnais de test : oracle, arenes, syscalls, portage du rasterizer |
| `tools/` | outillage de developpement (generateur de references depuis Gastinel Write) |
| `cmake/` | fichiers de toolchain de cross-compilation |
## Documents de reference
| document | ce qu il fixe |
|---|---|
| [`doc/convention-aarch64.md`](doc/convention-aarch64.md) | AAPCS64, conventions internes, nommage des symboles, regles NEON. Fait autorite sur tout `.S`. |
| [`doc/convention-syscall.md`](doc/convention-syscall.md) | remontee d erreur syscall. **Decision definitive, une seule convention.** |
| [`doc/methode-oracle.md`](doc/methode-oracle.md) | validation croisee C++ / assembleur, comment ajouter une paire |
| [`doc/memoire.md`](doc/memoire.md) | trois modes de pages, cinq arenes, garde-fou d allocation |
| [`doc/adr/`](doc/adr/) | ADR-0001 socle, ADR-0002 wrappers asm, ADR-0003 arenes, ADR-0004 portage |
## Construction
### Prerequis Debian / Ubuntu
```bash
sudo apt install cmake ninja-build
```
Puis **au choix**, une des deux familles de toolchain :
```bash
# Famille 1 (recommandee sous Debian) : GCC croise
sudo apt install g++-aarch64-linux-gnu binutils-aarch64-linux-gnu
# Famille 2 : Clang/LLVM monolithe (un seul paquet pour toutes les cibles)
sudo apt install clang lld llvm
```
Le paquet **`g++-aarch64-linux-gnu`** est celui qui fournit le
cross-compilateur `aarch64-linux-gnu-g++`. Aucun sysroot n est necessaire : le
binaire est `-nostdlib` et n a besoin d aucune bibliotheque cible.
Pour executer le harnais de syscalls sans materiel ARM :
```bash
sudo apt install qemu-user
```
### Cible embarquee (AArch64, le produit)
```bash
cmake -S . -B build-arm64 -G Ninja \
-DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-aarch64-linux.cmake
ninja -C build-arm64
```
La famille de toolchain est choisie automatiquement (GCC croise s il est
present, Clang sinon) et peut etre forcee par `-DPROJ3_TOOLCHAIN=gcc` ou
`-DPROJ3_TOOLCHAIN=clang`. **Aucun chemin n est en dur** : le fichier de
toolchain cherche dans le `PATH`.
Binaires produits :
| binaire | role |
|---|---|
| `proj3_boot` | le produit. Acquiert la memoire, journalise le mode de pages, termine avec le code 0. |
| `proj3_test_syscalls` | harnais des wrappers syscall |
| `proj3_oracle_target` | harnais d oracle, versions assembleur AArch64 comprises |
### Cible hote (outillage et tests)
```bash
cmake -S . -B build-host -G Ninja
ninja -C build-host
ctest --test-dir build-host --output-on-failure
```
### Verifier que le binaire ne depend de rien
```bash
llvm-readelf -h build-arm64/proj3_boot # Type EXEC, Machine AArch64
llvm-readelf -d build-arm64/proj3_boot # aucune section .dynamic
llvm-nm -u build-arm64/proj3_boot # aucun symbole indefini
```
(ou `readelf` / `nm` prefixes `aarch64-linux-gnu-` avec la toolchain GCC.)
### Executer le harnais de syscalls
Sur n importe quel Linux AArch64 — Raspberry Pi 64 bits, VM, conteneur — ou
sous emulation utilisateur. **Pas besoin du telephone.**
```bash
qemu-aarch64 build-arm64/proj3_test_syscalls ; echo "code=$?"
```
## Double cible : une asymetrie assumee
Il y a **deux cibles, et elles n ont pas les memes droits** :
- **Cible embarquee** (`aarch64-linux`, freestanding) : le produit. `-nostdlib`,
pas de libc, point d entree `_start` maison, syscalls maison.
- **Cible hote** (la machine de dev) : l outillage seul. **Elle a le droit
d utiliser la libc de l hote.** Elle ne produit jamais de binaire livre.
La raison est simple : le harnais d oracle doit pouvoir tourner sans telephone,
sans affichage et sans emulateur, sinon il ne sera pas execute.
La frontiere est materialisee dans `CMakeLists.txt` par la liste
`proj3_portable_sources`. Ces unites sont freestanding par construction et
compilees a l identique par les deux cibles ; ce sont les seules partagees.
Tout le reste est specifique a une cible et **le nom du fichier le dit** :
`page_source_linux.cpp` contre `page_source_host.cpp`, `panic.cpp` contre
`panic_host.cpp`.
Consequence visible : `asm/host/demo_fill_x86_64.S`. La machine de dev ne peut
pas executer de l AArch64 ; pour que la preuve « le harnais sait rejeter une
implementation fausse » puisse etre faite sur la machine de dev, la paire de
demonstration existe dans les deux jeux d instructions. **Ce doublon ne sera pas
etendu** aux vraies routines : cf. `doc/methode-oracle.md` section 7.
## Dette technique — inventaire
Rien de ce qui suit n est implicite. Chaque point est aussi documente a
l endroit du code concerne.
### Heritee de Gastinel Write, CONSERVEE VOLONTAIREMENT
| dette | ou | statut |
|---|---|---|
| **Pas de crenage** (ni `kern` ni GPOS) | `font/ttf.hpp` | volontaire cote Write, non corrigee ici |
| **Pas d antialiasing** : couverture binaire 0 ou 255 | `render/rasterizer.hpp` | volontaire cote Write, non corrigee ici |
| **Pas de hinting** : les instructions `fpgm`/`prep`/`cvt` sont ignorees | `font/ttf.hpp` | volontaire cote Write, non corrigee ici |
| Polices CFF / CFF2 / WOFF / TTC refusees | `font/ttf.cpp` | refus explicite avec message utile |
| Alignement composite par indices de points non gere | `font/ttf.cpp` | rarissime hors CJK ancien |
### Introduite ou heritee du socle
| dette | ou | pourquoi elle existe |
|---|---|---|
| `clock_gettime` passe par un vrai `svc`, **pas par le vDSO** | `asm/syscall.S` | le vDSO demande de parcourir l auxiliary vector et de resoudre un symbole ELF ; hors perimetre du chantier 2. A traiter au chantier de mesure de latence, la ou ca comptera. |
| `_start` **ne parcourt pas `.init_array`** | `asm/start.S` | le projet n a aucun constructeur statique non trivial. Verifie : `llvm-readelf -S` ne montre aucune section `.init_array` dans `proj3_boot`. Si un jour il en fallait un, l ADR-0001 devrait etre revise. |
| `memcpy` / `memset` / `memmove` / `memcmp` fournis a la main | `base/cstring.cpp` | le compilateur peut les emettre de lui-meme meme en `-ffreestanding`. Implementations naives, octet par octet : ce sont des candidats evidents pour une paire d oracle et un noyau NEON. |
| `std::hypot` remplace par un calcul naif en `double` | `base/math.hpp` | pas de libm. **Seule divergence numerique connue du portage.** Verifiee nulle sur le jeu de test golden (120 combinaisons glyphe/taille). |
| Enregistrement des paires d oracle : deux mecanismes selon la cible | `test/oracle/oracle.hpp` | section ELF `proj3_pairs` sur la cible (pas de `.init_array`), constructeur statique sur l hote (PE ne synthetise pas `__start_`/`__stop_`). |
| Une variable globale mutable : le mode de pages retenu | `mem/page_source_*.cpp` | seule entorse a « pas de `.data` mutable ». Ecrite une fois a l init, lue ensuite. Justifiee dans le fichier. |
| Le harnais d oracle detourne l arene `scanout` pour lire des fichiers | `test/test_raster_golden.cpp` | detournement local a un test, assume. |
| Pas de mesure de latence, pas de DRM/KMS, pas de `/dev/input` | — | hors perimetre : depend de verifications materielles non faites sur le Pixel 3a. |
## Licence des polices
`test/data/Inter-Regular.ttf` est distribue avec le depot pour le test de
portage du rasterizer. **Inter est sous SIL Open Font License 1.1** ; le texte
integral de la licence accompagne la police dans `test/data/OFL.txt`, comme
l OFL l exige (clause 2 : la notice de copyright et la licence doivent
accompagner toute redistribution).
Copyright (c) 2016 The Inter Project Authors — https://github.com/rsms/inter
## Substitution du nom
`proj3` doit etre remplace partout ci-dessous quand le vrai nom sera arrete :
| ou | forme |
|---|---|
| `src/proj3/` | nom du dossier |
| tous les `#include "proj3/..."` | chemin d inclusion |
| `namespace proj3` et ses sous-namespaces | `proj3::sys`, `proj3::mem`, `proj3::font`, `proj3::render`, `proj3::oracle` |
| `asm/*.S` | symboles `proj3_sys_*`, `proj3_fill_bytes_*`, `_start` (inchange) |
| `src/proj3/sys/syscall_nr.hpp` | macros `PROJ3_NR_*`, `PROJ3_AT_FDCWD` |
| `CMakeLists.txt` | `project(proj3)`, cibles `proj3_*`, variables `PROJ3_*` |
| `test/oracle/oracle.hpp` | macro `PROJ3_ORACLE_PAIR`, section ELF `proj3_pairs` |
| `mem/new_guard.cpp`, `sys/panic.cpp` | prefixe des messages `proj3:` |
| ce README et les documents de `doc/` | texte |
La section ELF `proj3_pairs` est le seul endroit ou le nom a une contrainte
technique : il doit rester un **identifiant C valide**, sans quoi l editeur de
liens ne synthetise plus `__start_` / `__stop_`.
+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
+51
Voir le fichier
@@ -0,0 +1,51 @@
# cmake/toolchain-aarch64-linux.cmake — cible finale : AArch64 / Linux, freestanding.
#
# AUCUN chemin en dur ici. Les binaires sont cherches dans le PATH, ou
# surcharges par l appelant via -DPROJ3_AARCH64_CC=... / -DPROJ3_AARCH64_CXX=...
#
# Deux familles de toolchain sont acceptees :
# 1. GCC croise Debian : aarch64-linux-gnu-gcc / -g++ (paquet g++-aarch64-linux-gnu)
# 2. Clang/LLVM monolithe : clang / clang++ -target aarch64-linux-gnu + ld.lld
#
# La famille est choisie par -DPROJ3_TOOLCHAIN=gcc|clang (defaut : gcc si
# aarch64-linux-gnu-g++ existe, clang sinon).
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR aarch64)
# Rien a lier : pas de libc, pas de sysroot. On empeche CMake de tenter un
# link de test qui echouerait faute de crt*.o.
set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
if(NOT DEFINED PROJ3_TOOLCHAIN)
find_program(_p3_gcc aarch64-linux-gnu-g++)
if(_p3_gcc)
set(PROJ3_TOOLCHAIN "gcc")
else()
set(PROJ3_TOOLCHAIN "clang")
endif()
endif()
if(PROJ3_TOOLCHAIN STREQUAL "gcc")
set(CMAKE_C_COMPILER aarch64-linux-gnu-gcc)
set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)
set(CMAKE_ASM_COMPILER aarch64-linux-gnu-gcc)
set(PROJ3_TARGET_TRIPLE_FLAGS "")
set(PROJ3_LINK_DRIVER_FLAGS "")
else()
set(CMAKE_C_COMPILER clang)
set(CMAKE_CXX_COMPILER clang)
set(CMAKE_ASM_COMPILER clang)
# clang++ n est pas utilise : on invoque clang avec -x c++ via CMake, ce qui
# evite qu il tente de lier libc++ implicitement.
set(CMAKE_CXX_COMPILER clang++)
set(PROJ3_TARGET_TRIPLE_FLAGS "--target=aarch64-linux-gnu")
set(PROJ3_LINK_DRIVER_FLAGS "-fuse-ld=lld")
endif()
set(PROJ3_TARGET_TRIPLE_FLAGS "${PROJ3_TARGET_TRIPLE_FLAGS}" CACHE INTERNAL "")
set(PROJ3_LINK_DRIVER_FLAGS "${PROJ3_LINK_DRIVER_FLAGS}" CACHE INTERNAL "")
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM BEFORE)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+109
Voir le fichier
@@ -0,0 +1,109 @@
# ADR-0001 — Socle de compilation : C++20 bride, absence de libc, double cible
- Statut : accepte
- Date : 2026-09-05
- Portee : chantier 1 (structure du depot, chaine de compilation)
## Contexte
Le projet vise un environnement graphique deterministe sur AArch64/Linux, avec
trois piliers : determinisme de latence, budget memoire explicite, acces direct
justifie. Aucune ligne de code fonctionnel n existe encore. Il faut fixer le
socle avant d ecrire quoi que ce soit, sinon les choix se prendront par defaut
et par accident.
## Decision
### 1. C++20, bride
Compile avec `-std=c++20 -nostdlib -fno-exceptions -fno-rtti
-fno-threadsafe-statics -Wall -Wextra -O2`.
- `-fno-exceptions` : une exception est un chemin de sortie de latence non
bornee (deroulement de pile, tables `.eh_frame`, allocation du bloc
d exception). Incompatible avec le pilier 1.
- `-fno-rtti` : `dynamic_cast` et `typeid` impliquent une comparaison de
chaines ou une marche de hierarchie a l execution. Le projet n a aucun
polymorphisme dynamique prevu.
- `-fno-threadsafe-statics` : sans cette option, chaque variable statique
locale non triviale genere un appel a `__cxa_guard_acquire` — donc une
dependance libc et un branchement supplementaire a chaque acces. Le projet
n a pas d initialisation statique dynamique (cf. ADR-0003 sur les arenes).
- `-O2` et non `-O3` : `-O3` active un deroulage et une vectorisation
agressifs dont le gain est incertain et le cout en taille de code (donc en
pression sur le cache d instructions, donc en variance) est reel. Le projet
optimisera par des noyaux assembleur explicites, pas par des drapeaux.
- `-Wall -Wextra` avec zero warning tolere. Aucun `-Werror` en local pour ne
pas bloquer un debogage, mais la regle est contractuelle.
Ce qui reste autorise du C++ : `constexpr`, templates, `<type_traits>` et les
autres en-tetes purement compile-time. Aucun conteneur, aucun `std::string`,
aucun flux.
### 2. Aucune libc, point d entree maison
Le binaire final est lie avec `-nostdlib -nostartfiles -static -Wl,-e,_start`.
`_start` est ecrit en assembleur (`asm/start.S`), appelle une fonction C++
unique, puis termine le processus par `exit_group` via `svc #0`.
Raison : le pilier 3. Une libc apporte un initialiseur (`__libc_start_main`),
un allocateur (`malloc`), des tampons de flux, des gestionnaires TLS et une
resolution de symboles dynamique — toutes choses dont le projet ne veut ni le
comportement memoire ni la variance. Le cout assume est qu il faut ecrire
soi-meme tout ce dont on a besoin : les wrappers syscall (chantier 2), les
routines memoire, les conversions numeriques.
Consequence non evidente, notee ici pour memoire : sans `crt1.o`, il n y a
**aucun appel aux constructeurs statiques** (`.init_array`). Le projet ne doit
donc dependre d aucune initialisation statique non triviale, ou bien
`_start` devra parcourir `.init_array` explicitement. Le choix actuel est le
premier : pas d initialisation statique dynamique du tout.
### 3. Double cible, asymetrique
- **Cible embarquee** `aarch64-linux`, freestanding : le produit.
- **Cible hote**, la machine de developpement : l outillage seul (harnais
d oracle du chantier 4, generateurs de references).
**La cible hote a le droit d utiliser la libc de l hote.** Elle ne produit
jamais de binaire livre. Cette asymetrie est deliberee : le harnais doit
pouvoir s executer sans telephone, sans affichage et sans emulateur, sinon il
ne sera pas execute.
La frontiere est materialisee dans `CMakeLists.txt` par la liste
`proj3_portable_sources`. Ces unites de compilation sont freestanding par
construction et compilees a l identique par les deux cibles ; ce sont les
seules partagees. Tout le reste est specifique a une cible et le nom du
fichier le dit (`page_source_linux.cpp` / `page_source_host.cpp`).
Risque accepte et surveille : une divergence de comportement flottant ou
d endianness entre hote x86-64 et cible AArch64 rendrait la comparaison du
harnais trompeuse. Les hypotheses correspondantes sont listees dans
`doc/methode-oracle.md` (mode d arrondi IEEE identique, little-endian des deux
cotes, pas de x87 80 bits car x86-64 utilise SSE2 pour `float`/`double`).
## Alternatives ecartees
- **Utiliser une libc minimale (musl, picolibc).** Aurait fait gagner du temps
au demarrage. Ecartee : elle reintroduit `malloc` et un initialiseur qu il
faudrait ensuite neutraliser un par un, et elle brouille la frontiere que
l ADR cherche precisement a etablir.
- **Cible unique aarch64, tests sous qemu-user.** Ecartee : ajoute une
dependance d emulation au chemin de test le plus frequent. Le harnais doit
etre trivial a lancer, sinon il pourrit.
- **Meson ou Makefile a la main.** Ecarte : CMake+Ninja donne la
cross-compilation par fichier de toolchain et un graphe de dependances
correct sans travail supplementaire. Aucun besoin exotique ici.
## Consequences
- Il faut ecrire des wrappers syscall avant tout code utile (chantier 2).
- Il faut ecrire un allocateur avant tout code de rendu (chantier 3).
- Toute tentation d appeler `memcpy` doit etre traitee : `-ffreestanding`
autorise le compilateur a **generer** des appels a `memcpy`/`memset`/
`memmove`/`memcmp` meme sans libc. Le projet doit fournir ces quatre
symboles lui-meme. C est note comme dette a traiter au moment ou un lien
echoue dessus ; a ce jour aucun appel n a ete genere (verifie par
`llvm-nm -u` sur le binaire, qui ne liste aucun symbole indefini).
- L absence de `-Werror` repose sur la discipline. Si elle se relache, on
l ajoutera.
+84
Voir le fichier
@@ -0,0 +1,84 @@
# ADR-0002 — Wrappers syscall en assembleur plutot qu en asm inline C++
- Statut : accepte
- Date : 2026-09-05
- Portee : chantier 2
## Contexte
Sans libc, il faut emettre `svc #0` soi-meme. Deux facons de le faire :
1. **Assembleur pur**, dans un `.S` : une routine par appel, assemblee telle
quelle, appelee par `bl`.
2. **Assembleur inline** dans une fonction C++ `static inline`, avec des
contraintes de registres et une liste de clobbers.
L asm inline est la solution la plus repandue — c est ce que fait musl, et ce
que font la plupart des noyaux unikernel. Elle merite donc une justification
explicite d etre ecartee.
## Decision
**Assembleur pur, dans `asm/syscall.S`.**
## Ce que ca coute
- **Un appel de fonction par syscall.** L asm inline se serait fondu dans
l appelant : pas de `bl`, pas de `ret`, et le compilateur aurait pu ordonner
les instructions autour du `svc`. On paie donc environ deux instructions et
une prediction de branchement par appel. Sur un `svc` qui coute plusieurs
centaines de cycles de transition en mode noyau, c est du bruit — mais c est
un cout reel, et il faut le nommer.
- **Aucune propagation de constantes a travers le wrapper.** Le compilateur ne
voit qu un appel opaque : il ne peut pas savoir que `sys::write(2, s, n)`
utilise toujours le meme descripteur, ni eliminer un appel mort.
- **Deux endroits a tenir a jour** pour ajouter un appel : le `.S` et le `.hpp`.
## Ce que ca apporte
1. **Le contrat de registres est verifiable a l oeil.** Une routine de trois
instructions est lisible dans un desassemblage et se compare directement a
`arch/arm64/kernel/entry.S`. Une contrainte inline `"r"(x)` avec une liste
de clobbers est un contrat entre nous et l optimiseur, et ce contrat est
silencieux quand il est faux.
2. **Pas de dependance au comportement de l optimiseur.** L asm inline peut
etre duplique, deplace, ou sorti d une boucle par le compilateur s il juge
le bloc pur. Il faut alors `volatile` et une liste de clobbers `"memory"`
exacte, sous peine de bugs qui n apparaissent qu a `-O2` et pas a `-O0`.
C est exactement le genre de non-determinisme que le pilier 1 rejette.
3. **Cout constant, mesurable, identique a chaque site d appel.** Avec l asm
inline, le code genere autour du `svc` depend du contexte : le cout du
wrapper varie d un appel a l autre. Ici il est le meme partout.
4. **Alignement de pile garanti par construction.** Aucun wrapper ne touche a
`sp` ni n empile `x30`. Il n y a donc rien a verifier : la contrainte des
16 octets de l AAPCS64 est respectee parce qu il n existe pas de code pour
la violer.
5. **Une macro assure l uniformite.** `PROJ3_SYSCALL_DIRECT` emet les quatorze
wrappers directs a l identique. Il est structurellement impossible que l un
d eux ait un prologue ou une transformation qui traine.
## Consequences
- Les numeros d appel sont dans `src/proj3/sys/syscall_nr.hpp`, inclus par le
`.S` (qui est preprocesse). Ils ne sont jamais ecrits en dur dans le corps
d une routine.
- La valeur de retour n est pas transformee dans le wrapper (cf.
`doc/convention-syscall.md`, option C). Le `.S` se limite a
`mov x8, #N` puis `svc #0` puis `ret`.
- `open` est le seul wrapper qui remanie ses arguments : la table generique
AArch64 n a pas de `__NR_open`, seulement `openat`. Il decale les quatre
arguments et injecte `AT_FDCWD`. C est documente dans le fichier, et c est
pour cela qu il n utilise pas la macro.
- Si un jour le cout de l appel devenait mesurable sur un chemin chaud — ce qui
demanderait un syscall dans une boucle serree, situation que le projet
cherche a eviter par ailleurs — la reponse serait de supprimer le syscall,
pas de l inliner.
## Alternatives ecartees
- **`asm volatile` inline avec contraintes.** Ecartee pour les raisons 1, 2 et
3 ci-dessus.
- **Une seule routine generique `syscall(nr, a, b, c, d, e, f)`.** Ecartee :
elle oblige a decaler sept arguments a chaque appel, elle perd le typage des
arguments, et elle rend le desassemblage illisible (tous les appels se
ressemblent).
+93
Voir le fichier
@@ -0,0 +1,93 @@
# ADR-0003 — Arene lineaire plutot qu allocateur generaliste
- Statut : accepte
- Date : 2026-09-05
- Portee : chantier 3
## Contexte
Le projet doit fournir de la memoire au rasterizer, a l atlas de glyphes, au
scanout et aux tampons d entree. La solution reflexe serait un allocateur
generaliste — un `malloc` maison : listes libres par classe de taille, ou
allocateur de dalles.
## Decision
**Un allocateur d arene lineaire (bump allocator), sans liberation
individuelle, sur des arenes de taille fixe decidees a la compilation.**
## Justification par les piliers
### Pilier 1 — determinisme de latence
Un allocateur generaliste a un cout d allocation **variable et non borne** : il
depend de l etat de fragmentation, donc de tout l historique du programme. Deux
executions identiques n ont pas la meme latence. Pire, le cout du pire cas
(fusion de blocs adjacents, parcours d une liste libre longue) arrive rarement
— donc au plus mauvais moment, et de facon irreproductible.
Une arene alloue en **une addition et un masque**. Le cout est constant, connu,
et identique a la millionieme allocation comme a la premiere. Il n y a pas de
fragmentation parce qu il n y a pas de trous.
### Pilier 2 — budget memoire explicite
Un allocateur generaliste rend la question « combien ce programme
consomme-t-il ? » difficile a repondre : le pic depend de l ordre des
allocations. Avec des arenes de taille `constexpr`, la reponse est dans
`mem/layout.hpp` et elle est verifiee a la compilation.
Surtout : un allocateur generaliste **peut echouer tard**. Une arene, elle,
echoue **fort et tout de suite**, avec le nom de l arene et le calcul a
corriger.
### Pilier 3 — acces direct justifie
Un allocateur generaliste est une couche d abstraction de plusieurs centaines
de lignes, avec ses propres invariants et ses propres bugs. Une arene, c est un
pointeur et une capacite. Il n y a rien a justifier parce qu il n y a presque
rien.
## Ce que ca coute — honnetement
1. **Aucune liberation individuelle.** Un objet a duree de vie courte au milieu
d objets a duree de vie longue occupe sa place jusqu au prochain `reset()`
de son arene. Il faut donc **penser les durees de vie par lot**, et c est
une discipline reelle : elle se voit dans la conception, pas seulement dans
l implementation.
2. **Le decoupage doit etre juste.** Cinq arenes signifient cinq calculs qui
peuvent etre faux. Un allocateur generaliste aurait absorbe un mauvais
dimensionnement au prix de la latence. Ici, un mauvais dimensionnement
plante. C est voulu : `Arena::peak()` existe pour confronter le calcul a la
realite.
3. **Pas de reutilisation entre arenes.** Si l atlas est plein alors que la
geometrie est vide, on ne peut pas emprunter. Une arene unique partagee
eviterait cela, mais rendrait toute analyse d occupation impossible. On
prefere savoir.
4. **`mark()` / `rewind_to()` est un couteau.** Rembobiner invalide tout ce qui
a ete alloue apres la marque, sans que rien ne le signale. Un pointeur garde
au-dela d un rewind est un usage-apres-liberation classique. Le projet
confine ce motif au harnais et au rasterizer, ou la portee est locale et
visible en entier.
## Alternatives ecartees
- **Allocateur de dalles (slab) par type.** Aurait donne un cout constant lui
aussi, et permis la liberation individuelle. Ecarte : il faut une liste libre
par type, donc de l etat mutable par type, et le dimensionnement de chaque
dalle pose exactement le meme probleme que celui des arenes — avec plus de
code.
- **Allocateur de pile unique pour tout le programme.** C est une arene, avec
une seule arene. Ecarte parce qu on perd la ventilation par usage, donc la
capacite de dire quelle partie du programme consomme quoi.
- **Un vrai `malloc`.** Ecarte : cf. pilier 1.
## Consequences
- Le rasterizer porte de Gastinel Write ne peut plus faire croitre un
`std::vector` d aretes : il a un plafond (`kMaxEdges`) et un depassement est
un echec explicite. C est un changement de comportement par rapport a
l original, documente dans `render/rasterizer.hpp`.
- Le garde-fou `operator new` (cf. `doc/memoire.md`) est le complement
indispensable de cette decision : sans lui, une allocation cachee
reintroduirait par la fenetre ce que l arene interdit par la porte.
+92
Voir le fichier
@@ -0,0 +1,92 @@
# ADR-0004 — Portage du rasterizer de Gastinel Write
- Statut : accepte
- Date : 2026-09-05
- Portee : chantier 5
## Contexte
Gastinel Write contient un parser TTF maison et un rasterizer scanline nonzero
winding, valides glyphe par glyphe sur Windows. Les reecrire serait du travail
perdu et introduirait des bugs dans du code qui n en a plus.
## Decision
**On porte, on ne reecrit pas.** L algorithme est conserve pas a pas ; ce qui
change est l environnement, pas le calcul.
Changements effectues, et rien d autre :
| ce qui change | pourquoi | ou |
|---|---|---|
| `std::vector` / `std::string` vers arenes | pilier 2 ; le garde-fou tuerait le processus sinon | partout |
| lecture de fichier retiree de `TtfFont` | `fopen` est de la libc ; l appelant fournit un tampon | `font/ttf.hpp` |
| `std::sort` vers heapsort maison | cout pire cas borne (pilier 1) | `base/sort.hpp` |
| `std::hypot` vers calcul naif en `double` | pas de libm | `base/math.hpp` |
| `std::floor` / `ceil` / `lround` vers equivalents maison | pas de libm | `base/math.hpp` |
| composition separee de la rasterization | rend les noyaux NEON possibles | `render/compose.hpp` |
| plafond d aretes au lieu d un vector qui pousse | une allocation en plein rendu est interdite | `render/rasterizer.hpp` |
## La separation couverture / composition
C est le seul changement de **structure**, et il est delibere.
Dans Write, la rasterization et l ecriture dans le DIB Win32 etaient voisines,
et le format BGRA du DIB s etait infiltre dans le raisonnement. Ici :
- `render/rasterizer.cpp` produit de la **couverture** : une valeur par pixel,
aucune notion de couleur ni de format ;
- `render/compose.cpp` — et lui seul — connait le format de destination
(XRGB8888, celui d un plan DRM).
Sans cette separation, un futur noyau NEON de composition obligerait a toucher
au rasterizer, donc a invalider sa validation.
## La dette technique heritee est CONSERVEE
Le rasterizer de Write assume explicitement : **pas de crenage, pas
d antialiasing (couverture binaire), pas de hinting**. Ces choix sont
documentes et volontaires cote Write.
**Ils ne sont pas corriges dans ce chantier.** L avis du portage figure dans le
rapport de chantier, pas dans le code, et aucun de ces trois points n a ete
modifie.
## Hypotheses qui changent en quittant x86 Windows
- **Endianness.** Le format TrueType est big-endian et le parser le lit octet
par octet : il est insensible a l endianness de la machine, hier comme
aujourd hui. En revanche la **composition** manipule des `u32` de pixel et
suppose le little-endian ; l hypothese est verifiee par `static_assert` sur
`__BYTE_ORDER__` dans `base/types.hpp` et rappelee dans `render/compose.hpp`.
- **Alignement.** x86-64 tolere les acces desalignes ; AArch64 les tolere pour
les acces ordinaires mais **pas** pour ceux qui utilisent `sp` comme base, et
les futurs noyaux NEON auront des chemins distincts selon l alignement.
`compose_coverage` verifie donc explicitement l alignement 4 octets du
framebuffer au lieu de le supposer.
- **Pile.** Le code d origine allouait des tableaux temporaires par `vector`.
Le portage ne les a pas transformes en tableaux de pile : `GlyphBuilder`
porte les tampons de travail (points, drapeaux, fins de contours) dans une
arene, parce qu une pile sans libc n a pas de page de garde automatique.
## Verification
Le portage n est pas « plausible », il est **verifie** :
`tools/write_reference_dump.cpp` compile les sources **originales** de Write
(`font/ttf.cpp` et `render/rasterizer.cpp`, qui ne dependent d aucune API
Windows) et vide leurs sorties dans un format texte.
`test/test_raster_golden.cpp` compare, octet par octet, la sortie du code porte
a cette reference.
C est ce qui transforme la divergence potentielle de `std::hypot` d un risque
en un fait mesure.
## Alternatives ecartees
- **Reecrire depuis la specification TrueType.** Ecarte : c est refaire le
travail de validation glyphe par glyphe deja fait.
- **Garder `std::vector` et n interdire l allocation qu apres l init.** Ecarte :
la frontiere « apres l init » n est pas verifiable mecaniquement, alors que
« jamais » l est, par le garde-fou.
- **Porter aussi la composition telle quelle depuis le backend GDI.** Ecarte :
cf. la separation ci-dessus.
+200
Voir le fichier
@@ -0,0 +1,200 @@
# Convention de registres AArch64 — reference normative du projet
Ce document fait autorite sur tout fichier `.S` du depot. Toute routine
assembleur qui s en ecarte doit le declarer en commentaire d en-tete, avec la
raison.
Cible : AArch64 (ARMv8-A, A64 uniquement, pas de Thumb, pas d AArch32),
Linux, ABI LP64.
---
## 1. Rappel AAPCS64 (Procedure Call Standard for the Arm 64-bit Architecture)
### 1.1 Registres generaux
| Registre | Role AAPCS64 | Sauvegarde |
|-----------|--------------|-----------|
| `x0`-`x7` | Arguments entiers/pointeurs 1 a 8, et valeurs de retour (`x0`, ou `x0`+`x1` pour 128 bits) | caller-saved |
| `x8` | Adresse du resultat indirect (XR) quand la valeur de retour est trop grosse pour les registres. **Sous Linux c est aussi le registre du numero de syscall.** | caller-saved |
| `x9`-`x15`| Temporaires | caller-saved |
| `x16` (IP0), `x17` (IP1) | Registres d appel intra-procedure, utilisables par l editeur de liens pour les veneers. Ne jamais supposer qu ils survivent a un `bl`. | caller-saved |
| `x18` | Registre de plateforme. Sous Linux ELF il est libre, mais d autres environnements (Windows, Darwin, certains SDK) le reservent. **Regle du projet : `x18` est interdit d usage.** Cout nul, portabilite gagnee. | reserve |
| `x19`-`x28` | Variables locales | **callee-saved** |
| `x29` (FP) | Pointeur de trame | **callee-saved** |
| `x30` (LR) | Registre de lien : adresse de retour deposee par `bl`/`blr` | **callee-saved** (a empiler des qu on appelle soi-meme) |
| `sp` | Pointeur de pile. Ce n est pas `x31`. | special |
| `xzr`/`wzr` (encodes 31) | Registre zero : lit 0, absorbe les ecritures | special |
`w0`-`w30` sont les moities basses 32 bits. **Ecrire dans `wN` met a zero les
32 bits hauts de `xN`.** C est une source de bugs classique quand on manipule
un `int` puis qu on l utilise comme offset 64 bits : il faut un `sxtw` explicite
pour l extension de signe.
### 1.2 Pile
- `sp` doit etre **aligne sur 16 octets** a chaque frontiere d appel public
(`bl`, `ret`) et a chaque acces memoire qui l utilise comme base. Un `sp`
desaligne provoque un `SIGBUS` sur AArch64 : ce n est pas une penalite de
performance, c est un plantage.
- La pile croit vers le bas. Prologue standard :
```asm
stp x29, x30, [sp, #-16]! // empile FP+LR, decremente sp de 16
mov x29, sp
// ... corps ...
ldp x29, x30, [sp], #16 // depile, reincremente sp
ret
```
- Il n existe **pas de red zone** en AAPCS64 : la memoire sous `sp` peut etre
ecrasee a tout instant (signal, debogueur). Toute donnee temporaire doit etre
au-dessus de `sp` apres decrement.
- Reserver de la place se fait en un seul `sub sp, sp, #N` avec N multiple de 16.
### 1.3 Arguments qui ne tiennent pas dans les registres
Au-dela de 8 arguments entiers, les suivants passent sur la pile, alignes sur
8 octets, dans l ordre de declaration, a partir de `[sp]` au moment de l appel.
Le projet **n a aucune routine a plus de 8 arguments** ; si le cas se presente,
c est un signal de conception, pas un probleme d ABI a resoudre.
### 1.4 Registres vectoriels (NEON / SIMD, `v0`-`v31`)
| Registre | Role AAPCS64 | Sauvegarde |
|-----------|--------------|-----------|
| `v0`-`v7` | Arguments flottants/vectoriels 1 a 8, valeurs de retour | caller-saved |
| `v8`-`v15`| Variables locales — **mais seuls les 64 bits BAS (`d8`-`d15`) sont callee-saved.** Les 64 bits hauts sont caller-saved. | **partiellement callee-saved** |
| `v16`-`v31` | Temporaires | caller-saved |
Le point `v8`-`v15` est le piege classique : une routine qui utilise `v8` en
128 bits complet doit sauvegarder `d8`, pas `v8`, pour respecter l ABI — et si
elle veut preserver les 128 bits pour son propre compte, c est son affaire,
pas celle de l appelant.
**Regle du projet :** dans une routine A64 exposee (`.global`), on **n utilise
pas du tout `v8`-`v15`**. On dispose de 24 registres vectoriels caller-saved
(`v0`-`v7`, `v16`-`v31`), ce qui suffit largement pour tous les noyaux de
composition prevus, et cela supprime entierement la question de la
sauvegarde/restauration vectorielle. Si un noyau futur demande plus de 24
registres vectoriels, c est que son ordonnancement est a revoir.
`fpsr`/`fpcr` : aucune routine du projet ne modifie le mode d arrondi ni les
drapeaux d exception flottante. Le mode d arrondi est **round-to-nearest-even**,
suppose etabli au demarrage et jamais touche. Cette hypothese est ce qui rend
valide la comparaison octet-a-octet du harnais d oracle (cf. `methode-oracle.md`).
---
## 2. Conventions internes aux routines qui ne suivent pas l AAPCS64
Certaines routines de rendu sont des **feuilles** (elles n appellent personne)
et sont appelees exclusivement depuis d autres routines assembleur du meme
fichier. Pour celles-la seulement, on s autorise une convention allegee.
### 2.1 Classe "routine feuille interne" (suffixe `__leaf`, symbole local `.L`)
Contraintes :
1. Elle **n emet aucun `bl`/`blr`**. Consequence : elle n a pas a empiler `x30`.
2. Elle **ne touche pas a `sp`** du tout. Pas de trame, pas de spill. Si elle a
besoin de spiller, elle n est pas une feuille : on la promeut en routine
AAPCS64 normale.
3. Registres qu elle peut ecraser librement : `x0`-`x17` (sauf `x18`, interdit),
`v0`-`v7`, `v16`-`v31`.
4. Registres qu elle doit laisser intacts : `x19`-`x30`, `sp`, `v8`-`v15`.
Autrement dit : **la convention interne n autorise pas a casser plus que
l AAPCS64 n autorise deja.** Elle autorise seulement a *omettre* le
prologue/epilogue.
5. Elle documente en en-tete : ses entrees (registre par registre), ses sorties,
et la liste exacte des registres qu elle detruit.
Ce choix est deliberement conservateur. Une convention exotique
(`x19` accumulateur global, par exemple) ferait gagner un registre et couterait
une classe entiere de bugs non reproductibles a chaque insertion d appel. Le
pilier 1 (determinisme) inclut le determinisme du debogage.
### 2.2 Registres a usage reserve global
**Il n y en a aucun.** Aucun registre ne porte de valeur vivante entre deux
routines du projet. Pas de pointeur de contexte permanent en `x28`, pas de base
de framebuffer en `x27`.
Raison : un registre reserve globalement est un etat cache. Il oblige chaque
nouvelle routine a connaitre une convention non exprimee dans sa signature, et
il rend tout appel vers du code externe (ou genere par le compilateur)
potentiellement destructeur. Le gain — economiser un `ldr` par routine — est
sans commune mesure avec le cout.
Cette decision est **definitive**. Si elle devait etre revue, ce serait par un
ADR dedie, pas par un commentaire dans un `.S`.
---
## 3. Nommage des symboles et visibilite
### 3.1 Nommage
- Tout symbole assembleur visible depuis le C++ est declare `extern "C"` cote
C++ et prefixe `proj3_` cote assembleur.
- Forme : `proj3_<module>_<action>`, en minuscules, mots separes par `_`.
Exemples : `proj3_sys_write`, `proj3_fill_bytes_asm`.
- Les routines qui sont la version assembleur d une paire d oracle portent le
suffixe `_asm`. La version C++ de reference porte le suffixe `_ref`.
Une version volontairement fausse (test du harnais) porte `_asm_broken`.
- Les symboles locaux a un fichier commencent par `.L` : l assembleur ne les
emet pas dans la table des symboles, ils n apparaissent donc ni dans `nm` ni
dans les traces.
- Les etiquettes de boucle internes sont `.L<routine>_<role>` :
`.Lfill_bytes_loop`, `.Lfill_bytes_tail`. Jamais `1:` / `1b`, illisible en
revue.
### 3.2 Visibilite — boilerplate obligatoire
Toute routine exportee est declaree exactement ainsi :
```asm
.text
.balign 4
.global proj3_exemple
.hidden proj3_exemple // pas d export dynamique : rien a interposer
.type proj3_exemple, %function
proj3_exemple:
// ...
ret
.size proj3_exemple, . - proj3_exemple
```
- `.balign 4` : toutes les instructions A64 font 4 octets ; l alignement
explicite protege des sections concatenees a la main.
- `.hidden` : le binaire est statique et sans libc, aucune interposition n a de
sens. Cela evite au passage toute entree de PLT.
- `.type`/`.size` : necessaires pour que `llvm-objdump`, `perf` et un debogueur
retrouvent les bornes de la fonction. Un `.size` manquant donne des profils
inexploitables — ce qui, sur un projet dont la these est la mesure de latence,
est disqualifiant.
### 3.3 Sections
- Code : `.text`.
- Constantes en lecture seule : `.section .rodata,"a",@progbits`.
- **Aucune section `.data` ni `.bss` dans un fichier `.S`.** Toute donnee
mutable vit dans une arene (cf. chantier 3). Un `.S` qui declare de l etat
mutable contourne le budget memoire explicite du pilier 2.
- Aucun fichier `.S` n emet de section a la fois executable et inscriptible.
- Chaque `.S` se termine par `.section .note.GNU-stack,"",@progbits` afin que
l editeur de liens ne marque pas la pile executable.
---
## 4. Notes de portabilite entre les deux cibles materielles
- Pixel 3a (`sargo`) : Snapdragon 670, coeurs Kryo 360 (Cortex-A75/A55),
ARMv8.0-A avec extensions ARMv8.2 partielles. **Ne pas supposer** la presence
de LSE (atomiques `casal`), de dotprod, ni de FP16 arithmetique.
- Poco F5 Pro (`mondrian`) : SD 8+ Gen 1, ARMv8.4+, beaucoup plus riche.
- **Regle : le code assembleur ecrit ne suppose que la base ARMv8.0-A + NEON.**
Toute utilisation d une extension doit passer par une detection au runtime
(lecture de `AT_HWCAP` dans l auxiliary vector) et un chemin de repli, sur le
modele du repli memoire du chantier 3. Aucune extension n est utilisee a ce
jour.
+152
Voir le fichier
@@ -0,0 +1,152 @@
# Convention de remontee d erreur syscall — decision definitive
Statut : **arrete**. Une seule convention dans tout le projet. Tout code qui
appelle un wrapper syscall suit celle-ci, sans exception ni variante locale.
---
## 1. Le probleme
Le noyau Linux ne dispose pas d `errno`. Sur AArch64, `svc #0` place dans `x0`
soit le resultat de l appel, soit **l oppose du code d erreur**. Un resultat
est une erreur si et seulement si :
```
-4095 <= x0 <= -1
```
La borne `-4095` n est pas decorative : `MAX_ERRNO` vaut 4095 dans le noyau
(`include/linux/err.h`), et c est exactement ce que fait la macro
`IS_ERR_VALUE`. Certains appels retournent legitimement des valeurs negatives
hors de cette plage — `lseek` sur un fichier de plus de 8 exaoctets, `mmap`
retournant une adresse dont le bit 63 est a 1 sur une configuration a 64 bits
d espace utilisateur. Un test approximatif du genre `if (ret < 0)` est donc
**faux**, pas seulement imprecis.
C est la libc qui, normalement, traduit cela en `-1` + `errno`. Sans libc,
il faut choisir.
---
## 2. Options envisagees
### Option A — Valeur sentinelle plus etat global (mimer errno)
Le wrapper retourne `-1` en cas d echec et depose le code dans une variable
globale `proj3_last_errno`.
| Pilier | Evaluation |
|---|---|
| 1. Determinisme de latence | Neutre en soi, mais impose une variable globale mutable. Des qu on aura plus d un fil d execution ou un gestionnaire de signal, il faut du stockage par contexte : c est le chemin qui mene a `__errno_location()`, donc a un appel indirect non inlinable sur le chemin chaud. |
| 2. Budget memoire explicite | Une section `.data`/`.bss` mutable hors arene. Contredit directement la regle "toute donnee mutable vit dans une arene" (`convention-aarch64.md` 3.3). |
| 3. Acces direct justifie | C est reconstruire la couche libc qu on a explicitement decide de ne pas avoir. Abstraction non justifiee. |
Verdict : **rejetee**. Elle detruit l information (deux appels, le second
ecrase le code du premier) et introduit un etat global cache.
### Option B — Structure de retour `{ valeur, code_erreur }`
Le wrapper retourne un agregat de deux `i64`.
| Pilier | Evaluation |
|---|---|
| 1. Determinisme de latence | Un agregat de 16 octets rentre dans `x0`+`x1` en AAPCS64, donc pas de retour indirect ni de trafic memoire. Cout nul en theorie. En pratique, cela oblige chaque wrapper assembleur a produire deux registres, donc a tester la plage d erreur **dans** le wrapper : une comparaison et un `csel` par appel, meme quand l appelant ignore l erreur. |
| 2. Budget memoire | Rien a allouer. Correct. |
| 3. Acces direct | La valeur brute rendue par le noyau est deja porteuse des deux informations. Les scinder puis les recombiner cote appelant est du travail ajoute pour rien. |
Verdict : **rejetee**, mais de peu. Le seul reproche serieux est le travail
inconditionnel dans le wrapper alors que la meme information est disponible
gratuitement.
### Option C — Valeur brute du noyau, encapsulee dans un type a cout nul
Le wrapper retourne exactement ce que `svc #0` a mis dans `x0`, tel quel. Cote
C++, ce `i64` est enveloppe dans une structure d un seul membre,
`proj3::sys::Result`, dont toutes les methodes sont `constexpr` et inlinees :
`is_err()`, `err()`, `value()`, `ptr()`, `fd()`.
| Pilier | Evaluation |
|---|---|
| 1. Determinisme de latence | Le wrapper assembleur ne fait **rien** apres le `svc` : `svc #0 ; ret`. Cout strictement minimal et constant. Le test de plage n est paye que par l appelant qui le demande. |
| 2. Budget memoire | Aucun etat, aucune allocation, aucune section mutable. |
| 3. Acces direct | Zero couche : la valeur traversee est celle du noyau, bit pour bit. La structure n existe qu au niveau du type, pas a l execution (`sizeof == 8`, trivialement copiable, passee en registre). |
Verdict : **retenue.**
---
## 3. Convention retenue
### 3.1 Cote assembleur
Chaque wrapper est de la forme :
```asm
proj3_sys_<nom>:
mov x8, #PROJ3_NR_<nom>
svc #0
ret
```
Aucune transformation. La valeur de retour est le `x0` du noyau.
Consequence directe : **aucun wrapper n a de prologue, ne touche a `sp`, ni
n empile `x30`.** L alignement de pile est preserve trivialement.
### 3.2 Cote C++
```cpp
namespace proj3::sys {
// Valeur de retour brute d un appel systeme Linux.
// sizeof == 8, trivialement copiable : passee et rendue en registre.
struct Result {
i64 raw;
// Plage d erreur exacte du noyau : [-4095, -1]. Ni approximative,
// ni "raw < 0".
constexpr bool is_err() const { return raw < 0 && raw >= -4095; }
constexpr bool is_ok() const { return !is_err(); }
// Code errno positif. Precondition : is_err().
constexpr i32 err() const { return static_cast<i32>(-raw); }
// Valeur utile. Precondition : is_ok().
constexpr i64 value() const { return raw; }
constexpr i32 fd() const { return static_cast<i32>(raw); }
void* ptr() const { return reinterpret_cast<void*>(raw); }
};
}
```
### 3.3 Regles d usage — obligatoires
1. **Toute valeur `Result` est testee avec `is_err()` avant tout usage de
`value()`, `fd()` ou `ptr()`.** Il n existe pas de conversion implicite vers
un entier ou un booleen : le type ne se laisse pas utiliser par accident.
2. **Ignorer un `Result` est explicite.** Le type est marque
`[[nodiscard]]` ; l ignorer demande d ecrire `(void)`. Le seul cas ou c est
legitime est `close()` en chemin de sortie.
3. **Aucun code du projet ne stocke un `errno`.** Un code d erreur est traite
la ou il apparait : soit il est recuperable et le chemin de repli est pris
sur place (c est le cas du repli `MAP_HUGETLB` -> THP -> `mmap` simple),
soit il ne l est pas et on appelle `panic()` avec le nom de l appel et le
code. Rien n est mis de cote pour plus tard.
4. **`EINTR` n est jamais reessaye en boucle silencieuse.** Une boucle de
retry est une latence non bornee, donc une violation du pilier 1. Le projet
n installe aucun gestionnaire de signal ; si `EINTR` apparait, c est un
evenement inattendu et il doit remonter.
5. Les constantes `errno` utilisees sont definies dans
`src/proj3/sys/errno.hpp`, avec leur source. On ne definit que celles qu on
teste effectivement.
### 3.4 Ce que cette convention coute
- L appelant doit se souvenir que `mmap` peut legitimement rendre un pointeur
dont la valeur signee est negative hors plage d erreur. `is_err()` gere ce
cas correctement, mais un appelant qui ecrirait `if (r.raw < 0)` a la main
aurait tort. C est le seul piege, et il est nomme ici.
- Il n y a pas de message d erreur lisible associe a un code. On imprime le
numero. Une table `errno -> chaine` couterait plusieurs kilooctets de
`.rodata` pour du confort de debogage ; si elle devient necessaire, elle sera
conditionnee a un build de debogage, par un ADR.
+187
Voir le fichier
@@ -0,0 +1,187 @@
# Memoire — trois modes de pages, cinq arenes, un garde-fou
## 1. Les trois modes, et ce qu ils valent
L acquisition des pages (`src/proj3/mem/page_source_linux.cpp`) essaie trois
chemins **dans l ordre**, au demarrage, **dans un seul binaire** :
| ordre | appel | mode retenu |
|---|---|---|
| 1 | `mmap(MAP_HUGETLB \| MAP_HUGE_2MB)` | `HugeMode::Hugetlb2MB` |
| 2 | `mmap` classique puis `madvise(MADV_HUGEPAGE)` | `HugeMode::TransparentHuge` |
| 3 | `mmap` classique seul | `HugeMode::PlainPages` |
C est exactement l esprit du repli OpenGL/GDI de Gastinel Write : detection au
runtime, un seul binaire, aucune question a l utilisateur, et le mode
effectivement retenu est journalise et interrogeable par le programme.
### Ils n ont PAS les memes proprietes de determinisme
C est le point central, pas une note de bas de page.
**`Hugetlb2MB`** — les pages viennent du pool hugetlbfs, reservees d avance.
Elles ne sont ni deplacees, ni fusionnees, ni recuperees, ni scindees. Une
entree de TLB couvre 2 Mo. **Les mesures de latence faites dans ce mode sont
valides.**
**`TransparentHuge`** — le noyau *peut* promouvoir la region en huge pages, ou
pas. Il le fait par un fil de fond, `khugepaged`, dont l ordonnancement nous
echappe totalement. Une promotion — ou une scission — peut se produire
**pendant** une mesure. **Toute mesure de latence faite dans ce mode porte une
barre d erreur inconnue** et doit etre annotee comme telle. Le mode est
utilisable, le chiffre qui en sort ne l est pas sans reserve.
**`PlainPages`** — pages de 4 Ko. Comportement previsible, mais couvrir les
9,6 Mo de scanout demande environ 2342 entrees de TLB, ce qui depasse la TLB
de second niveau d un Cortex-A75. Les manques de TLB deviennent alors une
source de variance mesurable. **Le mode est correct, pas rapide.**
**`HostEmulated`** — cible hote uniquement, memoire fournie par `malloc`.
Aucune garantie d aucune sorte. Ce mode existe pour que le harnais tourne sur
la machine de dev, et pour qu il soit **impossible** de confondre un chiffre
obtenu sur un x86 de bureau avec un chiffre obtenu sur le telephone.
### Savoir lequel est actif
```cpp
#include "proj3/mem/page_source.hpp"
proj3::mem::HugeMode m = proj3::mem::active_mode();
const char* nom = proj3::mem::huge_mode_name(m); // "HUGETLB-2MB", ...
bool mesurable = proj3::mem::mode_is_deterministic(m); // true pour Hugetlb2MB seul
proj3::mem::log_active_mode(); // journalise + avertit
```
`log_active_mode()` ecrit sur la sortie d erreur, au demarrage, quelque chose
comme :
```
proj3: memoire : mode retenu = PAGES-4K
proj3: memoire : ATTENTION, pages NON garanties.
proj3: memoire : toute mesure de latence faite dans ce mode
proj3: memoire : porte une barre d erreur inconnue.
```
### Attention : `MAP_HUGETLB` n est pas suppose disponible
Sa presence sur le noyau stock du Pixel 3a **n a pas ete verifiee
materiellement**. Sur un noyau Android par defaut, `nr_hugepages` vaut zero et
le pool est vide : le chemin 1 echouera avec `ENOMEM`. C est precisement
pourquoi le repli existe et pourquoi il est teste des le premier demarrage.
`MAP_HUGE_2MB` est passe explicitement. Sans lui, `MAP_HUGETLB` utilise la
taille de huge page par defaut du systeme, qui peut valoir 512 Mo sur certaines
configurations arm64 — l appel echouerait alors pour une raison difficile a
diagnostiquer.
## 2. Les cinq arenes
Un **seul** `mmap` est fait, puis decoupe. Raison : le repli huge pages ne vaut
que sur une region contigue. Cinq `mmap` separes auraient cinq modes
potentiellement differents, et la question « quel mode est actif ? » n aurait
plus de reponse unique.
Toutes les tailles sont dans `src/proj3/mem/layout.hpp`, en `constexpr`, avec
leur calcul. Dimensionnement **Pixel 3a : 4 Go de RAM, 1080x2220**.
| arene | taille | calcul |
|---|---:|---|
| `scanout` | 19 185 664 | `1080*2220*4 = 9 590 400` par tampon, arrondi a la page (9 592 832), **deux** tampons. Double buffering, pas triple : un troisieme tampon ajoute une image entiere de latence, ce que le projet combat. |
| `geometrie` | 2 097 152 | Une arete = 20 octets. Pire cas raisonne : ~600 points de contour, chaque quadratique subdivisee au plus 64 fois -> 38 400 aretes = 768 000 octets. 2 Mo laisse la place d y ajouter un trace d interface dans la meme passe. |
| `atlas` | 2 097 152 | Couverture 8 bits. Trois corps (16/24/32 px), cellule `(corps+2)^2` : 324 + 676 + 1156 = 2156 octets par glyphe. 256 glyphes (Latin-1 + ponctuation) = 551 936 octets. Facteur 3,8 de marge pour un quatrieme corps ou une graisse. |
| `entree` | 131 072 | Evenement normalise = 32 octets. Ecran tactile : ~200 evt/s par contact, 10 contacts = 2000 evt/s. 4096 emplacements = plus de deux secondes de rafale. |
| `scratch` | 2 097 152 | Remis a zero a chaque image. Majorant des intersections de balayage : 38 400 croisements de 8 octets = 307 200 octets, plus les tampons de composition par tuiles. |
**Total decoupe : 25 608 192 octets.** Le bloc demande au noyau est arrondi au
multiple superieur de 2 Mo — `MAP_HUGETLB` exige une longueur multiple de la
taille de huge page — soit **27 262 976 octets (26 Mo)**. Le reliquat de
1 654 784 octets n est pas perdu : il est expose comme `kReserveBytes`.
Soit **0,63 % des 4 Go du Pixel 3a**.
### Comportement
- Allocation = avance de pointeur, avec alignement calcule **sur l offset** et
non sur l adresse. La base d une arene etant alignee sur 2 Mo, cela revient
au meme — mais cela rend le comportement rigoureusement identique entre
l hote et la cible, ce qui compte pour le harnais d oracle.
- **Pas de liberation individuelle.** Un `reset()` global par arene, un
`mark()` / `rewind_to()` pour les usages en pile.
- **Un debordement est une panique**, jamais un agrandissement. Le message
donne le nom de l arene, la taille demandee, l alignement, l occupation et la
capacite :
```
proj3: PANIQUE: debordement d arene 'geometrie' : demande=4194304 align=8 occupe=0 capacite=2097152
Un debordement d arene est un defaut de conception, pas un cas
a gerer : corriger le calcul dans mem/layout.hpp.
```
- `Arena::peak()` donne la plus haute occupation atteinte. C est la seule
metrique qui permette de dire si une taille de `layout.hpp` est juste ou
fantaisiste. Cout : une comparaison par allocation.
## 3. Le garde-fou
`src/proj3/mem/new_guard.cpp` redefinit `operator new`, `operator new[]`,
`operator delete`, `operator delete[]`, ainsi que leurs formes dimensionnees et
alignees. Toutes tuent le processus immediatement :
```
proj3: ALLOCATION INTERDITE: operator new[] taille=64
Le projet n alloue rien apres l init. Tout passe par une arene
(mem/arena.hpp). Poser un point d arret sur operator new et
remonter la pile pour trouver l appelant.
```
Code de sortie **71**, distinct du **70** de `panic()`, pour qu un script sache
que c est une allocation et pas autre chose.
**Ce que le garde-fou n attrape pas**, et il faut le savoir :
- `malloc` / `calloc` / `realloc` / `free` appeles directement. Ce sont des
fonctions C, sans rapport avec `operator new`. Sur la cible embarquee la
question ne se pose pas (le lien echouerait). Sur l hote,
`page_source_host.cpp` les utilise deliberement.
- les allocations faites par le noyau (pile, `mmap`) ;
- les VLA et `alloca`, qui prennent sur la pile.
Le perimetre est donc exactement : **aucun `new` C++ nulle part**. C est ce
qu on veut verifier.
**Il est en bibliotheque separee** (`proj3_newguard`) et n est lie qu aux
executables qui pretendent ne rien allouer. Le lier partout casserait tout
outil utilisant la STL de l hote — ce qui est le comportement recherche, mais
doit etre choisi executable par executable.
Preuve qu il fonctionne : `test/test_new_guard.cpp`, declare `WILL_FAIL TRUE`
dans CTest. Le test est reussi si et seulement si le processus meurt.
## 4. A REVERIFIER lors du passage a la cible 12 Go (Poco F5 Pro)
Cette section est le point de reprise. Rien de ce qui suit n est fait.
1. **La resolution change.** Le Poco F5 Pro est en 1440x3200. Le calcul du
scanout devient `1440*3200*4 = 18 432 000` par tampon, soit **36 Mo pour
deux** au lieu de 19 Mo. `kScreenWidth` / `kScreenHeight` doivent devenir
des parametres, pas des constantes — et la question « constexpr ou lu depuis
DRM ? » se posera : une taille lue au runtime interdit le dimensionnement
`constexpr` des arenes, ce qui est un changement d architecture, pas un
ajustement.
2. **La taille de page peut differer.** Certains noyaux arm64 recents sont
compiles en pages de 16 Ko. `kPageSize` doit alors changer ; `kHugePageSize`
passerait de 2 Mo (PMD sur 4K) a 32 Mo (PMD sur 16K), ce qui invaliderait
`MAP_HUGE_2MB`.
3. **`MAP_HUGETLB` a peut-etre plus de chances d aboutir** sur un noyau plus
recent — ou pas. A verifier materiellement, pas a supposer. Si le mode 1
devient disponible sur une cible et pas sur l autre, les mesures des deux
cibles ne sont **pas comparables entre elles**.
4. **Les tailles d atlas et de geometrie ne doivent PAS etre augmentees
mecaniquement.** Elles sont dimensionnees par un raisonnement (nombre de
glyphes, nombre d aretes), pas par un pourcentage de la RAM. Plus de RAM ne
justifie pas plus d atlas ; une densite de pixels plus elevee, qui impose des
corps plus grands, oui — et il faudra refaire le calcul, pas le doubler.
5. **`kArenaTotal < RAM/64` deviendra trivialement vrai** et cessera d etre un
garde-fou utile. Le remplacer par une borne absolue reflechie.
6. **Le pic reel doit etre releve avant de retoucher quoi que ce soit.**
`Arena::peak()` existe pour cela. Redimensionner sans avoir regarde les pics
sur la cible actuelle serait du reglage a l aveugle.
+172
Voir le fichier
@@ -0,0 +1,172 @@
# Methode de l oracle — validation croisee C++ / assembleur
## 1. La regle
Toute routine critique du projet existe en **deux exemplaires** :
- une **version de reference en C++**, ecrite d abord, lisible, evidemment
correcte, jamais optimisee ;
- une **version assembleur**, ecrite ensuite, rapide, et suspecte jusqu a
preuve du contraire.
Le harnais execute les deux sur les memes entrees et compare les sorties
**octet par octet**. Pas d epsilon, pas de tolerance, pas de "presque".
## 2. La regle qui compte vraiment
> **La version C++ de reference n est JAMAIS supprimee.**
Meme quand la version assembleur est validee. Meme quand elle tourne depuis
deux ans sans incident. Meme quand la version C++ n est plus compilee en
production.
Raisons, dans l ordre d importance :
1. **Sans reference, il n y a plus d oracle.** Le jour ou l assembleur se met
a produire un resultat different apres un changement de compilateur, de
modele de CPU ou de flag, il n y a plus rien a quoi le comparer. On aurait
un bug et aucun moyen de dire ou.
2. **La reference est la specification.** Elle dit ce que la routine doit
faire, dans un langage que quelqu un peut lire dans cinq ans. Le commentaire
d en-tete d une routine NEON, non.
3. **Elle est le chemin de repli.** Un portage vers une architecture sans notre
assembleur (un simulateur, une machine de dev, une future cible) reste
possible tant qu elle existe.
La selection production/reference est un choix de compilation, jamais une
suppression de code.
## 3. Ce que le harnais garantit, et ce qu il ne garantit pas
Garanti :
- egalite exacte des octets de sortie ;
- egalite exacte de la longueur rendue ;
- absence de debordement du tampon de sortie, y compris d **un seul octet**
(zone de garde de 32 octets remplie de `0xA5`, verifiee apres chaque appel) ;
- absence d allocation dynamique, quand l executable est lie a
`proj3_newguard` — c est le cas de `proj3_oracle`.
Non garanti, et il faut le savoir :
- **la performance**. Ce harnais valide la correction, rien d autre. La mesure
de latence est un chantier distinct, plus tard, avec son propre outillage.
- **la couverture**. Le harnais teste ce qu on lui donne. Les cas explicites
sont ecrits a la main, le reste est aleatoire reproductible.
## 4. Ajouter une paire
Trois choses a ecrire, aucune modification du harnais :
```cpp
#include "oracle.hpp"
namespace proj3::oracle {
// 1. la reference C++
usize ma_routine_ref(const u8* in, usize in_len, u8* out, usize out_cap) { ... }
// 2. les cas
const CaseSpec kMesCas[] = {
{"vide", 0, 0, 0, 0},
{"16 octets", 16, 0, 0, 0},
{"desaligne +1/+3", 256, 0, 1, 3},
{"aleatoire", 4096, 0xDEADBEEFCAFEBABEull, 0, 0},
};
// 3. l enregistrement
PROJ3_ORACLE_PAIR(ma_routine, "mon::module::ma_routine",
&ma_routine_ref, &proj3_ma_routine_asm, kMesCas);
}
```
`opt` peut valoir `nullptr` : la paire est alors enregistree comme
**reference figee**, la reference est executee seule (ce qui verifie deja
qu elle ne plante pas, ne deborde pas et n alloue pas), et le harnais l affiche
comme telle. C est ainsi qu on enregistre une routine **avant** d avoir ecrit
son assembleur — ce que fait `pairs_render.cpp` pour tout le pipeline de
rendu du chantier 5.
Le champ `CaseSpec` :
| champ | role |
|---|---|
| `label` | affiche en cas d echec ; ecrire de quoi identifier le cas |
| `in_len` | taille de l entree, qui vaut aussi capacite de la sortie |
| `seed` | 0 = motif deterministe ; sinon graine du xorshift64* |
| `in_align_offset` | decalage en octets de la base d entree |
| `out_align_offset` | decalage en octets de la base de sortie |
Les tampons viennent d une arene dont la base est alignee sur 2 Mo : un
decalage de *k* octets donne donc une adresse congrue a *k* modulo 16, ce qui
est exactement le levier dont un chemin NEON a besoin pour etre teste des deux
cotes.
## 5. Le diagnostic
En cas de divergence, le harnais affiche :
```
ECHEC fill_bytes (VERSION FAUSSE) / 16 (128 bits pile)
octet divergent
rejouer ce cas : graine=0 in_len=16 align_in=+0 align_out=+0
longueurs : reference=16 optimisee=16
premier octet divergent a l offset 15 : attendu=0x5b obtenu=0x0
attendu [0..16) : 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b
obtenu [0..16) : 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 00
```
Tout est la pour rejouer exactement le cas : la graine, la longueur, les deux
alignements. Le contexte de 16 octets de part et d autre permet de distinguer
d un coup d oeil un decalage d une valeur fausse.
## 6. Validation du harnais lui-meme
`proj3_oracle_selftest` execute deux passes sur la meme paire de
demonstration :
1. la version assembleur **correcte** doit etre acceptee ;
2. la version assembleur **volontairement fausse** (un octet de moins ecrit,
longueur rendue correcte — le genre de bug qu un test indulgent laisse
passer) doit etre **rejetee**.
Le test rend 0 seulement si les deux attentes sont satisfaites.
> Un harnais qui ne sait pas detecter une erreur connue ne vaut rien. C est
> pour cela que la version fausse existe et qu elle reste dans le depot.
## 7. Ou tourne quoi — limite assumee
| executable | cible | ce qu il compare |
|---|---|---|
| `proj3_oracle` | hote | reference C++ contre asm **x86-64**, pour la paire de demonstration seulement. Les autres paires sont en reference figee. |
| `proj3_oracle_selftest` | hote | la meme paire, correcte puis fausse |
| `proj3_oracle_target` | AArch64 | reference C++ contre asm **AArch64**, toutes paires |
La machine de developpement ne peut pas executer de l AArch64. Pour que la
preuve « le harnais sait rejeter une erreur » puisse etre faite **sur la
machine de dev**, la paire de demonstration est ecrite deux fois :
`asm/demo_fill_aarch64.S` et `asm/host/demo_fill_x86_64.S`.
**Ce doublon ne sera pas etendu.** Les vraies routines optimisees seront
ecrites en AArch64 seulement ; leur comparaison se fera sur la cible, avec
`proj3_oracle_target`. Sur l hote elles apparaitront comme « reference figee,
version assembleur absente ». C est une limite de la double cible, pas un
oubli.
## 8. Hypotheses numeriques
La comparaison octet-a-octet entre l hote et la cible n a de sens que si les
deux calculent rigoureusement pareil. Ce qui est suppose, et pourquoi c est
vrai :
| hypothese | justification |
|---|---|
| `float` = IEEE-754 binary32, `double` = binary64 | vrai sur AArch64 et x86-64 |
| mode d arrondi round-to-nearest-even | valeur par defaut, et aucune routine du projet ne touche `fpcr` ni `mxcsr` (regle inscrite dans `convention-aarch64.md` 1.4) |
| pas de precision excedentaire | x86-64 calcule en SSE2, pas en x87 80 bits ; AArch64 n a pas de format etendu |
| `sqrt` correctement arrondi | `fsqrt` (A64) et `sqrtsd` (SSE2) le sont, par la norme |
| pas de `-ffast-math` | seul `-fno-math-errno` est utilise, et il ne change aucune valeur : il supprime uniquement la mise a jour d `errno`, dont le projet n a pas |
| little-endian des deux cotes | `static_assert` sur `__BYTE_ORDER__` dans `base/types.hpp` |
Si l une de ces hypotheses tombait, le harnais deviendrait un generateur de
faux positifs. Elles sont donc listees ici, et non enfouies dans un
commentaire.
+58
Voir le fichier
@@ -0,0 +1,58 @@
// base/cstring.cpp — les quatre symboles que le compilateur peut emettre seul.
//
// COMPILE UNIQUEMENT POUR LA CIBLE EMBARQUEE. Sur l hote, la libc les fournit
// et les redefinir provoquerait un conflit de symboles.
//
// Pourquoi ce fichier existe : meme avec -nostdlib -ffreestanding, GCC et
// Clang se reservent le droit de transformer une boucle de copie ou une
// initialisation d agregat en appel a memcpy / memset / memmove / memcmp.
// C est documente et parfaitement legal de leur part. Sans ces definitions,
// le lien echoue avec un symbole indefini au moment le moins pratique.
//
// -fno-builtin est passe a la compilation pour eviter que le compilateur ne
// reconnaisse ces definitions et ne les remplace par un appel a elles-memes.
#include "proj3/base/types.hpp"
using proj3::i32;
using proj3::u8;
using proj3::usize;
extern "C" {
void* memset(void* dst, int value, usize n) {
u8* p = static_cast<u8*>(dst);
const u8 v = static_cast<u8>(value);
for (usize i = 0; i < n; ++i) p[i] = v;
return dst;
}
void* memcpy(void* dst, const void* src, usize n) {
u8* d = static_cast<u8*>(dst);
const u8* s = static_cast<const u8*>(src);
for (usize i = 0; i < n; ++i) d[i] = s[i];
return dst;
}
void* memmove(void* dst, const void* src, usize n) {
u8* d = static_cast<u8*>(dst);
const u8* s = static_cast<const u8*>(src);
if (d == s || n == 0) return dst;
if (d < s) {
for (usize i = 0; i < n; ++i) d[i] = s[i];
} else {
for (usize i = n; i-- > 0;) d[i] = s[i];
}
return dst;
}
int memcmp(const void* a, const void* b, usize n) {
const u8* x = static_cast<const u8*>(a);
const u8* y = static_cast<const u8*>(b);
for (usize i = 0; i < n; ++i) {
if (x[i] != y[i]) return static_cast<i32>(x[i]) - static_cast<i32>(y[i]);
}
return 0;
}
} // extern "C"
+68
Voir le fichier
@@ -0,0 +1,68 @@
// base/fmt.hpp — formatage entier minimal, freestanding, sans allocation.
//
// Chaque fonction ecrit dans un tampon fourni par l appelant et rend le
// nombre d octets ecrits. Aucun etat, aucune allocation, aucun appel a la
// libc : utilisable depuis un chemin de panique.
#pragma once
#include "proj3/base/types.hpp"
namespace proj3 {
inline usize str_len(const char* s) {
usize n = 0;
while (s[n] != '\0') ++n;
return n;
}
// Tampon minimal : 20 chiffres pour un u64, 21 avec le signe d un i64.
inline constexpr usize kDecBufSize = 24;
inline usize fmt_u64(char* out, usize cap, u64 v) {
char tmp[kDecBufSize];
usize n = 0;
do {
tmp[n++] = static_cast<char>('0' + (v % 10u));
v /= 10u;
} while (v != 0 && n < sizeof(tmp));
if (n > cap) return 0;
for (usize i = 0; i < n; ++i) out[i] = tmp[n - 1 - i];
return n;
}
inline usize fmt_i64(char* out, usize cap, i64 v) {
if (v >= 0) return fmt_u64(out, cap, static_cast<u64>(v));
if (cap == 0) return 0;
out[0] = '-';
// Negation via u64 : -v deborde pour v == INT64_MIN, pas la soustraction
// depuis zero en non signe.
const u64 mag = 0u - static_cast<u64>(v);
const usize n = fmt_u64(out + 1, cap - 1, mag);
return n == 0 ? 0 : n + 1;
}
inline usize fmt_hex_u64(char* out, usize cap, u64 v) {
static const char kDigits[] = "0123456789abcdef";
char tmp[16];
usize n = 0;
do {
tmp[n++] = kDigits[v & 0xFu];
v >>= 4;
} while (v != 0 && n < sizeof(tmp));
if (n + 2 > cap) return 0;
out[0] = '0';
out[1] = 'x';
for (usize i = 0; i < n; ++i) out[2 + i] = tmp[n - 1 - i];
return n + 2;
}
// Deux chiffres hexadecimaux, sans prefixe : pour les vidages d octets.
inline usize fmt_hex_u8(char* out, usize cap, u8 v) {
static const char kDigits[] = "0123456789abcdef";
if (cap < 2) return 0;
out[0] = kDigits[(v >> 4) & 0xFu];
out[1] = kDigits[v & 0xFu];
return 2;
}
} // namespace proj3
+84
Voir le fichier
@@ -0,0 +1,84 @@
// base/math.hpp — le strict minimum de mathematiques flottantes, sans libm.
//
// HYPOTHESES, valables sur les deux cibles et verifiees par static_assert
// autant que le langage le permet :
// - float est IEEE-754 binary32, double est binary64 ;
// - le mode d arrondi est round-to-nearest-even et personne ne le change ;
// - x86-64 calcule en SSE2, pas en x87 80 bits : pas de precision excedentaire
// surprise. (C est vrai par defaut pour tout compilateur 64 bits.)
// - aucune option de type -ffast-math n est utilisee.
// Ces hypotheses sont ce qui rend la comparaison octet-a-octet du harnais
// d oracle valide entre l hote et la cible.
#pragma once
#include "proj3/base/types.hpp"
namespace proj3 {
using f32 = float;
using f64 = double;
static_assert(sizeof(f32) == 4 && sizeof(f64) == 8);
template <class T>
constexpr T min_of(T a, T b) {
return a < b ? a : b;
}
template <class T>
constexpr T max_of(T a, T b) {
return a > b ? a : b;
}
template <class T>
constexpr T clamp_to(T v, T lo, T hi) {
return v < lo ? lo : (v > hi ? hi : v);
}
// floor / ceil par troncature entiere.
//
// Valide seulement pour |v| < 2^62, ce qui est garanti ici : toutes les
// coordonnees manipulees sont bornees par la taille de l ecran multipliee par
// l echelle, soit quelques milliers. Un garde-fou explicite plutot qu une
// implementation generale : le cas general n existe pas dans ce projet.
inline f32 floor_f32(f32 v) {
const i64 t = static_cast<i64>(v);
const f32 tf = static_cast<f32>(t);
return (tf > v) ? tf - 1.0f : tf;
}
inline f32 ceil_f32(f32 v) {
const i64 t = static_cast<i64>(v);
const f32 tf = static_cast<f32>(t);
return (tf < v) ? tf + 1.0f : tf;
}
// Arrondi a l entier le plus proche, moitie loin de zero.
// C est exactement la semantique de std::lround, celle qu utilisait le code
// d origine pour l avance des glyphes. Ne pas la changer : elle est visible
// dans la position de chaque caractere.
inline i32 lround_f32(f32 v) {
return v >= 0.0f ? static_cast<i32>(v + 0.5f) : -static_cast<i32>(-v + 0.5f);
}
// Racine carree. __builtin_sqrt se compile en une instruction machine
// (fsqrt sur AArch64, sqrtsd sur x86-64), toutes deux correctement arrondies
// par IEEE-754 : le resultat est bit-a-bit identique sur les deux cibles.
// Aucun appel a libm n est emis.
inline f64 sqrt_f64(f64 v) { return __builtin_sqrt(v); }
// Longueur euclidienne.
//
// DIVERGENCE CONNUE AVEC LE CODE D ORIGINE, documentee ici parce qu elle est
// la seule du portage : Gastinel Write utilise std::hypot, qui evite le
// debordement intermediaire et peut etre plus precis d un ULP que le calcul
// naif. On n a pas de libm, donc on calcule naivement — mais en double, ce qui
// rend l ecart avec hypot inferieur a un ULP de float.
//
// Consequence possible : subdivision_count() pourrait choisir un nombre de
// segments different, si et seulement si d/1.5 tombait exactement sur un
// entier a un ULP pres. Le test golden (test/test_raster_golden.cpp) compare
// les sorties reelles aux sorties de Write pour verifier que ce cas ne se
// produit pas sur les glyphes testes. Si un jour il se produisait, ce serait
// visible immediatement.
inline f64 hypot_f64(f64 a, f64 b) { return sqrt_f64(a * a + b * b); }
} // namespace proj3
+51
Voir le fichier
@@ -0,0 +1,51 @@
// base/mem.hpp — primitives memoire du projet.
//
// Elles sont volontairement naives : octet par octet, sans deroulage ni SIMD.
// C est le point de depart d une paire d oracle (chantier 4), pas une version
// finale. Une version NEON viendra les remplacer, la version C++ restant la
// reference a vie.
//
// Attention : sur la cible embarquee, ces fonctions ne SONT PAS memcpy/memset.
// Les symboles memcpy/memset que le compilateur peut emettre de lui-meme sont
// fournis separement dans base/cstring.cpp.
#pragma once
#include "proj3/base/types.hpp"
namespace proj3 {
inline void mem_fill(void* dst, u8 value, usize n) {
u8* p = static_cast<u8*>(dst);
for (usize i = 0; i < n; ++i) p[i] = value;
}
inline void mem_copy(void* dst, const void* src, usize n) {
u8* d = static_cast<u8*>(dst);
const u8* s = static_cast<const u8*>(src);
for (usize i = 0; i < n; ++i) d[i] = s[i];
}
// Rend true si les deux zones sont identiques. Pas de tri lexicographique :
// le projet n a besoin que de l egalite, et rendre un ordre inviterait a s en
// servir sur des donnees ou il n a pas de sens.
inline bool mem_equal(const void* a, const void* b, usize n) {
const u8* x = static_cast<const u8*>(a);
const u8* y = static_cast<const u8*>(b);
for (usize i = 0; i < n; ++i) {
if (x[i] != y[i]) return false;
}
return true;
}
// Indice du premier octet different, ou n si les zones sont identiques.
// Utilise par le diagnostic du harnais d oracle.
inline usize mem_first_diff(const void* a, const void* b, usize n) {
const u8* x = static_cast<const u8*>(a);
const u8* y = static_cast<const u8*>(b);
for (usize i = 0; i < n; ++i) {
if (x[i] != y[i]) return i;
}
return n;
}
} // namespace proj3
+53
Voir le fichier
@@ -0,0 +1,53 @@
// base/sort.hpp — tri en place, sans allocation, a cout pire cas borne.
//
// HEAPSORT, et pas quicksort ni std::sort.
//
// Ce n est pas un detail d implementation, c est le pilier 1 applique a un
// algorithme : le quicksort a un pire cas en O(n^2) atteignable par des
// donnees reelles, et std::sort (introsort) a un cout qui depend de la
// distribution des entrees. Le heapsort est O(n log n) DANS TOUS LES CAS, en
// place, sans recursion, sans memoire auxiliaire. Il est en moyenne un peu
// plus lent que le quicksort ; c est exactement l arbitrage que le projet
// assume : on rejette une construction plus rapide en moyenne mais a variance
// non bornee.
//
// Note sur la stabilite : le heapsort n est pas stable. Aucun usage du projet
// n en depend — le rasterizer trie des intersections par abscisse, et deux
// intersections de meme abscisse delimitent un intervalle de largeur nulle,
// donc invisible quel que soit leur ordre.
#pragma once
#include "proj3/base/types.hpp"
namespace proj3 {
template <class T, class Less>
inline void sift_down(T* a, usize start, usize end, Less less) {
usize root = start;
for (;;) {
const usize child = 2 * root + 1;
if (child >= end) break;
usize swap = root;
if (less(a[swap], a[child])) swap = child;
if (child + 1 < end && less(a[swap], a[child + 1])) swap = child + 1;
if (swap == root) return;
const T tmp = a[root];
a[root] = a[swap];
a[swap] = tmp;
root = swap;
}
}
template <class T, class Less>
inline void heap_sort(T* a, usize n, Less less) {
if (n < 2) return;
for (usize i = n / 2; i-- > 0;) sift_down(a, i, n, less);
for (usize end = n; end-- > 1;) {
const T tmp = a[0];
a[0] = a[end];
a[end] = tmp;
sift_down(a, 0, end, less);
}
}
} // namespace proj3
+44
Voir le fichier
@@ -0,0 +1,44 @@
// base/types.hpp — types entiers de largeur fixe, sans <cstdint>.
//
// Pourquoi ne pas inclure <cstdint> : il est theoriquement disponible en
// freestanding, mais il tire l en-tete systeme <stdint.h> de la libc de la
// plateforme, donc un chemin d inclusion qui differe entre la cible embarquee
// et la cible hote. Douze lignes de typedefs suppriment la question. Les
// static_assert ci-dessous garantissent qu on ne se trompe pas.
#pragma once
namespace proj3 {
using u8 = unsigned char;
using i8 = signed char;
using u16 = unsigned short;
using i16 = short;
using u32 = unsigned int;
using i32 = int;
using u64 = unsigned long long;
using i64 = long long;
// Taille et decalage : LP64 des deux cotes (aarch64-linux et x86-64).
using usize = decltype(sizeof(0));
using iptr = i64;
using uptr = u64;
static_assert(sizeof(u8) == 1 && sizeof(i8) == 1);
static_assert(sizeof(u16) == 2 && sizeof(i16) == 2);
static_assert(sizeof(u32) == 4 && sizeof(i32) == 4);
static_assert(sizeof(u64) == 8 && sizeof(i64) == 8);
static_assert(sizeof(usize) == 8, "cible LP64 attendue");
static_assert(sizeof(void*) == 8, "cible 64 bits attendue");
// Little-endian suppose partout (AArch64 en mode EL0 Linux, x86-64).
// Le parser TTF lit du big-endian octet par octet, il ne depend donc pas de
// cette hypothese ; mais la composition de framebuffer, si.
// (troncation et endianness sont deux choses differentes : seul le predefini
// du compilateur repond vraiment a la question, en constant de compilation.)
#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__)
static_assert(__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__, "little-endian attendu");
#else
#error "compilateur sans __BYTE_ORDER__ : verifier l endianness a la main"
#endif
} // namespace proj3
+45
Voir le fichier
@@ -0,0 +1,45 @@
// boot/main.cpp — unique fonction C++ appelee par _start.
//
// Ce que fait le binaire embarque a ce stade des chantiers :
// 1. acquiert le bloc memoire et journalise le mode de pages retenu ;
// 2. affiche l occupation des arenes ;
// 3. termine avec le code 0.
//
// Il ne dessine rien, n ouvre aucun peripherique et ne mesure rien : le code
// DRM/KMS, /dev/input et la mesure de latence sont hors perimetre tant que les
// verifications materielles sur le Pixel 3a n ont pas ete faites.
//
// Le code de retour part directement dans exit_group depuis asm/start.S.
#include "proj3/mem/system.hpp"
#include "proj3/sys/panic.hpp"
#include "proj3/sys/syscalls.hpp"
using namespace proj3;
extern "C" int proj3_main(int argc, char** argv) {
(void)argc;
(void)argv;
err_write("proj3: demarrage (pid=");
const sys::Result pid = sys::getpid();
err_write_i64(pid.is_ok() ? pid.value() : -1);
err_write(")\n");
// Le System est en stockage statique et POD : pas de constructeur a
// executer, donc rien ne depend de .init_array (que _start ne parcourt
// pas, cf. ADR-0001). Il occupe environ 300 octets de .bss.
static mem::System g_mem;
if (!mem::system_init(g_mem)) {
err_write("proj3: acquisition memoire impossible : les trois chemins\n");
err_write("proj3: (HUGETLB, THP, pages simples) ont echoue.\n");
return 1;
}
mem::log_active_mode();
mem::system_report(g_mem);
err_write("proj3: arret normal.\n");
return 0;
}
+641
Voir le fichier
@@ -0,0 +1,641 @@
#include "proj3/font/ttf.hpp"
#include "proj3/base/sort.hpp"
namespace proj3::font {
namespace {
// --- Lecture big-endian bornee --------------------------------------------
// Identique a l original : chaque accesseur verifie ses bornes. Un fichier
// tronque doit produire un echec propre, jamais une lecture hors tampon.
bool rd_u8(const u8* d, usize n, u32 off, u8& out) {
if (static_cast<usize>(off) + 1 > n) return false;
out = d[off];
return true;
}
bool rd_u16(const u8* d, usize n, u32 off, u16& out) {
if (static_cast<usize>(off) + 2 > n) return false;
out = static_cast<u16>((static_cast<u32>(d[off]) << 8) | d[off + 1]);
return true;
}
bool rd_i16(const u8* d, usize n, u32 off, i16& out) {
u16 v = 0;
if (!rd_u16(d, n, off, v)) return false;
out = static_cast<i16>(v);
return true;
}
bool rd_u32(const u8* d, usize n, u32 off, u32& out) {
if (static_cast<usize>(off) + 4 > n) return false;
out = (static_cast<u32>(d[off]) << 24) | (static_cast<u32>(d[off + 1]) << 16) |
(static_cast<u32>(d[off + 2]) << 8) | static_cast<u32>(d[off + 3]);
return true;
}
// F2Dot14 : entier signe 16 bits interprete comme un fixe 2.14.
bool rd_f2dot14(const u8* d, usize n, u32 off, f32& out) {
i16 v = 0;
if (!rd_i16(d, n, off, v)) return false;
out = static_cast<f32>(v) / 16384.0f;
return true;
}
// Drapeaux glyf (glyphe simple)
constexpr u8 kOnCurve = 0x01;
constexpr u8 kXShortVector = 0x02;
constexpr u8 kYShortVector = 0x04;
constexpr u8 kRepeatFlag = 0x08;
constexpr u8 kXSameOrPos = 0x10;
constexpr u8 kYSameOrPos = 0x20;
// Drapeaux glyf (glyphe composite)
constexpr u16 kArg1And2AreWords = 0x0001;
constexpr u16 kArgsAreXyValues = 0x0002;
constexpr u16 kWeHaveAScale = 0x0008;
constexpr u16 kMoreComponents = 0x0020;
constexpr u16 kWeHaveXAndYScale = 0x0040;
constexpr u16 kWeHaveATwoByTwo = 0x0080;
bool tag_equal(const char* a, const char b[4]) {
return a[0] == b[0] && a[1] == b[1] && a[2] == b[2] && a[3] == b[3];
}
} // namespace
// ---------------------------------------------------------------------------
TtfFont::TableRecord TtfFont::find_table(const char tag[4]) const {
for (u32 i = 0; i < table_count_; ++i) {
if (tag_equal(table_tag_[i], tag)) return table_rec_[i];
}
return TableRecord{};
}
bool TtfFont::load(const u8* data, usize size, mem::Arena& arena, const char*& error) {
error = "";
data_ = data;
size_ = size;
table_count_ = 0;
if (size <= 12) {
error = "fichier trop court pour etre un TTF";
return false;
}
// En-tete sfnt. Les refus explicites de l original sont conserves mot pour
// mot : ils disent quoi faire, ce qui vaut mieux qu un "signature inconnue".
u32 sfnt = 0;
if (!rd_u32(data_, size_, 0, sfnt)) {
error = "en-tete illisible";
return false;
}
if (sfnt == 0x4F54544Fu) {
error = "police OpenType/CFF (OTTO) non supportee : il faut un TTF a contours glyf";
return false;
}
if (sfnt == 0x74746366u) {
error = "collection TrueType (.ttc) : extraire la police voulue en .ttf";
return false;
}
if (sfnt == 0x774F4646u || sfnt == 0x774F4632u) {
error = "police web (WOFF/WOFF2) non supportee : il faut un .ttf";
return false;
}
if (sfnt != 0x00010000u && sfnt != 0x74727565u) {
error = "signature sfnt inconnue : ce fichier n est pas un TTF";
return false;
}
u16 num_tables = 0;
if (!rd_u16(data_, size_, 4, num_tables)) {
error = "numTables illisible";
return false;
}
for (u16 i = 0; i < num_tables; ++i) {
const u32 rec = 12u + 16u * i;
if (static_cast<usize>(rec) + 16 > size_) {
error = "repertoire de tables tronque";
return false;
}
TableRecord tr;
rd_u32(data_, size_, rec + 8, tr.offset);
rd_u32(data_, size_, rec + 12, tr.length);
// Table hors fichier : ignoree plutot que fatale, certaines polices
// ont des longueurs padees legerement fausses. Comportement d origine.
if (tr.offset > size_ || static_cast<usize>(tr.offset) + tr.length > size_) continue;
if (table_count_ >= kMaxTables) continue;
tr.present = true;
for (int k = 0; k < 4; ++k) table_tag_[table_count_][k] = static_cast<char>(data_[rec + k]);
table_rec_[table_count_] = tr;
++table_count_;
}
const TableRecord glyf = find_table("glyf");
if (!glyf.present) {
error = "table glyf absente";
return false;
}
glyf_offset_ = glyf.offset;
glyf_length_ = glyf.length;
if (!parse_head(error)) return false;
if (!parse_maxp(error)) return false;
if (!parse_hhea_hmtx(error)) return false;
if (!parse_loca(arena, error)) return false;
if (!parse_cmap(arena, error)) return false;
return true;
}
bool TtfFont::parse_head(const char*& error) {
const TableRecord head = find_table("head");
if (!head.present || head.length < 54) {
error = "table head absente ou trop courte";
return false;
}
if (!rd_u16(data_, size_, head.offset + 18, units_per_em_) || units_per_em_ == 0) {
error = "unitsPerEm invalide";
return false;
}
if (!rd_i16(data_, size_, head.offset + 50, index_to_loc_format_)) {
error = "indexToLocFormat illisible";
return false;
}
if (index_to_loc_format_ != 0 && index_to_loc_format_ != 1) {
error = "indexToLocFormat inattendu";
return false;
}
return true;
}
bool TtfFont::parse_maxp(const char*& error) {
const TableRecord maxp = find_table("maxp");
if (!maxp.present || maxp.length < 6) {
error = "table maxp absente ou trop courte";
return false;
}
if (!rd_u16(data_, size_, maxp.offset + 4, num_glyphs_) || num_glyphs_ == 0) {
error = "numGlyphs invalide";
return false;
}
return true;
}
bool TtfFont::parse_hhea_hmtx(const char*& error) {
const TableRecord hhea = find_table("hhea");
const TableRecord hmtx = find_table("hmtx");
if (!hhea.present || hhea.length < 36 || !hmtx.present) {
error = "tables hhea/hmtx absentes";
return false;
}
if (!rd_u16(data_, size_, hhea.offset + 34, num_h_metrics_) || num_h_metrics_ == 0) {
error = "numberOfHMetrics invalide";
return false;
}
rd_i16(data_, size_, hhea.offset + 4, ascender_);
rd_i16(data_, size_, hhea.offset + 6, descender_);
rd_i16(data_, size_, hhea.offset + 8, line_gap_);
hmtx_offset_ = hmtx.offset;
return true;
}
bool TtfFont::parse_loca(mem::Arena& arena, const char*& error) {
const TableRecord loca = find_table("loca");
if (!loca.present) {
error = "table loca absente";
return false;
}
loca_count_ = static_cast<u32>(num_glyphs_) + 1u;
loca_ = arena.alloc_array<u32>(loca_count_);
for (u32 i = 0; i < loca_count_; ++i) {
u32 rel = 0;
if (index_to_loc_format_ == 0) {
// Format court : les offsets sont stockes divises par deux.
u16 half = 0;
if (!rd_u16(data_, size_, loca.offset + i * 2u, half)) {
error = "loca (format court) tronquee";
return false;
}
rel = static_cast<u32>(half) * 2u;
} else {
if (!rd_u32(data_, size_, loca.offset + i * 4u, rel)) {
error = "loca (format long) tronquee";
return false;
}
}
loca_[i] = glyf_offset_ + rel;
}
return true;
}
u32 TtfFont::walk_cmap_format4(u32 off, CmapEntry* out, u32 cap) const {
u16 seg_x2 = 0;
if (!rd_u16(data_, size_, off + 6, seg_x2) || seg_x2 == 0) return 0;
const u32 seg_count = seg_x2 / 2u;
const u32 end_base = off + 14u;
const u32 start_base = end_base + seg_x2 + 2u; // +2 : reservedPad
const u32 delta_base = start_base + seg_x2;
const u32 range_base = delta_base + seg_x2;
u32 n = 0;
for (u32 s = 0; s < seg_count; ++s) {
u16 end_code = 0, start_code = 0, range_offset = 0;
i16 id_delta = 0;
if (!rd_u16(data_, size_, end_base + s * 2u, end_code) ||
!rd_u16(data_, size_, start_base + s * 2u, start_code) ||
!rd_i16(data_, size_, delta_base + s * 2u, id_delta) ||
!rd_u16(data_, size_, range_base + s * 2u, range_offset)) {
return n;
}
if (start_code > end_code) continue;
for (u32 c = start_code; c <= end_code; ++c) {
if (c == 0xFFFF) continue; // sentinelle de fin de segment
u16 gid = 0;
if (range_offset == 0) {
gid = static_cast<u16>((c + static_cast<u16>(id_delta)) & 0xFFFF);
} else {
// Adressage indirect : l offset est relatif a la position du
// champ idRangeOffset lui-meme. Particularite du format 4 et
// source d erreur classique.
const u32 idx = range_base + s * 2u + range_offset + (c - start_code) * 2u;
if (!rd_u16(data_, size_, idx, gid)) return n;
if (gid != 0) gid = static_cast<u16>((gid + static_cast<u16>(id_delta)) & 0xFFFF);
}
if (gid != 0) {
if (out != nullptr) {
if (n >= cap) return n;
out[n] = CmapEntry{c, gid};
}
++n;
}
}
}
return n;
}
u32 TtfFont::walk_cmap_format12(u32 off, CmapEntry* out, u32 cap) const {
u32 n_groups = 0;
if (!rd_u32(data_, size_, off + 12, n_groups)) return 0;
u32 n = 0;
for (u32 g = 0; g < n_groups; ++g) {
const u32 rec = off + 16u + 12u * g;
u32 start = 0, end = 0, start_gid = 0;
if (!rd_u32(data_, size_, rec, start) || !rd_u32(data_, size_, rec + 4, end) ||
!rd_u32(data_, size_, rec + 8, start_gid)) {
return n;
}
if (end < start || end > 0x10FFFF) continue;
for (u32 c = start; c <= end; ++c) {
const u32 gid = start_gid + (c - start);
if (gid != 0 && gid < num_glyphs_) {
if (out != nullptr) {
if (n >= cap) return n;
out[n] = CmapEntry{c, static_cast<u16>(gid)};
}
++n;
}
}
}
return n;
}
bool TtfFont::parse_cmap(mem::Arena& arena, const char*& error) {
const TableRecord cmap = find_table("cmap");
if (!cmap.present || cmap.length < 4) {
error = "table cmap absente";
return false;
}
u16 num_sub = 0;
if (!rd_u16(data_, size_, cmap.offset + 2, num_sub)) {
error = "cmap : numTables illisible";
return false;
}
// Selection de la sous-table : (3,10) UCS-4, puis (3,1) BMP, puis
// plateforme 0 en repli. Comportement d origine, inchange.
u32 best_offset = 0;
int best_score = -1;
for (u16 i = 0; i < num_sub; ++i) {
const u32 rec = cmap.offset + 4u + 8u * i;
u16 platform = 0, encoding = 0;
u32 sub_off = 0;
if (!rd_u16(data_, size_, rec, platform) || !rd_u16(data_, size_, rec + 2, encoding) ||
!rd_u32(data_, size_, rec + 4, sub_off)) {
continue;
}
int score = -1;
if (platform == 3 && encoding == 10) score = 3;
else if (platform == 3 && encoding == 1) score = 2;
else if (platform == 0) score = 1;
if (score > best_score) {
best_score = score;
best_offset = cmap.offset + sub_off;
}
}
if (best_score < 0) {
error = "cmap : aucune sous-table Unicode exploitable";
return false;
}
u16 format = 0;
if (!rd_u16(data_, size_, best_offset, format)) {
error = "cmap : format illisible";
return false;
}
if (format != 4 && format != 12) {
error = "cmap : format non gere (attendu 4 ou 12)";
return false;
}
// Deux passes : la premiere compte, la seconde remplit. C est le prix a
// payer pour ne pas avoir de conteneur qui pousse. Le cout est une
// relecture de la sous-table, quelques microsecondes a l init.
const u32 count = (format == 4) ? walk_cmap_format4(best_offset, nullptr, 0)
: walk_cmap_format12(best_offset, nullptr, 0);
if (count == 0) {
error = "cmap : sous-table vide ou tronquee";
return false;
}
cmap_ = arena.alloc_array<CmapEntry>(count);
const u32 filled = (format == 4) ? walk_cmap_format4(best_offset, cmap_, count)
: walk_cmap_format12(best_offset, cmap_, count);
cmap_count_ = filled;
// Tri par (codepoint, gid) puis deduplication sur le codepoint, en gardant
// la premiere entree : c est exactement ce que faisaient std::sort +
// std::unique dans l original.
heap_sort(cmap_, cmap_count_, [](const CmapEntry& a, const CmapEntry& b) {
if (a.codepoint != b.codepoint) return a.codepoint < b.codepoint;
return a.gid < b.gid;
});
u32 w = 0;
for (u32 r = 0; r < cmap_count_; ++r) {
if (w > 0 && cmap_[w - 1].codepoint == cmap_[r].codepoint) continue;
cmap_[w++] = cmap_[r];
}
cmap_count_ = w;
return true;
}
u16 TtfFont::glyph_index_for_codepoint(u32 codepoint) const {
// Recherche binaire, comme l original (lower_bound sur un vector trie).
u32 lo = 0, hi = cmap_count_;
while (lo < hi) {
const u32 mid = lo + (hi - lo) / 2;
if (cmap_[mid].codepoint < codepoint) lo = mid + 1;
else hi = mid;
}
if (lo >= cmap_count_ || cmap_[lo].codepoint != codepoint) return 0;
return cmap_[lo].gid;
}
// ---------------------------------------------------------------------------
bool TtfFont::load_glyph(u16 glyph_index, GlyphBuilder& builder, Glyph& out) const {
out = Glyph{};
builder.reset();
if (glyph_index >= num_glyphs_) return false;
// --- Metriques horizontales (hmtx) ---
// Les glyphes d indice >= numberOfHMetrics partagent la derniere advance ;
// seul leur leftSideBearing est stocke, dans le tableau qui suit.
{
const u16 m = glyph_index < static_cast<u16>(num_h_metrics_ - 1)
? glyph_index
: static_cast<u16>(num_h_metrics_ - 1);
u16 adv = 0;
i16 lsb = 0;
rd_u16(data_, size_, hmtx_offset_ + m * 4u, adv);
if (glyph_index < num_h_metrics_) {
rd_i16(data_, size_, hmtx_offset_ + glyph_index * 4u + 2u, lsb);
} else {
const u32 tail = hmtx_offset_ + num_h_metrics_ * 4u;
rd_i16(data_, size_, tail + (glyph_index - num_h_metrics_) * 2u, lsb);
}
out.advance_width = static_cast<f32>(adv);
out.left_side_bearing = static_cast<f32>(lsb);
}
const u32 start = loca_[glyph_index];
const u32 end = loca_[glyph_index + 1];
out.points = builder.points;
out.contour_end = builder.contour_end;
if (end <= start) {
// Longueur nulle = glyphe vide (l espace). Les metriques restent
// valides, ce n est pas une erreur.
return true;
}
if (end > glyf_offset_ + glyf_length_ || static_cast<usize>(start) + 10 > size_) return false;
i16 xmin = 0, ymin = 0, xmax = 0, ymax = 0;
i16 n_contours = 0;
if (!rd_i16(data_, size_, start, n_contours) || !rd_i16(data_, size_, start + 2, xmin) ||
!rd_i16(data_, size_, start + 4, ymin) || !rd_i16(data_, size_, start + 6, xmax) ||
!rd_i16(data_, size_, start + 8, ymax)) {
return false;
}
out.x_min = xmin;
out.y_min = ymin;
out.x_max = xmax;
out.y_max = ymax;
const bool ok = append_glyph(glyph_index, builder, 0);
out.point_count = builder.point_count;
out.contour_count = builder.contour_count;
return ok;
}
bool TtfFont::append_glyph(u16 gid, GlyphBuilder& b, int depth) const {
if (gid >= num_glyphs_) return false;
const u32 start = loca_[gid];
const u32 end = loca_[gid + 1];
if (end <= start) return true;
if (end > glyf_offset_ + glyf_length_ || static_cast<usize>(start) + 10 > size_) return false;
i16 n_contours = 0;
if (!rd_i16(data_, size_, start, n_contours)) return false;
if (n_contours >= 0) return append_simple_glyph(start, b);
return append_composite_glyph(start, end, b, depth);
}
bool TtfFont::append_simple_glyph(u32 start, GlyphBuilder& b) const {
i16 n_contours_s = 0;
rd_i16(data_, size_, start, n_contours_s);
if (n_contours_s <= 0) return true;
const u32 n_contours = static_cast<u32>(n_contours_s);
if (b.contour_count + n_contours > kMaxGlyphContours) return false;
u32 p = start + 10;
// endPtsOfContours : indice du dernier point de chaque contour.
// Ils sont relus depuis le fichier a chaque besoin plutot que stockes
// dans un tableau temporaire : evite une allocation, coute deux lectures.
u16 last_end = 0;
for (u32 i = 0; i < n_contours; ++i) {
if (!rd_u16(data_, size_, p + i * 2u, last_end)) return false;
}
const u32 n_points = static_cast<u32>(last_end) + 1u;
if (n_points == 0 || n_points > kMaxGlyphPoints) return false;
if (b.point_count + n_points > kMaxGlyphPoints) return false;
const u32 end_pts_base = p;
p += n_contours * 2u;
// On saute les instructions de hinting : elles ne sont pas interpretees.
u16 instr_len = 0;
if (!rd_u16(data_, size_, p, instr_len)) return false;
p += 2u + instr_len;
// --- Drapeaux, avec run-length (bit kRepeatFlag) ---
const u32 base = b.point_count;
u8* flags = b.flags;
{
u32 nf = 0;
while (nf < n_points) {
u8 f = 0;
if (!rd_u8(data_, size_, p, f)) return false;
++p;
flags[nf++] = f;
if (f & kRepeatFlag) {
u8 repeat = 0;
if (!rd_u8(data_, size_, p, repeat)) return false;
++p;
for (u8 r = 0; r < repeat && nf < n_points; ++r) flags[nf++] = f;
}
}
}
// --- Coordonnees, deltas sur 1 ou 2 octets ---
// Le couple (kXShortVector, kXSameOrPos) encode a la fois la taille et le
// signe du delta : c est le point le plus contre-intuitif du format glyf.
//
// Les accumulateurs restent en i32 comme dans l original, puis sont
// convertis en float. Les coordonnees TrueType sont bornees a +-16384
// unites de police, donc la conversion est exacte (bien en dessous de
// 2^24) : aucune perte par rapport au code de Write.
{
i32 acc = 0;
for (u32 i = 0; i < n_points; ++i) {
const u8 f = flags[i];
if (f & kXShortVector) {
u8 d = 0;
if (!rd_u8(data_, size_, p, d)) return false;
++p;
acc += (f & kXSameOrPos) ? static_cast<i32>(d) : -static_cast<i32>(d);
} else if (!(f & kXSameOrPos)) {
i16 d = 0;
if (!rd_i16(data_, size_, p, d)) return false;
p += 2;
acc += d;
} // sinon : delta nul, x inchange
b.points[base + i].x = static_cast<f32>(acc);
}
}
{
i32 acc = 0;
for (u32 i = 0; i < n_points; ++i) {
const u8 f = flags[i];
if (f & kYShortVector) {
u8 d = 0;
if (!rd_u8(data_, size_, p, d)) return false;
++p;
acc += (f & kYSameOrPos) ? static_cast<i32>(d) : -static_cast<i32>(d);
} else if (!(f & kYSameOrPos)) {
i16 d = 0;
if (!rd_i16(data_, size_, p, d)) return false;
p += 2;
acc += d;
}
b.points[base + i].y = static_cast<f32>(acc);
b.points[base + i].on_curve = (f & kOnCurve) != 0;
}
}
// --- Decoupage en contours ---
u32 first = 0;
for (u32 c = 0; c < n_contours; ++c) {
u16 last = 0;
if (!rd_u16(data_, size_, end_pts_base + c * 2u, last)) return false;
if (last < first || last >= n_points) return false;
b.contour_end[b.contour_count++] = base + last + 1u;
first = last + 1u;
}
b.point_count = base + n_points;
return true;
}
bool TtfFont::append_composite_glyph(u32 start, u32 end, GlyphBuilder& b, int depth) const {
if (depth >= kMaxCompositeDepth) return false;
u32 p = start + 10;
for (;;) {
u16 flags = 0, glyph_index = 0;
if (!rd_u16(data_, size_, p, flags) || !rd_u16(data_, size_, p + 2, glyph_index)) {
return false;
}
p += 4;
// Arguments : decalage xy, ou indices de points a aligner. Seul le cas
// xy est gere, comme dans l original (l alignement par points est
// rarissime hors polices CJK anciennes).
f32 dx = 0.0f, dy = 0.0f;
if (flags & kArg1And2AreWords) {
i16 a1 = 0, a2 = 0;
if (!rd_i16(data_, size_, p, a1) || !rd_i16(data_, size_, p + 2, a2)) return false;
p += 4;
if (flags & kArgsAreXyValues) {
dx = static_cast<f32>(a1);
dy = static_cast<f32>(a2);
}
} else {
u8 b1 = 0, b2 = 0;
if (!rd_u8(data_, size_, p, b1) || !rd_u8(data_, size_, p + 1, b2)) return false;
p += 2;
if (flags & kArgsAreXyValues) {
dx = static_cast<f32>(static_cast<i8>(b1));
dy = static_cast<f32>(static_cast<i8>(b2));
}
}
f32 a = 1.0f, bb = 0.0f, c = 0.0f, d = 1.0f;
if (flags & kWeHaveAScale) {
if (!rd_f2dot14(data_, size_, p, a)) return false;
d = a;
p += 2;
} else if (flags & kWeHaveXAndYScale) {
if (!rd_f2dot14(data_, size_, p, a) || !rd_f2dot14(data_, size_, p + 2, d)) {
return false;
}
p += 4;
} else if (flags & kWeHaveATwoByTwo) {
if (!rd_f2dot14(data_, size_, p, a) || !rd_f2dot14(data_, size_, p + 2, bb) ||
!rd_f2dot14(data_, size_, p + 4, c) || !rd_f2dot14(data_, size_, p + 6, d)) {
return false;
}
p += 8;
}
// La composante est ajoutee directement a la suite dans le builder,
// puis transformee sur place. L original construisait un Glyph
// temporaire et copiait ses contours ; ici il n y a pas de copie.
const u32 mark_points = b.point_count;
if (append_glyph(glyph_index, b, depth + 1)) {
for (u32 i = mark_points; i < b.point_count; ++i) {
const f32 x = b.points[i].x, y = b.points[i].y;
b.points[i].x = a * x + c * y + dx;
b.points[i].y = bb * x + d * y + dy;
}
}
if (!(flags & kMoreComponents)) break;
if (p >= end) break;
}
return true;
}
} // namespace proj3::font
+181
Voir le fichier
@@ -0,0 +1,181 @@
// font/ttf.hpp — parser TTF, porte depuis Gastinel Write (src/font/ttf.h).
//
// SOUS-ENSEMBLE STRICT, inchange par rapport a l original :
// head : unitsPerEm, indexToLocFormat
// maxp : numGlyphs
// cmap : Unicode -> index de glyphe (formats 4 et 12 uniquement)
// loca : offsets dans glyf
// glyf : contours quadratiques (simples et composites)
// hmtx : advanceWidth / leftSideBearing (avec hhea)
//
// DETTE TECHNIQUE HERITEE, CONSERVEE TELLE QUELLE (cf. README) :
// pas de kern / GPOS -> aucun crenage
// pas de fpgm/prep/cvt -> aucun hinting, instructions ignorees
// pas de CFF / CFF2 -> les polices PostScript sont refusees
// pas de VORG / vmtx -> pas d ecriture verticale
// Ces choix sont volontaires et ne doivent pas etre "corriges" dans ce
// chantier.
//
// CE QUI CHANGE PAR RAPPORT A L ORIGINAL, et pourquoi :
// 1. std::vector / std::string ont disparu. Rien n alloue : l appelant
// fournit les arenes. Le garde-fou du chantier 3 tue le processus si une
// allocation cachee subsistait.
// 2. Le fichier n est plus copie. load() prend un tampon deja en memoire,
// dont l appelant garde la propriete et qui doit rester valide aussi
// longtemps que la police. L original copiait tout le fichier dans un
// vector ; ici c est l arene de l appelant qui le detient.
// 3. Les messages d erreur sont des chaines litterales, pas des std::string
// concatenees. On perd le nom du fichier dans le message ; l appelant l a.
// 4. La lecture de fichier n est plus dans cette classe (elle utilisait
// fopen). Elle est dans io/file.hpp, avec une implementation par cible.
//
// ENDIANNESS : le format TrueType est big-endian. Le parser lit octet par
// octet et reconstruit les valeurs a la main, exactement comme l original :
// il est donc insensible a l endianness de la machine. Ce point ne change pas
// entre x86 Windows et AArch64 Linux. (Ce n est PAS vrai de la composition
// vers le framebuffer : cf. render/compose.hpp.)
#pragma once
#include "proj3/base/math.hpp"
#include "proj3/base/types.hpp"
#include "proj3/mem/arena.hpp"
namespace proj3::font {
// Un point de contour, en unites de police.
// on_curve distingue les points d ancrage des points de controle quadratiques
// (TrueType n a pas de cubiques).
struct GlyphPoint {
f32 x = 0.0f;
f32 y = 0.0f;
bool on_curve = false;
};
// Bornes reprises de l original : n_points > 10000 y etait deja un refus.
// kMaxGlyphContours est nouveau — l original s appuyait sur la croissance du
// vector. 256 contours est deja bien au-dela de tout glyphe reel (le glyphe
// le plus charge d Inter en compte moins de 40).
inline constexpr u32 kMaxGlyphPoints = 10000;
inline constexpr u32 kMaxGlyphContours = 256;
inline constexpr int kMaxCompositeDepth = 5;
// Tampon de construction d un glyphe. Alloue UNE FOIS dans une arene, puis
// reutilise pour tous les glyphes. C est ce qui remplace la croissance des
// vector de l original.
struct GlyphBuilder {
GlyphPoint* points = nullptr;
u32* contour_end = nullptr; // indice de fin exclusif de chaque contour
// Tampon de drapeaux glyf. Il vit dans le builder et non sur la pile :
// 10000 octets de pile seraient deja discutables, et la pile d un
// processus sans libc n a pas de garde-page automatique.
u8* flags = nullptr;
u32 point_count = 0;
u32 contour_count = 0;
void init(mem::Arena& a) {
points = a.alloc_array<GlyphPoint>(kMaxGlyphPoints);
contour_end = a.alloc_array<u32>(kMaxGlyphContours);
flags = a.alloc_array<u8>(kMaxGlyphPoints);
reset();
}
void reset() {
point_count = 0;
contour_count = 0;
}
};
// Un glyphe decode. Les pointeurs visent le GlyphBuilder : la duree de vie
// d un Glyph est celle du prochain appel a load_glyph.
struct Glyph {
const GlyphPoint* points = nullptr;
const u32* contour_end = nullptr;
u32 point_count = 0;
u32 contour_count = 0;
f32 x_min = 0.0f, y_min = 0.0f, x_max = 0.0f, y_max = 0.0f;
f32 advance_width = 0.0f;
f32 left_side_bearing = 0.0f;
bool empty() const { return contour_count == 0; }
// Bornes du contour i dans points[].
u32 contour_begin(u32 i) const { return i == 0 ? 0u : contour_end[i - 1]; }
u32 contour_size(u32 i) const { return contour_end[i] - contour_begin(i); }
};
class TtfFont {
public:
// `data` doit rester valide tant que la police est utilisee : rien n est
// copie. `arena` sert a loca et cmap, alloues une fois pour toutes.
// En cas d echec, `error` recoit un litteral (jamais nullptr).
bool load(const u8* data, usize size, mem::Arena& arena, const char*& error);
u16 glyph_index_for_codepoint(u32 codepoint) const;
// Decode les contours d un glyphe dans `builder`. `out` pointe dedans.
bool load_glyph(u16 glyph_index, GlyphBuilder& builder, Glyph& out) const;
u16 units_per_em() const { return units_per_em_; }
i16 ascender() const { return ascender_; }
i16 descender() const { return descender_; }
i16 line_gap() const { return line_gap_; }
u16 num_glyphs() const { return num_glyphs_; }
u32 cmap_size() const { return cmap_count_; }
private:
struct TableRecord {
u32 offset = 0;
u32 length = 0;
bool present = false;
};
struct CmapEntry {
u32 codepoint;
u16 gid;
};
TableRecord find_table(const char tag[4]) const;
bool parse_head(const char*& error);
bool parse_maxp(const char*& error);
bool parse_hhea_hmtx(const char*& error);
bool parse_loca(mem::Arena& arena, const char*& error);
bool parse_cmap(mem::Arena& arena, const char*& error);
// Deux passes : compte puis remplit. `out` nul = passe de comptage.
u32 walk_cmap_format4(u32 off, CmapEntry* out, u32 cap) const;
u32 walk_cmap_format12(u32 off, CmapEntry* out, u32 cap) const;
bool append_simple_glyph(u32 start, GlyphBuilder& b) const;
bool append_composite_glyph(u32 start, u32 end, GlyphBuilder& b, int depth) const;
bool append_glyph(u16 gid, GlyphBuilder& b, int depth) const;
const u8* data_ = nullptr;
usize size_ = 0;
// Repertoire de tables : tableau fixe. 64 tables est deja plus du double
// de ce qu une police reelle expose.
static constexpr u32 kMaxTables = 64;
char table_tag_[kMaxTables][4] = {};
TableRecord table_rec_[kMaxTables] = {};
u32 table_count_ = 0;
u16 units_per_em_ = 1000;
i16 index_to_loc_format_ = 0;
u16 num_glyphs_ = 0;
u16 num_h_metrics_ = 0;
i16 ascender_ = 0;
i16 descender_ = 0;
i16 line_gap_ = 0;
u32 glyf_offset_ = 0;
u32 glyf_length_ = 0;
u32 hmtx_offset_ = 0;
u32* loca_ = nullptr; // num_glyphs + 1 offsets absolus
u32 loca_count_ = 0;
CmapEntry* cmap_ = nullptr;
u32 cmap_count_ = 0;
};
} // namespace proj3::font
+71
Voir le fichier
@@ -0,0 +1,71 @@
#include "proj3/mem/arena.hpp"
#include "proj3/sys/panic.hpp"
namespace proj3::mem {
namespace {
constexpr bool is_power_of_two(usize v) { return v != 0 && (v & (v - 1)) == 0; }
} // namespace
void Arena::init(const char* name, u8* base, usize capacity) {
name_ = name;
base_ = base;
capacity_ = capacity;
used_ = 0;
peak_ = 0;
}
void* Arena::try_alloc(usize size, usize align) {
if (base_ == nullptr) return nullptr;
if (!is_power_of_two(align)) return nullptr;
// Alignement calcule sur l offset, pas sur l adresse : la base d une arene
// est toujours alignee sur une page (donc sur tout ce qui nous interesse),
// et travailler en offset garde le calcul independant de l adresse reelle.
// C est ce qui rend le comportement identique entre l hote et la cible.
const usize aligned = (used_ + (align - 1)) & ~(align - 1);
// Debordement arithmetique verifie avant le test de capacite : sur une
// taille absurde, aligned + size pourrait reboucler et passer le test.
if (aligned < used_) return nullptr;
if (size > capacity_ - aligned) return nullptr;
u8* p = base_ + aligned;
used_ = aligned + size;
if (used_ > peak_) peak_ = used_;
return p;
}
void* Arena::alloc(usize size, usize align) {
void* p = try_alloc(size, align);
if (p != nullptr) return p;
// Diagnostic exploitable : on veut savoir QUELLE arene, combien elle a,
// combien on demandait. Sans ces trois nombres, le message ne sert a rien.
err_write("proj3: PANIQUE: debordement d arene '");
err_write(name_);
err_write("' : demande=");
err_write_i64(static_cast<i64>(size));
err_write(" align=");
err_write_i64(static_cast<i64>(align));
err_write(" occupe=");
err_write_i64(static_cast<i64>(used_));
err_write(" capacite=");
err_write_i64(static_cast<i64>(capacity_));
err_write("\n");
err_write(" Un debordement d arene est un defaut de conception, pas un cas\n");
err_write(" a gerer : corriger le calcul dans mem/layout.hpp.\n");
panic("debordement d arene");
}
void Arena::rewind_to(usize m) {
if (m > used_) {
panic_v("rewind_to au-dela de la position courante", "marque",
static_cast<i64>(m));
}
used_ = m;
}
} // namespace proj3::mem
+76
Voir le fichier
@@ -0,0 +1,76 @@
// mem/arena.hpp — allocateur lineaire (bump allocator).
//
// Regles, non negociables :
// - allocation = avance de pointeur, avec alignement ;
// - aucune liberation individuelle ; un reset global par arene ;
// - un debordement est une PANIQUE, jamais un agrandissement.
//
// Le dernier point est le plus important : un debordement d arene signifie que
// le calcul de mem/layout.hpp est faux. Agrandir masquerait l erreur et
// reintroduirait une allocation apres l init, donc une latence non bornee.
// On veut que ca casse, fort, au premier essai, avec le nom de l arene.
#pragma once
#include "proj3/base/types.hpp"
namespace proj3::mem {
class Arena {
public:
// Une arene non initialisee est inutilisable : toute allocation panique.
constexpr Arena() = default;
void init(const char* name, u8* base, usize capacity);
// Alloue `size` octets alignes sur `align` (puissance de deux).
// Ne rend jamais nullptr : soit ca reussit, soit ca panique.
void* alloc(usize size, usize align);
// Allocation typee. L alignement vient du type. La memoire N EST PAS
// construite : Arena ne connait pas les constructeurs, et le projet
// n utilise que des types trivialement constructibles.
template <class T>
T* alloc_array(usize count) {
return static_cast<T*>(alloc(count * sizeof(T), alignof(T)));
}
template <class T>
T* alloc_one() {
return static_cast<T*>(alloc(sizeof(T), alignof(T)));
}
// Version qui rend nullptr au lieu de paniquer. Reservee aux cas ou
// l appelant a un vrai chemin de repli. Il n y en a aucun aujourd hui ;
// elle existe pour que le harnais de test puisse verifier la borne sans
// se faire tuer.
void* try_alloc(usize size, usize align);
// Marque de position, pour un rembobinage local (motif "scratch dans le
// scratch"). Ce n est PAS une liberation : rembobiner invalide tout ce qui
// a ete alloue apres la marque.
usize mark() const { return used_; }
void rewind_to(usize m);
void reset() { used_ = 0; }
const char* name() const { return name_; }
usize capacity() const { return capacity_; }
usize used() const { return used_; }
usize remaining() const { return capacity_ - used_; }
u8* base() const { return base_; }
// Plus haute occupation atteinte depuis l init. C est la seule metrique
// qui permette de dire si une taille de mem/layout.hpp est juste ou
// fantaisiste. Elle est mise a jour a chaque allocation, cout : une
// comparaison.
usize peak() const { return peak_; }
private:
const char* name_ = "<non initialisee>";
u8* base_ = nullptr;
usize capacity_ = 0;
usize used_ = 0;
usize peak_ = 0;
};
} // namespace proj3::mem
+117
Voir le fichier
@@ -0,0 +1,117 @@
// mem/layout.hpp — budget memoire du projet, en constexpr.
//
// DIMENSIONNE POUR LE PIXEL 3A : 4 Go de RAM, ecran 1080x2220.
// PAS pour la cible 12 Go. Cf. doc/memoire.md, section "Passage a la cible
// 12 Go", pour la liste de ce qu il faudra revalider.
//
// Chaque taille ci-dessous est un CALCUL, pas un chiffre rond. Si un calcul
// est faux, il doit etre corrige ici, pas contourne par une marge.
#pragma once
#include "proj3/base/types.hpp"
namespace proj3::mem {
inline constexpr usize kKiB = 1024;
inline constexpr usize kMiB = 1024 * kKiB;
// Granularite de page classique sur arm64 avec un noyau Android stock
// (CONFIG_ARM64_4K_PAGES). Les noyaux 16K existent (certains Pixel recents) :
// si la cible en utilisait un, l alignement ci-dessous resterait valide, il
// serait seulement plus grossier que necessaire.
inline constexpr usize kPageSize = 4 * kKiB;
// Taille de huge page visee. 2 Mo est la seule taille garantie presente sur
// arm64 en 4K pages (PMD-level). 1 Go (PUD) existe mais n est pas active sur
// un noyau mobile.
inline constexpr usize kHugePageSize = 2 * kMiB;
inline constexpr usize align_up(usize v, usize a) { return (v + (a - 1)) & ~(a - 1); }
// --- Ecran ----------------------------------------------------------------
inline constexpr usize kScreenWidth = 1080;
inline constexpr usize kScreenHeight = 2220;
inline constexpr usize kBytesPerPixel = 4; // XRGB8888, format de scanout DRM
// --- 1. Scanout -----------------------------------------------------------
// Calcul : 1080 * 2220 * 4 = 9 590 400 octets par tampon.
// Deux tampons : double buffering. Pas trois : un triple buffering ajoute une
// image entiere de latence, ce qui est exactement ce que le projet combat.
// Chaque tampon est aligne sur une page pour pouvoir etre passe tel quel a un
// import DRM ulterieur.
inline constexpr usize kScanoutOneRaw = kScreenWidth * kScreenHeight * kBytesPerPixel;
inline constexpr usize kScanoutOne = align_up(kScanoutOneRaw, kPageSize);
inline constexpr usize kScanoutBuffers = 2;
inline constexpr usize kScanoutBytes = kScanoutOne * kScanoutBuffers;
static_assert(kScanoutOneRaw == 9590400);
// --- 2. Geometrie / contours du rasterizer --------------------------------
// Une arete de balayage occupe 20 octets (4 float + 1 int32).
// Pire cas raisonne : un glyphe complexe (ideogramme, ligature dense) compte
// jusqu a ~600 points de contour. A 64 px/em, une courbe quadratique mesure au
// plus ~64 px de polygone de controle, donc au plus ceil(64/1.5) = 43
// subdivisions, plafonnees a 64 par le rasterizer. Majorant : 600 * 64 = 38400
// aretes, soit 768 000 octets.
// On prend 2 Mo, ce qui laisse la place pour rasteriser un trace d interface
// (bordures, coins arrondis) dans la meme passe sans reset intermediaire.
inline constexpr usize kEdgeBytes = 20;
inline constexpr usize kGeometryBytes = 2 * kMiB;
static_assert(kGeometryBytes / kEdgeBytes > 38400 * 2, "marge geometrie insuffisante");
// --- 3. Atlas de glyphes --------------------------------------------------
// Couverture 8 bits, 1 octet par pixel.
// Trois corps prevus : 16 px (texte), 24 px (interface), 32 px (titres).
// Une cellule mesure (corps + 2) au carre, les 2 px absorbant la marge d un
// pixel que le rasterizer ajoute de chaque cote.
// 16 -> 18*18 = 324
// 24 -> 26*26 = 676
// 32 -> 34*34 = 1156
// total par glyphe = 2156 octets
// Jeu couvert : Latin-1 complet plus ponctuation, soit 256 glyphes.
// 256 * 2156 = 551 936 octets.
// On prend 2 Mo, soit un facteur 3,8 : de quoi ajouter un quatrieme corps ou
// une variante grasse sans redimensionner l arene.
inline constexpr usize kAtlasGlyphSlots = 256;
inline constexpr usize kAtlasBytesPerGlyph = 18 * 18 + 26 * 26 + 34 * 34;
inline constexpr usize kAtlasBytes = 2 * kMiB;
static_assert(kAtlasBytesPerGlyph == 2156);
static_assert(kAtlasBytes > kAtlasGlyphSlots * kAtlasBytesPerGlyph * 3);
// --- 4. Evenements d entree -----------------------------------------------
// Un evenement d entree normalise fait 32 octets (horodatage 64 bits, type,
// code, valeur, identifiant de contact, remplissage).
// Un ecran tactile rapporte au plus ~200 evenements par seconde et par point
// de contact, dix points simultanes au maximum : 2000 evenements/seconde.
// Un tampon de 4096 evenements couvre donc plus de deux secondes d entree en
// rafale — largement au-dela du delai maximal entre deux images.
// 4096 * 32 = 131 072 octets.
inline constexpr usize kInputEventBytes = 32;
inline constexpr usize kInputEventSlots = 4096;
inline constexpr usize kInputBytes = kInputEventBytes * kInputEventSlots;
static_assert(kInputBytes == 128 * kKiB);
// --- 5. Scratch de frame --------------------------------------------------
// Remise a zero a chaque image. Contient les intersections de balayage, les
// listes de rectangles sales, les tampons temporaires de composition.
// Majorant pour les intersections : une ligne de balayage peut etre traversee
// par toutes les aretes du glyphe, soit 38400 croisements de 8 octets =
// 307 200 octets. Le reste est de la composition par tuiles.
// 2 Mo, avec le meme raisonnement de marge que la geometrie.
inline constexpr usize kFrameScratchBytes = 2 * kMiB;
// --- Total ----------------------------------------------------------------
inline constexpr usize kArenaTotalRaw =
kScanoutBytes + kGeometryBytes + kAtlasBytes + kInputBytes + kFrameScratchBytes;
// On demande au noyau un bloc arrondi au multiple superieur de 2 Mo, sans quoi
// MAP_HUGETLB echoue (le noyau exige une longueur multiple de la taille de
// huge page). Le reliquat n est pas perdu : il est expose comme reserve.
inline constexpr usize kArenaTotal = align_up(kArenaTotalRaw, kHugePageSize);
inline constexpr usize kReserveBytes = kArenaTotal - kArenaTotalRaw;
static_assert(kArenaTotal % kHugePageSize == 0);
// Verification d ordre de grandeur : le budget total doit rester tres en
// dessous du pour-cent de la RAM du Pixel 3a. 4 Go = 4 294 967 296 octets.
static_assert(kArenaTotal < 4294967296ull / 64, "budget memoire hors de proportion");
} // namespace proj3::mem
+119
Voir le fichier
@@ -0,0 +1,119 @@
// mem/new_guard.cpp — GARDE-FOU DU PILIER 2.
//
// Redefinit les operateurs d allocation globaux pour qu ils tuent le processus
// immediatement, avec un message identifiable.
//
// Ce n est pas un test : c est un filet permanent. Toute allocation dynamique
// cachee — un std::vector oublie dans du code porte, une lambda capturee par
// valeur qui deborde du stockage local, un conteneur d une bibliotheque tierce
// — devient un plantage immediat et localisable au lieu d une degradation
// silencieuse de la latence.
//
// COMMENT LOCALISER LE COUPABLE quand ce message apparait :
// 1. Le message donne la taille demandee.
// 2. Poser un point d arret sur `operator new` (le symbole existe, il n est
// pas inline) et remonter la pile. Deux images suffisent en general.
// 3. Sur la cible : le processus s arrete avec le code 71, distinct du 70
// de panic(), pour qu un script sache que c est une allocation et pas
// autre chose.
//
// CE QUE LE GARDE-FOU N ATTRAPE PAS, et c est important de le savoir :
// - malloc / calloc / realloc / free appeles directement. Ce sont des
// fonctions C, sans rapport avec operator new. Sur la cible embarquee la
// question ne se pose pas (pas de libc, le lien echouerait). Sur l hote,
// page_source_host.cpp les utilise deliberement.
// - les allocations faites par le noyau (pile, mmap).
// - les VLA et alloca, qui prennent sur la pile.
// Le perimetre est donc exactement : "aucun new C++ nulle part". C est ce
// qu on veut verifier.
//
// EMPLACEMENT DANS LA CONSTRUCTION : ce fichier est une bibliotheque separee
// (proj3_newguard). On ne le lie que dans les executables qui pretendent ne
// rien allouer. Le lier partout casserait tout outil qui utilise la STL de
// l hote — ce qui est precisement le comportement recherche, mais il faut le
// choisir explicitement, executable par executable.
#include "proj3/base/types.hpp"
#include "proj3/sys/panic.hpp"
#if PROJ3_EMBEDDED
#include "proj3/sys/syscalls.hpp"
// Sur la cible embarquee il n y a pas d en-tete <new> a inclure : la
// bibliotheque standard n est pas installee pour le triplet croise. On declare
// donc le seul type dont on a besoin, avec exactement la definition qu impose
// le standard ([support.types], enumeration a portee de type sous-jacent
// size_t). Le compilateur reconnait ce type par son nom qualifie.
namespace std {
enum class align_val_t : proj3::usize {};
}
#else
#include <cstdlib>
#include <new>
#endif
namespace {
[[noreturn]] void trap_allocation(const char* which, proj3::usize size) {
proj3::err_write("proj3: ALLOCATION INTERDITE: ");
proj3::err_write(which);
proj3::err_write(" taille=");
proj3::err_write_i64(static_cast<proj3::i64>(size));
proj3::err_write("\n");
proj3::err_write(
" Le projet n alloue rien apres l init. Tout passe par une arene\n"
" (mem/arena.hpp). Poser un point d arret sur operator new et\n"
" remonter la pile pour trouver l appelant.\n");
#if PROJ3_EMBEDDED
proj3::sys::exit_group(71);
#else
std::_Exit(71);
#endif
}
[[noreturn]] void trap_free(const char* which) {
proj3::err_write("proj3: LIBERATION INTERDITE: ");
proj3::err_write(which);
proj3::err_write("\n");
proj3::err_write(
" Une arene ne libere pas individuellement. Atteindre ce point\n"
" signifie qu un objet a ete alloue par new quelque part.\n");
#if PROJ3_EMBEDDED
proj3::sys::exit_group(71);
#else
std::_Exit(71);
#endif
}
} // namespace
// Les signatures doivent correspondre exactement a celles du standard, sinon
// on ne remplace pas l operateur, on en ajoute un autre. On couvre les formes
// de base et les formes alignees (C++17), que le compilateur choisit tout seul
// pour un type sur-aligne — cas typique d un tampon NEON.
void* operator new(proj3::usize size) { trap_allocation("operator new", size); }
void* operator new[](proj3::usize size) { trap_allocation("operator new[]", size); }
void* operator new(proj3::usize size, std::align_val_t) {
trap_allocation("operator new (aligne)", size);
}
void* operator new[](proj3::usize size, std::align_val_t) {
trap_allocation("operator new[] (aligne)", size);
}
void operator delete(void*) noexcept { trap_free("operator delete"); }
void operator delete[](void*) noexcept { trap_free("operator delete[]"); }
void operator delete(void*, proj3::usize) noexcept { trap_free("operator delete (dimensionne)"); }
void operator delete[](void*, proj3::usize) noexcept {
trap_free("operator delete[] (dimensionne)");
}
void operator delete(void*, std::align_val_t) noexcept { trap_free("operator delete (aligne)"); }
void operator delete[](void*, std::align_val_t) noexcept {
trap_free("operator delete[] (aligne)");
}
void operator delete(void*, proj3::usize, std::align_val_t) noexcept {
trap_free("operator delete (dimensionne aligne)");
}
void operator delete[](void*, proj3::usize, std::align_val_t) noexcept {
trap_free("operator delete[] (dimensionne aligne)");
}
+85
Voir le fichier
@@ -0,0 +1,85 @@
// mem/page_source.hpp — acquisition des pages, avec repli detecte au runtime.
//
// UN SEUL BINAIRE, TROIS CHEMINS, choisis a l execution :
//
// 1. mmap(MAP_HUGETLB | MAP_HUGE_2MB) -> HugeMode::Hugetlb2MB
// 2. mmap classique + madvise(MADV_HUGEPAGE) -> HugeMode::TransparentHuge
// 3. mmap classique seul -> HugeMode::PlainPages
//
// Meme esprit que le repli OpenGL/GDI de Gastinel Write : on ne compile pas
// deux binaires, on ne demande pas a l utilisateur, on essaie dans l ordre et
// on journalise ce qui a marche.
//
// CES TROIS MODES N ONT PAS LES MEMES PROPRIETES DE DETERMINISME.
// C est le point central de ce fichier, pas une note de bas de page :
//
// Hugetlb2MB Les pages sont reservees d avance dans le pool hugetlbfs.
// Elles ne sont ni deplacees, ni fusionnees, ni recuperees.
// Une entree de TLB couvre 2 Mo. Les mesures de latence
// faites dans ce mode sont valides.
//
// TransparentHuge Le noyau PEUT promouvoir la region en huge pages, ou pas,
// et il le fait par un fil de fond (khugepaged) dont
// l ordonnancement nous echappe. Une promotion ou une
// scission peut se produire PENDANT une mesure. Toute
// mesure de latence faite dans ce mode porte une barre
// d erreur inconnue et doit etre annotee comme telle.
//
// PlainPages Pages de 4 Ko. Le comportement est previsible mais le
// nombre d entrees de TLB necessaires pour couvrir le
// scanout (9,6 Mo, soit ~2342 pages) depasse la TLB L2 d un
// Cortex-A75. Les manques de TLB sont alors une source de
// variance mesurable. Le mode est correct, pas rapide.
//
// C est pourquoi active_mode() est expose dans l API : tout code qui produit
// une mesure doit pouvoir l estampiller.
#pragma once
#include "proj3/base/types.hpp"
namespace proj3::mem {
enum class HugeMode : u32 {
Uninitialized = 0,
Hugetlb2MB,
TransparentHuge,
PlainPages,
// Cible hote uniquement : memoire fournie par la libc de l hote. Aucune
// garantie d aucune sorte. Presente pour que le harnais puisse tourner
// sur la machine de dev, et pour qu il soit IMPOSSIBLE de confondre une
// mesure faite ici avec une mesure faite sur la cible.
HostEmulated,
};
struct PageBlock {
u8* base = nullptr;
usize size = 0;
HugeMode mode = HugeMode::Uninitialized;
};
// Nom lisible, pour la journalisation. Jamais nullptr.
const char* huge_mode_name(HugeMode m);
// true si le mode donne autorise a publier une mesure de latence sans
// avertissement. Un seul mode repond true.
constexpr bool mode_is_deterministic(HugeMode m) { return m == HugeMode::Hugetlb2MB; }
// Acquiert `size` octets. `size` doit etre un multiple de 2 Mo (exige par
// MAP_HUGETLB ; on impose la meme contrainte aux trois chemins pour que le
// mode retenu ne change pas la disposition memoire).
// Rend false uniquement si les TROIS chemins ont echoue.
bool page_acquire(usize size, PageBlock& out);
// Rend les pages. N est appele qu en fin de processus, et meme la c est
// superflu (le noyau nettoie). Existe pour que le harnais hote puisse
// enchainer plusieurs acquisitions sans fuir.
void page_release(PageBlock& block);
// Mode effectivement retenu par la derniere acquisition reussie.
// Interrogeable par le programme, comme demande.
HugeMode active_mode();
// Journalise sur la sortie d erreur le mode retenu et ses implications.
void log_active_mode();
} // namespace proj3::mem
+91
Voir le fichier
@@ -0,0 +1,91 @@
// mem/page_source_host.cpp — acquisition des pages sur la machine de dev.
//
// CIBLE HOTE UNIQUEMENT. Utilise malloc, ce qui serait inacceptable sur la
// cible embarquee. C est l asymetrie assumee de l ADR-0001.
//
// Le mode rendu est toujours HugeMode::HostEmulated, precisement pour qu il
// soit impossible de prendre une mesure faite ici pour une mesure faite sur
// le telephone. Ce n est pas un detail cosmetique : c est la seule protection
// contre la publication d un chiffre obtenu sur un x86 de bureau.
//
// Le malloc utilise ici est appele AVANT que le garde-fou d allocation ne
// puisse intervenir, et il passe par malloc et non par operator new : les deux
// mecanismes sont distincts, le garde-fou n intercepte que operator new.
// C est voulu. Cf. mem/new_guard.cpp, section "Ce que le garde-fou n attrape
// pas".
#include "proj3/mem/page_source.hpp"
#include <cstdlib>
#include "proj3/mem/layout.hpp"
#include "proj3/sys/panic.hpp"
namespace proj3::mem {
namespace {
HugeMode g_active = HugeMode::Uninitialized;
// On garde le pointeur brut rendu par malloc pour pouvoir le liberer, puisque
// la base publiee est alignee et donc potentiellement decalee.
void* g_raw = nullptr;
} // namespace
const char* huge_mode_name(HugeMode m) {
switch (m) {
case HugeMode::Hugetlb2MB: return "HUGETLB-2MB";
case HugeMode::TransparentHuge: return "THP-MADV_HUGEPAGE";
case HugeMode::PlainPages: return "PAGES-4K";
case HugeMode::HostEmulated: return "HOTE-EMULE";
case HugeMode::Uninitialized: break;
}
return "NON-INITIALISE";
}
bool page_acquire(usize size, PageBlock& out) {
out = PageBlock{};
if (size == 0 || (size % kHugePageSize) != 0) {
panic_v("page_acquire : taille non multiple de 2 Mo", "taille",
static_cast<i64>(size));
}
if (g_raw != nullptr) {
panic("page_acquire hote : une seule acquisition a la fois");
}
// Alignement manuel sur 2 Mo : on veut que la disposition memoire vue par
// les arenes soit la meme que sur la cible, sinon un bug d alignement ne
// se manifesterait que sur le telephone.
void* raw = std::malloc(size + kHugePageSize);
if (raw == nullptr) return false;
g_raw = raw;
const uptr addr = reinterpret_cast<uptr>(raw);
const uptr aligned = (addr + (kHugePageSize - 1)) & ~static_cast<uptr>(kHugePageSize - 1);
out.base = reinterpret_cast<u8*>(aligned);
out.size = size;
out.mode = HugeMode::HostEmulated;
g_active = out.mode;
return true;
}
void page_release(PageBlock& block) {
if (g_raw != nullptr) {
std::free(g_raw);
g_raw = nullptr;
}
block = PageBlock{};
}
HugeMode active_mode() { return g_active; }
void log_active_mode() {
err_write("proj3: memoire : mode retenu = ");
err_write(huge_mode_name(g_active));
err_write("\n");
err_write("proj3: memoire : CIBLE HOTE. Aucune propriete de determinisme.\n");
err_write("proj3: memoire : ce mode sert a valider la CORRECTION, jamais\n");
err_write("proj3: memoire : la latence. Ne publier aucun chiffre d ici.\n");
}
} // namespace proj3::mem
+114
Voir le fichier
@@ -0,0 +1,114 @@
// mem/page_source_linux.cpp — acquisition des pages sur la cible embarquee.
//
// N utilise que nos wrappers syscall. Aucune libc.
#include "proj3/mem/page_source.hpp"
#include "proj3/mem/layout.hpp"
#include "proj3/sys/panic.hpp"
#include "proj3/sys/syscalls.hpp"
#include "proj3/sys/uapi.hpp"
namespace proj3::mem {
namespace {
// Etat global mutable : une seule variable, un enum, ecrite une fois a l init
// et lue ensuite. C est la seule entorse a la regle "pas de .data mutable",
// et elle est ici parce que le mode retenu doit rester interrogeable par tout
// le programme sans etre passe de main en main.
HugeMode g_active = HugeMode::Uninitialized;
sys::Result map_anon(usize size, i32 extra_flags) {
const i32 prot = sys::PROT_READ | sys::PROT_WRITE;
const i32 flags = sys::MAP_PRIVATE | sys::MAP_ANONYMOUS | extra_flags;
return sys::mmap(nullptr, size, prot, flags, -1, 0);
}
} // namespace
const char* huge_mode_name(HugeMode m) {
switch (m) {
case HugeMode::Hugetlb2MB: return "HUGETLB-2MB";
case HugeMode::TransparentHuge: return "THP-MADV_HUGEPAGE";
case HugeMode::PlainPages: return "PAGES-4K";
case HugeMode::HostEmulated: return "HOTE-EMULE";
case HugeMode::Uninitialized: break;
}
return "NON-INITIALISE";
}
bool page_acquire(usize size, PageBlock& out) {
out = PageBlock{};
if (size == 0 || (size % kHugePageSize) != 0) {
panic_v("page_acquire : taille non multiple de 2 Mo", "taille",
static_cast<i64>(size));
}
// --- Chemin 1 : huge pages reservees ---------------------------------
// MAP_HUGE_2MB est explicite : sans lui, MAP_HUGETLB prend la taille par
// defaut du systeme, qui peut etre 512 Mo sur certaines configurations et
// ferait echouer l appel pour une raison difficile a diagnostiquer.
//
// Echoue typiquement avec ENOMEM (pool hugetlbfs vide, cas le plus
// probable sur un noyau Android stock : nr_hugepages vaut 0 par defaut),
// EPERM, ou EINVAL si le noyau est compile sans CONFIG_HUGETLBFS.
{
const sys::Result r = map_anon(size, sys::MAP_HUGETLB | sys::MAP_HUGE_2MB);
if (r.is_ok()) {
out.base = static_cast<u8*>(r.ptr());
out.size = size;
out.mode = HugeMode::Hugetlb2MB;
g_active = out.mode;
return true;
}
}
// --- Chemin 2 : pages classiques + conseil THP ------------------------
{
const sys::Result r = map_anon(size, 0);
if (r.is_ok()) {
out.base = static_cast<u8*>(r.ptr());
out.size = size;
const sys::Result a = sys::madvise(out.base, size, sys::MADV_HUGEPAGE);
if (a.is_ok()) {
out.mode = HugeMode::TransparentHuge;
} else {
// madvise echoue avec EINVAL si le noyau est compile sans
// CONFIG_TRANSPARENT_HUGEPAGE, ou si THP est en mode "never".
// Le mapping reste parfaitement utilisable : on tombe au
// chemin 3 sans refaire de mmap.
out.mode = HugeMode::PlainPages;
}
g_active = out.mode;
return true;
}
}
// --- Les trois chemins ont echoue -------------------------------------
// On ne panique pas ici : l appelant peut vouloir reessayer avec une
// taille plus petite, ou afficher un message plus precis.
return false;
}
void page_release(PageBlock& block) {
if (block.base == nullptr) return;
(void)sys::munmap(block.base, block.size);
block = PageBlock{};
}
HugeMode active_mode() { return g_active; }
void log_active_mode() {
err_write("proj3: memoire : mode retenu = ");
err_write(huge_mode_name(g_active));
err_write("\n");
if (mode_is_deterministic(g_active)) {
err_write("proj3: memoire : pages garanties, mesures de latence valides.\n");
} else {
err_write("proj3: memoire : ATTENTION, pages NON garanties.\n");
err_write("proj3: memoire : toute mesure de latence faite dans ce mode\n");
err_write("proj3: memoire : porte une barre d erreur inconnue.\n");
}
}
} // namespace proj3::mem
+68
Voir le fichier
@@ -0,0 +1,68 @@
#include "proj3/mem/system.hpp"
#include "proj3/mem/layout.hpp"
#include "proj3/sys/panic.hpp"
namespace proj3::mem {
bool system_init(System& out) {
if (!page_acquire(kArenaTotal, out.block)) return false;
u8* p = out.block.base;
auto carve = [&p](Arena& a, const char* name, usize bytes) {
a.init(name, p, bytes);
p += bytes;
};
// L ordre n est pas indifferent : le scanout d abord, parce que c est la
// region la plus grosse et celle qu on voudra un jour passer telle quelle
// a un import DRM ; elle est donc a l offset 0 du bloc, donc alignee sur
// 2 Mo par construction.
carve(out.scanout, "scanout", kScanoutBytes);
carve(out.geometry, "geometrie", kGeometryBytes);
carve(out.atlas, "atlas", kAtlasBytes);
carve(out.input, "entree", kInputBytes);
carve(out.scratch, "scratch", kFrameScratchBytes);
const usize consumed = static_cast<usize>(p - out.block.base);
if (consumed != kArenaTotalRaw) {
panic_v("decoupage des arenes incoherent avec layout.hpp", "consomme",
static_cast<i64>(consumed));
}
out.initialized = true;
return true;
}
void system_begin_frame(System& s) { s.scratch.reset(); }
namespace {
void report_one(const Arena& a) {
err_write("proj3: arene ");
err_write(a.name());
err_write(" : capacite=");
err_write_i64(static_cast<i64>(a.capacity()));
err_write(" pic=");
err_write_i64(static_cast<i64>(a.peak()));
err_write(" base=");
err_write_hex(reinterpret_cast<uptr>(a.base()));
err_write("\n");
}
} // namespace
void system_report(const System& s) {
err_write("proj3: budget memoire total = ");
err_write_i64(static_cast<i64>(kArenaTotal));
err_write(" octets (reserve non decoupee = ");
err_write_i64(static_cast<i64>(kReserveBytes));
err_write(")\n");
report_one(s.scanout);
report_one(s.geometry);
report_one(s.atlas);
report_one(s.input);
report_one(s.scratch);
}
} // namespace proj3::mem
+39
Voir le fichier
@@ -0,0 +1,39 @@
// mem/system.hpp — les arenes du projet, decoupees en une fois a l init.
//
// Un seul bloc est demande au noyau (kArenaTotal), puis decoupe. Raison : le
// repli huge pages ne vaut que sur une region contigue. Cinq mmap separes
// auraient cinq modes potentiellement differents, ce qui rendrait la question
// "quel mode est actif ?" sans reponse unique.
#pragma once
#include "proj3/mem/arena.hpp"
#include "proj3/mem/page_source.hpp"
namespace proj3::mem {
struct System {
Arena scanout; // deux tampons d image
Arena geometry; // aretes du rasterizer
Arena atlas; // atlas de glyphes 8 bits
Arena input; // anneau d evenements d entree
Arena scratch; // remis a zero a chaque image
PageBlock block;
bool initialized = false;
};
// Acquiert le bloc et initialise les cinq arenes.
// Rend false si l acquisition des pages a echoue (les trois chemins).
// Ne panique pas : l appelant decide quoi dire.
bool system_init(System& out);
// Remet a zero l arene de scratch. A appeler au debut de chaque image.
// C est la SEULE liberation memoire du projet.
void system_begin_frame(System& s);
// Vidage lisible de l occupation de chaque arene. Sert a verifier que les
// tailles de mem/layout.hpp correspondent a la realite.
void system_report(const System& s);
} // namespace proj3::mem
+54
Voir le fichier
@@ -0,0 +1,54 @@
#include "proj3/render/compose.hpp"
#include "proj3/base/math.hpp"
#include "proj3/sys/panic.hpp"
namespace proj3::render {
Framebuffer framebuffer_alloc(mem::Arena& a, i32 w, i32 h) {
Framebuffer fb;
fb.width = w;
fb.height = h;
fb.pixels = a.alloc_array<u32>(static_cast<usize>(w) * static_cast<usize>(h));
return fb;
}
void framebuffer_clear(Framebuffer& fb, u32 xrgb) {
const usize n = static_cast<usize>(fb.width) * static_cast<usize>(fb.height);
for (usize i = 0; i < n; ++i) fb.pixels[i] = xrgb;
}
void compose_coverage(Framebuffer& fb, i32 dst_x, i32 dst_y, const Coverage8& cov, u32 xrgb) {
if (fb.empty() || cov.empty()) return;
// L hypothese d alignement est verifiee, pas supposee : un tampon de
// destination desaligne rendrait tout futur noyau NEON incorrect, et le
// symptome apparaitrait tres loin d ici.
if ((reinterpret_cast<uptr>(fb.pixels) & 3u) != 0) {
panic("compose_coverage : framebuffer non aligne sur 4 octets");
}
// Decoupage : on calcule d abord l intersection, puis on boucle sans
// aucun test par pixel. Un test de bord dans la boucle interne serait un
// branchement imprevisible par pixel, donc de la variance.
i32 sx0 = 0, sy0 = 0;
i32 sx1 = cov.width, sy1 = cov.height;
if (dst_x < 0) sx0 = -dst_x;
if (dst_y < 0) sy0 = -dst_y;
if (dst_x + sx1 > fb.width) sx1 = fb.width - dst_x;
if (dst_y + sy1 > fb.height) sy1 = fb.height - dst_y;
if (sx0 >= sx1 || sy0 >= sy1) return;
for (i32 y = sy0; y < sy1; ++y) {
const u8* src = cov.pixels + static_cast<usize>(y) * static_cast<usize>(cov.width);
u32* dst = fb.row(dst_y + y) + (dst_x + sx0);
for (i32 x = sx0; x < sx1; ++x) {
// Couverture binaire : 0 ou 255. On teste la valeur plutot que de
// melanger, parce qu il n y a rien a melanger (cf. compose.hpp).
if (src[x] != 0) dst[x - sx0] = xrgb;
}
}
}
} // namespace proj3::render
+60
Voir le fichier
@@ -0,0 +1,60 @@
// render/compose.hpp — composition d une couverture 8 bits vers le framebuffer.
//
// POURQUOI CE FICHIER EXISTE SEPAREMENT DU RASTERIZER.
// Dans Gastinel Write, la rasterization et l ecriture dans le DIB Win32
// etaient voisines, et le format BGRA du DIB s etait infiltre dans le
// raisonnement. Ici la frontiere est explicite :
// - le rasterizer produit de la COUVERTURE, une valeur par pixel, sans
// aucune notion de couleur ni de format ;
// - ce fichier, et lui seul, connait le format de destination.
// C est cette separation qui rendra possible d ecrire un noyau NEON de
// composition sans jamais toucher au rasterizer, et de valider les deux
// separement dans le harnais d oracle.
//
// FORMAT DE DESTINATION : XRGB8888 tel que l attend un plan DRM
// (DRM_FORMAT_XRGB8888). En memoire, sur une machine little-endian, un pixel
// occupe quatre octets dans l ordre B, G, R, X. Manipule comme un u32, cela
// donne 0xXXRRGGBB.
//
// HYPOTHESES, differentes de celles du code Windows d origine :
// - little-endian. Verifie par static_assert dans base/types.hpp. AArch64
// tourne en little-endian sous Linux ; le mode big-endian existe mais
// n est pas utilise par Android ni par aucun noyau grand public.
// - Le tampon de destination est aligne sur 4 octets au minimum. Il vient
// d une arene dont la base est alignee sur 2 Mo, donc c est acquis ; la
// verification est faite a l entree pour que l hypothese ne devienne pas
// tacite.
// - Aucun alpha : le canal X est ecrit a 0xFF et jamais lu. Le rasterizer
// ne produisant qu une couverture binaire (dette heritee, cf.
// rasterizer.hpp), il n y a rien a melanger : un pixel est ecrit ou il ne
// l est pas.
#pragma once
#include "proj3/mem/arena.hpp"
#include "proj3/render/coverage.hpp"
namespace proj3::render {
struct Framebuffer {
u32* pixels = nullptr;
i32 width = 0;
i32 height = 0;
u32* row(i32 y) { return pixels + static_cast<usize>(y) * static_cast<usize>(width); }
const u32* row(i32 y) const {
return pixels + static_cast<usize>(y) * static_cast<usize>(width);
}
bool empty() const { return width <= 0 || height <= 0 || pixels == nullptr; }
};
Framebuffer framebuffer_alloc(mem::Arena& a, i32 w, i32 h);
void framebuffer_clear(Framebuffer& fb, u32 xrgb);
// Compose `cov` a la position (dst_x, dst_y) avec la couleur `xrgb`.
// La couverture etant binaire, un pixel de couverture non nulle ecrit la
// couleur telle quelle ; un pixel a zero ne touche pas la destination.
// Le decoupage aux bords du framebuffer est fait ici.
void compose_coverage(Framebuffer& fb, i32 dst_x, i32 dst_y, const Coverage8& cov, u32 xrgb);
} // namespace proj3::render
+54
Voir le fichier
@@ -0,0 +1,54 @@
// render/coverage.hpp — image de couverture 8 bits.
//
// Porte depuis Gastinel Write (src/render/bitmap.h, struct Coverage8), avec un
// changement de fond : les pixels ne sont plus dans un std::vector qui pousse,
// mais dans une arene fournie par l appelant. Il n y a donc plus de
// resize() ni de grow_height() : une couverture est dimensionnee une fois, a
// la creation.
//
// SEPARATION CENTRALE DU PORTAGE : ce type ne connait AUCUN format de pixel.
// C est de la couverture pure, une valeur par pixel, 0 = vide, 255 = plein.
// La conversion vers le format du framebuffer est un autre fichier
// (render/compose.hpp). C est cette separation qui rendra possible d ecrire
// des noyaux NEON de composition sans toucher au rasterizer.
#pragma once
#include "proj3/base/mem.hpp"
#include "proj3/base/types.hpp"
#include "proj3/mem/arena.hpp"
namespace proj3::render {
struct Coverage8 {
u8* pixels = nullptr;
i32 width = 0;
i32 height = 0;
// Pas de stride distinct de la largeur : les lignes sont contigues.
// Un stride separe serait utile pour ecrire dans une sous-fenetre ; aucun
// usage du projet n en a besoin, et l ajouter maintenant compliquerait les
// futurs noyaux NEON pour rien.
usize size_bytes() const {
return static_cast<usize>(width) * static_cast<usize>(height);
}
u8 at(i32 x, i32 y) const {
return pixels[static_cast<usize>(y) * static_cast<usize>(width) + static_cast<usize>(x)];
}
void set(i32 x, i32 y, u8 v) {
pixels[static_cast<usize>(y) * static_cast<usize>(width) + static_cast<usize>(x)] = v;
}
bool empty() const { return width <= 0 || height <= 0 || pixels == nullptr; }
};
// Alloue une couverture w*h dans `a`, remise a zero.
inline Coverage8 coverage_alloc(mem::Arena& a, i32 w, i32 h) {
Coverage8 c;
c.width = w;
c.height = h;
c.pixels = a.alloc_array<u8>(static_cast<usize>(w) * static_cast<usize>(h));
mem_fill(c.pixels, 0, c.size_bytes());
return c;
}
} // namespace proj3::render
+262
Voir le fichier
@@ -0,0 +1,262 @@
#include "proj3/render/rasterizer.hpp"
#include "proj3/base/math.hpp"
#include "proj3/base/sort.hpp"
namespace proj3::render {
namespace {
struct Vec2 {
f32 x = 0.0f;
f32 y = 0.0f;
};
// Une arete non horizontale, prete pour le balayage.
// `winding` vaut +1 si l arete descend dans le repere bitmap, -1 sinon : c est
// ce signe qui alimente la regle nonzero.
struct Edge {
f32 x0, y0, x1, y1;
i32 winding;
};
struct Crossing {
f32 x;
i32 winding;
};
// Accumulateur d aretes a capacite fixe. Remplace le std::vector<Edge> de
// l original. Le debordement est signale, jamais absorbe.
struct EdgeList {
Edge* data = nullptr;
u32 count = 0;
u32 cap = 0;
bool overflow = false;
void push(const Edge& e) {
if (count >= cap) {
overflow = true;
return;
}
data[count++] = e;
}
};
// Nombre de segments utilises pour approcher une courbe quadratique.
// Calcule a partir de la longueur du polygone de controle : une courbe de 2 px
// n a pas besoin du meme decoupage qu une courbe de 200 px. La borne haute
// evite qu une taille absurde fasse exploser la liste d aretes.
//
// C est le SEUL endroit du portage ou la valeur numerique peut, en theorie,
// differer de celle de Write : hypot_f64 est un calcul naif la ou l original
// appelait std::hypot. Cf. base/math.hpp.
i32 subdivision_count(const Vec2& p0, const Vec2& p1, const Vec2& p2) {
const f64 d = hypot_f64(static_cast<f64>(p1.x) - p0.x, static_cast<f64>(p1.y) - p0.y) +
hypot_f64(static_cast<f64>(p2.x) - p1.x, static_cast<f64>(p2.y) - p1.y);
const i32 n = static_cast<i32>(ceil_f32(static_cast<f32>(d) / 1.5f));
return clamp_to(n, 2, 64);
}
void emit_edge(EdgeList& edges, const Vec2& a, const Vec2& b) {
if (a.y == b.y) return; // arete horizontale : aucune intersection utile
if (a.y < b.y) {
edges.push(Edge{a.x, a.y, b.x, b.y, +1});
} else {
edges.push(Edge{b.x, b.y, a.x, a.y, -1});
}
}
void emit_quadratic(EdgeList& edges, const Vec2& p0, const Vec2& ctrl, const Vec2& p1) {
const i32 n = subdivision_count(p0, ctrl, p1);
Vec2 prev = p0;
for (i32 i = 1; i <= n; ++i) {
const f32 t = static_cast<f32>(i) / static_cast<f32>(n);
const f32 u = 1.0f - t;
Vec2 cur;
cur.x = u * u * p0.x + 2.0f * u * t * ctrl.x + t * t * p1.x;
cur.y = u * u * p0.y + 2.0f * u * t * ctrl.y + t * t * p1.y;
emit_edge(edges, prev, cur);
prev = cur;
}
}
Vec2 midpoint(const Vec2& a, const Vec2& b) {
return Vec2{(a.x + b.x) * 0.5f, (a.y + b.y) * 0.5f};
}
// Convertit un contour TrueType en aretes, en resolvant les points de controle
// implicites : deux points off-curve consecutifs sous-entendent un point
// on-curve situe exactement a leur milieu. C est une compression du format, pas
// une approximation — le milieu est la vraie position du point.
void flatten_contour(const font::GlyphPoint* pts, u32 n, f32 scale, f32 origin_x, f32 origin_y,
EdgeList& edges) {
if (n < 2) return;
// Repere bitmap : X vers la droite, Y vers le bas (d ou le signe negatif).
auto to_device = [&](const font::GlyphPoint& p) {
return Vec2{p.x * scale - origin_x, origin_y - p.y * scale};
};
// Le contour peut tres bien commencer par un point de controle.
u32 start_index = 0;
Vec2 start{};
bool found_on_curve = false;
for (u32 i = 0; i < n; ++i) {
if (pts[i].on_curve) {
start_index = i;
start = to_device(pts[i]);
found_on_curve = true;
break;
}
}
if (!found_on_curve) {
// Contour entierement off-curve : le point de depart est le milieu
// entre le dernier et le premier point de controle.
start = midpoint(to_device(pts[n - 1]), to_device(pts[0]));
start_index = 0;
}
Vec2 cursor = start;
bool have_ctrl = false;
Vec2 ctrl{};
const u32 first = found_on_curve ? start_index + 1 : start_index;
for (u32 k = 0; k < n; ++k) {
const u32 i = (first + k) % n;
if (found_on_curve && i == start_index) break;
const Vec2 p = to_device(pts[i]);
if (pts[i].on_curve) {
if (have_ctrl) {
emit_quadratic(edges, cursor, ctrl, p);
have_ctrl = false;
} else {
emit_edge(edges, cursor, p);
}
cursor = p;
} else {
if (have_ctrl) {
const Vec2 implied = midpoint(ctrl, p);
emit_quadratic(edges, cursor, ctrl, implied);
cursor = implied;
}
ctrl = p;
have_ctrl = true;
}
}
// Fermeture du contour, en consommant un eventuel controle en attente.
if (have_ctrl) {
emit_quadratic(edges, cursor, ctrl, start);
} else {
emit_edge(edges, cursor, start);
}
}
} // namespace
bool rasterize_glyph(const font::Glyph& glyph, u16 units_per_em, f32 pixel_size,
mem::Arena& out_arena, mem::Arena& scratch, RasterizedGlyph& out) {
out = RasterizedGlyph{};
if (units_per_em == 0 || pixel_size <= 0.0f) return false;
const f32 scale = pixel_size / static_cast<f32>(units_per_em);
out.advance = lround_f32(glyph.advance_width * scale);
if (glyph.empty()) return false;
// Bornes reelles calculees depuis les points plutot que depuis la bbox
// declaree : les points de controle peuvent depasser la bbox, et une bbox
// fausse (ca existe) produirait des contours coupes.
f32 min_x = 1e30f, min_y = 1e30f, max_x = -1e30f, max_y = -1e30f;
for (u32 i = 0; i < glyph.point_count; ++i) {
const font::GlyphPoint& p = glyph.points[i];
min_x = min_of(min_x, p.x);
min_y = min_of(min_y, p.y);
max_x = max_of(max_x, p.x);
max_y = max_of(max_y, p.y);
}
if (min_x > max_x) return false;
// Un pixel de marge de chaque cote absorbe les arrondis.
const i32 px_min_x = static_cast<i32>(floor_f32(min_x * scale)) - 1;
const i32 px_max_x = static_cast<i32>(ceil_f32(max_x * scale)) + 1;
const i32 px_min_y = static_cast<i32>(floor_f32(min_y * scale)) - 1;
const i32 px_max_y = static_cast<i32>(ceil_f32(max_y * scale)) + 1;
const i32 w = px_max_x - px_min_x;
const i32 h = px_max_y - px_min_y;
if (w <= 0 || h <= 0 || w > 8192 || h > 8192) return false;
const usize scratch_mark = scratch.mark();
EdgeList edges;
edges.data = scratch.alloc_array<Edge>(kMaxEdges);
edges.cap = kMaxEdges;
for (u32 c = 0; c < glyph.contour_count; ++c) {
const u32 b = glyph.contour_begin(c);
flatten_contour(glyph.points + b, glyph.contour_size(c), scale,
static_cast<f32>(px_min_x), static_cast<f32>(px_max_y), edges);
}
if (edges.overflow) {
// Refus explicite. L original aurait fait croitre son vector, donc
// alloue en plein rendu : c est exactement ce qu on interdit.
scratch.rewind_to(scratch_mark);
return false;
}
if (edges.count == 0) {
scratch.rewind_to(scratch_mark);
return false;
}
// La couverture est allouee APRES les aretes et dans une AUTRE arene :
// elle survit au rembobinage du scratch.
out.bearing_x = px_min_x;
out.bearing_y = px_max_y; // haut du bitmap, au-dessus de la ligne de base
out.coverage = coverage_alloc(out_arena, w, h);
// --- Balayage ---
// Une passe par ligne, echantillonnee au centre du pixel (y + 0.5). Les
// intersections sont collectees puis triees par x ; le compteur de winding
// s incremente en traversant chaque arete et la ligne est remplie partout
// ou il est non nul.
Crossing* crossings = scratch.alloc_array<Crossing>(kMaxEdges);
for (i32 y = 0; y < h; ++y) {
const f32 sample_y = static_cast<f32>(y) + 0.5f;
u32 nc = 0;
for (u32 e = 0; e < edges.count; ++e) {
const Edge& ed = edges.data[e];
// Intervalle semi-ouvert [y0, y1) : indispensable pour qu un
// sommet partage par deux aretes ne compte qu une fois.
if (sample_y < ed.y0 || sample_y >= ed.y1) continue;
const f32 t = (sample_y - ed.y0) / (ed.y1 - ed.y0);
crossings[nc++] = Crossing{ed.x0 + t * (ed.x1 - ed.x0), ed.winding};
}
if (nc < 2) continue;
heap_sort(crossings, nc, [](const Crossing& a, const Crossing& b) { return a.x < b.x; });
i32 winding = 0;
for (u32 i = 0; i + 1 < nc; ++i) {
winding += crossings[i].winding;
if (winding == 0) continue;
const f32 span_start = crossings[i].x;
const f32 span_end = crossings[i + 1].x;
// On remplit les pixels dont le centre tombe dans le span.
i32 x0 = static_cast<i32>(ceil_f32(span_start - 0.5f));
i32 x1 = static_cast<i32>(ceil_f32(span_end - 0.5f));
x0 = max_of(x0, 0);
x1 = min_of(x1, w);
for (i32 x = x0; x < x1; ++x) out.coverage.set(x, y, 255);
}
}
scratch.rewind_to(scratch_mark);
return true;
}
} // namespace proj3::render
+73
Voir le fichier
@@ -0,0 +1,73 @@
// render/rasterizer.hpp — rasterization scanline, portee depuis Gastinel Write.
//
// REGLE DE REMPLISSAGE : NONZERO WINDING. Inchangee, et ce n est pas une
// preference : c est la regle qu impose la specification TrueType. Les
// contours d un glyphe sont orientes (exterieur horaire, interieur
// anti-horaire) precisement pour que le nonzero creuse les contreformes. En
// even-odd, deux contours exterieurs qui se chevauchent — frequent apres
// decomposition d un composite, un accent qui mord sur la lettre — laisseraient
// un trou a l intersection.
//
// DETTE TECHNIQUE HERITEE, CONSERVEE TELLE QUELLE :
// - aucun antialiasing : la couverture vaut 0 ou 255, jamais autre chose ;
// - aucun hinting ;
// - aucun crenage (c est le parser qui l ignore, pas le rasterizer).
// Ces trois choix sont volontaires cote Write et ne sont pas revus ici.
// L avis du portage figure dans le rapport, pas dans le code.
//
// CE QUI CHANGE PAR RAPPORT A L ORIGINAL :
// 1. Plus aucune allocation. Les aretes et les intersections viennent d une
// arene de travail fournie par l appelant ; la couverture est ecrite dans
// une arene de sortie fournie par l appelant. Le rasterizer n alloue
// jamais, et le garde-fou du chantier 3 le prouve.
// 2. std::sort devient un heapsort maison a cout pire cas borne
// (base/sort.hpp). Le tri porte sur des abscisses ; deux intersections de
// meme abscisse delimitent un intervalle de largeur nulle, donc
// l instabilite du heapsort est sans effet sur la sortie.
// 3. std::hypot devient un calcul naif en double (base/math.hpp). Seule
// divergence numerique connue du portage ; elle est bornee a moins d un
// ULP de float et verifiee par le test golden.
// 4. Le nombre d aretes est plafonne. L original laissait le vector croitre ;
// ici un depassement est un echec explicite, pas une allocation.
#pragma once
#include "proj3/font/ttf.hpp"
#include "proj3/mem/arena.hpp"
#include "proj3/render/coverage.hpp"
namespace proj3::render {
// Plafond du nombre d aretes par glyphe. Justification dans mem/layout.hpp
// (majorant raisonne : 600 points * 64 subdivisions = 38400).
inline constexpr u32 kMaxEdges = 65536;
struct RasterizedGlyph {
Coverage8 coverage;
// Coin haut-gauche du bitmap par rapport a l origine du glyphe (le point
// de base sur la ligne de base), en pixels. bearing_y est positif vers le
// haut, convention typographique.
i32 bearing_x = 0;
i32 bearing_y = 0;
// Avance horizontale en pixels, arrondie a l entier le plus proche.
i32 advance = 0;
};
// Rasterise un glyphe a `pixel_size` pixels par em.
//
// Le glyphe arrive en unites de police ; la conversion utilise units_per_em.
// Le repere TrueType a son axe Y vers le haut, le bitmap vers le bas : la
// conversion est faite ici, une seule fois.
//
// `out_arena` : recoit les pixels de couverture (duree de vie longue).
// `scratch` : aretes et intersections (rembobinee avant de rendre la main).
//
// Rend false si le glyphe est vide, si la taille est invalide, ou si le
// plafond d aretes est atteint ; dans ce cas seules les metriques de `out`
// sont renseignees. C est le comportement de l original, plus le cas du
// plafond qui n existait pas.
bool rasterize_glyph(const font::Glyph& glyph, u16 units_per_em, f32 pixel_size,
mem::Arena& out_arena, mem::Arena& scratch, RasterizedGlyph& out);
} // namespace proj3::render
+57
Voir le fichier
@@ -0,0 +1,57 @@
// sys/panic.cpp — implementation embarquee (AArch64, sans libc).
#include "proj3/sys/panic.hpp"
#include "proj3/base/fmt.hpp"
#include "proj3/sys/syscalls.hpp"
#include "proj3/sys/uapi.hpp"
namespace proj3 {
void err_write_bytes(const void* p, usize n) {
const u8* cur = static_cast<const u8*>(p);
usize left = n;
// Une ecriture peut etre partielle. La boucle est bornee : chaque tour
// consomme au moins un octet, sinon on abandonne. Pas de boucle infinie
// possible, ce qui compte sur un chemin de panique.
while (left > 0) {
const sys::Result r = sys::write(sys::FD_STDERR, cur, left);
if (r.is_err() || r.value() <= 0) return;
const usize done = static_cast<usize>(r.value());
cur += done;
left -= done;
}
}
void err_write(const char* s) { err_write_bytes(s, str_len(s)); }
void err_write_i64(i64 v) {
char buf[kDecBufSize];
const usize n = fmt_i64(buf, sizeof(buf), v);
err_write_bytes(buf, n);
}
void err_write_hex(u64 v) {
char buf[kDecBufSize];
const usize n = fmt_hex_u64(buf, sizeof(buf), v);
err_write_bytes(buf, n);
}
[[noreturn]] void panic(const char* what) {
err_write("proj3: PANIQUE: ");
err_write(what);
err_write("\n");
sys::exit_group(70);
}
[[noreturn]] void panic_v(const char* what, const char* detail, i64 value) {
err_write("proj3: PANIQUE: ");
err_write(what);
err_write(" [");
err_write(detail);
err_write("=");
err_write_i64(value);
err_write("]\n");
sys::exit_group(70);
}
} // namespace proj3
+32
Voir le fichier
@@ -0,0 +1,32 @@
// sys/panic.hpp — arret bruyant.
//
// Le projet n a pas de gestion d erreur recuperable au-dela du point ou une
// decision de repli est prise sur place (cf. doc/convention-syscall.md 3.3).
// Tout le reste est un defaut de conception, et un defaut de conception doit
// s arreter immediatement, la ou il se produit, avec de quoi le localiser.
//
// Deux implementations, une par cible :
// sys/panic.cpp (embarquee) : write(2) direct + exit_group(70)
// sys/panic_host.cpp (hote) : fwrite(stderr) + _Exit(70)
// Le code portable ne voit que ces declarations.
#pragma once
#include "proj3/base/types.hpp"
namespace proj3 {
// Ecrit tel quel sur la sortie d erreur. Pas de tampon, pas de retour de
// statut : si l ecriture echoue, il n y a rien de sense a faire.
void err_write(const char* s);
void err_write_bytes(const void* p, usize n);
void err_write_i64(i64 v);
void err_write_hex(u64 v);
// Code de sortie 70 : EX_SOFTWARE de sysexits.h. Choisi parce qu il est
// distinct de tout code d erreur applicatif et reconnaissable dans un script.
[[noreturn]] void panic(const char* what);
// Variante avec un detail et une valeur (code errno, offset, taille...).
[[noreturn]] void panic_v(const char* what, const char* detail, i64 value);
} // namespace proj3
+54
Voir le fichier
@@ -0,0 +1,54 @@
// sys/panic_host.cpp — implementation HOTE.
//
// Cette unite a le droit d utiliser la libc de l hote (cf. ADR-0001). Elle
// n est JAMAIS compilee pour la cible embarquee.
//
// _Exit et non exit : on ne veut ni vidage des flux ni appel des destructeurs
// statiques, pour que le comportement soit aussi brutal que sur la cible.
#include "proj3/sys/panic.hpp"
#include <cstdio>
#include <cstdlib>
#include "proj3/base/fmt.hpp"
namespace proj3 {
void err_write_bytes(const void* p, usize n) {
std::fwrite(p, 1, n, stderr);
std::fflush(stderr);
}
void err_write(const char* s) { err_write_bytes(s, str_len(s)); }
void err_write_i64(i64 v) {
char buf[kDecBufSize];
const usize n = fmt_i64(buf, sizeof(buf), v);
err_write_bytes(buf, n);
}
void err_write_hex(u64 v) {
char buf[kDecBufSize];
const usize n = fmt_hex_u64(buf, sizeof(buf), v);
err_write_bytes(buf, n);
}
[[noreturn]] void panic(const char* what) {
err_write("proj3: PANIQUE: ");
err_write(what);
err_write("\n");
std::_Exit(70);
}
[[noreturn]] void panic_v(const char* what, const char* detail, i64 value) {
err_write("proj3: PANIQUE: ");
err_write(what);
err_write(" [");
err_write(detail);
err_write("=");
err_write_i64(value);
err_write("]\n");
std::_Exit(70);
}
} // namespace proj3
+36
Voir le fichier
@@ -0,0 +1,36 @@
// sys/result.hpp — valeur de retour d un appel systeme.
//
// Convention arretee au chantier 1 : doc/convention-syscall.md, option C.
// Le wrapper rend le x0 du noyau tel quel. Ce type est une enveloppe de cout
// nul : sizeof == 8, trivialement copiable, donc passee et rendue en registre
// exactement comme un i64 nu.
#pragma once
#include "proj3/base/types.hpp"
namespace proj3::sys {
struct [[nodiscard]] Result {
i64 raw;
// Plage d erreur EXACTE du noyau : [-4095, -1]. C est la definition de
// IS_ERR_VALUE (include/linux/err.h, MAX_ERRNO = 4095).
//
// Ce n est pas "raw < 0" : mmap peut legitimement rendre une adresse dont
// le bit 63 est a 1, et lseek une position au-dela de 2^63. Le test
// approximatif serait faux, pas seulement imprecis.
constexpr bool is_err() const { return raw < 0 && raw >= -4095; }
constexpr bool is_ok() const { return !is_err(); }
// Code errno positif. Precondition : is_err().
constexpr i32 err() const { return static_cast<i32>(-raw); }
// Valeur utile. Precondition : is_ok().
constexpr i64 value() const { return raw; }
constexpr i32 fd() const { return static_cast<i32>(raw); }
void* ptr() const { return reinterpret_cast<void*>(static_cast<uptr>(raw)); }
};
static_assert(sizeof(Result) == 8, "Result doit tenir dans un registre");
} // namespace proj3::sys
+50
Voir le fichier
@@ -0,0 +1,50 @@
// sys/syscall_nr.hpp — numeros d appels systeme AArch64.
//
// SOURCE DE LA TABLE (unique et citee, comme demande) :
// Linux, include/uapi/asm-generic/unistd.h
// AArch64 n a PAS de table de syscalls propre : arch/arm64/include/asm/
// unistd.h se contente d inclure la table generique asm-generic. Les
// numeros ci-dessous sont donc ceux de la table generique 64 bits, valables
// pour tout portage recent (arm64, riscv64, loongarch...).
//
// Ils sont STABLES : le noyau garantit qu un numero attribue ne change
// jamais. Verifier une valeur ne demande qu un grep dans unistd.h.
//
// CES NUMEROS DIFFERENT DE x86-64. Exemples de pieges :
// write vaut 64 ici, 1 sur x86-64
// mmap vaut 222 ici, 9 sur x86-64
// read vaut 63 ici, 0 sur x86-64
// Aucun numero n a ete recopie de memoire depuis une table x86-64.
//
// ABSENCES NOTABLES de la table generique, qui ont des consequences ici :
// - PAS de __NR_open. Seul openat existe (56). open(path, flags, mode)
// se rend par openat(AT_FDCWD, path, flags, mode).
// - PAS de __NR_stat / __NR_lstat. Seuls fstat (80) et fstatat (79).
// - PAS de __NR_mmap2. mmap (222) prend un offset en OCTETS, pas en pages.
//
// La regle du chantier : ces constantes ne sont JAMAIS ecrites en dur dans le
// corps d une routine assembleur. Le fichier .S inclut celui-ci (il est ecrit
// pour etre lisible par le preprocesseur C ET par C++).
#pragma once
#define PROJ3_NR_ioctl 29
#define PROJ3_NR_openat 56
#define PROJ3_NR_close 57
#define PROJ3_NR_lseek 62
#define PROJ3_NR_read 63
#define PROJ3_NR_write 64
#define PROJ3_NR_fstat 80
#define PROJ3_NR_exit 93
#define PROJ3_NR_exit_group 94
#define PROJ3_NR_nanosleep 101
#define PROJ3_NR_clock_gettime 113
#define PROJ3_NR_getpid 172
#define PROJ3_NR_munmap 215
#define PROJ3_NR_mmap 222
#define PROJ3_NR_madvise 233
// AT_FDCWD : descripteur special designant le repertoire courant pour les
// appels *at. Valeur -100, definie dans include/uapi/linux/fcntl.h.
// Elle est ici parce que le wrapper open l utilise ; ce n est pas un numero
// de syscall mais elle appartient au meme contrat.
#define PROJ3_AT_FDCWD (-100)
+153
Voir le fichier
@@ -0,0 +1,153 @@
// sys/syscalls.hpp — declarations C++ des wrappers de asm/syscall.S.
//
// Toutes rendent proj3::sys::Result (cf. doc/convention-syscall.md).
//
// PAS DE VARIADIQUE — decision et justification :
//
// En C, open() et ioctl() sont declares variadiques :
// int open(const char*, int, ...);
// int ioctl(int, unsigned long, ...);
// C est un artefact historique de la libc, pas une propriete du noyau : le
// noyau recoit toujours un nombre fixe d arguments dans des registres fixes.
//
// Une signature variadique nous couterait trois choses, toutes contraires aux
// piliers :
// 1. L AAPCS64 impose un traitement DIFFERENT des arguments variadiques
// (zone de sauvegarde des registres, va_list). Un wrapper assembleur nu
// ne peut pas les recuperer de facon portable.
// 2. Elle supprime toute verification de type a l appel : passer un int la
// ou le pilote attend un pointeur compile sans un mot.
// 3. Elle empeche le compilateur de savoir combien de registres sont
// reellement vivants a l appel.
//
// On declare donc des SURCHARGES EXPLICITES, une par forme reellement
// utilisee. Ajouter une forme = ajouter une surcharge, pas assouplir le type.
#pragma once
#include "proj3/base/types.hpp"
#include "proj3/sys/result.hpp"
namespace proj3::sys {
// struct timespec du noyau (asm-generic). 16 octets sur LP64.
struct TimeSpec {
i64 sec;
i64 nsec;
};
static_assert(sizeof(TimeSpec) == 16);
// struct stat du noyau AArch64.
// Source : include/uapi/asm-generic/stat.h (arm64 utilise la version
// generique 64 bits). Attention : ce N EST PAS la struct stat de la glibc,
// qui a une disposition differente. Ne jamais passer un stat de libc ici.
struct Stat {
u64 dev;
u64 ino;
u32 mode;
u32 nlink;
u32 uid;
u32 gid;
u64 rdev;
u64 pad1;
i64 size;
i32 blksize;
i32 pad2;
i64 blocks;
i64 atime_sec, atime_nsec;
i64 mtime_sec, mtime_nsec;
i64 ctime_sec, ctime_nsec;
u32 unused4, unused5;
};
static_assert(sizeof(Stat) == 128, "disposition de struct stat AArch64");
} // namespace proj3::sys
// --- Symboles bruts exportes par asm/syscall.S -----------------------------
// Declares avec les types exacts attendus par l assembleur. Ils ne sont pas
// destines a un usage direct : la couche C++ ci-dessous les enveloppe.
extern "C" {
proj3::i64 proj3_sys_open(const char* path, proj3::i32 flags, proj3::u32 mode);
proj3::i64 proj3_sys_close(proj3::i32 fd);
proj3::i64 proj3_sys_read(proj3::i32 fd, void* buf, proj3::usize count);
proj3::i64 proj3_sys_write(proj3::i32 fd, const void* buf, proj3::usize count);
proj3::i64 proj3_sys_ioctl(proj3::i32 fd, proj3::u64 request, void* argp);
proj3::i64 proj3_sys_mmap(void* addr, proj3::usize length, proj3::i32 prot,
proj3::i32 flags, proj3::i32 fd, proj3::i64 offset);
proj3::i64 proj3_sys_munmap(void* addr, proj3::usize length);
proj3::i64 proj3_sys_madvise(void* addr, proj3::usize length, proj3::i32 advice);
proj3::i64 proj3_sys_clock_gettime(proj3::i32 clk, proj3::sys::TimeSpec* out);
proj3::i64 proj3_sys_nanosleep(const proj3::sys::TimeSpec* req,
proj3::sys::TimeSpec* rem);
proj3::i64 proj3_sys_getpid(void);
proj3::i64 proj3_sys_fstat(proj3::i32 fd, proj3::sys::Stat* out);
proj3::i64 proj3_sys_lseek(proj3::i32 fd, proj3::i64 offset, proj3::i32 whence);
[[noreturn]] void proj3_sys_exit(proj3::i32 code);
[[noreturn]] void proj3_sys_exit_group(proj3::i32 code);
}
namespace proj3::sys {
// --- open : surcharges explicites au lieu du variadique -------------------
// Ouverture sans creation. `mode` n est pas transmis parce qu il n a aucun
// sens sans O_CREAT ; le noyau l ignorerait, mais le laisser dans la
// signature laisserait croire qu il sert.
inline Result open(const char* path, i32 flags) {
return Result{proj3_sys_open(path, flags, 0)};
}
// Ouverture avec creation. Forme distincte, exigeant le mode : impossible
// d appeler O_CREAT en oubliant les permissions, ce qui donnerait un fichier
// aux droits aleatoires (le bug classique du open variadique).
inline Result open_create(const char* path, i32 flags, u32 mode) {
return Result{proj3_sys_open(path, flags, mode)};
}
inline Result close(i32 fd) { return Result{proj3_sys_close(fd)}; }
inline Result read(i32 fd, void* buf, usize n) { return Result{proj3_sys_read(fd, buf, n)}; }
inline Result write(i32 fd, const void* buf, usize n) {
return Result{proj3_sys_write(fd, buf, n)};
}
// --- ioctl : surcharges explicites ----------------------------------------
// Les trois seules formes qui existent reellement au niveau du noyau : sans
// argument, avec un argument entier passe par valeur, avec un pointeur.
// Le troisieme argument est TOUJOURS place dans x2 ; ces surcharges ne font
// que rendre le type explicite a l appel.
inline Result ioctl(i32 fd, u64 request) {
return Result{proj3_sys_ioctl(fd, request, nullptr)};
}
inline Result ioctl(i32 fd, u64 request, void* argp) {
return Result{proj3_sys_ioctl(fd, request, argp)};
}
inline Result ioctl_val(i32 fd, u64 request, u64 value) {
return Result{proj3_sys_ioctl(fd, request, reinterpret_cast<void*>(value))};
}
inline Result mmap(void* addr, usize length, i32 prot, i32 flags, i32 fd, i64 offset) {
return Result{proj3_sys_mmap(addr, length, prot, flags, fd, offset)};
}
inline Result munmap(void* addr, usize length) {
return Result{proj3_sys_munmap(addr, length)};
}
inline Result madvise(void* addr, usize length, i32 advice) {
return Result{proj3_sys_madvise(addr, length, advice)};
}
inline Result clock_gettime(i32 clk, TimeSpec* out) {
return Result{proj3_sys_clock_gettime(clk, out)};
}
inline Result nanosleep(const TimeSpec* req, TimeSpec* rem) {
return Result{proj3_sys_nanosleep(req, rem)};
}
inline Result getpid() { return Result{proj3_sys_getpid()}; }
inline Result fstat(i32 fd, Stat* out) { return Result{proj3_sys_fstat(fd, out)}; }
inline Result lseek(i32 fd, i64 offset, i32 whence) {
return Result{proj3_sys_lseek(fd, offset, whence)};
}
[[noreturn]] inline void exit(i32 code) { proj3_sys_exit(code); }
[[noreturn]] inline void exit_group(i32 code) { proj3_sys_exit_group(code); }
} // namespace proj3::sys
+75
Voir le fichier
@@ -0,0 +1,75 @@
// sys/uapi.hpp — constantes de l interface noyau utilisees par le projet.
//
// REGLE : on ne definit ici que ce qu on utilise reellement. Pas de recopie
// exhaustive d en-tetes systeme. Chaque bloc cite sa source dans le noyau.
//
// Toutes ces valeurs sont celles de la variante ASM-GENERIC, celle qu utilise
// arm64. Elles ne sont pas toutes identiques a x86-64 (O_CREAT et MAP_* le
// sont ; d autres, comme les numeros de syscall, ne le sont pas du tout).
#pragma once
#include "proj3/base/types.hpp"
namespace proj3::sys {
// --- include/uapi/asm-generic/fcntl.h -------------------------------------
inline constexpr i32 O_RDONLY = 0;
inline constexpr i32 O_WRONLY = 1;
inline constexpr i32 O_RDWR = 2;
inline constexpr i32 O_CREAT = 0100; // octal, comme dans l en-tete d origine
inline constexpr i32 O_TRUNC = 01000;
inline constexpr i32 O_CLOEXEC = 02000000;
// --- include/uapi/asm-generic/mman-common.h -------------------------------
inline constexpr i32 PROT_NONE = 0;
inline constexpr i32 PROT_READ = 1;
inline constexpr i32 PROT_WRITE = 2;
inline constexpr i32 MAP_SHARED = 0x01;
inline constexpr i32 MAP_PRIVATE = 0x02;
inline constexpr i32 MAP_FIXED = 0x10;
inline constexpr i32 MAP_ANONYMOUS = 0x20;
// --- include/uapi/asm-generic/mman.h (extensions Linux) -------------------
inline constexpr i32 MAP_POPULATE = 0x8000;
inline constexpr i32 MAP_HUGETLB = 0x40000;
// Selection explicite de la taille de huge page. Sans ces bits, MAP_HUGETLB
// utilise la taille par defaut du systeme, qui n est pas garantie a 2 Mo.
// include/uapi/linux/mman.h : MAP_HUGE_SHIFT = 26.
inline constexpr i32 MAP_HUGE_SHIFT = 26;
inline constexpr i32 MAP_HUGE_2MB = 21 << MAP_HUGE_SHIFT;
inline constexpr i32 MADV_WILLNEED = 3;
inline constexpr i32 MADV_HUGEPAGE = 14;
// --- include/uapi/linux/time.h --------------------------------------------
inline constexpr i32 CLOCK_REALTIME = 0;
inline constexpr i32 CLOCK_MONOTONIC = 1;
inline constexpr i32 CLOCK_MONOTONIC_RAW = 4;
// --- include/uapi/linux/fs.h ----------------------------------------------
inline constexpr i32 SEEK_SET = 0;
inline constexpr i32 SEEK_CUR = 1;
inline constexpr i32 SEEK_END = 2;
// --- Descripteurs standards -----------------------------------------------
// Ils ne sont pas "de la libc" : c est le noyau qui les etablit a l exec.
inline constexpr i32 FD_STDOUT = 1;
inline constexpr i32 FD_STDERR = 2;
// --- include/uapi/asm-generic/errno-base.h et errno.h ---------------------
// Uniquement les codes que le projet teste explicitement.
inline constexpr i32 EPERM = 1;
inline constexpr i32 ENOENT = 2;
inline constexpr i32 EINTR = 4;
inline constexpr i32 EBADF = 9;
inline constexpr i32 ENOMEM = 12;
inline constexpr i32 EACCES = 13;
inline constexpr i32 EFAULT = 14;
inline constexpr i32 ENODEV = 19;
inline constexpr i32 EINVAL = 22;
inline constexpr i32 ENOTTY = 25;
inline constexpr i32 ESPIPE = 29;
inline constexpr i32 ENOSYS = 38;
} // namespace proj3::sys
BIN
Voir le fichier
Fichier binaire non affiché.
+92
Voir le fichier
@@ -0,0 +1,92 @@
Copyright (c) 2016 The Inter Project Authors (https://github.com/rsms/inter)
This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at:
http://scripts.sil.org/OFL
-----------------------------------------------------------
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------
PREAMBLE
The goals of the Open Font License (OFL) are to stimulate worldwide
development of collaborative font projects, to support the font creation
efforts of academic and linguistic communities, and to provide a free and
open framework in which fonts may be shared and improved in partnership
with others.
The OFL allows the licensed fonts to be used, studied, modified and
redistributed freely as long as they are not sold by themselves. The
fonts, including any derivative works, can be bundled, embedded,
redistributed and/or sold with any software provided that any reserved
names are not used by derivative works. The fonts and derivatives,
however, cannot be released under any other type of license. The
requirement for fonts to remain under this license does not apply
to any document created using the fonts or their derivatives.
DEFINITIONS
"Font Software" refers to the set of files released by the Copyright
Holder(s) under this license and clearly marked as such. This may
include source files, build scripts and documentation.
"Reserved Font Name" refers to any names specified as such after the
copyright statement(s).
"Original Version" refers to the collection of Font Software components as
distributed by the Copyright Holder(s).
"Modified Version" refers to any derivative made by adding to, deleting,
or substituting -- in part or in whole -- any of the components of the
Original Version, by changing formats or by porting the Font Software to a
new environment.
"Author" refers to any designer, engineer, programmer, technical
writer or other person who contributed to the Font Software.
PERMISSION AND CONDITIONS
Permission is hereby granted, free of charge, to any person obtaining
a copy of the Font Software, to use, study, copy, merge, embed, modify,
redistribute, and sell modified and unmodified copies of the Font
Software, subject to the following conditions:
1) Neither the Font Software nor any of its individual components,
in Original or Modified Versions, may be sold by itself.
2) Original or Modified Versions of the Font Software may be bundled,
redistributed and/or sold with any software, provided that each copy
contains the above copyright notice and this license. These can be
included either as stand-alone text files, human-readable headers or
in the appropriate machine-readable metadata fields within text or
binary files as long as those fields can be easily viewed by the user.
3) No Modified Version of the Font Software may use the Reserved Font
Name(s) unless explicit written permission is granted by the corresponding
Copyright Holder. This restriction only applies to the primary font name as
presented to the users.
4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
Software shall not be used to promote, endorse or advertise any
Modified Version, except to acknowledge the contribution(s) of the
Copyright Holder(s) and the Author(s) or with their explicit written
permission.
5) The Font Software, modified or unmodified, in part or in whole,
must be distributed entirely under this license, and must not be
distributed under any other license. The requirement for fonts to
remain under this license does not apply to any document created
using the Font Software.
TERMINATION
This license becomes null and void if any of the above conditions are
not met.
DISCLAIMER
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
OTHER DEALINGS IN THE FONT SOFTWARE.
+122
Voir le fichier
@@ -0,0 +1,122 @@
# proj3 golden raster dump v1 (source : Gastinel Write)
# upem 2048
32 12 1777 0 0 0 0 0 3
32 16 1777 0 0 0 0 0 5
32 24 1777 0 0 0 0 0 7
32 32 1777 0 0 0 0 0 9
33 12 1427 1 5 12 -1 10 3 00000000000000ff00000000ff00000000ff00000000ff00000000ff00000000ff0000000000000000000000000000ff000000000000000000000000
33 16 1427 1 5 15 0 13 5 00000000000000ff00000000ff00000000ff00000000ff00000000ff00000000ff00000000ff00000000ff00000000000000000000000000ffff000000ffff000000000000000000000000
33 24 1427 1 7 21 0 19 7 00000000000000000000000000000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffff0000000000000000000000000000000000000000000000000000ffffff00000000ffffff00000000ffffff00000000000000000000000000000000
33 32 1427 1 7 27 1 25 9 00000000000000000000000000000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000000000000000000000000000000000000000000000ffffff00000000ffffffff000000ffffffff000000ffffff00000000000000000000000000000000
44 12 1501 1 5 7 -1 3 3 000000000000000000000000ff00000000ff00000000ff000000000000000000000000
44 16 1501 1 5 7 0 3 5 00000000000000ff00000000ff000000ffff000000ff00000000ff0000000000000000
44 24 1501 1 6 10 0 4 7 0000000000000000000000000000ffffff000000ffff00000000ffff00000000ffff00000000ffff00000000ff000000000000000000000000000000
44 32 1501 1 7 12 1 5 9 00000000000000000000000000000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffff00000000ffffff00000000ffffff00000000ffff0000000000ffff0000000000000000000000
46 12 1502 1 5 5 -1 3 3 000000000000000000000000ff000000000000000000000000
46 16 1502 1 5 6 0 4 5 0000000000000000000000ffff000000ffff000000000000000000000000
46 24 1502 1 7 7 0 5 7 00000000000000000000000000000000ffffff00000000ffffff00000000ffffff00000000000000000000000000000000
46 32 1502 1 7 8 1 6 9 00000000000000000000000000000000ffffff00000000ffffffff000000ffffffff000000ffffff00000000000000000000000000000000
48 12 1341 1 9 12 -1 10 8 000000000000000000000000ffffff0000000000ffff0000ff00000000ff000000ffff000000ff00000000ff000000ff00000000ff000000ff00000000ff000000ff00000000ff000000ffff0000ff0000000000ffffff000000000000000000000000000000000000000000
48 16 1341 1 12 15 -1 13 10 0000000000000000000000000000000000ffff0000000000000000ffffffffffff000000000000ff00000000ff0000000000ffff00000000ffff00000000ffff0000000000ff00000000ff000000000000ff00000000ff000000000000ff00000000ff000000000000ff00000000ffff00000000ffff00000000ffff00000000ffff0000000000ffff0000ffff00000000000000ffffffff00000000000000000000000000000000000000000000000000000000
48 24 1341 1 15 21 0 19 15 000000000000000000000000000000000000000000ffffff00000000000000000000ffffffffffffff00000000000000ffffff000000ffffff000000000000ffff0000000000ffffff00000000ffff00000000000000ffff00000000ffff00000000000000ffff00000000ffff00000000000000ffff00000000ffff00000000000000ffffff0000ffffff0000000000000000ffff0000ffffff0000000000000000ffff0000ffffff0000000000000000ffff000000ffff00000000000000ffffff000000ffff00000000000000ffff00000000ffff00000000000000ffff00000000ffffff0000000000ffffff0000000000ffff0000000000ffff00000000000000ffffffffffffffff0000000000000000ffffffffff0000000000000000000000000000000000000000000000000000000000000000000000
48 32 1341 1 20 27 0 25 20 0000000000000000000000000000000000000000000000000000000000ffff000000000000000000000000000000ffffffffffffffff0000000000000000000000ffffffffffffffffffff000000000000000000ffffffff00000000ffffffff0000000000000000ffffff000000000000ffffffff000000000000ffffff0000000000000000ffffff000000000000ffffff000000000000000000ffff0000000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff0000000000ffffff0000000000000000ffffff000000000000ffffff0000000000000000ffffff00000000000000ffffff000000000000ffffffff00000000000000ffffffffff0000ffffffffff000000000000000000ffffffffffffffffffff000000000000000000000000ffffffffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
49 12 1342 1 6 11 -1 10 5 000000000000000000ffff000000ff00ff0000000000ff0000000000ff0000000000ff0000000000ff0000000000ff0000000000ff0000000000ff00000000000000
49 16 1342 1 8 14 -1 13 7 000000000000000000000000ffff0000000000ffffff00000000ffff00ff00000000000000ff00000000000000ff00000000000000ff00000000000000ff00000000000000ff00000000000000ff00000000000000ff00000000000000ff00000000000000ff00000000000000000000
49 24 1342 1 9 20 0 19 10 00000000000000000000000000000000000000000000ffffffff000000ffffffffffff0000ffffff00ffffff0000ffff0000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff00000000000000000000
49 32 1342 1 12 26 0 25 13 000000000000000000000000000000000000000000000000000000000000ffffffff000000000000ffffffffffff0000000000ffffffffffffff000000ffffffffff00ffffff000000ffffff000000ffffff000000ffff00000000ffffff000000ff0000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff0000000000000000000000000000
56 12 1351 1 9 12 -1 10 7 000000000000000000000000ffffff0000000000ffff0000ff00000000ff000000ff00000000ff000000ff0000000000ffffff0000000000ff000000ff00000000ff00000000ff000000ff000000ffff00000000ffffffff0000000000000000000000000000000000000000
56 16 1351 1 11 15 -1 13 10 000000000000000000000000000000ffffff00000000000000ffffffffffff00000000ffff00000000ff00000000ffff00000000ff0000000000ff00000000ff0000000000ffffffffff000000000000ffffffffffff00000000ffff00000000ffff000000ff0000000000ffff000000ffff00000000ffff000000ffff000000ffff0000000000ffffffffff00000000000000000000000000000000000000000000000000
56 24 1351 1 15 21 0 19 15 000000000000000000000000000000000000000000ffffff00000000000000000000ffffffffffffff00000000000000ffffff000000ffffff0000000000ffffff0000000000ffffff00000000ffff000000000000ffffff00000000ffff00000000000000ffff00000000ffffff0000000000ffff000000000000ffffff000000ffffff00000000000000ffffffffffffff00000000000000ffffffffffffffff000000000000ffffff0000000000ffff0000000000ffff00000000000000ffff00000000ffff00000000000000ffff000000ffffff00000000000000ffff00000000ffff00000000000000ffff00000000ffffff0000000000ffffff0000000000ffffffffffffffffff00000000000000ffffffffffffff00000000000000000000000000000000000000000000000000000000000000000000
56 32 1351 1 19 27 0 25 20 00000000000000000000000000000000000000000000000000000000ffff0000000000000000000000000000ffffffffffffffff000000000000000000ffffffffffffffffffffff0000000000000000ffffffff00000000ffffffff000000000000ffffff00000000000000ffffffff0000000000ffffff0000000000000000ffffff0000000000ffffff0000000000000000ffffff0000000000ffffff0000000000000000ffffff0000000000ffffff0000000000000000ffffff000000000000ffffff000000000000ffffff00000000000000ffffffff000000ffffffff00000000000000000000ffffffffffffffff00000000000000000000ffffffffffffffffffff0000000000000000ffffffff00000000ffffffff000000000000ffffff0000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff00000000000000000000ffffff000000ffffff00000000000000000000ffffff000000ffffff00000000000000000000ffffff000000ffffff000000000000000000ffffffff00000000ffffff0000000000000000ffffff0000000000ffffffffff00000000ffffffffff000000000000ffffffffffffffffffffffff000000000000000000ffffffffffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
65 12 2 1 10 11 -1 10 8 0000000000000000000000000000ffff0000000000000000ffff0000000000000000ff00ff000000000000ff0000ff000000000000ff0000ff000000000000ff000000ff00000000ffffffffffff00000000ff00000000ff000000ffff0000000000ff0000000000000000000000
65 16 2 1 13 14 -1 13 11 00000000000000000000000000000000000000ff0000000000000000000000ffffff00000000000000000000ff00ff000000000000000000ffff00ffff0000000000000000ffff00ffff0000000000000000ff000000ff00000000000000ffff000000ffff000000000000ffffffffffffff000000000000ffffffffffffff0000000000ffff0000000000ffff00000000ffff000000000000ff00000000ff00000000000000ff000000000000000000000000000000
65 24 2 1 18 20 -1 19 17 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff0000000000000000000000000000ffffffff0000000000000000000000000000ffff00ffff00000000000000000000000000ffff00ffff000000000000000000000000ffff0000ffff000000000000000000000000ffff000000ffff00000000000000000000ffffff000000ffff00000000000000000000ffff00000000ffff00000000000000000000ffff0000000000ffff0000000000000000ffffff0000000000ffff0000000000000000ffffffffffffffffffffff00000000000000ffffffffffffffffffffff000000000000ffffff00000000000000ffff000000000000ffff0000000000000000ffffff0000000000ffff000000000000000000ffff00000000ffff00000000000000000000ffff00000000ffff00000000000000000000ffffff00000000000000000000000000000000000000
65 32 2 1 24 26 -1 25 22 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffff0000000000000000000000000000000000000000ffffffff00000000000000000000000000000000000000ffffffffffff000000000000000000000000000000000000ffffffffffff000000000000000000000000000000000000ffff0000ffff0000000000000000000000000000000000ffffff0000ffffff00000000000000000000000000000000ffffff0000ffffff000000000000000000000000000000ffffff00000000ffffff0000000000000000000000000000ffffff00000000ffffff0000000000000000000000000000ffffff00000000ffffff00000000000000000000000000ffffff000000000000ffffff000000000000000000000000ffffff000000000000ffffff000000000000000000000000ffffff000000000000ffffff0000000000000000000000ffffff0000000000000000ffffff00000000000000000000ffffffffffffffffffffffffffff00000000000000000000ffffffffffffffffffffffffffffff0000000000000000ffffff00000000000000000000ffffff0000000000000000ffffff00000000000000000000ffffff00000000000000ffffffff0000000000000000000000ffffff000000000000ffffff000000000000000000000000ffffff000000000000ffffff000000000000000000000000ffffff0000000000ffffff0000000000000000000000000000ffffff00000000ffffff0000000000000000000000000000ffffff0000000000000000000000000000000000000000000000000000
66 12 65 1 9 11 0 10 8 00000000000000000000ffffffff0000000000ff000000ffff000000ff00000000ff000000ff000000ffff000000ffffffff0000000000ff00000000ff000000ff00000000ff000000ff00000000ff000000ffffffffff000000000000000000000000
66 16 65 1 11 14 0 13 10 000000000000000000000000ffffffffffff0000000000ffffffffffffff00000000ffff00000000ffff000000ffff0000000000ff000000ffff00000000ffff000000ffffffffffffff00000000ffffffffffffff00000000ffff0000000000ff000000ffff0000000000ffff0000ffff0000000000ff000000ffff00000000ffff000000ffffffffffffff0000000000000000000000000000
66 24 65 1 15 20 1 19 16 00000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffff0000000000ffffffffffffffffffffff00000000ffff00000000000000ffff00000000ffff00000000000000ffffff000000ffff00000000000000ffffff000000ffff00000000000000ffff00000000ffff000000000000ffffff00000000ffffffffffffffffffff0000000000ffffffffffffffffffff0000000000ffff000000000000ffffff00000000ffff0000000000000000ffff000000ffff0000000000000000ffff000000ffff0000000000000000ffff000000ffff0000000000000000ffff000000ffff00000000000000ffffff000000ffffffffffffffffffffff00000000ffffffffffffffffffff00000000000000000000000000000000000000
66 32 65 1 20 26 1 25 21 000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000ffffffffffffffffffffffffff00000000000000ffffff00000000000000ffffffff000000000000ffffff0000000000000000ffffffff0000000000ffffff000000000000000000ffffff0000000000ffffff000000000000000000ffffff0000000000ffffff000000000000000000ffffff0000000000ffffff000000000000000000ffffff0000000000ffffff0000000000000000ffffffff0000000000ffffff00000000000000ffffffff000000000000ffffffffffffffffffffffff0000000000000000ffffffffffffffffffffffffff00000000000000ffffff000000000000ffffffffff000000000000ffffff000000000000000000ffffff0000000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff000000000000000000ffffffff00000000ffffffffffffffffffffffffffffff0000000000ffffffffffffffffffffffffffff000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000
71 12 141 1 11 12 -1 10 9 000000000000000000000000000000ffffff00000000000000ff000000ff0000000000ff0000000000ff00000000ff00000000000000000000ff00000000000000000000ff000000ffffff00000000ff0000000000ff0000000000ff000000ffff0000000000ffffffffff00000000000000000000000000000000000000000000000000
71 16 141 1 13 15 -1 13 12 000000000000000000000000000000000000ffffffff0000000000000000ffffffffffff000000000000ffff00000000ffff00000000ffff000000000000ffff000000ffff0000000000000000000000ff000000000000000000000000ff00000000ffffffffff000000ffff000000000000ffff000000ffff000000000000ffff00000000ff000000000000ff0000000000ffffff000000ffff00000000000000ffffffffff0000000000000000000000000000000000000000000000000000000000
71 24 141 1 18 21 0 19 18 00000000000000000000000000000000000000000000000000ffffffff000000000000000000000000ffffffffffffffff000000000000000000ffffffff0000ffffffff00000000000000ffffff000000000000ffffff0000000000ffffff0000000000000000ffffff00000000ffff00000000000000000000ffff00000000ffff00000000000000000000000000000000ffff000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000ffffffffffff000000ffffff000000000000ffffffffffff00000000ffff00000000000000000000ffff00000000ffff00000000000000000000ffff00000000ffffff000000000000000000ffff0000000000ffff0000000000000000ffffff0000000000ffffffff0000000000ffffff00000000000000ffffffffffffffffffff00000000000000000000ffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000
71 32 141 1 23 27 0 25 24 00000000000000000000000000000000000000000000000000000000000000000000ffffff0000000000000000000000000000000000ffffffffffffffffff000000000000000000000000ffffffffffffffffffffffff00000000000000000000ffffffffff00000000ffffffffff0000000000000000ffffffff0000000000000000ffffffff000000000000ffffffff00000000000000000000ffffffff0000000000ffffff000000000000000000000000ffffff0000000000ffffff000000000000000000000000ffffffff000000ffffff0000000000000000000000000000000000000000ffffff0000000000000000000000000000000000000000ffffff0000000000000000000000000000000000000000ffffff0000000000000000000000000000000000000000ffffff0000000000000000ffffffffffffffffff000000ffffff0000000000000000ffffffffffffffffff000000ffffff0000000000000000ffffffffffffffffff000000ffffff0000000000000000000000000000ffffff000000ffffff0000000000000000000000000000ffffff00000000ffffff00000000000000000000000000ffffff00000000ffffff000000000000000000000000ffffff000000000000ffffff00000000000000000000ffffffff000000000000ffffffff0000000000000000ffffffff0000000000000000ffffffffffffff00ffffffffffff00000000000000000000ffffffffffffffffffffffff00000000000000000000000000ffffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
79 12 321 1 11 12 -1 10 9 000000000000000000000000000000ffffff00000000000000ff000000ff0000000000ff0000000000ff00000000ff0000000000ff00000000ff0000000000ff00000000ff0000000000ff00000000ff0000000000ff0000000000ff000000ffff000000000000ffffffff00000000000000000000000000000000000000000000000000
79 16 321 1 14 15 -1 13 12 00000000000000000000000000000000000000ffffffff000000000000000000ffffffffffff00000000000000ffff00000000ffff0000000000ffff000000000000ffff00000000ffff00000000000000ff00000000ff0000000000000000ff00000000ff0000000000000000ff00000000ffff00000000000000ff00000000ffff000000000000ffff0000000000ff000000000000ffff0000000000ffffff0000ffffff0000000000000000ffffffffff0000000000000000000000000000000000000000000000000000000000000000
79 24 321 1 18 21 0 19 18 00000000000000000000000000000000000000000000000000ffffffff000000000000000000000000ffffffffffffffff000000000000000000ffffffff0000ffffffff00000000000000ffffff000000000000ffffff0000000000ffffff0000000000000000ffffff00000000ffff00000000000000000000ffff00000000ffff00000000000000000000ffffff000000ffff0000000000000000000000ffff0000ffffff0000000000000000000000ffff0000ffffff0000000000000000000000ffff0000ffffff0000000000000000000000ffff000000ffff0000000000000000000000ffff000000ffff00000000000000000000ffff00000000ffffff000000000000000000ffff0000000000ffff0000000000000000ffffff0000000000ffffffff0000000000ffffff00000000000000ffffffffffffffffffff00000000000000000000ffffffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000
79 32 321 1 24 27 0 25 24 0000000000000000000000000000000000000000000000000000000000000000000000ffffff000000000000000000000000000000000000ffffffffffffffffff00000000000000000000000000ffffffffffffffffffffffff0000000000000000000000ffffffffff00000000ffffffffffff0000000000000000ffffffff0000000000000000ffffffff0000000000000000ffffff00000000000000000000ffffffff000000000000ffffff000000000000000000000000ffffff000000000000ffffff00000000000000000000000000ffffff00000000ffffff0000000000000000000000000000ffffff00000000ffffff0000000000000000000000000000ffffff00000000ffffff000000000000000000000000000000ffff00000000ffffff000000000000000000000000000000ffffff000000ffffff000000000000000000000000000000ffffff000000ffffff000000000000000000000000000000ffffff000000ffffff000000000000000000000000000000ffff00000000ffffff0000000000000000000000000000ffffff00000000ffffff0000000000000000000000000000ffffff0000000000ffffff00000000000000000000000000ffffff0000000000ffffff000000000000000000000000ffffff00000000000000ffffff00000000000000000000ffffffff00000000000000ffffffff0000000000000000ffffffff000000000000000000ffffffffffffff00ffffffffffff0000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000ffffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
87 12 459 1 14 11 -1 10 12 000000000000000000000000000000ffff000000ffff000000ff00000000ff000000ffff000000ff00000000ff000000ffff000000ff00000000ff0000ff00ff000000ff00000000ffff00ff0000ff00ff000000000000ff00ff0000ff00ff000000000000ff00ff0000ff00ff000000000000ffff000000ff00ff00000000000000ff00000000ff000000000000000000000000000000000000
87 16 459 1 18 14 -1 13 16 00000000000000000000000000000000000000ffff0000000000ffff0000000000ff00000000ff0000000000ffff0000000000ff00000000ff00000000ffffff00000000ffff00000000ffff000000ffffffff000000ff000000000000ff000000ff00ffff000000ff000000000000ff000000ff0000ff000000ff000000000000ffff00ffff0000ff0000ffff000000000000ffff00ffff0000ffff00ff0000000000000000ff00ff000000ffff00ff0000000000000000ff00ff00000000ff00ff0000000000000000ffffff00000000ffffff0000000000000000ffff0000000000ffff0000000000000000000000000000000000000000000000
87 24 459 1 26 20 -1 19 24 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffff00000000000000ffffff00000000000000ffffff00000000ffff00000000000000ffffffff000000000000ffffff00000000ffffff000000000000ffffffff000000000000ffff000000000000ffff000000000000ffffffff000000000000ffff000000000000ffff0000000000ffff00ffff0000000000ffffff000000000000ffff0000000000ffff0000ffff00000000ffff0000000000000000ffff00000000ffff0000ffff00000000ffff0000000000000000ffff000000ffffff0000ffff00000000ffff0000000000000000ffff000000ffff000000ffff000000ffffff0000000000000000ffff000000ffff00000000ffff0000ffff00000000000000000000ffff0000ffff00000000ffff0000ffff00000000000000000000ffff00ffff0000000000ffff0000ffff00000000000000000000ffff00ffff0000000000ffff00ffff0000000000000000000000ffff00ffff000000000000ffffffff000000000000000000000000ffffffff000000000000ffffffff000000000000000000000000ffffff00000000000000ffffffff000000000000000000000000ffffff0000000000000000ffff000000000000000000000000000000000000000000000000000000000000000000
87 32 459 1 33 26 -1 25 32 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff00000000000000000000ffffffff000000000000000000ffffffff000000ffffff00000000000000000000ffffffff000000000000000000ffffff0000000000ffffff0000000000000000ffffffffff000000000000000000ffffff0000000000ffffff0000000000000000ffffffffff000000000000000000ffffff0000000000ffffff0000000000000000ffff00ffffff00000000000000ffffff000000000000ffffff0000000000000000ffff00ffffff00000000000000ffffff00000000000000ffffff000000000000ffffff00ffffff00000000000000ffffff00000000000000ffffff000000000000ffffff0000ffff00000000000000ffffff00000000000000ffffff000000000000ffffff0000ffffff0000000000ffffff0000000000000000ffffff0000000000ffffff000000ffffff0000000000ffffff000000000000000000ffffff00000000ffffff00000000ffff0000000000ffffff000000000000000000ffffff00000000ffffff00000000ffffff00000000ffff00000000000000000000ffffff00000000ffff0000000000ffffff000000ffffff0000000000000000000000ffff000000ffffff0000000000ffffff000000ffffff0000000000000000000000ffffff0000ffffff000000000000ffff000000ffffff0000000000000000000000ffffff0000ffffff000000000000ffffff0000ffff000000000000000000000000ffffff0000ffff00000000000000ffffff00ffffff00000000000000000000000000ffff00ffffff00000000000000ffffff00ffffff00000000000000000000000000ffffffffffff0000000000000000ffff00ffffff00000000000000000000000000ffffffffffff0000000000000000ffff00ffff0000000000000000000000000000ffffffffff000000000000000000ffffffffff000000000000000000000000000000ffffffff000000000000000000ffffffffff000000000000000000000000000000ffffffff00000000000000000000ffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000
97 12 507 1 8 10 -1 8 7 0000000000000000000000ffff0000000000ff0000ffff00000000000000ff00000000ffffffff000000ff000000ff000000ff0000ffff000000ffffff00ff0000000000000000000000000000000000
97 16 507 1 10 12 -1 10 9 0000000000000000000000000000ffffff0000000000ffffff00ffff000000000000000000ffff0000000000000000ffff00000000ffffffffffff000000ffff000000ffff000000ff00000000ffff000000ffff0000ffffff00000000ffffffffffff000000000000000000000000000000000000000000
97 24 507 1 13 17 0 15 13 000000000000000000000000000000000000000000000000000000000000ffffffffffff0000000000ffffffffffffffffff00000000ffff0000000000ffff0000000000000000000000ffffff00000000000000000000ffffff00000000000000ffffffffffff000000ffffffffffffff00ffff0000ffffffff0000000000ffff0000ffff000000000000ffffff0000ffff000000000000ffffff0000ffffff0000000000ffffff000000ffffffffffffff00ffff00000000ffffffffff0000ffff000000000000000000000000000000000000000000000000000000
97 32 507 1 17 21 0 19 18 000000000000000000000000000000000000000000000000ffffffff00000000000000000000ffffffffffffffffff00000000000000ffffffffffffffffffffff0000000000ffffffff000000000000ffffff00000000ffffff00000000000000ffffff000000000000000000000000000000ffff000000000000000000000000000000ffff00000000000000000000000000ffffffff00000000000000ffffffffffffffffffff0000000000ffffffffffffffffff00ffff00000000ffffffffff000000000000ffff00000000ffffff0000000000000000ffff000000ffffff000000000000000000ffff000000ffffff0000000000000000ffffff00000000ffffff00000000000000ffffff00000000ffffffff00000000ffffffffff0000000000ffffffffffffffffff00ffff000000000000ffffffffffffff0000ffff000000000000000000000000000000000000000000000000000000000000000000000000
98 12 578 1 9 12 -1 10 7 0000000000000000000000ff0000000000000000ff0000000000000000ff00ffff0000000000ffff0000ff00000000ff000000ffff000000ff00000000ff000000ff00000000ff000000ff000000ff00000000ffffffffff0000000000000000000000000000000000000000
98 16 578 1 10 15 0 13 10 0000000000000000000000ffff0000000000000000ffff0000000000000000ffff0000000000000000ffff00ffffff00000000ffffffff00ffff000000ffff00000000ffff0000ffff00000000ffff0000ffff0000000000ff0000ffff00000000ffff0000ffff00000000ffff0000ffffff0000ffff000000ffffffffffff0000000000000000000000000000000000000000000000
98 24 578 1 15 21 0 19 15 0000000000000000000000000000000000000000000000000000000000000000ffff00000000000000000000000000ffff00000000000000000000000000ffff00000000000000000000000000ffff00000000000000000000000000ffff00ffffffffffff000000000000ffffffffffffffffffff0000000000ffffff0000000000ffffff00000000ffffff000000000000ffff00000000ffff00000000000000ffff00000000ffff00000000000000ffff00000000ffff00000000000000ffff00000000ffff00000000000000ffff00000000ffff00000000000000ffff00000000ffffff000000000000ffff00000000ffffff0000000000ffffff00000000ffffffffffffffffffff0000000000ffff00ffffffffffff00000000000000000000000000000000000000000000000000000000000000000000
98 32 578 1 18 27 1 25 20 00000000000000000000000000000000000000000000000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000ffffff00000000ffffff0000000000000000ffffff0000ffffffffffffffff0000000000ffffff00ffffffffffffffffffff00000000ffffffffffff0000000000ffffff00000000ffffffffff00000000000000ffffff000000ffffffff0000000000000000ffffff000000ffffffff000000000000000000ffffff0000ffffff00000000000000000000ffffff0000ffffff00000000000000000000ffffff0000ffffff00000000000000000000ffffff0000ffffff00000000000000000000ffffff0000ffffff00000000000000000000ffffff0000ffffffff000000000000000000ffffff0000ffffffff0000000000000000ffffff000000ffffffffff000000000000ffffffff000000ffffff00ffff00000000ffffffff00000000ffffff00ffffffffffffffffff0000000000ffffff0000ffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000
103 12 658 1 9 12 -1 8 7 00000000000000000000000000ff00ff00000000ffff00ffff00000000ff000000ff00000000ff000000ff00000000ff000000ff00000000ff000000ff0000000000ffffffff0000000000000000ff00000000ffff00ffff000000000000ff00000000000000000000000000
103 16 658 1 11 15 -1 10 10 000000000000000000000000000000ffffff00ffff00000000ffff00ffffffff000000ffff00000000ffff000000ff0000000000ffff000000ff0000000000ffff000000ff0000000000ffff000000ffff00000000ffff00000000ffff00ffffffff0000000000ffffff00ffff000000000000000000ffff000000ffff00000000ff0000000000ffffffffffff000000000000000000000000000000000000000000000000
103 24 658 1 14 22 0 15 15 0000000000000000000000000000000000000000000000000000000000000000ffffffffff0000ffff00000000ffffffffffffff00ffff000000ffffff00000000ffffffff000000ffff000000000000ffffff0000ffffff00000000000000ffff0000ffff0000000000000000ffff0000ffff0000000000000000ffff0000ffff0000000000000000ffff0000ffffff000000000000ffffff000000ffff000000000000ffffff000000ffffff00000000ffffffff00000000ffffffffffffff00ffff000000000000ffffff000000ffff000000000000000000000000ffff00000000ff00000000000000ffff000000ffff000000000000ffff0000000000ffffffffffffffffff000000000000ffffffffffff0000000000000000000000000000000000000000000000000000000000000000
103 32 658 1 19 27 0 19 20 0000000000000000000000000000000000000000000000000000ffffffff00000000000000000000000000ffffffffffffffff00ffffff000000000000ffffffffffffffffffffffffff0000000000ffffffff0000000000ffffffffff0000000000ffffff00000000000000ffffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffffff00000000000000ffffffff0000000000ffffffff0000000000ffffffffff000000000000ffffffffffffffffffffffffff00000000000000ffffffffffffffff00ffffff000000000000000000ffffffff000000ffffff00000000000000000000000000000000ffffff00000000000000000000000000000000ffffff000000000000ff000000000000000000ffffff00000000ffffffff00000000000000ffffff000000000000ffffffffffffffffffffffffff00000000000000ffffffffffffffffffffff00000000000000000000ffffffffffffff00000000000000000000000000000000000000000000000000
109 12 766 1 12 9 -1 8 11 0000000000000000000000000000ff00ffff0000ff0000000000ffff00ff000000ff00000000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff00000000000000000000000000
109 16 766 1 14 11 0 10 14 000000000000000000000000000000ffff00ffff000000ffff00000000ffffff00ffff00ff00ffff000000ffff000000ffff000000ffff0000ffff000000ffff000000ffff0000ffff000000ffff000000ffff0000ffff000000ffff000000ffff0000ffff000000ffff000000ffff0000ffff000000ffff000000ffff0000ffff000000ffff000000ffff000000000000000000000000000000
109 24 766 1 21 16 0 15 21 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffff00ffffffffff0000ffffffffffff0000000000ffffffffffffffffffffffffffffffffff00000000ffffff00000000ffffff00000000ffffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff0000000000000000000000000000000000000000000000
109 32 766 1 26 20 1 19 28 000000000000000000000000000000000000000000000000000000000000000000ffffffff000000000000ffffffff000000000000ffffff0000ffffffffffff000000ffffffffffffffff00000000ffffff00ffffffffffffffff00ffffffffffffffffffff000000ffffffffff00000000ffffff00ffff0000000000ffffff000000ffffffff000000000000ffffffff000000000000ffffff000000ffffff0000000000000000ffffff00000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff000000000000000000000000000000000000000000000000000000
111 12 790 1 9 10 -1 8 7 00000000000000000000000000ff000000000000ffff00ffff00000000ff000000ff00000000ff000000ffff000000ff000000ffff000000ff000000ff0000000000ffffff000000000000000000000000000000000000000000
111 16 790 1 11 12 -1 10 10 000000000000000000000000000000ffffff00000000000000ffff00ffffff00000000ffff00000000ff00000000ff0000000000ffff000000ff0000000000ffff000000ff0000000000ffff000000ffff00000000ff0000000000ff000000ffff000000000000ffffffff00000000000000000000000000000000000000000000000000
111 24 790 1 15 17 0 15 14 00000000000000000000000000000000000000000000000000000000000000000000ffffffffffff0000000000000000ffffffffffffffff000000000000ffffff0000000000ffff0000000000ffff000000000000ffffff000000ffffff00000000000000ffff000000ffff0000000000000000ffff000000ffff0000000000000000ffff000000ffff0000000000000000ffff000000ffffff00000000000000ffff00000000ffff000000000000ffffff00000000ffffff0000000000ffff000000000000ffffffffffffffff0000000000000000ffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000
111 32 790 1 19 21 0 19 19 000000000000000000000000000000000000000000000000000000ffffff00000000000000000000000000ffffffffffffffffff000000000000000000ffffffffffffffffffffff00000000000000ffffffff0000000000ffffffff000000000000ffffff00000000000000ffffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff00000000000000000000ffff00000000ffffff00000000000000000000ffffff000000ffff0000000000000000000000ffffff000000ffffff00000000000000000000ffffff000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff0000000000ffffff00000000000000ffffff00000000000000ffffffff00000000ffffffff00000000000000ffffffffffffffffffffff00000000000000000000ffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
115 12 871 1 8 10 -1 8 6 0000000000000000000000ffff0000000000ff0000ff00000000ff00000000000000ffffff0000000000000000ffff000000ff000000ff000000ffffffff000000000000000000000000000000000000
115 16 871 1 10 12 -1 10 8 0000000000000000000000000000ffffff0000000000ffffff00ffff00000000ffff000000ff00000000ffff000000000000000000ffffffff000000000000000000ffff000000000000000000ffff000000ffff000000ff0000000000ffffffffff00000000000000000000000000000000000000000000
115 24 871 1 13 17 0 15 13 000000000000000000000000000000000000000000000000000000000000ffffffffff000000000000ffffffffffffffff0000000000ffff0000000000ffff00000000ffff0000000000000000000000ffff0000000000000000000000ffffffffff00000000000000000000ffffffffffff00000000000000000000ffffffff0000000000000000000000ffff0000000000000000000000ffff000000ffffff0000000000ffff00000000ffffffffffffffffff0000000000ffffffffffff000000000000000000000000000000000000000000000000000000000000
115 32 871 1 17 21 0 19 17 000000000000000000000000000000000000000000000000ffffffff00000000000000000000ffffffffffffffffff00000000000000ffffffffffffffffffffff000000000000ffffff0000000000ffffffff00000000ffffff00000000000000ffffff00000000ffffff0000000000000000000000000000ffffffff0000000000000000000000000000ffffffff00000000000000000000000000ffffffffffffffff0000000000000000000000ffffffffffffffff000000000000000000000000ffffffffffff0000000000000000000000000000ffffffff0000000000000000000000000000ffffff0000000000ffff00000000000000ffffff00000000ffffff00000000000000ffffff00000000ffffffff0000000000ffffffff0000000000ffffffffffffffffffffff00000000000000ffffffffffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000
119 12 984 1 12 9 -1 8 10 00000000000000000000000000ffff0000ff000000ff00000000ff0000ffff0000ff00000000ff0000ffff0000ff00000000ff000000ff00ff000000000000ffff0000ffff000000000000ffff0000ffff000000000000ffff0000ffff000000000000000000000000000000
119 16 984 1 15 11 -1 10 13 0000000000000000000000000000000000ff00000000ff00000000ff00000000ff000000ffffff000000ff00000000ffff0000ff00ff0000ffff0000000000ff0000ff00ff0000ffff0000000000ff0000ff00ff0000ff000000000000ff00ffff00ffff00ff000000000000ffffff000000ffffff00000000000000ffff000000ffff0000000000000000ffff000000ffff00000000000000000000000000000000000000
119 24 984 1 21 16 -1 15 20 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffff000000000000ffff0000000000ffffff000000ffffff00000000ffffff0000000000ffff0000000000ffff00000000ffffffff00000000ffff0000000000ffff00000000ffffffff00000000ffff0000000000ffff000000ffff00ffff000000ffff00000000000000ffff0000ffff0000ff000000ffff00000000000000ffff0000ffff0000ffff0000ffff00000000000000ffff0000ff000000ffff00ffffff00000000000000ffff00ffff000000ffff00ffff000000000000000000ffffffff00000000ff00ffff000000000000000000ffffffff00000000ffffffff000000000000000000ffffff0000000000ffffff0000000000000000000000ffff000000000000ffff0000000000000000000000000000000000000000000000000000
119 32 984 1 27 20 0 19 26 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff00000000000000ffffffff00000000000000ffffff00000000ffffff000000000000ffffffff00000000000000ffff0000000000ffffff000000000000ffffffff000000000000ffffff0000000000ffffff000000000000ffffffffff0000000000ffffff000000000000ffff0000000000ffffff00ffff0000000000ffffff000000000000ffffff00000000ffff0000ffff00000000ffffff00000000000000ffffff00000000ffff0000ffffff000000ffffff0000000000000000ffff000000ffffff0000ffffff000000ffffff0000000000000000ffffff0000ffffff000000ffff000000ffff000000000000000000ffffff0000ffff00000000ffff0000ffffff000000000000000000ffffff0000ffff00000000ffffff00ffffff00000000000000000000ffff00ffffff00000000ffffff00ffff0000000000000000000000ffffffffff000000000000ffff00ffff0000000000000000000000ffffffffff000000000000ffffffffff000000000000000000000000ffffffff000000000000ffffffffff000000000000000000000000ffffffff00000000000000ffffff00000000000000000000000000ffffff0000000000000000ffffff00000000000000000000000000000000000000000000000000000000000000000000
122 12 1022 1 8 9 -1 8 7 00000000000000000000ffffffffff000000000000ffff000000000000ff000000000000ff000000000000ff000000000000ffff000000000000ffffffffff000000000000000000
122 16 1022 1 10 11 -1 10 9 000000000000000000000000ffffffffffffff000000ffffffffffffff00000000000000ffff00000000000000ffff0000000000000000ff0000000000000000ffff00000000000000ffff00000000000000ffff0000000000000000ffffffffffffff0000000000000000000000
122 24 1022 1 13 16 0 15 13 00000000000000000000000000000000000000000000000000000000ffffffffffffffffffff000000ffffffffffffffffffff000000000000000000ffffff00000000000000000000ffff00000000000000000000ffff00000000000000000000ffffff000000000000000000ffffff00000000000000000000ffff00000000000000000000ffff00000000000000000000ffff00000000000000000000ffffff000000000000000000ffffffffffffffffffffff0000ffffffffffffffffffffff0000000000000000000000000000
122 32 1022 1 17 20 0 19 18 000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffff00000000ffffffffffffffffffffffffff0000000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000ffffffff00000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000ffffffff00000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000ffffffffffffffffffffffffffff000000ffffffffffffffffffffffffffff000000ffffffffffffffffffffffffffff000000000000000000000000000000000000
35 12 1453 1 10 11 -1 10 8 00000000000000000000000000ff000000000000000000ff0000ff000000000000ff0000ff0000000000ffffffffffff0000000000ff0000ff000000000000ff0000ff00000000ffffffffffffff00000000ff0000ff000000000000ff0000ff0000000000000000000000000000
35 16 1453 1 12 14 -1 13 10 00000000000000000000000000000000ffff0000ffff000000000000ff000000ff00000000000000ff000000ff00000000000000ff000000ff0000000000ffffffffffffffffff0000000000ff000000ff000000000000ffff0000ffff000000000000ff000000ff0000000000ffffffffffffffffff0000000000ff000000ff00000000000000ff000000ff00000000000000ff000000ff00000000000000000000000000000000
35 24 1453 1 17 20 -1 19 15 00000000000000000000000000000000000000000000000000000000000000000000000000000000ffff00000000ffff000000000000000000ffff00000000ffff000000000000000000ff0000000000ffff0000000000000000ffff0000000000ff00000000000000ffffffffffffffffffffffffff00000000ffffffffffffffffffffffffff000000000000ffff00000000ffff000000000000000000ffff00000000ffff000000000000000000ff0000000000ffff0000000000000000ffff0000000000ff00000000000000ffffffffffffffffffffffffff00000000ffffffffffffffffffffffffff000000000000ffff00000000ffff000000000000000000ffff00000000ffff000000000000000000ff0000000000ffff0000000000000000ffff0000000000ff000000000000000000ffff00000000ffff0000000000000000000000000000000000000000000000
35 32 1453 1 22 26 -1 25 20 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffff000000000000ffff0000000000000000000000ffffff000000000000ffff0000000000000000000000ffffff0000000000ffffff0000000000000000000000ffffff0000000000ffffff0000000000000000000000ffff000000000000ffffff0000000000000000000000ffff000000000000ffff0000000000000000ffffffffffffffffffffffffffffffffffff00000000ffffffffffffffffffffffffffffffffff0000000000ffffffffffffffffffffffffffffffffff0000000000000000ffffff0000000000ffffff0000000000000000000000ffff000000000000ffffff0000000000000000000000ffff000000000000ffff000000000000000000000000ffff000000000000ffff000000000000000000000000ffff000000000000ffff0000000000000000ffffffffffffffffffffffffffffffffff0000000000ffffffffffffffffffffffffffffffffff0000000000ffffffffffffffffffffffffffffffffff0000000000000000ffff000000000000ffff000000000000000000000000ffff000000000000ffff000000000000000000000000ffff000000000000ffff0000000000000000000000ffffff000000000000ffff0000000000000000000000ffffff0000000000ffffff0000000000000000000000ffff000000000000ffffff0000000000000000000000000000000000000000000000000000000000
37 12 1744 1 12 12 0 10 12 0000000000000000000000000000ffff00000000ff00000000ff0000ff000000ff00000000ff0000ff0000ff000000000000ffff0000ff00000000000000000000ff0000000000000000000000ff0000ffff000000000000ff0000ff00ff0000000000ff000000ff00000000000000ff000000ffffff0000000000000000000000000000000000000000000000000000
37 16 1744 1 15 15 0 13 16 000000000000000000000000000000000000ffff000000000000ff0000000000ff0000ff00000000ffff0000000000ff0000ff00000000ff000000000000ff0000ff000000ff00000000000000ffffffff0000ffff00000000000000000000000000ff00000000000000000000000000ff00000000000000000000000000ffff0000ffffff0000000000000000ff0000ffff0000ff000000000000ff000000ffff0000ff0000000000ffff000000ffff0000ff00000000ffff0000000000ffffff0000000000000000000000000000000000000000000000000000000000000000
37 24 1744 1 21 21 1 19 24 00000000000000000000000000000000000000000000000000ffff0000000000000000000000000000000000ffffffffffff00000000000000ffff000000000000ffff0000ffff000000000000ffff00000000000000ffff000000ffff0000000000ffff00000000000000ff00000000ffff00000000ffff0000000000000000ffff000000ff00000000ffff000000000000000000ffff0000ffff00000000ffff00000000000000000000ffffffff00000000ffff000000000000000000000000000000000000ffff00000000000000000000000000000000000000ffff000000000000000000000000000000000000ffff00000000ffffff0000000000000000000000ffff00000000ffffffffff00000000000000000000ff00000000ffff000000ffff0000000000000000ffff00000000ffff000000ffff00000000000000ffff0000000000ffff000000ffff000000000000ffff000000000000ffff000000ffff000000000000ffff000000000000ffffff00ffff000000000000ffff0000000000000000ffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
37 32 1744 1 27 27 2 25 31 0000000000000000000000000000000000000000000000000000000000000000ffff0000000000000000000000000000000000000000000000ffffffffffff0000000000000000000000ffff00000000000000ffffffff00ffffff000000000000000000ffffff00000000000000ffff00000000ffff0000000000000000ffffff0000000000000000ffff00000000ffffff00000000000000ffff000000000000000000ffff00000000ffffff000000000000ffffff000000000000000000ffff00000000ffffff0000000000ffffff00000000000000000000ffff00000000ffffff0000000000ffff0000000000000000000000ffffff0000ffffff0000000000ffffff000000000000000000000000ffffffffffffff00000000ffffff0000000000000000000000000000ffffffff000000000000ffff000000000000000000000000000000000000000000000000ffffff0000000000000000000000000000000000000000000000ffffff000000000000000000000000000000000000000000000000ffff000000000000000000000000000000000000000000000000ffff000000000000ffffffffff00000000000000000000000000ffffff0000000000ffffffffffffff0000000000000000000000ffffff0000000000ffffff000000ffff0000000000000000000000ffff000000000000ffff00000000ffffff000000000000000000ffffff000000000000ffff00000000ffffff0000000000000000ffffff00000000000000ffff00000000ffffff0000000000000000ffff0000000000000000ffff00000000ffffff00000000000000ffffff0000000000000000ffffff000000ffffff000000000000ffffff00000000000000000000ffffffffffffff00000000000000ffff0000000000000000000000ffffffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
38 12 1425 1 10 12 -1 10 8 00000000000000000000000000ffffff000000000000ffff00ff000000000000ff0000ffff000000000000ffffff00000000000000ffff00000000000000ff00ffff00ff00000000ff0000ff00ff00000000ff000000ff0000000000ffffffff00ff00000000000000000000000000000000000000000000
38 16 1425 1 13 15 -1 13 10 0000000000000000000000000000000000ffffff000000000000000000ffff00ffff0000000000000000ff000000ff0000000000000000ff000000ff0000000000000000ffff00ffff000000000000000000ffffff000000000000000000ffffffff0000000000000000ffff0000ff0000ff0000000000ff000000ffff00ff0000000000ff00000000ffffff0000000000ffff000000ffffff000000000000ffffffffff00ffff00000000000000000000000000000000000000000000000000000000
38 24 1425 1 17 21 0 19 15 0000000000000000000000000000000000000000000000ffff00000000000000000000000000ffffffffffff00000000000000000000ffffff0000ffffff000000000000000000ffff00000000ffff000000000000000000ffff00000000ffff000000000000000000ffff00000000ffff000000000000000000ffffff00ffffff0000000000000000000000ffffffffff00000000000000000000000000ffffff000000000000000000000000ffffffffff0000000000000000000000ffffff00ffffff000000ffff0000000000ffff000000ffffff0000ffff00000000ffffff00000000ffffff00ffff00000000ffff000000000000ffffffff0000000000ffffff000000000000ffffff000000000000ffff0000000000ffffffff000000000000ffffffffffffffffffffffff00000000000000ffffffffffff0000ffffff000000000000000000000000000000000000000000000000000000000000000000000000
38 32 1425 1 22 27 0 25 21 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffff0000000000000000000000000000ffffffffffffffffff000000000000000000000000ffffff00000000ffffff000000000000000000000000ffffff0000000000ffffff0000000000000000000000ffff000000000000ffffff0000000000000000000000ffff000000000000ffffff0000000000000000000000ffffff00000000ffffff000000000000000000000000ffffff000000ffffffff00000000000000000000000000ffffff00ffffffff0000000000000000000000000000ffffffffffffff00000000000000000000000000000000ffffffffff00000000000000000000000000000000ffffffffffff000000000000000000000000000000ffffffffffffff0000000000000000000000000000ffffffff0000ffffff00000000ffffff0000000000ffffffff00000000ffffff000000ffffff0000000000ffffff0000000000ffffffff0000ffff000000000000ffffff000000000000ffffffffffffff000000000000ffffff00000000000000ffffffffffff000000000000ffffff0000000000000000ffffffff00000000000000ffffff0000000000000000ffffffff0000000000000000ffffffff00000000ffffffffffffff0000000000000000ffffffffffffffffffffffffffffff0000000000000000ffffffffffffffff000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
63 12 1431 1 8 12 -1 10 6 0000000000000000000000ffff0000000000ff0000ff00000000000000ffff000000000000ff000000000000ff000000000000ff0000000000000000000000000000000000000000000000ffff00000000000000000000000000000000000000
63 16 1431 1 10 15 -1 13 8 0000000000000000000000000000ffffff0000000000ffffffffffff00000000ff00000000ff000000000000000000ff0000000000000000ffff00000000000000ffff00000000000000ffff0000000000000000ffff00000000000000000000000000000000000000000000000000000000ffff0000000000000000ffff000000000000000000000000000000000000000000000000
63 24 1431 1 14 21 -1 19 12 0000000000000000000000000000000000000000ffffff000000000000000000ffffffffffffff000000000000ffffff0000ffffff0000000000ffffff0000000000ffff00000000ffff000000000000ffff000000000000000000000000ffff0000000000000000000000ffffff00000000000000000000ffffff00000000000000000000ffffff00000000000000000000ffffff0000000000000000000000ffff000000000000000000000000ffff0000000000000000000000ffffff000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff0000000000000000000000ffffff0000000000000000000000ffffff00000000000000000000000000000000000000000000000000000000000000000000
63 32 1431 1 16 27 0 25 16 0000000000000000000000000000000000000000000000ffff0000000000000000000000ffffffffffffffff00000000000000ffffffffffffffffffff0000000000ffffffff00000000ffffffff00000000ffffff000000000000ffffff000000ffffff0000000000000000ffffff0000ffffff0000000000000000ffffff00000000000000000000000000ffffff000000000000000000000000ffffff00000000000000000000000000ffffff0000000000000000000000ffffffff0000000000000000000000ffffffff0000000000000000000000ffffffff0000000000000000000000ffffffff000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff000000000000000000000000ffffffff000000000000000000000000ffffffff00000000000000000000000000ffffff000000000000000000000000000000000000000000000000000000000000000000000000000000
233 12 618 1 9 13 -1 11 7 0000000000000000000000000000000000000000000000ff00000000000000ff0000000000000000ff000000000000ffff00ffff00000000ff000000ff00000000ffffffffff00000000ff0000000000000000ff000000ff0000000000ffffffff0000000000000000000000000000000000000000
233 16 618 1 11 16 -1 14 9 00000000000000000000000000000000000000000000000000000000ff000000000000000000ffff00000000000000000000000000000000000000ffffff00000000000000ffff00ffffff00000000ffff00000000ff00000000ff0000000000ff00000000ffffffffffffffff000000ff00000000000000000000ffff00000000000000000000ff000000ffff000000000000ffffffff00000000000000000000000000000000000000000000000000
233 24 618 1 14 22 0 20 14 0000000000000000000000000000000000000000000000000000000000000000000000ffffff0000000000000000000000ffff0000000000000000000000ffff0000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffff00000000000000ffffffffffffffff0000000000ffffff00000000ffffff00000000ffff000000000000ffff000000ffffff00000000000000ffff0000ffffffffffffffffffffffff0000ffffffffffffffffffffffff0000ffff000000000000000000000000ffffff000000000000000000000000ffff000000000000000000000000ffffff0000000000ffff0000000000ffffffffffffffffff000000000000ffffffffffff0000000000000000000000000000000000000000000000000000000000000000
233 32 618 1 19 28 0 26 19 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff000000000000000000000000000000ffffff00000000000000000000000000000000ffffff00000000000000000000000000000000ffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff00000000000000000000000000ffffffffffffffffff000000000000000000ffffffffffffffffffffff00000000000000ffffffff0000000000ffffffff000000000000ffffff00000000000000ffffff0000000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffffffffffffffffffffffffffff00000000ffffffffffffffffffffffffffffff00000000ffff0000000000000000000000000000000000ffffff00000000000000000000000000000000ffffff00000000000000000000000000000000ffffff000000000000000000ff00000000000000ffffff00000000000000ffffffff000000000000ffffffff00000000ffffffff00000000000000ffffffffffffffffffffff00000000000000000000ffffffffffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
224 12 528 1 8 13 -1 11 7 00000000000000000000000000000000000000ff0000000000000000ff000000000000ffff0000000000ff0000ffff00000000000000ff00000000ffffffff000000ff000000ff000000ff0000ffff000000ffffff00ff0000000000000000000000000000000000
224 16 528 1 10 16 -1 14 9 000000000000000000000000000000000000000000000000ff000000000000000000ffff000000000000000000000000000000000000ffffff0000000000ffffff00ffff000000000000000000ffff0000000000000000ffff00000000ffffffffffff000000ffff000000ffff000000ff00000000ffff000000ffff0000ffffff00000000ffffffffffff000000000000000000000000000000000000000000
224 24 528 1 13 22 0 20 13 000000000000000000000000000000000000000000000000000000000000ffff000000000000000000000000ffff0000000000000000000000ffff000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffff0000000000ffffffffffffffffff00000000ffff0000000000ffff0000000000000000000000ffffff00000000000000000000ffffff00000000000000ffffffffffff000000ffffffffffffff00ffff0000ffffffff0000000000ffff0000ffff000000000000ffffff0000ffff000000000000ffffff0000ffffff0000000000ffffff000000ffffffffffffff00ffff00000000ffffffffff0000ffff000000000000000000000000000000000000000000000000000000
224 32 528 1 17 28 0 26 18 000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff000000000000000000000000000000ffffff0000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffff00000000000000000000ffffffffffffffffff00000000000000ffffffffffffffffffffff0000000000ffffffff000000000000ffffff00000000ffffff00000000000000ffffff000000000000000000000000000000ffff000000000000000000000000000000ffff00000000000000000000000000ffffffff00000000000000ffffffffffffffffffff0000000000ffffffffffffffffff00ffff00000000ffffffffff000000000000ffff00000000ffffff0000000000000000ffff000000ffffff000000000000000000ffff000000ffffff0000000000000000ffffff00000000ffffff00000000000000ffffff00000000ffffffff00000000ffffffffff0000000000ffffffffffffffffff00ffff000000000000ffffffffffffff0000ffff000000000000000000000000000000000000000000000000000000000000000000000000
231 12 589 1 9 12 -1 8 7 00000000000000000000000000ffff0000000000ffff00ffff00000000ff0000000000000000ff0000000000000000ff0000000000000000ff000000ff0000000000ffffff00000000000000ff000000000000000000ff000000000000000000000000000000000000000000
231 16 589 1 11 15 -1 10 9 000000000000000000000000000000ffffff00000000000000ffff00ffffff00000000ffff00000000ff00000000ff00000000000000000000ff00000000000000000000ff00000000000000000000ffff00000000ff0000000000ff000000ffff000000000000ffffffff0000000000000000ff0000000000000000000000ffff0000000000000000ffffff00000000000000000000000000000000000000000000000000
231 24 589 1 14 21 0 15 14 0000000000000000000000000000000000000000000000000000000000000000ffffffffffff00000000000000ffffffffffffffff0000000000ffffff0000000000ffff00000000ffff000000000000ffff000000ffffff0000000000000000000000ffff000000000000000000000000ffff000000000000000000000000ffff000000000000000000000000ffffff000000000000000000000000ffff000000000000ffff00000000ffffff0000000000ffff0000000000ffffffffffffffff00000000000000ffffffffffff0000000000000000000000ff000000000000000000000000ffffff00000000000000000000000000ffff000000000000000000000000ffff00000000000000000000ffffff00000000000000000000000000000000000000
231 32 589 1 18 27 0 19 18 0000000000000000000000000000000000000000000000000000ffffff000000000000000000000000ffffffffffffffffff0000000000000000ffffffffffffffffffffff000000000000ffffffff0000000000ffffffff0000000000ffffff00000000000000ffffff00000000ffffff000000000000000000ff0000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000ffff00000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000ffffff00000000ffffff00000000000000ffffff000000000000ffffffff00000000ffffffff000000000000ffffffffffffffffffffff000000000000000000ffffffffffffff0000000000000000000000000000ff0000000000000000000000000000000000ffff000000000000000000000000000000ffffffffff00000000000000000000000000000000ffff00000000000000000000000000000000ffff00000000000000000000000000ffffffffff00000000000000000000000000ffff0000000000000000000000000000000000000000000000000000
252 12 916 1 9 13 -1 11 7 000000000000000000000000000000000000000000ff00ff0000000000000000000000000000ff000000ff00000000ff000000ff00000000ff000000ff00000000ff000000ff00000000ff000000ff00000000ff000000ff0000000000ffffffff0000000000000000000000000000000000000000
252 16 916 1 10 16 0 14 9 00000000000000000000000000000000000000000000ffff0000ff0000000000ffff0000ff0000000000000000000000000000ffff00000000ff000000ffff00000000ff000000ffff00000000ff000000ffff00000000ff000000ffff00000000ff000000ffff00000000ff000000ffff00000000ff00000000ffff0000ffff00000000ffffffff00ff00000000000000000000000000000000000000000000
252 24 916 1 14 22 0 20 14 0000000000000000000000000000000000000000000000000000000000000000ffff0000ffffff000000000000ffffff0000ffffff00000000000000ff00000000ff00000000000000000000000000000000000000000000000000000000000000000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffffff00000000ffffff0000000000ffffffffffffffffff000000000000ffffffffff00ffff000000000000000000000000000000000000000000000000000000000000
252 32 916 1 17 28 1 26 19 0000000000000000000000000000000000000000000000000000000000000000000000000000ffff00000000ffffff00000000000000ffffffff000000ffffffff000000000000ffffffff000000ffffff0000000000000000ffff0000000000ffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff00000000ffff0000000000000000ffffff00000000ffffff00000000000000ffffff00000000ffffff000000000000ffffffff00000000ffffffffff000000ffff00ffff0000000000ffffffffffffffffff00ffff000000000000ffffffffffff000000ffff000000000000000000000000000000000000000000000000000000000000000000000000
216 12 324 1 11 12 -1 10 9 000000000000000000000000000000ffffff00ff0000000000ff000000ff0000000000ff00000000ffff00000000ff000000ff00ff00000000ff0000ff0000ff00000000ff00ffff0000ff00000000ff00ff000000ff0000000000ff000000ffff00000000ff00ffffffff00000000000000000000000000000000000000000000000000
216 16 324 1 14 15 -1 13 12 00000000000000000000000000000000000000ffffffff00ff00000000000000ffffffffffffff000000000000ffff00000000ffff0000000000ffff00000000ffffffff00000000ffff00000000ff0000ff00000000ff00000000ff000000ff00000000ff000000ffff000000ff00000000ffff00ffff00000000ff00000000ffff00ff00000000ffff0000000000ffffff00000000ffff0000000000ffffff0000ffffff000000000000ff00ffffffffff0000000000000000000000000000000000000000000000000000000000000000
216 24 324 1 18 21 0 19 18 00000000000000000000000000000000000000000000000000ffffffff000000ff0000000000000000ffffffffffffffffffffff000000000000ffffffff0000ffffffffff000000000000ffffff000000000000ffffff0000000000ffffff000000000000ffffffffff00000000ffff00000000000000ffff00ffff00000000ffff000000000000ffff0000ffffff000000ffff0000000000ffffff000000ffff0000ffffff0000000000ffff00000000ffff0000ffffff00000000ffff0000000000ffff0000ffffff000000ffff000000000000ffff000000ffff000000ffff000000000000ffff000000ffff0000ffff000000000000ffff00000000ffffffffff00000000000000ffff0000000000ffffffff000000000000ffffff0000000000ffffffff0000000000ffffff000000000000ffffffffffffffffffffff000000000000ffffff00ffffffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000
216 32 324 1 24 27 0 25 24 0000000000000000000000000000000000000000000000000000000000000000000000ffffff0000000000ff000000000000000000000000ffffffffffffffffff00ffffff000000000000000000ffffffffffffffffffffffffffffff0000000000000000ffffffffff00000000ffffffffffff0000000000000000ffffffff0000000000000000ffffffff0000000000000000ffffff000000000000000000ffffffffff000000000000ffffff000000000000000000ffffffffffff000000000000ffffff0000000000000000ffffff0000ffffff00000000ffffff0000000000000000ffffff000000ffffff00000000ffffff0000000000000000ffffff000000ffffff00000000ffffff00000000000000ffffff0000000000ffff00000000ffffff000000000000ffffff000000000000ffffff000000ffffff000000000000ffffff000000000000ffffff000000ffffff0000000000ffffff00000000000000ffffff000000ffffff00000000ffffff0000000000000000ffff00000000ffffff00000000ffffff00000000000000ffffff00000000ffffff000000ffffff0000000000000000ffffff0000000000ffffff00ffffff000000000000000000ffffff0000000000ffffffffffff000000000000000000ffffff00000000000000ffffffffff0000000000000000ffffffff00000000000000ffffffff0000000000000000ffffffff0000000000000000ffffffffffffffff00ffffffffffff000000000000000000ffffffffffffffffffffffffffff000000000000000000ffffff0000ffffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
64 12 1445 1 13 14 -1 10 12 000000000000000000000000000000000000000000000000000000000000ffff0000ffff000000000000ff000000000000ff00000000ff0000ffffffff0000ff000000ff0000ff0000ff0000ff000000ff00ff000000ff0000ff000000ff00ff000000ff0000ff000000ff0000ff0000ff0000ff000000ff000000ffff00ffff0000000000ff00000000000000000000000000ffffffffffff0000000000000000000000000000000000000000000000000000000000
64 16 1445 1 17 18 -1 13 15 000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffff000000000000000000ffff000000000000ffff000000000000ffff0000000000000000ff000000000000ff000000ffffff00ff0000ff00000000ffff0000ffff0000ffff0000ff00000000ff000000ff000000ffff0000ff00000000ff0000ffff00000000ff0000ff00000000ff0000ffff00000000ff0000ff00000000ff000000ff000000ffff0000ff00000000ffff0000ffff00ffffff00ffff0000000000ff000000ffffff0000ffff000000000000ffff00000000000000000000000000000000ffffff00000000000000000000000000000000ffffffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000
64 24 1445 1 23 24 0 18 23 0000000000000000000000000000000000000000000000000000000000000000ffffffffffff0000000000000000000000000000ffffffffffffffffffffff0000000000000000000000ffffff00000000000000ffffffff0000000000000000ffffff00000000000000000000ffffff000000000000ffff00000000000000000000000000ffff000000000000ffff0000000000ffffff000000000000ffff00000000ffff00000000ffffffffffffffff000000ffff00000000ffff000000ffffff000000ffffff00000000ffff000000ffff000000ffff0000000000ffff00000000ffff0000ffff00000000ff000000000000ffff00000000ffff0000ffff000000ffff000000000000ffff00000000ffff0000ffff00000000ff000000000000ffff00000000ffff000000ff00000000ffff0000000000ffff00000000ffff000000ffff000000ffff0000000000ffff00000000ff00000000ffff000000ffffff000000ffffffff0000ffff00000000ffff00000000ffffffffffff00ffffffffff000000000000ffff000000000000ff0000000000ffff00000000000000ffffff000000000000000000000000000000000000000000ffffff000000000000000000000000000000000000000000ffffffff000000000000ffff00000000000000000000000000ffffffffffffffffffff00000000000000000000000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000
64 32 1445 1 30 32 0 24 31 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffff0000000000000000000000000000000000ffffffffffffffffffffffffffffff0000000000000000000000000000ffffffff000000000000000000ffffffffff00000000000000000000ffffffff00000000000000000000000000ffffffff000000000000000000ffffff000000000000000000000000000000ffffffff00000000000000ffffff0000000000000000000000000000000000ffffff000000000000ffffff0000000000000000ffffff0000000000000000ffffff0000000000ffffff0000000000ffffffffffffffffffffff00000000ffff0000000000ffff0000000000ffffffffffffffffffffffff00000000ffffff000000ffffff0000000000ffffff0000000000ffffffff00000000ffffff000000ffffff00000000ffffff00000000000000ffffff00000000ffffff000000ffffff00000000ffff0000000000000000ffffff00000000ffffff000000ffffff00000000ffff0000000000000000ffffff0000000000ffff000000ffffff00000000ffff0000000000000000ffffff00000000ffffff000000ffffff00000000ffff0000000000000000ffffff00000000ffffff000000ffffff00000000ffff0000000000000000ffffff00000000ffffff000000ffffff00000000ffffff00000000000000ffffff00000000ffffff000000ffffff00000000ffffff000000000000ffffffff00000000ffff00000000ffffff0000000000ffffff00000000ffffffffff000000ffffff0000000000ffff0000000000ffffffffffffffffff00ffffffffffffffff0000000000ffffff000000000000ffffffffffff0000ffffffffffffff00000000000000ffffff00000000000000000000000000000000ff00000000000000000000ffffff00000000000000000000000000000000000000000000000000000000ffffff00000000000000000000000000000000000000000000000000000000ffffffff000000000000000000000000000000000000000000000000000000ffffffffffff00000000000000ffffff000000000000000000000000000000ffffffffffffffffffffffffffffff000000000000000000000000000000000000ffffffffffffffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+57
Voir le fichier
@@ -0,0 +1,57 @@
// test/oracle/main.cpp — point d entree du harnais d oracle.
//
// Le meme fichier sert aux deux cibles :
// hote -> main(), executable proj3_oracle
// embarquee -> proj3_main(), executable proj3_oracle_target
//
// Code de sortie : 0 si toutes les paires concordent, 1 sinon. Rien d autre,
// pour qu il soit utilisable tel quel par ctest ou par un script.
#include "oracle.hpp"
#include "proj3/mem/system.hpp"
#include "proj3/sys/panic.hpp"
using namespace proj3;
static int oracle_entry() {
err_write("=== harnais d oracle proj3 ===\n");
static mem::System sys;
if (!mem::system_init(sys)) {
err_write("impossible d acquerir la memoire de travail\n");
return 1;
}
oracle::g_system = &sys;
mem::log_active_mode();
err_write("\n");
oracle::Report rep;
const bool ok = oracle::run_all(sys.scratch, rep);
err_write("\npaires comparees : ");
err_write_i64(rep.pairs_run);
err_write("\npaires en reference seule : ");
err_write_i64(rep.pairs_ref_only);
err_write("\ncas executes : ");
err_write_i64(rep.cases_run);
err_write("\ncas en echec : ");
err_write_i64(rep.cases_failed);
err_write(ok ? "\nRESULTAT : concordance totale\n" : "\nRESULTAT : DIVERGENCE\n");
// Pic d occupation du scratch : verifie que le dimensionnement de
// mem/layout.hpp tient, y compris sous le harnais.
err_write("pic scratch : ");
err_write_i64(static_cast<i64>(sys.scratch.peak()));
err_write(" / ");
err_write_i64(static_cast<i64>(sys.scratch.capacity()));
err_write("\n");
return ok ? 0 : 1;
}
#if PROJ3_EMBEDDED
extern "C" int proj3_main(int, char**) { return oracle_entry(); }
#else
int main() { return oracle_entry(); }
#endif
+243
Voir le fichier
@@ -0,0 +1,243 @@
#include "oracle.hpp"
#include "proj3/base/fmt.hpp"
#include "proj3/base/mem.hpp"
#include "proj3/sys/panic.hpp"
namespace proj3::oracle {
mem::System* g_system = nullptr;
namespace {
// Octet de garde ecrit apres chaque tampon de sortie. Toute routine qui ecrit
// un octet de trop l ecrase, et le harnais le voit. C est ce qui transforme
// le cas "debordement d un octet" en detection, au lieu d une corruption
// silencieuse d une zone voisine.
constexpr u8 kGuardByte = 0xA5;
constexpr usize kGuardBytes = 32;
// Motif deterministe, pour les cas de graine 0. Volontairement non trivial
// (ni tout a zero ni croissant) pour qu une routine qui ignore son entree ne
// passe pas par chance.
void fill_deterministic(u8* p, usize n) {
for (usize i = 0; i < n; ++i) {
p[i] = static_cast<u8>((i * 31u + (i >> 3) * 17u + 0x5Bu) & 0xFFu);
}
}
void fill_random(u8* p, usize n, u64 seed) {
Rng rng(seed);
usize i = 0;
while (i < n) {
u64 v = rng.next();
for (int b = 0; b < 8 && i < n; ++b, ++i) {
p[i] = static_cast<u8>(v & 0xFFu);
v >>= 8;
}
}
}
void dump_hex(const u8* p, usize n) {
char buf[3];
for (usize i = 0; i < n; ++i) {
const usize k = fmt_hex_u8(buf, sizeof(buf), p[i]);
err_write_bytes(buf, k);
buf[0] = ' ';
err_write_bytes(buf, 1);
}
}
// Contexte autour de l offset divergent : 16 octets avant, 16 apres, bornes au
// tampon. Sans contexte, un offset seul ne dit pas si l erreur est un decalage
// ou une valeur fausse.
void dump_context(const char* tag, const u8* p, usize len, usize center) {
const usize begin = center >= 16 ? center - 16 : 0;
usize end = center + 17;
if (end > len) end = len;
err_write(" ");
err_write(tag);
err_write(" [");
err_write_i64(static_cast<i64>(begin));
err_write("..");
err_write_i64(static_cast<i64>(end));
err_write(") : ");
dump_hex(p + begin, end - begin);
err_write("\n");
}
bool guards_intact(const u8* guard) {
for (usize i = 0; i < kGuardBytes; ++i) {
if (guard[i] != kGuardByte) return false;
}
return true;
}
// --- Enregistrement --------------------------------------------------------
#if PROJ3_EMBEDDED
// Symboles synthetises par l editeur de liens pour la section proj3_pairs.
extern "C" const Pair* const __start_proj3_pairs[];
extern "C" const Pair* const __stop_proj3_pairs[];
#else
// Stockage statique a initialisation constante : il est pret AVANT que le
// moindre constructeur statique ne tourne, donc l ordre d initialisation ne
// peut pas nous mordre.
constexpr usize kMaxPairs = 64;
const Pair* g_pairs[kMaxPairs];
usize g_pair_count;
#endif
} // namespace
void register_pair(const Pair* p) {
#if PROJ3_EMBEDDED
(void)p; // l enregistrement se fait par la section, pas par appel
#else
if (g_pair_count >= kMaxPairs) panic("oracle : trop de paires enregistrees");
g_pairs[g_pair_count++] = p;
#endif
}
bool run_pair(const Pair& p, mem::Arena& work, Report& out, bool expect_failure) {
bool pair_ok = true;
if (p.opt == nullptr) {
++out.pairs_ref_only;
} else {
++out.pairs_run;
}
for (usize ci = 0; ci < p.case_count; ++ci) {
const CaseSpec& c = p.cases[ci];
const usize mark = work.mark();
// Tampons : chacun precede de son decalage d alignement et suivi d une
// zone de garde. La base de l arene est alignee sur 2 Mo, donc un
// decalage de k octets donne une adresse ≡ k modulo 16 : c est
// exactement le levier dont les chemins NEON auront besoin.
u8* in_raw = work.alloc_array<u8>(c.in_len + 64);
u8* in = in_raw + c.in_align_offset;
const usize out_cap = c.in_len;
u8* ref_raw = work.alloc_array<u8>(out_cap + 64 + kGuardBytes);
u8* ref_out = ref_raw + c.out_align_offset;
u8* ref_guard = ref_out + out_cap;
u8* opt_raw = work.alloc_array<u8>(out_cap + 64 + kGuardBytes);
u8* opt_out = opt_raw + c.out_align_offset;
u8* opt_guard = opt_out + out_cap;
if (c.seed == 0) {
fill_deterministic(in, c.in_len);
} else {
fill_random(in, c.in_len, c.seed);
}
mem_fill(ref_out, 0, out_cap);
mem_fill(opt_out, 0, out_cap);
mem_fill(ref_guard, kGuardByte, kGuardBytes);
mem_fill(opt_guard, kGuardByte, kGuardBytes);
const usize ref_len = p.ref(in, c.in_len, ref_out, out_cap);
++out.cases_run;
bool case_ok = true;
const char* reason = nullptr;
usize diff_at = 0;
if (!guards_intact(ref_guard)) {
case_ok = false;
reason = "la REFERENCE a deborde son tampon de sortie";
}
if (case_ok && p.opt != nullptr) {
const usize opt_len = p.opt(in, c.in_len, opt_out, out_cap);
if (!guards_intact(opt_guard)) {
case_ok = false;
reason = "l implementation optimisee a deborde son tampon";
} else if (opt_len != ref_len) {
case_ok = false;
reason = "longueur de sortie differente";
} else {
diff_at = mem_first_diff(ref_out, opt_out, ref_len);
if (diff_at != ref_len) {
case_ok = false;
reason = "octet divergent";
}
}
if (!case_ok) {
err_write("ECHEC ");
err_write(p.name);
err_write(" / ");
err_write(c.label);
err_write("\n ");
err_write(reason);
err_write("\n");
err_write(" rejouer ce cas : graine=");
err_write_i64(static_cast<i64>(c.seed));
err_write(" in_len=");
err_write_i64(static_cast<i64>(c.in_len));
err_write(" align_in=+");
err_write_i64(c.in_align_offset);
err_write(" align_out=+");
err_write_i64(c.out_align_offset);
err_write("\n");
err_write(" longueurs : reference=");
err_write_i64(static_cast<i64>(ref_len));
err_write(" optimisee=");
err_write_i64(static_cast<i64>(opt_len));
err_write("\n");
if (diff_at < ref_len) {
err_write(" premier octet divergent a l offset ");
err_write_i64(static_cast<i64>(diff_at));
err_write(" : attendu=");
err_write_hex(ref_out[diff_at]);
err_write(" obtenu=");
err_write_hex(opt_out[diff_at]);
err_write("\n");
dump_context("attendu", ref_out, ref_len, diff_at);
dump_context("obtenu ", opt_out, opt_len, diff_at);
}
}
}
if (!case_ok) {
++out.cases_failed;
pair_ok = false;
}
work.rewind_to(mark);
}
if (pair_ok) {
err_write(p.opt == nullptr ? "REF " : "OK ");
err_write(p.name);
if (p.opt == nullptr) {
err_write(" (reference figee, version assembleur absente)");
}
err_write("\n");
}
// Un self-test attend un echec : dans ce cas, "reussi" veut dire "a bien
// echoue". Sans cette inversion, on ne saurait pas prouver que le harnais
// sait detecter une erreur connue.
return expect_failure ? !pair_ok : pair_ok;
}
bool run_all(mem::Arena& work, Report& out) {
bool ok = true;
#if PROJ3_EMBEDDED
for (const Pair* const* it = __start_proj3_pairs; it != __stop_proj3_pairs; ++it) {
if (!run_pair(**it, work, out, false)) ok = false;
}
#else
for (usize i = 0; i < g_pair_count; ++i) {
if (!run_pair(*g_pairs[i], work, out, false)) ok = false;
}
#endif
return ok;
}
} // namespace proj3::oracle
+134
Voir le fichier
@@ -0,0 +1,134 @@
// test/oracle/oracle.hpp — harnais de validation croisee C++ / assembleur.
//
// METHODE (doc/methode-oracle.md) :
// Toute routine critique existe en deux exemplaires : une reference C++ qui
// marche, et une version assembleur qui va vite. Le harnais les execute sur
// les MEMES entrees et compare les sorties OCTET PAR OCTET. Pas d epsilon,
// pas de tolerance. La reference C++ n est jamais supprimee.
//
// AJOUTER UNE PAIRE : ecrire deux fonctions de signature RunFn, un tableau de
// CaseSpec, et une ligne PROJ3_ORACLE_PAIR. Aucun fichier du harnais n est a
// modifier. C est la condition pour qu il serve encore dans six mois.
#pragma once
#include "proj3/base/types.hpp"
#include "proj3/mem/arena.hpp"
#include "proj3/mem/system.hpp"
namespace proj3::oracle {
// Arenes du programme, publiees pour que les paires puissent s en servir sans
// que la signature RunFn ait a les transporter. Positionne par le point
// d entree avant run_all(). Une paire qui l utilise doit rembobiner ce qu elle
// prend (mark/rewind_to) : le harnais ne le fait que pour SES tampons.
extern mem::System* g_system;
// Signature unique de toute routine testable.
// in / in_len : entree en lecture seule
// out / out_cap : sortie, deja remise a zero par le harnais
// retour : nombre d octets ecrits (compare lui aussi)
//
// Tout passe par des octets. Une routine qui manipule des structures les
// reinterprete depuis `in` : c est volontairement fruste, parce que c est ce
// qui permet a UN harnais de comparer n importe quelle paire sans savoir de
// quoi elle parle.
using RunFn = usize (*)(const u8* in, usize in_len, u8* out, usize out_cap);
struct CaseSpec {
const char* label;
usize in_len;
// Graine du generateur pseudo-aleatoire. 0 = cas deterministe explicite :
// l entree est remplie par un motif fixe (voir fill_deterministic).
u64 seed;
// Decalage applique a la base des tampons, en octets, pour forcer un
// desalignement. Les routines NEON auront des chemins differents selon
// l alignement : il faut pouvoir tester les deux.
u8 in_align_offset;
u8 out_align_offset;
};
struct Pair {
const char* name;
RunFn ref;
// nullptr autorise : la paire existe, la version assembleur n est pas
// encore ecrite. Le harnais execute alors la reference seule (pour
// verifier qu elle ne plante ni n alloue) et signale la paire comme
// "reference figee, asm absent". C est ce qui permet d enregistrer une
// routine AVANT d avoir son asm, comme demande au chantier 5.
RunFn opt;
const CaseSpec* cases;
usize case_count;
};
// --- Enregistrement --------------------------------------------------------
//
// Deux mecanismes, un par cible, derriere la meme macro :
//
// Cible embarquee : les pointeurs de paires sont places dans une section ELF
// nommee `proj3_pairs`. L editeur de liens synthetise automatiquement
// __start_proj3_pairs / __stop_proj3_pairs pour toute section dont le nom
// est un identifiant C valide. AUCUN constructeur statique n est
// necessaire — c est indispensable ici, puisque asm/start.S ne parcourt
// pas .init_array (cf. ADR-0001).
//
// Cible hote : le format PE de MinGW ne synthetise pas ces symboles. On
// retombe sur un constructeur statique qui chaine la paire dans une liste.
// L hote, lui, a un vrai demarrage C++ : c est sans risque.
//
// L asymetrie est laide mais elle est confinee a ces vingt lignes, et elle
// evite d imposer un enregistrement manuel qui, lui, serait oublie.
void register_pair(const Pair* p);
struct Registrar {
explicit Registrar(const Pair* p) { register_pair(p); }
};
#if PROJ3_EMBEDDED
#define PROJ3_ORACLE_PAIR(ident, name_str, ref_fn, opt_fn, cases_arr) \
static const ::proj3::oracle::Pair ident##_pair = { \
name_str, ref_fn, opt_fn, cases_arr, \
sizeof(cases_arr) / sizeof(cases_arr[0])}; \
__attribute__((used, section("proj3_pairs"))) static const ::proj3::oracle::Pair* \
const ident##_slot = &ident##_pair
#else
#define PROJ3_ORACLE_PAIR(ident, name_str, ref_fn, opt_fn, cases_arr) \
static const ::proj3::oracle::Pair ident##_pair = { \
name_str, ref_fn, opt_fn, cases_arr, \
sizeof(cases_arr) / sizeof(cases_arr[0])}; \
static const ::proj3::oracle::Registrar ident##_slot(&ident##_pair)
#endif
// --- Execution -------------------------------------------------------------
struct Report {
u32 pairs_run = 0;
u32 pairs_ref_only = 0;
u32 cases_run = 0;
u32 cases_failed = 0;
};
// Execute toutes les paires enregistrees. `work` fournit les tampons.
// Rend true si aucune divergence.
bool run_all(mem::Arena& work, Report& out);
// Execute UNE paire donnee, sans passer par l enregistrement. Sert au
// self-test du harnais (prouver qu il rejette une implementation fausse).
bool run_pair(const Pair& p, mem::Arena& work, Report& out, bool expect_failure);
// Generateur pseudo-aleatoire reproductible : xorshift64*.
// Choisi parce qu il tient en quatre lignes, n a aucun etat cache, et donne
// exactement la meme suite sur AArch64 et sur x86-64 (arithmetique entiere
// 64 bits non signee uniquement, aucun flottant).
struct Rng {
u64 state;
explicit constexpr Rng(u64 seed) : state(seed == 0 ? 0x9E3779B97F4A7C15ull : seed) {}
u64 next() {
state ^= state >> 12;
state ^= state << 25;
state ^= state >> 27;
return state * 0x2545F4914F6CDD1Dull;
}
};
} // namespace proj3::oracle
+69
Voir le fichier
@@ -0,0 +1,69 @@
// test/oracle/pairs_demo.cpp — paire de demonstration du harnais.
//
// Elle sert a deux choses et rien d autre :
// 1. montrer a quoi ressemble l ajout d une paire (trois declarations, une
// macro, aucun fichier du harnais touche) ;
// 2. donner au self-test une erreur CONNUE a detecter.
#include "oracle.hpp"
extern "C" {
proj3::usize proj3_fill_bytes_asm(const proj3::u8* in, proj3::usize in_len,
proj3::u8* out, proj3::usize out_cap);
proj3::usize proj3_fill_bytes_asm_broken(const proj3::u8* in, proj3::usize in_len,
proj3::u8* out, proj3::usize out_cap);
}
namespace proj3::oracle {
// Version de reference C++. Elle est la definition de ce qui est correct.
// Elle n est JAMAIS supprimee, meme quand l assembleur est valide.
usize fill_bytes_ref(const u8* in, usize in_len, u8* out, usize out_cap) {
if (in_len == 0) return 0;
const u8 value = in[0];
for (usize i = 0; i < out_cap; ++i) out[i] = value;
return out_cap;
}
// Jeu de cas. Les explicites d abord, les aleatoires ensuite.
//
// Ce qui est couvert et pourquoi :
// - taille nulle : le cas ou une boucle mal ecrite ecrit quand meme
// - 1 octet : pas de corps de boucle vectorisable
// - 15 / 16 / 17 : juste sous, sur, et juste au-dessus d une ligne
// NEON de 128 bits
// - 63 / 64 / 65 : idem pour une ligne de cache
// - desalignements +1 +7 +9 : entree et sortie desalignees separement, puis
// ensemble, parce qu un chemin NEON qui n aligne
// qu un cote existe et est faux
// - tailles aleatoires : ce a quoi on n a pas pense
const CaseSpec kFillCases[] = {
{"vide", 0, 0, 0, 0},
{"un octet", 1, 0, 0, 0},
{"15 (sous 128 bits)", 15, 0, 0, 0},
{"16 (128 bits pile)", 16, 0, 0, 0},
{"17 (128 bits +1)", 17, 0, 0, 0},
{"63 (sous une ligne)", 63, 0, 0, 0},
{"64 (une ligne pile)", 64, 0, 0, 0},
{"65 (une ligne +1)", 65, 0, 0, 0},
{"256 aligne", 256, 0, 0, 0},
{"256 entree +1", 256, 0, 1, 0},
{"256 sortie +1", 256, 0, 0, 1},
{"256 les deux +7/+9", 256, 0, 7, 9},
{"aleatoire 1021", 1021, 0x1234'5678'9ABC'DEF0ull, 0, 0},
{"aleatoire 1021 +3/+5", 1021, 0x0F0F'0F0F'0F0F'0F0Full, 3, 5},
{"aleatoire 4096", 4096, 0xDEAD'BEEF'CAFE'BABEull, 0, 0},
};
// --- L ajout d une paire tient en une ligne -------------------------------
PROJ3_ORACLE_PAIR(fill_bytes, "fill_bytes", &fill_bytes_ref, &proj3_fill_bytes_asm,
kFillCases);
// La paire fausse n est PAS enregistree ici : elle ne doit pas faire echouer
// la suite normale. Le self-test la construit a la main.
extern const Pair kBrokenPair;
const Pair kBrokenPair = {"fill_bytes (VERSION FAUSSE)", &fill_bytes_ref,
&proj3_fill_bytes_asm_broken, kFillCases,
sizeof(kFillCases) / sizeof(kFillCases[0])};
} // namespace proj3::oracle
+197
Voir le fichier
@@ -0,0 +1,197 @@
// test/oracle/pairs_render.cpp — enregistrement des routines du pipeline de
// rendu comme REFERENCES FIGEES.
//
// Aucune version assembleur n existe encore (chantier 5 : « Pas de version
// assembleur du rasterizer dans cette passe »). C est precisement pour cela
// que ces paires sont enregistrees maintenant, avec opt = nullptr :
//
// - le harnais execute la reference sur tous les cas, ce qui verifie qu elle
// ne plante pas, ne deborde pas son tampon, et n alloue rien (le garde-fou
// du chantier 3 est lie a cet executable) ;
// - le jour ou la version NEON arrive, il n y a qu un pointeur a remplir.
// Personne n a a se demander comment brancher le test : il est deja la.
//
// Enregistrer une routine AVANT d avoir son assembleur est la seule facon
// d etre sur que le harnais sera utilise. Construit apres coup, il ne l est
// jamais.
#include "oracle.hpp"
#include "proj3/render/compose.hpp"
#include "proj3/render/rasterizer.hpp"
namespace proj3::oracle {
namespace {
// --- Glyphe synthetique ----------------------------------------------------
// Le harnais ne doit dependre d aucun fichier : il doit tourner sur la machine
// de dev, sur un Raspberry Pi, dans un conteneur, sans police installee. On
// fabrique donc un glyphe a partir des octets d entree.
//
// Forme : un rectangle exterieur (sens horaire) et un rectangle interieur
// (sens anti-horaire), plus un arc quadratique. C est le minimum qui exerce
// vraiment le nonzero winding : si la regle etait mal portee, le rectangle
// interieur ne serait pas creuse et la difference sauterait aux yeux.
constexpr u32 kSynthPointCount = 12;
constexpr u32 kSynthContourCount = 2;
struct SynthGlyph {
font::GlyphPoint points[kSynthPointCount];
u32 contour_end[kSynthContourCount];
font::Glyph glyph;
};
void build_synth(SynthGlyph& g, const u8* in, usize in_len) {
// Deux octets d entree pilotent la geometrie. Bornes pour rester dans des
// valeurs de police plausibles et pour que le glyphe ne soit jamais vide.
const f32 w = 200.0f + static_cast<f32>(in_len > 0 ? in[0] : 0u) * 2.0f;
const f32 h = 300.0f + static_cast<f32>(in_len > 1 ? in[1] : 0u) * 2.0f;
const f32 inset = 40.0f + static_cast<f32>(in_len > 2 ? (in[2] & 0x3Fu) : 0u);
auto P = [](f32 x, f32 y, bool on) {
font::GlyphPoint p;
p.x = x;
p.y = y;
p.on_curve = on;
return p;
};
// Contour exterieur : rectangle avec un cote superieur bombe (un point de
// controle off-curve), 6 points.
g.points[0] = P(0.0f, 0.0f, true);
g.points[1] = P(w, 0.0f, true);
g.points[2] = P(w, h, true);
g.points[3] = P(w * 0.5f, h + 80.0f, false); // controle quadratique
g.points[4] = P(0.0f, h, true);
g.points[5] = P(0.0f, h * 0.5f, true);
g.contour_end[0] = 6;
// Contour interieur, oriente en sens inverse : c est lui que le nonzero
// doit creuser. 6 points aussi, pour garder un tableau simple.
const f32 x0 = inset, x1 = w - inset;
const f32 y0 = inset, y1 = h - inset;
g.points[6] = P(x0, y0, true);
g.points[7] = P(x0, y1, true);
g.points[8] = P((x0 + x1) * 0.5f, y1 + 20.0f, false);
g.points[9] = P(x1, y1, true);
g.points[10] = P(x1, y0, true);
g.points[11] = P((x0 + x1) * 0.5f, y0 - 20.0f, false);
g.contour_end[1] = 12;
g.glyph = font::Glyph{};
g.glyph.points = g.points;
g.glyph.contour_end = g.contour_end;
g.glyph.point_count = kSynthPointCount;
g.glyph.contour_count = kSynthContourCount;
g.glyph.advance_width = w + 100.0f;
}
// --- Paire 1 : rasterization ----------------------------------------------
usize rasterize_ref(const u8* in, usize in_len, u8* out, usize out_cap) {
if (g_system == nullptr) return 0;
SynthGlyph g;
build_synth(g, in, in_len);
// Taille en pixels pilotee par l entree, bornee a des corps realistes.
const f32 px = 8.0f + static_cast<f32>(in_len > 3 ? (in[3] & 0x3Fu) : 16u);
mem::Arena& scratch = g_system->geometry;
mem::Arena& store = g_system->atlas;
const usize m_scratch = scratch.mark();
const usize m_store = store.mark();
render::RasterizedGlyph rg;
const bool ok = render::rasterize_glyph(g.glyph, 1000, px, store, scratch, rg);
usize written = 0;
if (ok) {
// On publie la couverture brute, plus les trois metriques en tete :
// une divergence de bearing ou d avance doit etre detectee au meme
// titre qu une divergence de pixel.
const i32 meta[3] = {rg.bearing_x, rg.bearing_y, rg.advance};
const u8* meta_bytes = reinterpret_cast<const u8*>(meta);
for (usize i = 0; i < sizeof(meta) && written < out_cap; ++i) {
out[written++] = meta_bytes[i];
}
const usize n = rg.coverage.size_bytes();
for (usize i = 0; i < n && written < out_cap; ++i) {
out[written++] = rg.coverage.pixels[i];
}
}
store.rewind_to(m_store);
scratch.rewind_to(m_scratch);
return written;
}
// Les tailles sont choisies pour que la couverture depasse largement out_cap
// dans les petits cas (on ne compare alors que le prefixe) et la remplisse
// dans les grands.
const CaseSpec kRasterCases[] = {
{"entree vide", 0, 0, 0, 0},
{"4 octets", 4, 0, 0, 0},
{"64 octets", 64, 0, 0, 0},
{"4 Ko", 4096, 0, 0, 0},
{"4 Ko desaligne +1/+3", 4096, 0, 1, 3},
{"aleatoire 4 Ko", 4096, 0xA5A5'5A5A'0F0F'F0F0ull, 0, 0},
{"aleatoire 16 Ko", 16384, 0x0123'4567'89AB'CDEFull, 0, 0},
};
PROJ3_ORACLE_PAIR(raster_glyph, "render::rasterize_glyph (glyphe synthetique)",
&rasterize_ref, nullptr, kRasterCases);
// --- Paire 2 : composition -------------------------------------------------
// Separee de la rasterization, comme le code l est : c est cette routine-la
// qui deviendra un noyau NEON en premier.
usize compose_ref(const u8* in, usize in_len, u8* out, usize out_cap) {
if (g_system == nullptr || out_cap < 16) return 0;
// Framebuffer minuscule ecrit directement dans `out` : on compare donc
// exactement les octets que la routine produit, sans recopie.
const i32 fw = 32;
const i32 fh = static_cast<i32>(out_cap / (4u * 32u));
if (fh <= 0) return 0;
render::Framebuffer fb;
fb.pixels = reinterpret_cast<u32*>(out);
fb.width = fw;
fb.height = fh;
// out est aligne par le harnais selon out_align_offset ; compose_coverage
// exige 4 octets. On refuse proprement si l alignement ne convient pas,
// plutot que de paniquer : ce cas fait partie de ce qu on veut tester.
if ((reinterpret_cast<uptr>(out) & 3u) != 0) return 0;
render::framebuffer_clear(fb, 0xFF000000u);
mem::Arena& store = g_system->atlas;
const usize m = store.mark();
render::Coverage8 cov = render::coverage_alloc(store, 16, 16);
for (usize i = 0; i < cov.size_bytes(); ++i) {
cov.pixels[i] = (i < in_len && (in[i] & 1u) != 0) ? 255 : 0;
}
// Trois positions : entierement dedans, a cheval sur le bord droit, a
// cheval sur le coin haut-gauche (coordonnees negatives).
render::compose_coverage(fb, 2, 2, cov, 0xFFFFFFFFu);
render::compose_coverage(fb, fw - 8, 4, cov, 0xFF00FF00u);
render::compose_coverage(fb, -6, -6, cov, 0xFFFF0000u);
store.rewind_to(m);
return static_cast<usize>(fw) * static_cast<usize>(fh) * 4u;
}
const CaseSpec kComposeCases[] = {
{"1 ligne", 128, 0, 0, 0},
{"8 lignes", 1024, 0, 0, 0},
{"32 lignes", 4096, 0, 0, 0},
{"32 lignes aleatoire", 4096, 0xFEED'FACE'DEAD'C0DEull, 0, 0},
};
PROJ3_ORACLE_PAIR(compose_cov, "render::compose_coverage", &compose_ref, nullptr,
kComposeCases);
} // namespace
} // namespace proj3::oracle
+76
Voir le fichier
@@ -0,0 +1,76 @@
// test/oracle/selftest_main.cpp — VALIDATION DU HARNAIS LUI-MEME.
//
// « Un harnais qui ne sait pas detecter une erreur connue ne vaut rien. »
//
// Ce programme fait deux passes :
// 1. la paire correcte doit etre ACCEPTEE ;
// 2. la paire volontairement fausse (un octet de decalage) doit etre
// REJETEE, avec un diagnostic exploitable affiche a l ecran.
//
// Il rend 0 seulement si les deux attentes sont satisfaites. Un harnais qui
// accepterait la version fausse ferait echouer ce test, ce qui est le but.
//
// Ce binaire NE LIE PAS proj3_newguard : il doit afficher son diagnostic
// jusqu au bout, et l on ne veut pas qu une allocation de la libc dans printf
// vienne brouiller le resultat du test qui nous interesse ici.
#include "oracle.hpp"
#include "proj3/mem/system.hpp"
#include "proj3/sys/panic.hpp"
using namespace proj3;
namespace proj3::oracle {
usize fill_bytes_ref(const u8* in, usize in_len, u8* out, usize out_cap);
extern const Pair kBrokenPair;
} // namespace proj3::oracle
extern "C" {
proj3::usize proj3_fill_bytes_asm(const proj3::u8*, proj3::usize, proj3::u8*, proj3::usize);
}
int main() {
err_write("=== self-test du harnais d oracle ===\n\n");
static mem::System sys;
if (!mem::system_init(sys)) {
err_write("impossible d acquerir la memoire de travail\n");
return 1;
}
// --- Passe 1 : la version correcte doit passer -------------------------
err_write("passe 1 : la version assembleur CORRECTE doit etre acceptee\n");
const oracle::Pair good = {"fill_bytes (version correcte)", &oracle::fill_bytes_ref,
&proj3_fill_bytes_asm, oracle::kBrokenPair.cases,
oracle::kBrokenPair.case_count};
oracle::Report rep_good;
const bool good_ok = oracle::run_pair(good, sys.scratch, rep_good, /*expect_failure=*/false);
err_write(good_ok ? " -> acceptee, comme attendu\n\n"
: " -> REJETEE ALORS QU ELLE EST CORRECTE (harnais casse)\n\n");
// --- Passe 2 : la version fausse doit etre rejetee ---------------------
err_write("passe 2 : la version assembleur FAUSSE doit etre rejetee\n");
err_write(" (defaut injecte : un octet de moins ecrit, longueur rendue correcte)\n");
err_write(" le diagnostic ci-dessous est celui que le harnais produirait\n");
err_write(" sur un vrai bug ; c est lui qu on evalue :\n\n");
oracle::Report rep_bad;
const bool bad_ok =
oracle::run_pair(oracle::kBrokenPair, sys.scratch, rep_bad, /*expect_failure=*/true);
err_write("\n");
err_write(bad_ok ? " -> rejetee, comme attendu\n"
: " -> ACCEPTEE ALORS QU ELLE EST FAUSSE (harnais inutile)\n");
err_write(" cas en echec detectes : ");
err_write_i64(rep_bad.cases_failed);
err_write(" / ");
err_write_i64(rep_bad.cases_run);
err_write("\n");
err_write(" (les cas de longueur nulle ne peuvent pas diverger : c est normal\n");
err_write(" qu ils ne comptent pas dans les echecs)\n");
const bool ok = good_ok && bad_ok;
err_write(ok ? "\nRESULTAT : le harnais discrimine correctement\n"
: "\nRESULTAT : LE HARNAIS EST DEFAILLANT\n");
return ok ? 0 : 1;
}
+122
Voir le fichier
@@ -0,0 +1,122 @@
// test/test_arena.cpp — arenes et acquisition de pages (chantier 3).
//
// S execute sur la machine de dev. Il ne teste PAS le repli huge pages, qui
// demande un vrai noyau Linux : sur l hote, page_acquire rend toujours
// HostEmulated. Ce que ce test verifie, c est la logique d arene elle-meme,
// qui est du code portable partage a l identique par les deux cibles.
#include "proj3/mem/layout.hpp"
#include "proj3/mem/system.hpp"
#include "proj3/sys/panic.hpp"
using namespace proj3;
namespace {
int g_failures = 0;
void check(bool cond, const char* what) {
err_write(cond ? "OK " : "ECHEC ");
err_write(what);
err_write("\n");
if (!cond) ++g_failures;
}
} // namespace
int main() {
err_write("=== arenes ===\n\n");
static mem::System sys;
check(mem::system_init(sys), "system_init");
mem::log_active_mode();
err_write("\n");
check(sys.scanout.capacity() == mem::kScanoutBytes, "taille de l arene scanout");
check(sys.scanout.used() == 0, "arene neuve : occupation nulle");
// --- Alignement ---------------------------------------------------------
{
mem::Arena& a = sys.scratch;
a.reset();
(void)a.alloc(1, 1); // desaligne volontairement la suite
void* p16 = a.alloc(8, 16);
void* p64 = a.alloc(8, 64);
check((reinterpret_cast<uptr>(p16) & 15u) == 0, "alignement 16 respecte");
check((reinterpret_cast<uptr>(p64) & 63u) == 0, "alignement 64 respecte");
}
// --- Avance de pointeur -------------------------------------------------
{
mem::Arena& a = sys.scratch;
a.reset();
u8* x = a.alloc_array<u8>(100);
u8* y = a.alloc_array<u8>(100);
check(y == x + 100, "allocations contigues sans alignement force");
check(a.used() == 200, "occupation exacte");
}
// --- mark / rewind ------------------------------------------------------
{
mem::Arena& a = sys.scratch;
a.reset();
(void)a.alloc_array<u8>(500);
const usize m = a.mark();
(void)a.alloc_array<u8>(1000);
check(a.used() == 1500, "occupation apres deux allocations");
a.rewind_to(m);
check(a.used() == 500, "rewind_to restitue la position");
}
// --- reset --------------------------------------------------------------
{
mem::Arena& a = sys.scratch;
(void)a.alloc_array<u8>(1000);
const usize peak_before = a.peak();
a.reset();
check(a.used() == 0, "reset remet l occupation a zero");
check(a.peak() == peak_before, "reset ne remet PAS le pic a zero");
}
// --- Borne : try_alloc rend nullptr au lieu de paniquer -----------------
// On ne peut pas tester alloc() directement : par conception, il tue le
// processus. C est exactement ce que verifie test_new_guard pour operator
// new ; ici on se contente de la variante non fatale.
{
mem::Arena& a = sys.input;
a.reset();
void* p = a.try_alloc(a.capacity() + 1, 1);
check(p == nullptr, "try_alloc au-dela de la capacite rend nullptr");
check(a.used() == 0, "un try_alloc refuse ne consomme rien");
void* q = a.try_alloc(a.capacity(), 1);
check(q != nullptr, "try_alloc de la capacite exacte reussit");
check(a.remaining() == 0, "arene pleine : reste nul");
check(a.try_alloc(1, 1) == nullptr, "arene pleine : un octet de plus est refuse");
}
// --- Debordement arithmetique -------------------------------------------
{
mem::Arena& a = sys.input;
a.reset();
const usize huge = ~static_cast<usize>(0) - 8;
check(a.try_alloc(huge, 16) == nullptr, "taille absurde refusee sans reboucler");
}
// --- Le budget annonce correspond au budget decoupe ---------------------
{
const usize sum = sys.scanout.capacity() + sys.geometry.capacity() +
sys.atlas.capacity() + sys.input.capacity() +
sys.scratch.capacity();
check(sum == mem::kArenaTotalRaw, "somme des arenes == kArenaTotalRaw");
check(sum + mem::kReserveBytes == mem::kArenaTotal, "reserve coherente");
}
err_write("\nbudget total demande au noyau : ");
err_write_i64(static_cast<i64>(mem::kArenaTotal));
err_write(" octets\n");
err_write("echecs : ");
err_write_i64(g_failures);
err_write("\n");
return g_failures == 0 ? 0 : 1;
}
+31
Voir le fichier
@@ -0,0 +1,31 @@
// test/test_new_guard.cpp — declenche VOLONTAIREMENT le garde-fou.
//
// CE TEST DOIT ECHOUER. CMake le declare avec WILL_FAIL TRUE : ctest le
// considere reussi si et seulement si le processus se termine anormalement.
//
// C est la preuve demandee au chantier 3 : le filet de securite du pilier 2
// fonctionne reellement, il n est pas seulement ecrit.
//
// Ce qu on observe quand on le lance a la main :
// proj3: ALLOCATION INTERDITE: operator new taille=64
// Le projet n alloue rien apres l init. Tout passe par une arene ...
// code de sortie 71
#include "proj3/sys/panic.hpp"
using namespace proj3;
// volatile : empeche le compilateur d elider l allocation. Sans cela, un
// -O2 un peu zele supprimerait le new et le test ne prouverait rien.
volatile void* g_sink = nullptr;
int main() {
err_write("=== garde-fou d allocation ===\n");
err_write("Ce programme DOIT se terminer anormalement (code 71).\n");
err_write("S il affiche la derniere ligne, le garde-fou ne marche pas.\n\n");
g_sink = new char[64];
err_write("\nECHEC : l allocation est passee, le garde-fou est inoperant.\n");
return 0;
}
+274
Voir le fichier
@@ -0,0 +1,274 @@
// test/test_raster_golden.cpp — VALIDATION DU PORTAGE DU RASTERIZER.
//
// Compare, octet par octet, la sortie du code porte (proj3) a une reference
// produite par le code d ORIGINE de Gastinel Write (tools/write_reference_dump.cpp).
// Une divergence est un bug de portage, pas une tolerance a accorder.
//
// Ce test tourne sur la machine de dev. Ni telephone, ni affichage.
//
// NOTE SUR LA LECTURE DE FICHIER. Le rasterizer et le parser ne lisent aucun
// fichier : c est l appelant qui fournit un tampon en memoire. C est le
// decouplage demande au chantier 5 (l original appelait fopen depuis
// TtfFont::load_from_file). Ici, l appelant est ce test, sur la cible hote,
// et il utilise donc stdio. Sur la cible embarquee, l appelant utilisera
// sys::open / sys::read. Aucune des deux voies ne traverse le rasterizer.
//
// Ce binaire lie proj3_newguard : si le portage avait laisse une allocation
// dynamique quelque part, il mourrait ici avec le code 71.
#include <cstdio>
#include "proj3/font/ttf.hpp"
#include "proj3/mem/system.hpp"
#include "proj3/render/rasterizer.hpp"
#include "proj3/sys/panic.hpp"
using namespace proj3;
namespace {
int g_failures = 0;
int g_lines = 0;
// Lecture d un fichier entier dans une arene. stdio est autorise ici (cible
// hote) ; fread n alloue pas via operator new, le garde-fou reste satisfait.
u8* read_all(const char* path, mem::Arena& a, usize& out_size) {
std::FILE* f = std::fopen(path, "rb");
if (!f) return nullptr;
std::fseek(f, 0, SEEK_END);
const long n = std::ftell(f);
std::fseek(f, 0, SEEK_SET);
if (n <= 0) {
std::fclose(f);
return nullptr;
}
u8* buf = a.alloc_array<u8>(static_cast<usize>(n) + 1);
const usize got = std::fread(buf, 1, static_cast<usize>(n), f);
std::fclose(f);
if (got != static_cast<usize>(n)) return nullptr;
buf[n] = 0;
out_size = static_cast<usize>(n);
return buf;
}
// --- Analyse lexicale minimale du fichier golden ---------------------------
struct Cursor {
const char* p;
const char* end;
};
void skip_spaces(Cursor& c) {
while (c.p < c.end && (*c.p == ' ' || *c.p == '\t')) ++c.p;
}
bool parse_u32(Cursor& c, u32& out) {
skip_spaces(c);
if (c.p >= c.end || *c.p < '0' || *c.p > '9') return false;
u32 v = 0;
while (c.p < c.end && *c.p >= '0' && *c.p <= '9') v = v * 10u + static_cast<u32>(*c.p++ - '0');
out = v;
return true;
}
bool parse_i32(Cursor& c, i32& out) {
skip_spaces(c);
bool neg = false;
if (c.p < c.end && *c.p == '-') {
neg = true;
++c.p;
}
u32 v = 0;
if (!parse_u32(c, v)) return false;
out = neg ? -static_cast<i32>(v) : static_cast<i32>(v);
return true;
}
// Les tailles sont ecrites par %g et sont toutes entieres dans le jeu de test.
// On accepte quand meme une partie fractionnaire, pour que le format ne se
// referme pas sur une hypothese.
bool parse_f32(Cursor& c, f32& out) {
skip_spaces(c);
i32 whole = 0;
if (!parse_i32(c, whole)) return false;
f32 v = static_cast<f32>(whole);
if (c.p < c.end && *c.p == '.') {
++c.p;
f32 scale = 0.1f;
while (c.p < c.end && *c.p >= '0' && *c.p <= '9') {
v += static_cast<f32>(*c.p++ - '0') * scale;
scale *= 0.1f;
}
}
out = v;
return true;
}
i32 hex_digit(char ch) {
if (ch >= '0' && ch <= '9') return ch - '0';
if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10;
if (ch >= 'A' && ch <= 'F') return ch - 'A' + 10;
return -1;
}
void fail(const char* what, u32 cp, f32 px) {
++g_failures;
err_write("ECHEC ");
err_write(what);
err_write(" codepoint=");
err_write_hex(cp);
err_write(" taille=");
err_write_i64(static_cast<i64>(px));
err_write("\n");
}
} // namespace
int main(int argc, char** argv) {
if (argc < 3) {
err_write("usage: proj3_test_raster <police.ttf> <golden_write.txt>\n");
return 2;
}
static mem::System sys;
if (!mem::system_init(sys)) {
err_write("acquisition memoire impossible\n");
return 2;
}
// Les deux fichiers vivent dans l arene de scanout, qui est la plus grande
// et n a aucun usage a ce stade des chantiers. C est un detournement
// assume et local a ce test.
usize ttf_size = 0, golden_size = 0;
const u8* ttf = read_all(argv[1], sys.scanout, ttf_size);
if (ttf == nullptr) {
err_write("police illisible\n");
return 2;
}
const u8* golden = read_all(argv[2], sys.scanout, golden_size);
if (golden == nullptr) {
err_write("fichier golden illisible : lancer d abord proj3_write_reference\n");
return 2;
}
font::TtfFont f;
const char* err = nullptr;
if (!f.load(ttf, ttf_size, sys.atlas, err)) {
err_write("chargement TTF : ");
err_write(err);
err_write("\n");
return 2;
}
err_write("police chargee : upem=");
err_write_i64(f.units_per_em());
err_write(" glyphes=");
err_write_i64(f.num_glyphs());
err_write(" entrees cmap=");
err_write_i64(f.cmap_size());
err_write("\n\n");
font::GlyphBuilder builder;
builder.init(sys.atlas);
Cursor c{reinterpret_cast<const char*>(golden),
reinterpret_cast<const char*>(golden) + golden_size};
while (c.p < c.end) {
// Une ligne a la fois.
const char* line_end = c.p;
while (line_end < c.end && *line_end != '\n') ++line_end;
Cursor line{c.p, line_end};
c.p = (line_end < c.end) ? line_end + 1 : c.end;
skip_spaces(line);
if (line.p >= line.end || *line.p == '#' || *line.p == '\r') continue;
u32 cp = 0, gid_ref = 0, ok_ref = 0;
f32 px = 0.0f;
i32 w_ref = 0, h_ref = 0, bx_ref = 0, by_ref = 0, adv_ref = 0;
if (!parse_u32(line, cp) || !parse_f32(line, px) || !parse_u32(line, gid_ref) ||
!parse_u32(line, ok_ref) || !parse_i32(line, w_ref) || !parse_i32(line, h_ref) ||
!parse_i32(line, bx_ref) || !parse_i32(line, by_ref) || !parse_i32(line, adv_ref)) {
err_write("ECHEC ligne golden malformee\n");
++g_failures;
continue;
}
skip_spaces(line);
const char* hex = line.p;
usize hex_len = 0;
while (line.p < line.end && hex_digit(*line.p) >= 0) {
++line.p;
++hex_len;
}
++g_lines;
// --- Cote proj3 -----------------------------------------------------
const u16 gid = f.glyph_index_for_codepoint(cp);
if (static_cast<u32>(gid) != gid_ref) {
fail("index de glyphe different (cmap)", cp, px);
continue;
}
font::Glyph g;
f.load_glyph(gid, builder, g);
const usize m_atlas = sys.atlas.mark();
const usize m_geo = sys.geometry.mark();
render::RasterizedGlyph rg;
const bool ok = render::rasterize_glyph(g, f.units_per_em(), px, sys.atlas,
sys.geometry, rg);
if (ok != (ok_ref != 0)) {
fail("rasterize_glyph : succes/echec different", cp, px);
} else if (!ok) {
// Glyphe vide : seule l avance a un sens, et elle doit coincider.
if (rg.advance != adv_ref) fail("avance differente (glyphe vide)", cp, px);
} else {
if (rg.coverage.width != w_ref || rg.coverage.height != h_ref) {
fail("dimensions du bitmap differentes", cp, px);
} else if (rg.bearing_x != bx_ref || rg.bearing_y != by_ref) {
fail("bearing different", cp, px);
} else if (rg.advance != adv_ref) {
fail("avance differente", cp, px);
} else if (hex_len != rg.coverage.size_bytes() * 2) {
fail("longueur de couverture differente", cp, px);
} else {
// Comparaison octet par octet. Aucun epsilon : la couverture
// est binaire, l egalite doit etre exacte.
usize bad = rg.coverage.size_bytes();
for (usize i = 0; i < rg.coverage.size_bytes(); ++i) {
const i32 hi = hex_digit(hex[i * 2]);
const i32 lo = hex_digit(hex[i * 2 + 1]);
const u8 expect = static_cast<u8>((hi << 4) | lo);
if (rg.coverage.pixels[i] != expect) {
bad = i;
break;
}
}
if (bad != rg.coverage.size_bytes()) {
fail("pixel divergent", cp, px);
err_write(" premier octet divergent a l offset ");
err_write_i64(static_cast<i64>(bad));
err_write(" (x=");
err_write_i64(static_cast<i64>(bad % static_cast<usize>(w_ref)));
err_write(" y=");
err_write_i64(static_cast<i64>(bad / static_cast<usize>(w_ref)));
err_write(") attendu=");
err_write_hex(static_cast<u64>((hex_digit(hex[bad * 2]) << 4) |
hex_digit(hex[bad * 2 + 1])));
err_write(" obtenu=");
err_write_hex(rg.coverage.pixels[bad]);
err_write("\n");
}
}
}
sys.geometry.rewind_to(m_geo);
sys.atlas.rewind_to(m_atlas);
}
err_write("\nlignes comparees : ");
err_write_i64(g_lines);
err_write("\nechecs : ");
err_write_i64(g_failures);
err_write("\n");
return g_failures == 0 ? 0 : 1;
}
+263
Voir le fichier
@@ -0,0 +1,263 @@
// test/test_syscalls.cpp — harnais des wrappers d appels systeme (chantier 2).
//
// OU L EXECUTER : n importe quel Linux AArch64. Raspberry Pi sous 64 bits,
// VM ARM, conteneur, ou qemu-user. PAS BESOIN DU TELEPHONE : aucun test ne
// touche au graphique, a l entree, ni au reseau.
//
// qemu-aarch64 ./proj3_test_syscalls # emulation utilisateur
// ./proj3_test_syscalls # natif
//
// Code de sortie : 0 si tout passe, 1 sinon. Chaque ligne dit OK ou ECHEC.
//
// LE CAS D ERREUR EST LE PLUS IMPORTANT. Un wrapper qui rendrait -2 et qu on
// interpreterait comme un descripteur valide donnerait un bug tres loin d ici.
// Chaque appel a donc son cas nominal ET son cas d erreur, et le cas d erreur
// verifie a la fois is_err() ET le code errno exact.
#include "proj3/base/mem.hpp"
#include "proj3/sys/panic.hpp"
#include "proj3/sys/syscalls.hpp"
#include "proj3/sys/uapi.hpp"
using namespace proj3;
namespace {
int g_failures = 0;
void check(bool cond, const char* what) {
err_write(cond ? "OK " : "ECHEC ");
err_write(what);
err_write("\n");
if (!cond) ++g_failures;
}
void check_err(const sys::Result r, i32 expected_errno, const char* what) {
const bool ok = r.is_err() && r.err() == expected_errno;
err_write(ok ? "OK " : "ECHEC ");
err_write(what);
if (!ok) {
err_write(" (attendu -");
err_write_i64(expected_errno);
err_write(", obtenu ");
err_write_i64(r.raw);
err_write(")");
++g_failures;
}
err_write("\n");
}
// Chemin garanti inexistant. On evite /tmp, qui peut etre monte en lecture
// seule ou absent sur un systeme minimal.
const char kMissing[] = "/proj3-ce-fichier-n-existe-pas-42";
const char kSelf[] = "/proc/self/maps";
} // namespace
extern "C" int proj3_main(int, char**) {
err_write("=== wrappers syscall AArch64 ===\n\n");
// --- Verification prealable de la convention elle-meme -----------------
// Si ces trois assertions ne tenaient pas, tous les tests suivants
// seraient sans valeur.
{
constexpr sys::Result ok_zero{0};
constexpr sys::Result ok_big{-4096};
constexpr sys::Result err_min{-1};
constexpr sys::Result err_max{-4095};
static_assert(!ok_zero.is_err());
static_assert(!ok_big.is_err(), "-4096 est HORS de la plage d erreur");
static_assert(err_min.is_err() && err_min.err() == 1);
static_assert(err_max.is_err() && err_max.err() == 4095);
check(true, "plage d erreur [-4095,-1] exacte (verifiee a la compilation)");
}
// --- getpid : nominal seulement (il ne peut pas echouer) ---------------
{
const sys::Result r = sys::getpid();
check(r.is_ok() && r.value() > 0, "getpid nominal");
}
// --- write ------------------------------------------------------------
{
const char msg[] = "";
const sys::Result r = sys::write(sys::FD_STDOUT, msg, 0);
check(r.is_ok() && r.value() == 0, "write nominal (0 octet)");
}
{
const sys::Result r = sys::write(-1, "x", 1);
check_err(r, sys::EBADF, "write cas d erreur (descripteur invalide -> EBADF)");
}
// --- open --------------------------------------------------------------
// LE test qui compte : un open sur un fichier absent doit remonter une
// erreur, pas un descripteur.
{
const sys::Result r = sys::open(kMissing, sys::O_RDONLY);
check_err(r, sys::ENOENT, "open cas d erreur (fichier absent -> ENOENT)");
// Verification supplementaire, explicite : la valeur ne doit surtout
// pas etre utilisable comme descripteur.
check(r.is_err(), "open absent : is_err() vaut bien true");
}
i32 fd = -1;
{
const sys::Result r = sys::open(kSelf, sys::O_RDONLY);
check(r.is_ok() && r.fd() >= 0, "open nominal (/proc/self/maps)");
if (r.is_ok()) fd = r.fd();
}
// --- read --------------------------------------------------------------
{
u8 buf[64];
mem_fill(buf, 0, sizeof(buf));
if (fd >= 0) {
const sys::Result r = sys::read(fd, buf, sizeof(buf));
check(r.is_ok() && r.value() > 0, "read nominal");
} else {
check(false, "read nominal (open prealable a echoue)");
}
const sys::Result r2 = sys::read(-1, buf, sizeof(buf));
check_err(r2, sys::EBADF, "read cas d erreur (descripteur invalide -> EBADF)");
}
// --- lseek -------------------------------------------------------------
{
if (fd >= 0) {
const sys::Result r = sys::lseek(fd, 0, sys::SEEK_SET);
check(r.is_ok() && r.value() == 0, "lseek nominal (retour au debut)");
} else {
check(false, "lseek nominal (open prealable a echoue)");
}
const sys::Result r2 = sys::lseek(-1, 0, sys::SEEK_SET);
check_err(r2, sys::EBADF, "lseek cas d erreur (descripteur invalide -> EBADF)");
}
// --- fstat -------------------------------------------------------------
{
sys::Stat st;
mem_fill(&st, 0, sizeof(st));
if (fd >= 0) {
const sys::Result r = sys::fstat(fd, &st);
// /proc/self/maps a une taille declaree nulle : on verifie le mode,
// pas la taille. S_IFREG = 0100000 octal.
check(r.is_ok() && (st.mode & 0170000u) == 0100000u,
"fstat nominal (mode de fichier regulier)");
} else {
check(false, "fstat nominal (open prealable a echoue)");
}
const sys::Result r2 = sys::fstat(-1, &st);
check_err(r2, sys::EBADF, "fstat cas d erreur (descripteur invalide -> EBADF)");
}
// --- ioctl -------------------------------------------------------------
// Aucun ioctl graphique dans cette passe. On se contente de verifier que
// le wrapper transmet bien et que l erreur remonte : un ioctl inconnu sur
// un fichier regulier donne ENOTTY.
{
if (fd >= 0) {
const sys::Result r = sys::ioctl(fd, 0xDEADu);
check(r.is_err() && (r.err() == sys::ENOTTY || r.err() == sys::EINVAL),
"ioctl cas d erreur (requete inconnue -> ENOTTY/EINVAL)");
} else {
check(false, "ioctl cas d erreur (open prealable a echoue)");
}
const sys::Result r2 = sys::ioctl(-1, 0x1234u);
check_err(r2, sys::EBADF, "ioctl descripteur invalide -> EBADF");
}
// --- close -------------------------------------------------------------
{
if (fd >= 0) {
const sys::Result r = sys::close(fd);
check(r.is_ok(), "close nominal");
} else {
check(false, "close nominal (open prealable a echoue)");
}
const sys::Result r2 = sys::close(-1);
check_err(r2, sys::EBADF, "close cas d erreur (descripteur invalide -> EBADF)");
}
// --- mmap / munmap / madvise -------------------------------------------
// Verification explicite du 6e argument de mmap : on mappe avec un offset
// non nul sur un descripteur invalide. Si le 6e argument n arrivait pas au
// noyau, l erreur serait EINVAL au lieu de EBADF.
{
const usize len = 4096;
const sys::Result r = sys::mmap(nullptr, len, sys::PROT_READ | sys::PROT_WRITE,
sys::MAP_PRIVATE | sys::MAP_ANONYMOUS, -1, 0);
check(r.is_ok(), "mmap nominal (anonyme 4 Ko)");
if (r.is_ok()) {
u8* p = static_cast<u8*>(r.ptr());
p[0] = 0x42;
p[len - 1] = 0x43;
check(p[0] == 0x42 && p[len - 1] == 0x43, "mmap : la memoire est ecrivable");
const sys::Result a = sys::madvise(p, len, sys::MADV_WILLNEED);
check(a.is_ok(), "madvise nominal (MADV_WILLNEED)");
const sys::Result u = sys::munmap(p, len);
check(u.is_ok(), "munmap nominal");
} else {
check(false, "mmap : la memoire est ecrivable (mmap a echoue)");
check(false, "madvise nominal (mmap a echoue)");
check(false, "munmap nominal (mmap a echoue)");
}
}
{
// Longueur nulle : EINVAL. Cas d erreur simple et sans effet de bord.
const sys::Result r = sys::mmap(nullptr, 0, sys::PROT_READ,
sys::MAP_PRIVATE | sys::MAP_ANONYMOUS, -1, 0);
check_err(r, sys::EINVAL, "mmap cas d erreur (longueur nulle -> EINVAL)");
}
{
// 6e argument : offset non nul, descripteur invalide, mapping de
// fichier. Le noyau doit voir un fd invalide (EBADF).
const sys::Result r = sys::mmap(nullptr, 4096, sys::PROT_READ, sys::MAP_PRIVATE, -1,
4096);
check(r.is_err(), "mmap 6e argument : l appel parvient au noyau et echoue proprement");
}
{
const sys::Result r = sys::munmap(nullptr, 0);
check_err(r, sys::EINVAL, "munmap cas d erreur (longueur nulle -> EINVAL)");
}
{
const sys::Result r = sys::madvise(nullptr, 0, 0xFFFF);
check(r.is_err(), "madvise cas d erreur (conseil inconnu)");
}
// --- clock_gettime ------------------------------------------------------
{
sys::TimeSpec ts{0, 0};
const sys::Result r = sys::clock_gettime(sys::CLOCK_MONOTONIC, &ts);
check(r.is_ok() && (ts.sec > 0 || ts.nsec > 0), "clock_gettime nominal (MONOTONIC)");
const sys::Result r2 = sys::clock_gettime(0x7FFF, &ts);
check(r2.is_err(), "clock_gettime cas d erreur (horloge inconnue)");
}
// --- nanosleep ----------------------------------------------------------
{
const sys::TimeSpec req{0, 1000000}; // 1 ms
const sys::Result r = sys::nanosleep(&req, nullptr);
check(r.is_ok(), "nanosleep nominal (1 ms)");
const sys::TimeSpec bad{0, 2000000000}; // nsec >= 1e9 : invalide
const sys::Result r2 = sys::nanosleep(&bad, nullptr);
check_err(r2, sys::EINVAL, "nanosleep cas d erreur (nsec hors bornes -> EINVAL)");
}
// --- exit / exit_group ---------------------------------------------------
// Ils ne reviennent pas : on ne peut pas les tester ici sans terminer le
// processus. Ils sont testes IMPLICITEMENT et de la seule facon possible :
// ce programme se termine par exit_group via asm/start.S, et son code de
// sortie est observable par le script appelant. Si exit_group etait faux,
// ce binaire ne rendrait jamais la main proprement.
err_write("NOTE exit/exit_group : testes implicitement par la terminaison\n");
err_write(" de ce programme (code de sortie observable a l exterieur).\n");
err_write("\nechecs : ");
err_write_i64(g_failures);
err_write("\n");
return g_failures == 0 ? 0 : 1;
}
+27
Voir le fichier
@@ -0,0 +1,27 @@
#!/bin/sh
# tools/regen-golden.sh — regenere test/data/golden_write.txt depuis les
# sources ORIGINALES de Gastinel Write.
#
# A relancer uniquement si le rasterizer de Write change, ou si le jeu de
# glyphes de tools/write_reference_dump.cpp est etendu.
#
# NE PAS le relancer pour "faire passer" un test golden qui echoue : un echec
# signifie que le portage a diverge, et c est le portage qu il faut corriger.
#
# usage : tools/regen-golden.sh <chemin/vers/Gastinel Write/src>
set -eu
if [ $# -lt 1 ]; then
echo "usage: $0 <chemin/vers/Gastinel Write/src>" >&2
exit 2
fi
WRITE_SRC="$1"
ROOT="$(cd "$(dirname "$0")/.." && pwd)"
cmake -S "$ROOT" -B "$ROOT/build-host" -G Ninja -DPROJ3_WRITE_SRC="$WRITE_SRC"
ninja -C "$ROOT/build-host" proj3_write_reference
"$ROOT/build-host/proj3_write_reference" "$ROOT/test/data/Inter-Regular.ttf" \
> "$ROOT/test/data/golden_write.txt"
echo "golden regenere : $(wc -l < "$ROOT/test/data/golden_write.txt") lignes"
+87
Voir le fichier
@@ -0,0 +1,87 @@
// tools/write_reference_dump.cpp — ORACLE EXTERNE DU PORTAGE.
//
// Ce programme compile les sources ORIGINALES de Gastinel Write
// (src/font/ttf.cpp et src/render/rasterizer.cpp, qui ne dependent d aucune
// API Windows) et vide leurs sorties dans un format texte.
//
// C est ce qui rend le portage verifiable au lieu de simplement plausible :
// le test test_raster_golden.cpp compare octet par octet la sortie du code
// porte a celle produite ici par le code d origine. Si les deux divergent,
// c est un bug de portage et il doit etre trouve maintenant.
//
// Construction (cible hote uniquement) :
// cmake -B build-host -G Ninja -DPROJ3_WRITE_SRC="<...>/Gastinel Write/src"
// ninja -C build-host proj3_write_reference
// ./build-host/proj3_write_reference test/data/Inter-Regular.ttf > test/data/golden_write.txt
//
// FORMAT (v1), une ligne par (codepoint, taille) :
// <codepoint> <pixel_size> <gid> <ok> <w> <h> <bx> <by> <adv> <hex de la couverture>
// `ok` vaut 1 si rasterize_glyph a rendu true. Quand il vaut 0, les champs
// suivants valent 0 et le hex est vide.
#include <cstdio>
#include <cstdlib>
#include <string>
#include <vector>
#include "font/ttf.h"
#include "render/rasterizer.h"
namespace {
// Jeu de glyphes. Choisi pour couvrir :
// - des glyphes simples (A, o, 0) ;
// - des composites, qui exercent la recursion et la matrice 2x2 (e aigu,
// a grave, c cedille, u trema) ;
// - de la ponctuation fine, ou l arrondi au pixel se voit ;
// - l espace, glyphe vide dont seules les metriques comptent.
const unsigned kCodepoints[] = {
0x20, 0x21, 0x2C, 0x2E, 0x30, 0x31, 0x38, 0x41, 0x42, 0x47, 0x4F, 0x57,
0x61, 0x62, 0x67, 0x6D, 0x6F, 0x73, 0x77, 0x7A, 0x23, 0x25, 0x26, 0x3F,
0xE9, 0xE0, 0xE7, 0xFC, 0xD8, 0x40,
};
// Tailles en pixels par em. 12 et 16 sont les corps de texte ou l arrondi est
// le plus sensible ; 24 et 32 exercent des courbes plus longues, donc des
// subdivisions plus nombreuses.
const float kSizes[] = {12.0f, 16.0f, 24.0f, 32.0f};
} // namespace
int main(int argc, char** argv) {
if (argc < 2) {
std::fprintf(stderr, "usage: %s <police.ttf>\n", argv[0]);
return 2;
}
gw::font::TtfFont font;
std::string err;
if (!font.load_from_file(argv[1], err)) {
std::fprintf(stderr, "chargement impossible : %s\n", err.c_str());
return 2;
}
std::printf("# proj3 golden raster dump v1 (source : Gastinel Write)\n");
std::printf("# upem %u\n", static_cast<unsigned>(font.units_per_em()));
for (unsigned cp : kCodepoints) {
const unsigned gid = font.glyph_index_for_codepoint(cp);
gw::font::Glyph g;
const bool loaded = font.load_glyph(static_cast<std::uint16_t>(gid), g);
for (float px : kSizes) {
gw::render::RasterizedGlyph rg;
const bool ok = loaded && gw::render::rasterize_glyph(g, font.units_per_em(), px, rg);
std::printf("%u %g %u %d", cp, static_cast<double>(px), gid, ok ? 1 : 0);
if (ok) {
std::printf(" %d %d %d %d %d ", rg.coverage.width, rg.coverage.height,
rg.bearing_x, rg.bearing_y, rg.advance);
for (unsigned char v : rg.coverage.pixels) std::printf("%02x", v);
} else {
// Meme quand la rasterization echoue (glyphe vide), l avance
// reste significative : elle positionne le caractere suivant.
std::printf(" 0 0 0 0 %d ", rg.advance);
}
std::printf("\n");
}
}
return 0;
}