Premier commit
Cette révision appartient à :
révision
536792a769
62 fichiers modifiés
+6766
Aucun fichier ne correspond à votre recherche
@@ -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
|
||||
@@ -0,0 +1,46 @@
|
||||
CONTEXTE PROJET
|
||||
|
||||
Environnement graphique déterministe pour ARM64 (AArch64), sur noyau Linux.
|
||||
Cible de prototypage : Google Pixel 3a (nom de code sargo, Snapdragon 670,
|
||||
4 Go de RAM, driver DRM msm mainline). Cible ultérieure : Poco F5 Pro
|
||||
(mondrian, SD 8+ Gen 1). Le code doit rester portable entre les deux.
|
||||
|
||||
Le nom officiel du projet N'EST PAS ARRÊTÉ. N'en invente aucun. Utilise le
|
||||
placeholder `proj3` pour les namespaces, préfixes et noms de dossiers, et
|
||||
signale dans ton rapport tous les endroits où un vrai nom devra être
|
||||
substitué plus tard.
|
||||
|
||||
TROIS PILIERS — contraintes de conception, pas des objectifs vagues
|
||||
|
||||
1. Déterminisme de latence. Ce qui compte n'est pas le débit moyen mais la
|
||||
variance. Toute construction qui introduit une variabilité non bornée est
|
||||
à rejeter, même si elle est plus rapide en moyenne.
|
||||
|
||||
2. Budget mémoire explicite. Aucune allocation dynamique après la phase
|
||||
d'init. Tout est préalloué en arènes de taille fixe. Pas de free, pas de
|
||||
realloc, pas de conteneur qui pousse.
|
||||
|
||||
3. Accès direct justifié. Chaque couche d'abstraction traversée doit être
|
||||
justifiée explicitement. Pas de libc, pas de framework, pas de dépendance
|
||||
externe. Les appels système passent par nos propres wrappers.
|
||||
|
||||
CONTRAINTES TECHNIQUES NON NÉGOCIABLES
|
||||
|
||||
- C++20, compilé avec `-nostdlib -fno-exceptions -fno-rtti -fno-threadsafe-statics`.
|
||||
- Aucune dépendance externe. Aucune libc. Pas de STL (les headers purement
|
||||
compile-time comme <type_traits> sont tolérés, à signaler s'ils sont utilisés).
|
||||
- Zéro warning avec `-Wall -Wextra`.
|
||||
- Toute dette technique, tout compromis, tout écart par rapport à ces
|
||||
consignes doit être documenté explicitement dans le code ET dans le README.
|
||||
Jamais implicite.
|
||||
- Si une consigne te semble techniquement impossible ou contre-productive,
|
||||
DIS-LE dans ton rapport au lieu de la contourner silencieusement.
|
||||
|
||||
MÉTHODE
|
||||
|
||||
- Reste strictement dans le périmètre du chantier demandé. Ne fais pas
|
||||
"tant qu'on y est".
|
||||
- Livrable systématique : rapport détaillé de ce qui a été fait, ce qui reste
|
||||
en stub, ce qui est bloquant, et les décisions que tu as dû prendre seul.
|
||||
- N'affirme jamais qu'une chose est vérifiée si tu ne l'as pas réellement
|
||||
exécutée. Distingue explicitement "écrit" de "compilé" de "testé".
|
||||
@@ -0,0 +1,192 @@
|
||||
# CMakeLists.txt — racine.
|
||||
#
|
||||
# DEUX CIBLES, ASYMETRIQUES ET ASSUMEES (cf. README, section "Double cible") :
|
||||
#
|
||||
# * cible EMBARQUEE (aarch64-linux, freestanding) : le vrai produit.
|
||||
# -nostdlib, pas de libc, point d entree _start maison, syscalls maison.
|
||||
# Selectionnee par -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-aarch64-linux.cmake
|
||||
#
|
||||
# * cible HOTE (la machine de dev, quelle qu elle soit) : outillage.
|
||||
# Le harnais d oracle et les generateurs de references. Cette cible A LE
|
||||
# DROIT d utiliser la libc de l hote. Elle ne produit JAMAIS de binaire
|
||||
# livre. Aucun fichier compile pour la cible embarquee ne doit dependre de
|
||||
# ce que la cible hote s autorise.
|
||||
#
|
||||
# Le partage de code entre les deux se fait uniquement par les fichiers listes
|
||||
# dans proj3_portable_sources : ceux-la sont freestanding par construction.
|
||||
|
||||
cmake_minimum_required(VERSION 3.20)
|
||||
project(proj3 LANGUAGES CXX ASM)
|
||||
|
||||
set(CMAKE_CXX_STANDARD 20)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||
set(CMAKE_CXX_EXTENSIONS OFF)
|
||||
|
||||
if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64")
|
||||
set(PROJ3_EMBEDDED ON)
|
||||
else()
|
||||
set(PROJ3_EMBEDDED OFF)
|
||||
endif()
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Sources portables : compilables a l identique par les deux cibles.
|
||||
# Aucune de ces unites n inclut d en-tete systeme ni de libc.
|
||||
# ---------------------------------------------------------------------------
|
||||
set(proj3_portable_sources
|
||||
src/proj3/mem/arena.cpp
|
||||
src/proj3/mem/system.cpp
|
||||
src/proj3/font/ttf.cpp
|
||||
src/proj3/render/rasterizer.cpp
|
||||
src/proj3/render/compose.cpp
|
||||
)
|
||||
|
||||
# -fno-math-errno : sans lui, __builtin_sqrt genere un APPEL a sqrt() de la
|
||||
# libm, uniquement pour pouvoir positionner errno sur une entree negative.
|
||||
# Avec lui, le compilateur emet l instruction machine (fsqrt / sqrtsd) et rien
|
||||
# d autre. C est indispensable en freestanding — le lien echoue sinon — et
|
||||
# c est sans effet sur la precision : contrairement au reste de -ffast-math,
|
||||
# cette option ne change ni le mode d arrondi, ni l associativite, ni le
|
||||
# traitement des NaN. Elle est passee aux DEUX cibles, pour que l hote et la
|
||||
# cible calculent rigoureusement pareil (cf. doc/methode-oracle.md).
|
||||
set(proj3_common_flags
|
||||
-std=c++20 -fno-exceptions -fno-rtti -fno-threadsafe-statics
|
||||
-fno-math-errno
|
||||
-Wall -Wextra -O2
|
||||
)
|
||||
|
||||
# ===========================================================================
|
||||
# CIBLE EMBARQUEE
|
||||
# ===========================================================================
|
||||
if(PROJ3_EMBEDDED)
|
||||
|
||||
separate_arguments(_p3_triple UNIX_COMMAND "${PROJ3_TARGET_TRIPLE_FLAGS}")
|
||||
separate_arguments(_p3_linkdrv UNIX_COMMAND "${PROJ3_LINK_DRIVER_FLAGS}")
|
||||
|
||||
# Tout binaire embarque partage exactement le meme socle : meme _start,
|
||||
# memes wrappers syscall, meme garde-fou, meme allocateur. On le factorise
|
||||
# dans une fonction pour qu il soit impossible qu un executable de test
|
||||
# soit construit avec des reglages differents du binaire livre.
|
||||
function(proj3_add_embedded_executable target)
|
||||
add_executable(${target}
|
||||
asm/start.S
|
||||
asm/syscall.S
|
||||
asm/demo_fill_aarch64.S
|
||||
src/proj3/base/cstring.cpp
|
||||
src/proj3/sys/panic.cpp
|
||||
src/proj3/mem/new_guard.cpp
|
||||
src/proj3/mem/page_source_linux.cpp
|
||||
${proj3_portable_sources}
|
||||
${ARGN}
|
||||
)
|
||||
target_include_directories(${target} PRIVATE src)
|
||||
target_compile_options(${target} PRIVATE
|
||||
${_p3_triple}
|
||||
$<$<COMPILE_LANGUAGE:CXX>:${proj3_common_flags}>
|
||||
$<$<COMPILE_LANGUAGE:CXX>:-nostdlib;-ffreestanding;-fno-builtin>
|
||||
$<$<COMPILE_LANGUAGE:ASM>:-Wall>
|
||||
)
|
||||
target_compile_definitions(${target} PRIVATE PROJ3_EMBEDDED=1)
|
||||
target_link_options(${target} PRIVATE
|
||||
${_p3_triple} ${_p3_linkdrv}
|
||||
-nostdlib -nostartfiles -static -Wl,-e,_start -Wl,--build-id=none
|
||||
)
|
||||
endfunction()
|
||||
|
||||
# Le binaire livre.
|
||||
proj3_add_embedded_executable(proj3_boot src/proj3/boot/main.cpp)
|
||||
|
||||
# Harnais des wrappers syscall (chantier 2). S execute sur n importe quel
|
||||
# Linux AArch64 : Raspberry Pi, VM, conteneur, qemu-user. Pas de telephone.
|
||||
proj3_add_embedded_executable(proj3_test_syscalls test/test_syscalls.cpp)
|
||||
|
||||
# Harnais d oracle, version embarquee : c est la SEULE facon d executer
|
||||
# reellement les versions assembleur des paires. Sur l hote, seules les
|
||||
# versions de reference et les paires a asm x86-64 tournent.
|
||||
proj3_add_embedded_executable(proj3_oracle_target
|
||||
test/oracle/oracle.cpp
|
||||
test/oracle/main.cpp
|
||||
test/oracle/pairs_demo.cpp
|
||||
test/oracle/pairs_render.cpp)
|
||||
|
||||
# ===========================================================================
|
||||
# CIBLE HOTE (outillage et tests seulement)
|
||||
# ===========================================================================
|
||||
else()
|
||||
|
||||
# -- Bibliotheque portable, compilee en mode hote --------------------------
|
||||
add_library(proj3_portable STATIC
|
||||
${proj3_portable_sources}
|
||||
src/proj3/sys/panic_host.cpp
|
||||
src/proj3/mem/page_source_host.cpp
|
||||
)
|
||||
target_include_directories(proj3_portable PUBLIC src)
|
||||
target_compile_options(proj3_portable PRIVATE ${proj3_common_flags})
|
||||
target_compile_definitions(proj3_portable PUBLIC PROJ3_EMBEDDED=0)
|
||||
|
||||
# -- Garde-fou d allocation, en bibliotheque separee -----------------------
|
||||
# Separee parce qu il TUE le processus : on ne le lie que dans les
|
||||
# executables qui pretendent ne rien allouer.
|
||||
add_library(proj3_newguard STATIC src/proj3/mem/new_guard.cpp)
|
||||
target_include_directories(proj3_newguard PUBLIC src)
|
||||
target_compile_options(proj3_newguard PRIVATE ${proj3_common_flags})
|
||||
|
||||
enable_testing()
|
||||
|
||||
# -- Harnais d oracle ------------------------------------------------------
|
||||
add_executable(proj3_oracle
|
||||
test/oracle/oracle.cpp
|
||||
test/oracle/main.cpp
|
||||
test/oracle/pairs_demo.cpp
|
||||
test/oracle/pairs_render.cpp
|
||||
asm/host/demo_fill_x86_64.S
|
||||
)
|
||||
target_link_libraries(proj3_oracle PRIVATE proj3_portable proj3_newguard)
|
||||
target_compile_options(proj3_oracle PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${proj3_common_flags}>)
|
||||
add_test(NAME oracle COMMAND proj3_oracle)
|
||||
|
||||
# -- Preuve que le harnais rejette une implementation fausse ---------------
|
||||
add_executable(proj3_oracle_selftest
|
||||
test/oracle/oracle.cpp
|
||||
test/oracle/selftest_main.cpp
|
||||
test/oracle/pairs_demo.cpp
|
||||
asm/host/demo_fill_x86_64.S
|
||||
)
|
||||
target_link_libraries(proj3_oracle_selftest PRIVATE proj3_portable)
|
||||
target_compile_options(proj3_oracle_selftest PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${proj3_common_flags}>)
|
||||
add_test(NAME oracle_selftest COMMAND proj3_oracle_selftest)
|
||||
|
||||
# -- Tests d arene ---------------------------------------------------------
|
||||
add_executable(proj3_test_arena test/test_arena.cpp)
|
||||
target_link_libraries(proj3_test_arena PRIVATE proj3_portable proj3_newguard)
|
||||
target_compile_options(proj3_test_arena PRIVATE ${proj3_common_flags})
|
||||
add_test(NAME arena COMMAND proj3_test_arena)
|
||||
|
||||
# -- Test du garde-fou : DOIT planter -------------------------------------
|
||||
add_executable(proj3_test_newguard test/test_new_guard.cpp)
|
||||
target_link_libraries(proj3_test_newguard PRIVATE proj3_portable proj3_newguard)
|
||||
target_compile_options(proj3_test_newguard PRIVATE ${proj3_common_flags})
|
||||
add_test(NAME new_guard_traps COMMAND proj3_test_newguard)
|
||||
set_tests_properties(new_guard_traps PROPERTIES WILL_FAIL TRUE)
|
||||
|
||||
# -- Test de portage du rasterizer (golden) --------------------------------
|
||||
add_executable(proj3_test_raster test/test_raster_golden.cpp)
|
||||
target_link_libraries(proj3_test_raster PRIVATE proj3_portable proj3_newguard)
|
||||
target_compile_options(proj3_test_raster PRIVATE ${proj3_common_flags})
|
||||
add_test(NAME raster_golden COMMAND proj3_test_raster
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/test/data/Inter-Regular.ttf"
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/test/data/golden_write.txt")
|
||||
|
||||
# -- Generateur de references depuis Gastinel Write ------------------------
|
||||
# Compile les sources ORIGINALES de Write (ttf.cpp + rasterizer.cpp, qui ne
|
||||
# dependent d aucune API Windows) pour produire l oracle externe du portage.
|
||||
# Optionnel : n existe que si -DPROJ3_WRITE_SRC=<chemin/src> est fourni.
|
||||
if(PROJ3_WRITE_SRC)
|
||||
add_executable(proj3_write_reference
|
||||
tools/write_reference_dump.cpp
|
||||
"${PROJ3_WRITE_SRC}/font/ttf.cpp"
|
||||
"${PROJ3_WRITE_SRC}/render/rasterizer.cpp")
|
||||
target_include_directories(proj3_write_reference PRIVATE "${PROJ3_WRITE_SRC}")
|
||||
target_compile_features(proj3_write_reference PRIVATE cxx_std_20)
|
||||
endif()
|
||||
|
||||
endif()
|
||||
+200
@@ -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_`.
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1,143 @@
|
||||
// asm/syscall.S — wrappers d appels systeme AArch64, assembleur pur.
|
||||
//
|
||||
// Conventions : doc/convention-aarch64.md et doc/convention-syscall.md.
|
||||
//
|
||||
// FORME CANONIQUE, et pourquoi elle est aussi courte :
|
||||
//
|
||||
// proj3_sys_<nom>:
|
||||
// mov x8, #PROJ3_NR_<nom>
|
||||
// svc #0
|
||||
// ret
|
||||
//
|
||||
// L ABI syscall Linux/AArch64 (arch/arm64/kernel/entry.S, et Documentation/
|
||||
// arm64/) fait coincider exactement les registres d arguments de l AAPCS64 et
|
||||
// ceux de l appel systeme :
|
||||
//
|
||||
// argument 1..6 -> x0 x1 x2 x3 x4 x5
|
||||
// numero d appel -> x8
|
||||
// retour -> x0
|
||||
//
|
||||
// Il n y a donc AUCUN mouvement de registre a faire dans le cas general. Le
|
||||
// 6e argument de mmap arrive en x5 par l ABI d appel normale : rien de special
|
||||
// n est requis, contrairement a x86-64 ou r10 remplace rcx.
|
||||
//
|
||||
// Registres detruits par svc : x0 (resultat) et x8 (que nous avons ecrit).
|
||||
// Le noyau preserve x1-x7 et x9-x30. x8 etant caller-saved en AAPCS64, nous
|
||||
// avons le droit de l ecraser sans le sauvegarder.
|
||||
//
|
||||
// ALIGNEMENT DE PILE : aucun de ces wrappers ne touche a sp ni n empile x30.
|
||||
// L alignement 16 octets exige par l AAPCS64 est donc preserve trivialement,
|
||||
// par construction et non par vigilance.
|
||||
//
|
||||
// LA VALEUR DE RETOUR N EST PAS TRANSFORMEE. Le x0 du noyau ressort tel quel,
|
||||
// conformement a l option C de doc/convention-syscall.md. Le test de plage
|
||||
// [-4095, -1] est fait cote C++ par proj3::sys::Result::is_err(), en constexpr
|
||||
// inline, et seulement quand l appelant le demande.
|
||||
|
||||
#include "proj3/sys/syscall_nr.hpp"
|
||||
|
||||
// Macro d emission d un wrapper direct (aucun remaniement d argument).
|
||||
// L usage d une macro ici n est pas de la coquetterie : il garantit que les
|
||||
// 14 wrappers directs sont rigoureusement identiques, donc qu aucun d entre
|
||||
// eux ne peut avoir un prologue ou une transformation qui traine.
|
||||
.macro PROJ3_SYSCALL_DIRECT name, nr
|
||||
.text
|
||||
.balign 4
|
||||
.global proj3_sys_\name
|
||||
.hidden proj3_sys_\name
|
||||
.type proj3_sys_\name, %function
|
||||
proj3_sys_\name:
|
||||
mov x8, #\nr
|
||||
svc #0
|
||||
ret
|
||||
.size proj3_sys_\name, . - proj3_sys_\name
|
||||
.endm
|
||||
|
||||
// --- Fichiers -------------------------------------------------------------
|
||||
|
||||
// open : la table generique AArch64 n a PAS de __NR_open. On passe par
|
||||
// openat avec AT_FDCWD. C est le seul wrapper qui remanie ses arguments,
|
||||
// et c est la raison pour laquelle il n utilise pas la macro.
|
||||
//
|
||||
// entree : x0 = const char* path
|
||||
// x1 = int flags
|
||||
// x2 = int mode (ignore par le noyau sans O_CREAT)
|
||||
// sortie : x0 = fd ou -errno
|
||||
.text
|
||||
.balign 4
|
||||
.global proj3_sys_open
|
||||
.hidden proj3_sys_open
|
||||
.type proj3_sys_open, %function
|
||||
proj3_sys_open:
|
||||
mov x3, x2 // mode -> arg4
|
||||
mov x2, x1 // flags -> arg3
|
||||
mov x1, x0 // path -> arg2
|
||||
mov x0, #PROJ3_AT_FDCWD // dirfd -> arg1
|
||||
mov x8, #PROJ3_NR_openat
|
||||
svc #0
|
||||
ret
|
||||
.size proj3_sys_open, . - proj3_sys_open
|
||||
|
||||
PROJ3_SYSCALL_DIRECT close, PROJ3_NR_close
|
||||
PROJ3_SYSCALL_DIRECT read, PROJ3_NR_read
|
||||
PROJ3_SYSCALL_DIRECT write, PROJ3_NR_write
|
||||
PROJ3_SYSCALL_DIRECT ioctl, PROJ3_NR_ioctl
|
||||
PROJ3_SYSCALL_DIRECT fstat, PROJ3_NR_fstat
|
||||
PROJ3_SYSCALL_DIRECT lseek, PROJ3_NR_lseek
|
||||
|
||||
// --- Memoire --------------------------------------------------------------
|
||||
//
|
||||
// mmap prend six arguments : addr, length, prot, flags, fd, offset.
|
||||
// Le sixieme (offset) arrive en x5 par l AAPCS64 et c est exactement la ou le
|
||||
// noyau l attend. Verifie sur arch/arm64 : le point d entree svc recopie
|
||||
// x0-x5 dans les six premiers champs de pt_regs, sans decalage.
|
||||
// C est la difference avec x86-64, ou l argument 4 doit etre deplace de rcx
|
||||
// vers r10 parce que syscall ecrase rcx.
|
||||
|
||||
PROJ3_SYSCALL_DIRECT mmap, PROJ3_NR_mmap
|
||||
PROJ3_SYSCALL_DIRECT munmap, PROJ3_NR_munmap
|
||||
PROJ3_SYSCALL_DIRECT madvise, PROJ3_NR_madvise
|
||||
|
||||
// --- Temps ----------------------------------------------------------------
|
||||
//
|
||||
// Note d honnetete : clock_gettime passe ici par un vrai svc, PAS par le
|
||||
// vDSO. Le vDSO eviterait la transition en mode noyau et couterait environ
|
||||
// vingt fois moins cher. Ce n est pas un oubli : utiliser le vDSO demande de
|
||||
// parcourir l auxiliary vector (AT_SYSINFO_EHDR) et de resoudre un symbole
|
||||
// ELF au demarrage, ce qui n est pas dans le perimetre du chantier 2. Dette
|
||||
// documentee, a traiter au chantier de mesure de latence — la ou elle
|
||||
// comptera vraiment.
|
||||
|
||||
PROJ3_SYSCALL_DIRECT clock_gettime, PROJ3_NR_clock_gettime
|
||||
PROJ3_SYSCALL_DIRECT nanosleep, PROJ3_NR_nanosleep
|
||||
|
||||
// --- Processus ------------------------------------------------------------
|
||||
|
||||
PROJ3_SYSCALL_DIRECT getpid, PROJ3_NR_getpid
|
||||
|
||||
// exit et exit_group ne reviennent pas. Le `ret` de la macro serait mort ;
|
||||
// on met un brk a la place pour que, si le noyau revenait (il ne le fait
|
||||
// pas), on s arrete net au lieu de partir dans du code indefini.
|
||||
.text
|
||||
.balign 4
|
||||
.global proj3_sys_exit
|
||||
.hidden proj3_sys_exit
|
||||
.type proj3_sys_exit, %function
|
||||
proj3_sys_exit:
|
||||
mov x8, #PROJ3_NR_exit
|
||||
svc #0
|
||||
brk #0
|
||||
.size proj3_sys_exit, . - proj3_sys_exit
|
||||
|
||||
.text
|
||||
.balign 4
|
||||
.global proj3_sys_exit_group
|
||||
.hidden proj3_sys_exit_group
|
||||
.type proj3_sys_exit_group, %function
|
||||
proj3_sys_exit_group:
|
||||
mov x8, #PROJ3_NR_exit_group
|
||||
svc #0
|
||||
brk #0
|
||||
.size proj3_sys_exit_group, . - proj3_sys_exit_group
|
||||
|
||||
.section .note.GNU-stack,"",@progbits
|
||||
@@ -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)
|
||||
@@ -0,0 +1,109 @@
|
||||
# ADR-0001 — Socle de compilation : C++20 bride, absence de libc, double cible
|
||||
|
||||
- Statut : accepte
|
||||
- Date : 2026-09-05
|
||||
- Portee : chantier 1 (structure du depot, chaine de compilation)
|
||||
|
||||
## Contexte
|
||||
|
||||
Le projet vise un environnement graphique deterministe sur AArch64/Linux, avec
|
||||
trois piliers : determinisme de latence, budget memoire explicite, acces direct
|
||||
justifie. Aucune ligne de code fonctionnel n existe encore. Il faut fixer le
|
||||
socle avant d ecrire quoi que ce soit, sinon les choix se prendront par defaut
|
||||
et par accident.
|
||||
|
||||
## Decision
|
||||
|
||||
### 1. C++20, bride
|
||||
|
||||
Compile avec `-std=c++20 -nostdlib -fno-exceptions -fno-rtti
|
||||
-fno-threadsafe-statics -Wall -Wextra -O2`.
|
||||
|
||||
- `-fno-exceptions` : une exception est un chemin de sortie de latence non
|
||||
bornee (deroulement de pile, tables `.eh_frame`, allocation du bloc
|
||||
d exception). Incompatible avec le pilier 1.
|
||||
- `-fno-rtti` : `dynamic_cast` et `typeid` impliquent une comparaison de
|
||||
chaines ou une marche de hierarchie a l execution. Le projet n a aucun
|
||||
polymorphisme dynamique prevu.
|
||||
- `-fno-threadsafe-statics` : sans cette option, chaque variable statique
|
||||
locale non triviale genere un appel a `__cxa_guard_acquire` — donc une
|
||||
dependance libc et un branchement supplementaire a chaque acces. Le projet
|
||||
n a pas d initialisation statique dynamique (cf. ADR-0003 sur les arenes).
|
||||
- `-O2` et non `-O3` : `-O3` active un deroulage et une vectorisation
|
||||
agressifs dont le gain est incertain et le cout en taille de code (donc en
|
||||
pression sur le cache d instructions, donc en variance) est reel. Le projet
|
||||
optimisera par des noyaux assembleur explicites, pas par des drapeaux.
|
||||
- `-Wall -Wextra` avec zero warning tolere. Aucun `-Werror` en local pour ne
|
||||
pas bloquer un debogage, mais la regle est contractuelle.
|
||||
|
||||
Ce qui reste autorise du C++ : `constexpr`, templates, `<type_traits>` et les
|
||||
autres en-tetes purement compile-time. Aucun conteneur, aucun `std::string`,
|
||||
aucun flux.
|
||||
|
||||
### 2. Aucune libc, point d entree maison
|
||||
|
||||
Le binaire final est lie avec `-nostdlib -nostartfiles -static -Wl,-e,_start`.
|
||||
`_start` est ecrit en assembleur (`asm/start.S`), appelle une fonction C++
|
||||
unique, puis termine le processus par `exit_group` via `svc #0`.
|
||||
|
||||
Raison : le pilier 3. Une libc apporte un initialiseur (`__libc_start_main`),
|
||||
un allocateur (`malloc`), des tampons de flux, des gestionnaires TLS et une
|
||||
resolution de symboles dynamique — toutes choses dont le projet ne veut ni le
|
||||
comportement memoire ni la variance. Le cout assume est qu il faut ecrire
|
||||
soi-meme tout ce dont on a besoin : les wrappers syscall (chantier 2), les
|
||||
routines memoire, les conversions numeriques.
|
||||
|
||||
Consequence non evidente, notee ici pour memoire : sans `crt1.o`, il n y a
|
||||
**aucun appel aux constructeurs statiques** (`.init_array`). Le projet ne doit
|
||||
donc dependre d aucune initialisation statique non triviale, ou bien
|
||||
`_start` devra parcourir `.init_array` explicitement. Le choix actuel est le
|
||||
premier : pas d initialisation statique dynamique du tout.
|
||||
|
||||
### 3. Double cible, asymetrique
|
||||
|
||||
- **Cible embarquee** `aarch64-linux`, freestanding : le produit.
|
||||
- **Cible hote**, la machine de developpement : l outillage seul (harnais
|
||||
d oracle du chantier 4, generateurs de references).
|
||||
|
||||
**La cible hote a le droit d utiliser la libc de l hote.** Elle ne produit
|
||||
jamais de binaire livre. Cette asymetrie est deliberee : le harnais doit
|
||||
pouvoir s executer sans telephone, sans affichage et sans emulateur, sinon il
|
||||
ne sera pas execute.
|
||||
|
||||
La frontiere est materialisee dans `CMakeLists.txt` par la liste
|
||||
`proj3_portable_sources`. Ces unites de compilation sont freestanding par
|
||||
construction et compilees a l identique par les deux cibles ; ce sont les
|
||||
seules partagees. Tout le reste est specifique a une cible et le nom du
|
||||
fichier le dit (`page_source_linux.cpp` / `page_source_host.cpp`).
|
||||
|
||||
Risque accepte et surveille : une divergence de comportement flottant ou
|
||||
d endianness entre hote x86-64 et cible AArch64 rendrait la comparaison du
|
||||
harnais trompeuse. Les hypotheses correspondantes sont listees dans
|
||||
`doc/methode-oracle.md` (mode d arrondi IEEE identique, little-endian des deux
|
||||
cotes, pas de x87 80 bits car x86-64 utilise SSE2 pour `float`/`double`).
|
||||
|
||||
## Alternatives ecartees
|
||||
|
||||
- **Utiliser une libc minimale (musl, picolibc).** Aurait fait gagner du temps
|
||||
au demarrage. Ecartee : elle reintroduit `malloc` et un initialiseur qu il
|
||||
faudrait ensuite neutraliser un par un, et elle brouille la frontiere que
|
||||
l ADR cherche precisement a etablir.
|
||||
- **Cible unique aarch64, tests sous qemu-user.** Ecartee : ajoute une
|
||||
dependance d emulation au chemin de test le plus frequent. Le harnais doit
|
||||
etre trivial a lancer, sinon il pourrit.
|
||||
- **Meson ou Makefile a la main.** Ecarte : CMake+Ninja donne la
|
||||
cross-compilation par fichier de toolchain et un graphe de dependances
|
||||
correct sans travail supplementaire. Aucun besoin exotique ici.
|
||||
|
||||
## Consequences
|
||||
|
||||
- Il faut ecrire des wrappers syscall avant tout code utile (chantier 2).
|
||||
- Il faut ecrire un allocateur avant tout code de rendu (chantier 3).
|
||||
- Toute tentation d appeler `memcpy` doit etre traitee : `-ffreestanding`
|
||||
autorise le compilateur a **generer** des appels a `memcpy`/`memset`/
|
||||
`memmove`/`memcmp` meme sans libc. Le projet doit fournir ces quatre
|
||||
symboles lui-meme. C est note comme dette a traiter au moment ou un lien
|
||||
echoue dessus ; a ce jour aucun appel n a ete genere (verifie par
|
||||
`llvm-nm -u` sur le binaire, qui ne liste aucun symbole indefini).
|
||||
- L absence de `-Werror` repose sur la discipline. Si elle se relache, on
|
||||
l ajoutera.
|
||||
@@ -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).
|
||||
@@ -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.
|
||||
@@ -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.
|
||||
@@ -0,0 +1,200 @@
|
||||
# Convention de registres AArch64 — reference normative du projet
|
||||
|
||||
Ce document fait autorite sur tout fichier `.S` du depot. Toute routine
|
||||
assembleur qui s en ecarte doit le declarer en commentaire d en-tete, avec la
|
||||
raison.
|
||||
|
||||
Cible : AArch64 (ARMv8-A, A64 uniquement, pas de Thumb, pas d AArch32),
|
||||
Linux, ABI LP64.
|
||||
|
||||
---
|
||||
|
||||
## 1. Rappel AAPCS64 (Procedure Call Standard for the Arm 64-bit Architecture)
|
||||
|
||||
### 1.1 Registres generaux
|
||||
|
||||
| Registre | Role AAPCS64 | Sauvegarde |
|
||||
|-----------|--------------|-----------|
|
||||
| `x0`-`x7` | Arguments entiers/pointeurs 1 a 8, et valeurs de retour (`x0`, ou `x0`+`x1` pour 128 bits) | caller-saved |
|
||||
| `x8` | Adresse du resultat indirect (XR) quand la valeur de retour est trop grosse pour les registres. **Sous Linux c est aussi le registre du numero de syscall.** | caller-saved |
|
||||
| `x9`-`x15`| Temporaires | caller-saved |
|
||||
| `x16` (IP0), `x17` (IP1) | Registres d appel intra-procedure, utilisables par l editeur de liens pour les veneers. Ne jamais supposer qu ils survivent a un `bl`. | caller-saved |
|
||||
| `x18` | Registre de plateforme. Sous Linux ELF il est libre, mais d autres environnements (Windows, Darwin, certains SDK) le reservent. **Regle du projet : `x18` est interdit d usage.** Cout nul, portabilite gagnee. | reserve |
|
||||
| `x19`-`x28` | Variables locales | **callee-saved** |
|
||||
| `x29` (FP) | Pointeur de trame | **callee-saved** |
|
||||
| `x30` (LR) | Registre de lien : adresse de retour deposee par `bl`/`blr` | **callee-saved** (a empiler des qu on appelle soi-meme) |
|
||||
| `sp` | Pointeur de pile. Ce n est pas `x31`. | special |
|
||||
| `xzr`/`wzr` (encodes 31) | Registre zero : lit 0, absorbe les ecritures | special |
|
||||
|
||||
`w0`-`w30` sont les moities basses 32 bits. **Ecrire dans `wN` met a zero les
|
||||
32 bits hauts de `xN`.** C est une source de bugs classique quand on manipule
|
||||
un `int` puis qu on l utilise comme offset 64 bits : il faut un `sxtw` explicite
|
||||
pour l extension de signe.
|
||||
|
||||
### 1.2 Pile
|
||||
|
||||
- `sp` doit etre **aligne sur 16 octets** a chaque frontiere d appel public
|
||||
(`bl`, `ret`) et a chaque acces memoire qui l utilise comme base. Un `sp`
|
||||
desaligne provoque un `SIGBUS` sur AArch64 : ce n est pas une penalite de
|
||||
performance, c est un plantage.
|
||||
- La pile croit vers le bas. Prologue standard :
|
||||
|
||||
```asm
|
||||
stp x29, x30, [sp, #-16]! // empile FP+LR, decremente sp de 16
|
||||
mov x29, sp
|
||||
// ... corps ...
|
||||
ldp x29, x30, [sp], #16 // depile, reincremente sp
|
||||
ret
|
||||
```
|
||||
|
||||
- Il n existe **pas de red zone** en AAPCS64 : la memoire sous `sp` peut etre
|
||||
ecrasee a tout instant (signal, debogueur). Toute donnee temporaire doit etre
|
||||
au-dessus de `sp` apres decrement.
|
||||
- Reserver de la place se fait en un seul `sub sp, sp, #N` avec N multiple de 16.
|
||||
|
||||
### 1.3 Arguments qui ne tiennent pas dans les registres
|
||||
|
||||
Au-dela de 8 arguments entiers, les suivants passent sur la pile, alignes sur
|
||||
8 octets, dans l ordre de declaration, a partir de `[sp]` au moment de l appel.
|
||||
Le projet **n a aucune routine a plus de 8 arguments** ; si le cas se presente,
|
||||
c est un signal de conception, pas un probleme d ABI a resoudre.
|
||||
|
||||
### 1.4 Registres vectoriels (NEON / SIMD, `v0`-`v31`)
|
||||
|
||||
| Registre | Role AAPCS64 | Sauvegarde |
|
||||
|-----------|--------------|-----------|
|
||||
| `v0`-`v7` | Arguments flottants/vectoriels 1 a 8, valeurs de retour | caller-saved |
|
||||
| `v8`-`v15`| Variables locales — **mais seuls les 64 bits BAS (`d8`-`d15`) sont callee-saved.** Les 64 bits hauts sont caller-saved. | **partiellement callee-saved** |
|
||||
| `v16`-`v31` | Temporaires | caller-saved |
|
||||
|
||||
Le point `v8`-`v15` est le piege classique : une routine qui utilise `v8` en
|
||||
128 bits complet doit sauvegarder `d8`, pas `v8`, pour respecter l ABI — et si
|
||||
elle veut preserver les 128 bits pour son propre compte, c est son affaire,
|
||||
pas celle de l appelant.
|
||||
|
||||
**Regle du projet :** dans une routine A64 exposee (`.global`), on **n utilise
|
||||
pas du tout `v8`-`v15`**. On dispose de 24 registres vectoriels caller-saved
|
||||
(`v0`-`v7`, `v16`-`v31`), ce qui suffit largement pour tous les noyaux de
|
||||
composition prevus, et cela supprime entierement la question de la
|
||||
sauvegarde/restauration vectorielle. Si un noyau futur demande plus de 24
|
||||
registres vectoriels, c est que son ordonnancement est a revoir.
|
||||
|
||||
`fpsr`/`fpcr` : aucune routine du projet ne modifie le mode d arrondi ni les
|
||||
drapeaux d exception flottante. Le mode d arrondi est **round-to-nearest-even**,
|
||||
suppose etabli au demarrage et jamais touche. Cette hypothese est ce qui rend
|
||||
valide la comparaison octet-a-octet du harnais d oracle (cf. `methode-oracle.md`).
|
||||
|
||||
---
|
||||
|
||||
## 2. Conventions internes aux routines qui ne suivent pas l AAPCS64
|
||||
|
||||
Certaines routines de rendu sont des **feuilles** (elles n appellent personne)
|
||||
et sont appelees exclusivement depuis d autres routines assembleur du meme
|
||||
fichier. Pour celles-la seulement, on s autorise une convention allegee.
|
||||
|
||||
### 2.1 Classe "routine feuille interne" (suffixe `__leaf`, symbole local `.L`)
|
||||
|
||||
Contraintes :
|
||||
|
||||
1. Elle **n emet aucun `bl`/`blr`**. Consequence : elle n a pas a empiler `x30`.
|
||||
2. Elle **ne touche pas a `sp`** du tout. Pas de trame, pas de spill. Si elle a
|
||||
besoin de spiller, elle n est pas une feuille : on la promeut en routine
|
||||
AAPCS64 normale.
|
||||
3. Registres qu elle peut ecraser librement : `x0`-`x17` (sauf `x18`, interdit),
|
||||
`v0`-`v7`, `v16`-`v31`.
|
||||
4. Registres qu elle doit laisser intacts : `x19`-`x30`, `sp`, `v8`-`v15`.
|
||||
Autrement dit : **la convention interne n autorise pas a casser plus que
|
||||
l AAPCS64 n autorise deja.** Elle autorise seulement a *omettre* le
|
||||
prologue/epilogue.
|
||||
5. Elle documente en en-tete : ses entrees (registre par registre), ses sorties,
|
||||
et la liste exacte des registres qu elle detruit.
|
||||
|
||||
Ce choix est deliberement conservateur. Une convention exotique
|
||||
(`x19` accumulateur global, par exemple) ferait gagner un registre et couterait
|
||||
une classe entiere de bugs non reproductibles a chaque insertion d appel. Le
|
||||
pilier 1 (determinisme) inclut le determinisme du debogage.
|
||||
|
||||
### 2.2 Registres a usage reserve global
|
||||
|
||||
**Il n y en a aucun.** Aucun registre ne porte de valeur vivante entre deux
|
||||
routines du projet. Pas de pointeur de contexte permanent en `x28`, pas de base
|
||||
de framebuffer en `x27`.
|
||||
|
||||
Raison : un registre reserve globalement est un etat cache. Il oblige chaque
|
||||
nouvelle routine a connaitre une convention non exprimee dans sa signature, et
|
||||
il rend tout appel vers du code externe (ou genere par le compilateur)
|
||||
potentiellement destructeur. Le gain — economiser un `ldr` par routine — est
|
||||
sans commune mesure avec le cout.
|
||||
|
||||
Cette decision est **definitive**. Si elle devait etre revue, ce serait par un
|
||||
ADR dedie, pas par un commentaire dans un `.S`.
|
||||
|
||||
---
|
||||
|
||||
## 3. Nommage des symboles et visibilite
|
||||
|
||||
### 3.1 Nommage
|
||||
|
||||
- Tout symbole assembleur visible depuis le C++ est declare `extern "C"` cote
|
||||
C++ et prefixe `proj3_` cote assembleur.
|
||||
- Forme : `proj3_<module>_<action>`, en minuscules, mots separes par `_`.
|
||||
Exemples : `proj3_sys_write`, `proj3_fill_bytes_asm`.
|
||||
- Les routines qui sont la version assembleur d une paire d oracle portent le
|
||||
suffixe `_asm`. La version C++ de reference porte le suffixe `_ref`.
|
||||
Une version volontairement fausse (test du harnais) porte `_asm_broken`.
|
||||
- Les symboles locaux a un fichier commencent par `.L` : l assembleur ne les
|
||||
emet pas dans la table des symboles, ils n apparaissent donc ni dans `nm` ni
|
||||
dans les traces.
|
||||
- Les etiquettes de boucle internes sont `.L<routine>_<role>` :
|
||||
`.Lfill_bytes_loop`, `.Lfill_bytes_tail`. Jamais `1:` / `1b`, illisible en
|
||||
revue.
|
||||
|
||||
### 3.2 Visibilite — boilerplate obligatoire
|
||||
|
||||
Toute routine exportee est declaree exactement ainsi :
|
||||
|
||||
```asm
|
||||
.text
|
||||
.balign 4
|
||||
.global proj3_exemple
|
||||
.hidden proj3_exemple // pas d export dynamique : rien a interposer
|
||||
.type proj3_exemple, %function
|
||||
proj3_exemple:
|
||||
// ...
|
||||
ret
|
||||
.size proj3_exemple, . - proj3_exemple
|
||||
```
|
||||
|
||||
- `.balign 4` : toutes les instructions A64 font 4 octets ; l alignement
|
||||
explicite protege des sections concatenees a la main.
|
||||
- `.hidden` : le binaire est statique et sans libc, aucune interposition n a de
|
||||
sens. Cela evite au passage toute entree de PLT.
|
||||
- `.type`/`.size` : necessaires pour que `llvm-objdump`, `perf` et un debogueur
|
||||
retrouvent les bornes de la fonction. Un `.size` manquant donne des profils
|
||||
inexploitables — ce qui, sur un projet dont la these est la mesure de latence,
|
||||
est disqualifiant.
|
||||
|
||||
### 3.3 Sections
|
||||
|
||||
- Code : `.text`.
|
||||
- Constantes en lecture seule : `.section .rodata,"a",@progbits`.
|
||||
- **Aucune section `.data` ni `.bss` dans un fichier `.S`.** Toute donnee
|
||||
mutable vit dans une arene (cf. chantier 3). Un `.S` qui declare de l etat
|
||||
mutable contourne le budget memoire explicite du pilier 2.
|
||||
- Aucun fichier `.S` n emet de section a la fois executable et inscriptible.
|
||||
- Chaque `.S` se termine par `.section .note.GNU-stack,"",@progbits` afin que
|
||||
l editeur de liens ne marque pas la pile executable.
|
||||
|
||||
---
|
||||
|
||||
## 4. Notes de portabilite entre les deux cibles materielles
|
||||
|
||||
- Pixel 3a (`sargo`) : Snapdragon 670, coeurs Kryo 360 (Cortex-A75/A55),
|
||||
ARMv8.0-A avec extensions ARMv8.2 partielles. **Ne pas supposer** la presence
|
||||
de LSE (atomiques `casal`), de dotprod, ni de FP16 arithmetique.
|
||||
- Poco F5 Pro (`mondrian`) : SD 8+ Gen 1, ARMv8.4+, beaucoup plus riche.
|
||||
- **Regle : le code assembleur ecrit ne suppose que la base ARMv8.0-A + NEON.**
|
||||
Toute utilisation d une extension doit passer par une detection au runtime
|
||||
(lecture de `AT_HWCAP` dans l auxiliary vector) et un chemin de repli, sur le
|
||||
modele du repli memoire du chantier 3. Aucune extension n est utilisee a ce
|
||||
jour.
|
||||
@@ -0,0 +1,152 @@
|
||||
# Convention de remontee d erreur syscall — decision definitive
|
||||
|
||||
Statut : **arrete**. Une seule convention dans tout le projet. Tout code qui
|
||||
appelle un wrapper syscall suit celle-ci, sans exception ni variante locale.
|
||||
|
||||
---
|
||||
|
||||
## 1. Le probleme
|
||||
|
||||
Le noyau Linux ne dispose pas d `errno`. Sur AArch64, `svc #0` place dans `x0`
|
||||
soit le resultat de l appel, soit **l oppose du code d erreur**. Un resultat
|
||||
est une erreur si et seulement si :
|
||||
|
||||
```
|
||||
-4095 <= x0 <= -1
|
||||
```
|
||||
|
||||
La borne `-4095` n est pas decorative : `MAX_ERRNO` vaut 4095 dans le noyau
|
||||
(`include/linux/err.h`), et c est exactement ce que fait la macro
|
||||
`IS_ERR_VALUE`. Certains appels retournent legitimement des valeurs negatives
|
||||
hors de cette plage — `lseek` sur un fichier de plus de 8 exaoctets, `mmap`
|
||||
retournant une adresse dont le bit 63 est a 1 sur une configuration a 64 bits
|
||||
d espace utilisateur. Un test approximatif du genre `if (ret < 0)` est donc
|
||||
**faux**, pas seulement imprecis.
|
||||
|
||||
C est la libc qui, normalement, traduit cela en `-1` + `errno`. Sans libc,
|
||||
il faut choisir.
|
||||
|
||||
---
|
||||
|
||||
## 2. Options envisagees
|
||||
|
||||
### Option A — Valeur sentinelle plus etat global (mimer errno)
|
||||
|
||||
Le wrapper retourne `-1` en cas d echec et depose le code dans une variable
|
||||
globale `proj3_last_errno`.
|
||||
|
||||
| Pilier | Evaluation |
|
||||
|---|---|
|
||||
| 1. Determinisme de latence | Neutre en soi, mais impose une variable globale mutable. Des qu on aura plus d un fil d execution ou un gestionnaire de signal, il faut du stockage par contexte : c est le chemin qui mene a `__errno_location()`, donc a un appel indirect non inlinable sur le chemin chaud. |
|
||||
| 2. Budget memoire explicite | Une section `.data`/`.bss` mutable hors arene. Contredit directement la regle "toute donnee mutable vit dans une arene" (`convention-aarch64.md` 3.3). |
|
||||
| 3. Acces direct justifie | C est reconstruire la couche libc qu on a explicitement decide de ne pas avoir. Abstraction non justifiee. |
|
||||
|
||||
Verdict : **rejetee**. Elle detruit l information (deux appels, le second
|
||||
ecrase le code du premier) et introduit un etat global cache.
|
||||
|
||||
### Option B — Structure de retour `{ valeur, code_erreur }`
|
||||
|
||||
Le wrapper retourne un agregat de deux `i64`.
|
||||
|
||||
| Pilier | Evaluation |
|
||||
|---|---|
|
||||
| 1. Determinisme de latence | Un agregat de 16 octets rentre dans `x0`+`x1` en AAPCS64, donc pas de retour indirect ni de trafic memoire. Cout nul en theorie. En pratique, cela oblige chaque wrapper assembleur a produire deux registres, donc a tester la plage d erreur **dans** le wrapper : une comparaison et un `csel` par appel, meme quand l appelant ignore l erreur. |
|
||||
| 2. Budget memoire | Rien a allouer. Correct. |
|
||||
| 3. Acces direct | La valeur brute rendue par le noyau est deja porteuse des deux informations. Les scinder puis les recombiner cote appelant est du travail ajoute pour rien. |
|
||||
|
||||
Verdict : **rejetee**, mais de peu. Le seul reproche serieux est le travail
|
||||
inconditionnel dans le wrapper alors que la meme information est disponible
|
||||
gratuitement.
|
||||
|
||||
### Option C — Valeur brute du noyau, encapsulee dans un type a cout nul
|
||||
|
||||
Le wrapper retourne exactement ce que `svc #0` a mis dans `x0`, tel quel. Cote
|
||||
C++, ce `i64` est enveloppe dans une structure d un seul membre,
|
||||
`proj3::sys::Result`, dont toutes les methodes sont `constexpr` et inlinees :
|
||||
`is_err()`, `err()`, `value()`, `ptr()`, `fd()`.
|
||||
|
||||
| Pilier | Evaluation |
|
||||
|---|---|
|
||||
| 1. Determinisme de latence | Le wrapper assembleur ne fait **rien** apres le `svc` : `svc #0 ; ret`. Cout strictement minimal et constant. Le test de plage n est paye que par l appelant qui le demande. |
|
||||
| 2. Budget memoire | Aucun etat, aucune allocation, aucune section mutable. |
|
||||
| 3. Acces direct | Zero couche : la valeur traversee est celle du noyau, bit pour bit. La structure n existe qu au niveau du type, pas a l execution (`sizeof == 8`, trivialement copiable, passee en registre). |
|
||||
|
||||
Verdict : **retenue.**
|
||||
|
||||
---
|
||||
|
||||
## 3. Convention retenue
|
||||
|
||||
### 3.1 Cote assembleur
|
||||
|
||||
Chaque wrapper est de la forme :
|
||||
|
||||
```asm
|
||||
proj3_sys_<nom>:
|
||||
mov x8, #PROJ3_NR_<nom>
|
||||
svc #0
|
||||
ret
|
||||
```
|
||||
|
||||
Aucune transformation. La valeur de retour est le `x0` du noyau.
|
||||
Consequence directe : **aucun wrapper n a de prologue, ne touche a `sp`, ni
|
||||
n empile `x30`.** L alignement de pile est preserve trivialement.
|
||||
|
||||
### 3.2 Cote C++
|
||||
|
||||
```cpp
|
||||
namespace proj3::sys {
|
||||
|
||||
// Valeur de retour brute d un appel systeme Linux.
|
||||
// sizeof == 8, trivialement copiable : passee et rendue en registre.
|
||||
struct Result {
|
||||
i64 raw;
|
||||
|
||||
// Plage d erreur exacte du noyau : [-4095, -1]. Ni approximative,
|
||||
// ni "raw < 0".
|
||||
constexpr bool is_err() const { return raw < 0 && raw >= -4095; }
|
||||
constexpr bool is_ok() const { return !is_err(); }
|
||||
|
||||
// Code errno positif. Precondition : is_err().
|
||||
constexpr i32 err() const { return static_cast<i32>(-raw); }
|
||||
|
||||
// Valeur utile. Precondition : is_ok().
|
||||
constexpr i64 value() const { return raw; }
|
||||
constexpr i32 fd() const { return static_cast<i32>(raw); }
|
||||
void* ptr() const { return reinterpret_cast<void*>(raw); }
|
||||
};
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
### 3.3 Regles d usage — obligatoires
|
||||
|
||||
1. **Toute valeur `Result` est testee avec `is_err()` avant tout usage de
|
||||
`value()`, `fd()` ou `ptr()`.** Il n existe pas de conversion implicite vers
|
||||
un entier ou un booleen : le type ne se laisse pas utiliser par accident.
|
||||
2. **Ignorer un `Result` est explicite.** Le type est marque
|
||||
`[[nodiscard]]` ; l ignorer demande d ecrire `(void)`. Le seul cas ou c est
|
||||
legitime est `close()` en chemin de sortie.
|
||||
3. **Aucun code du projet ne stocke un `errno`.** Un code d erreur est traite
|
||||
la ou il apparait : soit il est recuperable et le chemin de repli est pris
|
||||
sur place (c est le cas du repli `MAP_HUGETLB` -> THP -> `mmap` simple),
|
||||
soit il ne l est pas et on appelle `panic()` avec le nom de l appel et le
|
||||
code. Rien n est mis de cote pour plus tard.
|
||||
4. **`EINTR` n est jamais reessaye en boucle silencieuse.** Une boucle de
|
||||
retry est une latence non bornee, donc une violation du pilier 1. Le projet
|
||||
n installe aucun gestionnaire de signal ; si `EINTR` apparait, c est un
|
||||
evenement inattendu et il doit remonter.
|
||||
5. Les constantes `errno` utilisees sont definies dans
|
||||
`src/proj3/sys/errno.hpp`, avec leur source. On ne definit que celles qu on
|
||||
teste effectivement.
|
||||
|
||||
### 3.4 Ce que cette convention coute
|
||||
|
||||
- L appelant doit se souvenir que `mmap` peut legitimement rendre un pointeur
|
||||
dont la valeur signee est negative hors plage d erreur. `is_err()` gere ce
|
||||
cas correctement, mais un appelant qui ecrirait `if (r.raw < 0)` a la main
|
||||
aurait tort. C est le seul piege, et il est nomme ici.
|
||||
- Il n y a pas de message d erreur lisible associe a un code. On imprime le
|
||||
numero. Une table `errno -> chaine` couterait plusieurs kilooctets de
|
||||
`.rodata` pour du confort de debogage ; si elle devient necessaire, elle sera
|
||||
conditionnee a un build de debogage, par un ADR.
|
||||
@@ -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.
|
||||
@@ -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.
|
||||
@@ -0,0 +1,58 @@
|
||||
// base/cstring.cpp — les quatre symboles que le compilateur peut emettre seul.
|
||||
//
|
||||
// COMPILE UNIQUEMENT POUR LA CIBLE EMBARQUEE. Sur l hote, la libc les fournit
|
||||
// et les redefinir provoquerait un conflit de symboles.
|
||||
//
|
||||
// Pourquoi ce fichier existe : meme avec -nostdlib -ffreestanding, GCC et
|
||||
// Clang se reservent le droit de transformer une boucle de copie ou une
|
||||
// initialisation d agregat en appel a memcpy / memset / memmove / memcmp.
|
||||
// C est documente et parfaitement legal de leur part. Sans ces definitions,
|
||||
// le lien echoue avec un symbole indefini au moment le moins pratique.
|
||||
//
|
||||
// -fno-builtin est passe a la compilation pour eviter que le compilateur ne
|
||||
// reconnaisse ces definitions et ne les remplace par un appel a elles-memes.
|
||||
|
||||
#include "proj3/base/types.hpp"
|
||||
|
||||
using proj3::i32;
|
||||
using proj3::u8;
|
||||
using proj3::usize;
|
||||
|
||||
extern "C" {
|
||||
|
||||
void* memset(void* dst, int value, usize n) {
|
||||
u8* p = static_cast<u8*>(dst);
|
||||
const u8 v = static_cast<u8>(value);
|
||||
for (usize i = 0; i < n; ++i) p[i] = v;
|
||||
return dst;
|
||||
}
|
||||
|
||||
void* memcpy(void* dst, const void* src, usize n) {
|
||||
u8* d = static_cast<u8*>(dst);
|
||||
const u8* s = static_cast<const u8*>(src);
|
||||
for (usize i = 0; i < n; ++i) d[i] = s[i];
|
||||
return dst;
|
||||
}
|
||||
|
||||
void* memmove(void* dst, const void* src, usize n) {
|
||||
u8* d = static_cast<u8*>(dst);
|
||||
const u8* s = static_cast<const u8*>(src);
|
||||
if (d == s || n == 0) return dst;
|
||||
if (d < s) {
|
||||
for (usize i = 0; i < n; ++i) d[i] = s[i];
|
||||
} else {
|
||||
for (usize i = n; i-- > 0;) d[i] = s[i];
|
||||
}
|
||||
return dst;
|
||||
}
|
||||
|
||||
int memcmp(const void* a, const void* b, usize n) {
|
||||
const u8* x = static_cast<const u8*>(a);
|
||||
const u8* y = static_cast<const u8*>(b);
|
||||
for (usize i = 0; i < n; ++i) {
|
||||
if (x[i] != y[i]) return static_cast<i32>(x[i]) - static_cast<i32>(y[i]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
} // extern "C"
|
||||
@@ -0,0 +1,68 @@
|
||||
// base/fmt.hpp — formatage entier minimal, freestanding, sans allocation.
|
||||
//
|
||||
// Chaque fonction ecrit dans un tampon fourni par l appelant et rend le
|
||||
// nombre d octets ecrits. Aucun etat, aucune allocation, aucun appel a la
|
||||
// libc : utilisable depuis un chemin de panique.
|
||||
#pragma once
|
||||
|
||||
#include "proj3/base/types.hpp"
|
||||
|
||||
namespace proj3 {
|
||||
|
||||
inline usize str_len(const char* s) {
|
||||
usize n = 0;
|
||||
while (s[n] != '\0') ++n;
|
||||
return n;
|
||||
}
|
||||
|
||||
// Tampon minimal : 20 chiffres pour un u64, 21 avec le signe d un i64.
|
||||
inline constexpr usize kDecBufSize = 24;
|
||||
|
||||
inline usize fmt_u64(char* out, usize cap, u64 v) {
|
||||
char tmp[kDecBufSize];
|
||||
usize n = 0;
|
||||
do {
|
||||
tmp[n++] = static_cast<char>('0' + (v % 10u));
|
||||
v /= 10u;
|
||||
} while (v != 0 && n < sizeof(tmp));
|
||||
if (n > cap) return 0;
|
||||
for (usize i = 0; i < n; ++i) out[i] = tmp[n - 1 - i];
|
||||
return n;
|
||||
}
|
||||
|
||||
inline usize fmt_i64(char* out, usize cap, i64 v) {
|
||||
if (v >= 0) return fmt_u64(out, cap, static_cast<u64>(v));
|
||||
if (cap == 0) return 0;
|
||||
out[0] = '-';
|
||||
// Negation via u64 : -v deborde pour v == INT64_MIN, pas la soustraction
|
||||
// depuis zero en non signe.
|
||||
const u64 mag = 0u - static_cast<u64>(v);
|
||||
const usize n = fmt_u64(out + 1, cap - 1, mag);
|
||||
return n == 0 ? 0 : n + 1;
|
||||
}
|
||||
|
||||
inline usize fmt_hex_u64(char* out, usize cap, u64 v) {
|
||||
static const char kDigits[] = "0123456789abcdef";
|
||||
char tmp[16];
|
||||
usize n = 0;
|
||||
do {
|
||||
tmp[n++] = kDigits[v & 0xFu];
|
||||
v >>= 4;
|
||||
} while (v != 0 && n < sizeof(tmp));
|
||||
if (n + 2 > cap) return 0;
|
||||
out[0] = '0';
|
||||
out[1] = 'x';
|
||||
for (usize i = 0; i < n; ++i) out[2 + i] = tmp[n - 1 - i];
|
||||
return n + 2;
|
||||
}
|
||||
|
||||
// Deux chiffres hexadecimaux, sans prefixe : pour les vidages d octets.
|
||||
inline usize fmt_hex_u8(char* out, usize cap, u8 v) {
|
||||
static const char kDigits[] = "0123456789abcdef";
|
||||
if (cap < 2) return 0;
|
||||
out[0] = kDigits[(v >> 4) & 0xFu];
|
||||
out[1] = kDigits[v & 0xFu];
|
||||
return 2;
|
||||
}
|
||||
|
||||
} // namespace proj3
|
||||
@@ -0,0 +1,84 @@
|
||||
// base/math.hpp — le strict minimum de mathematiques flottantes, sans libm.
|
||||
//
|
||||
// HYPOTHESES, valables sur les deux cibles et verifiees par static_assert
|
||||
// autant que le langage le permet :
|
||||
// - float est IEEE-754 binary32, double est binary64 ;
|
||||
// - le mode d arrondi est round-to-nearest-even et personne ne le change ;
|
||||
// - x86-64 calcule en SSE2, pas en x87 80 bits : pas de precision excedentaire
|
||||
// surprise. (C est vrai par defaut pour tout compilateur 64 bits.)
|
||||
// - aucune option de type -ffast-math n est utilisee.
|
||||
// Ces hypotheses sont ce qui rend la comparaison octet-a-octet du harnais
|
||||
// d oracle valide entre l hote et la cible.
|
||||
#pragma once
|
||||
|
||||
#include "proj3/base/types.hpp"
|
||||
|
||||
namespace proj3 {
|
||||
|
||||
using f32 = float;
|
||||
using f64 = double;
|
||||
|
||||
static_assert(sizeof(f32) == 4 && sizeof(f64) == 8);
|
||||
|
||||
template <class T>
|
||||
constexpr T min_of(T a, T b) {
|
||||
return a < b ? a : b;
|
||||
}
|
||||
template <class T>
|
||||
constexpr T max_of(T a, T b) {
|
||||
return a > b ? a : b;
|
||||
}
|
||||
template <class T>
|
||||
constexpr T clamp_to(T v, T lo, T hi) {
|
||||
return v < lo ? lo : (v > hi ? hi : v);
|
||||
}
|
||||
|
||||
// floor / ceil par troncature entiere.
|
||||
//
|
||||
// Valide seulement pour |v| < 2^62, ce qui est garanti ici : toutes les
|
||||
// coordonnees manipulees sont bornees par la taille de l ecran multipliee par
|
||||
// l echelle, soit quelques milliers. Un garde-fou explicite plutot qu une
|
||||
// implementation generale : le cas general n existe pas dans ce projet.
|
||||
inline f32 floor_f32(f32 v) {
|
||||
const i64 t = static_cast<i64>(v);
|
||||
const f32 tf = static_cast<f32>(t);
|
||||
return (tf > v) ? tf - 1.0f : tf;
|
||||
}
|
||||
|
||||
inline f32 ceil_f32(f32 v) {
|
||||
const i64 t = static_cast<i64>(v);
|
||||
const f32 tf = static_cast<f32>(t);
|
||||
return (tf < v) ? tf + 1.0f : tf;
|
||||
}
|
||||
|
||||
// Arrondi a l entier le plus proche, moitie loin de zero.
|
||||
// C est exactement la semantique de std::lround, celle qu utilisait le code
|
||||
// d origine pour l avance des glyphes. Ne pas la changer : elle est visible
|
||||
// dans la position de chaque caractere.
|
||||
inline i32 lround_f32(f32 v) {
|
||||
return v >= 0.0f ? static_cast<i32>(v + 0.5f) : -static_cast<i32>(-v + 0.5f);
|
||||
}
|
||||
|
||||
// Racine carree. __builtin_sqrt se compile en une instruction machine
|
||||
// (fsqrt sur AArch64, sqrtsd sur x86-64), toutes deux correctement arrondies
|
||||
// par IEEE-754 : le resultat est bit-a-bit identique sur les deux cibles.
|
||||
// Aucun appel a libm n est emis.
|
||||
inline f64 sqrt_f64(f64 v) { return __builtin_sqrt(v); }
|
||||
|
||||
// Longueur euclidienne.
|
||||
//
|
||||
// DIVERGENCE CONNUE AVEC LE CODE D ORIGINE, documentee ici parce qu elle est
|
||||
// la seule du portage : Gastinel Write utilise std::hypot, qui evite le
|
||||
// debordement intermediaire et peut etre plus precis d un ULP que le calcul
|
||||
// naif. On n a pas de libm, donc on calcule naivement — mais en double, ce qui
|
||||
// rend l ecart avec hypot inferieur a un ULP de float.
|
||||
//
|
||||
// Consequence possible : subdivision_count() pourrait choisir un nombre de
|
||||
// segments different, si et seulement si d/1.5 tombait exactement sur un
|
||||
// entier a un ULP pres. Le test golden (test/test_raster_golden.cpp) compare
|
||||
// les sorties reelles aux sorties de Write pour verifier que ce cas ne se
|
||||
// produit pas sur les glyphes testes. Si un jour il se produisait, ce serait
|
||||
// visible immediatement.
|
||||
inline f64 hypot_f64(f64 a, f64 b) { return sqrt_f64(a * a + b * b); }
|
||||
|
||||
} // namespace proj3
|
||||
@@ -0,0 +1,51 @@
|
||||
// base/mem.hpp — primitives memoire du projet.
|
||||
//
|
||||
// Elles sont volontairement naives : octet par octet, sans deroulage ni SIMD.
|
||||
// C est le point de depart d une paire d oracle (chantier 4), pas une version
|
||||
// finale. Une version NEON viendra les remplacer, la version C++ restant la
|
||||
// reference a vie.
|
||||
//
|
||||
// Attention : sur la cible embarquee, ces fonctions ne SONT PAS memcpy/memset.
|
||||
// Les symboles memcpy/memset que le compilateur peut emettre de lui-meme sont
|
||||
// fournis separement dans base/cstring.cpp.
|
||||
#pragma once
|
||||
|
||||
#include "proj3/base/types.hpp"
|
||||
|
||||
namespace proj3 {
|
||||
|
||||
inline void mem_fill(void* dst, u8 value, usize n) {
|
||||
u8* p = static_cast<u8*>(dst);
|
||||
for (usize i = 0; i < n; ++i) p[i] = value;
|
||||
}
|
||||
|
||||
inline void mem_copy(void* dst, const void* src, usize n) {
|
||||
u8* d = static_cast<u8*>(dst);
|
||||
const u8* s = static_cast<const u8*>(src);
|
||||
for (usize i = 0; i < n; ++i) d[i] = s[i];
|
||||
}
|
||||
|
||||
// Rend true si les deux zones sont identiques. Pas de tri lexicographique :
|
||||
// le projet n a besoin que de l egalite, et rendre un ordre inviterait a s en
|
||||
// servir sur des donnees ou il n a pas de sens.
|
||||
inline bool mem_equal(const void* a, const void* b, usize n) {
|
||||
const u8* x = static_cast<const u8*>(a);
|
||||
const u8* y = static_cast<const u8*>(b);
|
||||
for (usize i = 0; i < n; ++i) {
|
||||
if (x[i] != y[i]) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Indice du premier octet different, ou n si les zones sont identiques.
|
||||
// Utilise par le diagnostic du harnais d oracle.
|
||||
inline usize mem_first_diff(const void* a, const void* b, usize n) {
|
||||
const u8* x = static_cast<const u8*>(a);
|
||||
const u8* y = static_cast<const u8*>(b);
|
||||
for (usize i = 0; i < n; ++i) {
|
||||
if (x[i] != y[i]) return i;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
} // namespace proj3
|
||||
@@ -0,0 +1,53 @@
|
||||
// base/sort.hpp — tri en place, sans allocation, a cout pire cas borne.
|
||||
//
|
||||
// HEAPSORT, et pas quicksort ni std::sort.
|
||||
//
|
||||
// Ce n est pas un detail d implementation, c est le pilier 1 applique a un
|
||||
// algorithme : le quicksort a un pire cas en O(n^2) atteignable par des
|
||||
// donnees reelles, et std::sort (introsort) a un cout qui depend de la
|
||||
// distribution des entrees. Le heapsort est O(n log n) DANS TOUS LES CAS, en
|
||||
// place, sans recursion, sans memoire auxiliaire. Il est en moyenne un peu
|
||||
// plus lent que le quicksort ; c est exactement l arbitrage que le projet
|
||||
// assume : on rejette une construction plus rapide en moyenne mais a variance
|
||||
// non bornee.
|
||||
//
|
||||
// Note sur la stabilite : le heapsort n est pas stable. Aucun usage du projet
|
||||
// n en depend — le rasterizer trie des intersections par abscisse, et deux
|
||||
// intersections de meme abscisse delimitent un intervalle de largeur nulle,
|
||||
// donc invisible quel que soit leur ordre.
|
||||
#pragma once
|
||||
|
||||
#include "proj3/base/types.hpp"
|
||||
|
||||
namespace proj3 {
|
||||
|
||||
template <class T, class Less>
|
||||
inline void sift_down(T* a, usize start, usize end, Less less) {
|
||||
usize root = start;
|
||||
for (;;) {
|
||||
const usize child = 2 * root + 1;
|
||||
if (child >= end) break;
|
||||
usize swap = root;
|
||||
if (less(a[swap], a[child])) swap = child;
|
||||
if (child + 1 < end && less(a[swap], a[child + 1])) swap = child + 1;
|
||||
if (swap == root) return;
|
||||
const T tmp = a[root];
|
||||
a[root] = a[swap];
|
||||
a[swap] = tmp;
|
||||
root = swap;
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, class Less>
|
||||
inline void heap_sort(T* a, usize n, Less less) {
|
||||
if (n < 2) return;
|
||||
for (usize i = n / 2; i-- > 0;) sift_down(a, i, n, less);
|
||||
for (usize end = n; end-- > 1;) {
|
||||
const T tmp = a[0];
|
||||
a[0] = a[end];
|
||||
a[end] = tmp;
|
||||
sift_down(a, 0, end, less);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace proj3
|
||||
@@ -0,0 +1,44 @@
|
||||
// base/types.hpp — types entiers de largeur fixe, sans <cstdint>.
|
||||
//
|
||||
// Pourquoi ne pas inclure <cstdint> : il est theoriquement disponible en
|
||||
// freestanding, mais il tire l en-tete systeme <stdint.h> de la libc de la
|
||||
// plateforme, donc un chemin d inclusion qui differe entre la cible embarquee
|
||||
// et la cible hote. Douze lignes de typedefs suppriment la question. Les
|
||||
// static_assert ci-dessous garantissent qu on ne se trompe pas.
|
||||
#pragma once
|
||||
|
||||
namespace proj3 {
|
||||
|
||||
using u8 = unsigned char;
|
||||
using i8 = signed char;
|
||||
using u16 = unsigned short;
|
||||
using i16 = short;
|
||||
using u32 = unsigned int;
|
||||
using i32 = int;
|
||||
using u64 = unsigned long long;
|
||||
using i64 = long long;
|
||||
|
||||
// Taille et decalage : LP64 des deux cotes (aarch64-linux et x86-64).
|
||||
using usize = decltype(sizeof(0));
|
||||
using iptr = i64;
|
||||
using uptr = u64;
|
||||
|
||||
static_assert(sizeof(u8) == 1 && sizeof(i8) == 1);
|
||||
static_assert(sizeof(u16) == 2 && sizeof(i16) == 2);
|
||||
static_assert(sizeof(u32) == 4 && sizeof(i32) == 4);
|
||||
static_assert(sizeof(u64) == 8 && sizeof(i64) == 8);
|
||||
static_assert(sizeof(usize) == 8, "cible LP64 attendue");
|
||||
static_assert(sizeof(void*) == 8, "cible 64 bits attendue");
|
||||
|
||||
// Little-endian suppose partout (AArch64 en mode EL0 Linux, x86-64).
|
||||
// Le parser TTF lit du big-endian octet par octet, il ne depend donc pas de
|
||||
// cette hypothese ; mais la composition de framebuffer, si.
|
||||
// (troncation et endianness sont deux choses differentes : seul le predefini
|
||||
// du compilateur repond vraiment a la question, en constant de compilation.)
|
||||
#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__)
|
||||
static_assert(__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__, "little-endian attendu");
|
||||
#else
|
||||
#error "compilateur sans __BYTE_ORDER__ : verifier l endianness a la main"
|
||||
#endif
|
||||
|
||||
} // namespace proj3
|
||||
@@ -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;
|
||||
}
|
||||
@@ -0,0 +1,641 @@
|
||||
#include "proj3/font/ttf.hpp"
|
||||
|
||||
#include "proj3/base/sort.hpp"
|
||||
|
||||
namespace proj3::font {
|
||||
namespace {
|
||||
|
||||
// --- Lecture big-endian bornee --------------------------------------------
|
||||
// Identique a l original : chaque accesseur verifie ses bornes. Un fichier
|
||||
// tronque doit produire un echec propre, jamais une lecture hors tampon.
|
||||
|
||||
bool rd_u8(const u8* d, usize n, u32 off, u8& out) {
|
||||
if (static_cast<usize>(off) + 1 > n) return false;
|
||||
out = d[off];
|
||||
return true;
|
||||
}
|
||||
|
||||
bool rd_u16(const u8* d, usize n, u32 off, u16& out) {
|
||||
if (static_cast<usize>(off) + 2 > n) return false;
|
||||
out = static_cast<u16>((static_cast<u32>(d[off]) << 8) | d[off + 1]);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool rd_i16(const u8* d, usize n, u32 off, i16& out) {
|
||||
u16 v = 0;
|
||||
if (!rd_u16(d, n, off, v)) return false;
|
||||
out = static_cast<i16>(v);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool rd_u32(const u8* d, usize n, u32 off, u32& out) {
|
||||
if (static_cast<usize>(off) + 4 > n) return false;
|
||||
out = (static_cast<u32>(d[off]) << 24) | (static_cast<u32>(d[off + 1]) << 16) |
|
||||
(static_cast<u32>(d[off + 2]) << 8) | static_cast<u32>(d[off + 3]);
|
||||
return true;
|
||||
}
|
||||
|
||||
// F2Dot14 : entier signe 16 bits interprete comme un fixe 2.14.
|
||||
bool rd_f2dot14(const u8* d, usize n, u32 off, f32& out) {
|
||||
i16 v = 0;
|
||||
if (!rd_i16(d, n, off, v)) return false;
|
||||
out = static_cast<f32>(v) / 16384.0f;
|
||||
return true;
|
||||
}
|
||||
|
||||
// Drapeaux glyf (glyphe simple)
|
||||
constexpr u8 kOnCurve = 0x01;
|
||||
constexpr u8 kXShortVector = 0x02;
|
||||
constexpr u8 kYShortVector = 0x04;
|
||||
constexpr u8 kRepeatFlag = 0x08;
|
||||
constexpr u8 kXSameOrPos = 0x10;
|
||||
constexpr u8 kYSameOrPos = 0x20;
|
||||
|
||||
// Drapeaux glyf (glyphe composite)
|
||||
constexpr u16 kArg1And2AreWords = 0x0001;
|
||||
constexpr u16 kArgsAreXyValues = 0x0002;
|
||||
constexpr u16 kWeHaveAScale = 0x0008;
|
||||
constexpr u16 kMoreComponents = 0x0020;
|
||||
constexpr u16 kWeHaveXAndYScale = 0x0040;
|
||||
constexpr u16 kWeHaveATwoByTwo = 0x0080;
|
||||
|
||||
bool tag_equal(const char* a, const char b[4]) {
|
||||
return a[0] == b[0] && a[1] == b[1] && a[2] == b[2] && a[3] == b[3];
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
TtfFont::TableRecord TtfFont::find_table(const char tag[4]) const {
|
||||
for (u32 i = 0; i < table_count_; ++i) {
|
||||
if (tag_equal(table_tag_[i], tag)) return table_rec_[i];
|
||||
}
|
||||
return TableRecord{};
|
||||
}
|
||||
|
||||
bool TtfFont::load(const u8* data, usize size, mem::Arena& arena, const char*& error) {
|
||||
error = "";
|
||||
data_ = data;
|
||||
size_ = size;
|
||||
table_count_ = 0;
|
||||
|
||||
if (size <= 12) {
|
||||
error = "fichier trop court pour etre un TTF";
|
||||
return false;
|
||||
}
|
||||
|
||||
// En-tete sfnt. Les refus explicites de l original sont conserves mot pour
|
||||
// mot : ils disent quoi faire, ce qui vaut mieux qu un "signature inconnue".
|
||||
u32 sfnt = 0;
|
||||
if (!rd_u32(data_, size_, 0, sfnt)) {
|
||||
error = "en-tete illisible";
|
||||
return false;
|
||||
}
|
||||
if (sfnt == 0x4F54544Fu) {
|
||||
error = "police OpenType/CFF (OTTO) non supportee : il faut un TTF a contours glyf";
|
||||
return false;
|
||||
}
|
||||
if (sfnt == 0x74746366u) {
|
||||
error = "collection TrueType (.ttc) : extraire la police voulue en .ttf";
|
||||
return false;
|
||||
}
|
||||
if (sfnt == 0x774F4646u || sfnt == 0x774F4632u) {
|
||||
error = "police web (WOFF/WOFF2) non supportee : il faut un .ttf";
|
||||
return false;
|
||||
}
|
||||
if (sfnt != 0x00010000u && sfnt != 0x74727565u) {
|
||||
error = "signature sfnt inconnue : ce fichier n est pas un TTF";
|
||||
return false;
|
||||
}
|
||||
|
||||
u16 num_tables = 0;
|
||||
if (!rd_u16(data_, size_, 4, num_tables)) {
|
||||
error = "numTables illisible";
|
||||
return false;
|
||||
}
|
||||
|
||||
for (u16 i = 0; i < num_tables; ++i) {
|
||||
const u32 rec = 12u + 16u * i;
|
||||
if (static_cast<usize>(rec) + 16 > size_) {
|
||||
error = "repertoire de tables tronque";
|
||||
return false;
|
||||
}
|
||||
TableRecord tr;
|
||||
rd_u32(data_, size_, rec + 8, tr.offset);
|
||||
rd_u32(data_, size_, rec + 12, tr.length);
|
||||
// Table hors fichier : ignoree plutot que fatale, certaines polices
|
||||
// ont des longueurs padees legerement fausses. Comportement d origine.
|
||||
if (tr.offset > size_ || static_cast<usize>(tr.offset) + tr.length > size_) continue;
|
||||
if (table_count_ >= kMaxTables) continue;
|
||||
tr.present = true;
|
||||
for (int k = 0; k < 4; ++k) table_tag_[table_count_][k] = static_cast<char>(data_[rec + k]);
|
||||
table_rec_[table_count_] = tr;
|
||||
++table_count_;
|
||||
}
|
||||
|
||||
const TableRecord glyf = find_table("glyf");
|
||||
if (!glyf.present) {
|
||||
error = "table glyf absente";
|
||||
return false;
|
||||
}
|
||||
glyf_offset_ = glyf.offset;
|
||||
glyf_length_ = glyf.length;
|
||||
|
||||
if (!parse_head(error)) return false;
|
||||
if (!parse_maxp(error)) return false;
|
||||
if (!parse_hhea_hmtx(error)) return false;
|
||||
if (!parse_loca(arena, error)) return false;
|
||||
if (!parse_cmap(arena, error)) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TtfFont::parse_head(const char*& error) {
|
||||
const TableRecord head = find_table("head");
|
||||
if (!head.present || head.length < 54) {
|
||||
error = "table head absente ou trop courte";
|
||||
return false;
|
||||
}
|
||||
if (!rd_u16(data_, size_, head.offset + 18, units_per_em_) || units_per_em_ == 0) {
|
||||
error = "unitsPerEm invalide";
|
||||
return false;
|
||||
}
|
||||
if (!rd_i16(data_, size_, head.offset + 50, index_to_loc_format_)) {
|
||||
error = "indexToLocFormat illisible";
|
||||
return false;
|
||||
}
|
||||
if (index_to_loc_format_ != 0 && index_to_loc_format_ != 1) {
|
||||
error = "indexToLocFormat inattendu";
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TtfFont::parse_maxp(const char*& error) {
|
||||
const TableRecord maxp = find_table("maxp");
|
||||
if (!maxp.present || maxp.length < 6) {
|
||||
error = "table maxp absente ou trop courte";
|
||||
return false;
|
||||
}
|
||||
if (!rd_u16(data_, size_, maxp.offset + 4, num_glyphs_) || num_glyphs_ == 0) {
|
||||
error = "numGlyphs invalide";
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TtfFont::parse_hhea_hmtx(const char*& error) {
|
||||
const TableRecord hhea = find_table("hhea");
|
||||
const TableRecord hmtx = find_table("hmtx");
|
||||
if (!hhea.present || hhea.length < 36 || !hmtx.present) {
|
||||
error = "tables hhea/hmtx absentes";
|
||||
return false;
|
||||
}
|
||||
if (!rd_u16(data_, size_, hhea.offset + 34, num_h_metrics_) || num_h_metrics_ == 0) {
|
||||
error = "numberOfHMetrics invalide";
|
||||
return false;
|
||||
}
|
||||
rd_i16(data_, size_, hhea.offset + 4, ascender_);
|
||||
rd_i16(data_, size_, hhea.offset + 6, descender_);
|
||||
rd_i16(data_, size_, hhea.offset + 8, line_gap_);
|
||||
hmtx_offset_ = hmtx.offset;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TtfFont::parse_loca(mem::Arena& arena, const char*& error) {
|
||||
const TableRecord loca = find_table("loca");
|
||||
if (!loca.present) {
|
||||
error = "table loca absente";
|
||||
return false;
|
||||
}
|
||||
loca_count_ = static_cast<u32>(num_glyphs_) + 1u;
|
||||
loca_ = arena.alloc_array<u32>(loca_count_);
|
||||
for (u32 i = 0; i < loca_count_; ++i) {
|
||||
u32 rel = 0;
|
||||
if (index_to_loc_format_ == 0) {
|
||||
// Format court : les offsets sont stockes divises par deux.
|
||||
u16 half = 0;
|
||||
if (!rd_u16(data_, size_, loca.offset + i * 2u, half)) {
|
||||
error = "loca (format court) tronquee";
|
||||
return false;
|
||||
}
|
||||
rel = static_cast<u32>(half) * 2u;
|
||||
} else {
|
||||
if (!rd_u32(data_, size_, loca.offset + i * 4u, rel)) {
|
||||
error = "loca (format long) tronquee";
|
||||
return false;
|
||||
}
|
||||
}
|
||||
loca_[i] = glyf_offset_ + rel;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
u32 TtfFont::walk_cmap_format4(u32 off, CmapEntry* out, u32 cap) const {
|
||||
u16 seg_x2 = 0;
|
||||
if (!rd_u16(data_, size_, off + 6, seg_x2) || seg_x2 == 0) return 0;
|
||||
const u32 seg_count = seg_x2 / 2u;
|
||||
|
||||
const u32 end_base = off + 14u;
|
||||
const u32 start_base = end_base + seg_x2 + 2u; // +2 : reservedPad
|
||||
const u32 delta_base = start_base + seg_x2;
|
||||
const u32 range_base = delta_base + seg_x2;
|
||||
|
||||
u32 n = 0;
|
||||
for (u32 s = 0; s < seg_count; ++s) {
|
||||
u16 end_code = 0, start_code = 0, range_offset = 0;
|
||||
i16 id_delta = 0;
|
||||
if (!rd_u16(data_, size_, end_base + s * 2u, end_code) ||
|
||||
!rd_u16(data_, size_, start_base + s * 2u, start_code) ||
|
||||
!rd_i16(data_, size_, delta_base + s * 2u, id_delta) ||
|
||||
!rd_u16(data_, size_, range_base + s * 2u, range_offset)) {
|
||||
return n;
|
||||
}
|
||||
if (start_code > end_code) continue;
|
||||
for (u32 c = start_code; c <= end_code; ++c) {
|
||||
if (c == 0xFFFF) continue; // sentinelle de fin de segment
|
||||
u16 gid = 0;
|
||||
if (range_offset == 0) {
|
||||
gid = static_cast<u16>((c + static_cast<u16>(id_delta)) & 0xFFFF);
|
||||
} else {
|
||||
// Adressage indirect : l offset est relatif a la position du
|
||||
// champ idRangeOffset lui-meme. Particularite du format 4 et
|
||||
// source d erreur classique.
|
||||
const u32 idx = range_base + s * 2u + range_offset + (c - start_code) * 2u;
|
||||
if (!rd_u16(data_, size_, idx, gid)) return n;
|
||||
if (gid != 0) gid = static_cast<u16>((gid + static_cast<u16>(id_delta)) & 0xFFFF);
|
||||
}
|
||||
if (gid != 0) {
|
||||
if (out != nullptr) {
|
||||
if (n >= cap) return n;
|
||||
out[n] = CmapEntry{c, gid};
|
||||
}
|
||||
++n;
|
||||
}
|
||||
}
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
u32 TtfFont::walk_cmap_format12(u32 off, CmapEntry* out, u32 cap) const {
|
||||
u32 n_groups = 0;
|
||||
if (!rd_u32(data_, size_, off + 12, n_groups)) return 0;
|
||||
u32 n = 0;
|
||||
for (u32 g = 0; g < n_groups; ++g) {
|
||||
const u32 rec = off + 16u + 12u * g;
|
||||
u32 start = 0, end = 0, start_gid = 0;
|
||||
if (!rd_u32(data_, size_, rec, start) || !rd_u32(data_, size_, rec + 4, end) ||
|
||||
!rd_u32(data_, size_, rec + 8, start_gid)) {
|
||||
return n;
|
||||
}
|
||||
if (end < start || end > 0x10FFFF) continue;
|
||||
for (u32 c = start; c <= end; ++c) {
|
||||
const u32 gid = start_gid + (c - start);
|
||||
if (gid != 0 && gid < num_glyphs_) {
|
||||
if (out != nullptr) {
|
||||
if (n >= cap) return n;
|
||||
out[n] = CmapEntry{c, static_cast<u16>(gid)};
|
||||
}
|
||||
++n;
|
||||
}
|
||||
}
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
bool TtfFont::parse_cmap(mem::Arena& arena, const char*& error) {
|
||||
const TableRecord cmap = find_table("cmap");
|
||||
if (!cmap.present || cmap.length < 4) {
|
||||
error = "table cmap absente";
|
||||
return false;
|
||||
}
|
||||
u16 num_sub = 0;
|
||||
if (!rd_u16(data_, size_, cmap.offset + 2, num_sub)) {
|
||||
error = "cmap : numTables illisible";
|
||||
return false;
|
||||
}
|
||||
|
||||
// Selection de la sous-table : (3,10) UCS-4, puis (3,1) BMP, puis
|
||||
// plateforme 0 en repli. Comportement d origine, inchange.
|
||||
u32 best_offset = 0;
|
||||
int best_score = -1;
|
||||
for (u16 i = 0; i < num_sub; ++i) {
|
||||
const u32 rec = cmap.offset + 4u + 8u * i;
|
||||
u16 platform = 0, encoding = 0;
|
||||
u32 sub_off = 0;
|
||||
if (!rd_u16(data_, size_, rec, platform) || !rd_u16(data_, size_, rec + 2, encoding) ||
|
||||
!rd_u32(data_, size_, rec + 4, sub_off)) {
|
||||
continue;
|
||||
}
|
||||
int score = -1;
|
||||
if (platform == 3 && encoding == 10) score = 3;
|
||||
else if (platform == 3 && encoding == 1) score = 2;
|
||||
else if (platform == 0) score = 1;
|
||||
if (score > best_score) {
|
||||
best_score = score;
|
||||
best_offset = cmap.offset + sub_off;
|
||||
}
|
||||
}
|
||||
if (best_score < 0) {
|
||||
error = "cmap : aucune sous-table Unicode exploitable";
|
||||
return false;
|
||||
}
|
||||
|
||||
u16 format = 0;
|
||||
if (!rd_u16(data_, size_, best_offset, format)) {
|
||||
error = "cmap : format illisible";
|
||||
return false;
|
||||
}
|
||||
if (format != 4 && format != 12) {
|
||||
error = "cmap : format non gere (attendu 4 ou 12)";
|
||||
return false;
|
||||
}
|
||||
|
||||
// Deux passes : la premiere compte, la seconde remplit. C est le prix a
|
||||
// payer pour ne pas avoir de conteneur qui pousse. Le cout est une
|
||||
// relecture de la sous-table, quelques microsecondes a l init.
|
||||
const u32 count = (format == 4) ? walk_cmap_format4(best_offset, nullptr, 0)
|
||||
: walk_cmap_format12(best_offset, nullptr, 0);
|
||||
if (count == 0) {
|
||||
error = "cmap : sous-table vide ou tronquee";
|
||||
return false;
|
||||
}
|
||||
cmap_ = arena.alloc_array<CmapEntry>(count);
|
||||
const u32 filled = (format == 4) ? walk_cmap_format4(best_offset, cmap_, count)
|
||||
: walk_cmap_format12(best_offset, cmap_, count);
|
||||
cmap_count_ = filled;
|
||||
|
||||
// Tri par (codepoint, gid) puis deduplication sur le codepoint, en gardant
|
||||
// la premiere entree : c est exactement ce que faisaient std::sort +
|
||||
// std::unique dans l original.
|
||||
heap_sort(cmap_, cmap_count_, [](const CmapEntry& a, const CmapEntry& b) {
|
||||
if (a.codepoint != b.codepoint) return a.codepoint < b.codepoint;
|
||||
return a.gid < b.gid;
|
||||
});
|
||||
u32 w = 0;
|
||||
for (u32 r = 0; r < cmap_count_; ++r) {
|
||||
if (w > 0 && cmap_[w - 1].codepoint == cmap_[r].codepoint) continue;
|
||||
cmap_[w++] = cmap_[r];
|
||||
}
|
||||
cmap_count_ = w;
|
||||
return true;
|
||||
}
|
||||
|
||||
u16 TtfFont::glyph_index_for_codepoint(u32 codepoint) const {
|
||||
// Recherche binaire, comme l original (lower_bound sur un vector trie).
|
||||
u32 lo = 0, hi = cmap_count_;
|
||||
while (lo < hi) {
|
||||
const u32 mid = lo + (hi - lo) / 2;
|
||||
if (cmap_[mid].codepoint < codepoint) lo = mid + 1;
|
||||
else hi = mid;
|
||||
}
|
||||
if (lo >= cmap_count_ || cmap_[lo].codepoint != codepoint) return 0;
|
||||
return cmap_[lo].gid;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
bool TtfFont::load_glyph(u16 glyph_index, GlyphBuilder& builder, Glyph& out) const {
|
||||
out = Glyph{};
|
||||
builder.reset();
|
||||
if (glyph_index >= num_glyphs_) return false;
|
||||
|
||||
// --- Metriques horizontales (hmtx) ---
|
||||
// Les glyphes d indice >= numberOfHMetrics partagent la derniere advance ;
|
||||
// seul leur leftSideBearing est stocke, dans le tableau qui suit.
|
||||
{
|
||||
const u16 m = glyph_index < static_cast<u16>(num_h_metrics_ - 1)
|
||||
? glyph_index
|
||||
: static_cast<u16>(num_h_metrics_ - 1);
|
||||
u16 adv = 0;
|
||||
i16 lsb = 0;
|
||||
rd_u16(data_, size_, hmtx_offset_ + m * 4u, adv);
|
||||
if (glyph_index < num_h_metrics_) {
|
||||
rd_i16(data_, size_, hmtx_offset_ + glyph_index * 4u + 2u, lsb);
|
||||
} else {
|
||||
const u32 tail = hmtx_offset_ + num_h_metrics_ * 4u;
|
||||
rd_i16(data_, size_, tail + (glyph_index - num_h_metrics_) * 2u, lsb);
|
||||
}
|
||||
out.advance_width = static_cast<f32>(adv);
|
||||
out.left_side_bearing = static_cast<f32>(lsb);
|
||||
}
|
||||
|
||||
const u32 start = loca_[glyph_index];
|
||||
const u32 end = loca_[glyph_index + 1];
|
||||
out.points = builder.points;
|
||||
out.contour_end = builder.contour_end;
|
||||
|
||||
if (end <= start) {
|
||||
// Longueur nulle = glyphe vide (l espace). Les metriques restent
|
||||
// valides, ce n est pas une erreur.
|
||||
return true;
|
||||
}
|
||||
if (end > glyf_offset_ + glyf_length_ || static_cast<usize>(start) + 10 > size_) return false;
|
||||
|
||||
i16 xmin = 0, ymin = 0, xmax = 0, ymax = 0;
|
||||
i16 n_contours = 0;
|
||||
if (!rd_i16(data_, size_, start, n_contours) || !rd_i16(data_, size_, start + 2, xmin) ||
|
||||
!rd_i16(data_, size_, start + 4, ymin) || !rd_i16(data_, size_, start + 6, xmax) ||
|
||||
!rd_i16(data_, size_, start + 8, ymax)) {
|
||||
return false;
|
||||
}
|
||||
out.x_min = xmin;
|
||||
out.y_min = ymin;
|
||||
out.x_max = xmax;
|
||||
out.y_max = ymax;
|
||||
|
||||
const bool ok = append_glyph(glyph_index, builder, 0);
|
||||
out.point_count = builder.point_count;
|
||||
out.contour_count = builder.contour_count;
|
||||
return ok;
|
||||
}
|
||||
|
||||
bool TtfFont::append_glyph(u16 gid, GlyphBuilder& b, int depth) const {
|
||||
if (gid >= num_glyphs_) return false;
|
||||
const u32 start = loca_[gid];
|
||||
const u32 end = loca_[gid + 1];
|
||||
if (end <= start) return true;
|
||||
if (end > glyf_offset_ + glyf_length_ || static_cast<usize>(start) + 10 > size_) return false;
|
||||
|
||||
i16 n_contours = 0;
|
||||
if (!rd_i16(data_, size_, start, n_contours)) return false;
|
||||
if (n_contours >= 0) return append_simple_glyph(start, b);
|
||||
return append_composite_glyph(start, end, b, depth);
|
||||
}
|
||||
|
||||
bool TtfFont::append_simple_glyph(u32 start, GlyphBuilder& b) const {
|
||||
i16 n_contours_s = 0;
|
||||
rd_i16(data_, size_, start, n_contours_s);
|
||||
if (n_contours_s <= 0) return true;
|
||||
const u32 n_contours = static_cast<u32>(n_contours_s);
|
||||
if (b.contour_count + n_contours > kMaxGlyphContours) return false;
|
||||
|
||||
u32 p = start + 10;
|
||||
|
||||
// endPtsOfContours : indice du dernier point de chaque contour.
|
||||
// Ils sont relus depuis le fichier a chaque besoin plutot que stockes
|
||||
// dans un tableau temporaire : evite une allocation, coute deux lectures.
|
||||
u16 last_end = 0;
|
||||
for (u32 i = 0; i < n_contours; ++i) {
|
||||
if (!rd_u16(data_, size_, p + i * 2u, last_end)) return false;
|
||||
}
|
||||
const u32 n_points = static_cast<u32>(last_end) + 1u;
|
||||
if (n_points == 0 || n_points > kMaxGlyphPoints) return false;
|
||||
if (b.point_count + n_points > kMaxGlyphPoints) return false;
|
||||
|
||||
const u32 end_pts_base = p;
|
||||
p += n_contours * 2u;
|
||||
|
||||
// On saute les instructions de hinting : elles ne sont pas interpretees.
|
||||
u16 instr_len = 0;
|
||||
if (!rd_u16(data_, size_, p, instr_len)) return false;
|
||||
p += 2u + instr_len;
|
||||
|
||||
// --- Drapeaux, avec run-length (bit kRepeatFlag) ---
|
||||
const u32 base = b.point_count;
|
||||
u8* flags = b.flags;
|
||||
{
|
||||
u32 nf = 0;
|
||||
while (nf < n_points) {
|
||||
u8 f = 0;
|
||||
if (!rd_u8(data_, size_, p, f)) return false;
|
||||
++p;
|
||||
flags[nf++] = f;
|
||||
if (f & kRepeatFlag) {
|
||||
u8 repeat = 0;
|
||||
if (!rd_u8(data_, size_, p, repeat)) return false;
|
||||
++p;
|
||||
for (u8 r = 0; r < repeat && nf < n_points; ++r) flags[nf++] = f;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// --- Coordonnees, deltas sur 1 ou 2 octets ---
|
||||
// Le couple (kXShortVector, kXSameOrPos) encode a la fois la taille et le
|
||||
// signe du delta : c est le point le plus contre-intuitif du format glyf.
|
||||
//
|
||||
// Les accumulateurs restent en i32 comme dans l original, puis sont
|
||||
// convertis en float. Les coordonnees TrueType sont bornees a +-16384
|
||||
// unites de police, donc la conversion est exacte (bien en dessous de
|
||||
// 2^24) : aucune perte par rapport au code de Write.
|
||||
{
|
||||
i32 acc = 0;
|
||||
for (u32 i = 0; i < n_points; ++i) {
|
||||
const u8 f = flags[i];
|
||||
if (f & kXShortVector) {
|
||||
u8 d = 0;
|
||||
if (!rd_u8(data_, size_, p, d)) return false;
|
||||
++p;
|
||||
acc += (f & kXSameOrPos) ? static_cast<i32>(d) : -static_cast<i32>(d);
|
||||
} else if (!(f & kXSameOrPos)) {
|
||||
i16 d = 0;
|
||||
if (!rd_i16(data_, size_, p, d)) return false;
|
||||
p += 2;
|
||||
acc += d;
|
||||
} // sinon : delta nul, x inchange
|
||||
b.points[base + i].x = static_cast<f32>(acc);
|
||||
}
|
||||
}
|
||||
{
|
||||
i32 acc = 0;
|
||||
for (u32 i = 0; i < n_points; ++i) {
|
||||
const u8 f = flags[i];
|
||||
if (f & kYShortVector) {
|
||||
u8 d = 0;
|
||||
if (!rd_u8(data_, size_, p, d)) return false;
|
||||
++p;
|
||||
acc += (f & kYSameOrPos) ? static_cast<i32>(d) : -static_cast<i32>(d);
|
||||
} else if (!(f & kYSameOrPos)) {
|
||||
i16 d = 0;
|
||||
if (!rd_i16(data_, size_, p, d)) return false;
|
||||
p += 2;
|
||||
acc += d;
|
||||
}
|
||||
b.points[base + i].y = static_cast<f32>(acc);
|
||||
b.points[base + i].on_curve = (f & kOnCurve) != 0;
|
||||
}
|
||||
}
|
||||
|
||||
// --- Decoupage en contours ---
|
||||
u32 first = 0;
|
||||
for (u32 c = 0; c < n_contours; ++c) {
|
||||
u16 last = 0;
|
||||
if (!rd_u16(data_, size_, end_pts_base + c * 2u, last)) return false;
|
||||
if (last < first || last >= n_points) return false;
|
||||
b.contour_end[b.contour_count++] = base + last + 1u;
|
||||
first = last + 1u;
|
||||
}
|
||||
b.point_count = base + n_points;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TtfFont::append_composite_glyph(u32 start, u32 end, GlyphBuilder& b, int depth) const {
|
||||
if (depth >= kMaxCompositeDepth) return false;
|
||||
|
||||
u32 p = start + 10;
|
||||
for (;;) {
|
||||
u16 flags = 0, glyph_index = 0;
|
||||
if (!rd_u16(data_, size_, p, flags) || !rd_u16(data_, size_, p + 2, glyph_index)) {
|
||||
return false;
|
||||
}
|
||||
p += 4;
|
||||
|
||||
// Arguments : decalage xy, ou indices de points a aligner. Seul le cas
|
||||
// xy est gere, comme dans l original (l alignement par points est
|
||||
// rarissime hors polices CJK anciennes).
|
||||
f32 dx = 0.0f, dy = 0.0f;
|
||||
if (flags & kArg1And2AreWords) {
|
||||
i16 a1 = 0, a2 = 0;
|
||||
if (!rd_i16(data_, size_, p, a1) || !rd_i16(data_, size_, p + 2, a2)) return false;
|
||||
p += 4;
|
||||
if (flags & kArgsAreXyValues) {
|
||||
dx = static_cast<f32>(a1);
|
||||
dy = static_cast<f32>(a2);
|
||||
}
|
||||
} else {
|
||||
u8 b1 = 0, b2 = 0;
|
||||
if (!rd_u8(data_, size_, p, b1) || !rd_u8(data_, size_, p + 1, b2)) return false;
|
||||
p += 2;
|
||||
if (flags & kArgsAreXyValues) {
|
||||
dx = static_cast<f32>(static_cast<i8>(b1));
|
||||
dy = static_cast<f32>(static_cast<i8>(b2));
|
||||
}
|
||||
}
|
||||
|
||||
f32 a = 1.0f, bb = 0.0f, c = 0.0f, d = 1.0f;
|
||||
if (flags & kWeHaveAScale) {
|
||||
if (!rd_f2dot14(data_, size_, p, a)) return false;
|
||||
d = a;
|
||||
p += 2;
|
||||
} else if (flags & kWeHaveXAndYScale) {
|
||||
if (!rd_f2dot14(data_, size_, p, a) || !rd_f2dot14(data_, size_, p + 2, d)) {
|
||||
return false;
|
||||
}
|
||||
p += 4;
|
||||
} else if (flags & kWeHaveATwoByTwo) {
|
||||
if (!rd_f2dot14(data_, size_, p, a) || !rd_f2dot14(data_, size_, p + 2, bb) ||
|
||||
!rd_f2dot14(data_, size_, p + 4, c) || !rd_f2dot14(data_, size_, p + 6, d)) {
|
||||
return false;
|
||||
}
|
||||
p += 8;
|
||||
}
|
||||
|
||||
// La composante est ajoutee directement a la suite dans le builder,
|
||||
// puis transformee sur place. L original construisait un Glyph
|
||||
// temporaire et copiait ses contours ; ici il n y a pas de copie.
|
||||
const u32 mark_points = b.point_count;
|
||||
if (append_glyph(glyph_index, b, depth + 1)) {
|
||||
for (u32 i = mark_points; i < b.point_count; ++i) {
|
||||
const f32 x = b.points[i].x, y = b.points[i].y;
|
||||
b.points[i].x = a * x + c * y + dx;
|
||||
b.points[i].y = bb * x + d * y + dy;
|
||||
}
|
||||
}
|
||||
|
||||
if (!(flags & kMoreComponents)) break;
|
||||
if (p >= end) break;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace proj3::font
|
||||
@@ -0,0 +1,181 @@
|
||||
// font/ttf.hpp — parser TTF, porte depuis Gastinel Write (src/font/ttf.h).
|
||||
//
|
||||
// SOUS-ENSEMBLE STRICT, inchange par rapport a l original :
|
||||
// head : unitsPerEm, indexToLocFormat
|
||||
// maxp : numGlyphs
|
||||
// cmap : Unicode -> index de glyphe (formats 4 et 12 uniquement)
|
||||
// loca : offsets dans glyf
|
||||
// glyf : contours quadratiques (simples et composites)
|
||||
// hmtx : advanceWidth / leftSideBearing (avec hhea)
|
||||
//
|
||||
// DETTE TECHNIQUE HERITEE, CONSERVEE TELLE QUELLE (cf. README) :
|
||||
// pas de kern / GPOS -> aucun crenage
|
||||
// pas de fpgm/prep/cvt -> aucun hinting, instructions ignorees
|
||||
// pas de CFF / CFF2 -> les polices PostScript sont refusees
|
||||
// pas de VORG / vmtx -> pas d ecriture verticale
|
||||
// Ces choix sont volontaires et ne doivent pas etre "corriges" dans ce
|
||||
// chantier.
|
||||
//
|
||||
// CE QUI CHANGE PAR RAPPORT A L ORIGINAL, et pourquoi :
|
||||
// 1. std::vector / std::string ont disparu. Rien n alloue : l appelant
|
||||
// fournit les arenes. Le garde-fou du chantier 3 tue le processus si une
|
||||
// allocation cachee subsistait.
|
||||
// 2. Le fichier n est plus copie. load() prend un tampon deja en memoire,
|
||||
// dont l appelant garde la propriete et qui doit rester valide aussi
|
||||
// longtemps que la police. L original copiait tout le fichier dans un
|
||||
// vector ; ici c est l arene de l appelant qui le detient.
|
||||
// 3. Les messages d erreur sont des chaines litterales, pas des std::string
|
||||
// concatenees. On perd le nom du fichier dans le message ; l appelant l a.
|
||||
// 4. La lecture de fichier n est plus dans cette classe (elle utilisait
|
||||
// fopen). Elle est dans io/file.hpp, avec une implementation par cible.
|
||||
//
|
||||
// ENDIANNESS : le format TrueType est big-endian. Le parser lit octet par
|
||||
// octet et reconstruit les valeurs a la main, exactement comme l original :
|
||||
// il est donc insensible a l endianness de la machine. Ce point ne change pas
|
||||
// entre x86 Windows et AArch64 Linux. (Ce n est PAS vrai de la composition
|
||||
// vers le framebuffer : cf. render/compose.hpp.)
|
||||
#pragma once
|
||||
|
||||
#include "proj3/base/math.hpp"
|
||||
#include "proj3/base/types.hpp"
|
||||
#include "proj3/mem/arena.hpp"
|
||||
|
||||
namespace proj3::font {
|
||||
|
||||
// Un point de contour, en unites de police.
|
||||
// on_curve distingue les points d ancrage des points de controle quadratiques
|
||||
// (TrueType n a pas de cubiques).
|
||||
struct GlyphPoint {
|
||||
f32 x = 0.0f;
|
||||
f32 y = 0.0f;
|
||||
bool on_curve = false;
|
||||
};
|
||||
|
||||
// Bornes reprises de l original : n_points > 10000 y etait deja un refus.
|
||||
// kMaxGlyphContours est nouveau — l original s appuyait sur la croissance du
|
||||
// vector. 256 contours est deja bien au-dela de tout glyphe reel (le glyphe
|
||||
// le plus charge d Inter en compte moins de 40).
|
||||
inline constexpr u32 kMaxGlyphPoints = 10000;
|
||||
inline constexpr u32 kMaxGlyphContours = 256;
|
||||
inline constexpr int kMaxCompositeDepth = 5;
|
||||
|
||||
// Tampon de construction d un glyphe. Alloue UNE FOIS dans une arene, puis
|
||||
// reutilise pour tous les glyphes. C est ce qui remplace la croissance des
|
||||
// vector de l original.
|
||||
struct GlyphBuilder {
|
||||
GlyphPoint* points = nullptr;
|
||||
u32* contour_end = nullptr; // indice de fin exclusif de chaque contour
|
||||
// Tampon de drapeaux glyf. Il vit dans le builder et non sur la pile :
|
||||
// 10000 octets de pile seraient deja discutables, et la pile d un
|
||||
// processus sans libc n a pas de garde-page automatique.
|
||||
u8* flags = nullptr;
|
||||
u32 point_count = 0;
|
||||
u32 contour_count = 0;
|
||||
|
||||
void init(mem::Arena& a) {
|
||||
points = a.alloc_array<GlyphPoint>(kMaxGlyphPoints);
|
||||
contour_end = a.alloc_array<u32>(kMaxGlyphContours);
|
||||
flags = a.alloc_array<u8>(kMaxGlyphPoints);
|
||||
reset();
|
||||
}
|
||||
void reset() {
|
||||
point_count = 0;
|
||||
contour_count = 0;
|
||||
}
|
||||
};
|
||||
|
||||
// Un glyphe decode. Les pointeurs visent le GlyphBuilder : la duree de vie
|
||||
// d un Glyph est celle du prochain appel a load_glyph.
|
||||
struct Glyph {
|
||||
const GlyphPoint* points = nullptr;
|
||||
const u32* contour_end = nullptr;
|
||||
u32 point_count = 0;
|
||||
u32 contour_count = 0;
|
||||
|
||||
f32 x_min = 0.0f, y_min = 0.0f, x_max = 0.0f, y_max = 0.0f;
|
||||
f32 advance_width = 0.0f;
|
||||
f32 left_side_bearing = 0.0f;
|
||||
|
||||
bool empty() const { return contour_count == 0; }
|
||||
|
||||
// Bornes du contour i dans points[].
|
||||
u32 contour_begin(u32 i) const { return i == 0 ? 0u : contour_end[i - 1]; }
|
||||
u32 contour_size(u32 i) const { return contour_end[i] - contour_begin(i); }
|
||||
};
|
||||
|
||||
class TtfFont {
|
||||
public:
|
||||
// `data` doit rester valide tant que la police est utilisee : rien n est
|
||||
// copie. `arena` sert a loca et cmap, alloues une fois pour toutes.
|
||||
// En cas d echec, `error` recoit un litteral (jamais nullptr).
|
||||
bool load(const u8* data, usize size, mem::Arena& arena, const char*& error);
|
||||
|
||||
u16 glyph_index_for_codepoint(u32 codepoint) const;
|
||||
|
||||
// Decode les contours d un glyphe dans `builder`. `out` pointe dedans.
|
||||
bool load_glyph(u16 glyph_index, GlyphBuilder& builder, Glyph& out) const;
|
||||
|
||||
u16 units_per_em() const { return units_per_em_; }
|
||||
i16 ascender() const { return ascender_; }
|
||||
i16 descender() const { return descender_; }
|
||||
i16 line_gap() const { return line_gap_; }
|
||||
u16 num_glyphs() const { return num_glyphs_; }
|
||||
u32 cmap_size() const { return cmap_count_; }
|
||||
|
||||
private:
|
||||
struct TableRecord {
|
||||
u32 offset = 0;
|
||||
u32 length = 0;
|
||||
bool present = false;
|
||||
};
|
||||
struct CmapEntry {
|
||||
u32 codepoint;
|
||||
u16 gid;
|
||||
};
|
||||
|
||||
TableRecord find_table(const char tag[4]) const;
|
||||
|
||||
bool parse_head(const char*& error);
|
||||
bool parse_maxp(const char*& error);
|
||||
bool parse_hhea_hmtx(const char*& error);
|
||||
bool parse_loca(mem::Arena& arena, const char*& error);
|
||||
bool parse_cmap(mem::Arena& arena, const char*& error);
|
||||
|
||||
// Deux passes : compte puis remplit. `out` nul = passe de comptage.
|
||||
u32 walk_cmap_format4(u32 off, CmapEntry* out, u32 cap) const;
|
||||
u32 walk_cmap_format12(u32 off, CmapEntry* out, u32 cap) const;
|
||||
|
||||
bool append_simple_glyph(u32 start, GlyphBuilder& b) const;
|
||||
bool append_composite_glyph(u32 start, u32 end, GlyphBuilder& b, int depth) const;
|
||||
bool append_glyph(u16 gid, GlyphBuilder& b, int depth) const;
|
||||
|
||||
const u8* data_ = nullptr;
|
||||
usize size_ = 0;
|
||||
|
||||
// Repertoire de tables : tableau fixe. 64 tables est deja plus du double
|
||||
// de ce qu une police reelle expose.
|
||||
static constexpr u32 kMaxTables = 64;
|
||||
char table_tag_[kMaxTables][4] = {};
|
||||
TableRecord table_rec_[kMaxTables] = {};
|
||||
u32 table_count_ = 0;
|
||||
|
||||
u16 units_per_em_ = 1000;
|
||||
i16 index_to_loc_format_ = 0;
|
||||
u16 num_glyphs_ = 0;
|
||||
u16 num_h_metrics_ = 0;
|
||||
i16 ascender_ = 0;
|
||||
i16 descender_ = 0;
|
||||
i16 line_gap_ = 0;
|
||||
|
||||
u32 glyf_offset_ = 0;
|
||||
u32 glyf_length_ = 0;
|
||||
u32 hmtx_offset_ = 0;
|
||||
|
||||
u32* loca_ = nullptr; // num_glyphs + 1 offsets absolus
|
||||
u32 loca_count_ = 0;
|
||||
|
||||
CmapEntry* cmap_ = nullptr;
|
||||
u32 cmap_count_ = 0;
|
||||
};
|
||||
|
||||
} // namespace proj3::font
|
||||
@@ -0,0 +1,71 @@
|
||||
#include "proj3/mem/arena.hpp"
|
||||
|
||||
#include "proj3/sys/panic.hpp"
|
||||
|
||||
namespace proj3::mem {
|
||||
namespace {
|
||||
|
||||
constexpr bool is_power_of_two(usize v) { return v != 0 && (v & (v - 1)) == 0; }
|
||||
|
||||
} // namespace
|
||||
|
||||
void Arena::init(const char* name, u8* base, usize capacity) {
|
||||
name_ = name;
|
||||
base_ = base;
|
||||
capacity_ = capacity;
|
||||
used_ = 0;
|
||||
peak_ = 0;
|
||||
}
|
||||
|
||||
void* Arena::try_alloc(usize size, usize align) {
|
||||
if (base_ == nullptr) return nullptr;
|
||||
if (!is_power_of_two(align)) return nullptr;
|
||||
|
||||
// Alignement calcule sur l offset, pas sur l adresse : la base d une arene
|
||||
// est toujours alignee sur une page (donc sur tout ce qui nous interesse),
|
||||
// et travailler en offset garde le calcul independant de l adresse reelle.
|
||||
// C est ce qui rend le comportement identique entre l hote et la cible.
|
||||
const usize aligned = (used_ + (align - 1)) & ~(align - 1);
|
||||
|
||||
// Debordement arithmetique verifie avant le test de capacite : sur une
|
||||
// taille absurde, aligned + size pourrait reboucler et passer le test.
|
||||
if (aligned < used_) return nullptr;
|
||||
if (size > capacity_ - aligned) return nullptr;
|
||||
|
||||
u8* p = base_ + aligned;
|
||||
used_ = aligned + size;
|
||||
if (used_ > peak_) peak_ = used_;
|
||||
return p;
|
||||
}
|
||||
|
||||
void* Arena::alloc(usize size, usize align) {
|
||||
void* p = try_alloc(size, align);
|
||||
if (p != nullptr) return p;
|
||||
|
||||
// Diagnostic exploitable : on veut savoir QUELLE arene, combien elle a,
|
||||
// combien on demandait. Sans ces trois nombres, le message ne sert a rien.
|
||||
err_write("proj3: PANIQUE: debordement d arene '");
|
||||
err_write(name_);
|
||||
err_write("' : demande=");
|
||||
err_write_i64(static_cast<i64>(size));
|
||||
err_write(" align=");
|
||||
err_write_i64(static_cast<i64>(align));
|
||||
err_write(" occupe=");
|
||||
err_write_i64(static_cast<i64>(used_));
|
||||
err_write(" capacite=");
|
||||
err_write_i64(static_cast<i64>(capacity_));
|
||||
err_write("\n");
|
||||
err_write(" Un debordement d arene est un defaut de conception, pas un cas\n");
|
||||
err_write(" a gerer : corriger le calcul dans mem/layout.hpp.\n");
|
||||
panic("debordement d arene");
|
||||
}
|
||||
|
||||
void Arena::rewind_to(usize m) {
|
||||
if (m > used_) {
|
||||
panic_v("rewind_to au-dela de la position courante", "marque",
|
||||
static_cast<i64>(m));
|
||||
}
|
||||
used_ = m;
|
||||
}
|
||||
|
||||
} // namespace proj3::mem
|
||||
@@ -0,0 +1,76 @@
|
||||
// mem/arena.hpp — allocateur lineaire (bump allocator).
|
||||
//
|
||||
// Regles, non negociables :
|
||||
// - allocation = avance de pointeur, avec alignement ;
|
||||
// - aucune liberation individuelle ; un reset global par arene ;
|
||||
// - un debordement est une PANIQUE, jamais un agrandissement.
|
||||
//
|
||||
// Le dernier point est le plus important : un debordement d arene signifie que
|
||||
// le calcul de mem/layout.hpp est faux. Agrandir masquerait l erreur et
|
||||
// reintroduirait une allocation apres l init, donc une latence non bornee.
|
||||
// On veut que ca casse, fort, au premier essai, avec le nom de l arene.
|
||||
#pragma once
|
||||
|
||||
#include "proj3/base/types.hpp"
|
||||
|
||||
namespace proj3::mem {
|
||||
|
||||
class Arena {
|
||||
public:
|
||||
// Une arene non initialisee est inutilisable : toute allocation panique.
|
||||
constexpr Arena() = default;
|
||||
|
||||
void init(const char* name, u8* base, usize capacity);
|
||||
|
||||
// Alloue `size` octets alignes sur `align` (puissance de deux).
|
||||
// Ne rend jamais nullptr : soit ca reussit, soit ca panique.
|
||||
void* alloc(usize size, usize align);
|
||||
|
||||
// Allocation typee. L alignement vient du type. La memoire N EST PAS
|
||||
// construite : Arena ne connait pas les constructeurs, et le projet
|
||||
// n utilise que des types trivialement constructibles.
|
||||
template <class T>
|
||||
T* alloc_array(usize count) {
|
||||
return static_cast<T*>(alloc(count * sizeof(T), alignof(T)));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
T* alloc_one() {
|
||||
return static_cast<T*>(alloc(sizeof(T), alignof(T)));
|
||||
}
|
||||
|
||||
// Version qui rend nullptr au lieu de paniquer. Reservee aux cas ou
|
||||
// l appelant a un vrai chemin de repli. Il n y en a aucun aujourd hui ;
|
||||
// elle existe pour que le harnais de test puisse verifier la borne sans
|
||||
// se faire tuer.
|
||||
void* try_alloc(usize size, usize align);
|
||||
|
||||
// Marque de position, pour un rembobinage local (motif "scratch dans le
|
||||
// scratch"). Ce n est PAS une liberation : rembobiner invalide tout ce qui
|
||||
// a ete alloue apres la marque.
|
||||
usize mark() const { return used_; }
|
||||
void rewind_to(usize m);
|
||||
|
||||
void reset() { used_ = 0; }
|
||||
|
||||
const char* name() const { return name_; }
|
||||
usize capacity() const { return capacity_; }
|
||||
usize used() const { return used_; }
|
||||
usize remaining() const { return capacity_ - used_; }
|
||||
u8* base() const { return base_; }
|
||||
|
||||
// Plus haute occupation atteinte depuis l init. C est la seule metrique
|
||||
// qui permette de dire si une taille de mem/layout.hpp est juste ou
|
||||
// fantaisiste. Elle est mise a jour a chaque allocation, cout : une
|
||||
// comparaison.
|
||||
usize peak() const { return peak_; }
|
||||
|
||||
private:
|
||||
const char* name_ = "<non initialisee>";
|
||||
u8* base_ = nullptr;
|
||||
usize capacity_ = 0;
|
||||
usize used_ = 0;
|
||||
usize peak_ = 0;
|
||||
};
|
||||
|
||||
} // namespace proj3::mem
|
||||
@@ -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
|
||||
@@ -0,0 +1,119 @@
|
||||
// mem/new_guard.cpp — GARDE-FOU DU PILIER 2.
|
||||
//
|
||||
// Redefinit les operateurs d allocation globaux pour qu ils tuent le processus
|
||||
// immediatement, avec un message identifiable.
|
||||
//
|
||||
// Ce n est pas un test : c est un filet permanent. Toute allocation dynamique
|
||||
// cachee — un std::vector oublie dans du code porte, une lambda capturee par
|
||||
// valeur qui deborde du stockage local, un conteneur d une bibliotheque tierce
|
||||
// — devient un plantage immediat et localisable au lieu d une degradation
|
||||
// silencieuse de la latence.
|
||||
//
|
||||
// COMMENT LOCALISER LE COUPABLE quand ce message apparait :
|
||||
// 1. Le message donne la taille demandee.
|
||||
// 2. Poser un point d arret sur `operator new` (le symbole existe, il n est
|
||||
// pas inline) et remonter la pile. Deux images suffisent en general.
|
||||
// 3. Sur la cible : le processus s arrete avec le code 71, distinct du 70
|
||||
// de panic(), pour qu un script sache que c est une allocation et pas
|
||||
// autre chose.
|
||||
//
|
||||
// CE QUE LE GARDE-FOU N ATTRAPE PAS, et c est important de le savoir :
|
||||
// - malloc / calloc / realloc / free appeles directement. Ce sont des
|
||||
// fonctions C, sans rapport avec operator new. Sur la cible embarquee la
|
||||
// question ne se pose pas (pas de libc, le lien echouerait). Sur l hote,
|
||||
// page_source_host.cpp les utilise deliberement.
|
||||
// - les allocations faites par le noyau (pile, mmap).
|
||||
// - les VLA et alloca, qui prennent sur la pile.
|
||||
// Le perimetre est donc exactement : "aucun new C++ nulle part". C est ce
|
||||
// qu on veut verifier.
|
||||
//
|
||||
// EMPLACEMENT DANS LA CONSTRUCTION : ce fichier est une bibliotheque separee
|
||||
// (proj3_newguard). On ne le lie que dans les executables qui pretendent ne
|
||||
// rien allouer. Le lier partout casserait tout outil qui utilise la STL de
|
||||
// l hote — ce qui est precisement le comportement recherche, mais il faut le
|
||||
// choisir explicitement, executable par executable.
|
||||
|
||||
#include "proj3/base/types.hpp"
|
||||
#include "proj3/sys/panic.hpp"
|
||||
|
||||
#if PROJ3_EMBEDDED
|
||||
#include "proj3/sys/syscalls.hpp"
|
||||
// Sur la cible embarquee il n y a pas d en-tete <new> a inclure : la
|
||||
// bibliotheque standard n est pas installee pour le triplet croise. On declare
|
||||
// donc le seul type dont on a besoin, avec exactement la definition qu impose
|
||||
// le standard ([support.types], enumeration a portee de type sous-jacent
|
||||
// size_t). Le compilateur reconnait ce type par son nom qualifie.
|
||||
namespace std {
|
||||
enum class align_val_t : proj3::usize {};
|
||||
}
|
||||
#else
|
||||
#include <cstdlib>
|
||||
#include <new>
|
||||
#endif
|
||||
|
||||
namespace {
|
||||
|
||||
[[noreturn]] void trap_allocation(const char* which, proj3::usize size) {
|
||||
proj3::err_write("proj3: ALLOCATION INTERDITE: ");
|
||||
proj3::err_write(which);
|
||||
proj3::err_write(" taille=");
|
||||
proj3::err_write_i64(static_cast<proj3::i64>(size));
|
||||
proj3::err_write("\n");
|
||||
proj3::err_write(
|
||||
" Le projet n alloue rien apres l init. Tout passe par une arene\n"
|
||||
" (mem/arena.hpp). Poser un point d arret sur operator new et\n"
|
||||
" remonter la pile pour trouver l appelant.\n");
|
||||
#if PROJ3_EMBEDDED
|
||||
proj3::sys::exit_group(71);
|
||||
#else
|
||||
std::_Exit(71);
|
||||
#endif
|
||||
}
|
||||
|
||||
[[noreturn]] void trap_free(const char* which) {
|
||||
proj3::err_write("proj3: LIBERATION INTERDITE: ");
|
||||
proj3::err_write(which);
|
||||
proj3::err_write("\n");
|
||||
proj3::err_write(
|
||||
" Une arene ne libere pas individuellement. Atteindre ce point\n"
|
||||
" signifie qu un objet a ete alloue par new quelque part.\n");
|
||||
#if PROJ3_EMBEDDED
|
||||
proj3::sys::exit_group(71);
|
||||
#else
|
||||
std::_Exit(71);
|
||||
#endif
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
// Les signatures doivent correspondre exactement a celles du standard, sinon
|
||||
// on ne remplace pas l operateur, on en ajoute un autre. On couvre les formes
|
||||
// de base et les formes alignees (C++17), que le compilateur choisit tout seul
|
||||
// pour un type sur-aligne — cas typique d un tampon NEON.
|
||||
|
||||
void* operator new(proj3::usize size) { trap_allocation("operator new", size); }
|
||||
void* operator new[](proj3::usize size) { trap_allocation("operator new[]", size); }
|
||||
|
||||
void* operator new(proj3::usize size, std::align_val_t) {
|
||||
trap_allocation("operator new (aligne)", size);
|
||||
}
|
||||
void* operator new[](proj3::usize size, std::align_val_t) {
|
||||
trap_allocation("operator new[] (aligne)", size);
|
||||
}
|
||||
|
||||
void operator delete(void*) noexcept { trap_free("operator delete"); }
|
||||
void operator delete[](void*) noexcept { trap_free("operator delete[]"); }
|
||||
void operator delete(void*, proj3::usize) noexcept { trap_free("operator delete (dimensionne)"); }
|
||||
void operator delete[](void*, proj3::usize) noexcept {
|
||||
trap_free("operator delete[] (dimensionne)");
|
||||
}
|
||||
void operator delete(void*, std::align_val_t) noexcept { trap_free("operator delete (aligne)"); }
|
||||
void operator delete[](void*, std::align_val_t) noexcept {
|
||||
trap_free("operator delete[] (aligne)");
|
||||
}
|
||||
void operator delete(void*, proj3::usize, std::align_val_t) noexcept {
|
||||
trap_free("operator delete (dimensionne aligne)");
|
||||
}
|
||||
void operator delete[](void*, proj3::usize, std::align_val_t) noexcept {
|
||||
trap_free("operator delete[] (dimensionne aligne)");
|
||||
}
|
||||
@@ -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
|
||||
@@ -0,0 +1,91 @@
|
||||
// mem/page_source_host.cpp — acquisition des pages sur la machine de dev.
|
||||
//
|
||||
// CIBLE HOTE UNIQUEMENT. Utilise malloc, ce qui serait inacceptable sur la
|
||||
// cible embarquee. C est l asymetrie assumee de l ADR-0001.
|
||||
//
|
||||
// Le mode rendu est toujours HugeMode::HostEmulated, precisement pour qu il
|
||||
// soit impossible de prendre une mesure faite ici pour une mesure faite sur
|
||||
// le telephone. Ce n est pas un detail cosmetique : c est la seule protection
|
||||
// contre la publication d un chiffre obtenu sur un x86 de bureau.
|
||||
//
|
||||
// Le malloc utilise ici est appele AVANT que le garde-fou d allocation ne
|
||||
// puisse intervenir, et il passe par malloc et non par operator new : les deux
|
||||
// mecanismes sont distincts, le garde-fou n intercepte que operator new.
|
||||
// C est voulu. Cf. mem/new_guard.cpp, section "Ce que le garde-fou n attrape
|
||||
// pas".
|
||||
#include "proj3/mem/page_source.hpp"
|
||||
|
||||
#include <cstdlib>
|
||||
|
||||
#include "proj3/mem/layout.hpp"
|
||||
#include "proj3/sys/panic.hpp"
|
||||
|
||||
namespace proj3::mem {
|
||||
namespace {
|
||||
|
||||
HugeMode g_active = HugeMode::Uninitialized;
|
||||
|
||||
// On garde le pointeur brut rendu par malloc pour pouvoir le liberer, puisque
|
||||
// la base publiee est alignee et donc potentiellement decalee.
|
||||
void* g_raw = nullptr;
|
||||
|
||||
} // namespace
|
||||
|
||||
const char* huge_mode_name(HugeMode m) {
|
||||
switch (m) {
|
||||
case HugeMode::Hugetlb2MB: return "HUGETLB-2MB";
|
||||
case HugeMode::TransparentHuge: return "THP-MADV_HUGEPAGE";
|
||||
case HugeMode::PlainPages: return "PAGES-4K";
|
||||
case HugeMode::HostEmulated: return "HOTE-EMULE";
|
||||
case HugeMode::Uninitialized: break;
|
||||
}
|
||||
return "NON-INITIALISE";
|
||||
}
|
||||
|
||||
bool page_acquire(usize size, PageBlock& out) {
|
||||
out = PageBlock{};
|
||||
if (size == 0 || (size % kHugePageSize) != 0) {
|
||||
panic_v("page_acquire : taille non multiple de 2 Mo", "taille",
|
||||
static_cast<i64>(size));
|
||||
}
|
||||
if (g_raw != nullptr) {
|
||||
panic("page_acquire hote : une seule acquisition a la fois");
|
||||
}
|
||||
|
||||
// Alignement manuel sur 2 Mo : on veut que la disposition memoire vue par
|
||||
// les arenes soit la meme que sur la cible, sinon un bug d alignement ne
|
||||
// se manifesterait que sur le telephone.
|
||||
void* raw = std::malloc(size + kHugePageSize);
|
||||
if (raw == nullptr) return false;
|
||||
g_raw = raw;
|
||||
|
||||
const uptr addr = reinterpret_cast<uptr>(raw);
|
||||
const uptr aligned = (addr + (kHugePageSize - 1)) & ~static_cast<uptr>(kHugePageSize - 1);
|
||||
|
||||
out.base = reinterpret_cast<u8*>(aligned);
|
||||
out.size = size;
|
||||
out.mode = HugeMode::HostEmulated;
|
||||
g_active = out.mode;
|
||||
return true;
|
||||
}
|
||||
|
||||
void page_release(PageBlock& block) {
|
||||
if (g_raw != nullptr) {
|
||||
std::free(g_raw);
|
||||
g_raw = nullptr;
|
||||
}
|
||||
block = PageBlock{};
|
||||
}
|
||||
|
||||
HugeMode active_mode() { return g_active; }
|
||||
|
||||
void log_active_mode() {
|
||||
err_write("proj3: memoire : mode retenu = ");
|
||||
err_write(huge_mode_name(g_active));
|
||||
err_write("\n");
|
||||
err_write("proj3: memoire : CIBLE HOTE. Aucune propriete de determinisme.\n");
|
||||
err_write("proj3: memoire : ce mode sert a valider la CORRECTION, jamais\n");
|
||||
err_write("proj3: memoire : la latence. Ne publier aucun chiffre d ici.\n");
|
||||
}
|
||||
|
||||
} // namespace proj3::mem
|
||||
@@ -0,0 +1,114 @@
|
||||
// mem/page_source_linux.cpp — acquisition des pages sur la cible embarquee.
|
||||
//
|
||||
// N utilise que nos wrappers syscall. Aucune libc.
|
||||
#include "proj3/mem/page_source.hpp"
|
||||
|
||||
#include "proj3/mem/layout.hpp"
|
||||
#include "proj3/sys/panic.hpp"
|
||||
#include "proj3/sys/syscalls.hpp"
|
||||
#include "proj3/sys/uapi.hpp"
|
||||
|
||||
namespace proj3::mem {
|
||||
namespace {
|
||||
|
||||
// Etat global mutable : une seule variable, un enum, ecrite une fois a l init
|
||||
// et lue ensuite. C est la seule entorse a la regle "pas de .data mutable",
|
||||
// et elle est ici parce que le mode retenu doit rester interrogeable par tout
|
||||
// le programme sans etre passe de main en main.
|
||||
HugeMode g_active = HugeMode::Uninitialized;
|
||||
|
||||
sys::Result map_anon(usize size, i32 extra_flags) {
|
||||
const i32 prot = sys::PROT_READ | sys::PROT_WRITE;
|
||||
const i32 flags = sys::MAP_PRIVATE | sys::MAP_ANONYMOUS | extra_flags;
|
||||
return sys::mmap(nullptr, size, prot, flags, -1, 0);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
const char* huge_mode_name(HugeMode m) {
|
||||
switch (m) {
|
||||
case HugeMode::Hugetlb2MB: return "HUGETLB-2MB";
|
||||
case HugeMode::TransparentHuge: return "THP-MADV_HUGEPAGE";
|
||||
case HugeMode::PlainPages: return "PAGES-4K";
|
||||
case HugeMode::HostEmulated: return "HOTE-EMULE";
|
||||
case HugeMode::Uninitialized: break;
|
||||
}
|
||||
return "NON-INITIALISE";
|
||||
}
|
||||
|
||||
bool page_acquire(usize size, PageBlock& out) {
|
||||
out = PageBlock{};
|
||||
if (size == 0 || (size % kHugePageSize) != 0) {
|
||||
panic_v("page_acquire : taille non multiple de 2 Mo", "taille",
|
||||
static_cast<i64>(size));
|
||||
}
|
||||
|
||||
// --- Chemin 1 : huge pages reservees ---------------------------------
|
||||
// MAP_HUGE_2MB est explicite : sans lui, MAP_HUGETLB prend la taille par
|
||||
// defaut du systeme, qui peut etre 512 Mo sur certaines configurations et
|
||||
// ferait echouer l appel pour une raison difficile a diagnostiquer.
|
||||
//
|
||||
// Echoue typiquement avec ENOMEM (pool hugetlbfs vide, cas le plus
|
||||
// probable sur un noyau Android stock : nr_hugepages vaut 0 par defaut),
|
||||
// EPERM, ou EINVAL si le noyau est compile sans CONFIG_HUGETLBFS.
|
||||
{
|
||||
const sys::Result r = map_anon(size, sys::MAP_HUGETLB | sys::MAP_HUGE_2MB);
|
||||
if (r.is_ok()) {
|
||||
out.base = static_cast<u8*>(r.ptr());
|
||||
out.size = size;
|
||||
out.mode = HugeMode::Hugetlb2MB;
|
||||
g_active = out.mode;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// --- Chemin 2 : pages classiques + conseil THP ------------------------
|
||||
{
|
||||
const sys::Result r = map_anon(size, 0);
|
||||
if (r.is_ok()) {
|
||||
out.base = static_cast<u8*>(r.ptr());
|
||||
out.size = size;
|
||||
|
||||
const sys::Result a = sys::madvise(out.base, size, sys::MADV_HUGEPAGE);
|
||||
if (a.is_ok()) {
|
||||
out.mode = HugeMode::TransparentHuge;
|
||||
} else {
|
||||
// madvise echoue avec EINVAL si le noyau est compile sans
|
||||
// CONFIG_TRANSPARENT_HUGEPAGE, ou si THP est en mode "never".
|
||||
// Le mapping reste parfaitement utilisable : on tombe au
|
||||
// chemin 3 sans refaire de mmap.
|
||||
out.mode = HugeMode::PlainPages;
|
||||
}
|
||||
g_active = out.mode;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// --- Les trois chemins ont echoue -------------------------------------
|
||||
// On ne panique pas ici : l appelant peut vouloir reessayer avec une
|
||||
// taille plus petite, ou afficher un message plus precis.
|
||||
return false;
|
||||
}
|
||||
|
||||
void page_release(PageBlock& block) {
|
||||
if (block.base == nullptr) return;
|
||||
(void)sys::munmap(block.base, block.size);
|
||||
block = PageBlock{};
|
||||
}
|
||||
|
||||
HugeMode active_mode() { return g_active; }
|
||||
|
||||
void log_active_mode() {
|
||||
err_write("proj3: memoire : mode retenu = ");
|
||||
err_write(huge_mode_name(g_active));
|
||||
err_write("\n");
|
||||
if (mode_is_deterministic(g_active)) {
|
||||
err_write("proj3: memoire : pages garanties, mesures de latence valides.\n");
|
||||
} else {
|
||||
err_write("proj3: memoire : ATTENTION, pages NON garanties.\n");
|
||||
err_write("proj3: memoire : toute mesure de latence faite dans ce mode\n");
|
||||
err_write("proj3: memoire : porte une barre d erreur inconnue.\n");
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace proj3::mem
|
||||
@@ -0,0 +1,68 @@
|
||||
#include "proj3/mem/system.hpp"
|
||||
|
||||
#include "proj3/mem/layout.hpp"
|
||||
#include "proj3/sys/panic.hpp"
|
||||
|
||||
namespace proj3::mem {
|
||||
|
||||
bool system_init(System& out) {
|
||||
if (!page_acquire(kArenaTotal, out.block)) return false;
|
||||
|
||||
u8* p = out.block.base;
|
||||
auto carve = [&p](Arena& a, const char* name, usize bytes) {
|
||||
a.init(name, p, bytes);
|
||||
p += bytes;
|
||||
};
|
||||
|
||||
// L ordre n est pas indifferent : le scanout d abord, parce que c est la
|
||||
// region la plus grosse et celle qu on voudra un jour passer telle quelle
|
||||
// a un import DRM ; elle est donc a l offset 0 du bloc, donc alignee sur
|
||||
// 2 Mo par construction.
|
||||
carve(out.scanout, "scanout", kScanoutBytes);
|
||||
carve(out.geometry, "geometrie", kGeometryBytes);
|
||||
carve(out.atlas, "atlas", kAtlasBytes);
|
||||
carve(out.input, "entree", kInputBytes);
|
||||
carve(out.scratch, "scratch", kFrameScratchBytes);
|
||||
|
||||
const usize consumed = static_cast<usize>(p - out.block.base);
|
||||
if (consumed != kArenaTotalRaw) {
|
||||
panic_v("decoupage des arenes incoherent avec layout.hpp", "consomme",
|
||||
static_cast<i64>(consumed));
|
||||
}
|
||||
|
||||
out.initialized = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
void system_begin_frame(System& s) { s.scratch.reset(); }
|
||||
|
||||
namespace {
|
||||
|
||||
void report_one(const Arena& a) {
|
||||
err_write("proj3: arene ");
|
||||
err_write(a.name());
|
||||
err_write(" : capacite=");
|
||||
err_write_i64(static_cast<i64>(a.capacity()));
|
||||
err_write(" pic=");
|
||||
err_write_i64(static_cast<i64>(a.peak()));
|
||||
err_write(" base=");
|
||||
err_write_hex(reinterpret_cast<uptr>(a.base()));
|
||||
err_write("\n");
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
void system_report(const System& s) {
|
||||
err_write("proj3: budget memoire total = ");
|
||||
err_write_i64(static_cast<i64>(kArenaTotal));
|
||||
err_write(" octets (reserve non decoupee = ");
|
||||
err_write_i64(static_cast<i64>(kReserveBytes));
|
||||
err_write(")\n");
|
||||
report_one(s.scanout);
|
||||
report_one(s.geometry);
|
||||
report_one(s.atlas);
|
||||
report_one(s.input);
|
||||
report_one(s.scratch);
|
||||
}
|
||||
|
||||
} // namespace proj3::mem
|
||||
@@ -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
|
||||
@@ -0,0 +1,54 @@
|
||||
#include "proj3/render/compose.hpp"
|
||||
|
||||
#include "proj3/base/math.hpp"
|
||||
#include "proj3/sys/panic.hpp"
|
||||
|
||||
namespace proj3::render {
|
||||
|
||||
Framebuffer framebuffer_alloc(mem::Arena& a, i32 w, i32 h) {
|
||||
Framebuffer fb;
|
||||
fb.width = w;
|
||||
fb.height = h;
|
||||
fb.pixels = a.alloc_array<u32>(static_cast<usize>(w) * static_cast<usize>(h));
|
||||
return fb;
|
||||
}
|
||||
|
||||
void framebuffer_clear(Framebuffer& fb, u32 xrgb) {
|
||||
const usize n = static_cast<usize>(fb.width) * static_cast<usize>(fb.height);
|
||||
for (usize i = 0; i < n; ++i) fb.pixels[i] = xrgb;
|
||||
}
|
||||
|
||||
void compose_coverage(Framebuffer& fb, i32 dst_x, i32 dst_y, const Coverage8& cov, u32 xrgb) {
|
||||
if (fb.empty() || cov.empty()) return;
|
||||
|
||||
// L hypothese d alignement est verifiee, pas supposee : un tampon de
|
||||
// destination desaligne rendrait tout futur noyau NEON incorrect, et le
|
||||
// symptome apparaitrait tres loin d ici.
|
||||
if ((reinterpret_cast<uptr>(fb.pixels) & 3u) != 0) {
|
||||
panic("compose_coverage : framebuffer non aligne sur 4 octets");
|
||||
}
|
||||
|
||||
// Decoupage : on calcule d abord l intersection, puis on boucle sans
|
||||
// aucun test par pixel. Un test de bord dans la boucle interne serait un
|
||||
// branchement imprevisible par pixel, donc de la variance.
|
||||
i32 sx0 = 0, sy0 = 0;
|
||||
i32 sx1 = cov.width, sy1 = cov.height;
|
||||
|
||||
if (dst_x < 0) sx0 = -dst_x;
|
||||
if (dst_y < 0) sy0 = -dst_y;
|
||||
if (dst_x + sx1 > fb.width) sx1 = fb.width - dst_x;
|
||||
if (dst_y + sy1 > fb.height) sy1 = fb.height - dst_y;
|
||||
if (sx0 >= sx1 || sy0 >= sy1) return;
|
||||
|
||||
for (i32 y = sy0; y < sy1; ++y) {
|
||||
const u8* src = cov.pixels + static_cast<usize>(y) * static_cast<usize>(cov.width);
|
||||
u32* dst = fb.row(dst_y + y) + (dst_x + sx0);
|
||||
for (i32 x = sx0; x < sx1; ++x) {
|
||||
// Couverture binaire : 0 ou 255. On teste la valeur plutot que de
|
||||
// melanger, parce qu il n y a rien a melanger (cf. compose.hpp).
|
||||
if (src[x] != 0) dst[x - sx0] = xrgb;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace proj3::render
|
||||
@@ -0,0 +1,60 @@
|
||||
// render/compose.hpp — composition d une couverture 8 bits vers le framebuffer.
|
||||
//
|
||||
// POURQUOI CE FICHIER EXISTE SEPAREMENT DU RASTERIZER.
|
||||
// Dans Gastinel Write, la rasterization et l ecriture dans le DIB Win32
|
||||
// etaient voisines, et le format BGRA du DIB s etait infiltre dans le
|
||||
// raisonnement. Ici la frontiere est explicite :
|
||||
// - le rasterizer produit de la COUVERTURE, une valeur par pixel, sans
|
||||
// aucune notion de couleur ni de format ;
|
||||
// - ce fichier, et lui seul, connait le format de destination.
|
||||
// C est cette separation qui rendra possible d ecrire un noyau NEON de
|
||||
// composition sans jamais toucher au rasterizer, et de valider les deux
|
||||
// separement dans le harnais d oracle.
|
||||
//
|
||||
// FORMAT DE DESTINATION : XRGB8888 tel que l attend un plan DRM
|
||||
// (DRM_FORMAT_XRGB8888). En memoire, sur une machine little-endian, un pixel
|
||||
// occupe quatre octets dans l ordre B, G, R, X. Manipule comme un u32, cela
|
||||
// donne 0xXXRRGGBB.
|
||||
//
|
||||
// HYPOTHESES, differentes de celles du code Windows d origine :
|
||||
// - little-endian. Verifie par static_assert dans base/types.hpp. AArch64
|
||||
// tourne en little-endian sous Linux ; le mode big-endian existe mais
|
||||
// n est pas utilise par Android ni par aucun noyau grand public.
|
||||
// - Le tampon de destination est aligne sur 4 octets au minimum. Il vient
|
||||
// d une arene dont la base est alignee sur 2 Mo, donc c est acquis ; la
|
||||
// verification est faite a l entree pour que l hypothese ne devienne pas
|
||||
// tacite.
|
||||
// - Aucun alpha : le canal X est ecrit a 0xFF et jamais lu. Le rasterizer
|
||||
// ne produisant qu une couverture binaire (dette heritee, cf.
|
||||
// rasterizer.hpp), il n y a rien a melanger : un pixel est ecrit ou il ne
|
||||
// l est pas.
|
||||
#pragma once
|
||||
|
||||
#include "proj3/mem/arena.hpp"
|
||||
#include "proj3/render/coverage.hpp"
|
||||
|
||||
namespace proj3::render {
|
||||
|
||||
struct Framebuffer {
|
||||
u32* pixels = nullptr;
|
||||
i32 width = 0;
|
||||
i32 height = 0;
|
||||
|
||||
u32* row(i32 y) { return pixels + static_cast<usize>(y) * static_cast<usize>(width); }
|
||||
const u32* row(i32 y) const {
|
||||
return pixels + static_cast<usize>(y) * static_cast<usize>(width);
|
||||
}
|
||||
bool empty() const { return width <= 0 || height <= 0 || pixels == nullptr; }
|
||||
};
|
||||
|
||||
Framebuffer framebuffer_alloc(mem::Arena& a, i32 w, i32 h);
|
||||
|
||||
void framebuffer_clear(Framebuffer& fb, u32 xrgb);
|
||||
|
||||
// Compose `cov` a la position (dst_x, dst_y) avec la couleur `xrgb`.
|
||||
// La couverture etant binaire, un pixel de couverture non nulle ecrit la
|
||||
// couleur telle quelle ; un pixel a zero ne touche pas la destination.
|
||||
// Le decoupage aux bords du framebuffer est fait ici.
|
||||
void compose_coverage(Framebuffer& fb, i32 dst_x, i32 dst_y, const Coverage8& cov, u32 xrgb);
|
||||
|
||||
} // namespace proj3::render
|
||||
@@ -0,0 +1,54 @@
|
||||
// render/coverage.hpp — image de couverture 8 bits.
|
||||
//
|
||||
// Porte depuis Gastinel Write (src/render/bitmap.h, struct Coverage8), avec un
|
||||
// changement de fond : les pixels ne sont plus dans un std::vector qui pousse,
|
||||
// mais dans une arene fournie par l appelant. Il n y a donc plus de
|
||||
// resize() ni de grow_height() : une couverture est dimensionnee une fois, a
|
||||
// la creation.
|
||||
//
|
||||
// SEPARATION CENTRALE DU PORTAGE : ce type ne connait AUCUN format de pixel.
|
||||
// C est de la couverture pure, une valeur par pixel, 0 = vide, 255 = plein.
|
||||
// La conversion vers le format du framebuffer est un autre fichier
|
||||
// (render/compose.hpp). C est cette separation qui rendra possible d ecrire
|
||||
// des noyaux NEON de composition sans toucher au rasterizer.
|
||||
#pragma once
|
||||
|
||||
#include "proj3/base/mem.hpp"
|
||||
#include "proj3/base/types.hpp"
|
||||
#include "proj3/mem/arena.hpp"
|
||||
|
||||
namespace proj3::render {
|
||||
|
||||
struct Coverage8 {
|
||||
u8* pixels = nullptr;
|
||||
i32 width = 0;
|
||||
i32 height = 0;
|
||||
|
||||
// Pas de stride distinct de la largeur : les lignes sont contigues.
|
||||
// Un stride separe serait utile pour ecrire dans une sous-fenetre ; aucun
|
||||
// usage du projet n en a besoin, et l ajouter maintenant compliquerait les
|
||||
// futurs noyaux NEON pour rien.
|
||||
usize size_bytes() const {
|
||||
return static_cast<usize>(width) * static_cast<usize>(height);
|
||||
}
|
||||
|
||||
u8 at(i32 x, i32 y) const {
|
||||
return pixels[static_cast<usize>(y) * static_cast<usize>(width) + static_cast<usize>(x)];
|
||||
}
|
||||
void set(i32 x, i32 y, u8 v) {
|
||||
pixels[static_cast<usize>(y) * static_cast<usize>(width) + static_cast<usize>(x)] = v;
|
||||
}
|
||||
bool empty() const { return width <= 0 || height <= 0 || pixels == nullptr; }
|
||||
};
|
||||
|
||||
// Alloue une couverture w*h dans `a`, remise a zero.
|
||||
inline Coverage8 coverage_alloc(mem::Arena& a, i32 w, i32 h) {
|
||||
Coverage8 c;
|
||||
c.width = w;
|
||||
c.height = h;
|
||||
c.pixels = a.alloc_array<u8>(static_cast<usize>(w) * static_cast<usize>(h));
|
||||
mem_fill(c.pixels, 0, c.size_bytes());
|
||||
return c;
|
||||
}
|
||||
|
||||
} // namespace proj3::render
|
||||
@@ -0,0 +1,262 @@
|
||||
#include "proj3/render/rasterizer.hpp"
|
||||
|
||||
#include "proj3/base/math.hpp"
|
||||
#include "proj3/base/sort.hpp"
|
||||
|
||||
namespace proj3::render {
|
||||
namespace {
|
||||
|
||||
struct Vec2 {
|
||||
f32 x = 0.0f;
|
||||
f32 y = 0.0f;
|
||||
};
|
||||
|
||||
// Une arete non horizontale, prete pour le balayage.
|
||||
// `winding` vaut +1 si l arete descend dans le repere bitmap, -1 sinon : c est
|
||||
// ce signe qui alimente la regle nonzero.
|
||||
struct Edge {
|
||||
f32 x0, y0, x1, y1;
|
||||
i32 winding;
|
||||
};
|
||||
|
||||
struct Crossing {
|
||||
f32 x;
|
||||
i32 winding;
|
||||
};
|
||||
|
||||
// Accumulateur d aretes a capacite fixe. Remplace le std::vector<Edge> de
|
||||
// l original. Le debordement est signale, jamais absorbe.
|
||||
struct EdgeList {
|
||||
Edge* data = nullptr;
|
||||
u32 count = 0;
|
||||
u32 cap = 0;
|
||||
bool overflow = false;
|
||||
|
||||
void push(const Edge& e) {
|
||||
if (count >= cap) {
|
||||
overflow = true;
|
||||
return;
|
||||
}
|
||||
data[count++] = e;
|
||||
}
|
||||
};
|
||||
|
||||
// Nombre de segments utilises pour approcher une courbe quadratique.
|
||||
// Calcule a partir de la longueur du polygone de controle : une courbe de 2 px
|
||||
// n a pas besoin du meme decoupage qu une courbe de 200 px. La borne haute
|
||||
// evite qu une taille absurde fasse exploser la liste d aretes.
|
||||
//
|
||||
// C est le SEUL endroit du portage ou la valeur numerique peut, en theorie,
|
||||
// differer de celle de Write : hypot_f64 est un calcul naif la ou l original
|
||||
// appelait std::hypot. Cf. base/math.hpp.
|
||||
i32 subdivision_count(const Vec2& p0, const Vec2& p1, const Vec2& p2) {
|
||||
const f64 d = hypot_f64(static_cast<f64>(p1.x) - p0.x, static_cast<f64>(p1.y) - p0.y) +
|
||||
hypot_f64(static_cast<f64>(p2.x) - p1.x, static_cast<f64>(p2.y) - p1.y);
|
||||
const i32 n = static_cast<i32>(ceil_f32(static_cast<f32>(d) / 1.5f));
|
||||
return clamp_to(n, 2, 64);
|
||||
}
|
||||
|
||||
void emit_edge(EdgeList& edges, const Vec2& a, const Vec2& b) {
|
||||
if (a.y == b.y) return; // arete horizontale : aucune intersection utile
|
||||
if (a.y < b.y) {
|
||||
edges.push(Edge{a.x, a.y, b.x, b.y, +1});
|
||||
} else {
|
||||
edges.push(Edge{b.x, b.y, a.x, a.y, -1});
|
||||
}
|
||||
}
|
||||
|
||||
void emit_quadratic(EdgeList& edges, const Vec2& p0, const Vec2& ctrl, const Vec2& p1) {
|
||||
const i32 n = subdivision_count(p0, ctrl, p1);
|
||||
Vec2 prev = p0;
|
||||
for (i32 i = 1; i <= n; ++i) {
|
||||
const f32 t = static_cast<f32>(i) / static_cast<f32>(n);
|
||||
const f32 u = 1.0f - t;
|
||||
Vec2 cur;
|
||||
cur.x = u * u * p0.x + 2.0f * u * t * ctrl.x + t * t * p1.x;
|
||||
cur.y = u * u * p0.y + 2.0f * u * t * ctrl.y + t * t * p1.y;
|
||||
emit_edge(edges, prev, cur);
|
||||
prev = cur;
|
||||
}
|
||||
}
|
||||
|
||||
Vec2 midpoint(const Vec2& a, const Vec2& b) {
|
||||
return Vec2{(a.x + b.x) * 0.5f, (a.y + b.y) * 0.5f};
|
||||
}
|
||||
|
||||
// Convertit un contour TrueType en aretes, en resolvant les points de controle
|
||||
// implicites : deux points off-curve consecutifs sous-entendent un point
|
||||
// on-curve situe exactement a leur milieu. C est une compression du format, pas
|
||||
// une approximation — le milieu est la vraie position du point.
|
||||
void flatten_contour(const font::GlyphPoint* pts, u32 n, f32 scale, f32 origin_x, f32 origin_y,
|
||||
EdgeList& edges) {
|
||||
if (n < 2) return;
|
||||
|
||||
// Repere bitmap : X vers la droite, Y vers le bas (d ou le signe negatif).
|
||||
auto to_device = [&](const font::GlyphPoint& p) {
|
||||
return Vec2{p.x * scale - origin_x, origin_y - p.y * scale};
|
||||
};
|
||||
|
||||
// Le contour peut tres bien commencer par un point de controle.
|
||||
u32 start_index = 0;
|
||||
Vec2 start{};
|
||||
bool found_on_curve = false;
|
||||
for (u32 i = 0; i < n; ++i) {
|
||||
if (pts[i].on_curve) {
|
||||
start_index = i;
|
||||
start = to_device(pts[i]);
|
||||
found_on_curve = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!found_on_curve) {
|
||||
// Contour entierement off-curve : le point de depart est le milieu
|
||||
// entre le dernier et le premier point de controle.
|
||||
start = midpoint(to_device(pts[n - 1]), to_device(pts[0]));
|
||||
start_index = 0;
|
||||
}
|
||||
|
||||
Vec2 cursor = start;
|
||||
bool have_ctrl = false;
|
||||
Vec2 ctrl{};
|
||||
|
||||
const u32 first = found_on_curve ? start_index + 1 : start_index;
|
||||
for (u32 k = 0; k < n; ++k) {
|
||||
const u32 i = (first + k) % n;
|
||||
if (found_on_curve && i == start_index) break;
|
||||
|
||||
const Vec2 p = to_device(pts[i]);
|
||||
if (pts[i].on_curve) {
|
||||
if (have_ctrl) {
|
||||
emit_quadratic(edges, cursor, ctrl, p);
|
||||
have_ctrl = false;
|
||||
} else {
|
||||
emit_edge(edges, cursor, p);
|
||||
}
|
||||
cursor = p;
|
||||
} else {
|
||||
if (have_ctrl) {
|
||||
const Vec2 implied = midpoint(ctrl, p);
|
||||
emit_quadratic(edges, cursor, ctrl, implied);
|
||||
cursor = implied;
|
||||
}
|
||||
ctrl = p;
|
||||
have_ctrl = true;
|
||||
}
|
||||
}
|
||||
|
||||
// Fermeture du contour, en consommant un eventuel controle en attente.
|
||||
if (have_ctrl) {
|
||||
emit_quadratic(edges, cursor, ctrl, start);
|
||||
} else {
|
||||
emit_edge(edges, cursor, start);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
bool rasterize_glyph(const font::Glyph& glyph, u16 units_per_em, f32 pixel_size,
|
||||
mem::Arena& out_arena, mem::Arena& scratch, RasterizedGlyph& out) {
|
||||
out = RasterizedGlyph{};
|
||||
if (units_per_em == 0 || pixel_size <= 0.0f) return false;
|
||||
|
||||
const f32 scale = pixel_size / static_cast<f32>(units_per_em);
|
||||
out.advance = lround_f32(glyph.advance_width * scale);
|
||||
|
||||
if (glyph.empty()) return false;
|
||||
|
||||
// Bornes reelles calculees depuis les points plutot que depuis la bbox
|
||||
// declaree : les points de controle peuvent depasser la bbox, et une bbox
|
||||
// fausse (ca existe) produirait des contours coupes.
|
||||
f32 min_x = 1e30f, min_y = 1e30f, max_x = -1e30f, max_y = -1e30f;
|
||||
for (u32 i = 0; i < glyph.point_count; ++i) {
|
||||
const font::GlyphPoint& p = glyph.points[i];
|
||||
min_x = min_of(min_x, p.x);
|
||||
min_y = min_of(min_y, p.y);
|
||||
max_x = max_of(max_x, p.x);
|
||||
max_y = max_of(max_y, p.y);
|
||||
}
|
||||
if (min_x > max_x) return false;
|
||||
|
||||
// Un pixel de marge de chaque cote absorbe les arrondis.
|
||||
const i32 px_min_x = static_cast<i32>(floor_f32(min_x * scale)) - 1;
|
||||
const i32 px_max_x = static_cast<i32>(ceil_f32(max_x * scale)) + 1;
|
||||
const i32 px_min_y = static_cast<i32>(floor_f32(min_y * scale)) - 1;
|
||||
const i32 px_max_y = static_cast<i32>(ceil_f32(max_y * scale)) + 1;
|
||||
|
||||
const i32 w = px_max_x - px_min_x;
|
||||
const i32 h = px_max_y - px_min_y;
|
||||
if (w <= 0 || h <= 0 || w > 8192 || h > 8192) return false;
|
||||
|
||||
const usize scratch_mark = scratch.mark();
|
||||
|
||||
EdgeList edges;
|
||||
edges.data = scratch.alloc_array<Edge>(kMaxEdges);
|
||||
edges.cap = kMaxEdges;
|
||||
|
||||
for (u32 c = 0; c < glyph.contour_count; ++c) {
|
||||
const u32 b = glyph.contour_begin(c);
|
||||
flatten_contour(glyph.points + b, glyph.contour_size(c), scale,
|
||||
static_cast<f32>(px_min_x), static_cast<f32>(px_max_y), edges);
|
||||
}
|
||||
if (edges.overflow) {
|
||||
// Refus explicite. L original aurait fait croitre son vector, donc
|
||||
// alloue en plein rendu : c est exactement ce qu on interdit.
|
||||
scratch.rewind_to(scratch_mark);
|
||||
return false;
|
||||
}
|
||||
if (edges.count == 0) {
|
||||
scratch.rewind_to(scratch_mark);
|
||||
return false;
|
||||
}
|
||||
|
||||
// La couverture est allouee APRES les aretes et dans une AUTRE arene :
|
||||
// elle survit au rembobinage du scratch.
|
||||
out.bearing_x = px_min_x;
|
||||
out.bearing_y = px_max_y; // haut du bitmap, au-dessus de la ligne de base
|
||||
out.coverage = coverage_alloc(out_arena, w, h);
|
||||
|
||||
// --- Balayage ---
|
||||
// Une passe par ligne, echantillonnee au centre du pixel (y + 0.5). Les
|
||||
// intersections sont collectees puis triees par x ; le compteur de winding
|
||||
// s incremente en traversant chaque arete et la ligne est remplie partout
|
||||
// ou il est non nul.
|
||||
Crossing* crossings = scratch.alloc_array<Crossing>(kMaxEdges);
|
||||
|
||||
for (i32 y = 0; y < h; ++y) {
|
||||
const f32 sample_y = static_cast<f32>(y) + 0.5f;
|
||||
u32 nc = 0;
|
||||
|
||||
for (u32 e = 0; e < edges.count; ++e) {
|
||||
const Edge& ed = edges.data[e];
|
||||
// Intervalle semi-ouvert [y0, y1) : indispensable pour qu un
|
||||
// sommet partage par deux aretes ne compte qu une fois.
|
||||
if (sample_y < ed.y0 || sample_y >= ed.y1) continue;
|
||||
const f32 t = (sample_y - ed.y0) / (ed.y1 - ed.y0);
|
||||
crossings[nc++] = Crossing{ed.x0 + t * (ed.x1 - ed.x0), ed.winding};
|
||||
}
|
||||
if (nc < 2) continue;
|
||||
|
||||
heap_sort(crossings, nc, [](const Crossing& a, const Crossing& b) { return a.x < b.x; });
|
||||
|
||||
i32 winding = 0;
|
||||
for (u32 i = 0; i + 1 < nc; ++i) {
|
||||
winding += crossings[i].winding;
|
||||
if (winding == 0) continue;
|
||||
|
||||
const f32 span_start = crossings[i].x;
|
||||
const f32 span_end = crossings[i + 1].x;
|
||||
|
||||
// On remplit les pixels dont le centre tombe dans le span.
|
||||
i32 x0 = static_cast<i32>(ceil_f32(span_start - 0.5f));
|
||||
i32 x1 = static_cast<i32>(ceil_f32(span_end - 0.5f));
|
||||
x0 = max_of(x0, 0);
|
||||
x1 = min_of(x1, w);
|
||||
for (i32 x = x0; x < x1; ++x) out.coverage.set(x, y, 255);
|
||||
}
|
||||
}
|
||||
|
||||
scratch.rewind_to(scratch_mark);
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace proj3::render
|
||||
@@ -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
|
||||
@@ -0,0 +1,57 @@
|
||||
// sys/panic.cpp — implementation embarquee (AArch64, sans libc).
|
||||
#include "proj3/sys/panic.hpp"
|
||||
|
||||
#include "proj3/base/fmt.hpp"
|
||||
#include "proj3/sys/syscalls.hpp"
|
||||
#include "proj3/sys/uapi.hpp"
|
||||
|
||||
namespace proj3 {
|
||||
|
||||
void err_write_bytes(const void* p, usize n) {
|
||||
const u8* cur = static_cast<const u8*>(p);
|
||||
usize left = n;
|
||||
// Une ecriture peut etre partielle. La boucle est bornee : chaque tour
|
||||
// consomme au moins un octet, sinon on abandonne. Pas de boucle infinie
|
||||
// possible, ce qui compte sur un chemin de panique.
|
||||
while (left > 0) {
|
||||
const sys::Result r = sys::write(sys::FD_STDERR, cur, left);
|
||||
if (r.is_err() || r.value() <= 0) return;
|
||||
const usize done = static_cast<usize>(r.value());
|
||||
cur += done;
|
||||
left -= done;
|
||||
}
|
||||
}
|
||||
|
||||
void err_write(const char* s) { err_write_bytes(s, str_len(s)); }
|
||||
|
||||
void err_write_i64(i64 v) {
|
||||
char buf[kDecBufSize];
|
||||
const usize n = fmt_i64(buf, sizeof(buf), v);
|
||||
err_write_bytes(buf, n);
|
||||
}
|
||||
|
||||
void err_write_hex(u64 v) {
|
||||
char buf[kDecBufSize];
|
||||
const usize n = fmt_hex_u64(buf, sizeof(buf), v);
|
||||
err_write_bytes(buf, n);
|
||||
}
|
||||
|
||||
[[noreturn]] void panic(const char* what) {
|
||||
err_write("proj3: PANIQUE: ");
|
||||
err_write(what);
|
||||
err_write("\n");
|
||||
sys::exit_group(70);
|
||||
}
|
||||
|
||||
[[noreturn]] void panic_v(const char* what, const char* detail, i64 value) {
|
||||
err_write("proj3: PANIQUE: ");
|
||||
err_write(what);
|
||||
err_write(" [");
|
||||
err_write(detail);
|
||||
err_write("=");
|
||||
err_write_i64(value);
|
||||
err_write("]\n");
|
||||
sys::exit_group(70);
|
||||
}
|
||||
|
||||
} // namespace proj3
|
||||
@@ -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
|
||||
@@ -0,0 +1,54 @@
|
||||
// sys/panic_host.cpp — implementation HOTE.
|
||||
//
|
||||
// Cette unite a le droit d utiliser la libc de l hote (cf. ADR-0001). Elle
|
||||
// n est JAMAIS compilee pour la cible embarquee.
|
||||
//
|
||||
// _Exit et non exit : on ne veut ni vidage des flux ni appel des destructeurs
|
||||
// statiques, pour que le comportement soit aussi brutal que sur la cible.
|
||||
#include "proj3/sys/panic.hpp"
|
||||
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
|
||||
#include "proj3/base/fmt.hpp"
|
||||
|
||||
namespace proj3 {
|
||||
|
||||
void err_write_bytes(const void* p, usize n) {
|
||||
std::fwrite(p, 1, n, stderr);
|
||||
std::fflush(stderr);
|
||||
}
|
||||
|
||||
void err_write(const char* s) { err_write_bytes(s, str_len(s)); }
|
||||
|
||||
void err_write_i64(i64 v) {
|
||||
char buf[kDecBufSize];
|
||||
const usize n = fmt_i64(buf, sizeof(buf), v);
|
||||
err_write_bytes(buf, n);
|
||||
}
|
||||
|
||||
void err_write_hex(u64 v) {
|
||||
char buf[kDecBufSize];
|
||||
const usize n = fmt_hex_u64(buf, sizeof(buf), v);
|
||||
err_write_bytes(buf, n);
|
||||
}
|
||||
|
||||
[[noreturn]] void panic(const char* what) {
|
||||
err_write("proj3: PANIQUE: ");
|
||||
err_write(what);
|
||||
err_write("\n");
|
||||
std::_Exit(70);
|
||||
}
|
||||
|
||||
[[noreturn]] void panic_v(const char* what, const char* detail, i64 value) {
|
||||
err_write("proj3: PANIQUE: ");
|
||||
err_write(what);
|
||||
err_write(" [");
|
||||
err_write(detail);
|
||||
err_write("=");
|
||||
err_write_i64(value);
|
||||
err_write("]\n");
|
||||
std::_Exit(70);
|
||||
}
|
||||
|
||||
} // namespace proj3
|
||||
@@ -0,0 +1,36 @@
|
||||
// sys/result.hpp — valeur de retour d un appel systeme.
|
||||
//
|
||||
// Convention arretee au chantier 1 : doc/convention-syscall.md, option C.
|
||||
// Le wrapper rend le x0 du noyau tel quel. Ce type est une enveloppe de cout
|
||||
// nul : sizeof == 8, trivialement copiable, donc passee et rendue en registre
|
||||
// exactement comme un i64 nu.
|
||||
#pragma once
|
||||
|
||||
#include "proj3/base/types.hpp"
|
||||
|
||||
namespace proj3::sys {
|
||||
|
||||
struct [[nodiscard]] Result {
|
||||
i64 raw;
|
||||
|
||||
// Plage d erreur EXACTE du noyau : [-4095, -1]. C est la definition de
|
||||
// IS_ERR_VALUE (include/linux/err.h, MAX_ERRNO = 4095).
|
||||
//
|
||||
// Ce n est pas "raw < 0" : mmap peut legitimement rendre une adresse dont
|
||||
// le bit 63 est a 1, et lseek une position au-dela de 2^63. Le test
|
||||
// approximatif serait faux, pas seulement imprecis.
|
||||
constexpr bool is_err() const { return raw < 0 && raw >= -4095; }
|
||||
constexpr bool is_ok() const { return !is_err(); }
|
||||
|
||||
// Code errno positif. Precondition : is_err().
|
||||
constexpr i32 err() const { return static_cast<i32>(-raw); }
|
||||
|
||||
// Valeur utile. Precondition : is_ok().
|
||||
constexpr i64 value() const { return raw; }
|
||||
constexpr i32 fd() const { return static_cast<i32>(raw); }
|
||||
void* ptr() const { return reinterpret_cast<void*>(static_cast<uptr>(raw)); }
|
||||
};
|
||||
|
||||
static_assert(sizeof(Result) == 8, "Result doit tenir dans un registre");
|
||||
|
||||
} // namespace proj3::sys
|
||||
@@ -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)
|
||||
@@ -0,0 +1,153 @@
|
||||
// sys/syscalls.hpp — declarations C++ des wrappers de asm/syscall.S.
|
||||
//
|
||||
// Toutes rendent proj3::sys::Result (cf. doc/convention-syscall.md).
|
||||
//
|
||||
// PAS DE VARIADIQUE — decision et justification :
|
||||
//
|
||||
// En C, open() et ioctl() sont declares variadiques :
|
||||
// int open(const char*, int, ...);
|
||||
// int ioctl(int, unsigned long, ...);
|
||||
// C est un artefact historique de la libc, pas une propriete du noyau : le
|
||||
// noyau recoit toujours un nombre fixe d arguments dans des registres fixes.
|
||||
//
|
||||
// Une signature variadique nous couterait trois choses, toutes contraires aux
|
||||
// piliers :
|
||||
// 1. L AAPCS64 impose un traitement DIFFERENT des arguments variadiques
|
||||
// (zone de sauvegarde des registres, va_list). Un wrapper assembleur nu
|
||||
// ne peut pas les recuperer de facon portable.
|
||||
// 2. Elle supprime toute verification de type a l appel : passer un int la
|
||||
// ou le pilote attend un pointeur compile sans un mot.
|
||||
// 3. Elle empeche le compilateur de savoir combien de registres sont
|
||||
// reellement vivants a l appel.
|
||||
//
|
||||
// On declare donc des SURCHARGES EXPLICITES, une par forme reellement
|
||||
// utilisee. Ajouter une forme = ajouter une surcharge, pas assouplir le type.
|
||||
#pragma once
|
||||
|
||||
#include "proj3/base/types.hpp"
|
||||
#include "proj3/sys/result.hpp"
|
||||
|
||||
namespace proj3::sys {
|
||||
|
||||
// struct timespec du noyau (asm-generic). 16 octets sur LP64.
|
||||
struct TimeSpec {
|
||||
i64 sec;
|
||||
i64 nsec;
|
||||
};
|
||||
static_assert(sizeof(TimeSpec) == 16);
|
||||
|
||||
// struct stat du noyau AArch64.
|
||||
// Source : include/uapi/asm-generic/stat.h (arm64 utilise la version
|
||||
// generique 64 bits). Attention : ce N EST PAS la struct stat de la glibc,
|
||||
// qui a une disposition differente. Ne jamais passer un stat de libc ici.
|
||||
struct Stat {
|
||||
u64 dev;
|
||||
u64 ino;
|
||||
u32 mode;
|
||||
u32 nlink;
|
||||
u32 uid;
|
||||
u32 gid;
|
||||
u64 rdev;
|
||||
u64 pad1;
|
||||
i64 size;
|
||||
i32 blksize;
|
||||
i32 pad2;
|
||||
i64 blocks;
|
||||
i64 atime_sec, atime_nsec;
|
||||
i64 mtime_sec, mtime_nsec;
|
||||
i64 ctime_sec, ctime_nsec;
|
||||
u32 unused4, unused5;
|
||||
};
|
||||
static_assert(sizeof(Stat) == 128, "disposition de struct stat AArch64");
|
||||
|
||||
} // namespace proj3::sys
|
||||
|
||||
// --- Symboles bruts exportes par asm/syscall.S -----------------------------
|
||||
// Declares avec les types exacts attendus par l assembleur. Ils ne sont pas
|
||||
// destines a un usage direct : la couche C++ ci-dessous les enveloppe.
|
||||
extern "C" {
|
||||
proj3::i64 proj3_sys_open(const char* path, proj3::i32 flags, proj3::u32 mode);
|
||||
proj3::i64 proj3_sys_close(proj3::i32 fd);
|
||||
proj3::i64 proj3_sys_read(proj3::i32 fd, void* buf, proj3::usize count);
|
||||
proj3::i64 proj3_sys_write(proj3::i32 fd, const void* buf, proj3::usize count);
|
||||
proj3::i64 proj3_sys_ioctl(proj3::i32 fd, proj3::u64 request, void* argp);
|
||||
proj3::i64 proj3_sys_mmap(void* addr, proj3::usize length, proj3::i32 prot,
|
||||
proj3::i32 flags, proj3::i32 fd, proj3::i64 offset);
|
||||
proj3::i64 proj3_sys_munmap(void* addr, proj3::usize length);
|
||||
proj3::i64 proj3_sys_madvise(void* addr, proj3::usize length, proj3::i32 advice);
|
||||
proj3::i64 proj3_sys_clock_gettime(proj3::i32 clk, proj3::sys::TimeSpec* out);
|
||||
proj3::i64 proj3_sys_nanosleep(const proj3::sys::TimeSpec* req,
|
||||
proj3::sys::TimeSpec* rem);
|
||||
proj3::i64 proj3_sys_getpid(void);
|
||||
proj3::i64 proj3_sys_fstat(proj3::i32 fd, proj3::sys::Stat* out);
|
||||
proj3::i64 proj3_sys_lseek(proj3::i32 fd, proj3::i64 offset, proj3::i32 whence);
|
||||
[[noreturn]] void proj3_sys_exit(proj3::i32 code);
|
||||
[[noreturn]] void proj3_sys_exit_group(proj3::i32 code);
|
||||
}
|
||||
|
||||
namespace proj3::sys {
|
||||
|
||||
// --- open : surcharges explicites au lieu du variadique -------------------
|
||||
|
||||
// Ouverture sans creation. `mode` n est pas transmis parce qu il n a aucun
|
||||
// sens sans O_CREAT ; le noyau l ignorerait, mais le laisser dans la
|
||||
// signature laisserait croire qu il sert.
|
||||
inline Result open(const char* path, i32 flags) {
|
||||
return Result{proj3_sys_open(path, flags, 0)};
|
||||
}
|
||||
|
||||
// Ouverture avec creation. Forme distincte, exigeant le mode : impossible
|
||||
// d appeler O_CREAT en oubliant les permissions, ce qui donnerait un fichier
|
||||
// aux droits aleatoires (le bug classique du open variadique).
|
||||
inline Result open_create(const char* path, i32 flags, u32 mode) {
|
||||
return Result{proj3_sys_open(path, flags, mode)};
|
||||
}
|
||||
|
||||
inline Result close(i32 fd) { return Result{proj3_sys_close(fd)}; }
|
||||
inline Result read(i32 fd, void* buf, usize n) { return Result{proj3_sys_read(fd, buf, n)}; }
|
||||
inline Result write(i32 fd, const void* buf, usize n) {
|
||||
return Result{proj3_sys_write(fd, buf, n)};
|
||||
}
|
||||
|
||||
// --- ioctl : surcharges explicites ----------------------------------------
|
||||
// Les trois seules formes qui existent reellement au niveau du noyau : sans
|
||||
// argument, avec un argument entier passe par valeur, avec un pointeur.
|
||||
// Le troisieme argument est TOUJOURS place dans x2 ; ces surcharges ne font
|
||||
// que rendre le type explicite a l appel.
|
||||
inline Result ioctl(i32 fd, u64 request) {
|
||||
return Result{proj3_sys_ioctl(fd, request, nullptr)};
|
||||
}
|
||||
inline Result ioctl(i32 fd, u64 request, void* argp) {
|
||||
return Result{proj3_sys_ioctl(fd, request, argp)};
|
||||
}
|
||||
inline Result ioctl_val(i32 fd, u64 request, u64 value) {
|
||||
return Result{proj3_sys_ioctl(fd, request, reinterpret_cast<void*>(value))};
|
||||
}
|
||||
|
||||
inline Result mmap(void* addr, usize length, i32 prot, i32 flags, i32 fd, i64 offset) {
|
||||
return Result{proj3_sys_mmap(addr, length, prot, flags, fd, offset)};
|
||||
}
|
||||
inline Result munmap(void* addr, usize length) {
|
||||
return Result{proj3_sys_munmap(addr, length)};
|
||||
}
|
||||
inline Result madvise(void* addr, usize length, i32 advice) {
|
||||
return Result{proj3_sys_madvise(addr, length, advice)};
|
||||
}
|
||||
|
||||
inline Result clock_gettime(i32 clk, TimeSpec* out) {
|
||||
return Result{proj3_sys_clock_gettime(clk, out)};
|
||||
}
|
||||
inline Result nanosleep(const TimeSpec* req, TimeSpec* rem) {
|
||||
return Result{proj3_sys_nanosleep(req, rem)};
|
||||
}
|
||||
|
||||
inline Result getpid() { return Result{proj3_sys_getpid()}; }
|
||||
inline Result fstat(i32 fd, Stat* out) { return Result{proj3_sys_fstat(fd, out)}; }
|
||||
inline Result lseek(i32 fd, i64 offset, i32 whence) {
|
||||
return Result{proj3_sys_lseek(fd, offset, whence)};
|
||||
}
|
||||
|
||||
[[noreturn]] inline void exit(i32 code) { proj3_sys_exit(code); }
|
||||
[[noreturn]] inline void exit_group(i32 code) { proj3_sys_exit_group(code); }
|
||||
|
||||
} // namespace proj3::sys
|
||||
@@ -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
|
||||
Fichier binaire non affiché.
@@ -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.
|
||||
@@ -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
|
||||
@@ -0,0 +1,57 @@
|
||||
// test/oracle/main.cpp — point d entree du harnais d oracle.
|
||||
//
|
||||
// Le meme fichier sert aux deux cibles :
|
||||
// hote -> main(), executable proj3_oracle
|
||||
// embarquee -> proj3_main(), executable proj3_oracle_target
|
||||
//
|
||||
// Code de sortie : 0 si toutes les paires concordent, 1 sinon. Rien d autre,
|
||||
// pour qu il soit utilisable tel quel par ctest ou par un script.
|
||||
|
||||
#include "oracle.hpp"
|
||||
|
||||
#include "proj3/mem/system.hpp"
|
||||
#include "proj3/sys/panic.hpp"
|
||||
|
||||
using namespace proj3;
|
||||
|
||||
static int oracle_entry() {
|
||||
err_write("=== harnais d oracle proj3 ===\n");
|
||||
|
||||
static mem::System sys;
|
||||
if (!mem::system_init(sys)) {
|
||||
err_write("impossible d acquerir la memoire de travail\n");
|
||||
return 1;
|
||||
}
|
||||
oracle::g_system = &sys;
|
||||
mem::log_active_mode();
|
||||
err_write("\n");
|
||||
|
||||
oracle::Report rep;
|
||||
const bool ok = oracle::run_all(sys.scratch, rep);
|
||||
|
||||
err_write("\npaires comparees : ");
|
||||
err_write_i64(rep.pairs_run);
|
||||
err_write("\npaires en reference seule : ");
|
||||
err_write_i64(rep.pairs_ref_only);
|
||||
err_write("\ncas executes : ");
|
||||
err_write_i64(rep.cases_run);
|
||||
err_write("\ncas en echec : ");
|
||||
err_write_i64(rep.cases_failed);
|
||||
err_write(ok ? "\nRESULTAT : concordance totale\n" : "\nRESULTAT : DIVERGENCE\n");
|
||||
|
||||
// Pic d occupation du scratch : verifie que le dimensionnement de
|
||||
// mem/layout.hpp tient, y compris sous le harnais.
|
||||
err_write("pic scratch : ");
|
||||
err_write_i64(static_cast<i64>(sys.scratch.peak()));
|
||||
err_write(" / ");
|
||||
err_write_i64(static_cast<i64>(sys.scratch.capacity()));
|
||||
err_write("\n");
|
||||
|
||||
return ok ? 0 : 1;
|
||||
}
|
||||
|
||||
#if PROJ3_EMBEDDED
|
||||
extern "C" int proj3_main(int, char**) { return oracle_entry(); }
|
||||
#else
|
||||
int main() { return oracle_entry(); }
|
||||
#endif
|
||||
@@ -0,0 +1,243 @@
|
||||
#include "oracle.hpp"
|
||||
|
||||
#include "proj3/base/fmt.hpp"
|
||||
#include "proj3/base/mem.hpp"
|
||||
#include "proj3/sys/panic.hpp"
|
||||
|
||||
namespace proj3::oracle {
|
||||
|
||||
mem::System* g_system = nullptr;
|
||||
|
||||
namespace {
|
||||
|
||||
// Octet de garde ecrit apres chaque tampon de sortie. Toute routine qui ecrit
|
||||
// un octet de trop l ecrase, et le harnais le voit. C est ce qui transforme
|
||||
// le cas "debordement d un octet" en detection, au lieu d une corruption
|
||||
// silencieuse d une zone voisine.
|
||||
constexpr u8 kGuardByte = 0xA5;
|
||||
constexpr usize kGuardBytes = 32;
|
||||
|
||||
// Motif deterministe, pour les cas de graine 0. Volontairement non trivial
|
||||
// (ni tout a zero ni croissant) pour qu une routine qui ignore son entree ne
|
||||
// passe pas par chance.
|
||||
void fill_deterministic(u8* p, usize n) {
|
||||
for (usize i = 0; i < n; ++i) {
|
||||
p[i] = static_cast<u8>((i * 31u + (i >> 3) * 17u + 0x5Bu) & 0xFFu);
|
||||
}
|
||||
}
|
||||
|
||||
void fill_random(u8* p, usize n, u64 seed) {
|
||||
Rng rng(seed);
|
||||
usize i = 0;
|
||||
while (i < n) {
|
||||
u64 v = rng.next();
|
||||
for (int b = 0; b < 8 && i < n; ++b, ++i) {
|
||||
p[i] = static_cast<u8>(v & 0xFFu);
|
||||
v >>= 8;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void dump_hex(const u8* p, usize n) {
|
||||
char buf[3];
|
||||
for (usize i = 0; i < n; ++i) {
|
||||
const usize k = fmt_hex_u8(buf, sizeof(buf), p[i]);
|
||||
err_write_bytes(buf, k);
|
||||
buf[0] = ' ';
|
||||
err_write_bytes(buf, 1);
|
||||
}
|
||||
}
|
||||
|
||||
// Contexte autour de l offset divergent : 16 octets avant, 16 apres, bornes au
|
||||
// tampon. Sans contexte, un offset seul ne dit pas si l erreur est un decalage
|
||||
// ou une valeur fausse.
|
||||
void dump_context(const char* tag, const u8* p, usize len, usize center) {
|
||||
const usize begin = center >= 16 ? center - 16 : 0;
|
||||
usize end = center + 17;
|
||||
if (end > len) end = len;
|
||||
err_write(" ");
|
||||
err_write(tag);
|
||||
err_write(" [");
|
||||
err_write_i64(static_cast<i64>(begin));
|
||||
err_write("..");
|
||||
err_write_i64(static_cast<i64>(end));
|
||||
err_write(") : ");
|
||||
dump_hex(p + begin, end - begin);
|
||||
err_write("\n");
|
||||
}
|
||||
|
||||
bool guards_intact(const u8* guard) {
|
||||
for (usize i = 0; i < kGuardBytes; ++i) {
|
||||
if (guard[i] != kGuardByte) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// --- Enregistrement --------------------------------------------------------
|
||||
#if PROJ3_EMBEDDED
|
||||
// Symboles synthetises par l editeur de liens pour la section proj3_pairs.
|
||||
extern "C" const Pair* const __start_proj3_pairs[];
|
||||
extern "C" const Pair* const __stop_proj3_pairs[];
|
||||
#else
|
||||
// Stockage statique a initialisation constante : il est pret AVANT que le
|
||||
// moindre constructeur statique ne tourne, donc l ordre d initialisation ne
|
||||
// peut pas nous mordre.
|
||||
constexpr usize kMaxPairs = 64;
|
||||
const Pair* g_pairs[kMaxPairs];
|
||||
usize g_pair_count;
|
||||
#endif
|
||||
|
||||
} // namespace
|
||||
|
||||
void register_pair(const Pair* p) {
|
||||
#if PROJ3_EMBEDDED
|
||||
(void)p; // l enregistrement se fait par la section, pas par appel
|
||||
#else
|
||||
if (g_pair_count >= kMaxPairs) panic("oracle : trop de paires enregistrees");
|
||||
g_pairs[g_pair_count++] = p;
|
||||
#endif
|
||||
}
|
||||
|
||||
bool run_pair(const Pair& p, mem::Arena& work, Report& out, bool expect_failure) {
|
||||
bool pair_ok = true;
|
||||
|
||||
if (p.opt == nullptr) {
|
||||
++out.pairs_ref_only;
|
||||
} else {
|
||||
++out.pairs_run;
|
||||
}
|
||||
|
||||
for (usize ci = 0; ci < p.case_count; ++ci) {
|
||||
const CaseSpec& c = p.cases[ci];
|
||||
const usize mark = work.mark();
|
||||
|
||||
// Tampons : chacun precede de son decalage d alignement et suivi d une
|
||||
// zone de garde. La base de l arene est alignee sur 2 Mo, donc un
|
||||
// decalage de k octets donne une adresse ≡ k modulo 16 : c est
|
||||
// exactement le levier dont les chemins NEON auront besoin.
|
||||
u8* in_raw = work.alloc_array<u8>(c.in_len + 64);
|
||||
u8* in = in_raw + c.in_align_offset;
|
||||
|
||||
const usize out_cap = c.in_len;
|
||||
u8* ref_raw = work.alloc_array<u8>(out_cap + 64 + kGuardBytes);
|
||||
u8* ref_out = ref_raw + c.out_align_offset;
|
||||
u8* ref_guard = ref_out + out_cap;
|
||||
|
||||
u8* opt_raw = work.alloc_array<u8>(out_cap + 64 + kGuardBytes);
|
||||
u8* opt_out = opt_raw + c.out_align_offset;
|
||||
u8* opt_guard = opt_out + out_cap;
|
||||
|
||||
if (c.seed == 0) {
|
||||
fill_deterministic(in, c.in_len);
|
||||
} else {
|
||||
fill_random(in, c.in_len, c.seed);
|
||||
}
|
||||
|
||||
mem_fill(ref_out, 0, out_cap);
|
||||
mem_fill(opt_out, 0, out_cap);
|
||||
mem_fill(ref_guard, kGuardByte, kGuardBytes);
|
||||
mem_fill(opt_guard, kGuardByte, kGuardBytes);
|
||||
|
||||
const usize ref_len = p.ref(in, c.in_len, ref_out, out_cap);
|
||||
++out.cases_run;
|
||||
|
||||
bool case_ok = true;
|
||||
const char* reason = nullptr;
|
||||
usize diff_at = 0;
|
||||
|
||||
if (!guards_intact(ref_guard)) {
|
||||
case_ok = false;
|
||||
reason = "la REFERENCE a deborde son tampon de sortie";
|
||||
}
|
||||
|
||||
if (case_ok && p.opt != nullptr) {
|
||||
const usize opt_len = p.opt(in, c.in_len, opt_out, out_cap);
|
||||
|
||||
if (!guards_intact(opt_guard)) {
|
||||
case_ok = false;
|
||||
reason = "l implementation optimisee a deborde son tampon";
|
||||
} else if (opt_len != ref_len) {
|
||||
case_ok = false;
|
||||
reason = "longueur de sortie differente";
|
||||
} else {
|
||||
diff_at = mem_first_diff(ref_out, opt_out, ref_len);
|
||||
if (diff_at != ref_len) {
|
||||
case_ok = false;
|
||||
reason = "octet divergent";
|
||||
}
|
||||
}
|
||||
|
||||
if (!case_ok) {
|
||||
err_write("ECHEC ");
|
||||
err_write(p.name);
|
||||
err_write(" / ");
|
||||
err_write(c.label);
|
||||
err_write("\n ");
|
||||
err_write(reason);
|
||||
err_write("\n");
|
||||
err_write(" rejouer ce cas : graine=");
|
||||
err_write_i64(static_cast<i64>(c.seed));
|
||||
err_write(" in_len=");
|
||||
err_write_i64(static_cast<i64>(c.in_len));
|
||||
err_write(" align_in=+");
|
||||
err_write_i64(c.in_align_offset);
|
||||
err_write(" align_out=+");
|
||||
err_write_i64(c.out_align_offset);
|
||||
err_write("\n");
|
||||
err_write(" longueurs : reference=");
|
||||
err_write_i64(static_cast<i64>(ref_len));
|
||||
err_write(" optimisee=");
|
||||
err_write_i64(static_cast<i64>(opt_len));
|
||||
err_write("\n");
|
||||
if (diff_at < ref_len) {
|
||||
err_write(" premier octet divergent a l offset ");
|
||||
err_write_i64(static_cast<i64>(diff_at));
|
||||
err_write(" : attendu=");
|
||||
err_write_hex(ref_out[diff_at]);
|
||||
err_write(" obtenu=");
|
||||
err_write_hex(opt_out[diff_at]);
|
||||
err_write("\n");
|
||||
dump_context("attendu", ref_out, ref_len, diff_at);
|
||||
dump_context("obtenu ", opt_out, opt_len, diff_at);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!case_ok) {
|
||||
++out.cases_failed;
|
||||
pair_ok = false;
|
||||
}
|
||||
|
||||
work.rewind_to(mark);
|
||||
}
|
||||
|
||||
if (pair_ok) {
|
||||
err_write(p.opt == nullptr ? "REF " : "OK ");
|
||||
err_write(p.name);
|
||||
if (p.opt == nullptr) {
|
||||
err_write(" (reference figee, version assembleur absente)");
|
||||
}
|
||||
err_write("\n");
|
||||
}
|
||||
|
||||
// Un self-test attend un echec : dans ce cas, "reussi" veut dire "a bien
|
||||
// echoue". Sans cette inversion, on ne saurait pas prouver que le harnais
|
||||
// sait detecter une erreur connue.
|
||||
return expect_failure ? !pair_ok : pair_ok;
|
||||
}
|
||||
|
||||
bool run_all(mem::Arena& work, Report& out) {
|
||||
bool ok = true;
|
||||
#if PROJ3_EMBEDDED
|
||||
for (const Pair* const* it = __start_proj3_pairs; it != __stop_proj3_pairs; ++it) {
|
||||
if (!run_pair(**it, work, out, false)) ok = false;
|
||||
}
|
||||
#else
|
||||
for (usize i = 0; i < g_pair_count; ++i) {
|
||||
if (!run_pair(*g_pairs[i], work, out, false)) ok = false;
|
||||
}
|
||||
#endif
|
||||
return ok;
|
||||
}
|
||||
|
||||
} // namespace proj3::oracle
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1,197 @@
|
||||
// test/oracle/pairs_render.cpp — enregistrement des routines du pipeline de
|
||||
// rendu comme REFERENCES FIGEES.
|
||||
//
|
||||
// Aucune version assembleur n existe encore (chantier 5 : « Pas de version
|
||||
// assembleur du rasterizer dans cette passe »). C est precisement pour cela
|
||||
// que ces paires sont enregistrees maintenant, avec opt = nullptr :
|
||||
//
|
||||
// - le harnais execute la reference sur tous les cas, ce qui verifie qu elle
|
||||
// ne plante pas, ne deborde pas son tampon, et n alloue rien (le garde-fou
|
||||
// du chantier 3 est lie a cet executable) ;
|
||||
// - le jour ou la version NEON arrive, il n y a qu un pointeur a remplir.
|
||||
// Personne n a a se demander comment brancher le test : il est deja la.
|
||||
//
|
||||
// Enregistrer une routine AVANT d avoir son assembleur est la seule facon
|
||||
// d etre sur que le harnais sera utilise. Construit apres coup, il ne l est
|
||||
// jamais.
|
||||
|
||||
#include "oracle.hpp"
|
||||
|
||||
#include "proj3/render/compose.hpp"
|
||||
#include "proj3/render/rasterizer.hpp"
|
||||
|
||||
namespace proj3::oracle {
|
||||
namespace {
|
||||
|
||||
// --- Glyphe synthetique ----------------------------------------------------
|
||||
// Le harnais ne doit dependre d aucun fichier : il doit tourner sur la machine
|
||||
// de dev, sur un Raspberry Pi, dans un conteneur, sans police installee. On
|
||||
// fabrique donc un glyphe a partir des octets d entree.
|
||||
//
|
||||
// Forme : un rectangle exterieur (sens horaire) et un rectangle interieur
|
||||
// (sens anti-horaire), plus un arc quadratique. C est le minimum qui exerce
|
||||
// vraiment le nonzero winding : si la regle etait mal portee, le rectangle
|
||||
// interieur ne serait pas creuse et la difference sauterait aux yeux.
|
||||
constexpr u32 kSynthPointCount = 12;
|
||||
constexpr u32 kSynthContourCount = 2;
|
||||
|
||||
struct SynthGlyph {
|
||||
font::GlyphPoint points[kSynthPointCount];
|
||||
u32 contour_end[kSynthContourCount];
|
||||
font::Glyph glyph;
|
||||
};
|
||||
|
||||
void build_synth(SynthGlyph& g, const u8* in, usize in_len) {
|
||||
// Deux octets d entree pilotent la geometrie. Bornes pour rester dans des
|
||||
// valeurs de police plausibles et pour que le glyphe ne soit jamais vide.
|
||||
const f32 w = 200.0f + static_cast<f32>(in_len > 0 ? in[0] : 0u) * 2.0f;
|
||||
const f32 h = 300.0f + static_cast<f32>(in_len > 1 ? in[1] : 0u) * 2.0f;
|
||||
const f32 inset = 40.0f + static_cast<f32>(in_len > 2 ? (in[2] & 0x3Fu) : 0u);
|
||||
|
||||
auto P = [](f32 x, f32 y, bool on) {
|
||||
font::GlyphPoint p;
|
||||
p.x = x;
|
||||
p.y = y;
|
||||
p.on_curve = on;
|
||||
return p;
|
||||
};
|
||||
|
||||
// Contour exterieur : rectangle avec un cote superieur bombe (un point de
|
||||
// controle off-curve), 6 points.
|
||||
g.points[0] = P(0.0f, 0.0f, true);
|
||||
g.points[1] = P(w, 0.0f, true);
|
||||
g.points[2] = P(w, h, true);
|
||||
g.points[3] = P(w * 0.5f, h + 80.0f, false); // controle quadratique
|
||||
g.points[4] = P(0.0f, h, true);
|
||||
g.points[5] = P(0.0f, h * 0.5f, true);
|
||||
g.contour_end[0] = 6;
|
||||
|
||||
// Contour interieur, oriente en sens inverse : c est lui que le nonzero
|
||||
// doit creuser. 6 points aussi, pour garder un tableau simple.
|
||||
const f32 x0 = inset, x1 = w - inset;
|
||||
const f32 y0 = inset, y1 = h - inset;
|
||||
g.points[6] = P(x0, y0, true);
|
||||
g.points[7] = P(x0, y1, true);
|
||||
g.points[8] = P((x0 + x1) * 0.5f, y1 + 20.0f, false);
|
||||
g.points[9] = P(x1, y1, true);
|
||||
g.points[10] = P(x1, y0, true);
|
||||
g.points[11] = P((x0 + x1) * 0.5f, y0 - 20.0f, false);
|
||||
g.contour_end[1] = 12;
|
||||
|
||||
g.glyph = font::Glyph{};
|
||||
g.glyph.points = g.points;
|
||||
g.glyph.contour_end = g.contour_end;
|
||||
g.glyph.point_count = kSynthPointCount;
|
||||
g.glyph.contour_count = kSynthContourCount;
|
||||
g.glyph.advance_width = w + 100.0f;
|
||||
}
|
||||
|
||||
// --- Paire 1 : rasterization ----------------------------------------------
|
||||
usize rasterize_ref(const u8* in, usize in_len, u8* out, usize out_cap) {
|
||||
if (g_system == nullptr) return 0;
|
||||
|
||||
SynthGlyph g;
|
||||
build_synth(g, in, in_len);
|
||||
|
||||
// Taille en pixels pilotee par l entree, bornee a des corps realistes.
|
||||
const f32 px = 8.0f + static_cast<f32>(in_len > 3 ? (in[3] & 0x3Fu) : 16u);
|
||||
|
||||
mem::Arena& scratch = g_system->geometry;
|
||||
mem::Arena& store = g_system->atlas;
|
||||
const usize m_scratch = scratch.mark();
|
||||
const usize m_store = store.mark();
|
||||
|
||||
render::RasterizedGlyph rg;
|
||||
const bool ok = render::rasterize_glyph(g.glyph, 1000, px, store, scratch, rg);
|
||||
|
||||
usize written = 0;
|
||||
if (ok) {
|
||||
// On publie la couverture brute, plus les trois metriques en tete :
|
||||
// une divergence de bearing ou d avance doit etre detectee au meme
|
||||
// titre qu une divergence de pixel.
|
||||
const i32 meta[3] = {rg.bearing_x, rg.bearing_y, rg.advance};
|
||||
const u8* meta_bytes = reinterpret_cast<const u8*>(meta);
|
||||
for (usize i = 0; i < sizeof(meta) && written < out_cap; ++i) {
|
||||
out[written++] = meta_bytes[i];
|
||||
}
|
||||
const usize n = rg.coverage.size_bytes();
|
||||
for (usize i = 0; i < n && written < out_cap; ++i) {
|
||||
out[written++] = rg.coverage.pixels[i];
|
||||
}
|
||||
}
|
||||
|
||||
store.rewind_to(m_store);
|
||||
scratch.rewind_to(m_scratch);
|
||||
return written;
|
||||
}
|
||||
|
||||
// Les tailles sont choisies pour que la couverture depasse largement out_cap
|
||||
// dans les petits cas (on ne compare alors que le prefixe) et la remplisse
|
||||
// dans les grands.
|
||||
const CaseSpec kRasterCases[] = {
|
||||
{"entree vide", 0, 0, 0, 0},
|
||||
{"4 octets", 4, 0, 0, 0},
|
||||
{"64 octets", 64, 0, 0, 0},
|
||||
{"4 Ko", 4096, 0, 0, 0},
|
||||
{"4 Ko desaligne +1/+3", 4096, 0, 1, 3},
|
||||
{"aleatoire 4 Ko", 4096, 0xA5A5'5A5A'0F0F'F0F0ull, 0, 0},
|
||||
{"aleatoire 16 Ko", 16384, 0x0123'4567'89AB'CDEFull, 0, 0},
|
||||
};
|
||||
|
||||
PROJ3_ORACLE_PAIR(raster_glyph, "render::rasterize_glyph (glyphe synthetique)",
|
||||
&rasterize_ref, nullptr, kRasterCases);
|
||||
|
||||
// --- Paire 2 : composition -------------------------------------------------
|
||||
// Separee de la rasterization, comme le code l est : c est cette routine-la
|
||||
// qui deviendra un noyau NEON en premier.
|
||||
usize compose_ref(const u8* in, usize in_len, u8* out, usize out_cap) {
|
||||
if (g_system == nullptr || out_cap < 16) return 0;
|
||||
|
||||
// Framebuffer minuscule ecrit directement dans `out` : on compare donc
|
||||
// exactement les octets que la routine produit, sans recopie.
|
||||
const i32 fw = 32;
|
||||
const i32 fh = static_cast<i32>(out_cap / (4u * 32u));
|
||||
if (fh <= 0) return 0;
|
||||
|
||||
render::Framebuffer fb;
|
||||
fb.pixels = reinterpret_cast<u32*>(out);
|
||||
fb.width = fw;
|
||||
fb.height = fh;
|
||||
|
||||
// out est aligne par le harnais selon out_align_offset ; compose_coverage
|
||||
// exige 4 octets. On refuse proprement si l alignement ne convient pas,
|
||||
// plutot que de paniquer : ce cas fait partie de ce qu on veut tester.
|
||||
if ((reinterpret_cast<uptr>(out) & 3u) != 0) return 0;
|
||||
|
||||
render::framebuffer_clear(fb, 0xFF000000u);
|
||||
|
||||
mem::Arena& store = g_system->atlas;
|
||||
const usize m = store.mark();
|
||||
|
||||
render::Coverage8 cov = render::coverage_alloc(store, 16, 16);
|
||||
for (usize i = 0; i < cov.size_bytes(); ++i) {
|
||||
cov.pixels[i] = (i < in_len && (in[i] & 1u) != 0) ? 255 : 0;
|
||||
}
|
||||
|
||||
// Trois positions : entierement dedans, a cheval sur le bord droit, a
|
||||
// cheval sur le coin haut-gauche (coordonnees negatives).
|
||||
render::compose_coverage(fb, 2, 2, cov, 0xFFFFFFFFu);
|
||||
render::compose_coverage(fb, fw - 8, 4, cov, 0xFF00FF00u);
|
||||
render::compose_coverage(fb, -6, -6, cov, 0xFFFF0000u);
|
||||
|
||||
store.rewind_to(m);
|
||||
return static_cast<usize>(fw) * static_cast<usize>(fh) * 4u;
|
||||
}
|
||||
|
||||
const CaseSpec kComposeCases[] = {
|
||||
{"1 ligne", 128, 0, 0, 0},
|
||||
{"8 lignes", 1024, 0, 0, 0},
|
||||
{"32 lignes", 4096, 0, 0, 0},
|
||||
{"32 lignes aleatoire", 4096, 0xFEED'FACE'DEAD'C0DEull, 0, 0},
|
||||
};
|
||||
|
||||
PROJ3_ORACLE_PAIR(compose_cov, "render::compose_coverage", &compose_ref, nullptr,
|
||||
kComposeCases);
|
||||
|
||||
} // namespace
|
||||
} // namespace proj3::oracle
|
||||
@@ -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;
|
||||
}
|
||||
@@ -0,0 +1,122 @@
|
||||
// test/test_arena.cpp — arenes et acquisition de pages (chantier 3).
|
||||
//
|
||||
// S execute sur la machine de dev. Il ne teste PAS le repli huge pages, qui
|
||||
// demande un vrai noyau Linux : sur l hote, page_acquire rend toujours
|
||||
// HostEmulated. Ce que ce test verifie, c est la logique d arene elle-meme,
|
||||
// qui est du code portable partage a l identique par les deux cibles.
|
||||
|
||||
#include "proj3/mem/layout.hpp"
|
||||
#include "proj3/mem/system.hpp"
|
||||
#include "proj3/sys/panic.hpp"
|
||||
|
||||
using namespace proj3;
|
||||
|
||||
namespace {
|
||||
|
||||
int g_failures = 0;
|
||||
|
||||
void check(bool cond, const char* what) {
|
||||
err_write(cond ? "OK " : "ECHEC ");
|
||||
err_write(what);
|
||||
err_write("\n");
|
||||
if (!cond) ++g_failures;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
int main() {
|
||||
err_write("=== arenes ===\n\n");
|
||||
|
||||
static mem::System sys;
|
||||
check(mem::system_init(sys), "system_init");
|
||||
mem::log_active_mode();
|
||||
err_write("\n");
|
||||
|
||||
check(sys.scanout.capacity() == mem::kScanoutBytes, "taille de l arene scanout");
|
||||
check(sys.scanout.used() == 0, "arene neuve : occupation nulle");
|
||||
|
||||
// --- Alignement ---------------------------------------------------------
|
||||
{
|
||||
mem::Arena& a = sys.scratch;
|
||||
a.reset();
|
||||
(void)a.alloc(1, 1); // desaligne volontairement la suite
|
||||
void* p16 = a.alloc(8, 16);
|
||||
void* p64 = a.alloc(8, 64);
|
||||
check((reinterpret_cast<uptr>(p16) & 15u) == 0, "alignement 16 respecte");
|
||||
check((reinterpret_cast<uptr>(p64) & 63u) == 0, "alignement 64 respecte");
|
||||
}
|
||||
|
||||
// --- Avance de pointeur -------------------------------------------------
|
||||
{
|
||||
mem::Arena& a = sys.scratch;
|
||||
a.reset();
|
||||
u8* x = a.alloc_array<u8>(100);
|
||||
u8* y = a.alloc_array<u8>(100);
|
||||
check(y == x + 100, "allocations contigues sans alignement force");
|
||||
check(a.used() == 200, "occupation exacte");
|
||||
}
|
||||
|
||||
// --- mark / rewind ------------------------------------------------------
|
||||
{
|
||||
mem::Arena& a = sys.scratch;
|
||||
a.reset();
|
||||
(void)a.alloc_array<u8>(500);
|
||||
const usize m = a.mark();
|
||||
(void)a.alloc_array<u8>(1000);
|
||||
check(a.used() == 1500, "occupation apres deux allocations");
|
||||
a.rewind_to(m);
|
||||
check(a.used() == 500, "rewind_to restitue la position");
|
||||
}
|
||||
|
||||
// --- reset --------------------------------------------------------------
|
||||
{
|
||||
mem::Arena& a = sys.scratch;
|
||||
(void)a.alloc_array<u8>(1000);
|
||||
const usize peak_before = a.peak();
|
||||
a.reset();
|
||||
check(a.used() == 0, "reset remet l occupation a zero");
|
||||
check(a.peak() == peak_before, "reset ne remet PAS le pic a zero");
|
||||
}
|
||||
|
||||
// --- Borne : try_alloc rend nullptr au lieu de paniquer -----------------
|
||||
// On ne peut pas tester alloc() directement : par conception, il tue le
|
||||
// processus. C est exactement ce que verifie test_new_guard pour operator
|
||||
// new ; ici on se contente de la variante non fatale.
|
||||
{
|
||||
mem::Arena& a = sys.input;
|
||||
a.reset();
|
||||
void* p = a.try_alloc(a.capacity() + 1, 1);
|
||||
check(p == nullptr, "try_alloc au-dela de la capacite rend nullptr");
|
||||
check(a.used() == 0, "un try_alloc refuse ne consomme rien");
|
||||
|
||||
void* q = a.try_alloc(a.capacity(), 1);
|
||||
check(q != nullptr, "try_alloc de la capacite exacte reussit");
|
||||
check(a.remaining() == 0, "arene pleine : reste nul");
|
||||
check(a.try_alloc(1, 1) == nullptr, "arene pleine : un octet de plus est refuse");
|
||||
}
|
||||
|
||||
// --- Debordement arithmetique -------------------------------------------
|
||||
{
|
||||
mem::Arena& a = sys.input;
|
||||
a.reset();
|
||||
const usize huge = ~static_cast<usize>(0) - 8;
|
||||
check(a.try_alloc(huge, 16) == nullptr, "taille absurde refusee sans reboucler");
|
||||
}
|
||||
|
||||
// --- Le budget annonce correspond au budget decoupe ---------------------
|
||||
{
|
||||
const usize sum = sys.scanout.capacity() + sys.geometry.capacity() +
|
||||
sys.atlas.capacity() + sys.input.capacity() +
|
||||
sys.scratch.capacity();
|
||||
check(sum == mem::kArenaTotalRaw, "somme des arenes == kArenaTotalRaw");
|
||||
check(sum + mem::kReserveBytes == mem::kArenaTotal, "reserve coherente");
|
||||
}
|
||||
|
||||
err_write("\nbudget total demande au noyau : ");
|
||||
err_write_i64(static_cast<i64>(mem::kArenaTotal));
|
||||
err_write(" octets\n");
|
||||
err_write("echecs : ");
|
||||
err_write_i64(g_failures);
|
||||
err_write("\n");
|
||||
return g_failures == 0 ? 0 : 1;
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -0,0 +1,274 @@
|
||||
// test/test_raster_golden.cpp — VALIDATION DU PORTAGE DU RASTERIZER.
|
||||
//
|
||||
// Compare, octet par octet, la sortie du code porte (proj3) a une reference
|
||||
// produite par le code d ORIGINE de Gastinel Write (tools/write_reference_dump.cpp).
|
||||
// Une divergence est un bug de portage, pas une tolerance a accorder.
|
||||
//
|
||||
// Ce test tourne sur la machine de dev. Ni telephone, ni affichage.
|
||||
//
|
||||
// NOTE SUR LA LECTURE DE FICHIER. Le rasterizer et le parser ne lisent aucun
|
||||
// fichier : c est l appelant qui fournit un tampon en memoire. C est le
|
||||
// decouplage demande au chantier 5 (l original appelait fopen depuis
|
||||
// TtfFont::load_from_file). Ici, l appelant est ce test, sur la cible hote,
|
||||
// et il utilise donc stdio. Sur la cible embarquee, l appelant utilisera
|
||||
// sys::open / sys::read. Aucune des deux voies ne traverse le rasterizer.
|
||||
//
|
||||
// Ce binaire lie proj3_newguard : si le portage avait laisse une allocation
|
||||
// dynamique quelque part, il mourrait ici avec le code 71.
|
||||
|
||||
#include <cstdio>
|
||||
|
||||
#include "proj3/font/ttf.hpp"
|
||||
#include "proj3/mem/system.hpp"
|
||||
#include "proj3/render/rasterizer.hpp"
|
||||
#include "proj3/sys/panic.hpp"
|
||||
|
||||
using namespace proj3;
|
||||
|
||||
namespace {
|
||||
|
||||
int g_failures = 0;
|
||||
int g_lines = 0;
|
||||
|
||||
// Lecture d un fichier entier dans une arene. stdio est autorise ici (cible
|
||||
// hote) ; fread n alloue pas via operator new, le garde-fou reste satisfait.
|
||||
u8* read_all(const char* path, mem::Arena& a, usize& out_size) {
|
||||
std::FILE* f = std::fopen(path, "rb");
|
||||
if (!f) return nullptr;
|
||||
std::fseek(f, 0, SEEK_END);
|
||||
const long n = std::ftell(f);
|
||||
std::fseek(f, 0, SEEK_SET);
|
||||
if (n <= 0) {
|
||||
std::fclose(f);
|
||||
return nullptr;
|
||||
}
|
||||
u8* buf = a.alloc_array<u8>(static_cast<usize>(n) + 1);
|
||||
const usize got = std::fread(buf, 1, static_cast<usize>(n), f);
|
||||
std::fclose(f);
|
||||
if (got != static_cast<usize>(n)) return nullptr;
|
||||
buf[n] = 0;
|
||||
out_size = static_cast<usize>(n);
|
||||
return buf;
|
||||
}
|
||||
|
||||
// --- Analyse lexicale minimale du fichier golden ---------------------------
|
||||
struct Cursor {
|
||||
const char* p;
|
||||
const char* end;
|
||||
};
|
||||
|
||||
void skip_spaces(Cursor& c) {
|
||||
while (c.p < c.end && (*c.p == ' ' || *c.p == '\t')) ++c.p;
|
||||
}
|
||||
|
||||
bool parse_u32(Cursor& c, u32& out) {
|
||||
skip_spaces(c);
|
||||
if (c.p >= c.end || *c.p < '0' || *c.p > '9') return false;
|
||||
u32 v = 0;
|
||||
while (c.p < c.end && *c.p >= '0' && *c.p <= '9') v = v * 10u + static_cast<u32>(*c.p++ - '0');
|
||||
out = v;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool parse_i32(Cursor& c, i32& out) {
|
||||
skip_spaces(c);
|
||||
bool neg = false;
|
||||
if (c.p < c.end && *c.p == '-') {
|
||||
neg = true;
|
||||
++c.p;
|
||||
}
|
||||
u32 v = 0;
|
||||
if (!parse_u32(c, v)) return false;
|
||||
out = neg ? -static_cast<i32>(v) : static_cast<i32>(v);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Les tailles sont ecrites par %g et sont toutes entieres dans le jeu de test.
|
||||
// On accepte quand meme une partie fractionnaire, pour que le format ne se
|
||||
// referme pas sur une hypothese.
|
||||
bool parse_f32(Cursor& c, f32& out) {
|
||||
skip_spaces(c);
|
||||
i32 whole = 0;
|
||||
if (!parse_i32(c, whole)) return false;
|
||||
f32 v = static_cast<f32>(whole);
|
||||
if (c.p < c.end && *c.p == '.') {
|
||||
++c.p;
|
||||
f32 scale = 0.1f;
|
||||
while (c.p < c.end && *c.p >= '0' && *c.p <= '9') {
|
||||
v += static_cast<f32>(*c.p++ - '0') * scale;
|
||||
scale *= 0.1f;
|
||||
}
|
||||
}
|
||||
out = v;
|
||||
return true;
|
||||
}
|
||||
|
||||
i32 hex_digit(char ch) {
|
||||
if (ch >= '0' && ch <= '9') return ch - '0';
|
||||
if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10;
|
||||
if (ch >= 'A' && ch <= 'F') return ch - 'A' + 10;
|
||||
return -1;
|
||||
}
|
||||
|
||||
void fail(const char* what, u32 cp, f32 px) {
|
||||
++g_failures;
|
||||
err_write("ECHEC ");
|
||||
err_write(what);
|
||||
err_write(" codepoint=");
|
||||
err_write_hex(cp);
|
||||
err_write(" taille=");
|
||||
err_write_i64(static_cast<i64>(px));
|
||||
err_write("\n");
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
if (argc < 3) {
|
||||
err_write("usage: proj3_test_raster <police.ttf> <golden_write.txt>\n");
|
||||
return 2;
|
||||
}
|
||||
|
||||
static mem::System sys;
|
||||
if (!mem::system_init(sys)) {
|
||||
err_write("acquisition memoire impossible\n");
|
||||
return 2;
|
||||
}
|
||||
|
||||
// Les deux fichiers vivent dans l arene de scanout, qui est la plus grande
|
||||
// et n a aucun usage a ce stade des chantiers. C est un detournement
|
||||
// assume et local a ce test.
|
||||
usize ttf_size = 0, golden_size = 0;
|
||||
const u8* ttf = read_all(argv[1], sys.scanout, ttf_size);
|
||||
if (ttf == nullptr) {
|
||||
err_write("police illisible\n");
|
||||
return 2;
|
||||
}
|
||||
const u8* golden = read_all(argv[2], sys.scanout, golden_size);
|
||||
if (golden == nullptr) {
|
||||
err_write("fichier golden illisible : lancer d abord proj3_write_reference\n");
|
||||
return 2;
|
||||
}
|
||||
|
||||
font::TtfFont f;
|
||||
const char* err = nullptr;
|
||||
if (!f.load(ttf, ttf_size, sys.atlas, err)) {
|
||||
err_write("chargement TTF : ");
|
||||
err_write(err);
|
||||
err_write("\n");
|
||||
return 2;
|
||||
}
|
||||
err_write("police chargee : upem=");
|
||||
err_write_i64(f.units_per_em());
|
||||
err_write(" glyphes=");
|
||||
err_write_i64(f.num_glyphs());
|
||||
err_write(" entrees cmap=");
|
||||
err_write_i64(f.cmap_size());
|
||||
err_write("\n\n");
|
||||
|
||||
font::GlyphBuilder builder;
|
||||
builder.init(sys.atlas);
|
||||
|
||||
Cursor c{reinterpret_cast<const char*>(golden),
|
||||
reinterpret_cast<const char*>(golden) + golden_size};
|
||||
|
||||
while (c.p < c.end) {
|
||||
// Une ligne a la fois.
|
||||
const char* line_end = c.p;
|
||||
while (line_end < c.end && *line_end != '\n') ++line_end;
|
||||
Cursor line{c.p, line_end};
|
||||
c.p = (line_end < c.end) ? line_end + 1 : c.end;
|
||||
|
||||
skip_spaces(line);
|
||||
if (line.p >= line.end || *line.p == '#' || *line.p == '\r') continue;
|
||||
|
||||
u32 cp = 0, gid_ref = 0, ok_ref = 0;
|
||||
f32 px = 0.0f;
|
||||
i32 w_ref = 0, h_ref = 0, bx_ref = 0, by_ref = 0, adv_ref = 0;
|
||||
if (!parse_u32(line, cp) || !parse_f32(line, px) || !parse_u32(line, gid_ref) ||
|
||||
!parse_u32(line, ok_ref) || !parse_i32(line, w_ref) || !parse_i32(line, h_ref) ||
|
||||
!parse_i32(line, bx_ref) || !parse_i32(line, by_ref) || !parse_i32(line, adv_ref)) {
|
||||
err_write("ECHEC ligne golden malformee\n");
|
||||
++g_failures;
|
||||
continue;
|
||||
}
|
||||
skip_spaces(line);
|
||||
const char* hex = line.p;
|
||||
usize hex_len = 0;
|
||||
while (line.p < line.end && hex_digit(*line.p) >= 0) {
|
||||
++line.p;
|
||||
++hex_len;
|
||||
}
|
||||
++g_lines;
|
||||
|
||||
// --- Cote proj3 -----------------------------------------------------
|
||||
const u16 gid = f.glyph_index_for_codepoint(cp);
|
||||
if (static_cast<u32>(gid) != gid_ref) {
|
||||
fail("index de glyphe different (cmap)", cp, px);
|
||||
continue;
|
||||
}
|
||||
font::Glyph g;
|
||||
f.load_glyph(gid, builder, g);
|
||||
|
||||
const usize m_atlas = sys.atlas.mark();
|
||||
const usize m_geo = sys.geometry.mark();
|
||||
render::RasterizedGlyph rg;
|
||||
const bool ok = render::rasterize_glyph(g, f.units_per_em(), px, sys.atlas,
|
||||
sys.geometry, rg);
|
||||
|
||||
if (ok != (ok_ref != 0)) {
|
||||
fail("rasterize_glyph : succes/echec different", cp, px);
|
||||
} else if (!ok) {
|
||||
// Glyphe vide : seule l avance a un sens, et elle doit coincider.
|
||||
if (rg.advance != adv_ref) fail("avance differente (glyphe vide)", cp, px);
|
||||
} else {
|
||||
if (rg.coverage.width != w_ref || rg.coverage.height != h_ref) {
|
||||
fail("dimensions du bitmap differentes", cp, px);
|
||||
} else if (rg.bearing_x != bx_ref || rg.bearing_y != by_ref) {
|
||||
fail("bearing different", cp, px);
|
||||
} else if (rg.advance != adv_ref) {
|
||||
fail("avance differente", cp, px);
|
||||
} else if (hex_len != rg.coverage.size_bytes() * 2) {
|
||||
fail("longueur de couverture differente", cp, px);
|
||||
} else {
|
||||
// Comparaison octet par octet. Aucun epsilon : la couverture
|
||||
// est binaire, l egalite doit etre exacte.
|
||||
usize bad = rg.coverage.size_bytes();
|
||||
for (usize i = 0; i < rg.coverage.size_bytes(); ++i) {
|
||||
const i32 hi = hex_digit(hex[i * 2]);
|
||||
const i32 lo = hex_digit(hex[i * 2 + 1]);
|
||||
const u8 expect = static_cast<u8>((hi << 4) | lo);
|
||||
if (rg.coverage.pixels[i] != expect) {
|
||||
bad = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (bad != rg.coverage.size_bytes()) {
|
||||
fail("pixel divergent", cp, px);
|
||||
err_write(" premier octet divergent a l offset ");
|
||||
err_write_i64(static_cast<i64>(bad));
|
||||
err_write(" (x=");
|
||||
err_write_i64(static_cast<i64>(bad % static_cast<usize>(w_ref)));
|
||||
err_write(" y=");
|
||||
err_write_i64(static_cast<i64>(bad / static_cast<usize>(w_ref)));
|
||||
err_write(") attendu=");
|
||||
err_write_hex(static_cast<u64>((hex_digit(hex[bad * 2]) << 4) |
|
||||
hex_digit(hex[bad * 2 + 1])));
|
||||
err_write(" obtenu=");
|
||||
err_write_hex(rg.coverage.pixels[bad]);
|
||||
err_write("\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sys.geometry.rewind_to(m_geo);
|
||||
sys.atlas.rewind_to(m_atlas);
|
||||
}
|
||||
|
||||
err_write("\nlignes comparees : ");
|
||||
err_write_i64(g_lines);
|
||||
err_write("\nechecs : ");
|
||||
err_write_i64(g_failures);
|
||||
err_write("\n");
|
||||
return g_failures == 0 ? 0 : 1;
|
||||
}
|
||||
@@ -0,0 +1,263 @@
|
||||
// test/test_syscalls.cpp — harnais des wrappers d appels systeme (chantier 2).
|
||||
//
|
||||
// OU L EXECUTER : n importe quel Linux AArch64. Raspberry Pi sous 64 bits,
|
||||
// VM ARM, conteneur, ou qemu-user. PAS BESOIN DU TELEPHONE : aucun test ne
|
||||
// touche au graphique, a l entree, ni au reseau.
|
||||
//
|
||||
// qemu-aarch64 ./proj3_test_syscalls # emulation utilisateur
|
||||
// ./proj3_test_syscalls # natif
|
||||
//
|
||||
// Code de sortie : 0 si tout passe, 1 sinon. Chaque ligne dit OK ou ECHEC.
|
||||
//
|
||||
// LE CAS D ERREUR EST LE PLUS IMPORTANT. Un wrapper qui rendrait -2 et qu on
|
||||
// interpreterait comme un descripteur valide donnerait un bug tres loin d ici.
|
||||
// Chaque appel a donc son cas nominal ET son cas d erreur, et le cas d erreur
|
||||
// verifie a la fois is_err() ET le code errno exact.
|
||||
|
||||
#include "proj3/base/mem.hpp"
|
||||
#include "proj3/sys/panic.hpp"
|
||||
#include "proj3/sys/syscalls.hpp"
|
||||
#include "proj3/sys/uapi.hpp"
|
||||
|
||||
using namespace proj3;
|
||||
|
||||
namespace {
|
||||
|
||||
int g_failures = 0;
|
||||
|
||||
void check(bool cond, const char* what) {
|
||||
err_write(cond ? "OK " : "ECHEC ");
|
||||
err_write(what);
|
||||
err_write("\n");
|
||||
if (!cond) ++g_failures;
|
||||
}
|
||||
|
||||
void check_err(const sys::Result r, i32 expected_errno, const char* what) {
|
||||
const bool ok = r.is_err() && r.err() == expected_errno;
|
||||
err_write(ok ? "OK " : "ECHEC ");
|
||||
err_write(what);
|
||||
if (!ok) {
|
||||
err_write(" (attendu -");
|
||||
err_write_i64(expected_errno);
|
||||
err_write(", obtenu ");
|
||||
err_write_i64(r.raw);
|
||||
err_write(")");
|
||||
++g_failures;
|
||||
}
|
||||
err_write("\n");
|
||||
}
|
||||
|
||||
// Chemin garanti inexistant. On evite /tmp, qui peut etre monte en lecture
|
||||
// seule ou absent sur un systeme minimal.
|
||||
const char kMissing[] = "/proj3-ce-fichier-n-existe-pas-42";
|
||||
const char kSelf[] = "/proc/self/maps";
|
||||
|
||||
} // namespace
|
||||
|
||||
extern "C" int proj3_main(int, char**) {
|
||||
err_write("=== wrappers syscall AArch64 ===\n\n");
|
||||
|
||||
// --- Verification prealable de la convention elle-meme -----------------
|
||||
// Si ces trois assertions ne tenaient pas, tous les tests suivants
|
||||
// seraient sans valeur.
|
||||
{
|
||||
constexpr sys::Result ok_zero{0};
|
||||
constexpr sys::Result ok_big{-4096};
|
||||
constexpr sys::Result err_min{-1};
|
||||
constexpr sys::Result err_max{-4095};
|
||||
static_assert(!ok_zero.is_err());
|
||||
static_assert(!ok_big.is_err(), "-4096 est HORS de la plage d erreur");
|
||||
static_assert(err_min.is_err() && err_min.err() == 1);
|
||||
static_assert(err_max.is_err() && err_max.err() == 4095);
|
||||
check(true, "plage d erreur [-4095,-1] exacte (verifiee a la compilation)");
|
||||
}
|
||||
|
||||
// --- getpid : nominal seulement (il ne peut pas echouer) ---------------
|
||||
{
|
||||
const sys::Result r = sys::getpid();
|
||||
check(r.is_ok() && r.value() > 0, "getpid nominal");
|
||||
}
|
||||
|
||||
// --- write ------------------------------------------------------------
|
||||
{
|
||||
const char msg[] = "";
|
||||
const sys::Result r = sys::write(sys::FD_STDOUT, msg, 0);
|
||||
check(r.is_ok() && r.value() == 0, "write nominal (0 octet)");
|
||||
}
|
||||
{
|
||||
const sys::Result r = sys::write(-1, "x", 1);
|
||||
check_err(r, sys::EBADF, "write cas d erreur (descripteur invalide -> EBADF)");
|
||||
}
|
||||
|
||||
// --- open --------------------------------------------------------------
|
||||
// LE test qui compte : un open sur un fichier absent doit remonter une
|
||||
// erreur, pas un descripteur.
|
||||
{
|
||||
const sys::Result r = sys::open(kMissing, sys::O_RDONLY);
|
||||
check_err(r, sys::ENOENT, "open cas d erreur (fichier absent -> ENOENT)");
|
||||
// Verification supplementaire, explicite : la valeur ne doit surtout
|
||||
// pas etre utilisable comme descripteur.
|
||||
check(r.is_err(), "open absent : is_err() vaut bien true");
|
||||
}
|
||||
|
||||
i32 fd = -1;
|
||||
{
|
||||
const sys::Result r = sys::open(kSelf, sys::O_RDONLY);
|
||||
check(r.is_ok() && r.fd() >= 0, "open nominal (/proc/self/maps)");
|
||||
if (r.is_ok()) fd = r.fd();
|
||||
}
|
||||
|
||||
// --- read --------------------------------------------------------------
|
||||
{
|
||||
u8 buf[64];
|
||||
mem_fill(buf, 0, sizeof(buf));
|
||||
if (fd >= 0) {
|
||||
const sys::Result r = sys::read(fd, buf, sizeof(buf));
|
||||
check(r.is_ok() && r.value() > 0, "read nominal");
|
||||
} else {
|
||||
check(false, "read nominal (open prealable a echoue)");
|
||||
}
|
||||
const sys::Result r2 = sys::read(-1, buf, sizeof(buf));
|
||||
check_err(r2, sys::EBADF, "read cas d erreur (descripteur invalide -> EBADF)");
|
||||
}
|
||||
|
||||
// --- lseek -------------------------------------------------------------
|
||||
{
|
||||
if (fd >= 0) {
|
||||
const sys::Result r = sys::lseek(fd, 0, sys::SEEK_SET);
|
||||
check(r.is_ok() && r.value() == 0, "lseek nominal (retour au debut)");
|
||||
} else {
|
||||
check(false, "lseek nominal (open prealable a echoue)");
|
||||
}
|
||||
const sys::Result r2 = sys::lseek(-1, 0, sys::SEEK_SET);
|
||||
check_err(r2, sys::EBADF, "lseek cas d erreur (descripteur invalide -> EBADF)");
|
||||
}
|
||||
|
||||
// --- fstat -------------------------------------------------------------
|
||||
{
|
||||
sys::Stat st;
|
||||
mem_fill(&st, 0, sizeof(st));
|
||||
if (fd >= 0) {
|
||||
const sys::Result r = sys::fstat(fd, &st);
|
||||
// /proc/self/maps a une taille declaree nulle : on verifie le mode,
|
||||
// pas la taille. S_IFREG = 0100000 octal.
|
||||
check(r.is_ok() && (st.mode & 0170000u) == 0100000u,
|
||||
"fstat nominal (mode de fichier regulier)");
|
||||
} else {
|
||||
check(false, "fstat nominal (open prealable a echoue)");
|
||||
}
|
||||
const sys::Result r2 = sys::fstat(-1, &st);
|
||||
check_err(r2, sys::EBADF, "fstat cas d erreur (descripteur invalide -> EBADF)");
|
||||
}
|
||||
|
||||
// --- ioctl -------------------------------------------------------------
|
||||
// Aucun ioctl graphique dans cette passe. On se contente de verifier que
|
||||
// le wrapper transmet bien et que l erreur remonte : un ioctl inconnu sur
|
||||
// un fichier regulier donne ENOTTY.
|
||||
{
|
||||
if (fd >= 0) {
|
||||
const sys::Result r = sys::ioctl(fd, 0xDEADu);
|
||||
check(r.is_err() && (r.err() == sys::ENOTTY || r.err() == sys::EINVAL),
|
||||
"ioctl cas d erreur (requete inconnue -> ENOTTY/EINVAL)");
|
||||
} else {
|
||||
check(false, "ioctl cas d erreur (open prealable a echoue)");
|
||||
}
|
||||
const sys::Result r2 = sys::ioctl(-1, 0x1234u);
|
||||
check_err(r2, sys::EBADF, "ioctl descripteur invalide -> EBADF");
|
||||
}
|
||||
|
||||
// --- close -------------------------------------------------------------
|
||||
{
|
||||
if (fd >= 0) {
|
||||
const sys::Result r = sys::close(fd);
|
||||
check(r.is_ok(), "close nominal");
|
||||
} else {
|
||||
check(false, "close nominal (open prealable a echoue)");
|
||||
}
|
||||
const sys::Result r2 = sys::close(-1);
|
||||
check_err(r2, sys::EBADF, "close cas d erreur (descripteur invalide -> EBADF)");
|
||||
}
|
||||
|
||||
// --- mmap / munmap / madvise -------------------------------------------
|
||||
// Verification explicite du 6e argument de mmap : on mappe avec un offset
|
||||
// non nul sur un descripteur invalide. Si le 6e argument n arrivait pas au
|
||||
// noyau, l erreur serait EINVAL au lieu de EBADF.
|
||||
{
|
||||
const usize len = 4096;
|
||||
const sys::Result r = sys::mmap(nullptr, len, sys::PROT_READ | sys::PROT_WRITE,
|
||||
sys::MAP_PRIVATE | sys::MAP_ANONYMOUS, -1, 0);
|
||||
check(r.is_ok(), "mmap nominal (anonyme 4 Ko)");
|
||||
if (r.is_ok()) {
|
||||
u8* p = static_cast<u8*>(r.ptr());
|
||||
p[0] = 0x42;
|
||||
p[len - 1] = 0x43;
|
||||
check(p[0] == 0x42 && p[len - 1] == 0x43, "mmap : la memoire est ecrivable");
|
||||
|
||||
const sys::Result a = sys::madvise(p, len, sys::MADV_WILLNEED);
|
||||
check(a.is_ok(), "madvise nominal (MADV_WILLNEED)");
|
||||
|
||||
const sys::Result u = sys::munmap(p, len);
|
||||
check(u.is_ok(), "munmap nominal");
|
||||
} else {
|
||||
check(false, "mmap : la memoire est ecrivable (mmap a echoue)");
|
||||
check(false, "madvise nominal (mmap a echoue)");
|
||||
check(false, "munmap nominal (mmap a echoue)");
|
||||
}
|
||||
}
|
||||
{
|
||||
// Longueur nulle : EINVAL. Cas d erreur simple et sans effet de bord.
|
||||
const sys::Result r = sys::mmap(nullptr, 0, sys::PROT_READ,
|
||||
sys::MAP_PRIVATE | sys::MAP_ANONYMOUS, -1, 0);
|
||||
check_err(r, sys::EINVAL, "mmap cas d erreur (longueur nulle -> EINVAL)");
|
||||
}
|
||||
{
|
||||
// 6e argument : offset non nul, descripteur invalide, mapping de
|
||||
// fichier. Le noyau doit voir un fd invalide (EBADF).
|
||||
const sys::Result r = sys::mmap(nullptr, 4096, sys::PROT_READ, sys::MAP_PRIVATE, -1,
|
||||
4096);
|
||||
check(r.is_err(), "mmap 6e argument : l appel parvient au noyau et echoue proprement");
|
||||
}
|
||||
{
|
||||
const sys::Result r = sys::munmap(nullptr, 0);
|
||||
check_err(r, sys::EINVAL, "munmap cas d erreur (longueur nulle -> EINVAL)");
|
||||
}
|
||||
{
|
||||
const sys::Result r = sys::madvise(nullptr, 0, 0xFFFF);
|
||||
check(r.is_err(), "madvise cas d erreur (conseil inconnu)");
|
||||
}
|
||||
|
||||
// --- clock_gettime ------------------------------------------------------
|
||||
{
|
||||
sys::TimeSpec ts{0, 0};
|
||||
const sys::Result r = sys::clock_gettime(sys::CLOCK_MONOTONIC, &ts);
|
||||
check(r.is_ok() && (ts.sec > 0 || ts.nsec > 0), "clock_gettime nominal (MONOTONIC)");
|
||||
|
||||
const sys::Result r2 = sys::clock_gettime(0x7FFF, &ts);
|
||||
check(r2.is_err(), "clock_gettime cas d erreur (horloge inconnue)");
|
||||
}
|
||||
|
||||
// --- nanosleep ----------------------------------------------------------
|
||||
{
|
||||
const sys::TimeSpec req{0, 1000000}; // 1 ms
|
||||
const sys::Result r = sys::nanosleep(&req, nullptr);
|
||||
check(r.is_ok(), "nanosleep nominal (1 ms)");
|
||||
|
||||
const sys::TimeSpec bad{0, 2000000000}; // nsec >= 1e9 : invalide
|
||||
const sys::Result r2 = sys::nanosleep(&bad, nullptr);
|
||||
check_err(r2, sys::EINVAL, "nanosleep cas d erreur (nsec hors bornes -> EINVAL)");
|
||||
}
|
||||
|
||||
// --- exit / exit_group ---------------------------------------------------
|
||||
// Ils ne reviennent pas : on ne peut pas les tester ici sans terminer le
|
||||
// processus. Ils sont testes IMPLICITEMENT et de la seule facon possible :
|
||||
// ce programme se termine par exit_group via asm/start.S, et son code de
|
||||
// sortie est observable par le script appelant. Si exit_group etait faux,
|
||||
// ce binaire ne rendrait jamais la main proprement.
|
||||
err_write("NOTE exit/exit_group : testes implicitement par la terminaison\n");
|
||||
err_write(" de ce programme (code de sortie observable a l exterieur).\n");
|
||||
|
||||
err_write("\nechecs : ");
|
||||
err_write_i64(g_failures);
|
||||
err_write("\n");
|
||||
return g_failures == 0 ? 0 : 1;
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
#!/bin/sh
|
||||
# tools/regen-golden.sh — regenere test/data/golden_write.txt depuis les
|
||||
# sources ORIGINALES de Gastinel Write.
|
||||
#
|
||||
# A relancer uniquement si le rasterizer de Write change, ou si le jeu de
|
||||
# glyphes de tools/write_reference_dump.cpp est etendu.
|
||||
#
|
||||
# NE PAS le relancer pour "faire passer" un test golden qui echoue : un echec
|
||||
# signifie que le portage a diverge, et c est le portage qu il faut corriger.
|
||||
#
|
||||
# usage : tools/regen-golden.sh <chemin/vers/Gastinel Write/src>
|
||||
set -eu
|
||||
|
||||
if [ $# -lt 1 ]; then
|
||||
echo "usage: $0 <chemin/vers/Gastinel Write/src>" >&2
|
||||
exit 2
|
||||
fi
|
||||
WRITE_SRC="$1"
|
||||
ROOT="$(cd "$(dirname "$0")/.." && pwd)"
|
||||
|
||||
cmake -S "$ROOT" -B "$ROOT/build-host" -G Ninja -DPROJ3_WRITE_SRC="$WRITE_SRC"
|
||||
ninja -C "$ROOT/build-host" proj3_write_reference
|
||||
|
||||
"$ROOT/build-host/proj3_write_reference" "$ROOT/test/data/Inter-Regular.ttf" \
|
||||
> "$ROOT/test/data/golden_write.txt"
|
||||
|
||||
echo "golden regenere : $(wc -l < "$ROOT/test/data/golden_write.txt") lignes"
|
||||
@@ -0,0 +1,87 @@
|
||||
// tools/write_reference_dump.cpp — ORACLE EXTERNE DU PORTAGE.
|
||||
//
|
||||
// Ce programme compile les sources ORIGINALES de Gastinel Write
|
||||
// (src/font/ttf.cpp et src/render/rasterizer.cpp, qui ne dependent d aucune
|
||||
// API Windows) et vide leurs sorties dans un format texte.
|
||||
//
|
||||
// C est ce qui rend le portage verifiable au lieu de simplement plausible :
|
||||
// le test test_raster_golden.cpp compare octet par octet la sortie du code
|
||||
// porte a celle produite ici par le code d origine. Si les deux divergent,
|
||||
// c est un bug de portage et il doit etre trouve maintenant.
|
||||
//
|
||||
// Construction (cible hote uniquement) :
|
||||
// cmake -B build-host -G Ninja -DPROJ3_WRITE_SRC="<...>/Gastinel Write/src"
|
||||
// ninja -C build-host proj3_write_reference
|
||||
// ./build-host/proj3_write_reference test/data/Inter-Regular.ttf > test/data/golden_write.txt
|
||||
//
|
||||
// FORMAT (v1), une ligne par (codepoint, taille) :
|
||||
// <codepoint> <pixel_size> <gid> <ok> <w> <h> <bx> <by> <adv> <hex de la couverture>
|
||||
// `ok` vaut 1 si rasterize_glyph a rendu true. Quand il vaut 0, les champs
|
||||
// suivants valent 0 et le hex est vide.
|
||||
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "font/ttf.h"
|
||||
#include "render/rasterizer.h"
|
||||
|
||||
namespace {
|
||||
|
||||
// Jeu de glyphes. Choisi pour couvrir :
|
||||
// - des glyphes simples (A, o, 0) ;
|
||||
// - des composites, qui exercent la recursion et la matrice 2x2 (e aigu,
|
||||
// a grave, c cedille, u trema) ;
|
||||
// - de la ponctuation fine, ou l arrondi au pixel se voit ;
|
||||
// - l espace, glyphe vide dont seules les metriques comptent.
|
||||
const unsigned kCodepoints[] = {
|
||||
0x20, 0x21, 0x2C, 0x2E, 0x30, 0x31, 0x38, 0x41, 0x42, 0x47, 0x4F, 0x57,
|
||||
0x61, 0x62, 0x67, 0x6D, 0x6F, 0x73, 0x77, 0x7A, 0x23, 0x25, 0x26, 0x3F,
|
||||
0xE9, 0xE0, 0xE7, 0xFC, 0xD8, 0x40,
|
||||
};
|
||||
|
||||
// Tailles en pixels par em. 12 et 16 sont les corps de texte ou l arrondi est
|
||||
// le plus sensible ; 24 et 32 exercent des courbes plus longues, donc des
|
||||
// subdivisions plus nombreuses.
|
||||
const float kSizes[] = {12.0f, 16.0f, 24.0f, 32.0f};
|
||||
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
if (argc < 2) {
|
||||
std::fprintf(stderr, "usage: %s <police.ttf>\n", argv[0]);
|
||||
return 2;
|
||||
}
|
||||
gw::font::TtfFont font;
|
||||
std::string err;
|
||||
if (!font.load_from_file(argv[1], err)) {
|
||||
std::fprintf(stderr, "chargement impossible : %s\n", err.c_str());
|
||||
return 2;
|
||||
}
|
||||
|
||||
std::printf("# proj3 golden raster dump v1 (source : Gastinel Write)\n");
|
||||
std::printf("# upem %u\n", static_cast<unsigned>(font.units_per_em()));
|
||||
|
||||
for (unsigned cp : kCodepoints) {
|
||||
const unsigned gid = font.glyph_index_for_codepoint(cp);
|
||||
gw::font::Glyph g;
|
||||
const bool loaded = font.load_glyph(static_cast<std::uint16_t>(gid), g);
|
||||
for (float px : kSizes) {
|
||||
gw::render::RasterizedGlyph rg;
|
||||
const bool ok = loaded && gw::render::rasterize_glyph(g, font.units_per_em(), px, rg);
|
||||
std::printf("%u %g %u %d", cp, static_cast<double>(px), gid, ok ? 1 : 0);
|
||||
if (ok) {
|
||||
std::printf(" %d %d %d %d %d ", rg.coverage.width, rg.coverage.height,
|
||||
rg.bearing_x, rg.bearing_y, rg.advance);
|
||||
for (unsigned char v : rg.coverage.pixels) std::printf("%02x", v);
|
||||
} else {
|
||||
// Meme quand la rasterization echoue (glyphe vide), l avance
|
||||
// reste significative : elle positionne le caractere suivant.
|
||||
std::printf(" 0 0 0 0 %d ", rg.advance);
|
||||
}
|
||||
std::printf("\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur