From 536792a769e1efd551a1a4071895dc76be772d68 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Gastinel?= <264859180+gastinelt@users.noreply.github.com> Date: Sun, 11 Oct 2026 01:55:22 +0200 Subject: [PATCH] Premier commit --- .gitignore | 70 ++ CLAUDE.md | 46 ++ CMakeLists.txt | 192 ++++++ README.md | 200 ++++++ asm/demo_fill_aarch64.S | 74 ++ asm/host/demo_fill_x86_64.S | 88 +++ asm/start.S | 54 ++ asm/syscall.S | 143 ++++ cmake/toolchain-aarch64-linux.cmake | 51 ++ doc/adr/ADR-0001-socle-compilation.md | 109 +++ doc/adr/ADR-0002-wrappers-syscall-en-asm.md | 84 +++ ...0003-arene-plutot-qu-allocateur-general.md | 93 +++ doc/adr/ADR-0004-portage-rasterizer.md | 92 +++ doc/convention-aarch64.md | 200 ++++++ doc/convention-syscall.md | 152 +++++ doc/memoire.md | 187 +++++ doc/methode-oracle.md | 172 +++++ src/proj3/base/cstring.cpp | 58 ++ src/proj3/base/fmt.hpp | 68 ++ src/proj3/base/math.hpp | 84 +++ src/proj3/base/mem.hpp | 51 ++ src/proj3/base/sort.hpp | 53 ++ src/proj3/base/types.hpp | 44 ++ src/proj3/boot/main.cpp | 45 ++ src/proj3/font/ttf.cpp | 641 ++++++++++++++++++ src/proj3/font/ttf.hpp | 181 +++++ src/proj3/mem/arena.cpp | 71 ++ src/proj3/mem/arena.hpp | 76 +++ src/proj3/mem/layout.hpp | 117 ++++ src/proj3/mem/new_guard.cpp | 119 ++++ src/proj3/mem/page_source.hpp | 85 +++ src/proj3/mem/page_source_host.cpp | 91 +++ src/proj3/mem/page_source_linux.cpp | 114 ++++ src/proj3/mem/system.cpp | 68 ++ src/proj3/mem/system.hpp | 39 ++ src/proj3/render/compose.cpp | 54 ++ src/proj3/render/compose.hpp | 60 ++ src/proj3/render/coverage.hpp | 54 ++ src/proj3/render/rasterizer.cpp | 262 +++++++ src/proj3/render/rasterizer.hpp | 73 ++ src/proj3/sys/panic.cpp | 57 ++ src/proj3/sys/panic.hpp | 32 + src/proj3/sys/panic_host.cpp | 54 ++ src/proj3/sys/result.hpp | 36 + src/proj3/sys/syscall_nr.hpp | 50 ++ src/proj3/sys/syscalls.hpp | 153 +++++ src/proj3/sys/uapi.hpp | 75 ++ test/data/Inter-Regular.ttf | Bin 0 -> 411640 bytes test/data/OFL.txt | 92 +++ test/data/golden_write.txt | 122 ++++ test/oracle/main.cpp | 57 ++ test/oracle/oracle.cpp | 243 +++++++ test/oracle/oracle.hpp | 134 ++++ test/oracle/pairs_demo.cpp | 69 ++ test/oracle/pairs_render.cpp | 197 ++++++ test/oracle/selftest_main.cpp | 76 +++ test/test_arena.cpp | 122 ++++ test/test_new_guard.cpp | 31 + test/test_raster_golden.cpp | 274 ++++++++ test/test_syscalls.cpp | 263 +++++++ tools/regen-golden.sh | 27 + tools/write_reference_dump.cpp | 87 +++ 62 files changed, 6766 insertions(+) create mode 100644 .gitignore create mode 100644 CLAUDE.md create mode 100644 CMakeLists.txt create mode 100644 README.md create mode 100644 asm/demo_fill_aarch64.S create mode 100644 asm/host/demo_fill_x86_64.S create mode 100644 asm/start.S create mode 100644 asm/syscall.S create mode 100644 cmake/toolchain-aarch64-linux.cmake create mode 100644 doc/adr/ADR-0001-socle-compilation.md create mode 100644 doc/adr/ADR-0002-wrappers-syscall-en-asm.md create mode 100644 doc/adr/ADR-0003-arene-plutot-qu-allocateur-general.md create mode 100644 doc/adr/ADR-0004-portage-rasterizer.md create mode 100644 doc/convention-aarch64.md create mode 100644 doc/convention-syscall.md create mode 100644 doc/memoire.md create mode 100644 doc/methode-oracle.md create mode 100644 src/proj3/base/cstring.cpp create mode 100644 src/proj3/base/fmt.hpp create mode 100644 src/proj3/base/math.hpp create mode 100644 src/proj3/base/mem.hpp create mode 100644 src/proj3/base/sort.hpp create mode 100644 src/proj3/base/types.hpp create mode 100644 src/proj3/boot/main.cpp create mode 100644 src/proj3/font/ttf.cpp create mode 100644 src/proj3/font/ttf.hpp create mode 100644 src/proj3/mem/arena.cpp create mode 100644 src/proj3/mem/arena.hpp create mode 100644 src/proj3/mem/layout.hpp create mode 100644 src/proj3/mem/new_guard.cpp create mode 100644 src/proj3/mem/page_source.hpp create mode 100644 src/proj3/mem/page_source_host.cpp create mode 100644 src/proj3/mem/page_source_linux.cpp create mode 100644 src/proj3/mem/system.cpp create mode 100644 src/proj3/mem/system.hpp create mode 100644 src/proj3/render/compose.cpp create mode 100644 src/proj3/render/compose.hpp create mode 100644 src/proj3/render/coverage.hpp create mode 100644 src/proj3/render/rasterizer.cpp create mode 100644 src/proj3/render/rasterizer.hpp create mode 100644 src/proj3/sys/panic.cpp create mode 100644 src/proj3/sys/panic.hpp create mode 100644 src/proj3/sys/panic_host.cpp create mode 100644 src/proj3/sys/result.hpp create mode 100644 src/proj3/sys/syscall_nr.hpp create mode 100644 src/proj3/sys/syscalls.hpp create mode 100644 src/proj3/sys/uapi.hpp create mode 100644 test/data/Inter-Regular.ttf create mode 100644 test/data/OFL.txt create mode 100644 test/data/golden_write.txt create mode 100644 test/oracle/main.cpp create mode 100644 test/oracle/oracle.cpp create mode 100644 test/oracle/oracle.hpp create mode 100644 test/oracle/pairs_demo.cpp create mode 100644 test/oracle/pairs_render.cpp create mode 100644 test/oracle/selftest_main.cpp create mode 100644 test/test_arena.cpp create mode 100644 test/test_new_guard.cpp create mode 100644 test/test_raster_golden.cpp create mode 100644 test/test_syscalls.cpp create mode 100644 tools/regen-golden.sh create mode 100644 tools/write_reference_dump.cpp diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..1e92f2f --- /dev/null +++ b/.gitignore @@ -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 diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..c3bd42c --- /dev/null +++ b/CLAUDE.md @@ -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 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é". \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..e7695b5 --- /dev/null +++ b/CMakeLists.txt @@ -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} + $<$:${proj3_common_flags}> + $<$:-nostdlib;-ffreestanding;-fno-builtin> + $<$:-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 $<$:${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 $<$:${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= 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() diff --git a/README.md b/README.md new file mode 100644 index 0000000..e370bf9 --- /dev/null +++ b/README.md @@ -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_`. diff --git a/asm/demo_fill_aarch64.S b/asm/demo_fill_aarch64.S new file mode 100644 index 0000000..47b4a96 --- /dev/null +++ b/asm/demo_fill_aarch64.S @@ -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 diff --git a/asm/host/demo_fill_x86_64.S b/asm/host/demo_fill_x86_64.S new file mode 100644 index 0000000..c7fdd10 --- /dev/null +++ b/asm/host/demo_fill_x86_64.S @@ -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 diff --git a/asm/start.S b/asm/start.S new file mode 100644 index 0000000..17dad2a --- /dev/null +++ b/asm/start.S @@ -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 diff --git a/asm/syscall.S b/asm/syscall.S new file mode 100644 index 0000000..092f341 --- /dev/null +++ b/asm/syscall.S @@ -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_: +// mov x8, #PROJ3_NR_ +// 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 diff --git a/cmake/toolchain-aarch64-linux.cmake b/cmake/toolchain-aarch64-linux.cmake new file mode 100644 index 0000000..c9222e1 --- /dev/null +++ b/cmake/toolchain-aarch64-linux.cmake @@ -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) diff --git a/doc/adr/ADR-0001-socle-compilation.md b/doc/adr/ADR-0001-socle-compilation.md new file mode 100644 index 0000000..41e1f26 --- /dev/null +++ b/doc/adr/ADR-0001-socle-compilation.md @@ -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, `` 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. diff --git a/doc/adr/ADR-0002-wrappers-syscall-en-asm.md b/doc/adr/ADR-0002-wrappers-syscall-en-asm.md new file mode 100644 index 0000000..1a14f61 --- /dev/null +++ b/doc/adr/ADR-0002-wrappers-syscall-en-asm.md @@ -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). diff --git a/doc/adr/ADR-0003-arene-plutot-qu-allocateur-general.md b/doc/adr/ADR-0003-arene-plutot-qu-allocateur-general.md new file mode 100644 index 0000000..f41509b --- /dev/null +++ b/doc/adr/ADR-0003-arene-plutot-qu-allocateur-general.md @@ -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. diff --git a/doc/adr/ADR-0004-portage-rasterizer.md b/doc/adr/ADR-0004-portage-rasterizer.md new file mode 100644 index 0000000..1e27aee --- /dev/null +++ b/doc/adr/ADR-0004-portage-rasterizer.md @@ -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. diff --git a/doc/convention-aarch64.md b/doc/convention-aarch64.md new file mode 100644 index 0000000..46d2779 --- /dev/null +++ b/doc/convention-aarch64.md @@ -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__`, 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_` : + `.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. diff --git a/doc/convention-syscall.md b/doc/convention-syscall.md new file mode 100644 index 0000000..64e2b03 --- /dev/null +++ b/doc/convention-syscall.md @@ -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_: + mov x8, #PROJ3_NR_ + 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(-raw); } + + // Valeur utile. Precondition : is_ok(). + constexpr i64 value() const { return raw; } + constexpr i32 fd() const { return static_cast(raw); } + void* ptr() const { return reinterpret_cast(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. diff --git a/doc/memoire.md b/doc/memoire.md new file mode 100644 index 0000000..df6d846 --- /dev/null +++ b/doc/memoire.md @@ -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. diff --git a/doc/methode-oracle.md b/doc/methode-oracle.md new file mode 100644 index 0000000..081c296 --- /dev/null +++ b/doc/methode-oracle.md @@ -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. diff --git a/src/proj3/base/cstring.cpp b/src/proj3/base/cstring.cpp new file mode 100644 index 0000000..2ca513b --- /dev/null +++ b/src/proj3/base/cstring.cpp @@ -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(dst); + const u8 v = static_cast(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(dst); + const u8* s = static_cast(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(dst); + const u8* s = static_cast(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(a); + const u8* y = static_cast(b); + for (usize i = 0; i < n; ++i) { + if (x[i] != y[i]) return static_cast(x[i]) - static_cast(y[i]); + } + return 0; +} + +} // extern "C" diff --git a/src/proj3/base/fmt.hpp b/src/proj3/base/fmt.hpp new file mode 100644 index 0000000..dfe1fc8 --- /dev/null +++ b/src/proj3/base/fmt.hpp @@ -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('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(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(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 diff --git a/src/proj3/base/math.hpp b/src/proj3/base/math.hpp new file mode 100644 index 0000000..c06edab --- /dev/null +++ b/src/proj3/base/math.hpp @@ -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 +constexpr T min_of(T a, T b) { + return a < b ? a : b; +} +template +constexpr T max_of(T a, T b) { + return a > b ? a : b; +} +template +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(v); + const f32 tf = static_cast(t); + return (tf > v) ? tf - 1.0f : tf; +} + +inline f32 ceil_f32(f32 v) { + const i64 t = static_cast(v); + const f32 tf = static_cast(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(v + 0.5f) : -static_cast(-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 diff --git a/src/proj3/base/mem.hpp b/src/proj3/base/mem.hpp new file mode 100644 index 0000000..fb11e19 --- /dev/null +++ b/src/proj3/base/mem.hpp @@ -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(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(dst); + const u8* s = static_cast(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(a); + const u8* y = static_cast(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(a); + const u8* y = static_cast(b); + for (usize i = 0; i < n; ++i) { + if (x[i] != y[i]) return i; + } + return n; +} + +} // namespace proj3 diff --git a/src/proj3/base/sort.hpp b/src/proj3/base/sort.hpp new file mode 100644 index 0000000..e72af45 --- /dev/null +++ b/src/proj3/base/sort.hpp @@ -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 +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 +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 diff --git a/src/proj3/base/types.hpp b/src/proj3/base/types.hpp new file mode 100644 index 0000000..dfd27ef --- /dev/null +++ b/src/proj3/base/types.hpp @@ -0,0 +1,44 @@ +// base/types.hpp — types entiers de largeur fixe, sans . +// +// Pourquoi ne pas inclure : il est theoriquement disponible en +// freestanding, mais il tire l en-tete systeme 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 diff --git a/src/proj3/boot/main.cpp b/src/proj3/boot/main.cpp new file mode 100644 index 0000000..ce0ed29 --- /dev/null +++ b/src/proj3/boot/main.cpp @@ -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; +} diff --git a/src/proj3/font/ttf.cpp b/src/proj3/font/ttf.cpp new file mode 100644 index 0000000..955fd15 --- /dev/null +++ b/src/proj3/font/ttf.cpp @@ -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(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(off) + 2 > n) return false; + out = static_cast((static_cast(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(v); + return true; +} + +bool rd_u32(const u8* d, usize n, u32 off, u32& out) { + if (static_cast(off) + 4 > n) return false; + out = (static_cast(d[off]) << 24) | (static_cast(d[off + 1]) << 16) | + (static_cast(d[off + 2]) << 8) | static_cast(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(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(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(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(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(num_glyphs_) + 1u; + loca_ = arena.alloc_array(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(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((c + static_cast(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((gid + static_cast(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(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(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(num_h_metrics_ - 1) + ? glyph_index + : static_cast(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(adv); + out.left_side_bearing = static_cast(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(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(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(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(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(d) : -static_cast(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(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(d) : -static_cast(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(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(a1); + dy = static_cast(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(static_cast(b1)); + dy = static_cast(static_cast(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 diff --git a/src/proj3/font/ttf.hpp b/src/proj3/font/ttf.hpp new file mode 100644 index 0000000..5f95558 --- /dev/null +++ b/src/proj3/font/ttf.hpp @@ -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(kMaxGlyphPoints); + contour_end = a.alloc_array(kMaxGlyphContours); + flags = a.alloc_array(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 diff --git a/src/proj3/mem/arena.cpp b/src/proj3/mem/arena.cpp new file mode 100644 index 0000000..b10ab15 --- /dev/null +++ b/src/proj3/mem/arena.cpp @@ -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(size)); + err_write(" align="); + err_write_i64(static_cast(align)); + err_write(" occupe="); + err_write_i64(static_cast(used_)); + err_write(" capacite="); + err_write_i64(static_cast(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(m)); + } + used_ = m; +} + +} // namespace proj3::mem diff --git a/src/proj3/mem/arena.hpp b/src/proj3/mem/arena.hpp new file mode 100644 index 0000000..b4e5c9b --- /dev/null +++ b/src/proj3/mem/arena.hpp @@ -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 + T* alloc_array(usize count) { + return static_cast(alloc(count * sizeof(T), alignof(T))); + } + + template + T* alloc_one() { + return static_cast(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_ = ""; + u8* base_ = nullptr; + usize capacity_ = 0; + usize used_ = 0; + usize peak_ = 0; +}; + +} // namespace proj3::mem diff --git a/src/proj3/mem/layout.hpp b/src/proj3/mem/layout.hpp new file mode 100644 index 0000000..4ff3a25 --- /dev/null +++ b/src/proj3/mem/layout.hpp @@ -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 diff --git a/src/proj3/mem/new_guard.cpp b/src/proj3/mem/new_guard.cpp new file mode 100644 index 0000000..83dc3ba --- /dev/null +++ b/src/proj3/mem/new_guard.cpp @@ -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 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 +#include +#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(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)"); +} diff --git a/src/proj3/mem/page_source.hpp b/src/proj3/mem/page_source.hpp new file mode 100644 index 0000000..09e5060 --- /dev/null +++ b/src/proj3/mem/page_source.hpp @@ -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 diff --git a/src/proj3/mem/page_source_host.cpp b/src/proj3/mem/page_source_host.cpp new file mode 100644 index 0000000..54f6dc9 --- /dev/null +++ b/src/proj3/mem/page_source_host.cpp @@ -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 + +#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(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(raw); + const uptr aligned = (addr + (kHugePageSize - 1)) & ~static_cast(kHugePageSize - 1); + + out.base = reinterpret_cast(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 diff --git a/src/proj3/mem/page_source_linux.cpp b/src/proj3/mem/page_source_linux.cpp new file mode 100644 index 0000000..2ce59ef --- /dev/null +++ b/src/proj3/mem/page_source_linux.cpp @@ -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(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(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(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 diff --git a/src/proj3/mem/system.cpp b/src/proj3/mem/system.cpp new file mode 100644 index 0000000..4e427ba --- /dev/null +++ b/src/proj3/mem/system.cpp @@ -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(p - out.block.base); + if (consumed != kArenaTotalRaw) { + panic_v("decoupage des arenes incoherent avec layout.hpp", "consomme", + static_cast(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(a.capacity())); + err_write(" pic="); + err_write_i64(static_cast(a.peak())); + err_write(" base="); + err_write_hex(reinterpret_cast(a.base())); + err_write("\n"); +} + +} // namespace + +void system_report(const System& s) { + err_write("proj3: budget memoire total = "); + err_write_i64(static_cast(kArenaTotal)); + err_write(" octets (reserve non decoupee = "); + err_write_i64(static_cast(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 diff --git a/src/proj3/mem/system.hpp b/src/proj3/mem/system.hpp new file mode 100644 index 0000000..ba78721 --- /dev/null +++ b/src/proj3/mem/system.hpp @@ -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 diff --git a/src/proj3/render/compose.cpp b/src/proj3/render/compose.cpp new file mode 100644 index 0000000..6c54170 --- /dev/null +++ b/src/proj3/render/compose.cpp @@ -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(static_cast(w) * static_cast(h)); + return fb; +} + +void framebuffer_clear(Framebuffer& fb, u32 xrgb) { + const usize n = static_cast(fb.width) * static_cast(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(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(y) * static_cast(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 diff --git a/src/proj3/render/compose.hpp b/src/proj3/render/compose.hpp new file mode 100644 index 0000000..5f7353a --- /dev/null +++ b/src/proj3/render/compose.hpp @@ -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(y) * static_cast(width); } + const u32* row(i32 y) const { + return pixels + static_cast(y) * static_cast(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 diff --git a/src/proj3/render/coverage.hpp b/src/proj3/render/coverage.hpp new file mode 100644 index 0000000..445947d --- /dev/null +++ b/src/proj3/render/coverage.hpp @@ -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(width) * static_cast(height); + } + + u8 at(i32 x, i32 y) const { + return pixels[static_cast(y) * static_cast(width) + static_cast(x)]; + } + void set(i32 x, i32 y, u8 v) { + pixels[static_cast(y) * static_cast(width) + static_cast(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(static_cast(w) * static_cast(h)); + mem_fill(c.pixels, 0, c.size_bytes()); + return c; +} + +} // namespace proj3::render diff --git a/src/proj3/render/rasterizer.cpp b/src/proj3/render/rasterizer.cpp new file mode 100644 index 0000000..044c11a --- /dev/null +++ b/src/proj3/render/rasterizer.cpp @@ -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 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(p1.x) - p0.x, static_cast(p1.y) - p0.y) + + hypot_f64(static_cast(p2.x) - p1.x, static_cast(p2.y) - p1.y); + const i32 n = static_cast(ceil_f32(static_cast(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(i) / static_cast(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(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(floor_f32(min_x * scale)) - 1; + const i32 px_max_x = static_cast(ceil_f32(max_x * scale)) + 1; + const i32 px_min_y = static_cast(floor_f32(min_y * scale)) - 1; + const i32 px_max_y = static_cast(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(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(px_min_x), static_cast(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(kMaxEdges); + + for (i32 y = 0; y < h; ++y) { + const f32 sample_y = static_cast(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(ceil_f32(span_start - 0.5f)); + i32 x1 = static_cast(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 diff --git a/src/proj3/render/rasterizer.hpp b/src/proj3/render/rasterizer.hpp new file mode 100644 index 0000000..9a6d641 --- /dev/null +++ b/src/proj3/render/rasterizer.hpp @@ -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 diff --git a/src/proj3/sys/panic.cpp b/src/proj3/sys/panic.cpp new file mode 100644 index 0000000..6e8b403 --- /dev/null +++ b/src/proj3/sys/panic.cpp @@ -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(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(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 diff --git a/src/proj3/sys/panic.hpp b/src/proj3/sys/panic.hpp new file mode 100644 index 0000000..70566b6 --- /dev/null +++ b/src/proj3/sys/panic.hpp @@ -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 diff --git a/src/proj3/sys/panic_host.cpp b/src/proj3/sys/panic_host.cpp new file mode 100644 index 0000000..d7a7e06 --- /dev/null +++ b/src/proj3/sys/panic_host.cpp @@ -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 +#include + +#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 diff --git a/src/proj3/sys/result.hpp b/src/proj3/sys/result.hpp new file mode 100644 index 0000000..f64d030 --- /dev/null +++ b/src/proj3/sys/result.hpp @@ -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(-raw); } + + // Valeur utile. Precondition : is_ok(). + constexpr i64 value() const { return raw; } + constexpr i32 fd() const { return static_cast(raw); } + void* ptr() const { return reinterpret_cast(static_cast(raw)); } +}; + +static_assert(sizeof(Result) == 8, "Result doit tenir dans un registre"); + +} // namespace proj3::sys diff --git a/src/proj3/sys/syscall_nr.hpp b/src/proj3/sys/syscall_nr.hpp new file mode 100644 index 0000000..4a83d70 --- /dev/null +++ b/src/proj3/sys/syscall_nr.hpp @@ -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) diff --git a/src/proj3/sys/syscalls.hpp b/src/proj3/sys/syscalls.hpp new file mode 100644 index 0000000..b5a2b74 --- /dev/null +++ b/src/proj3/sys/syscalls.hpp @@ -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(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 diff --git a/src/proj3/sys/uapi.hpp b/src/proj3/sys/uapi.hpp new file mode 100644 index 0000000..3b4cd8e --- /dev/null +++ b/src/proj3/sys/uapi.hpp @@ -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 diff --git a/test/data/Inter-Regular.ttf b/test/data/Inter-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..b7aaca8de1fe458399e17311d35d543a1fa2f984 GIT binary patch literal 411640 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 literal 0 HcmV?d00001 diff --git a/test/data/OFL.txt b/test/data/OFL.txt new file mode 100644 index 0000000..9b2ca37 --- /dev/null +++ b/test/data/OFL.txt @@ -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. diff --git a/test/data/golden_write.txt b/test/data/golden_write.txt new file mode 100644 index 0000000..3d6d57a --- /dev/null +++ b/test/data/golden_write.txt @@ -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 diff --git a/test/oracle/main.cpp b/test/oracle/main.cpp new file mode 100644 index 0000000..487febb --- /dev/null +++ b/test/oracle/main.cpp @@ -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(sys.scratch.peak())); + err_write(" / "); + err_write_i64(static_cast(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 diff --git a/test/oracle/oracle.cpp b/test/oracle/oracle.cpp new file mode 100644 index 0000000..a2e7f4f --- /dev/null +++ b/test/oracle/oracle.cpp @@ -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((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(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(begin)); + err_write(".."); + err_write_i64(static_cast(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(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(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(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(c.seed)); + err_write(" in_len="); + err_write_i64(static_cast(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(ref_len)); + err_write(" optimisee="); + err_write_i64(static_cast(opt_len)); + err_write("\n"); + if (diff_at < ref_len) { + err_write(" premier octet divergent a l offset "); + err_write_i64(static_cast(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 diff --git a/test/oracle/oracle.hpp b/test/oracle/oracle.hpp new file mode 100644 index 0000000..de21a4b --- /dev/null +++ b/test/oracle/oracle.hpp @@ -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 diff --git a/test/oracle/pairs_demo.cpp b/test/oracle/pairs_demo.cpp new file mode 100644 index 0000000..d1ce669 --- /dev/null +++ b/test/oracle/pairs_demo.cpp @@ -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 diff --git a/test/oracle/pairs_render.cpp b/test/oracle/pairs_render.cpp new file mode 100644 index 0000000..e56179e --- /dev/null +++ b/test/oracle/pairs_render.cpp @@ -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(in_len > 0 ? in[0] : 0u) * 2.0f; + const f32 h = 300.0f + static_cast(in_len > 1 ? in[1] : 0u) * 2.0f; + const f32 inset = 40.0f + static_cast(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(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(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(out_cap / (4u * 32u)); + if (fh <= 0) return 0; + + render::Framebuffer fb; + fb.pixels = reinterpret_cast(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(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(fw) * static_cast(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 diff --git a/test/oracle/selftest_main.cpp b/test/oracle/selftest_main.cpp new file mode 100644 index 0000000..009db3a --- /dev/null +++ b/test/oracle/selftest_main.cpp @@ -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; +} diff --git a/test/test_arena.cpp b/test/test_arena.cpp new file mode 100644 index 0000000..b237bea --- /dev/null +++ b/test/test_arena.cpp @@ -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(p16) & 15u) == 0, "alignement 16 respecte"); + check((reinterpret_cast(p64) & 63u) == 0, "alignement 64 respecte"); + } + + // --- Avance de pointeur ------------------------------------------------- + { + mem::Arena& a = sys.scratch; + a.reset(); + u8* x = a.alloc_array(100); + u8* y = a.alloc_array(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(500); + const usize m = a.mark(); + (void)a.alloc_array(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(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(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(mem::kArenaTotal)); + err_write(" octets\n"); + err_write("echecs : "); + err_write_i64(g_failures); + err_write("\n"); + return g_failures == 0 ? 0 : 1; +} diff --git a/test/test_new_guard.cpp b/test/test_new_guard.cpp new file mode 100644 index 0000000..5b1e240 --- /dev/null +++ b/test/test_new_guard.cpp @@ -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; +} diff --git a/test/test_raster_golden.cpp b/test/test_raster_golden.cpp new file mode 100644 index 0000000..9f160b2 --- /dev/null +++ b/test/test_raster_golden.cpp @@ -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 + +#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(static_cast(n) + 1); + const usize got = std::fread(buf, 1, static_cast(n), f); + std::fclose(f); + if (got != static_cast(n)) return nullptr; + buf[n] = 0; + out_size = static_cast(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(*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(v) : static_cast(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(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(*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(px)); + err_write("\n"); +} + +} // namespace + +int main(int argc, char** argv) { + if (argc < 3) { + err_write("usage: proj3_test_raster \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(golden), + reinterpret_cast(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(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((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(bad)); + err_write(" (x="); + err_write_i64(static_cast(bad % static_cast(w_ref))); + err_write(" y="); + err_write_i64(static_cast(bad / static_cast(w_ref))); + err_write(") attendu="); + err_write_hex(static_cast((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; +} diff --git a/test/test_syscalls.cpp b/test/test_syscalls.cpp new file mode 100644 index 0000000..3054f4d --- /dev/null +++ b/test/test_syscalls.cpp @@ -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(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; +} diff --git a/tools/regen-golden.sh b/tools/regen-golden.sh new file mode 100644 index 0000000..b9ae597 --- /dev/null +++ b/tools/regen-golden.sh @@ -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 +set -eu + +if [ $# -lt 1 ]; then + echo "usage: $0 " >&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" diff --git a/tools/write_reference_dump.cpp b/tools/write_reference_dump.cpp new file mode 100644 index 0000000..ec24715 --- /dev/null +++ b/tools/write_reference_dump.cpp @@ -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) : +// +// `ok` vaut 1 si rasterize_glyph a rendu true. Quand il vaut 0, les champs +// suivants valent 0 et le hex est vide. + +#include +#include +#include +#include + +#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 \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(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(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(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; +}